opengstack 0.13.6 → 0.13.8

package/skills/browse/test/cookie-picker-routes.test.ts

@@ -0,0 +1,260 @@
+/**
+ * Tests for cookie-picker route handler
+ *
+ * Tests the HTTP glue layer directly with mock BrowserManager objects.
+ * Verifies that all routes return valid JSON (not HTML) with correct CORS headers.
+ */
+
+import { describe, test, expect } from 'bun:test';
+import { handleCookiePickerRoute } from '../src/cookie-picker-routes';
+
+// ─── Mock BrowserManager ──────────────────────────────────────
+
+function mockBrowserManager() {
+  const addedCookies: any[] = [];
+  const clearedDomains: string[] = [];
+  return {
+    bm: {
+      getPage: () => ({
+        context: () => ({
+          addCookies: (cookies: any[]) => { addedCookies.push(...cookies); },
+          clearCookies: (opts: { domain: string }) => { clearedDomains.push(opts.domain); },
+        }),
+      }),
+    } as any,
+    addedCookies,
+    clearedDomains,
+  };
+}
+
+function makeUrl(path: string, port = 9470): URL {
+  return new URL(`http://127.0.0.1:${port}${path}`);
+}
+
+function makeReq(method: string, body?: any): Request {
+  const opts: RequestInit = { method };
+  if (body) {
+    opts.body = JSON.stringify(body);
+    opts.headers = { 'Content-Type': 'application/json' };
+  }
+  return new Request('http://127.0.0.1:9470', opts);
+}
+
+// ─── Tests ──────────────────────────────────────────────────────
+
+describe('cookie-picker-routes', () => {
+  describe('CORS', () => {
+    test('OPTIONS returns 204 with correct CORS headers', async () => {
+      const { bm } = mockBrowserManager();
+      const url = makeUrl('/cookie-picker/browsers');
+      const req = new Request('http://127.0.0.1:9470', { method: 'OPTIONS' });
+
+      const res = await handleCookiePickerRoute(url, req, bm);
+
+      expect(res.status).toBe(204);
+      expect(res.headers.get('Access-Control-Allow-Origin')).toBe('http://127.0.0.1:9470');
+      expect(res.headers.get('Access-Control-Allow-Methods')).toContain('POST');
+    });
+
+    test('JSON responses include correct CORS origin with port', async () => {
+      const { bm } = mockBrowserManager();
+      const url = makeUrl('/cookie-picker/browsers', 9450);
+      const req = new Request('http://127.0.0.1:9450', { method: 'GET' });
+
+      const res = await handleCookiePickerRoute(url, req, bm);
+
+      expect(res.headers.get('Access-Control-Allow-Origin')).toBe('http://127.0.0.1:9450');
+    });
+  });
+
+  describe('JSON responses (not HTML)', () => {
+    test('GET /cookie-picker/browsers returns JSON', async () => {
+      const { bm } = mockBrowserManager();
+      const url = makeUrl('/cookie-picker/browsers');
+      const req = new Request('http://127.0.0.1:9470', { method: 'GET' });
+
+      const res = await handleCookiePickerRoute(url, req, bm);
+
+      expect(res.status).toBe(200);
+      expect(res.headers.get('Content-Type')).toBe('application/json');
+      const body = await res.json();
+      expect(body).toHaveProperty('browsers');
+      expect(Array.isArray(body.browsers)).toBe(true);
+    });
+
+    test('GET /cookie-picker/domains without browser param returns JSON error', async () => {
+      const { bm } = mockBrowserManager();
+      const url = makeUrl('/cookie-picker/domains');
+      const req = new Request('http://127.0.0.1:9470', { method: 'GET' });
+
+      const res = await handleCookiePickerRoute(url, req, bm);
+
+      expect(res.status).toBe(400);
+      expect(res.headers.get('Content-Type')).toBe('application/json');
+      const body = await res.json();
+      expect(body).toHaveProperty('error');
+      expect(body).toHaveProperty('code', 'missing_param');
+    });
+
+    test('POST /cookie-picker/import with invalid JSON returns JSON error', async () => {
+      const { bm } = mockBrowserManager();
+      const url = makeUrl('/cookie-picker/import');
+      const req = new Request('http://127.0.0.1:9470', {
+        method: 'POST',
+        body: 'not json',
+        headers: { 'Content-Type': 'application/json' },
+      });
+
+      const res = await handleCookiePickerRoute(url, req, bm);
+
+      expect(res.status).toBe(400);
+      expect(res.headers.get('Content-Type')).toBe('application/json');
+      const body = await res.json();
+      expect(body.code).toBe('bad_request');
+    });
+
+    test('POST /cookie-picker/import missing browser field returns JSON error', async () => {
+      const { bm } = mockBrowserManager();
+      const url = makeUrl('/cookie-picker/import');
+      const req = makeReq('POST', { domains: ['.example.com'] });
+
+      const res = await handleCookiePickerRoute(url, req, bm);
+
+      expect(res.status).toBe(400);
+      const body = await res.json();
+      expect(body.code).toBe('missing_param');
+    });
+
+    test('POST /cookie-picker/import missing domains returns JSON error', async () => {
+      const { bm } = mockBrowserManager();
+      const url = makeUrl('/cookie-picker/import');
+      const req = makeReq('POST', { browser: 'Chrome' });
+
+      const res = await handleCookiePickerRoute(url, req, bm);
+
+      expect(res.status).toBe(400);
+      const body = await res.json();
+      expect(body.code).toBe('missing_param');
+    });
+
+    test('POST /cookie-picker/remove with invalid JSON returns JSON error', async () => {
+      const { bm } = mockBrowserManager();
+      const url = makeUrl('/cookie-picker/remove');
+      const req = new Request('http://127.0.0.1:9470', {
+        method: 'POST',
+        body: '{bad',
+        headers: { 'Content-Type': 'application/json' },
+      });
+
+      const res = await handleCookiePickerRoute(url, req, bm);
+
+      expect(res.status).toBe(400);
+      expect(res.headers.get('Content-Type')).toBe('application/json');
+    });
+
+    test('POST /cookie-picker/remove missing domains returns JSON error', async () => {
+      const { bm } = mockBrowserManager();
+      const url = makeUrl('/cookie-picker/remove');
+      const req = makeReq('POST', {});
+
+      const res = await handleCookiePickerRoute(url, req, bm);
+
+      expect(res.status).toBe(400);
+      const body = await res.json();
+      expect(body.code).toBe('missing_param');
+    });
+
+    test('GET /cookie-picker/imported returns JSON with domain list', async () => {
+      const { bm } = mockBrowserManager();
+      const url = makeUrl('/cookie-picker/imported');
+      const req = new Request('http://127.0.0.1:9470', { method: 'GET' });
+
+      const res = await handleCookiePickerRoute(url, req, bm);
+
+      expect(res.status).toBe(200);
+      expect(res.headers.get('Content-Type')).toBe('application/json');
+      const body = await res.json();
+      expect(body).toHaveProperty('domains');
+      expect(body).toHaveProperty('totalDomains');
+      expect(body).toHaveProperty('totalCookies');
+    });
+  });
+
+  describe('routing', () => {
+    test('GET /cookie-picker returns HTML', async () => {
+      const { bm } = mockBrowserManager();
+      const url = makeUrl('/cookie-picker');
+      const req = new Request('http://127.0.0.1:9470', { method: 'GET' });
+
+      const res = await handleCookiePickerRoute(url, req, bm);
+
+      expect(res.status).toBe(200);
+      expect(res.headers.get('Content-Type')).toContain('text/html');
+    });
+
+    test('unknown path returns 404', async () => {
+      const { bm } = mockBrowserManager();
+      const url = makeUrl('/cookie-picker/nonexistent');
+      const req = new Request('http://127.0.0.1:9470', { method: 'GET' });
+
+      const res = await handleCookiePickerRoute(url, req, bm);
+
+      expect(res.status).toBe(404);
+    });
+  });
+
+  describe('auth gate security', () => {
+    test('GET /cookie-picker HTML page works without auth token', async () => {
+      const { bm } = mockBrowserManager();
+      const url = makeUrl('/cookie-picker');
+      // Request with no Authorization header, but authToken is set on the server
+      const req = new Request('http://127.0.0.1:9470', { method: 'GET' });
+
+      const res = await handleCookiePickerRoute(url, req, bm, 'test-secret-token');
+
+      expect(res.status).toBe(200);
+      expect(res.headers.get('Content-Type')).toContain('text/html');
+    });
+
+    test('GET /cookie-picker/browsers returns 401 without auth', async () => {
+      const { bm } = mockBrowserManager();
+      const url = makeUrl('/cookie-picker/browsers');
+      // No Authorization header
+      const req = new Request('http://127.0.0.1:9470', { method: 'GET' });
+
+      const res = await handleCookiePickerRoute(url, req, bm, 'test-secret-token');
+
+      expect(res.status).toBe(401);
+      const body = await res.json();
+      expect(body.error).toBe('Unauthorized');
+    });
+
+    test('POST /cookie-picker/import returns 401 without auth', async () => {
+      const { bm } = mockBrowserManager();
+      const url = makeUrl('/cookie-picker/import');
+      const req = makeReq('POST', { browser: 'Chrome', domains: ['.example.com'] });
+
+      const res = await handleCookiePickerRoute(url, req, bm, 'test-secret-token');
+
+      expect(res.status).toBe(401);
+      const body = await res.json();
+      expect(body.error).toBe('Unauthorized');
+    });
+
+    test('GET /cookie-picker/browsers works with valid auth', async () => {
+      const { bm } = mockBrowserManager();
+      const url = makeUrl('/cookie-picker/browsers');
+      const req = new Request('http://127.0.0.1:9470', {
+        method: 'GET',
+        headers: { 'Authorization': 'Bearer test-secret-token' },
+      });
+
+      const res = await handleCookiePickerRoute(url, req, bm, 'test-secret-token');
+
+      expect(res.status).toBe(200);
+      expect(res.headers.get('Content-Type')).toBe('application/json');
+      const body = await res.json();
+      expect(body).toHaveProperty('browsers');
+    });
+  });
+});

package/skills/browse/test/file-drop.test.ts

@@ -0,0 +1,271 @@
+/**
+ * Tests for the inbox meta-command handler (file drop relay).
+ *
+ * Tests the inbox display, --clear flag, and edge cases by creating
+ * temp directories with test JSON files and calling handleMetaCommand.
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { handleMetaCommand } from '../src/meta-commands';
+import { BrowserManager } from '../src/browser-manager';
+
+let tmpDir: string;
+let bm: BrowserManager;
+
+// We need a BrowserManager instance for handleMetaCommand, but inbox
+// doesn't use it. We also need to mock git rev-parse to point to our
+// temp directory. We'll test the inbox logic directly by manipulating
+// the filesystem and using child_process.execSync override.
+
+// ─── Direct filesystem tests (bypassing handleMetaCommand) ──────
+// The inbox handler in meta-commands.ts calls `git rev-parse --show-toplevel`
+// to find the inbox directory. Since we can't easily mock that in unit tests,
+// we test the inbox parsing logic directly.
+
+interface InboxMessage {
+  timestamp: string;
+  url: string;
+  userMessage: string;
+}
+
+/** Replicate the inbox file reading logic from meta-commands.ts */
+function readInbox(inboxDir: string): InboxMessage[] {
+  if (!fs.existsSync(inboxDir)) return [];
+
+  const files = fs.readdirSync(inboxDir)
+    .filter(f => f.endsWith('.json') && !f.startsWith('.'))
+    .sort()
+    .reverse();
+
+  if (files.length === 0) return [];
+
+  const messages: InboxMessage[] = [];
+  for (const file of files) {
+    try {
+      const data = JSON.parse(fs.readFileSync(path.join(inboxDir, file), 'utf-8'));
+      messages.push({
+        timestamp: data.timestamp || '',
+        url: data.page?.url || 'unknown',
+        userMessage: data.userMessage || '',
+      });
+    } catch {
+      // Skip malformed files
+    }
+  }
+  return messages;
+}
+
+/** Replicate the inbox formatting logic from meta-commands.ts */
+function formatInbox(messages: InboxMessage[]): string {
+  if (messages.length === 0) return 'Inbox empty.';
+
+  const lines: string[] = [];
+  lines.push(`SIDEBAR INBOX (${messages.length} message${messages.length === 1 ? '' : 's'})`);
+  lines.push('────────────────────────────────');
+
+  for (const msg of messages) {
+    const ts = msg.timestamp ? `[${msg.timestamp}]` : '[unknown]';
+    lines.push(`${ts} ${msg.url}`);
+    lines.push(`  "${msg.userMessage}"`);
+    lines.push('');
+  }
+
+  lines.push('────────────────────────────────');
+  return lines.join('\n');
+}
+
+/** Replicate the --clear logic from meta-commands.ts */
+function clearInbox(inboxDir: string): number {
+  const files = fs.readdirSync(inboxDir)
+    .filter(f => f.endsWith('.json') && !f.startsWith('.'));
+  for (const file of files) {
+    try { fs.unlinkSync(path.join(inboxDir, file)); } catch {}
+  }
+  return files.length;
+}
+
+function writeTestInboxFile(
+  inboxDir: string,
+  message: string,
+  pageUrl: string,
+  timestamp: string,
+): string {
+  fs.mkdirSync(inboxDir, { recursive: true });
+  const filename = `${timestamp.replace(/:/g, '-')}-observation.json`;
+  const filePath = path.join(inboxDir, filename);
+  fs.writeFileSync(filePath, JSON.stringify({
+    type: 'observation',
+    timestamp,
+    page: { url: pageUrl, title: '' },
+    userMessage: message,
+    sidebarSessionId: 'test-session',
+  }, null, 2));
+  return filePath;
+}
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'file-drop-test-'));
+});
+
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+// ─── Empty Inbox ─────────────────────────────────────────────────
+
+describe('inbox — empty states', () => {
+  test('no .context/sidebar-inbox directory returns empty', () => {
+    const inboxDir = path.join(tmpDir, '.context', 'sidebar-inbox');
+    const messages = readInbox(inboxDir);
+    expect(messages.length).toBe(0);
+    expect(formatInbox(messages)).toBe('Inbox empty.');
+  });
+
+  test('empty inbox directory returns empty', () => {
+    const inboxDir = path.join(tmpDir, '.context', 'sidebar-inbox');
+    fs.mkdirSync(inboxDir, { recursive: true });
+    const messages = readInbox(inboxDir);
+    expect(messages.length).toBe(0);
+    expect(formatInbox(messages)).toBe('Inbox empty.');
+  });
+
+  test('directory with only dotfiles returns empty', () => {
+    const inboxDir = path.join(tmpDir, '.context', 'sidebar-inbox');
+    fs.mkdirSync(inboxDir, { recursive: true });
+    fs.writeFileSync(path.join(inboxDir, '.tmp-file.json'), '{}');
+    const messages = readInbox(inboxDir);
+    expect(messages.length).toBe(0);
+  });
+});
+
+// ─── Valid Messages ──────────────────────────────────────────────
+
+describe('inbox — valid messages', () => {
+  test('displays formatted output with timestamps and URLs', () => {
+    const inboxDir = path.join(tmpDir, '.context', 'sidebar-inbox');
+    writeTestInboxFile(inboxDir, 'This button is broken', 'https://example.com/page', '2024-06-15T10:30:00.000Z');
+    writeTestInboxFile(inboxDir, 'Login form fails', 'https://example.com/login', '2024-06-15T10:31:00.000Z');
+
+    const messages = readInbox(inboxDir);
+    expect(messages.length).toBe(2);
+
+    const output = formatInbox(messages);
+    expect(output).toContain('SIDEBAR INBOX (2 messages)');
+    expect(output).toContain('https://example.com/page');
+    expect(output).toContain('https://example.com/login');
+    expect(output).toContain('"This button is broken"');
+    expect(output).toContain('"Login form fails"');
+    expect(output).toContain('[2024-06-15T10:30:00.000Z]');
+    expect(output).toContain('[2024-06-15T10:31:00.000Z]');
+  });
+
+  test('single message uses singular form', () => {
+    const inboxDir = path.join(tmpDir, '.context', 'sidebar-inbox');
+    writeTestInboxFile(inboxDir, 'Just one', 'https://example.com', '2024-06-15T10:30:00.000Z');
+
+    const messages = readInbox(inboxDir);
+    const output = formatInbox(messages);
+    expect(output).toContain('1 message)');
+    expect(output).not.toContain('messages)');
+  });
+
+  test('messages sorted newest first', () => {
+    const inboxDir = path.join(tmpDir, '.context', 'sidebar-inbox');
+    writeTestInboxFile(inboxDir, 'older', 'https://example.com', '2024-06-15T10:00:00.000Z');
+    writeTestInboxFile(inboxDir, 'newer', 'https://example.com', '2024-06-15T11:00:00.000Z');
+
+    const messages = readInbox(inboxDir);
+    // Filenames sort lexicographically, reversed = newest first
+    expect(messages[0].userMessage).toBe('newer');
+    expect(messages[1].userMessage).toBe('older');
+  });
+});
+
+// ─── Malformed Files ─────────────────────────────────────────────
+
+describe('inbox — malformed files', () => {
+  test('malformed JSON files are skipped gracefully', () => {
+    const inboxDir = path.join(tmpDir, '.context', 'sidebar-inbox');
+    fs.mkdirSync(inboxDir, { recursive: true });
+
+    // Write a valid message
+    writeTestInboxFile(inboxDir, 'valid message', 'https://example.com', '2024-06-15T10:30:00.000Z');
+
+    // Write a malformed JSON file
+    fs.writeFileSync(
+      path.join(inboxDir, '2024-06-15T10-35-00.000Z-observation.json'),
+      'this is not valid json {{{',
+    );
+
+    const messages = readInbox(inboxDir);
+    expect(messages.length).toBe(1);
+    expect(messages[0].userMessage).toBe('valid message');
+  });
+
+  test('JSON file missing fields uses defaults', () => {
+    const inboxDir = path.join(tmpDir, '.context', 'sidebar-inbox');
+    fs.mkdirSync(inboxDir, { recursive: true });
+
+    // Write a JSON file with missing fields
+    fs.writeFileSync(
+      path.join(inboxDir, '2024-06-15T10-30-00.000Z-observation.json'),
+      JSON.stringify({ type: 'observation' }),
+    );
+
+    const messages = readInbox(inboxDir);
+    expect(messages.length).toBe(1);
+    expect(messages[0].timestamp).toBe('');
+    expect(messages[0].url).toBe('unknown');
+    expect(messages[0].userMessage).toBe('');
+  });
+});
+
+// ─── Clear Flag ──────────────────────────────────────────────────
+
+describe('inbox — --clear flag', () => {
+  test('files deleted after clear', () => {
+    const inboxDir = path.join(tmpDir, '.context', 'sidebar-inbox');
+    writeTestInboxFile(inboxDir, 'message 1', 'https://example.com', '2024-06-15T10:30:00.000Z');
+    writeTestInboxFile(inboxDir, 'message 2', 'https://example.com', '2024-06-15T10:31:00.000Z');
+
+    // Verify files exist
+    const filesBefore = fs.readdirSync(inboxDir).filter(f => f.endsWith('.json') && !f.startsWith('.'));
+    expect(filesBefore.length).toBe(2);
+
+    // Clear
+    const cleared = clearInbox(inboxDir);
+    expect(cleared).toBe(2);
+
+    // Verify files deleted
+    const filesAfter = fs.readdirSync(inboxDir).filter(f => f.endsWith('.json') && !f.startsWith('.'));
+    expect(filesAfter.length).toBe(0);
+  });
+
+  test('clear on empty directory does nothing', () => {
+    const inboxDir = path.join(tmpDir, '.context', 'sidebar-inbox');
+    fs.mkdirSync(inboxDir, { recursive: true });
+
+    const cleared = clearInbox(inboxDir);
+    expect(cleared).toBe(0);
+  });
+
+  test('clear preserves dotfiles', () => {
+    const inboxDir = path.join(tmpDir, '.context', 'sidebar-inbox');
+    fs.mkdirSync(inboxDir, { recursive: true });
+
+    // Write a dotfile and a regular file
+    fs.writeFileSync(path.join(inboxDir, '.keep'), '');
+    writeTestInboxFile(inboxDir, 'to be cleared', 'https://example.com', '2024-06-15T10:30:00.000Z');
+
+    clearInbox(inboxDir);
+
+    // Dotfile should remain
+    expect(fs.existsSync(path.join(inboxDir, '.keep'))).toBe(true);
+    // Regular file should be gone
+    const jsonFiles = fs.readdirSync(inboxDir).filter(f => f.endsWith('.json') && !f.startsWith('.'));
+    expect(jsonFiles.length).toBe(0);
+  });
+});

package/skills/browse/test/find-browse.test.ts

@@ -0,0 +1,50 @@
+/**
+ * Tests for find-browse binary locator.
+ */
+
+import { describe, test, expect } from 'bun:test';
+import { locateBinary } from '../src/find-browse';
+import { existsSync } from 'fs';
+
+describe('locateBinary', () => {
+  test('returns null when no binary exists at known paths', () => {
+    // This test depends on the test environment — if a real binary exists at
+    // ~/.claude/skills/gstack/browse/dist/browse, it will find it.
+    // We mainly test that the function doesn't throw.
+    const result = locateBinary();
+    expect(result === null || typeof result === 'string').toBe(true);
+  });
+
+  test('returns string path when binary exists', () => {
+    const result = locateBinary();
+    if (result !== null) {
+      expect(existsSync(result)).toBe(true);
+    }
+  });
+
+  test('priority chain checks .codex, .agents, .claude markers', () => {
+    // Verify the source code implements the correct priority order.
+    // We read the function source to confirm the markers array order.
+    const src = require('fs').readFileSync(require('path').join(__dirname, '../src/find-browse.ts'), 'utf-8');
+    // The markers array should list .codex first, then .agents, then .claude
+    const markersMatch = src.match(/const markers = \[([^\]]+)\]/);
+    expect(markersMatch).not.toBeNull();
+    const markers = markersMatch![1];
+    const codexIdx = markers.indexOf('.codex');
+    const agentsIdx = markers.indexOf('.agents');
+    const claudeIdx = markers.indexOf('.claude');
+    // All three must be present
+    expect(codexIdx).toBeGreaterThanOrEqual(0);
+    expect(agentsIdx).toBeGreaterThanOrEqual(0);
+    expect(claudeIdx).toBeGreaterThanOrEqual(0);
+    // .codex before .agents before .claude
+    expect(codexIdx).toBeLessThan(agentsIdx);
+    expect(agentsIdx).toBeLessThan(claudeIdx);
+  });
+
+  test('function signature accepts no arguments', () => {
+    // locateBinary should be callable with no arguments
+    expect(typeof locateBinary).toBe('function');
+    expect(locateBinary.length).toBe(0);
+  });
+});