@vibelet/cli 0.1.37 → 1.0.0

package/src/test-daemon-harness.ts

@@ -1,410 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

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