openclaw-channel-dmwork 0.5.21 → 0.6.0-dev.1c691678

package/dist/cli/openclaw-cli.js

@@ -4,7 +4,7 @@
  * argument arrays to avoid shell-quoting issues.
  */
 import { execFileSync, execSync } from "node:child_process";
-import { readFileSync, writeFileSync, copyFileSync, existsSync } from "node:fs";
+import { readFileSync, writeFileSync, copyFileSync, existsSync, rmSync, readdirSync, statSync, renameSync } from "node:fs";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 /**
@@ -15,6 +15,7 @@ import { resolve } from "node:path";
  * causes version incompatibility crashes on older OpenClaw servers.
  */
 function findGlobalOpenclaw() {
+    const isWindows = process.platform === "win32";
     // Strategy 1: use "which -a" (Unix) or "where" (Windows) to find all openclaw paths
     // Skip: _npx (npx cache), npx-cache, node_modules (project-local devDependency)
     for (const cmd of ["which -a openclaw", "where openclaw"]) {
@@ -37,7 +38,26 @@ function findGlobalOpenclaw() {
             // command not available on this platform
         }
     }
-    // Strategy 2: check common global install paths
+    // Strategy 2 (Windows): npm global prefix + openclaw.cmd
+    // npm i -g openclaw 在 Windows 上生成 .ps1 和 .cmd，但 npx 子进程的 PATH
+    // 可能不包含 npm 全局目录，导致 where 找不到。直接通过 npm prefix 定位。
+    if (isWindows) {
+        try {
+            const prefix = execSync("npm config get prefix", {
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            }).trim();
+            if (prefix) {
+                const cmdPath = resolve(prefix, "openclaw.cmd");
+                if (existsSync(cmdPath))
+                    return cmdPath;
+            }
+        }
+        catch {
+            // npm not available
+        }
+    }
+    // Strategy 3: check common global install paths
     const candidates = [
         "/opt/homebrew/bin/openclaw",
         "/usr/local/bin/openclaw",
@@ -52,6 +72,24 @@ function findGlobalOpenclaw() {
     return "openclaw";
 }
 const OPENCLAW = findGlobalOpenclaw();
+const NEEDS_SHELL = process.platform === "win32" && /\.cmd$/i.test(OPENCLAW);
+/**
+ * Execute openclaw CLI command. On Windows, .cmd shims require shell: true.
+ * All openclaw invocations in this module MUST go through this function.
+ *
+ * 使用 execFileSync + shell:true 而非手动拼字符串，
+ * 让 Node.js 自动处理 cmd.exe 参数转义（包括 JSON 内的引号）。
+ */
+function runOpenclaw(args, opts = {}) {
+    const shellOpt = NEEDS_SHELL ? { shell: true } : {};
+    return execFileSync(OPENCLAW, args, { encoding: "utf-8", ...shellOpt, ...opts });
+}
+/** Get the resolved openclaw binary path */
+export function getOpenClawBin() {
+    return OPENCLAW;
+}
+/** Execute openclaw command (exported for quickstart.ts etc.) */
+export { runOpenclaw };
 /** Expand ~ to home directory */
 function expandHome(p) {
     if (p.startsWith("~/"))
@@ -62,14 +100,44 @@ function expandHome(p) {
 // Config helpers
 // ---------------------------------------------------------------------------
 export function getConfigFilePath() {
-    return execFileSync(OPENCLAW, ["config", "file"], { encoding: "utf-8" }).trim();
+    const out = runOpenclaw(["config", "file"]);
+    // openclaw may prepend warnings/box-drawing to stdout; extract the actual path
+    // The path is typically the last non-empty line containing openclaw.json
+    const lines = out.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
+    const pathLine = lines.find((l) => l.endsWith("openclaw.json")) ?? lines[lines.length - 1];
+    return pathLine ?? out.trim();
+}
+/**
+ * Strip OpenClaw stdout noise (banner, plugin log lines, timestamps).
+ * Old OpenClaw versions mix these into stdout alongside the actual value.
+ */
+function stripStdoutNoise(raw) {
+    return raw
+        .split("\n")
+        .filter((line) => {
+        const t = line.trim();
+        if (!t)
+            return false;
+        // Banner: 🦞 OpenClaw ...
+        if (/^[\u{1F980}\u{1F600}-\u{1FAFF}]/u.test(t))
+            return false;
+        // Plugin log: [plugins] ..., [dmwork] ...
+        if (/^\[[\w-]+\]/.test(t))
+            return false;
+        // Timestamped log: 17:37:26 [plugins] ...
+        if (/^\d{1,2}:\d{2}(:\d{2})?\s*\[/.test(t))
+            return false;
+        return true;
+    })
+        .join("\n")
+        .trim();
 }
 export function configGet(path) {
     try {
-        const val = execFileSync(OPENCLAW, ["config", "get", path], {
-            encoding: "utf-8",
+        const raw = runOpenclaw(["config", "get", path], {
             stdio: ["pipe", "pipe", "pipe"],
-        }).trim();
+        });
+        const val = stripStdoutNoise(raw);
         return val === "" ? null : val;
     }
     catch {
@@ -78,8 +146,7 @@ export function configGet(path) {
 }
 export function configGetJson(path) {
     try {
-        const out = execFileSync(OPENCLAW, ["config", "get", path, "--json"], {
-            encoding: "utf-8",
+        const out = runOpenclaw(["config", "get", path, "--json"], {
             stdio: ["pipe", "pipe", "pipe"],
         });
         const jsonStart = out.indexOf("{");
@@ -89,88 +156,264 @@ export function configGetJson(path) {
             : Math.max(jsonStart, arrStart);
         if (start < 0)
             return null;
-        return JSON.parse(out.slice(start));
+        // Find matching end bracket to avoid trailing log noise breaking JSON.parse
+        const openChar = out[start];
+        const closeChar = openChar === "{" ? "}" : "]";
+        let depth = 0;
+        let end = -1;
+        for (let i = start; i < out.length; i++) {
+            if (out[i] === openChar)
+                depth++;
+            else if (out[i] === closeChar) {
+                depth--;
+                if (depth === 0) {
+                    end = i;
+                    break;
+                }
+            }
+        }
+        if (end < 0)
+            return null;
+        return JSON.parse(out.slice(start, end + 1));
     }
     catch {
         return null;
     }
 }
 export function configSet(path, value) {
-    execFileSync(OPENCLAW, ["config", "set", path, value], {
+    runOpenclaw(["config", "set", path, value], {
         stdio: ["pipe", "pipe", "pipe"],
     });
 }
 export function configSetBatch(operations) {
     const batchJson = JSON.stringify(operations.map((op) => ({ path: op.path, value: op.value })));
-    execFileSync(OPENCLAW, ["config", "set", "--batch-json", batchJson], {
+    runOpenclaw(["config", "set", "--batch-json", batchJson], {
         stdio: ["pipe", "pipe", "pipe"],
     });
 }
 export function configSetJson(path, value) {
-    execFileSync(OPENCLAW, ["config", "set", path, JSON.stringify(value), "--strict-json"], {
+    runOpenclaw(["config", "set", path, JSON.stringify(value), "--strict-json"], {
         stdio: ["pipe", "pipe", "pipe"],
     });
 }
 export function configUnset(path) {
-    execFileSync(OPENCLAW, ["config", "unset", path], {
+    runOpenclaw(["config", "unset", path], {
         stdio: ["pipe", "pipe", "pipe"],
     });
 }
 // ---------------------------------------------------------------------------
 // Plugin helpers
 // ---------------------------------------------------------------------------
+/**
+ * Check if an error indicates an unsupported CLI option.
+ * Checks stderr/stdout/message across different Node versions and shells.
+ */
+function isUnsupportedOptionError(err) {
+    const sources = [
+        err?.stderr?.toString?.(),
+        err?.stdout?.toString?.(),
+        err?.message,
+        String(err),
+    ];
+    return sources.some((s) => s && (/unknown option|unrecognized option/i.test(s)));
+}
+function isPluginNotInstalledError(err) {
+    const sources = [
+        err?.stderr?.toString?.(),
+        err?.stdout?.toString?.(),
+        err?.message,
+        String(err),
+    ];
+    return sources.some((s) => s && (/not installed|no such plugin|plugin not found/i.test(s)));
+}
 export function pluginsInstall(spec, quiet, force) {
-    const args = ["plugins", "install", spec, "--dangerously-force-unsafe-install"];
-    if (force)
-        args.push("--force");
-    execFileSync(OPENCLAW, args, {
-        stdio: quiet ? ["pipe", "pipe", "pipe"] : "inherit",
-    });
+    const baseArgs = ["plugins", "install", spec];
+    // 3-layer degradation for old openclaw versions:
+    //   1. --force --dangerously-force-unsafe-install  (newest openclaw)
+    //   2. --force                                     (mid-age openclaw)
+    //   3. bare install                                (oldest openclaw)
+    const attempts = force
+        ? [
+            [...baseArgs, "--force", "--dangerously-force-unsafe-install"],
+            [...baseArgs, "--force"],
+            baseArgs,
+        ]
+        : [
+            [...baseArgs, "--dangerously-force-unsafe-install"],
+            baseArgs,
+        ];
+    // Always pipe to capture stderr for degradation detection.
+    // stdio: "inherit" causes Node to omit stderr from the error object,
+    // making isUnsupportedOptionError() unable to detect "unknown option".
+    for (let i = 0; i < attempts.length; i++) {
+        try {
+            const result = runOpenclaw(attempts[i], {
+                stdio: ["pipe", "pipe", "pipe"],
+                encoding: "utf-8",
+            });
+            if (!quiet && result)
+                process.stdout.write(result);
+            return;
+        }
+        catch (err) {
+            if (isUnsupportedOptionError(err) && i < attempts.length - 1) {
+                continue; // try next degradation level
+            }
+            // Final attempt failed: replay captured output, then throw
+            if (!quiet) {
+                const stdout = err?.stdout?.toString?.();
+                const stderr = err?.stderr?.toString?.();
+                if (stdout)
+                    process.stdout.write(stdout);
+                if (stderr)
+                    process.stderr.write(stderr);
+            }
+            throw err;
+        }
+    }
 }
 export function pluginsUpdate(id, quiet) {
-    execFileSync(OPENCLAW, ["plugins", "update", id], {
-        stdio: quiet ? ["pipe", "pipe", "pipe"] : "inherit",
+    const result = runOpenclaw(["plugins", "update", id], {
+        stdio: ["pipe", "pipe", "pipe"],
+        encoding: "utf-8",
     });
+    if (!quiet && result)
+        process.stdout.write(result);
 }
 export function pluginsUninstall(id, yes) {
     const args = ["plugins", "uninstall", id];
     if (yes)
         args.push("--force");
-    execFileSync(OPENCLAW, args, { stdio: "inherit" });
+    runOpenclaw(args, { stdio: "inherit" });
 }
-export function pluginsInspect(id) {
+/**
+ * Inspect a plugin. Returns structured outcome distinguishing:
+ * - ok + data: inspect succeeded
+ * - unsupported: old OpenClaw without `plugins inspect`
+ * - not_found: plugin genuinely not found
+ * - error: other failure (config corruption, plugin load crash, etc.)
+ */
+export function pluginsInspectDetailed(id) {
     try {
-        const out = execFileSync(OPENCLAW, ["plugins", "inspect", id, "--json"], {
+        const out = runOpenclaw(["plugins", "inspect", id, "--json"], {
             encoding: "utf-8",
             stdio: ["pipe", "pipe", "pipe"],
         });
-        // stdout may contain plugin log noise before JSON — find the JSON object
         const jsonStart = out.indexOf("{");
         if (jsonStart < 0)
-            return null;
-        return JSON.parse(out.slice(jsonStart));
+            return { ok: false, data: null, failReason: "error" };
+        const data = JSON.parse(out.slice(jsonStart));
+        return { ok: true, data, failReason: null };
     }
-    catch {
-        return null;
+    catch (err) {
+        const sources = [
+            err?.stderr?.toString?.(),
+            err?.stdout?.toString?.(),
+            err?.message,
+            String(err),
+        ];
+        const text = sources.filter(Boolean).join(" ");
+        if (/unknown command|unrecognized command/i.test(text)) {
+            return { ok: false, data: null, failReason: "unsupported" };
+        }
+        if (/not found|not installed|no such plugin/i.test(text)) {
+            return { ok: false, data: null, failReason: "not_found" };
+        }
+        return { ok: false, data: null, failReason: "error" };
     }
 }
+/** Backward-compatible wrapper: returns data or null. */
+export function pluginsInspect(id) {
+    const outcome = pluginsInspectDetailed(id);
+    return outcome.ok ? outcome.data : null;
+}
+/**
+ * Resolve plugin install state. Uses `plugins inspect` when available,
+ * falls back to config entries + directory + package.json for old OpenClaw
+ * versions that don't support `plugins inspect`.
+ *
+ * Fallback installed = all 3 artifacts present (entries + installs + dir),
+ * matching detectScenario()'s healthy definition. Partial presence is NOT
+ * considered installed — that's a broken state for doctor --fix to handle.
+ */
+export function resolvePluginState(id) {
+    // Try inspect first
+    const outcome = pluginsInspectDetailed(id);
+    if (outcome.ok && outcome.data?.plugin) {
+        return {
+            installed: true,
+            enabled: outcome.data.plugin.enabled,
+            version: outcome.data.plugin.version,
+            installPath: outcome.data.install?.installPath ?? null,
+            source: "inspect",
+            inspectFailReason: null,
+        };
+    }
+    // Fallback: check config + filesystem
+    const cfg = readConfigFromFile();
+    const extDir = getConfigFilePathSafe().replace(/openclaw\.json$/, "extensions");
+    const pluginDir = resolve(extDir, id);
+    const hasDir = existsSync(pluginDir);
+    const entries = cfg?.plugins?.entries?.[id];
+    const installs = cfg?.plugins?.installs?.[id];
+    const hasEntry = Boolean(entries);
+    const hasInstall = Boolean(installs);
+    // Healthy install requires all 3 artifacts, same as detectScenario().
+    // Partial presence (e.g. dir exists but no entries/installs) is broken, not installed.
+    const installed = hasDir && hasEntry && hasInstall;
+    if (!installed) {
+        return {
+            installed: false, enabled: null, version: null, installPath: null,
+            source: "fallback", inspectFailReason: outcome.failReason,
+        };
+    }
+    // Resolve version: installs record > package.json on disk
+    let version = installs?.version ?? null;
+    if (!version && hasDir) {
+        try {
+            const pkg = JSON.parse(readFileSync(resolve(pluginDir, "package.json"), "utf-8"));
+            version = pkg.version ?? null;
+        }
+        catch { /* no package.json */ }
+    }
+    const enabled = entries?.enabled ?? null;
+    const installPath = installs?.installPath ?? (hasDir ? `~/.openclaw/extensions/${id}` : null);
+    return { installed, enabled, version, installPath, source: "fallback", inspectFailReason: outcome.failReason };
+}
 // ---------------------------------------------------------------------------
 // Gateway helpers
 // ---------------------------------------------------------------------------
 export function gatewayStatus() {
     try {
-        const out = execFileSync(OPENCLAW, ["gateway", "status", "--json"], {
+        const out = runOpenclaw(["gateway", "status", "--json"], {
             encoding: "utf-8",
             stdio: ["pipe", "pipe", "pipe"],
         });
         const jsonStart = out.indexOf("{");
         if (jsonStart < 0)
             return { running: false };
-        const data = JSON.parse(out.slice(jsonStart));
-        // Real structure: { service.runtime.status: "running", health.healthy: true }
+        // Find matching } to avoid trailing log noise
+        let depth = 0;
+        let end = -1;
+        for (let i = jsonStart; i < out.length; i++) {
+            if (out[i] === "{")
+                depth++;
+            else if (out[i] === "}") {
+                depth--;
+                if (depth === 0) {
+                    end = i;
+                    break;
+                }
+            }
+        }
+        if (end < 0)
+            return { running: false };
+        const data = JSON.parse(out.slice(jsonStart, end + 1));
         const runtimeRunning = data.service?.runtime?.status === "running";
         const healthy = data.health?.healthy === true;
-        return { running: runtimeRunning || healthy };
+        // Fallback: port is busy with an openclaw-gateway process = gateway is running
+        const portBusy = data.port?.status === "busy";
+        return { running: runtimeRunning || healthy || portBusy };
     }
     catch {
         return { running: false };
@@ -178,7 +421,7 @@ export function gatewayStatus() {
 }
 export function gatewayRestart(quiet) {
     try {
-        execFileSync(OPENCLAW, ["gateway", "restart"], {
+        runOpenclaw(["gateway", "restart"], {
             stdio: quiet ? ["pipe", "pipe", "pipe"] : "inherit",
         });
         return true;
@@ -192,7 +435,7 @@ export function gatewayRestart(quiet) {
 // ---------------------------------------------------------------------------
 export function getOpenClawVersion() {
     try {
-        const out = execFileSync(OPENCLAW, ["--version"], {
+        const out = runOpenclaw(["--version"], {
             encoding: "utf-8",
             stdio: ["pipe", "pipe", "pipe"],
         });
@@ -218,7 +461,7 @@ export function getOpenClawVersion() {
  */
 export function saveChannelConfigFromFile() {
     try {
-        const configPath = expandHome(getConfigFilePath());
+        const configPath = getConfigFilePathSafe();
         const raw = readFileSync(configPath, "utf-8");
         const cfg = JSON.parse(raw);
         return cfg?.channels?.dmwork ?? null;
@@ -233,7 +476,7 @@ export function saveChannelConfigFromFile() {
  * Creates a .bak backup before writing.
  */
 export function restoreChannelConfigToFile(dmworkConfig) {
-    const configPath = expandHome(getConfigFilePath());
+    const configPath = getConfigFilePathSafe();
     // Backup
     copyFileSync(configPath, configPath + ".bak");
     // Read, merge, write
@@ -242,7 +485,7 @@ export function restoreChannelConfigToFile(dmworkConfig) {
     if (!cfg.channels)
         cfg.channels = {};
     cfg.channels.dmwork = dmworkConfig;
-    writeFileSync(configPath, JSON.stringify(cfg, null, 2), "utf-8");
+    writeConfigAtomic(cfg);
 }
 /**
  * Remove channels.dmwork directly from the JSON file.
@@ -254,7 +497,7 @@ export function restoreChannelConfigToFile(dmworkConfig) {
  * Falls back to the standard default when CLI is unavailable
  * (e.g. during uninstall when config validation fails).
  */
-function getConfigFilePathSafe() {
+export function getConfigFilePathSafe() {
     try {
         return expandHome(getConfigFilePath());
     }
@@ -266,11 +509,10 @@ export function removeChannelConfigFromFile() {
     try {
         const configPath = getConfigFilePathSafe();
         copyFileSync(configPath, configPath + ".bak");
-        const raw = readFileSync(configPath, "utf-8");
-        const cfg = JSON.parse(raw);
-        if (cfg.channels?.dmwork) {
+        const cfg = readConfigFromFile();
+        if (cfg?.channels?.dmwork) {
             delete cfg.channels.dmwork;
-            writeFileSync(configPath, JSON.stringify(cfg, null, 2), "utf-8");
+            writeConfigAtomic(cfg);
         }
     }
     catch {
@@ -311,7 +553,7 @@ export function removeOrphanedBindingsFromFile(channel, validAccountIds) {
             // Keep only if accountId is in valid list (or no accountId specified)
             return !b.match.accountId || validAccountIds.includes(b.match.accountId);
         });
-        writeFileSync(configPath, JSON.stringify(cfg, null, 2), "utf-8");
+        writeConfigAtomic(cfg);
     }
     catch {
         // best effort
@@ -338,7 +580,7 @@ export function cleanupLegacyPlugin() {
     if (existsSync(legacyDir)) {
         // Try to uninstall via openclaw CLI first (removes entries/installs/allow)
         try {
-            execFileSync(OPENCLAW, ["plugins", "uninstall", LEGACY_PLUGIN_ID, "--force", "--keep-files"], {
+            runOpenclaw(["plugins", "uninstall", LEGACY_PLUGIN_ID, "--force", "--keep-files"], {
                 stdio: ["pipe", "pipe", "pipe"],
             });
             actions.push(`Unregistered legacy plugin "${LEGACY_PLUGIN_ID}"`);
@@ -348,7 +590,6 @@ export function cleanupLegacyPlugin() {
         }
         // Remove legacy directory
         try {
-            const { rmSync } = require("node:fs");
             rmSync(legacyDir, { recursive: true, force: true });
             actions.push(`Removed legacy directory: ${legacyDir}`);
         }
@@ -370,7 +611,7 @@ export function cleanupLegacyPlugin() {
             if (Array.isArray(cfg.plugins?.allow)) {
                 cfg.plugins.allow = cfg.plugins.allow.filter((id) => id !== LEGACY_PLUGIN_ID);
             }
-            writeFileSync(configPath, JSON.stringify(cfg, null, 2), "utf-8");
+            writeConfigAtomic(cfg);
             actions.push(`Cleaned legacy entries from openclaw.json`);
         }
     }
@@ -379,4 +620,318 @@ export function cleanupLegacyPlugin() {
     }
     return actions;
 }
+/**
+ * Clean up stale openclaw-channel-dmwork directory that is not registered
+ * in plugins.installs (orphaned from a failed previous install).
+ *
+ * Only removes the directory if ALL of these are true:
+ * 1. The directory exists
+ * 2. pluginsInspect returns null (openclaw doesn't recognize it)
+ * 3. plugins.installs has no record for openclaw-channel-dmwork
+ */
+export function cleanupStalePluginDir() {
+    const actions = [];
+    const extensionsDir = getConfigFilePathSafe().replace(/openclaw\.json$/, "extensions");
+    const pluginDir = resolve(extensionsDir, "openclaw-channel-dmwork");
+    if (!existsSync(pluginDir))
+        return actions;
+    // Check if openclaw recognizes it
+    const inspect = pluginsInspect("openclaw-channel-dmwork");
+    if (inspect?.plugin)
+        return actions; // recognized, don't touch
+    // Check if it's in installs registry
+    try {
+        const cfg = readConfigFromFile();
+        if (cfg?.plugins?.installs?.["openclaw-channel-dmwork"]) {
+            return actions; // has install record, might just be inspect anomaly
+        }
+    }
+    catch { /* proceed with cleanup */ }
+    // All three conditions met: exists + not recognized + not in registry → stale
+    try {
+        rmSync(pluginDir, { recursive: true, force: true });
+        actions.push(`Removed stale plugin directory: ${pluginDir}`);
+    }
+    catch {
+        actions.push(`Warning: could not remove stale directory: ${pluginDir}`);
+    }
+    return actions;
+}
+/**
+ * Clean up stale openclaw-install-stage directories that belong to DMWork.
+ * Only removes directories that:
+ * 1. Match .openclaw-install-stage-* pattern
+ * 2. Are older than 10 minutes (not a current installation)
+ * 3. Contain a package.json with name "openclaw-channel-dmwork"
+ */
+export function cleanupStaleStageDirectories() {
+    const actions = [];
+    const extensionsDir = getConfigFilePathSafe().replace(/openclaw\.json$/, "extensions");
+    try {
+        const entries = readdirSync(extensionsDir);
+        const now = Date.now();
+        const TEN_MINUTES = 10 * 60 * 1000;
+        for (const entry of entries) {
+            if (!entry.startsWith(".openclaw-install-stage-"))
+                continue;
+            const stagePath = resolve(extensionsDir, entry);
+            try {
+                const stat = statSync(stagePath);
+                if (!stat.isDirectory())
+                    continue;
+                if (now - stat.mtimeMs < TEN_MINUTES)
+                    continue; // too recent, skip
+                // Check if it's DMWork's stage directory
+                const pkgPath = resolve(stagePath, "package", "package.json");
+                const altPkgPath = resolve(stagePath, "package.json");
+                let isDmwork = false;
+                for (const p of [pkgPath, altPkgPath]) {
+                    try {
+                        const pkg = JSON.parse(readFileSync(p, "utf-8"));
+                        if (pkg.name === "openclaw-channel-dmwork") {
+                            isDmwork = true;
+                            break;
+                        }
+                    }
+                    catch { /* try next */ }
+                }
+                if (!isDmwork)
+                    continue; // not ours, don't touch
+                rmSync(stagePath, { recursive: true, force: true });
+                actions.push(`Removed stale stage directory: ${entry}`);
+            }
+            catch { /* skip this entry */ }
+        }
+    }
+    catch { /* best effort */ }
+    return actions;
+}
+// ---------------------------------------------------------------------------
+// Atomic config write
+// ---------------------------------------------------------------------------
+/**
+ * Write openclaw.json atomically: write to .tmp then rename.
+ * Prevents gateway watcher from reading half-written/truncated JSON.
+ */
+export function writeConfigAtomic(cfg) {
+    const configPath = getConfigFilePathSafe();
+    const tmpPath = configPath + ".tmp";
+    writeFileSync(tmpPath, JSON.stringify(cfg, null, 2), "utf-8");
+    renameSync(tmpPath, configPath);
+}
+export function detectScenario() {
+    const cfg = readConfigFromFile();
+    const extDir = getConfigFilePathSafe().replace(/openclaw\.json$/, "extensions");
+    const hasLegacyDir = existsSync(resolve(extDir, "dmwork"));
+    const hasLegacyEntries = Boolean(cfg?.plugins?.entries?.["dmwork"]);
+    const hasLegacyInstalls = Boolean(cfg?.plugins?.installs?.["dmwork"]);
+    const hasLegacy = hasLegacyDir || hasLegacyEntries || hasLegacyInstalls;
+    const hasNewDir = existsSync(resolve(extDir, "openclaw-channel-dmwork"));
+    const hasNewEntries = Boolean(cfg?.plugins?.entries?.["openclaw-channel-dmwork"]);
+    const hasNewInstalls = Boolean(cfg?.plugins?.installs?.["openclaw-channel-dmwork"]);
+    const inspectOk = Boolean(pluginsInspect("openclaw-channel-dmwork")?.plugin);
+    const isHealthy = inspectOk || (hasNewDir && hasNewEntries && hasNewInstalls);
+    const hasNewPartial = (hasNewDir || hasNewEntries || hasNewInstalls) && !isHealthy;
+    const hasDmworkChannel = Boolean(cfg?.channels?.dmwork);
+    if (hasLegacy)
+        return "legacy";
+    if (isHealthy)
+        return "update";
+    if (hasNewPartial)
+        return "broken";
+    if (hasDmworkChannel)
+        return "deadlock";
+    return "fresh";
+}
+export function isHealthyInstall() {
+    const cfg = readConfigFromFile();
+    const extDir = getConfigFilePathSafe().replace(/openclaw\.json$/, "extensions");
+    const hasNewDir = existsSync(resolve(extDir, "openclaw-channel-dmwork"));
+    const hasNewEntries = Boolean(cfg?.plugins?.entries?.["openclaw-channel-dmwork"]);
+    const hasNewInstalls = Boolean(cfg?.plugins?.installs?.["openclaw-channel-dmwork"]);
+    const inspectOk = Boolean(pluginsInspect("openclaw-channel-dmwork")?.plugin);
+    return inspectOk || (hasNewDir && hasNewEntries && hasNewInstalls);
+}
+export function ensurePluginsAllow() {
+    try {
+        const cfg = readConfigFromFile();
+        if (!cfg?.plugins?.allow || !Array.isArray(cfg.plugins.allow))
+            return;
+        if (cfg.plugins.allow.includes("openclaw-channel-dmwork"))
+            return;
+        cfg.plugins.allow.push("openclaw-channel-dmwork");
+        writeConfigAtomic(cfg);
+    }
+    catch { /* best effort */ }
+}
+// ---------------------------------------------------------------------------
+// pluginsUpdateCompat
+// ---------------------------------------------------------------------------
+export function pluginsUpdateCompat(id, tag, quiet) {
+    try {
+        const result = runOpenclaw(["plugins", "update", id], {
+            stdio: ["pipe", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+        if (!quiet && result)
+            process.stdout.write(result);
+    }
+    catch (err) {
+        // Only fallback to install when update is unsupported or plugin not installed.
+        // Other errors (network, permissions, etc.) should propagate.
+        if (isUnsupportedOptionError(err) || isPluginNotInstalledError(err)) {
+            pluginsInstall(`${id}@${tag}`, quiet, true);
+            return;
+        }
+        if (!quiet) {
+            const stdout = err?.stdout?.toString?.();
+            const stderr = err?.stderr?.toString?.();
+            if (stdout)
+                process.stdout.write(stdout);
+            if (stderr)
+                process.stderr.write(stderr);
+        }
+        throw err;
+    }
+}
+// ---------------------------------------------------------------------------
+// Legacy migration helpers
+// ---------------------------------------------------------------------------
+export function renameLegacyDir() {
+    const extDir = getConfigFilePathSafe().replace(/openclaw\.json$/, "extensions");
+    const legacyDir = resolve(extDir, "dmwork");
+    const backupDir = resolve(extDir, ".dmwork-backup");
+    if (!existsSync(legacyDir))
+        return false;
+    try {
+        if (existsSync(backupDir))
+            rmSync(backupDir, { recursive: true, force: true });
+        renameSync(legacyDir, backupDir);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function restoreLegacyDir() {
+    const extDir = getConfigFilePathSafe().replace(/openclaw\.json$/, "extensions");
+    const legacyDir = resolve(extDir, "dmwork");
+    const backupDir = resolve(extDir, ".dmwork-backup");
+    if (!existsSync(backupDir))
+        return;
+    try {
+        if (existsSync(legacyDir))
+            rmSync(legacyDir, { recursive: true, force: true });
+        renameSync(backupDir, legacyDir);
+    }
+    catch { /* best effort */ }
+}
+export function deleteLegacyBackup() {
+    const extDir = getConfigFilePathSafe().replace(/openclaw\.json$/, "extensions");
+    const backupDir = resolve(extDir, ".dmwork-backup");
+    if (existsSync(backupDir)) {
+        try {
+            rmSync(backupDir, { recursive: true, force: true });
+        }
+        catch { /* best effort */ }
+    }
+}
+export function removeLegacyFromConfig() {
+    try {
+        const cfg = readConfigFromFile();
+        if (!cfg)
+            return;
+        if (cfg.plugins?.entries?.["dmwork"])
+            delete cfg.plugins.entries["dmwork"];
+        if (cfg.plugins?.installs?.["dmwork"])
+            delete cfg.plugins.installs["dmwork"];
+        if (Array.isArray(cfg.plugins?.allow)) {
+            cfg.plugins.allow = cfg.plugins.allow.filter((id) => id !== "dmwork");
+        }
+        if (cfg.channels?.dmwork)
+            delete cfg.channels.dmwork;
+        writeConfigAtomic(cfg);
+    }
+    catch { /* best effort */ }
+}
+export function saveChannelConfigToDisk() {
+    try {
+        const backupPath = getConfigFilePathSafe().replace(/openclaw\.json$/, "channels-dmwork-backup.json");
+        const cfg = readConfigFromFile();
+        const dmwork = cfg?.channels?.dmwork;
+        if (dmwork) {
+            writeFileSync(backupPath, JSON.stringify(dmwork, null, 2), "utf-8");
+        }
+        else {
+            // No channels.dmwork — remove stale backup to prevent wrong restore
+            if (existsSync(backupPath))
+                rmSync(backupPath, { force: true });
+        }
+    }
+    catch { /* best effort */ }
+}
+export function restoreChannelConfigFromDisk() {
+    try {
+        const backupPath = getConfigFilePathSafe().replace(/openclaw\.json$/, "channels-dmwork-backup.json");
+        if (!existsSync(backupPath))
+            return;
+        let dmwork = JSON.parse(readFileSync(backupPath, "utf-8"));
+        // Migrate flat config → accounts.default
+        if (dmwork.botToken && !dmwork.accounts) {
+            dmwork = {
+                ...dmwork,
+                accounts: { default: { botToken: dmwork.botToken, apiUrl: dmwork.apiUrl } },
+            };
+            delete dmwork.botToken;
+        }
+        const cfg = readConfigFromFile();
+        if (!cfg)
+            return;
+        if (!cfg.channels)
+            cfg.channels = {};
+        cfg.channels.dmwork = dmwork;
+        writeConfigAtomic(cfg);
+        rmSync(backupPath, { force: true });
+    }
+    catch { /* best effort */ }
+}
+export function cleanupBrokenInstall() {
+    const actions = [];
+    const cfg = readConfigFromFile();
+    const extDir = getConfigFilePathSafe().replace(/openclaw\.json$/, "extensions");
+    const pluginDir = resolve(extDir, "openclaw-channel-dmwork");
+    const hasDir = existsSync(pluginDir);
+    const hasEntries = Boolean(cfg?.plugins?.entries?.["openclaw-channel-dmwork"]);
+    const hasInstalls = Boolean(cfg?.plugins?.installs?.["openclaw-channel-dmwork"]);
+    // Use same healthy definition as detectScenario(): inspect OK OR all 3 artifacts present
+    const inspectOk = Boolean(pluginsInspect("openclaw-channel-dmwork")?.plugin);
+    const isHealthy = inspectOk || (hasDir && hasEntries && hasInstalls);
+    if (isHealthy)
+        return actions; // Actually healthy, nothing to clean
+    // Remove directory if it exists (orphan or partial)
+    if (hasDir) {
+        try {
+            rmSync(pluginDir, { recursive: true, force: true });
+            actions.push("Removed broken/orphan plugin directory");
+        }
+        catch { /* best effort */ }
+    }
+    // Remove stale config entries
+    if (cfg && (hasEntries || hasInstalls)) {
+        let changed = false;
+        if (hasEntries) {
+            delete cfg.plugins.entries["openclaw-channel-dmwork"];
+            changed = true;
+        }
+        if (hasInstalls) {
+            delete cfg.plugins.installs["openclaw-channel-dmwork"];
+            changed = true;
+        }
+        if (changed) {
+            writeConfigAtomic(cfg);
+            actions.push("Cleaned stale config entries");
+        }
+    }
+    return actions;
+}
 //# sourceMappingURL=openclaw-cli.js.map