@dassi_ai/cli 0.1.2 → 0.2.0

package/README.md

@@ -47,6 +47,13 @@ dassi list-tabs --json
 # Use a named session
 dassi list-tabs --session work
 
+# List connected profiles (multiple Chrome profiles can connect at once)
+dassi list-profiles
+
+# Target a specific profile by label when more than one is connected
+dassi list-tabs --profile dev
+dassi run "summarize" --tab 456 --profile dev   # alias: --label
+
 # Show version / help
 dassi --version
 dassi --help

package/dassi-daemon.mjs

@@ -24,6 +24,7 @@ import {
   cleanupDaemonFiles,
   buildReadyPayload,
   createCommandQueue,
+  createConnectionRegistry,
 } from './dassi-shared.mjs';
 
 // ─── Constants ────────────────────────────────────────────────────────────────
@@ -31,12 +32,9 @@ import {
 const IDLE_TIMEOUT_MS = 30 * 60 * 1000;
 const IDLE_CHECK_INTERVAL_MS = 5 * 60 * 1000;
 
-// ─── Module-level extension connection state ──────────────────────────────────
-
-/** Active WebSocket connection to the registered Dassi extension. */
-let extensionSocket = null;
-/** Pending response callbacks keyed by request ID. */
-const pendingExtResponses = new Map();
+// Reason: a registry of connected extensions keyed by profile label replaces
+// the old single-socket model so multiple Chrome profiles can connect at once.
+const registry = createConnectionRegistry();
 
 // ─── WebSocket loader helper ──────────────────────────────────────────────────
 
@@ -62,17 +60,16 @@ async function loadWebSocket() {
 // ─── Extension response routing ──────────────────────────────────────────────
 
 /**
- * Sets up the persistent message handler on the extension WebSocket that routes
- * responses back to callers waiting in pendingExtResponses.
- * @param {import('ws').WebSocket} ws
+ * Route responses from one extension connection back to its pending callers.
+ * @param {{ ws: any; pending: Map<string, any> }} entry
  */
-function setupResponseRouter(ws) {
-  ws.on('message', (responseData) => {
+function setupResponseRouter(entry) {
+  entry.ws.on('message', (responseData) => {
     let resp;
     try { resp = JSON.parse(responseData.toString()); } catch { return; }
-    const pending = pendingExtResponses.get(String(resp.id));
+    const pending = entry.pending.get(String(resp.id));
     if (!pending) return;
-    pendingExtResponses.delete(String(resp.id));
+    entry.pending.delete(String(resp.id));
     if (resp.error) {
       pending.reject(new Error(resp.error.message ?? String(resp.error)));
     } else {
@@ -82,38 +79,37 @@ function setupResponseRouter(ws) {
 }
 
 /**
- * Reject all pending extension responses with a disconnection error.
- * Called when the extension WebSocket closes so callers don't hang forever.
+ * Reject all pending responses for one connection (called when it closes).
+ * @param {{ pending: Map<string, any> }} entry
  */
-function drainPendingResponses() {
-  for (const [id, pending] of pendingExtResponses) {
+function drainPendingResponses(entry) {
+  for (const [id, pending] of entry.pending) {
     pending.reject(new Error('Extension disconnected'));
-    pendingExtResponses.delete(id);
+    entry.pending.delete(id);
   }
 }
 
 // ─── Extension server ─────────────────────────────────────────────────────────
 
 /**
- * Accepts a newly registered extension WebSocket: replaces any existing socket,
- * drains pending responses from the old connection, and wires up the new one.
- * @param {import('ws').WebSocket} ws - The new WebSocket connection.
+ * Register a newly connected extension socket into the registry and wire up
+ * its response router + close handler.
+ * @param {any} ws
+ * @param {{ label: string | null; installId: string }} identity
+ * @param {number} port - The port this daemon session listens on.
+ * @returns {object} The registry entry.
  */
-function acceptExtensionSocket(ws) {
-  // Reason: if an old socket exists, close it cleanly before replacing
-  if (extensionSocket && extensionSocket !== ws) {
-    try { extensionSocket.close(); } catch { /* already closed */ }
-  }
-  drainPendingResponses();
-  extensionSocket = ws;
+function acceptExtensionSocket(ws, identity, port) {
+  const key = registry.add({ ws, label: identity.label, installId: identity.installId, port });
+  const entry = registry.getByWs(ws);
   ws.on('close', () => {
-    if (extensionSocket === ws) {
-      extensionSocket = null;
-      drainPendingResponses();
-      console.log('[dassi-daemon] Extension disconnected, waiting for reconnect…');
-    }
+    const removed = registry.remove(ws);
+    drainPendingResponses(entry);
+    if (removed) console.log(`[dassi-daemon] Extension "${removed.label}" disconnected`);
   });
-  setupResponseRouter(ws);
+  setupResponseRouter(entry);
+  console.log(`[dassi-daemon] Extension registered as "${key}"`);
+  return entry;
 }
 
 /**
@@ -123,39 +119,37 @@ function acceptExtensionSocket(ws) {
  * @param {import('ws').WebSocket} ws - The connected WebSocket.
  * @param {Buffer} data - Raw message data.
  * @param {{ resolved: boolean; timeout: ReturnType<typeof setTimeout> }} ctx - Shared state.
- * @param {import('ws').WebSocketServer} wss - The server (closed on fatal error).
  * @param {(value: unknown) => void} resolve - Promise resolve callback.
  * @param {(reason: Error) => void} reject - Promise reject callback.
+ * @param {number} port - The port the WS server is bound to.
  */
-async function handleRegistration(ws, data, ctx, wss, resolve, reject) {
+async function handleRegistration(ws, data, ctx, resolve, reject, port) {
   let msg;
   try { msg = JSON.parse(data.toString()); } catch { return; }
   if (msg.type !== 'register' || msg.client !== 'dassi-extension') return;
 
-  // Reason: only accept a new registration when the current socket is dead.
-  // This prevents a rogue local process from hijacking the extension socket
-  // while a healthy connection exists.
-  if (extensionSocket && extensionSocket.readyState === 1 /* OPEN */) {
-    console.log('[dassi-daemon] Rejected registration — existing socket still healthy');
-    ws.close();
-    return;
-  }
-
-  acceptExtensionSocket(ws);
+  const entry = acceptExtensionSocket(
+    ws,
+    { label: typeof msg.label === 'string' ? msg.label : null, installId: String(msg.installId ?? '') },
+    port,
+  );
 
   if (!ctx.resolved) {
     clearTimeout(ctx.timeout);
     try {
-      const status = await dispatchToExtension({ id: 'init', action: 'status' });
+      // Reason: route the startup status check to the connection that just registered.
+      const status = await dispatchToExtension({ id: 'init', action: 'status', target: entry.label });
       ctx.resolved = true;
       resolve(status);
     } catch (err) {
-      // Reason: don't close WSS — extension may reconnect and retry
+      // Reason: leave ctx.resolved false so a reconnecting extension can retry
+      // the startup status check rather than failing the daemon permanently.
       console.error('[dassi-daemon] Initial status check failed:', err.message);
       reject(err);
     }
   } else {
-    console.log('[dassi-daemon] Extension reconnected');
+    // Reason: daemon already started — this is a reconnect or an additional profile.
+    console.log('[dassi-daemon] Extension registered (daemon already started)');
   }
 }
 
@@ -199,7 +193,7 @@ async function startExtensionServer() {
     });
 
     wss.on('connection', (ws) => {
-      ws.once('message', (data) => handleRegistration(ws, data, ctx, wss, resolve, reject));
+      ws.once('message', (data) => handleRegistration(ws, data, ctx, resolve, reject, BRIDGE_PORT));
     });
   });
 }
@@ -210,34 +204,51 @@ async function startExtensionServer() {
  * Dispatches a single command to the Dassi extension via the persistent WS
  * connection, translating from the daemon's internal format to the extension's
  * JSON-RPC-style protocol.
- * @param {Record<string, unknown>} cmd - Command object with {id, action, ...params}
+ * @param {Record<string, unknown>} cmd - Command object with {id, action, target?, ...params}
  * @returns {Promise<unknown>} The extension's result value (not wrapped in success/data).
  */
 async function dispatchToExtension(cmd) {
-  if (!extensionSocket || extensionSocket.readyState !== 1 /* OPEN */) {
+  const { id, action, target = null, ...params } = cmd;
+  const entry = registry.resolve(target); // throws with a helpful message if ambiguous/unknown/none
+  if (!entry.ws || entry.ws.readyState !== 1 /* OPEN */) {
     throw new Error('Extension not connected');
   }
 
-  const { id, action, ...params } = cmd;
-  // Reason: the extension expects JSON-RPC style {id, method, params}, not {id, action, ...}
+  // Reason: the extension expects JSON-RPC {id, method, params}; `target` is a
+  // daemon-only routing field and must not leak into the extension params.
   const message = { id, method: action ?? String(id), params };
-  extensionSocket.send(JSON.stringify(message));
+  entry.ws.send(JSON.stringify(message));
 
   const timeoutMs = typeof params.timeoutMs === 'number' ? params.timeoutMs + 10_000 : 65_000;
 
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => {
-      pendingExtResponses.delete(String(id));
+      entry.pending.delete(String(id));
       reject(new Error(`Extension timeout after ${timeoutMs}ms`));
     }, timeoutMs);
 
-    pendingExtResponses.set(String(id), {
+    entry.pending.set(String(id), {
       resolve: (result) => { clearTimeout(timer); resolve(result); },
       reject: (err) => { clearTimeout(timer); reject(err); },
     });
   });
 }
 
+/**
+ * Handle commands the daemon answers itself (no extension round-trip).
+ * Returns a response object, or null if the command should be dispatched to
+ * an extension instead.
+ * @param {Record<string, unknown>} cmd
+ * @param {ReturnType<typeof createConnectionRegistry>} reg
+ * @returns {object | null}
+ */
+export function handleDaemonLocalCommand(cmd, reg) {
+  if (cmd?.action === 'list_profiles') {
+    return { id: String(cmd.id ?? 'unknown'), success: true, data: reg.list() };
+  }
+  return null;
+}
+
 /**
  * Refresh the ready file when the latest dispatched command was a `status` query.
  *
@@ -395,6 +406,10 @@ export async function startDaemon() {
   let lastCommandAt = Date.now();
   const queue = createCommandQueue(async (cmd) => {
     lastCommandAt = Date.now();
+    // Reason: daemon-local commands (e.g. list_profiles) are answered from the
+    // registry and intentionally skip extension dispatch + ready-file refresh.
+    const local = handleDaemonLocalCommand(cmd, registry);
+    if (local) return local;
     try {
       const result = await dispatchToExtension(cmd);
       refreshReadyFileFromStatusResult(readyFile, cmd, result);

package/dassi-shared.mjs

@@ -180,3 +180,123 @@ export function createCommandQueue(handler) {
     },
   };
 }
+
+// ─── 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; }
+        }
+      }
+      // 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;
+    },
+
+    /**
+     * 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;
+    },
+
+    /**
+     * 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}
+     */
+    resolve(target) {
+      if (conns.size === 0) throw new Error('No extension connected');
+      if (target == null) {
+        if (conns.size === 1) return [...conns.values()][0];
+        throw new Error(`Multiple profiles connected (${labels().join(', ')}). Specify --profile <label>.`);
+      }
+      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;
+    },
+  };
+}

package/dassi.mjs

@@ -37,7 +37,7 @@ const CHROME_WEB_STORE_URL = 'https://chromewebstore.google.com/detail/dassi-ai-
  * 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 }}
+ * @returns {{ action: string; params: Record<string, unknown>; session: string; json: boolean; profile: string | null }}
  */
 export function parseCliArgs(argv) {
   const args = [...argv];
@@ -45,30 +45,39 @@ 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 };
+    return { action: 'version', params: {}, session: 'default', json: false, profile: null };
   }
   if (consumeFlag(args, '--help')) {
-    return { action: 'help', params: {}, session: 'default', json: false };
+    return { action: 'help', params: {}, session: 'default', json: false, profile: null };
   }
 
   const session = validateSession(getFlag(args, '--session') ?? process.env.DASSI_SESSION ?? 'default');
   const json = consumeFlag(args, '--json');
+  const profile = getFlag(args, '--profile') ?? getFlag(args, '--label') ?? null;
+
+  // 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 command = args.shift();
   if (!command) throw new Error('No command specified. Run: dassi --help');
 
   if (command === 'list-tabs') {
     const all = consumeFlag(args, '--all');
-    return { action: 'list_tabs', params: all ? { all: true } : {}, session, json };
+    return finish('list_tabs', all ? { all: true } : {});
   }
 
   if (command === 'list-groups') {
     const all = consumeFlag(args, '--all');
-    return { action: 'list_groups', params: all ? { all: true } : {}, session, json };
+    return finish('list_groups', all ? { all: true } : {});
   }
 
   if (command === 'status') {
-    return { action: 'status', params: {}, session, json };
+    return finish('status', {});
+  }
+
+  if (command === 'list-profiles') {
+    return finish('list_profiles', {});
   }
 
   if (command === 'run') {
@@ -78,12 +87,12 @@ export function parseCliArgs(argv) {
     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 };
+    return finish('run', { ...base, ...target });
   }
 
   if (command === 'bug-report') {
     const output = getFlag(args, '-o') ?? getFlag(args, '--output');
-    return { action: 'export_logs', params: { output }, session, json };
+    return finish('export_logs', { output });
   }
 
   if (command === 'panel-screenshot') {
@@ -95,7 +104,7 @@ export function parseCliArgs(argv) {
     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 };
+    return finish('panel_screenshot', { tabId, ...(output ? { _output: output } : {}), ...(width ? { width } : {}), ...(height ? { height } : {}) });
   }
 
   if (command === 'raw') {
@@ -104,14 +113,14 @@ export function parseCliArgs(argv) {
     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 };
+    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) {
-    return { action: 'tool_exec', params: toolParams, session, json };
+    return finish('tool_exec', toolParams);
   }
 
   throw new Error(`Unknown command: "${command}". Run: dassi --help`);
@@ -331,6 +340,7 @@ const HELP_TEXT =
   '                                  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\n' +
@@ -339,6 +349,7 @@ const HELP_TEXT =
   '  --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' +
@@ -417,7 +428,7 @@ export async function run() {
     process.exit(1);
   }
 
-  const { action, params, session, json } = parsed;
+  const { action, params, session, json, profile } = parsed;
   handleImmediateAction(action);
 
   const socketPath = await ensureDaemonReady(session);
@@ -429,13 +440,16 @@ export async function run() {
     (action === 'run' || action === 'tool_exec') &&
     (params.groupId !== undefined || params.groupTitle !== undefined)
   ) {
-    const allOk = await runWithGroupExpansion(socketPath, action, params, json, sendCommand, formatResponse);
+    const allOk = await runWithGroupExpansion(socketPath, action, params, json, sendCommand, formatResponse, profile);
     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 };
+  // Reason: for 'raw' the user controls the full envelope — send params verbatim (no target injection).
+  // For all other commands, include target only when --profile/--label was given so back-compat is exact.
+  const command = action === 'raw'
+    ? { id, ...params }
+    : { id, action, ...params, ...(profile ? { target: profile } : {}) };
   const response = await sendCommand(socketPath, command);
 
   console.log(formatResponse(action, response, json, params));

package/format-response.mjs

@@ -95,6 +95,15 @@ function formatExportLogs(response, params) {
   }
 }
 
+/** @param {{ success: boolean; data?: unknown }} response */
+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}`);
+  return [header, ...body].join('\n');
+}
+
 /** @param {{ success: boolean; data?: unknown }} response */
 function formatStatus(response) {
   const d = /** @type {{ authenticated?: boolean; email?: string | null }} */ (response.data ?? {});
@@ -114,6 +123,7 @@ const FORMATTERS = {
   panel_screenshot: (r, p, a) => formatToolExec(r, p, a),
   export_logs: (r, p, _a) => formatExportLogs(r, p),
   status: (r, _p, _a) => formatStatus(r),
+  list_profiles: (r, _p, _a) => formatListProfiles(r),
 };
 
 /**

package/group-expansion.mjs

@@ -39,16 +39,20 @@ export function uniquifyOutputForTab(output, tabId) {
  * @param {string} socketPath  Daemon Unix socket
  * @param {{ groupId?: number; groupTitle?: string }} ref
  * @param {(socketPath: string, command: object) => Promise<{success:boolean,data?:any,error?:string}>} sendFn - send function (required, injectable for tests)
+ * @param {string | null} [target] - Profile label to route the resolving queries to (when --profile is set).
  * @returns {Promise<number[]>}  Member tab IDs (order: ascending)
  */
-export async function expandGroupToTabIds(socketPath, ref, sendFn) {
+export async function expandGroupToTabIds(socketPath, ref, sendFn, target = null) {
+  // Reason: route the group-resolving queries to the same profile the command
+  // targets, so resolution isn't ambiguous when multiple profiles are connected.
+  const targetField = target ? { target } : {};
   // Reason: pass all:true (flat, NOT nested under `params`) so --group /
   // --group-title can resolve against any Chrome tab group, not just groups
   // dassi currently has open. The daemon's dispatchToExtension does
   // `{ 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 });
+  const groupsResp = await sendFn(socketPath, { id: `cli_lg_${Date.now()}`, action: 'list_groups', all: true, ...targetField });
   if (!groupsResp.success) throw new Error(`Failed to list groups: ${groupsResp.error ?? 'unknown'}`);
   const groups = /** @type {Array<{id:number;title:string;windowId:number}>} */ (groupsResp.data ?? []);
 
@@ -70,7 +74,7 @@ export async function expandGroupToTabIds(socketPath, ref, sendFn) {
     throw new Error('expandGroupToTabIds: pass groupId or groupTitle');
   }
 
-  const tabsResp = await sendFn(socketPath, { id: `cli_lt_${Date.now()}`, action: 'list_tabs', all: true });
+  const tabsResp = await sendFn(socketPath, { id: `cli_lt_${Date.now()}`, 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);
@@ -100,14 +104,16 @@ export function formatGroupJsonResults(results) {
  * @param {number} tabId
  * @param {boolean} multiTab  True when >1 tab in the expansion (triggers output uniquification)
  * @param {(socketPath: string, command: object) => Promise<{success:boolean,data?:any,error?:string}>} sendFn
+ * @param {string | null} [target] - Profile label to route the child command to (when --profile is set).
  * @returns {Promise<{tabId: number, response: {success:boolean,data?:any,error?:string}, childParams: object}>}
  */
-async function dispatchChildForTab(socketPath, action, childBase, tabId, multiTab, sendFn) {
+async function dispatchChildForTab(socketPath, action, childBase, tabId, multiTab, sendFn, target = null) {
   // Reason: uniquify _output per tab when fanning out so each file write targets a distinct path
   const perTabOutput =
     multiTab && childBase._output ? uniquifyOutputForTab(childBase._output, tabId) : childBase._output;
   const childParams = { ...childBase, tabId, ...(perTabOutput !== childBase._output ? { _output: perTabOutput } : {}) };
-  const response = await sendFn(socketPath, { id: `cli_${Date.now()}_${tabId}`, action, ...childParams });
+  // 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 } : {}) });
   return { tabId, response, childParams };
 }
 
@@ -128,13 +134,15 @@ async function dispatchChildForTab(socketPath, action, childBase, tabId, multiTa
  * @param {boolean} json
  * @param {(socketPath: string, command: object) => Promise<{success:boolean,data?:any,error?:string}>} sendFn
  * @param {(action: string, response: object, json: boolean, params: object) => string} formatFn
+ * @param {string | null} [target] - Profile label to route every query/child command to (when --profile is set).
  * @returns {Promise<boolean>}  true if all child calls succeeded, false if any failed
  */
-export async function runWithGroupExpansion(socketPath, action, params, json, sendFn, formatFn) {
+export async function runWithGroupExpansion(socketPath, action, params, json, sendFn, formatFn, target = null) {
   const tabIds = await expandGroupToTabIds(
     socketPath,
     { groupId: params.groupId, groupTitle: params.groupTitle },
     sendFn,
+    target,
   );
   // 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(', ')}`);
@@ -146,7 +154,7 @@ export async function runWithGroupExpansion(socketPath, action, params, json, se
   let allOk = true;
 
   for (const tabId of tabIds) {
-    const { response, childParams } = await dispatchChildForTab(socketPath, action, childBase, tabId, multiTab, sendFn);
+    const { response, childParams } = await dispatchChildForTab(socketPath, action, childBase, tabId, multiTab, sendFn, target);
     if (!response.success) allOk = false;
     if (json) {
       // Reason: collect for a single JSON array emission after the loop

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dassi_ai/cli",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "CLI for the Dassi Chrome extension — run browser automation from the terminal",
   "type": "module",
   "bin": {
@@ -37,6 +37,11 @@
   "scripts": {
     "test": "vitest run"
   },
-  "keywords": ["dassi", "cli", "browser-automation", "chrome-extension"],
+  "keywords": [
+    "dassi",
+    "cli",
+    "browser-automation",
+    "chrome-extension"
+  ],
   "license": "MIT"
 }