@mycadet/assistant 0.12.10 → 0.13.0

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

@@ -1,349 +0,0 @@
-/**
- * Unit tests for the pure policy module shared by both vbundle importers.
- *
- * No `node:fs`, no temp dirs — every test exercises a constant or a
- * predicate over strings.
- */
-
-import { describe, expect, test } from "bun:test";
-
-import {
-  compareSemver,
-  CONFIG_ARCHIVE_PATHS,
-  CREDENTIAL_METADATA_ARCHIVE_PATH,
-  evaluateRuntimeCompatibility,
-  isConfigArchivePath,
-  isCredentialMetadataArchivePath,
-  isLegacyPersonaArchivePath,
-  isLocalDevRuntimeVersion,
-  isWorkspaceNamespacedArchivePath,
-  LEGACY_USER_MD_ARCHIVE_PATH,
-  partitionWorkspacePreserveSkipDirs,
-  WORKSPACE_PRESERVE_PATHS,
-} from "../vbundle-import-policy.js";
-
-describe("LEGACY_USER_MD_ARCHIVE_PATH", () => {
-  test("equals the legacy guardian persona archive path", () => {
-    expect(LEGACY_USER_MD_ARCHIVE_PATH).toBe("prompts/USER.md");
-  });
-});
-
-describe("CONFIG_ARCHIVE_PATHS", () => {
-  test("contains exactly the two known config archive paths", () => {
-    expect(CONFIG_ARCHIVE_PATHS.size).toBe(2);
-    expect(CONFIG_ARCHIVE_PATHS.has("workspace/config.json")).toBe(true);
-    expect(CONFIG_ARCHIVE_PATHS.has("config/settings.json")).toBe(true);
-  });
-});
-
-describe("CREDENTIAL_METADATA_ARCHIVE_PATH", () => {
-  test("equals the workspace-namespaced credential metadata path", () => {
-    expect(CREDENTIAL_METADATA_ARCHIVE_PATH).toBe(
-      "workspace/data/credentials/metadata.json",
-    );
-  });
-});
-
-describe("WORKSPACE_PRESERVE_PATHS", () => {
-  test("matches the literal 4-element ordered list", () => {
-    expect(WORKSPACE_PRESERVE_PATHS).toEqual([
-      "embedding-models",
-      "deprecated",
-      "data/db",
-      "data/qdrant",
-    ]);
-  });
-});
-
-describe("isWorkspaceNamespacedArchivePath", () => {
-  test("true for paths under workspace/", () => {
-    expect(isWorkspaceNamespacedArchivePath("workspace/foo")).toBe(true);
-    expect(isWorkspaceNamespacedArchivePath("workspace/data/db/x")).toBe(true);
-  });
-
-  test("false for non-workspace paths", () => {
-    expect(isWorkspaceNamespacedArchivePath("prompts/USER.md")).toBe(false);
-    expect(isWorkspaceNamespacedArchivePath("data/db/assistant.db")).toBe(
-      false,
-    );
-    expect(isWorkspaceNamespacedArchivePath("")).toBe(false);
-    expect(isWorkspaceNamespacedArchivePath("workspace")).toBe(false);
-  });
-});
-
-describe("isLegacyPersonaArchivePath", () => {
-  test("true only for the exact legacy path", () => {
-    expect(isLegacyPersonaArchivePath("prompts/USER.md")).toBe(true);
-  });
-
-  test("false for near-misses and unrelated paths", () => {
-    expect(isLegacyPersonaArchivePath("prompts/USER")).toBe(false);
-    expect(isLegacyPersonaArchivePath("workspace/prompts/USER.md")).toBe(false);
-    expect(isLegacyPersonaArchivePath("")).toBe(false);
-  });
-});
-
-describe("isConfigArchivePath", () => {
-  test("true for both members of CONFIG_ARCHIVE_PATHS", () => {
-    expect(isConfigArchivePath("workspace/config.json")).toBe(true);
-    expect(isConfigArchivePath("config/settings.json")).toBe(true);
-  });
-
-  test("false for non-members", () => {
-    expect(isConfigArchivePath("workspace/foo.json")).toBe(false);
-    expect(isConfigArchivePath("config/settings")).toBe(false);
-    expect(isConfigArchivePath("")).toBe(false);
-  });
-});
-
-describe("isCredentialMetadataArchivePath", () => {
-  test("true for the exact constant", () => {
-    expect(
-      isCredentialMetadataArchivePath(
-        "workspace/data/credentials/metadata.json",
-      ),
-    ).toBe(true);
-  });
-
-  test("false for the legacy non-prefixed form and empty string", () => {
-    expect(
-      isCredentialMetadataArchivePath("data/credentials/metadata.json"),
-    ).toBe(false);
-    expect(isCredentialMetadataArchivePath("")).toBe(false);
-  });
-});
-
-describe("partitionWorkspacePreserveSkipDirs", () => {
-  test("splits preserve-paths into top-level vs data-subdir skip sets", () => {
-    const { topLevelSkipDirs, dataSubdirSkipDirs } =
-      partitionWorkspacePreserveSkipDirs();
-
-    expect(topLevelSkipDirs.size).toBe(2);
-    expect(topLevelSkipDirs.has("embedding-models")).toBe(true);
-    expect(topLevelSkipDirs.has("deprecated")).toBe(true);
-
-    expect(dataSubdirSkipDirs.size).toBe(2);
-    expect(dataSubdirSkipDirs.has("db")).toBe(true);
-    expect(dataSubdirSkipDirs.has("qdrant")).toBe(true);
-  });
-});
-
-describe("compareSemver", () => {
-  test("0.10.0 > 0.9.0 (numeric, not lexical)", () => {
-    expect(compareSemver("0.10.0", "0.9.0")).toBe(1);
-  });
-
-  test("equal triples return 0", () => {
-    expect(compareSemver("0.7.1", "0.7.1")).toBe(0);
-  });
-
-  test("smaller patch returns -1", () => {
-    expect(compareSemver("0.7.0", "0.7.1")).toBe(-1);
-  });
-
-  test("prerelease tag is stripped (treated as base release)", () => {
-    expect(compareSemver("0.7.1-staging.1", "0.7.1")).toBe(0);
-  });
-
-  test("non-version string returns null", () => {
-    expect(compareSemver("not-a-version", "0.7.1")).toBe(null);
-  });
-
-  test("two-part version returns null", () => {
-    expect(compareSemver("1.2", "0.7.1")).toBe(null);
-  });
-
-  // Regression: Number.parseInt accepts numeric prefixes and ignores
-  // trailing junk ("0foo" → 0), which previously coerced malformed
-  // triples through the gate. parseSemverTriple now requires each
-  // component to match /^\d+$/ exactly.
-  test("trailing junk on a component returns null (left arg)", () => {
-    expect(compareSemver("0.8.0foo", "0.8.0")).toBe(null);
-  });
-
-  test("trailing junk on a component returns null (right arg)", () => {
-    expect(compareSemver("0.8.0", "0.7.1xyz")).toBe(null);
-  });
-
-  // Leading zeros are accepted: "01.02.03" parses to the same numeric
-  // triple as "1.2.3" since Number("01") === 1. We pin this behavior
-  // so a future tightening doesn't accidentally regress callers that
-  // pass zero-padded versions from upstream tooling.
-  test("leading zeros parse equal to un-padded triple", () => {
-    expect(compareSemver("01.02.03", "1.2.3")).toBe(0);
-  });
-
-  test("leading whitespace returns null", () => {
-    expect(compareSemver(" 0.8.0", "0.8.0")).toBe(null);
-  });
-
-  test("negative component returns null", () => {
-    expect(compareSemver("0.8.-1", "0.8.0")).toBe(null);
-  });
-});
-
-describe("evaluateRuntimeCompatibility", () => {
-  test("legacy sentinel passes regardless of runtime version", () => {
-    expect(
-      evaluateRuntimeCompatibility(
-        { min_runtime_version: "0.0.0-legacy", max_runtime_version: null },
-        "0.7.1",
-      ),
-    ).toEqual({ ok: true });
-  });
-
-  test("runtime above min with no max passes", () => {
-    expect(
-      evaluateRuntimeCompatibility(
-        { min_runtime_version: "0.7.0", max_runtime_version: null },
-        "0.7.1",
-      ),
-    ).toEqual({ ok: true });
-  });
-
-  test("runtime below min fails with full echo", () => {
-    const compat = {
-      min_runtime_version: "0.8.0",
-      max_runtime_version: null,
-    };
-    expect(evaluateRuntimeCompatibility(compat, "0.7.1")).toEqual({
-      ok: false,
-      reason: "version_incompatible",
-      bundle_compat: compat,
-      runtime_version: "0.7.1",
-    });
-  });
-
-  test("runtime above max fails", () => {
-    const compat = {
-      min_runtime_version: "0.7.0",
-      max_runtime_version: "0.7.5",
-    };
-    expect(evaluateRuntimeCompatibility(compat, "0.8.0")).toEqual({
-      ok: false,
-      reason: "version_incompatible",
-      bundle_compat: compat,
-      runtime_version: "0.8.0",
-    });
-  });
-
-  test("max is inclusive", () => {
-    expect(
-      evaluateRuntimeCompatibility(
-        { min_runtime_version: "0.7.0", max_runtime_version: "0.7.5" },
-        "0.7.5",
-      ),
-    ).toEqual({ ok: true });
-  });
-
-  test("unparsable min skips the gate (fail-open)", () => {
-    expect(
-      evaluateRuntimeCompatibility(
-        { min_runtime_version: "garbage", max_runtime_version: null },
-        "0.7.1",
-      ),
-    ).toEqual({ ok: true });
-  });
-
-  // Regression for Codex feedback: a malformed min like "0.8.0foo"
-  // previously coerced to [0, 8, 0] via Number.parseInt and incorrectly
-  // produced a version_incompatible decision against runtime "0.7.1".
-  // With strict per-component digit matching, the parse fails and the
-  // gate fails open.
-  test("malformed min with trailing junk fails open, does not block", () => {
-    expect(
-      evaluateRuntimeCompatibility(
-        { min_runtime_version: "0.8.0foo", max_runtime_version: null },
-        "0.7.1",
-      ),
-    ).toEqual({ ok: true });
-  });
-
-  // A `vel up` minikube assistant image is stamped
-  // `<pkg.version>-local.<ts>.<sha>` from the checkout's package.json,
-  // which only moves on release cuts, so the minimum bound cannot be
-  // decided from it; the explicit maximum ceiling still applies.
-  test("local dev runtime build skips the minimum bound", () => {
-    expect(
-      evaluateRuntimeCompatibility(
-        { min_runtime_version: "0.12.2-staging.4", max_runtime_version: null },
-        "0.12.1-local.20260916144827.2f409056e6",
-      ),
-    ).toEqual({ ok: true });
-  });
-
-  test("local dev runtime build within an explicit range passes", () => {
-    expect(
-      evaluateRuntimeCompatibility(
-        { min_runtime_version: "0.12.2", max_runtime_version: "0.12.5" },
-        "0.12.1-local.20260916144827.2f409056e6",
-      ),
-    ).toEqual({ ok: true });
-  });
-
-  test("local dev runtime build above max still fails", () => {
-    const compat = {
-      min_runtime_version: "0.7.0",
-      max_runtime_version: "0.7.5",
-    };
-    const runtime = "0.12.1-local.20260916144827.2f409056e6";
-    expect(evaluateRuntimeCompatibility(compat, runtime)).toEqual({
-      ok: false,
-      reason: "version_incompatible",
-      bundle_compat: compat,
-      runtime_version: runtime,
-    });
-  });
-
-  test("local dev runtime build with unparsable max fails open", () => {
-    expect(
-      evaluateRuntimeCompatibility(
-        { min_runtime_version: "0.7.0", max_runtime_version: "garbage" },
-        "0.12.1-local.20260916144827.2f409056e6",
-      ),
-    ).toEqual({ ok: true });
-  });
-
-  test("other prerelease builds are still gated", () => {
-    const compat = {
-      min_runtime_version: "0.12.2-staging.4",
-      max_runtime_version: null,
-    };
-    for (const runtime of [
-      "0.12.1-dev.202609151913.a151da3",
-      "0.12.1-staging.9",
-      "0.12.1",
-    ]) {
-      expect(evaluateRuntimeCompatibility(compat, runtime)).toEqual({
-        ok: false,
-        reason: "version_incompatible",
-        bundle_compat: compat,
-        runtime_version: runtime,
-      });
-    }
-  });
-});
-
-describe("isLocalDevRuntimeVersion", () => {
-  test("matches the local hatch / minikube version stamp", () => {
-    expect(
-      isLocalDevRuntimeVersion("0.12.1-local.20260916144827.2f409056e6"),
-    ).toBe(true);
-    expect(isLocalDevRuntimeVersion("0.0.0-local.1789584535000")).toBe(true);
-  });
-
-  test("rejects release, dev and staging builds and lookalikes", () => {
-    for (const version of [
-      "0.12.1",
-      "0.12.1-dev.202609151913.a151da3",
-      "0.12.2-staging.4",
-      "0.0.0-dev",
-      "0.0.0-legacy",
-      "0.12.1-localhost.1",
-      "local.0.12.1",
-      "",
-    ]) {
-      expect(isLocalDevRuntimeVersion(version)).toBe(false);
-    }
-  });
-});

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

@@ -1,196 +0,0 @@
-/**
- * Buffer importer runtime-version compat gate.
- *
- * Wires `commitImport` to `policy.evaluateRuntimeCompatibility` BEFORE any
- * state mutation. The cloud-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 cloud-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"]);
-  });
-});