@vellumai/assistant 0.4.17 → 0.4.19

package/src/__tests__/domain-normalize.test.ts

@@ -1,113 +1,113 @@
-import { describe, expect,test } from 'bun:test';
+import { describe, expect, test } from "bun:test";
 
-import { normalizeDomain } from '../tools/network/domain-normalize.js';
+import { normalizeDomain } from "../tools/network/domain-normalize.js";
 
-describe('normalizeDomain', () => {
+describe("normalizeDomain", () => {
   // ── Basic hostname parsing ──────────────────────────────────────────
 
-  test('parses simple hostname', () => {
-    const result = normalizeDomain('example.com');
+  test("parses simple hostname", () => {
+    const result = normalizeDomain("example.com");
     expect(result).not.toBeNull();
-    expect(result!.hostname).toBe('example.com');
-    expect(result!.registrableDomain).toBe('example.com');
+    expect(result!.hostname).toBe("example.com");
+    expect(result!.registrableDomain).toBe("example.com");
   });
 
-  test('parses subdomain', () => {
-    const result = normalizeDomain('login.example.com');
+  test("parses subdomain", () => {
+    const result = normalizeDomain("login.example.com");
     expect(result).not.toBeNull();
-    expect(result!.hostname).toBe('login.example.com');
-    expect(result!.registrableDomain).toBe('example.com');
+    expect(result!.hostname).toBe("login.example.com");
+    expect(result!.registrableDomain).toBe("example.com");
   });
 
-  test('parses deep subdomain', () => {
-    const result = normalizeDomain('foo.bar.example.co.uk');
+  test("parses deep subdomain", () => {
+    const result = normalizeDomain("foo.bar.example.co.uk");
     expect(result).not.toBeNull();
-    expect(result!.hostname).toBe('foo.bar.example.co.uk');
-    expect(result!.registrableDomain).toBe('example.co.uk');
+    expect(result!.hostname).toBe("foo.bar.example.co.uk");
+    expect(result!.registrableDomain).toBe("example.co.uk");
   });
 
   // ── URL extraction ──────────────────────────────────────────────────
 
-  test('extracts hostname from full URL', () => {
-    const result = normalizeDomain('https://login.example.com/path?q=1');
+  test("extracts hostname from full URL", () => {
+    const result = normalizeDomain("https://login.example.com/path?q=1");
     expect(result).not.toBeNull();
-    expect(result!.hostname).toBe('login.example.com');
-    expect(result!.registrableDomain).toBe('example.com');
+    expect(result!.hostname).toBe("login.example.com");
+    expect(result!.registrableDomain).toBe("example.com");
   });
 
-  test('extracts hostname from URL with port', () => {
-    const result = normalizeDomain('https://example.com:8443/api');
+  test("extracts hostname from URL with port", () => {
+    const result = normalizeDomain("https://example.com:8443/api");
     expect(result).not.toBeNull();
-    expect(result!.hostname).toBe('example.com');
+    expect(result!.hostname).toBe("example.com");
   });
 
-  test('strips port from bare hostname', () => {
-    const result = normalizeDomain('example.com:8080');
+  test("strips port from bare hostname", () => {
+    const result = normalizeDomain("example.com:8080");
     expect(result).not.toBeNull();
-    expect(result!.hostname).toBe('example.com');
-    expect(result!.registrableDomain).toBe('example.com');
+    expect(result!.hostname).toBe("example.com");
+    expect(result!.registrableDomain).toBe("example.com");
   });
 
   // ── Normalization ───────────────────────────────────────────────────
 
-  test('lowercases hostname', () => {
-    const result = normalizeDomain('Login.EXAMPLE.Com');
+  test("lowercases hostname", () => {
+    const result = normalizeDomain("Login.EXAMPLE.Com");
     expect(result).not.toBeNull();
-    expect(result!.hostname).toBe('login.example.com');
-    expect(result!.registrableDomain).toBe('example.com');
+    expect(result!.hostname).toBe("login.example.com");
+    expect(result!.registrableDomain).toBe("example.com");
   });
 
-  test('strips trailing dot', () => {
-    const result = normalizeDomain('example.com.');
+  test("strips trailing dot", () => {
+    const result = normalizeDomain("example.com.");
     expect(result).not.toBeNull();
-    expect(result!.hostname).toBe('example.com');
-    expect(result!.registrableDomain).toBe('example.com');
+    expect(result!.hostname).toBe("example.com");
+    expect(result!.registrableDomain).toBe("example.com");
   });
 
   // ── Punycode / IDN ──────────────────────────────────────────────────
 
-  test('handles punycode domain', () => {
-    const result = normalizeDomain('xn--nxasmq6b.example.com');
+  test("handles punycode domain", () => {
+    const result = normalizeDomain("xn--nxasmq6b.example.com");
     expect(result).not.toBeNull();
-    expect(result!.hostname).toBe('xn--nxasmq6b.example.com');
-    expect(result!.registrableDomain).toBe('example.com');
+    expect(result!.hostname).toBe("xn--nxasmq6b.example.com");
+    expect(result!.registrableDomain).toBe("example.com");
   });
 
   // ── Rejection cases ─────────────────────────────────────────────────
 
-  test('returns null for IPv4 address', () => {
-    expect(normalizeDomain('192.168.1.1')).toBeNull();
+  test("returns null for IPv4 address", () => {
+    expect(normalizeDomain("192.168.1.1")).toBeNull();
   });
 
-  test('returns null for IPv6 address', () => {
-    expect(normalizeDomain('[::1]')).toBeNull();
-    expect(normalizeDomain('::1')).toBeNull();
+  test("returns null for IPv6 address", () => {
+    expect(normalizeDomain("[::1]")).toBeNull();
+    expect(normalizeDomain("::1")).toBeNull();
   });
 
-  test('returns null for localhost', () => {
-    expect(normalizeDomain('localhost')).toBeNull();
+  test("returns null for localhost", () => {
+    expect(normalizeDomain("localhost")).toBeNull();
   });
 
-  test('returns null for empty string', () => {
-    expect(normalizeDomain('')).toBeNull();
+  test("returns null for empty string", () => {
+    expect(normalizeDomain("")).toBeNull();
   });
 
-  test('returns null for null-like input', () => {
+  test("returns null for null-like input", () => {
     expect(normalizeDomain(null as unknown as string)).toBeNull();
     expect(normalizeDomain(undefined as unknown as string)).toBeNull();
   });
 
   // ── Co.uk / multi-part TLD ──────────────────────────────────────────
 
-  test('handles co.uk correctly', () => {
-    const result = normalizeDomain('www.bbc.co.uk');
+  test("handles co.uk correctly", () => {
+    const result = normalizeDomain("www.bbc.co.uk");
     expect(result).not.toBeNull();
-    expect(result!.registrableDomain).toBe('bbc.co.uk');
+    expect(result!.registrableDomain).toBe("bbc.co.uk");
   });
 
-  test('handles com.au correctly', () => {
-    const result = normalizeDomain('shop.example.com.au');
+  test("handles com.au correctly", () => {
+    const result = normalizeDomain("shop.example.com.au");
     expect(result).not.toBeNull();
-    expect(result!.registrableDomain).toBe('example.com.au');
+    expect(result!.registrableDomain).toBe("example.com.au");
   });
 });

package/src/__tests__/domain-policy.test.ts

@@ -1,125 +1,141 @@
-import { describe, expect,test } from 'bun:test';
+import { describe, expect, test } from "bun:test";
 
-import { isDomainAllowed } from '../tools/credentials/domain-policy.js';
+import { isDomainAllowed } from "../tools/credentials/domain-policy.js";
 
-describe('isDomainAllowed', () => {
+describe("isDomainAllowed", () => {
   // ── Exact host match ────────────────────────────────────────────────
 
-  test('allows exact hostname match', () => {
-    expect(isDomainAllowed('example.com', ['example.com'])).toBe(true);
+  test("allows exact hostname match", () => {
+    expect(isDomainAllowed("example.com", ["example.com"])).toBe(true);
   });
 
-  test('allows exact hostname match (case insensitive)', () => {
-    expect(isDomainAllowed('Example.COM', ['example.com'])).toBe(true);
+  test("allows exact hostname match (case insensitive)", () => {
+    expect(isDomainAllowed("Example.COM", ["example.com"])).toBe(true);
   });
 
   // ── Registrable-domain + subdomain ──────────────────────────────────
 
-  test('allows subdomain when registrable domain matches', () => {
-    expect(isDomainAllowed('login.example.com', ['example.com'])).toBe(true);
+  test("allows subdomain when registrable domain matches", () => {
+    expect(isDomainAllowed("login.example.com", ["example.com"])).toBe(true);
   });
 
-  test('allows deep subdomain when registrable domain matches', () => {
-    expect(isDomainAllowed('a.b.c.example.com', ['example.com'])).toBe(true);
+  test("allows deep subdomain when registrable domain matches", () => {
+    expect(isDomainAllowed("a.b.c.example.com", ["example.com"])).toBe(true);
   });
 
-  test('allows subdomain of co.uk domain', () => {
-    expect(isDomainAllowed('login.bbc.co.uk', ['bbc.co.uk'])).toBe(true);
+  test("allows subdomain of co.uk domain", () => {
+    expect(isDomainAllowed("login.bbc.co.uk", ["bbc.co.uk"])).toBe(true);
   });
 
   // ── Deny cases ──────────────────────────────────────────────────────
 
-  test('denies unrelated domain', () => {
-    expect(isDomainAllowed('evil.com', ['example.com'])).toBe(false);
+  test("denies unrelated domain", () => {
+    expect(isDomainAllowed("evil.com", ["example.com"])).toBe(false);
   });
 
-  test('denies domain that looks similar but differs', () => {
-    expect(isDomainAllowed('notexample.com', ['example.com'])).toBe(false);
+  test("denies domain that looks similar but differs", () => {
+    expect(isDomainAllowed("notexample.com", ["example.com"])).toBe(false);
   });
 
-  test('denies different TLD', () => {
-    expect(isDomainAllowed('example.org', ['example.com'])).toBe(false);
+  test("denies different TLD", () => {
+    expect(isDomainAllowed("example.org", ["example.com"])).toBe(false);
   });
 
-  test('denies when allowed list is empty', () => {
-    expect(isDomainAllowed('example.com', [])).toBe(false);
+  test("denies when allowed list is empty", () => {
+    expect(isDomainAllowed("example.com", [])).toBe(false);
   });
 
-  test('denies when allowed list is undefined-like', () => {
-    expect(isDomainAllowed('example.com', undefined as unknown as string[])).toBe(false);
+  test("denies when allowed list is undefined-like", () => {
+    expect(
+      isDomainAllowed("example.com", undefined as unknown as string[]),
+    ).toBe(false);
   });
 
-  test('denies when request host is empty', () => {
-    expect(isDomainAllowed('', ['example.com'])).toBe(false);
+  test("denies when request host is empty", () => {
+    expect(isDomainAllowed("", ["example.com"])).toBe(false);
   });
 
-  test('denies when request host is invalid', () => {
-    expect(isDomainAllowed('not a valid host!!!', ['example.com'])).toBe(false);
+  test("denies when request host is invalid", () => {
+    expect(isDomainAllowed("not a valid host!!!", ["example.com"])).toBe(false);
   });
 
-  test('denies malformed host even when same string is in allowed list', () => {
-    expect(isDomainAllowed('not a valid host!!!', ['not a valid host!!!'])).toBe(false);
+  test("denies malformed host even when same string is in allowed list", () => {
+    expect(
+      isDomainAllowed("not a valid host!!!", ["not a valid host!!!"]),
+    ).toBe(false);
   });
 
-  test('denies hostname with consecutive dots', () => {
-    expect(isDomainAllowed('a..b', ['a..b'])).toBe(false);
+  test("denies hostname with consecutive dots", () => {
+    expect(isDomainAllowed("a..b", ["a..b"])).toBe(false);
   });
 
-  test('denies hostname with label starting with hyphen', () => {
-    expect(isDomainAllowed('-foo.example.com', ['example.com'])).toBe(false);
+  test("denies hostname with label starting with hyphen", () => {
+    expect(isDomainAllowed("-foo.example.com", ["example.com"])).toBe(false);
   });
 
-  test('denies hostname with label ending with hyphen', () => {
-    expect(isDomainAllowed('foo-.example.com', ['example.com'])).toBe(false);
+  test("denies hostname with label ending with hyphen", () => {
+    expect(isDomainAllowed("foo-.example.com", ["example.com"])).toBe(false);
   });
 
-  test('denies IP addresses', () => {
-    expect(isDomainAllowed('192.168.1.1', ['192.168.1.1'])).toBe(false);
+  test("denies IP addresses", () => {
+    expect(isDomainAllowed("192.168.1.1", ["192.168.1.1"])).toBe(false);
   });
 
-  test('denies localhost', () => {
-    expect(isDomainAllowed('localhost', ['localhost'])).toBe(false);
+  test("denies localhost", () => {
+    expect(isDomainAllowed("localhost", ["localhost"])).toBe(false);
   });
 
   // ── Internal / non-registrable hosts ────────────────────────────────
 
-  test('allows exact match for single-label intranet host', () => {
-    expect(isDomainAllowed('intranet', ['intranet'])).toBe(true);
+  test("allows exact match for single-label intranet host", () => {
+    expect(isDomainAllowed("intranet", ["intranet"])).toBe(true);
   });
 
-  test('allows exact match for internal two-label host', () => {
-    expect(isDomainAllowed('vault.corp', ['vault.corp'])).toBe(true);
+  test("allows exact match for internal two-label host", () => {
+    expect(isDomainAllowed("vault.corp", ["vault.corp"])).toBe(true);
   });
 
   // ── URL extraction ──────────────────────────────────────────────────
 
-  test('extracts hostname from full URL', () => {
-    expect(isDomainAllowed('https://login.example.com/path', ['example.com'])).toBe(true);
+  test("extracts hostname from full URL", () => {
+    expect(
+      isDomainAllowed("https://login.example.com/path", ["example.com"]),
+    ).toBe(true);
   });
 
-  test('denies URL with wrong domain', () => {
-    expect(isDomainAllowed('https://evil.com/path', ['example.com'])).toBe(false);
+  test("denies URL with wrong domain", () => {
+    expect(isDomainAllowed("https://evil.com/path", ["example.com"])).toBe(
+      false,
+    );
   });
 
   // ── Subdomain in allowed list ──────────────────────────────────────
 
-  test('allows exact subdomain match when subdomain is in allowed list', () => {
-    expect(isDomainAllowed('login.example.com', ['login.example.com'])).toBe(true);
+  test("allows exact subdomain match when subdomain is in allowed list", () => {
+    expect(isDomainAllowed("login.example.com", ["login.example.com"])).toBe(
+      true,
+    );
   });
 
-  test('denies different subdomain when only specific subdomain is allowed', () => {
+  test("denies different subdomain when only specific subdomain is allowed", () => {
     // When allowed is a subdomain (not the registrable domain itself),
     // only exact matches should work
-    expect(isDomainAllowed('other.example.com', ['login.example.com'])).toBe(false);
+    expect(isDomainAllowed("other.example.com", ["login.example.com"])).toBe(
+      false,
+    );
   });
 
   // ── Multiple allowed domains ────────────────────────────────────────
 
-  test('matches against any domain in the allowed list', () => {
-    expect(isDomainAllowed('login.github.com', ['example.com', 'github.com'])).toBe(true);
+  test("matches against any domain in the allowed list", () => {
+    expect(
+      isDomainAllowed("login.github.com", ["example.com", "github.com"]),
+    ).toBe(true);
   });
 
-  test('denies when none of the allowed domains match', () => {
-    expect(isDomainAllowed('evil.com', ['example.com', 'github.com'])).toBe(false);
+  test("denies when none of the allowed domains match", () => {
+    expect(isDomainAllowed("evil.com", ["example.com", "github.com"])).toBe(
+      false,
+    );
   });
 });

package/src/__tests__/dynamic-page-surface.test.ts

@@ -1,37 +1,35 @@
-import { describe, expect,test } from 'bun:test';
+import { describe, expect, test } from "bun:test";
 
 import type {
   DynamicPageSurfaceData,
   UiSurfaceShowDynamicPage,
-} from '../daemon/ipc-protocol.js';
-import {
-  INTERACTIVE_SURFACE_TYPES,
-} from '../daemon/ipc-protocol.js';
-import { uiShowTool } from '../tools/ui-surface/definitions.js';
+} from "../daemon/ipc-protocol.js";
+import { INTERACTIVE_SURFACE_TYPES } from "../daemon/ipc-protocol.js";
+import { uiShowTool } from "../tools/ui-surface/definitions.js";
 
 // ---------------------------------------------------------------------------
 // DynamicPageSurfaceData shape
 // ---------------------------------------------------------------------------
 
-describe('DynamicPageSurfaceData shape', () => {
-  test('accepts an object with html, width, and height', () => {
+describe("DynamicPageSurfaceData shape", () => {
+  test("accepts an object with html, width, and height", () => {
     const data: DynamicPageSurfaceData = {
-      html: '<h1>Hi</h1>',
+      html: "<h1>Hi</h1>",
       width: 400,
       height: 300,
     };
 
-    expect(data.html).toBe('<h1>Hi</h1>');
+    expect(data.html).toBe("<h1>Hi</h1>");
     expect(data.width).toBe(400);
     expect(data.height).toBe(300);
   });
 
-  test('width and height are optional', () => {
+  test("width and height are optional", () => {
     const data: DynamicPageSurfaceData = {
-      html: '<p>Hello</p>',
+      html: "<p>Hello</p>",
     };
 
-    expect(data.html).toBe('<p>Hello</p>');
+    expect(data.html).toBe("<p>Hello</p>");
     expect(data.width).toBeUndefined();
     expect(data.height).toBeUndefined();
   });
@@ -41,8 +39,8 @@ describe('DynamicPageSurfaceData shape', () => {
 // Tool definition includes dynamic_page
 // ---------------------------------------------------------------------------
 
-describe('Tool definition includes dynamic_page', () => {
-  test('input_schema surface_type enum includes dynamic_page', () => {
+describe("Tool definition includes dynamic_page", () => {
+  test("input_schema surface_type enum includes dynamic_page", () => {
     const definition = uiShowTool.getDefinition();
     const surfaceTypeEnum = (
       definition.input_schema as {
@@ -50,12 +48,12 @@ describe('Tool definition includes dynamic_page', () => {
       }
     ).properties.surface_type.enum;
 
-    expect(surfaceTypeEnum).toContain('dynamic_page');
+    expect(surfaceTypeEnum).toContain("dynamic_page");
   });
 
-  test('description mentions dynamic_page', () => {
+  test("description mentions dynamic_page", () => {
     const definition = uiShowTool.getDefinition();
-    expect(definition.description).toContain('dynamic_page');
+    expect(definition.description).toContain("dynamic_page");
   });
 });
 
@@ -63,21 +61,21 @@ describe('Tool definition includes dynamic_page', () => {
 // UiSurfaceShowDynamicPage structure
 // ---------------------------------------------------------------------------
 
-describe('UiSurfaceShowDynamicPage structure', () => {
-  test('can construct a well-typed UiSurfaceShowDynamicPage object', () => {
+describe("UiSurfaceShowDynamicPage structure", () => {
+  test("can construct a well-typed UiSurfaceShowDynamicPage object", () => {
     const msg: UiSurfaceShowDynamicPage = {
-      type: 'ui_surface_show',
-      sessionId: 'session-abc',
-      surfaceId: 'surface-123',
-      surfaceType: 'dynamic_page',
-      data: { html: '<div>Content</div>' },
+      type: "ui_surface_show",
+      sessionId: "session-abc",
+      surfaceId: "surface-123",
+      surfaceType: "dynamic_page",
+      data: { html: "<div>Content</div>" },
     };
 
-    expect(msg.type).toBe('ui_surface_show');
-    expect(msg.surfaceType).toBe('dynamic_page');
-    expect(typeof msg.data.html).toBe('string');
-    expect(msg.sessionId).toBe('session-abc');
-    expect(msg.surfaceId).toBe('surface-123');
+    expect(msg.type).toBe("ui_surface_show");
+    expect(msg.surfaceType).toBe("dynamic_page");
+    expect(typeof msg.data.html).toBe("string");
+    expect(msg.sessionId).toBe("session-abc");
+    expect(msg.surfaceId).toBe("surface-123");
   });
 });
 
@@ -85,8 +83,8 @@ describe('UiSurfaceShowDynamicPage structure', () => {
 // Interactivity
 // ---------------------------------------------------------------------------
 
-describe('dynamic_page interactivity', () => {
-  test('dynamic_page is in the interactive surface types list', () => {
-    expect(INTERACTIVE_SURFACE_TYPES).toContain('dynamic_page');
+describe("dynamic_page interactivity", () => {
+  test("dynamic_page is in the interactive surface types list", () => {
+    expect(INTERACTIVE_SURFACE_TYPES).toContain("dynamic_page");
   });
 });