@vellumai/credential-executor 0.10.5 → 0.10.6-dev.202607062124.26c976d

package/Dockerfile

@@ -1,3 +1,4 @@
+# syntax=docker/dockerfile:1.20@sha256:26147acbda4f14c5add9946e2fd2ed543fc402884fd75146bd342a7f6271dc1d
 # Build stage
 FROM debian:trixie@sha256:3615a749858a1cba49b408fb49c37093db813321355a9ab7c1f9f4836341e9db AS builder
 
@@ -13,18 +14,23 @@ RUN apt-get update && apt-get install -y \
 RUN curl -fsSL https://bun.sh/install | bash -s "bun-v1.3.11"
 ENV PATH="/root/.bun/bin:${PATH}"
 
-# Copy shared packages first (needed for repo-local dependencies)
-COPY packages/service-contracts ./packages/service-contracts
-COPY packages/credential-storage ./packages/credential-storage
-COPY packages/egress-proxy ./packages/egress-proxy
-
-# Install deps for service-contracts so its own source can resolve zod
-# at runtime (loaded via grants.ts and siblings).
-RUN cd /app/packages/service-contracts && bun install --frozen-lockfile
-
-# Install credential-executor dependencies with local package resolution
-COPY credential-executor/package.json credential-executor/bun.lock* ./credential-executor/
-RUN cd /app/credential-executor && bun install --frozen-lockfile
+# We must include every workspace member's manifest to validate and install the
+# workspace lockfile via --frozen-lockfile.
+# Note that we don't need source code to resolve cross-workspace dependencies.
+COPY package.json bun.lock ./
+COPY patches ./patches
+COPY clients/web/patches ./clients/web/patches
+COPY clients/macos/package.json ./clients/macos/
+COPY clients/web/package.json ./clients/web/
+COPY cli/package.json ./cli/
+COPY gateway/package.json ./gateway/
+COPY credential-executor/package.json ./credential-executor/
+COPY assistant/package.json ./assistant/
+COPY assistant/src/api/package.json ./assistant/src/api/
+COPY --parents packages/*/package.json ./
+
+RUN bun install --frozen-lockfile --ignore-scripts \
+    --filter='./credential-executor'
 
 # Runtime stage
 FROM debian:trixie-slim@sha256:1d3c811171a08a5adaa4a163fbafd96b61b87aa871bbc7aa15431ac275d3d430 AS runner
@@ -46,10 +52,12 @@ RUN ln -sf /usr/local/bin/bun /usr/local/bin/bunx
 RUN groupadd --system --gid 1001 ces && \
     useradd --system --uid 1001 --gid ces --create-home ces
 
-# Copy installed deps + shared packages from builder.
 COPY --from=builder --chown=ces:ces /app /app
 
-# Copy source separately to avoid invalidating builder layer.
+# Copy source after installing dependencies for better layer caching.
+COPY --chown=ces:ces packages/service-contracts /app/packages/service-contracts
+COPY --chown=ces:ces packages/credential-storage /app/packages/credential-storage
+COPY --chown=ces:ces packages/egress-proxy /app/packages/egress-proxy
 COPY --chown=ces:ces credential-executor ./
 
 # Pre-create /ces-data so the non-root ces user can write to it

package/node_modules/@vellumai/credential-storage/tsconfig.json

@@ -13,7 +13,7 @@
     "sourceMap": true,
     "outDir": "./dist",
     "rootDir": "./src",
-    "types": ["bun-types"]
+    "types": ["bun"]
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]

package/node_modules/@vellumai/egress-proxy/tsconfig.json

@@ -13,7 +13,7 @@
     "sourceMap": true,
     "outDir": "./dist",
     "rootDir": "./src",
-    "types": ["bun-types"]
+    "types": ["bun"]
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]

package/node_modules/@vellumai/service-contracts/src/__tests__/ingress.test.ts

@@ -5,10 +5,8 @@ import {
   normalizePublicBaseUrl,
 } from "../ingress.js";
 import {
-  buildTwilioConnectActionUrl,
   buildTwilioMediaStreamUrl,
   buildTwilioPhoneNumberWebhookUrls,
-  buildTwilioRelayUrl,
   buildTwilioVoiceWebhookUrl,
   resolveTwilioPublicBaseUrl,
 } from "../twilio-ingress.js";
@@ -90,12 +88,6 @@ describe("Twilio ingress helpers", () => {
     expect(buildTwilioVoiceWebhookUrl("https://example.test", "call-123")).toBe(
       "https://example.test/webhooks/twilio/voice?callSessionId=call-123",
     );
-    expect(buildTwilioConnectActionUrl("https://example.test")).toBe(
-      "https://example.test/webhooks/twilio/connect-action",
-    );
-    expect(buildTwilioRelayUrl("https://example.test")).toBe(
-      "wss://example.test/webhooks/twilio/relay",
-    );
     expect(buildTwilioMediaStreamUrl("http://example.test")).toBe(
       "ws://example.test/webhooks/twilio/media-stream",
     );

package/node_modules/@vellumai/service-contracts/src/twilio-ingress.ts

@@ -2,9 +2,6 @@ import { normalizePublicBaseUrl } from "./ingress.js";
 
 export const TWILIO_VOICE_WEBHOOK_PATH = "/webhooks/twilio/voice";
 export const TWILIO_STATUS_WEBHOOK_PATH = "/webhooks/twilio/status";
-export const TWILIO_CONNECT_ACTION_WEBHOOK_PATH =
-  "/webhooks/twilio/connect-action";
-export const TWILIO_RELAY_WEBHOOK_PATH = "/webhooks/twilio/relay";
 export const TWILIO_MEDIA_STREAM_WEBHOOK_PATH = "/webhooks/twilio/media-stream";
 
 /**
@@ -13,9 +10,9 @@ export const TWILIO_MEDIA_STREAM_WEBHOOK_PATH = "/webhooks/twilio/media-stream";
  * with the actual public URL (from Velay registration, config, or the
  * `X-Vellum-Ingress-URL` header) before returning TwiML to Twilio.
  *
- * The placeholder uses `https://` so that `buildTwilioRelayUrl` /
- * `buildTwilioMediaStreamUrl` can apply the standard `http→ws` scheme
- * conversion, producing `wss://__VELLUM_PUBLIC_BASE_URL__/…` in the output.
+ * The placeholder uses `https://` so that `buildTwilioMediaStreamUrl` can
+ * apply the standard `http→ws` scheme conversion, producing
+ * `wss://__VELLUM_PUBLIC_BASE_URL__/…` in the output.
  */
 export const TWILIO_PUBLIC_BASE_URL_PLACEHOLDER =
   "https://__VELLUM_PUBLIC_BASE_URL__";
@@ -58,14 +55,6 @@ export function buildTwilioStatusWebhookUrl(baseUrl: string): string {
   return `${baseUrl}${TWILIO_STATUS_WEBHOOK_PATH}`;
 }
 
-export function buildTwilioConnectActionUrl(baseUrl: string): string {
-  return `${baseUrl}${TWILIO_CONNECT_ACTION_WEBHOOK_PATH}`;
-}
-
-export function buildTwilioRelayUrl(baseUrl: string): string {
-  return `${toTwilioWebSocketBaseUrl(baseUrl)}${TWILIO_RELAY_WEBHOOK_PATH}`;
-}
-
 export function buildTwilioMediaStreamUrl(baseUrl: string): string {
   return `${toTwilioWebSocketBaseUrl(baseUrl)}${TWILIO_MEDIA_STREAM_WEBHOOK_PATH}`;
 }

package/node_modules/@vellumai/service-contracts/tsconfig.json

@@ -13,7 +13,7 @@
     "sourceMap": true,
     "outDir": "./dist",
     "rootDir": "./src",
-    "types": ["bun-types"]
+    "types": ["bun"]
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/credential-executor",
-  "version": "0.10.5",
+  "version": "0.10.6-dev.202607062124.26c976d",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -17,13 +17,9 @@
     "lint": "eslint",
     "lint:unused": "knip --include files,dependencies,unlisted",
     "typecheck": "bunx tsc --noEmit",
-    "test": "bun test src/",
-    "prepack": "node ../scripts/prepack-bundled-deps.mjs"
+    "test": "bun test src/"
   },
   "dependencies": {
-    "@vellumai/service-contracts": "file:../packages/service-contracts",
-    "@vellumai/credential-storage": "file:../packages/credential-storage",
-    "@vellumai/egress-proxy": "file:../packages/egress-proxy",
     "pino": "9.14.0",
     "pino-pretty": "13.1.3"
   },

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

@@ -0,0 +1,233 @@
+/**
+ * Local CES standalone-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:
+ *
+ *   1. binds its Unix socket and serves RPC despite having no stdio parent
+ *      (lifecycle anchored to SIGTERM, not stdin), and
+ *   2. survives a client disconnecting, and
+ *   3. shuts down on SIGTERM.
+ *
+ * Local mode has no TCP health server, so this runs without binding a TCP port.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { createConnection, type Socket } from "node:net";
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+
+import {
+  CES_PROTOCOL_VERSION,
+  CesRpcMethod,
+  type HandshakeAck,
+  type RpcEnvelope,
+  type ListCredentialsResponse,
+} from "@vellumai/service-contracts/credential-rpc";
+
+import type { Subprocess } from "bun";
+
+function delay(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+async function waitForSocket(
+  socketPath: string,
+  timeoutMs = 10_000,
+): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (existsSync(socketPath)) return;
+    await delay(50);
+  }
+  throw new Error(`Standalone CES socket did not appear within ${timeoutMs}ms`);
+}
+
+function connectToSocket(
+  socketPath: string,
+  { maxRetries = 40, baseDelayMs = 25 } = {},
+): Promise<Socket> {
+  return new Promise((resolveConn, reject) => {
+    let attempt = 0;
+    const tryConnect = () => {
+      const sock = createConnection(socketPath, () => {
+        sock.removeAllListeners("error");
+        resolveConn(sock);
+      });
+      sock.on("error", (err: NodeJS.ErrnoException) => {
+        sock.destroy();
+        attempt++;
+        if (
+          attempt < maxRetries &&
+          (err.code === "ENOENT" || err.code === "ECONNREFUSED")
+        ) {
+          setTimeout(tryConnect, baseDelayMs);
+        } else {
+          reject(err);
+        }
+      });
+    };
+    tryConnect();
+  });
+}
+
+/** Read one newline-delimited JSON message from the socket. */
+function readOne<T>(sock: Socket, timeoutMs = 5_000): Promise<T> {
+  return new Promise((resolveMsg, reject) => {
+    let buffer = "";
+    const timer = setTimeout(() => {
+      sock.removeAllListeners("data");
+      reject(new Error("Timed out waiting for a message"));
+    }, timeoutMs);
+    const onData = (chunk: Buffer) => {
+      buffer += chunk.toString("utf-8");
+      const idx = buffer.indexOf("\n");
+      if (idx === -1) return;
+      clearTimeout(timer);
+      sock.removeListener("data", onData);
+      try {
+        resolveMsg(JSON.parse(buffer.slice(0, idx).trim()) as T);
+      } catch (err) {
+        reject(err as Error);
+      }
+    };
+    sock.on("data", onData);
+    sock.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+async function handshake(
+  sock: Socket,
+  sessionId: string,
+): Promise<HandshakeAck> {
+  sock.write(
+    JSON.stringify({
+      type: "handshake_request",
+      protocolVersion: CES_PROTOCOL_VERSION,
+      sessionId,
+    }) + "\n",
+  );
+  return readOne<HandshakeAck>(sock);
+}
+
+let tmpDir: string | undefined;
+let proc: Subprocess | undefined;
+
+afterEach(async () => {
+  if (proc) {
+    proc.kill("SIGTERM");
+    await Promise.race([proc.exited, delay(3_000)]);
+    proc = undefined;
+  }
+  if (tmpDir) {
+    try {
+      rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+      /* ok */
+    }
+    tmpDir = undefined;
+  }
+});
+
+describe("local CES standalone sibling (real entrypoint)", () => {
+  test("serves over a socket with no stdio parent, survives disconnect, exits on SIGTERM", async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "ces-standalone-"));
+    const socketPath = join(tmpDir, "ces.sock");
+    const securityDir = join(tmpDir, "protected");
+    const workspaceDir = join(tmpDir, "workspace");
+    mkdirSync(securityDir, { recursive: true });
+    mkdirSync(workspaceDir, { recursive: true });
+
+    const localMain = resolve(__dirname, "..", "main.ts");
+
+    // CES_STANDALONE=1 + stdin closed is how the CLI launches the sibling.
+    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,
+      },
+      stdin: "ignore",
+      stdout: "ignore",
+      stderr: "ignore",
+    });
+
+    await waitForSocket(socketPath);
+    expect(proc.killed).toBe(false);
+
+    // First client: handshake + a real RPC.
+    const first = await connectToSocket(socketPath);
+    const ack1 = await handshake(first, "sibling-1");
+    expect(ack1.accepted).toBe(true);
+
+    first.write(
+      JSON.stringify({
+        type: "rpc",
+        id: "rpc-1",
+        kind: "request",
+        method: CesRpcMethod.ListCredentials,
+        payload: {},
+        timestamp: new Date().toISOString(),
+      }) + "\n",
+    );
+    const rpcResp = await readOne<RpcEnvelope & { type: "rpc" }>(first);
+    expect((rpcResp.payload as ListCredentialsResponse).accounts).toEqual([]);
+
+    // Disconnect — CES must stay up.
+    first.destroy();
+    await delay(200);
+    expect(proc.killed).toBe(false);
+
+    // Reconnect proves it survived.
+    const second = await connectToSocket(socketPath);
+    const ack2 = await handshake(second, "sibling-2");
+    expect(ack2.accepted).toBe(true);
+    second.destroy();
+
+    // SIGTERM shuts it down.
+    proc.kill("SIGTERM");
+    const exited = await Promise.race([
+      proc.exited.then(() => true),
+      delay(5_000).then(() => false),
+    ]);
+    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

@@ -23,7 +23,11 @@ import {
   type RpcEnvelope,
 } from "@vellumai/service-contracts/credential-rpc";
 
-import { getCesDataRoot, getBootstrapSocketPath, getHealthPort } from "../paths.js";
+import {
+  getCesDataRoot,
+  getBootstrapSocketPath,
+  getHealthPort,
+} from "../paths.js";
 import { CesRpcServer, type RpcHandlerRegistry } from "../server.js";
 
 // ---------------------------------------------------------------------------
@@ -104,7 +108,16 @@ function createTestServer(handlers: RpcHandlerRegistry = {}) {
     return JSON.parse(lines[lines.length - 1]) as RpcEnvelope;
   }
 
-  return { server, input, output, send, collectOutputLines, handshake, rpc, logs };
+  return {
+    server,
+    input,
+    output,
+    send,
+    collectOutputLines,
+    handshake,
+    rpc,
+    logs,
+  };
 }
 
 // ---------------------------------------------------------------------------
@@ -194,15 +207,15 @@ describe("health probes", () => {
 // ---------------------------------------------------------------------------
 
 describe("local entrypoint transport isolation", () => {
-  test("main.ts uses process.stdin/stdout, not TCP listeners", () => {
+  test("main.ts serves over stdio or a Unix socket, never a TCP listener", () => {
     const src = readFileSync(resolve(__dirname, "..", "main.ts"), "utf-8");
-    // Uses stdin/stdout for transport
+    // Serves the stdio-child transport (default mode).
     expect(src).toMatch(/process\.stdin/);
     expect(src).toMatch(/process\.stdout/);
-    // Does not open any TCP or Unix socket listener
+    // Standalone mode (CES_STANDALONE=1) 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(/createServer\(/);
-    expect(src).not.toMatch(/\.listen\(/);
+    expect(src).not.toMatch(/\.listen\(\d+/);
   });
 
   test("main.ts logs to stderr, not stdout (avoids polluting transport)", () => {
@@ -310,9 +323,10 @@ describe("CesRpcServer", () => {
 
     const resp = await rpc("nonexistent_method", {});
     expect(resp.kind).toBe("response");
-    expect((resp.payload as { success: boolean; error: { code: string } }).error.code).toBe(
-      "METHOD_NOT_FOUND",
-    );
+    expect(
+      (resp.payload as { success: boolean; error: { code: string } }).error
+        .code,
+    ).toBe("METHOD_NOT_FOUND");
 
     server.close();
     input.end();
@@ -332,7 +346,10 @@ describe("CesRpcServer", () => {
 
     const resp = await rpc("fail_method", {});
     expect(resp.kind).toBe("response");
-    const payload = resp.payload as { success: boolean; error: { code: string; message: string } };
+    const payload = resp.payload as {
+      success: boolean;
+      error: { code: string; message: string };
+    };
     expect(payload.error.code).toBe("HANDLER_ERROR");
     expect(payload.error.message).toMatch(/Intentional test failure/);