@dassi_ai/cli 0.5.0 → 0.7.1

package/dassi-daemon.mjs

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { randomUUID } from 'node:crypto';
+import { CLI_PROTOCOL_VERSION } from './dassi-shared.mjs';
 /**
  * Dassi CLI Daemon
  *
@@ -13,6 +15,7 @@
  */
 
 import * as net from 'net';
+import { setTimeout as sleep } from 'node:timers/promises';
 import * as fs from 'fs';
 import { pathToFileURL } from 'url';
 import {
@@ -22,10 +25,9 @@ import {
   getPidFile,
   validateSession,
   cleanupDaemonFiles,
-  buildReadyPayload,
-  createCommandQueue,
   createConnectionRegistry,
   getDaemonBridgePort,
+  unknownToolOutcome,
 } from './dassi-shared.mjs';
 
 // ─── Constants ────────────────────────────────────────────────────────────────
@@ -33,8 +35,6 @@ import {
 const IDLE_TIMEOUT_MS = 30 * 60 * 1000;
 const IDLE_CHECK_INTERVAL_MS = 5 * 60 * 1000;
 
-// Reason: a registry of connected extensions keyed by profile label replaces
-// the old single-socket model so multiple Chrome profiles can connect at once.
 const registry = createConnectionRegistry();
 
 // ─── WebSocket loader helper ──────────────────────────────────────────────────
@@ -72,7 +72,7 @@ function setupResponseRouter(entry) {
     if (!pending) return;
     entry.pending.delete(String(resp.id));
     if (resp.error) {
-      pending.reject(new Error(resp.error.message ?? String(resp.error)));
+      pending.reject(Object.assign(new Error(resp.error.message ?? String(resp.error)), { taskId: resp.error.taskId, existingTaskId: resp.error.existingTaskId }));
     } else {
       pending.resolve(resp.result);
     }
@@ -85,7 +85,7 @@ function setupResponseRouter(entry) {
  */
 function drainPendingResponses(entry) {
   for (const [id, pending] of entry.pending) {
-    pending.reject(new Error('Extension disconnected'));
+    pending.reject(Object.assign(new Error('Extension disconnected'), { outcome: 'unknown' }));
     entry.pending.delete(id);
   }
 }
@@ -113,45 +113,12 @@ function acceptExtensionSocket(ws, identity, port) {
   return entry;
 }
 
-/**
- * Handles a registration message from a newly connected extension WebSocket.
- * On first registration, resolves the startup promise with auth status.
- * On subsequent registrations (reconnects), logs and continues silently.
- * @param {import('ws').WebSocket} ws - The connected WebSocket.
- * @param {Buffer} data - Raw message data.
- * @param {{ resolved: boolean; timeout: ReturnType<typeof setTimeout> }} ctx - Shared state.
- * @param {(value: unknown) => void} resolve - Promise resolve callback.
- * @param {(reason: Error) => void} reject - Promise reject callback.
- * @param {number} port - The port the WS server is bound to.
- */
-async function handleRegistration(ws, data, ctx, resolve, reject, port) {
+function handleRegistration(ws, data, port) {
   let msg;
-  try { msg = JSON.parse(data.toString()); } catch { return; }
-  if (msg.type !== 'register' || msg.client !== 'dassi-extension') return;
-
-  const entry = acceptExtensionSocket(
-    ws,
-    { label: typeof msg.label === 'string' ? msg.label : null, installId: String(msg.installId ?? '') },
-    port,
-  );
-
-  if (!ctx.resolved) {
-    clearTimeout(ctx.timeout);
-    try {
-      // Reason: route the startup status check to the connection that just registered.
-      const status = await dispatchToExtension({ id: 'init', action: 'status', target: entry.label });
-      ctx.resolved = true;
-      resolve(status);
-    } catch (err) {
-      // Reason: leave ctx.resolved false so a reconnecting extension can retry
-      // the startup status check rather than failing the daemon permanently.
-      console.error('[dassi-daemon] Initial status check failed:', err.message);
-      reject(err);
-    }
-  } else {
-    // Reason: daemon already started — this is a reconnect or an additional profile.
-    console.log('[dassi-daemon] Extension registered (daemon already started)');
-  }
+  try { msg = JSON.parse(data.toString()); } catch { ws.close(); return; }
+  if (msg.type !== 'register' || msg.client !== 'dassi-extension') { ws.close(); return; }
+  acceptExtensionSocket(ws, { label: typeof msg.label === 'string' ? msg.label : null,
+    installId: String(msg.installId ?? '') }, port);
 }
 
 // Reason: Port is configurable via DASSI_BRIDGE_PORT (single source of truth in
@@ -161,35 +128,15 @@ async function handleRegistration(ws, data, ctx, resolve, reject, port) {
 // silently accept and bind to a random ephemeral port.
 const BRIDGE_PORT = getDaemonBridgePort();
 
-/**
- * Starts a WebSocket server on the configured bridge port (default 18790).
- * Stays alive for the daemon's lifetime. Waits for the first extension
- * connection, then resolves with the auth status. Subsequent reconnections
- * are handled transparently.
- * @returns {Promise<{ authenticated: boolean; email: string | null; optionsUrl: string }>}
- */
+/** Listen independently of whether Chrome is connected or signed in. */
 async function startExtensionServer() {
   const { WSServer } = await loadWebSocket();
-
   return new Promise((resolve, reject) => {
     const wss = new WSServer({ host: '127.0.0.1', port: BRIDGE_PORT });
-    const ctx = { resolved: false, timeout: null };
-
-    ctx.timeout = setTimeout(() => {
-      wss.close();
-      reject(new Error('extension_not_installed'));
-    }, 30_000);
-
-    wss.on('error', (err) => {
-      if (!ctx.resolved) {
-        clearTimeout(ctx.timeout);
-        // Reason: EADDRINUSE means another daemon instance already owns the port
-        reject(err.code === 'EADDRINUSE' ? new Error('port_in_use') : new Error('extension_not_installed'));
-      }
-    });
-
+    wss.once('listening', () => resolve(wss));
+    wss.on('error', reject);
     wss.on('connection', (ws) => {
-      ws.once('message', (data) => handleRegistration(ws, data, ctx, resolve, reject, BRIDGE_PORT));
+      ws.once('message', (data) => handleRegistration(ws, data, BRIDGE_PORT));
     });
   });
 }
@@ -203,76 +150,98 @@ async function startExtensionServer() {
  * @param {Record<string, unknown>} cmd - Command object with {id, action, target?, ...params}
  * @returns {Promise<unknown>} The extension's result value (not wrapped in success/data).
  */
-async function dispatchToExtension(cmd) {
+export async function dispatchToExtension(cmd, reg = registry) {
   const { id, action, target = null, ...params } = cmd;
-  const entry = registry.resolve(target); // throws with a helpful message if ambiguous/unknown/none
+  const entry = reg.resolve(target); // throws with a helpful message if ambiguous/unknown/none
   if (!entry.ws || entry.ws.readyState !== 1 /* OPEN */) {
     throw new Error('Extension not connected');
   }
 
   // Reason: the extension expects JSON-RPC {id, method, params}; `target` is a
   // daemon-only routing field and must not leak into the extension params.
-  const message = { id, method: action ?? String(id), params };
-  entry.ws.send(JSON.stringify(message));
-
-  const timeoutMs = typeof params.timeoutMs === 'number' ? params.timeoutMs + 10_000 : 65_000;
+  const correlationId = randomUUID();
+  const message = { id: correlationId, method: action ?? String(id), params };
+  // The canonical tool controls execution deadlines, including for dynamic plugins.
+  const timeoutMs = action === 'tool_exec' ? null : action === 'status' ? 10_000 : action === 'run' ? 65_000
+    : Number.isFinite(params.timeoutMs) && params.timeoutMs > 0 ? Math.min(params.timeoutMs + 10_000, 2147483647) : 65_000;
 
   return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      entry.pending.delete(String(id));
+    const timer = timeoutMs == null ? null : setTimeout(() => {
+      entry.pending.delete(correlationId);
       reject(new Error(`Extension timeout after ${timeoutMs}ms`));
     }, timeoutMs);
 
-    entry.pending.set(String(id), {
+    entry.pending.set(correlationId, {
       resolve: (result) => { clearTimeout(timer); resolve(result); },
       reject: (err) => { clearTimeout(timer); reject(err); },
     });
+    try { entry.ws.send(JSON.stringify(message)); } catch (error) {
+      entry.pending.delete(correlationId); clearTimeout(timer); reject(error);
+    }
   });
 }
 
-/**
- * Handle commands the daemon answers itself (no extension round-trip).
- * Returns a response object, or null if the command should be dispatched to
- * an extension instead.
- * @param {Record<string, unknown>} cmd
- * @param {ReturnType<typeof createConnectionRegistry>} reg
- * @returns {object | null}
- */
-export function handleDaemonLocalCommand(cmd, reg) {
-  if (cmd?.action === 'list_profiles') {
-    return { id: String(cmd.id ?? 'unknown'), success: true, data: reg.list() };
-  }
-  return null;
-}
+/** Discovery is independent of authentication and in-flight agent work. */
+const session = validateSession(process.env.DASSI_SESSION ?? 'default');
 
-/**
- * Refresh the ready file when the latest dispatched command was a `status` query.
- *
- * Reason: The daemon previously wrote the ready file exactly once on startup.
- * When the user wasn't signed in at that moment, the file stayed `needs_login`
- * even after waitForLogin's polling confirmed authentication via socket — so
- * every subsequent CLI invocation re-read the stale file and re-triggered the
- * login flow. Refreshing on every `status` response — which waitForLogin's
- * poll loop drives naturally — converges the file to the truth without needing
- * a separate signal channel.
- *
- * @param {string} readyFile - Absolute path to the daemon's ready file.
- * @param {{ action?: string }} cmd - The command that was dispatched.
- * @param {unknown} result - The dispatch result (extension's status payload).
- * @returns {void}
- */
-export function refreshReadyFileFromStatusResult(readyFile, cmd, result) {
-  if (cmd?.action !== 'status') return;
-  if (!result || typeof result !== 'object') return;
+export async function routeCommand(cmd, reg = registry, dispatch = dispatchToExtension) {
+  let resolvedProfile;
+  const call = (command) => dispatch(command, reg);
   try {
-    fs.writeFileSync(readyFile, JSON.stringify(buildReadyPayload(result)), { mode: 0o600 });
-    // Reason: writeFileSync's `mode` is ignored when the file already exists.
-    // chmod explicitly so installs with a pre-hardening 0o644 ready file get
-    // tightened. The file contains the signed-in email — owner-only.
-    try { fs.chmodSync(readyFile, 0o600); } catch { /* best-effort */ }
-  } catch {
-    // Reason: best-effort sync; don't fail the command if the FS write itself
-    // races (e.g. file permission flake). The next status query will retry.
+    if (['run', 'task_status', 'task_stop'].includes(cmd.action) && cmd.protocolVersion !== CLI_PROTOCOL_VERSION) throw new Error(cmd.protocolVersion > CLI_PROTOCOL_VERSION
+      ? `This Dassi daemon is older than the CLI (daemon protocol ${CLI_PROTOCOL_VERSION}, CLI ${cmd.protocolVersion}). Stop it (kill the PID in ${getPidFile(session)}) and retry.`
+      : `Incompatible CLI (protocol ${cmd.protocolVersion ?? 'none'}, this daemon speaks ${CLI_PROTOCOL_VERSION}). Run \`npm install -g @dassi_ai/cli@latest\` and retry.`);
+    let target = cmd.target ?? null;
+    let localTaskId = cmd.taskId;
+    if (cmd.action === 'task_status' || cmd.action === 'task_stop' || (cmd.action === 'run' && cmd.taskId)) {
+      const split = typeof cmd.taskId === 'string' ? cmd.taskId.indexOf('~') : -1;
+      if (split < 1) throw new Error('Invalid task ID. Copy the ID returned by dassi run.');
+      const taskProfile = cmd.taskId.slice(0, split);
+      if (target && reg.resolve(target).id !== taskProfile) throw new Error('Task belongs to another profile.');
+      target = taskProfile;
+      localTaskId = cmd.taskId.slice(split + 1);
+    }
+    const discovery = ['list_profiles', 'list_tabs', 'list_groups', 'status'].includes(cmd.action);
+    if (discovery) {
+      const profiles = target ? [reg.resolve(target)] : reg.list();
+      const profileOnly = cmd.action === 'list_profiles' || cmd.action === 'status';
+      const snapshots = await Promise.all(profiles.map(async (profile) => {
+        const [status, listing] = await Promise.allSettled([
+          call({ id: `${cmd.id}-${profile.id}-status`, action: 'status', target: profile.id }),
+          profileOnly ? Promise.resolve([]) : call({ ...cmd, id: `${cmd.id}-${profile.id}`, target: profile.id }),
+        ]);
+        const info = { id: profile.id, label: profile.label,
+          ...(status.status === 'fulfilled' ? status.value
+            : { [profileOnly ? 'error' : 'authError']: status.reason.message }),
+          ...(listing.status === 'rejected' ? { error: listing.reason.message } : {}),
+        };
+        const items = listing.status === 'fulfilled' ? listing.value : [];
+        return { profile: info, items: items.map(item => ({ ...item, profileId: profile.id, profile: profile.label,
+          target: `${profile.id}:${cmd.action === 'list_tabs' ? item.tabId : item.id}` })) };
+      }));
+      return { id: cmd.id, success: true,
+        data: cmd.action === 'list_profiles' || cmd.action === 'status' ? snapshots.map(s => s.profile) : snapshots.flatMap(s => s.items),
+        profiles: snapshots.map(s => s.profile) };
+    }
+    const profile = reg.resolve(target);
+    resolvedProfile = profile;
+    if (cmd.action === 'run') {
+      const status = await call({ id: `${cmd.id}-auth`, action: 'status', target: profile.id });
+      if (status.cliProtocolVersion !== CLI_PROTOCOL_VERSION) throw new Error(`Update Dassi in profile "${profile.label}" to use task commands.`);
+      if (!status.authenticated) throw new Error(`Sign in to Dassi in profile "${profile.label}" (${profile.id}), then retry.`);
+    }
+    const data = await call({ ...cmd, target: profile.id, ...(localTaskId ? { taskId: localTaskId } : {}) });
+    return { id: cmd.id, success: true, data: data?.taskId
+      ? { ...data, taskId: `${profile.id}~${data.taskId}`, profileId: profile.id, profile: profile.label } : data };
+  } catch (error) {
+    if (cmd.action === 'tool_exec' && error.outcome === 'unknown') {
+      const uncertain = unknownToolOutcome(error);
+      return { id: cmd.id, success: false, error: uncertain.message, outcome: uncertain.outcome };
+    }
+    const taskId = error.taskId && resolvedProfile ? `${resolvedProfile.id}~${error.taskId}` : undefined;
+    const existingTaskId = error.existingTaskId && resolvedProfile ? `${resolvedProfile.id}~${error.existingTaskId}` : undefined;
+    const checkId = taskId ?? existingTaskId;
+    return { id: cmd.id, success: false, ...(taskId ? { taskId } : {}), ...(existingTaskId ? { existingTaskId } : {}), error: `${error.message}${checkId ? ` Check: dassi status '${checkId}'` : ''}` };
   }
 }
 
@@ -298,7 +267,6 @@ function initDaemonProcess(session) {
   cleanupDaemonFiles(session);
   const pidFile = getPidFile(session);
   fs.writeFileSync(pidFile, String(process.pid), { mode: 0o600 });
-  // Reason: see refreshReadyFileFromStatusResult — chmod normalizes pre-existing files.
   try { fs.chmodSync(pidFile, 0o600); } catch { /* best-effort */ }
 
   const shutdown = () => {
@@ -312,12 +280,12 @@ function initDaemonProcess(session) {
 }
 
 /**
- * Creates and starts a Unix socket server that dispatches NDJSON commands to the queue.
- * @param {{ enqueue: (cmd: Record<string, unknown>) => Promise<unknown> }} queue
+ * Creates a Unix socket server that dispatches independent NDJSON commands.
+ * @param {(cmd: Record<string, unknown>) => Promise<unknown>} dispatch
  * @param {string} socketPath
  * @returns {net.Server}
  */
-function createSocketServer(queue, socketPath) {
+function createSocketServer(dispatch, socketPath) {
   const server = net.createServer((socket) => {
     let buffer = '';
 
@@ -337,11 +305,11 @@ function createSocketServer(queue, socketPath) {
           continue;
         }
 
-        queue.enqueue(cmd)
+        dispatch(cmd)
           .then((response) => {
             if (!socket.destroyed) socket.write(JSON.stringify(response) + '\n');
           })
-          .catch((err) => console.error('[dassi-daemon] enqueue error:', err));
+          .catch((err) => console.error('[dassi-daemon] dispatch error:', err));
       }
     });
 
@@ -379,49 +347,34 @@ function startIdleShutdown(server, session, getLastCommandAt) {
 // ─── Daemon entry point ───────────────────────────────────────────────────────
 
 /**
- * Main daemon entry point. Starts the extension WebSocket server, waits for
- * the extension to register, runs onboarding checks, starts the Unix socket
- * server for CLI commands, and sets up idle shutdown.
+ * Starts the two local transports and idle shutdown. Browser tasks outlive this process.
  * @returns {Promise<void>}
  */
 export async function startDaemon() {
-  const session = validateSession(process.env.DASSI_SESSION ?? 'default');
   const { socketPath, readyFile } = initDaemonProcess(session);
 
-  let statusData;
   try {
-    statusData = await startExtensionServer();
-  } catch {
-    // Reason: write the ready file even on failure so the CLI can read the error state,
-    // then exit so the WSS doesn't keep the process alive as a zombie.
-    fs.writeFileSync(readyFile, JSON.stringify({ status: 'extension_not_installed' }), { mode: 0o600 });
-    try { fs.chmodSync(readyFile, 0o600); } catch { /* best-effort */ }
+    await startExtensionServer();
+  } catch (error) {
+    fs.writeFileSync(readyFile, JSON.stringify({ status: 'error', error: error.code === 'EADDRINUSE'
+      ? `Bridge port ${BRIDGE_PORT} is already in use. Use the existing daemon; --session does not select a browser.` : error.message }), { mode: 0o600 });
     process.exit(1);
   }
-
   let lastCommandAt = Date.now();
-  const queue = createCommandQueue(async (cmd) => {
-    lastCommandAt = Date.now();
-    // Reason: daemon-local commands (e.g. list_profiles) are answered from the
-    // registry and intentionally skip extension dispatch + ready-file refresh.
-    const local = handleDaemonLocalCommand(cmd, registry);
-    if (local) return local;
+  let inFlight = 0;
+  const server = createSocketServer(async (cmd) => {
+    inFlight++;
     try {
-      const result = await dispatchToExtension(cmd);
-      refreshReadyFileFromStatusResult(readyFile, cmd, result);
-      return { id: String(cmd.id ?? 'unknown'), success: true, data: result };
-    } catch (err) {
-      return { id: String(cmd.id ?? 'unknown'), success: false, error: err.message };
+      // Chrome reconnects every five seconds after an idle daemon exits.
+      const connectDeadline = Date.now() + 6000;
+      while (!registry.size() && Date.now() < connectDeadline) await sleep(100);
+      return await routeCommand(cmd);
     }
-  });
-
-  // Reason: start the socket server before writing the ready file so the CLI
-  // can connect immediately (e.g. for needs_login polling).
-  const server = createSocketServer(queue, socketPath);
-  fs.writeFileSync(readyFile, JSON.stringify(buildReadyPayload(statusData)), { mode: 0o600 });
-  try { fs.chmodSync(readyFile, 0o600); } catch { /* best-effort */ }
-
-  startIdleShutdown(server, session, () => lastCommandAt);
+    finally { inFlight--; lastCommandAt = Date.now(); }
+  }, socketPath);
+  await new Promise(resolve => server.listening ? resolve() : server.once('listening', resolve));
+  fs.writeFileSync(readyFile, JSON.stringify({ status: 'ok', protocolVersion: CLI_PROTOCOL_VERSION }), { mode: 0o600 });
+  startIdleShutdown(server, session, () => inFlight ? Date.now() : lastCommandAt);
 }
 
 // ── Entry point ───────────────────────────────────────────────────────────────