@opentrust/cli 7.3.33 → 7.3.34

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,29 @@ 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(() => { });
+            let result;
+            try {
+                result = executeHostCommand(cmd);
+            }
+            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.34",
+        "@opentrust/gateway": "^7.3.34",
+        "@opentrust/dashboard": "^7.3.34",
     },
 };
 const ENV_TEMPLATE = `# OpenTrust Configuration

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

@@ -1,7 +1,8 @@
-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 setCommandLogger(fn: (msg: string) => void): void;
 export declare function executeHostCommand(cmd: HostCommand): CommandResult;

package/dist/lib/command-handler.js

@@ -4,6 +4,11 @@ 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; }
+function cmdLog(msg) { if (_logger)
+    _logger(msg); }
 const SERVICE_KEYS = Object.keys(SERVICES);
 const OPENCLAW_HOME = process.env.OPENCLAW_HOME || path.join(os.homedir(), ".openclaw");
 function clawExecOpts(timeoutMs = 120_000) {
@@ -289,51 +294,108 @@ function handleUpgradeGuards(payload) {
     };
 }
 // ── OpenClaw installation ────────────────────────────
+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";
+}
 function handleInstallOpenclaw(payload) {
     const config = payload.config;
     if (!config)
         return { success: false, error: "Missing config in payload. Configure OpenClaw template in Settings first." };
     const results = [];
+    // Override Guards plugin URLs with the CLI's own connection URL
+    const cliConfig = loadConfig();
+    if (cliConfig?.dashboardUrl) {
+        const guardEntry = config?.plugins?.entries?.["opentrust-guard"];
+        if (guardEntry?.config) {
+            guardEntry.config.dashboardUrl = cliConfig.dashboardUrl;
+            guardEntry.config.coreUrl = cliConfig.dashboardUrl.replace(/:53667/, ":53666");
+            cmdLog(`  Guards URLs → dashboardUrl=${guardEntry.config.dashboardUrl}, coreUrl=${guardEntry.config.coreUrl}`);
+        }
+    }
     // Step 1: Install OpenClaw via curl
+    cmdLog("  [1/3] Installing OpenClaw (curl -fsSL https://openclaw.ai/install.sh | bash)...");
     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(" | ")}`);
+        results.push("Install script: completed");
+        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) {
+            results.push("Install script: completed (non-zero might be ok)");
+            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)}` };
+            const msg = `Install script exited with code ${code}`;
+            cmdLog(`  [1/3] ${msg}`);
+            results.push(msg);
+            // Don't return failure — the binary may already exist or the error is non-fatal
         }
     }
     // Step 2: Write openclaw.json config
+    cmdLog("  [2/3] Writing ~/.openclaw/openclaw.json ...");
     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}`);
+        return { success: false, error: msg };
     }
-    // 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()})` : ""}`);
+    // Step 3: Auto-install Guards plugin — expand PATH to find freshly-installed openclaw
+    const clawBin = findOpenclawBin();
+    cmdLog(`  [3/3] Installing Guards plugin (${clawBin} plugins install @opentrust/guards)...`);
+    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;
+        const output = 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 ?? ""}` },
+        });
+        results.push(`Guards plugin: installed`);
+        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)) {
+            results.push("Guards plugin: installed (with warnings)");
+            cmdLog("  [3/3] Guards plugin installed (with warnings)");
+        }
+        else {
+            const errMsg = (stderr || err.message || String(err)).slice(0, 300);
+            results.push(`Guards plugin: install failed — ${errMsg}`);
+            cmdLog(`  [3/3] Guards plugin install failed: ${errMsg}`);
+        }
     }
+    cmdLog("  install_openclaw complete");
     return { success: true, output: results.join("\n") };
 }

package/package.json

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