@konglx/rotom 2.21.0

package/dist/executor/session-store.js

@@ -0,0 +1,188 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createLogger } from "../shared/logger.js";
+const log = createLogger("mesh-executor-session-store", { stream: "stderr" });
+/**
+ * In-memory registry of conversation sessions per group per CLI.
+ *
+ * Persistence moved to master DB (`agent_sessions` table). On startup the
+ * worker receives a `session_sync_push` from master with all its active
+ * sessions; mutations are pushed back via `session_snapshot`. The old
+ * `~/.rotom/sessions.json` file is gone — master is the single source of
+ * truth, which fixes the multi-worker flush-overwrite bug and lets the
+ * dashboard surface full session history (including invalidated ones).
+ *
+ * Key format: `${cliTool}:${groupId}` → StoredSession
+ */
+export class SessionStore {
+    sessions = new Map();
+    /** Populate from master's session_sync_push on startup. Merges with any
+     *  existing in-memory state (e.g. legacy backfill) — master entries only
+     *  fill in (cliTool, groupId) pairs the store doesn't already have. */
+    hydrate(entries) {
+        let added = 0;
+        for (const e of entries) {
+            const k = this.key(e.cliTool, e.groupId);
+            if (this.sessions.has(k))
+                continue;
+            const stored = { sessionId: e.sessionId };
+            if (e.usage)
+                stored.usage = e.usage;
+            if (e.model)
+                stored.model = e.model;
+            if (typeof e.cumulativeCostUsd === "number")
+                stored.cumulativeCostUsd = e.cumulativeCostUsd;
+            if (typeof e.cumulativeInputTokens === "number")
+                stored.cumulativeInputTokens = e.cumulativeInputTokens;
+            if (typeof e.cumulativeOutputTokens === "number")
+                stored.cumulativeOutputTokens = e.cumulativeOutputTokens;
+            if (typeof e.cumulativeCacheReadTokens === "number")
+                stored.cumulativeCacheReadTokens = e.cumulativeCacheReadTokens;
+            if (typeof e.cumulativeCacheCreationTokens === "number")
+                stored.cumulativeCacheCreationTokens = e.cumulativeCacheCreationTokens;
+            this.sessions.set(k, stored);
+            added++;
+        }
+        if (added > 0) {
+            log.info(`Hydrated ${added} session(s) from master (of ${entries.length} pushed)`);
+        }
+    }
+    /**
+     * One-time migration: read the legacy `~/.rotom/sessions.json` file and
+     * populate the in-memory store. The file is deleted after reading so
+     * subsequent starts don't re-backfill (which would overwrite newer DB
+     * state). Safe to call multiple times — no-op if the file is gone.
+     *
+     * Called once from executor index.ts after constructing the shared
+     * SessionStore. After this, master DB is the source of truth.
+     */
+    backfillFromLegacyJson(rotomHome) {
+        const file = path.join(rotomHome, "sessions.json");
+        let raw;
+        try {
+            raw = fs.readFileSync(file, "utf-8");
+        }
+        catch {
+            return; // file gone or never existed — normal path after first migration
+        }
+        try {
+            const data = JSON.parse(raw);
+            let count = 0;
+            for (const [k, v] of Object.entries(data)) {
+                const sep = k.indexOf(":");
+                if (sep === -1)
+                    continue;
+                const cliTool = k.slice(0, sep);
+                const groupId = k.slice(sep + 1);
+                if (typeof v === "string") {
+                    this.sessions.set(k, { sessionId: v });
+                    count++;
+                }
+                else if (v && typeof v === "object" && typeof v.sessionId === "string") {
+                    const obj = v;
+                    const stored = { sessionId: obj.sessionId };
+                    if (obj.usage)
+                        stored.usage = obj.usage;
+                    if (obj.model)
+                        stored.model = obj.model;
+                    if (typeof obj.cumulativeCostUsd === "number")
+                        stored.cumulativeCostUsd = obj.cumulativeCostUsd;
+                    this.sessions.set(k, stored);
+                    count++;
+                }
+            }
+            log.info(`Backfilled ${count} session(s) from legacy ${file}`);
+            // Delete the file so we never re-backfill (would clobber DB state).
+            try {
+                fs.unlinkSync(file);
+                log.info(`Removed legacy ${file}`);
+            }
+            catch (err) {
+                log.warn(`Failed to remove legacy ${file}: ${err.message}`);
+            }
+        }
+        catch (err) {
+            log.warn(`Failed to parse legacy ${file}: ${err.message} (leaving file in place)`);
+        }
+    }
+    key(cliTool, groupId) {
+        return `${cliTool}:${groupId}`;
+    }
+    get(cliTool, groupId) {
+        return this.sessions.get(this.key(cliTool, groupId))?.sessionId;
+    }
+    set(cliTool, groupId, sessionId) {
+        // Preserve existing usage/model when the sessionId is being refreshed
+        // (e.g. a new chat turn returned the same sessionId). If the sessionId
+        // truly changed, clear stale usage — the new session has no turns yet.
+        const k = this.key(cliTool, groupId);
+        const existing = this.sessions.get(k);
+        if (existing && existing.sessionId === sessionId) {
+            this.sessions.set(k, { ...existing, sessionId });
+        }
+        else {
+            this.sessions.set(k, { sessionId });
+        }
+    }
+    /** Record the latest usage/model captured from the CLI backend for this
+     *  session. No-op if no session exists for (cliTool, groupId). */
+    recordUsage(cliTool, groupId, usage, model) {
+        const k = this.key(cliTool, groupId);
+        const existing = this.sessions.get(k);
+        if (!existing)
+            return;
+        // Only update if there's something to record — avoids bumping state
+        // on every chat turn that reports nothing.
+        if (!usage && !model)
+            return;
+        // 累加 cost + tokens:每次 turn 的值加到 cumulative 字段。
+        // usage 本身仍整体覆盖(保留"最近一 turn 用量"语义,tooltip 用)。
+        const turnCost = typeof usage?.totalCostUsd === "number" ? usage.totalCostUsd : 0;
+        const turnIn = typeof usage?.inputTokens === "number" ? usage.inputTokens : 0;
+        const turnOut = typeof usage?.outputTokens === "number" ? usage.outputTokens : 0;
+        const turnCacheRead = typeof usage?.cacheReadTokens === "number" ? usage.cacheReadTokens : 0;
+        const turnCacheCreation = typeof usage?.cacheCreationTokens === "number" ? usage.cacheCreationTokens : 0;
+        this.sessions.set(k, {
+            ...existing,
+            ...(usage ? { usage } : {}),
+            ...(model ? { model } : {}),
+            cumulativeCostUsd: (existing.cumulativeCostUsd ?? 0) + turnCost,
+            cumulativeInputTokens: (existing.cumulativeInputTokens ?? 0) + turnIn,
+            cumulativeOutputTokens: (existing.cumulativeOutputTokens ?? 0) + turnOut,
+            cumulativeCacheReadTokens: (existing.cumulativeCacheReadTokens ?? 0) + turnCacheRead,
+            cumulativeCacheCreationTokens: (existing.cumulativeCacheCreationTokens ?? 0) + turnCacheCreation,
+        });
+    }
+    delete(cliTool, groupId) {
+        this.sessions.delete(this.key(cliTool, groupId));
+    }
+    has(cliTool, groupId, sessionId) {
+        return this.sessions.get(this.key(cliTool, groupId))?.sessionId === sessionId;
+    }
+    /**
+     * Return every entry in the store, parsed from the `${cliTool}:${groupId}`
+     * keys. Used by the worker's session_snapshot push so master can persist
+     * to DB.
+     */
+    listAll() {
+        const out = [];
+        for (const [k, stored] of this.sessions) {
+            const sep = k.indexOf(":");
+            if (sep === -1)
+                continue;
+            out.push({
+                cliTool: k.slice(0, sep),
+                groupId: k.slice(sep + 1),
+                sessionId: stored.sessionId,
+                ...(stored.usage ? { usage: stored.usage } : {}),
+                ...(stored.model ? { model: stored.model } : {}),
+                ...(typeof stored.cumulativeCostUsd === "number" ? { cumulativeCostUsd: stored.cumulativeCostUsd } : {}),
+                ...(typeof stored.cumulativeInputTokens === "number" ? { cumulativeInputTokens: stored.cumulativeInputTokens } : {}),
+                ...(typeof stored.cumulativeOutputTokens === "number" ? { cumulativeOutputTokens: stored.cumulativeOutputTokens } : {}),
+                ...(typeof stored.cumulativeCacheReadTokens === "number" ? { cumulativeCacheReadTokens: stored.cumulativeCacheReadTokens } : {}),
+                ...(typeof stored.cumulativeCacheCreationTokens === "number" ? { cumulativeCacheCreationTokens: stored.cumulativeCacheCreationTokens } : {}),
+            });
+        }
+        return out;
+    }
+}

package/dist/executor/worker-chat.js

@@ -0,0 +1,257 @@
+/**
+ * ChatHandler — group chat replies for ExecutorWorker.
+ *
+ * handleChatReply serves @mention / DM turns; the activeTasks key is
+ * `chat:${requestId}` so the WS router's `chat_cancelled` branch can find it.
+ * Shares session/usage bookkeeping via the worker's SessionStore.
+ */
+import { composePrompt } from "../shared/prompt-composer.js";
+import { createLogger } from "../shared/logger.js";
+const log = createLogger("mesh-executor-worker-chat", { stream: "stderr" });
+export class ChatHandler {
+    worker;
+    /** 同群 chat 队列:groupId → 待处理消息队列。同群串行,保证 session 不丢。 */
+    groupChatQueues = new Map();
+    groupChatActive = new Set();
+    constructor(worker) {
+        this.worker = worker;
+    }
+    async handleChatReply(requestId, content, fromName, conversation, cwdOverride, repoCtx) {
+        const taskKey = `chat:${requestId}`;
+        if (this.worker.activeTasks.has(taskKey))
+            return;
+        const groupId = conversation?.id ?? conversation?.groupId ?? "";
+        // 同群串行:若该群已有活跃 chat 任务,排队等当前任务结束(session 已存)再处理。
+        // 避免新 chat 开新 session 丢失上下文(ask-bridge 复述到达时 A 的原始 turn 可能还没结束)。
+        if (groupId && this.groupChatActive.has(groupId)) {
+            const queue = this.groupChatQueues.get(groupId) ?? [];
+            queue.push({ requestId, content, fromName, conversation, cwdOverride, repoCtx });
+            this.groupChatQueues.set(groupId, queue);
+            log.info(this.worker.tag, `Chat from ${fromName} queued for group ${groupId} (queue=${queue.length})`);
+            return;
+        }
+        await this.runChatReply(requestId, content, fromName, conversation, cwdOverride, groupId, undefined, repoCtx);
+    }
+    async runChatReply(requestId, content, fromName, conversation, cwdOverride, groupId, mergedSiblings, repoCtx) {
+        const taskKey = `chat:${requestId}`;
+        // cwd 优先用 master 推送(Dashboard 群工作目录 / per-agent override);
+        // 本机不存在或未推送时回落本地派生(<workingDirMap[groupId]> 或 <base>/<groupId>)。
+        // 旧的 conversation.workingDir 仍忽略(那是展示元数据,与 spawn 无关)。
+        // group 配了 repo 且同机时 master 在 a2a_message 里下发 repoCtx,这里走 group 模式
+        // 共享 worktree(<groupDir>/repos/primary/),让 chat 也能查 repo 代码。
+        const resolveChatCwd = async () => this.worker.resolveIssueCwd(groupId || undefined, cwdOverride, repoCtx);
+        if (this.worker.activeTasks.size >= this.worker.maxConcurrent) {
+            this.worker.sendChatEnd(requestId, `[系统] 当前任务繁忙，请稍后再试`, conversation, await resolveChatCwd());
+            return;
+        }
+        const controller = new AbortController();
+        const task = { aborted: false, controller };
+        this.worker.activeTasks.set(taskKey, task);
+        if (groupId)
+            this.groupChatActive.add(groupId);
+        const body = content.replace(`@${this.worker.config.name}`, "").trim();
+        if (!body) {
+            this.worker.activeTasks.delete(taskKey);
+            this.dequeueNextChat(groupId);
+            this.worker.sendChatEnd(requestId, "你好，有什么可以帮你的？", conversation, await resolveChatCwd());
+            return;
+        }
+        // Resolve session for this group
+        const sessionId = groupId ? this.worker.sessions.get(this.worker.cliTool, groupId) : undefined;
+        const cwd = await resolveChatCwd();
+        // 拼 prompt:rotom-cli → agent-role → group-basic → cwd → task。
+        // group 信息从 conversation 抽出(master 已 enrich 过 activeIssues / groupName)。
+        // fromName 告诉 agent 这条消息是谁发的,避免 agent 不知道对话方身份。
+        const composed = composePrompt({
+            mode: "chat",
+            agentName: this.worker.config.name,
+            agentProfile: this.worker.agentProfile,
+            group: conversation?.groupId
+                ? {
+                    id: conversation.groupId,
+                    name: conversation.groupName || conversation.groupId,
+                    activeIssues: conversation.activeIssues ?? [],
+                    guidancePrompt: conversation.guidancePrompt ?? null,
+                    memoryCounts: conversation.memoryCounts,
+                    skillCount: conversation.skillCount,
+                }
+                : null,
+            cwd,
+            fromName: fromName || null,
+            body,
+        });
+        log.info(this.worker.tag, `Session lookup: cliTool=${this.worker.cliTool}, groupId=${groupId}, sessionId=${sessionId ?? "(none)"}, conversation=${JSON.stringify(conversation)}`);
+        log.info(this.worker.tag, `Replying to ${fromName}: ${composed.final.slice(0, 60)}...`);
+        // 合并 turn:把合并用的 composedPrompt 挂到 sibling 气泡上,让 dashboard
+        // "查看 prompt"在每个被合并的 bubble 都能打开(否则 sibling 只有一条系统
+        // 文案,hasPrompt=false,按钮不出现)。sibling 的 loading bubble 也由此关闭。
+        if (mergedSiblings && mergedSiblings.length > 0) {
+            for (const sib of mergedSiblings) {
+                this.worker.sendChatEnd(sib.requestId, "[系统] 已合并到下一条回复", sib.conversation, undefined, composed);
+            }
+        }
+        // 提到 try 块外:catch 路径下(子进程被 SIGTERM 后某些 executor 会 throw)
+        // 仍要拿着已积累的 partial content 走 cancelled 终态,否则传空字符串给
+        // master 会把前端已经看到的流式内容覆盖成空。
+        let fullContent = "";
+        try {
+            // Chat replies (DM + @-mention in groups) intentionally do NOT pass
+            // onApprovalRequest. Rationale:
+            //   • Conversational tool calls should feel snappy — pausing for a
+            //     human Accept/Deny breaks the chat UX.
+            //   • Codex chat sessions are resumed by sessionId; a denied tool call
+            //     leaves an "assistant tool_calls without matching tool message"
+            //     hole in the conversation history, which makes the NEXT chat turn
+            //     fail with `invalid_request_error: An assistant message with
+            //     'tool_calls' must be followed by tool messages…`.
+            // File writes here still need a backing in-progress issue (the prompt
+            // tells the agent so — see composePrompt group-basic active_issues block).
+            const execOptions = {
+                signal: controller.signal,
+                env: this.worker.agentEnv(),
+                kind: "chat",
+                // 2-minute hard wall-clock cap on chat replies. Without this a
+                // hanging openclaw subprocess can tie up the worker's
+                // activeTasks slot until the user gives up and the daemon
+                // restarts. Executors pass this through to `--timeout` AND set
+                // a defensive SIGKILL after a small grace.
+                timeoutMs: 120_000,
+            };
+            if (sessionId)
+                execOptions.sessionId = sessionId;
+            // cwd 按 groupId 派生
+            const result = await this.worker.executor.execute(composed.final, cwd, (chunk) => {
+                if (task.aborted)
+                    return;
+                fullContent += chunk;
+                this.worker.sendChatChunk(requestId, chunk);
+            }, execOptions);
+            // Drop the cached sessionId if the executor reports the conversation
+            // history is poisoned (e.g. dangling tool_calls, or a terminal
+            // provider error — see HermesCliExecutor's provider error sniffer).
+            // Next chat turn will start fresh instead of trying to resume into
+            // a broken transcript.
+            //
+            // 中断态不视为 poison —— codex 的 turn_aborted 走自己的清理路径,
+            // session 可以正常续聊。只有 invalidateSession=true 且非用户主动中断
+            // 时才丢弃 sessionId。
+            if (groupId && result.invalidateSession && !task.aborted) {
+                // 失效前抓住 sessionId,通知 master 在 DB 里打 invalidated_at 戳(保留历史)。
+                const invalidatedSessionId = sessionId;
+                this.worker.sessions.delete(this.worker.cliTool, groupId);
+                log.warn(this.worker.tag, `Session invalidated: ${this.worker.cliTool}:${groupId}` +
+                    (result.failed ? " (provider error)" : " (poisoned history)"));
+                if (invalidatedSessionId) {
+                    this.worker.send({
+                        type: "session_invalidated",
+                        cliTool: this.worker.cliTool,
+                        groupId,
+                        sessionId: invalidatedSessionId,
+                    });
+                }
+                this.worker.sendSessionSnapshot();
+            }
+            else {
+                // Persist sessionId for future messages in this group. Even when
+                // result.sessionId is absent (some backends only return it on the
+                // first turn), the existing session is still valid — record usage
+                // so the Debug view can show this chat session's own token cost.
+                if (groupId && result.sessionId) {
+                    this.worker.sessions.set(this.worker.cliTool, groupId, result.sessionId);
+                    log.info(this.worker.tag, `Session stored: ${this.worker.cliTool}:${groupId} → ${result.sessionId}`);
+                }
+                if (groupId && (result.usage || result.model)) {
+                    this.worker.sessions.recordUsage(this.worker.cliTool, groupId, result.usage, result.model);
+                    // Snapshot push is needed so master picks up the new usage/model.
+                    // Coalesce with the set() push above by always sending here when
+                    // we recorded anything.
+                    this.worker.sendSessionSnapshot();
+                }
+                else if (groupId && result.sessionId) {
+                    this.worker.sendSessionSnapshot();
+                }
+            }
+            if (task.aborted) {
+                // 用户中断:已积累的 partial content 落库(走 master 的 cancelled_at 路径),
+                // bubble 切到「已中断」状态。不暴露 executor 返回的 aborted 错误文案 ——
+                // 用户自己点的中断,不需要再看"turn was aborted" 之类的内部噪声。
+                this.worker.sendChatEnd(requestId, fullContent, conversation, cwd, undefined, { cancelled: true });
+                log.info(this.worker.tag, `Reply cancelled mid-stream to ${fromName} (kept ${fullContent.length} chars)`);
+            }
+            else {
+                // Provider-error path: executor detected a terminal model failure
+                // (e.g. hermes's "API call failed after N retries: …" reply, which
+                // is not a legitimate assistant message). Surface it as a clean
+                // [错误] notice instead of streaming the error string as the
+                // agent's "answer". The dashboard's status pill is already on
+                // "Failed" from the executor's [status:Failed] emit.
+                if (result.failed) {
+                    const reason = result.errorMessage || "unknown provider error";
+                    this.worker.sendChatEnd(requestId, `[错误] 模型调用失败：${reason}\n（已清空会话上下文,下一条消息将重新开始）`, conversation, cwd, composed);
+                    log.error(this.worker.tag, `Provider error surfaced to ${fromName}: ${reason}`);
+                }
+                else {
+                    this.worker.sendChatEnd(requestId, fullContent, conversation, cwd, composed);
+                    log.info(this.worker.tag, `Reply sent to ${fromName} (${fullContent.length} chars)`);
+                }
+            }
+        }
+        catch (err) {
+            if (task.aborted) {
+                // 子进程被 SIGTERM/SIGKILL 时 executor 可能 throw(SIGNAL error),
+                // 这是用户主动取消的预期结果,走 cancelled 终态而不是 error。
+                this.worker.sendChatEnd(requestId, fullContent, conversation, cwd, undefined, { cancelled: true });
+                log.info(this.worker.tag, `Reply cancelled (executor threw on abort) to ${fromName} (kept ${fullContent.length} chars)`);
+            }
+            else {
+                this.worker.sendChatEnd(requestId, `[错误] ${err.message}`, conversation, cwd, composed);
+                log.error(this.worker.tag, "Reply error:", err.message);
+            }
+        }
+        finally {
+            this.worker.activeTasks.delete(taskKey);
+            this.dequeueNextChat(groupId);
+        }
+    }
+    /** 当前群 chat 任务结束,从队列取下一条处理。session 已存,新任务能复用。
+     *  积压合并:队列里有 ≥2 条待处理时,取最多 MAX_MERGE=3 条合并成一次 turn
+     *  (首条 requestId 作主回复流,其余发系统文案 bubble 关闭 loading),省 LLM 调用。
+     */
+    dequeueNextChat(groupId) {
+        if (!groupId)
+            return;
+        this.groupChatActive.delete(groupId);
+        const queue = this.groupChatQueues.get(groupId);
+        if (!queue || queue.length === 0) {
+            this.groupChatQueues.delete(groupId);
+            return;
+        }
+        const MAX_MERGE = 3;
+        const batch = queue.splice(0, Math.min(MAX_MERGE, queue.length));
+        if (queue.length === 0)
+            this.groupChatQueues.delete(groupId);
+        if (batch.length === 1) {
+            const n = batch[0];
+            log.info(this.worker.tag, `Dequeue chat from ${n.fromName} for group ${groupId} (remaining=${queue.length})`);
+            this.runChatReply(n.requestId, n.content, n.fromName, n.conversation, n.cwdOverride, groupId, undefined, n.repoCtx).catch((err) => {
+                log.error(this.worker.tag, "Dequeued chat error:", err.message);
+            });
+            return;
+        }
+        // 合并:首条作主 requestId 流式回复,其余 sibling 在 runChatReply compose 完后
+        // 用同一份 composedPrompt 关闭 loading(让 dashboard 每个 sibling 都能查看 prompt)。
+        const primary = batch[0];
+        const mergedNames = batch.map((b) => b.fromName).join(", ");
+        const siblings = batch.slice(1).map((b) => ({ requestId: b.requestId, conversation: b.conversation }));
+        // 合并 body:每条标 [from=X] 让 agent 区分发送者;fromName 传 null 避免 composePrompt
+        // 再加单 sender 头(多 sender 已在 body 内标注)。
+        const mentionTag = `@${this.worker.config.name}`;
+        const mergedBody = batch
+            .map((b) => `[from=${b.fromName}]\n${b.content.replace(mentionTag, "").trim()}`)
+            .join("\n\n---\n\n");
+        log.info(this.worker.tag, `Dequeue merged chat for group ${groupId} (merged=${batch.length}, from=[${mergedNames}], remaining=${queue.length})`);
+        this.runChatReply(primary.requestId, mergedBody, null, primary.conversation, primary.cwdOverride, groupId, siblings, primary.repoCtx).catch((err) => {
+            log.error(this.worker.tag, "Dequeued merged chat error:", err.message);
+        });
+    }
+}

package/dist/executor/worker-connection.js

@@ -0,0 +1,89 @@
+/**
+ * WorkerConnection — WS lifecycle for ExecutorWorker.
+ *
+ * Owns heartbeat + reconnect timers. The underlying `ws` socket lives on the
+ * worker (shared with send helpers), this module just wires connect/reconnect
+ * and routes incoming messages back to `worker.handleMessage`.
+ */
+import { WebSocket } from "ws";
+import os from "node:os";
+import { randomUUID } from "node:crypto";
+import { decodeJson } from "../shared/json-codec.js";
+import { createLogger } from "../shared/logger.js";
+const log = createLogger("mesh-executor-worker-connection", { stream: "stderr" });
+export class WorkerConnection {
+    worker;
+    heartbeatTimer = null;
+    reconnectTimer = null;
+    constructor(worker) {
+        this.worker = worker;
+    }
+    start() {
+        this.worker.stopped = false;
+        this.connect();
+    }
+    stop() {
+        this.worker.stopped = true;
+        if (this.heartbeatTimer)
+            clearInterval(this.heartbeatTimer);
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        if (this.worker.ws)
+            this.worker.ws.close(1000, "shutdown");
+    }
+    /** Called from handleMessage on auth_ok. Starts the 10s heartbeat loop. */
+    startHeartbeat() {
+        this.heartbeatTimer = setInterval(() => {
+            if (this.worker.ws?.readyState === WebSocket.OPEN) {
+                this.worker.ws.send(JSON.stringify({ type: "heartbeat" }));
+            }
+        }, 10_000);
+    }
+    wsUrl() {
+        let url = this.worker.masterUrl;
+        if (!url.endsWith("/ws"))
+            url += "/ws";
+        return url;
+    }
+    connect() {
+        if (this.worker.stopped)
+            return;
+        const url = this.wsUrl();
+        const cliName = this.worker.config.cliTool || "auto";
+        log.info(this.worker.tag, "Connecting to", url, `(cli: ${cliName}, cwd: ${this.worker.workingDir})`);
+        this.worker.ws = new WebSocket(url);
+        this.worker.ws.on("open", () => {
+            this.worker.ws.send(JSON.stringify({
+                type: "auth",
+                name: this.worker.config.name,
+                token: this.worker.config.token,
+                version: 2,
+                profile: this.worker.config.profile || {},
+                cliTool: this.worker.cliTool,
+                instance: {
+                    instanceId: `${os.hostname()}-${process.pid}-${randomUUID()}`,
+                    hostname: os.hostname(),
+                    platform: `${process.platform} ${process.arch}`,
+                    endpoint: this.worker.masterUrl,
+                },
+            }));
+        });
+        this.worker.ws.on("message", (raw) => {
+            const msg = decodeJson(raw);
+            if (!msg)
+                return;
+            this.worker.handleMessage(msg);
+        });
+        this.worker.ws.on("close", () => {
+            log.info(this.worker.tag, "Disconnected, reconnecting in 3s...");
+            if (this.heartbeatTimer)
+                clearInterval(this.heartbeatTimer);
+            if (!this.worker.stopped) {
+                this.reconnectTimer = setTimeout(() => this.connect(), 3_000);
+            }
+        });
+        this.worker.ws.on("error", (err) => {
+            log.error(this.worker.tag, "WS error:", err.message);
+        });
+    }
+}