@claude-flow/cli 3.46.0 → 3.46.1

package/.claude/helpers/helpers.manifest.json

@@ -1,6 +1,6 @@
 {
   "manifest": {
-    "version": "3.46.0",
+    "version": "3.46.1",
     "files": {
       "auto-memory-hook.mjs": "85fe05c757421c52137c0bc8545a0896bab6b4714538c2a11d1d0835bfcc8c1c",
       "hook-handler.cjs": "209d9fafe10e17d1be0866727f6f9cf9ac66f9a0793f1c793a4f58319e8e4583",
@@ -9,6 +9,6 @@
       "router.js": "b6998397e7883191b62229ccdc66fb87f1ccca1d5b2039ecb8c1e686d1ad81f8"
     }
   },
-  "signature": "LwKXka3qAKGSIVpcv4vpg5vlv8CFHolvyCQwzW0hNvPIn7Un3+qpidc7drdoDzsrNyzx3gnZJBFEWeXxlTabDA==",
+  "signature": "F1SDoeGrsywBpjrcev0ITXmm1FHHi2PuKGrZGudnoH96qyOhbYfvxhvlQIeusWqN7theLd6k3PQ6/67nCjCKAw==",
   "algorithm": "ed25519"
 }

package/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 6,
-  "generatedAt": "2026-09-26T22:32:39.004Z",
-  "gitSha": "39ea61fd",
+  "generatedAt": "2026-09-26T23:25:25.296Z",
+  "gitSha": "a5adb5aa",
   "catalog": {
     "agents": 167,
     "tools": 418,

package/dist/src/mcp-tools/browser-tools.js

@@ -6,6 +6,7 @@
  */
 import { readFileSync, existsSync } from 'node:fs';
 import { validateIdentifier, validateText } from './validate-input.js';
+import { resolveAgentBrowserLaunch, resolveNpxLaunch } from '../runtime/browser-command.js';
 // Session registry for multi-session support
 const browserSessions = new Map();
 /** Preserve agent-browser's JSON error on non-zero exit without echoing other process output. */
@@ -46,36 +47,39 @@ function browserCommandFailure(error, missingExecutable) {
 export async function execBrowserCommand(args, session = 'default') {
     const { execFileSync } = await import('child_process');
     const fullArgs = ['--session', session, '--json', ...args];
+    // ADR-401: fullArgs carries tool-supplied text (fill values, eval scripts,
+    // selectors), so no spawn here may use a shell. On Windows the npm shims are
+    // resolved to the process behind them instead of enabling `shell: true`,
+    // which would hand that text to cmd.exe. Never add a `shell` option below.
+    const missing = 'Neither agent-browser nor npx found. Install with: npm i -g agent-browser';
     let result;
-    try {
-        result = execFileSync('agent-browser', fullArgs, {
-            encoding: 'utf-8',
-            timeout: 30000,
-        });
+    const global = resolveAgentBrowserLaunch();
+    if (global) {
+        try {
+            result = execFileSync(global.command, [...global.argsPrefix, ...fullArgs], {
+                encoding: 'utf-8',
+                timeout: 30000,
+                windowsHide: true,
+            });
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                return browserCommandFailure(error);
+        }
     }
-    catch (error) {
-        const err = error;
-        if (err.code === 'ENOENT') {
-            try {
-                // #2770: On Windows, `npx` ships as `npx.cmd`; execFileSync cannot spawn
-                // a .cmd file without going through cmd.exe. Enable shell on win32 so
-                // cmd.exe resolves the .cmd extension. POSIX keeps shell:false.
-                // NOTE: shell:true joins args by spaces and passes to cmd.exe — the args
-                // here are hard-coded flags + a package name, so no injection risk. If
-                // user-controlled args are ever added, escape them before spawn.
-                result = execFileSync('npx', ['--yes', 'agent-browser', ...fullArgs], {
-                    encoding: 'utf-8',
-                    timeout: 60000,
-                    shell: process.platform === 'win32',
-                    windowsHide: true,
-                });
-            }
-            catch (npxError) {
-                return browserCommandFailure(npxError, 'Neither agent-browser nor npx found. Install with: npm i -g agent-browser');
-            }
+    if (result === undefined) {
+        const npx = resolveNpxLaunch();
+        if (!npx)
+            return browserCommandFailure(Object.assign(new Error('npx not resolvable'), { code: 'ENOENT' }), missing);
+        try {
+            result = execFileSync(npx.command, [...npx.argsPrefix, '--yes', 'agent-browser', ...fullArgs], {
+                encoding: 'utf-8',
+                timeout: 60000,
+                windowsHide: true,
+            });
         }
-        else {
-            return browserCommandFailure(error);
+        catch (npxError) {
+            return browserCommandFailure(npxError, missing);
         }
     }
     let data;

package/dist/src/runtime/browser-command.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A process target Node can spawn with `shell: false`.
+ * The caller appends its own argv after `argsPrefix`.
+ */
+export interface BrowserLaunch {
+    command: string;
+    argsPrefix: string[];
+}
+export interface BrowserLaunchOptions {
+    platform?: NodeJS.Platform;
+    nodeExecutable?: string;
+    lookup?: (command: string, args: string[]) => string;
+    fileExists?: (path: string) => boolean;
+    readFile?: (path: string) => string;
+}
+/**
+ * Locate a globally installed `agent-browser`.
+ * POSIX: the command name itself (spawned without a shell, as before).
+ * Windows: a native `.exe`, or `node <entry.js>` behind the npm shim; null when
+ * neither can be resolved without a shell.
+ */
+export declare function resolveAgentBrowserLaunch(options?: BrowserLaunchOptions): BrowserLaunch | null;
+/**
+ * Locate `npx` for the `npx --yes agent-browser` fallback.
+ * POSIX: `npx` itself. Windows: `node <npm>/bin/npx-cli.js`, taken from the
+ * running Node's own npm or from the npm that `where.exe npx` points at.
+ */
+export declare function resolveNpxLaunch(options?: BrowserLaunchOptions): BrowserLaunch | null;
+//# sourceMappingURL=browser-command.d.ts.map

package/dist/src/runtime/browser-command.js

@@ -0,0 +1,101 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { posix, win32 } from 'node:path';
+/**
+ * Windows npm shims (`agent-browser.cmd`, `npx.cmd`) are batch files. Node
+ * cannot spawn them with `shell: false`, and `shell: true` joins argv with
+ * spaces and hands the result to cmd.exe, so every tool-supplied value (a
+ * `fill` value, an `eval` script, a selector) becomes shell syntax. Resolve
+ * the shim to the JavaScript entry point (or native executable) behind it and
+ * spawn that directly, so argv reaches the process as literal data.
+ *
+ * A target ending in `.cmd` or `.bat` is never returned: spawning one implies
+ * cmd.exe regardless of the `shell` option.
+ */
+const BATCH_TARGET = /\.(cmd|bat)$/i;
+function defaults(options) {
+    const platform = options.platform ?? process.platform;
+    return {
+        platform,
+        path: platform === 'win32' ? win32 : posix,
+        nodeExecutable: options.nodeExecutable ?? process.execPath,
+        lookup: options.lookup ?? ((command, args) => execFileSync(command, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })),
+        fileExists: options.fileExists ?? existsSync,
+        readFile: options.readFile ?? ((file) => readFileSync(file, 'utf8')),
+    };
+}
+function whereAll(lookup, name) {
+    try {
+        return lookup('where.exe', [name])
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+/** `bin` of a package.json, resolved to a path that stays inside the package. */
+function packageBinEntry(packageRoot, binName, d) {
+    let manifest;
+    try {
+        manifest = JSON.parse(d.readFile(d.path.join(packageRoot, 'package.json')));
+    }
+    catch {
+        return null;
+    }
+    const relative = typeof manifest.bin === 'string' ? manifest.bin : manifest.bin?.[binName];
+    if (typeof relative !== 'string' || !relative)
+        return null;
+    const entry = d.path.resolve(packageRoot, relative);
+    const rootWithSep = d.path.resolve(packageRoot) + d.path.sep;
+    if (!entry.startsWith(rootWithSep))
+        return null;
+    return d.fileExists(entry) ? entry : null;
+}
+/**
+ * Locate a globally installed `agent-browser`.
+ * POSIX: the command name itself (spawned without a shell, as before).
+ * Windows: a native `.exe`, or `node <entry.js>` behind the npm shim; null when
+ * neither can be resolved without a shell.
+ */
+export function resolveAgentBrowserLaunch(options = {}) {
+    const d = defaults(options);
+    if (d.platform !== 'win32')
+        return { command: 'agent-browser', argsPrefix: [] };
+    const matches = whereAll(d.lookup, 'agent-browser');
+    const executable = matches.find((candidate) => d.path.extname(candidate).toLowerCase() === '.exe' && d.fileExists(candidate));
+    if (executable)
+        return { command: executable, argsPrefix: [] };
+    for (const shim of matches) {
+        const packageRoot = d.path.join(d.path.dirname(shim), 'node_modules', 'agent-browser');
+        const entry = packageBinEntry(packageRoot, 'agent-browser', d);
+        if (!entry || BATCH_TARGET.test(entry))
+            continue;
+        if (d.path.extname(entry).toLowerCase() === '.exe')
+            return { command: entry, argsPrefix: [] };
+        return { command: d.nodeExecutable, argsPrefix: [entry] };
+    }
+    return null;
+}
+/**
+ * Locate `npx` for the `npx --yes agent-browser` fallback.
+ * POSIX: `npx` itself. Windows: `node <npm>/bin/npx-cli.js`, taken from the
+ * running Node's own npm or from the npm that `where.exe npx` points at.
+ */
+export function resolveNpxLaunch(options = {}) {
+    const d = defaults(options);
+    if (d.platform !== 'win32')
+        return { command: 'npx', argsPrefix: [] };
+    const roots = [
+        d.path.dirname(d.nodeExecutable),
+        ...whereAll(d.lookup, 'npx').map((shim) => d.path.dirname(shim)),
+    ];
+    for (const root of roots) {
+        const entry = d.path.join(root, 'node_modules', 'npm', 'bin', 'npx-cli.js');
+        if (d.fileExists(entry))
+            return { command: d.nodeExecutable, argsPrefix: [entry] };
+    }
+    return null;
+}
+//# sourceMappingURL=browser-command.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.46.0",
+  "version": "3.46.1",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",