@vibelet/cli 0.1.34 → 0.1.36

package/src/dev-auth.test.ts

@@ -0,0 +1,183 @@
+import assert from 'node:assert/strict';
+import { spawn, type ChildProcess } from 'node:child_process';
+import { rmSync, mkdtempSync } 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 test from 'node:test';
+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');
+
+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 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;
+}
+
+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'}.`);
+}
+
+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 cleanupChild(child: ChildProcess, port: number): Promise<void> {
+  if (child.exitCode === null && child.signalCode === null) {
+    child.kill('SIGTERM');
+    try {
+      await waitForExit(child, 5000);
+    } catch {}
+  }
+
+  await waitForPortState(port, false, 5000).catch(() => {});
+}
+
+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}`));
+    }, 5000);
+
+    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()}`));
+    });
+  });
+}
+
+async function waitForCloseCode(url: string): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(url);
+    const timer = setTimeout(() => {
+      ws.terminate();
+      reject(new Error(`Timed out waiting for websocket close: ${url}`));
+    }, 5000);
+
+    ws.once('close', (code) => {
+      clearTimeout(timer);
+      resolve(code);
+    });
+    ws.once('error', () => {
+      // The server closes invalid connections quickly; rely on the close code.
+    });
+  });
+}
+
+test(
+  'dev mode still requires a valid token for protected HTTP and WebSocket access',
+  { timeout: 30000 },
+  async (t) => {
+    const port = await getFreePort();
+    const homeDir = mkdtempSync(path.join(tmpdir(), 'vibelet-dev-auth-'));
+    const packageJsonPath = path.resolve(daemonDir, 'package.json');
+    const validToken = 'test-token';
+
+    const child = spawn(process.execPath, [tsxCliPath, 'src/index.ts'], {
+      cwd: daemonDir,
+      env: {
+        ...process.env,
+        HOME: homeDir,
+        VIBE_PORT: String(port),
+        VIBE_DEV: '1',
+        VIBE_TOKEN: validToken,
+        CLAUDE_PATH: process.execPath,
+        CODEX_PATH: process.execPath,
+      },
+      stdio: 'ignore',
+    });
+
+    t.after(async () => {
+      await cleanupChild(child, port);
+      rmSync(homeDir, { recursive: true, force: true });
+    });
+
+    await waitForPortState(port, true, 15000);
+
+    const invalidUrl = new URL(`http://127.0.0.1:${port}/file`);
+    invalidUrl.searchParams.set('path', packageJsonPath);
+    invalidUrl.searchParams.set('token', '1');
+
+    const invalidResponse = await fetch(invalidUrl);
+    assert.equal(invalidResponse.status, 401);
+
+    const validUrl = new URL(`http://127.0.0.1:${port}/file`);
+    validUrl.searchParams.set('path', packageJsonPath);
+    validUrl.searchParams.set('token', validToken);
+
+    const validResponse = await fetch(validUrl);
+    assert.equal(validResponse.status, 200);
+    assert.match(await validResponse.text(), /"name": "@vibelet\/daemon"/);
+
+    const closedCode = await waitForCloseCode(`ws://127.0.0.1:${port}?token=1`);
+    assert.equal(closedCode, 4001);
+
+    const ws = await openWebSocket(`ws://127.0.0.1:${port}?token=${encodeURIComponent(validToken)}`);
+    ws.close();
+    await new Promise<void>((resolve) => ws.once('close', () => resolve()));
+  },
+);

package/src/dev-script.test.ts

@@ -0,0 +1,511 @@
+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);
+});