letagents 0.12.9 → 0.12.11

package/dist/mcp/codex-session/session-supervisor.js

@@ -0,0 +1,111 @@
+import { getStoredCodexLiveSession, } from "../local-state.js";
+import { terminateSpawnedProcess } from "./app-server.js";
+import { createCodexRuntimeBridgeController } from "./runtime-bridge.js";
+import { isTerminalCodexSessionStatus } from "./session-status.js";
+const SESSION_MONITOR_INTERVAL_MS = 30_000;
+const spawnedServerPids = new Set();
+const sessionMonitorTimers = new Map();
+let inspectSession = null;
+let cleanupRegistered = false;
+function inspectConfiguredSession(sessionId) {
+    if (!inspectSession) {
+        throw new Error("Codex session inspector has not been configured.");
+    }
+    return inspectSession(sessionId);
+}
+const runtimeBridge = createCodexRuntimeBridgeController({
+    inspectSession: inspectConfiguredSession,
+    isTerminalStatus: isTerminalCodexSessionStatus,
+});
+export function configureCodexSessionInspector(inspector) {
+    inspectSession = inspector;
+}
+function registerProcessCleanup() {
+    if (cleanupRegistered)
+        return;
+    cleanupRegistered = true;
+    const cleanup = () => {
+        for (const timer of sessionMonitorTimers.values()) {
+            clearInterval(timer);
+        }
+        sessionMonitorTimers.clear();
+        runtimeBridge.cleanup();
+        for (const pid of spawnedServerPids) {
+            terminateSpawnedProcess(pid);
+        }
+        spawnedServerPids.clear();
+    };
+    process.on("exit", cleanup);
+    process.on("SIGINT", () => { cleanup(); process.exit(130); });
+    process.on("SIGTERM", () => { cleanup(); process.exit(143); });
+}
+export function registerLaunchedAppServer(pid) {
+    spawnedServerPids.add(pid);
+    registerProcessCleanup();
+}
+export function forgetLaunchedAppServer(pid) {
+    spawnedServerPids.delete(pid);
+}
+export function clearSessionMonitor(sessionId) {
+    const timer = sessionMonitorTimers.get(sessionId);
+    if (!timer) {
+        return;
+    }
+    clearInterval(timer);
+    sessionMonitorTimers.delete(sessionId);
+}
+export function killOwnedAppServer(session) {
+    if (!session.launched_server || !session.server_pid) {
+        return;
+    }
+    terminateSpawnedProcess(session.server_pid);
+    spawnedServerPids.delete(session.server_pid);
+}
+export function scheduleOwnedSessionMonitor(session) {
+    if (!session.launched_server || sessionMonitorTimers.has(session.session_id)) {
+        return;
+    }
+    const timer = setInterval(() => {
+        void inspectConfiguredSession(session.session_id)
+            .then((status) => {
+            if (!status ||
+                !status.server_reachable ||
+                isTerminalCodexSessionStatus(status.session.status)) {
+                runtimeBridge.stop(session.session_id);
+                clearSessionMonitor(session.session_id);
+                return;
+            }
+            void runtimeBridge.maybeStart(status.session).catch(() => {
+                // The monitor should keep supervising even when the optional stream bridge is unavailable.
+            });
+        })
+            .catch(() => {
+            const latest = getStoredCodexLiveSession(session.session_id);
+            if (latest?.launched_server) {
+                killOwnedAppServer(latest);
+            }
+            runtimeBridge.stop(session.session_id);
+            clearSessionMonitor(session.session_id);
+        });
+    }, SESSION_MONITOR_INTERVAL_MS);
+    timer.unref?.();
+    sessionMonitorTimers.set(session.session_id, timer);
+}
+export async function bindCodexRuntimeStreamBridgeForAgentSession(workerSession) {
+    return runtimeBridge.bindForAgentSession(workerSession);
+}
+export function scheduleCodexRuntimeStreamBridgeBind(workerSession, attempts) {
+    runtimeBridge.scheduleBind(workerSession, attempts);
+}
+export async function maybeStartCodexRuntimeBridge(session) {
+    await runtimeBridge.maybeStart(session);
+}
+export function startCodexRuntimeBridge(session, client) {
+    runtimeBridge.start(session, client);
+}
+export async function postCodexRuntimeReasoningSummary(session, summary) {
+    if (!summary) {
+        return;
+    }
+    await runtimeBridge.postReasoningSummary(session, summary);
+}

package/dist/mcp/codex-session/start-prompt.js

@@ -0,0 +1,49 @@
+import { randomUUID } from "crypto";
+export const DEFAULT_STOP_PHRASE = "/stop-codex-room";
+export function makeToken() {
+    return `LOCAL_CODEX_ROOM_${randomUUID()}`;
+}
+export function formatDeadline(minutes) {
+    if (minutes <= 0) {
+        return { utc: null };
+    }
+    const deadline = new Date(Date.now() + minutes * 60 * 1000);
+    return {
+        utc: deadline.toISOString().replace("T", " ").replace(".000Z", " UTC"),
+    };
+}
+function buildJoinInstruction(joinedVia, roomIdentifier) {
+    if (joinedVia === "join_code") {
+        return `Call the LetAgents MCP tool join_code with {"code":"${roomIdentifier}","session_mode":"current"}.`;
+    }
+    return `Call the LetAgents MCP tool join_room with {"name":"${roomIdentifier}","session_mode":"current"}.`;
+}
+export function buildStartPrompt(input) {
+    const deadlineInstruction = input.max_minutes > 0 && input.deadline_utc
+        ? `Hard stop deadline: ${input.deadline_utc}. Stop when the stop phrase appears or when that deadline is reached, whichever comes first.`
+        : "There is no hard deadline. Stop only when the stop phrase appears or when you are interrupted.";
+    return [
+        "Run as a persistent local Codex worker for a LetAgents room.",
+        `Primary working directory: ${input.cwd}. Use this repository/worktree when the room asks for implementation or repo work.`,
+        input.repo_branch ? `Active git branch at startup: ${input.repo_branch}.` : null,
+        deadlineInstruction,
+        "",
+        "Instructions:",
+        `1. ${buildJoinInstruction(input.joined_via, input.room_identifier)}`,
+        "2. Call register_agent_session with session_kind=\"worker\" and runtime=\"codex\". Keep the returned agent_session_id.",
+        "3. Pass that agent_session_id to wait_for_messages, send_message, send_thread_message, post_status, and task tools whenever the tool accepts it.",
+        "4. Do not start another live session. Join the room inline in this worker only.",
+        "5. Read the room and task board before contributing so you have current context.",
+        "6. Keep polling with wait_for_messages using a 30000 ms timeout. Track the latest returned message id, or last_observed_message_id when present even if messages is empty.",
+        "7. When new messages arrive, contribute when useful. Be concise, thoughtful, and non-repetitive.",
+        "8. When the room asks for coding work, do the work locally in this repository: inspect files, edit code, run checks, commit when asked, and push only when explicitly requested.",
+        "9. Post short status updates to the room when you start meaningful work, when you are blocked, and when you finish meaningful work.",
+        `10. Stop immediately if a browser/user room message text exactly equals: ${input.stop_phrase}`,
+        `11. When stopping, reply in this thread with exactly: ${input.token}_DONE`,
+        "",
+        "Constraints:",
+        "- Do not narrate hidden chain-of-thought.",
+        "- Do not spam the room with keepalive messages.",
+        "- Stay in the room continuously until stopped.",
+    ].filter(Boolean).join("\n");
+}

package/dist/mcp/codex-session/types.js

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