@mycadet/assistant 0.12.10 → 0.13.0

package/src/runtime/migrations/__tests__/vbundle-builder-fd-leak.test.ts

@@ -1,126 +0,0 @@
-/**
- * Regression test for descriptor hygiene in the vbundle export path.
- *
- * `streamExportVBundle` opens every file in the workspace twice — once to hash
- * it (Pass 1) and once to stream it into the tar (Pass 2). This test pins the
- * invariant that those reads release their descriptors: the number of open
- * descriptors held by the process must not grow proportionally to the number
- * of files exported. Without that guarantee a workspace-sized export exhausts
- * the daemon's descriptor limit (EMFILE) and every subsequent subprocess spawn
- * fails.
- *
- * Descriptor counting uses `/proc/self/fd`, which only exists on Linux. The
- * assertion is skipped on platforms without it (e.g. macOS dev machines); CI
- * runs on Linux, so the regression stays covered there.
- */
-
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, test } from "bun:test";
-
-import { assertNotLiveDb } from "../../../__tests__/assert-not-live-db.js";
-import { streamExportVBundle } from "../vbundle-builder.js";
-import { defaultV1Options } from "./v1-test-helpers.js";
-
-const PROC_SELF_FD = "/proc/self/fd";
-const hasProcFd = existsSync(PROC_SELF_FD);
-
-/** Count the descriptors currently open by this process. */
-function openFdCount(): number {
-  return readdirSync(PROC_SELF_FD).length;
-}
-
-/**
- * Build a workspace with enough distinct files (across nested directories) that
- * a per-file descriptor leak would be obvious against the assertion bound.
- */
-function createPopulatedWorkspace(fileCount: number): {
-  dir: string;
-  cleanup: () => void;
-} {
-  const dir = join(
-    tmpdir(),
-    `vbundle-fd-leak-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-  );
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, "config.json"), JSON.stringify({ test: true }));
-  const dbDir = join(dir, "data", "db");
-  mkdirSync(dbDir, { recursive: true });
-  writeFileSync(join(dbDir, "assistant.db"), "fake-db-content");
-
-  // A spread of files under a few nested directories, each with non-trivial
-  // (multi-chunk) content so the read loop iterates more than once.
-  const filler = "x".repeat(200 * 1024);
-  for (let i = 0; i < fileCount; i++) {
-    const sub = join(dir, "data", "files", `dir-${i % 5}`);
-    mkdirSync(sub, { recursive: true });
-    writeFileSync(join(sub, `file-${i}.txt`), `${filler}\n${i}`);
-  }
-
-  return {
-    dir,
-    cleanup: () => {
-      assertNotLiveDb(dir);
-      rmSync(dir, { recursive: true, force: true });
-    },
-  };
-}
-
-describe("streamExportVBundle — descriptor lifecycle", () => {
-  test.skipIf(!hasProcFd)(
-    "does not leak a file descriptor per exported file",
-    async () => {
-      const fileCount = 60;
-      const workspace = createPopulatedWorkspace(fileCount);
-
-      // Warm-up export: first run can open and cache descriptors that legitimately
-      // persist (loggers, the daemon DB, etc.). Measuring the delta around a
-      // second export isolates per-file leakage from one-time setup.
-      let warmup: Awaited<ReturnType<typeof streamExportVBundle>> | undefined;
-      try {
-        warmup = await streamExportVBundle({
-          workspaceDir: workspace.dir,
-          ...defaultV1Options(),
-        });
-      } finally {
-        await warmup?.cleanup();
-      }
-
-      const before = openFdCount();
-
-      let result: Awaited<ReturnType<typeof streamExportVBundle>> | undefined;
-      try {
-        result = await streamExportVBundle({
-          workspaceDir: workspace.dir,
-          ...defaultV1Options(),
-        });
-        // Manifest covers every file we wrote — proves the walk actually read
-        // them (otherwise a no-op export would trivially leak nothing).
-        expect(result.manifest.contents.length).toBeGreaterThanOrEqual(
-          fileCount,
-        );
-      } finally {
-        await result?.cleanup();
-        workspace.cleanup();
-      }
-
-      const after = openFdCount();
-      const delta = after - before;
-
-      // Each export reads 2×fileCount files (hash pass + tar pass). A per-file
-      // leak would push the delta past `fileCount`. Allow a small constant for
-      // incidental descriptors (temp output file already cleaned up, jitter).
-      expect(delta).toBeLessThan(8);
-    },
-    // Two full exports of a multi-megabyte workspace (hash pass + tar pass each)
-    // do real disk I/O; the default 5s budget is tight under loaded CI runners.
-    30_000,
-  );
-});

package/src/runtime/migrations/__tests__/vbundle-builder-v1-shape.test.ts

@@ -1,253 +0,0 @@
-/**
- * Verifies that the buffered (`buildVBundle` / `buildExportVBundle`) and
- * streaming (`streamExportVBundle`) emit paths both produce manifests
- * conforming to the canonical v1 ten-field shape.
- *
- * Drift between the two emit paths is exactly how the prior schema
- * mismatch went unnoticed — these tests pin both paths to the same shape
- * and run a round-trip through `validateVBundle` so any future
- * canonicalization drift fails loudly.
- */
-
-import { createHash } from "node:crypto";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { gunzipSync } from "node:zlib";
-import { describe, expect, test } from "bun:test";
-
-import {
-  buildExportVBundle,
-  buildVBundle,
-  streamExportVBundle,
-} from "../vbundle-builder.js";
-import { canonicalizeJson, validateVBundle } from "../vbundle-validator.js";
-import { defaultV1Options } from "./v1-test-helpers.js";
-
-function sha256Hex(data: Uint8Array | string): string {
-  return createHash("sha256").update(data).digest("hex");
-}
-
-function createTestWorkspace(): { dir: string; cleanup: () => void } {
-  const dir = join(
-    tmpdir(),
-    `vbundle-v1-shape-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-  );
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, "config.json"), JSON.stringify({ test: true }));
-  const dbDir = join(dir, "data", "db");
-  mkdirSync(dbDir, { recursive: true });
-  writeFileSync(join(dbDir, "assistant.db"), "fake-db-content");
-  return {
-    dir,
-    cleanup: () => rmSync(dir, { recursive: true, force: true }),
-  };
-}
-
-const UUID_V4_RE =
-  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-const ISO_8601_RE =
-  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
-const SHA256_HEX_RE = /^[0-9a-f]{64}$/;
-
-describe("buildVBundle — v1 ten-field manifest shape", () => {
-  test("emits all ten required top-level fields with correct types", () => {
-    const { manifest } = buildVBundle({
-      files: [
-        {
-          path: "data/db/assistant.db",
-          data: new TextEncoder().encode("db-bytes"),
-        },
-      ],
-      ...defaultV1Options(),
-    });
-
-    expect(manifest.schema_version).toBe(1);
-    expect(typeof manifest.bundle_id).toBe("string");
-    expect(manifest.bundle_id).toMatch(UUID_V4_RE);
-    expect(manifest.created_at).toMatch(ISO_8601_RE);
-    expect(manifest.assistant.id).toBe("self");
-    expect(manifest.assistant.name).toBe("Test");
-    expect(manifest.assistant.runtime_version).toBe("0.0.0-test");
-    expect(manifest.origin.mode).toBe("self-hosted-local");
-    expect(manifest.compatibility.min_runtime_version).toBe("0.0.0-test");
-    expect(manifest.compatibility.max_runtime_version).toBeNull();
-    expect(Array.isArray(manifest.contents)).toBe(true);
-    expect(manifest.contents.length).toBeGreaterThan(0);
-    expect(manifest.checksum).toMatch(SHA256_HEX_RE);
-    expect(typeof manifest.secrets_redacted).toBe("boolean");
-    expect(typeof manifest.export_options.include_logs).toBe("boolean");
-  });
-
-  test("contents always declares data/db/assistant.db when the input includes it", () => {
-    const { manifest } = buildVBundle({
-      files: [
-        {
-          path: "data/db/assistant.db",
-          data: new TextEncoder().encode("db-bytes"),
-        },
-        {
-          path: "config/settings.json",
-          data: new TextEncoder().encode("{}"),
-        },
-      ],
-      ...defaultV1Options(),
-    });
-
-    const dbEntry = manifest.contents.find(
-      (f) => f.path === "data/db/assistant.db",
-    );
-    expect(dbEntry).toBeDefined();
-    expect(dbEntry!.size_bytes).toBe(
-      new TextEncoder().encode("db-bytes").length,
-    );
-  });
-
-  test("checksum is the sha256 of the canonicalized manifest with checksum=''", () => {
-    const { manifest } = buildVBundle({
-      files: [
-        {
-          path: "data/db/assistant.db",
-          data: new TextEncoder().encode("db-bytes"),
-        },
-      ],
-      ...defaultV1Options(),
-    });
-
-    const expected = sha256Hex(canonicalizeJson({ ...manifest, checksum: "" }));
-    expect(manifest.checksum).toBe(expected);
-  });
-
-  test("secrets_redacted reflects the input flag", () => {
-    const truthy = buildVBundle({
-      files: [
-        {
-          path: "data/db/assistant.db",
-          data: new TextEncoder().encode("db-bytes"),
-        },
-      ],
-      ...defaultV1Options(),
-      secretsRedacted: true,
-    });
-    expect(truthy.manifest.secrets_redacted).toBe(true);
-
-    const falsey = buildVBundle({
-      files: [
-        {
-          path: "data/db/assistant.db",
-          data: new TextEncoder().encode("db-bytes"),
-        },
-      ],
-      ...defaultV1Options(),
-      secretsRedacted: false,
-    });
-    expect(falsey.manifest.secrets_redacted).toBe(false);
-  });
-
-  test("bundle_id is a fresh UUID per export", () => {
-    const a = buildVBundle({
-      files: [
-        {
-          path: "data/db/assistant.db",
-          data: new TextEncoder().encode("db-bytes"),
-        },
-      ],
-      ...defaultV1Options(),
-    });
-    const b = buildVBundle({
-      files: [
-        {
-          path: "data/db/assistant.db",
-          data: new TextEncoder().encode("db-bytes"),
-        },
-      ],
-      ...defaultV1Options(),
-    });
-    expect(a.manifest.bundle_id).not.toBe(b.manifest.bundle_id);
-  });
-});
-
-describe("streamExportVBundle — v1 ten-field manifest shape", () => {
-  test("matches buildExportVBundle's manifest shape (modulo bundle_id and created_at)", async () => {
-    const workspace = createTestWorkspace();
-    let streamResult:
-      | Awaited<ReturnType<typeof streamExportVBundle>>
-      | undefined;
-    try {
-      const sync = buildExportVBundle({
-        workspaceDir: workspace.dir,
-        ...defaultV1Options(),
-      });
-      streamResult = await streamExportVBundle({
-        workspaceDir: workspace.dir,
-        ...defaultV1Options(),
-      });
-
-      expect(streamResult.manifest.schema_version).toBe(
-        sync.manifest.schema_version,
-      );
-      expect(streamResult.manifest.assistant).toEqual(sync.manifest.assistant);
-      expect(streamResult.manifest.origin).toEqual(sync.manifest.origin);
-      expect(streamResult.manifest.compatibility).toEqual(
-        sync.manifest.compatibility,
-      );
-      expect(streamResult.manifest.export_options).toEqual(
-        sync.manifest.export_options,
-      );
-      expect(streamResult.manifest.secrets_redacted).toBe(
-        sync.manifest.secrets_redacted,
-      );
-
-      // Same set of files (paths + sha + size).
-      const sortByPath = (a: { path: string }, b: { path: string }) =>
-        a.path.localeCompare(b.path);
-      expect(streamResult.manifest.contents.slice().sort(sortByPath)).toEqual(
-        sync.manifest.contents.slice().sort(sortByPath),
-      );
-    } finally {
-      await streamResult?.cleanup();
-      workspace.cleanup();
-    }
-  });
-});
-
-describe("buildExportVBundle round-trip", () => {
-  test("validateVBundle accepts the buffered emit", () => {
-    const workspace = createTestWorkspace();
-    try {
-      const result = buildExportVBundle({
-        workspaceDir: workspace.dir,
-        ...defaultV1Options(),
-      });
-      const validation = validateVBundle(result.archive);
-      expect(validation.is_valid).toBe(true);
-      expect(validation.errors).toHaveLength(0);
-      expect(validation.manifest?.checksum).toBe(result.manifest.checksum);
-    } finally {
-      workspace.cleanup();
-    }
-  });
-
-  test("validateVBundle accepts the streaming emit", async () => {
-    const workspace = createTestWorkspace();
-    let result: Awaited<ReturnType<typeof streamExportVBundle>> | undefined;
-    try {
-      result = await streamExportVBundle({
-        workspaceDir: workspace.dir,
-        ...defaultV1Options(),
-      });
-      const archive = new Uint8Array(
-        await Bun.file(result.tempPath).arrayBuffer(),
-      );
-      // Sanity: archive is valid gzip of a tar.
-      expect(gunzipSync(archive).length).toBeGreaterThan(0);
-      const validation = validateVBundle(archive);
-      expect(validation.is_valid).toBe(true);
-      expect(validation.errors).toHaveLength(0);
-      expect(validation.manifest?.checksum).toBe(result.manifest.checksum);
-    } finally {
-      await result?.cleanup();
-      workspace.cleanup();
-    }
-  });
-});

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

@@ -1,208 +0,0 @@
-/**
- * Tests for credential import from vbundle archives.
- *
- * Covers:
- * - extractCredentialsFromBundle() correctly extracts credential entries
- * - DefaultPathResolver skips credentials/ paths (not written to disk)
- * - Empty and missing credential entries are handled gracefully
- */
-
-import { describe, expect, test } from "bun:test";
-
-import { DefaultPathResolver } from "../vbundle-import-analyzer.js";
-import { extractCredentialsFromBundle } from "../vbundle-importer.js";
-import type { ManifestType, VBundleTarEntry } from "../vbundle-validator.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeTarEntry(data: string): VBundleTarEntry {
-  const encoded = new TextEncoder().encode(data);
-  return { name: "", data: encoded, size: encoded.length };
-}
-
-function makeManifest(paths: string[]): ManifestType {
-  return {
-    schema_version: 1,
-    bundle_id: "00000000-0000-4000-8000-000000000000",
-    created_at: new Date().toISOString(),
-    assistant: { id: "self", name: "Test", runtime_version: "0.0.0-test" },
-    origin: { mode: "self-hosted-local" },
-    compatibility: {
-      min_runtime_version: "0.0.0-test",
-      max_runtime_version: null,
-    },
-    contents: paths.map((path) => ({
-      path,
-      size_bytes: 0,
-      sha256: "test",
-    })),
-    checksum:
-      "0000000000000000000000000000000000000000000000000000000000000000",
-    secrets_redacted: false,
-    export_options: {
-      include_logs: false,
-      include_browser_state: false,
-      include_memory_vectors: false,
-    },
-  } as unknown as ManifestType;
-}
-
-// ---------------------------------------------------------------------------
-// extractCredentialsFromBundle
-// ---------------------------------------------------------------------------
-
-describe("extractCredentialsFromBundle", () => {
-  test("extracts credential entries from tar entries map", () => {
-    const entries = new Map<string, VBundleTarEntry>();
-    entries.set("credentials/openai-key", makeTarEntry("sk-test-123"));
-    entries.set("credentials/anthropic-key", makeTarEntry("sk-ant-456"));
-    entries.set("workspace/config.json", makeTarEntry('{"test": true}'));
-    entries.set("manifest.json", makeTarEntry("{}"));
-
-    const manifest = makeManifest([
-      "credentials/openai-key",
-      "credentials/anthropic-key",
-      "workspace/config.json",
-    ]);
-    const credentials = extractCredentialsFromBundle(entries, manifest);
-
-    expect(credentials).toHaveLength(2);
-    expect(credentials).toContainEqual({
-      account: "openai-key",
-      value: "sk-test-123",
-    });
-    expect(credentials).toContainEqual({
-      account: "anthropic-key",
-      value: "sk-ant-456",
-    });
-  });
-
-  test("returns empty array when no credential entries exist", () => {
-    const entries = new Map<string, VBundleTarEntry>();
-    entries.set("workspace/config.json", makeTarEntry('{"test": true}'));
-    entries.set("manifest.json", makeTarEntry("{}"));
-
-    const manifest = makeManifest(["workspace/config.json"]);
-    const credentials = extractCredentialsFromBundle(entries, manifest);
-
-    expect(credentials).toHaveLength(0);
-  });
-
-  test("returns empty array for empty entries map", () => {
-    const entries = new Map<string, VBundleTarEntry>();
-
-    const manifest = makeManifest([]);
-    const credentials = extractCredentialsFromBundle(entries, manifest);
-
-    expect(credentials).toHaveLength(0);
-  });
-
-  test("skips bare credentials/ path with no account name", () => {
-    const entries = new Map<string, VBundleTarEntry>();
-    entries.set("credentials/", makeTarEntry("some-value"));
-    entries.set("credentials/valid-key", makeTarEntry("valid-secret"));
-
-    const manifest = makeManifest(["credentials/", "credentials/valid-key"]);
-    const credentials = extractCredentialsFromBundle(entries, manifest);
-
-    expect(credentials).toHaveLength(1);
-    expect(credentials[0]).toEqual({
-      account: "valid-key",
-      value: "valid-secret",
-    });
-  });
-
-  test("ignores credential entries not declared in manifest", () => {
-    const entries = new Map<string, VBundleTarEntry>();
-    entries.set("credentials/declared-key", makeTarEntry("declared-secret"));
-    entries.set(
-      "credentials/undeclared-key",
-      makeTarEntry("undeclared-secret"),
-    );
-
-    const manifest = makeManifest(["credentials/declared-key"]);
-    const credentials = extractCredentialsFromBundle(entries, manifest);
-
-    expect(credentials).toHaveLength(1);
-    expect(credentials[0]).toEqual({
-      account: "declared-key",
-      value: "declared-secret",
-    });
-  });
-
-  test("handles credential values with special characters", () => {
-    const entries = new Map<string, VBundleTarEntry>();
-    entries.set(
-      "credentials/complex-key",
-      makeTarEntry("value with spaces & special=chars!"),
-    );
-
-    const manifest = makeManifest(["credentials/complex-key"]);
-    const credentials = extractCredentialsFromBundle(entries, manifest);
-
-    expect(credentials).toHaveLength(1);
-    expect(credentials[0]).toEqual({
-      account: "complex-key",
-      value: "value with spaces & special=chars!",
-    });
-  });
-
-  test("extracts cadet:-prefixed credentials (filtering happens in migration-routes)", () => {
-    const entries = new Map<string, VBundleTarEntry>();
-    entries.set("credentials/cadet:assistant_api_key", makeTarEntry("key-123"));
-    entries.set(
-      "credentials/cadet:platform_assistant_id",
-      makeTarEntry("asst-456"),
-    );
-    entries.set("credentials/openai-key", makeTarEntry("sk-user-789"));
-
-    const manifest = makeManifest([
-      "credentials/cadet:assistant_api_key",
-      "credentials/cadet:platform_assistant_id",
-      "credentials/openai-key",
-    ]);
-    const credentials = extractCredentialsFromBundle(entries, manifest);
-
-    // extractCredentialsFromBundle does NOT filter — it returns all credentials.
-    // Filtering of cadet:* platform credentials is done in migration-routes.ts.
-    expect(credentials).toHaveLength(3);
-    expect(credentials).toContainEqual({
-      account: "cadet:assistant_api_key",
-      value: "key-123",
-    });
-    expect(credentials).toContainEqual({
-      account: "cadet:platform_assistant_id",
-      value: "asst-456",
-    });
-    expect(credentials).toContainEqual({
-      account: "openai-key",
-      value: "sk-user-789",
-    });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// DefaultPathResolver — credential path skipping
-// ---------------------------------------------------------------------------
-
-describe("DefaultPathResolver skips credential paths", () => {
-  test("resolve() returns null for credentials/ paths", () => {
-    const resolver = new DefaultPathResolver("/tmp/workspace", "/tmp/hooks");
-
-    expect(resolver.resolve("credentials/openai-key")).toBeNull();
-    expect(resolver.resolve("credentials/anthropic-key")).toBeNull();
-    expect(resolver.resolve("credentials/")).toBeNull();
-  });
-
-  test("resolve() still resolves non-credential paths normally", () => {
-    const resolver = new DefaultPathResolver("/tmp/workspace", "/tmp/hooks");
-
-    // workspace/ paths should resolve
-    expect(resolver.resolve("workspace/config.json")).not.toBeNull();
-
-    // data/db should resolve
-    expect(resolver.resolve("data/db/assistant.db")).not.toBeNull();
-  });
-});