@vellumai/cli 0.5.16 → 0.6.1

package/src/__tests__/teleport.test.ts

@@ -64,7 +64,6 @@ mock.module("../lib/guardian-token.js", () => ({
 }));
 
 const readPlatformTokenMock = mock((): string | null => "platform-token");
-const fetchOrganizationIdMock = mock(async () => "org-123");
 const getPlatformUrlMock = mock(() => "https://platform.vellum.ai");
 const hatchAssistantMock = mock(async () => ({
   id: "platform-new-id",
@@ -108,10 +107,40 @@ const platformImportBundleMock = mock(async () => ({
     },
   } as Record<string, unknown>,
 }));
+const platformRequestUploadUrlMock = mock(async () => ({
+  uploadUrl: "https://storage.googleapis.com/bucket/signed-upload-url",
+  bundleKey: "bundle-key-123",
+  expiresAt: new Date(Date.now() + 3600_000).toISOString(),
+}));
+const platformUploadToSignedUrlMock = mock(async () => {});
+const platformImportPreflightFromGcsMock = mock(async () => ({
+  statusCode: 200,
+  body: {
+    can_import: true,
+    summary: {
+      files_to_create: 2,
+      files_to_overwrite: 1,
+      files_unchanged: 0,
+      total_files: 3,
+    },
+  } as Record<string, unknown>,
+}));
+const platformImportBundleFromGcsMock = mock(async () => ({
+  statusCode: 200,
+  body: {
+    success: true,
+    summary: {
+      total_files: 3,
+      files_created: 2,
+      files_overwritten: 1,
+      files_skipped: 0,
+      backups_created: 1,
+    },
+  } as Record<string, unknown>,
+}));
 
 mock.module("../lib/platform-client.js", () => ({
   readPlatformToken: readPlatformTokenMock,
-  fetchOrganizationId: fetchOrganizationIdMock,
   getPlatformUrl: getPlatformUrlMock,
   hatchAssistant: hatchAssistantMock,
   platformInitiateExport: platformInitiateExportMock,
@@ -119,6 +148,10 @@ mock.module("../lib/platform-client.js", () => ({
   platformDownloadExport: platformDownloadExportMock,
   platformImportPreflight: platformImportPreflightMock,
   platformImportBundle: platformImportBundleMock,
+  platformRequestUploadUrl: platformRequestUploadUrlMock,
+  platformUploadToSignedUrl: platformUploadToSignedUrlMock,
+  platformImportPreflightFromGcs: platformImportPreflightFromGcsMock,
+  platformImportBundleFromGcs: platformImportBundleFromGcsMock,
 }));
 
 const hatchLocalMock = mock(async () => {});
@@ -205,8 +238,6 @@ beforeEach(() => {
 
   readPlatformTokenMock.mockReset();
   readPlatformTokenMock.mockReturnValue("platform-token");
-  fetchOrganizationIdMock.mockReset();
-  fetchOrganizationIdMock.mockResolvedValue("org-123");
   getPlatformUrlMock.mockReset();
   getPlatformUrlMock.mockReturnValue("https://platform.vellum.ai");
   hatchAssistantMock.mockReset();
@@ -256,6 +287,41 @@ beforeEach(() => {
       },
     },
   });
+  platformRequestUploadUrlMock.mockReset();
+  platformRequestUploadUrlMock.mockResolvedValue({
+    uploadUrl: "https://storage.googleapis.com/bucket/signed-upload-url",
+    bundleKey: "bundle-key-123",
+    expiresAt: new Date(Date.now() + 3600_000).toISOString(),
+  });
+  platformUploadToSignedUrlMock.mockReset();
+  platformUploadToSignedUrlMock.mockResolvedValue(undefined);
+  platformImportPreflightFromGcsMock.mockReset();
+  platformImportPreflightFromGcsMock.mockResolvedValue({
+    statusCode: 200,
+    body: {
+      can_import: true,
+      summary: {
+        files_to_create: 2,
+        files_to_overwrite: 1,
+        files_unchanged: 0,
+        total_files: 3,
+      },
+    },
+  });
+  platformImportBundleFromGcsMock.mockReset();
+  platformImportBundleFromGcsMock.mockResolvedValue({
+    statusCode: 200,
+    body: {
+      success: true,
+      summary: {
+        total_files: 3,
+        files_created: 2,
+        files_overwritten: 1,
+        files_skipped: 0,
+        backups_created: 1,
+      },
+    },
+  });
 
   hatchLocalMock.mockReset();
   hatchLocalMock.mockResolvedValue(undefined);
@@ -998,3 +1064,363 @@ describe("teleport full flow", () => {
     );
   });
 });
+
+// ---------------------------------------------------------------------------
+// Signed-URL upload tests
+// ---------------------------------------------------------------------------
+
+describe("signed-URL upload flow", () => {
+  test("happy path: signed URL upload succeeds → GCS-based import used", async () => {
+    setArgv("--from", "my-local", "--platform");
+
+    const localEntry = makeEntry("my-local", { cloud: "local" });
+
+    findAssistantByNameMock.mockImplementation((name: string) => {
+      if (name === "my-local") return localEntry;
+      return null;
+    });
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = createFetchMock() as unknown as typeof globalThis.fetch;
+
+    try {
+      await teleport();
+
+      // Signed-URL flow should be used
+      expect(platformRequestUploadUrlMock).toHaveBeenCalled();
+      expect(platformUploadToSignedUrlMock).toHaveBeenCalled();
+      expect(platformImportBundleFromGcsMock).toHaveBeenCalledWith(
+        "bundle-key-123",
+        "platform-token",
+        "https://platform.vellum.ai",
+      );
+      // Inline import should NOT be called
+      expect(platformImportBundleMock).not.toHaveBeenCalled();
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining("Teleport complete"),
+      );
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  test("happy path dry-run: signed URL upload succeeds → GCS-based preflight used", async () => {
+    setArgv(
+      "--from",
+      "my-local",
+      "--platform",
+      "existing-platform",
+      "--dry-run",
+    );
+
+    const localEntry = makeEntry("my-local", { cloud: "local" });
+    const platformEntry = makeEntry("existing-platform", {
+      cloud: "vellum",
+      runtimeUrl: "https://platform.vellum.ai",
+    });
+
+    findAssistantByNameMock.mockImplementation((name: string) => {
+      if (name === "my-local") return localEntry;
+      if (name === "existing-platform") return platformEntry;
+      return null;
+    });
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = createFetchMock() as unknown as typeof globalThis.fetch;
+
+    try {
+      await teleport();
+
+      // Signed-URL flow should be used for preflight
+      expect(platformRequestUploadUrlMock).toHaveBeenCalled();
+      expect(platformUploadToSignedUrlMock).toHaveBeenCalled();
+      expect(platformImportPreflightFromGcsMock).toHaveBeenCalledWith(
+        "bundle-key-123",
+        "platform-token",
+        "https://platform.vellum.ai",
+      );
+      // Inline preflight should NOT be called
+      expect(platformImportPreflightMock).not.toHaveBeenCalled();
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  test("fallback: platformRequestUploadUrl throws 503 → falls back to inline import", async () => {
+    setArgv("--from", "my-local", "--platform");
+
+    const localEntry = makeEntry("my-local", { cloud: "local" });
+
+    findAssistantByNameMock.mockImplementation((name: string) => {
+      if (name === "my-local") return localEntry;
+      return null;
+    });
+
+    // Simulate 503 — "not available" in the error message
+    platformRequestUploadUrlMock.mockRejectedValue(
+      new Error("Signed uploads are not available on this platform instance"),
+    );
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = createFetchMock() as unknown as typeof globalThis.fetch;
+
+    try {
+      await teleport();
+
+      // Should fall back to inline import
+      expect(platformRequestUploadUrlMock).toHaveBeenCalled();
+      expect(platformUploadToSignedUrlMock).not.toHaveBeenCalled();
+      expect(platformImportBundleFromGcsMock).not.toHaveBeenCalled();
+      expect(platformImportBundleMock).toHaveBeenCalled();
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining("Teleport complete"),
+      );
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  test("fallback: platformRequestUploadUrl throws 404 → falls back to inline import", async () => {
+    setArgv("--from", "my-local", "--platform");
+
+    const localEntry = makeEntry("my-local", { cloud: "local" });
+
+    findAssistantByNameMock.mockImplementation((name: string) => {
+      if (name === "my-local") return localEntry;
+      return null;
+    });
+
+    // Simulate 404 — endpoint doesn't exist on older platform versions
+    platformRequestUploadUrlMock.mockRejectedValue(
+      new Error("Signed uploads are not available on this platform instance"),
+    );
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = createFetchMock() as unknown as typeof globalThis.fetch;
+
+    try {
+      await teleport();
+
+      // Should fall back to inline import
+      expect(platformRequestUploadUrlMock).toHaveBeenCalled();
+      expect(platformUploadToSignedUrlMock).not.toHaveBeenCalled();
+      expect(platformImportBundleFromGcsMock).not.toHaveBeenCalled();
+      expect(platformImportBundleMock).toHaveBeenCalled();
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining("Teleport complete"),
+      );
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  test("upload error: platformUploadToSignedUrl throws → error propagates", async () => {
+    setArgv("--from", "my-local", "--platform");
+
+    const localEntry = makeEntry("my-local", { cloud: "local" });
+
+    findAssistantByNameMock.mockImplementation((name: string) => {
+      if (name === "my-local") return localEntry;
+      return null;
+    });
+
+    // Upload succeeds at getting URL but fails during PUT
+    platformUploadToSignedUrlMock.mockRejectedValue(
+      new Error("Upload to signed URL failed: 500 Internal Server Error"),
+    );
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = createFetchMock() as unknown as typeof globalThis.fetch;
+
+    try {
+      await expect(teleport()).rejects.toThrow(
+        "Upload to signed URL failed: 500 Internal Server Error",
+      );
+      // Should NOT fall back to inline import
+      expect(platformImportBundleMock).not.toHaveBeenCalled();
+      expect(platformImportBundleFromGcsMock).not.toHaveBeenCalled();
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  test("413 from GCS import: error message includes 'too large'", async () => {
+    setArgv("--from", "my-local", "--platform");
+
+    const localEntry = makeEntry("my-local", { cloud: "local" });
+
+    findAssistantByNameMock.mockImplementation((name: string) => {
+      if (name === "my-local") return localEntry;
+      return null;
+    });
+
+    // GCS import returns 413
+    platformImportBundleFromGcsMock.mockRejectedValue(
+      new Error("Bundle too large to import"),
+    );
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = createFetchMock() as unknown as typeof globalThis.fetch;
+
+    try {
+      await expect(teleport()).rejects.toThrow("too large");
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Platform teleport org ID and reordered flow tests
+// ---------------------------------------------------------------------------
+
+describe("platform teleport org ID and reordered flow", () => {
+  test("hatchAssistant is called without orgId (authHeaders fetches it internally)", async () => {
+    setArgv("--from", "my-local", "--platform");
+
+    const localEntry = makeEntry("my-local", { cloud: "local" });
+
+    findAssistantByNameMock.mockImplementation((name: string) => {
+      if (name === "my-local") return localEntry;
+      return null;
+    });
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = createFetchMock() as unknown as typeof globalThis.fetch;
+
+    try {
+      await teleport();
+
+      // hatchAssistant should be called with just the token (orgId is resolved internally by authHeaders)
+      expect(hatchAssistantMock).toHaveBeenCalledWith("platform-token");
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  test("upload to GCS happens before hatchAssistant for platform targets", async () => {
+    setArgv("--from", "my-local", "--platform");
+
+    const localEntry = makeEntry("my-local", { cloud: "local" });
+
+    findAssistantByNameMock.mockImplementation((name: string) => {
+      if (name === "my-local") return localEntry;
+      return null;
+    });
+
+    const callOrder: string[] = [];
+
+    platformRequestUploadUrlMock.mockImplementation(async () => {
+      callOrder.push("platformRequestUploadUrl");
+      return {
+        uploadUrl: "https://storage.googleapis.com/bucket/signed-upload-url",
+        bundleKey: "bundle-key-123",
+        expiresAt: new Date(Date.now() + 3600_000).toISOString(),
+      };
+    });
+
+    platformUploadToSignedUrlMock.mockImplementation(async () => {
+      callOrder.push("platformUploadToSignedUrl");
+    });
+
+    hatchAssistantMock.mockImplementation(async () => {
+      callOrder.push("hatchAssistant");
+      return { id: "platform-new-id", name: "platform-new", status: "active" };
+    });
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = createFetchMock() as unknown as typeof globalThis.fetch;
+
+    try {
+      await teleport();
+
+      // Verify ordering: upload steps come before hatch
+      const uploadUrlIdx = callOrder.indexOf("platformRequestUploadUrl");
+      const uploadIdx = callOrder.indexOf("platformUploadToSignedUrl");
+      const hatchIdx = callOrder.indexOf("hatchAssistant");
+
+      expect(uploadUrlIdx).toBeGreaterThanOrEqual(0);
+      expect(uploadIdx).toBeGreaterThanOrEqual(0);
+      expect(hatchIdx).toBeGreaterThanOrEqual(0);
+      expect(uploadUrlIdx).toBeLessThan(hatchIdx);
+      expect(uploadIdx).toBeLessThan(hatchIdx);
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  test("signed-URL fallback: when platformRequestUploadUrl throws 'not available', falls back to inline upload via importToAssistant", async () => {
+    setArgv("--from", "my-local", "--platform");
+
+    const localEntry = makeEntry("my-local", { cloud: "local" });
+
+    findAssistantByNameMock.mockImplementation((name: string) => {
+      if (name === "my-local") return localEntry;
+      return null;
+    });
+
+    // Simulate 503 — signed uploads not available
+    platformRequestUploadUrlMock.mockRejectedValue(
+      new Error("Signed uploads are not available on this platform instance"),
+    );
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = createFetchMock() as unknown as typeof globalThis.fetch;
+
+    try {
+      await teleport();
+
+      // Upload URL was attempted but failed
+      expect(platformRequestUploadUrlMock).toHaveBeenCalled();
+      // No signed URL upload should have happened
+      expect(platformUploadToSignedUrlMock).not.toHaveBeenCalled();
+      // Should NOT use GCS-based import
+      expect(platformImportBundleFromGcsMock).not.toHaveBeenCalled();
+      // Should fall back to inline import
+      expect(platformImportBundleMock).toHaveBeenCalled();
+      // Hatch should still succeed
+      expect(hatchAssistantMock).toHaveBeenCalled();
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining("Teleport complete"),
+      );
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  test("bundleKey from pre-upload is forwarded to platformImportBundleFromGcs", async () => {
+    setArgv("--from", "my-local", "--platform");
+
+    const localEntry = makeEntry("my-local", { cloud: "local" });
+
+    findAssistantByNameMock.mockImplementation((name: string) => {
+      if (name === "my-local") return localEntry;
+      return null;
+    });
+
+    // Return a specific bundle key from the pre-upload step
+    platformRequestUploadUrlMock.mockResolvedValue({
+      uploadUrl: "https://storage.googleapis.com/bucket/signed-upload-url",
+      bundleKey: "pre-uploaded-key-789",
+      expiresAt: new Date(Date.now() + 3600_000).toISOString(),
+    });
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = createFetchMock() as unknown as typeof globalThis.fetch;
+
+    try {
+      await teleport();
+
+      // The bundle key from the pre-upload step should be forwarded to GCS import
+      expect(platformImportBundleFromGcsMock).toHaveBeenCalledWith(
+        "pre-uploaded-key-789",
+        "platform-token",
+        expect.any(String),
+      );
+      // Inline import should NOT be used since signed upload succeeded
+      expect(platformImportBundleMock).not.toHaveBeenCalled();
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});

package/src/__tests__/version-compat.test.ts

@@ -0,0 +1,206 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  parseVersion,
+  compareVersions,
+  isVersionCompatible,
+} from "../lib/version-compat.js";
+
+describe("parseVersion", () => {
+  test("parses basic semver", () => {
+    expect(parseVersion("1.2.3")).toEqual({
+      major: 1,
+      minor: 2,
+      patch: 3,
+      pre: null,
+    });
+  });
+
+  test("strips v prefix", () => {
+    expect(parseVersion("v1.2.3")).toEqual({
+      major: 1,
+      minor: 2,
+      patch: 3,
+      pre: null,
+    });
+  });
+
+  test("strips V prefix", () => {
+    expect(parseVersion("V1.2.3")).toEqual({
+      major: 1,
+      minor: 2,
+      patch: 3,
+      pre: null,
+    });
+  });
+
+  test("defaults missing patch to 0", () => {
+    expect(parseVersion("1.2")).toEqual({
+      major: 1,
+      minor: 2,
+      patch: 0,
+      pre: null,
+    });
+  });
+
+  test("captures pre-release suffix", () => {
+    expect(parseVersion("0.6.0-staging.5")).toEqual({
+      major: 0,
+      minor: 6,
+      patch: 0,
+      pre: "staging.5",
+    });
+  });
+
+  test("captures pre-release with v prefix", () => {
+    expect(parseVersion("v0.6.0-staging.1")).toEqual({
+      major: 0,
+      minor: 6,
+      patch: 0,
+      pre: "staging.1",
+    });
+  });
+
+  test("captures hyphenated pre-release suffix", () => {
+    expect(parseVersion("1.0.0-pre-release-1")).toEqual({
+      major: 1,
+      minor: 0,
+      patch: 0,
+      pre: "pre-release-1",
+    });
+  });
+
+  test("returns null for single segment", () => {
+    expect(parseVersion("1")).toBeNull();
+  });
+
+  test("returns null for non-numeric segments", () => {
+    expect(parseVersion("abc.def")).toBeNull();
+  });
+
+  test("returns null for empty string", () => {
+    expect(parseVersion("")).toBeNull();
+  });
+});
+
+describe("compareVersions", () => {
+  // ── Basic numeric comparison ──────────────────────────────────────
+  test("equal versions return 0", () => {
+    expect(compareVersions("1.2.3", "1.2.3")).toBe(0);
+  });
+
+  test("higher major returns positive", () => {
+    expect(compareVersions("2.0.0", "1.0.0")).toBeGreaterThan(0);
+  });
+
+  test("lower major returns negative", () => {
+    expect(compareVersions("1.0.0", "2.0.0")).toBeLessThan(0);
+  });
+
+  test("higher minor returns positive", () => {
+    expect(compareVersions("1.3.0", "1.2.0")).toBeGreaterThan(0);
+  });
+
+  test("higher patch returns positive", () => {
+    expect(compareVersions("1.2.4", "1.2.3")).toBeGreaterThan(0);
+  });
+
+  // ── v prefix handling ─────────────────────────────────────────────
+  test("strips v prefix for comparison", () => {
+    expect(compareVersions("v1.2.3", "1.2.3")).toBe(0);
+  });
+
+  // ── Pre-release vs release ────────────────────────────────────────
+  test("pre-release sorts lower than release", () => {
+    expect(compareVersions("0.6.0-staging.1", "0.6.0")).toBeLessThan(0);
+  });
+
+  test("release sorts higher than pre-release", () => {
+    expect(compareVersions("0.6.0", "0.6.0-staging.1")).toBeGreaterThan(0);
+  });
+
+  // ── Pre-release numeric comparison ────────────────────────────────
+  test("staging.1 < staging.2", () => {
+    expect(compareVersions("0.6.0-staging.1", "0.6.0-staging.2")).toBeLessThan(
+      0,
+    );
+  });
+
+  test("staging.10 > staging.2 (numeric, not lexical)", () => {
+    expect(
+      compareVersions("0.6.0-staging.10", "0.6.0-staging.2"),
+    ).toBeGreaterThan(0);
+  });
+
+  // ── Pre-release lexical comparison ────────────────────────────────
+  test("alpha < beta (lexical)", () => {
+    expect(compareVersions("1.0.0-alpha", "1.0.0-beta")).toBeLessThan(0);
+  });
+
+  // ── Mixed numeric vs non-numeric per §11.4.4 ─────────────────────
+  test("numeric identifier sorts lower than non-numeric", () => {
+    expect(compareVersions("1.0.0-1", "1.0.0-alpha")).toBeLessThan(0);
+  });
+
+  // ── Fewer pre-release identifiers sorts earlier ───────────────────
+  test("fewer pre-release identifiers sorts earlier", () => {
+    expect(compareVersions("1.0.0-alpha", "1.0.0-alpha.1")).toBeLessThan(0);
+  });
+
+  // ── Returns null for unparseable input ────────────────────────────
+  test("returns null if first version is unparseable", () => {
+    expect(compareVersions("bad", "1.0.0")).toBeNull();
+  });
+
+  test("returns null if second version is unparseable", () => {
+    expect(compareVersions("1.0.0", "bad")).toBeNull();
+  });
+
+  // ── Different major.minor.patch trumps pre-release ────────────────
+  test("higher patch wins regardless of pre-release", () => {
+    expect(compareVersions("0.6.1", "0.6.0-staging.99")).toBeGreaterThan(0);
+  });
+
+  // ── Sort integration ──────────────────────────────────────────────
+  test("Array.sort produces correct semver order", () => {
+    const versions = [
+      "0.6.0",
+      "0.6.0-staging.2",
+      "0.5.9",
+      "0.6.0-staging.10",
+      "v0.6.0-staging.1",
+      "0.6.1",
+    ];
+    const sorted = [...versions].sort((a, b) => compareVersions(a, b) ?? 0);
+    expect(sorted).toEqual([
+      "0.5.9",
+      "v0.6.0-staging.1",
+      "0.6.0-staging.2",
+      "0.6.0-staging.10",
+      "0.6.0",
+      "0.6.1",
+    ]);
+  });
+});
+
+describe("isVersionCompatible", () => {
+  test("same major.minor are compatible", () => {
+    expect(isVersionCompatible("1.2.3", "1.2.5")).toBe(true);
+  });
+
+  test("different minor are incompatible", () => {
+    expect(isVersionCompatible("1.2.3", "1.3.0")).toBe(false);
+  });
+
+  test("different major are incompatible", () => {
+    expect(isVersionCompatible("1.2.3", "2.2.3")).toBe(false);
+  });
+
+  test("pre-release on same major.minor is compatible", () => {
+    expect(isVersionCompatible("0.6.0-staging.5", "0.6.0")).toBe(true);
+  });
+
+  test("returns false for unparseable input", () => {
+    expect(isVersionCompatible("bad", "1.0.0")).toBe(false);
+  });
+});