@vibelet/cli 0.1.38 → 1.0.1

package/src/drivers/types.ts

@@ -1,15 +0,0 @@
-import type { ApprovalRequestPayload, ServerMessage } from '@vibelet/shared';
-
-export type MessageHandler = (msg: ServerMessage) => void;
-
-export interface Driver {
-  start(cwd: string, resumeSessionId?: string, approvalMode?: string): Promise<string>;
-  sendPrompt(text: string): void;
-  respondApproval(requestId: string, approved: boolean): boolean;
-  restorePendingApproval?(approval: ApprovalRequestPayload): void;
-  interrupt(): void;
-  stop(): void;
-  setApprovalMode(mode: string): void;
-  onMessage(handler: MessageHandler): void;
-  onExit(handler: (code: number | null) => void): void;
-}

package/src/e2e.test.ts

@@ -1,139 +0,0 @@
-import assert from 'node:assert/strict';
-import { mkdirSync } from 'node:fs';
-import path from 'node:path';
-import test from 'node:test';
-import type { SessionInfo } from '@vibelet/shared';
-import {
-  cleanupDaemon,
-  createWebSocketRecorder,
-  openWebSocket,
-  spawnDaemon,
-  waitForWebSocketClose,
-} from './test-daemon-harness.js';
-
-function send(ws: { send: (data: string) => void }, payload: object): void {
-  ws.send(JSON.stringify(payload));
-}
-
-function responseData(message: Record<string, unknown>): Record<string, unknown> {
-  const data = message.data;
-  assert.ok(data && typeof data === 'object' && !Array.isArray(data));
-  return data as Record<string, unknown>;
-}
-
-const E2E_WAIT_TIMEOUT_MS = 10_000;
-
-test('daemon automated e2e covers list/create/send/stream/resume without real agent binaries', async (t) => {
-  const daemon = await spawnDaemon({ useFakeClaudeCli: true });
-  t.after(() => cleanupDaemon(daemon));
-
-  const cwd = path.join(daemon.homeDir, 'workspace');
-  mkdirSync(cwd, { recursive: true });
-
-  const ws1 = await openWebSocket(`ws://127.0.0.1:${daemon.port}?token=${daemon.token}`);
-  const recorder1 = createWebSocketRecorder(ws1);
-  t.after(() => {
-    recorder1.stop();
-    try {
-      ws1.close();
-    } catch {}
-  });
-
-  send(ws1, { action: 'sessions.list', id: 'list-1', agent: 'claude', cwd });
-  const listBefore = await recorder1.waitFor((message) => message.type === 'response' && message.id === 'list-1', E2E_WAIT_TIMEOUT_MS);
-  assert.equal(listBefore.ok, true);
-  assert.deepEqual(responseData(listBefore).sessions, []);
-
-  send(ws1, { action: 'session.create', id: 'create-1', agent: 'claude', cwd });
-  const createResponse = await recorder1.waitFor((message) => message.type === 'response' && message.id === 'create-1', E2E_WAIT_TIMEOUT_MS);
-  assert.equal(createResponse.ok, true);
-  const pendingSessionId = String(responseData(createResponse).sessionId);
-  assert.match(pendingSessionId, /^pending_/);
-
-  const firstPrompt = 'First fake prompt for automated daemon e2e.';
-  send(ws1, {
-    action: 'session.send',
-    id: 'send-1',
-    sessionId: pendingSessionId,
-    agent: 'claude',
-    message: firstPrompt,
-  });
-
-  const sendResponse = await recorder1.waitFor((message) => message.type === 'response' && message.id === 'send-1', E2E_WAIT_TIMEOUT_MS);
-  assert.equal(sendResponse.ok, true);
-
-  const idUpdate = await recorder1.waitFor((message) =>
-    message.type === 'response'
-    && typeof message.id === 'string'
-    && message.id.startsWith('id_update_'),
-  E2E_WAIT_TIMEOUT_MS);
-  assert.equal(idUpdate.ok, true);
-  const idUpdateData = responseData(idUpdate);
-  assert.equal(idUpdateData.oldSessionId, pendingSessionId);
-  const actualSessionId = String(idUpdateData.sessionId);
-  assert.notEqual(actualSessionId, pendingSessionId);
-
-  await recorder1.waitFor((message) => message.type === 'session.done' && message.sessionId === actualSessionId, E2E_WAIT_TIMEOUT_MS);
-  const firstReply = recorder1.messages
-    .filter((message) => message.type === 'text.delta' && message.sessionId === actualSessionId)
-    .map((message) => String(message.content ?? ''))
-    .join('');
-  assert.equal(firstReply, `fake claude reply: ${firstPrompt}`);
-
-  send(ws1, { action: 'sessions.list', id: 'list-2', agent: 'claude', cwd });
-  const listAfter = await recorder1.waitFor((message) => message.type === 'response' && message.id === 'list-2', E2E_WAIT_TIMEOUT_MS);
-  assert.equal(listAfter.ok, true);
-  const listedSessions = responseData(listAfter).sessions as SessionInfo[];
-  const listedSession = listedSessions.find((session) => session.sessionId === actualSessionId);
-  assert.ok(listedSession);
-  assert.equal(listedSession.agent, 'claude');
-  assert.ok(listedSession.sources.includes('record'));
-  if (listedSession.sources.includes('daemon')) {
-    assert.equal(listedSession.runtime.state, 'daemonActive');
-  } else {
-    assert.equal(listedSession.runtime.state, 'idle');
-  }
-  assert.match(listedSession.title ?? '', /First fake prompt/);
-
-  ws1.close();
-  const closeCode = await waitForWebSocketClose(ws1, E2E_WAIT_TIMEOUT_MS);
-  assert.equal(closeCode, 1005);
-  recorder1.stop();
-
-  const ws2 = await openWebSocket(`ws://127.0.0.1:${daemon.port}?token=${daemon.token}`);
-  const recorder2 = createWebSocketRecorder(ws2);
-  t.after(() => {
-    recorder2.stop();
-    try {
-      ws2.close();
-    } catch {}
-  });
-
-  send(ws2, { action: 'session.resume', id: 'resume-1', sessionId: actualSessionId, agent: 'claude' });
-  const historyMessage = await recorder2.waitFor((message) => message.type === 'session.history' && message.sessionId === actualSessionId, E2E_WAIT_TIMEOUT_MS);
-  const resumeResponse = await recorder2.waitFor((message) => message.type === 'response' && message.id === 'resume-1', E2E_WAIT_TIMEOUT_MS);
-  assert.equal(resumeResponse.ok, true);
-  assert.deepEqual(historyMessage.messages, [
-    { role: 'user', content: firstPrompt },
-    { role: 'assistant', content: `fake claude reply: ${firstPrompt}` },
-  ]);
-
-  const secondPrompt = 'Second fake prompt after websocket resume.';
-  send(ws2, {
-    action: 'session.send',
-    id: 'send-2',
-    sessionId: actualSessionId,
-    agent: 'claude',
-    message: secondPrompt,
-  });
-
-  const sendResponse2 = await recorder2.waitFor((message) => message.type === 'response' && message.id === 'send-2', E2E_WAIT_TIMEOUT_MS);
-  assert.equal(sendResponse2.ok, true);
-  await recorder2.waitFor((message) => message.type === 'session.done' && message.sessionId === actualSessionId, E2E_WAIT_TIMEOUT_MS);
-
-  const secondReply = recorder2.messages
-    .filter((message) => message.type === 'text.delta' && message.sessionId === actualSessionId)
-    .map((message) => String(message.content ?? ''))
-    .join('');
-  assert.match(secondReply, /Second fake prompt after websocket resume\./);
-});

package/src/identity.test.ts

@@ -1,26 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtemp, readFile, rm } from 'fs/promises';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { loadOrCreateDaemonIdentity } from './identity.js';
-
-test('loadOrCreateDaemonIdentity persists identity details and reuses the daemon id', async () => {
-  const dir = await mkdtemp(join(tmpdir(), 'vibelet-identity-'));
-  const identityPath = join(dir, 'identity.json');
-
-  try {
-    const first = loadOrCreateDaemonIdentity(9876, identityPath);
-    const second = loadOrCreateDaemonIdentity(9999, identityPath);
-    const persisted = JSON.parse(await readFile(identityPath, 'utf8'));
-
-    assert.match(first.daemonId, /^d_/);
-    assert.equal(second.daemonId, first.daemonId);
-    assert.equal(second.daemonSecret, first.daemonSecret);
-    assert.equal(second.port, 9999);
-    assert.equal(persisted.port, 9999);
-    assert.equal(persisted.daemonId, first.daemonId);
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-});

package/src/identity.ts

@@ -1,82 +0,0 @@
-import { mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { hostname } from 'os';
-import { randomBytes } from 'crypto';
-import { dirname } from 'path';
-import { IDENTITY_PATH } from './paths.js';
-
-export interface DaemonIdentity {
-  daemonId: string;
-  daemonSecret: string;
-  displayName: string;
-  canonicalHost: string;
-  port: number;
-  createdAt: string;
-}
-
-function base64Url(bytes: number): string {
-  return randomBytes(bytes).toString('base64url');
-}
-
-function buildDaemonId(): string {
-  return `d_${base64Url(12)}`;
-}
-
-function defaultDisplayName(): string {
-  return hostname();
-}
-
-function defaultCanonicalHost(): string {
-  const raw = hostname().trim().toLowerCase();
-  if (!raw) return 'localhost';
-  return raw.endsWith('.local') ? raw : `${raw}.local`;
-}
-
-function createIdentity(port: number): DaemonIdentity {
-  return {
-    daemonId: buildDaemonId(),
-    daemonSecret: base64Url(32),
-    displayName: defaultDisplayName(),
-    canonicalHost: defaultCanonicalHost(),
-    port,
-    createdAt: new Date().toISOString(),
-  };
-}
-
-function writeIdentity(identity: DaemonIdentity, identityPath: string): void {
-  mkdirSync(dirname(identityPath), { recursive: true });
-  writeFileSync(identityPath, JSON.stringify(identity, null, 2) + '\n', 'utf8');
-}
-
-export function loadOrCreateDaemonIdentity(port: number, identityPath = IDENTITY_PATH): DaemonIdentity {
-  try {
-    const raw = readFileSync(identityPath, 'utf8');
-    const parsed = JSON.parse(raw) as Partial<DaemonIdentity>;
-    if (
-      typeof parsed.daemonId === 'string' &&
-      typeof parsed.daemonSecret === 'string' &&
-      typeof parsed.displayName === 'string' &&
-      typeof parsed.canonicalHost === 'string' &&
-      typeof parsed.createdAt === 'string'
-    ) {
-      const identity: DaemonIdentity = {
-        daemonId: parsed.daemonId,
-        daemonSecret: parsed.daemonSecret,
-        displayName: parsed.displayName,
-        canonicalHost: parsed.canonicalHost,
-        port: typeof parsed.port === 'number' && Number.isFinite(parsed.port) ? parsed.port : port,
-        createdAt: parsed.createdAt,
-      };
-      if (identity.port !== port) {
-        identity.port = port;
-        writeIdentity(identity, identityPath);
-      }
-      return identity;
-    }
-  } catch {
-    // Fall through to create a new identity.
-  }
-
-  const identity = createIdentity(port);
-  writeIdentity(identity, identityPath);
-  return identity;
-}

package/src/index-entry.test.ts

@@ -1,336 +0,0 @@
-import assert from 'node:assert/strict';
-import { mkdirSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
-import test from 'node:test';
-import type { PairingQrPayload } from '@vibelet/shared';
-import {
-  cleanupDaemon,
-  openWebSocket,
-  readAuditLog,
-  spawnDaemon,
-  waitForHealth,
-  waitForStdout,
-  waitForWebSocketClose,
-  waitForWebSocketMessage,
-} from './test-daemon-harness.js';
-
-test('health endpoint reports daemon status and pairing flow can create then reset pairings', async (t) => {
-  const daemon = await spawnDaemon();
-  t.after(() => cleanupDaemon(daemon));
-
-  const initialHealth = await waitForHealth(daemon.port);
-  assert.equal(initialHealth.status, 'ok');
-  assert.equal(initialHealth.pairedDevices, 0);
-  assert.equal(typeof initialHealth.daemonId, 'string');
-  assert.equal(typeof initialHealth.metrics, 'object');
-  assert.equal(typeof initialHealth.sessionInventory, 'object');
-  assert.equal(
-    typeof (initialHealth.sessionInventory as { backfillInFlight: unknown }).backfillInFlight,
-    'boolean',
-  );
-  assert.equal(
-    typeof (initialHealth.sessionInventory as { cachedSessions: unknown }).cachedSessions,
-    'number',
-  );
-
-  const pairOpenResponse = await fetch(`http://127.0.0.1:${daemon.port}/pair/open`, { method: 'POST' });
-  assert.equal(pairOpenResponse.status, 200);
-  const pairPayload = await pairOpenResponse.json() as PairingQrPayload;
-  assert.equal(pairPayload.type, 'vibelet-pair');
-  assert.equal(typeof pairPayload.daemonId, 'string');
-  assert.equal(typeof pairPayload.pairNonce, 'string');
-
-  const createBody = {
-    daemonId: pairPayload.daemonId,
-    pairNonce: pairPayload.pairNonce,
-    deviceId: 'device-1',
-    deviceName: 'QA Phone',
-  };
-
-  const createResponse = await fetch(`http://127.0.0.1:${daemon.port}/pair/create`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(createBody),
-  });
-  assert.equal(createResponse.status, 200);
-  const createPayload = await createResponse.json() as Record<string, unknown>;
-  assert.equal(createPayload.deviceId, 'device-1');
-  assert.equal(typeof createPayload.pairToken, 'string');
-
-  const reusedNonceResponse = await fetch(`http://127.0.0.1:${daemon.port}/pair/create`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(createBody),
-  });
-  assert.equal(reusedNonceResponse.status, 401);
-  assert.equal((await reusedNonceResponse.json() as Record<string, unknown>).error, 'pair_window_expired');
-
-  const pairedHealth = await waitForHealth(daemon.port);
-  assert.equal(pairedHealth.pairedDevices, 1);
-
-  const resetResponse = await fetch(`http://127.0.0.1:${daemon.port}/pair/reset`, { method: 'POST' });
-  assert.equal(resetResponse.status, 200);
-  assert.deepEqual(await resetResponse.json(), { ok: true });
-
-  const resetHealth = await waitForHealth(daemon.port);
-  assert.equal(resetHealth.pairedDevices, 0);
-
-  const missingFileUrl = new URL(`http://127.0.0.1:${daemon.port}/file`);
-  missingFileUrl.searchParams.set('token', daemon.token);
-  missingFileUrl.searchParams.set('path', path.join(daemon.homeDir, 'does-not-exist.png'));
-
-  const missingFileResponse = await fetch(missingFileUrl);
-  assert.equal(missingFileResponse.status, 404);
-  assert.equal(await missingFileResponse.text(), 'File not found');
-});
-
-test('pairing endpoints return the relay host and port when VIBELET_RELAY_URL is configured', async (t) => {
-  const daemon = await spawnDaemon({
-    env: {
-      VIBELET_RELAY_URL: 'https://relay.example.com',
-    },
-  });
-  t.after(() => cleanupDaemon(daemon));
-
-  const health = await waitForHealth(daemon.port);
-  assert.equal(health.canonicalHost, 'relay.example.com');
-  assert.equal(health.relayUrl, 'https://relay.example.com');
-
-  const pairOpenResponse = await fetch(`http://127.0.0.1:${daemon.port}/pair/open`, { method: 'POST' });
-  assert.equal(pairOpenResponse.status, 200);
-  const pairPayload = await pairOpenResponse.json() as PairingQrPayload;
-  assert.equal(pairPayload.canonicalHost, 'relay.example.com');
-  assert.equal(pairPayload.port, 443);
-  assert.ok(Array.isArray(pairPayload.fallbackHosts));
-  assert.ok((pairPayload.fallbackHosts?.length ?? 0) > 0);
-  assert.ok(pairPayload.fallbackHosts?.every((host) => host !== pairPayload.canonicalHost));
-
-  const createResponse = await fetch(`http://127.0.0.1:${daemon.port}/pair/create`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      daemonId: pairPayload.daemonId,
-      pairNonce: pairPayload.pairNonce,
-      deviceId: 'device-relay',
-      deviceName: 'Relay Phone',
-    }),
-  });
-  assert.equal(createResponse.status, 200);
-
-  const createPayload = await createResponse.json() as Record<string, unknown>;
-  assert.equal(createPayload.canonicalHost, 'relay.example.com');
-  assert.equal(createPayload.port, 443);
-  assert.deepEqual(createPayload.fallbackHosts, pairPayload.fallbackHosts);
-  assert.equal(createPayload.deviceId, 'device-relay');
-  assert.equal(typeof createPayload.pairToken, 'string');
-});
-
-test('file endpoint resolves relative paths against cwd and returns markdown content type', async (t) => {
-  const daemon = await spawnDaemon();
-  t.after(() => cleanupDaemon(daemon));
-
-  const workspaceDir = path.join(daemon.homeDir, 'workspace');
-  const docsDir = path.join(workspaceDir, 'docs');
-  mkdirSync(docsDir, { recursive: true });
-  writeFileSync(path.join(docsDir, 'guide.md'), '# Remote Guide\n', 'utf8');
-
-  const fileUrl = new URL(`http://127.0.0.1:${daemon.port}/file`);
-  fileUrl.searchParams.set('token', daemon.token);
-  fileUrl.searchParams.set('path', 'docs/guide.md');
-  fileUrl.searchParams.set('cwd', workspaceDir);
-
-  const response = await fetch(fileUrl);
-  assert.equal(response.status, 200);
-  assert.equal(response.headers.get('content-type'), 'text/markdown; charset=utf-8');
-  assert.equal(await response.text(), '# Remote Guide\n');
-});
-
-test('upload endpoint stores image files and returns their daemon path', async (t) => {
-  const daemon = await spawnDaemon();
-  t.after(() => cleanupDaemon(daemon));
-
-  const uploadUrl = new URL(`http://127.0.0.1:${daemon.port}/upload`);
-  uploadUrl.searchParams.set('token', daemon.token);
-
-  const response = await fetch(uploadUrl, {
-    method: 'POST',
-    headers: { 'Content-Type': 'image/heic' },
-    body: Buffer.from('fake-heic-data'),
-  });
-
-  assert.equal(response.status, 200);
-  const payload = await response.json() as { path: string };
-  assert.match(payload.path, /\/uploads\/.+\.heic$/);
-
-  const fileResponse = await fetch(`http://127.0.0.1:${daemon.port}/file?token=${encodeURIComponent(daemon.token)}&path=${encodeURIComponent(payload.path)}`);
-  assert.equal(fileResponse.status, 200);
-  assert.equal(fileResponse.headers.get('content-type'), 'image/heic');
-  assert.equal(await fileResponse.text(), 'fake-heic-data');
-});
-
-test('auth.hello can authenticate a device, dirs.list omits hidden entries, and log.report is forwarded to audit/stdout', async (t) => {
-  const daemon = await spawnDaemon();
-  t.after(() => cleanupDaemon(daemon));
-
-  const pairPayload = await (await fetch(`http://127.0.0.1:${daemon.port}/pair/open`, { method: 'POST' })).json() as PairingQrPayload;
-  const createResponse = await fetch(`http://127.0.0.1:${daemon.port}/pair/create`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      daemonId: pairPayload.daemonId,
-      pairNonce: pairPayload.pairNonce,
-      deviceId: 'device-auth',
-      deviceName: 'Auth Device',
-    }),
-  });
-  const pairing = await createResponse.json() as Record<string, unknown>;
-  const pairToken = String(pairing.pairToken);
-
-  const ws = await openWebSocket(`ws://127.0.0.1:${daemon.port}`);
-  t.after(() => {
-    try {
-      ws.close();
-    } catch {}
-  });
-
-  ws.send(JSON.stringify({
-    action: 'auth.hello',
-    id: 'auth-1',
-    daemonId: pairPayload.daemonId,
-    deviceId: 'device-auth',
-    pairToken,
-  }));
-
-  const authResponse = await waitForWebSocketMessage(ws, (message) => message.type === 'response' && message.id === 'auth-1');
-  assert.equal(authResponse.ok, true);
-  assert.deepEqual(authResponse.data, {
-    daemonId: pairPayload.daemonId,
-    displayName: authResponse.data && typeof authResponse.data === 'object' ? (authResponse.data as Record<string, unknown>).displayName : undefined,
-  });
-
-  const dirsRoot = path.join(daemon.homeDir, 'dirs');
-  mkdirSync(path.join(dirsRoot, 'alpha'), { recursive: true });
-  writeFileSync(path.join(dirsRoot, 'z-last.txt'), 'z');
-  writeFileSync(path.join(dirsRoot, 'b.txt'), 'b');
-  writeFileSync(path.join(dirsRoot, '.hidden.txt'), 'hidden');
-
-  ws.send(JSON.stringify({
-    action: 'dirs.list',
-    id: 'dirs-1',
-    path: dirsRoot,
-  }));
-
-  const dirsResponse = await waitForWebSocketMessage(ws, (message) => message.type === 'response' && message.id === 'dirs-1');
-  assert.equal(dirsResponse.ok, true);
-  assert.deepEqual((dirsResponse.data as { entries: Array<{ name: string; isDirectory: boolean }> }).entries, [
-    { name: 'alpha', isDirectory: true },
-    { name: 'b.txt', isDirectory: false },
-    { name: 'z-last.txt', isDirectory: false },
-  ]);
-
-  ws.send(JSON.stringify({
-    action: 'log.report',
-    id: 'log-1',
-    entries: [
-      {
-        level: 'info',
-        event: 'app.session.create',
-        data: { agent: 'codex', cwd: '/tmp/repo' },
-        ts: '2026-03-29T00:00:00.000Z',
-      },
-    ],
-  }));
-
-  const logResponse = await waitForWebSocketMessage(ws, (message) => message.type === 'response' && message.id === 'log-1');
-  assert.equal(logResponse.ok, true);
-
-  const auditLog = await readAuditLog(daemon.homeDir);
-  assert.match(auditLog, /"event":"app\.log"/);
-  assert.match(auditLog, /"appEvent":"app\.session\.create"/);
-  assert.match(auditLog, /"agent":"codex"/);
-
-  const stdout = await waitForStdout(daemon, /\[app\] app\.session\.create/);
-  assert.match(stdout, /\[app\] app\.session\.create/);
-});
-
-test('dirs.list expands tilde paths before reading the directory', async (t) => {
-  const daemon = await spawnDaemon();
-  t.after(() => cleanupDaemon(daemon));
-
-  const tildeDir = path.join(daemon.homeDir, 'tilde-browse');
-  mkdirSync(path.join(tildeDir, 'nested'), { recursive: true });
-  writeFileSync(path.join(tildeDir, 'notes.txt'), 'browse me', 'utf8');
-
-  const ws = await openWebSocket(`ws://127.0.0.1:${daemon.port}?token=${encodeURIComponent(daemon.token)}`);
-  t.after(() => {
-    try {
-      ws.close();
-    } catch {}
-  });
-
-  ws.send(JSON.stringify({
-    action: 'dirs.list',
-    id: 'dirs-tilde',
-    path: '~/tilde-browse',
-  }));
-
-  const response = await waitForWebSocketMessage(ws, (message) => message.type === 'response' && message.id === 'dirs-tilde');
-  assert.equal(response.ok, true);
-  assert.deepEqual((response.data as { entries: Array<{ name: string; isDirectory: boolean }> }).entries, [
-    { name: 'nested', isDirectory: true },
-    { name: 'notes.txt', isDirectory: false },
-  ]);
-});
-
-test('dirs.list resolves relative paths against the provided cwd', async (t) => {
-  const daemon = await spawnDaemon();
-  t.after(() => cleanupDaemon(daemon));
-
-  const repoRoot = path.join(daemon.homeDir, 'repo-root');
-  const assetsDir = path.join(repoRoot, 'apps', 'aino-desktop', 'src', 'renderer', 'src', 'assets');
-  mkdirSync(assetsDir, { recursive: true });
-  writeFileSync(path.join(assetsDir, 'wavy-lines.svg'), '<svg />', 'utf8');
-
-  const ws = await openWebSocket(`ws://127.0.0.1:${daemon.port}?token=${encodeURIComponent(daemon.token)}`);
-  t.after(() => {
-    try {
-      ws.close();
-    } catch {}
-  });
-
-  ws.send(JSON.stringify({
-    action: 'dirs.list',
-    id: 'dirs-relative',
-    path: 'apps/aino-desktop/src/renderer/src/assets/',
-    cwd: repoRoot,
-  }));
-
-  const response = await waitForWebSocketMessage(ws, (message) => message.type === 'response' && message.id === 'dirs-relative');
-  assert.equal(response.ok, true);
-  assert.deepEqual((response.data as { entries: Array<{ name: string; isDirectory: boolean }> }).entries, [
-    { name: 'wavy-lines.svg', isDirectory: false },
-  ]);
-});
-
-test('auth.hello rejects invalid pair tokens and closes the websocket', async (t) => {
-  const daemon = await spawnDaemon();
-  t.after(() => cleanupDaemon(daemon));
-
-  const pairPayload = await (await fetch(`http://127.0.0.1:${daemon.port}/pair/open`, { method: 'POST' })).json() as PairingQrPayload;
-  const ws = await openWebSocket(`ws://127.0.0.1:${daemon.port}`);
-
-  ws.send(JSON.stringify({
-    action: 'auth.hello',
-    id: 'auth-fail',
-    daemonId: pairPayload.daemonId,
-    deviceId: 'device-auth',
-    pairToken: 'invalid-token',
-  }));
-
-  const response = await waitForWebSocketMessage(ws, (message) => message.type === 'response' && message.id === 'auth-fail');
-  assert.equal(response.ok, false);
-  assert.equal(response.error, 'auth_failed');
-
-  const closeCode = await waitForWebSocketClose(ws);
-  assert.equal(closeCode, 4001);
-});