@dassi_ai/cli 0.4.0 → 0.7.0

package/dassi.mjs

@@ -4,56 +4,52 @@
  * Protocol-compatible with agent-browser: {id, action, ...} → {id, success, data/error}
  */
 
-import * as net from 'net';
 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,
-  getReadyFile,
-  isDaemonRunning,
-  parseReadyPayload,
-  validateSession,
-  DASSI_EXTENSION_ID,
-  getAppDir,
-  getLaunchesFile,
-} from './dassi-shared.mjs';
+import { getSocketPath, validateSession, getAppDir, getLaunchesFile } 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 DAEMON_SCRIPT = path.join(__dirname, 'dassi-daemon.mjs');
 const VERSION = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8')).version;
-const READY_POLL_MS = 100;
-const READY_TIMEOUT_MS = 30_000;
-const LOGIN_POLL_MS = 2_000;
-const LOGIN_TIMEOUT_MS = 5 * 60_000;
-const CHROME_WEB_STORE_URL = `https://chromewebstore.google.com/detail/dassi-ai-browser-agent-fo/${DASSI_EXTENSION_ID}`;
 
 // ─── 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
+  // passthrough tokens like --json, --label, --profile, or --stop can never be
+  // mistakenly consumed as CLI flags. Everything after the first `--` token is
+  // sliced out here and stored verbatim in `chromeArgs`; the remaining `args`
+  // array is then parsed as usual with no risk of collision. Non-launch commands
+  // that supply a `--` separator are rejected loudly below (after the action is
+  // known) so callers get a clear error instead of silent data loss.
+  const sepIdx = args.indexOf('--');
+  const chromeArgs = sepIdx === -1 ? [] : args.splice(sepIdx).slice(1);
+
   // 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,23 +58,51 @@ 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() ?? (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
+  // dropped — fail loudly instead so the caller knows their intent was not honoured.
+  if (chromeArgs.length > 0 && command !== 'launch') {
+    throw new Error("'--' is only valid with the launch command");
+  }
 
-  const command = args.shift();
-  if (!command) throw new Error('No command specified. Run: dassi --help');
+  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') {
@@ -86,10 +110,16 @@ export function parseCliArgs(argv) {
   }
 
   if (command === 'launch') {
-    if (consumeFlag(args, '--stop-all')) return finish('launch_stop', { all: true });
+    if (consumeFlag(args, '--stop-all')) {
+      // Reason: chromeArgs with --stop-all makes no sense — reject to prevent confusion.
+      if (chromeArgs.length > 0) throw new Error("'--' chrome args cannot be combined with launch --stop-all");
+      return finish('launch_stop', { all: true });
+    }
     const stopIdx = args.indexOf('--stop');
     if (stopIdx !== -1) {
       args.splice(stopIdx, 1);
+      // Reason: chromeArgs with --stop makes no sense — reject to prevent confusion.
+      if (chromeArgs.length > 0) throw new Error("'--' chrome args cannot be combined with launch --stop");
       // Reason: resolve the stop label like the start path does — a positional
       // token after --stop wins, else the global --label/--profile (parsed into
       // `profile` before this branch), else the default. Keeps `--stop --label qa`
@@ -117,6 +147,7 @@ export function parseCliArgs(argv) {
       profileDir: getFlag(args, '--profile-dir') ?? null,
       loadMode,
       timeoutMs: timeoutRaw ? parseStrictInt(timeoutRaw, '--timeout') : 30000,
+      chromeArgs,
     });
   }
 
@@ -126,10 +157,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 });
   }
 
@@ -141,13 +175,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') {
@@ -159,14 +193,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`);
 }
 
 /**
@@ -199,258 +237,78 @@ function consumeFlag(args, flag) {
   return true;
 }
 
-// ─── Daemon management ────────────────────────────────────────────────────────
-
-/**
- * Ensures the daemon is running for the given session.
- * Spawns it as a detached background process if the PID file is missing or stale.
- * @param {string} session
- */
-export function ensureDaemonRunning(session) {
-  if (isDaemonRunning(session)) return;
-
-  // Reason: detached + unref means the daemon outlives the CLI process
-  const daemon = child_process.spawn(process.execPath, [DAEMON_SCRIPT], {
-    detached: true,
-    stdio: 'ignore',
-    env: { ...process.env, DASSI_SESSION: session },
-  });
-  daemon.unref();
-}
-
-/**
- * Polls for the ready file until it appears or the timeout elapses.
- * Resolves with the parsed ready payload.
- * @param {string} readyFile
- * @param {number} [timeoutMs]
- * @returns {Promise<{ status: string; [key: string]: unknown }>}
- */
-export function waitForReady(readyFile, timeoutMs = READY_TIMEOUT_MS) {
-  return new Promise((resolve, reject) => {
-    const deadline = Date.now() + timeoutMs;
-    const check = () => {
-      if (fs.existsSync(readyFile)) {
-        try {
-          resolve(parseReadyPayload(fs.readFileSync(readyFile, 'utf8')));
-          return;
-        } catch { /* file may be partially written — keep polling */ }
-      }
-      if (Date.now() >= deadline) {
-        const seconds = Math.round(timeoutMs / 1000);
-        reject(new Error(`Timed out waiting for Dassi daemon to start (${seconds}s)`));
-        return;
-      }
-      setTimeout(check, READY_POLL_MS);
-    };
-    check();
-  });
-}
-
-/**
- * Connects to the daemon Unix socket, sends one NDJSON command, and reads the response.
- * @param {string} socketPath - Unix socket path.
- * @param {object} command - Command object to send (will be JSON-stringified).
- * @returns {Promise<object>} Parsed response object.
- */
-export function sendCommand(socketPath, command) {
-  return new Promise((resolve, reject) => {
-    const socket = net.createConnection(socketPath);
-    let buffer = '';
-    let settled = false;
-
-    // Reason: guard against double-settlement since 'close' fires after socket.destroy()
-    // in the normal data path, and we don't want the close handler to re-resolve
-    const settle = (fn, val) => {
-      if (settled) return;
-      settled = true;
-      fn(val);
-    };
-
-    socket.on('connect', () => {
-      socket.write(JSON.stringify(command) + '\n');
-    });
-
-    socket.on('data', (chunk) => {
-      buffer += chunk.toString();
-      const nl = buffer.indexOf('\n');
-      if (nl !== -1) {
-        const line = buffer.slice(0, nl);
-        socket.destroy();
-        try { settle(resolve, JSON.parse(line)); }
-        catch { settle(reject, new Error(`Invalid JSON from daemon: ${line}`)); }
-      }
-    });
-
-    socket.on('error', (err) => settle(reject, err));
-
-    socket.on('close', () => {
-      if (settled) return;
-      // Reason: attempt to parse whatever arrived before the socket closed unexpectedly
-      if (buffer.trim()) {
-        try { settle(resolve, JSON.parse(buffer.trim())); }
-        catch { settle(reject, new Error(`Invalid JSON from daemon: ${buffer.trim()}`)); }
-      } else {
-        settle(reject, new Error('Daemon closed connection without a response'));
-      }
-    });
-  });
-}
-
-// ─── Login helpers ────────────────────────────────────────────────────────────
-
-/**
- * Defense-in-depth check for `optionsUrl` before handing it to the `open`
- * package. Legit URLs always come from `chrome.runtime.getURL('options.html')`
- * → `chrome-extension://<id>/options.html`. Anything else is unexpected and
- * we should not auto-launch it (the `open` package shells out to the OS URL
- * handler).
- * @param {unknown} optionsUrl
- * @returns {boolean}
- */
-export function isValidOptionsUrl(optionsUrl) {
-  return typeof optionsUrl === 'string' && /^chrome-extension:\/\/[a-z]{32}\//.test(optionsUrl);
-}
-
-/**
- * Polls the daemon's status until the user signs in (extension reports
- * authenticated=true) or the LOGIN_TIMEOUT_MS deadline elapses. On entry,
- * best-effort auto-opens the extension's options page (subject to the
- * isValidOptionsUrl guard above).
- * @param {string} socketPath - Path to the daemon Unix socket.
- * @param {string | undefined} optionsUrl - URL of the Dassi options page.
- * @returns {Promise<void>} Resolves on successful login; throws on timeout.
- */
-export async function waitForLogin(socketPath, optionsUrl) {
-  console.error(`⚠️  Dassi is installed but you're not signed in.\n    Opening the Dassi settings page...\n`);
-
-  // Auto-open the options page — best-effort (package may not be installed).
-  // Reason: only open URLs the extension would legitimately produce
-  // (chrome.runtime.getURL → `chrome-extension://<id>/options.html`).
-  // Defense-in-depth: even though optionsUrl is sourced from the daemon's
-  // ready file (which lives in our owner-only ~/.dassi/ dir), validating the
-  // protocol prevents `open` from launching arbitrary URIs/shell-handlers if
-  // the file is ever tampered with.
-  if (isValidOptionsUrl(optionsUrl)) {
-    try {
-      const { default: open } = await import('open');
-      await open(String(optionsUrl));
-    } catch {
-      console.error(`    Please open: ${optionsUrl}`);
-    }
-  } else if (optionsUrl) {
-    console.error(`    Refusing to auto-open unexpected URL: ${optionsUrl}\n    Please open the Dassi settings page manually.`);
-  }
-
-  // Poll the daemon socket every LOGIN_POLL_MS until authenticated
-  console.error('    Waiting for sign-in... (Ctrl+C to cancel)');
-  const deadline = Date.now() + LOGIN_TIMEOUT_MS;
-  let pollIndex = 0;
-  while (Date.now() < deadline) {
-    await new Promise((r) => setTimeout(r, LOGIN_POLL_MS));
-    try {
-      // Reason: increment poll index so each status request has a unique id for tracing
-      const resp = await sendCommand(socketPath, { id: `poll-auth-${pollIndex++}`, action: 'status' });
-      if (resp.success && resp.data?.authenticated) {
-        console.error(`    ✓  Signed in as ${resp.data.email}\n    ✓  Ready\n`);
-        return;
-      }
-    } catch { /* daemon may not be socket-ready yet — keep polling */ }
-  }
-
-  throw new Error('Login timed out. Please sign in and try again.');
-}
-
 // ─── Immediate actions ────────────────────────────────────────────────────────
 
 // 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;
-}
-
-// ─── Daemon readiness ─────────────────────────────────────────────────────────
-
-/**
- * Ensures the daemon is running and ready, handling onboarding if needed.
- * @param {string} session
- * @returns {Promise<string>} The daemon's Unix socket path.
- */
-async function ensureDaemonReady(session) {
-  const socketPath = getSocketPath(session);
-  const readyFile = getReadyFile(session);
-
-  // Reason: delete any stale ready file from a previous run so the new daemon
-  // writes a fresh one. Skip if a daemon is already running to avoid racing.
-  if (!isDaemonRunning(session)) {
-    try { fs.unlinkSync(readyFile); } catch { /* ok if missing */ }
-  }
-
-  ensureDaemonRunning(session);
-
-  const ready = await waitForReady(readyFile);
-
-  if (ready.status === 'extension_not_installed') {
-    console.error(
-      `❌  Dassi extension not detected.\n\n` +
-      `   Install it from:\n   ${CHROME_WEB_STORE_URL}\n\n` +
-      `   Then run this command again.`
-    );
-    process.exit(1);
-  }
-
-  if (ready.status === 'needs_login') {
-    await waitForLogin(socketPath, ready.optionsUrl ? String(ready.optionsUrl) : undefined);
-  }
-
-  return socketPath;
+function handleImmediateAction({ action, params, json }) {
+  let text;
+  if (action === 'version') text = 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;
   }
 
@@ -459,10 +317,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 ─────────────────────────────────────────────────────────
@@ -493,8 +351,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);
 }