@dassi_ai/cli 0.5.0 → 0.7.1

package/dassi-shared.mjs

@@ -3,13 +3,18 @@
  *
  * Pure helper functions shared between the CLI client (dassi.mjs) and the
  * daemon process (dassi-daemon.mjs). Includes path resolution, session
- * validation, daemon lifecycle helpers, ready-file payload handling, and
- * the serialized command queue.
+ * validation, daemon lifecycle helpers, readiness, and browser identity.
  */
 
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
+import { fileURLToPath } from 'url';
+
+const PACKAGE = JSON.parse(fs.readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), 'package.json'), 'utf8'));
+export const CLI_VERSION = PACKAGE.version;
+/** Lives in package.json so the extension release gate can read it from npm (`npm view … dassi.protocol`) without downloading the tarball. */
+export const CLI_PROTOCOL_VERSION = PACKAGE.dassi.protocol;
 
 // ─── Extension identity ───────────────────────────────────────────────────────
 
@@ -19,6 +24,7 @@ import * as os from 'os';
  * path — letting `dassi launch` open the extension's options page directly.
  */
 export const DASSI_EXTENSION_ID = 'bjcngahpcjeililljmfegmlanlpgibdi';
+export const CHROME_WEB_STORE_URL = `https://chromewebstore.google.com/detail/dassi-ai-browser-agent-fo/${DASSI_EXTENSION_ID}`;
 
 // ─── Path helpers ─────────────────────────────────────────────────────────────
 
@@ -54,7 +60,7 @@ export function getPidFile(session) {
 
 /**
  * Returns the ready file path for the given session.
- * Written by the daemon once the extension WS is connected and auth is verified.
+ * Written when the local command transport is listening.
  * @param {string} session
  * @returns {string}
  */
@@ -132,205 +138,67 @@ export function isDaemonRunning(session) {
     // Reason: signal 0 checks process existence without delivering a real signal
     process.kill(pid, 0);
     return true;
-  } catch {
+  } catch (error) {
+    if (error.code === 'EPERM') return true;
     // Process does not exist — clean up stale files
     cleanupDaemonFiles(session);
     return false;
   }
 }
 
-// ─── Onboarding payload helpers ───────────────────────────────────────────────
-
-/**
- * Builds the ready file payload from an extension status response.
- * @param {{ authenticated: boolean; email: string | null; optionsUrl: string }} status
- * @returns {{ status: string; email?: string | null; optionsUrl?: string }}
- */
-export function buildReadyPayload(status) {
-  if (status.authenticated) {
-    return { status: 'ok', email: status.email };
-  }
-  return { status: 'needs_login', optionsUrl: status.optionsUrl };
-}
+// ─── Readiness payload helpers ───────────────────────────────────────────────
 
 /**
  * Parses the ready file content into a status object.
- * Returns extension_not_installed on parse failure as a safe fallback.
+ * Throws for incomplete writes so startup can keep polling.
  * @param {string} raw
  * @returns {{ status: string; [key: string]: unknown }}
  */
 export function parseReadyPayload(raw) {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return { status: 'extension_not_installed' };
-  }
+  const payload = JSON.parse(raw);
+  if (!payload || typeof payload.status !== 'string') throw new Error('Invalid daemon readiness file');
+  return payload;
 }
 
-// ─── Serialized command queue ─────────────────────────────────────────────────
-
-/**
- * Creates a serialized command queue.
- * Commands are executed one at a time in FIFO order regardless of how many
- * socket clients are connected simultaneously. This prevents concurrent `run`
- * calls from racing inside the extension.
- *
- * @param {(cmd: Record<string, unknown>) => Promise<{id: string; success: boolean; data?: unknown; error?: string}>} handler
- * @returns {{ enqueue: (cmd: Record<string, unknown>) => Promise<{id: string; success: boolean; data?: unknown; error?: string}> }}
- */
-export function createCommandQueue(handler) {
-  const queue = [];
-  let processing = false;
-
-  async function processNext() {
-    if (processing || queue.length === 0) return;
-    processing = true;
-    const { cmd, resolve } = queue.shift();
-    try {
-      const result = await handler(cmd);
-      resolve(result);
-    } catch (err) {
-      resolve({ id: String(cmd.id ?? 'unknown'), success: false, error: err.message ?? String(err) });
-    } finally {
-      processing = false;
-      // Reason: .catch() prevents unhandled rejection from crashing the daemon
-      // if the recursive call fails before reaching its own try/catch
-      processNext().catch(() => {});
-    }
-  }
+// ─── Connected browser installations ──────────────────────────────────────────
 
-  return {
-    /**
-     * Enqueue a command and return a promise that resolves with the response.
-     * The returned Promise always resolves; errors are encoded as { success: false, error } values.
-     * @param {Record<string, unknown>} cmd
-     * @returns {Promise<{id: string; success: boolean; data?: unknown; error?: string}>}
-     */
-    enqueue(cmd) {
-      return new Promise((resolve) => {
-        queue.push({ cmd, resolve });
-        processNext().catch(() => {});
-      });
-    },
-  };
+/** A lost transport is not evidence that a browser action failed or stopped. */
+export function unknownToolOutcome(error) {
+  return Object.assign(new Error(`${error.message} Tool outcome unknown; it may still be running. Inspect the browser before retrying.`), { outcome: 'unknown' });
 }
 
-// ─── Connection registry ──────────────────────────────────────────────────────
-
-/**
- * Creates a registry of connected extension sockets, keyed by a unique label.
- * Replaces the daemon's old single-socket model so multiple Chrome profiles can
- * connect at once and commands can be routed to a chosen one by label.
- *
- * @returns {{
- *   add: (conn: { ws: any; label: string | null; installId: string; port: number }) => string;
- *   remove: (ws: any) => ({ label: string; installId: string } | null);
- *   getByWs: (ws: any) => (object | null);
- *   resolve: (target: string | null) => object;
- *   list: () => Array<{ label: string; port: number }>;
- *   size: () => number;
- * }}
- */
 export function createConnectionRegistry() {
-  /** @type {Map<string, { ws: any; label: string; installId: string; port: number; pending: Map<string, any> }>} */
   const conns = new Map();
-
-  // Reason: label is the routing key; if two profiles share a label, suffix the
-  // installId so a connection never silently fails to register (suffix > reject).
-  function uniqueKey(label) {
-    if (!conns.has(label)) return label;
-    let i = 2;
-    while (conns.has(`${label}#${i}`)) i++;
-    return `${label}#${i}`;
-  }
-
-  function labels() {
-    return [...conns.values()].map((c) => c.label);
-  }
-
   return {
-    /**
-     * Register a new extension connection. Returns the unique key (label) assigned.
-     * Duplicate labels are disambiguated by appending a numeric suffix.
-     * @param {{ ws: any; label: string | null; installId: string; port: number }} conn
-     * @returns {string}
-     */
     add({ ws, label, installId, port }) {
-      // Reason: on reconnect (port/label change) the new TCP connection can register
-      // before the daemon observes the old socket's close. Evict any stale entry for
-      // the same install first, so we don't end up with phantom duplicates (dev +
-      // dev#2) that make resolve(null) wrongly report "multiple profiles".
-      if (installId) {
-        for (const [k, c] of conns) {
-          if (c.installId === installId) { conns.delete(k); break; }
-        }
+      const id = installId || `legacy-${port}`;
+      const old = conns.get(id);
+      if (old) {
+        for (const pending of old.pending.values()) pending.reject(Object.assign(new Error('Extension reconnected; check the existing task before retrying.'), { outcome: 'unknown' }));
+        old.ws.close();
       }
-      // Reason: identity fallback chain — label, then installId, then port — so a
-      // connection is always addressable even if a legacy build reports neither.
-      const base =
-        (label && String(label).trim()) || (installId && String(installId).trim()) || String(port);
-      const key = uniqueKey(base);
-      conns.set(key, { ws, label: key, installId, port, pending: new Map() });
-      return key;
+      conns.set(id, { id, installId, label: label?.trim() || id, port, ws, pending: new Map() });
+      return id;
     },
-
-    /**
-     * Remove the connection associated with the given WebSocket.
-     * @param {any} ws
-     * @returns {{ label: string; installId: string } | null}
-     */
     remove(ws) {
-      for (const [key, c] of conns) {
-        if (c.ws === ws) {
-          conns.delete(key);
-          return { label: c.label, installId: c.installId };
-        }
-      }
-      return null;
-    },
-
-    /**
-     * Look up the registry entry for a given WebSocket (includes its pending map).
-     * @param {any} ws
-     * @returns {object | null}
-     */
-    getByWs(ws) {
-      for (const c of conns.values()) if (c.ws === ws) return c;
-      return null;
+      const entry = this.getByWs(ws);
+      if (entry) conns.delete(entry.id);
+      return entry ?? null;
     },
-
-    /**
-     * Resolve a target label to its registry entry.
-     * Passing null auto-resolves when exactly one connection is registered.
-     * Throws descriptive errors for no connections, ambiguity, or unknown label.
-     * @param {string | null} target
-     * @returns {object}
-     */
+    getByWs(ws) { return [...conns.values()].find((entry) => entry.ws === ws) ?? null; },
     resolve(target) {
-      if (conns.size === 0) throw new Error('No extension connected');
+      if (!conns.size) throw new Error('No extension connected. Open Dassi in Chrome, then retry.');
       if (target == null) {
         if (conns.size === 1) return [...conns.values()][0];
-        throw new Error(`Multiple profiles connected (${labels().join(', ')}). Specify --profile <label>.`);
+        throw new Error(`Multiple profiles connected (${[...conns.values()].map(e => e.label).join(', ')}). Copy a target from dassi list-tabs or use --profile <id>.`);
       }
-      const entry = conns.get(String(target));
-      if (!entry) throw new Error(`Unknown profile "${target}". Connected: ${labels().join(', ')}`);
-      return entry;
-    },
-
-    /**
-     * Returns a shallow list of all connected profiles (label + port only).
-     * @returns {Array<{ label: string; port: number }>}
-     */
-    list() {
-      return [...conns.values()].map((c) => ({ label: c.label, port: c.port }));
-    },
-
-    /**
-     * Returns the number of currently connected profiles.
-     * @returns {number}
-     */
-    size() {
-      return conns.size;
+      if (conns.has(String(target))) return conns.get(String(target));
+      const matches = [...conns.values()].filter(entry => entry.label === target);
+      if (matches.length === 1) return matches[0];
+      if (matches.length > 1) throw new Error(`Profile name "${target}" is ambiguous. Use a profile ID from dassi list-profiles.`);
+      throw new Error(`Unknown profile "${target}". Connected: ${[...conns.values()].map(e => `${e.label} (${e.id})`).join(', ')}`);
     },
+    list() { return [...conns.values()].map(({ id, label, port }) => ({ id, label, port })); },
+    size() { return conns.size; },
   };
 }

package/dassi.mjs

@@ -7,34 +7,29 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as child_process from 'child_process';
+import { randomUUID } from 'node:crypto';
 import { fileURLToPath, pathToFileURL } from 'url';
-import { getSocketPath, validateSession, getAppDir, getLaunchesFile } from './dassi-shared.mjs';
-import { ensureDaemonRunning, sendCommand, ensureDaemonReady } from './daemon-client.mjs';
+import { getSocketPath, validateSession, getAppDir, getLaunchesFile, CLI_VERSION } from './dassi-shared.mjs';
+import { ensureDaemonRunning, sendCommand, sendAndWait, ensureDaemonReady } from './daemon-client.mjs';
 import { dispatchLaunch } from './launch.mjs';
-import { parseToolCommand, requireTarget, parseStrictInt } from './tool-commands.mjs';
+import { parseToolCommand, requireTarget, parseStrictInt, parseTarget, parseWait } from './tool-commands.mjs';
 import { runWithGroupExpansion } from './group-expansion.mjs';
 import { formatResponse } from './format-response.mjs';
 import { HELP_TEXT } from './help-text.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const VERSION = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8')).version;
-
-// Reason: tests import isValidOptionsUrl from this module (it moved to
-// daemon-client.mjs with the rest of the daemon-client unit) — re-export to
-// keep the public surface and the tests unchanged.
-export { isValidOptionsUrl } from './daemon-client.mjs';
 
 // ─── Arg parsing ──────────────────────────────────────────────────────────────
 
 /**
  * Parses CLI arguments into a command descriptor.
- * Supports browser tool commands (navigate, click, fill, type, read-page, etc.),
+ * Supports live tool discovery and generic browser calls,
  * agent commands (run, list-tabs, status, raw), and top-level flags (--version, --help).
  * Run `dassi --help` for the full command reference.
  * @param {string[]} argv  process.argv.slice(2)
  * @returns {{ action: string; params: Record<string, unknown>; session: string; json: boolean; profile: string | null }}
  */
-export function parseCliArgs(argv) {
+export function parseCliArgs(argv, { interactive = false } = {}) {
   const args = [...argv];
 
   // Reason: hoist the `--` split to BEFORE global flag parsing so that Chrome
@@ -50,10 +45,10 @@ export function parseCliArgs(argv) {
   // Reason: handle --version and --help before any flag parsing so they work
   // even when other flags like --session are incomplete (e.g. `dassi --version --session`)
   if (consumeFlag(args, '--version')) {
-    return { action: 'version', params: {}, session: 'default', json: false, profile: null };
+    return { action: 'version', params: {}, session: 'default', json: args.includes('--json'), profile: null };
   }
   if (consumeFlag(args, '--help')) {
-    return { action: 'help', params: {}, session: 'default', json: false, profile: null };
+    return { action: 'help', params: {}, session: 'default', json: args.includes('--json'), profile: null };
   }
 
   const session = validateSession(getFlag(args, '--session') ?? process.env.DASSI_SESSION ?? 'default');
@@ -62,10 +57,15 @@ export function parseCliArgs(argv) {
 
   // Reason: centralise the return shape so every command branch includes profile
   // without editing each return individually
-  const finish = (action, params) => ({ action, params, session, json, profile });
+  const finish = (action, params) => {
+    if (args.length) throw new Error(`Unexpected argument: ${args[0]}. Run: dassi --help`);
+    const { profileTarget, ...rest } = params;
+    if (profile && profileTarget && profile !== profileTarget) throw new Error('Target includes a profile; omit --profile or use the same profile ID.');
+    return { action, params: rest, session, json, profile: profileTarget ?? profile };
+  };
 
-  const command = args.shift();
-  if (!command) throw new Error('No command specified. Run: dassi --help');
+  const command = args.shift() ?? (interactive && argv.length === 0 ? 'setup' : undefined);
+  if (!command) throw new Error('No command specified. Run dassi setup to connect Chrome, or dassi --help for commands.');
 
   // Reason: chromeArgs (tokens after `--`) are only meaningful for the `launch`
   // command. Any other command that supplies `--` tokens would have them silently
@@ -74,18 +74,34 @@ export function parseCliArgs(argv) {
     throw new Error("'--' is only valid with the launch command");
   }
 
+  if (command === 'setup') {
+    const waitRaw = getFlag(args, '--wait');
+    return finish('setup', { waitMs: parseWait(waitRaw ?? '5m'), noOpen: consumeFlag(args, '--no-open') });
+  }
+
+  if (command === 'skill') {
+    const pathOnly = consumeFlag(args, '--path');
+    const remove = consumeFlag(args, '--remove');
+    if (pathOnly && remove) throw new Error('Use either skill --path or skill --remove.');
+    return finish(remove ? 'remove_skill' : 'skill', remove ? {} : { pathOnly });
+  }
+
   if (command === 'list-tabs') {
-    const all = consumeFlag(args, '--all');
-    return finish('list_tabs', all ? { all: true } : {});
+    consumeFlag(args, '--all');
+    return finish('list_tabs', { all: true });
   }
 
   if (command === 'list-groups') {
-    const all = consumeFlag(args, '--all');
-    return finish('list_groups', all ? { all: true } : {});
+    consumeFlag(args, '--all');
+    return finish('list_groups', { all: true });
   }
 
-  if (command === 'status') {
-    return finish('status', {});
+  if (command === 'status' || command === 'stop') {
+    const waitRaw = getFlag(args, '--wait');
+    const taskId = args[0] && !args[0].startsWith('-') ? args.shift() : undefined;
+    if (!taskId && (command === 'stop' || waitRaw !== undefined)) throw new Error(`${command} requires a task ID`);
+    return finish(taskId ? (command === 'stop' ? 'task_stop' : 'task_status') : 'status',
+      taskId ? { taskId, ...(waitRaw !== undefined ? { waitMs: parseWait(waitRaw) } : {}) } : {});
   }
 
   if (command === 'list-profiles') {
@@ -140,10 +156,13 @@ export function parseCliArgs(argv) {
   if (command === 'run') {
     const prompt = args.shift();
     if (!prompt) throw new Error('run requires a prompt argument');
-    const target = requireTarget('run', args, getFlag);
-    const timeoutRaw = getFlag(args, '--timeout');
-    const timeoutMs = timeoutRaw ? parseStrictInt(timeoutRaw, '--timeout') : undefined;
-    const base = { prompt, ...(timeoutMs !== undefined ? { timeoutMs } : {}) };
+    const taskId = getFlag(args, '--task');
+    if (args.includes('--timeout')) throw new Error('run no longer accepts --timeout. Use --wait to wait locally, or stop <task-id> to cancel.');
+    if (taskId && ['--tab', '--group', '--group-title'].some(flag => args.includes(flag))) throw new Error('Use --task to continue its original browser context; omit tab/group selectors.');
+    const target = taskId ? { taskId } : requireTarget('run', args, getFlag);
+    const waitRaw = getFlag(args, '--wait');
+    const waitMs = waitRaw !== undefined ? parseWait(waitRaw) : 0;
+    const base = { prompt, ...(waitMs ? { waitMs } : {}) };
     return finish('run', { ...base, ...target });
   }
 
@@ -155,13 +174,13 @@ export function parseCliArgs(argv) {
   if (command === 'panel-screenshot') {
     const tabRaw = getFlag(args, '--tab');
     if (!tabRaw) throw new Error('panel-screenshot requires --tab <tabId>');
-    const tabId = parseStrictInt(tabRaw, '--tab');
+    const { id: tabId, ...target } = parseTarget(tabRaw, '--tab');
     const output = getFlag(args, '-o') ?? getFlag(args, '--output') ?? null;
     const widthRaw = getFlag(args, '--width');
     const heightRaw = getFlag(args, '--height');
     const width = widthRaw ? parseStrictInt(widthRaw, '--width') : undefined;
     const height = heightRaw ? parseStrictInt(heightRaw, '--height') : undefined;
-    return finish('panel_screenshot', { tabId, ...(output ? { _output: output } : {}), ...(width ? { width } : {}), ...(height ? { height } : {}) });
+    return finish('panel_screenshot', { tabId, ...target, ...(output ? { _output: output } : {}), ...(width ? { width } : {}), ...(height ? { height } : {}) });
   }
 
   if (command === 'raw') {
@@ -173,14 +192,18 @@ export function parseCliArgs(argv) {
     return finish('raw', cmd);
   }
 
-  // Reason: Tool commands are extracted to tool-commands.mjs to keep parseCliArgs
-  // and dassi.mjs within CLAUDE.md size limits (40 lines / 500 lines).
   const toolParams = parseToolCommand(command, args, getFlag, consumeFlag);
   if (toolParams) {
+    // Reason: some tool commands resolve to dedicated bridge methods rather
+    // than tool_exec (open --window → open_tab).
+    if (toolParams.__bridgeAction) {
+      const { __bridgeAction, ...params } = toolParams;
+      return finish(__bridgeAction, params);
+    }
     return finish('tool_exec', toolParams);
   }
 
-  throw new Error(`Unknown command: "${command}". Run: dassi --help`);
+  throw new Error(`Unknown command: "${command}". Browser commands use dassi tools and dassi call. Run: dassi --help`);
 }
 
 /**
@@ -217,56 +240,74 @@ function consumeFlag(args, flag) {
 
 // HELP_TEXT lives in ./help-text.mjs (extracted to keep this file within the size limit).
 
-/**
- * Handles --version and --help, which don't need a daemon. Returns true if handled.
- * @param {string} action
- * @returns {boolean}
- */
-function handleImmediateAction(action) {
-  if (action === 'version') {
-    console.log(VERSION);
-    process.exit(0);
-  }
-  if (action === 'help') {
-    console.log(HELP_TEXT);
-    process.exit(0);
-  }
-  return false;
+function handleImmediateAction({ action, params, json }) {
+  let text;
+  if (action === 'version') text = CLI_VERSION;
+  else if (action === 'help') text = HELP_TEXT;
+  else if (action === 'skill') {
+    const skillDir = path.join(__dirname, 'skills', 'dassi');
+    text = params.pathOnly ? skillDir : fs.readFileSync(path.join(skillDir, 'SKILL.md'), 'utf8');
+  } else return false;
+  console.log(json ? JSON.stringify({ success: true, data: text }) : text);
+  return true;
 }
 
 // ─── Entry point ──────────────────────────────────────────────────────────────
 
 /**
- * Main CLI entry point. Parses args, ensures daemon is running, handles
- * onboarding, sends command, prints response.
+ * Parses arguments, connects to the daemon, and prints the command result.
  * @returns {Promise<void>}
  */
-export async function run() {
+export async function run(argv = process.argv.slice(2)) {
   let parsed;
   try {
-    parsed = parseCliArgs(process.argv.slice(2));
+    parsed = parseCliArgs(argv, { interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY) });
+    await execute(parsed);
   } catch (err) {
-    console.error(err.message);
-    process.exit(1);
+    const args = argv.slice(0, argv.indexOf('--') === -1 ? argv.length : argv.indexOf('--'));
+    const json = parsed?.json ?? args.includes('--json');
+    const response = { success: false, error: err instanceof Error ? err.message : String(err), ...(err?.outcome === 'unknown' ? { outcome: 'unknown' } : {}) };
+    if (json) console.log(formatResponse('error', response, true));
+    else console.error(formatResponse('error', response, false));
+    process.exitCode = 1;
   }
+}
 
+async function execute(parsed) {
   const { action, params, session, json, profile } = parsed;
-  handleImmediateAction(action);
+  if (handleImmediateAction(parsed)) return;
+  if (action === 'remove_skill') {
+    const { unregisterSkills } = await import('./setup.mjs');
+    const skills = await unregisterSkills();
+    console.log(json ? JSON.stringify({ success: true, data: { skills } }) : [
+      ...skills.map(skill => `${skill.status}: ${skill.path}`),
+      'To remove the CLI, run: npm uninstall -g @dassi_ai/cli',
+    ].join('\n'));
+    return;
+  }
+  if (action === 'setup') {
+    const { setup, formatSetup } = await import('./setup.mjs');
+    const data = await setup({ ...params, profile, session, interactive: !json && Boolean(process.stdin.isTTY) });
+    const response = { success: data.ready, data, ...(!data.ready ? { error: data.next } : {}) };
+    console.log(json ? JSON.stringify(response) : formatSetup(data));
+    if (!data.ready) process.exitCode = 1;
+    return;
+  }
 
   // Launch family (launch / --stop / __launch-hold) → launch.mjs.
   if (await dispatchLaunch(action, params, { spawn: child_process.spawn, ensureDaemonRunning, getSocketPath, sendCommand, appDir: getAppDir(), launchesFile: getLaunchesFile() })) return;
 
   const socketPath = await ensureDaemonReady(session);
 
-  const id = `cli_${Date.now()}`;
+  const id = `cli_${randomUUID()}`;
 
   // Group expansion: if action=run or action=tool_exec with groupId/groupTitle, expand and fan out sequentially
   if (
     (action === 'run' || action === 'tool_exec') &&
     (params.groupId !== undefined || params.groupTitle !== undefined)
   ) {
-    const allOk = await runWithGroupExpansion(socketPath, action, params, json, sendCommand, formatResponse, profile);
-    if (!allOk) process.exit(1);
+    const allOk = await runWithGroupExpansion(socketPath, action, params, json, sendAndWait, formatResponse, profile);
+    if (!allOk) process.exitCode = 1;
     return;
   }
 
@@ -275,10 +316,10 @@ export async function run() {
   const command = action === 'raw'
     ? { id, ...params }
     : { id, action, ...params, ...(profile ? { target: profile } : {}) };
-  const response = await sendCommand(socketPath, command);
+  const response = await sendAndWait(socketPath, command);
 
   console.log(formatResponse(action, response, json, params));
-  if (!response.success) process.exit(1);
+  if (!response.success || (command.action !== 'task_stop' && ['failed', 'stopped'].includes(response.data?.status))) process.exitCode = 1;
 }
 
 // ── Entry point guard ─────────────────────────────────────────────────────────
@@ -309,8 +350,5 @@ export function isMainModule(metaUrl, argvPath) {
 }
 
 if (isMainModule(import.meta.url, process.argv[1])) {
-  run().catch((err) => {
-    console.error(`❌  ${err.message}`);
-    process.exit(1);
-  });
+  await run();
 }

package/format-response.mjs

@@ -8,13 +8,13 @@ import * as fs from 'fs';
 /** @param {{ success: boolean; data?: unknown }} response */
 function formatListTabs(response) {
   const tabs = /** @type {Array<{tabId:number;title:string;url:string;active:boolean}>} */ (response.data ?? []);
-  if (tabs.length === 0) return '(no open tabs)';
-  const header = 'TAB ID  TITLE                                    URL';
+  if (tabs.length === 0) return '(no open tabs — open Dassi in Chrome, then retry)';
+  const header = 'PROFILE          TARGET                                           TITLE / URL';
   const rows = tabs.map((t) => {
     const id = String(t.tabId).padEnd(7);
     const prefix = t.active ? '* ' : '  ';
     const title = (prefix + t.title).slice(0, 42).padEnd(42);
-    return `${id} ${title}  ${t.url}`;
+    return `${(t.profile ?? '').padEnd(16)} ${(t.target ?? id).padEnd(48)} ${title}  ${t.url}`;
   });
   return [header, ...rows].join('\n');
 }
@@ -23,22 +23,27 @@ function formatListTabs(response) {
 function formatListGroups(response) {
   const groups = /** @type {Array<{id:number;title:string;color:string;windowId:number;tabCount:number}>} */ (response.data ?? []);
   if (groups.length === 0) return '(no tab groups)';
-  const header = 'GROUP ID  COLOR    TABS   WINDOW   TITLE';
+  const header = 'PROFILE          TARGET                                           COLOR    TABS   WINDOW   TITLE';
   const rows = groups.map((g) => {
     const id = String(g.id).padEnd(9);
     const color = (g.color ?? '').padEnd(8);
     const tabs = String(g.tabCount).padEnd(6);
     const win = String(g.windowId).padEnd(8);
-    return `${id} ${color} ${tabs} ${win} ${g.title || '(untitled)'}`;
+    return `${(g.profile ?? '').padEnd(16)} ${(g.target ?? id).padEnd(48)} ${color} ${tabs} ${win} ${g.title || '(untitled)'}`;
   });
   return [header, ...rows].join('\n');
 }
 
 /** @param {{ success: boolean; data?: unknown }} response */
 function formatRun(response) {
-  const d = /** @type {{ answer?: string; toolCalls?: number; durationMs?: number }} */ (response.data ?? {});
-  const footer = `\n(${d.toolCalls ?? 0} tool calls, ${((d.durationMs ?? 0) / 1000).toFixed(1)}s)`;
-  return (d.answer ?? '') + footer;
+  const d = response.data ?? {};
+  if (!d.taskId) return `${d.answer ?? ''}\n(${d.toolCalls ?? 0} tool calls, ${((d.durationMs ?? 0) / 1000).toFixed(1)}s)`;
+  const status = d.status[0].toUpperCase() + d.status.slice(1);
+  const lines = [`${status} · ${Math.floor((d.durationMs ?? 0) / 60000)} minutes · ${d.profile ?? ''}`, `Task: ${d.taskId}`];
+  if (d.answer) lines.push(d.answer);
+  if (d.reason) lines.push(d.reason);
+  if (d.status === 'running' || d.status === 'stopping') lines.push(`Check: dassi status '${d.taskId}'`, `Stop:  dassi stop '${d.taskId}'`);
+  return lines.join('\n');
 }
 
 /**
@@ -99,13 +104,14 @@ function formatExportLogs(response, params) {
 function formatListProfiles(response) {
   const rows = /** @type {Array<{label:string;port:number}>} */ (response.data ?? []);
   if (rows.length === 0) return '(no profiles connected)';
-  const header = 'PROFILE                          PORT';
-  const body = rows.map((r) => `${String(r.label).padEnd(32)} ${r.port}`);
+  const header = 'PROFILE          ID                                    STATUS';
+  const body = rows.map((r) => `${String(r.label).padEnd(16)} ${String(r.id ?? r.port).padEnd(37)} ${r.error ?? (r.authenticated ? 'Signed in' : 'Sign in required')}`);
   return [header, ...body].join('\n');
 }
 
 /** @param {{ success: boolean; data?: unknown }} response */
 function formatStatus(response) {
+  if (Array.isArray(response.data)) return formatListProfiles(response);
   const d = /** @type {{ authenticated?: boolean; email?: string | null }} */ (response.data ?? {});
   if (d.authenticated) {
     return `✓  Signed in as ${d.email}`;
@@ -119,6 +125,9 @@ const FORMATTERS = {
   list_tabs: (r, _p, _a) => formatListTabs(r),
   list_groups: (r, _p, _a) => formatListGroups(r),
   run: (r, _p, _a) => formatRun(r),
+  task_status: (r) => formatRun(r),
+  task_stop: (r) => formatRun(r),
+  list_tools: (r) => Array.isArray(r.data) ? r.data.map(t => `${t.name}  ${t.description}`).join('\n') : JSON.stringify(r.data, null, 2),
   tool_exec: (r, p, a) => formatToolExec(r, p, a),
   panel_screenshot: (r, p, a) => formatToolExec(r, p, a),
   export_logs: (r, p, _a) => formatExportLogs(r, p),
@@ -138,7 +147,13 @@ export function formatResponse(action, response, rawJson, params) {
   if (rawJson) return JSON.stringify(response);
   if (!response.success) return `❌  Error: ${response.error ?? 'Unknown error'}`;
   const formatter = FORMATTERS[action];
-  if (formatter) return formatter(response, params, action);
+  if (formatter) {
+    const output = formatter(response, params, action);
+    const errors = ['list_tabs', 'list_groups'].includes(action)
+      ? (response.profiles ?? []).flatMap(p => [p.error, p.authError].filter(Boolean).map(error => `${p.label} (${p.id}): ${error}`))
+      : [];
+    return [output, ...errors].join('\n');
+  }
   // Default: pretty-print data
   return JSON.stringify(response.data, null, 2);
 }