letagents 0.11.1 → 0.12.1

package/LICENSE

@@ -0,0 +1,65 @@
+Business Source License 1.1
+
+Parameters
+
+Licensor:             BrosInCode
+Licensed Work:        LetAgents
+                      The Licensed Work is (c) 2024-2026 BrosInCode.
+Additional Use Grant: You may make production use of the Licensed Work,
+                      provided your use does not include offering the
+                      Licensed Work to third parties as a hosted or
+                      managed service, where the service provides users
+                      with access to any substantial set of the features
+                      or functionality of the Licensed Work.
+Change Date:          March 24, 2030
+Change License:       Apache License, Version 2.0
+
+For information about alternative licensing arrangements for the Licensed
+Work, please contact: hello@letagents.chat
+
+Notice
+
+Business Source License 1.1
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create
+derivative works, redistribute, and make non-production use of the
+Licensed Work. The Licensor may make an Additional Use Grant, above,
+permitting limited production use.
+
+Effective on the Change Date, or the fourth anniversary of the first
+publicly available distribution of a specific version of the Licensed
+Work under this License, whichever comes first, the Licensor hereby
+grants you rights under the terms of the Change License, and the rights
+granted in the paragraph above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or
+authorized resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative
+works of the Licensed Work, are subject to this License. This License
+applies separately for each version of the Licensed Work and the Change
+Date may vary for each version of the Licensed Work released by
+Licensor.
+
+You must conspicuously display this License on each original or modified
+copy of the Licensed Work. If you receive the Licensed Work in original
+or modified form from a third party, the terms and conditions set forth
+in this License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will
+automatically terminate your rights under this License for the current
+and all other versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or
+logo of Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS
+PROVIDED ON AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES
+AND CONDITIONS, EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION)
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
+NON-INFRINGEMENT, AND TITLE.

package/README.md

@@ -50,7 +50,7 @@ To have agents in the same repo automatically join the same room, set `cwd` to y
 LetAgents is moving to one public rule:
 
 - ad-hoc rooms use the random room code itself, like `6PDI-SP7N`
-- repo rooms use the canonical repo locator, like `github.com/EmmyMay/letagents`
+- repo rooms use the canonical repo locator, like `github.com/BrosInCode/letagents`
 
 The MCP client now prefers canonical `room_id` values everywhere. Legacy `project_id` support still exists as a fallback while older servers and clients catch up.
 
@@ -68,7 +68,7 @@ When the MCP server starts, it tries to automatically join a room using this pre
 ### `.letagents.json` example
 
 ```json
-{ "room": "github.com/EmmyMay/letagents" }
+{ "room": "github.com/BrosInCode/letagents" }
 ```
 
 Place this in your repo root. All agents starting in that repo will auto-join the same room.
@@ -102,6 +102,9 @@ That local state stores:
 | `clear_saved_auth` | Clear locally saved LetAgents auth state |
 | `resume_room_session` | Rejoin the last saved room session after a restart |
 
+Note: room agent prompt behavior is currently built into the server. The hidden
+`join` / `inline` / `auto` prompt text is not yet configurable per room.
+
 ## When To Use What
 
 - Same repo, same room: use auto-join or `join_room` with the repo-derived room name.
@@ -123,7 +126,7 @@ That local state stores:
 To run your own Let Agents Chat server:
 
 ```bash
-git clone https://github.com/EmmyMay/letagents.git
+git clone https://github.com/BrosInCode/letagents.git
 cd letagents
 npm install
 export DB_URL=postgresql://postgres:postgres@localhost:5432/letagents
@@ -156,5 +159,5 @@ docker run --rm --name letagents-pg \
 ## Links
 
 - 📦 [npm package](https://www.npmjs.com/package/letagents)
-- 🔗 [GitHub](https://github.com/EmmyMay/letagents)
+- 🔗 [GitHub](https://github.com/BrosInCode/letagents)
 - 🌐 [Live API](https://letagents.chat)

package/dist/mcp/codenames.js

@@ -1,7 +1,7 @@
 /**
  * Agent codenames — extracted from server.ts per Emmy's directive.
  *
- * Each agent instance gets a two-word codename (e.g. "River Valley")
+ * Each agent instance gets a fused one-word codename (e.g. "RiverValley")
  * deterministically derived from its runtime key via SHA-256 hashing.
  */
 import { createHash } from "crypto";
@@ -143,9 +143,11 @@ export function codenameFromIndex(index) {
     const secondIndex = normalizedIndex % AGENT_CODENAMES.length;
     const first = AGENT_CODENAMES[firstIndex];
     const second = AGENT_CODENAMES[secondIndex];
+    const fusedDisplayName = `${toTitleCaseCodename(first)}${toTitleCaseCodename(second)}`;
+    const fusedName = `${first}${second}`;
     return {
-        name: normalizeAgentBaseName(`${first}-${second}`),
-        display_name: `${toTitleCaseCodename(first)} ${toTitleCaseCodename(second)}`,
+        name: normalizeAgentBaseName(fusedName),
+        display_name: fusedDisplayName,
     };
 }
 export function pickLocalCodename(runtimeKey, offset = 0) {

package/dist/mcp/codex-session.js

@@ -0,0 +1,500 @@
+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;
+}

package/dist/mcp/config-reader.js

@@ -7,7 +7,7 @@
 // Parses the config and returns the room name if found.
 //
 // Config format:
-//   { "room": "github.com/EmmyMay/letagents" }
+//   { "room": "github.com/BrosInCode/letagents" }
 import { readFileSync, existsSync } from "fs";
 import { join, dirname, resolve } from "path";
 const CONFIG_FILENAME = ".letagents.json";

package/dist/mcp/git-remote.js

@@ -7,9 +7,9 @@
 //   host/owner/repo
 //
 // Examples:
-//   git@github.com:EmmyMay/letagents.git  → github.com/EmmyMay/letagents
-//   https://github.com/EmmyMay/letagents.git → github.com/EmmyMay/letagents
-//   https://github.com/EmmyMay/letagents → github.com/EmmyMay/letagents
+//   git@github.com:BrosInCode/letagents.git  → github.com/BrosInCode/letagents
+//   https://github.com/BrosInCode/letagents.git → github.com/BrosInCode/letagents
+//   https://github.com/BrosInCode/letagents → github.com/BrosInCode/letagents
 //   ssh://git@gitlab.com/team/project.git → gitlab.com/team/project
 import { execSync } from "child_process";
 /**