@aiagenta2z/onekey-gateway 0.1.4 → 0.1.5

package/dist/gateway.js

@@ -0,0 +1,1049 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_LOCAL_GATEWAY = exports.COACHOWL_TIMETABLE_GATEWAY = void 0;
+exports.loadConfigFile = loadConfigFile;
+exports.loadGatewayEndpointConfigSync = loadGatewayEndpointConfigSync;
+exports.resolveGatewayProfile = resolveGatewayProfile;
+exports.getAgentTasks = getAgentTasks;
+exports.claimAgentTask = claimAgentTask;
+exports.runLocalAgent = runLocalAgent;
+exports.runCodex = runCodex;
+exports.runGemini = runGemini;
+exports.runClaude = runClaude;
+exports.runGenericCLI = runGenericCLI;
+exports.runGenericCLIWithMonitor = runGenericCLIWithMonitor;
+exports.postAgentTaskResult = postAgentTaskResult;
+exports.startPullWorker = startPullWorker;
+exports.startCallbackServer = startCallbackServer;
+exports.runGateway = runGateway;
+// =========================
+// OneKey Gateway Runtime
+// coachowl/coachowl
+// =========================
+const fs_1 = __importDefault(require("fs"));
+const http_1 = __importDefault(require("http"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const WORKSPACE_ROOT = process.cwd(); // this is your codebase root
+function createTaskWorkspace(taskId) {
+    const base = path_1.default.join(WORKSPACE_ROOT, ".onekey", "tmp", taskId);
+    fs_1.default.mkdirSync(base, { recursive: true });
+    return {
+        root: base,
+        logs: path_1.default.join(base, "logs.txt"),
+        output: path_1.default.join(base, "output.txt"),
+    };
+}
+const DEBUG_ENABLE = false;
+const DEFAULT_AGENT_RUN_TIMEOUT = 600000; // 10 minutes default
+const HEALTH_INTERVAL = 1 * 60 * 1000; // /health/post endpoint
+const HEARTBEAT_TIMER_INTERVAL = 1 * 60 * 1000; // heartbeat timer interval
+const DEFAULT_CALLBACK_ENDPOINT_PORT = 18000; // call back port of onekey gateway
+const EVENT_LOG_STATUS_RUNNING = "running";
+const EVENT_LOG_STATUS_STALLED = "stalled";
+const EVENT_LOG_STATUS_COMPLETED = "completed";
+const EVENT_LOG_STATUS_ERROR = "error";
+exports.COACHOWL_TIMETABLE_GATEWAY = "https://coachowl.aiagenta2z.com";
+exports.DEFAULT_LOCAL_GATEWAY = "http://0.0.0.0:7115";
+const PROJECT_LOCAL_DIR = process.cwd();
+const DEFAULT_LOCAL_AGENT_CLI = "claude";
+// ------------------------------
+// Load JSON file safely
+// ------------------------------
+function loadConfigFile(filePath) {
+    if (!filePath || typeof filePath !== "string") {
+        console.warn("[loadConfigFile] invalid filePath");
+        return null;
+    }
+    if (!fs_1.default.existsSync(filePath)) {
+        console.warn(`[loadConfigFile] file not found: ${filePath}`);
+        return null;
+    }
+    try {
+        const raw = fs_1.default.readFileSync(filePath, "utf8");
+        if (!raw?.trim()) {
+            console.warn("[loadConfigFile] empty file");
+            return null;
+        }
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            console.warn("[loadConfigFile] invalid JSON structure");
+            return null;
+        }
+        return parsed;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error("[loadConfigFile] failed:", message);
+        return null;
+    }
+}
+function findDataConfigDir() {
+    const candidates = [path_1.default.resolve(PROJECT_LOCAL_DIR, "data", "config")];
+    for (const candidate of candidates) {
+        if (fs_1.default.existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+function getDefaultGatewayConfig() {
+    return {
+        "coachowl/coachowl": {
+            local: {
+                endpoint: exports.DEFAULT_LOCAL_GATEWAY,
+                auth_header: "X-OneKey",
+                routes: {
+                    get_tasks: "/api/v1/agent/tasks/get",
+                    claim_task: "/api/v1/agent/tasks/claim",
+                    post_result: "/api/v1/agent/tasks/post",
+                    // agent_execution_state upsert + heartbeat
+                    update_health: "/api/v1/agent/tasks/health/post",
+                    // selective important logs
+                    update_log: "/api/v1/agent/tasks/log/post"
+                },
+                agents_clis: ["codex", "gemini", "claude", "openclaw"]
+            },
+            production: {
+                endpoint: exports.COACHOWL_TIMETABLE_GATEWAY,
+                auth_header: "X-OneKey",
+                routes: {
+                    get_tasks: "/api/v1/agent/tasks/get",
+                    claim_task: "/api/v1/agent/tasks/claim",
+                    post_result: "/api/v1/agent/tasks/post",
+                    update_health: "/api/v1/agent/tasks/health/post",
+                    update_log: "/api/v1/agent/tasks/log/post"
+                },
+                agents_clis: ["codex", "gemini", "claude", "openclaw"]
+            }
+        }
+    };
+}
+function normalizeGatewayConfig(config) {
+    if (!config || typeof config !== "object" || Array.isArray(config)) {
+        return getDefaultGatewayConfig();
+    }
+    return config;
+}
+function loadGatewayEndpointConfigSync() {
+    const configDir = findDataConfigDir();
+    if (!configDir) {
+        console.warn("[gateway] config dir not found, using defaults");
+        return getDefaultGatewayConfig();
+    }
+    const configPath = path_1.default.join(configDir, "gateway_endpoint.json");
+    const config = loadConfigFile(configPath);
+    if (!config) {
+        console.warn("[gateway] invalid config, fallback to defaults");
+        return getDefaultGatewayConfig();
+    }
+    return normalizeGatewayConfig(config);
+}
+const gatewayEndpointConfig = loadGatewayEndpointConfigSync();
+// -------------------------
+// Utilities
+// -------------------------
+function today() {
+    return new Date().toISOString().slice(0, 10);
+}
+function safeJson(res) {
+    return res.json().catch(async (err) => {
+        const raw = await res.text().catch(() => "<unreadable body>");
+        console.error("❌ safeJson parse failed");
+        console.error("Status:", res.status);
+        console.error("StatusText:", res.statusText);
+        console.error("Error:", err);
+        console.error("Raw response body:", raw);
+        return {};
+    });
+}
+function toBaseUrl(url) {
+    return url.replace(/\/+$/, "");
+}
+function isCliAvailable(cli) {
+    try {
+        (0, child_process_1.execSync)(process.platform === "win32" ? `where ${cli}` : `command -v ${cli}`, {
+            stdio: "ignore"
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function pickAvailableCli(profile) {
+    const list = profile.agents_clis?.length ? profile.agents_clis : [DEFAULT_LOCAL_AGENT_CLI];
+    for (const cli of list) {
+        if (isCliAvailable(cli))
+            return cli;
+    }
+    return null;
+}
+function makeAgentId(cli) {
+    const host = os_1.default.hostname().replace(/[^a-zA-Z0-9_.-]+/g, "_");
+    return `${cli}_${host}_${process.pid}`;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+        req.on("end", () => {
+            const raw = Buffer.concat(chunks).toString("utf8");
+            if (!raw.trim())
+                return resolve({});
+            try {
+                resolve(JSON.parse(raw));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        req.on("error", reject);
+    });
+}
+function sendJson(res, statusCode, data) {
+    const body = JSON.stringify(data);
+    res.statusCode = statusCode;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.setHeader("Content-Length", Buffer.byteLength(body));
+    res.end(body);
+}
+// -------------------------
+// Gateway profile resolution
+// -------------------------
+function resolveGatewayProfile(uniqueId, mode = "local") {
+    const entry = gatewayEndpointConfig?.[uniqueId];
+    const profile = entry?.[mode];
+    if (!profile?.endpoint || !profile?.auth_header || !profile?.routes) {
+        const fallback = getDefaultGatewayConfig()?.[uniqueId]?.[mode];
+        if (fallback)
+            return fallback;
+        throw new Error(`Gateway profile not found for ${uniqueId} (${mode})`);
+    }
+    return profile;
+}
+// -------------------------
+// 1) GET TASKS
+// -------------------------
+/**
+    "local": {
+      "endpoint": "http://0.0.0.0:7115",
+      "auth_header": "X-OneKey",
+      "routes": {
+        "get_tasks": "/api/v1/agent/tasks/get",
+        "claim_task": "/api/v1/agent/tasks/claim",
+        "post_result": "/api/v1/agent/tasks/post"
+      },
+      "agents_clis": ["codex","gemini","claude","openclaw"]
+    }
+*/
+async function getAgentTasks(accessKey, profileOrGatewayUrl = exports.DEFAULT_LOCAL_GATEWAY) {
+    const profile = typeof profileOrGatewayUrl === "string"
+        ? {
+            endpoint: profileOrGatewayUrl,
+            auth_header: "X-OneKey",
+            routes: {
+                get_tasks: "/api/v1/agent/tasks/get",
+                claim_task: "/api/v1/agent/tasks/claim",
+                post_result: "/api/v1/agent/tasks/post",
+                update_health: "/api/v1/agent/tasks/health/post",
+                update_log: "/api/v1/agent/tasks/log/post"
+            }
+        }
+        : profileOrGatewayUrl;
+    const url = `${toBaseUrl(profile.endpoint)}${profile.routes.get_tasks}`;
+    if (DEBUG_ENABLE) {
+        const headers = { [profile.auth_header]: accessKey };
+        console.log(`url ${url} and headers ${headers}`);
+    }
+    const res = await fetch(url, {
+        method: "GET",
+        headers: {
+            [profile.auth_header]: accessKey
+        }
+    });
+    const data = (await safeJson(res));
+    if (!data?.success) {
+        throw new Error("[onekey gateway] getAgentTasks failed to get tasks");
+    }
+    return data;
+}
+// -------------------------
+// 2) CLAIM TASK
+// -------------------------
+async function claimAgentTask(accessKey, payload, profileOrGatewayUrl = exports.DEFAULT_LOCAL_GATEWAY) {
+    const profile = typeof profileOrGatewayUrl === "string"
+        ? {
+            endpoint: profileOrGatewayUrl,
+            auth_header: "X-OneKey",
+            routes: {
+                get_tasks: "/api/v1/agent/tasks/get",
+                claim_task: "/api/v1/agent/tasks/claim",
+                post_result: "/api/v1/agent/tasks/post",
+                update_health: "/api/v1/agent/tasks/health/post",
+                update_log: "/api/v1/agent/tasks/log/post"
+            }
+        }
+        : profileOrGatewayUrl;
+    const url = `${toBaseUrl(profile.endpoint)}${profile.routes.claim_task}`;
+    const routed_payload = {
+        method: "POST",
+        headers: {
+            [profile.auth_header]: accessKey,
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+            agent_id: payload.agent_id,
+            agent_name: payload.agent_name || payload.agent_id?.split("_")[0] || "unknown",
+            habit_id: payload.habit_id,
+            execution_date: payload.execution_date
+        })
+    };
+    if (DEBUG_ENABLE) {
+        console.log(`/claim claimAgentTask url ${url} and payload ${JSON.stringify(routed_payload)}`);
+    }
+    const res = await fetch(url, routed_payload);
+    const data = await safeJson(res);
+    if (DEBUG_ENABLE) {
+        console.log(`/claim claimAgentTask result ${JSON.stringify(data)}`);
+    }
+    if (!data?.success)
+        return { success: false, error: data?.message || "claim_failed" };
+    return data;
+}
+function isAgentCLI(cli) {
+    return ["codex", "gemini", "claude", "claude-code", "openclaw"].includes(cli);
+}
+async function runLocalAgent(cli, prompt, accessKey, profile, executionContext, timeoutMs = DEFAULT_AGENT_RUN_TIMEOUT, opts) {
+    const cwd = opts?.cwd ?? process.cwd();
+    const taskDir = opts?.taskDir;
+    console.log("\n==============================");
+    console.log("[onekey gateway] runLocalAgent ROUTER START");
+    console.log("CLI:", cli);
+    console.log("CWD:", cwd);
+    console.log("TASK_DIR:", taskDir);
+    console.log("Prompt:", prompt);
+    console.log("==============================\n");
+    switch (cli) {
+        case "codex":
+            return runCodex(prompt, accessKey, profile, executionContext, timeoutMs, opts);
+        case "gemini":
+            return runGemini(prompt, accessKey, profile, executionContext, timeoutMs, opts);
+        case "claude":
+            return runClaude(prompt, accessKey, profile, executionContext, timeoutMs, opts);
+        default:
+            return runGenericCLIWithMonitor(cli, ["-p", prompt], accessKey, profile, executionContext, timeoutMs, cli, cwd, taskDir);
+    }
+}
+function runProcess(label, cmd, args, timeoutMs) {
+    return new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)(cmd, args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                TERM: "dumb",
+                CI: "true",
+            },
+        });
+        let stdout = "";
+        let stderr = "";
+        let finished = false;
+        const kill = (reason) => {
+            if (finished)
+                return;
+            finished = true;
+            try {
+                child.kill("SIGKILL");
+            }
+            catch { }
+            resolve({
+                success: false,
+                content: `${label} killed: ${reason}\n${stdout}\n${stderr}`.trim(),
+                exitCode: null,
+            });
+        };
+        const timer = timeoutMs > 0 ? setTimeout(() => kill("timeout"), timeoutMs) : null;
+        child.stdout.on("data", (d) => {
+            const text = d.toString();
+            stdout += text;
+            if (DEBUG_ENABLE)
+                console.log(`[${label} stdout]`, text);
+        });
+        child.stderr.on("data", (d) => {
+            const text = d.toString();
+            stderr += text;
+            if (DEBUG_ENABLE)
+                console.log(`[${label} stderr]`, text);
+        });
+        child.on("error", (err) => {
+            if (timer)
+                clearTimeout(timer);
+            kill(`spawn error: ${err.message}`);
+        });
+        child.on("close", (code) => {
+            if (timer)
+                clearTimeout(timer);
+            if (finished)
+                return;
+            finished = true;
+            resolve({
+                success: code === 0,
+                content: (stdout + "\n" + stderr).trim() || "(no output)",
+                exitCode: code,
+            });
+        });
+    });
+}
+function runCodex(prompt, accessKey, profile, executionContext, timeoutMs = 120000, opts) {
+    return runGenericCLIWithMonitor("codex", [
+        "exec",
+        "--skip-git-repo-check",
+        "--full-auto",
+        "-C",
+        opts?.cwd ?? process.cwd(),
+        prompt
+    ], accessKey, profile, executionContext, timeoutMs, "codex", opts?.cwd, opts?.taskDir);
+}
+function runGemini(prompt, accessKey, profile, executionContext, timeoutMs = 60000, opts) {
+    return runGenericCLIWithMonitor("gemini", ["-p", prompt], accessKey, profile, executionContext, timeoutMs, "gemini", opts?.cwd, opts?.taskDir);
+}
+function runClaude(prompt, accessKey, profile, executionContext, timeoutMs = 60000, opts) {
+    return runGenericCLIWithMonitor("claude", ["-p", prompt], accessKey, profile, executionContext, timeoutMs, "claude", opts?.cwd, opts?.taskDir);
+}
+async function runGenericCLI(cli, args, timeoutMs = 60000, label = cli, cwd = process.cwd(), taskDir) {
+    return new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)(cli, args, {
+            cwd, // WORKING DIRECTORY CONTROL
+            stdio: ["ignore", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                TERM: "dumb",
+                CI: "true",
+                NO_COLOR: "1",
+                // optional per-task sandbox context
+                TASK_DIR: taskDir || "",
+            },
+        });
+        console.info(`[onekey gateway] INFO: Process ID Started: ${child.pid}, CLI: ${cli} ${args.join(" ")}`);
+        let stdout = "";
+        let stderr = "";
+        let finished = false;
+        const kill = (reason) => {
+            if (finished)
+                return;
+            finished = true;
+            try {
+                child.kill("SIGKILL");
+            }
+            catch { }
+            resolve({
+                success: false,
+                content: `${label} killed: ${reason}\n${stdout}\n${stderr}`.trim(),
+                exitCode: null,
+            });
+        };
+        const timer = timeoutMs > 0 ? setTimeout(() => kill("timeout"), timeoutMs) : null;
+        child.stdout.on("data", (d) => {
+            const text = d.toString("utf8");
+            stdout += text;
+            if (DEBUG_ENABLE) {
+                console.log(`[${label} stdout]`, text);
+            }
+        });
+        child.stderr.on("data", (d) => {
+            const text = d.toString("utf8");
+            stderr += text;
+            if (DEBUG_ENABLE) {
+                console.log(`[${label} stderr]`, text);
+            }
+        });
+        child.on("error", (err) => {
+            if (timer)
+                clearTimeout(timer);
+            kill(`spawn error: ${err.message}`);
+        });
+        child.on("close", (code) => {
+            if (timer)
+                clearTimeout(timer);
+            if (finished)
+                return;
+            finished = true;
+            resolve({
+                success: code === 0,
+                content: (stdout + "\n" + stderr).trim() || "(no output)",
+                exitCode: code,
+            });
+        });
+    });
+}
+async function runGenericCLIWithMonitor(cli, args, accessKey, profile, executionContext, timeoutMs = DEFAULT_AGENT_RUN_TIMEOUT, label = cli, cwd = process.cwd(), taskDir) {
+    return new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)(cli, args, {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                TERM: "dumb",
+                CI: "true",
+                NO_COLOR: "1",
+                TASK_DIR: taskDir || "",
+            },
+        });
+        const pid = child.pid;
+        const baseUrl = profile.endpoint;
+        const routes = profile.routes;
+        const updateHealthRoute = routes?.update_health || "/api/v1/agent/tasks/health/post";
+        const updateLogRoute = routes?.update_log || "/api/v1/agent/tasks/log/post";
+        function nowUtcSqlString() {
+            // backend expects/produces "%Y-%m-%d %H:%M:%S" (UTC)
+            const iso = new Date().toISOString(); // 2026-01-01T00:00:00.000Z
+            return iso.replace("T", " ").slice(0, 19);
+        }
+        async function post(urlPath, body) {
+            try {
+                const controller = new AbortController();
+                const t = setTimeout(() => controller.abort(), 8000);
+                await fetch(`${toBaseUrl(baseUrl)}${urlPath}`, {
+                    method: "POST",
+                    headers: {
+                        [profile.auth_header]: accessKey,
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify(body),
+                    signal: controller.signal,
+                });
+                clearTimeout(t);
+            }
+            catch (e) {
+                console.error(`[gateway monitor] post failed`, e);
+            }
+        }
+        let stdout = "";
+        let stderr = "";
+        let finished = false;
+        let lastOutputTime = Date.now();
+        let heartbeatTimer = null;
+        const startedAt = nowUtcSqlString();
+        let lastHealthSentAt = 0;
+        let lastImportantLogSentAt = 0;
+        let lastImportantMessage;
+        let lastReportedStatus;
+        const logLineBuffer = {
+            stdout: "",
+            stderr: "",
+        };
+        // Aggregate Batched Buffered Log Lines and Post Back
+        const batchedLogBuffer = {
+            stdout: [],
+            stderr: [],
+        };
+        const BATCH_SIZE = 5;
+        function makeLogBody(kind, message, chunk, timestamp, status) {
+            return {
+                ...executionContext,
+                event_type: kind,
+                status: status,
+                message,
+                metadata: {
+                    pid,
+                    label,
+                    chunk,
+                    timestamp
+                },
+            };
+        }
+        async function postStatusLog(status, message) {
+            if (lastReportedStatus === status)
+                return;
+            lastReportedStatus = status;
+            const now = Date.now();
+            const clipped = message.slice(0, 2000);
+            await post(updateLogRoute, makeLogBody("stdout", clipped, clipped, now, status));
+        }
+        async function flushLogBuffer(kind, status) {
+            const buffer = batchedLogBuffer[kind];
+            if (buffer.length === 0)
+                return;
+            const combined = buffer.join("\n");
+            batchedLogBuffer[kind] = []; // clear BEFORE await (avoid race)
+            const now = Date.now();
+            const clipped = combined.slice(0, 4000);
+            // const status = "running";
+            await post(updateLogRoute, makeLogBody(kind, clipped, clipped, now, status));
+        }
+        function pushLog(kind, line) {
+            batchedLogBuffer[kind].push(line);
+            if (batchedLogBuffer[kind].length >= BATCH_SIZE) {
+                flushLogBuffer(kind, EVENT_LOG_STATUS_RUNNING); // fire async (don’t await to avoid blocking stream)
+            }
+        }
+        function isImportantLogLine(line) {
+            const s = line.trim();
+            if (!s)
+                return false;
+            if (s.length < 3)
+                return false;
+            if (s.startsWith("{") && s.endsWith("}"))
+                return false; // avoid raw JSON spam
+            // Keep high-signal lines (errors, warnings, progress, summaries)
+            if (/(^|\b)(error|failed|failure|exception|traceback|panic)\b/i.test(s))
+                return true;
+            if (/(^|\b)(warn|warning)\b/i.test(s))
+                return true;
+            if (/(^|\b)(done|complete|completed|success|succeed|finished)\b/i.test(s))
+                return true;
+            if (/(^|\b)(progress|step|phase|running|starting)\b/i.test(s))
+                return true;
+            if (/(^|\b)(patch|apply_patch|diff|files changed|tests?|build)\b/i.test(s))
+                return true;
+            if (/(^|\b)(http|https):\/\//i.test(s))
+                return true; // usually important links
+            return false;
+        }
+        function normalizeLogChunkToLines(kind, chunk) {
+            logLineBuffer[kind] += chunk;
+            const parts = logLineBuffer[kind].split(/\r?\n/);
+            logLineBuffer[kind] = parts.pop() ?? "";
+            return parts;
+        }
+        async function postHealth(fields) {
+            const now = Date.now();
+            if (now - lastHealthSentAt < HEALTH_INTERVAL)
+                return; // avoid bursts when stdout is noisy
+            lastHealthSentAt = now;
+            await post(updateHealthRoute, {
+                ...executionContext,
+                pid,
+                label,
+                is_alive: true,
+                started_at: startedAt,
+                heartbeat_at: nowUtcSqlString(),
+                last_message: lastImportantMessage,
+                ...fields,
+            });
+        }
+        async function postImportantLog(kind, line, status) {
+            const now = Date.now();
+            if (now - lastImportantLogSentAt < 1200)
+                return; // cap log posts
+            lastImportantLogSentAt = now;
+            const clipped = line.slice(0, 2000);
+            // const status = "running";
+            await post(updateLogRoute, makeLogBody(kind, clipped, clipped, now, status));
+        }
+        console.info(`[onekey gateway] Process Started PID=${pid}, CLI=${cli} ${args.join(" ")}`);
+        // 🚀 START HEALTH
+        postHealth({ status: "starting", progress: 0 });
+        postStatusLog(EVENT_LOG_STATUS_RUNNING, `[gateway] process started pid=${pid} cli=${cli}`);
+        // 🧠 HEARTBEAT
+        heartbeatTimer = setInterval(() => {
+            const idleSeconds = Math.floor((Date.now() - lastOutputTime) / 1000);
+            const nextStatus = idleSeconds > 120 ? EVENT_LOG_STATUS_STALLED : EVENT_LOG_STATUS_RUNNING;
+            postHealth({ status: nextStatus, idle_seconds: idleSeconds });
+            postStatusLog(nextStatus, `[gateway] heartbeat idle_seconds=${idleSeconds}`);
+        }, HEARTBEAT_TIMER_INTERVAL);
+        const kill = (reason) => {
+            if (finished)
+                return;
+            finished = true;
+            if (heartbeatTimer)
+                clearInterval(heartbeatTimer);
+            try {
+                child.kill("SIGKILL");
+            }
+            catch { }
+            postHealth({ status: "killed", reason, is_alive: false });
+            postStatusLog(EVENT_LOG_STATUS_ERROR, `[gateway] killed: ${reason}`);
+            resolve({
+                success: false,
+                content: `${label} killed: ${reason}\n${stdout}\n${stderr}`.trim(),
+                exitCode: null,
+            });
+        };
+        const timer = timeoutMs > 0 ? setTimeout(() => kill("timeout"), timeoutMs) : null;
+        // 📡 STDOUT LOG STREAM
+        child.stdout.on("data", (d) => {
+            const text = d.toString("utf8");
+            stdout += text;
+            lastOutputTime = Date.now();
+            const lines = normalizeLogChunkToLines("stdout", text);
+            // Chunking and Post Logs
+            for (const line of lines) {
+                if (!isImportantLogLine(line))
+                    continue;
+                const trimmed = line.trim();
+                lastImportantMessage = trimmed.slice(0, 500);
+                // buffered instead of immediate
+                pushLog("stdout", trimmed);
+                postHealth({ status: EVENT_LOG_STATUS_RUNNING });
+            }
+            console.log(`[${label} stdout]`, text);
+            //     if (DEBUG_ENABLE) {
+            //         console.log(`[${label} stdout]`, text);
+            //     }
+        });
+        // 📡 STDERR LOG STREAM
+        child.stderr.on("data", (d) => {
+            const text = d.toString("utf8");
+            stderr += text;
+            lastOutputTime = Date.now();
+            const lines = normalizeLogChunkToLines("stderr", text);
+            for (const line of lines) {
+                if (!isImportantLogLine(line))
+                    continue;
+                lastImportantMessage = line.trim().slice(0, 500);
+                postImportantLog("stderr", line, EVENT_LOG_STATUS_RUNNING);
+                postHealth({ status: EVENT_LOG_STATUS_RUNNING });
+            }
+            console.log(`[${label} stderr]`, text);
+            //       if (DEBUG_ENABLE) {
+            //         console.log(`[${label} stderr]`, text);
+            //       }
+        });
+        child.on("error", (err) => {
+            if (timer)
+                clearTimeout(timer);
+            kill(`spawn error: ${err.message}`);
+        });
+        child.on("close", (code) => {
+            if (timer)
+                clearTimeout(timer);
+            if (heartbeatTimer)
+                clearInterval(heartbeatTimer);
+            if (finished)
+                return;
+            finished = true;
+            // flush trailing buffered lines
+            for (const kind of ["stdout", "stderr"]) {
+                const tail = logLineBuffer[kind].trim();
+                if (tail && isImportantLogLine(tail)) {
+                    lastImportantMessage = tail.slice(0, 500);
+                    postImportantLog(kind, tail, code === 0 ? EVENT_LOG_STATUS_COMPLETED : EVENT_LOG_STATUS_ERROR);
+                }
+            }
+            const finalStatus = code === 0 ? EVENT_LOG_STATUS_COMPLETED : EVENT_LOG_STATUS_ERROR;
+            flushLogBuffer("stdout", finalStatus);
+            flushLogBuffer("stderr", finalStatus);
+            postHealth({
+                status: finalStatus,
+                exitCode: code,
+                success: code === 0,
+                is_alive: false,
+                progress: 100,
+            });
+            postStatusLog(finalStatus, `[gateway] process exited code=${code ?? "null"}`);
+            post(routes.post_result, {
+                results: [
+                    {
+                        task_id: executionContext.habit_id,
+                        execution_id: executionContext.execution_id,
+                        root_execution_id: executionContext.root_execution_id,
+                        content: (stdout + "\n" + stderr).trim() || "(no output)",
+                        agent_id: executionContext.agent_id,
+                        status: "completed",
+                        agent_name: executionContext.agent_name,
+                    },
+                ],
+            });
+            resolve({
+                success: code === 0,
+                content: (stdout + "\n" + stderr).trim() || "(no output)",
+                exitCode: code,
+            });
+        });
+    });
+}
+// -------------------------
+// 4) POST RESULTS
+// -------------------------
+async function postAgentTaskResult(accessKey, result, profileOrGatewayUrl = exports.DEFAULT_LOCAL_GATEWAY) {
+    const profile = typeof profileOrGatewayUrl === "string"
+        ? {
+            endpoint: profileOrGatewayUrl,
+            auth_header: "X-OneKey",
+            routes: {
+                get_tasks: "/api/v1/agent/tasks/get",
+                claim_task: "/api/v1/agent/tasks/claim",
+                post_result: "/api/v1/agent/tasks/post",
+                update_health: "/api/v1/agent/tasks/health/post",
+                update_log: "/api/v1/agent/tasks/log/post"
+            }
+        }
+        : profileOrGatewayUrl;
+    const url = `${toBaseUrl(profile.endpoint)}${profile.routes.post_result}`;
+    const payload = {
+        method: "POST",
+        headers: {
+            [profile.auth_header]: accessKey,
+            "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+            results: [
+                {
+                    task_id: result.habit_id,
+                    execution_id: result.execution_id,
+                    root_execution_id: result.root_execution_id,
+                    content: result.content,
+                    images: result.images || [],
+                    agent_id: result.agent_id,
+                    status: result.status,
+                    agent_name: result.agent_name
+                }
+            ]
+        })
+    };
+    if (DEBUG_ENABLE) {
+        console.log(`/post postAgentTaskResult url ${url} and payload ${JSON.stringify(payload)}`);
+    }
+    const res = await fetch(url, payload);
+    if (DEBUG_ENABLE) {
+        console.log(`/post postAgentTaskResult url ${url} and payload ${JSON.stringify(payload)}`);
+    }
+    return safeJson(res);
+}
+const claimedInProcess = new Set();
+function taskKey(task) {
+    return `${task.habit_id}:${task.execution_date}`;
+}
+function taskPrompt(task) {
+    const raw = task.raw || {};
+    const taskName = raw.name ??
+        raw.title ??
+        raw.task ??
+        "Default Task";
+    const taskContent = raw.content ??
+        raw.note ??
+        "";
+    return [
+        `Task Name: ${taskName}`,
+        `Description: ${taskContent}`
+    ].join("\n");
+}
+async function processTask(task, ctx) {
+    const key = taskKey(task);
+    if (claimedInProcess.has(key))
+        return;
+    const cli = pickAvailableCli(ctx.profile);
+    if (!cli) {
+        console.warn(`[onekey gateway] no local agent CLI available for task ${task.habit_id}`);
+        return;
+    }
+    const agentId = makeAgentId(cli);
+    const agentName = cli;
+    const claim = await claimAgentTask(ctx.accessKey, {
+        agent_id: agentId,
+        agent_name: agentName,
+        habit_id: task.habit_id,
+        execution_date: task.execution_date
+    }, ctx.profile);
+    if (!claim?.success) {
+        var error = claim?.error;
+        console.log(`/claim new task is not successful! Error ${error}`);
+        return;
+    }
+    claimedInProcess.add(key);
+    console.log(`[onekey gateway] pull /claim Task ID: ${task.habit_id} agent=${agentName}`);
+    // Running Message 1: Status: Idle -> Running
+    await postAgentTaskResult(ctx.accessKey, {
+        habit_id: task.habit_id,
+        execution_id: claim.execution_id,
+        root_execution_id: claim.root_execution_id,
+        content: `Agent starting: ${agentName}`,
+        images: [],
+        agent_id: agentId,
+        status: "starting",
+        agent_name: agentName
+    }, ctx.profile);
+    console.log(`[onekey gateway] pull /post status=starting Task ID: ${task.habit_id}`);
+    const prompt = taskPrompt(task);
+    console.log(`[onekey gateway] pull /post status=running Task ID: ${task.habit_id} cli "${cli}" and prompt "${prompt}" ctx ${JSON.stringify(ctx)}...`);
+    const taskWorkspace = createTaskWorkspace(task.habit_id);
+    // const executionResult = await runLocalAgent(cli, prompt, ctx.timeoutMs, {cwd: WORKSPACE_ROOT, taskDir: taskWorkspace.root});
+    const executionResult = await runLocalAgent(cli, prompt, ctx.accessKey, ctx.profile, {
+        habit_id: task.habit_id,
+        execution_id: claim.execution_id,
+        root_execution_id: claim.root_execution_id,
+        agent_id: agentId,
+        agent_name: cli
+    }, ctx.timeoutMs, {
+        cwd: WORKSPACE_ROOT,
+        taskDir: taskWorkspace.root
+    });
+    console.log(`[onekey gateway] pull /post task status=completed Task ID: ${task.habit_id} executionResult "${JSON.stringify(executionResult)}"...`);
+    await postAgentTaskResult(ctx.accessKey, {
+        habit_id: task.habit_id,
+        execution_id: claim.execution_id,
+        root_execution_id: claim.root_execution_id,
+        content: executionResult.content,
+        images: [],
+        agent_id: agentId,
+        status: "completed",
+        agent_name: agentName
+    }, ctx.profile);
+    console.log(`[onekey gateway] pull /post status=completed Task ID: ${task.habit_id}`);
+}
+async function runWithConcurrency(items, limit, fn) {
+    const queue = [...items];
+    const workers = new Array(Math.max(1, limit)).fill(null).map(async () => {
+        while (queue.length) {
+            const item = queue.shift();
+            if (!item)
+                return;
+            await fn(item);
+        }
+    });
+    await Promise.all(workers);
+}
+// -------------------------
+// 2.1 Pull mode worker
+// -------------------------
+async function startPullWorker(ctx, intervalMs = 10 * 60 * 1000) {
+    let running = false;
+    async function runBatch() {
+        if (running)
+            return;
+        running = true;
+        try {
+            if (!ctx.accessKey || !ctx.accessKey.trim()) {
+                throw new Error("Missing access key: set DEEPNLP_ONEKEY_ROUTER_ACCESS or pass --key");
+            }
+            console.log("[onekey gateway] pull /get tasks ...");
+            const data = await getAgentTasks(ctx.accessKey, ctx.profile);
+            // const connectedAgents: ConnectedAgent[] = Array.isArray(data?.connected_agents) ? data.connected_agents : [];
+            const connectedAgents = Array.isArray(data?.connected_agents)
+                ? data.connected_agents.map((a) => ({
+                    id: a.id ?? "",
+                    name: a.name ?? "",
+                    cli: a.cli ?? "",
+                    description: a.description ?? "",
+                }))
+                : [];
+            const tasks = (data?.tasks || []).map((t) => ({
+                habit_id: t.id,
+                execution_date: t.execution_date || today(),
+                raw: t
+            }));
+            // Get Agents
+            const localAgents = (ctx.profile.agents_clis || [])
+                .map(a => a.trim())
+                .filter(Boolean);
+            // 'connected_agents': [{'id': '', 'name': 'claude', 'description': 'Agent for claude', 'cli': 'claude'}, {'id': '', 'name': 'codex', 'description': 'Agent for codex', 'cli': 'codex'}, {'id': '', 'name': 'gemini', 'description': 'Agent for gemini', 'cli': 'gemini'}]}
+            const remoteAgents = connectedAgents.map(a => a.cli);
+            // fallback logic
+            const selectedAgents = remoteAgents.length > 0 ? remoteAgents : localAgents;
+            console.log(`[onekey gateway] Available agents |remote setting="${remoteAgents.join(",")}" | selected="${selectedAgents.join(",")}"`);
+            console.log(`[onekey gateway] pull /get Task IDs: ${tasks.map((t) => t.habit_id).join(",") || "(none)"}`);
+            await runWithConcurrency(tasks, ctx.concurrency, async (task) => processTask(task, ctx));
+        }
+        catch (error) {
+            console.error("[gateway] pull_worker_error", error);
+        }
+        finally {
+            running = false;
+        }
+    }
+    await runBatch();
+    for (;;) {
+        await sleep(intervalMs);
+        await runBatch();
+    }
+}
+// -------------------------
+// 2.2 Callback mode server
+// -------------------------
+async function startCallbackServer(ctx, port) {
+    const server = http_1.default.createServer(async (req, res) => {
+        const url = req.url ? req.url.split("?", 1)[0] : "/";
+        if (req.method === "POST" && url === "/api/v1/agent/tasks/callback") {
+            try {
+                const headerName = (ctx.profile.auth_header || "X-OneKey").toLowerCase();
+                const headerValue = req.headers[headerName];
+                const accessKeyFromHeader = Array.isArray(headerValue) ? headerValue[0] : headerValue;
+                const accessKey = String(accessKeyFromHeader || ctx.accessKey || "").trim();
+                if (!accessKey) {
+                    return sendJson(res, 401, { success: false, error: "missing_access_key" });
+                }
+                const body = await parseJsonBody(req);
+                const rawTasks = Array.isArray(body?.tasks) ? body.tasks : [];
+                console.log(`[onekey gateway] AGENT EVENT PUSH callback received ${rawTasks.length} tasks`);
+                const tasks = rawTasks
+                    .map((t) => ({
+                    habit_id: t?.id || t?.habit_id,
+                    execution_date: t?.execution_date || today(),
+                    raw: t
+                }))
+                    .filter((t) => Boolean(t?.habit_id));
+                const ctxWithKey = { ...ctx, accessKey };
+                await runWithConcurrency(tasks, ctx.concurrency, async (task) => processTask(task, ctxWithKey));
+                return sendJson(res, 200, { success: true });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return sendJson(res, 400, { success: false, error: message });
+            }
+        }
+        if (req.method === "GET" && url === "/health") {
+            return sendJson(res, 200, { ok: true });
+        }
+        sendJson(res, 404, { success: false, error: "not_found" });
+    });
+    await new Promise((resolve) => {
+        server.listen(port, "0.0.0.0", () => resolve());
+    });
+    console.log(`[onekey gateway] Agent Event Push Listen | Callback listening on http://127.0.0.1:${port}/api/v1/agent/tasks/callback`);
+}
+// -------------------------
+// Entry (CLI)
+// -------------------------
+async function runGateway(positionals, flags = {}) {
+    const [uniqueId] = positionals;
+    if (!uniqueId)
+        throw new Error("gateway requires unique_id (e.g. coachowl/coachowl)");
+    const modeFlag = typeof flags.mode === "string" ? flags.mode : "pull";
+    const mode = modeFlag === "callback" ? "callback" : "pull";
+    const accessKey = typeof flags.key === "string" ? flags.key : process.env.DEEPNLP_ONEKEY_ROUTER_ACCESS;
+    if (mode === "pull" && (!accessKey || !accessKey.trim())) {
+        throw new Error("Missing access key: set DEEPNLP_ONEKEY_ROUTER_ACCESS or pass --key");
+    }
+    // default to local tasks
+    const envFlag = typeof flags.env === "string" ? flags.env : "production";
+    const env = envFlag === "production" ? "production" : "local";
+    const profile = resolveGatewayProfile(uniqueId, env);
+    const timeoutMsRaw = flags.timeout;
+    const timeoutMs = typeof timeoutMsRaw === "string" && Number.isFinite(Number(timeoutMsRaw)) ? Number(timeoutMsRaw) : 0;
+    const concurrencyRaw = flags.concurrency;
+    const concurrency = typeof concurrencyRaw === "string" && Number.isFinite(Number(concurrencyRaw)) ? Number(concurrencyRaw) : 1;
+    const intervalSecondsRaw = flags.interval;
+    const intervalMsRaw = flags["interval-ms"] ?? flags.intervalMs;
+    const intervalMs = typeof intervalSecondsRaw === "string" && Number.isFinite(Number(intervalSecondsRaw))
+        ? Number(intervalSecondsRaw) * 1000
+        : typeof intervalMsRaw === "string" && Number.isFinite(Number(intervalMsRaw))
+            ? Number(intervalMsRaw)
+            : 10 * 60 * 1000;
+    const portRaw = flags.port;
+    const port = typeof portRaw === "string" && Number.isFinite(Number(portRaw)) ? Number(portRaw) : DEFAULT_CALLBACK_ENDPOINT_PORT;
+    const ctx = {
+        uniqueId,
+        accessKey,
+        profile,
+        timeoutMs,
+        concurrency
+    };
+    console.log(`[onekey gateway] Agent Pull Event|unique_id=${uniqueId} env=${env} mode=${mode}`);
+    console.log(`[onekey gateway] Agent Pull Event|endpoint=${profile.endpoint}`);
+    console.log(`[onekey gateway] Agent Pull Event|agents_clis=${(profile.agents_clis || []).join(",")}`);
+    if (mode === "callback") {
+        await startCallbackServer(ctx, port);
+        // keep process alive
+        for (;;) {
+            await sleep(60000);
+        }
+    }
+    await startPullWorker(ctx, intervalMs);
+}