@dassi_ai/cli 0.1.0

package/dassi.mjs

@@ -0,0 +1,425 @@
+#!/usr/bin/env node
+/**
+ * Dassi CLI — thin client that talks to the daemon over a Unix socket.
+ * 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 { fileURLToPath, pathToFileURL } from 'url';
+import {
+  getSocketPath,
+  getReadyFile,
+  isDaemonRunning,
+  parseReadyPayload,
+  validateSession,
+} from './dassi-shared.mjs';
+import { parseToolCommand, requireTarget, parseStrictInt } from './tool-commands.mjs';
+import { runWithGroupExpansion } from './group-expansion.mjs';
+import { formatResponse } from './format-response.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/bjcngahpcjeililljmfegmlanlpgibdi';
+
+// ─── Arg parsing ──────────────────────────────────────────────────────────────
+
+/**
+ * Parses CLI arguments into a command descriptor.
+ * Supports browser tool commands (navigate, click, fill, type, read-page, etc.),
+ * 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 }}
+ */
+export function parseCliArgs(argv) {
+  const args = [...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 };
+  }
+  if (consumeFlag(args, '--help')) {
+    return { action: 'help', params: {}, session: 'default', json: false };
+  }
+
+  const session = validateSession(getFlag(args, '--session') ?? process.env.DASSI_SESSION ?? 'default');
+  const json = consumeFlag(args, '--json');
+
+  const command = args.shift();
+  if (!command) throw new Error('No command specified. Run: dassi --help');
+
+  if (command === 'list-tabs') {
+    return { action: 'list_tabs', params: {}, session, json };
+  }
+
+  if (command === 'list-groups') {
+    return { action: 'list_groups', params: {}, session, json };
+  }
+
+  if (command === 'status') {
+    return { action: 'status', params: {}, session, json };
+  }
+
+  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 } : {}) };
+    return { action: 'run', params: { ...base, ...target }, session, json };
+  }
+
+  if (command === 'bug-report') {
+    const output = getFlag(args, '-o') ?? getFlag(args, '--output');
+    return { action: 'export_logs', params: { output }, session, json };
+  }
+
+  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 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 { action: 'panel_screenshot', params: { tabId, ...(output ? { _output: output } : {}), ...(width ? { width } : {}), ...(height ? { height } : {}) }, session, json };
+  }
+
+  if (command === 'raw') {
+    const rawArg = args.shift();
+    if (!rawArg) throw new Error('raw requires a JSON string argument');
+    const cmd = JSON.parse(rawArg);
+    // Reason: store action='raw' as a sentinel so run() can send the full cmd envelope
+    // verbatim, letting the user control every field (including action) without reconstruction
+    return { action: 'raw', params: cmd, session, json };
+  }
+
+  // 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) {
+    return { action: 'tool_exec', params: toolParams, session, json };
+  }
+
+  throw new Error(`Unknown command: "${command}". Run: dassi --help`);
+}
+
+/**
+ * Extracts --flag <value> from args array (mutates array, removes both tokens).
+ * @param {string[]} args
+ * @param {string} flag
+ * @returns {string | undefined}
+ */
+function getFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx === -1) return undefined;
+  if (idx + 1 >= args.length || String(args[idx + 1]).startsWith('--')) {
+    throw new Error(`Flag ${flag} requires a value`);
+  }
+  const val = args[idx + 1];
+  args.splice(idx, 2);
+  return val;
+}
+
+/**
+ * Removes a boolean flag from args array (mutates). Returns true if it was present.
+ * @param {string[]} args
+ * @param {string} flag
+ * @returns {boolean}
+ */
+function consumeFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx === -1) return false;
+  args.splice(idx, 1);
+  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 ────────────────────────────────────────────────────────────
+
+/**
+ * Handles the `needs_login` onboarding flow: opens the options page in the
+ * default browser, then polls the daemon socket until the user authenticates
+ * or the timeout elapses.
+ * @param {string} socketPath  Unix socket path for the daemon
+ * @param {string | undefined} optionsUrl  URL of the Dassi options page to open
+ * @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)
+  try {
+    const { default: open } = await import('open');
+    if (optionsUrl) await open(String(optionsUrl));
+  } catch {
+    console.error(`    Please open: ${optionsUrl}`);
+  }
+
+  // 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 ────────────────────────────────────────────────────────
+
+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                       List all open Chrome tabs\n' +
+  '  list-groups                     List Chrome tab groups (with tab counts)\n' +
+  '  status                          Check extension status\n' +
+  '  bug-report [-o file]             Export debug logs from all contexts\n' +
+  '  raw <json>                      Send raw JSON command\n\n' +
+  'Options:\n' +
+  '  --tab <id>        Chrome tab ID (use list-tabs to find)\n' +
+  '  --timeout <ms>    Timeout for run command (default: 300000)\n' +
+  '  --session <name>  Daemon session name (default: "default")\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';
+
+/**
+ * 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;
+}
+
+// ─── Entry point ──────────────────────────────────────────────────────────────
+
+/**
+ * Main CLI entry point. Parses args, ensures daemon is running, handles
+ * onboarding, sends command, prints response.
+ * @returns {Promise<void>}
+ */
+export async function run() {
+  let parsed;
+  try {
+    parsed = parseCliArgs(process.argv.slice(2));
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+
+  const { action, params, session, json } = parsed;
+  handleImmediateAction(action);
+
+  const socketPath = await ensureDaemonReady(session);
+
+  const id = `cli_${Date.now()}`;
+
+  // 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);
+    if (!allOk) process.exit(1);
+    return;
+  }
+
+  // Reason: for 'raw' the user controls the full envelope — send params verbatim
+  const command = action === 'raw' ? { id, ...params } : { id, action, ...params };
+  const response = await sendCommand(socketPath, command);
+
+  console.log(formatResponse(action, response, json, params));
+  if (!response.success) process.exit(1);
+}
+
+// ── Entry point guard ─────────────────────────────────────────────────────────
+// Reason: guard allows this file to be imported by tests without running the CLI
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  run().catch((err) => {
+    console.error(`❌  ${err.message}`);
+    process.exit(1);
+  });
+}

package/format-response.mjs

@@ -0,0 +1,134 @@
+/**
+ * Response formatting for the Dassi CLI.
+ * Converts daemon responses into human-readable terminal output.
+ */
+
+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';
+  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 [header, ...rows].join('\n');
+}
+
+/** @param {{ success: boolean; data?: unknown }} 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 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 [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;
+}
+
+/**
+ * Formats tool_exec and panel_screenshot results.
+ * Tool results from pi-agent-core have a { content: [{type, text/data}] } shape.
+ * @param {{ success: boolean; data?: unknown }} response
+ * @param {Record<string, unknown>} [params]
+ * @param {string} action
+ */
+function formatToolExec(response, params, action) {
+  const data = response.data;
+  if (data && typeof data === 'object' && Array.isArray(data.content)) {
+    const defaultPrefix = action === 'panel_screenshot' ? 'panel-screenshot' : 'screenshot';
+    const parts = [];
+    for (const item of data.content) {
+      if (item.type === 'text') {
+        parts.push(item.text);
+      } else if (item.type === 'image' && item.data) {
+        // Reason: Save image to file like agent-browser does. Use _output param if provided,
+        // otherwise generate a timestamped filename.
+        const ext = item.mimeType === 'image/png' ? 'png' : 'jpg';
+        const outputPath = params?._output ?? `${defaultPrefix}-${Date.now()}.${ext}`;
+        try {
+          fs.writeFileSync(outputPath, Buffer.from(item.data, 'base64'));
+          parts.push(`Saved ${outputPath}`);
+        } catch (err) {
+          parts.push(`[Failed to save image: ${err.message}]`);
+        }
+      } else {
+        parts.push(`[${item.type ?? 'unknown'} content omitted]`);
+      }
+    }
+    return parts.join('\n');
+  }
+  return JSON.stringify(data, null, 2);
+}
+
+/**
+ * @param {{ success: boolean; data?: unknown }} response
+ * @param {Record<string, unknown>} [params]
+ */
+function formatExportLogs(response, params) {
+  const data = response.data;
+  const logsJson = JSON.stringify(data, null, 2);
+  const outputPath = params?.output ?? `dassi-debug-logs-${Date.now()}.json`;
+  try {
+    fs.writeFileSync(outputPath, logsJson);
+    const sources = data?.sources ?? {};
+    const total = data?.totalEntries ?? '?';
+    const summary = Object.entries(sources).map(([k, v]) => `${k}=${v}`).join(', ');
+    return `✓  Saved ${total} log entries to ${outputPath}\n   Sources: ${summary}`;
+  } catch (err) {
+    return `❌  Failed to save: ${err.message}\n${logsJson}`;
+  }
+}
+
+/** @param {{ success: boolean; data?: unknown }} response */
+function formatStatus(response) {
+  const d = /** @type {{ authenticated?: boolean; email?: string | null }} */ (response.data ?? {});
+  if (d.authenticated) {
+    return `✓  Signed in as ${d.email}`;
+  }
+  return '✗  Not signed in';
+}
+
+// Reason: dispatch table keeps formatResponse small (~10 lines) and lets each
+// action's formatting logic live in a focused, ≤40-line helper.
+const FORMATTERS = {
+  list_tabs: (r, _p, _a) => formatListTabs(r),
+  list_groups: (r, _p, _a) => formatListGroups(r),
+  run: (r, _p, _a) => formatRun(r),
+  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),
+  status: (r, _p, _a) => formatStatus(r),
+};
+
+/**
+ * Formats a daemon response for terminal output.
+ * @param {string} action
+ * @param {{ success: boolean; data?: unknown; error?: string }} response
+ * @param {boolean} rawJson  When true, outputs the raw JSON response
+ * @param {Record<string, unknown>} [params]  Original command params (used for screenshot output path)
+ * @returns {string}
+ */
+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);
+  // Default: pretty-print data
+  return JSON.stringify(response.data, null, 2);
+}