@mind2flow/daemon 0.1.0

package/dist/daemon.js

@@ -0,0 +1,1937 @@
+#!/usr/bin/env node
+/**
+ * Mind2Flow OpenClaw Daemon — main entry point.
+ *
+ * This is the bridge process that runs on the user's machine alongside
+ * their local OpenClaw Gateway instance. It:
+ *
+ *   1. Connects upstream to the Mind2Flow Command Center via WebSocket
+ *   2. Starts and manages the local OpenClaw Gateway subprocess
+ *   3. Connects locally to the Gateway's WS RPC (port 18789)
+ *   4. Bridges commands between Command Center ↔ Gateway
+ *   5. Sends periodic heartbeats with system info
+ *
+ * Usage:
+ *   m2f-daemon                         # uses config from ~/.m2f-daemon/config.json
+ *   m2f-daemon --token <install_token> # first-time registration
+ *
+ * Environment variables: see config.ts for M2F_* variables.
+ */
+import "dotenv/config";
+import { Command } from "commander";
+import { loadConfig, runtimeState } from "./config.js";
+import { CommandCenterClient } from "./command-center-client.js";
+import { GatewayClient } from "./gateway-client.js";
+import { OpenClawManager } from "./openclaw-manager.js";
+import { HeartbeatService } from "./heartbeat.js";
+import { createProtocol } from "./protocols/index.js";
+// ── CLI ────────────────────────────────────────────────────────────
+const program = new Command()
+    .name("m2f-daemon")
+    .description("Mind2Flow OpenClaw Command Center — Agent Daemon")
+    .version("0.1.0")
+    .option("--token <token>", "One-time install token for first registration")
+    .option("--server <url>", "Command Center WebSocket URL")
+    .option("--port <port>", "Local OpenClaw Gateway port", "18789")
+    .option("--protocol <type>", "Gateway wire protocol: openclaw or jsonrpc", "openclaw")
+    .option("--no-gateway", "Do not auto-start the OpenClaw Gateway")
+    .option("--debug", "Enable debug logging")
+    .parse(process.argv);
+const opts = program.opts();
+// ── Bootstrap ──────────────────────────────────────────────────────
+async function main() {
+    const config = loadConfig();
+    // CLI overrides
+    if (opts.server)
+        config.serverUrl = opts.server;
+    if (opts.port)
+        config.gatewayPort = parseInt(opts.port, 10);
+    if (opts.protocol)
+        config.gatewayProtocol = opts.protocol;
+    if (opts.gateway === false)
+        config.autoStartGateway = false;
+    if (opts.debug)
+        config.logLevel = "debug";
+    // TODO: handle --token for first-time registration flow
+    // For now, require instanceId and apiKey to be already set
+    if (!config.instanceId || !config.apiKey) {
+        if (opts.token) {
+            log("info", "Registration with install token is not yet implemented.");
+            log("info", "Set M2F_INSTANCE_ID and M2F_API_KEY environment variables or edit ~/.m2f-daemon/config.json");
+            process.exit(1);
+        }
+        log("error", "Missing instanceId or apiKey. Run with --token <token> to register, or set environment variables.");
+        process.exit(1);
+    }
+    log("info", "╔════════════════════════════════════════════╗");
+    log("info", "║   Mind2Flow OpenClaw Daemon v0.1.0        ║");
+    log("info", "╚════════════════════════════════════════════╝");
+    log("info", `Instance: ${config.instanceId}`);
+    log("info", `Server:   ${config.serverUrl}`);
+    log("info", `Gateway:  ws://127.0.0.1:${config.gatewayPort}`);
+    log("info", `Protocol: ${config.gatewayProtocol}`);
+    // ── Initialize components ────────────────────────────────────
+    const protocol = createProtocol(config.gatewayProtocol);
+    const ccClient = new CommandCenterClient(config);
+    const gwClient = new GatewayClient(config.gatewayPort, protocol, config.logLevel);
+    const ocManager = new OpenClawManager({
+        port: config.gatewayPort,
+        openclawBin: config.openclawBin,
+        logLevel: config.logLevel,
+    });
+    const heartbeat = new HeartbeatService(ccClient, gwClient, ocManager, config.heartbeatIntervalMs, config.logLevel);
+    // ── OpenClaw Gateway lifecycle ───────────────────────────────
+    if (config.autoStartGateway) {
+        ocManager.on("started", () => {
+            log("info", "OpenClaw Gateway started — connecting RPC client…");
+            runtimeState.gatewayPid = ocManager.pid;
+            // Give the Gateway a moment to initialize its WS server
+            setTimeout(() => gwClient.connect(), 3_000);
+        });
+        ocManager.on("exited", () => {
+            runtimeState.gatewayPid = null;
+            runtimeState.gatewayReady = false;
+        });
+        await ocManager.start();
+    }
+    else {
+        // User-managed Gateway — connect directly
+        gwClient.connect();
+    }
+    gwClient.on("connected", () => {
+        runtimeState.gatewayReady = true;
+        log("info", "Gateway RPC ready");
+    });
+    gwClient.on("disconnected", () => {
+        runtimeState.gatewayReady = false;
+    });
+    // ── Command Center connection ────────────────────────────────
+    ccClient.on("connected", () => {
+        runtimeState.connected = true;
+        heartbeat.start();
+        heartbeat.sendSystemInfo();
+    });
+    ccClient.on("disconnected", () => {
+        runtimeState.connected = false;
+        heartbeat.stop();
+    });
+    ccClient.on("message", (msg) => {
+        handleServerMessage(msg, config, ccClient, gwClient, ocManager);
+    });
+    // Connect to Command Center
+    ccClient.connect();
+    // ── Graceful shutdown ────────────────────────────────────────
+    const shutdown = async (signal) => {
+        log("info", `Received ${signal} — shutting down…`);
+        heartbeat.stop();
+        ccClient.disconnect();
+        gwClient.disconnect();
+        await ocManager.stop();
+        // Clear LLM keys from memory
+        runtimeState.llmConfig = null;
+        log("info", "Daemon stopped.");
+        process.exit(0);
+    };
+    process.on("SIGINT", () => shutdown("SIGINT"));
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+    // Keep process alive
+    await new Promise(() => { });
+}
+// ── Message handler ────────────────────────────────────────────────
+async function handleServerMessage(msg, config, ccClient, gwClient, ocManager) {
+    switch (msg.type) {
+        // ── Chat instruction from user ──────────────────────────────
+        case "chat_instruction": {
+            const messageId = msg.message_id;
+            const content = msg.content;
+            const userId = msg.user_id;
+            const sessionId = msg.session_id || undefined;
+            log("info", `Chat instruction received (msg=${messageId}${sessionId ? `, session=${sessionId}` : ''}): ${content.slice(0, 80)}…`);
+            if (!gwClient.isConnected) {
+                ccClient.send({
+                    type: "chat_response",
+                    ref_message_id: messageId,
+                    user_id: userId,
+                    content: "⚠️ OpenClaw Gateway is not connected. Please wait or check the instance status.",
+                });
+                return;
+            }
+            try {
+                // Call the OpenClaw agent via its RPC — pass sessionId if targeting a specific session
+                const agentOpts = {};
+                if (sessionId)
+                    agentOpts.sessionId = sessionId;
+                const result = await gwClient.agent(content, Object.keys(agentOpts).length ? agentOpts : undefined);
+                const fullText = typeof result === "string" ? result : JSON.stringify(result);
+                // Stream tokens back in chunks for real-time UI feel
+                const CHUNK_SIZE = 12; // characters per chunk
+                for (let i = 0; i < fullText.length; i += CHUNK_SIZE) {
+                    const token = fullText.slice(i, i + CHUNK_SIZE);
+                    const done = i + CHUNK_SIZE >= fullText.length;
+                    ccClient.send({
+                        type: "chat_stream",
+                        ref_message_id: messageId,
+                        user_id: userId,
+                        token,
+                        done,
+                    });
+                    // Small delay to feel natural (~30ms per chunk)
+                    if (!done)
+                        await new Promise(r => setTimeout(r, 30));
+                }
+                // Also send the final complete response for DB persistence
+                ccClient.send({
+                    type: "chat_response",
+                    ref_message_id: messageId,
+                    user_id: userId,
+                    content: fullText,
+                });
+            }
+            catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                log("error", `Agent RPC failed: ${errMsg}`);
+                ccClient.send({
+                    type: "chat_response",
+                    ref_message_id: messageId,
+                    user_id: userId,
+                    content: `❌ Agent error: ${errMsg}`,
+                });
+            }
+            break;
+        }
+        // ── Execute a predefined task ───────────────────────────────
+        case "execute_task": {
+            const executionId = msg.execution_id;
+            const taskConfig = msg.task_config;
+            const userId = msg.user_id;
+            log("info", `Executing task (execution=${executionId})`);
+            if (!gwClient.isConnected) {
+                ccClient.send({
+                    type: "task_result",
+                    execution_id: executionId,
+                    user_id: userId,
+                    status: "failed",
+                    error: "OpenClaw Gateway is not connected",
+                });
+                return;
+            }
+            try {
+                const prompt = taskConfig.prompt || "";
+                const result = await gwClient.agent(prompt);
+                ccClient.send({
+                    type: "task_result",
+                    execution_id: executionId,
+                    user_id: userId,
+                    status: "completed",
+                    output: result,
+                });
+            }
+            catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                ccClient.send({
+                    type: "task_result",
+                    execution_id: executionId,
+                    user_id: userId,
+                    status: "failed",
+                    error: errMsg,
+                });
+            }
+            break;
+        }
+        // ── Update LLM configuration ────────────────────────────────
+        case "update_llm_config": {
+            const llmConfig = {
+                provider: msg.llm_provider,
+                apiKey: msg.llm_api_key,
+                model: msg.llm_model,
+                baseUrl: msg.base_url,
+                temperature: msg.temperature,
+                maxTokens: msg.max_tokens,
+            };
+            log("info", `LLM config update: provider=${llmConfig.provider} model=${llmConfig.model}`);
+            // Store in runtime memory only (never on disk)
+            runtimeState.llmConfig = llmConfig;
+            // Set environment variables for the Gateway process
+            ocManager.applyLLMConfig(llmConfig);
+            // If Gateway is connected, patch config via RPC
+            if (gwClient.isConnected) {
+                try {
+                    const current = await gwClient.configGet();
+                    const configRaw = `{ agent: { model: "${llmConfig.provider}/${llmConfig.model}" } }`;
+                    await gwClient.configPatch(configRaw, current.hash);
+                    log("info", "Gateway LLM config patched successfully");
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to patch Gateway config (will apply on restart): ${errMsg}`);
+                    // Restart Gateway so it picks up env vars
+                    await ocManager.restart();
+                }
+            }
+            else {
+                // Gateway not connected — restart it with new env vars
+                log("info", "Gateway not connected — restarting with new LLM config…");
+                await ocManager.restart();
+            }
+            break;
+        }
+        // ── Gateway Config management ─────────────────────────────────
+        case "config_get": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            log("info", "Gateway config get requested");
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.configGet();
+                    ccClient.send({
+                        type: "config_get_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        config: result.config,
+                        hash: result.hash,
+                    });
+                    log("info", "Gateway config retrieved");
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to get config: ${errMsg}`);
+                    ccClient.send({
+                        type: "config_get_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "config_get_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "config_patch": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const raw = msg.raw;
+            const baseHash = msg.base_hash;
+            log("info", `Gateway config patch (hash=${baseHash?.slice(0, 8)}…)`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.configPatch(raw, baseHash);
+                    ccClient.send({
+                        type: "config_patch_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        result,
+                    });
+                    log("info", "Gateway config patched successfully");
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to patch config: ${errMsg}`);
+                    ccClient.send({
+                        type: "config_patch_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "config_patch_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "config_export": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            log("info", "Gateway config export requested (via config.get raw)");
+            if (gwClient.isConnected) {
+                try {
+                    // config.get returns { config, raw, hash } — use raw field as export
+                    const result = await gwClient.configExport();
+                    const r = result;
+                    ccClient.send({
+                        type: "config_export_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        exported: r.raw ?? JSON.stringify(r.config ?? {}, null, 2),
+                    });
+                    log("info", "Gateway config exported");
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to export config: ${errMsg}`);
+                    ccClient.send({
+                        type: "config_export_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "config_export_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "config_validate": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const raw = msg.raw;
+            log("info", "Gateway config validate requested");
+            if (gwClient.isConnected) {
+                try {
+                    // Gateway has no explicit validate method.
+                    // We use config.set with the raw config — if it fails validation,
+                    // the gateway returns an error with issues. If it succeeds, the config
+                    // is written. To avoid side effects, we do a client-side JSON parse check.
+                    // For now, try JSON parse and report basic validity.
+                    let valid = true;
+                    const errors = [];
+                    try {
+                        JSON.parse(raw);
+                    }
+                    catch (parseErr) {
+                        valid = false;
+                        errors.push(parseErr instanceof Error ? parseErr.message : String(parseErr));
+                    }
+                    ccClient.send({
+                        type: "config_validate_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        validation: { valid, errors },
+                    });
+                    log("info", "Gateway config validated (client-side)");
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to validate config: ${errMsg}`);
+                    ccClient.send({
+                        type: "config_validate_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "config_validate_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "config_diff": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const proposed = msg.proposed;
+            log("info", "Gateway config diff requested");
+            if (gwClient.isConnected) {
+                try {
+                    // Gateway has no explicit diff method.
+                    // Get current config and compute a basic diff client-side.
+                    const current = await gwClient.configGet();
+                    const currentRaw = current.raw ?? JSON.stringify(current.config ?? {}, null, 2);
+                    const changed = currentRaw.trim() !== proposed.trim();
+                    ccClient.send({
+                        type: "config_diff_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        diff: {
+                            changed,
+                            currentLength: currentRaw.length,
+                            proposedLength: proposed.length,
+                        },
+                    });
+                    log("info", "Gateway config diff computed (client-side)");
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to compute config diff: ${errMsg}`);
+                    ccClient.send({
+                        type: "config_diff_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "config_diff_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        // ── Skills management ─────────────────────────────────────────
+        case "skills_status": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            log("info", "Skills status requested");
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.skillsStatus();
+                    ccClient.send({
+                        type: "skills_status_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        skills: result,
+                    });
+                    log("info", "Skills status fetched from Gateway");
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to get skills status: ${errMsg}`);
+                    ccClient.send({
+                        type: "skills_status_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "skills_status_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "skill_update": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const skillKey = msg.skill_key;
+            const updates = msg.updates;
+            log("info", `Skill update: key=${skillKey}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.skillsUpdate(skillKey, updates);
+                    ccClient.send({
+                        type: "skill_update_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        skill_key: skillKey,
+                        result,
+                    });
+                    log("info", `Skill ${skillKey} updated`);
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to update skill ${skillKey}: ${errMsg}`);
+                    ccClient.send({
+                        type: "skill_update_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        skill_key: skillKey,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "skill_update_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    skill_key: skillKey,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "skill_install": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const skillKey = msg.skill_key;
+            const installOptionId = msg.install_option_id;
+            log("info", `Skill install: key=${skillKey} option=${installOptionId || "default"}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.skillsInstall(skillKey, installOptionId);
+                    ccClient.send({
+                        type: "skill_install_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        skill_key: skillKey,
+                        result,
+                    });
+                    log("info", `Skill ${skillKey} dependencies installed`);
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to install skill ${skillKey}: ${errMsg}`);
+                    ccClient.send({
+                        type: "skill_install_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        skill_key: skillKey,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "skill_install_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    skill_key: skillKey,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "skills_bins": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            log("info", "Skills bins requested");
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.skillsBins();
+                    ccClient.send({
+                        type: "skills_bins_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        bins: result,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    ccClient.send({
+                        type: "skills_bins_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "skills_bins_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        // ── Cron Jobs management ──────────────────────────────────────
+        case "cron_list": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            log("info", "Cron jobs list requested");
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.cronList();
+                    ccClient.send({
+                        type: "cron_list_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        jobs: result,
+                    });
+                    log("info", "Cron jobs listed");
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to list cron jobs: ${errMsg}`);
+                    ccClient.send({
+                        type: "cron_list_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "cron_list_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "cron_add": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const job = msg.job;
+            log("info", `Cron job add: ${job?.name || "unnamed"}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.cronAdd(job);
+                    ccClient.send({
+                        type: "cron_add_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        result,
+                    });
+                    log("info", "Cron job added");
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to add cron job: ${errMsg}`);
+                    ccClient.send({
+                        type: "cron_add_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "cron_add_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "cron_update": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const jobId = msg.job_id;
+            const patch = msg.patch;
+            log("info", `Cron job update: ${jobId}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.cronUpdate(jobId, patch);
+                    ccClient.send({
+                        type: "cron_update_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        job_id: jobId,
+                        result,
+                    });
+                    log("info", `Cron job ${jobId} updated`);
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to update cron job ${jobId}: ${errMsg}`);
+                    ccClient.send({
+                        type: "cron_update_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        job_id: jobId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "cron_update_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    job_id: jobId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "cron_remove": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const jobId = msg.job_id;
+            log("info", `Cron job remove: ${jobId}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.cronRemove(jobId);
+                    ccClient.send({
+                        type: "cron_remove_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        job_id: jobId,
+                        result,
+                    });
+                    log("info", `Cron job ${jobId} removed`);
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to remove cron job ${jobId}: ${errMsg}`);
+                    ccClient.send({
+                        type: "cron_remove_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        job_id: jobId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "cron_remove_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    job_id: jobId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "cron_run": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const jobId = msg.job_id;
+            const mode = msg.mode;
+            log("info", `Cron job manual run: ${jobId} mode=${mode || "force"}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.cronRun(jobId, mode);
+                    ccClient.send({
+                        type: "cron_run_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        job_id: jobId,
+                        result,
+                    });
+                    log("info", `Cron job ${jobId} triggered`);
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to run cron job ${jobId}: ${errMsg}`);
+                    ccClient.send({
+                        type: "cron_run_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        job_id: jobId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "cron_run_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    job_id: jobId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "cron_runs": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const jobId = msg.job_id;
+            const limit = msg.limit;
+            log("info", `Cron job runs history: ${jobId}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.cronRuns(jobId, limit);
+                    ccClient.send({
+                        type: "cron_runs_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        job_id: jobId,
+                        runs: result,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    ccClient.send({
+                        type: "cron_runs_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        job_id: jobId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "cron_runs_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    job_id: jobId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "cron_status": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            log("info", "Cron scheduler status requested");
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.cronStatus();
+                    ccClient.send({
+                        type: "cron_status_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        status: result,
+                    });
+                    log("info", "Cron scheduler status retrieved");
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to get cron status: ${errMsg}`);
+                    ccClient.send({
+                        type: "cron_status_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "cron_status_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "cron_toggle": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const enabled = msg.enabled;
+            log("info", `Cron scheduler toggle: enabled=${enabled}`);
+            if (gwClient.isConnected) {
+                try {
+                    // Gateway has no native cron.toggle RPC.
+                    // Toggle via config.patch to set cron.enabled.
+                    const result = await gwClient.cronToggle(enabled);
+                    ccClient.send({
+                        type: "cron_toggle_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        result: { ok: true, enabled },
+                    });
+                    log("info", `Cron scheduler toggled to ${enabled ? "enabled" : "paused"} via config.patch`);
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to toggle cron: ${errMsg}`);
+                    ccClient.send({
+                        type: "cron_toggle_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "cron_toggle_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        // ── Usage / Token Tracking ──────────────────────────────────
+        case "usage_current": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            log("info", "Usage current snapshot requested");
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.usageStatus();
+                    ccClient.send({
+                        type: "usage_current_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        usage: result,
+                    });
+                    log("info", "Usage current retrieved");
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to get usage: ${errMsg}`);
+                    ccClient.send({
+                        type: "usage_current_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "usage_current_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "usage_history": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const days = msg.days;
+            const granularity = msg.granularity;
+            log("info", `Usage history requested (days=${days ?? 30}, granularity=${granularity ?? "daily"})`);
+            if (gwClient.isConnected) {
+                try {
+                    const opts = {};
+                    if (days !== undefined)
+                        opts.days = days;
+                    if (granularity)
+                        opts.granularity = granularity;
+                    const result = await gwClient.usageCost(Object.keys(opts).length ? opts : undefined);
+                    ccClient.send({
+                        type: "usage_history_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        history: result,
+                    });
+                    log("info", "Usage history retrieved");
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to get usage history: ${errMsg}`);
+                    ccClient.send({
+                        type: "usage_history_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "usage_history_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        // ── Channels management ─────────────────────────────────────
+        case "channels_status": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const probe = msg.probe;
+            const timeoutMs = msg.timeout_ms;
+            log("info", `Channels status requested (probe=${probe ?? false})`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.channelsStatus(probe, timeoutMs);
+                    ccClient.send({
+                        type: "channels_status_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        channels: result,
+                    });
+                    log("info", "Channels status retrieved");
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to get channels status: ${errMsg}`);
+                    ccClient.send({
+                        type: "channels_status_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "channels_status_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "channels_logout": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const channel = msg.channel;
+            const accountId = msg.account_id;
+            log("info", `Channel logout: channel=${channel} accountId=${accountId || "default"}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.channelsLogout(channel, accountId);
+                    ccClient.send({
+                        type: "channels_logout_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        channel,
+                        result,
+                    });
+                    log("info", `Channel ${channel} logged out`);
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to logout channel ${channel}: ${errMsg}`);
+                    ccClient.send({
+                        type: "channels_logout_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        channel,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "channels_logout_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    channel,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "web_login_start": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const force = msg.force;
+            const timeoutMs = msg.timeout_ms;
+            const accountId = msg.account_id;
+            log("info", `WhatsApp web login start (force=${force ?? false})`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.webLoginStart({
+                        force,
+                        timeoutMs,
+                        accountId,
+                    });
+                    ccClient.send({
+                        type: "web_login_start_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        result,
+                    });
+                    log("info", "WhatsApp web login started — QR generated");
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to start web login: ${errMsg}`);
+                    ccClient.send({
+                        type: "web_login_start_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "web_login_start_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "web_login_wait": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const timeoutMs = msg.timeout_ms;
+            const accountId = msg.account_id;
+            log("info", "WhatsApp web login wait…");
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.webLoginWait(timeoutMs, accountId);
+                    ccClient.send({
+                        type: "web_login_wait_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        result,
+                    });
+                    log("info", "WhatsApp web login completed");
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `WhatsApp web login wait failed: ${errMsg}`);
+                    ccClient.send({
+                        type: "web_login_wait_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "web_login_wait_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "channels_configure": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const patch = msg.patch;
+            log("info", "Channels configure via config.patch");
+            if (gwClient.isConnected) {
+                try {
+                    // Two-step: get current config → apply patch → save
+                    const { config: rawConfig, hash } = await gwClient.configGet();
+                    let parsed;
+                    if (typeof rawConfig === "string") {
+                        parsed = JSON.parse(rawConfig);
+                    }
+                    else {
+                        parsed = (rawConfig ?? {});
+                    }
+                    // Deep-merge patch into parsed config
+                    for (const [key, value] of Object.entries(patch)) {
+                        if (typeof value === "object" && value !== null && !Array.isArray(value) &&
+                            typeof parsed[key] === "object" && parsed[key] !== null) {
+                            parsed[key] = { ...parsed[key], ...value };
+                        }
+                        else {
+                            parsed[key] = value;
+                        }
+                    }
+                    const result = await gwClient.configPatch(JSON.stringify(parsed, null, 2), hash);
+                    ccClient.send({
+                        type: "channels_configure_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        result,
+                    });
+                    log("info", "Channel configuration applied");
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Failed to configure channel: ${errMsg}`);
+                    ccClient.send({
+                        type: "channels_configure_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "channels_configure_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        // ── Sessions management ─────────────────────────────────────
+        case "sessions_list": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            log("info", "Sessions list requested");
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.sessionsList();
+                    ccClient.send({
+                        type: "sessions_list_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        sessions: result,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Sessions list failed: ${errMsg}`);
+                    ccClient.send({
+                        type: "sessions_list_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "sessions_list_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "sessions_kill": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const sessionId = msg.session_id;
+            log("info", `Session kill: session=${sessionId}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.sessionsKill(sessionId);
+                    ccClient.send({
+                        type: "sessions_kill_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        result,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Session kill failed: ${errMsg}`);
+                    ccClient.send({
+                        type: "sessions_kill_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "sessions_kill_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "sessions_preview": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const sessionId = msg.session_id;
+            log("info", `Session preview: session=${sessionId}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.sessionsPreview(sessionId);
+                    ccClient.send({
+                        type: "sessions_preview_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        result,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Session preview failed: ${errMsg}`);
+                    ccClient.send({
+                        type: "sessions_preview_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "sessions_preview_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "sessions_patch": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const sessionId = msg.session_id;
+            const patch = msg.patch;
+            log("info", `Session patch: session=${sessionId}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.sessionsPatch(sessionId, patch);
+                    ccClient.send({
+                        type: "sessions_patch_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        result,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Session patch failed: ${errMsg}`);
+                    ccClient.send({
+                        type: "sessions_patch_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "sessions_patch_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "sessions_reset": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const sessionId = msg.session_id;
+            log("info", `Session reset: session=${sessionId}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.sessionsReset(sessionId);
+                    ccClient.send({
+                        type: "sessions_reset_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        result,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Session reset failed: ${errMsg}`);
+                    ccClient.send({
+                        type: "sessions_reset_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "sessions_reset_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "sessions_delete": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const sessionId = msg.session_id;
+            log("info", `Session delete: session=${sessionId}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.sessionsDelete(sessionId);
+                    ccClient.send({
+                        type: "sessions_delete_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        result,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Session delete failed: ${errMsg}`);
+                    ccClient.send({
+                        type: "sessions_delete_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "sessions_delete_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "sessions_compact": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const sessionId = msg.session_id;
+            log("info", `Session compact: session=${sessionId}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.sessionsCompact(sessionId);
+                    ccClient.send({
+                        type: "sessions_compact_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        result,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Session compact failed: ${errMsg}`);
+                    ccClient.send({
+                        type: "sessions_compact_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "sessions_compact_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        // ── Models ──────────────────────────────────────────────────
+        case "models_list": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            log("info", "Models list requested");
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.modelsList();
+                    ccClient.send({
+                        type: "models_list_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        models: result,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Models list failed: ${errMsg}`);
+                    ccClient.send({
+                        type: "models_list_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "models_list_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        // ── Agents (gateway) management ─────────────────────────────
+        case "agents_gw_list": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            log("info", "Agents list requested");
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.agentsList();
+                    ccClient.send({
+                        type: "agents_gw_list_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        agents: result,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Agents list failed: ${errMsg}`);
+                    ccClient.send({
+                        type: "agents_gw_list_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "agents_gw_list_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "agents_gw_create": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const config = msg.config;
+            log("info", "Agent create requested");
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.agentsCreate(config);
+                    ccClient.send({
+                        type: "agents_gw_create_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        result,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Agent create failed: ${errMsg}`);
+                    ccClient.send({
+                        type: "agents_gw_create_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "agents_gw_create_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "agents_gw_update": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const agentId = msg.agent_id;
+            const patch = msg.patch;
+            log("info", `Agent update: agent=${agentId}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.agentsUpdate(agentId, patch);
+                    ccClient.send({
+                        type: "agents_gw_update_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        result,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Agent update failed: ${errMsg}`);
+                    ccClient.send({
+                        type: "agents_gw_update_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "agents_gw_update_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "agents_gw_delete": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const agentId = msg.agent_id;
+            log("info", `Agent delete: agent=${agentId}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.agentsDelete(agentId);
+                    ccClient.send({
+                        type: "agents_gw_delete_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        result,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Agent delete failed: ${errMsg}`);
+                    ccClient.send({
+                        type: "agents_gw_delete_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "agents_gw_delete_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "agents_gw_files_list": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const agentId = msg.agent_id;
+            log("info", `Agent files list: agent=${agentId}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.agentsFilesList(agentId);
+                    ccClient.send({
+                        type: "agents_gw_files_list_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        files: result,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Agent files list failed: ${errMsg}`);
+                    ccClient.send({
+                        type: "agents_gw_files_list_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "agents_gw_files_list_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "agents_gw_files_get": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const agentId = msg.agent_id;
+            const filePath = msg.file_path;
+            log("info", `Agent files get: agent=${agentId} path=${filePath}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.agentsFilesGet(agentId, filePath);
+                    ccClient.send({
+                        type: "agents_gw_files_get_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        content: result,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Agent files get failed: ${errMsg}`);
+                    ccClient.send({
+                        type: "agents_gw_files_get_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "agents_gw_files_get_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        case "agents_gw_files_set": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const agentId = msg.agent_id;
+            const filePath = msg.file_path;
+            const content = msg.content;
+            log("info", `Agent files set: agent=${agentId} path=${filePath}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.agentsFilesSet(agentId, filePath, content);
+                    ccClient.send({
+                        type: "agents_gw_files_set_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        result,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Agent files set failed: ${errMsg}`);
+                    ccClient.send({
+                        type: "agents_gw_files_set_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "agents_gw_files_set_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        // ── Logs tail ───────────────────────────────────────────────
+        case "logs_tail": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const cursor = msg.cursor;
+            const limit = msg.limit;
+            const maxBytes = msg.max_bytes;
+            log("info", `Logs tail requested (cursor=${cursor ?? "start"}, limit=${limit ?? "default"})`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.logsTail({ cursor, limit, maxBytes });
+                    ccClient.send({
+                        type: "logs_tail_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        result,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Logs tail failed: ${errMsg}`);
+                    ccClient.send({
+                        type: "logs_tail_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "logs_tail_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        // ── Browser request ─────────────────────────────────────────
+        case "browser_request": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            const method = msg.method;
+            const path = msg.path;
+            const query = msg.query;
+            const body = msg.body;
+            const timeoutMs = msg.timeout_ms;
+            log("info", `Browser request: ${method} ${path}`);
+            if (gwClient.isConnected) {
+                try {
+                    const result = await gwClient.browserRequest({ method, path, query, body, timeoutMs });
+                    ccClient.send({
+                        type: "browser_request_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        result,
+                    });
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    log("warn", `Browser request failed: ${errMsg}`);
+                    ccClient.send({
+                        type: "browser_request_response",
+                        user_id: userId,
+                        request_id: requestId,
+                        error: errMsg,
+                    });
+                }
+            }
+            else {
+                ccClient.send({
+                    type: "browser_request_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: "Gateway not connected",
+                });
+            }
+            break;
+        }
+        // ── Screenshot request ──────────────────────────────────────
+        case "screenshot_request": {
+            const userId = msg.user_id;
+            const requestId = msg.request_id;
+            log("info", "Screenshot requested");
+            try {
+                // Dynamic import since screenshot-desktop is a CJS module
+                // @ts-expect-error — screenshot-desktop has no type declarations
+                const screenshot = (await import("screenshot-desktop")).default;
+                const imgBuffer = await screenshot({ format: "png" });
+                const base64 = imgBuffer.toString("base64");
+                ccClient.send({
+                    type: "screenshot_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    image_base64: base64,
+                    format: "png",
+                    timestamp: new Date().toISOString(),
+                });
+                log("info", `Screenshot captured (${Math.round(base64.length / 1024)}KB base64)`);
+            }
+            catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                log("error", `Screenshot failed: ${errMsg}`);
+                ccClient.send({
+                    type: "screenshot_response",
+                    user_id: userId,
+                    request_id: requestId,
+                    error: errMsg,
+                });
+            }
+            break;
+        }
+        // ── Cancel running task ─────────────────────────────────────
+        case "cancel_task": {
+            const executionId = msg.execution_id;
+            log("info", `Cancel requested for execution=${executionId}`);
+            // TODO: Implement session-based cancellation via sessions.kill
+            break;
+        }
+        // ── Ping/pong ───────────────────────────────────────────────
+        case "ping": {
+            ccClient.send({ type: "pong" });
+            break;
+        }
+        default:
+            log("warn", `Unknown message type: ${msg.type}`);
+    }
+}
+// ── Logging ────────────────────────────────────────────────────────
+function log(level, msg) {
+    const ts = new Date().toISOString();
+    const prefix = `[${ts}] [Daemon] [${level.toUpperCase()}]`;
+    if (level === "error")
+        console.error(`${prefix} ${msg}`);
+    else if (level === "warn")
+        console.warn(`${prefix} ${msg}`);
+    else
+        console.log(`${prefix} ${msg}`);
+}
+// ── Run ────────────────────────────────────────────────────────────
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=daemon.js.map