@geteigen/cli 0.0.0-stage → 3.0.0

package/dist/cli/src/workerCore.js

@@ -0,0 +1,702 @@
+import { io } from "socket.io-client";
+import { arch, hostname, platform } from "os";
+import { detectAgentTools } from "./agentTools.js";
+import { createHash } from "crypto";
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { listLocalModelsForBackend } from "./listModels.js";
+import { runAgentWithHandle, abortRun, abortAll, isEditTool, getFileDiff, revertFiles, } from "./agent.js";
+import { listChatSessions } from "./listSessions.js";
+import { WorkRoots, finalizeGit, prepareRepo } from "./workRoots.js";
+import { checkoutWorkspaceGit, commitWorkspaceGit, getWorkspaceGit, listWorkspaceDir, pushWorkspaceGit, readWorkspaceFile, searchWorkspaceFiles, } from "./workspace.js";
+import { isSafeAttachmentRelPath, } from "../../shared/uploads.js";
+/**
+ * 6: worker:list-models accepts optional `backend` (cursor | claude-code | codex).
+ * 7: worker:run-prompt carries `mcpServers` (room tools + Integrations Hub).
+ * 8: worker:ready reports os / arch / client / detected agent CLIs.
+ * 9: machine credentials, worker:settings (allowed roots), list-dirs,
+ *    prepare-repo, finalize-git, per-run env, worker:revoked.
+ * 10: OpenCode backend + model listing.
+ * 11: workspace git snapshot and repo file browsing.
+ * 12: commit, push, and branch switching from the git panel.
+ */
+const WORKER_PROTOCOL = 12;
+const MAX_CONCURRENT = Number(process.env.STEER_MAX_CONCURRENT_AGENTS || 4);
+/** Match server attachFileDiff — wait for the working tree to flush. */
+const DIFF_WAIT_MS = 120;
+function writeWorkerAttachments(cwd, attachments) {
+    const root = resolve(cwd);
+    for (const file of attachments) {
+        if (!file?.relPath || !isSafeAttachmentRelPath(file.relPath)) {
+            throw new Error(`Invalid attachment path: ${file?.relPath || "(empty)"}`);
+        }
+        const abs = resolve(root, file.relPath);
+        if (abs !== root && !abs.startsWith(root + "/") && !abs.startsWith(root + "\\")) {
+            throw new Error(`Attachment escaped workspace: ${file.relPath}`);
+        }
+        mkdirSync(dirname(abs), { recursive: true });
+        writeFileSync(abs, Buffer.from(file.data, "base64"));
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function generateWorkerId(email) {
+    const raw = `${hostname()}-${email}`;
+    return createHash("sha256").update(raw).digest("hex").slice(0, 16);
+}
+function makeRunKey(roomId, agentId) {
+    return `${roomId}:${agentId}`;
+}
+/** Connect a local agent worker to the Steer server. */
+export function createWorker(options) {
+    const { serverUrl, token, repoPathOverride, pickFolder, log } = options;
+    const workerId = options.machineId || generateWorkerId(options.email);
+    const roots = new WorkRoots(options.workRoots ?? []);
+    let maxConcurrent = MAX_CONCURRENT;
+    log.info(`Connecting to ${serverUrl}`);
+    log.detail(`Worker ID: ${workerId}`);
+    log.detail(`Protocol: ${WORKER_PROTOCOL}`);
+    const activeRuns = new Map();
+    /** Last known repo root per room/agent — used for revert after runs finish. */
+    const revertRootByRunKey = new Map();
+    let runSeqCounter = 0;
+    const offlineQueue = [];
+    const lastSessionByAgent = new Map();
+    const MAX_QUEUE = 500;
+    const listActiveRuns = () => [...activeRuns.values()].map((r) => ({
+        roomId: r.roomId,
+        agentId: r.agentId,
+    }));
+    let state = "connecting";
+    let stateMessage;
+    const status = () => ({
+        state,
+        message: stateMessage,
+        workerId,
+        serverUrl,
+        activeRuns: listActiveRuns(),
+    });
+    const setState = (next, message) => {
+        state = next;
+        stateMessage = message;
+        options.onStatus?.(status());
+    };
+    /** Active runs changed — same connection state, new run list. */
+    const notifyRuns = () => options.onStatus?.(status());
+    const socket = io(`${serverUrl}/worker`, {
+        auth: { token },
+        reconnection: true,
+        reconnectionAttempts: Infinity,
+        reconnectionDelay: 2000,
+        reconnectionDelayMax: 30000,
+        transports: ["websocket", "polling"],
+    });
+    const emitOrQueue = (event, payload) => {
+        if (socket.connected) {
+            socket.emit(event, payload);
+            return;
+        }
+        if (offlineQueue.length >= MAX_QUEUE)
+            offlineQueue.shift();
+        offlineQueue.push({ event, payload });
+    };
+    const flushQueue = () => {
+        if (!offlineQueue.length)
+            return;
+        log.detail(`  Flushing ${offlineQueue.length} buffered event(s)…`);
+        const batch = offlineQueue.splice(0, offlineQueue.length);
+        for (const item of batch) {
+            socket.emit(item.event, item.payload);
+        }
+    };
+    // Which agent CLIs this machine has; refreshed on each (re)connect.
+    let agentTools = [];
+    const refreshAgentTools = () => detectAgentTools()
+        .then((tools) => {
+        agentTools = tools;
+    })
+        .catch(() => undefined);
+    const announceReady = () => {
+        const runs = listActiveRuns();
+        socket.emit("worker:ready", {
+            workerId,
+            machineName: hostname(),
+            os: platform(),
+            arch: arch(),
+            client: options.client ?? "cli",
+            agents: agentTools,
+            maxConcurrent,
+            protocol: WORKER_PROTOCOL,
+            activeRuns: runs,
+            // Legacy fields for older servers
+            activeRoomId: runs[0]?.roomId ?? null,
+            busy: runs.length > 0,
+        });
+    };
+    socket.on("connect", () => {
+        log.success("✓ Connected to server");
+        setState("connected");
+        if (activeRuns.size > 0) {
+            log.info(`  ${activeRuns.size} agent run(s) still going — resuming stream`);
+        }
+        announceReady();
+        // Tool detection can take a few seconds; send it once it's in.
+        void refreshAgentTools().then(() => {
+            if (socket.connected)
+                socket.emit("worker:info", { agents: agentTools });
+        });
+        flushQueue();
+    });
+    socket.on("disconnect", (reason) => {
+        log.warn(`Disconnected: ${reason}`);
+        setState("disconnected", reason);
+        if (activeRuns.size > 0) {
+            log.warn(`  ${activeRuns.size} agent(s) keep running locally (will sync on reconnect)`);
+        }
+    });
+    socket.on("connect_error", (err) => {
+        log.error(`Connection error: ${err.message}`);
+        setState("error", err.message);
+        // A revoked machine credential is rejected at the handshake — stop retrying.
+        if (options.machineId && /was removed|setup token/i.test(err.message)) {
+            socket.io.opts.reconnection = false;
+            socket.disconnect();
+            options.onRevoked?.(err.message);
+        }
+    });
+    socket.on("worker:run-prompt", (payload) => {
+        const { roomId, prompt, repoPath: payloadRepoPath, cwd: payloadCwd, modelId, } = payload;
+        const agentId = payload.agentId || "default";
+        const backendKind = payload.backend === "claude-code" ||
+            payload.backend === "codex" ||
+            payload.backend === "opencode"
+            ? payload.backend
+            : "cursor";
+        const mode = payload.mode === "plan" ? "plan" : "agent";
+        const runKey = makeRunKey(roomId, agentId);
+        const repoPath = repoPathOverride || payloadCwd || payloadRepoPath;
+        const cwd = payloadCwd || repoPath;
+        revertRootByRunKey.set(runKey, repoPath);
+        const sessionId = payload.sessionId || lastSessionByAgent.get(runKey) || null;
+        if (activeRuns.has(runKey)) {
+            log.warn(`  Rejecting new prompt — agent ${agentId} already running in room ${roomId}`);
+            emitOrQueue("worker:agent-event", {
+                roomId,
+                agentId,
+                event: {
+                    kind: "error",
+                    message: "This agent is already running another prompt",
+                },
+            });
+            emitOrQueue("worker:agent-event", {
+                roomId,
+                agentId,
+                event: { kind: "done", result: "" },
+            });
+            return;
+        }
+        const outside = [repoPath, cwd].find((p) => p && !roots.isAllowed(p));
+        if (outside) {
+            log.warn(`  Rejecting new prompt — ${outside} is outside this machine's allowed folders`);
+            emitOrQueue("worker:agent-event", {
+                roomId,
+                agentId,
+                event: {
+                    kind: "error",
+                    message: `This machine only runs agents inside ${roots.effective().join(", ")}. Pick a folder there.`,
+                },
+            });
+            emitOrQueue("worker:agent-event", {
+                roomId,
+                agentId,
+                event: { kind: "done", result: "" },
+            });
+            return;
+        }
+        if (activeRuns.size >= maxConcurrent) {
+            log.warn(`  Rejecting new prompt — max concurrent agents (${maxConcurrent}) reached`);
+            emitOrQueue("worker:agent-event", {
+                roomId,
+                agentId,
+                event: {
+                    kind: "error",
+                    message: `Worker is at max concurrent agents (${maxConcurrent})`,
+                },
+            });
+            emitOrQueue("worker:agent-event", {
+                roomId,
+                agentId,
+                event: { kind: "done", result: "" },
+            });
+            return;
+        }
+        const thisRun = ++runSeqCounter;
+        const runState = {
+            roomId,
+            agentId,
+            runSeq: thisRun,
+            editedPaths: new Map(),
+            pendingCallPaths: new Map(),
+            emittedTerminal: false,
+            abort: () => { },
+        };
+        activeRuns.set(runKey, runState);
+        notifyRuns();
+        if (payload.attachments?.length) {
+            try {
+                writeWorkerAttachments(cwd, payload.attachments);
+                log.detail(`  Saved ${payload.attachments.length} attachment(s) to ${cwd}/.steer-uploads`);
+            }
+            catch (err) {
+                const message = err.message || "Failed to save attached files";
+                log.error(`  ✗ ${message}`);
+                activeRuns.delete(runKey);
+                notifyRuns();
+                emitOrQueue("worker:agent-event", {
+                    roomId,
+                    agentId,
+                    event: { kind: "error", message },
+                });
+                emitOrQueue("worker:agent-event", {
+                    roomId,
+                    agentId,
+                    event: { kind: "done", result: "" },
+                });
+                return;
+            }
+        }
+        log.info(`\n━━━ Running prompt in room ${roomId} / agent ${agentId} ━━━`);
+        log.detail(`Cwd: ${cwd}`);
+        log.detail(`Backend: ${backendKind}`);
+        log.detail(`Model: ${modelId}`);
+        const mcpNames = Object.keys(payload.mcpServers || {});
+        if (mcpNames.length) {
+            // Names only — the entries carry bearer tokens.
+            log.detail(`MCP: ${mcpNames.join(", ")}`);
+        }
+        if (payload.env && Object.keys(payload.env).length) {
+            // Names only — values are provider keys.
+            log.detail(`Env: ${Object.keys(payload.env).join(", ")} (this run only)`);
+        }
+        log.detail(`Prompt: ${prompt.slice(0, 100)}${prompt.length > 100 ? "…" : ""}`);
+        // Process stream events in order. Fire-and-forget handlers used to race
+        // lock acquisition / git diffs ahead of later tool_done rows, so chat
+        // grouped cards often missed path + patch until the whole run finished.
+        let eventQueue = Promise.resolve();
+        const onEvent = (event) => {
+            eventQueue = eventQueue
+                .then(() => handleEvent(event))
+                .catch((err) => {
+                log.error(`  ✗ Event handler: ${err.message || String(err)}`);
+            });
+        };
+        const handleEvent = async (event) => {
+            const current = activeRuns.get(runKey);
+            if (!current || current.runSeq !== thisRun)
+                return;
+            let outgoing = event;
+            if (event.kind === "tool_start") {
+                log.warn(`  ▸ ${event.name} ${event.detail}`);
+                if (event.path && event.callId) {
+                    current.pendingCallPaths.set(event.callId, event.path);
+                }
+            }
+            else if (event.kind === "tool_done") {
+                const path = event.path ||
+                    (event.callId
+                        ? current.pendingCallPaths.get(event.callId)
+                        : undefined);
+                log.success(`  ✓ ${event.name}${path ? ` ${path}` : ` ${event.detail}`}`);
+                if (isEditTool(event.name) && path && event.callId) {
+                    current.editedPaths.set(path, event.callId);
+                    await sleep(DIFF_WAIT_MS);
+                    if (activeRuns.get(runKey)?.runSeq !== thisRun)
+                        return;
+                    let patch = event.diffPatch?.trim() || "";
+                    try {
+                        const git = (await getFileDiff(cwd, path)).trim();
+                        if (git)
+                            patch = git;
+                    }
+                    catch {
+                        // synthetic parser patch is still useful
+                    }
+                    outgoing = {
+                        ...event,
+                        path,
+                        diffPatch: patch || event.diffPatch,
+                    };
+                    if (patch) {
+                        emitOrQueue("worker:file-diff", {
+                            roomId,
+                            agentId,
+                            callId: event.callId,
+                            toolName: event.name || "edit",
+                            path,
+                            patch,
+                        });
+                    }
+                }
+            }
+            else if (event.kind === "assistant_final") {
+                log.info(`  Assistant: ${event.text.slice(0, 120)}…`);
+            }
+            else if (event.kind === "session") {
+                if (event.sessionId)
+                    lastSessionByAgent.set(runKey, event.sessionId);
+                log.detail(`  session ${event.sessionId}`);
+            }
+            else if (event.kind === "error") {
+                log.error(`  ✗ Error: ${event.message}`);
+            }
+            else if (event.kind === "done") {
+                log.success("  ✓ Agent finished");
+            }
+            if (outgoing.kind === "done" || outgoing.kind === "error") {
+                current.emittedTerminal = true;
+            }
+            emitOrQueue("worker:agent-event", { roomId, agentId, event: outgoing });
+        };
+        const finishRun = (terminal) => {
+            const current = activeRuns.get(runKey);
+            if (!current || current.runSeq !== thisRun)
+                return;
+            if (terminal && !current.emittedTerminal) {
+                emitOrQueue("worker:agent-event", {
+                    roomId,
+                    agentId,
+                    event: terminal,
+                });
+                current.emittedTerminal = true;
+            }
+            else if (!current.emittedTerminal) {
+                emitOrQueue("worker:agent-event", {
+                    roomId,
+                    agentId,
+                    event: { kind: "done", result: "" },
+                });
+                current.emittedTerminal = true;
+            }
+            activeRuns.delete(runKey);
+            notifyRuns();
+        };
+        const handle = runAgentWithHandle(cwd, prompt, modelId, onEvent, sessionId, runKey, backendKind, mode, payload.mcpServers, payload.env);
+        runState.abort = handle.abort;
+        handle.promise
+            .then(async () => {
+            await eventQueue;
+            const current = activeRuns.get(runKey);
+            if (!current || current.runSeq !== thisRun)
+                return;
+            for (const [filePath, callId] of current.editedPaths) {
+                try {
+                    const patch = await getFileDiff(cwd, filePath);
+                    if (patch) {
+                        emitOrQueue("worker:file-diff", {
+                            roomId,
+                            agentId,
+                            callId,
+                            toolName: "edit",
+                            path: filePath,
+                            patch,
+                        });
+                    }
+                }
+                catch {
+                    // diff failures are non-fatal
+                }
+            }
+            finishRun({ kind: "done", result: "" });
+        })
+            .catch(async (err) => {
+            await eventQueue;
+            const current = activeRuns.get(runKey);
+            if (!current || current.runSeq !== thisRun)
+                return;
+            const message = err.message || "Agent error";
+            log.error(`Agent error: ${message}`);
+            finishRun({ kind: "error", message });
+            emitOrQueue("worker:agent-event", {
+                roomId,
+                agentId,
+                event: { kind: "done", result: "" },
+            });
+        });
+    });
+    socket.on("worker:abort", (payload) => {
+        const agentId = payload.agentId;
+        if (agentId) {
+            const runKey = makeRunKey(payload.roomId, agentId);
+            log.warn(`  ⚠ Abort requested for ${payload.roomId}/${agentId}`);
+            const run = activeRuns.get(runKey);
+            run?.abort();
+            abortRun(runKey);
+            activeRuns.delete(runKey);
+        }
+        else {
+            // Legacy: abort all runs for the room
+            log.warn(`  ⚠ Abort requested for room ${payload.roomId}`);
+            for (const [key, run] of [...activeRuns.entries()]) {
+                if (run.roomId === payload.roomId) {
+                    run.abort();
+                    abortRun(key);
+                    activeRuns.delete(key);
+                }
+            }
+        }
+        notifyRuns();
+    });
+    socket.on("worker:revert-files", async (payload) => {
+        log.warn(`  ↺ Revert requested for ${payload.filePaths.length} file(s) in room ${payload.roomId}`);
+        const agentId = payload.agentId || "default";
+        const runKey = makeRunKey(payload.roomId, agentId);
+        const repoPath = payload.repoPath ||
+            revertRootByRunKey.get(runKey) ||
+            repoPathOverride ||
+            "";
+        if (!repoPath) {
+            emitOrQueue("worker:files-reverted", {
+                roomId: payload.roomId,
+                agentId: payload.agentId,
+                filePaths: [],
+                messageId: payload.messageId,
+                error: "No local repo path for this room — run an agent once or reconnect the worker with a repo",
+            });
+            return;
+        }
+        try {
+            const { reverted, errors } = await revertFiles(repoPath, payload.filePaths);
+            emitOrQueue("worker:files-reverted", {
+                roomId: payload.roomId,
+                agentId: payload.agentId,
+                filePaths: reverted,
+                messageId: payload.messageId,
+                error: errors.length ? errors.join("; ") : undefined,
+            });
+        }
+        catch (err) {
+            emitOrQueue("worker:files-reverted", {
+                roomId: payload.roomId,
+                agentId: payload.agentId,
+                filePaths: [],
+                messageId: payload.messageId,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    });
+    socket.on("worker:pick-folder", async (payload) => {
+        log.info("  📂 Opening folder picker…");
+        try {
+            const path = await pickFolder();
+            if (path) {
+                log.success(`  ✓ Selected: ${path}`);
+            }
+            else {
+                log.warn("  Folder pick cancelled");
+            }
+            emitOrQueue("worker:folder-picked", {
+                requestId: payload.requestId,
+                path,
+            });
+        }
+        catch (err) {
+            const message = err.message;
+            log.error(`  ✗ Folder picker error: ${message}`);
+            emitOrQueue("worker:folder-picked", {
+                requestId: payload.requestId,
+                path: null,
+                error: message,
+            });
+        }
+    });
+    socket.on("worker:list-models", async (payload) => {
+        const backend = payload.backend || "cursor";
+        const label = backend === "claude-code"
+            ? "Claude Code"
+            : backend === "codex"
+                ? "Codex"
+                : backend === "opencode"
+                    ? "OpenCode"
+                    : "Cursor";
+        log.info(`  Listing ${label} models…`);
+        try {
+            const models = await listLocalModelsForBackend(backend);
+            log.success(`  ✓ ${models.length} models`);
+            emitOrQueue("worker:models-listed", {
+                requestId: payload.requestId,
+                models,
+            });
+        }
+        catch (err) {
+            const message = err.message;
+            log.error(`  ✗ List models error: ${message}`);
+            emitOrQueue("worker:models-listed", {
+                requestId: payload.requestId,
+                error: message,
+            });
+        }
+    });
+    socket.on("worker:list-sessions", (payload) => {
+        log.info(`  Listing Cursor chats for ${payload.repoPath}…`);
+        try {
+            const sessions = listChatSessions(payload.repoPath);
+            log.success(`  ✓ ${sessions.length} chat(s)`);
+            emitOrQueue("worker:sessions-listed", {
+                requestId: payload.requestId,
+                sessions,
+            });
+        }
+        catch (err) {
+            const message = err.message;
+            log.error(`  ✗ List sessions error: ${message}`);
+            emitOrQueue("worker:sessions-listed", {
+                requestId: payload.requestId,
+                sessions: [],
+                error: message,
+            });
+        }
+    });
+    socket.on("worker:workspace-git", async (payload) => {
+        try {
+            if (!roots.isAllowed(payload.repoPath))
+                throw new Error("That folder is outside this machine's allowed folders");
+            const snapshot = await getWorkspaceGit(payload.repoPath);
+            emitOrQueue("worker:workspace-git-result", { requestId: payload.requestId, snapshot });
+        }
+        catch (err) {
+            emitOrQueue("worker:workspace-git-result", {
+                requestId: payload.requestId,
+                error: err.message || "Couldn't read git state",
+            });
+        }
+    });
+    socket.on("worker:workspace-git-action", async (payload) => {
+        try {
+            if (!roots.isAllowed(payload.repoPath))
+                throw new Error("That folder is outside this machine's allowed folders");
+            if (payload.action === "commit")
+                await commitWorkspaceGit(payload.repoPath, payload.message || "");
+            else if (payload.action === "push")
+                await pushWorkspaceGit(payload.repoPath);
+            else if (payload.action === "checkout")
+                await checkoutWorkspaceGit(payload.repoPath, payload.branch || "");
+            else
+                throw new Error("Unknown git action");
+            emitOrQueue("worker:workspace-git-action-result", { requestId: payload.requestId, ok: true });
+        }
+        catch (err) {
+            emitOrQueue("worker:workspace-git-action-result", {
+                requestId: payload.requestId,
+                error: err.message || "Git failed",
+            });
+        }
+    });
+    socket.on("worker:workspace-dir", async (payload) => {
+        try {
+            if (!roots.isAllowed(payload.repoPath))
+                throw new Error("That folder is outside this machine's allowed folders");
+            const entries = await listWorkspaceDir(payload.repoPath, payload.path);
+            emitOrQueue("worker:workspace-dir-result", { requestId: payload.requestId, entries });
+        }
+        catch (err) {
+            emitOrQueue("worker:workspace-dir-result", {
+                requestId: payload.requestId,
+                error: err.message || "Couldn't list files",
+            });
+        }
+    });
+    socket.on("worker:workspace-file", async (payload) => {
+        try {
+            if (!roots.isAllowed(payload.repoPath))
+                throw new Error("That folder is outside this machine's allowed folders");
+            const file = await readWorkspaceFile(payload.repoPath, payload.path);
+            emitOrQueue("worker:workspace-file-result", { requestId: payload.requestId, file });
+        }
+        catch (err) {
+            emitOrQueue("worker:workspace-file-result", {
+                requestId: payload.requestId,
+                error: err.message || "Couldn't read file",
+            });
+        }
+    });
+    socket.on("worker:workspace-search", async (payload) => {
+        try {
+            if (!roots.isAllowed(payload.repoPath))
+                throw new Error("That folder is outside this machine's allowed folders");
+            const matches = await searchWorkspaceFiles(payload.repoPath, payload.query);
+            emitOrQueue("worker:workspace-search-result", { requestId: payload.requestId, matches });
+        }
+        catch (err) {
+            emitOrQueue("worker:workspace-search-result", {
+                requestId: payload.requestId,
+                error: err.message || "Couldn't search files",
+            });
+        }
+    });
+    socket.on("worker:settings", (data) => {
+        roots.setServerRoots(Array.isArray(data?.allowedRoots) ? data.allowedRoots : []);
+        if (typeof data?.maxConcurrent === "number" && data.maxConcurrent > 0) {
+            maxConcurrent = Math.min(16, Math.floor(data.maxConcurrent));
+        }
+        const allowed = roots.effective();
+        log.detail(`  Settings: up to ${maxConcurrent} agents${allowed.length ? ` · folders: ${allowed.join(", ")}` : ""}`);
+    });
+    socket.on("worker:list-dirs", (payload) => {
+        try {
+            const listing = roots.listDirs(payload.path || undefined);
+            emitOrQueue("worker:dirs-listed", { requestId: payload.requestId, listing });
+        }
+        catch (err) {
+            emitOrQueue("worker:dirs-listed", {
+                requestId: payload.requestId,
+                error: err.message || "Couldn't list folders",
+            });
+        }
+    });
+    socket.on("worker:prepare-repo", async (payload) => {
+        log.info(payload.repoUrl ? `  ⤓ Preparing ${payload.repoUrl} (${payload.ref || "main"})…` : "  Preparing a workspace…");
+        try {
+            const path = await prepareRepo(roots, payload);
+            log.success(`  ✓ Ready at ${path}`);
+            emitOrQueue("worker:repo-prepared", { requestId: payload.requestId, path });
+        }
+        catch (err) {
+            const message = err.message || "Couldn't prepare the repository";
+            log.error(`  ✗ ${message}`);
+            emitOrQueue("worker:repo-prepared", { requestId: payload.requestId, error: message });
+        }
+    });
+    socket.on("worker:finalize-git", async (payload) => {
+        log.info(`  ⤒ Pushing ${payload.branch}…`);
+        try {
+            const result = await finalizeGit(roots, payload);
+            log.success(result.pushed ? `  ✓ Pushed ${result.branch}` : "  Nothing to push");
+            emitOrQueue("worker:git-finalized", { requestId: payload.requestId, ...result });
+        }
+        catch (err) {
+            const message = err.message || "Couldn't push changes";
+            log.error(`  ✗ ${message}`);
+            emitOrQueue("worker:git-finalized", { requestId: payload.requestId, error: message });
+        }
+    });
+    socket.on("worker:revoked", (data) => {
+        const message = data?.message || "This machine was removed in Eigen.";
+        log.warn(`  ${message}`);
+        abortAll();
+        activeRuns.clear();
+        socket.io.opts.reconnection = false;
+        socket.disconnect();
+        setState("error", message);
+        options.onRevoked?.(message);
+    });
+    return {
+        workerId,
+        status,
+        stop() {
+            abortAll();
+            activeRuns.clear();
+            socket.disconnect();
+        },
+    };
+}