letagents 0.12.8 → 0.12.10

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 {};

package/dist/mcp/codex-session.js

@@ -1,500 +1 @@
-import { randomUUID } from "crypto";
-import { spawn } from "child_process";
-import { resolve } from "path";
-import { getCurrentCodexLiveSession, getStoredCodexLiveSession, saveCodexLiveSession, updateCodexLiveSession, } from "./local-state.js";
-const DEFAULT_SERVER_URL = "ws://127.0.0.1:8765";
-const DEFAULT_STOP_PHRASE = "/stop-codex-room";
-const DEFAULT_TIMEOUT_MS = 15_000;
-function getWebSocketCtor() {
-    const ctor = globalThis.WebSocket;
-    if (!ctor) {
-        throw new Error("Codex live sessions require a Node runtime with global WebSocket support (Node >= 22).");
-    }
-    return ctor;
-}
-/** Track spawned server PIDs for cleanup on process exit. */
-const spawnedServerPids = new Set();
-let cleanupRegistered = false;
-function registerProcessCleanup() {
-    if (cleanupRegistered)
-        return;
-    cleanupRegistered = true;
-    const cleanup = () => {
-        for (const pid of spawnedServerPids) {
-            try {
-                process.kill(pid, "SIGTERM");
-            }
-            catch {
-                // Already dead — ignore.
-            }
-        }
-        spawnedServerPids.clear();
-    };
-    process.on("exit", cleanup);
-    process.on("SIGINT", () => { cleanup(); process.exit(130); });
-    process.on("SIGTERM", () => { cleanup(); process.exit(143); });
-}
-class RpcClient {
-    serverUrl;
-    ws = null;
-    nextId = 1;
-    pending = new Map();
-    constructor(serverUrl) {
-        this.serverUrl = serverUrl;
-    }
-    async connect() {
-        const WS = getWebSocketCtor();
-        await new Promise((resolve, reject) => {
-            const ws = new WS(this.serverUrl);
-            this.ws = ws;
-            ws.onopen = () => resolve();
-            ws.onerror = () => reject(new Error(`WebSocket error connecting to ${this.serverUrl}`));
-            ws.onmessage = (event) => this.handleMessage(String(event.data));
-            ws.onclose = () => {
-                for (const pending of this.pending.values()) {
-                    pending.reject(new Error("WebSocket closed"));
-                }
-                this.pending.clear();
-            };
-        });
-        await this.request("initialize", {
-            clientInfo: { name: "letagents-local-codex-session", version: "0.1.0" },
-            capabilities: { experimentalApi: true },
-        });
-        this.ws?.send(JSON.stringify({ method: "initialized" }));
-    }
-    async request(method, params) {
-        const id = this.nextId++;
-        const payload = { jsonrpc: "2.0", id, method };
-        if (params !== undefined) {
-            payload.params = params;
-        }
-        return new Promise((resolve, reject) => {
-            this.pending.set(id, {
-                resolve: (value) => resolve(value),
-                reject,
-            });
-            this.ws?.send(JSON.stringify(payload));
-        });
-    }
-    close() {
-        if (this.ws?.readyState === getWebSocketCtor().OPEN) {
-            this.ws.close();
-        }
-    }
-    handleMessage(raw) {
-        let message;
-        try {
-            message = JSON.parse(raw);
-        }
-        catch {
-            return;
-        }
-        if (message.id === undefined) {
-            return;
-        }
-        const pending = this.pending.get(message.id);
-        if (!pending) {
-            return;
-        }
-        this.pending.delete(message.id);
-        if (message.error) {
-            pending.reject(new Error(typeof message.error === "object" && message.error && "message" in message.error
-                ? String(message.error.message || JSON.stringify(message.error))
-                : JSON.stringify(message.error)));
-            return;
-        }
-        pending.resolve(message.result);
-    }
-}
-function readyUrlFromServerUrl(serverUrl) {
-    const url = new URL(serverUrl);
-    url.protocol = url.protocol === "wss:" ? "https:" : "http:";
-    url.pathname = "/readyz";
-    url.search = "";
-    url.hash = "";
-    return url.toString();
-}
-async function isServerReady(serverUrl) {
-    try {
-        const response = await fetch(readyUrlFromServerUrl(serverUrl), {
-            signal: AbortSignal.timeout(1_000),
-        });
-        return response.ok;
-    }
-    catch {
-        return false;
-    }
-}
-async function waitForServer(serverUrl, timeoutMs = DEFAULT_TIMEOUT_MS) {
-    const startedAt = Date.now();
-    while (Date.now() - startedAt < timeoutMs) {
-        if (await isServerReady(serverUrl)) {
-            return true;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 250));
-    }
-    return false;
-}
-function launchAppServer(serverUrl, codexBin) {
-    const child = spawn(codexBin, ["app-server", "--listen", serverUrl], {
-        detached: true,
-        stdio: "ignore",
-    });
-    child.unref();
-    return child.pid ?? null;
-}
-function makeToken() {
-    return `LOCAL_CODEX_ROOM_${randomUUID()}`;
-}
-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"}.`;
-}
-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.`,
-        deadlineInstruction,
-        "",
-        "Instructions:",
-        `1. ${buildJoinInstruction(input.joined_via, input.room_identifier)}`,
-        "2. Do not start another live session. Join the room inline in this worker only.",
-        "3. Read the room and task board before contributing so you have current context.",
-        "4. Keep polling with wait_for_messages using a 30000 ms timeout and track the latest seen message id.",
-        "5. When new messages arrive, contribute when useful. Be concise, thoughtful, and non-repetitive.",
-        "6. 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.",
-        "7. Post short status updates to the room when you start meaningful work, when you are blocked, and when you finish meaningful work.",
-        `8. Stop immediately if a browser/user room message text exactly equals: ${input.stop_phrase}`,
-        `9. 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.",
-    ].join("\n");
-}
-function extractTurnStatus(turn) {
-    if (!turn) {
-        return null;
-    }
-    if (typeof turn.status === "string") {
-        return turn.status;
-    }
-    if (turn.status && typeof turn.status === "object" && "status" in turn.status) {
-        return typeof turn.status.status === "string" ? turn.status.status : null;
-    }
-    return null;
-}
-function extractThreadStatus(thread) {
-    if (!thread?.status) {
-        return null;
-    }
-    if (typeof thread.status === "string") {
-        return thread.status;
-    }
-    return typeof thread.status.type === "string" ? thread.status.type : null;
-}
-function summarizeItems(items) {
-    return (items ?? []).slice(-6).map((item) => {
-        if (item.type === "agentMessage") {
-            return { type: item.type, phase: item.phase, text: item.text ?? null };
-        }
-        if (item.type === "userMessage") {
-            return {
-                type: item.type,
-                text: (item.content ?? []).map((part) => part.text ?? "").join("\n"),
-            };
-        }
-        return { type: item.type ?? "unknown" };
-    });
-}
-function mapSessionStatus(session, serverReachable, threadStatus, turnStatus) {
-    if (turnStatus === "completed") {
-        return "completed";
-    }
-    if (turnStatus === "interrupted") {
-        return "interrupted";
-    }
-    if (turnStatus === "inProgress" || threadStatus === "active") {
-        return "running";
-    }
-    if (!serverReachable) {
-        return session.status === "completed" || session.status === "interrupted"
-            ? session.status
-            : "unknown";
-    }
-    if (session.status === "starting") {
-        return "starting";
-    }
-    return session.status;
-}
-function toSessionState(input) {
-    const now = new Date().toISOString();
-    return {
-        session_id: input.session_id,
-        room_id: input.room_id,
-        room_identifier: input.room_identifier,
-        room_code: input.room_code ?? null,
-        room_display_name: input.room_display_name ?? null,
-        joined_via: input.joined_via,
-        cwd: input.cwd,
-        stop_phrase: input.stop_phrase,
-        max_minutes: input.max_minutes,
-        deadline_utc: input.deadline_utc,
-        token: input.token,
-        thread_id: input.thread_id,
-        turn_id: input.turn_id,
-        server_url: input.server_url,
-        server_pid: input.server_pid,
-        launched_server: input.launched_server,
-        codex_bin: input.codex_bin,
-        status: "running",
-        last_error: null,
-        started_at: now,
-        updated_at: now,
-    };
-}
-function isLikelyMaterializingError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return message.includes("not materialized yet");
-}
-export function toPublicCodexLiveSession(session) {
-    return {
-        session_id: session.session_id,
-        room_id: session.room_id,
-        room_code: session.room_code ?? null,
-        room_display_name: session.room_display_name ?? null,
-        joined_via: session.joined_via,
-        cwd: session.cwd,
-        stop_phrase: session.stop_phrase,
-        max_minutes: session.max_minutes,
-        deadline_utc: session.deadline_utc ?? null,
-        thread_id: session.thread_id,
-        turn_id: session.turn_id,
-        server_url: session.server_url,
-        server_pid: session.server_pid ?? null,
-        launched_server: session.launched_server,
-        status: session.status,
-        last_error: session.last_error ?? null,
-        started_at: session.started_at,
-        updated_at: session.updated_at,
-    };
-}
-export async function inspectLocalCodexSession(sessionId, roomId) {
-    const session = sessionId
-        ? getStoredCodexLiveSession(sessionId)
-        : getCurrentCodexLiveSession(roomId ?? undefined);
-    if (!session) {
-        return null;
-    }
-    const serverReachable = await isServerReady(session.server_url);
-    if (!serverReachable) {
-        const updated = updateCodexLiveSession(session.session_id, (current) => ({
-            ...current,
-            status: mapSessionStatus(current, false, null, null),
-            updated_at: new Date().toISOString(),
-        })) ?? session;
-        return {
-            session: updated,
-            server_reachable: false,
-            thread_status: null,
-            turn_status: null,
-            recent_items: [],
-        };
-    }
-    const client = new RpcClient(session.server_url);
-    await client.connect();
-    try {
-        let read = null;
-        try {
-            read = await client.request("thread/read", {
-                threadId: session.thread_id,
-                includeTurns: true,
-            });
-        }
-        catch (error) {
-            if (!isLikelyMaterializingError(error)) {
-                throw error;
-            }
-        }
-        const turns = read?.thread?.turns ?? [];
-        const turn = turns.find((candidate) => candidate.id === session.turn_id) ?? turns[turns.length - 1];
-        const threadStatus = extractThreadStatus(read?.thread);
-        const turnStatus = extractTurnStatus(turn);
-        const updated = updateCodexLiveSession(session.session_id, (current) => ({
-            ...current,
-            status: mapSessionStatus(current, true, threadStatus, turnStatus),
-            last_error: null,
-            updated_at: new Date().toISOString(),
-        })) ?? session;
-        return {
-            session: updated,
-            server_reachable: true,
-            thread_status: read?.thread?.status ?? null,
-            turn_status: turn?.status ?? null,
-            recent_items: summarizeItems(turn?.items ?? turn?.output),
-        };
-    }
-    catch (error) {
-        const updated = updateCodexLiveSession(session.session_id, (current) => ({
-            ...current,
-            status: "unknown",
-            last_error: error instanceof Error ? error.message : String(error),
-            updated_at: new Date().toISOString(),
-        })) ?? session;
-        return {
-            session: updated,
-            server_reachable: true,
-            thread_status: null,
-            turn_status: null,
-            recent_items: [],
-        };
-    }
-    finally {
-        client.close();
-    }
-}
-export async function startLocalCodexSession(input) {
-    const cwd = resolve(input.cwd || process.cwd());
-    const currentSession = getCurrentCodexLiveSession(input.room_id);
-    if (currentSession &&
-        currentSession.room_id === input.room_id &&
-        resolve(currentSession.cwd) === cwd) {
-        const inspected = await inspectLocalCodexSession(currentSession.session_id);
-        if (inspected &&
-            (inspected.session.status === "running" || inspected.session.status === "starting")) {
-            return { session: inspected.session, reused: true };
-        }
-    }
-    const serverUrl = input.server_url || DEFAULT_SERVER_URL;
-    const stopPhrase = input.stop_phrase || DEFAULT_STOP_PHRASE;
-    const maxMinutes = Number.isFinite(input.max_minutes) ? Math.max(0, input.max_minutes ?? 0) : 0;
-    const codexBin = input.codex_bin || process.env.LETAGENTS_CODEX_BIN || "codex";
-    const token = makeToken();
-    const deadline = formatDeadline(maxMinutes);
-    const launchedServer = !(await isServerReady(serverUrl));
-    let serverPid = null;
-    if (launchedServer) {
-        serverPid = launchAppServer(serverUrl, codexBin);
-        if (serverPid) {
-            spawnedServerPids.add(serverPid);
-            registerProcessCleanup();
-        }
-        const ready = await waitForServer(serverUrl);
-        if (!ready) {
-            throw new Error(`Timed out waiting for codex app-server at ${serverUrl}`);
-        }
-    }
-    const client = new RpcClient(serverUrl);
-    await client.connect();
-    try {
-        const threadStart = await client.request("thread/start", {});
-        const threadId = threadStart.thread?.id;
-        if (!threadId) {
-            throw new Error("Codex app-server did not return a thread id.");
-        }
-        const prompt = buildStartPrompt({
-            room_identifier: input.room_identifier,
-            joined_via: input.joined_via,
-            cwd,
-            stop_phrase: stopPhrase,
-            token,
-            deadline_utc: deadline.utc,
-            max_minutes: maxMinutes,
-        });
-        const turnStart = await client.request("turn/start", {
-            threadId,
-            cwd,
-            approvalPolicy: "never",
-            sandboxPolicy: { type: "dangerFullAccess" },
-            input: [{ type: "text", text: prompt, text_elements: [] }],
-        });
-        const turnId = turnStart.turn?.id;
-        if (!turnId) {
-            throw new Error("Codex app-server did not return a turn id.");
-        }
-        const session = saveCodexLiveSession(toSessionState({
-            session_id: randomUUID(),
-            room_id: input.room_id,
-            room_identifier: input.room_identifier,
-            room_code: input.room_code ?? null,
-            room_display_name: input.room_display_name ?? null,
-            joined_via: input.joined_via,
-            cwd,
-            stop_phrase: stopPhrase,
-            max_minutes: maxMinutes,
-            deadline_utc: deadline.utc,
-            token,
-            thread_id: threadId,
-            turn_id: turnId,
-            server_url: serverUrl,
-            server_pid: serverPid,
-            launched_server: launchedServer,
-            codex_bin: codexBin,
-        }));
-        return { session, reused: false };
-    }
-    finally {
-        client.close();
-    }
-}
-export async function stopLocalCodexSession(options) {
-    const session = options?.session_id
-        ? getStoredCodexLiveSession(options.session_id)
-        : getCurrentCodexLiveSession(options?.room_id ?? undefined);
-    if (!session) {
-        return null;
-    }
-    // Attempt to interrupt the turn via RPC, but gracefully handle a dead server.
-    const serverReachable = await isServerReady(session.server_url);
-    if (serverReachable) {
-        try {
-            const client = new RpcClient(session.server_url);
-            await client.connect();
-            try {
-                await client.request("turn/interrupt", {
-                    threadId: session.thread_id,
-                    turnId: session.turn_id,
-                });
-            }
-            finally {
-                client.close();
-            }
-        }
-        catch {
-            // Server may have died between the readiness check and the RPC call.
-        }
-    }
-    const updated = updateCodexLiveSession(session.session_id, (current) => ({
-        ...current,
-        status: "interrupted",
-        last_error: serverReachable ? null : "server unreachable at stop time",
-        updated_at: new Date().toISOString(),
-    })) ?? session;
-    if (options?.shutdown_server && updated.server_pid) {
-        try {
-            process.kill(updated.server_pid, "SIGTERM");
-            spawnedServerPids.delete(updated.server_pid);
-        }
-        catch {
-            // Process already dead — ignore.
-            spawnedServerPids.delete(updated.server_pid);
-        }
-    }
-    return updated;
-}
+export * from "./codex-session/index.js";

package/dist/mcp/config-reader.js

@@ -7,10 +7,18 @@
 // Parses the config and returns the room name if found.
 //
 // Config format:
-//   { "room": "github.com/BrosInCode/letagents" }
+//   { "room": "github.com/brosincode/letagents" }
 import { readFileSync, existsSync } from "fs";
 import { join, dirname, resolve } from "path";
 const CONFIG_FILENAME = ".letagents.json";
+function normalizeConfiguredRoom(room) {
+    const trimmed = room.trim();
+    const githubRepoRoom = /^github\.com\/([^/:\s]+)\/([^/:\s]+)$/i.exec(trimmed);
+    if (!githubRepoRoom) {
+        return trimmed;
+    }
+    return `github.com/${githubRepoRoom[1].toLowerCase()}/${githubRepoRoom[2].toLowerCase()}`;
+}
 /**
  * Search for `.letagents.json` starting from `startDir` and walking up
  * to the filesystem root. Returns the parsed config or null if not found.
@@ -27,7 +35,7 @@ export function findLetagentsConfig(startDir) {
                 const parsed = JSON.parse(raw);
                 // Validate required fields
                 if (typeof parsed.room === "string" && parsed.room.trim() !== "") {
-                    return { room: parsed.room.trim() };
+                    return { room: normalizeConfiguredRoom(parsed.room) };
                 }
                 // Config exists but is malformed — log and continue
                 console.error(`[letagents] Found ${configPath} but missing valid "room" field`);