@opentrust/cli 7.3.33 → 7.3.35

package/dist/commands/connect.js

@@ -1,6 +1,6 @@
 import { DashboardClient, loadConfig, saveConfig, clearConfig, } from "../lib/dashboard-client.js";
 import { getHostInfo, getServicesSnapshot, getSystemMetadata } from "../lib/host-reporter.js";
-import { executeHostCommand } from "../lib/command-handler.js";
+import { executeHostCommand, setCommandLogger } from "../lib/command-handler.js";
 import { projectMode, projectRoot } from "../lib/paths.js";
 import fs from "node:fs";
 import path from "node:path";
@@ -124,6 +124,7 @@ function stopDaemon() {
 async function runDaemon(config) {
     const client = new DashboardClient(config);
     const log = (msg) => console.log(`[${new Date().toISOString()}] ${msg}`);
+    setCommandLogger(log);
     // Register
     log("Registering with Dashboard...");
     const hostInfo = getHostInfo();
@@ -159,23 +160,32 @@ async function runDaemon(config) {
     const heartbeatTimer = setInterval(heartbeat, HEARTBEAT_INTERVAL);
     // Command polling
     const poll = async () => {
+        let cmds;
         try {
-            const cmds = await client.fetchPendingCommands();
-            for (const cmd of cmds) {
-                log(`Executing command: ${cmd.type} (${cmd.id})`);
-                await client.ackCommand(cmd.id, "running").catch(() => { });
-                const result = executeHostCommand(cmd);
-                await client
-                    .ackCommand(cmd.id, result.success ? "completed" : "failed", {
-                    output: result.output,
-                    error: result.error,
-                })
-                    .catch(() => { });
-                log(`Command ${cmd.id}: ${result.success ? "completed" : "failed"}`);
-            }
+            cmds = await client.fetchPendingCommands();
         }
         catch {
-            // Dashboard may be unreachable
+            return; // Dashboard unreachable
+        }
+        for (const cmd of cmds) {
+            log(`Executing command: ${cmd.type} (${cmd.id})`);
+            await client.ackCommand(cmd.id, "running").catch(() => { });
+            const progressFn = async (output) => {
+                await client.ackCommand(cmd.id, "running", { output }).catch(() => { });
+            };
+            let result;
+            try {
+                result = await executeHostCommand(cmd, progressFn);
+            }
+            catch (err) {
+                log(`Command ${cmd.id} threw unexpectedly: ${err.message ?? err}`);
+                result = { success: false, error: `Unexpected error: ${(err.message ?? String(err)).slice(0, 500)}` };
+            }
+            const status = result.success ? "completed" : "failed";
+            await client
+                .ackCommand(cmd.id, status, { output: result.output, error: result.error })
+                .catch((e) => log(`Failed to ack command ${cmd.id}: ${e.message}`));
+            log(`Command ${cmd.id}: ${status}`);
         }
     };
     const pollTimer = setInterval(poll, POLL_INTERVAL);

package/dist/commands/init.js

@@ -13,9 +13,9 @@ const SCAFFOLD_PKG = {
         status: "opentrust status",
     },
     dependencies: {
-        "@opentrust/core": "^7.3.33",
-        "@opentrust/gateway": "^7.3.33",
-        "@opentrust/dashboard": "^7.3.33",
+        "@opentrust/core": "^7.3.35",
+        "@opentrust/gateway": "^7.3.35",
+        "@opentrust/dashboard": "^7.3.35",
     },
 };
 const ENV_TEMPLATE = `# OpenTrust Configuration

package/dist/lib/command-handler.d.ts

@@ -1,7 +1,9 @@
-import type { HostCommand } from "./dashboard-client.js";
+import { type HostCommand } from "./dashboard-client.js";
 export interface CommandResult {
     success: boolean;
     output?: string;
     error?: string;
 }
-export declare function executeHostCommand(cmd: HostCommand): CommandResult;
+export type ProgressFn = (output: string) => Promise<void>;
+export declare function setCommandLogger(fn: (msg: string) => void): void;
+export declare function executeHostCommand(cmd: HostCommand, progress?: ProgressFn): Promise<CommandResult>;

package/dist/lib/command-handler.js

@@ -4,6 +4,15 @@ import path from "node:path";
 import os from "node:os";
 import { startService, stopService, getStatus, SERVICES } from "./process-manager.js";
 import { paths, projectRoot, projectMode } from "./paths.js";
+import { loadConfig } from "./dashboard-client.js";
+let _logger = null;
+export function setCommandLogger(fn) { _logger = fn; }
+let _cmdOutput = [];
+function cmdLog(msg) {
+    if (_logger)
+        _logger(msg);
+    _cmdOutput.push(msg);
+}
 const SERVICE_KEYS = Object.keys(SERVICES);
 const OPENCLAW_HOME = process.env.OPENCLAW_HOME || path.join(os.homedir(), ".openclaw");
 function clawExecOpts(timeoutMs = 120_000) {
@@ -16,7 +25,8 @@ function clawExecOpts(timeoutMs = 120_000) {
         env: { ...restEnv, HOME: os.homedir() },
     };
 }
-export function executeHostCommand(cmd) {
+export async function executeHostCommand(cmd, progress) {
+    _cmdOutput = [];
     const payload = cmd.payload ?? {};
     switch (cmd.type) {
         case "start_service":
@@ -48,7 +58,7 @@ export function executeHostCommand(cmd) {
         case "upgrade_guards":
             return handleUpgradeGuards(payload);
         case "install_openclaw":
-            return handleInstallOpenclaw(payload);
+            return handleInstallOpenclaw(payload, progress);
         default:
             return { success: false, error: `Unknown command type: ${cmd.type}` };
     }
@@ -289,51 +299,116 @@ function handleUpgradeGuards(payload) {
     };
 }
 // ── OpenClaw installation ────────────────────────────
-function handleInstallOpenclaw(payload) {
+function findOpenclawBin() {
+    const candidates = [
+        path.join(os.homedir(), ".local", "bin", "openclaw"),
+        "/usr/local/bin/openclaw",
+        path.join(os.homedir(), ".openclaw", "bin", "openclaw"),
+    ];
+    for (const p of candidates) {
+        if (fs.existsSync(p))
+            return p;
+    }
+    return "openclaw";
+}
+async function handleInstallOpenclaw(payload, progress) {
     const config = payload.config;
     if (!config)
         return { success: false, error: "Missing config in payload. Configure OpenClaw template in Settings first." };
-    const results = [];
+    const sendProgress = async () => {
+        if (progress)
+            await progress(_cmdOutput.join("\n")).catch(() => { });
+    };
+    // Override Guards plugin URLs with the CLI's own connection URL
+    const cliConfig = loadConfig();
+    if (cliConfig?.dashboardUrl) {
+        if (!config.plugins)
+            config.plugins = {};
+        if (!config.plugins.entries)
+            config.plugins.entries = {};
+        if (!config.plugins.entries["opentrust-guard"])
+            config.plugins.entries["opentrust-guard"] = { enabled: true, config: {} };
+        if (!config.plugins.entries["opentrust-guard"].config)
+            config.plugins.entries["opentrust-guard"].config = {};
+        const gc = config.plugins.entries["opentrust-guard"].config;
+        gc.dashboardUrl = cliConfig.dashboardUrl;
+        gc.coreUrl = cliConfig.dashboardUrl.replace(/:(\d+)$/, (_, port) => {
+            return `:${Number(port) === 53667 ? 53666 : Number(port) - 1}`;
+        });
+        cmdLog(`Guards URLs → dashboardUrl=${gc.dashboardUrl}, coreUrl=${gc.coreUrl}`);
+    }
     // Step 1: Install OpenClaw via curl
+    cmdLog("[1/3] Installing OpenClaw (curl -fsSL https://openclaw.ai/install.sh | bash)...");
+    await sendProgress();
     try {
-        const output = execSync("curl -fsSL https://openclaw.ai/install.sh | bash", {
+        execSync("curl -fsSL https://openclaw.ai/install.sh | bash", {
             encoding: "utf-8",
-            timeout: 300_000,
-            stdio: ["pipe", "pipe", "pipe"],
+            timeout: 180_000,
+            stdio: ["pipe", "inherit", "inherit"],
             cwd: os.homedir(),
             env: { ...process.env, HOME: os.homedir() },
             shell: "/bin/bash",
         });
-        results.push(`Install script: ${output.trim().split("\n").slice(-3).join(" | ")}`);
+        cmdLog("[1/3] OpenClaw install script completed");
     }
     catch (err) {
-        const stderr = err.stderr?.toString() || "";
-        const stdout = err.stdout?.toString() || "";
-        if (stdout.toLowerCase().includes("already installed") || stdout.toLowerCase().includes("openclaw")) {
-            results.push(`Install script: ${stdout.trim().split("\n").slice(-2).join(" | ")} (may already be installed)`);
+        const code = err.status;
+        if (code === 0 || code === null) {
+            cmdLog("[1/3] OpenClaw install script finished (exit code ignored)");
         }
         else {
-            return { success: false, error: `Install script failed: ${(stderr || err.message || String(err)).slice(0, 500)}` };
+            cmdLog(`[1/3] Install script exited with code ${code}`);
         }
     }
+    await sendProgress();
     // Step 2: Write openclaw.json config
+    cmdLog("[2/3] Writing ~/.openclaw/openclaw.json ...");
+    await sendProgress();
     try {
         const clawHome = path.join(os.homedir(), ".openclaw");
         fs.mkdirSync(clawHome, { recursive: true });
         const configFile = path.join(clawHome, "openclaw.json");
         fs.writeFileSync(configFile, JSON.stringify(config, null, 2) + "\n", "utf-8");
-        results.push(`Config written to ${configFile}`);
+        cmdLog(`[2/3] Config written to ${configFile}`);
     }
     catch (err) {
-        return { success: false, error: `Failed to write config: ${(err.message || String(err)).slice(0, 500)}` };
+        const msg = `Failed to write config: ${(err.message || String(err)).slice(0, 500)}`;
+        cmdLog(`[2/3] ${msg}`);
+        await sendProgress();
+        return { success: false, output: _cmdOutput.join("\n"), error: msg };
     }
+    await sendProgress();
     // Step 3: Auto-install Guards plugin
-    const guardsResult = runClawPluginCmd("openclaw plugins install @opentrust/guards");
-    if (guardsResult.success) {
-        results.push(`Guards plugin: installed${guardsResult.output ? ` (${guardsResult.output.split("\n").pop()})` : ""}`);
+    const clawBin = findOpenclawBin();
+    cmdLog(`[3/3] Installing Guards plugin (${clawBin} plugins install @opentrust/guards)...`);
+    await sendProgress();
+    try {
+        const extraPaths = [
+            path.join(os.homedir(), ".local", "bin"),
+            path.join(os.homedir(), ".openclaw", "bin"),
+            "/usr/local/bin",
+        ].join(":");
+        const { OPENCLAW_HOME: _, ...restEnv } = process.env;
+        execSync(`${clawBin} plugins install @opentrust/guards`, {
+            encoding: "utf-8",
+            timeout: 180_000,
+            stdio: ["pipe", "pipe", "pipe"],
+            cwd: os.homedir(),
+            env: { ...restEnv, HOME: os.homedir(), PATH: `${extraPaths}:${process.env.PATH ?? ""}` },
+        });
+        cmdLog("[3/3] Guards plugin installed successfully");
     }
-    else {
-        results.push(`Guards plugin: install failed — ${guardsResult.error?.slice(0, 200) ?? "unknown error"}`);
+    catch (err) {
+        const stderr = err.stderr?.toString() || "";
+        const stdout = err.stdout?.toString() || "";
+        if (isOnlyWarnings(stderr) || isOnlyWarnings(stdout + stderr)) {
+            cmdLog("[3/3] Guards plugin installed (with warnings)");
+        }
+        else {
+            const errMsg = (stderr || err.message || String(err)).slice(0, 300);
+            cmdLog(`[3/3] Guards plugin install failed: ${errMsg}`);
+        }
     }
-    return { success: true, output: results.join("\n") };
+    cmdLog("install_openclaw complete");
+    return { success: true, output: _cmdOutput.join("\n") };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opentrust/cli",
-  "version": "7.3.33",
+  "version": "7.3.35",
   "description": "CLI tool to manage OpenTrust AI Agent Runtime Security Platform — setup, start, stop, status, logs",
   "type": "module",
   "bin": {