@vibelet/cli 0.1.34 → 0.1.36

package/src/test-daemon-harness.ts

@@ -0,0 +1,410 @@
+import assert from 'node:assert/strict';
+import { spawn, type ChildProcess } from 'node:child_process';
+import { chmodSync, existsSync, rmSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import { createServer, Socket } from 'node:net';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import WebSocket from 'ws';
+
+const require = createRequire(import.meta.url);
+const srcDir = path.dirname(fileURLToPath(import.meta.url));
+const daemonDir = path.resolve(srcDir, '..');
+const tsxPackageJsonPath = require.resolve('tsx/package.json');
+const tsxCliPath = path.resolve(path.dirname(tsxPackageJsonPath), 'dist/cli.mjs');
+
+export interface SpawnedDaemon {
+  child: ChildProcess;
+  port: number;
+  homeDir: string;
+  token: string;
+  getStdout: () => string;
+  getStderr: () => string;
+}
+
+export async function getFreePort(): Promise<number> {
+  const server = createServer();
+  server.listen(0, '127.0.0.1');
+  await new Promise<void>((resolve) => server.once('listening', () => resolve()));
+  const address = server.address();
+  assert.ok(address && typeof address === 'object');
+  const { port } = address;
+  await new Promise<void>((resolve, reject) => {
+    server.close((error) => (error ? reject(error) : resolve()));
+  });
+  return port;
+}
+
+export async function spawnDaemon(options: {
+  port?: number;
+  token?: string;
+  useFakeClaudeCli?: boolean;
+  env?: Record<string, string>;
+} = {}): Promise<SpawnedDaemon> {
+  const port = options.port ?? await getFreePort();
+  const token = options.token ?? 'test-token';
+  const homeDir = mkdtempSync(path.join(tmpdir(), 'vibelet-daemon-entry-'));
+  const fakeClaudeCliPath = options.useFakeClaudeCli ? createFakeClaudeCli(homeDir) : undefined;
+  let stdout = '';
+  let stderr = '';
+
+  const child = spawn(process.execPath, [tsxCliPath, 'src/index.ts'], {
+    cwd: daemonDir,
+    env: {
+      ...process.env,
+      HOME: homeDir,
+      VIBE_TEST: '0',
+      VIBE_PORT: String(port),
+      VIBE_TOKEN: token,
+      CLAUDE_PATH: fakeClaudeCliPath ?? process.execPath,
+      CODEX_PATH: process.execPath,
+      VIBE_FAKE_CLAUDE_HOME: homeDir,
+      ...options.env,
+    },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  child.stdout?.setEncoding('utf8');
+  child.stdout?.on('data', (chunk) => {
+    stdout += chunk;
+  });
+  child.stderr?.setEncoding('utf8');
+  child.stderr?.on('data', (chunk) => {
+    stderr += chunk;
+  });
+
+  await waitForPortState(port, true, 15_000);
+  await waitForHealth(port, 15_000);
+
+  return {
+    child,
+    port,
+    homeDir,
+    token,
+    getStdout: () => stdout,
+    getStderr: () => stderr,
+  };
+}
+
+export async function cleanupDaemon(daemon: SpawnedDaemon): Promise<void> {
+  const { child, port, homeDir } = daemon;
+  if (child.exitCode === null && child.signalCode === null) {
+    child.kill('SIGTERM');
+    try {
+      await waitForExit(child, 5_000);
+    } catch {}
+  }
+  await waitForPortState(port, false, 5_000).catch(() => {});
+  rmSync(homeDir, { recursive: true, force: true });
+}
+
+export async function waitForHealth(port: number, timeoutMs = 10_000): Promise<Record<string, unknown>> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${port}/health`);
+      if (response.ok) {
+        return await response.json() as Record<string, unknown>;
+      }
+    } catch {}
+    await delay(150);
+  }
+  throw new Error(`Timed out waiting for health on port ${port}`);
+}
+
+export async function openWebSocket(url: string): Promise<WebSocket> {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(url);
+    const timer = setTimeout(() => {
+      ws.terminate();
+      reject(new Error(`Timed out waiting for websocket open: ${url}`));
+    }, 5_000);
+
+    ws.once('open', () => {
+      clearTimeout(timer);
+      resolve(ws);
+    });
+    ws.once('error', (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    ws.once('close', (code, reason) => {
+      clearTimeout(timer);
+      reject(new Error(`WebSocket closed before opening (${code}): ${reason.toString()}`));
+    });
+  });
+}
+
+export async function waitForWebSocketMessage(
+  ws: WebSocket,
+  predicate: (message: Record<string, unknown>) => boolean,
+  timeoutMs = 5_000,
+): Promise<Record<string, unknown>> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      ws.off('message', onMessage);
+      reject(new Error('Timed out waiting for websocket message'));
+    }, timeoutMs);
+
+    const onMessage = (data: WebSocket.Data) => {
+      const message = JSON.parse(data.toString()) as Record<string, unknown>;
+      if (predicate(message)) {
+        clearTimeout(timer);
+        ws.off('message', onMessage);
+        resolve(message);
+      }
+    };
+
+    ws.on('message', onMessage);
+  });
+}
+
+export async function waitForWebSocketClose(ws: WebSocket, timeoutMs = 5_000): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      ws.terminate();
+      reject(new Error('Timed out waiting for websocket close'));
+    }, timeoutMs);
+
+    ws.once('close', (code) => {
+      clearTimeout(timer);
+      resolve(code);
+    });
+  });
+}
+
+export interface WebSocketRecorder {
+  messages: Array<Record<string, unknown>>;
+  waitFor: (
+    predicate: (message: Record<string, unknown>) => boolean,
+    timeoutMs?: number,
+  ) => Promise<Record<string, unknown>>;
+  stop: () => void;
+}
+
+export function createWebSocketRecorder(ws: WebSocket): WebSocketRecorder {
+  const messages: Array<Record<string, unknown>> = [];
+  const waiters = new Set<{
+    predicate: (message: Record<string, unknown>) => boolean;
+    resolve: (message: Record<string, unknown>) => void;
+    reject: (error: Error) => void;
+    timer: ReturnType<typeof setTimeout>;
+  }>();
+
+  const finishWaiter = (
+    waiter: {
+      predicate: (message: Record<string, unknown>) => boolean;
+      resolve: (message: Record<string, unknown>) => void;
+      reject: (error: Error) => void;
+      timer: ReturnType<typeof setTimeout>;
+    },
+    error?: Error,
+    message?: Record<string, unknown>,
+  ) => {
+    clearTimeout(waiter.timer);
+    waiters.delete(waiter);
+    if (error) {
+      waiter.reject(error);
+      return;
+    }
+    waiter.resolve(message as Record<string, unknown>);
+  };
+
+  const onMessage = (data: WebSocket.Data) => {
+    const message = JSON.parse(data.toString()) as Record<string, unknown>;
+    messages.push(message);
+    for (const waiter of [...waiters]) {
+      if (waiter.predicate(message)) {
+        finishWaiter(waiter, undefined, message);
+      }
+    }
+  };
+
+  ws.on('message', onMessage);
+
+  return {
+    messages,
+    waitFor(predicate, timeoutMs = 5_000) {
+      const existing = messages.find(predicate);
+      if (existing) {
+        return Promise.resolve(existing);
+      }
+      return new Promise((resolve, reject) => {
+        const waiter = {
+          predicate,
+          resolve,
+          reject,
+          timer: setTimeout(() => {
+            finishWaiter(waiter, new Error('Timed out waiting for recorded websocket message'));
+          }, timeoutMs),
+        };
+        waiters.add(waiter);
+      });
+    },
+    stop() {
+      ws.off('message', onMessage);
+      for (const waiter of [...waiters]) {
+        finishWaiter(waiter, new Error('Recorder stopped'));
+      }
+    },
+  };
+}
+
+export async function readAuditLog(homeDir: string, timeoutMs = 5_000): Promise<string> {
+  const auditPath = path.join(homeDir, '.vibelet', 'data', 'audit.jsonl');
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (existsSync(auditPath)) {
+      return readFileSync(auditPath, 'utf8');
+    }
+    await delay(100);
+  }
+  throw new Error(`Timed out waiting for audit log at ${auditPath}`);
+}
+
+export async function waitForStdout(
+  daemon: SpawnedDaemon,
+  pattern: RegExp,
+  timeoutMs = 5_000,
+): Promise<string> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const stdout = daemon.getStdout();
+    if (pattern.test(stdout)) {
+      return stdout;
+    }
+    await delay(100);
+  }
+  throw new Error(`Timed out waiting for stdout pattern ${pattern}`);
+}
+
+async function waitForExit(child: ChildProcess, timeoutMs: number): Promise<void> {
+  if (child.exitCode !== null || child.signalCode !== null) return;
+
+  await new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error('Timed out waiting for daemon to exit.')), timeoutMs);
+    child.once('exit', () => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+}
+
+async function isPortListening(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const socket = new Socket();
+
+    const finish = (result: boolean) => {
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve(result);
+    };
+
+    socket.setTimeout(200);
+    socket.once('connect', () => finish(true));
+    socket.once('timeout', () => finish(false));
+    socket.once('error', () => finish(false));
+    socket.connect(port, '127.0.0.1');
+  });
+}
+
+async function waitForPortState(port: number, expectedListening: boolean, timeoutMs: number): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if ((await isPortListening(port)) === expectedListening) {
+      return;
+    }
+    await delay(100);
+  }
+
+  throw new Error(`Timed out waiting for port ${port} to become ${expectedListening ? 'open' : 'closed'}.`);
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function createFakeClaudeCli(homeDir: string): string {
+  const scriptPath = path.join(homeDir, 'fake-claude.mjs');
+  writeFileSync(scriptPath, `#!/usr/bin/env node
+import { appendFileSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+function readArg(name) {
+  const index = process.argv.indexOf(name);
+  return index >= 0 ? process.argv[index + 1] ?? '' : '';
+}
+
+function encodeCwd(cwd) {
+  return cwd.replace(/[^a-zA-Z0-9]/g, '-');
+}
+
+function emit(payload) {
+  process.stdout.write(JSON.stringify(payload) + '\\n');
+}
+
+function appendJsonl(filePath, payload) {
+  appendFileSync(filePath, JSON.stringify(payload) + '\\n');
+}
+
+const prompt = readArg('-p');
+const resumeId = readArg('--resume');
+const cwd = process.cwd();
+const transcriptHome = process.env.VIBE_FAKE_CLAUDE_HOME || process.env.HOME || cwd;
+const sessionId = resumeId || 'fake-claude-' + randomUUID();
+const responseText = 'fake claude reply: ' + prompt;
+const projectDir = path.join(transcriptHome, '.claude', 'projects', encodeCwd(cwd));
+const transcriptPath = path.join(projectDir, sessionId + '.jsonl');
+
+mkdirSync(projectDir, { recursive: true });
+
+appendJsonl(transcriptPath, {
+  type: 'user',
+  cwd,
+  sessionId,
+  message: {
+    role: 'user',
+    content: [{ type: 'text', text: prompt }],
+  },
+});
+
+emit({ type: 'system', subtype: 'init', session_id: sessionId });
+
+for (const chunk of responseText.match(/.{1,10}/g) ?? []) {
+  emit({
+    type: 'stream_event',
+    event: {
+      type: 'content_block_delta',
+      delta: {
+        type: 'text_delta',
+        text: chunk,
+      },
+    },
+  });
+}
+
+appendJsonl(transcriptPath, {
+  type: 'assistant',
+  cwd,
+  sessionId,
+  message: {
+    role: 'assistant',
+    content: [{ type: 'text', text: responseText }],
+  },
+});
+
+emit({
+  type: 'result',
+  result: responseText,
+  total_cost_usd: 0,
+  usage: {
+    input_tokens: prompt.length,
+    output_tokens: responseText.length,
+  },
+});
+`, 'utf8');
+  chmodSync(scriptPath, 0o755);
+  return scriptPath;
+}

package/src/token-auth.test.ts

@@ -0,0 +1,67 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  isAuthorizedToken,
+  isLegacyToken,
+  isLoopbackAddress,
+  readBearerToken,
+  resolveRequestToken,
+} from './auth.js';
+
+test('isLoopbackAddress accepts IPv4 and IPv6 loopback addresses', () => {
+  assert.equal(isLoopbackAddress('127.0.0.1'), true);
+  assert.equal(isLoopbackAddress('::1'), true);
+  assert.equal(isLoopbackAddress('::ffff:127.0.0.1'), true);
+});
+
+test('isLoopbackAddress rejects non-loopback addresses', () => {
+  assert.equal(isLoopbackAddress('192.168.1.10'), false);
+  assert.equal(isLoopbackAddress(undefined), false);
+});
+
+test('readBearerToken parses bearer authorization header values', () => {
+  assert.equal(readBearerToken('Bearer abc123'), 'abc123');
+  assert.equal(readBearerToken('bearer abc123'), 'abc123');
+});
+
+test('readBearerToken returns null for missing or malformed headers', () => {
+  assert.equal(readBearerToken(undefined), null);
+  assert.equal(readBearerToken('Basic abc123'), null);
+});
+
+test('resolveRequestToken prefers Authorization bearer token over query token', () => {
+  assert.equal(resolveRequestToken('Bearer header-token', 'query-token'), 'header-token');
+  assert.equal(resolveRequestToken(undefined, 'query-token'), 'query-token');
+  assert.equal(resolveRequestToken(undefined, null), null);
+});
+
+test('isLegacyToken matches only when both token and configured legacy token are present', () => {
+  assert.equal(isLegacyToken('legacy', 'legacy'), true);
+  assert.equal(isLegacyToken('legacy', ''), false);
+  assert.equal(isLegacyToken(null, 'legacy'), false);
+});
+
+test('isAuthorizedToken accepts the configured legacy token without consulting pairings', () => {
+  let called = false;
+  assert.equal(isAuthorizedToken('legacy', 'legacy', () => {
+    called = true;
+    return false;
+  }), true);
+  assert.equal(called, false);
+});
+
+test('isAuthorizedToken falls back to pair-token validation for non-legacy tokens', () => {
+  const calls: Array<{ token: string; touch: boolean | undefined }> = [];
+  const authorized = isAuthorizedToken('pair-token', 'legacy', (token, touch) => {
+    calls.push({ token, touch });
+    return token === 'pair-token';
+  }, false);
+
+  assert.equal(authorized, true);
+  assert.deepEqual(calls, [{ token: 'pair-token', touch: false }]);
+});
+
+test('isAuthorizedToken rejects missing or invalid tokens', () => {
+  assert.equal(isAuthorizedToken(null, 'legacy', () => true), false);
+  assert.equal(isAuthorizedToken('wrong', 'legacy', () => false), false);
+});

package/src/utils.test.ts

@@ -0,0 +1,65 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { homedir } from 'os';
+import { join, resolve } from 'path';
+import { expandPath, normalizeFileRequestPath, resolveFileRequestPath } from './utils.js';
+
+test('expandPath: returns absolute paths unchanged', () => {
+  assert.equal(expandPath('/usr/local/bin'), '/usr/local/bin');
+  assert.equal(expandPath('/Volumes/T5/project'), '/Volumes/T5/project');
+});
+
+test('expandPath: expands ~ to home directory', () => {
+  const home = homedir();
+  assert.equal(expandPath('~/projects'), join(home, 'projects'));
+  assert.equal(expandPath('~/a/b/c'), join(home, 'a/b/c'));
+});
+
+test('expandPath: expands standalone ~', () => {
+  assert.equal(expandPath('~'), homedir());
+});
+
+test('expandPath: expands fullwidth ～ to home directory', () => {
+  const home = homedir();
+  assert.equal(expandPath('～/projects'), join(home, 'projects'));
+  assert.equal(expandPath('～'), homedir());
+});
+
+test('expandPath: does not expand ~ in the middle of path', () => {
+  assert.equal(expandPath('/some/~/path'), '/some/~/path');
+});
+
+test('expandPath: returns empty string unchanged', () => {
+  assert.equal(expandPath(''), '');
+});
+
+test('expandPath: returns relative paths unchanged', () => {
+  assert.equal(expandPath('relative/path'), 'relative/path');
+  assert.equal(expandPath('Volumes/T5/project'), 'Volumes/T5/project');
+});
+
+test('normalizeFileRequestPath: strips local file location suffixes', () => {
+  assert.equal(normalizeFileRequestPath('/tmp/hello.md#L12'), '/tmp/hello.md');
+  assert.equal(normalizeFileRequestPath('/tmp/hello.md:12:3'), '/tmp/hello.md');
+  assert.equal(normalizeFileRequestPath('./README.md:9'), './README.md');
+});
+
+test('resolveFileRequestPath: keeps absolute paths unchanged', () => {
+  assert.equal(resolveFileRequestPath('/tmp/hello.md', '/repo'), '/tmp/hello.md');
+  assert.equal(resolveFileRequestPath('/tmp/hello.md#L12', '/repo'), '/tmp/hello.md');
+});
+
+test('resolveFileRequestPath: resolves relative paths against cwd', () => {
+  assert.equal(resolveFileRequestPath('docs/plan.md', '/repo/project'), resolve('/repo/project', 'docs/plan.md'));
+  assert.equal(resolveFileRequestPath('./README.md', '/repo/project'), resolve('/repo/project', './README.md'));
+  assert.equal(resolveFileRequestPath('./README.md:12', '/repo/project'), resolve('/repo/project', './README.md'));
+});
+
+test('resolveFileRequestPath: expands tilde cwd before resolving', () => {
+  const home = homedir();
+  assert.equal(resolveFileRequestPath('notes/today.md', '~/workspace'), resolve(join(home, 'workspace'), 'notes/today.md'));
+});
+
+test('resolveFileRequestPath: returns relative path unchanged when cwd is missing', () => {
+  assert.equal(resolveFileRequestPath('docs/plan.md'), 'docs/plan.md');
+});

package/src/utils.ts

@@ -0,0 +1,47 @@
+import { isAbsolute, join, resolve } from 'path';
+import { homedir } from 'os';
+
+export function expandPath(p: string): string {
+  // Handle both normal ~ and fullwidth ～
+  p = p.replace(/^～/, '~');
+  if (p.startsWith('~/') || p === '~') {
+    return join(homedir(), p.slice(2));
+  }
+  return p;
+}
+
+export function normalizeFileRequestPath(path: string): string {
+  let normalized = path.trim();
+  if (!normalized) {
+    return '';
+  }
+
+  const hashIndex = normalized.indexOf('#');
+  if (hashIndex > 0) {
+    normalized = normalized.slice(0, hashIndex);
+  }
+
+  const locationMatch = normalized.match(/^(.*?)(:\d+(?::\d+)?)$/);
+  if (locationMatch) {
+    normalized = locationMatch[1] ?? normalized;
+  }
+
+  return normalized;
+}
+
+export function resolveFileRequestPath(path: string, cwd?: string): string {
+  const expandedPath = expandPath(normalizeFileRequestPath(path));
+  if (!expandedPath) {
+    return expandedPath;
+  }
+  if (isAbsolute(expandedPath)) {
+    return expandedPath;
+  }
+
+  const expandedCwd = expandPath(cwd ?? '');
+  if (!expandedCwd) {
+    return expandedPath;
+  }
+
+  return resolve(expandedCwd, expandedPath);
+}

package/src/ws-data.test.ts

@@ -0,0 +1,20 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readRawDataAsText } from './ws-data.js';
+
+test('readRawDataAsText returns string data unchanged', () => {
+  assert.equal(readRawDataAsText('{"ok":true}'), '{"ok":true}');
+});
+
+test('readRawDataAsText decodes Buffer data', () => {
+  assert.equal(readRawDataAsText(Buffer.from('{"ok":true}', 'utf8')), '{"ok":true}');
+});
+
+test('readRawDataAsText decodes ArrayBuffer data', () => {
+  const data = new TextEncoder().encode('{"ok":true}').buffer;
+  assert.equal(readRawDataAsText(data), '{"ok":true}');
+});
+
+test('readRawDataAsText decodes Buffer array payloads', () => {
+  assert.equal(readRawDataAsText([Buffer.from('{"ok":'), Buffer.from('true}')]), '{"ok":true}');
+});

package/src/ws-data.ts

@@ -0,0 +1,26 @@
+type WebSocketRawTextData = string | Buffer | ArrayBuffer | ArrayBufferView | Buffer[];
+
+export function readRawDataAsText(data: WebSocketRawTextData): string {
+  if (typeof data === 'string') {
+    return data;
+  }
+
+  if (Buffer.isBuffer(data)) {
+    return data.toString('utf8');
+  }
+
+  if (Array.isArray(data)) {
+    return Buffer.concat(data).toString('utf8');
+  }
+
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(data).toString('utf8');
+  }
+
+  if (ArrayBuffer.isView(data)) {
+    const view = data as ArrayBufferView;
+    return Buffer.from(view.buffer, view.byteOffset, view.byteLength).toString('utf8');
+  }
+
+  return String(data);
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@vibelet/shared": ["../../packages/shared/dist/types"]
+    },
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}