@opentrust/cli 7.3.34 → 7.3.36

package/dist/commands/connect.js

@@ -170,9 +170,12 @@ async function runDaemon(config) {
         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 = executeHostCommand(cmd);
+                result = await executeHostCommand(cmd, progressFn);
             }
             catch (err) {
                 log(`Command ${cmd.id} threw unexpectedly: ${err.message ?? err}`);

package/dist/commands/init.js

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

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

@@ -4,5 +4,6 @@ export interface CommandResult {
     output?: string;
     error?: string;
 }
+export type ProgressFn = (output: string) => Promise<void>;
 export declare function setCommandLogger(fn: (msg: string) => void): void;
-export declare function executeHostCommand(cmd: HostCommand): CommandResult;
+export declare function executeHostCommand(cmd: HostCommand, progress?: ProgressFn): Promise<CommandResult>;

package/dist/lib/command-handler.js

@@ -7,8 +7,12 @@ 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); }
+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) {
@@ -21,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":
@@ -53,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}` };
     }
@@ -300,102 +305,145 @@ function findOpenclawBin() {
         "/usr/local/bin/openclaw",
         path.join(os.homedir(), ".openclaw", "bin", "openclaw"),
     ];
+    // Try npm global bin path
+    try {
+        const npmPrefix = execSync("npm config get prefix", { encoding: "utf-8", timeout: 5_000 }).trim();
+        if (npmPrefix)
+            candidates.push(path.join(npmPrefix, "bin", "openclaw"));
+    }
+    catch { }
     for (const p of candidates) {
         if (fs.existsSync(p))
             return p;
     }
+    // Last resort: try `which openclaw`
+    try {
+        const w = execSync("which openclaw", { encoding: "utf-8", timeout: 5_000 }).trim();
+        if (w)
+            return w;
+    }
+    catch { }
     return "openclaw";
 }
-function handleInstallOpenclaw(payload) {
+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) {
-        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}`);
-        }
+        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: Write openclaw.json config FIRST (so install script detects it and skips onboarding)
+    cmdLog("[1/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");
+        cmdLog(`[1/3] Config written to ${configFile}`);
+    }
+    catch (err) {
+        const msg = `Failed to write config: ${(err.message || String(err)).slice(0, 500)}`;
+        cmdLog(`[1/3] ${msg}`);
+        await sendProgress();
+        return { success: false, output: _cmdOutput.join("\n"), error: msg };
     }
-    // Step 1: Install OpenClaw via curl
-    cmdLog("  [1/3] Installing OpenClaw (curl -fsSL https://openclaw.ai/install.sh | bash)...");
+    await sendProgress();
+    // Step 2: Install OpenClaw via curl (non-interactive: CI=1, pipe stdin to /dev/null)
+    cmdLog("[2/3] Installing OpenClaw (curl -fsSL https://openclaw.ai/install.sh | bash)...");
+    await sendProgress();
     try {
         execSync("curl -fsSL https://openclaw.ai/install.sh | bash", {
             encoding: "utf-8",
-            timeout: 180_000,
-            stdio: ["pipe", "inherit", "inherit"],
+            timeout: 300_000,
+            stdio: ["ignore", "inherit", "inherit"],
             cwd: os.homedir(),
-            env: { ...process.env, HOME: os.homedir() },
+            env: {
+                ...process.env,
+                HOME: os.homedir(),
+                CI: "1",
+                NONINTERACTIVE: "1",
+                OPENCLAW_ACCEPT_TOS: "1",
+            },
             shell: "/bin/bash",
         });
-        results.push("Install script: completed");
-        cmdLog("  [1/3] OpenClaw install script completed");
+        cmdLog("[2/3] OpenClaw install script completed");
     }
     catch (err) {
         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)");
+            cmdLog("[2/3] OpenClaw install script finished (exit code ignored)");
         }
         else {
-            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
+            cmdLog(`[2/3] Install script exited with code ${code}`);
         }
     }
-    // Step 2: Write openclaw.json config
-    cmdLog("  [2/3] Writing ~/.openclaw/openclaw.json ...");
+    await sendProgress();
+    // Re-write config (install script may have overwritten it during setup)
     try {
-        const clawHome = path.join(os.homedir(), ".openclaw");
-        fs.mkdirSync(clawHome, { recursive: true });
-        const configFile = path.join(clawHome, "openclaw.json");
+        const configFile = path.join(os.homedir(), ".openclaw", "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) {
-        const msg = `Failed to write config: ${(err.message || String(err)).slice(0, 500)}`;
-        cmdLog(`  [2/3] ${msg}`);
-        return { success: false, error: msg };
+        cmdLog("[2/3] Config re-written (ensuring our template is used)");
     }
-    // Step 3: Auto-install Guards plugin — expand PATH to find freshly-installed openclaw
+    catch { }
+    await sendProgress();
+    // Step 3: Auto-install Guards plugin — resolve openclaw binary from multiple locations
     const clawBin = findOpenclawBin();
-    cmdLog(`  [3/3] Installing Guards plugin (${clawBin} plugins install @opentrust/guards)...`);
+    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(":");
+        ];
+        // Also discover npm global bin directory
+        try {
+            const npmBin = execSync("npm config get prefix", { encoding: "utf-8", timeout: 5_000 }).trim();
+            if (npmBin)
+                extraPaths.push(path.join(npmBin, "bin"));
+        }
+        catch { }
         const { OPENCLAW_HOME: _, ...restEnv } = process.env;
-        const output = execSync(`${clawBin} plugins install @opentrust/guards`, {
+        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 ?? ""}` },
+            env: { ...restEnv, HOME: os.homedir(), PATH: `${extraPaths.join(":")}:${process.env.PATH ?? ""}` },
         });
-        results.push(`Guards plugin: installed`);
-        cmdLog(`  [3/3] Guards plugin installed successfully`);
+        cmdLog("[3/3] Guards plugin installed successfully");
     }
     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)");
+            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(`[3/3] Guards plugin install failed: ${errMsg}`);
         }
     }
-    cmdLog("  install_openclaw complete");
-    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.34",
+  "version": "7.3.36",
   "description": "CLI tool to manage OpenTrust AI Agent Runtime Security Platform — setup, start, stop, status, logs",
   "type": "module",
   "bin": {