@claude-flow/cli 3.39.3 → 3.41.0

package/dist/src/mcp-tools/x-federation-tools.js

@@ -0,0 +1,96 @@
+// ADR-125 precedence: the tool arg `gatewayUrl` (fed by `ruflo federation --gateway`)
+// takes precedence over the RUFLO_X_GATEWAY_URL env var, which precedes the default.
+const GATEWAY = (override) => ((typeof override === 'string' && override) || process.env.RUFLO_X_GATEWAY_URL || 'https://x.ruv.io').replace(/\/$/, '');
+const gatewayArg = { gatewayUrl: { type: 'string', description: 'Gateway base URL; takes precedence over RUFLO_X_GATEWAY_URL (default https://x.ruv.io).' } };
+const TIMEOUT_MS = 25_000;
+/** Minimal MCP-over-Streamable-HTTP client: POST JSON-RPC, parse the SSE `data:` frame. */
+async function gatewayRpc(method, params, gatewayUrl) {
+    const res = await fetch(`${GATEWAY(gatewayUrl)}/mcp`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', accept: 'application/json, text/event-stream' },
+        body: JSON.stringify({ jsonrpc: '2.0', id: Date.now(), method, params }),
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+    });
+    const text = await res.text();
+    const line = text.split('\n').find((l) => l.startsWith('data:'));
+    const payload = JSON.parse(line ? line.slice(5) : text);
+    if (payload.error)
+        throw new Error(`x.ruv.io: ${payload.error.message ?? 'rpc error'}`);
+    return payload.result;
+}
+async function gatewayTool(name, args) {
+    const { gatewayUrl, ...rest } = args;
+    const r = (await gatewayRpc('tools/call', { name, arguments: rest }, gatewayUrl));
+    const text = r.content?.[0]?.text ?? '{}';
+    const parsed = JSON.parse(text);
+    if (r.isError || parsed.error)
+        throw new Error(String(parsed.error ?? 'gateway tool error'));
+    return parsed;
+}
+async function gatewayResource(uri, gatewayUrl) {
+    const r = (await gatewayRpc('resources/read', { uri }, gatewayUrl));
+    return JSON.parse(r.contents?.[0]?.text ?? '{}');
+}
+// Credential: intentionally env-only (a secret must never be a CLI flag — it would land in
+// shell history / process lists). Registered in scripts/audit-env-var-precedence.mjs.
+const adminToken = () => process.env.RUFLO_X_ADMIN_TOKEN;
+export const xFederationTools = [
+    {
+        name: 'x_federation_sync',
+        description: 'Fetch recent signature-verified coordination messages from the open x.ruv.io swarm federation (Nostr, #t=ruflo-swarm). Use when you need to see what other ruflo nodes across the internet have posted (PeerHello/Status/Task/Result/Claim*). Reading the relay directly is wrong because you would have to do NIP-42 auth yourself; the gateway does it and only returns events whose signatures verify.',
+        inputSchema: { type: 'object', properties: { ...gatewayArg, sinceSeconds: { type: 'number', description: 'Look-back window (default 3600).' }, limit: { type: 'number', description: 'Max messages (default 100).' }, type: { type: 'string', description: 'Optional message type filter, e.g. Task.' } } },
+        handler: async (input) => gatewayTool('federation_sync', input),
+    },
+    {
+        name: 'x_federation_roster',
+        description: 'List nodes currently announcing themselves on the open swarm (recent PeerHello events) via the ruv://swarm/roster resource. Use when you need to know who is online across the federation before assigning work. Grepping sync output by hand is wrong because the roster resource already de-duplicates by pubkey and carries lastSeen.',
+        inputSchema: { type: 'object', properties: { ...gatewayArg } },
+        handler: async (input) => gatewayResource('ruv://swarm/roster', input.gatewayUrl),
+    },
+    {
+        name: 'x_federation_claims',
+        description: 'Return the current owner-per-resource work-claims ledger for the open swarm (ruv://claims/board). Use when you are about to start shared work and need to know whether a resourceId is already owned. Inferring ownership from raw ClaimIssued events is wrong because releases, TTL expiry and handoffs change the answer; the board applies those rules.',
+        inputSchema: { type: 'object', properties: { ...gatewayArg } },
+        handler: async (input) => gatewayResource('ruv://claims/board', input.gatewayUrl),
+    },
+    {
+        name: 'x_federation_registry',
+        description: 'Read the federation registry resource (ruv://federation/registry): relay URL, canonical relay tag for NIP-42, gateway pubkey, and the exact self-join steps. Use when onboarding a new node or user to the open federation. Hard-coding the relay URL is wrong because the relay verifies the NIP-42 relay tag strictly against its canonical host, which this resource states.',
+        inputSchema: { type: 'object', properties: { ...gatewayArg } },
+        handler: async (input) => gatewayResource('ruv://federation/registry', input.gatewayUrl),
+    },
+    {
+        name: 'x_federation_publish',
+        description: 'Publish a signed coordination message to the open swarm AS THE GATEWAY identity (Status/Task/Result/…). Requires RUFLO_X_ADMIN_TOKEN. Use when a trusted operator needs a hub-level broadcast. Using this to post on behalf of an individual node is wrong because it attributes the message to the gateway, not the node — nodes should join with their own key via invite→claim and publish themselves.',
+        inputSchema: { type: 'object', properties: { ...gatewayArg, msgType: { type: 'string' }, payload: { type: 'object' } }, required: ['msgType', 'payload'] },
+        handler: async (input) => {
+            const t = adminToken();
+            if (!t)
+                throw new Error('RUFLO_X_ADMIN_TOKEN is not set (gateway-identity writes are admin-gated)');
+            return gatewayTool('federation_publish', { ...input, adminToken: t });
+        },
+    },
+    {
+        name: 'x_federation_invite_mint',
+        description: 'Mint a use-limited, expiring invite code so a new ruflo user can self-join the open federation with THEIR OWN key. Requires RUFLO_X_ADMIN_TOKEN. Use when onboarding someone. Sharing the relay owner key instead is wrong because invites are revocable, hashed at rest, and bind membership to the claimant\'s key; the code is a bearer secret — hand it over privately.',
+        inputSchema: { type: 'object', properties: { ...gatewayArg, ttlSecs: { type: 'number', description: 'Validity (default 7 days).' }, maxUses: { type: 'number', description: 'Redemptions (default 25).' } } },
+        handler: async (input) => {
+            const t = adminToken();
+            if (!t)
+                throw new Error('RUFLO_X_ADMIN_TOKEN is not set (invite minting is admin-gated)');
+            return gatewayTool('federation_invite_mint', { ...input, adminToken: t });
+        },
+    },
+    {
+        name: 'x_federation_admit',
+        description: 'Admit a Nostr pubkey as a relay member directly (NIP-43 kind 9030). Requires RUFLO_X_ADMIN_TOKEN. Use when a known node reports its 64-hex pubkey and you want to skip the invite step. Padding or hand-editing a reported pubkey is wrong because it is a cryptographic identity; a malformed key must be re-reported, never fixed up.',
+        inputSchema: { type: 'object', properties: { ...gatewayArg, pubkey: { type: 'string', description: '64-hex secp256k1 x-only pubkey.' }, role: { type: 'string', enum: ['member', 'admin'] } }, required: ['pubkey'] },
+        handler: async (input) => {
+            const t = adminToken();
+            if (!t)
+                throw new Error('RUFLO_X_ADMIN_TOKEN is not set (admission is admin-gated)');
+            return gatewayTool('federation_admit', { ...input, adminToken: t });
+        },
+    },
+];
+//# sourceMappingURL=x-federation-tools.js.map

package/dist/src/services/distill-oracle.d.ts

@@ -36,7 +36,7 @@
  */
 import { type VerifyTaskKind } from '../ruvector/output-verifier.js';
 import { FableHarness, type ReflectItem, type ReflectResult } from './fable-harness.js';
-export declare const MH_DARWIN_PIN = "0.9.0";
+export declare const MH_DARWIN_PIN = "0.10.2";
 export type ResolvedProvenance = 'oracle:test-exec' | 'judge:fable' | 'proxy:structural';
 /** SWE-bench-shaped / bench-suite-mapped test spec that Tier 1 can execute. */
 export interface TestSpec {

package/dist/src/services/distill-oracle.js

@@ -44,7 +44,7 @@ import { FableHarness, } from './fable-harness.js';
 // scripts/check-metaharness-pins.mjs watch this constant for drift. Kept in
 // lock-step with the optionalDependencies pin in package.json and the plugin
 // darwin cache (versioned by the plugin's own `~0.8.0` pin in _darwin.mjs).
-export const MH_DARWIN_PIN = '0.9.0';
+export const MH_DARWIN_PIN = '0.10.2';
 // ── Public API ───────────────────────────────────────────────────────────
 /**
  * Label each trajectory with `resolved` + honest provenance, trying the tiers

package/dist/src/services/harness-project-anchor.js

@@ -17,14 +17,25 @@ function normalizeHash(value) {
     return trimmed.startsWith('sha256:') ? trimmed : `sha256:${trimmed}`;
 }
 function containedPath(projectRoot, requested) {
-    const root = realpathSync(resolve(projectRoot));
-    const absolute = isAbsolute(requested) ? resolve(requested) : resolve(root, requested);
-    const lexical = relative(root, absolute);
-    if (lexical === '..' || lexical.startsWith(`..${sep}`) || isAbsolute(lexical)) {
+    // The project root has two equally valid spellings when its path crosses a
+    // symlink — on macOS `/tmp/x` and `/private/tmp/x` name the same directory.
+    // Comparing a realpath'd root against a NON-realpath'd candidate (as this
+    // did) makes every such project look like an escape, so a project anchored
+    // anywhere under a symlink was rejected outright. Compare like with like:
+    // the lexical guard accepts either spelling of the root, and the symlink
+    // guard below still resolves the target and re-checks it physically.
+    const rootLexical = resolve(projectRoot);
+    const rootPhysical = realpathSync(rootLexical);
+    const absolute = isAbsolute(requested) ? resolve(requested) : resolve(rootLexical, requested);
+    const escapes = (base) => {
+        const rel = relative(base, absolute);
+        return rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel);
+    };
+    if (escapes(rootLexical) && escapes(rootPhysical)) {
         throw new Error('flywheel anchor path must stay inside project root');
     }
     const actual = realpathSync(absolute);
-    const physical = relative(root, actual);
+    const physical = relative(rootPhysical, actual);
     if (physical === '..' || physical.startsWith(`..${sep}`) || isAbsolute(physical)) {
         throw new Error('flywheel anchor symlink escapes project root');
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.39.3",
+  "version": "3.41.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",
@@ -130,7 +130,7 @@
   "optionalDependencies": {
     "@agntcy/slim-bindings": "2.0.0-alpha.5",
     "@claude-flow/memory": "^3.0.0-alpha.23",
-    "@metaharness/darwin": "~0.9.0",
+    "@metaharness/darwin": "~0.10.2",
     "@metaharness/flywheel": "~0.1.10",
     "@metaharness/radio": "~0.1.0",
     "@metaharness/turn-credit": "~0.1.0",
@@ -138,7 +138,8 @@
     "agentdb": "^3.0.0-alpha.17",
     "agentic-flow": "^3.0.0-alpha.1",
     "better-sqlite3": "^12.9.0",
-    "ruvector": "^0.2.27"
+    "ruvector": "^0.2.27",
+    "nostr-tools": "^2.7.0"
   },
   "peerDependencies": {
     "@metaharness/router": "^0.4.0",