@ozaiya/openclaw-channel 0.10.4 → 0.10.6

package/dist/src/gateway.js

@@ -24,6 +24,8 @@ import _sodium from "libsodium-wrappers";
 import { io as ioConnect } from "socket.io-client";
 import { decryptBox } from "./crypto.js";
 import { resolveOzaiyaSttConfig } from "./transcribeAudio.js";
+import * as desktop from "./desktopContainer.js";
+import { WeChatMonitorSession, getMonitor, getAllMonitors } from "./wechatMonitor.js";
 let sodiumReady = false;
 async function ensureSodium() {
     if (!sodiumReady) {
@@ -328,8 +330,10 @@ export async function startGatewayMode(options) {
             log?.warn(`[gateway] Socket.io connection error: ${String(err)}`);
             startPolling();
         });
-        // Sandbox browser VNC relay state — must be declared before update/rpc handlers
-        const sandboxConnections = new Map();
+        // Screen connections (VNC): both dockerWs and relayWs per channel
+        const screenConnections = new Map();
+        // PTY terminal connections (pty + dedicated relay WS)
+        const terminalConnections = new Map();
         socket.on("update", (payload) => {
             const body = payload?.body;
             if (!body?.t)
@@ -347,26 +351,7 @@ export async function startGatewayMode(options) {
                 }
                 onWebhookEvent(body.botId, webhookPayload);
             }
-            else if (body.t === "sandbox-screen-data" && body.channelId && body.data) {
-                // Server → Docker: relay VNC data from browser
-                const ws = sandboxConnections.get(body.channelId);
-                if (ws && ws.readyState === 1 /* OPEN */) {
-                    // Handle both Buffer (binary) and string (base64) formats
-                    const buf = Buffer.isBuffer(body.data) ? body.data : Buffer.from(body.data, "base64");
-                    ws.send(buf);
-                }
-            }
-            else if (body.t === "sandbox-screen-close" && body.channelId) {
-                // Server requests closing a sandbox screen channel
-                const ws = sandboxConnections.get(body.channelId);
-                if (ws) {
-                    sandboxConnections.delete(body.channelId);
-                    try {
-                        ws.close();
-                    }
-                    catch { /* ignore */ }
-                }
-            }
+            // Screen data/close events removed — screen data now flows via dedicated WS pipe
         });
         // Initialize file browser sandbox to stateDir
         const fileBrowser = await import("./fileBrowser.js");
@@ -375,99 +360,486 @@ export async function startGatewayMode(options) {
         const sock = socket; // capture non-null for use in callbacks
         socket.on("gateway-rpc", async (payload, ack) => {
             try {
-                if (payload.method === 'list-files') {
+                if (payload.method === 'list-screens') {
+                    const screens = [];
+                    if (desktop.isInContainer) {
+                        // In-container: if NOVNC_HOST is set, a separate browser container is reachable
+                        if (process.env.NOVNC_HOST) {
+                            screens.push({ id: 'local', type: 'sandbox', name: 'Browser' });
+                        }
+                    }
+                    else {
+                        // On host: detect sandbox browser via Docker
+                        try {
+                            const dockerEnvLocal = { ...process.env, PATH: `${process.env.PATH}:/usr/local/bin:/Applications/Docker.app/Contents/Resources/bin` };
+                            let containerId = '';
+                            try {
+                                containerId = execSync("docker ps -q --filter 'label=openclaw.sandboxBrowser=1' | head -1", { timeout: 5000, env: dockerEnvLocal }).toString().trim();
+                            }
+                            catch { /* ignore */ }
+                            if (!containerId) {
+                                try {
+                                    containerId = execSync("docker ps -q --filter 'name=sandbox-browser' | head -1", { timeout: 5000, env: dockerEnvLocal }).toString().trim();
+                                }
+                                catch { /* ignore */ }
+                            }
+                            if (containerId) {
+                                screens.push({ id: 'sandbox', type: 'sandbox', name: 'Browser Sandbox' });
+                            }
+                        }
+                        catch { /* ignore */ }
+                        // Desktop containers on host
+                        for (const c of desktop.listContainers()) {
+                            if (c.status.startsWith('Up') || c.status === 'running') {
+                                screens.push({ id: c.id, type: 'desktop', name: c.name.replace(/^ozaiya-desktop-/, '') });
+                            }
+                        }
+                    }
+                    ack({ ok: true, result: { screens } });
+                }
+                else if (payload.method === 'list-files') {
                     const files = await fileBrowser.listDirectory(payload.params.path ?? '.');
                     ack({ ok: true, result: files });
                 }
                 else if (payload.method === 'sandbox-screen-open') {
-                    // Open sandbox browser VNC relay — connect to Docker noVNC container
+                    // Open sandbox browser VNC relay — connect to Docker noVNC + relay WS back to server
                     const { channelId, botId } = payload.params;
                     log?.info(`[gateway] sandbox-screen-open channelId=${channelId} botId=${botId}`);
                     // Find the Docker sandbox container's noVNC port
                     let port;
-                    try {
-                        const dockerEnv = { ...process.env, PATH: `${process.env.PATH}:/usr/local/bin:/Applications/Docker.app/Contents/Resources/bin` };
-                        let output = '';
+                    if (desktop.isInContainer) {
+                        // In-container mode: connect to local noVNC
+                        port = process.env.NOVNC_PORT || '6080';
+                    }
+                    else
                         try {
-                            output = execSync("docker port $(docker ps -q --filter 'label=openclaw.sandboxBrowser=1' | head -1) 6080 2>/dev/null", { timeout: 5000, env: dockerEnv }).toString().trim();
+                            const dockerEnvLocal = { ...process.env, PATH: `${process.env.PATH}:/usr/local/bin:/Applications/Docker.app/Contents/Resources/bin` };
+                            let output = '';
+                            try {
+                                output = execSync("docker port $(docker ps -q --filter 'label=openclaw.sandboxBrowser=1' | head -1) 6080 2>/dev/null", { timeout: 5000, env: dockerEnvLocal }).toString().trim();
+                            }
+                            catch {
+                                output = execSync("docker port sandbox-browser 6080 2>/dev/null", { timeout: 5000, env: dockerEnvLocal }).toString().trim();
+                            }
+                            const lastLine = output.split('\n').pop() || output;
+                            port = lastLine.split(':').pop() || '6080';
                         }
                         catch {
-                            output = execSync("docker port sandbox-browser 6080 2>/dev/null", { timeout: 5000, env: dockerEnv }).toString().trim();
+                            log?.warn(`[gateway] sandbox-screen: no Docker sandbox container found`);
+                            ack({ ok: false, error: 'No Docker sandbox container found' });
+                            return;
                         }
-                        const lastLine = output.split('\n').pop() || output;
-                        port = lastLine.split(':').pop() || '6080';
-                    }
-                    catch {
-                        log?.warn(`[gateway] sandbox-screen: no Docker sandbox container found`);
-                        ack({ ok: false, error: 'No Docker sandbox container found' });
-                        return;
-                    }
                     // Connect to noVNC websockify in the Docker container
-                    let ws;
+                    const noVncHost = process.env.NOVNC_HOST || 'localhost';
+                    let dockerWs;
                     try {
                         const WsModule = await import("ws");
                         const WsCtor = WsModule.default ?? WsModule;
-                        ws = new WsCtor(`ws://localhost:${port}/websockify`);
-                        ws.binaryType = "arraybuffer";
+                        dockerWs = new WsCtor(`ws://${noVncHost}:${port}/websockify`);
+                        dockerWs.binaryType = "arraybuffer";
                     }
                     catch (err) {
                         log?.warn(`[gateway] sandbox-screen: failed to create WS: ${String(err)}`);
                         ack({ ok: false, error: `Failed to connect to noVNC: ${String(err)}` });
                         return;
                     }
-                    sandboxConnections.set(channelId, ws);
-                    ws.on("open", () => {
+                    // Open dedicated relay WS back to the server
+                    const relayUrl = `${apiBaseUrl.replace(/^http/, 'ws')}/v1/ws-relay/${channelId}/ws?token=${encodeURIComponent(gatewayToken)}`;
+                    let relayWs;
+                    try {
+                        const WsModule = await import("ws");
+                        const WsCtor = WsModule.default ?? WsModule;
+                        relayWs = new WsCtor(relayUrl);
+                    }
+                    catch (err) {
+                        log?.warn(`[gateway] sandbox-screen: failed to create relay WS: ${String(err)}`);
+                        try {
+                            dockerWs.close();
+                        }
+                        catch { /* ignore */ }
+                        ack({ ok: false, error: `Failed to connect relay WS: ${String(err)}` });
+                        return;
+                    }
+                    screenConnections.set(channelId, { dockerWs, relayWs });
+                    const cleanupScreen = (reason) => {
+                        const entry = screenConnections.get(channelId);
+                        if (!entry)
+                            return;
+                        screenConnections.delete(channelId);
+                        try {
+                            if (entry.dockerWs.readyState !== 3 /* CLOSED */)
+                                entry.dockerWs.close();
+                        }
+                        catch { /* ignore */ }
+                        try {
+                            if (entry.relayWs.readyState !== 3 /* CLOSED */)
+                                entry.relayWs.close();
+                        }
+                        catch { /* ignore */ }
+                        log?.info(`[gateway] sandbox-screen: closed channelId=${channelId} reason=${reason}`);
+                    };
+                    dockerWs.on("open", () => {
                         log?.info(`[gateway] sandbox-screen: connected to Docker noVNC on port ${port}`);
                     });
-                    // Docker → Server: relay VNC data (client→server emit always works)
-                    // Send raw Buffer — Socket.io handles binary natively (no base64 overhead)
-                    ws.on("message", (data) => {
-                        const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
-                        sock.volatile.emit("sandbox-screen-data", {
-                            channelId,
-                            data: buf,
-                        });
+                    // Buffer Docker messages until relay WS is open.
+                    // Docker noVNC sends the VNC handshake immediately on connect (local, fast),
+                    // but relay WS (over internet) may not be open yet. Without buffering, the
+                    // handshake is dropped and the VNC server times out waiting for a response.
+                    const earlyDockerMsgs = [];
+                    let relayOpen = false;
+                    relayWs.on("open", () => {
+                        log?.info(`[gateway] sandbox-screen: relay WS connected channelId=${channelId}`);
+                        relayOpen = true;
+                        for (const msg of earlyDockerMsgs) {
+                            if (relayWs.readyState === 1)
+                                relayWs.send(msg);
+                        }
+                        earlyDockerMsgs.length = 0;
                     });
-                    ws.on("close", () => {
-                        sandboxConnections.delete(channelId);
-                        sock.emit("sandbox-screen-close", { channelId });
-                        log?.info(`[gateway] sandbox-screen: Docker WS closed channelId=${channelId}`);
+                    // Raw binary pipe: Docker noVNC ↔ relay WS (server ↔ browser)
+                    dockerWs.on("message", (data) => {
+                        const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+                        if (relayOpen && relayWs.readyState === 1 /* OPEN */) {
+                            relayWs.send(buf);
+                        }
+                        else {
+                            earlyDockerMsgs.push(buf);
+                        }
                     });
-                    ws.on("error", (err) => {
-                        log?.warn(`[gateway] sandbox-screen: Docker WS error: ${String(err)}`);
-                        sandboxConnections.delete(channelId);
-                        sock.emit("sandbox-screen-close", { channelId });
+                    relayWs.on("message", (data) => {
+                        if (dockerWs.readyState === 1 /* OPEN */) {
+                            dockerWs.send(Buffer.isBuffer(data) ? data : Buffer.from(data));
+                        }
                     });
+                    dockerWs.on("close", () => cleanupScreen('docker-ws-close'));
+                    dockerWs.on("error", (err) => cleanupScreen(`docker-ws-error(${err.message})`));
+                    relayWs.on("close", () => cleanupScreen('relay-ws-close'));
+                    relayWs.on("error", (err) => cleanupScreen(`relay-ws-error(${err.message})`));
                     ack({ ok: true });
                 }
                 else if (payload.method === 'sandbox-screen-password') {
                     // Return VNC password from Docker container env (no WS connection)
                     let password = '';
+                    if (desktop.isInContainer) {
+                        password = process.env.VNC_PASSWORD || process.env.OPENCLAW_BROWSER_NOVNC_PASSWORD || '';
+                    }
+                    else
+                        try {
+                            const dockerEnvLocal = { ...process.env, PATH: `${process.env.PATH}:/usr/local/bin:/Applications/Docker.app/Contents/Resources/bin` };
+                            let containerId = '';
+                            try {
+                                containerId = execSync("docker ps -q --filter 'label=openclaw.sandboxBrowser=1' | head -1", { timeout: 5000, env: dockerEnvLocal }).toString().trim();
+                            }
+                            catch { /* ignore */ }
+                            if (!containerId) {
+                                try {
+                                    containerId = execSync("docker ps -q --filter 'name=sandbox-browser' | head -1", { timeout: 5000, env: dockerEnvLocal }).toString().trim();
+                                }
+                                catch { /* ignore */ }
+                            }
+                            if (containerId) {
+                                const envOutput = execSync(`docker inspect ${containerId} -f '{{range .Config.Env}}{{println .}}{{end}}'`, { timeout: 5000, env: dockerEnvLocal }).toString();
+                                for (const line of envOutput.split('\n')) {
+                                    if (line.startsWith('OPENCLAW_BROWSER_NOVNC_PASSWORD=')) {
+                                        password = line.slice('OPENCLAW_BROWSER_NOVNC_PASSWORD='.length).trim();
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        catch { /* ignore */ }
+                    ack({ ok: true, result: { password } });
+                    // ── Desktop container lifecycle ─────────────────────────────────────
+                }
+                else if (payload.method === 'desktop-container-create') {
+                    ack({ ok: true, result: desktop.createContainer(payload.params) });
+                }
+                else if (payload.method === 'desktop-container-list') {
+                    ack({ ok: true, result: desktop.listContainers() });
+                }
+                else if (payload.method === 'desktop-container-start') {
+                    ack({ ok: true, result: desktop.startContainer(payload.params.id) });
+                }
+                else if (payload.method === 'desktop-container-stop') {
+                    ack({ ok: true, result: desktop.stopContainer(payload.params.id) });
+                }
+                else if (payload.method === 'desktop-container-remove') {
+                    ack({ ok: true, result: desktop.removeContainer(payload.params.id) });
+                }
+                else if (payload.method === 'desktop-container-logs') {
+                    ack({ ok: true, result: { logs: desktop.getContainerLogs(payload.params.id, payload.params.tail) } });
+                }
+                else if (payload.method === 'desktop-container-launch-app') {
+                    ack({ ok: true, result: desktop.launchApp(payload.params.id, payload.params.app, payload.params.appArgs) });
+                    // ── Desktop AT-SPI proxy ────────────────────────────────────────────
+                }
+                else if (payload.method === 'desktop-atspi-health') {
+                    ack({ ok: true, result: desktop.atspiHealth(payload.params.agentPort) });
+                }
+                else if (payload.method === 'desktop-atspi-apps') {
+                    ack({ ok: true, result: desktop.atspiApps(payload.params.agentPort) });
+                }
+                else if (payload.method === 'desktop-atspi-tree') {
+                    ack({ ok: true, result: desktop.atspiTree(payload.params.agentPort, { app: payload.params.app, maxDepth: payload.params.maxDepth }) });
+                }
+                else if (payload.method === 'desktop-atspi-find') {
+                    const { agentPort, ...criteria } = payload.params;
+                    ack({ ok: true, result: desktop.atspiFind(agentPort, criteria) });
+                }
+                else if (payload.method === 'desktop-atspi-action') {
+                    ack({ ok: true, result: desktop.atspiAction(payload.params.agentPort, payload.params.path, payload.params.action) });
+                }
+                else if (payload.method === 'desktop-atspi-type') {
+                    ack({ ok: true, result: desktop.atspiType(payload.params.agentPort, payload.params.path, payload.params.text) });
+                }
+                else if (payload.method === 'desktop-atspi-key') {
+                    ack({ ok: true, result: desktop.atspiKey(payload.params.agentPort, payload.params.key, payload.params.modifiers) });
+                }
+                else if (payload.method === 'desktop-atspi-click') {
+                    ack({ ok: true, result: desktop.atspiClick(payload.params.agentPort, payload.params.x, payload.params.y, payload.params.button) });
+                }
+                else if (payload.method === 'desktop-atspi-screenshot') {
+                    ack({ ok: true, result: { data: desktop.atspiScreenshot(payload.params.agentPort, { bounds: payload.params.bounds, quality: payload.params.quality }) } });
+                    // ── Desktop screen VNC relay ────────────────────────────────────────
+                }
+                else if (payload.method === 'desktop-clipboard-type') {
+                    ack({ ok: true, result: desktop.clipboardType(payload.params.id, payload.params.text) });
+                }
+                else if (payload.method === 'desktop-xdotool-key') {
+                    ack({ ok: true, result: desktop.xdotoolKey(payload.params.id, payload.params.keys) });
+                }
+                else if (payload.method === 'desktop-screen-open') {
+                    const { channelId, containerId } = payload.params;
+                    log?.info(`[gateway] desktop-screen-open channelId=${channelId} containerId=${containerId}`);
+                    // Find the noVNC port for the desktop container
+                    const noVncPort = desktop.isInContainer
+                        ? parseInt(process.env.NOVNC_PORT || "6080", 10)
+                        : desktop.findContainerPort(containerId, 6080);
+                    if (!noVncPort) {
+                        ack({ ok: false, error: "Desktop container noVNC port not found" });
+                        return;
+                    }
+                    const noVncHost = process.env.NOVNC_HOST || 'localhost';
+                    let dockerWs;
+                    try {
+                        const WsModule = await import("ws");
+                        const WsCtor = WsModule.default ?? WsModule;
+                        dockerWs = new WsCtor(`ws://${noVncHost}:${noVncPort}/websockify`);
+                        dockerWs.binaryType = "arraybuffer";
+                    }
+                    catch (err) {
+                        ack({ ok: false, error: `Failed to connect to noVNC: ${String(err)}` });
+                        return;
+                    }
+                    // Open dedicated relay WS back to the server
+                    const desktopRelayUrl = `${apiBaseUrl.replace(/^http/, 'ws')}/v1/ws-relay/${channelId}/ws?token=${encodeURIComponent(gatewayToken)}`;
+                    let relayWs;
                     try {
-                        const dockerEnv = { ...process.env, PATH: `${process.env.PATH}:/usr/local/bin:/Applications/Docker.app/Contents/Resources/bin` };
-                        let containerId = '';
+                        const WsModule = await import("ws");
+                        const WsCtor = WsModule.default ?? WsModule;
+                        relayWs = new WsCtor(desktopRelayUrl);
+                    }
+                    catch (err) {
+                        try {
+                            dockerWs.close();
+                        }
+                        catch { /* ignore */ }
+                        ack({ ok: false, error: `Failed to connect relay WS: ${String(err)}` });
+                        return;
+                    }
+                    screenConnections.set(channelId, { dockerWs, relayWs });
+                    const cleanupDesktop = (reason) => {
+                        const entry = screenConnections.get(channelId);
+                        if (!entry)
+                            return;
+                        screenConnections.delete(channelId);
+                        try {
+                            if (entry.dockerWs.readyState !== 3 /* CLOSED */)
+                                entry.dockerWs.close();
+                        }
+                        catch { /* ignore */ }
                         try {
-                            containerId = execSync("docker ps -q --filter 'label=openclaw.sandboxBrowser=1' | head -1", { timeout: 5000, env: dockerEnv }).toString().trim();
+                            if (entry.relayWs.readyState !== 3 /* CLOSED */)
+                                entry.relayWs.close();
                         }
                         catch { /* ignore */ }
-                        if (!containerId) {
+                        log?.info(`[gateway] desktop-screen: closed channelId=${channelId} reason=${reason}`);
+                    };
+                    dockerWs.on("open", () => {
+                        log?.info(`[gateway] desktop-screen: connected to noVNC on port ${noVncPort}`);
+                    });
+                    // Buffer Docker messages until relay WS is open (same race fix as sandbox).
+                    const earlyDesktopMsgs = [];
+                    let desktopRelayOpen = false;
+                    relayWs.on("open", () => {
+                        log?.info(`[gateway] desktop-screen: relay WS connected channelId=${channelId}`);
+                        desktopRelayOpen = true;
+                        for (const msg of earlyDesktopMsgs) {
+                            if (relayWs.readyState === 1)
+                                relayWs.send(msg);
+                        }
+                        earlyDesktopMsgs.length = 0;
+                    });
+                    // Raw binary pipe: Docker noVNC ↔ relay WS (server ↔ browser)
+                    dockerWs.on("message", (data) => {
+                        const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+                        if (desktopRelayOpen && relayWs.readyState === 1 /* OPEN */) {
+                            relayWs.send(buf);
+                        }
+                        else {
+                            earlyDesktopMsgs.push(buf);
+                        }
+                    });
+                    relayWs.on("message", (data) => {
+                        if (dockerWs.readyState === 1 /* OPEN */) {
+                            dockerWs.send(Buffer.isBuffer(data) ? data : Buffer.from(data));
+                        }
+                    });
+                    dockerWs.on("close", () => cleanupDesktop('docker-ws-close'));
+                    dockerWs.on("error", (err) => cleanupDesktop(`docker-ws-error(${err.message})`));
+                    relayWs.on("close", () => cleanupDesktop('relay-ws-close'));
+                    relayWs.on("error", (err) => cleanupDesktop(`relay-ws-error(${err.message})`));
+                    ack({ ok: true });
+                }
+                else if (payload.method === 'desktop-screen-password') {
+                    const { containerId } = payload.params;
+                    ack({ ok: true, result: { password: desktop.getVncPassword(containerId) } });
+                    // ── Bot terminal PTY (dedicated WS pipe) ─────────────────────────────
+                }
+                else if (payload.method === 'bot-terminal-open') {
+                    const { channelId, containerId } = payload.params;
+                    log?.info(`[gateway] bot-terminal-open channelId=${channelId} containerId=${containerId ?? 'self'}`);
+                    try {
+                        const nodePty = await import("node-pty");
+                        const cols = 80;
+                        const rows = 24;
+                        const env = { TERM: 'xterm-256color', ...process.env };
+                        let ptyProcess;
+                        if (desktop.isInContainer) {
+                            ptyProcess = nodePty.spawn('/bin/bash', ['-l'], { cols, rows, cwd: '/', env });
+                        }
+                        else {
+                            const dockerEnvLocal = { ...env, PATH: `${process.env.PATH || ''}:/usr/local/bin:/Applications/Docker.app/Contents/Resources/bin` };
+                            let targetContainer = containerId;
+                            if (!targetContainer) {
+                                try {
+                                    targetContainer = execSync("docker ps -q --filter 'label=openclaw.sandboxBrowser=1' | head -1", { timeout: 5000, env: dockerEnvLocal }).toString().trim();
+                                }
+                                catch { /* ignore */ }
+                                if (!targetContainer) {
+                                    try {
+                                        targetContainer = execSync("docker ps -q --filter 'name=sandbox-browser' | head -1", { timeout: 5000, env: dockerEnvLocal }).toString().trim();
+                                    }
+                                    catch { /* ignore */ }
+                                }
+                            }
+                            if (!targetContainer) {
+                                ack({ ok: false, error: 'No Docker container found for terminal' });
+                                return;
+                            }
+                            ptyProcess = nodePty.spawn('docker', ['exec', '-it', targetContainer, '/bin/bash'], {
+                                cols, rows, cwd: '/', env: dockerEnvLocal,
+                            });
+                        }
+                        // Open dedicated WS back to the server relay endpoint
+                        const relayUrl = `${apiBaseUrl.replace(/^http/, 'ws')}/v1/ws-relay/${channelId}/ws?token=${encodeURIComponent(gatewayToken)}`;
+                        const WsModule = await import("ws");
+                        const WsCtor = WsModule.default ?? WsModule;
+                        const relayWs = new WsCtor(relayUrl);
+                        terminalConnections.set(channelId, { pty: ptyProcess, ws: relayWs });
+                        const cleanupTerminal = (reason) => {
+                            const entry = terminalConnections.get(channelId);
+                            if (!entry)
+                                return;
+                            terminalConnections.delete(channelId);
                             try {
-                                containerId = execSync("docker ps -q --filter 'name=sandbox-browser' | head -1", { timeout: 5000, env: dockerEnv }).toString().trim();
+                                entry.pty.kill();
                             }
                             catch { /* ignore */ }
-                        }
-                        if (containerId) {
-                            const envOutput = execSync(`docker inspect ${containerId} -f '{{range .Config.Env}}{{println .}}{{end}}'`, { timeout: 5000, env: dockerEnv }).toString();
-                            for (const line of envOutput.split('\n')) {
-                                if (line.startsWith('OPENCLAW_BROWSER_NOVNC_PASSWORD=')) {
-                                    password = line.slice('OPENCLAW_BROWSER_NOVNC_PASSWORD='.length).trim();
-                                    break;
+                            try {
+                                if (entry.ws.readyState !== 3 /* CLOSED */)
+                                    entry.ws.close();
+                            }
+                            catch { /* ignore */ }
+                            log?.info(`[gateway] bot-terminal: closed channelId=${channelId} reason=${reason}`);
+                        };
+                        relayWs.on("open", () => {
+                            log?.info(`[gateway] bot-terminal: relay WS connected channelId=${channelId}`);
+                        });
+                        // PTY → relay WS (binary)
+                        ptyProcess.onData((data) => {
+                            if (relayWs.readyState === 1 /* OPEN */) {
+                                relayWs.send(Buffer.from(data));
+                            }
+                        });
+                        // Relay WS → PTY (text input or JSON control messages)
+                        relayWs.on("message", (raw) => {
+                            const buf = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+                            const str = buf.toString();
+                            // Check for JSON control messages (resize)
+                            try {
+                                const msg = JSON.parse(str);
+                                if (msg.type === 'resize' && typeof msg.cols === 'number' && typeof msg.rows === 'number') {
+                                    ptyProcess.resize(msg.cols, msg.rows);
+                                    return;
                                 }
                             }
-                        }
+                            catch {
+                                // Not JSON — treat as terminal input
+                            }
+                            ptyProcess.write(str);
+                        });
+                        ptyProcess.onExit(({ exitCode }) => {
+                            // Send pty_exit control message before closing
+                            if (relayWs.readyState === 1 /* OPEN */) {
+                                relayWs.send(JSON.stringify({ type: 'pty_exit', exitCode }));
+                            }
+                            cleanupTerminal(`pty-exit(${exitCode})`);
+                        });
+                        relayWs.on("close", () => cleanupTerminal('relay-ws-close'));
+                        relayWs.on("error", (err) => cleanupTerminal(`relay-ws-error(${err.message})`));
+                        ack({ ok: true });
                     }
-                    catch { /* ignore */ }
-                    ack({ ok: true, result: { password } });
+                    catch (err) {
+                        log?.warn(`[gateway] bot-terminal-open failed: ${String(err)}`);
+                        ack({ ok: false, error: `Failed to open terminal: ${String(err)}` });
+                    }
+                    // ── WeChat monitor ──────────────────────────────────────────────────
+                }
+                else if (payload.method === 'wechat-monitor-start') {
+                    const { containerId, ...monitorConfig } = payload.params;
+                    const existing = getMonitor(containerId);
+                    if (existing) {
+                        ack({ ok: true, result: existing.getStatus() });
+                        return;
+                    }
+                    const monitor = new WeChatMonitorSession(containerId, {
+                        ...monitorConfig,
+                        onNewMessage: (event) => {
+                            sock.emit("wechat-monitor-event", event);
+                        },
+                        onError: (error) => {
+                            log?.warn(`[wechat-monitor] error: ${error.message}`);
+                        },
+                    }, log);
+                    await monitor.start();
+                    ack({ ok: true, result: monitor.getStatus() });
+                }
+                else if (payload.method === 'wechat-monitor-stop') {
+                    const { containerId } = payload.params;
+                    const monitor = getMonitor(containerId);
+                    if (monitor) {
+                        monitor.stop();
+                        ack({ ok: true, result: { stopped: true } });
+                    }
+                    else {
+                        ack({ ok: true, result: { stopped: false, reason: "not running" } });
+                    }
+                }
+                else if (payload.method === 'wechat-monitor-status') {
+                    const { containerId } = payload.params;
+                    const monitor = getMonitor(containerId);
+                    ack({ ok: true, result: monitor ? monitor.getStatus() : { running: false, containerId } });
                 }
                 else {
                     ack({ ok: false, error: `Unknown RPC method: ${payload.method}` });
@@ -477,15 +849,36 @@ export async function startGatewayMode(options) {
                 ack({ ok: false, error: err instanceof Error ? err.message : 'RPC handler error' });
             }
         });
-        // Clean up all sandbox connections on socket disconnect
+        // Clean up all screen connections, terminal connections, and monitors on socket disconnect
         sock.on("disconnect", () => {
-            for (const [, ws] of sandboxConnections) {
+            for (const [, entry] of screenConnections) {
+                try {
+                    if (entry.dockerWs.readyState !== 3)
+                        entry.dockerWs.close();
+                }
+                catch { /* ignore */ }
+                try {
+                    if (entry.relayWs.readyState !== 3)
+                        entry.relayWs.close();
+                }
+                catch { /* ignore */ }
+            }
+            screenConnections.clear();
+            for (const [, entry] of terminalConnections) {
                 try {
-                    ws.close();
+                    entry.pty.kill();
                 }
                 catch { /* ignore */ }
+                try {
+                    if (entry.ws.readyState !== 3)
+                        entry.ws.close();
+                }
+                catch { /* ignore */ }
+            }
+            terminalConnections.clear();
+            for (const [, monitor] of getAllMonitors()) {
+                monitor.stop();
             }
-            sandboxConnections.clear();
         });
     }
     catch (err) {