@sage-protocol/pi-adapter 0.1.9 → 0.2.1

package/dist/sage-pi-adapter.js

@@ -1,6 +1,16 @@
 import { Type } from "@sinclair/typebox";
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
+function formatSageCommand(command, args) {
+    const quoted = [command, ...args].map((part) => {
+        if (!part)
+            return "''";
+        return /[\s"'`$\\]/.test(part)
+            ? JSON.stringify(part)
+            : part;
+    });
+    return quoted.join(" ");
+}
 const CODE_MODE_SEARCH_TOOLS = ["sage_search", "sage_code_sage_search"];
 const CODE_MODE_EXECUTE_TOOLS = ["sage_execute", "sage_code_sage_execute"];
 const SEARCH_ACTION_ALIASES = {
@@ -62,6 +72,8 @@ const WEB_SEARCH_MAX_ATTEMPTS_PER_PROVIDER = 2;
 const WEB_SEARCH_MIN_INTERVAL_MS = 250;
 const WEB_SEARCH_RETRY_BASE_MS = 250;
 const LAST_WEB_SEARCH_CALL_BY_PROVIDER = new Map();
+const DAEMON_IPC_MAX_ATTEMPTS = Math.max(1, Number.parseInt(process.env.SAGE_DAEMON_IPC_MAX_ATTEMPTS || "3", 10) || 3);
+const DAEMON_IPC_RETRY_BASE_MS = Math.max(50, Number.parseInt(process.env.SAGE_DAEMON_IPC_RETRY_BASE_MS || "350", 10) || 350);
 const DOMAINLESS_ACTION_DOMAIN_HINTS = {
     search: "prompts",
     list: "prompts",
@@ -142,6 +154,14 @@ function isTransientWebSearchError(error) {
     const msg = toErrorMessage(error);
     return WEB_SEARCH_RETRY_PATTERNS.some((pattern) => pattern.test(msg));
 }
+function isTransientDaemonIpcError(error) {
+    const msg = toErrorMessage(error).toLowerCase();
+    return (msg.includes("daemon ipc failed") ||
+        msg.includes("resource temporarily unavailable") ||
+        msg.includes("os error 35") ||
+        msg.includes("eagain") ||
+        msg.includes("temporarily unavailable"));
+}
 function getExternalWebSearchTool(request) {
     if (request.domain !== "external")
         return "";
@@ -193,6 +213,26 @@ function retryBackoffMs(attempt) {
     const jitter = Math.floor(Math.random() * 200);
     return WEB_SEARCH_RETRY_BASE_MS * 2 ** Math.max(attempt - 1, 0) + jitter;
 }
+function daemonRetryBackoffMs(attempt) {
+    const jitter = Math.floor(Math.random() * 150);
+    return DAEMON_IPC_RETRY_BASE_MS * 2 ** Math.max(attempt - 1, 0) + jitter;
+}
+async function callWithDaemonRetry(call, args) {
+    let lastError;
+    for (let attempt = 1; attempt <= DAEMON_IPC_MAX_ATTEMPTS; attempt += 1) {
+        try {
+            return await call(args);
+        }
+        catch (error) {
+            lastError = error;
+            const retryable = isTransientDaemonIpcError(error);
+            if (!retryable || attempt >= DAEMON_IPC_MAX_ATTEMPTS)
+                throw error;
+            await wait(daemonRetryBackoffMs(attempt));
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError ?? "unknown daemon IPC failure"));
+}
 function withExternalToolName(request, toolName) {
     return {
         ...request,
@@ -208,7 +248,7 @@ async function callCodeModeWithWebResilience(mcpBridge, mode, request) {
         : (args) => mcpBridge.callCodeModeExecute(args);
     const requestedTool = getExternalWebSearchTool(request);
     if (!WEB_SEARCH_PROVIDER_TOOLS.has(requestedTool)) {
-        return call(request);
+        return callWithDaemonRetry(call, request);
     }
     const providers = webSearchProviderOrder(requestedTool);
     const failures = [];
@@ -217,7 +257,7 @@ async function callCodeModeWithWebResilience(mcpBridge, mode, request) {
         for (let attempt = 1; attempt <= WEB_SEARCH_MAX_ATTEMPTS_PER_PROVIDER; attempt += 1) {
             try {
                 await enforceWebSearchPacing(provider);
-                return await call(providerRequest);
+                return await callWithDaemonRetry(call, providerRequest);
             }
             catch (error) {
                 failures.push(`${provider} (attempt ${attempt}): ${toErrorMessage(error)}`);
@@ -318,7 +358,7 @@ function normalizeAction(aliasesByDomain, domain, action) {
         return normalizedAction;
     return domainAliases[normalizedAction] ?? normalizedAction;
 }
-async function defaultSageCommandRunner(request) {
+export async function defaultSageCommandRunner(request) {
     return new Promise((resolve, reject) => {
         const proc = spawn(request.command, request.args, {
             env: { ...process.env, ...request.env },
@@ -339,12 +379,18 @@ async function defaultSageCommandRunner(request) {
             clearTimeout(timeout);
             resolve(result);
         };
-        proc.on("error", (err) => {
+        const fail = (err) => {
             if (settled)
                 return;
             settled = true;
             clearTimeout(timeout);
             reject(err);
+        };
+        proc.on("error", (err) => {
+            fail(err);
+        });
+        proc.stdin.on("error", (err) => {
+            fail(err instanceof Error ? err : new Error(String(err)));
         });
         proc.stdout.setEncoding("utf8");
         proc.stderr.setEncoding("utf8");
@@ -362,10 +408,19 @@ async function defaultSageCommandRunner(request) {
                 timedOut,
             });
         });
-        if (request.stdin && proc.stdin.writable) {
-            proc.stdin.write(request.stdin);
+        if (!request.stdin) {
+            proc.stdin.end();
+            return;
+        }
+        if (!proc.stdin.writable || proc.stdin.destroyed) {
+            proc.stdin.end();
+            return;
         }
-        proc.stdin.end();
+        proc.stdin.end(request.stdin, (err) => {
+            if (!err)
+                return;
+            fail(err instanceof Error ? err : new Error(String(err)));
+        });
     });
 }
 function extractText(input) {
@@ -526,6 +581,7 @@ export class SageMcpBridge {
     ready = false;
     stopped = false;
     startPromise = null;
+    stderrBuffer = "";
     constructor(command, args, env = {}, requestTimeoutMs = 20_000) {
         this.command = command;
         this.args = args;
@@ -630,12 +686,10 @@ export class SageMcpBridge {
             proc.on("exit", (code) => {
                 if (this.stopped)
                     return;
-                if (!this.ready) {
-                    rejectOnce(new Error(`MCP process exited before initialization (code ${code ?? -1})`));
-                    return;
-                }
+                const message = this.withRecentStderr(`MCP process exited${this.ready ? '' : ' before initialization'} (code ${code ?? -1})`);
                 this.ready = false;
-                this.rejectAllPending(`MCP process exited (code ${code ?? -1})`);
+                this.rejectAllPending(message);
+                rejectOnce(new Error(message));
             });
             proc.stdin.on("error", () => {
                 // Swallow EPIPE — the exit handler above handles cleanup
@@ -651,6 +705,10 @@ export class SageMcpBridge {
                         this.handleLine(line);
                 }
             });
+            proc.stderr.setEncoding("utf8");
+            proc.stderr.on("data", (chunk) => {
+                this.appendStderr(chunk);
+            });
             this.proc = proc;
             settled = true;
             resolve();
@@ -665,11 +723,17 @@ export class SageMcpBridge {
             const id = randomUUID();
             const timeout = setTimeout(() => {
                 this.pending.delete(id);
-                reject(new Error(`MCP request timed out: ${method}`));
+                reject(new Error(this.withRecentStderr(`MCP request timed out: ${method}`)));
             }, this.requestTimeoutMs);
             this.pending.set(id, { resolve, reject, timeout });
             const req = { jsonrpc: "2.0", id, method, params };
-            this.proc.stdin.write(JSON.stringify(req) + "\n");
+            this.proc.stdin.write(JSON.stringify(req) + "\n", (err) => {
+                if (!err)
+                    return;
+                this.pending.delete(id);
+                clearTimeout(timeout);
+                reject(new Error(this.withRecentStderr(`Failed to write MCP request: ${err.message}`)));
+            });
         });
     }
     notify(method, params) {
@@ -707,6 +771,19 @@ export class SageMcpBridge {
         }
         this.pending.clear();
     }
+    appendStderr(chunk) {
+        this.stderrBuffer += chunk;
+        const maxChars = 4000;
+        if (this.stderrBuffer.length > maxChars) {
+            this.stderrBuffer = this.stderrBuffer.slice(-maxChars);
+        }
+    }
+    withRecentStderr(message) {
+        const stderr = this.stderrBuffer.trim();
+        if (!stderr)
+            return message;
+        return `${message}\nRecent MCP stderr:\n${stderr}`;
+    }
 }
 export class SageHookRuntime {
     config;
@@ -719,6 +796,103 @@ export class SageHookRuntime {
         const result = await this.run(["skill", "context", "--format", "opencode"], { SAGE_SESSION_ID: sessionId ?? "" }, undefined, true);
         return result?.stdout.trim() ?? "";
     }
+    /**
+     * Gather dynamic Sage Protocol identity context for system prompt injection.
+     *
+     * Fetches wallet, library, and skill information in parallel and returns a
+     * compact block suitable for appending to the system prompt. Returns an empty
+     * string if the sage CLI is unavailable or all queries fail.
+     *
+     * The result is cached for `identityCacheTtlMs` (default 60 s) to avoid
+     * redundant CLI calls on every turn.
+     */
+    identityCache = null;
+    identityCacheTtlMs = 60_000;
+    async getIdentityContext() {
+        const now = Date.now();
+        if (this.identityCache && now < this.identityCache.expiresAt) {
+            return this.identityCache.value;
+        }
+        const [walletResult, libraryResult, activeResult] = await Promise.allSettled([
+            this.run(["wallet", "current"], {}, undefined, true),
+            this.run(["library", "list"], {}, undefined, true),
+            this.run(["library", "active"], {}, undefined, true),
+        ]);
+        const lines = [];
+        // --- Wallet ---
+        const walletOut = walletResult.status === "fulfilled" ? walletResult.value?.stdout.trim() ?? "" : "";
+        if (walletOut) {
+            const addrMatch = walletOut.match(/Address:\s*(0x[a-fA-F0-9]+)/i);
+            const typeMatch = walletOut.match(/Type:\s*(\S+)/i);
+            const delegationMatch = walletOut.match(/Active on-chain delegation:\s*(.+)/i);
+            const delegatorMatch = walletOut.match(/Delegator:\s*(0x[a-fA-F0-9]+)/i);
+            const delegateSignerMatch = walletOut.match(/Delegate signer:\s*(0x[a-fA-F0-9]+)/i);
+            const profileMatch = walletOut.match(/Profile:\s*(\S+)/i);
+            const networkMatch = walletOut.match(/Network:\s*(.+)/i);
+            const chainMatch = walletOut.match(/Chain(?:\s*ID)?:\s*(\S+)/i);
+            if (addrMatch) {
+                const addr = addrMatch[1];
+                const walletType = typeMatch?.[1] ?? "unknown";
+                const network = networkMatch?.[1]?.trim() ?? (chainMatch?.[1] === "8453" ? "Base Mainnet" : chainMatch?.[1] === "84532" ? "Base Sepolia" : chainMatch?.[1] ?? "");
+                lines.push(`- Wallet: ${addr.slice(0, 10)}...${addr.slice(-4)} (${walletType}${network ? `, ${network}` : ""})`);
+            }
+            if (delegationMatch && delegatorMatch && delegateSignerMatch) {
+                const delegator = delegatorMatch[1];
+                const delegate = delegateSignerMatch[1];
+                lines.push(`- On-chain delegation: ${delegationMatch[1].trim()} via ${delegate.slice(0, 10)}...${delegate.slice(-4)} for ${delegator.slice(0, 10)}...${delegator.slice(-4)}`);
+            }
+        }
+        // --- Counts only — agent can query details via tools ---
+        const activeOut = activeResult.status === "fulfilled" ? activeResult.value?.stdout.trim() ?? "" : "";
+        if (activeOut) {
+            let activeCount = 0;
+            for (const line of activeOut.split("\n")) {
+                if (/^\s*\d+\.\s+/.test(line))
+                    activeCount++;
+            }
+            if (activeCount > 0) {
+                lines.push(`- ${activeCount} active libraries`);
+            }
+        }
+        const libraryOut = libraryResult.status === "fulfilled" ? libraryResult.value?.stdout.trim() ?? "" : "";
+        if (libraryOut) {
+            let totalSkills = 0;
+            let totalPrompts = 0;
+            let libraryCount = 0;
+            for (const line of libraryOut.split("\n")) {
+                const m = line.match(/\((\d+)\s+prompts?,\s*(\d+)\s+skills?\)/);
+                if (m) {
+                    libraryCount++;
+                    totalPrompts += Number.parseInt(m[1], 10);
+                    totalSkills += Number.parseInt(m[2], 10);
+                }
+            }
+            if (libraryCount > 0) {
+                lines.push(`- ${libraryCount} libraries, ${totalSkills} skills, ${totalPrompts} prompts installed`);
+            }
+        }
+        const PROTOCOL_DESC = "Sage Protocol is a decentralized network for curating prompts, skills, and knowledge on Base (L2).\n" +
+            "Libraries are like gardens — cultivated by communities around shared interests, taste, and tooling preferences.\n" +
+            "Users follow creators, tip valuable work, and post bounties for skills they need.\n" +
+            "Skills stay valuable when kept current with tooling and documentation — different knowledge bases and context work together to provide compounding value.\n" +
+            "SXXX is the governance token: vote, create DAOs, stake on proposals, shape the protocol. Burns from activity create deflationary pressure.\n" +
+            "Credits are the utility currency for IPFS storage and API services.\n" +
+            "The more skills published and curated, the more valuable discovery becomes for every user and agent — a compounding network effect.\n" +
+            "Use sage_search, sage_execute, and sage_status to interact with the protocol.";
+        const KEY_COMMANDS = "### Key Commands\n" +
+            "- Search: `sage_search({ domain: \"skills\", action: \"search\", params: { query: \"...\" } })` or `sage search \"...\" --search-type skills`\n" +
+            "- Use skill: `sage_execute({ domain: \"skills\", action: \"use\", params: { key: \"...\" } })`\n" +
+            "- Tip: `sage tip <address> <amount>` or `sage social tip ...`\n" +
+            "- Bounty: `sage bounties create --title \"...\" --reward <amount>`\n" +
+            "- DAOs: `sage governance dao discover`\n" +
+            "- Publish: `sage library push <name>`\n" +
+            "- Follow: `sage social follow <address>`";
+        const block = lines.length > 0
+            ? `## Sage Protocol Context\n${PROTOCOL_DESC}\n\n${lines.join("\n")}\n\n${KEY_COMMANDS}`
+            : "";
+        this.identityCache = { value: block, expiresAt: now + this.identityCacheTtlMs };
+        return block;
+    }
     async suggestSkill(prompt, sessionId) {
         const trimmed = prompt.trim();
         if (!trimmed)
@@ -791,7 +965,29 @@ export class SageHookRuntime {
         }, JSON.stringify(payload), true);
         return result ? parseSecurityDecision(result.stdout) : null;
     }
+    /**
+     * Resolve skill content by name(s) via `sage skill get`.
+     * Returns a map of skill name -> SKILL.md content (or empty string on miss).
+     * Used to auto-inject skills into subagent contexts when Pi can't resolve them locally.
+     */
+    async resolveSkills(names) {
+        const results = new Map();
+        if (!names.length)
+            return results;
+        const settled = await Promise.allSettled(names.map(async (name) => {
+            const result = await this.run(["skill", "get", name, "--format", "raw"], { SAGE_SOURCE: this.config.source ?? "pi" }, undefined, true);
+            const content = result?.stdout.trim() ?? "";
+            return { name, content };
+        }));
+        for (const outcome of settled) {
+            if (outcome.status === "fulfilled" && outcome.value.content) {
+                results.set(outcome.value.name, outcome.value.content);
+            }
+        }
+        return results;
+    }
     async run(args, env, stdin, ignoreFailures = false) {
+        const commandText = formatSageCommand(this.config.sageBin, args);
         try {
             const commandEnv = {
                 HOME: process.env.HOME ?? "",
@@ -809,17 +1005,25 @@ export class SageHookRuntime {
                 stdin,
                 timeoutMs: this.config.timeoutMs,
             });
-            if (!ignoreFailures && (result.timedOut || result.exitCode !== 0)) {
-                const reason = result.timedOut
-                    ? `timed out: ${this.config.sageBin} ${args.join(" ")}`
-                    : `failed (${result.exitCode}): ${result.stderr || result.stdout}`;
-                throw new Error(reason);
+            if (result.timedOut || result.exitCode !== 0) {
+                const detail = (result.stderr || result.stdout || "").trim();
+                const message = result.timedOut
+                    ? `[sage-pi-adapter] Sage command timed out: ${commandText}`
+                    : `[sage-pi-adapter] Sage command failed (${result.exitCode}): ${commandText}${detail ? `\n${detail}` : ""}`;
+                if (ignoreFailures) {
+                    console.error(message);
+                    return result;
+                }
+                throw new Error(message);
             }
             return result;
         }
         catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            const message = `[sage-pi-adapter] Sage command error: ${commandText}${detail ? `\n${detail}` : ""}`;
             if (!ignoreFailures)
-                throw error;
+                throw new Error(message);
+            console.error(message);
             return null;
         }
     }
@@ -849,8 +1053,6 @@ export function createSageSearchTool(mcpBridge) {
             "Use sage_search (NOT bash sage commands) for web searches, documentation lookups, and prompt/skill discovery",
             "NEVER run 'sage' CLI via bash -- always use the sage_search or sage_execute tools instead",
             "For web search: sage_search({ domain: 'external', action: 'search', params: { tool_name: 'web_search', tool_params: { query: '...' } } })",
-            "For GitHub code search: sage_search({ domain: 'external', action: 'search', params: { tool_name: 'github_search_code', tool_params: { query: '...' } } })",
-            "For library docs: sage_search({ domain: 'external', action: 'search', params: { tool_name: 'get_library_docs', tool_params: { context7CompatibleLibraryID: '/lib/id' } } })",
             "To list available tools: sage_search({ domain: 'external', action: 'list_servers' })",
         ],
         description: "Search the web, find documentation, search prompts/skills, and query external services. " +
@@ -909,10 +1111,8 @@ export function createSageExecuteTool(mcpBridge) {
         label: "Sage: Execute",
         promptSnippet: "Execute mutations: call external tools, use pi's hub-compat layer, create prompts, fetch URLs",
         promptGuidelines: [
-            "Use sage_execute (NOT bash sage commands) for calling external tools, fetching URLs, and pi-compatible MCP server management",
+            "Use sage_execute (NOT bash sage commands) for calling external tools, fetching URLs, and managing MCP servers",
             "To fetch a URL: sage_execute({ domain: 'external', action: 'call', params: { tool_name: 'fetch', tool_params: { url: 'https://...' } } })",
-            "In pi, hub lifecycle remains available through the compatibility wrapper: sage_execute({ domain: 'hub', action: 'start', params: { server_id: 'duckduckgo' } })",
-            "To call any external tool: sage_execute({ domain: 'external', action: 'call', params: { tool_name: 'tool_name', tool_params: { ... } } })",
         ],
         description: "Execute mutations: create prompts, use skills, send chat messages, call external tools, and manage external MCP servers through pi's hub-compat wrapper. " +
             "Preferred raw MCP clients use direct hub_* tools; in pi use domain='hub', action='start', params={server_id:'duckduckgo'} when needed. " +
@@ -988,6 +1188,40 @@ export function createSageExecuteTool(mcpBridge) {
         },
     };
 }
+// Tier 3: Complete CLI reference — available on-demand via sage_status().
+// Not injected into system prompt; model requests it when needed.
+const SAGE_CLI_REFERENCE = `
+## Sage CLI Reference (Tier 3 — on-demand)
+
+### Skill Trigger Workflow
+1) Discover: sage_search({ domain: "skills", action: "search", params: { query: "..." } })
+2) Inspect:  sage_search({ domain: "skills", action: "get", params: { key: "..." } })
+3) Activate: sage_execute({ domain: "skills", action: "use", params: { key: "..." } })
+4) Hook mode: sage suggest hook skill --limit 3 --provision (reads PROMPT env/stdin)
+
+### Rust CLI Fallback (when user asks for terminal commands)
+- Discovery: sage search "<query>" --search-type skills --scope both
+- Suggest:   sage suggest skill "<intent>" --limit 3 --provision
+- Inspect:   sage skill get <key>
+- Libraries: sage library list | sage library discover | sage library sync
+- Gov:       sage governance dao discover | sage governance proposals list --dao <addr>
+- MCP:       sage mcp start | sage mcp hub list | sage mcp hub status
+
+### Library / DAO / Bounty Recipes
+- Library: sage library create <name>; sage library skill add <path> -l <library>; sage library prompt add <name> -l <library> --file <path>; sage library push <library>; sage library promote <library> --dao 0x... --collection default
+- DAO:     sage governance dao create --name "My DAO" --description "..." --governance personal|team|community [--operator 0x...|--burn 1500]
+- Bounty:  sage bounties create --title "Task" --description "..." --reward 100 --deadline 7d --subdao 0x...
+
+### Hub Management
+- Start: sage_execute({ domain: "hub", action: "start", params: { server_id: "brave-search" } })
+- Stop:  sage_execute({ domain: "hub", action: "stop", params: { server_id: "brave-search" } })
+- List:  sage_search({ domain: "external", action: "list_servers" })
+
+### Guardrails
+- Verify uncertain syntax with sage --help / sage <group> --help.
+- Prefer sage search --search-type skills when sage skill search is unavailable.
+- Do not use legacy removed top-level commands: sage dao ..., sage proposals ..., sage ipfs ...
+`.trim();
 export function createSageStatusTool(mcpBridge) {
     return {
         name: "sage_status",
@@ -1015,6 +1249,10 @@ export function createSageStatusTool(mcpBridge) {
                                     context: extractJsonFromMcpResult(context) ?? context,
                                 }, null, 2),
                             },
+                            {
+                                type: "text",
+                                text: SAGE_CLI_REFERENCE,
+                            },
                         ],
                     };
                 }
@@ -1031,6 +1269,10 @@ export function createSageStatusTool(mcpBridge) {
                             sageAdapterVersion: "0.2.0",
                         }, null, 2),
                     },
+                    {
+                        type: "text",
+                        text: SAGE_CLI_REFERENCE,
+                    },
                 ],
                 details: { bridgeConnected },
             };
@@ -1187,6 +1429,17 @@ export async function createSageSessionConfig(config = {}) {
                 .catch((error) => {
                 console.error("[sage-pi-adapter] failed to inject session context:", error);
             });
+            // Inject dynamic identity context (wallet, libraries, skills) at session start.
+            hookRuntime
+                .getIdentityContext()
+                .then(async (identity) => {
+                if (!identity)
+                    return;
+                await injectHookMessage(session, "sage-identity-context", identity, false);
+            })
+                .catch((error) => {
+                console.error("[sage-pi-adapter] failed to inject identity context:", error);
+            });
             const unsubscribe = session.subscribe((event) => {
                 const parsed = parseMessageEndEvent(event);
                 if (!parsed)