@dassi_ai/cli 0.1.0 → 0.1.2

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:
@@ -72,7 +72,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

@@ -238,6 +238,37 @@ async function dispatchToExtension(cmd) {
   });
 }
 
+/**
+ * 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 +282,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 +341,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,7 +387,8 @@ 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);
   }
 
@@ -350,6 +397,7 @@ export async function startDaemon() {
     lastCommandAt = Date.now();
     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 +407,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.mjs

@@ -58,11 +58,13 @@ export function parseCliArgs(argv) {
   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 { action: 'list_tabs', params: all ? { all: true } : {}, session, json };
   }
 
   if (command === 'list-groups') {
-    return { action: 'list_groups', params: {}, session, json };
+    const all = consumeFlag(args, '--all');
+    return { action: 'list_groups', params: all ? { all: true } : {}, session, json };
   }
 
   if (command === 'status') {
@@ -245,22 +247,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,13 +329,14 @@ 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' +
   '  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' +
   '  --json            Output raw JSON\n' +
@@ -416,8 +443,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/group-expansion.mjs

@@ -42,7 +42,13 @@ export function uniquifyOutputForTab(output, tabId) {
  * @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' });
+  // 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 });
   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 +70,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 });
   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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dassi_ai/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "CLI for the Dassi Chrome extension — run browser automation from the terminal",
   "type": "module",
   "bin": {

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