@phnx-labs/agents-cli 1.21.3 → 1.22.1

package/dist/lib/secrets/install-helper.js

@@ -18,6 +18,7 @@ import { createHash } from 'crypto';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { copyAppBundle, withInstallLock } from '../app-bundle-install.js';
 const APP_BUNDLE_NAME = 'Agents CLI.app';
 const INSTALL_DIR_NAME = 'agents-cli';
 let installRootOverride = null;
@@ -107,19 +108,6 @@ function spctlAssess(appPath) {
     });
     return { ok: r.status === 0, output: (r.stderr || r.stdout || '').toString().trim() };
 }
-function copyAppBundle(src, dest) {
-    fs.mkdirSync(path.dirname(dest), { recursive: true });
-    if (fs.existsSync(dest))
-        fs.rmSync(dest, { recursive: true, force: true });
-    // `cp -R` preserves the bundle's signature, symlinks, and resource forks.
-    // `fs.cpSync({recursive: true})` works on simple trees but has historically
-    // mishandled extended attributes on `.app` bundles, breaking codesign.
-    const r = spawnSync('cp', ['-R', src, dest], { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf-8' });
-    if (r.status !== 0) {
-        const msg = (r.stderr || r.stdout || '').toString().trim();
-        throw new Error(`Failed to copy ${src} -> ${dest}: ${msg || 'unknown error'}`);
-    }
-}
 /**
  * Idempotent install. Copies the bundled `.app` to the stable user path. Skips
  * if the destination already exists, `codesign --verify` passes, AND the
@@ -135,25 +123,34 @@ function copyAppBundle(src, dest) {
 export function ensureKeychainHelperInstalled(opts = {}) {
     assertDarwin();
     const dest = installedAppPath();
-    if (!opts.forceReinstall && fs.existsSync(dest)) {
-        const { ok } = codesignVerify(dest);
-        if (ok && !installedHelperIsStale())
+    const upToDate = () => fs.existsSync(dest) && codesignVerify(dest).ok && !installedHelperIsStale();
+    // Fast path: already installed, valid, and current — no lock, no copy.
+    if (!opts.forceReinstall && upToDate())
+        return;
+    // Serialize the install so concurrent `agents` invocations don't race the
+    // atomic swap (and don't each run a redundant `cp`). The re-check inside the
+    // lock means a burst of callers copies once, not N times — the stampede that
+    // transiently corrupted the bundle and tripped the "damaged" dialog.
+    withInstallLock(dest, (heartbeat) => {
+        if (!opts.forceReinstall && upToDate())
             return;
-    }
-    const src = sourceAppPath();
-    copyAppBundle(src, dest);
-    const verify = codesignVerify(dest);
-    if (!verify.ok) {
-        throw new Error(`Installed helper failed codesign verification at ${dest}.\n${verify.output}\n` +
-            'The bundle may be corrupted. Try `agents helper install` to reinstall, or reinstall agents-cli.');
-    }
-    const assess = spctlAssess(dest);
-    if (!assess.ok) {
-        // Warn, do not fail. Gatekeeper ticket lookup needs network; offline
-        // installs and CI runners commonly fail this check. The ACL semantics
-        // we care about depend on codesign, not spctl.
-        process.stderr.write(`agents-cli: notarization check (spctl) did not pass for ${dest}: ${assess.output}\n`);
-    }
+        const src = sourceAppPath();
+        copyAppBundle(src, dest);
+        heartbeat(); // cp -R done; keep the lock fresh across the codesign/spctl spawns
+        const verify = codesignVerify(dest);
+        if (!verify.ok) {
+            throw new Error(`Installed helper failed codesign verification at ${dest}.\n${verify.output}\n` +
+                'The bundle may be corrupted. Try `agents helper install` to reinstall, or reinstall agents-cli.');
+        }
+        heartbeat(); // codesign done; spctl does a network Gatekeeper lookup — refresh again
+        const assess = spctlAssess(dest);
+        if (!assess.ok) {
+            // Warn, do not fail. Gatekeeper ticket lookup needs network; offline
+            // installs and CI runners commonly fail this check. The ACL semantics
+            // we care about depend on codesign, not spctl.
+            process.stderr.write(`agents-cli: notarization check (spctl) did not pass for ${dest}: ${assess.output}\n`);
+        }
+    });
 }
 /**
  * Return the absolute path to the helper executable. If the installed bundle

package/dist/lib/session/bash-command.js

@@ -64,6 +64,7 @@ const TOOL_REGISTRY = {
     mv: { category: 'shell', signal: 'low', action: 'moving files' },
     cp: { category: 'shell', signal: 'low', action: 'copying files' },
     mkdir: { category: 'shell', signal: 'low', action: 'making directories' },
+    rmdir: { category: 'shell', signal: 'low', action: 'removing directories' },
     touch: { category: 'shell', signal: 'low', action: 'touching files' },
     echo: { category: 'shell', signal: 'low', action: 'echoing' },
     printf: { category: 'shell', signal: 'low', action: 'printing' },
@@ -115,6 +116,13 @@ const VALUE_FLAGS = {
     kubectl: new Set(['-n', '--namespace', '--kubeconfig', '--context', '--cluster', '--user', '-s', '--server', '--as', '--token', '--cache-dir', '--request-timeout']),
     rush: new Set(),
     openclaw: new Set(),
+    // The repo's own toolchain — heavy in real transcripts (`agents` alone was the
+    // top unrecognized token). Two-level so they bucket by subcommand
+    // (`agents sessions`, `linear list`) instead of one flat `other` pile (#1830).
+    // `ag` is deliberately NOT here — it is the silver searcher in TOOL_REGISTRY,
+    // not the agents alias, in this classifier's world.
+    agents: new Set(['-H', '--host', '--device']),
+    linear: new Set(),
 };
 /** Tools whose bucket key includes the second token (subcommand). */
 const TWO_LEVEL_TOOLS = new Set(Object.keys(VALUE_FLAGS));
@@ -141,8 +149,8 @@ export function unwrapCommand(cmd) {
     const prefix = s.match(/^(?:sudo|time)(?:\s+(?:-[uUgGhpCrtDR]\s+\S+|-\S+))*\s+(.+)$/);
     if (prefix)
         return unwrapCommand(prefix[1]);
-    // cd foo && command
-    const cd = s.match(/^cd\s+\S+\s*&&\s*(.+)$/);
+    // cd foo && command  (also `cd foo; command` and newline-separated `cd foo\ncommand`)
+    const cd = s.match(/^cd\s+\S+\s*(?:&&|;|\n)\s*([\s\S]+)$/);
     if (cd)
         return unwrapCommand(cd[1]);
     // npx / bunx
@@ -191,7 +199,11 @@ function splitOnOperators(cmd) {
             i += 2;
             continue;
         }
-        if (ch === '|' || ch === ';') {
+        // A newline separates commands the same way `;` does (an unquoted, un-escaped
+        // line break), so `cd X\ncmd` splits into two segments instead of reading as
+        // one `cd` command — the top source of `other` classifications (#1830). A
+        // `\`-continued line never reaches here (handled by the escape branch above).
+        if (ch === '|' || ch === ';' || ch === '\n') {
             if (current.trim())
                 parts.push(current.trim());
             current = '';
@@ -247,22 +259,61 @@ function scanSubcommand(tokens, tool) {
     }
     return '';
 }
+/**
+ * The classifier reads only the executable and the first non-flag token, both at
+ * the very head of the first simple command. Tokenizing the *entire* command —
+ * every pipeline segment, multi-KB heredoc bodies included — to reach the first
+ * word cost up to ~1ms per call (a 7.8KB `cat <<HEREDOC …` classified on the word
+ * `cat`). Tokenize only this much of the head instead: enough for the executable
+ * plus a subcommand and its flags, never a heredoc tail (#1830, ~3.3x faster).
+ */
+const CLASSIFY_HEAD_LIMIT = 200;
+/**
+ * Tokens of the first simple command only, tokenizing just the head of the
+ * unwrapped string. Mirrors {@link tokenizeBash}'s first-segment result for
+ * short commands but skips the cost of tokenizing the whole command; the full
+ * multi-segment tokenizer stays available for callers that need every segment.
+ */
+function firstSimpleCommandTokens(command) {
+    const unwrapped = unwrapCommand(command);
+    const head = unwrapped.length > CLASSIFY_HEAD_LIMIT ? unwrapped.slice(0, CLASSIFY_HEAD_LIMIT) : unwrapped;
+    const firstSegment = splitOnOperators(head)[0] ?? '';
+    if (!firstSegment)
+        return [];
+    try {
+        return shlexSplit(firstSegment);
+    }
+    catch {
+        // The head cut a quote mid-string (e.g. a long quoted flag value like
+        // `git -c http.extraheader="Authorization: Bearer …" fetch`), so shlex threw
+        // on the unbalanced quote. A whitespace split of the truncated head would
+        // mis-read the value as the subcommand, so re-tokenize the FULL first
+        // segment instead — only the rare throw path pays that cost.
+        const fullFirst = splitOnOperators(unwrapped)[0] ?? firstSegment;
+        try {
+            return shlexSplit(fullFirst);
+        }
+        catch {
+            // Genuinely unbalanced quoting even in the full segment — a whitespace
+            // split of the full segment still yields the leading executable.
+            return fullFirst.split(/\s+/).filter(Boolean);
+        }
+    }
+}
 /**
  * Classify the first simple command in a Bash string. Returns coarse metadata
  * (tool name, category, subcommand, human action) used for summaries and
  * activity logging. Unknown executables fall back to `other`.
  */
 export function classifyBashCommand(command) {
-    const simpleCommands = tokenizeBash(command);
-    if (!simpleCommands.length) {
-        return { tool: 'other', category: 'other', subcommand: '', action: 'running command', summary: '', signal: 'low' };
-    }
-    const tokens = simpleCommands[0];
+    const tokens = firstSimpleCommandTokens(command);
     if (!tokens.length) {
         return { tool: 'other', category: 'other', subcommand: '', action: 'running command', summary: '', signal: 'low' };
     }
     const first = tokens[0];
-    const baseRaw = first.replace(/^[./]+/, '').toLowerCase();
+    // Reduce a path executable to its basename so `~/.agents/skills/linear/scripts/linear`,
+    // `/usr/bin/git`, and `./tool` all resolve by tool name, not the full path (#1830).
+    const baseRaw = first.replace(/^.*\//, '').toLowerCase();
     const base = baseRaw.endsWith('.exe') ? baseRaw.slice(0, -4) : baseRaw;
     const canonical = ALIAS_MAP.get(base);
     const info = canonical ? TOOL_REGISTRY[canonical] : undefined;

package/dist/lib/session/db.d.ts

@@ -8,10 +8,11 @@
  */
 import Database from '../sqlite.js';
 import type { SessionAgentId, SessionMeta } from './types.js';
+import { type IndexedToolCall } from './tool-calls.js';
 /** Current schema version; bumped when migrations are added. Exported so tests
  * assert against the constant instead of hardcoding a number that every bump
  * then has to chase (docs/05-sessions.md calls the constant the source of truth). */
-export declare const SCHEMA_VERSION = 24;
+export declare const SCHEMA_VERSION = 30;
 /** Raw row shape returned from the sessions table. */
 export interface SessionRow {
     id: string;
@@ -91,6 +92,8 @@ export interface QueryOptions {
      * with NULLs sorted last so unpriced rows never crowd out real data.
      */
     sortBy?: 'timestamp' | 'cost' | 'duration';
+    /** Internal warm-cache path; callers must validate the small final result set. */
+    skipExistenceCheck?: boolean;
     /**
      * Only sessions that invoked this skill (#12), joined against
      * session_resource_usage.kind='skill'. Matches either the full stored name
@@ -204,6 +207,9 @@ export declare function upsertSessionsBatch(entries: Array<{
     scan?: ScanStamp;
     parserState?: string;
     contentText?: string;
+    toolCalls?: IndexedToolCall[];
+    toolScan?: ScanStamp;
+    toolIndexMode?: 'replace' | 'append';
 }>): void;
 /**
  * Sync labels for a set of sessions. For each id in the map, if the stored