@mycadet/assistant 0.12.11 → 0.13.0

package/src/runtime/migrations/__tests__/vbundle-symlink-walker.test.ts

@@ -1,319 +0,0 @@
-/**
- * Tests for the symlink-aware directory walkers used by vbundle export.
- *
- * Two walkers exist (`walkDirectory` for the buffered path,
- * `walkDirectoryForMetadata` for the streaming path) and they must classify
- * symlinks identically: bundleable in-workspace targets become typeflag-2
- * entries, while broken / directory / outside-workspace / inside-skipDir
- * targets are dropped and reported. Each scenario below is exercised against
- * both walkers via describe.each so any drift between them fails loudly.
- *
- * One additional integration test drives `buildExportVBundle` end-to-end and
- * checks both that the dropped paths are summarized in a single aggregated
- * `log.warn` call and that a class-1 round-trip survives `validateVBundle`.
- */
-
-import {
-  mkdirSync,
-  mkdtempSync,
-  realpathSync,
-  rmSync,
-  symlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, mock, test } from "bun:test";
-
-const mockLogWarn = mock((_obj: unknown, _msg: string) => {});
-mock.module("../../../util/logger.js", () => ({
-  getLogger: () => ({
-    warn: mockLogWarn,
-    info: () => {},
-    error: () => {},
-    debug: () => {},
-    trace: () => {},
-  }),
-}));
-
-const { buildExportVBundle, walkDirectory, walkDirectoryForMetadata } =
-  await import("../vbundle-builder.js");
-const { validateVBundle } = await import("../vbundle-validator.js");
-const { defaultV1Options } = await import("./v1-test-helpers.js");
-
-// ---------------------------------------------------------------------------
-// Workspace fixtures
-// ---------------------------------------------------------------------------
-
-const cleanupQueue: string[] = [];
-
-function makeTempDir(prefix: string): string {
-  // Resolve to the canonical path so walker comparisons (which call
-  // realpathSync on the symlink target) line up with the workspace root on
-  // platforms where tmpdir() is itself a symlink (macOS: /var → /private/var).
-  const dir = realpathSync(mkdtempSync(join(tmpdir(), prefix)));
-  cleanupQueue.push(dir);
-  return dir;
-}
-
-afterEach(() => {
-  while (cleanupQueue.length > 0) {
-    const dir = cleanupQueue.pop();
-    if (dir) {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  }
-  mockLogWarn.mockClear();
-});
-
-// ---------------------------------------------------------------------------
-// Walker adapters — normalize both walker shapes to a common surface so the
-// parametrized tests below can assert the same fields against either one.
-// ---------------------------------------------------------------------------
-
-interface NormalizedSymlinkEntry {
-  archivePath: string;
-  linkTarget: string;
-}
-
-interface NormalizedWalkResult {
-  fileArchivePaths: string[];
-  symlinks: NormalizedSymlinkEntry[];
-  droppedSymlinks: string[];
-}
-
-interface WalkerAdapter {
-  name: string;
-  walk: (
-    dir: string,
-    prefix: string,
-    skipDirs: string[],
-  ) => NormalizedWalkResult;
-}
-
-const walkers: WalkerAdapter[] = [
-  {
-    name: "walkDirectory",
-    walk: (dir, prefix, skipDirs) => {
-      const result = walkDirectory(dir, prefix, {
-        includeBinary: true,
-        skipDirs,
-      });
-      return {
-        fileArchivePaths: result.files
-          .filter((f) => f.linkTarget === undefined)
-          .map((f) => f.path),
-        symlinks: result.files
-          .filter((f) => f.linkTarget !== undefined)
-          .map((f) => ({ archivePath: f.path, linkTarget: f.linkTarget! })),
-        droppedSymlinks: result.droppedSymlinks,
-      };
-    },
-  },
-  {
-    name: "walkDirectoryForMetadata",
-    walk: (dir, prefix, skipDirs) => {
-      const result = walkDirectoryForMetadata(dir, prefix, {
-        includeBinary: true,
-        skipDirs,
-      });
-      return {
-        fileArchivePaths: result.files.map((f) => f.archivePath),
-        symlinks: result.symlinks.map((s) => ({
-          archivePath: s.archivePath,
-          linkTarget: s.linkTarget,
-        })),
-        droppedSymlinks: result.droppedSymlinks,
-      };
-    },
-  },
-];
-
-// ---------------------------------------------------------------------------
-// Per-walker classification tests
-// ---------------------------------------------------------------------------
-
-describe.each(walkers)("$name — symlink classification", ({ walk }) => {
-  test("class 1: in-workspace symlink is emitted with relative linkTarget", () => {
-    const root = makeTempDir("vbundle-walker-class1-");
-    mkdirSync(join(root, "skills"), { recursive: true });
-    writeFileSync(join(root, "skills", "bar.md"), "bar contents");
-    symlinkSync("bar.md", join(root, "skills", "foo.md"));
-
-    const result = walk(root, "workspace", []);
-
-    expect(result.droppedSymlinks).toEqual([]);
-    expect(result.fileArchivePaths).toContain("workspace/skills/bar.md");
-    expect(result.symlinks).toEqual([
-      {
-        archivePath: "workspace/skills/foo.md",
-        linkTarget: "bar.md",
-      },
-    ]);
-  });
-
-  test("class 2: symlink targeting a path outside the workspace is dropped", () => {
-    const root = makeTempDir("vbundle-walker-class2-");
-    const outside = makeTempDir("vbundle-walker-outside-");
-    mkdirSync(join(root, "skills"), { recursive: true });
-    const outsideTarget = join(outside, "external.md");
-    writeFileSync(outsideTarget, "external contents");
-    symlinkSync(outsideTarget, join(root, "skills", "dev"));
-
-    const result = walk(root, "workspace", []);
-
-    expect(result.symlinks).toEqual([]);
-    expect(result.droppedSymlinks).toContain(join("skills", "dev"));
-  });
-
-  test("class 3: symlink targeting a skipDir is dropped", () => {
-    const root = makeTempDir("vbundle-walker-class3-");
-    mkdirSync(join(root, "embedding-models"), { recursive: true });
-    mkdirSync(join(root, "skills"), { recursive: true });
-    writeFileSync(join(root, "embedding-models", "x.bin"), "blob");
-    symlinkSync(
-      join(root, "embedding-models", "x.bin"),
-      join(root, "skills", "cache"),
-    );
-
-    const result = walk(root, "workspace", ["embedding-models"]);
-
-    expect(result.symlinks).toEqual([]);
-    expect(result.droppedSymlinks).toContain(join("skills", "cache"));
-    // The skipDir itself is not walked, so its files are not emitted either.
-    expect(result.fileArchivePaths).not.toContain(
-      "workspace/embedding-models/x.bin",
-    );
-  });
-
-  test("directory targets are out of scope and dropped", () => {
-    const root = makeTempDir("vbundle-walker-dirtarget-");
-    mkdirSync(join(root, "skills", "sub-dir"), { recursive: true });
-    writeFileSync(join(root, "skills", "sub-dir", "nested.md"), "nested");
-    symlinkSync(
-      join(root, "skills", "sub-dir"),
-      join(root, "skills", "dir-link"),
-    );
-
-    const result = walk(root, "workspace", []);
-
-    expect(result.symlinks).toEqual([]);
-    expect(result.droppedSymlinks).toContain(join("skills", "dir-link"));
-    // The real sub-dir is still walked through normally.
-    expect(result.fileArchivePaths).toContain(
-      "workspace/skills/sub-dir/nested.md",
-    );
-  });
-
-  test("broken symlinks are dropped without throwing", () => {
-    const root = makeTempDir("vbundle-walker-broken-");
-    mkdirSync(join(root, "skills"), { recursive: true });
-    symlinkSync(
-      join(root, "skills", "does-not-exist.md"),
-      join(root, "skills", "broken"),
-    );
-
-    const result = walk(root, "workspace", []);
-
-    expect(result.symlinks).toEqual([]);
-    expect(result.droppedSymlinks).toContain(join("skills", "broken"));
-  });
-
-  test("class 1: in-workspace symlink is emitted when walk root is a non-canonical path with symlinked prefix", () => {
-    // Intentionally NOT canonicalized — on macOS this stays as
-    // /var/folders/... while realpathSync canonicalizes to
-    // /private/var/folders/.... Without the realpathSync(walkRoot) fix in
-    // classifySymlink, the containment check misclassifies in-workspace
-    // symlinks as "outside workspace" and silently drops them.
-    const ws = mkdtempSync(join(tmpdir(), "vbundle-walker-noncanon-"));
-    cleanupQueue.push(ws);
-    mkdirSync(join(ws, "skills"), { recursive: true });
-    writeFileSync(join(ws, "skills", "bar.md"), "hello");
-    symlinkSync("bar.md", join(ws, "skills", "foo.md"));
-
-    const result = walk(ws, "workspace", []);
-
-    expect(result.droppedSymlinks).toEqual([]);
-    expect(result.symlinks).toEqual([
-      {
-        archivePath: "workspace/skills/foo.md",
-        linkTarget: "bar.md",
-      },
-    ]);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Aggregated warning + round-trip integration
-// ---------------------------------------------------------------------------
-
-describe("buildExportVBundle aggregated symlink warning", () => {
-  test("emits a single warn call covering every dropped symlink", () => {
-    const root = makeTempDir("vbundle-walker-agg-");
-    const outsideA = makeTempDir("vbundle-walker-agg-outA-");
-    const outsideB = makeTempDir("vbundle-walker-agg-outB-");
-    // Required workspace fixture so the walker has at least one regular file.
-    writeFileSync(join(root, "config.json"), JSON.stringify({ test: true }));
-    mkdirSync(join(root, "data", "db"), { recursive: true });
-    writeFileSync(join(root, "data", "db", "assistant.db"), "fake-db");
-
-    mkdirSync(join(root, "skills"), { recursive: true });
-    mkdirSync(join(root, "embedding-models"), { recursive: true });
-    writeFileSync(join(root, "embedding-models", "blob.bin"), "blob");
-
-    const externalA = join(outsideA, "ext.md");
-    const externalB = join(outsideB, "ext.md");
-    writeFileSync(externalA, "ext-a");
-    writeFileSync(externalB, "ext-b");
-
-    symlinkSync(externalA, join(root, "skills", "ext-a"));
-    symlinkSync(externalB, join(root, "skills", "ext-b"));
-    symlinkSync(
-      join(root, "embedding-models", "blob.bin"),
-      join(root, "skills", "cache"),
-    );
-
-    buildExportVBundle({
-      workspaceDir: root,
-      ...defaultV1Options(),
-    });
-
-    expect(mockLogWarn).toHaveBeenCalledTimes(1);
-    const [meta, msg] = mockLogWarn.mock.calls[0];
-    expect(meta).toMatchObject({ count: 3 });
-    expect((meta as { paths: string[] }).paths.sort()).toEqual(
-      [
-        join("skills", "cache"),
-        join("skills", "ext-a"),
-        join("skills", "ext-b"),
-      ].sort(),
-    );
-    expect(typeof msg).toBe("string");
-  });
-
-  test("class-1 symlink survives buildExportVBundle round-trip via validateVBundle", () => {
-    const root = makeTempDir("vbundle-walker-rt-");
-    writeFileSync(join(root, "config.json"), JSON.stringify({ test: true }));
-    mkdirSync(join(root, "data", "db"), { recursive: true });
-    writeFileSync(join(root, "data", "db", "assistant.db"), "fake-db");
-    mkdirSync(join(root, "skills"), { recursive: true });
-    writeFileSync(join(root, "skills", "bar.md"), "bar contents");
-    symlinkSync("bar.md", join(root, "skills", "foo.md"));
-
-    const result = buildExportVBundle({
-      workspaceDir: root,
-      ...defaultV1Options(),
-    });
-
-    const validation = validateVBundle(result.archive);
-    expect(validation.errors).toEqual([]);
-    expect(validation.is_valid).toBe(true);
-
-    const symlinkEntry = result.manifest.contents.find(
-      (f) => f.path === "workspace/skills/foo.md",
-    );
-    expect(symlinkEntry).toBeDefined();
-    expect(symlinkEntry?.link_target).toBe("bar.md");
-    expect(symlinkEntry?.size_bytes).toBe(0);
-  });
-});

package/src/runtime/migrations/__tests__/vbundle-tar-stream.test.ts

@@ -1,240 +0,0 @@
-/**
- * Tests for `parseVBundleStream` — the streaming tar reader for `.vbundle`
- * archives.
- *
- * Covered:
- * - Happy path: 3-file archive yields entries in order with correct names/sizes.
- * - Manifest-first invariant: first entry is `manifest.json`.
- * - Truncated gzip mid-stream: generator throws.
- * - Valid gzip but malformed tar payload: generator throws.
- * - Early termination (break in for-await loop): upstream source is destroyed.
- */
-
-import { Readable } from "node:stream";
-import { gzipSync } from "node:zlib";
-import { describe, expect, test } from "bun:test";
-
-import { buildVBundle } from "../vbundle-builder.js";
-import {
-  parseVBundleStream,
-  type StreamedTarEntry,
-} from "../vbundle-tar-stream.js";
-import { defaultV1Options } from "./v1-test-helpers.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-async function collectBody(entry: StreamedTarEntry): Promise<Uint8Array> {
-  const chunks: Buffer[] = [];
-  for await (const chunk of entry.body) {
-    chunks.push(chunk as Buffer);
-  }
-  return new Uint8Array(Buffer.concat(chunks));
-}
-
-function readableFromBuffer(buf: Uint8Array): Readable {
-  // `Readable.from(Uint8Array)` iterates byte-by-byte (each element becomes
-  // a chunk), which is not what we want here. Wrap in an array so the whole
-  // buffer arrives as a single chunk — closer to how the HTTP client will
-  // feed bytes in production.
-  return Readable.from([Buffer.from(buf)]);
-}
-
-/** Build a minimal vbundle archive with the given extra files (plus manifest). */
-function buildMinimalVBundle(
-  extraFiles: { path: string; data: Uint8Array }[],
-): Uint8Array {
-  const { archive } = buildVBundle({
-    files: extraFiles,
-    ...defaultV1Options(),
-  });
-  return archive;
-}
-
-// ---------------------------------------------------------------------------
-// Happy path
-// ---------------------------------------------------------------------------
-
-describe("parseVBundleStream — happy path", () => {
-  test("yields entries in order with correct names and sizes", async () => {
-    const fileA = new TextEncoder().encode("alpha\n");
-    const fileB = new TextEncoder().encode("beta beta\n");
-    const fileC = new TextEncoder().encode("gamma gamma gamma\n");
-
-    const archive = buildMinimalVBundle([
-      { path: "workspace/a.txt", data: fileA },
-      { path: "workspace/b.txt", data: fileB },
-      { path: "workspace/c.txt", data: fileC },
-    ]);
-
-    const source = readableFromBuffer(archive);
-    const seen: { name: string; size: number; body: Uint8Array }[] = [];
-
-    for await (const entry of parseVBundleStream(source)) {
-      const body = await collectBody(entry);
-      seen.push({
-        name: entry.header.name,
-        size: entry.header.size,
-        body,
-      });
-    }
-
-    // manifest.json is emitted first, then the 3 files in insertion order.
-    expect(seen.length).toBe(4);
-    expect(seen[0]?.name).toBe("manifest.json");
-    expect(seen[1]?.name).toBe("workspace/a.txt");
-    expect(seen[2]?.name).toBe("workspace/b.txt");
-    expect(seen[3]?.name).toBe("workspace/c.txt");
-
-    // Sizes in the header match the body lengths.
-    expect(seen[1]?.size).toBe(fileA.length);
-    expect(seen[1]?.body.length).toBe(fileA.length);
-    expect(seen[2]?.size).toBe(fileB.length);
-    expect(seen[2]?.body.length).toBe(fileB.length);
-    expect(seen[3]?.size).toBe(fileC.length);
-    expect(seen[3]?.body.length).toBe(fileC.length);
-
-    // Body contents round-trip correctly.
-    expect(new TextDecoder().decode(seen[1]?.body)).toBe("alpha\n");
-    expect(new TextDecoder().decode(seen[2]?.body)).toBe("beta beta\n");
-    expect(new TextDecoder().decode(seen[3]?.body)).toBe("gamma gamma gamma\n");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Manifest-first invariant
-// ---------------------------------------------------------------------------
-
-describe("parseVBundleStream — manifest-first", () => {
-  test("first entry is manifest.json", async () => {
-    const archive = buildMinimalVBundle([
-      { path: "z-last.txt", data: new TextEncoder().encode("zzz") },
-    ]);
-
-    const iter = parseVBundleStream(readableFromBuffer(archive));
-    const first = await iter.next();
-    expect(first.done).toBe(false);
-    expect(first.value?.header.name).toBe("manifest.json");
-    expect(first.value?.header.type).toBe("file");
-
-    // Drain the manifest body so the iterator can advance, then finish.
-    if (first.value) {
-      await collectBody(first.value);
-    }
-    // Exhaust the iterator to release resources. Drain each body so the
-    // extractor can advance. (We don't assert on the remaining entries here.)
-    for await (const entry of iter) {
-      await collectBody(entry);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Error handling
-// ---------------------------------------------------------------------------
-
-describe("parseVBundleStream — errors", () => {
-  test("throws on truncated gzip mid-stream", async () => {
-    const archive = buildMinimalVBundle([
-      { path: "workspace/a.txt", data: new TextEncoder().encode("hello") },
-    ]);
-
-    // Lop off the trailing bytes of the gzip member so the decoder fails
-    // partway through.
-    const truncated = archive.subarray(0, Math.max(32, archive.length - 20));
-    const source = readableFromBuffer(new Uint8Array(truncated));
-
-    let threw = false;
-    try {
-      for await (const entry of parseVBundleStream(source)) {
-        // Drain whatever the decoder can produce before the error hits.
-        try {
-          await collectBody(entry);
-        } catch {
-          // Body streams may error mid-drain; that also counts as a failure
-          // in the outer iterator on the next advance.
-          threw = true;
-          break;
-        }
-      }
-    } catch {
-      threw = true;
-    }
-
-    expect(threw).toBe(true);
-  });
-
-  test("throws on valid gzip wrapping malformed tar bytes", async () => {
-    // Gzipped junk — valid gzip member, but the inflated bytes aren't a tar.
-    const junk = new TextEncoder().encode("this is not a tar archive payload");
-    // Pad out so the extractor has enough bytes to attempt a header parse.
-    const padded = new Uint8Array(1024);
-    padded.set(junk, 0);
-    const gz = gzipSync(padded);
-    const source = readableFromBuffer(new Uint8Array(gz));
-
-    let threw = false;
-    try {
-      for await (const entry of parseVBundleStream(source)) {
-        try {
-          await collectBody(entry);
-        } catch {
-          threw = true;
-          break;
-        }
-      }
-    } catch {
-      threw = true;
-    }
-
-    expect(threw).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Early-termination cleanup
-// ---------------------------------------------------------------------------
-
-describe("parseVBundleStream — cleanup", () => {
-  test("destroys upstream source when caller breaks out of the loop", async () => {
-    const archive = buildMinimalVBundle([
-      { path: "workspace/a.txt", data: new TextEncoder().encode("hello") },
-      { path: "workspace/b.txt", data: new TextEncoder().encode("world") },
-    ]);
-
-    const source = readableFromBuffer(archive);
-    let destroyCalls = 0;
-    const originalDestroy = source.destroy.bind(source);
-    source.destroy = ((err?: Error) => {
-      destroyCalls += 1;
-      return originalDestroy(err);
-    }) as typeof source.destroy;
-
-    for await (const entry of parseVBundleStream(source)) {
-      // Consume just the first entry (manifest.json), then bail.
-      await collectBody(entry);
-      break;
-    }
-
-    expect(destroyCalls).toBeGreaterThan(0);
-    // Source should now be destroyed (no dangling listeners keeping it alive).
-    expect(source.destroyed).toBe(true);
-  });
-
-  test("throws (does not hang) when source is already destroyed before parse", async () => {
-    const source = readableFromBuffer(new Uint8Array(0));
-    source.destroy(new Error("upstream torn down"));
-
-    let threw = false;
-    try {
-      for await (const _entry of parseVBundleStream(source)) {
-        // unreachable
-      }
-    } catch {
-      threw = true;
-    }
-
-    expect(threw).toBe(true);
-  }, 1000);
-});