feat(cli): publish dedicated proxy binary

.github/workflows/cicd.yml

@@ -407,6 +407,23 @@ jobs:
   # Version comes directly from deno.json
   # ============================================
 
+  tests-proxy-binary:
+    if: ${{ (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository) && github.event_name == 'pull_request' }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1  # v7.0.1
+      - uses: ./.github/actions/setup-deno
+      - run: deno task build:prepare
+      - name: Compile proxy binary
+        run: |
+          deno run -A scripts/build/compile-binary.ts \
+            --entrypoint cli/proxy-main.ts \
+            --profile proxy \
+            --target x86_64-unknown-linux-gnu \
+            --output veryfront-proxy-linux-x64
+      - name: Smoke test proxy binary
+        run: bash scripts/build/smoke-proxy-binary.sh ./veryfront-proxy-linux-x64
+
   build-binaries:
     if: ${{ (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository) && github.ref == 'refs/heads/main' }}
     runs-on: ${{ matrix.os }}
@@ -417,18 +434,33 @@ jobs:
           - os: macos-latest
             target: aarch64-apple-darwin
             name: veryfront-macos-arm64
+            entrypoint: cli/main.ts
+            profile: full
           - os: macos-latest
             target: x86_64-apple-darwin
             name: veryfront-macos-x64
+            entrypoint: cli/main.ts
+            profile: full
           - os: ubuntu-latest
             target: x86_64-unknown-linux-gnu
             name: veryfront-linux-x64
+            entrypoint: cli/main.ts
+            profile: full
           - os: ubuntu-latest
             target: aarch64-unknown-linux-gnu
             name: veryfront-linux-arm64
+            entrypoint: cli/main.ts
+            profile: full
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+            name: veryfront-proxy-linux-x64
+            entrypoint: cli/proxy-main.ts
+            profile: proxy
           - os: windows-2022
             target: x86_64-pc-windows-msvc
             name: veryfront-windows-x64.exe
+            entrypoint: cli/main.ts
+            profile: full
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1  # v7.0.1
       - uses: ./.github/actions/setup-deno
@@ -439,9 +471,16 @@ jobs:
         shell: bash
         run: |
           deno run -A scripts/build/compile-binary.ts \
+            --entrypoint ${{ matrix.entrypoint }} \
+            --profile ${{ matrix.profile }} \
             --target ${{ matrix.target }} \
             --output ${{ matrix.name }}
 
+      - name: Smoke test proxy binary
+        if: matrix.profile == 'proxy'
+        shell: bash
+        run: bash scripts/build/smoke-proxy-binary.sh ./${{ matrix.name }}
+
       - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a  # v7.0.1
         with:
           name: ${{ matrix.name }}

cli/commands/serve/command.ts

@@ -5,6 +5,7 @@ import { exitProcess, registerTerminationSignals, showHeader } from "#cli/utils"
 import { generateDefaultProjectId } from "../../utils/project.ts";
 import { startCliProductionServer } from "#cli/shared/server-startup";
 import { ensureCliBundlerContracts } from "#cli/shared/default-contracts";
+import { runStandaloneProxyRuntime } from "./proxy-runtime.ts";
 
 const STARTUP_ERROR_FLUSH_TIMEOUT_MS = 2_000;
 
@@ -141,39 +142,10 @@ async function runSplit(options: ServeOptions): Promise<void> {
 }
 
 async function runProxy(options: ServeOptions): Promise<void> {
-  showHeader();
-  cliLogger.info(`Starting proxy server on ${options.bindAddress}:${options.port}`);
-
-  const { setEnv } = await import("veryfront/platform");
-  setEnv("PORT", String(options.port));
-  setEnv("HOST", options.bindAddress);
-
-  const {
-    activateStandaloneProxyCacheExtension,
-    registerStandaloneProxyCacheExtensionTeardown,
-  } = await import(
-    "./proxy-extension-composition.ts"
-  );
-  const extensionLoader = await activateStandaloneProxyCacheExtension();
-  const teardownCacheExtension = await registerStandaloneProxyCacheExtensionTeardown(
-    extensionLoader,
-  );
-
-  // DenoHttpServer.serve() blocks until the server stops,
-  // so this import keeps the process alive.
-  try {
-    await import("veryfront/proxy/main");
-  } catch (error) {
-    try {
-      await teardownCacheExtension();
-    } catch (cleanupError) {
-      cliLogger.error("Failed to clean up proxy extensions after startup failure", cleanupError);
-    }
-    throw error;
-  }
-
-  // Keep the process alive (Deno.serve returns immediately in compiled binaries)
-  await new Promise(() => {});
+  await runStandaloneProxyRuntime({
+    bindAddress: options.bindAddress,
+    port: options.port,
+  });
 }
 
 function createDeferredProductionStartupErrorReporter(): {

cli/commands/serve/proxy-extension-composition.test.ts

@@ -4,12 +4,13 @@ import { assertEquals, assertRejects, assertStrictEquals } from "#veryfront/test
 import { afterEach, describe, it } from "#veryfront/testing/bdd.ts";
 import { type ExtensionLoader, tryResolve } from "veryfront/extensions";
 import type { TokenCacheStore } from "#veryfront/extensions/cache/index.ts";
+import { RedisRuntimeProviderName } from "#veryfront/extensions/distributed/index.ts";
 import { createCacheFromEnv, TracingTokenCache } from "#veryfront/proxy/cache/index.ts";
 import { acquireExtensionTokenCacheStoreFromEnv } from "#veryfront/proxy/cache/extension-store.ts";
 import { createProxyShutdownHooks } from "#veryfront/proxy/shutdown-hooks.ts";
 import {
-  activateStandaloneProxyCacheExtension,
-  registerStandaloneProxyCacheExtensionTeardown,
+  activateStandaloneProxyExtensions,
+  registerStandaloneProxyExtensionTeardown,
 } from "./proxy-extension-composition.ts";
 
 describe("standalone proxy extension composition", () => {
@@ -28,8 +29,9 @@ describe("standalone proxy extension composition", () => {
 
   it("does not import or activate a cache provider for the memory backend", async () => {
     Deno.env.set("CACHE_TYPE", "memory");
+    Deno.env.delete("REDIS_URL");
 
-    loader = await activateStandaloneProxyCacheExtension();
+    loader = await activateStandaloneProxyExtensions();
 
     assertEquals(loader, null);
   });
@@ -38,12 +40,13 @@ describe("standalone proxy extension composition", () => {
     Deno.env.set("CACHE_TYPE", "extension");
     Deno.env.set("REDIS_URL", "redis://127.0.0.1:6379");
 
-    loader = await activateStandaloneProxyCacheExtension();
+    loader = await activateStandaloneProxyExtensions();
     const shutdownHooks = createProxyShutdownHooks();
-    await registerStandaloneProxyCacheExtensionTeardown(loader, shutdownHooks.register);
+    await registerStandaloneProxyExtensionTeardown(loader, shutdownHooks.register);
     const acquisition = await acquireExtensionTokenCacheStoreFromEnv();
 
     assertEquals(loader !== null, true);
+    assertEquals(tryResolve(RedisRuntimeProviderName) !== undefined, true);
     assertEquals(acquisition.kind, "borrowed");
     assertStrictEquals(
       acquisition.store,
@@ -60,17 +63,33 @@ describe("standalone proxy extension composition", () => {
 
     assertEquals(await shutdownHooks.settle(), []);
     assertEquals(tryResolve<TokenCacheStore>("TokenCacheStore"), undefined);
+    assertEquals(tryResolve(RedisRuntimeProviderName), undefined);
     loader = null;
   });
 
+  it("activates the Redis runtime for routing invalidation in memory-cache mode", async () => {
+    Deno.env.set("CACHE_TYPE", "memory");
+    Deno.env.set("REDIS_URL", "redis://127.0.0.1:6379");
+
+    loader = await activateStandaloneProxyExtensions();
+
+    assertEquals(loader !== null, true);
+    assertEquals(tryResolve<TokenCacheStore>("TokenCacheStore"), undefined);
+    assertEquals(tryResolve(RedisRuntimeProviderName) !== undefined, true);
+
+    await loader?.teardownAll();
+    loader = null;
+    assertEquals(tryResolve(RedisRuntimeProviderName), undefined);
+  });
+
   it("tears down the provider when shutdown registration fails", async () => {
     Deno.env.set("CACHE_TYPE", "extension");
     Deno.env.set("REDIS_URL", "redis://127.0.0.1:6379");
-    loader = await activateStandaloneProxyCacheExtension();
+    loader = await activateStandaloneProxyExtensions();
 
     await assertRejects(
       () =>
-        registerStandaloneProxyCacheExtensionTeardown(loader, () => {
+        registerStandaloneProxyExtensionTeardown(loader, () => {
           throw new Error("shutdown registration failed");
         }),
       Error,
@@ -83,8 +102,8 @@ describe("standalone proxy extension composition", () => {
   it("tears down the provider when shutdown-hook disposal fails", async () => {
     Deno.env.set("CACHE_TYPE", "extension");
     Deno.env.set("REDIS_URL", "redis://127.0.0.1:6379");
-    loader = await activateStandaloneProxyCacheExtension();
-    const teardown = await registerStandaloneProxyCacheExtensionTeardown(
+    loader = await activateStandaloneProxyExtensions();
+    const teardown = await registerStandaloneProxyExtensionTeardown(
       loader,
       () => () => {
         throw new Error("shutdown-hook disposal failed");
@@ -103,7 +122,7 @@ describe("standalone proxy extension composition", () => {
   it("uses Promise intrinsics captured before extension-owned mutation", async () => {
     Deno.env.set("CACHE_TYPE", "extension");
     Deno.env.set("REDIS_URL", "redis://127.0.0.1:6379");
-    loader = await activateStandaloneProxyCacheExtension();
+    loader = await activateStandaloneProxyExtensions();
     const resolveDescriptor = Object.getOwnPropertyDescriptor(Promise, "resolve")!;
     let registration: Promise<() => Promise<void>> | undefined;
 
@@ -114,7 +133,7 @@ describe("standalone proxy extension composition", () => {
           throw new Error("poisoned Promise.resolve");
         },
       });
-      registration = registerStandaloneProxyCacheExtensionTeardown(
+      registration = registerStandaloneProxyExtensionTeardown(
         loader,
         () => () => undefined,
       );

cli/commands/serve/proxy-extension-composition.ts

@@ -6,17 +6,18 @@
  * `TokenCacheStore` contract published by the extension loader.
  */
 
-import { cliLogger } from "#cli/utils";
-import { type ExtensionFactory, ExtensionLoader } from "veryfront/extensions";
+import { cliLogger } from "veryfront/utils/logger";
+import { ExtensionLoader } from "veryfront/extensions/loader";
+import type { ExtensionFactory } from "veryfront/extensions/types";
 import { importFirstPartyExtensionModule } from "veryfront/extensions/first-party-import";
-import { getEnv } from "veryfront/platform";
+import { getEnv } from "veryfront/platform/env";
 import {
   createProxyShutdownAggregateError,
   type RegisterProxyShutdownHook,
   registerProxyShutdownHook,
 } from "veryfront/proxy/shutdown-hooks";
 
-type CacheExtensionModule = Readonly<{ default: ExtensionFactory }>;
+type ProxyExtensionModule = Readonly<{ default: ExtensionFactory }>;
 
 // This module is evaluated before extension activation. Pin promises created
 // by the later teardown path so extension code cannot replace Promise species
@@ -42,54 +43,75 @@ const resolvedBeforeExtensionActivation = pinCompositionPromise(
 
 const CACHE_EXTENSION_SOURCE_DIRECTORY = "ext-cache-redis";
 const CACHE_EXTENSION_PACKAGE_NAME = "@veryfront/ext-cache-redis";
+const REDIS_EXTENSION_SOURCE_DIRECTORY = "ext-redis";
+const REDIS_EXTENSION_PACKAGE_NAME = "@veryfront/ext-redis";
 
 /**
- * Activate the standalone proxy's explicitly selected cache extension.
- * Memory mode performs no extension import. The returned loader owns provider
- * teardown; the proxy borrows its registered `TokenCacheStore`.
+ * Activate the standalone proxy's explicitly selected cache and Redis runtime
+ * providers. The returned loader owns provider teardown.
  */
-async function activateStandaloneProxyCacheExtensionInternal(): Promise<ExtensionLoader | null> {
+async function activateStandaloneProxyExtensionsInternal(): Promise<ExtensionLoader | null> {
   const cacheType = getEnv("CACHE_TYPE") || "memory";
   if (cacheType !== "memory" && cacheType !== "extension") {
     throw new NativeTypeError("CACHE_TYPE must be memory or extension");
   }
-  if (cacheType === "memory") return null;
 
-  const module = await importFirstPartyExtensionModule<CacheExtensionModule>(
-    CACHE_EXTENSION_SOURCE_DIRECTORY,
-    CACHE_EXTENSION_PACKAGE_NAME,
-  );
-  if (typeof module.default !== "function") {
-    throw new NativeTypeError(`${CACHE_EXTENSION_PACKAGE_NAME} must export an ExtensionFactory`);
+  const selected: Array<{
+    origin: string;
+    packageName: string;
+    sourceDirectory: string;
+  }> = [];
+  if (cacheType === "extension") {
+    selected.push({
+      origin: "standalone proxy cache selection",
+      packageName: CACHE_EXTENSION_PACKAGE_NAME,
+      sourceDirectory: CACHE_EXTENSION_SOURCE_DIRECTORY,
+    });
+  }
+  if (getEnv("REDIS_URL")) {
+    selected.push({
+      origin: "standalone proxy routing invalidation",
+      packageName: REDIS_EXTENSION_PACKAGE_NAME,
+      sourceDirectory: REDIS_EXTENSION_SOURCE_DIRECTORY,
+    });
   }
+  if (selected.length === 0) return null;
+
+  const extensions = await NativePromise.all(selected.map(async (definition) => {
+    const module = await importFirstPartyExtensionModule<ProxyExtensionModule>(
+      definition.sourceDirectory,
+      definition.packageName,
+    );
+    if (typeof module.default !== "function") {
+      throw new NativeTypeError(`${definition.packageName} must export an ExtensionFactory`);
+    }
+    return {
+      extension: module.default(),
+      source: "config" as const,
+      origin: definition.origin,
+    };
+  }));
 
   const loader = new ExtensionLoader(cliLogger);
   try {
-    await loader.setupAll(
-      [{
-        extension: module.default(),
-        source: "config",
-        origin: "standalone proxy cache selection",
-      }],
-      {},
-    );
+    await loader.setupAll(extensions, {});
     return loader;
   } catch (error) {
     try {
       await loader.teardownAll();
     } catch (cleanupError) {
-      cliLogger.error("Failed to clean up standalone proxy cache extension", cleanupError);
+      cliLogger.error("Failed to clean up standalone proxy extensions", cleanupError);
     }
     throw error;
   }
 }
 
-/** Start explicit standalone cache composition with a pinned lifecycle promise. */
-export function activateStandaloneProxyCacheExtension(): Promise<ExtensionLoader | null> {
-  return pinCompositionPromise(activateStandaloneProxyCacheExtensionInternal());
+/** Start explicit standalone proxy extension composition. */
+export function activateStandaloneProxyExtensions(): Promise<ExtensionLoader | null> {
+  return pinCompositionPromise(activateStandaloneProxyExtensionsInternal());
 }
 
-async function registerStandaloneProxyCacheExtensionTeardownInternal(
+async function registerStandaloneProxyExtensionTeardownInternal(
   loader: ExtensionLoader | null,
   registerHook: RegisterProxyShutdownHook,
 ): Promise<() => Promise<void>> {
@@ -114,7 +136,7 @@ async function registerStandaloneProxyCacheExtensionTeardownInternal(
     } catch (cleanupError) {
       throw createProxyShutdownAggregateError(
         [error, cleanupError],
-        "Failed to register and clean up standalone proxy cache extension teardown",
+        "Failed to register and clean up standalone proxy extension teardown",
       );
     }
     throw error;
@@ -137,7 +159,7 @@ async function registerStandaloneProxyCacheExtensionTeardownInternal(
         if (disposalFailed) {
           throw createProxyShutdownAggregateError(
             [disposalError, teardownError],
-            "Failed to unregister and tear down standalone proxy cache extension",
+            "Failed to unregister and tear down standalone proxy extensions",
           );
         }
         throw teardownError;
@@ -147,11 +169,11 @@ async function registerStandaloneProxyCacheExtensionTeardownInternal(
 }
 
 /** Register exactly-once provider teardown with the proxy's shutdown owner. */
-export function registerStandaloneProxyCacheExtensionTeardown(
+export function registerStandaloneProxyExtensionTeardown(
   loader: ExtensionLoader | null,
   registerHook: RegisterProxyShutdownHook = registerProxyShutdownHook,
 ): Promise<() => Promise<void>> {
   return pinCompositionPromise(
-    registerStandaloneProxyCacheExtensionTeardownInternal(loader, registerHook),
+    registerStandaloneProxyExtensionTeardownInternal(loader, registerHook),
   );
 }