claude-flow 3.46.0 → 3.47.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.46.0",
+  "version": "3.47.0",
   "workspaces": [
     "v3/@claude-flow/codex",
     "v3/@claude-flow/mcp",

package/v3/@claude-flow/cli/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 6,
-  "generatedAt": "2026-09-26T22:32:39.004Z",
-  "gitSha": "39ea61fd",
+  "generatedAt": "2026-09-27T19:39:37.000Z",
+  "gitSha": "09595b70",
   "catalog": {
     "agents": 167,
     "tools": 418,

package/v3/@claude-flow/cli/dist/src/commands/federation.js

@@ -13,6 +13,8 @@ async function run(ctx, tool, args, title) {
         // CLI flag --gateway takes precedence over the RUFLO_X_GATEWAY_URL env var (ADR-125).
         const data = await callMCPTool(tool, { gatewayUrl: ctx.flags.gateway, ...args });
         printJsonOrTable(ctx, data, title);
+        if (data && typeof data === 'object' && (('ok' in data && data.ok === false) || ('degraded' in data && data.degraded === true)))
+            return { success: false, exitCode: 1, data };
         return { success: true, data };
     }
     catch (e) {
@@ -28,8 +30,8 @@ export const federationCommand = {
         { name: 'gateway', description: 'Gateway base URL (takes precedence over RUFLO_X_GATEWAY_URL; default https://x.ruv.io)', type: 'string' },
     ],
     subcommands: [
-        { name: 'join', description: 'Join the open swarm with YOUR OWN key using an invite code (generates ~/.ruflo/nostr.key if absent, claims via NIP-98, verifies via NIP-42)',
-            options: [{ name: 'code', description: 'Invite code (v2.…) — a bearer secret, keep it private', type: 'string', required: true }],
+        { name: 'join', description: 'Join the open swarm with YOUR OWN key without an invite on open relays (generates ~/.ruflo/nostr.key if absent, registers via NIP-98, verifies via NIP-42)',
+            options: [{ name: 'code', description: 'Invite code (v2.…) — a bearer secret, keep it private', type: 'string' }],
             action: (ctx) => run(ctx, 'x_federation_join', { code: ctx.flags.code }, 'Join federation') },
         { name: 'sync', description: 'Fetch recent verified swarm messages',
             options: [{ name: 'since', description: 'Look-back seconds (default 3600)', type: 'number' }, { name: 'limit', description: 'Max messages', type: 'number' }, { name: 'type', description: 'Filter by message type', type: 'string' }],

package/v3/@claude-flow/cli/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/v3/@claude-flow/cli/dist/src/mcp-tools/x-federation-join.d.ts

@@ -1,8 +1,8 @@
 /**
- * Self-service join for the open swarm federation — the user-facing invite path.
+ * Self-service federation join with a local key: public registration or a private invite.
  *
  * Decentralized by design: the user generates/holds THEIR OWN Nostr key locally,
- * redeems an invite code with a NIP-98-signed claim (no admin in the loop), proves
+ * registers with a NIP-98-signed request (no admin in the user flow), proves
  * membership with NIP-42, and announces themselves. The gateway never signs for them.
  *
  * `nostr-tools` is an optional dependency (secp256k1/Schnorr is not in node:crypto):

package/v3/@claude-flow/cli/dist/src/mcp-tools/x-federation-join.js

@@ -36,49 +36,92 @@ export function nip98Header(nt, sk, url, method, body) {
 export async function verifyMembership(nt, sk, relayWs) {
     const { default: WebSocket } = await import('ws');
     return new Promise((resolve) => {
-        const ws = new WebSocket(relayWs, { perMessageDeflate: false });
-        let done = false;
+        const ws = new WebSocket(relayWs, { perMessageDeflate: false, maxPayload: 64 * 1024 });
+        let done = false, authId;
         const fin = (r) => { if (done)
-            return; done = true; try {
+            return; done = true; clearTimeout(timer); try {
             ws.close();
         }
         catch { /* */ } resolve(r); };
+        const timer = setTimeout(() => fin({ ok: false, reason: 'timeout' }), 15000);
         ws.on('message', (d) => {
-            const m = JSON.parse(d.toString());
-            if (m[0] === 'AUTH' && typeof m[1] === 'string')
-                ws.send(JSON.stringify(['AUTH', nt.finalizeEvent({ kind: 22242, created_at: Math.floor(Date.now() / 1000), tags: [['relay', relayWs], ['challenge', m[1]]], content: '' }, sk)]));
-            else if (m[0] === 'OK')
-                fin({ ok: !!m[2], reason: m[3] });
+            let m;
+            try {
+                m = JSON.parse(d.toString());
+            }
+            catch {
+                return;
+            }
+            if (!Array.isArray(m))
+                return;
+            if (m[0] === 'AUTH' && typeof m[1] === 'string' && m[1].length <= 1024 && !authId) {
+                const ev = nt.finalizeEvent({ kind: 22242, created_at: Math.floor(Date.now() / 1000), tags: [['relay', relayWs], ['challenge', m[1]]], content: '' }, sk);
+                authId = ev.id;
+                ws.send(JSON.stringify(['AUTH', ev]));
+            }
+            else if (m[0] === 'OK' && authId && m[1] === authId)
+                fin({ ok: m[2] === true, reason: m[3] });
         });
         ws.on('error', (e) => fin({ ok: false, reason: e.message }));
-        setTimeout(() => fin({ ok: false, reason: 'timeout' }), 15000);
+        ws.on('close', () => fin({ ok: false, reason: 'closed before authentication' }));
     });
 }
+function secureBase(value) {
+    const u = new URL(value);
+    if ((u.protocol !== 'https:' && !(u.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]'].includes(u.hostname)))
+        || u.username || u.password || u.search || u.hash || u.pathname !== '/')
+        throw new Error('gateway must be an HTTPS origin (HTTP allowed only for loopback tests)');
+    return u.origin;
+}
 export const xFederationJoinTools = [{
         name: 'x_federation_join',
-        description: 'Join the open swarm federation with YOUR OWN key using an invite code: generates (or reuses) a local Nostr key at ~/.ruflo/nostr.key (0600), redeems the code with a NIP-98-signed claim directly against the relay, proves membership via NIP-42, and returns your pubkey. Use when you have been handed an invite code and want to participate as yourself. Asking an admin to `federation_admit` you instead is wrong for an open swarm because it centralizes onboarding and requires trusting a pubkey out of band; the invite claim binds membership to the key you hold. Never share the invite code publicly — it is a bearer secret.',
+        description: 'Join the federation with YOUR OWN local key, without an invite when public registration is enabled. Reuses ~/.ruflo/nostr.key (0600), proves key ownership with NIP-98, and verifies membership with NIP-42. Use when a user wants to join as themselves. Publishing as the gateway is wrong for personal identity. Optional private invite codes remain supported; never share keys or codes in chat.',
         inputSchema: { type: 'object', properties: {
-                code: { type: 'string', description: 'Invite code (v2.…) received privately from a member/admin.' },
+                code: { type: 'string', description: 'Optional private invite code (v2.…), for invite-only relays.' },
+                gatewayUrl: { type: 'string', description: 'Public registration gateway origin; defaults to https://x.ruv.io.' },
                 relayHttp: { type: 'string', description: 'Relay HTTPS base for the claim; takes precedence over RUFLO_X_RELAY_HTTP.' },
                 relayWs: { type: 'string', description: 'Relay wss URL for NIP-42; takes precedence over RUFLO_X_RELAY_WS.' },
                 keyFile: { type: 'string', description: 'Key file path; takes precedence over RUFLO_NOSTR_KEY_FILE (default ~/.ruflo/nostr.key).' }
-            }, required: ['code'] },
+            }, required: [] },
         handler: async (input) => {
             const i = input;
             const nt = await loadNostrTools();
             // Validate input before the optional-dependency check so a bad code fails fast and identically
             // whether or not nostr-tools is present.
-            if (!/^v2\.[A-Za-z0-9._-]{8,}$/.test(i.code))
+            if (i.code !== undefined && !/^v2\.[A-Za-z0-9._-]{8,}$/.test(i.code))
                 throw new Error('invite code must look like v2.<token>');
             if (!nt)
                 return { degraded: true, reason: 'nostr-tools not installed', hint: 'npm i -g nostr-tools  (secp256k1 signing is not in node:crypto)' };
+            const registrationBase = i.code ? undefined : secureBase(i.gatewayUrl || process.env.RUFLO_X_GATEWAY_URL || 'https://x.ruv.io');
             const { sk, pubkey, created } = loadOrCreateKey(nt, i.keyFile);
-            const url = `${HTTP_BASE(i.relayHttp)}/api/invites/claim`;
-            const body = JSON.stringify({ code: i.code });
-            const r = await fetch(url, { method: 'POST', headers: { Authorization: nip98Header(nt, sk, url, 'POST', body), 'Content-Type': 'application/json' }, body, signal: AbortSignal.timeout(20_000) });
+            // Existing members need no new grant. In particular never downgrade/re-admit
+            // their key just because they run join again.
+            if (!i.code) {
+                const existing = await verifyMembership(nt, sk, RELAY_WS(i.relayWs));
+                if (existing.ok)
+                    return { ok: true, pubkey, keyCreated: created, membershipVerified: true, alreadyMember: true };
+            }
+            const url = i.code ? `${secureBase(HTTP_BASE(i.relayHttp))}/api/invites/claim` : `${registrationBase}/api/registration`;
+            const body = i.code ? JSON.stringify({ code: i.code }) : '{}';
+            let r;
+            try {
+                r = await fetch(url, { method: 'POST', redirect: 'error', headers: { Authorization: nip98Header(nt, sk, url, 'POST', body), 'Content-Type': 'application/json' }, body, signal: AbortSignal.timeout(20_000) });
+            }
+            catch {
+                const check = await verifyMembership(nt, sk, RELAY_WS(i.relayWs));
+                if (check.ok)
+                    return { ok: true, pubkey, keyCreated: created, membershipVerified: true };
+                throw new Error('Admission response unavailable and relay membership unverified. Keep your local key and retry; do not create another identity.');
+            }
             const claim = (await r.json().catch(() => ({})));
-            if (!r.ok)
-                throw new Error(`claim rejected (${r.status}): ${claim.error ?? claim.message ?? 'unknown'}`);
+            if (!r.ok) {
+                // A lost acknowledgment can follow a successful grant. Check with the
+                // relay before declaring failure; never silently generate a second key.
+                const check = await verifyMembership(nt, sk, RELAY_WS(i.relayWs));
+                if (check.ok)
+                    return { ok: true, pubkey, keyCreated: created, membershipVerified: true };
+                throw new Error(`join rejected (${r.status}): ${claim.error ?? claim.message ?? 'unknown'}`);
+            }
             const auth = await verifyMembership(nt, sk, RELAY_WS(i.relayWs));
             return { ok: auth.ok, pubkey, keyCreated: created, role: claim.role ?? 'member', membershipVerified: auth.ok, ...(auth.ok ? {} : { reason: auth.reason }),
                 next: 'Publish kind-1 events tagged ["t","ruflo-swarm"] — or run `ruflo federation sync` to read the swarm.' };

package/v3/@claude-flow/cli/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/v3/@claude-flow/cli/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/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.46.0",
+  "version": "3.47.0",
   "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",

package/.claude/.proven-config-version

@@ -1 +0,0 @@
-sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319

package/.claude/proven-config.json

@@ -1,42 +0,0 @@
-{
-  "adoptedAt": 1790430093159,
-  "championId": "sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319",
-  "manifest": {
-    "schema": "ruflo.proven-config/v1",
-    "policy": {
-      "ref": "sha256:6141a8ea990c5063b77e090ae8f37f9c539d8aa8f58dcceb30f3a82f97e57319",
-      "value": {
-        "alpha": 0.3,
-        "subjectWeight": 1,
-        "mmrLambda": 0.5,
-        "bodyWeight": 1.5,
-        "typePenaltyFactor": 0.5
-      }
-    },
-    "layer": "framework/node-cli",
-    "compatibility": {
-      "ruflo": ">=3.24.0"
-    },
-    "benchmark": {
-      "corpus": "ADR-081-labelled-v1",
-      "corpusHash": "sha256:2f700b5c363e20a3bd88ce2bc9b87bbbbaa61732c6177894c6ec37890f888982"
-    },
-    "receipt": {
-      "heldOutDelta": 0.07381404928570845,
-      "redblue": "PASS",
-      "drift": 0,
-      "canary": {
-        "rollbackRate": 0,
-        "latencyP95": 244.612458000076,
-        "costPerTask": 0
-      },
-      "receiptCoverage": 1
-    },
-    "platform": [
-      "linux",
-      "macOS",
-      "windows"
-    ]
-  },
-  "previous": ""
-}