@vibelet/cli 0.1.38 → 1.0.0

package/src/claude-hooks.ts

@@ -1,195 +0,0 @@
-import { mkdirSync, rmSync, writeFileSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { randomUUID } from 'crypto';
-
-export const CLAUDE_HOOK_APPROVAL_PREFIX = 'claude-hook:';
-export const CLAUDE_HOOK_SECRET_HEADER = 'x-vibelet-claude-hook-secret';
-
-export type ClaudeSessionHookData = {
-  session_id?: string;
-  sessionId?: string;
-  transcript_path?: string;
-  transcriptPath?: string;
-  cwd?: string;
-  hook_event_name?: string;
-  hookEventName?: string;
-  source?: string;
-  [key: string]: unknown;
-};
-
-export type ClaudePermissionHookData = {
-  session_id?: string;
-  sessionId?: string;
-  transcript_path?: string;
-  transcriptPath?: string;
-  cwd?: string;
-  hook_event_name?: string;
-  hookEventName?: string;
-  permission_mode?: string;
-  permissionMode?: string;
-  tool_name?: string;
-  toolName?: string;
-  tool_input?: unknown;
-  toolInput?: unknown;
-  tool_use_id?: string;
-  toolUseId?: string;
-  permission_suggestions?: unknown;
-  permissionSuggestions?: unknown;
-  [key: string]: unknown;
-};
-
-export type ClaudePermissionHookResponse = {
-  continue: boolean;
-  suppressOutput?: boolean;
-  stopReason?: string;
-  systemMessage?: string;
-  hookSpecificOutput?: {
-    hookEventName?: 'PreToolUse';
-    permissionDecision?: 'allow' | 'deny' | 'ask';
-    permissionDecisionReason?: string;
-    updatedInput?: unknown;
-    [key: string]: unknown;
-  };
-  [key: string]: unknown;
-};
-
-export type ClaudeHookFiles = {
-  secret: string;
-  dirPath: string;
-  settingsPath: string;
-  sessionScriptPath: string;
-  permissionScriptPath: string;
-};
-
-export const DEFAULT_CLAUDE_PERMISSION_HOOK_RESPONSE: ClaudePermissionHookResponse = {
-  continue: true,
-  suppressOutput: true,
-  hookSpecificOutput: {
-    hookEventName: 'PreToolUse',
-  },
-};
-
-function buildSessionForwarderScript(port: number, secret: string): string {
-  return `#!/usr/bin/env node
-const http = require('http');
-const chunks = [];
-process.stdin.on('data', (chunk) => chunks.push(chunk));
-process.stdin.on('end', () => {
-  const body = Buffer.concat(chunks);
-  const req = http.request({
-    host: '127.0.0.1',
-    port: ${port},
-    method: 'POST',
-    path: '/hook/claude/session-start',
-    headers: {
-      'Content-Type': 'application/json',
-      'Content-Length': body.length,
-      '${CLAUDE_HOOK_SECRET_HEADER}': ${JSON.stringify(secret)}
-    }
-  }, (res) => { res.resume(); });
-  req.on('error', () => {});
-  req.end(body);
-});
-process.stdin.resume();
-`;
-}
-
-function buildPermissionForwarderScript(port: number, secret: string): string {
-  return `#!/usr/bin/env node
-const http = require('http');
-const fallback = ${JSON.stringify(JSON.stringify(DEFAULT_CLAUDE_PERMISSION_HOOK_RESPONSE))};
-const chunks = [];
-process.stdin.on('data', (chunk) => chunks.push(chunk));
-process.stdin.on('end', () => {
-  const body = Buffer.concat(chunks);
-  const req = http.request({
-    host: '127.0.0.1',
-    port: ${port},
-    method: 'POST',
-    path: '/hook/claude/permission-request',
-    headers: {
-      'Content-Type': 'application/json',
-      'Content-Length': body.length,
-      '${CLAUDE_HOOK_SECRET_HEADER}': ${JSON.stringify(secret)}
-    }
-  }, (res) => {
-    const responseChunks = [];
-    res.on('data', (chunk) => responseChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
-    res.on('end', () => {
-      const statusCode = res.statusCode || 0;
-      if (statusCode < 200 || statusCode >= 300) {
-        process.stdout.write(fallback);
-        return;
-      }
-      const payload = Buffer.concat(responseChunks).toString('utf8').trim();
-      process.stdout.write(payload || fallback);
-    });
-  });
-  req.on('error', () => {
-    process.stdout.write(fallback);
-  });
-  req.end(body);
-});
-process.stdin.resume();
-`;
-}
-
-export function createClaudeHookFiles(port: number, secret: string): ClaudeHookFiles {
-  const dirPath = join(tmpdir(), `vibelet-claude-hooks-${process.pid}-${randomUUID()}`);
-  mkdirSync(dirPath, { recursive: true });
-
-  const settingsPath = join(dirPath, 'settings.json');
-  const sessionScriptPath = join(dirPath, 'session_hook_forwarder.cjs');
-  const permissionScriptPath = join(dirPath, 'permission_hook_forwarder.cjs');
-
-  writeFileSync(sessionScriptPath, buildSessionForwarderScript(port, secret), 'utf8');
-  writeFileSync(permissionScriptPath, buildPermissionForwarderScript(port, secret), 'utf8');
-  writeFileSync(
-    settingsPath,
-    JSON.stringify({
-      hooks: {
-        SessionStart: [
-          {
-            matcher: '*',
-            hooks: [
-              {
-                type: 'command',
-                command: `${JSON.stringify(process.execPath)} ${JSON.stringify(sessionScriptPath)}`,
-              },
-            ],
-          },
-        ],
-        PreToolUse: [
-          {
-            matcher: '*',
-            hooks: [
-              {
-                type: 'command',
-                command: `${JSON.stringify(process.execPath)} ${JSON.stringify(permissionScriptPath)}`,
-              },
-            ],
-          },
-        ],
-      },
-    }, null, 2),
-    'utf8',
-  );
-
-  return {
-    secret,
-    dirPath,
-    settingsPath,
-    sessionScriptPath,
-    permissionScriptPath,
-  };
-}
-
-export function cleanupClaudeHookFiles(hookFiles: ClaudeHookFiles | null | undefined): void {
-  if (!hookFiles) return;
-  try {
-    rmSync(hookFiles.dirPath, { recursive: true, force: true });
-  } catch {
-    // best effort cleanup
-  }
-}

package/src/cli-version.test.ts

@@ -1,36 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { createRequire } from 'node:module';
-import { fileURLToPath } from 'node:url';
-import { resolveCliVersion } from './cli-version.js';
-
-const require = createRequire(import.meta.url);
-const packageJson = require('../../../package.json') as { version?: string };
-const daemonPackageDir = fileURLToPath(new URL('..', import.meta.url));
-
-test('resolveCliVersion prefers VIBELET_CLI_VERSION when provided', () => {
-  const original = process.env.VIBELET_CLI_VERSION;
-  process.env.VIBELET_CLI_VERSION = '9.9.9-test';
-
-  try {
-    assert.equal(resolveCliVersion(), '9.9.9-test');
-  } finally {
-    if (original === undefined) delete process.env.VIBELET_CLI_VERSION;
-    else process.env.VIBELET_CLI_VERSION = original;
-  }
-});
-
-test('resolveCliVersion falls back to the root package version', () => {
-  const original = process.env.VIBELET_CLI_VERSION;
-  const originalCwd = process.cwd();
-  delete process.env.VIBELET_CLI_VERSION;
-  process.chdir(daemonPackageDir);
-
-  try {
-    assert.equal(resolveCliVersion(), packageJson.version);
-  } finally {
-    process.chdir(originalCwd);
-    if (original === undefined) delete process.env.VIBELET_CLI_VERSION;
-    else process.env.VIBELET_CLI_VERSION = original;
-  }
-});

package/src/cli-version.ts

@@ -1,46 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-
-type RootPackageJson = {
-  name?: string;
-  version?: string;
-};
-
-const ROOT_PACKAGE_NAME = '@vibelet/cli';
-
-function readVersionFromPackageJson(path: string): string | null {
-  try {
-    const packageJson = JSON.parse(readFileSync(path, 'utf8')) as RootPackageJson;
-    if (packageJson.name === ROOT_PACKAGE_NAME && typeof packageJson.version === 'string' && packageJson.version.length > 0) {
-      return packageJson.version;
-    }
-  } catch {
-    // Continue through the fallback chain.
-  }
-
-  return null;
-}
-
-export function resolveCliVersion(): string {
-  if (process.env.VIBELET_CLI_VERSION) {
-    return process.env.VIBELET_CLI_VERSION;
-  }
-
-  let currentDir = process.cwd();
-  for (let depth = 0; depth < 4; depth += 1) {
-    const version = readVersionFromPackageJson(resolve(currentDir, 'package.json'));
-    if (version) {
-      return version;
-    }
-
-    const parentDir = resolve(currentDir, '..');
-    if (parentDir === currentDir) {
-      break;
-    }
-    currentDir = parentDir;
-  }
-
-  return '0.0.0';
-}
-
-export const CLI_VERSION = resolveCliVersion();

package/src/config.test.ts

@@ -1,254 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { join } from 'path';
-import { homedir } from 'os';
-import { isTransientPath, buildSanitizedEnv, execViaLoginShell, config } from './config.js';
-
-const configModuleUrl = new URL('./config.ts', import.meta.url).href;
-
-function buildChildEnv(overrides: Record<string, string | undefined>): NodeJS.ProcessEnv {
-  const nextEnv: NodeJS.ProcessEnv = { ...process.env };
-  for (const [key, value] of Object.entries(overrides)) {
-    if (value === undefined) {
-      delete nextEnv[key];
-    } else {
-      nextEnv[key] = value;
-    }
-  }
-  return nextEnv;
-}
-
-function readConfigValueInIsolatedProcess(
-  overrides: Record<string, string | undefined>,
-  expression: string,
-): string {
-  return execFileSync(
-    process.execPath,
-    [
-      '--import',
-      'tsx',
-      '-e',
-      `import { config } from ${JSON.stringify(configModuleUrl)}; process.stdout.write(String(${expression}));`,
-    ],
-    {
-      env: buildChildEnv(overrides),
-      encoding: 'utf8',
-    },
-  ).trim();
-}
-
-test('isTransientPath: detects fnm_multishells as transient', () => {
-  assert.equal(isTransientPath('/tmp/fnm_multishells/12345/bin/codex'), true);
-});
-
-test('isTransientPath: returns false for normal paths', () => {
-  assert.equal(isTransientPath('/usr/local/bin/codex'), false);
-});
-
-test('isTransientPath: returns false for home directory paths', () => {
-  assert.equal(isTransientPath('/Users/test/.local/bin/claude'), false);
-});
-
-test('isTransientPath: returns false for empty string', () => {
-  assert.equal(isTransientPath(''), false);
-});
-
-// buildSanitizedEnv tests
-
-test('buildSanitizedEnv: returns an object with PATH key', () => {
-  const env = buildSanitizedEnv();
-  assert.ok('PATH' in env);
-  assert.equal(typeof env.PATH, 'string');
-  assert.ok(env.PATH.length > 0);
-});
-
-test('buildSanitizedEnv: PATH includes extra directories', () => {
-  const env = buildSanitizedEnv();
-  assert.ok(env.PATH.includes('/usr/local/bin'));
-});
-
-test('buildSanitizedEnv: HOME is set', () => {
-  const env = buildSanitizedEnv();
-  assert.ok('HOME' in env);
-  assert.equal(typeof env.HOME, 'string');
-  assert.ok(env.HOME.length > 0);
-});
-
-test('buildSanitizedEnv: CLAUDE_CODE_ENTRYPOINT is removed', () => {
-  process.env.CLAUDE_CODE_ENTRYPOINT = 'test_value';
-  const env = buildSanitizedEnv();
-  assert.equal(env.CLAUDE_CODE_ENTRYPOINT, undefined);
-  delete process.env.CLAUDE_CODE_ENTRYPOINT;
-});
-
-test('buildSanitizedEnv: CLAUDECODE is removed', () => {
-  process.env.CLAUDECODE = 'test_value';
-  const env = buildSanitizedEnv();
-  assert.equal(env.CLAUDECODE, undefined);
-  delete process.env.CLAUDECODE;
-});
-
-test('buildSanitizedEnv: contains process.env values', () => {
-  const testKey = 'VIBE_TEST_UNIQUE_KEY_' + Date.now();
-  process.env[testKey] = 'test_value_123';
-  const env = buildSanitizedEnv();
-  assert.equal(env[testKey], 'test_value_123');
-  delete process.env[testKey];
-});
-
-// execViaLoginShell tests
-
-test('execViaLoginShell: returns correct command (a shell path)', () => {
-  const result = execViaLoginShell('claude', ['--help']);
-  assert.equal(typeof result.command, 'string');
-  assert.ok(result.command.startsWith('/'));
-});
-
-test('execViaLoginShell: args contain -lc flag', () => {
-  const result = execViaLoginShell('claude', ['--help']);
-  assert.equal(result.args[0], '-lc');
-});
-
-test('execViaLoginShell: includes the passed cmd in the shell command string', () => {
-  const result = execViaLoginShell('claude', ['--help', '--verbose']);
-  assert.ok(result.args[1].includes('claude'));
-});
-
-test('execViaLoginShell: includes the passed args after -- separator', () => {
-  const result = execViaLoginShell('claude', ['--help', '--verbose']);
-  const dashDashIndex = result.args.indexOf('--');
-  assert.ok(dashDashIndex >= 0);
-  assert.equal(result.args[dashDashIndex + 1], '--help');
-  assert.equal(result.args[dashDashIndex + 2], '--verbose');
-});
-
-// config object tests
-
-test('config.port: defaults to 9876 when VIBE_PORT not set', () => {
-  assert.equal(config.port, 9876);
-});
-
-test('config.legacyToken: defaults to an empty string', () => {
-  assert.equal(config.legacyToken, '');
-});
-
-test('config.legacyToken: respects VIBE_TOKEN env override on fresh import', async () => {
-  const original = process.env.VIBE_TOKEN;
-  process.env.VIBE_TOKEN = 'legacy-secret';
-  try {
-    const freshModule = await import(`./config.ts?test=${Date.now()}`);
-    assert.equal(freshModule.config.legacyToken, 'legacy-secret');
-  } finally {
-    if (original == null) {
-      delete process.env.VIBE_TOKEN;
-    } else {
-      process.env.VIBE_TOKEN = original;
-    }
-  }
-});
-
-test('config.idleTimeoutMs: allows disabling idle sweep with 0', () => {
-  assert.equal(
-    readConfigValueInIsolatedProcess(
-      { VIBE_IDLE_TIMEOUT_MS: '0' },
-      'config.idleTimeoutMs',
-    ),
-    '0',
-  );
-});
-
-test('config.turnStallTimeoutMs: defaults to 5 minutes', () => {
-  assert.equal(config.turnStallTimeoutMs, 5 * 60 * 1000);
-});
-
-test('config.turnStallTimeoutMs: allows disabling stall sweep with 0', () => {
-  assert.equal(
-    readConfigValueInIsolatedProcess(
-      { VIBE_TURN_STALL_TIMEOUT_MS: '0' },
-      'config.turnStallTimeoutMs',
-    ),
-    '0',
-  );
-});
-
-test('config.turnStallTimeoutMs: respects env override on fresh import', () => {
-  assert.equal(
-    readConfigValueInIsolatedProcess(
-      { VIBE_TURN_STALL_TIMEOUT_MS: '120000' },
-      'config.turnStallTimeoutMs',
-    ),
-    '120000',
-  );
-});
-
-test('config.isTransientPath: is the isTransientPath function', () => {
-  assert.equal(config.isTransientPath, isTransientPath);
-});
-
-test('config.buildSanitizedEnv: is the buildSanitizedEnv function', () => {
-  assert.equal(config.buildSanitizedEnv, buildSanitizedEnv);
-});
-
-// Binary detection / cached resolver tests
-
-test('config.claudePath: returns a path string', () => {
-  // This may resolve to a real path or fall back to 'claude'
-  const path = config.claudePath;
-  assert.equal(typeof path, 'string');
-  assert.ok(path.length > 0);
-});
-
-test('config.codexPath: returns a path string', () => {
-  const path = config.codexPath;
-  assert.equal(typeof path, 'string');
-  assert.ok(path.length > 0);
-});
-
-test('config.claudePath: respects CLAUDE_PATH env override', () => {
-  assert.equal(
-    readConfigValueInIsolatedProcess(
-      { CLAUDE_PATH: '/custom/path/to/claude' },
-      'config.claudePath',
-    ),
-    '/custom/path/to/claude',
-  );
-});
-
-test('config.codexPath: respects CODEX_PATH env override', () => {
-  assert.equal(
-    readConfigValueInIsolatedProcess(
-      { CODEX_PATH: '/custom/path/to/codex' },
-      'config.codexPath',
-    ),
-    '/custom/path/to/codex',
-  );
-});
-
-test('buildSanitizedEnv: PATH includes all required extra directories', () => {
-  const env = buildSanitizedEnv();
-  const home = homedir();
-  const requiredDirs = [
-    '/usr/local/bin',
-    '/opt/homebrew/bin',
-    join(home, '.npm-global', 'bin'),
-    join(home, '.local', 'bin'),
-    join(home, '.claude', 'bin'),
-  ];
-  for (const dir of requiredDirs) {
-    assert.ok(env.PATH.includes(dir), `PATH should include ${dir}`);
-  }
-});
-
-test('buildSanitizedEnv: includes home-relative paths', () => {
-  const env = buildSanitizedEnv();
-  const home = homedir();
-  assert.ok(env.PATH.includes(join(home, '.local', 'bin')) || env.PATH.includes('.local/bin'));
-});
-
-test('execViaLoginShell: works with codex command', () => {
-  const result = execViaLoginShell('codex', ['app-server', '--listen', 'stdio://']);
-  assert.ok(result.args[1].includes('codex'));
-  const dashDashIndex = result.args.indexOf('--');
-  assert.equal(result.args[dashDashIndex + 1], 'app-server');
-});