@vellumai/cli 0.6.6 → 0.7.1

package/src/lib/__tests__/platform-client-signed-url.test.ts

@@ -0,0 +1,405 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import {
+  platformPollJobStatus,
+  platformRequestSignedUrl,
+  type UnifiedJobStatus,
+} from "../platform-client.js";
+
+const PLATFORM_URL = "https://platform.example.test";
+const VAK_TOKEN = "vak_test_1234567890"; // API-key path skips org-ID fetch.
+const SESSION_TOKEN = "session_test_1234567890"; // non-vak_ triggers org-ID lookup.
+
+interface CapturedCall {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  body: unknown;
+}
+
+function captureFetch(
+  responder: (call: CapturedCall) => Response | Promise<Response>,
+): {
+  calls: CapturedCall[];
+  fetchMock: typeof globalThis.fetch;
+} {
+  const calls: CapturedCall[] = [];
+  const fetchMock = mock(
+    async (url: string | URL | Request, init?: RequestInit) => {
+      const urlStr = typeof url === "string" ? url : url.toString();
+      const rawHeaders = (init?.headers ?? {}) as
+        | Record<string, string>
+        | Headers;
+      const headers: Record<string, string> = {};
+      if (rawHeaders instanceof Headers) {
+        rawHeaders.forEach((v, k) => {
+          headers[k] = v;
+        });
+      } else {
+        Object.assign(headers, rawHeaders);
+      }
+      let parsedBody: unknown = undefined;
+      const b = init?.body;
+      if (typeof b === "string") {
+        try {
+          parsedBody = JSON.parse(b);
+        } catch {
+          parsedBody = b;
+        }
+      }
+      const call: CapturedCall = {
+        url: urlStr,
+        method: init?.method ?? "GET",
+        headers,
+        body: parsedBody,
+      };
+      calls.push(call);
+      return responder(call);
+    },
+  );
+  return { calls, fetchMock: fetchMock as unknown as typeof globalThis.fetch };
+}
+
+let originalFetch: typeof globalThis.fetch;
+beforeEach(() => {
+  originalFetch = globalThis.fetch;
+});
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+describe("platformRequestSignedUrl", () => {
+  test("upload operation with just operation → posts correct body and parses response", async () => {
+    const { calls, fetchMock } = captureFetch(() => {
+      return new Response(
+        JSON.stringify({
+          url: "https://storage.example/signed/abc",
+          bundle_key: "bundles/abc.tar.gz",
+          expires_at: "2026-04-22T00:00:00Z",
+        }),
+        { status: 201, headers: { "Content-Type": "application/json" } },
+      );
+    });
+    globalThis.fetch = fetchMock;
+
+    const result = await platformRequestSignedUrl(
+      { operation: "upload" },
+      VAK_TOKEN,
+      PLATFORM_URL,
+    );
+
+    expect(result).toEqual({
+      url: "https://storage.example/signed/abc",
+      bundleKey: "bundles/abc.tar.gz",
+      expiresAt: "2026-04-22T00:00:00Z",
+      maxContentLength: undefined,
+    });
+    expect(calls).toHaveLength(1);
+    expect(calls[0]!.url).toBe(`${PLATFORM_URL}/v1/migrations/signed-url/`);
+    expect(calls[0]!.method).toBe("POST");
+    expect(calls[0]!.headers.Authorization).toBe(`Bearer ${VAK_TOKEN}`);
+    expect(calls[0]!.headers["Content-Type"]).toBe("application/json");
+    expect(calls[0]!.body).toEqual({ operation: "upload" });
+  });
+
+  test("upload operation with content_length + content_type passes them through", async () => {
+    const { calls, fetchMock } = captureFetch(() => {
+      return new Response(
+        JSON.stringify({
+          url: "https://storage.example/signed/xyz",
+          bundle_key: "bundles/xyz.tar.gz",
+          expires_at: "2026-04-22T01:00:00Z",
+          max_content_length: 10_000_000,
+        }),
+        { status: 201 },
+      );
+    });
+    globalThis.fetch = fetchMock;
+
+    const result = await platformRequestSignedUrl(
+      {
+        operation: "upload",
+        contentType: "application/octet-stream",
+        contentLength: 12345,
+      },
+      VAK_TOKEN,
+      PLATFORM_URL,
+    );
+
+    expect(result.maxContentLength).toBe(10_000_000);
+    expect(calls[0]!.body).toEqual({
+      operation: "upload",
+      content_type: "application/octet-stream",
+      content_length: 12345,
+    });
+  });
+
+  test("download operation with bundleKey → posts bundle_key and parses response", async () => {
+    const { calls, fetchMock } = captureFetch(() => {
+      return new Response(
+        JSON.stringify({
+          url: "https://storage.example/signed/dl-xyz",
+          bundle_key: "bundles/xyz.tar.gz",
+          expires_at: "2026-04-22T02:00:00Z",
+        }),
+        { status: 201 },
+      );
+    });
+    globalThis.fetch = fetchMock;
+
+    const result = await platformRequestSignedUrl(
+      { operation: "download", bundleKey: "bundles/xyz.tar.gz" },
+      VAK_TOKEN,
+      PLATFORM_URL,
+    );
+
+    expect(result.url).toBe("https://storage.example/signed/dl-xyz");
+    expect(result.bundleKey).toBe("bundles/xyz.tar.gz");
+    expect(calls[0]!.body).toEqual({
+      operation: "download",
+      bundle_key: "bundles/xyz.tar.gz",
+    });
+  });
+
+  test("401 → retries once and returns success on the retry", async () => {
+    let callCount = 0;
+    const { calls, fetchMock } = captureFetch(() => {
+      callCount += 1;
+      if (callCount === 1) {
+        return new Response(JSON.stringify({ detail: "unauthorized" }), {
+          status: 401,
+        });
+      }
+      return new Response(
+        JSON.stringify({
+          url: "https://storage.example/signed/after-retry",
+          bundle_key: "bundles/r.tar.gz",
+          expires_at: "2026-04-22T03:00:00Z",
+        }),
+        { status: 201 },
+      );
+    });
+    globalThis.fetch = fetchMock;
+
+    const result = await platformRequestSignedUrl(
+      { operation: "upload" },
+      VAK_TOKEN,
+      PLATFORM_URL,
+    );
+
+    expect(result.url).toBe("https://storage.example/signed/after-retry");
+    expect(calls).toHaveLength(2);
+  });
+
+  test("401 with session token → invalidates org-ID cache and re-fetches on retry", async () => {
+    // Session tokens (non-vak_) take the org-ID-fetch path. A 401 here
+    // frequently means the cached org ID is stale, so the retry must
+    // clear the cache and re-fetch before the second signed-url POST.
+    const orgIdCalls: string[] = [];
+    const signedUrlCalls: CapturedCall[] = [];
+    let orgIdFetchCount = 0;
+    let signedUrlCount = 0;
+
+    const fetchMock = mock(
+      async (url: string | URL | Request, init?: RequestInit) => {
+        const urlStr = typeof url === "string" ? url : url.toString();
+        const rawHeaders = (init?.headers ?? {}) as
+          | Record<string, string>
+          | Headers;
+        const headers: Record<string, string> = {};
+        if (rawHeaders instanceof Headers) {
+          rawHeaders.forEach((v, k) => {
+            headers[k] = v;
+          });
+        } else {
+          Object.assign(headers, rawHeaders);
+        }
+
+        if (urlStr.endsWith("/v1/organizations/")) {
+          orgIdFetchCount += 1;
+          orgIdCalls.push(urlStr);
+          const orgId = orgIdFetchCount === 1 ? "org-stale" : "org-fresh";
+          return new Response(
+            JSON.stringify({ results: [{ id: orgId, name: "Test Org" }] }),
+            { status: 200 },
+          );
+        }
+
+        if (urlStr.endsWith("/v1/migrations/signed-url/")) {
+          signedUrlCount += 1;
+          let parsedBody: unknown = undefined;
+          const b = init?.body;
+          if (typeof b === "string") {
+            try {
+              parsedBody = JSON.parse(b);
+            } catch {
+              parsedBody = b;
+            }
+          }
+          signedUrlCalls.push({
+            url: urlStr,
+            method: init?.method ?? "GET",
+            headers,
+            body: parsedBody,
+          });
+          if (signedUrlCount === 1) {
+            return new Response(JSON.stringify({ detail: "stale org" }), {
+              status: 401,
+            });
+          }
+          return new Response(
+            JSON.stringify({
+              url: "https://storage.example/signed/fresh",
+              bundle_key: "bundles/fresh.tar.gz",
+              expires_at: "2026-04-22T04:00:00Z",
+            }),
+            { status: 201 },
+          );
+        }
+
+        throw new Error(`Unexpected URL: ${urlStr}`);
+      },
+    );
+    globalThis.fetch = fetchMock as unknown as typeof globalThis.fetch;
+
+    const result = await platformRequestSignedUrl(
+      { operation: "upload" },
+      SESSION_TOKEN,
+      PLATFORM_URL,
+    );
+
+    // Both signed-url attempts were made and the retry succeeded.
+    expect(result.url).toBe("https://storage.example/signed/fresh");
+    expect(signedUrlCalls).toHaveLength(2);
+
+    // The cache was cleared after the 401, so the org-ID endpoint was
+    // hit a second time to fetch a fresh ID before the retry.
+    expect(orgIdFetchCount).toBe(2);
+    expect(orgIdCalls).toHaveLength(2);
+
+    // The first signed-url POST used the stale org ID, the second used
+    // the fresh one.
+    expect(signedUrlCalls[0]!.headers["Vellum-Organization-Id"]).toBe(
+      "org-stale",
+    );
+    expect(signedUrlCalls[1]!.headers["Vellum-Organization-Id"]).toBe(
+      "org-fresh",
+    );
+
+    // Session tokens use X-Session-Token, not Bearer.
+    expect(signedUrlCalls[0]!.headers["X-Session-Token"]).toBe(SESSION_TOKEN);
+    expect(signedUrlCalls[0]!.headers.Authorization).toBeUndefined();
+  });
+
+  test("5xx error response → surfaces platform detail message", async () => {
+    const { fetchMock } = captureFetch(() => {
+      return new Response(JSON.stringify({ detail: "temporarily down" }), {
+        status: 503,
+      });
+    });
+    globalThis.fetch = fetchMock;
+
+    await expect(
+      platformRequestSignedUrl(
+        { operation: "upload" },
+        VAK_TOKEN,
+        PLATFORM_URL,
+      ),
+    ).rejects.toThrow(/temporarily down/);
+  });
+});
+
+describe("platformPollJobStatus", () => {
+  test("GET /v1/migrations/jobs/{jobId}/ parses processing", async () => {
+    const { calls, fetchMock } = captureFetch(() => {
+      return new Response(
+        JSON.stringify({
+          job_id: "job-1",
+          type: "export",
+          status: "processing",
+        }),
+        { status: 200 },
+      );
+    });
+    globalThis.fetch = fetchMock;
+
+    const status = await platformPollJobStatus(
+      "job-1",
+      VAK_TOKEN,
+      PLATFORM_URL,
+    );
+
+    expect(status).toEqual({
+      jobId: "job-1",
+      type: "export",
+      status: "processing",
+    } satisfies UnifiedJobStatus);
+    expect(calls[0]!.url).toBe(`${PLATFORM_URL}/v1/migrations/jobs/job-1/`);
+    expect(calls[0]!.method).toBe("GET");
+  });
+
+  test("parses complete with bundle_key + result", async () => {
+    const { fetchMock } = captureFetch(() => {
+      return new Response(
+        JSON.stringify({
+          job_id: "job-2",
+          type: "export",
+          status: "complete",
+          bundle_key: "bundles/done.tar.gz",
+          result: { files: 42 },
+        }),
+        { status: 200 },
+      );
+    });
+    globalThis.fetch = fetchMock;
+
+    const status = await platformPollJobStatus(
+      "job-2",
+      VAK_TOKEN,
+      PLATFORM_URL,
+    );
+
+    expect(status.status).toBe("complete");
+    if (status.status === "complete") {
+      expect(status.bundleKey).toBe("bundles/done.tar.gz");
+      expect(status.result).toEqual({ files: 42 });
+    }
+  });
+
+  test("parses failed with error", async () => {
+    const { fetchMock } = captureFetch(() => {
+      return new Response(
+        JSON.stringify({
+          job_id: "job-3",
+          type: "import",
+          status: "failed",
+          error: "bundle corrupt",
+        }),
+        { status: 200 },
+      );
+    });
+    globalThis.fetch = fetchMock;
+
+    const status = await platformPollJobStatus(
+      "job-3",
+      VAK_TOKEN,
+      PLATFORM_URL,
+    );
+
+    expect(status.status).toBe("failed");
+    if (status.status === "failed") {
+      expect(status.error).toBe("bundle corrupt");
+    }
+  });
+
+  test("404 → throws 'Migration job not found'", async () => {
+    const { fetchMock } = captureFetch(() => {
+      return new Response("{}", { status: 404 });
+    });
+    globalThis.fetch = fetchMock;
+
+    await expect(
+      platformPollJobStatus("missing", VAK_TOKEN, PLATFORM_URL),
+    ).rejects.toThrow(/Migration job not found/);
+  });
+});

package/src/lib/__tests__/runtime-url.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, test } from "bun:test";
+
+import type { AssistantEntry } from "../assistant-config.js";
+import { resolveRuntimeMigrationUrl } from "../runtime-url.js";
+
+function makeEntry(
+  overrides: Partial<AssistantEntry> & {
+    cloud: string;
+    runtimeUrl: string;
+    assistantId: string;
+  },
+): Pick<AssistantEntry, "cloud" | "runtimeUrl" | "assistantId"> {
+  return {
+    cloud: overrides.cloud,
+    runtimeUrl: overrides.runtimeUrl,
+    assistantId: overrides.assistantId,
+  };
+}
+
+describe("resolveRuntimeMigrationUrl", () => {
+  test("local cloud uses gateway-loopback /v1/migrations/<subpath>", () => {
+    const entry = makeEntry({
+      cloud: "local",
+      runtimeUrl: "http://localhost:7821",
+      assistantId: "ast-local-1",
+    });
+    expect(resolveRuntimeMigrationUrl(entry, "export-to-gcs")).toBe(
+      "http://localhost:7821/v1/migrations/export-to-gcs",
+    );
+    expect(resolveRuntimeMigrationUrl(entry, "import-from-gcs")).toBe(
+      "http://localhost:7821/v1/migrations/import-from-gcs",
+    );
+    expect(resolveRuntimeMigrationUrl(entry, "jobs/job-abc")).toBe(
+      "http://localhost:7821/v1/migrations/jobs/job-abc",
+    );
+  });
+
+  test("docker cloud uses gateway-loopback /v1/migrations/<subpath>", () => {
+    const entry = makeEntry({
+      cloud: "docker",
+      runtimeUrl: "http://localhost:7831",
+      assistantId: "ast-docker-1",
+    });
+    expect(resolveRuntimeMigrationUrl(entry, "export-to-gcs")).toBe(
+      "http://localhost:7831/v1/migrations/export-to-gcs",
+    );
+  });
+
+  test("vellum (platform-managed) cloud uses wildcard-proxy /v1/assistants/<id>/migrations/<subpath>", () => {
+    const entry = makeEntry({
+      cloud: "vellum",
+      runtimeUrl: "https://platform.vellum.ai",
+      assistantId: "11111111-2222-3333-4444-555555555555",
+    });
+    expect(resolveRuntimeMigrationUrl(entry, "export-to-gcs")).toBe(
+      "https://platform.vellum.ai/v1/assistants/11111111-2222-3333-4444-555555555555/migrations/export-to-gcs",
+    );
+    expect(resolveRuntimeMigrationUrl(entry, "import-from-gcs")).toBe(
+      "https://platform.vellum.ai/v1/assistants/11111111-2222-3333-4444-555555555555/migrations/import-from-gcs",
+    );
+    expect(resolveRuntimeMigrationUrl(entry, "jobs/job-xyz")).toBe(
+      "https://platform.vellum.ai/v1/assistants/11111111-2222-3333-4444-555555555555/migrations/jobs/job-xyz",
+    );
+  });
+
+  test("dev platform URL still routes through the wildcard prefix", () => {
+    const entry = makeEntry({
+      cloud: "vellum",
+      runtimeUrl: "https://dev-platform.vellum.ai",
+      assistantId: "ast-dev-1",
+    });
+    expect(resolveRuntimeMigrationUrl(entry, "export-to-gcs")).toBe(
+      "https://dev-platform.vellum.ai/v1/assistants/ast-dev-1/migrations/export-to-gcs",
+    );
+  });
+
+  test("a non-vellum, non-local cloud (e.g. gcp) uses the local-shape URL", () => {
+    const entry = makeEntry({
+      cloud: "gcp",
+      runtimeUrl: "http://10.0.0.5:7821",
+      assistantId: "ast-gcp-1",
+    });
+    expect(resolveRuntimeMigrationUrl(entry, "export-to-gcs")).toBe(
+      "http://10.0.0.5:7821/v1/migrations/export-to-gcs",
+    );
+  });
+});

package/src/lib/__tests__/terminal-session.test.ts

@@ -0,0 +1,202 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  parseSentinelOutput,
+  stripAnsi,
+} from "../terminal-session.js";
+
+const START = "__VELLUM_EXEC_START_1234__";
+const END = "__VELLUM_EXEC_END_1234__";
+
+// ---------------------------------------------------------------------------
+// stripAnsi
+// ---------------------------------------------------------------------------
+
+describe("stripAnsi", () => {
+  test("removes SGR color codes", () => {
+    expect(stripAnsi("\x1b[32mINFO\x1b[39m hello")).toBe("INFO hello");
+  });
+
+  test("removes OSC title sequences", () => {
+    expect(stripAnsi("\x1b]0;title\x07prompt$ ")).toBe("prompt$ ");
+  });
+
+  test("removes carriage returns", () => {
+    expect(stripAnsi("line1\r\nline2\r\n")).toBe("line1\nline2\n");
+  });
+
+  test("removes bracket-paste mode escapes", () => {
+    expect(stripAnsi("\x1b[?2004hroot$ ")).toBe("root$ ");
+  });
+
+  test("removes charset designator sequences", () => {
+    expect(stripAnsi("\x1b(Bhello")).toBe("hello");
+  });
+
+  test("passes through plain text unchanged", () => {
+    expect(stripAnsi("just plain text")).toBe("just plain text");
+  });
+
+  test("handles mixed ANSI sequences", () => {
+    const raw =
+      "\x1b[?2004hroot:/workspace$ \r\x1b[K\rroot:/workspace$ echo hello\r\nhello\r\n";
+    const clean = stripAnsi(raw);
+    expect(clean).not.toContain("\x1b");
+    expect(clean).not.toContain("\r");
+    expect(clean).toContain("hello");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// parseSentinelOutput
+// ---------------------------------------------------------------------------
+
+describe("parseSentinelOutput", () => {
+  test("extracts output between sentinels", () => {
+    const cleaned = [
+      `echo '${START}'; ls; echo '${END}'; echo '__VELLUM_EXIT_'$__ec`,
+      START,
+      "file1.txt",
+      "file2.txt",
+      END,
+      "__VELLUM_EXIT_0",
+    ].join("\n");
+
+    const result = parseSentinelOutput(cleaned, START, END);
+    expect(result.output).toBe("file1.txt\nfile2.txt");
+    expect(result.exitCode).toBe(0);
+  });
+
+  test("extracts non-zero exit code", () => {
+    const cleaned = [
+      `echo '${START}'; false; echo '${END}'; echo '__VELLUM_EXIT_'$__ec`,
+      START,
+      END,
+      "__VELLUM_EXIT_1",
+    ].join("\n");
+
+    const result = parseSentinelOutput(cleaned, START, END);
+    expect(result.output).toBe("");
+    expect(result.exitCode).toBe(1);
+  });
+
+  test("handles exit code 127 (command not found)", () => {
+    const cleaned = [
+      START,
+      "bash: nosuchcmd: command not found",
+      END,
+      "__VELLUM_EXIT_127",
+    ].join("\n");
+
+    const result = parseSentinelOutput(cleaned, START, END);
+    expect(result.output).toBe("bash: nosuchcmd: command not found");
+    expect(result.exitCode).toBe(127);
+  });
+
+  test("uses last start sentinel (skips command echo)", () => {
+    // The command echo contains the sentinel text, then the actual output
+    // sentinel comes later. Parser must pick the last START, not the echo.
+    const cleaned = [
+      `root$ echo '${START}'; mycommand; echo '${END}'; echo '__VELLUM_EXIT_'$__ec`,
+      START,
+      "real output here",
+      END,
+      "__VELLUM_EXIT_0",
+    ].join("\n");
+
+    const result = parseSentinelOutput(cleaned, START, END);
+    expect(result.output).toBe("real output here");
+    expect(result.exitCode).toBe(0);
+  });
+
+  test("regression: end sentinel in echo before start sentinel in output", () => {
+    // This was the original bug: backward search found END in the echo
+    // (line 0) before START in the output (line 1), giving endIdx < startIdx.
+    const cleaned = [
+      `echo '${START}'; cmd; echo '${END}'; echo '__VELLUM_EXIT_'$__ec; exit $__ec`,
+      START,
+      "[INFO] Running clawhub command",
+      '    args: ["search"]',
+      '    cwd: "/workspace"',
+    ].join("\n");
+
+    // No end sentinel in actual output yet (stream was cut short in old code)
+    const result = parseSentinelOutput(cleaned, START, END);
+    // Should still return the partial output (no end sentinel → take everything)
+    expect(result.output).toContain("[INFO] Running clawhub command");
+    expect(result.output).toContain('cwd: "/workspace"');
+  });
+
+  test("handles multiline output with special characters", () => {
+    const cleaned = [
+      START,
+      "📤 Resend Email Setup [installed]",
+      "  ID: resend-setup",
+      '  Set up and send emails via a user-provided Resend account (BYO email provider)',
+      "",
+      "Community registry (1):",
+      "",
+      "  resend-setup [installed]",
+      END,
+      "__VELLUM_EXIT_0",
+    ].join("\n");
+
+    const result = parseSentinelOutput(cleaned, START, END);
+    expect(result.output).toContain("📤 Resend Email Setup");
+    expect(result.output).toContain("Community registry (1):");
+    expect(result.exitCode).toBe(0);
+  });
+
+  test("returns empty output and exit code 0 when no sentinels found", () => {
+    const cleaned = "just some random output\nwith no sentinels\n";
+    const result = parseSentinelOutput(cleaned, START, END);
+    // Falls back to entire output (trimmed)
+    expect(result.output).toBe(
+      "just some random output\nwith no sentinels",
+    );
+    expect(result.exitCode).toBe(0);
+  });
+
+  test("handles output with only start sentinel (no end)", () => {
+    const cleaned = [
+      START,
+      "partial output",
+      "more output",
+    ].join("\n");
+
+    const result = parseSentinelOutput(cleaned, START, END);
+    expect(result.output).toBe("partial output\nmore output");
+    expect(result.exitCode).toBe(0);
+  });
+
+  test("handles real-world verbose trace structure", () => {
+    // Simulates the full cleaned output from a real exec session
+    const cleaned = [
+      "root:/workspace$ root:/workspace$ " +
+        `echo '${START}'; 'assistant' 'skills' 'search' 'resend-setup'; __ec=$?; echo ` +
+        ` '${END}'; echo '__VELLUM_EXIT_'$__ec; exit $__ec`,
+      START,
+      "[13:06:38.851] INFO (761 on pod-0): [clawhub] Running clawhub command",
+      '    args: [',
+      '      "search",',
+      '      "resend-setup",',
+      '      "--limit",',
+      '      "10"',
+      "    ]",
+      '    cwd: "/workspace"',
+      "Bundled & installed skills (1):",
+      "",
+      "  📤 Resend Email Setup [installed]",
+      "    ID: resend-setup",
+      "",
+      END,
+      "__VELLUM_EXIT_0",
+    ].join("\n");
+
+    const result = parseSentinelOutput(cleaned, START, END);
+    expect(result.output).toContain("Bundled & installed skills (1):");
+    expect(result.output).toContain("📤 Resend Email Setup [installed]");
+    expect(result.output).toContain("[clawhub] Running clawhub command");
+    expect(result.exitCode).toBe(0);
+  });
+});