@liquidmetal-ai/precip 1.0.0

package/src/sandbox/test-helper.ts

@@ -0,0 +1,43 @@
+/**
+ * Test helper that mimics deprecated executeWithAsyncHost API
+ *
+ * Uses Sandbox under the hood for consistency with production code.
+ * This helper exists solely for test compatibility and should NOT be used in production.
+ *
+ * @deprecated Use Sandbox.configure() + Sandbox.getInstance() + sandbox.execute() instead
+ */
+
+import { Sandbox } from './index.js';
+import type {
+  SandboxGlobals,
+  SandboxResult,
+  Logger
+} from '../types.js';
+import type { BridgeInstaller } from './bridges/types.js';
+
+/**
+ * Execute code in a sandbox (test compatibility layer)
+ *
+ * Ensures the sandbox is configured before executing.
+ *
+ * @deprecated Use Sandbox.configure() + Sandbox.getInstance() + sandbox.execute() instead
+ */
+export async function executeWithAsyncHost(
+  code: string,
+  asyncGlobals: SandboxGlobals,
+  options: {
+    timeoutMs?: number;
+    memoryLimitBytes?: number;
+    logger?: Logger;
+    bridgeInstallers?: BridgeInstaller[];
+  } = {}
+): Promise<SandboxResult> {
+  // In tests, configure if not already configured, otherwise just get the instance
+  let sandbox: Sandbox;
+  try {
+    sandbox = await Sandbox.getInstance();
+  } catch {
+    sandbox = await Sandbox.configure(options);
+  }
+  return sandbox.execute(code, asyncGlobals, options);
+}

package/src/sandbox/test-mocks.ts

@@ -0,0 +1,154 @@
+/**
+ * Test utilities for mocking fetch responses
+ *
+ * Provides mock implementations of fetch to avoid external network dependencies
+ */
+
+export interface MockFetchResponse {
+  status?: number;
+  statusText?: string;
+  headers?: Record<string, string>;
+  body?: string | Uint8Array;
+  delay?: number;
+}
+
+export class MockFetchError extends Error {
+  constructor(message: string, public status?: number) {
+    super(message);
+    this.name = 'MockFetchError';
+  }
+}
+
+/**
+ * Create a mock fetch implementation for testing
+ */
+export function createMockFetch(responses: Map<string, MockFetchResponse> = new Map()) {
+  return async function mockFetch(url: string, init?: RequestInit): Promise<Response> {
+    const urlKey = url.split('?')[0] ?? url; // Strip query params
+    const mock = responses.get(urlKey);
+
+    if (!mock) {
+      throw new MockFetchError(`No mock response configured for: ${urlKey}`, 404);
+    }
+
+    // Simulate delay if specified
+    if (mock.delay) {
+      await new Promise(resolve => setTimeout(resolve, mock.delay));
+    }
+
+    // Simulate abort
+    if (init?.signal) {
+      if (init.signal.aborted) {
+        throw new DOMException('Aborted', 'AbortError');
+      }
+    }
+
+    const rawBody = mock.body !== undefined ? mock.body : JSON.stringify({ mock: true });
+    const headers = new Headers(mock.headers);
+
+    if (typeof rawBody === 'string') {
+      headers.set('content-type', 'application/json');
+    }
+
+    // Convert Uint8Array to ArrayBuffer for Response compatibility
+    const body = rawBody instanceof Uint8Array ? rawBody.buffer as ArrayBuffer : rawBody;
+
+    return new Response(body, {
+      status: mock.status ?? 200,
+      statusText: mock.statusText ?? 'OK',
+      headers
+    });
+  };
+}
+
+/**
+ * Setup common mock responses for httpbin.org endpoints
+ */
+export function createHttpbinMocks(): Map<string, MockFetchResponse> {
+  const mocks = new Map<string, MockFetchResponse>();
+
+  // GET https://httpbin.org/get
+  mocks.set('https://httpbin.org/get', {
+    status: 200,
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      args: {},
+      url: 'https://httpbin.org/get',
+      headers: { 'User-Agent': 'Test' },
+      origin: '127.0.0.1'
+    })
+  });
+
+  // POST https://httpbin.org/uuid
+  mocks.set('https://httpbin.org/uuid', {
+    status: 200,
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      uuid: '550e8400-e29b-41d4-a716-446655440000'
+    })
+  });
+
+  // GET https://httpbin.org/json
+  mocks.set('https://httpbin.org/json', {
+    status: 200,
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      slideshow: { author: 'Test User' }
+    })
+  });
+
+  // GET https://httpbin.org/stream-bytes/N
+  mocks.set('https://httpbin.org/stream-bytes/10', {
+    status: 200,
+    headers: { 'content-type': 'application/octet-stream' },
+    body: new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+  });
+
+  mocks.set('https://httpbin.org/stream-bytes/50', {
+    status: 200,
+    headers: { 'content-type': 'application/octet-stream' },
+    body: new Uint8Array(Array.from({ length: 50 }, (_, i) => i % 256))
+  });
+
+  mocks.set('https://httpbin.org/stream-bytes/10000', {
+    status: 200,
+    headers: { 'content-type': 'application/octet-stream' },
+    body: new Uint8Array(Array.from({ length: 10000 }, (_, i) => i % 256))
+  });
+
+  // GET https://httpbin.org/delay/N
+  const createDelayMock = (delayMs: number): MockFetchResponse => ({
+    status: 200,
+    headers: { 'content-type': 'application/json' },
+    delay: delayMs,
+    body: JSON.stringify({ delay: delayMs })
+  });
+
+  mocks.set('https://httpbin.org/delay/5', createDelayMock(5000));
+  mocks.set('https://httpbin.org/delay/10', createDelayMock(10000));
+
+  return mocks;
+}
+
+/**
+ * Create a bridge installer that mocks fetch
+ */
+import type { BridgeInstaller } from './bridges/types.js';
+import { installFetch } from './bridges/fetch.js';
+
+export function createMockFetchBridgeInstaller(): BridgeInstaller {
+  const mockFetch = createMockFetch(createHttpbinMocks());
+
+  return (ctx) => {
+    installFetch(ctx);
+
+    // Replace global fetch with mock
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mockFetch as any;
+
+    // Return cleanup that restores original fetch
+    return () => {
+      globalThis.fetch = originalFetch;
+    };
+  };
+}

package/src/sandbox/user-stream.test.ts

@@ -0,0 +1,77 @@
+/**
+ * Test the exact user code that was failing
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { executeWithAsyncHost } from './test-helper.js';
+import { createHttpbinMocks } from './test-mocks.js';
+
+describe('User Stream Test', () => {
+  let mockFetch: any;
+
+  beforeEach(() => {
+    const mocks = createHttpbinMocks();
+    mockFetch = vi.fn(async (url: string, _init?: RequestInit) => {
+      const urlKey = url.split('?')[0];
+      const mock = mocks.get(urlKey);
+      if (!mock) {
+        throw new Error(`No mock for: ${urlKey}`);
+      }
+      if (mock.delay) {
+        await new Promise(resolve => setTimeout(resolve, mock.delay));
+      }
+      return new Response(mock.body, {
+        status: mock.status ?? 200,
+        statusText: mock.statusText ?? 'OK',
+        headers: new Headers(mock.headers)
+      });
+    });
+    globalThis.fetch = mockFetch;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should handle streaming response with TextDecoder', async () => {
+    const code = `
+      async function main() {
+        const res = await fetch('https://httpbin.org/get');
+
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let result = '';
+
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          const text = decoder.decode(value, { stream: true });
+          result += text;
+        }
+
+        return {
+          status: res.status,
+          headers: Object.fromEntries(res.headers.entries()),
+          body: result
+        };
+      }
+
+      return await main();
+    `;
+
+    const result = await executeWithAsyncHost(
+      code,
+      {},
+      {
+        timeoutMs: 10000
+      }
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.result.status).toBe(200);
+    expect(mockFetch).toHaveBeenCalledWith('https://httpbin.org/get', expect.objectContaining({
+      signal: expect.any(AbortSignal)
+    }));
+    expect(Object.keys(result.result.headers).length).toBeGreaterThan(0);
+  });
+});

package/src/skills/frontmatter.test.ts

@@ -0,0 +1,305 @@
+/**
+ * Tests for YAML frontmatter parser
+ */
+
+import { describe, it, expect } from 'vitest';
+import { parseFrontmatter } from './frontmatter.js';
+
+describe('parseFrontmatter', () => {
+  it('should parse basic frontmatter with required fields', () => {
+    const content = `---
+name: data-cleanup
+description: Normalize and deduplicate data across tables.
+---
+
+# Data Cleanup Skill
+
+Instructions here...`;
+
+    const result = parseFrontmatter(content);
+    expect(result).not.toBeNull();
+    expect(result!.name).toBe('data-cleanup');
+    expect(result!.description).toBe('Normalize and deduplicate data across tables.');
+  });
+
+  it('should parse frontmatter with all optional fields', () => {
+    const content = `---
+name: pdf-processing
+description: Extracts text and tables from PDF files, fills forms, merges documents.
+license: Apache-2.0
+compatibility: Requires poppler and ghostscript
+allowed-tools: Bash(pdftotext:*) Read
+metadata:
+  author: example-org
+  version: "1.0"
+---
+
+# PDF Processing`;
+
+    const result = parseFrontmatter(content);
+    expect(result).not.toBeNull();
+    expect(result!.name).toBe('pdf-processing');
+    expect(result!.description).toBe(
+      'Extracts text and tables from PDF files, fills forms, merges documents.'
+    );
+    expect(result!.license).toBe('Apache-2.0');
+    expect(result!.compatibility).toBe('Requires poppler and ghostscript');
+    expect(result!.allowedTools).toBe('Bash(pdftotext:*) Read');
+    expect(result!.metadata).toEqual({ author: 'example-org', version: '1.0' });
+  });
+
+  it('should return null for content without frontmatter', () => {
+    const content = `# Just a Markdown File
+
+No frontmatter here.`;
+
+    expect(parseFrontmatter(content)).toBeNull();
+  });
+
+  it('should return null for unclosed frontmatter', () => {
+    const content = `---
+name: broken
+description: No closing delimiter`;
+
+    expect(parseFrontmatter(content)).toBeNull();
+  });
+
+  it('should return null for frontmatter missing required name', () => {
+    const content = `---
+description: Has description but no name
+---`;
+
+    expect(parseFrontmatter(content)).toBeNull();
+  });
+
+  it('should return null for frontmatter missing required description', () => {
+    const content = `---
+name: has-name
+---`;
+
+    expect(parseFrontmatter(content)).toBeNull();
+  });
+
+  it('should handle quoted values', () => {
+    const content = `---
+name: my-skill
+description: "A skill with quoted description"
+---`;
+
+    const result = parseFrontmatter(content);
+    expect(result).not.toBeNull();
+    expect(result!.description).toBe('A skill with quoted description');
+  });
+
+  it('should handle single-quoted values', () => {
+    const content = `---
+name: my-skill
+description: 'Single quoted description'
+---`;
+
+    const result = parseFrontmatter(content);
+    expect(result).not.toBeNull();
+    expect(result!.description).toBe('Single quoted description');
+  });
+
+  it('should skip comments in frontmatter', () => {
+    const content = `---
+# This is a comment
+name: my-skill
+description: A skill
+# Another comment
+---`;
+
+    const result = parseFrontmatter(content);
+    expect(result).not.toBeNull();
+    expect(result!.name).toBe('my-skill');
+  });
+
+  it('should skip empty lines in frontmatter', () => {
+    const content = `---
+name: my-skill
+
+description: A skill
+
+---`;
+
+    const result = parseFrontmatter(content);
+    expect(result).not.toBeNull();
+    expect(result!.name).toBe('my-skill');
+    expect(result!.description).toBe('A skill');
+  });
+
+  it('should handle metadata with tab indentation', () => {
+    const content = `---
+name: my-skill
+description: A skill
+metadata:
+\tauthor: test-org
+\tversion: "2.0"
+---`;
+
+    const result = parseFrontmatter(content);
+    expect(result).not.toBeNull();
+    expect(result!.metadata).toEqual({ author: 'test-org', version: '2.0' });
+  });
+});
+
+describe('parseFrontmatter — block scalars', () => {
+  it('should join folded scalar (>) lines with spaces', () => {
+    const content = `---
+name: my-skill
+description: >
+  This is a long
+  description that
+  spans multiple lines.
+---
+
+# Skill`;
+
+    const result = parseFrontmatter(content);
+    expect(result).not.toBeNull();
+    expect(result!.description).toBe(
+      'This is a long description that spans multiple lines.'
+    );
+  });
+
+  it('should preserve newlines in literal scalar (|)', () => {
+    const content = `---
+name: my-skill
+description: |
+  Line one.
+  Line two.
+  Line three.
+---
+
+# Skill`;
+
+    const result = parseFrontmatter(content);
+    expect(result).not.toBeNull();
+    expect(result!.description).toBe('Line one.\nLine two.\nLine three.');
+  });
+
+  it('should handle mixed single-line and block scalar fields', () => {
+    const content = `---
+name: mixed-skill
+description: >
+  A multi-line
+  folded description.
+license: MIT
+compatibility: |
+  Requires Node 18+
+  and npm 9+
+---
+
+# Mixed`;
+
+    const result = parseFrontmatter(content);
+    expect(result).not.toBeNull();
+    expect(result!.name).toBe('mixed-skill');
+    expect(result!.description).toBe('A multi-line folded description.');
+    expect(result!.license).toBe('MIT');
+    expect(result!.compatibility).toBe('Requires Node 18+\nand npm 9+');
+  });
+
+  it('should still parse existing single-line frontmatter unchanged', () => {
+    const content = `---
+name: simple
+description: A simple single-line description.
+license: Apache-2.0
+---`;
+
+    const result = parseFrontmatter(content);
+    expect(result).not.toBeNull();
+    expect(result!.name).toBe('simple');
+    expect(result!.description).toBe('A simple single-line description.');
+    expect(result!.license).toBe('Apache-2.0');
+  });
+
+  it('should preserve empty lines within a literal block scalar', () => {
+    const content = `---
+name: my-skill
+description: |
+  First paragraph.
+
+  Second paragraph.
+---`;
+
+    const result = parseFrontmatter(content);
+    expect(result).not.toBeNull();
+    expect(result!.description).toBe('First paragraph.\n\nSecond paragraph.');
+  });
+
+  it('should treat empty lines in folded scalar as paragraph breaks', () => {
+    const content = `---
+name: my-skill
+description: >
+  First paragraph
+  continues here.
+
+  Second paragraph
+  also continues.
+---`;
+
+    const result = parseFrontmatter(content);
+    expect(result).not.toBeNull();
+    expect(result!.description).toBe(
+      'First paragraph continues here.\n\nSecond paragraph also continues.'
+    );
+  });
+
+  it('should handle a block scalar with only one indented line', () => {
+    const content = `---
+name: my-skill
+description: >
+  Just one line.
+---`;
+
+    const result = parseFrontmatter(content);
+    expect(result).not.toBeNull();
+    expect(result!.description).toBe('Just one line.');
+  });
+
+  it('should handle literal scalar with only one indented line', () => {
+    const content = `---
+name: my-skill
+description: |
+  Single literal line.
+---`;
+
+    const result = parseFrontmatter(content);
+    expect(result).not.toBeNull();
+    expect(result!.description).toBe('Single literal line.');
+  });
+
+  it('should work with block scalar followed by metadata', () => {
+    const content = `---
+name: my-skill
+description: >
+  A folded
+  description here.
+metadata:
+  author: test-org
+  version: "1.0"
+---`;
+
+    const result = parseFrontmatter(content);
+    expect(result).not.toBeNull();
+    expect(result!.description).toBe('A folded description here.');
+    expect(result!.metadata).toEqual({ author: 'test-org', version: '1.0' });
+  });
+
+  it('should handle block scalar with tab-indented content', () => {
+    const content = `---
+name: my-skill
+description: |
+\tTab indented line one.
+\tTab indented line two.
+---`;
+
+    const result = parseFrontmatter(content);
+    expect(result).not.toBeNull();
+    expect(result!.description).toBe(
+      'Tab indented line one.\nTab indented line two.'
+    );
+  });
+});