@vellumai/assistant 0.4.16 → 0.4.18

package/src/__tests__/assistant-attachment-directive.test.ts

@@ -1,10 +1,14 @@
-import { mkdirSync, realpathSync,rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { afterEach,beforeEach, describe, expect, test } from 'bun:test';
-
-import { type DirectiveRequest,parseDirectives, resolveHostDirective, resolveSandboxDirective } from '../daemon/assistant-attachments.js';
+import { mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  type DirectiveRequest,
+  parseDirectives,
+  resolveHostDirective,
+  resolveSandboxDirective,
+} from "../daemon/assistant-attachments.js";
 
 // Use realpath to avoid macOS /tmp → /private/tmp symlink mismatches
 const RAW_TEST_DIR = join(tmpdir(), `vellum-sandbox-test-${Date.now()}`);
@@ -15,40 +19,41 @@ const TEST_DIR = realpathSync(RAW_TEST_DIR);
 // parseDirectives
 // ---------------------------------------------------------------------------
 
-describe('parseDirectives', () => {
-  test('parses a single sandbox directive with all attributes', () => {
-    const text = 'Here is the report:\n<vellum-attachment source="sandbox" path="output/report.pdf" filename="report.pdf" mime_type="application/pdf" />';
+describe("parseDirectives", () => {
+  test("parses a single sandbox directive with all attributes", () => {
+    const text =
+      'Here is the report:\n<vellum-attachment source="sandbox" path="output/report.pdf" filename="report.pdf" mime_type="application/pdf" />';
     const result = parseDirectives(text);
 
     expect(result.directiveRequests).toHaveLength(1);
     expect(result.directiveRequests[0]).toEqual({
-      source: 'sandbox',
-      path: 'output/report.pdf',
-      filename: 'report.pdf',
-      mimeType: 'application/pdf',
+      source: "sandbox",
+      path: "output/report.pdf",
+      filename: "report.pdf",
+      mimeType: "application/pdf",
     });
-    expect(result.cleanText).toBe('Here is the report:');
+    expect(result.cleanText).toBe("Here is the report:");
     expect(result.parseWarnings).toHaveLength(0);
   });
 
-  test('defaults source to sandbox when omitted', () => {
+  test("defaults source to sandbox when omitted", () => {
     const text = '<vellum-attachment path="chart.png" />';
     const result = parseDirectives(text);
 
     expect(result.directiveRequests).toHaveLength(1);
-    expect(result.directiveRequests[0].source).toBe('sandbox');
+    expect(result.directiveRequests[0].source).toBe("sandbox");
   });
 
-  test('parses host source', () => {
+  test("parses host source", () => {
     const text = '<vellum-attachment source="host" path="/Users/me/doc.pdf" />';
     const result = parseDirectives(text);
 
     expect(result.directiveRequests).toHaveLength(1);
-    expect(result.directiveRequests[0].source).toBe('host');
-    expect(result.directiveRequests[0].path).toBe('/Users/me/doc.pdf');
+    expect(result.directiveRequests[0].source).toBe("host");
+    expect(result.directiveRequests[0].path).toBe("/Users/me/doc.pdf");
   });
 
-  test('leaves optional filename and mime_type undefined when absent', () => {
+  test("leaves optional filename and mime_type undefined when absent", () => {
     const text = '<vellum-attachment path="file.txt" />';
     const result = parseDirectives(text);
 
@@ -56,23 +61,23 @@ describe('parseDirectives', () => {
     expect(result.directiveRequests[0].mimeType).toBeUndefined();
   });
 
-  test('parses multiple directives preserving order', () => {
+  test("parses multiple directives preserving order", () => {
     const text = [
-      'Results:',
+      "Results:",
       '<vellum-attachment path="a.png" />',
-      'And also:',
+      "And also:",
       '<vellum-attachment path="b.pdf" />',
-    ].join('\n');
+    ].join("\n");
 
     const result = parseDirectives(text);
 
     expect(result.directiveRequests).toHaveLength(2);
-    expect(result.directiveRequests[0].path).toBe('a.png');
-    expect(result.directiveRequests[1].path).toBe('b.pdf');
-    expect(result.cleanText).toBe('Results:\n\nAnd also:');
+    expect(result.directiveRequests[0].path).toBe("a.png");
+    expect(result.directiveRequests[1].path).toBe("b.pdf");
+    expect(result.cleanText).toBe("Results:\n\nAnd also:");
   });
 
-  test('rejects directive without path attribute', () => {
+  test("rejects directive without path attribute", () => {
     const text = '<vellum-attachment source="sandbox" />';
     const result = parseDirectives(text);
 
@@ -80,36 +85,36 @@ describe('parseDirectives', () => {
     expect(result.parseWarnings).toHaveLength(1);
     expect(result.parseWarnings[0]).toContain('missing required "path"');
     // Malformed tag preserved in text
-    expect(result.cleanText).toContain('<vellum-attachment');
+    expect(result.cleanText).toContain("<vellum-attachment");
   });
 
-  test('rejects directive with invalid source value', () => {
+  test("rejects directive with invalid source value", () => {
     const text = '<vellum-attachment source="cloud" path="x.txt" />';
     const result = parseDirectives(text);
 
     expect(result.directiveRequests).toHaveLength(0);
     expect(result.parseWarnings).toHaveLength(1);
     expect(result.parseWarnings[0]).toContain('invalid source="cloud"');
-    expect(result.cleanText).toContain('<vellum-attachment');
+    expect(result.cleanText).toContain("<vellum-attachment");
   });
 
-  test('handles mixed valid and invalid directives', () => {
+  test("handles mixed valid and invalid directives", () => {
     const text = [
       '<vellum-attachment path="good.png" />',
       '<vellum-attachment source="nope" path="bad.txt" />',
       '<vellum-attachment path="also-good.pdf" />',
-    ].join('\n');
+    ].join("\n");
 
     const result = parseDirectives(text);
 
     expect(result.directiveRequests).toHaveLength(2);
-    expect(result.directiveRequests[0].path).toBe('good.png');
-    expect(result.directiveRequests[1].path).toBe('also-good.pdf');
+    expect(result.directiveRequests[0].path).toBe("good.png");
+    expect(result.directiveRequests[1].path).toBe("also-good.pdf");
     expect(result.parseWarnings).toHaveLength(1);
   });
 
-  test('returns original text when no directives present', () => {
-    const text = 'Hello world, no attachments here.';
+  test("returns original text when no directives present", () => {
+    const text = "Hello world, no attachments here.";
     const result = parseDirectives(text);
 
     expect(result.cleanText).toBe(text);
@@ -117,55 +122,57 @@ describe('parseDirectives', () => {
     expect(result.parseWarnings).toHaveLength(0);
   });
 
-  test('preserves whitespace when no directives are present', () => {
-    const text = '\n  Leading space\n\n\n\nTrailing space  \n';
+  test("preserves whitespace when no directives are present", () => {
+    const text = "\n  Leading space\n\n\n\nTrailing space  \n";
     const result = parseDirectives(text);
 
     expect(result.cleanText).toBe(text);
     expect(result.directiveRequests).toHaveLength(0);
   });
 
-  test('preserves non-self-closing tags as plain text', () => {
-    const text = '<vellum-attachment path="file.txt">content</vellum-attachment>';
+  test("preserves non-self-closing tags as plain text", () => {
+    const text =
+      '<vellum-attachment path="file.txt">content</vellum-attachment>';
     const result = parseDirectives(text);
 
     // The regex only matches self-closing tags, so non-self-closing is not matched
     expect(result.directiveRequests).toHaveLength(0);
-    expect(result.cleanText).toContain('content</vellum-attachment>');
+    expect(result.cleanText).toContain("content</vellum-attachment>");
   });
 
-  test('handles single-quoted attributes', () => {
-    const text = "<vellum-attachment path='report.pdf' filename='my report.pdf' />";
+  test("handles single-quoted attributes", () => {
+    const text =
+      "<vellum-attachment path='report.pdf' filename='my report.pdf' />";
     const result = parseDirectives(text);
 
     expect(result.directiveRequests).toHaveLength(1);
-    expect(result.directiveRequests[0].path).toBe('report.pdf');
-    expect(result.directiveRequests[0].filename).toBe('my report.pdf');
+    expect(result.directiveRequests[0].path).toBe("report.pdf");
+    expect(result.directiveRequests[0].filename).toBe("my report.pdf");
   });
 
-  test('collapses excess blank lines after tag removal', () => {
+  test("collapses excess blank lines after tag removal", () => {
     const text = 'Before\n\n<vellum-attachment path="x.png" />\n\n\nAfter';
     const result = parseDirectives(text);
 
     // Should not have triple+ newlines
     expect(result.cleanText).not.toMatch(/\n{3,}/);
-    expect(result.cleanText).toBe('Before\n\nAfter');
+    expect(result.cleanText).toBe("Before\n\nAfter");
   });
 
-  test('handles directive with multiline attributes', () => {
+  test("handles directive with multiline attributes", () => {
     const text = [
-      '<vellum-attachment',
+      "<vellum-attachment",
       '  source="host"',
       '  path="/tmp/data.csv"',
       '  mime_type="text/csv"',
-      '/>',
-    ].join('\n');
+      "/>",
+    ].join("\n");
     const result = parseDirectives(text);
 
     expect(result.directiveRequests).toHaveLength(1);
-    expect(result.directiveRequests[0].source).toBe('host');
-    expect(result.directiveRequests[0].path).toBe('/tmp/data.csv');
-    expect(result.directiveRequests[0].mimeType).toBe('text/csv');
+    expect(result.directiveRequests[0].source).toBe("host");
+    expect(result.directiveRequests[0].path).toBe("/tmp/data.csv");
+    expect(result.directiveRequests[0].mimeType).toBe("text/csv");
   });
 });
 
@@ -173,110 +180,138 @@ describe('parseDirectives', () => {
 // resolveSandboxDirective
 // ---------------------------------------------------------------------------
 
-describe('resolveSandboxDirective', () => {
+describe("resolveSandboxDirective", () => {
   beforeEach(() => {
-    mkdirSync(join(TEST_DIR, 'sub'), { recursive: true });
+    mkdirSync(join(TEST_DIR, "sub"), { recursive: true });
   });
 
   afterEach(() => {
     rmSync(TEST_DIR, { recursive: true, force: true });
   });
 
-  function makeDirective(overrides: Partial<DirectiveRequest> = {}): DirectiveRequest {
+  function makeDirective(
+    overrides: Partial<DirectiveRequest> = {},
+  ): DirectiveRequest {
     return {
-      source: 'sandbox',
-      path: 'hello.txt',
+      source: "sandbox",
+      path: "hello.txt",
       filename: undefined,
       mimeType: undefined,
       ...overrides,
     };
   }
 
-  test('resolves a valid sandbox file to a draft', () => {
-    const filePath = join(TEST_DIR, 'hello.txt');
-    writeFileSync(filePath, 'hello world');
+  test("resolves a valid sandbox file to a draft", () => {
+    const filePath = join(TEST_DIR, "hello.txt");
+    writeFileSync(filePath, "hello world");
 
-    const result = resolveSandboxDirective(makeDirective({ path: 'hello.txt' }), TEST_DIR);
+    const result = resolveSandboxDirective(
+      makeDirective({ path: "hello.txt" }),
+      TEST_DIR,
+    );
 
     expect(result.draft).not.toBeNull();
     expect(result.warning).toBeNull();
-    expect(result.draft!.sourceType).toBe('sandbox_file');
-    expect(result.draft!.filename).toBe('hello.txt');
-    expect(result.draft!.mimeType).toBe('text/plain');
+    expect(result.draft!.sourceType).toBe("sandbox_file");
+    expect(result.draft!.filename).toBe("hello.txt");
+    expect(result.draft!.mimeType).toBe("text/plain");
     expect(result.draft!.sizeBytes).toBe(11);
-    expect(result.draft!.kind).toBe('document');
+    expect(result.draft!.kind).toBe("document");
   });
 
-  test('uses directive filename override when provided', () => {
-    writeFileSync(join(TEST_DIR, 'data.txt'), 'content');
+  test("uses directive filename override when provided", () => {
+    writeFileSync(join(TEST_DIR, "data.txt"), "content");
 
     const result = resolveSandboxDirective(
-      makeDirective({ path: 'data.txt', filename: 'custom-name.txt' }),
+      makeDirective({ path: "data.txt", filename: "custom-name.txt" }),
       TEST_DIR,
     );
 
-    expect(result.draft!.filename).toBe('custom-name.txt');
+    expect(result.draft!.filename).toBe("custom-name.txt");
   });
 
-  test('uses directive mimeType override when provided', () => {
-    writeFileSync(join(TEST_DIR, 'data.bin'), Buffer.from([1, 2, 3]));
+  test("uses directive mimeType override when provided", () => {
+    writeFileSync(join(TEST_DIR, "data.bin"), Buffer.from([1, 2, 3]));
 
     const result = resolveSandboxDirective(
-      makeDirective({ path: 'data.bin', mimeType: 'application/x-custom' }),
+      makeDirective({ path: "data.bin", mimeType: "application/x-custom" }),
       TEST_DIR,
     );
 
-    expect(result.draft!.mimeType).toBe('application/x-custom');
+    expect(result.draft!.mimeType).toBe("application/x-custom");
   });
 
-  test('infers MIME type from extension', () => {
-    writeFileSync(join(TEST_DIR, 'image.png'), Buffer.from([0x89, 0x50, 0x4e, 0x47]));
+  test("infers MIME type from extension", () => {
+    writeFileSync(
+      join(TEST_DIR, "image.png"),
+      Buffer.from([0x89, 0x50, 0x4e, 0x47]),
+    );
 
-    const result = resolveSandboxDirective(makeDirective({ path: 'image.png' }), TEST_DIR);
+    const result = resolveSandboxDirective(
+      makeDirective({ path: "image.png" }),
+      TEST_DIR,
+    );
 
-    expect(result.draft!.mimeType).toBe('image/png');
-    expect(result.draft!.kind).toBe('image');
+    expect(result.draft!.mimeType).toBe("image/png");
+    expect(result.draft!.kind).toBe("image");
   });
 
-  test('rejects paths that escape sandbox boundary', () => {
-    const result = resolveSandboxDirective(makeDirective({ path: '../../etc/passwd' }), TEST_DIR);
+  test("rejects paths that escape sandbox boundary", () => {
+    const result = resolveSandboxDirective(
+      makeDirective({ path: "../../etc/passwd" }),
+      TEST_DIR,
+    );
 
     expect(result.draft).toBeNull();
-    expect(result.warning).toContain('outside the working directory');
+    expect(result.warning).toContain("outside the working directory");
   });
 
-  test('warns when file does not exist', () => {
-    const result = resolveSandboxDirective(makeDirective({ path: 'nonexistent.txt' }), TEST_DIR);
+  test("warns when file does not exist", () => {
+    const result = resolveSandboxDirective(
+      makeDirective({ path: "nonexistent.txt" }),
+      TEST_DIR,
+    );
 
     expect(result.draft).toBeNull();
-    expect(result.warning).toContain('file not found');
+    expect(result.warning).toContain("file not found");
   });
 
-  test('warns when path is a directory', () => {
-    const result = resolveSandboxDirective(makeDirective({ path: 'sub' }), TEST_DIR);
+  test("warns when path is a directory", () => {
+    const result = resolveSandboxDirective(
+      makeDirective({ path: "sub" }),
+      TEST_DIR,
+    );
 
     expect(result.draft).toBeNull();
-    expect(result.warning).toContain('not a regular file');
+    expect(result.warning).toContain("not a regular file");
   });
 
-  test('resolves relative subdirectory paths', () => {
-    writeFileSync(join(TEST_DIR, 'sub', 'nested.json'), '{"key":"value"}');
+  test("resolves relative subdirectory paths", () => {
+    writeFileSync(join(TEST_DIR, "sub", "nested.json"), '{"key":"value"}');
 
-    const result = resolveSandboxDirective(makeDirective({ path: 'sub/nested.json' }), TEST_DIR);
+    const result = resolveSandboxDirective(
+      makeDirective({ path: "sub/nested.json" }),
+      TEST_DIR,
+    );
 
     expect(result.draft).not.toBeNull();
-    expect(result.draft!.filename).toBe('nested.json');
-    expect(result.draft!.mimeType).toBe('application/json');
+    expect(result.draft!.filename).toBe("nested.json");
+    expect(result.draft!.mimeType).toBe("application/json");
   });
 
-  test('base64 encodes file content correctly', () => {
-    const content = 'test content';
-    writeFileSync(join(TEST_DIR, 'test.txt'), content);
+  test("base64 encodes file content correctly", () => {
+    const content = "test content";
+    writeFileSync(join(TEST_DIR, "test.txt"), content);
 
-    const result = resolveSandboxDirective(makeDirective({ path: 'test.txt' }), TEST_DIR);
+    const result = resolveSandboxDirective(
+      makeDirective({ path: "test.txt" }),
+      TEST_DIR,
+    );
 
     expect(result.draft).not.toBeNull();
-    const decoded = Buffer.from(result.draft!.dataBase64, 'base64').toString('utf-8');
+    const decoded = Buffer.from(result.draft!.dataBase64, "base64").toString(
+      "utf-8",
+    );
     expect(decoded).toBe(content);
   });
 });
@@ -285,19 +320,21 @@ describe('resolveSandboxDirective', () => {
 // resolveHostDirective
 // ---------------------------------------------------------------------------
 
-describe('resolveHostDirective', () => {
+describe("resolveHostDirective", () => {
   beforeEach(() => {
-    mkdirSync(join(TEST_DIR, 'host-sub'), { recursive: true });
+    mkdirSync(join(TEST_DIR, "host-sub"), { recursive: true });
   });
 
   afterEach(() => {
     rmSync(TEST_DIR, { recursive: true, force: true });
   });
 
-  function makeHostDirective(overrides: Partial<DirectiveRequest> = {}): DirectiveRequest {
+  function makeHostDirective(
+    overrides: Partial<DirectiveRequest> = {},
+  ): DirectiveRequest {
     return {
-      source: 'host',
-      path: join(TEST_DIR, 'doc.txt'),
+      source: "host",
+      path: join(TEST_DIR, "doc.txt"),
       filename: undefined,
       mimeType: undefined,
       ...overrides,
@@ -307,96 +344,104 @@ describe('resolveHostDirective', () => {
   const alwaysApprove = async () => true;
   const alwaysDeny = async () => false;
 
-  test('resolves an approved host file to a draft', async () => {
-    const filePath = join(TEST_DIR, 'doc.txt');
-    writeFileSync(filePath, 'host content');
+  test("resolves an approved host file to a draft", async () => {
+    const filePath = join(TEST_DIR, "doc.txt");
+    writeFileSync(filePath, "host content");
 
-    const result = await resolveHostDirective(makeHostDirective(), alwaysApprove);
+    const result = await resolveHostDirective(
+      makeHostDirective(),
+      alwaysApprove,
+    );
 
     expect(result.draft).not.toBeNull();
     expect(result.warning).toBeNull();
-    expect(result.draft!.sourceType).toBe('host_file');
-    expect(result.draft!.filename).toBe('doc.txt');
-    expect(result.draft!.mimeType).toBe('text/plain');
+    expect(result.draft!.sourceType).toBe("host_file");
+    expect(result.draft!.filename).toBe("doc.txt");
+    expect(result.draft!.mimeType).toBe("text/plain");
     expect(result.draft!.sizeBytes).toBe(12);
   });
 
-  test('skips when user denies', async () => {
-    writeFileSync(join(TEST_DIR, 'secret.txt'), 'private');
+  test("skips when user denies", async () => {
+    writeFileSync(join(TEST_DIR, "secret.txt"), "private");
 
     const result = await resolveHostDirective(
-      makeHostDirective({ path: join(TEST_DIR, 'secret.txt') }),
+      makeHostDirective({ path: join(TEST_DIR, "secret.txt") }),
       alwaysDeny,
     );
 
     expect(result.draft).toBeNull();
-    expect(result.warning).toContain('access denied by user');
+    expect(result.warning).toContain("access denied by user");
   });
 
-  test('rejects relative paths', async () => {
+  test("rejects relative paths", async () => {
     const result = await resolveHostDirective(
-      makeHostDirective({ path: 'relative/path.txt' }),
+      makeHostDirective({ path: "relative/path.txt" }),
       alwaysApprove,
     );
 
     expect(result.draft).toBeNull();
-    expect(result.warning).toContain('must be absolute');
+    expect(result.warning).toContain("must be absolute");
   });
 
-  test('warns when file does not exist', async () => {
+  test("warns when file does not exist", async () => {
     const result = await resolveHostDirective(
-      makeHostDirective({ path: join(TEST_DIR, 'nonexistent.txt') }),
+      makeHostDirective({ path: join(TEST_DIR, "nonexistent.txt") }),
       alwaysApprove,
     );
 
     expect(result.draft).toBeNull();
-    expect(result.warning).toContain('file not found');
+    expect(result.warning).toContain("file not found");
   });
 
-  test('warns when path is a directory', async () => {
+  test("warns when path is a directory", async () => {
     const result = await resolveHostDirective(
-      makeHostDirective({ path: join(TEST_DIR, 'host-sub') }),
+      makeHostDirective({ path: join(TEST_DIR, "host-sub") }),
       alwaysApprove,
     );
 
     expect(result.draft).toBeNull();
-    expect(result.warning).toContain('not a regular file');
+    expect(result.warning).toContain("not a regular file");
   });
 
-  test('uses directive filename and mimeType overrides', async () => {
-    writeFileSync(join(TEST_DIR, 'data.bin'), Buffer.from([1, 2, 3]));
+  test("uses directive filename and mimeType overrides", async () => {
+    writeFileSync(join(TEST_DIR, "data.bin"), Buffer.from([1, 2, 3]));
 
     const result = await resolveHostDirective(
       makeHostDirective({
-        path: join(TEST_DIR, 'data.bin'),
-        filename: 'custom.dat',
-        mimeType: 'application/x-custom',
+        path: join(TEST_DIR, "data.bin"),
+        filename: "custom.dat",
+        mimeType: "application/x-custom",
       }),
       alwaysApprove,
     );
 
-    expect(result.draft!.filename).toBe('custom.dat');
-    expect(result.draft!.mimeType).toBe('application/x-custom');
+    expect(result.draft!.filename).toBe("custom.dat");
+    expect(result.draft!.mimeType).toBe("application/x-custom");
   });
 
-  test('handles approval callback error gracefully', async () => {
-    writeFileSync(join(TEST_DIR, 'doc.txt'), 'content');
+  test("handles approval callback error gracefully", async () => {
+    writeFileSync(join(TEST_DIR, "doc.txt"), "content");
 
-    const failApprove = async () => { throw new Error('IPC disconnected'); };
+    const failApprove = async () => {
+      throw new Error("IPC disconnected");
+    };
     const result = await resolveHostDirective(makeHostDirective(), failApprove);
 
     expect(result.draft).toBeNull();
-    expect(result.warning).toContain('approval request failed');
+    expect(result.warning).toContain("approval request failed");
   });
 
-  test('calls approve with the resolved absolute path', async () => {
-    writeFileSync(join(TEST_DIR, 'doc.txt'), 'content');
+  test("calls approve with the resolved absolute path", async () => {
+    writeFileSync(join(TEST_DIR, "doc.txt"), "content");
 
-    let approvedPath = '';
-    const captureApprove = async (p: string) => { approvedPath = p; return true; };
+    let approvedPath = "";
+    const captureApprove = async (p: string) => {
+      approvedPath = p;
+      return true;
+    };
 
     await resolveHostDirective(makeHostDirective(), captureApprove);
 
-    expect(approvedPath).toBe(join(TEST_DIR, 'doc.txt'));
+    expect(approvedPath).toBe(join(TEST_DIR, "doc.txt"));
   });
 });