jishushell 0.0.1 → 0.4.2-beta2

package/dist/routes/instances.js

@@ -0,0 +1,1303 @@
+import { createHash } from "crypto";
+import { existsSync, realpathSync } from "fs";
+import { readFile, stat } from "fs/promises";
+import { request as httpRequest } from "http";
+import { join } from "path";
+import { getServiceManagerType } from "../config.js";
+import { PROXY_IDENTITY_HEADERS } from "../constants.js";
+import * as instanceManager from "../services/instance-manager.js";
+import * as llmProxy from "../services/llm-proxy/index.js";
+import * as pluginInstaller from "../services/plugin-installer.js";
+import { TtlMap } from "../utils/ttl-cache.js";
+// Hop-by-hop headers that must not be forwarded by a proxy (RFC 2616 §13.5.1)
+const HOP_BY_HOP = new Set([
+    "connection", "keep-alive", "proxy-authenticate", "proxy-authorization",
+    "te", "trailer", "transfer-encoding", "upgrade",
+]);
+function readHeaderValue(value) {
+    const header = Array.isArray(value) ? value[0] : value;
+    return typeof header === "string" && header.trim() ? header.trim() : null;
+}
+function parseHttpOrigin(value) {
+    if (!value)
+        return null;
+    try {
+        const parsed = new URL(value);
+        return parsed.protocol === "http:" || parsed.protocol === "https:" ? parsed.origin : null;
+    }
+    catch {
+        return null;
+    }
+}
+function inferRequestOrigin(request) {
+    // Only trust browser-sent Origin/Referer for auto-allowlisting. Host and
+    // X-Forwarded-* are proxy metadata and should not become persisted origin
+    // policy by themselves.
+    return (parseHttpOrigin(readHeaderValue(request?.headers?.origin))
+        ?? parseHttpOrigin(readHeaderValue(request?.headers?.referer)));
+}
+function ensureControlUiAllowedOrigin(instanceId, origin) {
+    const normalizedOrigin = origin.trim();
+    if (!normalizedOrigin)
+        return false;
+    const config = instanceManager.getStoredConfig(instanceId);
+    if (!config)
+        return false;
+    const gateway = config.gateway ??= {};
+    const controlUi = gateway.controlUi ??= {};
+    const existing = Array.isArray(controlUi.allowedOrigins)
+        ? controlUi.allowedOrigins.map((value) => String(value))
+        : [];
+    const normalized = new Set(existing.map((value) => value.trim().toLowerCase()).filter(Boolean));
+    if (normalized.has("*") || normalized.has(normalizedOrigin.toLowerCase()))
+        return false;
+    controlUi.allowedOrigins = [...existing.filter((value) => value.trim()), normalizedOrigin];
+    instanceManager.saveConfig(instanceId, config);
+    return true;
+}
+// Resolve service manager once at route registration, re-resolve on config change
+let _svc = null;
+let _svcType = "";
+async function getSvc() {
+    const currentType = getServiceManagerType();
+    if (_svc && _svcType === currentType)
+        return _svc;
+    _svc = currentType === "nomad"
+        ? await import("../services/nomad-manager.js")
+        : await import("../services/process-manager.js");
+    _svcType = currentType;
+    return _svc;
+}
+function validateId(id) {
+    if (!/^[a-z0-9][a-z0-9-]{0,62}$/.test(id)) {
+        return "ID must be lowercase alphanumeric with hyphens, 1-63 chars";
+    }
+    return null;
+}
+// TTL 15s: outlives the frontend 10s polling interval so most requests hit cache
+const statusCache = new TtlMap(15_000);
+const controlUiRestartInFlight = new Map();
+function getCachedStatus(svc, instanceId) {
+    const cached = statusCache.get(instanceId);
+    if (cached !== undefined)
+        return Promise.resolve(cached);
+    return Promise.resolve(svc.getStatus(instanceId)).then((data) => {
+        statusCache.set(instanceId, data);
+        return data;
+    });
+}
+async function restartRunningInstanceForControlUiOrigin(instanceId, origin) {
+    const inFlight = controlUiRestartInFlight.get(instanceId);
+    if (inFlight)
+        return inFlight;
+    const task = (async () => {
+        const svc = await getSvc();
+        const status = await svc.getStatus(instanceId);
+        if (status.status !== "running")
+            return;
+        const result = await svc.restartInstance(instanceId);
+        statusCache.delete(instanceId);
+        if (!result.ok) {
+            console.warn(`[gateway-launch] failed to auto-restart ${instanceId} after allowing origin ${origin}:`, result.error || "unknown error");
+            return;
+        }
+        console.log(`[gateway-launch] auto-restarted ${instanceId} after allowing origin ${origin}`);
+    })().finally(() => {
+        controlUiRestartInFlight.delete(instanceId);
+    });
+    controlUiRestartInFlight.set(instanceId, task);
+    return task;
+}
+export async function instanceRoutes(app) {
+    // List
+    app.get("/api/instances", async () => {
+        const svc = await getSvc();
+        const instances = instanceManager.listInstances();
+        const statuses = await Promise.all(instances.map(inst => getCachedStatus(svc, inst.id).catch(() => ({ status: "unknown" }))));
+        return instances.map((inst, i) => ({ ...inst, service: statuses[i] }));
+    });
+    // Create
+    app.post("/api/instances", async (req, reply) => {
+        const err = validateId(req.body.id);
+        if (err)
+            return reply.status(400).send({ detail: err });
+        // Validate name/description length
+        if (typeof req.body.name !== "string" || req.body.name.length === 0 || req.body.name.length > 256) {
+            return reply.status(400).send({ detail: "Name must be 1-256 characters" });
+        }
+        if (req.body.description && req.body.description.length > 2048) {
+            return reply.status(400).send({ detail: "Description must be at most 2048 characters" });
+        }
+        // Validate clone_from if provided
+        if (req.body.clone_from) {
+            const cloneErr = validateId(req.body.clone_from);
+            if (cloneErr)
+                return reply.status(400).send({ detail: `Invalid clone_from: ${cloneErr}` });
+            const sourceInstance = instanceManager.getInstance(req.body.clone_from);
+            if (!sourceInstance)
+                return reply.status(400).send({ detail: `Source instance '${req.body.clone_from}' not found` });
+        }
+        try {
+            const meta = await instanceManager.createInstance(req.body.id, req.body.name, req.body.description || "", req.body.clone_from, req.body.openclaw_home);
+            // Auto-start if default provider is configured (model ready to use)
+            const { getPanelConfig } = await import("../config.js");
+            const dp = getPanelConfig().default_provider;
+            if (dp && dp.providerId && !dp.skipped) {
+                const svc = await getSvc();
+                svc.startInstance(req.body.id).catch((e) => {
+                    console.warn(`[instances] Auto-start ${req.body.id} failed: ${e.message}`);
+                });
+                meta.autoStarted = true;
+            }
+            return meta;
+        }
+        catch (e) {
+            return reply.status(409).send({ detail: e.message });
+        }
+    });
+    // Get
+    app.get("/api/instances/:id", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        const svc = await getSvc();
+        const inst = instanceManager.getInstance(req.params.id);
+        if (!inst)
+            return reply.status(404).send({ detail: "Instance not found" });
+        const status = await svc.getStatus(req.params.id);
+        return { ...inst, service: status };
+    });
+    // Update
+    app.put("/api/instances/:id", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        if (req.body.name !== undefined && (typeof req.body.name !== "string" || req.body.name.length === 0 || req.body.name.length > 256)) {
+            return reply.status(400).send({ detail: "Name must be 1-256 characters" });
+        }
+        if (req.body.description !== undefined && req.body.description.length > 2048) {
+            return reply.status(400).send({ detail: "Description must be at most 2048 characters" });
+        }
+        const inst = instanceManager.updateInstance(req.params.id, req.body.name, req.body.description);
+        if (!inst)
+            return reply.status(404).send({ detail: "Instance not found" });
+        return inst;
+    });
+    // Delete
+    app.delete("/api/instances/:id", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        const svc = await getSvc();
+        let stopFailed = false;
+        try {
+            await svc.stopInstance(req.params.id, true);
+        }
+        catch {
+            try {
+                await svc.stopInstance(req.params.id);
+            }
+            catch {
+                stopFailed = true;
+            }
+        }
+        // Also stop any legacy process-manager process that might be lingering
+        try {
+            const { getLegacyStatus, stopInstance: stopLegacy } = await import("../services/process-manager.js");
+            if ((await getLegacyStatus(req.params.id)).status === "running") {
+                await stopLegacy(req.params.id);
+                stopFailed = false;
+            }
+        }
+        catch { /* ignore */ }
+        statusCache.delete(req.params.id);
+        llmProxy.cleanupInstance(req.params.id);
+        const result = instanceManager.deleteInstance(req.params.id);
+        if (!result.ok && result.warnings?.some(w => w.includes("not found"))) {
+            return reply.status(404).send({ detail: "Instance not found" });
+        }
+        const warnings = result.warnings ? [...result.warnings] : [];
+        if (stopFailed) {
+            console.warn(`[instances] Delete ${req.params.id}: service stop failed, orphaned processes may remain`);
+            warnings.push("Service stop did not complete; verify no orphaned processes remain.");
+        }
+        return { ok: result.ok, warnings: warnings.length ? warnings : undefined };
+    });
+    // Config
+    app.get("/api/instances/:id/config", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        const config = llmProxy.getInstanceConfig(req.params.id);
+        if (!config)
+            return reply.status(404).send({ detail: "Instance or config not found" });
+        return config;
+    });
+    app.put("/api/instances/:id/config", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        // Basic payload validation
+        const body = req.body;
+        if (!body || typeof body !== "object" || Array.isArray(body)) {
+            return reply.status(400).send({ detail: "Config must be a JSON object" });
+        }
+        const bodyStr = JSON.stringify(body);
+        if (bodyStr.length > 512 * 1024) {
+            return reply.status(400).send({ detail: "Config too large (max 512KB)" });
+        }
+        try {
+            const saved = await llmProxy.saveInstanceConfig(req.params.id, body);
+            return { ok: true, config: saved };
+        }
+        catch (e) {
+            const msg = e.message || "";
+            if (msg.includes("not found"))
+                return reply.status(404).send({ detail: msg });
+            return reply.status(400).send({ detail: msg });
+        }
+    });
+    // Service control
+    app.get("/api/instances/:id/service/status", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        const svc = await getSvc();
+        if (!instanceManager.getInstance(req.params.id)) {
+            return reply.status(404).send({ detail: "Instance not found" });
+        }
+        return svc.getStatus(req.params.id);
+    });
+    app.post("/api/instances/:id/service/start", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        const svc = await getSvc();
+        if (!instanceManager.getInstance(req.params.id)) {
+            return reply.status(404).send({ detail: "Instance not found" });
+        }
+        const result = await svc.startInstance(req.params.id);
+        statusCache.delete(req.params.id);
+        if (!result.ok)
+            return reply.status(400).send({ detail: result.error });
+        return result;
+    });
+    app.post("/api/instances/:id/service/stop", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        const svc = await getSvc();
+        if (!instanceManager.getInstance(req.params.id)) {
+            return reply.status(404).send({ detail: "Instance not found" });
+        }
+        const result = await svc.stopInstance(req.params.id);
+        statusCache.delete(req.params.id);
+        if (!result.ok)
+            return reply.status(400).send({ detail: result.error });
+        return result;
+    });
+    app.post("/api/instances/:id/service/restart", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        const svc = await getSvc();
+        if (!instanceManager.getInstance(req.params.id)) {
+            return reply.status(404).send({ detail: "Instance not found" });
+        }
+        const result = await svc.restartInstance(req.params.id);
+        statusCache.delete(req.params.id);
+        if (!result.ok)
+            return reply.status(400).send({ detail: result.error || "Unknown error" });
+        return result;
+    });
+    // Plugin check & install — host-side, no container dependency
+    app.get("/api/instances/:id/plugins/check/:channelId", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        if (!instanceManager.getInstance(req.params.id)) {
+            return reply.status(404).send({ detail: "Instance not found" });
+        }
+        return {
+            channelId: req.params.channelId,
+            installed: instanceManager.isChannelPluginInstalled(req.params.id, req.params.channelId),
+        };
+    });
+    // Plugin status for all tracked IM plugins (feishu, openclaw-weixin)
+    app.get("/api/instances/:id/plugins/status", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        if (!instanceManager.getInstance(req.params.id)) {
+            return reply.status(404).send({ detail: "Instance not found" });
+        }
+        return { plugins: pluginInstaller.getAllPluginStatuses(req.params.id) };
+    });
+    // Quick status: IM binding + skill install state for the quick-skill panel
+    app.get("/api/instances/:id/quick-status", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        if (!instanceManager.getInstance(req.params.id)) {
+            return reply.status(404).send({ detail: "Instance not found" });
+        }
+        const id = req.params.id;
+        const cfg = instanceManager.getConfig(id) ?? {};
+        const channels = cfg.channels ?? {};
+        // IM binding: channel must be enabled AND have a non-empty token / accounts
+        const feishuCh = channels["feishu"] ?? channels["lark"] ?? {};
+        const weixinCh = channels["openclaw-weixin"] ?? {};
+        const feishuBound = !!(feishuCh.enabled && (feishuCh.appId || feishuCh.token || feishuCh.deviceToken || feishuCh.accessToken));
+        const weixinBound = !!(weixinCh.enabled && weixinCh.accounts && Object.keys(weixinCh.accounts).length > 0);
+        // Skill install state: scan workspace/skills/ and return all directory names
+        const { readdirSync: fsReaddir, existsSync: fsExists, readFileSync: fsRead } = await import("fs");
+        const { join: fsJoin } = await import("path");
+        const workspaceDir = fsJoin(instanceManager.getOpenclawHome(id), ".openclaw", "workspace");
+        const stateDir = fsJoin(workspaceDir, "skills");
+        let installedSkillDirs = [];
+        try {
+            installedSkillDirs = fsReaddir(stateDir, { withFileTypes: true })
+                .filter(e => e.isDirectory())
+                .map(e => e.name);
+        }
+        catch { }
+        // MCPorter install state — mcporter is installed as a skill in workspace/skills/mcporter
+        const mcporterInstalled = installedSkillDirs.some(d => d.toLowerCase() === 'mcporter');
+        // MCPorter configured servers
+        let mcporterServers = {};
+        const mcporterCfgPath = fsJoin(workspaceDir, "config", "mcporter.json");
+        try {
+            const raw = JSON.parse(fsRead(mcporterCfgPath, "utf8"));
+            mcporterServers = raw.mcpServers ?? {};
+        }
+        catch { }
+        return {
+            im: {
+                feishu: feishuBound,
+                weixin: weixinBound,
+            },
+            installedSkillDirs,
+            mcporterInstalled,
+            mcporterServers,
+        };
+    });
+    // Run `mcporter list --json` and return live server status
+    app.get("/api/instances/:id/mcporter/list", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        if (!instanceManager.getInstance(req.params.id)) {
+            return reply.status(404).send({ detail: "Instance not found" });
+        }
+        const id = req.params.id;
+        const openclawHome = instanceManager.getOpenclawHome(id);
+        const workspaceDir = join(openclawHome, ".openclaw", "workspace");
+        const mcporterBinPath = join(workspaceDir, ".npm-global", "bin", "mcporter");
+        const mcporterCfg = join(workspaceDir, "config", "mcporter.json");
+        if (!existsSync(mcporterBinPath)) {
+            return { servers: [], installed: false };
+        }
+        const { execFile } = await import("child_process");
+        const { promisify } = await import("util");
+        const execFileAsync = promisify(execFile);
+        try {
+            const { stdout } = await execFileAsync(mcporterBinPath, ["list", "--json"], {
+                env: { ...process.env, HOME: openclawHome, MCPORTER_CONFIG: mcporterCfg },
+                timeout: 60_000,
+            });
+            const parsed = JSON.parse(stdout);
+            return { servers: parsed.servers ?? [], installed: true };
+        }
+        catch (err) {
+            // execFile throws if exit code != 0; stdout may still have partial JSON
+            const raw = err?.stdout ?? "";
+            try {
+                const parsed = JSON.parse(raw);
+                return { servers: parsed.servers ?? [], installed: true };
+            }
+            catch { }
+            return { servers: [], installed: true, error: err?.message ?? "unknown" };
+        }
+    });
+    // Merge servers into mcporter.json
+    app.post("/api/instances/:id/mcporter/add", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        if (!instanceManager.getInstance(req.params.id)) {
+            return reply.status(404).send({ detail: "Instance not found" });
+        }
+        const { servers } = req.body;
+        if (!servers || typeof servers !== "object" || Array.isArray(servers)) {
+            return reply.status(400).send({ detail: "servers must be an object" });
+        }
+        const openclawHome = instanceManager.getOpenclawHome(req.params.id);
+        const workspaceDir = join(openclawHome, ".openclaw", "workspace");
+        const mcporterCfgPath = join(workspaceDir, "config", "mcporter.json");
+        const { readFileSync, writeFileSync, mkdirSync } = await import("fs");
+        let cfg = { mcpServers: {}, imports: [] };
+        try {
+            cfg = JSON.parse(readFileSync(mcporterCfgPath, "utf8"));
+        }
+        catch { }
+        if (!cfg.mcpServers)
+            cfg.mcpServers = {};
+        // Explicit key-by-key copy instead of Object.assign to prevent prototype pollution:
+        // a crafted body with "__proto__" or "constructor" keys could corrupt the object prototype.
+        const PROTO_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+        for (const [k, v] of Object.entries(servers)) {
+            if (!PROTO_KEYS.has(k))
+                cfg.mcpServers[k] = v;
+        }
+        try {
+            mkdirSync(join(workspaceDir, "config"), { recursive: true });
+            writeFileSync(mcporterCfgPath, JSON.stringify(cfg, null, 2), "utf8");
+        }
+        catch (err) {
+            return reply.status(500).send({ detail: `Write failed: ${err.message}` });
+        }
+        return { ok: true, mcpServers: cfg.mcpServers };
+    });
+    // Remove a server from mcporter.json
+    app.delete("/api/instances/:id/mcporter/:serverName", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        if (!instanceManager.getInstance(req.params.id)) {
+            return reply.status(404).send({ detail: "Instance not found" });
+        }
+        const { serverName } = req.params;
+        if (!serverName || typeof serverName !== "string") {
+            return reply.status(400).send({ detail: "serverName is required" });
+        }
+        const openclawHome = instanceManager.getOpenclawHome(req.params.id);
+        const workspaceDir = join(openclawHome, ".openclaw", "workspace");
+        const mcporterCfgPath = join(workspaceDir, "config", "mcporter.json");
+        const { readFileSync, writeFileSync } = await import("fs");
+        let cfg = { mcpServers: {}, imports: [] };
+        try {
+            cfg = JSON.parse(readFileSync(mcporterCfgPath, "utf8"));
+        }
+        catch { }
+        if (!cfg.mcpServers || !(serverName in cfg.mcpServers)) {
+            return reply.status(404).send({ detail: `Server '${serverName}' not found` });
+        }
+        delete cfg.mcpServers[serverName];
+        try {
+            writeFileSync(mcporterCfgPath, JSON.stringify(cfg, null, 2), "utf8");
+        }
+        catch (err) {
+            return reply.status(500).send({ detail: `Write failed: ${err.message}` });
+        }
+        return { ok: true, mcpServers: cfg.mcpServers };
+    });
+    // Delete a skill directory from workspace/skills/
+    app.delete("/api/instances/:id/skills/:skillDir", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        if (!instanceManager.getInstance(req.params.id)) {
+            return reply.status(404).send({ detail: "Instance not found" });
+        }
+        const { skillDir } = req.params;
+        // Prevent path traversal
+        if (!skillDir || skillDir.includes("/") || skillDir.includes("..") || skillDir.startsWith(".")) {
+            return reply.status(400).send({ detail: "Invalid skill directory name" });
+        }
+        const openclawHome = instanceManager.getOpenclawHome(req.params.id);
+        const skillPath = join(openclawHome, ".openclaw", "workspace", "skills", skillDir);
+        const { existsSync: fsEx, rmSync } = await import("fs");
+        if (!fsEx(skillPath)) {
+            return reply.status(404).send({ detail: `Skill '${skillDir}' not found` });
+        }
+        try {
+            rmSync(skillPath, { recursive: true, force: true });
+        }
+        catch (err) {
+            return reply.status(500).send({ detail: `Delete failed: ${err.message}` });
+        }
+        return { ok: true };
+    });
+    app.post("/api/instances/:id/plugins/install", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        if (!instanceManager.getInstance(req.params.id)) {
+            return reply.status(404).send({ detail: "Instance not found" });
+        }
+        const { channelId } = req.body;
+        if (!channelId || typeof channelId !== "string") {
+            return reply.status(400).send({ detail: "channelId is required" });
+        }
+        const pkg = instanceManager.CHANNEL_PLUGIN_MAP[channelId];
+        if (!pkg) {
+            return reply.status(400).send({ detail: `Unknown channel: ${channelId}` });
+        }
+        const pStatus = pluginInstaller.getPluginStatus(req.params.id, channelId);
+        if (pStatus.status === "installed")
+            return { ok: true, status: "already_installed" };
+        if (pStatus.status === "installing")
+            return { ok: true, status: "installing" };
+        pluginInstaller.enqueueInstall(req.params.id, channelId);
+        return { ok: true, status: "queued" };
+    });
+    // ── Helper: ensure a channel plugin is installed (check-only) ──
+    async function ensurePluginInstalled(instanceId, channelId) {
+        if (!instanceManager.CHANNEL_PLUGIN_MAP[channelId])
+            return;
+        if (!instanceManager.isChannelPluginInstalled(instanceId, channelId)) {
+            throw new Error(`Plugin ${channelId} is not installed. Please install it from the config page.`);
+        }
+    }
+    // ── Feishu/Lark OAuth Device Code Login ──
+    const FEISHU_AUTH_URL = "https://accounts.feishu.cn";
+    const MAX_LOGIN_SESSIONS = 100;
+    const feishuLogins = new Map();
+    app.post("/api/instances/:id/feishu/login", async (req, reply) => {
+        const channelKey = req.body?.channelKey || "feishu";
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        if (!instanceManager.getInstance(req.params.id)) {
+            return reply.status(404).send({ detail: "Instance not found" });
+        }
+        // Require instance to be running
+        const svc = await getSvc();
+        const svcStatus = await svc.getStatus(req.params.id);
+        if (svcStatus.status !== "running") {
+            return reply.status(400).send({ detail: "Instance must be running first" });
+        }
+        // Auto-install feishu plugin if not present
+        await ensurePluginInstalled(req.params.id, channelKey);
+        try {
+            // Step 1: init
+            await fetch(`${FEISHU_AUTH_URL}/oauth/v1/app/registration`, {
+                method: "POST",
+                headers: { "Content-Type": "application/x-www-form-urlencoded" },
+                body: "action=init",
+                signal: AbortSignal.timeout(30_000),
+            });
+            // Step 2: begin — get QR code URL and device code
+            const beginResp = await fetch(`${FEISHU_AUTH_URL}/oauth/v1/app/registration`, {
+                method: "POST",
+                headers: { "Content-Type": "application/x-www-form-urlencoded" },
+                body: "action=begin&archetype=PersonalAgent&auth_method=client_secret&request_user_info=open_id",
+                signal: AbortSignal.timeout(30_000),
+            });
+            if (!beginResp.ok)
+                throw new Error(`Feishu API error: ${beginResp.status}`);
+            const beginData = await beginResp.json();
+            const sessionKey = `${req.params.id}-${channelKey}-${Date.now()}`;
+            feishuLogins.set(sessionKey, {
+                instanceId: req.params.id,
+                deviceCode: beginData.device_code,
+                startedAt: Date.now(),
+                interval: beginData.interval || 5,
+                expireIn: beginData.expire_in || 600,
+                channelKey,
+            });
+            // Purge expired + enforce cap
+            for (const [k, v] of feishuLogins) {
+                if (Date.now() - v.startedAt > v.expireIn * 1000)
+                    feishuLogins.delete(k);
+            }
+            while (feishuLogins.size > MAX_LOGIN_SESSIONS) {
+                feishuLogins.delete(feishuLogins.keys().next().value);
+            }
+            return { qrcodeUrl: beginData.verification_uri_complete, sessionKey };
+        }
+        catch (e) {
+            return reply.status(502).send({ detail: e.message || "Failed to start Feishu login" });
+        }
+    });
+    app.get("/api/instances/:id/feishu/login/:sessionKey", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        const login = feishuLogins.get(req.params.sessionKey);
+        if (!login)
+            return reply.status(404).send({ detail: "Login session not found or expired" });
+        if (login.instanceId !== req.params.id)
+            return reply.status(403).send({ detail: "Session belongs to a different instance" });
+        if (Date.now() - login.startedAt > login.expireIn * 1000) {
+            feishuLogins.delete(req.params.sessionKey);
+            return { status: "expired", connected: false, message: "QR code expired, please regenerate." };
+        }
+        try {
+            const resp = await fetch(`${FEISHU_AUTH_URL}/oauth/v1/app/registration`, {
+                method: "POST",
+                headers: { "Content-Type": "application/x-www-form-urlencoded" },
+                body: `action=poll&device_code=${encodeURIComponent(login.deviceCode)}`,
+                signal: AbortSignal.timeout(10_000),
+            });
+            const data = await resp.json();
+            if (data.client_id && data.client_secret) {
+                const storedChannelKey = login.channelKey || "feishu";
+                feishuLogins.delete(req.params.sessionKey);
+                const domain = data.user_info?.tenant_brand === "lark" ? "lark" : "feishu";
+                instanceManager.saveFeishuCredentials(req.params.id, {
+                    appId: data.client_id,
+                    appSecret: data.client_secret,
+                    domain,
+                    channelKey: storedChannelKey,
+                });
+                return {
+                    status: "confirmed", connected: true, domain,
+                    message: domain === "lark" ? "Lark bot configured!" : "Feishu bot configured!",
+                };
+            }
+            if (data.error === "authorization_pending") {
+                return { status: "waiting", connected: false, message: "Waiting for scan..." };
+            }
+            if (data.error === "expired_token") {
+                feishuLogins.delete(req.params.sessionKey);
+                return { status: "expired", connected: false, message: "QR code expired, please regenerate." };
+            }
+            return { status: "waiting", connected: false, message: "Waiting for scan..." };
+        }
+        catch (e) {
+            return reply.status(502).send({ detail: e.message || "Poll failed" });
+        }
+    });
+    // ── Pairing ──────────────────────────────────────────────────────────────
+    // Pairing codes are uppercase alphanumeric, 4-16 chars (e.g. LVU7PNYK).
+    const PAIRING_CODE_RE = /^[A-Z0-9]{4,16}$/;
+    // Channel identifiers follow the same kebab-case rules as plugin IDs.
+    const PAIRING_CHANNEL_RE = /^[a-z][a-z0-9_-]{0,31}$/;
+    app.get("/api/instances/:id/pairing/list", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        if (!instanceManager.getInstance(req.params.id)) {
+            return reply.status(404).send({ detail: "Instance not found" });
+        }
+        const svc = await getSvc();
+        const result = await svc.exec(req.params.id, ["openclaw", "pairing", "list"], 15_000);
+        return { output: result.stdout + result.stderr, exitCode: result.exitCode };
+    });
+    app.post("/api/instances/:id/pairing/approve", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        if (!instanceManager.getInstance(req.params.id)) {
+            return reply.status(404).send({ detail: "Instance not found" });
+        }
+        const { channel, code, notify } = req.body ?? {};
+        if (!channel || !PAIRING_CHANNEL_RE.test(channel)) {
+            return reply.status(400).send({ detail: "Invalid channel: must be lowercase alphanumeric/hyphen/underscore" });
+        }
+        if (!code || !PAIRING_CODE_RE.test(code)) {
+            return reply.status(400).send({ detail: "Invalid pairing code: must be 4-16 uppercase alphanumeric characters" });
+        }
+        const cmd = ["openclaw", "pairing", "approve", channel, code];
+        if (notify)
+            cmd.push("--notify");
+        const svc = await getSvc();
+        const result = await svc.exec(req.params.id, cmd, 15_000);
+        if (result.exitCode !== 0) {
+            return reply.status(400).send({ detail: (result.stderr || result.stdout || "Approval failed").trim() });
+        }
+        return { ok: true, output: (result.stdout + result.stderr).trim() };
+    });
+    // WeChat accounts query
+    app.get("/api/instances/:id/weixin/accounts", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        if (!instanceManager.getInstance(req.params.id)) {
+            return reply.status(404).send({ detail: "Instance not found" });
+        }
+        return { accounts: instanceManager.getWeixinAccounts(req.params.id) };
+    });
+    // ── WeChat QR Login ──
+    const WEIXIN_API_BASE = "https://ilinkai.weixin.qq.com";
+    const WEIXIN_BOT_TYPE = "3";
+    // In-memory active login sessions (short-lived, 5 min TTL)
+    const weixinLogins = new Map();
+    app.post("/api/instances/:id/weixin/login", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        if (!instanceManager.getInstance(req.params.id)) {
+            return reply.status(404).send({ detail: "Instance not found" });
+        }
+        // Require instance to be running
+        const svc = await getSvc();
+        const svcStatus = await svc.getStatus(req.params.id);
+        if (svcStatus.status !== "running") {
+            return reply.status(400).send({ detail: "Instance must be running first" });
+        }
+        // Auto-install weixin plugin if not present
+        await ensurePluginInstalled(req.params.id, "openclaw-weixin");
+        try {
+            const resp = await fetch(`${WEIXIN_API_BASE}/ilink/bot/get_bot_qrcode?bot_type=${WEIXIN_BOT_TYPE}`, { signal: AbortSignal.timeout(30_000) });
+            if (!resp.ok)
+                throw new Error(`WeChat API error: ${resp.status}`);
+            const data = await resp.json();
+            const sessionKey = `${req.params.id}-${Date.now()}`;
+            weixinLogins.set(sessionKey, {
+                instanceId: req.params.id,
+                qrcode: data.qrcode,
+                qrcodeUrl: data.qrcode_img_content,
+                startedAt: Date.now(),
+            });
+            // Purge expired sessions + enforce cap
+            for (const [k, v] of weixinLogins) {
+                if (Date.now() - v.startedAt > 5 * 60_000)
+                    weixinLogins.delete(k);
+            }
+            while (weixinLogins.size > MAX_LOGIN_SESSIONS) {
+                weixinLogins.delete(weixinLogins.keys().next().value);
+            }
+            return { qrcodeUrl: data.qrcode_img_content, sessionKey };
+        }
+        catch (e) {
+            return reply.status(502).send({ detail: e.message || "Failed to get QR code" });
+        }
+    });
+    app.get("/api/instances/:id/weixin/login/:sessionKey", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        const login = weixinLogins.get(req.params.sessionKey);
+        if (!login)
+            return reply.status(404).send({ detail: "Login session not found or expired" });
+        if (login.instanceId !== req.params.id)
+            return reply.status(403).send({ detail: "Session belongs to a different instance" });
+        if (Date.now() - login.startedAt > 5 * 60_000) {
+            weixinLogins.delete(req.params.sessionKey);
+            return { status: "expired", connected: false, message: "QR code expired, please regenerate." };
+        }
+        try {
+            const resp = await fetch(`${WEIXIN_API_BASE}/ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(login.qrcode)}`, { headers: { "iLink-App-ClientVersion": "1" }, signal: AbortSignal.timeout(35_000) });
+            if (!resp.ok)
+                throw new Error(`Status poll failed: ${resp.status}`);
+            const data = await resp.json();
+            if (data.status === "confirmed" && data.ilink_bot_id) {
+                weixinLogins.delete(req.params.sessionKey);
+                // Save credentials to instance
+                try {
+                    instanceManager.saveWeixinCredentials(req.params.id, {
+                        accountId: data.ilink_bot_id,
+                        token: data.bot_token || "",
+                        baseUrl: data.baseurl || WEIXIN_API_BASE,
+                        userId: data.ilink_user_id || "",
+                    });
+                }
+                catch (e) {
+                    console.error(`[weixin-login] Failed to save credentials: ${e.message}`);
+                    return reply.status(500).send({
+                        status: "confirmed", connected: false,
+                        detail: "WeChat authenticated but failed to save credentials: " + e.message,
+                    });
+                }
+                return {
+                    status: "confirmed", connected: true,
+                    accountId: data.ilink_bot_id,
+                    message: "WeChat connected!",
+                };
+            }
+            if (data.status === "expired") {
+                // Auto-refresh QR
+                try {
+                    const refreshResp = await fetch(`${WEIXIN_API_BASE}/ilink/bot/get_bot_qrcode?bot_type=${WEIXIN_BOT_TYPE}`, { signal: AbortSignal.timeout(30_000) });
+                    if (refreshResp.ok) {
+                        const refreshData = await refreshResp.json();
+                        login.qrcode = refreshData.qrcode;
+                        login.qrcodeUrl = refreshData.qrcode_img_content;
+                        login.startedAt = Date.now();
+                        return {
+                            status: "refreshed", connected: false,
+                            qrcodeUrl: refreshData.qrcode_img_content,
+                            message: "QR code refreshed, please scan again.",
+                        };
+                    }
+                }
+                catch { /* fall through */ }
+                weixinLogins.delete(req.params.sessionKey);
+                return { status: "expired", connected: false, message: "QR code expired, please regenerate." };
+            }
+            return {
+                status: data.status, connected: false,
+                message: data.status === "scaned" ? "Scanned, please confirm on WeChat..." : "Waiting for scan...",
+            };
+        }
+        catch (e) {
+            return reply.status(502).send({ detail: e.message || "Status poll failed" });
+        }
+    });
+    // Usage
+    app.get("/api/instances/:id/usage", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        const inst = instanceManager.getInstance(req.params.id);
+        if (!inst)
+            return reply.status(404).send({ detail: "Instance not found" });
+        const openclawHome = instanceManager.getOpenclawHome(req.params.id);
+        const sessionsIndex = join(openclawHome, ".openclaw", "agents", "main", "sessions", "sessions.json");
+        const emptyTotals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, costTotal: 0, messages: 0 };
+        if (!existsSync(sessionsIndex))
+            return { sessions: [], totals: emptyTotals };
+        // Check file size before reading
+        const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
+        const indexStat = await stat(sessionsIndex);
+        if (indexStat.size > MAX_FILE_SIZE) {
+            return reply.status(400).send({ detail: "sessions.json exceeds 10MB size limit" });
+        }
+        let sessionsMap;
+        try {
+            const raw = await readFile(sessionsIndex, "utf-8");
+            sessionsMap = JSON.parse(raw);
+        }
+        catch {
+            return reply.status(500).send({ detail: "Failed to parse sessions.json" });
+        }
+        const sessions = [];
+        const totals = { ...emptyTotals };
+        for (const [sessionKey, sessionMeta] of Object.entries(sessionsMap)) {
+            const sessionFile = sessionMeta?.sessionFile;
+            if (!sessionFile || !existsSync(sessionFile))
+                continue;
+            // Prevent path traversal: sessionFile must be under the instance's openclaw home.
+            // Use realpathSync to resolve symlinks and prevent symlink-based bypasses.
+            try {
+                const resolvedSession = realpathSync(sessionFile);
+                const resolvedHome = realpathSync(openclawHome);
+                if (!resolvedSession.startsWith(resolvedHome + "/") && resolvedSession !== resolvedHome)
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            // Check session file size before reading
+            let sessionStat;
+            try {
+                sessionStat = await stat(sessionFile);
+            }
+            catch {
+                continue;
+            }
+            if (sessionStat.size > MAX_FILE_SIZE)
+                continue;
+            const sessionUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, costTotal: 0, messages: 0 };
+            let model = "";
+            let firstTs = "";
+            let lastTs = "";
+            const originLabel = sessionMeta?.origin?.label || "";
+            const channel = sessionMeta?.origin?.provider || "";
+            let sessionContent;
+            try {
+                sessionContent = await readFile(sessionFile, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            for (const line of sessionContent.split("\n")) {
+                let entry;
+                try {
+                    entry = JSON.parse(line.trim());
+                }
+                catch {
+                    continue;
+                }
+                if (entry.type !== "message")
+                    continue;
+                const msg = entry.message || {};
+                const ts = entry.timestamp || "";
+                if (ts && !firstTs)
+                    firstTs = ts;
+                if (ts)
+                    lastTs = ts;
+                if (msg.role === "assistant") {
+                    if (!model && msg.model)
+                        model = msg.model;
+                    const usage = msg.usage;
+                    if (usage) {
+                        sessionUsage.input += usage.input || 0;
+                        sessionUsage.output += usage.output || 0;
+                        sessionUsage.cacheRead += usage.cacheRead || 0;
+                        sessionUsage.cacheWrite += usage.cacheWrite || 0;
+                        sessionUsage.totalTokens += usage.totalTokens || 0;
+                        if (typeof usage.cost === "object")
+                            sessionUsage.costTotal += usage.cost.total || 0;
+                    }
+                    sessionUsage.messages++;
+                }
+                else if (msg.role === "user") {
+                    sessionUsage.messages++;
+                }
+            }
+            sessions.push({ key: sessionKey, model, channel, origin: originLabel, firstMessage: firstTs, lastMessage: lastTs, usage: sessionUsage });
+            for (const k of ["input", "output", "cacheRead", "cacheWrite", "totalTokens", "messages"]) {
+                totals[k] += sessionUsage[k];
+            }
+            totals.costTotal += sessionUsage.costTotal;
+        }
+        sessions.sort((a, b) => (b.lastMessage || "").localeCompare(a.lastMessage || ""));
+        return { sessions, totals };
+    });
+    // Logs
+    app.get("/api/instances/:id/logs", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        const svc = await getSvc();
+        if (!instanceManager.getInstance(req.params.id)) {
+            return reply.status(404).send({ detail: "Instance not found" });
+        }
+        const logType = req.query.log_type || "stderr";
+        if (logType !== "stdout" && logType !== "stderr") {
+            return reply.status(400).send({ detail: "log_type must be stdout or stderr" });
+        }
+        const MAX_LOG_LINES = 5000;
+        const lines = Math.min(parseInt(req.query.lines || "100", 10) || 100, MAX_LOG_LINES);
+        const logLines = await svc.getLogs(req.params.id, lines, logType);
+        return { lines: logLines };
+    });
+    // Admin: re-encrypt all instance secrets with current AES key
+    app.post("/api/admin/migrate-secrets", async (_req, reply) => {
+        const { getAesKey, getJwtSecret } = await import("../config.js");
+        const { scryptSync, createDecipheriv, createCipheriv, randomBytes } = await import("crypto");
+        const { readFileSync, writeFileSync, existsSync } = await import("fs");
+        const instances = instanceManager.listInstances();
+        const results = [];
+        const currentKey = getAesKey();
+        const legacyKey = scryptSync(getJwtSecret(), "jishushell-apikey-v1", 32);
+        for (const inst of instances) {
+            const envFiles = instanceManager.getRuntimeEnvFiles(inst.id);
+            const providerEnvFile = envFiles[0]?.replace(/model\.env$/, "provider.env");
+            if (!providerEnvFile || !existsSync(providerEnvFile)) {
+                results.push({ id: inst.id, status: "skipped", error: "no provider.env" });
+                continue;
+            }
+            const envContent = readFileSync(providerEnvFile, "utf-8");
+            const match = envContent.match(/UPSTREAM_API_KEY=(.+)/);
+            if (!match || !match[1]?.startsWith("enc:")) {
+                results.push({ id: inst.id, status: "skipped", error: "no encrypted key" });
+                continue;
+            }
+            const encrypted = match[1];
+            const raw = Buffer.from(encrypted.slice(4), "base64");
+            if (raw.length < 29) {
+                results.push({ id: inst.id, status: "error", error: "encrypted data too short" });
+                continue;
+            }
+            const iv = raw.subarray(0, 12);
+            const tag = raw.subarray(12, 28);
+            const ciphertext = raw.subarray(28);
+            // Try decrypt with current key first
+            let plaintext = null;
+            let needsReEncrypt = false;
+            try {
+                const d = createDecipheriv("aes-256-gcm", currentKey, iv);
+                d.setAuthTag(tag);
+                plaintext = d.update(ciphertext, undefined, "utf-8") + d.final("utf-8");
+                // Already encrypted with current key — no migration needed
+                results.push({ id: inst.id, status: "ok" });
+                continue;
+            }
+            catch {
+                // Current key failed — try legacy
+                needsReEncrypt = true;
+            }
+            if (needsReEncrypt) {
+                try {
+                    const d = createDecipheriv("aes-256-gcm", legacyKey, iv);
+                    d.setAuthTag(tag);
+                    plaintext = d.update(ciphertext, undefined, "utf-8") + d.final("utf-8");
+                }
+                catch {
+                    results.push({ id: inst.id, status: "error", error: "decrypt failed with both keys" });
+                    continue;
+                }
+                // Re-encrypt with current key
+                const newIv = randomBytes(12);
+                const c = createCipheriv("aes-256-gcm", currentKey, newIv);
+                const enc = Buffer.concat([c.update(plaintext, "utf-8"), c.final()]);
+                const newTag = c.getAuthTag();
+                const newEncrypted = "enc:" + Buffer.concat([newIv, newTag, enc]).toString("base64");
+                // Write back
+                const newContent = envContent.replace(/UPSTREAM_API_KEY=.+/, `UPSTREAM_API_KEY=${newEncrypted}`);
+                writeFileSync(providerEnvFile, newContent, { mode: 0o600 });
+                results.push({ id: inst.id, status: "migrated" });
+            }
+        }
+        // Invalidate proxy config cache for migrated instances
+        for (const r of results) {
+            if (r.status === "migrated")
+                llmProxy.invalidateConfigCache(r.id);
+        }
+        return { ok: true, results };
+    });
+    app.get("/api/instances/:id/gateway-launch", async (req, reply) => {
+        const idErr = validateId(req.params.id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        const inst = instanceManager.getInstance(req.params.id);
+        if (!inst)
+            return reply.status(404).send({ detail: "Instance not found" });
+        const panelOrigin = inferRequestOrigin(req);
+        if (panelOrigin) {
+            let addedAllowedOrigin = false;
+            try {
+                addedAllowedOrigin = ensureControlUiAllowedOrigin(req.params.id, panelOrigin);
+            }
+            catch (err) {
+                console.warn(`[gateway-launch] failed to add allowed origin for ${req.params.id}:`, err.message || err);
+            }
+            if (addedAllowedOrigin) {
+                await restartRunningInstanceForControlUiOrigin(req.params.id, panelOrigin);
+            }
+        }
+        const baseUrl = `/api/instances/${req.params.id}/gateway/`;
+        const cfg = instanceManager.getStoredConfig(req.params.id);
+        const token = cfg?.gateway?.auth?.token;
+        if (typeof token !== "string" || !token.trim()) {
+            return { url: baseUrl };
+        }
+        return { url: `${baseUrl}#token=${encodeURIComponent(token.trim())}` };
+    });
+    // Reverse-proxy to OpenClaw gateway web UI (gateway binds 127.0.0.1 only)
+    // NOTE: WebSocket upgrades are handled via server.on('upgrade') in server.ts
+    //       to avoid Fastify's HTTP lifecycle timeouts killing long-lived connections.
+    const gatewayProxy = async (request, reply) => {
+        const { id } = request.params;
+        const idErr = validateId(id);
+        if (idErr)
+            return reply.status(400).send({ detail: idErr });
+        const inst = instanceManager.getInstance(id);
+        if (!inst)
+            return reply.status(404).send({ detail: "Instance not found" });
+        const port = instanceManager.getGatewayPort(id);
+        const gwHost = await instanceManager.getGatewayHost(id);
+        const suffix = request.params["*"] || "";
+        const qs = request.url.includes("?") ? request.url.slice(request.url.indexOf("?")) : "";
+        // Raw HTTP proxy — stream the request body and preserve headers
+        const targetUrl = `http://${gwHost}:${port}/${suffix}${qs}`;
+        try {
+            // Build upstream headers: keep everything except hop-by-hop, rewrite host/origin
+            const fwdHeaders = {};
+            const rawHeaders = request.raw.headers;
+            for (const [k, v] of Object.entries(rawHeaders)) {
+                if (v === undefined)
+                    continue;
+                const lk = k.toLowerCase();
+                if (HOP_BY_HOP.has(lk) ||
+                    PROXY_IDENTITY_HEADERS.has(lk) ||
+                    lk === "host" ||
+                    // Strip panel auth credentials — do not leak to downstream OpenClaw gateway
+                    lk === "cookie" ||
+                    lk === "authorization")
+                    continue;
+                fwdHeaders[k] = Array.isArray(v) ? v.join(", ") : v;
+            }
+            fwdHeaders["host"] = `${gwHost}:${port}`;
+            // Request uncompressed responses — avoids having to decompress before HTML injection,
+            // and lets us stream non-HTML bodies without content-encoding mismatch.
+            fwdHeaders["accept-encoding"] = "identity";
+            // Use http.request for raw body streaming (avoids Fastify's parsed body)
+            const upstreamRes = await new Promise((resolve, reject) => {
+                const proxyReq = httpRequest(targetUrl, {
+                    method: request.method,
+                    headers: fwdHeaders,
+                }, resolve);
+                proxyReq.on("error", reject);
+                // Pipe the raw incoming body directly to the upstream
+                if (request.method !== "GET" && request.method !== "HEAD") {
+                    request.raw.pipe(proxyReq);
+                }
+                else {
+                    proxyReq.end();
+                }
+            });
+            reply.status(upstreamRes.statusCode || 502);
+            // Forward response headers — preserve most, rewrite security headers for iframe
+            for (const [k, v] of Object.entries(upstreamRes.headers)) {
+                if (v === undefined)
+                    continue;
+                const lk = k.toLowerCase();
+                if (HOP_BY_HOP.has(lk))
+                    continue;
+                if (lk === "x-frame-options") {
+                    reply.header("x-frame-options", "SAMEORIGIN");
+                    continue;
+                }
+                if (lk === "content-security-policy") {
+                    // Replace frame-ancestors directive, preserve the rest
+                    const csp = Array.isArray(v) ? v.join(", ") : v;
+                    const rewritten = csp.replace(/frame-ancestors\s+[^;]*/i, "frame-ancestors 'self'");
+                    reply.header("content-security-policy", rewritten === csp ? `${csp}; frame-ancestors 'self'` : rewritten);
+                    continue;
+                }
+                reply.header(k, Array.isArray(v) ? v.join(", ") : v);
+            }
+            // Rewrite control-ui-config.json to set basePath for proxied gateway
+            const respCt = upstreamRes.headers["content-type"] || "";
+            if (suffix === "__openclaw/control-ui-config.json" && respCt.includes("application/json")) {
+                const chunks = [];
+                for await (const chunk of upstreamRes)
+                    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                try {
+                    const config = JSON.parse(Buffer.concat(chunks).toString("utf-8"));
+                    config.basePath = `/api/instances/${id}/gateway`;
+                    const buf = Buffer.from(JSON.stringify(config));
+                    reply.header("content-length", buf.length);
+                    reply.removeHeader("content-encoding");
+                    return reply.send(buf);
+                }
+                catch { /* fall through to stream */ }
+            }
+            // For HTML responses: buffer to inject crypto shim + basePath
+            if (respCt.includes("text/html")) {
+                const chunks = [];
+                for await (const chunk of upstreamRes)
+                    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                let html = Buffer.concat(chunks).toString("utf-8");
+                const basePath = `/api/instances/${id}/gateway`;
+                const injectScript = [
+                    `window.__OPENCLAW_CONTROL_UI_BASE_PATH__=${JSON.stringify(basePath)};`,
+                    `(()=>{`,
+                    `  try {`,
+                    `    const settingsKey='openclaw.control.settings.v1';`,
+                    `    const tokenStoragePrefix='openclaw.control.token.v1:';`,
+                    `    const normalizeGatewayScope=(gatewayUrl)=>{`,
+                    `      const raw=(gatewayUrl||'').trim();`,
+                    `      if(!raw) return 'default';`,
+                    `      try {`,
+                    `        const base=\`\${window.location.protocol}//\${window.location.host}\${window.location.pathname||'/'}\`;`,
+                    `        const parsed=new URL(raw, base);`,
+                    `        const pathname=parsed.pathname==='/'?'':(parsed.pathname.replace(/\\/+$/,'')||parsed.pathname);`,
+                    `        return \`\${parsed.protocol}//\${parsed.host}\${pathname}\`;`,
+                    `      } catch {`,
+                    `        return raw;`,
+                    `      }`,
+                    `    };`,
+                    `    const proto=window.location.protocol==='https:'?'wss':'ws';`,
+                    `    const gatewayUrl=\`\${proto}://\${window.location.host}${basePath}\`;`,
+                    `    const tokenSessionKey=\`\${tokenStoragePrefix}\${normalizeGatewayScope(gatewayUrl)}\`;`,
+                    `    const raw=window.localStorage.getItem(settingsKey);`,
+                    `    let next={};`,
+                    `    try { next=raw ? JSON.parse(raw) : {}; } catch { next={}; }`,
+                    `    next.gatewayUrl=gatewayUrl;`,
+                    `    if('token' in next) delete next.token;`,
+                    `    const hashParams=new URLSearchParams(window.location.hash.startsWith('#')?window.location.hash.slice(1):window.location.hash);`,
+                    `    const searchParams=new URLSearchParams(window.location.search);`,
+                    `    const launchToken=(hashParams.get('token')||searchParams.get('token')||'').trim();`,
+                    `    if(launchToken){`,
+                    `      window.sessionStorage.setItem(tokenSessionKey, launchToken);`,
+                    `    }`,
+                    `    window.localStorage.setItem(settingsKey, JSON.stringify(next));`,
+                    `    const autoConnect=()=>{`,
+                    `      const attempt=()=>{`,
+                    `        const app=document.querySelector('openclaw-app');`,
+                    `        if(!app||typeof app.connect!=='function'||typeof app.applySettings!=='function'||!app.settings||typeof app.settings!=='object') return false;`,
+                    `        const sessionToken=(window.sessionStorage.getItem(tokenSessionKey)||'').trim();`,
+                    `        const token=(sessionToken||launchToken||app.settings.token||'').trim();`,
+                    `        if(!token) return false;`,
+                    `        const nextSettings={...app.settings, gatewayUrl, token};`,
+                    `        if(nextSettings.gatewayUrl!==app.settings.gatewayUrl||nextSettings.token!==app.settings.token){`,
+                    `          app.applySettings(nextSettings);`,
+                    `        }`,
+                    `        if(app.connected) return true;`,
+                    `        const wsState=app.client&&app.client.ws?app.client.ws.readyState:null;`,
+                    `        const connecting=wsState===0||wsState===1;`,
+                    `        if(!connecting){`,
+                    `          window.setTimeout(()=>{`,
+                    `            try { if(!app.connected) app.connect(); } catch {}`,
+                    `          }, 0);`,
+                    `        }`,
+                    `        return false;`,
+                    `      };`,
+                    `      const start=()=>{`,
+                    `        let tries=0;`,
+                    `        let timer=0;`,
+                    `        const tick=()=>{`,
+                    `          tries+=1;`,
+                    `          if(attempt()||tries>=120){`,
+                    `            window.clearInterval(timer);`,
+                    `          }`,
+                    `        };`,
+                    `        tick();`,
+                    `        timer=window.setInterval(()=>{`,
+                    `          tick();`,
+                    `        },500);`,
+                    `      };`,
+                    `      if(window.customElements&&typeof window.customElements.whenDefined==='function'){`,
+                    `        window.customElements.whenDefined('openclaw-app').then(start).catch(()=>{});`,
+                    `      }else{`,
+                    `        start();`,
+                    `      }`,
+                    `    };`,
+                    `    autoConnect();`,
+                    `  } catch {}`,
+                    `})();`,
+                ].join("");
+                const inject = `<script>${injectScript}</script>`;
+                // Append jishu-inject listener as a separate script tag (keeps CSP hash separate)
+                const injectCmdScript = [
+                    `(function(){`,
+                    `  var _jishuInject=function(cmd,send){`,
+                    `    // Primary path: use openclaw-app Lit component API directly.`,
+                    `    // app.chatMessage is the reactive property backing the textarea draft.`,
+                    `    // app.handleSendChat(cmd) invokes the component's own send handler.`,
+                    `    var app=document.querySelector('openclaw-app');`,
+                    `    if(!app)return false;`,
+                    `    if(send){`,
+                    `      // Only send when gateway WebSocket is connected`,
+                    `      if(!app.connected)return false;`,
+                    `      try{app.handleSendChat(cmd);return true;}catch(e){}`,
+                    `      return false;`,
+                    `    }else{`,
+                    `      // Draft-only: set reactive property so Lit re-renders the textarea`,
+                    `      try{app.chatMessage=cmd;return true;}catch(e){}`,
+                    `      return false;`,
+                    `    }`,
+                    `  };`,
+                    `  window.addEventListener('message',function(e){`,
+                    `    if(!e.data||e.data.type!=='jishu:inject-cmd')return;`,
+                    `    var cmd=e.data.cmd,send=!!e.data.send,tries=0;`,
+                    `    var poll=function(){if(_jishuInject(cmd,send)||++tries>=50)return;setTimeout(poll,200);};`,
+                    `    poll();`,
+                    `  },false);`,
+                    `})();`,
+                ].join("");
+                const injectCmdScriptHash = createHash("sha256").update(injectCmdScript, "utf8").digest("base64");
+                const fullHtmlInject = `${inject}<script>${injectCmdScript}</script>`;
+                html = html.replace(/<head\b[^>]*>/i, (match) => `${match}${fullHtmlInject}`);
+                const inlineScriptHash = createHash("sha256").update(injectScript, "utf8").digest("base64");
+                const cspHeader = reply.getHeader("content-security-policy");
+                if (typeof cspHeader === "string" && cspHeader) {
+                    const hashToken = `'sha256-${inlineScriptHash}'`;
+                    const hashToken2 = `'sha256-${injectCmdScriptHash}'`;
+                    const addHashes = (src) => {
+                        let s = src;
+                        if (!s.includes(hashToken))
+                            s = s + ` ${hashToken}`;
+                        if (!s.includes(hashToken2))
+                            s = s + ` ${hashToken2}`;
+                        return s;
+                    };
+                    const nextCsp = /\bscript-src\b/i.test(cspHeader)
+                        ? cspHeader.replace(/\bscript-src\b([^;]*)/i, (_m, value) => `script-src${addHashes(value)}`)
+                        : `${cspHeader}; script-src 'self' ${hashToken} ${hashToken2}`;
+                    reply.header("content-security-policy", nextCsp);
+                }
+                const buf = Buffer.from(html, "utf-8");
+                reply.header("cache-control", "no-store");
+                reply.header("content-length", buf.length);
+                reply.removeHeader("content-encoding");
+                return reply.send(buf);
+            }
+            // Non-HTML: stream response directly
+            return reply.send(upstreamRes);
+        }
+        catch (err) {
+            console.error(`[gateway-proxy] ${id}:`, err.message || err);
+            return reply.status(502).send({ detail: "Cannot reach OpenClaw gateway" });
+        }
+    };
+    app.all("/api/instances/:id/gateway/*", gatewayProxy);
+    app.all("/api/instances/:id/gateway", gatewayProxy);
+}
+//# sourceMappingURL=instances.js.map