@clawling/clawchat-plugin-openclaw 2026.6.23-1 → 2026.6.24-1

package/dist/src/liveware-cli.js

@@ -0,0 +1,93 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
+export const LIVEWARE_BASE_URL = "https://media.clawling.chat/liveware/";
+// A non-default User-Agent is required: the CDN (Cloudflare) returns 403 for
+// known scripting/default UAs, so download requests must identify themselves.
+const LIVEWARE_USER_AGENT = "clawchat-liveware-installer";
+/** Directory where the downloaded binaries live: <stateDir>/clawchat/liveware. */
+export function livewareDir(stateDir) {
+    const root = stateDir ?? resolveStateDir();
+    return path.join(root, "clawchat", "liveware");
+}
+/** Map host platform/arch to the two asset filenames, or null if unsupported. */
+export function platformAssets(plat = process.platform, arch = process.arch) {
+    const os = plat === "darwin" ? "darwin" : plat === "linux" ? "linux" : null;
+    const cpu = arch === "x64" ? "amd64" : arch === "arm64" ? "arm64" : null;
+    if (!os || !cpu)
+        return null;
+    return { liveware: `liveware-${os}-${cpu}`, tunneAgent: `tunnel-agent-${os}-${cpu}` };
+}
+function findOnPath(name) {
+    const raw = process.env.PATH ?? "";
+    for (const dir of raw.split(path.delimiter)) {
+        if (!dir)
+            continue;
+        const candidate = path.join(dir, name);
+        try {
+            fs.accessSync(candidate, fs.constants.X_OK);
+            return candidate;
+        }
+        catch {
+            // not here; keep scanning
+        }
+    }
+    return null;
+}
+/**
+ * Resolve the liveware executable to invoke:
+ *  1. on PATH        → "liveware" (let the OS resolve it)
+ *  2. downloaded dir → absolute path
+ *  3. otherwise      → null
+ */
+export function resolveLivewarePath(stateDir) {
+    if (findOnPath("liveware"))
+        return "liveware";
+    const local = path.join(livewareDir(stateDir), "liveware");
+    try {
+        fs.accessSync(local, fs.constants.X_OK);
+        return local;
+    }
+    catch {
+        return null;
+    }
+}
+async function downloadTo(url, dest) {
+    const res = await fetch(url, { headers: { "user-agent": LIVEWARE_USER_AGENT } });
+    if (!res.ok)
+        throw new Error(`download ${url} failed: HTTP ${res.status}`);
+    const buf = Buffer.from(await res.arrayBuffer());
+    if (buf.length === 0)
+        throw new Error(`download ${url} returned empty body`);
+    const tmp = `${dest}.tmp`;
+    await fs.promises.writeFile(tmp, buf);
+    await fs.promises.chmod(tmp, 0o755);
+    await fs.promises.rename(tmp, dest);
+}
+/**
+ * Startup hook: ensure the liveware CLI is available, downloading it when not.
+ * Fire-and-forget — never throws; logs and returns on any failure.
+ */
+export async function ensureLivewareCli(opts = {}) {
+    const { stateDir, log } = opts;
+    try {
+        if (findOnPath("liveware"))
+            return; // PATH wins
+        const dir = livewareDir(stateDir);
+        const target = path.join(dir, "liveware");
+        if (fs.existsSync(target))
+            return;
+        const assets = platformAssets();
+        if (!assets) {
+            log?.warn?.(`clawchat-plugin-openclaw: unsupported platform ${process.platform}/${process.arch}; skipping liveware download`);
+            return;
+        }
+        await fs.promises.mkdir(dir, { recursive: true });
+        await downloadTo(LIVEWARE_BASE_URL + assets.liveware, path.join(dir, "liveware"));
+        await downloadTo(LIVEWARE_BASE_URL + assets.tunneAgent, path.join(dir, "tunnel-agent"));
+        log?.debug?.(`clawchat-plugin-openclaw: liveware CLI downloaded to ${dir}`);
+    }
+    catch (err) {
+        log?.warn?.(`clawchat-plugin-openclaw: liveware CLI download skipped: ${String(err)}`);
+    }
+}

package/dist/src/runtime.js

@@ -5,6 +5,7 @@ import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
 import { createOpenclawClawlingClient, resolveOpenclawClawlingDeviceId } from "./client.js";
 import { createOpenclawClawlingApiClient } from "./api-client.js";
 import { reportPluginVersionSafe, resolvePluginVersion } from "./plugin-report.js";
+import { ensureLivewareCli } from "./liveware-cli.js";
 import { ClawlingApiError } from "./api-types.js";
 import { RefreshManager } from "./refresh-manager.js";
 import { runOpenclawClawlingLogin, } from "./login.runtime.js";
@@ -618,6 +619,15 @@ export async function startOpenclawClawlingGateway(params) {
         authenticated: false,
         log,
     });
+    // Ensure the liveware CLI is installed (async, never blocks startup).
+    void ensureLivewareCli({
+        stateDir: runtime.state?.resolveStateDir?.(),
+        log: {
+            warn: (m) => log?.info?.(m),
+            debug: (m) => log?.debug?.(m),
+            error: (m) => log?.error?.(m),
+        },
+    });
     // §B self-heal — non-interactive env connect-code activation BEFORE blocking on
     // the wait-for-activation loop. Gated so the common path (no env code, or an
     // already-credentialed account) adds NO async work: on success it credentials

package/dist/src/tools.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { execFile } from "node:child_process";
 import { createOpenclawClawlingApiClient } from "./api-client.js";
+import { resolveLivewarePath } from "./liveware-cli.js";
 import { ClawlingApiError, } from "./api-types.js";
 import { resolveOpenclawClawlingAccount } from "./config.js";
 import { clawChatDbPathForStateDir, getClawChatStore, } from "./storage.js";
@@ -1048,14 +1049,20 @@ export function registerOpenclawClawlingTools(api, options = {}) {
                     return configError("clawchat-plugin-openclaw: token is required");
                 }
                 return await new Promise((resolve) => {
+                    const livewarePath = resolveLivewarePath(api.runtime.state?.resolveStateDir?.());
+                    if (!livewarePath) {
+                        resolve(jsonResponse({
+                            error: "config",
+                            message: "liveware CLI not found in PATH; install liveware before calling this tool",
+                        }));
+                        return;
+                    }
                     // Security: the token is passed as a child process argv value using
                     // liveware's documented --access-token interface. It is in the child
                     // argv briefly during process creation; env-var or stdin delivery
                     // would be preferred if liveware supported it.
                     // NEVER log the argv array; scrub token from any captured output below.
-                    execFile("liveware", ["login", "--access-token", token], { timeout: 30000 }, (err, stdout, stderr) => {
-                        // Scrub token from any output before returning — token must never
-                        // appear in tool results visible to the LLM.
+                    execFile(livewarePath, ["login", "--access-token", token], { timeout: 30000 }, (err, stdout, stderr) => {
                         const scrub = (s) => (token ? s.split(token).join("***") : s);
                         const safeStdout = scrub(stdout ?? "").trim();
                         const safeStderr = scrub(stderr ?? "").trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawling/clawchat-plugin-openclaw",
-  "version": "2026.6.23-1",
+  "version": "2026.6.24-1",
   "description": "OpenClaw ClawChat channel plugin",
   "license": "MIT",
   "files": [

package/src/liveware-cli.ts

@@ -0,0 +1,106 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
+
+export const LIVEWARE_BASE_URL = "https://media.clawling.chat/liveware/";
+
+// A non-default User-Agent is required: the CDN (Cloudflare) returns 403 for
+// known scripting/default UAs, so download requests must identify themselves.
+const LIVEWARE_USER_AGENT = "clawchat-liveware-installer";
+
+export type LivewareLogger = {
+  warn?: (m: string) => void;
+  debug?: (m: string) => void;
+  error?: (m: string) => void;
+};
+
+/** Directory where the downloaded binaries live: <stateDir>/clawchat/liveware. */
+export function livewareDir(stateDir?: string): string {
+  const root = stateDir ?? resolveStateDir();
+  return path.join(root, "clawchat", "liveware");
+}
+
+/** Map host platform/arch to the two asset filenames, or null if unsupported. */
+export function platformAssets(
+  plat: string = process.platform,
+  arch: string = process.arch,
+): { liveware: string; tunneAgent: string } | null {
+  const os = plat === "darwin" ? "darwin" : plat === "linux" ? "linux" : null;
+  const cpu = arch === "x64" ? "amd64" : arch === "arm64" ? "arm64" : null;
+  if (!os || !cpu) return null;
+  return { liveware: `liveware-${os}-${cpu}`, tunneAgent: `tunnel-agent-${os}-${cpu}` };
+}
+
+function findOnPath(name: string): string | null {
+  const raw = process.env.PATH ?? "";
+  for (const dir of raw.split(path.delimiter)) {
+    if (!dir) continue;
+    const candidate = path.join(dir, name);
+    try {
+      fs.accessSync(candidate, fs.constants.X_OK);
+      return candidate;
+    } catch {
+      // not here; keep scanning
+    }
+  }
+  return null;
+}
+
+/**
+ * Resolve the liveware executable to invoke:
+ *  1. on PATH        → "liveware" (let the OS resolve it)
+ *  2. downloaded dir → absolute path
+ *  3. otherwise      → null
+ */
+export function resolveLivewarePath(stateDir?: string): string | null {
+  if (findOnPath("liveware")) return "liveware";
+  const local = path.join(livewareDir(stateDir), "liveware");
+  try {
+    fs.accessSync(local, fs.constants.X_OK);
+    return local;
+  } catch {
+    return null;
+  }
+}
+
+async function downloadTo(url: string, dest: string): Promise<void> {
+  const res = await fetch(url, { headers: { "user-agent": LIVEWARE_USER_AGENT } });
+  if (!res.ok) throw new Error(`download ${url} failed: HTTP ${res.status}`);
+  const buf = Buffer.from(await res.arrayBuffer());
+  if (buf.length === 0) throw new Error(`download ${url} returned empty body`);
+  const tmp = `${dest}.tmp`;
+  await fs.promises.writeFile(tmp, buf);
+  await fs.promises.chmod(tmp, 0o755);
+  await fs.promises.rename(tmp, dest);
+}
+
+/**
+ * Startup hook: ensure the liveware CLI is available, downloading it when not.
+ * Fire-and-forget — never throws; logs and returns on any failure.
+ */
+export async function ensureLivewareCli(
+  opts: { stateDir?: string; log?: LivewareLogger } = {},
+): Promise<void> {
+  const { stateDir, log } = opts;
+  try {
+    if (findOnPath("liveware")) return; // PATH wins
+    const dir = livewareDir(stateDir);
+    const target = path.join(dir, "liveware");
+    if (fs.existsSync(target)) return;
+
+    const assets = platformAssets();
+    if (!assets) {
+      log?.warn?.(
+        `clawchat-plugin-openclaw: unsupported platform ${process.platform}/${process.arch}; skipping liveware download`,
+      );
+      return;
+    }
+
+    await fs.promises.mkdir(dir, { recursive: true });
+    await downloadTo(LIVEWARE_BASE_URL + assets.liveware, path.join(dir, "liveware"));
+    await downloadTo(LIVEWARE_BASE_URL + assets.tunneAgent, path.join(dir, "tunnel-agent"));
+    log?.debug?.(`clawchat-plugin-openclaw: liveware CLI downloaded to ${dir}`);
+  } catch (err) {
+    log?.warn?.(`clawchat-plugin-openclaw: liveware CLI download skipped: ${String(err)}`);
+  }
+}

package/src/runtime.ts

@@ -16,6 +16,7 @@ import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
 import { createOpenclawClawlingClient, resolveOpenclawClawlingDeviceId } from "./client.ts";
 import { createOpenclawClawlingApiClient } from "./api-client.ts";
 import { reportPluginVersionSafe, resolvePluginVersion } from "./plugin-report.ts";
+import { ensureLivewareCli } from "./liveware-cli.ts";
 import { ClawlingApiError } from "./api-types.ts";
 import { RefreshManager } from "./refresh-manager.ts";
 import {
@@ -920,6 +921,15 @@ export async function startOpenclawClawlingGateway(params: StartGatewayParams):
     authenticated: false,
     log,
   });
+  // Ensure the liveware CLI is installed (async, never blocks startup).
+  void ensureLivewareCli({
+    stateDir: runtime.state?.resolveStateDir?.(),
+    log: {
+      warn: (m) => log?.info?.(m),
+      debug: (m) => log?.debug?.(m),
+      error: (m) => log?.error?.(m),
+    },
+  });
   // §B self-heal — non-interactive env connect-code activation BEFORE blocking on
   // the wait-for-activation loop. Gated so the common path (no env code, or an
   // already-credentialed account) adds NO async work: on success it credentials

package/src/tools.ts

@@ -4,6 +4,7 @@ import { execFile } from "node:child_process";
 import type { OpenClawAgentToolResult } from "openclaw/plugin-sdk/agent-harness-runtime";
 import type { OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk/core";
 import { createOpenclawClawlingApiClient } from "./api-client.ts";
+import { resolveLivewarePath } from "./liveware-cli.ts";
 import {
   ClawlingApiError,
   type Profile,
@@ -1366,18 +1367,24 @@ export function registerOpenclawClawlingTools(
           }
 
           return await new Promise<ReturnType<typeof jsonResponse>>((resolve) => {
+            const livewarePath = resolveLivewarePath(api.runtime.state?.resolveStateDir?.());
+            if (!livewarePath) {
+              resolve(jsonResponse({
+                error: "config",
+                message: "liveware CLI not found in PATH; install liveware before calling this tool",
+              }));
+              return;
+            }
             // Security: the token is passed as a child process argv value using
             // liveware's documented --access-token interface. It is in the child
             // argv briefly during process creation; env-var or stdin delivery
             // would be preferred if liveware supported it.
             // NEVER log the argv array; scrub token from any captured output below.
             execFile(
-              "liveware",
+              livewarePath,
               ["login", "--access-token", token],
               { timeout: 30000 },
               (err, stdout, stderr) => {
-                // Scrub token from any output before returning — token must never
-                // appear in tool results visible to the LLM.
                 const scrub = (s: string) => (token ? s.split(token).join("***") : s);
                 const safeStdout = scrub(stdout ?? "").trim();
                 const safeStderr = scrub(stderr ?? "").trim();