@vellumai/credential-executor 0.10.6-dev.202607071937.200b337 → 0.10.6-dev.202607072040.fb971ce

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/credential-executor",
-  "version": "0.10.6-dev.202607071937.200b337",
+  "version": "0.10.6-dev.202607072040.fb971ce",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/local-standalone.test.ts

@@ -1,9 +1,8 @@
 /**
- * Local CES standalone-sibling test (real entrypoint subprocess).
+ * Local CES sibling test (real entrypoint subprocess).
  *
- * Spawns the actual `main.ts` entrypoint with `CES_STANDALONE=1` and **stdin
- * closed** — the way the CLI launches the sibling (the `CES_STANDALONE`
- * opt-in) — and verifies that CES:
+ * Spawns the actual `main.ts` entrypoint with **stdin closed** — the way the
+ * CLI launches the sibling — and verifies that CES:
  *
  *   1. binds its Unix socket and serves RPC despite having no stdio parent
  *      (lifecycle anchored to SIGTERM, not stdin), and
@@ -145,12 +144,12 @@ describe("local CES standalone sibling (real entrypoint)", () => {
 
     const localMain = resolve(__dirname, "..", "main.ts");
 
-    // CES_STANDALONE=1 + stdin closed is how the CLI launches the sibling.
+    // stdin closed is how the CLI launches the sibling — CES serves over a
+    // Unix socket, not stdio.
     proc = Bun.spawn({
       cmd: [process.execPath, localMain],
       env: {
         ...process.env,
-        CES_STANDALONE: "1",
         CES_LOCAL_SOCKET: socketPath,
         CREDENTIAL_SECURITY_DIR: securityDir,
         VELLUM_WORKSPACE_DIR: workspaceDir,
@@ -200,34 +199,4 @@ describe("local CES standalone sibling (real entrypoint)", () => {
     ]);
     expect(exited).toBe(true);
   }, 30_000);
-
-  test("without CES_STANDALONE, exits when stdin closes (stdio child)", async () => {
-    tmpDir = mkdtempSync(join(tmpdir(), "ces-stdio-"));
-    const securityDir = join(tmpDir, "protected");
-    const workspaceDir = join(tmpDir, "workspace");
-    mkdirSync(securityDir, { recursive: true });
-    mkdirSync(workspaceDir, { recursive: true });
-
-    const localMain = resolve(__dirname, "..", "main.ts");
-
-    // Default mode: stdin "ignore" EOFs immediately, so the stdio server's
-    // input stream ends and CES shuts down on its own — the today behavior.
-    proc = Bun.spawn({
-      cmd: [process.execPath, localMain],
-      env: {
-        ...process.env,
-        CREDENTIAL_SECURITY_DIR: securityDir,
-        VELLUM_WORKSPACE_DIR: workspaceDir,
-      },
-      stdin: "ignore",
-      stdout: "ignore",
-      stderr: "ignore",
-    });
-
-    const exited = await Promise.race([
-      proc.exited.then(() => true),
-      delay(10_000).then(() => false),
-    ]);
-    expect(exited).toBe(true);
-  }, 20_000);
 });

package/src/__tests__/transport.test.ts

@@ -203,17 +203,17 @@ describe("health probes", () => {
 });
 
 // ---------------------------------------------------------------------------
-// 3. Local stdio transport not inherited by subprocesses
+// 3. Local socket transport not inherited by subprocesses
 // ---------------------------------------------------------------------------
 
 describe("local entrypoint transport isolation", () => {
-  test("main.ts serves over stdio or a Unix socket, never a TCP listener", () => {
+  test("main.ts serves over a Unix socket, never stdio or a TCP listener", () => {
     const src = readFileSync(resolve(__dirname, "..", "main.ts"), "utf-8");
-    // Serves the stdio-child transport (default mode).
-    expect(src).toMatch(/process\.stdin/);
-    expect(src).toMatch(/process\.stdout/);
-    // Standalone mode (CES_STANDALONE=1) listens on a Unix socket path only —
-    // never a numeric TCP port — and never opens an HTTP server.
+    // Socket transport only — no stdio-child transport.
+    expect(src).not.toMatch(/process\.stdin/);
+    expect(src).not.toMatch(/process\.stdout/);
+    // Listens on a Unix socket path only — never a numeric TCP port — and
+    // never opens an HTTP server.
     expect(src).not.toMatch(/Bun\.serve\(/);
     expect(src).not.toMatch(/\.listen\(\d+/);
   });

package/src/main.ts

@@ -1,21 +1,12 @@
 #!/usr/bin/env bun
 /**
- * Local CES entrypoint. Two run modes:
+ * Local CES entrypoint. Serves RPC over a Unix socket (`getLocalSocketPath()`),
+ * launched independently by the CLI as a sibling process. Runs until SIGTERM.
  *
- * - **stdio child (default):** the assistant spawns CES as a child process and
- *   communicates over stdin/stdout. CES shuts down when stdin closes (parent
- *   exit) or on SIGTERM. This is today's behavior.
- *
- * - **standalone sibling (`CES_STANDALONE=1`):** CES is launched independently
- *   by the CLI (the opt-in), serves RPC over a
- *   Unix socket (`getLocalSocketPath()`), and runs until SIGTERM — no stdio.
- *   This is the direction local CES is converging on; the socket-serving here
- *   is temporary scaffolding to be folded into a single unified CES entrypoint.
- *
- * Local mode never opens a TCP listener. Neither the stdio transport nor the
- * Unix socket's listening fd is inherited by shell subprocesses spawned by CES
- * (e.g. for `run_authenticated_command`): Bun's `Bun.spawn` defaults to "pipe"
- * for stdio, and the listening socket is not passed to those subprocesses.
+ * Local mode never opens a TCP listener. The Unix socket's listening fd is not
+ * inherited by shell subprocesses spawned by CES (e.g. for
+ * `run_authenticated_command`): Bun's `Bun.spawn` defaults to "pipe" for
+ * stdio, and the listening socket is not passed to those subprocesses.
  */
 
 import { mkdirSync, unlinkSync } from "node:fs";
@@ -351,12 +342,11 @@ function buildHandlers(secureKeyBackend: SecureKeyBackend): RpcHandlerRegistry {
 // ---------------------------------------------------------------------------
 
 /**
- * Serve RPC over a Unix socket for standalone-sibling mode.
+ * Serve RPC over a Unix socket.
  *
  * Binds the socket, accepts connections concurrently (each served by its own
  * CesRpcServer over the shared handler registry), and unlinks the socket when
- * the signal aborts. Temporary scaffolding — this serving path will be folded
- * into a single unified CES entrypoint shared with the managed sidecar.
+ * the signal aborts.
  */
 function serveStandaloneSocket(opts: {
   socketPath: string;
@@ -439,14 +429,8 @@ async function main(): Promise<void> {
   initLogger({ dir: getCesLogDir(), retentionDays: 30 });
   const log = getLogger("main");
 
-  // `CES_STANDALONE=1` runs CES as an independent, CLI-launched sibling over a
-  // Unix socket; otherwise CES is the assistant's stdio child, as today.
-  const standalone = process.env["CES_STANDALONE"] === "1";
-
   log.info(
-    `Starting CES v${CES_PROTOCOL_VERSION} (local mode, ${
-      standalone ? "standalone socket" : "stdio"
-    } transport)`,
+    `Starting CES v${CES_PROTOCOL_VERSION} (local mode, socket transport)`,
   );
 
   const controller = new AbortController();
@@ -485,43 +469,23 @@ async function main(): Promise<void> {
     error: (msg: string, ...args: unknown[]) => rpcLog.error({ args }, msg),
   };
 
-  if (standalone) {
-    // Serve over a Unix socket and run until a shutdown signal — no stdio
-    // parent to anchor the lifecycle.
-    serveStandaloneSocket({
-      socketPath: getLocalSocketPath(),
-      handlers,
-      signal: controller.signal,
-      logger: rpcLogger,
-      log,
-    });
-    await new Promise<void>((resolve) => {
-      if (controller.signal.aborted) {
-        resolve();
-        return;
-      }
-      controller.signal.addEventListener("abort", () => resolve(), {
-        once: true,
-      });
-    });
-    log.info("Server stopped.");
-    return;
-  }
-
-  // Default: serve the spawning assistant over stdio. stdin closing (parent
-  // exit) or SIGTERM shuts CES down.
-  const server = new CesRpcServer({
-    input: process.stdin,
-    output: process.stdout,
+  // Serve over a Unix socket and run until a shutdown signal.
+  serveStandaloneSocket({
+    socketPath: getLocalSocketPath(),
     handlers,
-    logger: rpcLogger,
     signal: controller.signal,
-    // Local mode reads API keys from env/store directly — no-op handler so
-    // update_managed_credential is still registered and returns success.
-    onApiKeyUpdate: () => {},
+    logger: rpcLogger,
+    log,
+  });
+  await new Promise<void>((resolve) => {
+    if (controller.signal.aborted) {
+      resolve();
+      return;
+    }
+    controller.signal.addEventListener("abort", () => resolve(), {
+      once: true,
+    });
   });
-
-  await server.serve();
   log.info("Server stopped.");
 }
 

package/src/paths.ts

@@ -141,7 +141,7 @@ export function getBootstrapSocketPath(): string {
 }
 
 // ---------------------------------------------------------------------------
-// Local-mode standalone socket (temporary — CES_STANDALONE)
+// Local-mode CES socket
 // ---------------------------------------------------------------------------
 
 /** Default local-mode CES socket filename (under the local data root). */
@@ -150,10 +150,9 @@ const LOCAL_SOCKET_NAME = "ces.sock";
 /**
  * Return the path to the local-mode CES Unix socket.
  *
- * Used when local CES runs as a standalone sibling (`CES_STANDALONE=1`, the
- * CLI-launched opt-in) rather than as the assistant's stdio
- * child. The socket lives under the CES-private local data root, whose
- * directory permissions are the access boundary.
+ * Used when local CES runs as a CLI-launched sibling process. The socket
+ * lives under the CES-private local data root, whose directory permissions
+ * are the access boundary.
  *
  * Priority:
  * 1. `CES_LOCAL_SOCKET` env var (full file path override; the CLI sets this