@vibelet/cli 0.1.38 → 1.0.0

package/src/dev-script.test.ts

@@ -1,511 +0,0 @@
-import assert from 'node:assert/strict';
-import { spawn, type ChildProcess } from 'node:child_process';
-import { once } from 'node:events';
-import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { createServer, Socket } from 'node:net';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import test from 'node:test';
-import { fileURLToPath } from 'node:url';
-
-const srcDir = path.dirname(fileURLToPath(import.meta.url));
-const daemonDir = path.resolve(srcDir, '..');
-const devScriptPath = path.resolve(daemonDir, 'scripts/dev.mjs');
-
-function delay(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function getFreePort(): Promise<number> {
-  const server = createServer();
-  server.listen(0, '127.0.0.1');
-  await once(server, 'listening');
-  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;
-}
-
-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,
-  getOutput: () => string,
-): 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'}.\n${getOutput()}`,
-  );
-}
-
-async function waitForExit(
-  child: ChildProcess,
-  timeoutMs: number,
-  getOutput: () => string,
-): Promise<{ code: number | null; signal: NodeJS.Signals | null }> {
-  if (child.exitCode !== null || child.signalCode !== null) {
-    return { code: child.exitCode, signal: child.signalCode };
-  }
-
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      reject(new Error(`Timed out waiting for dev wrapper to exit.\n${getOutput()}`));
-    }, timeoutMs);
-
-    child.once('exit', (code, signal) => {
-      clearTimeout(timer);
-      resolve({ code, signal });
-    });
-  });
-}
-
-function appendOutput(output: string, chunk: string | Buffer): string {
-  const next = `${output}${chunk.toString()}`;
-  return next.length > 12000 ? next.slice(-12000) : next;
-}
-
-function createDevEnv(homeDir: string, port: number, extraEnv: Record<string, string> = {}) {
-  return {
-    ...process.env,
-    HOME: homeDir,
-    VIBELET_RELAY_URL: '',
-    VIBELET_CANONICAL_HOST: '',
-    VIBELET_FALLBACK_HOSTS: '',
-    VIBE_PORT: String(port),
-    VIBE_TOKEN: 'test-token',
-    CLAUDE_PATH: process.execPath,
-    CODEX_PATH: process.execPath,
-    ...extraEnv,
-  };
-}
-
-function writeExecutableScript(filePath: string, contents: string) {
-  writeFileSync(filePath, contents, 'utf8');
-  chmodSync(filePath, 0o755);
-}
-
-function writeCloudflaredDependency(packageDir: string, cliContents: string) {
-  mkdirSync(path.join(packageDir, 'lib'), { recursive: true });
-  writeFileSync(path.join(packageDir, 'package.json'), JSON.stringify({
-    name: 'cloudflared',
-    bin: {
-      cloudflared: 'lib/cloudflared.js',
-    },
-  }), 'utf8');
-  writeFileSync(path.join(packageDir, 'lib', 'cloudflared.js'), cliContents, 'utf8');
-}
-
-async function cleanupChild(child: ChildProcess, port: number): Promise<void> {
-  if (child.exitCode === null && child.signalCode === null) {
-    child.kill('SIGTERM');
-    try {
-      await waitForExit(child, 5000, () => '');
-    } catch {}
-  }
-
-  if (await isPortListening(port)) {
-    await new Promise<void>((resolve) => {
-      const killer = spawn('/bin/zsh', ['-lc', `lsof -tiTCP:${port} -sTCP:LISTEN | xargs -r kill -9`], {
-        stdio: 'ignore',
-      });
-      killer.once('exit', () => resolve());
-      killer.once('error', () => resolve());
-    });
-  }
-}
-
-async function runShutdownSignalTest(
-  t: test.TestContext,
-  signal: NodeJS.Signals,
-  extraEnv: Record<string, string> = {},
-): Promise<void> {
-  const port = await getFreePort();
-  const homeDir = mkdtempSync(path.join(tmpdir(), 'vibelet-dev-test-'));
-  let output = '';
-
-  const child = spawn(process.execPath, [devScriptPath, '--local'], {
-    cwd: daemonDir,
-    env: createDevEnv(homeDir, port, extraEnv),
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-
-  child.stdout?.on('data', (chunk) => {
-    output = appendOutput(output, chunk);
-  });
-  child.stderr?.on('data', (chunk) => {
-    output = appendOutput(output, chunk);
-  });
-
-  t.after(async () => {
-    await cleanupChild(child, port);
-    rmSync(homeDir, { recursive: true, force: true });
-  });
-
-  await waitForPortState(port, true, 15000, () => output);
-  child.kill(signal);
-
-  const exit = await waitForExit(child, 10000, () => output);
-  assert.ok(exit.code !== null || exit.signal !== null);
-
-  await waitForPortState(port, false, 5000, () => output);
-}
-
-test('dev wrapper tears down tsx watch and releases the port on SIGHUP', { timeout: 30000 }, async (t) => {
-  await runShutdownSignalTest(t, 'SIGHUP');
-});
-
-test('dev wrapper tears down tsx watch and releases the port on SIGINT', { timeout: 30000 }, async (t) => {
-  await runShutdownSignalTest(t, 'SIGINT');
-});
-
-test(
-  'dev wrapper tears down tsx watch without detached child mode',
-  { timeout: 30000 },
-  async (t) => {
-    await runShutdownSignalTest(t, 'SIGINT', { VIBE_DEV_DETACHED: '0' });
-  },
-);
-
-test('dev wrapper restart stops the previous wrapper before rebinding the port', { timeout: 45000 }, async (t) => {
-  const port = await getFreePort();
-  const homeDir = mkdtempSync(path.join(tmpdir(), 'vibelet-dev-test-'));
-  let firstOutput = '';
-  let restartOutput = '';
-
-  const firstChild = spawn(process.execPath, [devScriptPath, '--local'], {
-    cwd: daemonDir,
-    env: createDevEnv(homeDir, port),
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-
-  firstChild.stdout?.on('data', (chunk) => {
-    firstOutput = appendOutput(firstOutput, chunk);
-  });
-  firstChild.stderr?.on('data', (chunk) => {
-    firstOutput = appendOutput(firstOutput, chunk);
-  });
-
-  let restartChild: ChildProcess | null = null;
-
-  t.after(async () => {
-    if (restartChild) {
-      await cleanupChild(restartChild, port);
-    }
-    await cleanupChild(firstChild, port);
-    rmSync(homeDir, { recursive: true, force: true });
-  });
-
-  await waitForPortState(port, true, 15000, () => firstOutput);
-
-  restartChild = spawn(process.execPath, [devScriptPath, 'restart', '--local'], {
-    cwd: daemonDir,
-    env: createDevEnv(homeDir, port),
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-
-  restartChild.stdout?.on('data', (chunk) => {
-    restartOutput = appendOutput(restartOutput, chunk);
-  });
-  restartChild.stderr?.on('data', (chunk) => {
-    restartOutput = appendOutput(restartOutput, chunk);
-  });
-
-  const combinedOutput = () => `${firstOutput}\n--- restart ---\n${restartOutput}`;
-
-  const firstExit = await waitForExit(firstChild, 10000, combinedOutput);
-  assert.ok(firstExit.code !== null || firstExit.signal !== null);
-
-  await waitForPortState(port, true, 15000, combinedOutput);
-  assert.doesNotMatch(restartOutput, /EADDRINUSE/);
-  assert.match(restartOutput, /\[dev\] Stopping previous dev wrapper/);
-
-  const response = await fetch(`http://127.0.0.1:${port}/health`);
-  assert.equal(response.status, 200);
-});
-
-test('dev wrapper rejects unknown positional commands', { timeout: 10000 }, async (t) => {
-  const port = await getFreePort();
-  const homeDir = mkdtempSync(path.join(tmpdir(), 'vibelet-dev-test-'));
-  let output = '';
-
-  const child = spawn(process.execPath, [devScriptPath, 'bogus', '--local'], {
-    cwd: daemonDir,
-    env: createDevEnv(homeDir, port),
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-
-  child.stdout?.on('data', (chunk) => {
-    output = appendOutput(output, chunk);
-  });
-  child.stderr?.on('data', (chunk) => {
-    output = appendOutput(output, chunk);
-  });
-
-  t.after(async () => {
-    await cleanupChild(child, port);
-    rmSync(homeDir, { recursive: true, force: true });
-  });
-
-  const exit = await waitForExit(child, 5000, () => output);
-  assert.notEqual(exit.code, 0);
-  assert.match(output, /\[dev\] Unknown command: bogus/);
-  assert.equal(await isPortListening(port), false);
-});
-
-test('dev wrapper forwards --relay to the watched daemon env', { timeout: 30000 }, async (t) => {
-  const port = await getFreePort();
-  const homeDir = mkdtempSync(path.join(tmpdir(), 'vibelet-dev-test-'));
-  let output = '';
-
-  const child = spawn(process.execPath, [devScriptPath, '--relay=https://relay.example.com:443'], {
-    cwd: daemonDir,
-    env: createDevEnv(homeDir, port),
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-
-  child.stdout?.on('data', (chunk) => {
-    output = appendOutput(output, chunk);
-  });
-  child.stderr?.on('data', (chunk) => {
-    output = appendOutput(output, chunk);
-  });
-
-  t.after(async () => {
-    await cleanupChild(child, port);
-    rmSync(homeDir, { recursive: true, force: true });
-  });
-
-  await waitForPortState(port, true, 15000, () => output);
-
-  const response = await fetch(`http://127.0.0.1:${port}/health`);
-  assert.equal(response.status, 200);
-  const health = await response.json() as { relayUrl?: string; canonicalHost?: string };
-  assert.equal(health.relayUrl, 'https://relay.example.com:443');
-  assert.equal(health.canonicalHost, 'relay.example.com');
-});
-
-test('dev wrapper falls back to npm_config_relay when npm run swallows the flag', { timeout: 30000 }, async (t) => {
-  const port = await getFreePort();
-  const homeDir = mkdtempSync(path.join(tmpdir(), 'vibelet-dev-test-'));
-  let output = '';
-
-  const child = spawn(process.execPath, [devScriptPath], {
-    cwd: daemonDir,
-    env: createDevEnv(homeDir, port, {
-      npm_config_relay: 'https://relay-from-npm.example.com:443',
-    }),
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-
-  child.stdout?.on('data', (chunk) => {
-    output = appendOutput(output, chunk);
-  });
-  child.stderr?.on('data', (chunk) => {
-    output = appendOutput(output, chunk);
-  });
-
-  t.after(async () => {
-    await cleanupChild(child, port);
-    rmSync(homeDir, { recursive: true, force: true });
-  });
-
-  await waitForPortState(port, true, 15000, () => output);
-
-  const response = await fetch(`http://127.0.0.1:${port}/health`);
-  assert.equal(response.status, 200);
-  const health = await response.json() as { relayUrl?: string; canonicalHost?: string };
-  assert.equal(health.relayUrl, 'https://relay-from-npm.example.com:443');
-  assert.equal(health.canonicalHost, 'relay-from-npm.example.com');
-});
-
-test('dev wrapper reuses an existing tunnel and forwards its relay URL by default', { timeout: 30000 }, async (t) => {
-  const port = await getFreePort();
-  const homeDir = mkdtempSync(path.join(tmpdir(), 'vibelet-dev-test-'));
-  const vibeletDir = path.join(homeDir, '.vibelet');
-  mkdirSync(vibeletDir, { recursive: true });
-  writeFileSync(path.join(vibeletDir, 'tunnel.json'), JSON.stringify({
-    pid: process.pid,
-    url: 'https://relay-from-tunnel.example.com:443',
-  }) + '\n', 'utf8');
-  let output = '';
-
-  const child = spawn(process.execPath, [devScriptPath], {
-    cwd: daemonDir,
-    env: createDevEnv(homeDir, port),
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-
-  child.stdout?.on('data', (chunk) => {
-    output = appendOutput(output, chunk);
-  });
-  child.stderr?.on('data', (chunk) => {
-    output = appendOutput(output, chunk);
-  });
-
-  t.after(async () => {
-    await cleanupChild(child, port);
-    rmSync(homeDir, { recursive: true, force: true });
-  });
-
-  await waitForPortState(port, true, 15000, () => output);
-  assert.match(output, /\[dev\] Reusing tunnel: https:\/\/relay-from-tunnel\.example\.com:443/);
-
-  const response = await fetch(`http://127.0.0.1:${port}/health`);
-  assert.equal(response.status, 200);
-  const health = await response.json() as { relayUrl?: string; canonicalHost?: string };
-  assert.equal(health.relayUrl, 'https://relay-from-tunnel.example.com:443');
-  assert.equal(health.canonicalHost, 'relay-from-tunnel.example.com');
-});
-
-test('dev wrapper starts the tunnel through the bundled cloudflared dependency when cloudflared is not installed', { timeout: 30000 }, async (t) => {
-  const port = await getFreePort();
-  const homeDir = mkdtempSync(path.join(tmpdir(), 'vibelet-dev-test-'));
-  const fakeBinDir = mkdtempSync(path.join(tmpdir(), 'vibelet-cloudflared-bin-'));
-  const fakePackageDir = mkdtempSync(path.join(tmpdir(), 'vibelet-cloudflared-package-'));
-  const tunnelUrl = 'https://bundled-dependency.trycloudflare.com';
-  let output = '';
-
-  writeCloudflaredDependency(fakePackageDir, `
-console.log('2026-04-07T14:00:01Z INF Requesting new quick Tunnel on trycloudflare.com...');
-console.log('2026-04-07T14:00:01Z INF Your quick Tunnel has been created! Visit it at:');
-console.log(${JSON.stringify(tunnelUrl)});
-`);
-
-  const child = spawn(process.execPath, [devScriptPath], {
-    cwd: daemonDir,
-    env: createDevEnv(homeDir, port, {
-      PATH: fakeBinDir,
-      VIBELET_CLOUDFLARED_PACKAGE_JSON: path.join(fakePackageDir, 'package.json'),
-    }),
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-
-  child.stdout?.on('data', (chunk) => {
-    output = appendOutput(output, chunk);
-  });
-  child.stderr?.on('data', (chunk) => {
-    output = appendOutput(output, chunk);
-  });
-
-  t.after(async () => {
-    await cleanupChild(child, port);
-    rmSync(fakeBinDir, { recursive: true, force: true });
-    rmSync(fakePackageDir, { recursive: true, force: true });
-    rmSync(homeDir, { recursive: true, force: true });
-  });
-
-  await waitForPortState(port, true, 15000, () => output);
-
-  const response = await fetch(`http://127.0.0.1:${port}/health`);
-  assert.equal(response.status, 200);
-  const health = await response.json() as { relayUrl?: string; canonicalHost?: string };
-  assert.equal(health.relayUrl, tunnelUrl);
-  assert.equal(health.canonicalHost, 'bundled-dependency.trycloudflare.com');
-});
-
-test('dev wrapper includes bundled dependency stderr when tunnel bootstrap fails', { timeout: 15000 }, async (t) => {
-  const port = await getFreePort();
-  const homeDir = mkdtempSync(path.join(tmpdir(), 'vibelet-dev-test-'));
-  const fakeBinDir = mkdtempSync(path.join(tmpdir(), 'vibelet-cloudflared-bin-'));
-  const fakePackageDir = mkdtempSync(path.join(tmpdir(), 'vibelet-cloudflared-package-'));
-  let output = '';
-
-  writeCloudflaredDependency(fakePackageDir, `
-console.error('dependency bootstrap failed');
-process.exit(42);
-`);
-
-  const child = spawn(process.execPath, [devScriptPath], {
-    cwd: daemonDir,
-    env: createDevEnv(homeDir, port, {
-      PATH: fakeBinDir,
-      VIBELET_CLOUDFLARED_PACKAGE_JSON: path.join(fakePackageDir, 'package.json'),
-    }),
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-
-  child.stdout?.on('data', (chunk) => {
-    output = appendOutput(output, chunk);
-  });
-  child.stderr?.on('data', (chunk) => {
-    output = appendOutput(output, chunk);
-  });
-
-  t.after(async () => {
-    await cleanupChild(child, port);
-    rmSync(fakeBinDir, { recursive: true, force: true });
-    rmSync(fakePackageDir, { recursive: true, force: true });
-    rmSync(homeDir, { recursive: true, force: true });
-  });
-
-  const exit = await waitForExit(child, 10000, () => output);
-  assert.notEqual(exit.code, 0);
-  assert.equal(await isPortListening(port), false);
-  assert.match(output, /\[dev\] Tunnel failed: cloudflared exited before producing a tunnel URL via bundled cloudflared dependency/);
-  assert.match(output, /dependency bootstrap failed/);
-});
-
-test('dev wrapper ignores the saved relay config when --local is provided', { timeout: 30000 }, async (t) => {
-  const port = await getFreePort();
-  const homeDir = mkdtempSync(path.join(tmpdir(), 'vibelet-dev-test-'));
-  const vibeletDir = path.join(homeDir, '.vibelet');
-  mkdirSync(vibeletDir, { recursive: true });
-  writeFileSync(path.join(vibeletDir, 'relay.json'), JSON.stringify({
-    relayUrl: 'https://relay-from-config.example.com:443',
-  }) + '\n', 'utf8');
-  let output = '';
-
-  const child = spawn(process.execPath, [devScriptPath, '--local'], {
-    cwd: daemonDir,
-    env: createDevEnv(homeDir, port),
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
-
-  child.stdout?.on('data', (chunk) => {
-    output = appendOutput(output, chunk);
-  });
-  child.stderr?.on('data', (chunk) => {
-    output = appendOutput(output, chunk);
-  });
-
-  t.after(async () => {
-    await cleanupChild(child, port);
-    rmSync(homeDir, { recursive: true, force: true });
-  });
-
-  await waitForPortState(port, true, 15000, () => output);
-
-  const response = await fetch(`http://127.0.0.1:${port}/health`);
-  assert.equal(response.status, 200);
-  const health = await response.json() as { relayUrl?: string; canonicalHost?: string };
-  assert.equal(health.relayUrl, undefined);
-});