@dassi_ai/cli 0.5.0 → 0.7.0

package/dassi.mjs

@@ -7,11 +7,12 @@
 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 { 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';
@@ -19,22 +20,17 @@ 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 +46,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 +58,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 +75,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 +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 });
   }
 
@@ -155,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') {
@@ -173,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`);
 }
 
 /**
@@ -217,56 +241,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 = 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 +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 ─────────────────────────────────────────────────────────
@@ -309,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);
 }

package/group-expansion.mjs

@@ -5,6 +5,7 @@
  */
 
 import * as path from 'path';
+import { randomUUID } from 'node:crypto';
 
 /**
  * Inject `tabId` into a filename before the extension so multi-tab fan-out
@@ -52,8 +53,9 @@ export async function expandGroupToTabIds(socketPath, ref, sendFn, target = null
   // `{ id, action, ...rest } = cmd` and forwards `rest` as JSON-RPC params,
   // so nesting under `params` would arrive at the extension as
   // `params.params.all` — and the filter would NOT bypass.
-  const groupsResp = await sendFn(socketPath, { id: `cli_lg_${Date.now()}`, action: 'list_groups', all: true, ...targetField });
+  const groupsResp = await sendFn(socketPath, { id: `cli_lg_${randomUUID()}`, action: 'list_groups', all: true, ...targetField });
   if (!groupsResp.success) throw new Error(`Failed to list groups: ${groupsResp.error ?? 'unknown'}`);
+  if (!target && groupsResp.profiles?.length > 1) throw new Error('Choose a profile with --profile <id>, or copy a group target from dassi list-groups.');
   const groups = /** @type {Array<{id:number;title:string;windowId:number}>} */ (groupsResp.data ?? []);
 
   let groupId;
@@ -74,7 +76,7 @@ export async function expandGroupToTabIds(socketPath, ref, sendFn, target = null
     throw new Error('expandGroupToTabIds: pass groupId or groupTitle');
   }
 
-  const tabsResp = await sendFn(socketPath, { id: `cli_lt_${Date.now()}`, action: 'list_tabs', all: true, ...targetField });
+  const tabsResp = await sendFn(socketPath, { id: `cli_lt_${randomUUID()}`, action: 'list_tabs', all: true, ...targetField });
   if (!tabsResp.success) throw new Error(`Failed to list tabs: ${tabsResp.error ?? 'unknown'}`);
   const tabs = /** @type {Array<{tabId:number;groupId:number}>} */ (tabsResp.data ?? []);
   const memberIds = tabs.filter((t) => t.groupId === groupId).map((t) => t.tabId);
@@ -113,7 +115,7 @@ async function dispatchChildForTab(socketPath, action, childBase, tabId, multiTa
     multiTab && childBase._output ? uniquifyOutputForTab(childBase._output, tabId) : childBase._output;
   const childParams = { ...childBase, tabId, ...(perTabOutput !== childBase._output ? { _output: perTabOutput } : {}) };
   // Reason: include target only when set so the fan-out routes to the chosen profile.
-  const response = await sendFn(socketPath, { id: `cli_${Date.now()}_${tabId}`, action, ...childParams, ...(target ? { target } : {}) });
+  const response = await sendFn(socketPath, { id: `cli_${randomUUID()}`, action, ...childParams, ...(target ? { target } : {}) });
   return { tabId, response, childParams };
 }
 
@@ -144,6 +146,13 @@ export async function runWithGroupExpansion(socketPath, action, params, json, se
     sendFn,
     target,
   );
+  // One group is one conversation: submit an agent prompt once for the whole workspace.
+  if (action === 'run') {
+    const { groupId: _group, groupTitle: _title, ...base } = params;
+    const { response } = await dispatchChildForTab(socketPath, action, base, tabIds[0], false, sendFn, target);
+    console.log(formatFn(action, response, json, base));
+    return response.success && !['failed', 'stopped'].includes(response.data?.status);
+  }
   // Reason: always on stderr so it doesn't pollute JSON output on stdout
   console.error(`Running on ${tabIds.length} tab${tabIds.length === 1 ? '' : 's'}: ${tabIds.join(', ')}`);
   // Strip group fields; substitute tabId per child call

package/help-text.mjs

@@ -1,48 +1,59 @@
-/**
- * `dassi --help` output. Extracted from dassi.mjs to keep that file within the
- * CLAUDE.md size limit; this is pure presentation with no runtime dependencies.
- */
-export const HELP_TEXT =
-  'Usage: dassi [options] <command>\n\n' +
-  'Browser commands (each accepts --tab <id> | --group <id> | --group-title <name>):\n' +
-  '  navigate <url> --tab <id>       Navigate to URL\n' +
-  '  click <ref> --tab <id>          Click element by ref\n' +
-  '  fill <ref> <text> --tab <id>    Fill input with text (instant)\n' +
-  '  type <ref> <text> --tab <id>    Type text with keyboard events\n' +
-  '  read-page --tab <id>            Read page accessibility tree\n' +
-  '  get-text --tab <id>             Extract page text\n' +
-  '  screenshot --tab <id> [-o file]  Capture viewport screenshot\n' +
-  '  panel-screenshot --tab <id> [-o f] [--width W] [--height H]\n' +
-  '                                     Capture side panel UI (default 360x800)\n' +
-  '  eval <code> --tab <id>          Execute JavaScript\n' +
-  '  tabs --tab <id>                 List tabs in same group\n' +
-  '  open [url] --tab <id>           Open new tab in group\n' +
-  '  close --tab <id>                Close tab\n\n' +
-  'Agent commands:\n' +
-  '  run <prompt> --tab <id> | --group <id> | --group-title <name>\n' +
-  '                                  Run AI agent on a tab or group (group = sequential)\n' +
-  '  list-tabs [--all]               List tabs in groups dassi has open (--all = every Chrome tab)\n' +
-  '  list-groups [--all]             List dassi-open tab groups (--all = every Chrome group)\n' +
-  '  list-profiles                   List connected profiles (Chrome instances)\n' +
-  '  status                          Check extension status\n' +
-  '  bug-report [-o file]             Export debug logs from all contexts\n' +
-  '  raw <json>                      Send raw JSON command\n' +
-  '  launch [--label <name>] [--dist <path>] [--chrome <path>]\n' +
-  '         [--load-mode auto|pipe|flag] [-- <chrome args…>]\n' +
-  '                                  Open Chrome with a dev dist loaded\n' +
-  '                                  (args after -- go to Chrome, e.g. --headless=new)\n' +
-  '  launch --stop [label] | --stop-all\n' +
-  '                                  Stop a launched Chrome\n\n' +
-  'Options:\n' +
-  '  --tab <id>        Chrome tab ID (use list-tabs to find)\n' +
-  '  --all             list-tabs/list-groups: include every Chrome tab/group\n' +
-  '  --timeout <ms>    Timeout for run command (default: 300000)\n' +
-  '  --session <name>  Daemon session name (default: "default")\n' +
-  '  --profile <label> Target a specific connected profile (alias: --label)\n' +
-  '  --json            Output raw JSON\n' +
-  '  --filter <type>   Filter for read-page (interactive|all)\n' +
-  '  --depth <n>       Depth for read-page tree\n' +
-  '  --await           Await promise in eval\n' +
-  '  -o, --output <f>  Output file for screenshot\n' +
-  '  --version         Show version\n' +
-  '  --help            Show help';
+export const HELP_TEXT = `Usage: dassi [command] [options]
+
+Start here:
+  dassi                          Start setup in an interactive terminal
+  setup                          Install agent skills and connect your Chrome profile
+  skill                          Read the local-agent workflow (no browser needed)
+  list-tabs                      Show tabs across connected profiles; copy a TARGET
+  run <prompt> --tab <target>     Start a new task and return its ID
+  run <prompt> --task <task-id>   Continue that conversation (queues a follow-up if busy)
+  status <task-id>                Show progress or the finished result
+  stop <task-id>                  Stop that task
+
+Options:
+  --wait <duration>              Wait for a result (30s, 10m, 1h); never stops the task
+  --profile <id-or-name>          Choose a profile for unscoped tab/group IDs
+  --json                         Machine-readable output
+  --help                         Show help
+  --version                      Show version
+
+Agent setup:
+  setup [--profile id]           Resume setup for the chosen profile
+  setup --wait 0 --json          Check setup immediately; report any user action needed
+  setup --no-open                Print browser instructions without opening Chrome
+  skill --path                   Print the bundled skill directory for installation
+  skill --remove                 Remove Dassi's registered agent skill links
+
+Update / remove:
+  npm install -g @dassi_ai/cli@latest    Update the CLI and its bundled agent skill
+  dassi skill --remove                  Unregister the agent skill
+  npm uninstall -g @dassi_ai/cli         Remove the npm package
+
+Browser tools:
+  tools [name] --tab <target>     Discover current tools or read one tool's schema
+  call <name> --tab <target>      Execute a discovered tool with --args '<json>'
+  call ... [-o file]             Save returned images (omit --json to write files)
+  panel-screenshot [-o file]     Capture Dassi (--tab, --width, --height)
+  open [url] --window <id>       Create an ungrouped tab (--foreground to activate)
+
+Other commands:
+  list-profiles                  Show profile IDs, labels, and sign-in status
+  list-groups                    Show groups with profile-bound targets
+  status                         Show connected profiles and their status
+  bug-report [-o file]            Export diagnostic logs
+  raw <json>                     Send a bridge command
+
+Groups:
+  run <prompt> --group <target>   Start one task for the whole group
+  --group-title <name>           Select a group by name (use --profile if needed)
+  call also accepts group targets and executes once per member tab.
+
+Development:
+  launch [--label name] [--dist path] [--chrome path]
+         [--load-mode auto|pipe|flag] [-- <chrome args>]
+  launch --stop [label] | --stop-all
+
+Browser aliases such as read-page and click have been replaced by tools and call.
+run rejects the old --timeout flag. Use --wait for local waiting; stop to cancel.
+A wait ending or terminal disconnecting does not cancel browser work.
+`;

package/launch.mjs

@@ -255,7 +255,7 @@ export async function handleLaunch(opts, deps) {
   if (pid === null) return exit(1);
 
   recordLaunch(launchesFile, { label: opts.label, pid, profileDir, mode: useFlag ? 'flag' : 'pipe', startedAt: Date.now() });
-  log(`✅  launched "${opts.label}" (pid ${pid}) — drive it with: dassi run "…" --profile ${opts.label}`);
+  log(`✅  launched "${opts.label}" (pid ${pid}) — find targets with: dassi list-tabs --profile ${opts.label}`);
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dassi_ai/cli",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "CLI for the Dassi Chrome extension \u2014 run browser automation from the terminal",
   "type": "module",
   "bin": {
@@ -16,6 +16,7 @@
     "group-expansion.mjs",
     "launch.mjs",
     "_launch-pipe.mjs",
+    "setup.mjs",
     "help-text.mjs",
     ".claude-plugin/",
     "skills/",
@@ -32,7 +33,6 @@
     "email": "team@dassi.ai"
   },
   "dependencies": {
-    "open": "^10.1.0",
     "ws": "^8.18.0"
   },
   "devDependencies": {