@vellumai/assistant 0.7.1 → 0.7.3

package/src/runtime/migrations/__tests__/vbundle-import-version-compat.test.ts

@@ -0,0 +1,189 @@
+/**
+ * Buffer importer runtime-version compat gate.
+ *
+ * Wires `commitImport` to `policy.evaluateRuntimeCompatibility` BEFORE any
+ * state mutation. The platform-side gate is the primary check; this catches
+ * legacy bundles whose ExportJob row predates PR #5470 (compat columns NULL
+ * → platform gate skipped) and any caller that bypasses the platform-issued
+ * signed URL flow.
+ *
+ * Invariants pinned here:
+ *   - A compatible bundle imports normally.
+ *   - An incompatible bundle (min_runtime_version above APP_VERSION) returns
+ *     `{ ok: false, reason: "version_incompatible", bundle_compat,
+ *     runtime_version }` with NO disk mutation.
+ *   - The legacy sentinel "0.0.0-legacy" passes the gate unconditionally.
+ *   - Pre-existing workspace files are byte-identical and no `*.backup-*`
+ *     files are created when the gate rejects.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join, relative } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { APP_VERSION } from "../../../version.js";
+import { buildVBundle } from "../vbundle-builder.js";
+import { DefaultPathResolver } from "../vbundle-import-analyzer.js";
+import { commitImport } from "../vbundle-importer.js";
+import { defaultV1Options } from "./v1-test-helpers.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function freshWorkspace(): string {
+  const parent = realpathSync(
+    mkdtempSync(join(tmpdir(), "vbundle-import-version-compat-")),
+  );
+  return join(parent, "workspace");
+}
+
+function cleanupWorkspaceParent(workspaceDir: string): void {
+  try {
+    rmSync(join(workspaceDir, ".."), { recursive: true, force: true });
+  } catch {
+    // best-effort
+  }
+}
+
+/** Recursively yields every regular file under `root` as a relative path. */
+function* walkFiles(root: string): Generator<string> {
+  if (!existsSync(root)) return;
+  const stack: string[] = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop()!;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const abs = join(dir, entry.name);
+      if (entry.isDirectory()) stack.push(abs);
+      else if (entry.isFile()) yield relative(root, abs);
+    }
+  }
+}
+
+function buildBundleWithMinRuntimeVersion(
+  minRuntimeVersion: string,
+): Uint8Array {
+  const dbBytes = new TextEncoder().encode("db-payload");
+  const configJson = JSON.stringify({ version: 1 });
+  const { archive } = buildVBundle({
+    files: [
+      { path: "workspace/data/db/assistant.db", data: dbBytes },
+      {
+        path: "workspace/config.json",
+        data: new TextEncoder().encode(configJson),
+      },
+    ],
+    ...defaultV1Options(),
+    compatibility: {
+      min_runtime_version: minRuntimeVersion,
+      max_runtime_version: null,
+    },
+  });
+  return archive;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("commitImport runtime-version compat gate", () => {
+  let workspaceDir: string;
+
+  beforeEach(() => {
+    workspaceDir = freshWorkspace();
+    mkdirSync(workspaceDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    cleanupWorkspaceParent(workspaceDir);
+  });
+
+  test("compatible bundle imports normally", () => {
+    const archive = buildBundleWithMinRuntimeVersion("0.0.1");
+
+    const result = commitImport({
+      archiveData: archive,
+      pathResolver: new DefaultPathResolver(workspaceDir),
+      workspaceDir,
+    });
+
+    expect(result.ok).toBe(true);
+    expect(existsSync(join(workspaceDir, "data/db/assistant.db"))).toBe(true);
+    expect(existsSync(join(workspaceDir, "config.json"))).toBe(true);
+  });
+
+  test("incompatible bundle (above APP_VERSION) returns version_incompatible without writing", () => {
+    const archive = buildBundleWithMinRuntimeVersion("99.0.0");
+
+    const result = commitImport({
+      archiveData: archive,
+      pathResolver: new DefaultPathResolver(workspaceDir),
+      workspaceDir,
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok && result.reason === "version_incompatible") {
+      expect(result.bundle_compat.min_runtime_version).toBe("99.0.0");
+      expect(result.bundle_compat.max_runtime_version).toBeNull();
+      expect(result.runtime_version).toBe(APP_VERSION);
+    } else {
+      throw new Error(
+        `expected version_incompatible, got ${JSON.stringify(result)}`,
+      );
+    }
+
+    // Fresh workspace stays empty — no bundle files, no backups.
+    expect([...walkFiles(workspaceDir)]).toEqual([]);
+  });
+
+  test("legacy sentinel passes through", () => {
+    const archive = buildBundleWithMinRuntimeVersion("0.0.0-legacy");
+
+    const result = commitImport({
+      archiveData: archive,
+      pathResolver: new DefaultPathResolver(workspaceDir),
+      workspaceDir,
+    });
+
+    expect(result.ok).toBe(true);
+    expect(existsSync(join(workspaceDir, "data/db/assistant.db"))).toBe(true);
+    expect(existsSync(join(workspaceDir, "config.json"))).toBe(true);
+  });
+
+  test("pre-existing workspace files stay untouched on incompatibility", () => {
+    const sentinelPath = join(workspaceDir, "sentinel.txt");
+    const sentinelContent = "keep me";
+    writeFileSync(sentinelPath, sentinelContent);
+
+    const archive = buildBundleWithMinRuntimeVersion("99.0.0");
+
+    const result = commitImport({
+      archiveData: archive,
+      pathResolver: new DefaultPathResolver(workspaceDir),
+      workspaceDir,
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.reason).toBe("version_incompatible");
+
+    expect(readFileSync(sentinelPath, "utf-8")).toBe(sentinelContent);
+    // Only the seeded sentinel remains — no bundle files, no `*.backup-*`.
+    expect([...walkFiles(workspaceDir)]).toEqual(["sentinel.txt"]);
+  });
+});

package/src/runtime/migrations/__tests__/vbundle-streaming-importer.test.ts

@@ -36,10 +36,16 @@ import { Readable } from "node:stream";
 import { gunzipSync, gzipSync } from "node:zlib";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
+import { APP_VERSION } from "../../../version.js";
 import { buildVBundle } from "../vbundle-builder.js";
 import { DefaultPathResolver } from "../vbundle-import-analyzer.js";
+import { LEGACY_RUNTIME_VERSION_SENTINEL } from "../vbundle-import-policy.js";
 import { commitImport } from "../vbundle-importer.js";
-import { streamCommitImport } from "../vbundle-streaming-importer.js";
+import {
+  IMPORT_BACKUP_PREFIX,
+  IMPORT_TEMP_PREFIX,
+  streamCommitImport,
+} from "../vbundle-streaming-importer.js";
 import { canonicalizeJson } from "../vbundle-validator.js";
 import { defaultV1Options } from "./v1-test-helpers.js";
 
@@ -594,6 +600,152 @@ describe("streamCommitImport — failure modes", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Runtime-version compat gate — the streaming importer must refuse to
+// populate the temp tree when the bundle's compat range excludes APP_VERSION.
+// ---------------------------------------------------------------------------
+
+describe("streamCommitImport — runtime-version compat gate", () => {
+  let workspaceDir: string;
+  beforeEach(() => {
+    workspaceDir = freshWorkspace();
+  });
+  afterEach(() => {
+    const parent = join(workspaceDir, "..");
+    try {
+      rmSync(parent, { recursive: true, force: true });
+    } catch {
+      // best-effort
+    }
+  });
+
+  /**
+   * The streaming importer creates scratch dirs `${workspaceDir}/.import-<uuid>`
+   * and `${workspaceDir}/.pre-import-<ts>-<uuid>` INSIDE workspaceDir (so every
+   * rename during the content-level swap stays on the same filesystem). Scan
+   * for orphan entries with those prefixes inside workspaceDir using the
+   * importer's own constants so this assertion stays in sync with the
+   * importer's actual layout.
+   */
+  function assertNoLeftoverTempDirs(): void {
+    if (!existsSync(workspaceDir)) return;
+    const entries = readdirSync(workspaceDir);
+    const leftover = entries.filter(
+      (name) =>
+        name.startsWith(IMPORT_TEMP_PREFIX) ||
+        name.startsWith(IMPORT_BACKUP_PREFIX),
+    );
+    expect(leftover).toEqual([]);
+  }
+
+  test("incompatible bundle returns version_incompatible without writing the temp tree", async () => {
+    const { archive } = buildVBundle({
+      files: [
+        { path: "data/db/assistant.db", data: new Uint8Array() },
+        {
+          path: "workspace/a.txt",
+          data: new TextEncoder().encode("never-written"),
+        },
+      ],
+      ...defaultV1Options(),
+      compatibility: {
+        min_runtime_version: "99.0.0",
+        max_runtime_version: null,
+      },
+    });
+
+    // Pre-condition: workspace dir does NOT exist on a fresh filesystem.
+    // The plan invariant requires that the streaming importer gate on
+    // runtime-version compat BEFORE any state mutation, so an
+    // incompatible bundle must leave the filesystem untouched.
+    expect(existsSync(workspaceDir)).toBe(false);
+
+    const result = await streamCommitImport({
+      source: readableFrom(archive),
+      pathResolver: new DefaultPathResolver(workspaceDir),
+      workspaceDir,
+    });
+
+    if (result.ok || result.reason !== "version_incompatible") {
+      throw new Error(
+        `expected version_incompatible, got ${JSON.stringify(result)}`,
+      );
+    }
+    expect(result.bundle_compat.min_runtime_version).toBe("99.0.0");
+    expect(result.bundle_compat.max_runtime_version).toBeNull();
+    expect(result.runtime_version).toBe(APP_VERSION);
+
+    // Post-condition: workspace dir STILL does not exist. The version
+    // gate now runs before the temp-staging mkdir, so rejecting an
+    // incompatible bundle leaves zero filesystem trace.
+    expect(existsSync(workspaceDir)).toBe(false);
+    assertNoLeftoverTempDirs();
+  });
+
+  test("legacy sentinel passes through the streaming path", async () => {
+    const fileA = new TextEncoder().encode("legacy-import\n");
+    const { archive } = buildVBundle({
+      files: [
+        { path: "data/db/assistant.db", data: new Uint8Array() },
+        { path: "workspace/a.txt", data: fileA },
+      ],
+      ...defaultV1Options(),
+      compatibility: {
+        min_runtime_version: LEGACY_RUNTIME_VERSION_SENTINEL,
+        max_runtime_version: null,
+      },
+    });
+
+    const result = await streamCommitImport({
+      source: readableFrom(archive),
+      pathResolver: new DefaultPathResolver(workspaceDir),
+      workspaceDir,
+    });
+
+    expect(result.ok).toBe(true);
+    expect(readFileSync(join(workspaceDir, "a.txt"))).toEqual(
+      Buffer.from(fileA),
+    );
+    assertNoLeftoverTempDirs();
+  });
+
+  test("pre-existing workspace files stay untouched on incompatibility", async () => {
+    mkdirSync(workspaceDir, { recursive: true });
+    const seedBytes = new TextEncoder().encode("preserve-me\n");
+    writeFileSync(join(workspaceDir, "seed.txt"), seedBytes);
+
+    const { archive } = buildVBundle({
+      files: [
+        { path: "data/db/assistant.db", data: new Uint8Array() },
+        {
+          path: "workspace/a.txt",
+          data: new TextEncoder().encode("never-written"),
+        },
+      ],
+      ...defaultV1Options(),
+      compatibility: {
+        min_runtime_version: "99.0.0",
+        max_runtime_version: null,
+      },
+    });
+
+    const result = await streamCommitImport({
+      source: readableFrom(archive),
+      pathResolver: new DefaultPathResolver(workspaceDir),
+      workspaceDir,
+    });
+
+    expect(result.ok).toBe(false);
+    if (result.ok) throw new Error("unreachable");
+    expect(result.reason).toBe("version_incompatible");
+
+    expect(readFileSync(join(workspaceDir, "seed.txt"))).toEqual(
+      Buffer.from(seedBytes),
+    );
+    assertNoLeftoverTempDirs();
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Memory ceiling — the point of the streaming path.
 // ---------------------------------------------------------------------------