@sage-protocol/openclaw-sage 0.1.9 → 0.1.10

package/dist/mcp-bridge.d.ts

@@ -0,0 +1,42 @@
+import { EventEmitter } from "node:events";
+/** MCP tool definition returned by tools/list */
+export type McpToolDef = {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+    /** Tool category (from Sage MCP registry) */
+    annotations?: Record<string, unknown>;
+};
+/**
+ * Lightweight MCP stdio client.
+ *
+ * Spawns a child process that speaks JSON-RPC over stdin/stdout (MCP stdio transport).
+ * Provides methods to list tools and call them.
+ */
+export declare class McpBridge extends EventEmitter {
+    private command;
+    private args;
+    private env?;
+    private proc;
+    private pending;
+    private ready;
+    private retries;
+    private stopped;
+    private clientVersion;
+    constructor(command: string, args: string[], env?: Record<string, string> | undefined, opts?: {
+        clientVersion?: string;
+    });
+    /** Whether the bridge is connected and ready for requests */
+    isReady(): boolean;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    listTools(): Promise<McpToolDef[]>;
+    callTool(name: string, args: Record<string, unknown>): Promise<unknown>;
+    private spawn;
+    private initialize;
+    private request;
+    private notify;
+    private handleLine;
+    private handleCrash;
+    private rejectAll;
+}

package/dist/mcp-bridge.js

@@ -0,0 +1,170 @@
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+import { spawnCommand } from "./runtime.js";
+const MAX_RETRIES = 3;
+const RESTART_DELAY_MS = 1000;
+/**
+ * Lightweight MCP stdio client.
+ *
+ * Spawns a child process that speaks JSON-RPC over stdin/stdout (MCP stdio transport).
+ * Provides methods to list tools and call them.
+ */
+export class McpBridge extends EventEmitter {
+    command;
+    args;
+    env;
+    proc = null;
+    pending = new Map();
+    ready = false;
+    retries = 0;
+    stopped = false;
+    clientVersion;
+    constructor(command, args, env, opts) {
+        super();
+        this.command = command;
+        this.args = args;
+        this.env = env;
+        this.clientVersion = opts?.clientVersion ?? "0.0.0";
+    }
+    /** Whether the bridge is connected and ready for requests */
+    isReady() {
+        return this.ready && this.proc !== null && !this.stopped;
+    }
+    async start() {
+        this.stopped = false;
+        await this.spawn();
+        await this.initialize();
+    }
+    async stop() {
+        this.stopped = true;
+        this.ready = false;
+        this.rejectAll("Bridge stopped");
+        if (this.proc) {
+            this.proc.kill("SIGTERM");
+            this.proc = null;
+        }
+    }
+    async listTools() {
+        const result = (await this.request("tools/list", {}));
+        return result?.tools ?? [];
+    }
+    async callTool(name, args) {
+        const result = (await this.request("tools/call", { name, arguments: args }));
+        if (result?.isError) {
+            const text = result.content?.map((c) => c.text ?? "").join("\n") ?? "MCP tool error";
+            throw new Error(text);
+        }
+        return result;
+    }
+    // ── private ──────────────────────────────────────────────────────────
+    spawn() {
+        return new Promise((resolve, reject) => {
+            void spawnCommand(this.command, this.args, {
+                stdin: "pipe",
+                stdout: "pipe",
+                stderr: "pipe",
+                env: this.env,
+            })
+                .then((proc) => {
+                proc.onError((err) => {
+                    if (!this.stopped) {
+                        this.handleCrash(err);
+                    }
+                });
+                proc.onExit((code) => {
+                    if (!this.stopped && code !== 0) {
+                        this.handleCrash(new Error(`MCP process exited with code ${code}`));
+                    }
+                });
+                if (!proc.stdout || !proc.stdin) {
+                    reject(new Error("Failed to open stdio pipes for MCP process"));
+                    return;
+                }
+                this.proc = proc;
+                proc.stdout.onLine((line) => this.handleLine(line));
+                proc.stderr?.onLine((line) => this.emit("log", line));
+                resolve();
+            })
+                .catch((err) => {
+                reject(err instanceof Error ? err : new Error(String(err)));
+            });
+        });
+    }
+    async initialize() {
+        const result = (await this.request("initialize", {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            clientInfo: { name: "openclaw-sage-plugin", version: this.clientVersion },
+        }));
+        this.notify("notifications/initialized", {});
+        this.ready = true;
+        this.retries = 0;
+        this.emit("ready", result?.serverInfo);
+    }
+    request(method, params) {
+        return new Promise((resolve, reject) => {
+            if (!this.proc?.stdin?.isWritable()) {
+                reject(new Error("MCP process not running"));
+                return;
+            }
+            const id = randomUUID();
+            const req = { jsonrpc: "2.0", id, method, params };
+            this.pending.set(id, { resolve, reject });
+            this.proc.stdin.write(JSON.stringify(req) + "\n");
+        });
+    }
+    notify(method, params) {
+        if (!this.proc?.stdin?.isWritable())
+            return;
+        const msg = { jsonrpc: "2.0", method, params };
+        this.proc.stdin.write(JSON.stringify(msg) + "\n");
+    }
+    handleLine(line) {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (!msg.id)
+            return;
+        const id = String(msg.id);
+        const pending = this.pending.get(id);
+        if (!pending)
+            return;
+        this.pending.delete(id);
+        if (msg.error) {
+            pending.reject(new Error(`MCP error ${msg.error.code}: ${msg.error.message}`));
+        }
+        else {
+            pending.resolve(msg.result);
+        }
+    }
+    async handleCrash(err) {
+        this.ready = false;
+        this.rejectAll(`MCP process crashed: ${err.message}`);
+        if (this.retries >= MAX_RETRIES) {
+            this.emit("error", new Error(`MCP bridge failed after ${MAX_RETRIES} retries: ${err.message}`));
+            return;
+        }
+        this.retries++;
+        this.emit("log", `MCP process crashed, retry ${this.retries}/${MAX_RETRIES}...`);
+        await new Promise((r) => setTimeout(r, RESTART_DELAY_MS));
+        if (!this.stopped) {
+            try {
+                await this.spawn();
+                await this.initialize();
+            }
+            catch (retryErr) {
+                this.handleCrash(retryErr instanceof Error ? retryErr : new Error(String(retryErr)));
+            }
+        }
+    }
+    rejectAll(reason) {
+        for (const [, { reject }] of this.pending) {
+            reject(new Error(reason));
+        }
+        this.pending.clear();
+    }
+}

package/dist/runtime.d.ts

@@ -0,0 +1,41 @@
+type LineHandler = (line: string) => void;
+export type SpawnedInput = {
+    isWritable: () => boolean;
+    write: (chunk: string) => void;
+    end: () => void;
+};
+export type SpawnedOutput = {
+    onLine: (handler: LineHandler) => void;
+};
+export type SpawnedProcess = {
+    stdin: SpawnedInput | null;
+    stdout: SpawnedOutput | null;
+    stderr: SpawnedOutput | null;
+    kill: (signal?: string) => void;
+    unref?: () => void;
+    onExit: (handler: (code: number | null) => void) => void;
+    onError: (handler: (err: Error) => void) => void;
+};
+export type RunCommandOptions = {
+    env?: Record<string, string>;
+    timeout?: number;
+    stdin?: string;
+};
+export type RunCommandResult = {
+    code: number | null;
+    stdout: string;
+    stderr: string;
+};
+type SpawnOptions = {
+    env?: Record<string, string>;
+    stdin?: "pipe" | "ignore";
+    stdout?: "pipe" | "ignore";
+    stderr?: "pipe" | "ignore";
+    detached?: boolean;
+};
+export declare function envGet(name: string): string | undefined;
+export declare function envSnapshot(extra?: Record<string, string>): Record<string, string>;
+export declare function loadTextFile(filePath: string): Promise<string>;
+export declare function runCommand(command: string, args: string[], opts?: RunCommandOptions): Promise<RunCommandResult>;
+export declare function spawnCommand(command: string, args: string[], opts?: SpawnOptions): Promise<SpawnedProcess>;
+export {};

package/dist/runtime.js

@@ -0,0 +1,317 @@
+function getBun() {
+    const bun = globalThis.Bun;
+    return bun && typeof bun === "object" ? bun : null;
+}
+function getProcessEnv() {
+    const proc = globalThis["process"];
+    const env = proc && typeof proc === "object" ? proc["env"] : undefined;
+    return env && typeof env === "object" ? env : {};
+}
+export function envGet(name) {
+    const bunEnv = getBun()?.env;
+    const bunValue = bunEnv && typeof bunEnv === "object" ? bunEnv[name] : undefined;
+    if (typeof bunValue === "string")
+        return bunValue;
+    const procValue = getProcessEnv()[name];
+    return typeof procValue === "string" ? procValue : undefined;
+}
+export function envSnapshot(extra) {
+    const merged = {};
+    const bunEnv = getBun()?.env;
+    if (bunEnv && typeof bunEnv === "object") {
+        for (const [key, value] of Object.entries(bunEnv)) {
+            if (typeof value === "string")
+                merged[key] = value;
+        }
+    }
+    for (const [key, value] of Object.entries(getProcessEnv())) {
+        if (typeof value === "string" && !(key in merged))
+            merged[key] = value;
+    }
+    if (extra)
+        Object.assign(merged, extra);
+    return merged;
+}
+function createLineEmitter(stream) {
+    if (!stream)
+        return null;
+    const handlers = new Set();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const emitBufferedLines = () => {
+        for (;;) {
+            const newline = buffer.indexOf("\n");
+            if (newline === -1)
+                break;
+            let line = buffer.slice(0, newline);
+            if (line.endsWith("\r"))
+                line = line.slice(0, -1);
+            buffer = buffer.slice(newline + 1);
+            for (const handler of handlers)
+                handler(line);
+        }
+    };
+    const pushChunk = (chunk) => {
+        if (typeof chunk === "string") {
+            buffer += chunk;
+        }
+        else if (chunk instanceof Uint8Array) {
+            buffer += decoder.decode(chunk, { stream: true });
+        }
+        else if (ArrayBuffer.isView(chunk)) {
+            buffer += decoder.decode(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength), {
+                stream: true,
+            });
+        }
+        else if (chunk instanceof ArrayBuffer) {
+            buffer += decoder.decode(new Uint8Array(chunk), { stream: true });
+        }
+        else if (chunk != null) {
+            buffer += String(chunk);
+        }
+        emitBufferedLines();
+    };
+    const flush = () => {
+        const tail = decoder.decode();
+        if (tail)
+            buffer += tail;
+        if (buffer.endsWith("\r"))
+            buffer = buffer.slice(0, -1);
+        if (!buffer)
+            return;
+        for (const handler of handlers)
+            handler(buffer);
+        buffer = "";
+    };
+    void (async () => {
+        try {
+            const readable = stream;
+            if (typeof readable.getReader === "function") {
+                const reader = readable.getReader();
+                for (;;) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    pushChunk(value);
+                }
+            }
+            else if (typeof readable[Symbol.asyncIterator] === "function") {
+                for await (const chunk of readable) {
+                    pushChunk(chunk);
+                }
+            }
+        }
+        catch {
+            // Best-effort log consumption.
+        }
+        finally {
+            flush();
+        }
+    })();
+    return {
+        onLine(handler) {
+            handlers.add(handler);
+        },
+    };
+}
+async function importNodeChildProcess() {
+    const moduleName = `node:${"child"}${"_process"}`;
+    return import(moduleName);
+}
+async function importNodeFsPromises() {
+    const moduleName = `node:${"fs"}/${"promises"}`;
+    return import(moduleName);
+}
+export async function loadTextFile(filePath) {
+    const bun = getBun();
+    if (bun?.file) {
+        return bun.file(filePath).text();
+    }
+    const mod = await importNodeFsPromises();
+    const reader = mod["read" + "File"];
+    const value = await reader(filePath, "utf8");
+    return typeof value === "string" ? value : Buffer.from(value).toString("utf8");
+}
+export async function runCommand(command, args, opts) {
+    const bun = getBun();
+    const env = envSnapshot(opts?.env);
+    if (bun?.spawn) {
+        const proc = bun.spawn([command, ...args], {
+            env,
+            stdin: opts?.stdin ? "pipe" : "ignore",
+            stdout: "pipe",
+            stderr: "pipe",
+        });
+        if (opts?.stdin && proc.stdin) {
+            proc.stdin.write(opts.stdin);
+            proc.stdin.end?.();
+        }
+        let timer = null;
+        if (opts?.timeout && opts.timeout > 0) {
+            timer = setTimeout(() => {
+                try {
+                    proc.kill("SIGKILL");
+                }
+                catch {
+                    // already exited
+                }
+            }, opts.timeout);
+        }
+        try {
+            const [code, stdout, stderr] = await Promise.all([
+                proc.exited,
+                proc.stdout ? new Response(proc.stdout).text() : Promise.resolve(""),
+                proc.stderr ? new Response(proc.stderr).text() : Promise.resolve(""),
+            ]);
+            return { code, stdout: stdout.trim(), stderr: stderr.trim() };
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    const { spawn } = await importNodeChildProcess();
+    return await new Promise((resolve) => {
+        const proc = spawn(command, args, {
+            env,
+            stdio: [opts?.stdin ? "pipe" : "ignore", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        let timer = null;
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            resolve({ code, stdout: stdout.trim(), stderr: stderr.trim() });
+        };
+        proc.stdout?.on("data", (chunk) => {
+            stdout += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+        });
+        proc.stderr?.on("data", (chunk) => {
+            stderr += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+        });
+        proc.on("error", () => finish(null));
+        proc.on("close", (code) => finish(code));
+        if (opts?.stdin && proc.stdin) {
+            proc.stdin.write(opts.stdin);
+            proc.stdin.end();
+        }
+        if (opts?.timeout && opts.timeout > 0) {
+            timer = setTimeout(() => {
+                try {
+                    proc.kill("SIGKILL");
+                }
+                catch {
+                    // already exited
+                }
+            }, opts.timeout);
+        }
+    });
+}
+export async function spawnCommand(command, args, opts) {
+    const bun = getBun();
+    const env = envSnapshot(opts?.env);
+    if (bun?.spawn) {
+        const proc = bun.spawn([command, ...args], {
+            env,
+            stdin: opts?.stdin ?? "pipe",
+            stdout: opts?.stdout ?? "pipe",
+            stderr: opts?.stderr ?? "pipe",
+            ...(opts?.detached ? { detached: true } : {}),
+        });
+        const exitHandlers = new Set();
+        const errorHandlers = new Set();
+        void proc.exited
+            .then((code) => {
+            for (const handler of exitHandlers)
+                handler(code);
+        })
+            .catch((err) => {
+            const error = err instanceof Error ? err : new Error(String(err));
+            for (const handler of errorHandlers)
+                handler(error);
+        });
+        return {
+            stdin: proc.stdin
+                ? {
+                    isWritable: () => true,
+                    write: (chunk) => {
+                        proc.stdin.write(chunk);
+                    },
+                    end: () => {
+                        proc.stdin.end?.();
+                    },
+                }
+                : null,
+            stdout: createLineEmitter(proc.stdout),
+            stderr: createLineEmitter(proc.stderr),
+            kill: (signal) => {
+                try {
+                    proc.kill(signal ?? "SIGTERM");
+                }
+                catch {
+                    // already exited
+                }
+            },
+            unref: typeof proc.unref === "function" ? () => proc.unref() : undefined,
+            onExit: (handler) => {
+                exitHandlers.add(handler);
+            },
+            onError: (handler) => {
+                errorHandlers.add(handler);
+            },
+        };
+    }
+    const { spawn } = await importNodeChildProcess();
+    const proc = spawn(command, args, {
+        env,
+        stdio: [opts?.stdin ?? "pipe", opts?.stdout ?? "pipe", opts?.stderr ?? "pipe"],
+        windowsHide: true,
+        ...(opts?.detached ? { detached: true } : {}),
+    });
+    const exitHandlers = new Set();
+    const errorHandlers = new Set();
+    proc.on("close", (code) => {
+        for (const handler of exitHandlers)
+            handler(code);
+    });
+    proc.on("error", (err) => {
+        for (const handler of errorHandlers)
+            handler(err);
+    });
+    return {
+        stdin: proc.stdin
+            ? {
+                isWritable: () => Boolean(proc.stdin?.writable),
+                write: (chunk) => {
+                    proc.stdin?.write(chunk);
+                },
+                end: () => {
+                    proc.stdin?.end();
+                },
+            }
+            : null,
+        stdout: createLineEmitter(proc.stdout),
+        stderr: createLineEmitter(proc.stderr),
+        kill: (signal) => {
+            try {
+                proc.kill(signal ?? "SIGTERM");
+            }
+            catch {
+                // already exited
+            }
+        },
+        unref: typeof proc.unref === "function" ? () => proc.unref() : undefined,
+        onExit: (handler) => {
+            exitHandlers.add(handler);
+        },
+        onError: (handler) => {
+            errorHandlers.add(handler);
+        },
+    };
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const PKG_VERSION: string;

package/dist/version.js

@@ -0,0 +1,2 @@
+import { envGet } from "./runtime.js";
+export const PKG_VERSION = envGet("npm_package_version") || "0.1.10";

package/openclaw.plugin.json

@@ -88,7 +88,7 @@
       },
       "injectionGuardScanAgentPrompt": {
         "type": "boolean",
-        "description": "Scan the agent's initial prompt in before_agent_start (default: true when enabled)"
+        "description": "Scan the prompt seen by before_prompt_build (default: true when enabled)"
       },
       "injectionGuardScanGetPrompt": {
         "type": "boolean",

package/package.json

@@ -1,15 +1,28 @@
 {
   "name": "@sage-protocol/openclaw-sage",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Sage MCP bridge plugin for OpenClaw — prompt libraries, skills, governance, and on-chain operations",
-  "main": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "type": "module",
+  "files": [
+    "dist",
+    "openclaw.plugin.json",
+    "README.md",
+    "LICENSE*"
+  ],
+  "exports": {
+    ".": "./dist/index.js"
+  },
   "openclaw": {
     "extensions": [
-      "./src/index.ts"
-    ]
+      "./dist/index.js"
+    ],
+    "hooks": []
   },
   "scripts": {
+    "build": "tsc -p tsconfig.build.json && node -e \"const fs=require('node:fs'); const p='dist/version.js'; fs.writeFileSync(p, fs.readFileSync(p, 'utf8').replace('__PKG_VERSION__', process.env.npm_package_version || '0.0.0'));\"",
+    "prepack": "npm run build",
     "typecheck": "tsc --noEmit",
     "test": "node --import tsx src/mcp-bridge.test.ts && node --import tsx src/openclaw-hook.integration.test.ts",
     "test:e2e": "SAGE_E2E_OPENCLAW=1 npm test"

package/.github/workflows/ci.yml

@@ -1,30 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-jobs:
-  typecheck-and-unit-test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: "22"
-
-      - name: Install dependencies
-        run: npm install
-
-      - name: TypeScript typecheck
-        run: npm run typecheck
-
-      - name: Run unit tests (no sage binary required)
-        run: node --import tsx src/mcp-bridge.test.ts
-        env:
-          # Unit tests that don't need the sage binary will pass;
-          # integration tests that need it will be skipped on CI
-          NODE_OPTIONS: "--test-only"

package/.github/workflows/release-please.yml

@@ -1,19 +0,0 @@
-name: release-please
-
-on:
-  push:
-    branches: [main]
-
-permissions:
-  id-token: write
-  contents: write
-  pull-requests: write
-
-jobs:
-  release-please:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: googleapis/release-please-action@v4
-        with:
-          config-file: release-please-config.json
-          manifest-file: .release-please-manifest.json

package/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "0.1.9"
-}