@seele00/seele 0.1.60

package/server/dist/runtime-worker/process.js

@@ -0,0 +1,216 @@
+import { readRuntimeThread, rebuildRuntimeThread, listRuntimeModels, readRuntimeRateLimits, runStreamedTurn, } from "../codex-runtime/run-streamed-turn.js";
+const activeTurns = new Map();
+const heartbeatTimers = new Map();
+process.on("message", (message) => {
+    void handleMessage(message).catch((error) => {
+        send({
+            type: "turn.worker_error",
+            message: error instanceof Error ? error.message : String(error),
+        });
+    });
+});
+async function handleMessage(message) {
+    if (message.type === "runtime.rate_limits.read") {
+        const { operationId, config } = message.payload;
+        try {
+            const result = await readRuntimeRateLimits(config);
+            send({
+                type: "runtime.rate_limits.read.completed",
+                operationId,
+                result,
+            });
+        }
+        catch (error) {
+            send({
+                type: "runtime.operation_failed",
+                operationId,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            scheduleExit();
+        }
+        return;
+    }
+    if (message.type === "runtime.models.list") {
+        const { operationId, config } = message.payload;
+        try {
+            const result = await listRuntimeModels(config);
+            send({
+                type: "runtime.models.list.completed",
+                operationId,
+                result,
+            });
+        }
+        catch (error) {
+            send({
+                type: "runtime.operation_failed",
+                operationId,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            scheduleExit();
+        }
+        return;
+    }
+    if (message.type === "thread.read") {
+        const { operationId, config, request } = message.payload;
+        try {
+            const result = await readRuntimeThread(config, request);
+            send({
+                type: "thread.read.completed",
+                operationId,
+                result,
+            });
+        }
+        catch (error) {
+            send({
+                type: "runtime.operation_failed",
+                operationId,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            scheduleExit();
+        }
+        return;
+    }
+    if (message.type === "thread.rebuild") {
+        const { operationId, config, request, injectedItems } = message.payload;
+        try {
+            const result = await rebuildRuntimeThread(config, request, injectedItems);
+            send({
+                type: "thread.rebuild.completed",
+                operationId,
+                result,
+            });
+        }
+        catch (error) {
+            send({
+                type: "runtime.operation_failed",
+                operationId,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            scheduleExit();
+        }
+        return;
+    }
+    if (message.type === "turn.start") {
+        const { turnId, config, request } = message.payload;
+        send({
+            type: "worker.ready",
+            turnId,
+        });
+        startHeartbeat(turnId);
+        try {
+            const result = await runStreamedTurn(config, request, undefined, {
+                onEvent: (event, data) => send({
+                    type: "turn.event",
+                    turnId,
+                    event,
+                    data,
+                }),
+                onActiveTurn: (control) => activeTurns.set(turnId, control),
+                onInactiveTurn: (control) => {
+                    if (activeTurns.get(turnId) === control) {
+                        activeTurns.delete(turnId);
+                    }
+                },
+            });
+            if (result) {
+                send({
+                    type: "turn.completed",
+                    turnId,
+                    result,
+                });
+            }
+            else {
+                send({
+                    type: "turn.failed",
+                    turnId,
+                    message: "Codex turn failed",
+                });
+            }
+        }
+        catch (error) {
+            send({
+                type: "turn.failed",
+                turnId,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            activeTurns.delete(turnId);
+            stopHeartbeat(turnId);
+            scheduleExit();
+        }
+        return;
+    }
+    if (message.type === "turn.stop") {
+        const control = activeTurns.get(message.payload.turnId);
+        if (!control) {
+            send({
+                type: "turn.worker_error",
+                turnId: message.payload.turnId,
+                message: "turn_not_running",
+            });
+            return;
+        }
+        await control.stop();
+        return;
+    }
+    if (message.type === "turn.steer") {
+        const control = activeTurns.get(message.payload.turnId);
+        if (!control) {
+            send({
+                type: "turn.worker_error",
+                turnId: message.payload.turnId,
+                message: "turn_not_running",
+            });
+            return;
+        }
+        await control.steer(message.payload.message);
+        return;
+    }
+    if (message.type === "turn.approval.respond") {
+        const control = activeTurns.get(message.payload.turnId);
+        if (!control) {
+            send({
+                type: "turn.worker_error",
+                turnId: message.payload.turnId,
+                message: "turn_not_running",
+            });
+            return;
+        }
+        control.respondApproval(message.payload.requestId, message.payload.decision);
+    }
+}
+function send(message) {
+    process.send?.(message);
+}
+function scheduleExit() {
+    setTimeout(() => process.exit(0), 10).unref();
+}
+function startHeartbeat(turnId) {
+    stopHeartbeat(turnId);
+    const timer = setInterval(() => {
+        send({
+            type: "worker.heartbeat",
+            turnId,
+            activeTurnCount: activeTurns.size,
+        });
+    }, 5_000);
+    timer.unref?.();
+    heartbeatTimers.set(turnId, timer);
+}
+function stopHeartbeat(turnId) {
+    const timer = heartbeatTimers.get(turnId);
+    if (!timer) {
+        return;
+    }
+    clearInterval(timer);
+    heartbeatTimers.delete(turnId);
+}

package/server/dist/runtime-worker/protocol.js

@@ -0,0 +1 @@
+export {};