jishushell 0.4.2 → 0.4.10

package/dist/services/instance-manager.js

@@ -1,12 +1,13 @@
 import { execFile, execFileSync } from "child_process";
 import { randomBytes } from "crypto";
-import { chmodSync, chownSync, copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync, } from "fs";
+import { chmodSync, chownSync, copyFileSync, cpSync, existsSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, } from "fs";
 import { createServer as netCreateServer } from "net";
 import { userInfo } from "os";
 import { dirname, join, resolve } from "path";
-import { INSTANCES_DIR, JISHUSHELL_HOME, getPanelConfig } from "../config.js";
+import { BACKUPS_DIR, INSTANCES_DIR, JISHUSHELL_HOME, getPanelConfig } from "../config.js";
 import { LEGACY_PROVIDER_API_ALIASES } from "../constants.js";
 import { safeReadJson, safeWriteJson } from "../utils/safe-json.js";
+import { ensureDirContainer, writeConfigFile, writeSecretFile } from "../utils/fs.js";
 const _configChangeListeners = [];
 export function onConfigChange(listener) {
     _configChangeListeners.push(listener);
@@ -357,7 +358,7 @@ function quoteEnvValue(value) {
     return JSON.stringify(value);
 }
 export function updateEnvFile(path, updates) {
-    mkdirSync(dirname(path), { recursive: true });
+    ensureDirContainer(dirname(path));
     const existing = existsSync(path) ? readFileSync(path, "utf-8").split("\n") : [];
     const remaining = { ...updates };
     const newLines = [];
@@ -389,7 +390,7 @@ export function updateEnvFile(path, updates) {
     const content = output ? output + "\n" : "";
     // Atomic write: tmp then rename to protect against RPi power loss
     const tmp = path + ".tmp";
-    writeFileSync(tmp, content, { mode: 0o600 });
+    writeSecretFile(tmp, content);
     renameSync(tmp, path);
 }
 // ── Provider key helpers ──
@@ -536,6 +537,40 @@ export const CHANNEL_PLUGIN_MAP = {
     // Official vendor plugins — need install (not bundled)
     "openclaw-weixin": "@tencent-weixin/openclaw-weixin",
 };
+/**
+ * Known IM plugin entry IDs as they appear under `config.plugins.entries`.
+ * This is the union of channel IDs and the dir-alias names (e.g. `feishu` may
+ * register the plugin as `openclaw-lark`), which is what must be scrubbed when
+ * dissociating an instance from its inherited IM bindings.
+ */
+const IM_PLUGIN_ENTRY_IDS = new Set([
+    ...Object.keys(CHANNEL_PLUGIN_MAP),
+    ...Object.values(CHANNEL_EXT_DIR_ALIAS),
+]);
+/**
+ * Dissociate a cloned/imported config from its source instance's IM bindings.
+ *
+ * Mutates the given config in place:
+ *   - Deletes the entire `channels` block (same channel cannot serve multiple
+ *     instances, so every inherited enabled/credential/account entry must go).
+ *   - Deletes matching IM entries from `plugins.entries` so the plugin loader
+ *     does not try to boot a channel whose config no longer exists.
+ *
+ * Used by both domain clone (`createInstance`'s `cloneFrom` path) and the
+ * backup import paths (`importInstance`, `createFromBackup`) so that a new
+ * instance never inherits a half-configured IM binding.
+ */
+export function stripImBindings(config) {
+    if (config?.channels)
+        delete config.channels;
+    const entries = config?.plugins?.entries;
+    if (entries && typeof entries === "object") {
+        for (const key of Object.keys(entries)) {
+            if (IM_PLUGIN_ENTRY_IDS.has(key))
+                delete entries[key];
+        }
+    }
+}
 /** Check if a channel plugin is installed for an instance. */
 export function isChannelPluginInstalled(instanceId, channelId) {
     const extDirName = CHANNEL_EXT_DIR_ALIAS[channelId] || channelId;
@@ -546,8 +581,9 @@ export function isChannelPluginInstalled(instanceId, channelId) {
         || (extDirName !== channelId && existsSync(join(stockExtDir, channelId)));
 }
 /**
- * Install a single channel plugin on the host.
- * This is the unified entry point for all plugin installation — never use docker exec.
+ * Install a single channel plugin.
+ * Docker mode: runs install inside the running container via docker exec.
+ * Host mode (fallback): spawns the host openclaw binary directly.
  */
 export async function installChannelPlugin(instanceId, channelId) {
     const pkg = CHANNEL_PLUGIN_MAP[channelId];
@@ -556,14 +592,17 @@ export async function installChannelPlugin(instanceId, channelId) {
     if (isChannelPluginInstalled(instanceId, channelId))
         return;
     const openclawHome = getOpenclawHomeInternal(instanceId);
-    const openclawBin = resolveOpenclawBin();
     const extensionsDir = getChannelExtensionsDir(instanceId);
-    // Ensure the node binary that runs jishushell is on PATH for the child process.
-    // When running under systemd, PATH may not include the nvm node directory, which
-    // causes the `#!/usr/bin/env node` shebang in the openclaw CLI to fail.
+    // Docker mode: always install inside container via docker exec
+    const { getNomadDriver } = await import("../config.js");
+    if (getNomadDriver() === "docker") {
+        await installChannelPluginViaDocker(instanceId, channelId, pkg, extensionsDir);
+        return;
+    }
+    const openclawBin = resolveOpenclawBin();
+    // Host mode: spawn openclaw binary directly
     const nodeBinDir = dirname(process.execPath);
     const childPath = [nodeBinDir, process.env.PATH].filter(Boolean).join(":");
-    // Pass through proxy and TLS env vars so fetch works under systemd / restricted environments.
     const proxyEnvKeys = [
         "http_proxy", "HTTP_PROXY", "https_proxy", "HTTPS_PROXY",
         "no_proxy", "NO_PROXY", "NODE_EXTRA_CA_CERTS", "NODE_TLS_REJECT_UNAUTHORIZED",
@@ -588,12 +627,9 @@ export async function installChannelPlugin(instanceId, channelId) {
             env: childEnv,
             timeout: 300_000,
         }, (err, stdout, stderr) => {
-            // openclaw plugins install may exit non-zero due to "plugins.allow is empty" warning
-            // even though the plugin was installed successfully. Check actual directory.
             if (err && !isChannelPluginInstalled(instanceId, channelId)) {
                 const msg = [stderr?.trim(), stdout?.trim(), err.message].filter(Boolean).join(" | ");
                 console.error(`[plugins] ${pkg} exit code ${err.code ?? '?'}, stderr: ${stderr?.trim() || '(empty)'}, stdout: ${stdout?.trim() || '(empty)'}`);
-                // Clean up leftover stage directories
                 try {
                     if (existsSync(extensionsDir)) {
                         for (const entry of readdirSync(extensionsDir)) {
@@ -604,7 +640,7 @@ export async function installChannelPlugin(instanceId, channelId) {
                         }
                     }
                 }
-                catch { /* best effort */ }
+                catch (_) { }
                 reject(new Error(msg));
             }
             else {
@@ -621,6 +657,20 @@ export async function installChannelPlugin(instanceId, channelId) {
     for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
         try {
             await attemptInstall();
+            const extDirName = CHANNEL_EXT_DIR_ALIAS[channelId] || channelId;
+            const installedExtDir = join(extensionsDir, extDirName);
+            if (existsSync(installedExtDir)) {
+                ensureDirContainer(installedExtDir);
+                try {
+                    for (const entry of readdirSync(installedExtDir, { withFileTypes: true })) {
+                        if (entry.isDirectory()) {
+                            ensureDirContainer(join(installedExtDir, entry.name));
+                        }
+                    }
+                }
+                catch { /* best effort */ }
+            }
+            ensureDirContainer(extensionsDir);
             return;
         }
         catch (err) {
@@ -637,6 +687,67 @@ export async function installChannelPlugin(instanceId, channelId) {
     }
     throw lastErr;
 }
+/**
+ * Install a channel plugin inside the running Docker container via nomad-manager.exec().
+ * Requires the instance to be running — the extensions dir is bind-mounted so
+ * the install persists on the host filesystem.
+ */
+async function installChannelPluginViaDocker(instanceId, channelId, pkg, extensionsDir) {
+    const { exec } = await import("./nomad-manager.js");
+    const MAX_ATTEMPTS = 3;
+    const RETRY_DELAY_MS = 5_000;
+    console.log(`[plugins] Installing ${pkg} for ${channelId} via docker exec (instance: ${instanceId})...`);
+    let lastErr;
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+        try {
+            const result = await exec(instanceId, ["openclaw", "plugins", "install", pkg], 300_000);
+            // Check if plugin was actually installed (openclaw may exit non-zero with warnings)
+            if (result.exitCode !== 0 && !isChannelPluginInstalled(instanceId, channelId)) {
+                const msg = [result.stderr?.trim(), result.stdout?.trim()].filter(Boolean).join(" | ");
+                console.error(`[plugins] ${pkg} docker exec exit code ${result.exitCode}, output: ${msg}`);
+                throw new Error(msg || `openclaw plugins install exited with code ${result.exitCode}`);
+            }
+            if (result.exitCode !== 0) {
+                console.log(`[plugins] ${pkg} installed via docker (ignored non-zero exit: warning only)`);
+            }
+            else {
+                console.log(`[plugins] ${pkg} installed via docker`);
+            }
+            // Fix ownership on host side
+            const extDirName = CHANNEL_EXT_DIR_ALIAS[channelId] || channelId;
+            const installedExtDir = join(extensionsDir, extDirName);
+            if (existsSync(installedExtDir)) {
+                ensureDirContainer(installedExtDir);
+                try {
+                    for (const entry of readdirSync(installedExtDir, { withFileTypes: true })) {
+                        if (entry.isDirectory()) {
+                            ensureDirContainer(join(installedExtDir, entry.name));
+                        }
+                    }
+                }
+                catch { /* best effort */ }
+            }
+            ensureDirContainer(extensionsDir);
+            return;
+        }
+        catch (err) {
+            lastErr = err;
+            // "Instance is not running" from nomad-manager.exec() — give a clear user-facing message
+            if (/not running/i.test(err.message ?? "")) {
+                throw new Error("请先启动实例后再安装插件（Docker 模式下插件需在容器内安装）");
+            }
+            const isTransient = /fetch failed|ECONNREFUSED/i.test(err.message ?? "");
+            if (isTransient && attempt < MAX_ATTEMPTS) {
+                console.warn(`[plugins] ${pkg} docker install attempt ${attempt}/${MAX_ATTEMPTS} failed, retrying in ${RETRY_DELAY_MS / 1000}s...`);
+                await new Promise(r => setTimeout(r, RETRY_DELAY_MS));
+                continue;
+            }
+            console.error(`[plugins] Failed to install ${pkg} via docker:`, err.message);
+            break;
+        }
+    }
+    throw lastErr;
+}
 function getChannelExtensionsDir(instanceId) {
     return join(getOpenclawHomeInternal(instanceId), OPENCLAW_STATE_DIRNAME, "extensions");
 }
@@ -678,7 +789,7 @@ export function getInstance(instanceId) {
         throw new Error(`Cannot read instance '${instanceId}' metadata: ${e.message}. Check file ownership with: ls -la ${metaPath}`);
     }
 }
-export async function createInstance(instanceId, name, description = "", cloneFrom, openclawHome) {
+export async function createInstance(instanceId, name, description = "", cloneFrom, openclawHome, cloneOptions) {
     const d = instanceDir(instanceId);
     if (existsSync(d))
         throw new Error(`Instance '${instanceId}' already exists`);
@@ -717,18 +828,15 @@ export async function createInstance(instanceId, name, description = "", cloneFr
             // readdirSync failed — directory might not be readable, proceed cautiously
         }
     }
-    mkdirSync(d, { recursive: true, mode: 0o750 });
-    chmodSync(d, 0o750);
+    ensureDirContainer(d);
     // Inherit group from INSTANCES_DIR so both root and the real user can access
     try {
         const parentGid = statSync(INSTANCES_DIR).gid;
         chownSync(d, -1, parentGid);
     }
     catch { /* non-root without CAP_CHOWN — already correct owner */ }
-    mkdirSync(home, { recursive: true, mode: 0o750 });
-    chmodSync(home, 0o750);
-    mkdirSync(join(home, OPENCLAW_STATE_DIRNAME), { recursive: true, mode: 0o750 });
-    chmodSync(join(home, OPENCLAW_STATE_DIRNAME), 0o750);
+    ensureDirContainer(home);
+    ensureDirContainer(join(home, OPENCLAW_STATE_DIRNAME));
     const runtime = await defaultRuntime(instanceId, home);
     const allocatedPort = extractGatewayPort(runtime);
     // Port already reserved inside defaultGatewayPort; just track for cleanup
@@ -744,9 +852,8 @@ export async function createInstance(instanceId, name, description = "", cloneFr
         safeWriteJson(instanceMetaPath(instanceId), meta);
         const envFiles = (runtime.env_files || []).map((p) => normalizePath(p));
         for (const ef of envFiles) {
-            mkdirSync(dirname(ef), { recursive: true });
             if (!existsSync(ef))
-                writeFileSync(ef, "", { mode: 0o600 });
+                writeConfigFile(ef, "");
         }
         // After writing env files, ensure the runtime user can read them
         try {
@@ -759,7 +866,7 @@ export async function createInstance(instanceId, name, description = "", cloneFr
         }
         catch { /* ignore - same user or no permission to chown */ }
         const configPath = openclawConfigPathInternal(instanceId);
-        mkdirSync(dirname(configPath), { recursive: true });
+        ensureDirContainer(dirname(configPath));
         if (cloneFrom && !existsSync(configPath)) {
             const srcConfig = resolveExistingConfigPath(cloneFrom);
             if (existsSync(srcConfig)) {
@@ -782,12 +889,26 @@ export async function createInstance(instanceId, name, description = "", cloneFr
                     if (typeof defaultModel === "string" && (defaultModel.startsWith("jsproxy/") || defaultModel.startsWith("js-"))) {
                         delete cloned.agents.defaults.model;
                     }
-                    // Strip IM channel configs — same channel cannot serve multiple instances
-                    if (cloned?.channels)
-                        delete cloned.channels;
+                    // Strip IM channel configs + matching plugin entries — same channel
+                    // cannot serve multiple instances and we don't want the plugin
+                    // loader to boot a half-configured binding.
+                    stripImBindings(cloned);
                     // Copy extensions directory so plugin references in config remain valid
                     // Copy workspace directory to preserve agent personality (.md files)
-                    for (const subdir of ["extensions", "workspace", "skills"]) {
+                    const subdirs = ["extensions", "workspace"];
+                    if (cloneOptions?.include_memory !== false) {
+                        // Memory may exist at .openclaw/memory/ if created by OpenClaw runtime
+                        const memDir = join(dirname(srcConfig), "memory");
+                        if (existsSync(memDir))
+                            subdirs.push("memory");
+                    }
+                    if (cloneOptions?.include_sessions) {
+                        // Sessions at .openclaw/agents/main/sessions/
+                        const sessDir = join(dirname(srcConfig), "agents");
+                        if (existsSync(sessDir))
+                            subdirs.push("agents");
+                    }
+                    for (const subdir of subdirs) {
                         const srcDir = join(dirname(srcConfig), subdir);
                         const dstDir = join(dirname(configPath), subdir);
                         if (existsSync(srcDir) && !existsSync(dstDir)) {
@@ -797,7 +918,7 @@ export async function createInstance(instanceId, name, description = "", cloneFr
                             catch { /* best effort */ }
                         }
                     }
-                    writeFileSync(configPath, JSON.stringify(cloned, null, 2), { mode: 0o600 });
+                    writeConfigFile(configPath, JSON.stringify(cloned, null, 2));
                     // Copy x-jishushell upstream metadata from source instance.json
                     // (saveConfig stores x-jishushell in instance.json, not openclaw.json)
                     const srcMetaPath = join(instanceDir(cloneFrom), "instance.json");
@@ -813,7 +934,7 @@ export async function createInstance(instanceId, name, description = "", cloneFr
                                 if (existsSync(metaPath)) {
                                     const dstMeta = JSON.parse(readFileSync(metaPath, "utf-8"));
                                     dstMeta["x-jishushell"] = dstXj;
-                                    writeFileSync(metaPath, JSON.stringify(dstMeta, null, 2));
+                                    writeConfigFile(metaPath, JSON.stringify(dstMeta, null, 2));
                                 }
                             }
                         }
@@ -827,7 +948,7 @@ export async function createInstance(instanceId, name, description = "", cloneFr
             }
         }
         if (!existsSync(configPath)) {
-            writeFileSync(configPath, JSON.stringify(starterConfig(), null, 2), { mode: 0o600 });
+            writeConfigFile(configPath, JSON.stringify(starterConfig(), null, 2));
             // Inject default provider API key from setup into both env files
             const dp = getPanelConfig().default_provider;
             if (dp?.apiKey && dp?.providerId && envFiles.length) {
@@ -895,11 +1016,28 @@ export function updateInstance(instanceId, name, description) {
     chownToServiceUser(instanceMetaPath(instanceId));
     return meta;
 }
-export function deleteInstance(instanceId) {
+/** Update instance.json metadata fields (shallow merge at top level). */
+export function updateInstanceMeta(instanceId, patch) {
+    const metaPath = instanceMetaPath(instanceId);
+    const meta = safeReadJson(metaPath, "instance-meta") || {};
+    Object.assign(meta, patch);
+    safeWriteJson(metaPath, meta);
+}
+export function deleteInstance(instanceId, purgeBackups = false) {
     const d = instanceDir(instanceId);
     if (!existsSync(d))
         return { ok: false, warnings: ["Instance directory not found"] };
     const warnings = [];
+    // Cancel auto-backup timer and any queued jobs for this instance
+    import("./backup-manager.js").then(({ cancelAutoBackup, getQueueStatus, cancelJob }) => {
+        cancelAutoBackup(instanceId);
+        // Cancel queued (not yet running) jobs for this instance
+        const q = getQueueStatus();
+        for (const job of q.queued) {
+            if (job.instanceId === instanceId)
+                cancelJob(job.id);
+        }
+    }).catch(() => { });
     // Cache metadata BEFORE deletion so we can check custom openclaw_home after rm
     const meta = getInstance(instanceId);
     const home = meta?.openclaw_home;
@@ -929,6 +1067,19 @@ export function deleteInstance(instanceId) {
     if (home && !home.startsWith(d) && existsSync(home)) {
         warnings.push(`Custom openclaw_home '${home}' was preserved. Delete manually if no longer needed.`);
     }
+    // Handle backups (stored in separate directory, not affected by instance rmSync)
+    const backupDir = join(BACKUPS_DIR, instanceId);
+    if (purgeBackups && existsSync(backupDir)) {
+        try {
+            rmSync(backupDir, { recursive: true, force: true });
+        }
+        catch (e) {
+            warnings.push(`Failed to delete backups: ${e.message}`);
+        }
+    }
+    else if (existsSync(backupDir)) {
+        warnings.push(`Backups preserved at ${backupDir}`);
+    }
     return { ok: dirDeleted, warnings: warnings.length ? warnings : undefined };
 }
 export function getConfig(instanceId) {
@@ -958,13 +1109,7 @@ export function saveConfig(instanceId, config) {
         return false;
     if (!existsSync(configPath)) {
         const legacyPath = legacyOpenclawConfigPath(instanceId);
-        mkdirSync(dirname(configPath), { recursive: true });
-        // Ensure the state dir is group-writable so the Docker container (which may
-        // run as a different UID) can create sub-directories via shared group.
-        try {
-            chmodSync(dirname(configPath), 0o770);
-        }
-        catch { /* best effort */ }
+        ensureDirContainer(dirname(configPath));
         if (existsSync(legacyPath))
             copyFileSync(legacyPath, configPath);
     }
@@ -1000,9 +1145,10 @@ export function saveConfig(instanceId, config) {
             configToWrite.plugins.entries.feishu = { enabled: false };
         }
     }
-    // Preserve plugins.installs from existing config on disk —
-    // these are managed by `openclaw plugins install` and must not be overwritten
-    // by the frontend config which doesn't track them.
+    // Preserve backend-managed fields from existing config on disk —
+    // plugins.installs, plugins.entries, and channels written by scan-to-bind
+    // flows (saveWeixinCredentials / saveFeishuCredentials) are not tracked by
+    // the frontend and would be lost on a frontend config save.
     if (existsSync(configPath)) {
         try {
             const existing = JSON.parse(readFileSync(configPath, "utf-8"));
@@ -1010,6 +1156,28 @@ export function saveConfig(instanceId, config) {
                 configToWrite.plugins ??= {};
                 configToWrite.plugins.installs = { ...existing.plugins.installs, ...configToWrite.plugins?.installs };
             }
+            // Merge plugin entries: for keys present in configToWrite, deep-merge
+            // backend-written sub-fields from disk. Keys absent from configToWrite
+            // (intentionally deleted) are NOT resurrected from existing.
+            if (existing.plugins?.entries && configToWrite.plugins?.entries) {
+                for (const [key, val] of Object.entries(configToWrite.plugins.entries)) {
+                    const old = existing.plugins.entries[key];
+                    if (val && typeof val === "object" && !Array.isArray(val) && old && typeof old === "object") {
+                        configToWrite.plugins.entries[key] = { ...old, ...val };
+                    }
+                }
+            }
+            // Merge channels: for keys present in configToWrite, deep-merge
+            // backend-written sub-fields (e.g. openclaw-weixin accounts) from disk.
+            // Keys absent from configToWrite (user-deleted channels) stay deleted.
+            if (existing.channels && configToWrite.channels) {
+                for (const [key, val] of Object.entries(configToWrite.channels)) {
+                    const old = existing.channels[key];
+                    if (val && typeof val === "object" && !Array.isArray(val) && old && typeof old === "object") {
+                        configToWrite.channels[key] = { ...old, ...val };
+                    }
+                }
+            }
         }
         catch { /* best effort */ }
     }
@@ -1018,18 +1186,18 @@ export function saveConfig(instanceId, config) {
         copyFileSync(configPath, configPath + ".bak");
     }
     const configJson = JSON.stringify(configToWrite, null, 2);
-    mkdirSync(dirname(configPath), { recursive: true });
-    writeFileSync(configPath + ".tmp", configJson, { mode: 0o600 });
+    ensureDirContainer(dirname(configPath));
+    writeConfigFile(configPath + ".tmp", configJson);
     // Verify tmp file is valid JSON before replacing (guards against disk-full partial writes)
     JSON.parse(readFileSync(configPath + ".tmp", "utf-8"));
     renameSync(configPath + ".tmp", configPath);
     chownToServiceUser(configPath);
-    // also write to legacy path (with restricted permissions)
+    // also write to legacy path
     const legacyPath = legacyOpenclawConfigPath(instanceId);
     if (existsSync(legacyPath)) {
         copyFileSync(legacyPath, legacyPath + ".bak");
     }
-    writeFileSync(legacyPath + ".tmp", configJson, { mode: 0o600 });
+    writeConfigFile(legacyPath + ".tmp", configJson);
     JSON.parse(readFileSync(legacyPath + ".tmp", "utf-8"));
     renameSync(legacyPath + ".tmp", legacyPath);
     chownToServiceUser(legacyPath);
@@ -1081,7 +1249,8 @@ export function saveFeishuCredentials(instanceId, creds) {
         appId: creds.appId,
         appSecret: creds.appSecret,
         domain: creds.domain,
-        dmPolicy: "pairing",
+        dmPolicy: "open",
+        allowFrom: ["*"],
     };
     safeWriteJson(configPath, config);
     chownToServiceUser(configPath);
@@ -1099,7 +1268,7 @@ export function saveWeixinCredentials(instanceId, creds) {
     const home = getOpenclawHomeInternal(instanceId);
     const stateDir = join(home, OPENCLAW_STATE_DIRNAME, "openclaw-weixin");
     const accountsDir = join(stateDir, "accounts");
-    mkdirSync(accountsDir, { recursive: true });
+    ensureDirContainer(accountsDir);
     // Save account credentials file (via safeWriteJson for atomic + .bak protection)
     const credObj = {
         token: creds.token,