@runfusion/fusion 0.20.0 → 0.22.0

package/dist/plugins/fusion-plugin-openclaw-runtime/bundled.js

@@ -0,0 +1,369 @@
+// ../plugin-sdk/dist/index.js
+function definePlugin(plugin2) {
+  return plugin2;
+}
+
+// ../../plugins/fusion-plugin-openclaw-runtime/dist/pi-module.js
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+var DEFAULT_BINARY = "openclaw";
+var DEFAULT_AGENT_ID = "main";
+var DEFAULT_THINKING = "off";
+var DEFAULT_TIMEOUT_SEC = 0;
+var DEFAULT_CLI_TIMEOUT_MS = 3e5;
+var ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
+function asString(v) {
+  return typeof v === "string" && v.trim() !== "" ? v.trim() : void 0;
+}
+function asNumber(v) {
+  if (typeof v === "number" && Number.isFinite(v))
+    return v;
+  const s = asString(v);
+  if (s === void 0)
+    return void 0;
+  const n = Number(s);
+  return Number.isFinite(n) ? n : void 0;
+}
+function asBool(v) {
+  if (typeof v === "boolean")
+    return v;
+  const s = asString(v);
+  if (s === void 0)
+    return void 0;
+  return s === "1" || s.toLowerCase() === "true";
+}
+function stripAnsi(text) {
+  return text.replace(ANSI_RE, "");
+}
+function resolveCliConfig(settings) {
+  return {
+    binaryPath: asString(settings?.binaryPath) ?? asString(process.env.OPENCLAW_BIN) ?? DEFAULT_BINARY,
+    agentId: asString(settings?.agentId) ?? asString(process.env.OPENCLAW_AGENT_ID) ?? DEFAULT_AGENT_ID,
+    model: asString(settings?.model) ?? asString(process.env.OPENCLAW_MODEL),
+    thinking: asString(settings?.thinking) ?? asString(process.env.OPENCLAW_THINKING) ?? DEFAULT_THINKING,
+    cliTimeoutSec: asNumber(settings?.cliTimeoutSec) ?? asNumber(process.env.OPENCLAW_TIMEOUT_SEC) ?? DEFAULT_TIMEOUT_SEC,
+    cliTimeoutMs: asNumber(settings?.cliTimeoutMs) ?? asNumber(process.env.OPENCLAW_CLI_TIMEOUT_MS) ?? DEFAULT_CLI_TIMEOUT_MS,
+    useGateway: asBool(settings?.useGateway) ?? asBool(process.env.OPENCLAW_USE_GATEWAY) ?? false
+  };
+}
+function buildOpenClawArgs(config, sessionId, message) {
+  const args = ["--no-color", "agent"];
+  if (!config.useGateway)
+    args.push("--local");
+  args.push("--json");
+  args.push("--session-id", sessionId);
+  args.push("--message", message);
+  args.push("--agent", config.agentId);
+  if (config.model) {
+    args.push("--model", config.model);
+  }
+  args.push("--thinking", config.thinking);
+  args.push("--timeout", String(config.cliTimeoutSec));
+  return args;
+}
+function extractStderrError(stderr, stdout) {
+  const tryExtract = (raw) => {
+    if (!raw)
+      return void 0;
+    const lines = stripAnsi(raw).split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+    return lines.length > 0 ? lines[lines.length - 1] : void 0;
+  };
+  return tryExtract(stderr) ?? tryExtract(stdout ?? "") ?? "openclaw exited with non-zero status (no stderr)";
+}
+function createCliSession(opts) {
+  return {
+    sessionId: randomUUID(),
+    agentId: opts.agentId ?? DEFAULT_AGENT_ID,
+    systemPrompt: opts.systemPrompt,
+    messages: [{ role: "developer", content: opts.systemPrompt }],
+    lastModelDescription: `openclaw/${opts.agentId ?? DEFAULT_AGENT_ID}`,
+    lastUsage: void 0,
+    callbacks: opts.callbacks
+  };
+}
+async function promptCli(session, message, config, callbacks, signal) {
+  const args = buildOpenClawArgs(config, session.sessionId, message);
+  const cb = { ...session.callbacks, ...callbacks };
+  cb.onToolStart?.("openclaw.agent", { sessionId: session.sessionId });
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const child = spawn(config.binaryPath, args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const hardKill = setTimeout(() => {
+      if (settled)
+        return;
+      settled = true;
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      reject(new Error(`openclaw: process timed out after ${config.cliTimeoutMs}ms`));
+    }, config.cliTimeoutMs);
+    const onAbort = () => {
+      if (settled)
+        return;
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    };
+    if (signal) {
+      if (signal.aborted) {
+        onAbort();
+      } else {
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+    }
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf-8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf-8");
+    });
+    child.on("error", (err) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(hardKill);
+      signal?.removeEventListener("abort", onAbort);
+      const isNotFound = err.code === "ENOENT";
+      reject(new Error(isNotFound ? `openclaw: binary not found at "${config.binaryPath}". Install OpenClaw (npm i -g openclaw) or set binaryPath/OPENCLAW_BIN.` : `openclaw: spawn error \u2014 ${err.message}`));
+    });
+    child.on("close", (code) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(hardKill);
+      signal?.removeEventListener("abort", onAbort);
+      if (code !== 0) {
+        const err = stderr.trim() || stdout.trim() ? extractStderrError(stderr, stdout) : `openclaw: exited with code ${String(code)}`;
+        reject(new Error(err));
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(stdout);
+      } catch {
+        reject(new Error(`openclaw: failed to parse JSON output (stdout=${stdout.slice(0, 200)})`));
+        return;
+      }
+      const payloads = parsed.payloads ?? [];
+      const visibleText = payloads.filter((p) => !p.isError && !p.isReasoning).map((p) => p.text ?? "").filter((t) => t.length > 0).join("");
+      const reasoningText = payloads.filter((p) => p.isReasoning).map((p) => p.text ?? "").filter((t) => t.length > 0).join("\n");
+      const errorText = payloads.filter((p) => p.isError).map((p) => p.text ?? "").filter((t) => t.length > 0);
+      const finalText = visibleText || parsed.meta?.finalAssistantVisibleText || "";
+      if (finalText)
+        cb.onText?.(finalText);
+      if (reasoningText)
+        cb.onThinking?.(reasoningText);
+      session.messages.push({ role: "user", content: message });
+      if (finalText) {
+        session.messages.push({ role: "assistant", content: finalText });
+      }
+      const agentMeta = parsed.meta?.agentMeta;
+      if (agentMeta?.usage)
+        session.lastUsage = agentMeta.usage;
+      if (agentMeta?.provider && agentMeta.model) {
+        session.lastModelDescription = `openclaw/${session.agentId}/${agentMeta.provider}/${agentMeta.model}`;
+      }
+      const metaError = parsed.meta?.error;
+      const isError = !!metaError;
+      cb.onToolEnd?.("openclaw.agent", isError, {
+        usage: agentMeta?.usage,
+        provider: agentMeta?.provider,
+        model: agentMeta?.model,
+        ...metaError ? { error: metaError } : {},
+        ...errorText.length > 0 ? { toolErrors: errorText } : {}
+      });
+      resolve();
+    });
+  });
+}
+function describeCliModel(session) {
+  return session.lastModelDescription || `openclaw/${session.agentId}`;
+}
+
+// ../../plugins/fusion-plugin-openclaw-runtime/dist/runtime-adapter.js
+var OpenClawRuntimeAdapter = class {
+  id = "openclaw";
+  name = "OpenClaw Runtime";
+  config;
+  constructor(settings) {
+    this.config = resolveCliConfig(settings);
+  }
+  async createSession(options) {
+    const session = createCliSession({
+      systemPrompt: options.systemPrompt,
+      agentId: this.config.agentId,
+      callbacks: {
+        onText: options.onText,
+        onThinking: options.onThinking,
+        onToolStart: options.onToolStart,
+        onToolEnd: options.onToolEnd
+      }
+    });
+    return { session, sessionFile: void 0 };
+  }
+  async promptWithFallback(session, prompt, options) {
+    const overrideCallbacks = options ?? void 0;
+    await promptCli(session, prompt, this.config, overrideCallbacks);
+  }
+  describeModel(session) {
+    return describeCliModel(session);
+  }
+  async dispose(_session) {
+  }
+};
+
+// ../../plugins/fusion-plugin-openclaw-runtime/dist/probe.js
+import { spawn as spawn2 } from "node:child_process";
+var DEFAULT_PROBE_TIMEOUT_MS = 2e3;
+async function probeOpenClawBinary(opts = {}) {
+  const startedAt = Date.now();
+  const binary = opts.binaryPath ?? "openclaw";
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
+  const resolvedPath = await tryResolveBinaryPath(binary);
+  return new Promise((resolvePromise) => {
+    const finish = (partial) => {
+      resolvePromise({ ...partial, probeDurationMs: Date.now() - startedAt });
+    };
+    let settled = false;
+    const child = spawn2(resolvedPath ?? binary, ["--version"], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const timer = setTimeout(() => {
+      if (settled)
+        return;
+      settled = true;
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      finish({
+        available: false,
+        binaryPath: resolvedPath,
+        reason: `Probe timed out after ${timeoutMs}ms`
+      });
+    }, timeoutMs);
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf-8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf-8");
+    });
+    child.on("error", (err) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      const isNotFound = err.code === "ENOENT";
+      finish({
+        available: false,
+        binaryPath: resolvedPath,
+        reason: isNotFound ? `\`${binary}\` not found on PATH \u2014 install via: npm install -g openclaw` : err.message
+      });
+    });
+    child.on("close", (code) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      if (code === 0) {
+        finish({
+          available: true,
+          binaryPath: resolvedPath,
+          version: stdout.trim() || void 0
+        });
+      } else {
+        finish({
+          available: false,
+          binaryPath: resolvedPath,
+          reason: stderr.trim() || `openclaw --version exited with code ${String(code)}`
+        });
+      }
+    });
+  });
+}
+async function tryResolveBinaryPath(binary) {
+  return new Promise((resolvePromise) => {
+    const which = process.platform === "win32" ? "where" : "which";
+    const child = spawn2(which, [binary], { stdio: ["ignore", "pipe", "ignore"] });
+    let out = "";
+    child.stdout?.on("data", (chunk) => {
+      out += chunk.toString("utf-8");
+    });
+    child.on("error", () => resolvePromise(void 0));
+    child.on("close", (code) => {
+      if (code === 0) {
+        const first = out.trim().split(/\r?\n/)[0];
+        resolvePromise(first?.length ? first : void 0);
+      } else {
+        resolvePromise(void 0);
+      }
+    });
+  });
+}
+
+// ../../plugins/fusion-plugin-openclaw-runtime/dist/index.js
+var OPENCLAW_RUNTIME_ID = "openclaw";
+var OPENCLAW_RUNTIME_VERSION = "0.2.0";
+var openclawRuntimeMetadata = {
+  runtimeId: OPENCLAW_RUNTIME_ID,
+  name: "OpenClaw Runtime",
+  description: "Drives the local `openclaw` CLI (openclaw/openclaw)",
+  version: OPENCLAW_RUNTIME_VERSION
+};
+var openclawRuntimeFactory = async (ctx) => {
+  return new OpenClawRuntimeAdapter(ctx?.settings);
+};
+var plugin = definePlugin({
+  manifest: {
+    id: "fusion-plugin-openclaw-runtime",
+    name: "OpenClaw Runtime Plugin",
+    version: OPENCLAW_RUNTIME_VERSION,
+    description: "Drives the local `openclaw` CLI for Fusion agents \u2014 embedded `--local` mode by default; gateway optional.",
+    author: "Fusion Team",
+    homepage: "https://docs.openclaw.ai/",
+    runtime: openclawRuntimeMetadata
+  },
+  state: "installed",
+  hooks: {
+    onLoad: async (ctx) => {
+      const config = resolveCliConfig(ctx.settings);
+      const probe = await probeOpenClawBinary({ binaryPath: config.binaryPath });
+      ctx.logger.info(probe.available ? `OpenClaw Runtime Plugin loaded \u2014 binary=${config.binaryPath}${probe.version ? ` (${probe.version})` : ""}` : `OpenClaw Runtime Plugin loaded but binary not detected: ${probe.reason ?? "unknown"}`);
+      ctx.emitEvent("openclaw-runtime:loaded", {
+        runtimeId: OPENCLAW_RUNTIME_ID,
+        version: OPENCLAW_RUNTIME_VERSION,
+        binaryAvailable: probe.available,
+        binaryPath: probe.binaryPath ?? config.binaryPath
+      });
+    },
+    onUnload: () => {
+    }
+  },
+  runtime: {
+    metadata: openclawRuntimeMetadata,
+    factory: openclawRuntimeFactory
+  }
+});
+var index_default = plugin;
+export {
+  OPENCLAW_RUNTIME_ID,
+  OpenClawRuntimeAdapter,
+  buildOpenClawArgs,
+  createCliSession,
+  index_default as default,
+  describeCliModel,
+  extractStderrError,
+  openclawRuntimeFactory,
+  openclawRuntimeMetadata,
+  probeOpenClawBinary,
+  promptCli,
+  resolveCliConfig
+};

package/dist/plugins/fusion-plugin-openclaw-runtime/manifest.json

@@ -0,0 +1,14 @@
+{
+  "id": "fusion-plugin-openclaw-runtime",
+  "name": "OpenClaw Runtime Plugin",
+  "version": "0.1.0",
+  "description": "Provides OpenClaw runtime for Fusion AI agents",
+  "author": "Fusion Team",
+  "homepage": "https://github.com/gsxdsm/fusion",
+  "runtime": {
+    "runtimeId": "openclaw",
+    "name": "OpenClaw Runtime",
+    "description": "OpenClaw-backed AI session using the local OpenClaw gateway",
+    "version": "0.1.0"
+  }
+}

package/dist/plugins/fusion-plugin-openclaw-runtime/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@fusion-plugin-examples/openclaw-runtime",
+  "version": "0.2.30",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./bundled.js"
+    }
+  },
+  "private": true
+}