@dassi_ai/cli 0.1.0 → 0.2.0

package/README.md

@@ -1,4 +1,4 @@
-# dassi-cli
+# @dassi_ai/cli
 
 Standalone CLI for the [Dassi](../extension/README.md) Chrome extension — run browser automation from the terminal.
 
@@ -6,10 +6,10 @@ Standalone CLI for the [Dassi](../extension/README.md) Chrome extension — run
 
 ```bash
 # Zero-install
-npx dassi-cli --help
+npx @dassi_ai/cli --help
 
 # Or install globally
-npm install -g dassi-cli
+npm install -g @dassi_ai/cli
 ```
 
 Or, for local development from a clone of this repo:
@@ -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
@@ -72,7 +79,7 @@ When `--group`/`--group-title` is used, the CLI expands to member tab ids and ru
 
 ## Claude Code Plugin
 
-This package also ships as a Claude Code plugin under the `dassi` namespace. After installation (via either `npm install -g dassi-cli` or `npm link` from this directory), Claude Code auto-discovers two skills:
+This package also ships as a Claude Code plugin under the `dassi` namespace. After installation (via either `npm install -g @dassi_ai/cli` or `npm link` from this directory), Claude Code auto-discovers two skills:
 
 - **`dassi:pick-tabs`** — a reusable tab/group picker. Lists open tabs and Chrome tab groups, asks the user to pick, returns the selected Chrome tab IDs.
 - **`dassi:operate`** — main entry point. Translates natural-language browser asks ("summarize my Research group", "screenshot the active tab", etc.) into `dassi` CLI invocations.

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,82 @@ 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.
+ *
+ * Reason: The daemon previously wrote the ready file exactly once on startup.
+ * When the user wasn't signed in at that moment, the file stayed `needs_login`
+ * even after waitForLogin's polling confirmed authentication via socket — so
+ * every subsequent CLI invocation re-read the stale file and re-triggered the
+ * login flow. Refreshing on every `status` response — which waitForLogin's
+ * poll loop drives naturally — converges the file to the truth without needing
+ * a separate signal channel.
+ *
+ * @param {string} readyFile - Absolute path to the daemon's ready file.
+ * @param {{ action?: string }} cmd - The command that was dispatched.
+ * @param {unknown} result - The dispatch result (extension's status payload).
+ * @returns {void}
+ */
+export function refreshReadyFileFromStatusResult(readyFile, cmd, result) {
+  if (cmd?.action !== 'status') return;
+  if (!result || typeof result !== 'object') return;
+  try {
+    fs.writeFileSync(readyFile, JSON.stringify(buildReadyPayload(result)), { mode: 0o600 });
+    // Reason: writeFileSync's `mode` is ignored when the file already exists.
+    // chmod explicitly so installs with a pre-hardening 0o644 ready file get
+    // tightened. The file contains the signed-in email — owner-only.
+    try { fs.chmodSync(readyFile, 0o600); } catch { /* best-effort */ }
+  } catch {
+    // Reason: best-effort sync; don't fail the command if the FS write itself
+    // races (e.g. file permission flake). The next status query will retry.
+  }
+}
+
 // ─── Daemon setup helpers ─────────────────────────────────────────────────────
 
 /**
@@ -251,8 +293,17 @@ function initDaemonProcess(session) {
   const readyFile = getReadyFile(session);
 
   fs.mkdirSync(appDir, { recursive: true, mode: 0o700 });
+  // Reason: mkdirSync's `mode` is ignored when the directory already exists.
+  // Normalize perms on every start so installs created before the mode arg
+  // was added (or with a permissive umask) get tightened to owner-only.
+  // The socket and ready/pid files live here; loose perms would let other
+  // local users connect to the socket and dispatch CLI commands.
+  try { fs.chmodSync(appDir, 0o700); } catch { /* best-effort */ }
   cleanupDaemonFiles(session);
-  fs.writeFileSync(getPidFile(session), String(process.pid));
+  const pidFile = getPidFile(session);
+  fs.writeFileSync(pidFile, String(process.pid), { mode: 0o600 });
+  // Reason: see refreshReadyFileFromStatusResult — chmod normalizes pre-existing files.
+  try { fs.chmodSync(pidFile, 0o600); } catch { /* best-effort */ }
 
   const shutdown = () => {
     cleanupDaemonFiles(session);
@@ -301,7 +352,13 @@ function createSocketServer(queue, socketPath) {
     socket.on('error', () => { /* ignore client disconnects */ });
   });
 
-  server.listen(socketPath);
+  // Reason: tighten the Unix socket to owner-only so other local users on a
+  // multi-user system can't connect and dispatch CLI commands. chmod has to
+  // happen after the socket file is actually created — listen()'s callback
+  // fires on the 'listening' event, by which point the inode exists.
+  server.listen(socketPath, () => {
+    try { fs.chmodSync(socketPath, 0o600); } catch { /* best-effort */ }
+  });
   return server;
 }
 
@@ -341,15 +398,21 @@ export async function startDaemon() {
   } catch {
     // Reason: write the ready file even on failure so the CLI can read the error state,
     // then exit so the WSS doesn't keep the process alive as a zombie.
-    fs.writeFileSync(readyFile, JSON.stringify({ status: 'extension_not_installed' }));
+    fs.writeFileSync(readyFile, JSON.stringify({ status: 'extension_not_installed' }), { mode: 0o600 });
+    try { fs.chmodSync(readyFile, 0o600); } catch { /* best-effort */ }
     process.exit(1);
   }
 
   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);
       return { id: String(cmd.id ?? 'unknown'), success: true, data: result };
     } catch (err) {
       return { id: String(cmd.id ?? 'unknown'), success: false, error: err.message };
@@ -359,7 +422,8 @@ export async function startDaemon() {
   // Reason: start the socket server before writing the ready file so the CLI
   // can connect immediately (e.g. for needs_login polling).
   const server = createSocketServer(queue, socketPath);
-  fs.writeFileSync(readyFile, JSON.stringify(buildReadyPayload(statusData)));
+  fs.writeFileSync(readyFile, JSON.stringify(buildReadyPayload(statusData)), { mode: 0o600 });
+  try { fs.chmodSync(readyFile, 0o600); } catch { /* best-effort */ }
 
   startIdleShutdown(server, session, () => lastCommandAt);
 }

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,28 +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') {
-    return { action: 'list_tabs', params: {}, session, json };
+    const all = consumeFlag(args, '--all');
+    return finish('list_tabs', all ? { all: true } : {});
   }
 
   if (command === 'list-groups') {
-    return { action: 'list_groups', params: {}, session, json };
+    const all = consumeFlag(args, '--all');
+    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') {
@@ -76,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') {
@@ -93,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') {
@@ -102,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`);
@@ -245,22 +256,46 @@ export function sendCommand(socketPath, command) {
 // ─── 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
+ * 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)
-  try {
-    const { default: open } = await import('open');
-    if (optionsUrl) await open(String(optionsUrl));
-  } catch {
-    console.error(`    Please open: ${optionsUrl}`);
+  // 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
@@ -303,15 +338,18 @@ const HELP_TEXT =
   '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' +
+  '  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' +
   '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' +
@@ -390,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);
@@ -402,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));
@@ -416,8 +457,33 @@ export async function run() {
 }
 
 // ── 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) {
+
+/**
+ * Returns true when this module is being executed as the CLI entry point,
+ * not imported by another module (e.g. tests).
+ *
+ * Reason: `npm i -g` installs a symlink in the bin dir; `import.meta.url`
+ * resolves symlinks but `process.argv[1]` does not, so they only match after
+ * canonicalizing argvPath via realpathSync. If realpathSync throws (e.g.
+ * `node -` makes argv[1] equal `"-"` which is not a real file), fall back to
+ * the raw argvPath so the module can still be imported safely.
+ *
+ * @param {string} metaUrl - import.meta.url of the candidate entry module.
+ * @param {string | undefined} argvPath - process.argv[1].
+ * @returns {boolean}
+ */
+export function isMainModule(metaUrl, argvPath) {
+  if (!argvPath) return false;
+  let resolvedPath = argvPath;
+  try {
+    resolvedPath = fs.realpathSync(argvPath);
+  } catch {
+    // Reason: argvPath may not be a real file (`node -`, REPL, etc.) — fall through with the raw path.
+  }
+  return metaUrl === pathToFileURL(resolvedPath).href;
+}
+
+if (isMainModule(import.meta.url, process.argv[1])) {
   run().catch((err) => {
     console.error(`❌  ${err.message}`);
     process.exit(1);

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,10 +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) {
-  const groupsResp = await sendFn(socketPath, { id: `cli_lg_${Date.now()}`, action: 'list_groups' });
+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, ...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 ?? []);
 
@@ -64,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' });
+  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);
@@ -94,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 };
 }
 
@@ -122,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(', ')}`);
@@ -140,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.0",
+  "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"
 }

package/skills/operate/SKILL.md

@@ -12,7 +12,7 @@ The main entry point for driving the Dassi Chrome extension from Claude Code.
 
 ## Prerequisites
 
-`dassi` must be on PATH. Install with `npm install -g dassi-cli` or `npm link` from the CLI package directory.
+`dassi` must be on PATH. Install with `npm install -g @dassi_ai/cli` or `npm link` from the CLI package directory.
 
 ## Process