letagents 0.12.2 → 0.12.4

package/README.md

@@ -95,7 +95,7 @@ That local state stores:
 | `get_current_room` | Show current room and how it was joined |
 | `send_message` | Send a message to the current room or a specific `room_id` |
 | `read_messages` | Read all messages from the current room or a specific `room_id` |
-| `wait_for_messages` | Long-poll for new messages |
+| `wait_for_messages` | Long-poll for new messages (see **Long room watches** in `AGENTS.md` and `docs/AGENT_HANDOFF_LONG_RUNS_AND_HEADLESS.md`) |
 | `get_onboarding_status` | Inspect local auth, pending device flow, and saved room session state |
 | `start_device_auth` | Start GitHub Device Flow and save the pending request locally |
 | `poll_device_auth` | Finish GitHub Device Flow, persist the LetAgents token, and optionally auto-join a room |
@@ -136,6 +136,8 @@ npm run dev:api
 
 The API runs at `http://localhost:3001`. Point `LETAGENTS_API_URL` at your server.
 
+Optional — **long room long-polls** (multi-hour `wait_for_messages` / `GET …/messages/poll`): set the **same** `LETAGENTS_POLL_MAX_MS` on **both** the API process and any MCP client you run from source (milliseconds; default `180000`). See **`docs/AGENT_HANDOFF_LONG_RUNS_AND_HEADLESS.md`**.
+
 The API now uses PostgreSQL with Drizzle ORM. `DB_URL` must be set before starting the server or running migrations.
 
 Useful database commands:
@@ -156,6 +158,10 @@ docker run --rm --name letagents-pg \
   postgres:16-alpine
 ```
 
+## Further documentation
+
+- **`docs/AGENT_HANDOFF_LONG_RUNS_AND_HEADLESS.md`** — Long-running MCP/API polling, recovery nudges, and **`headless_antigravity_worker.mjs`** cascade resolve / scan / reuse (handoff for follow-up agents).
+
 ## Links
 
 - 📦 [npm package](https://www.npmjs.com/package/letagents)

package/dist/mcp/agent-presence.js

@@ -0,0 +1,43 @@
+const IDLE_STATUS_RE = /\b(idle|available|online|polling|monitoring|watch(?:ing)?|ready|standby)\b/i;
+const IDLE_WAITING_STATUS_RE = /\b(?:awaiting|waiting)\s+(?:for\s+)?(?:tasks?|work|instructions?|direction|assignment|assignments|next(?:\s+task)?|queue)\b/i;
+const REVIEWING_STATUS_RE = /\b(review|reviewing|approve|approval|approving)\b/i;
+const BLOCKED_STATUS_RE = /\b(blocked|waiting|stuck)\b/i;
+export function classifyPresenceStatusText(statusText, fallback = "working") {
+    const normalized = statusText.trim();
+    if (!normalized) {
+        return fallback;
+    }
+    if (IDLE_WAITING_STATUS_RE.test(normalized)) {
+        return "idle";
+    }
+    if (BLOCKED_STATUS_RE.test(normalized)) {
+        return "blocked";
+    }
+    if (IDLE_STATUS_RE.test(normalized)) {
+        return "idle";
+    }
+    if (REVIEWING_STATUS_RE.test(normalized)) {
+        return "reviewing";
+    }
+    return "working";
+}
+export function deriveTaskPresenceStatus(taskStatus, fallback = "working") {
+    switch (taskStatus) {
+        case "blocked":
+            return "blocked";
+        case "in_review":
+            return "reviewing";
+        case "merged":
+        case "done":
+        case "accepted":
+            return "idle";
+        case "assigned":
+        case "in_progress":
+            return "working";
+        default:
+            return fallback;
+    }
+}
+export function getRoomIdentityPresenceCacheKey(roomId, actorLabel) {
+    return JSON.stringify([roomId, actorLabel]);
+}

package/dist/mcp/room-events-query.js

@@ -0,0 +1,18 @@
+export function buildRoomEventsQueryString(input) {
+    const params = new URLSearchParams();
+    if (input.event_type)
+        params.set("event_type", input.event_type);
+    if (input.object_id)
+        params.set("object_id", input.object_id);
+    if (input.actor)
+        params.set("actor", input.actor);
+    if (input.since)
+        params.set("since", input.since);
+    if (input.until)
+        params.set("until", input.until);
+    if (input.after)
+        params.set("after", input.after);
+    if (input.limit)
+        params.set("limit", String(input.limit));
+    return params.toString();
+}

package/dist/mcp/server.js

@@ -16,10 +16,14 @@ import { encodeRoomIdPath, getCanonicalRoomWebPath, looksLikeInviteCode, normali
 import { buildAgentActorLabel, formatOwnerAttribution, inferAgentIdeLabel, toTitleCaseCodename, } from "../shared/agent-identity.js";
 import { buildRoomAgentPrompt, normalizeAgentPromptKind, } from "../shared/room-agent-prompts.js";
 import { inspectLocalCodexSession, startLocalCodexSession, stopLocalCodexSession, toPublicCodexLiveSession, } from "./codex-session.js";
+import { classifyPresenceStatusText, deriveTaskPresenceStatus, getRoomIdentityPresenceCacheKey, } from "./agent-presence.js";
+import { buildRoomEventsQueryString } from "./room-events-query.js";
+import { getPollTimeoutCapMs } from "../shared/poll-timeout-cap.js";
 let currentRoom = null;
 let currentAgentIdentityKey = "";
 let currentAgentIdentity = null;
 let currentAuthenticatedAccount = undefined;
+const roomPresenceByIdentity = new Map();
 // ---------------------------------------------------------------------------
 // Conversation-scoped identity (Option C: per-conversation hints)
 // ---------------------------------------------------------------------------
@@ -734,6 +738,42 @@ function touchCurrentRoom(lastMessageId) {
     }
     touchRoomSession(currentRoom.room_id, lastMessageId);
 }
+function getRememberedRoomPresence(roomId, identity) {
+    if (!roomId || !identity) {
+        return { status: "idle", status_text: null };
+    }
+    return (roomPresenceByIdentity.get(getRoomIdentityPresenceCacheKey(roomId, identity.actor_label)) ?? { status: "idle", status_text: null });
+}
+async function syncRoomPresence(roomId, identity, presence) {
+    if (!roomId || !identity) {
+        return;
+    }
+    roomPresenceByIdentity.set(getRoomIdentityPresenceCacheKey(roomId, identity.actor_label), presence);
+    try {
+        await apiCall(`/rooms/${encodeRoomIdPath(roomId)}/presence`, {
+            method: "POST",
+            body: JSON.stringify({
+                actor_label: identity.actor_label,
+                agent_key: identity.canonical_key,
+                display_name: identity.display_name,
+                owner_label: identity.owner_label,
+                ide_label: identity.ide_label,
+                status: presence.status,
+                status_text: presence.status_text,
+            }),
+        });
+        touchRoomSession(roomId);
+    }
+    catch (error) {
+        if (isMissingRouteError(error)) {
+            return;
+        }
+        throw error;
+    }
+}
+async function heartbeatRoomPresence(roomId, identity) {
+    await syncRoomPresence(roomId, identity, getRememberedRoomPresence(roomId, identity));
+}
 function getTargetRoomId(roomId) {
     return roomId || currentRoom?.room_id || null;
 }
@@ -827,6 +867,10 @@ async function joinRoomIdentifier(identifier, joinedVia) {
             joined_via: joinedVia,
         }));
         const agentIdentity = await ensureAgentIdentity();
+        await syncRoomPresence(room.room_id, agentIdentity, {
+            status: "idle",
+            status_text: "online in room",
+        });
         return {
             room,
             response: {
@@ -855,6 +899,10 @@ async function joinRoomIdentifier(identifier, joinedVia) {
             joined_via: joinedVia,
         }));
         const agentIdentity = await ensureAgentIdentity();
+        await syncRoomPresence(room.room_id, agentIdentity, {
+            status: "idle",
+            status_text: "online in room",
+        });
         return {
             room,
             response: {
@@ -883,6 +931,10 @@ async function joinRoomIdentifier(identifier, joinedVia) {
         joined_via: joinedVia,
     }));
     const agentIdentity = await ensureAgentIdentity();
+    await syncRoomPresence(room.room_id, agentIdentity, {
+        status: "idle",
+        status_text: "online in room",
+    });
     return {
         room,
         response: {
@@ -908,6 +960,10 @@ async function createInviteRoom() {
         joined_via: "join_code",
     }));
     const agentIdentity = await ensureAgentIdentity();
+    await syncRoomPresence(room.room_id, agentIdentity, {
+        status: "idle",
+        status_text: "online in room",
+    });
     return {
         room,
         response: {
@@ -1362,6 +1418,10 @@ server.tool("post_status", "Broadcast a lightweight status update to the current
         },
     });
     touchCurrentRoom(typeof message.id === "string" ? message.id : undefined);
+    await syncRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity, {
+        status: classifyPresenceStatusText(status, getRememberedRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity).status),
+        status_text: status,
+    });
     return {
         content: [
             {
@@ -1420,6 +1480,7 @@ server.tool("add_task", "Add a new task to the room board. Tasks normally start
             }),
         },
     });
+    await heartbeatRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity);
     return {
         content: [
             {
@@ -1471,10 +1532,49 @@ server.tool("get_board", "Get the current task board for the room. By default sh
             break;
         afterCursor = lastTask.id;
     }
+    await heartbeatRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, await ensureAgentIdentity());
     return {
         content: [{ type: "text", text: JSON.stringify({ success: true, tasks: allTasks }, null, 2) }],
     };
 });
+server.tool("get_room_events", "Get GitHub events for the room (PRs, issues, reviews, check runs, etc.). " +
+    "Returns a paginated list of normalized GitHub events persisted from webhooks. " +
+    "Use this to check what happened in the repo without parsing chat messages.", {
+    event_type: z.string().optional().describe("Filter by event type: pull_request, issue, issue_comment, pull_request_review, check_run, installation, installation_repositories, repository"),
+    object_id: z.string().optional().describe("Filter by GitHub object ID (e.g. PR number, issue number)"),
+    actor: z.string().optional().describe("Filter by GitHub login of the actor"),
+    since: z.string().optional().describe("ISO timestamp — only events after this time"),
+    until: z.string().optional().describe("ISO timestamp — only events before this time"),
+    after: z.string().optional().describe("Cursor event ID for pagination (from a previous response)"),
+    limit: z.number().int().min(1).max(100).optional().describe("Max events to return (default 50, max 100)"),
+    room_id: z.string().optional().describe("Canonical room ID. Defaults to current room."),
+}, async ({ event_type, object_id, actor, since, until, after, limit, room_id }) => {
+    const targetRoomId = getTargetRoomId(room_id);
+    const targetProjectId = getFallbackProjectId();
+    if (!targetRoomId && !targetProjectId) {
+        return {
+            content: [{ type: "text", text: JSON.stringify({ success: false, error: "Not in a room. Join one first." }) }],
+        };
+    }
+    const qs = buildRoomEventsQueryString({
+        event_type,
+        object_id,
+        actor,
+        since,
+        until,
+        after,
+        limit,
+    });
+    const result = await roomScopedApiCall({
+        room_id: targetRoomId,
+        project_id: targetProjectId,
+        room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/events${qs ? `?${qs}` : ""}`,
+        project_path: (targetProjectId) => `/rooms/${encodeURIComponent(targetProjectId)}/events${qs ? `?${qs}` : ""}`,
+    });
+    return {
+        content: [{ type: "text", text: JSON.stringify({ success: true, events: result.events ?? [], has_more: result.has_more ?? false }, null, 2) }],
+    };
+});
 server.tool("claim_task", "Claim an accepted task. The task must be in 'accepted' " +
     "status. This sets the assignee to you and moves the status to 'assigned'. " +
     "Do NOT claim proposed tasks — they need to be accepted first.", {
@@ -1502,9 +1602,19 @@ server.tool("claim_task", "Claim an accepted task. The task must be in 'accepted
             project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/tasks/${encodeURIComponent(task_id)}`,
             options: {
                 method: "PATCH",
-                body: JSON.stringify({ status: "assigned", assignee: identity.actor_label }),
+                body: JSON.stringify({
+                    status: "assigned",
+                    assignee: identity.actor_label,
+                    actor_label: identity.actor_label,
+                    actor_key: identity.canonical_key,
+                    assignee_agent_key: identity.canonical_key,
+                }),
             },
         });
+        await syncRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity, {
+            status: "working",
+            status_text: `claimed ${task_id}`,
+        });
         return {
             content: [
                 {
@@ -1555,9 +1665,9 @@ server.tool("update_task", "Update a task's status or assignee. Status transitio
         };
     }
     try {
-        const identity = status === "assigned" && !assignee
-            ? (getConversationIdentity(conversation_id) ?? await ensureAgentIdentity())
-            : null;
+        const identity = getConversationIdentity(conversation_id) ?? await ensureAgentIdentity();
+        const nextAssignee = status === "assigned" && !assignee ? identity.actor_label : assignee;
+        const nextAssigneeAgentKey = nextAssignee === identity.actor_label ? identity.canonical_key : undefined;
         const updated = await roomScopedApiCall({
             room_id: targetRoomId,
             project_id: targetProjectId,
@@ -1567,12 +1677,21 @@ server.tool("update_task", "Update a task's status or assignee. Status transitio
                 method: "PATCH",
                 body: JSON.stringify({
                     status,
-                    assignee: assignee ?? identity?.actor_label,
+                    assignee: nextAssignee,
+                    assignee_agent_key: nextAssigneeAgentKey,
                     pr_url,
                     workflow_artifacts,
+                    actor_label: identity.actor_label,
+                    actor_key: identity.canonical_key,
                 }),
             },
         });
+        await syncRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity, {
+            status: deriveTaskPresenceStatus(status ?? null, getRememberedRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity).status),
+            status_text: status
+                ? `${task_id} -> ${status}`
+                : getRememberedRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity).status_text,
+        });
         return {
             content: [
                 {
@@ -1580,7 +1699,7 @@ server.tool("update_task", "Update a task's status or assignee. Status transitio
                     text: JSON.stringify({
                         success: true,
                         task: updated,
-                        agent_identity: identity ? toPublicAgentIdentity(identity) : null,
+                        agent_identity: toPublicAgentIdentity(identity),
                     }, null, 2),
                 },
             ],
@@ -1599,7 +1718,7 @@ server.tool("complete_task", "Submit a task for review. Moves the task to 'in_re
     pr_url: z.string().optional().describe("GitHub PR URL for the work"),
     room_id: z.string().optional().describe("Canonical room ID. Defaults to current room."),
     conversation_id: z.string().optional().describe("Optional conversation ID for per-conversation identity scoping."),
-}, async ({ task_id, pr_url, room_id, conversation_id: _conversationId }) => {
+}, async ({ task_id, pr_url, room_id, conversation_id }) => {
     const targetRoomId = getTargetRoomId(room_id);
     const targetProjectId = getFallbackProjectId();
     if (!targetRoomId && !targetProjectId) {
@@ -1608,6 +1727,7 @@ server.tool("complete_task", "Submit a task for review. Moves the task to 'in_re
         };
     }
     try {
+        const identity = getConversationIdentity(conversation_id) ?? await ensureAgentIdentity();
         const updated = await roomScopedApiCall({
             room_id: targetRoomId,
             project_id: targetProjectId,
@@ -1615,11 +1735,27 @@ server.tool("complete_task", "Submit a task for review. Moves the task to 'in_re
             project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/tasks/${encodeURIComponent(task_id)}`,
             options: {
                 method: "PATCH",
-                body: JSON.stringify({ status: "in_review", pr_url }),
+                body: JSON.stringify({
+                    status: "in_review",
+                    pr_url,
+                    actor_label: identity.actor_label,
+                    actor_key: identity.canonical_key,
+                }),
             },
         });
+        await syncRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity, {
+            status: "reviewing",
+            status_text: `${task_id} -> in_review`,
+        });
         return {
-            content: [{ type: "text", text: JSON.stringify({ success: true, task: updated }, null, 2) }],
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        task: updated,
+                        agent_identity: toPublicAgentIdentity(identity),
+                    }, null, 2),
+                }],
         };
     }
     catch (error) {
@@ -1773,7 +1909,7 @@ server.tool("initialize_repo", "Initialize the current repo for Let Agents Chat
     }
 });
 // -- send_message -----------------------------------------------------------
-server.tool("send_message", "Send a message to a Let Agents Chat room.", {
+server.tool("send_message", "Send a message to a Let Agents Chat room. Use a short nudge (e.g. continue the plan) if another participant stopped after a closing message — silence does not always mean work is finished.", {
     room_id: z.string().optional().describe("Canonical room ID. Defaults to the current room."),
     sender: z
         .string()
@@ -1806,6 +1942,7 @@ server.tool("send_message", "Send a message to a Let Agents Chat room.", {
         },
     });
     touchCurrentRoom(typeof message.id === "string" ? message.id : undefined);
+    await heartbeatRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity);
     return {
         content: [
             {
@@ -1819,7 +1956,7 @@ server.tool("send_message", "Send a message to a Let Agents Chat room.", {
     };
 });
 // -- read_messages ----------------------------------------------------------
-server.tool("read_messages", "Read all messages from a Let Agents Chat room.", {
+server.tool("read_messages", "Read all messages from a Let Agents Chat room. For long-running work, prefer wait_for_messages with after_message_id so you only process new lines and do not treat an empty poll as the end of the mission.", {
     room_id: z.string().optional().describe("Canonical room ID. Defaults to the current room."),
 }, async ({ room_id }) => {
     const targetRoomId = getTargetRoomId(room_id);
@@ -1850,6 +1987,7 @@ server.tool("read_messages", "Read all messages from a Let Agents Chat room.", {
             break;
         afterCursor = lastMsg.id;
     }
+    await heartbeatRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, await ensureAgentIdentity());
     const output = { messages: toAgentReadableMessages(allMessages) };
     if (roomIdFromResponse) {
         output[targetRoomId ? "room_id" : "project_id"] = roomIdFromResponse;
@@ -1864,9 +2002,8 @@ server.tool("read_messages", "Read all messages from a Let Agents Chat room.", {
     };
 });
 // -- wait_for_messages ------------------------------------------------------
-const MAX_POLL_TIMEOUT_MS = 180000; // 3 minutes
 const DEFAULT_POLL_TIMEOUT_MS = 30000; // 30 seconds
-server.tool("wait_for_messages", "Wait for new messages in a Let Agents Chat room. Blocks until new messages arrive or 30 seconds elapse. Use the after_message_id parameter to only receive messages newer than a specific message.", {
+server.tool("wait_for_messages", "Wait for new messages in a Let Agents Chat room (HTTP long-poll). For multi-hour runs, call in a loop: always pass after_message_id from the last message you processed so an empty result means 'nothing new yet', not 'stop working'. If someone posted a premature 'I will wait' closing line, use send_message with a brief continue instruction. Per-call wait is capped (default max 180s unless LETAGENTS_POLL_MAX_MS is set on API and MCP).", {
     room_id: z.string().optional().describe("Canonical room ID. Defaults to the current room."),
     after_message_id: z
         .string()
@@ -1875,12 +2012,15 @@ server.tool("wait_for_messages", "Wait for new messages in a Let Agents Chat roo
     timeout: z
         .number()
         .optional()
-        .describe("Maximum wait time in milliseconds. If set to 0, the default timeout will be used."),
+        .describe("Maximum wait time in milliseconds (min 1000, capped by LETAGENTS_POLL_MAX_MS / server). If set to 0, the default timeout will be used."),
 }, async ({ room_id, after_message_id, timeout }) => {
     const targetRoomId = getTargetRoomId(room_id);
     const targetProjectId = getFallbackProjectId();
-    const serverTimeout = Math.min(Math.max(timeout || DEFAULT_POLL_TIMEOUT_MS, 1000), MAX_POLL_TIMEOUT_MS);
-    const clientTimeout = serverTimeout + 5000; // 5s buffer over server timeout
+    const identity = await ensureAgentIdentity();
+    await heartbeatRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity);
+    const maxPollMs = getPollTimeoutCapMs();
+    const serverTimeout = Math.min(Math.max(timeout || DEFAULT_POLL_TIMEOUT_MS, 1000), maxPollMs);
+    const clientTimeout = serverTimeout + (serverTimeout > 120_000 ? 120_000 : 5_000);
     const params = new URLSearchParams();
     if (after_message_id)
         params.set("after", after_message_id);
@@ -1924,6 +2064,7 @@ server.tool("wait_for_messages", "Wait for new messages in a Let Agents Chat roo
     if (targetRoomId) {
         touchRoomSession(targetRoomId, getLastMessageId(output));
     }
+    await heartbeatRoomPresence(targetRoomId ?? currentRoom?.room_id ?? null, identity);
     return {
         content: [
             {

package/dist/shared/agent-presence.js

@@ -0,0 +1,26 @@
+export const AGENT_PRESENCE_STATUSES = [
+    "idle",
+    "working",
+    "reviewing",
+    "blocked",
+];
+export const AGENT_PRESENCE_FRESHNESS = [
+    "active",
+    "stale",
+];
+export const ACTIVE_AGENT_PRESENCE_WINDOW_MS = 90_000;
+export function normalizeAgentPresenceStatus(value) {
+    const normalized = String(value || "").trim().toLowerCase();
+    return AGENT_PRESENCE_STATUSES.includes(normalized)
+        ? normalized
+        : null;
+}
+export function getAgentPresenceFreshness(lastHeartbeatAt, now = Date.now()) {
+    const heartbeatTime = new Date(lastHeartbeatAt).getTime();
+    if (!Number.isFinite(heartbeatTime)) {
+        return "stale";
+    }
+    return now - heartbeatTime <= ACTIVE_AGENT_PRESENCE_WINDOW_MS
+        ? "active"
+        : "stale";
+}

package/dist/shared/poll-timeout-cap.js

@@ -0,0 +1,19 @@
+/**
+ * Upper bound for `GET .../messages/poll` wait duration and MCP `wait_for_messages` timeout.
+ *
+ * Default **180000** (3 minutes). Operators may raise it (e.g. **36000000** for 10 hours) by
+ * setting **`LETAGENTS_POLL_MAX_MS`** on both the API process and the MCP server process.
+ * Values are clamped to **24 hours** to avoid accidental runaway timers.
+ */
+export function getPollTimeoutCapMs() {
+    const raw = process.env.LETAGENTS_POLL_MAX_MS;
+    if (raw == null || raw === "") {
+        return 180_000;
+    }
+    const n = Number.parseInt(String(raw), 10);
+    if (Number.isNaN(n) || n < 1_000) {
+        return 180_000;
+    }
+    const ceiling = 86_400_000; // 24 hours
+    return Math.min(n, ceiling);
+}

package/dist/shared/room-participant.js

@@ -0,0 +1,20 @@
+import { parseAgentActorLabel } from "./agent-identity.js";
+export const ROOM_PARTICIPANT_KINDS = ["human", "agent"];
+function normalizeParticipantKeyPart(value) {
+    return String(value ?? "")
+        .trim()
+        .replace(/\s+/g, " ")
+        .toLowerCase();
+}
+export function buildAgentRoomParticipantKey(actorLabel) {
+    const normalizedActorLabel = normalizeParticipantKeyPart(parseAgentActorLabel(actorLabel)?.raw ?? actorLabel);
+    return normalizedActorLabel ? `agent:${normalizedActorLabel}` : null;
+}
+export function buildHumanRoomParticipantKey(input) {
+    const loginKey = normalizeParticipantKeyPart(input.github_login);
+    if (loginKey) {
+        return `human:login:${loginKey}`;
+    }
+    const displayNameKey = normalizeParticipantKeyPart(input.display_name);
+    return displayNameKey ? `human:name:${displayNameKey}` : null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letagents",
-  "version": "0.12.2",
+  "version": "0.12.4",
   "description": "Let Agents Chat — MCP server for AI agent communication",
   "type": "module",
   "main": "dist/mcp/server.js",
@@ -48,6 +48,7 @@
     "@types/pg": "^8.18.0",
     "drizzle-kit": "^0.31.10",
     "tsx": "^4.19.4",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "ws": "^8.20.0"
   }
 }

package/dist/mcp/__tests__/config-reader.test.js

@@ -1,93 +0,0 @@
-import { findLetagentsConfig, getRoomFromConfig } from "../config-reader";
-import { mkdirSync, writeFileSync, rmSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-// Helper to create temp directories with config files
-function createTempDir() {
-    const dir = join(tmpdir(), `letagents-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(dir, { recursive: true });
-    return dir;
-}
-function cleanup(dir) {
-    try {
-        rmSync(dir, { recursive: true, force: true });
-    }
-    catch {
-        // ignore cleanup errors
-    }
-}
-describe("findLetagentsConfig", () => {
-    let tempDir;
-    afterEach(() => {
-        if (tempDir)
-            cleanup(tempDir);
-    });
-    it("returns config when .letagents.json is in the start directory", () => {
-        tempDir = createTempDir();
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "github.com/EmmyMay/letagents" }));
-        const config = findLetagentsConfig(tempDir);
-        expect(config).toEqual({ room: "github.com/EmmyMay/letagents" });
-    });
-    it("walks up to find config in parent directory", () => {
-        tempDir = createTempDir();
-        const childDir = join(tempDir, "src", "mcp");
-        mkdirSync(childDir, { recursive: true });
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "gitlab.com/team/project" }));
-        const config = findLetagentsConfig(childDir);
-        expect(config).toEqual({ room: "gitlab.com/team/project" });
-    });
-    it("returns null when no config file exists", () => {
-        tempDir = createTempDir();
-        const config = findLetagentsConfig(tempDir);
-        expect(config).toBeNull();
-    });
-    it("returns null for config with missing room field", () => {
-        tempDir = createTempDir();
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ version: "1.0" }));
-        // Suppress console.error for this test
-        const spy = jest.spyOn(console, "error").mockImplementation();
-        const config = findLetagentsConfig(tempDir);
-        expect(config).toBeNull();
-        spy.mockRestore();
-    });
-    it("returns null for config with empty room field", () => {
-        tempDir = createTempDir();
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "" }));
-        const spy = jest.spyOn(console, "error").mockImplementation();
-        const config = findLetagentsConfig(tempDir);
-        expect(config).toBeNull();
-        spy.mockRestore();
-    });
-    it("returns null for invalid JSON", () => {
-        tempDir = createTempDir();
-        writeFileSync(join(tempDir, ".letagents.json"), "not valid json {{{");
-        const spy = jest.spyOn(console, "error").mockImplementation();
-        const config = findLetagentsConfig(tempDir);
-        expect(config).toBeNull();
-        spy.mockRestore();
-    });
-    it("trims whitespace from room name", () => {
-        tempDir = createTempDir();
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "  github.com/EmmyMay/letagents  " }));
-        const config = findLetagentsConfig(tempDir);
-        expect(config).toEqual({ room: "github.com/EmmyMay/letagents" });
-    });
-});
-describe("getRoomFromConfig", () => {
-    let tempDir;
-    afterEach(() => {
-        if (tempDir)
-            cleanup(tempDir);
-    });
-    it("returns room string when config exists", () => {
-        tempDir = createTempDir();
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "github.com/EmmyMay/letagents" }));
-        const room = getRoomFromConfig(tempDir);
-        expect(room).toBe("github.com/EmmyMay/letagents");
-    });
-    it("returns null when no config exists", () => {
-        tempDir = createTempDir();
-        const room = getRoomFromConfig(tempDir);
-        expect(room).toBeNull();
-    });
-});

package/dist/mcp/__tests__/git-remote.test.js

@@ -1,37 +0,0 @@
-import { normalizeGitRemote } from "../git-remote";
-describe("normalizeGitRemote", () => {
-    // SSH format tests
-    it("normalizes SSH git@github.com format", () => {
-        expect(normalizeGitRemote("git@github.com:EmmyMay/letagents.git")).toBe("github.com/EmmyMay/letagents");
-    });
-    it("normalizes SSH without .git suffix", () => {
-        expect(normalizeGitRemote("git@github.com:EmmyMay/letagents")).toBe("github.com/EmmyMay/letagents");
-    });
-    it("normalizes SSH with gitlab host", () => {
-        expect(normalizeGitRemote("git@gitlab.com:team/project.git")).toBe("gitlab.com/team/project");
-    });
-    // HTTPS format tests
-    it("normalizes HTTPS with .git suffix", () => {
-        expect(normalizeGitRemote("https://github.com/EmmyMay/letagents.git")).toBe("github.com/EmmyMay/letagents");
-    });
-    it("normalizes HTTPS without .git suffix", () => {
-        expect(normalizeGitRemote("https://github.com/EmmyMay/letagents")).toBe("github.com/EmmyMay/letagents");
-    });
-    it("normalizes HTTPS with trailing slash", () => {
-        expect(normalizeGitRemote("https://github.com/EmmyMay/letagents/")).toBe("github.com/EmmyMay/letagents");
-    });
-    // SSH protocol format tests
-    it("normalizes ssh:// protocol format", () => {
-        expect(normalizeGitRemote("ssh://git@gitlab.com/team/project.git")).toBe("gitlab.com/team/project");
-    });
-    // Edge cases
-    it("handles whitespace", () => {
-        expect(normalizeGitRemote("  git@github.com:EmmyMay/letagents.git  ")).toBe("github.com/EmmyMay/letagents");
-    });
-    it("handles nested paths", () => {
-        expect(normalizeGitRemote("https://gitlab.com/org/sub-group/project.git")).toBe("gitlab.com/org/sub-group/project");
-    });
-    it("handles Bitbucket SSH format", () => {
-        expect(normalizeGitRemote("git@bitbucket.org:workspace/repo.git")).toBe("bitbucket.org/workspace/repo");
-    });
-});

package/dist/mcp/__tests__/server-helpers.test.js

@@ -1,121 +0,0 @@
-/**
- * Tests for server helper functions:
- * - resolveGitRoot: resolves the root of a git repo from any subdirectory
- * - findExistingConfig: walks parent dirs to find .letagents.json
- *
- * These helpers underpin the corrected initialize_repo tool behavior.
- * @author Kingdavid Ehindero <kdof64squares@gmail.com>
- */
-import { execSync } from "child_process";
-import { existsSync, mkdirSync, writeFileSync, rmSync } from "fs";
-import { join, resolve } from "path";
-import { tmpdir } from "os";
-// ---------------------------------------------------------------------------
-// Re-implement helpers here (they are not exported from server.ts yet)
-// We test the logic directly until we extract them to a shared module.
-// ---------------------------------------------------------------------------
-function resolveGitRoot(dir) {
-    try {
-        const root = execSync("git rev-parse --show-toplevel", {
-            cwd: dir,
-            stdio: ["pipe", "pipe", "pipe"],
-            encoding: "utf-8",
-        }).trim();
-        return root || null;
-    }
-    catch {
-        return null;
-    }
-}
-function findExistingConfig(startDir) {
-    const { dirname } = require("path");
-    let current = startDir;
-    while (true) {
-        if (existsSync(join(current, ".letagents.json")))
-            return current;
-        const parent = dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-    }
-    return null;
-}
-// ---------------------------------------------------------------------------
-// Helpers for tests
-// ---------------------------------------------------------------------------
-function makeTempGitRepo() {
-    const dir = join(tmpdir(), `letagents-test-${Date.now()}`);
-    mkdirSync(dir, { recursive: true });
-    execSync("git init", { cwd: dir, stdio: "pipe" });
-    execSync("git commit --allow-empty -m init", { cwd: dir, stdio: "pipe" });
-    return dir;
-}
-function cleanup(dir) {
-    try {
-        rmSync(dir, { recursive: true, force: true });
-    }
-    catch { /* ignore */ }
-}
-// ---------------------------------------------------------------------------
-// resolveGitRoot tests
-// ---------------------------------------------------------------------------
-describe("resolveGitRoot", () => {
-    let repoDir;
-    beforeAll(() => { repoDir = makeTempGitRepo(); });
-    afterAll(() => cleanup(repoDir));
-    it("returns the repo root when called from repo root", () => {
-        const result = resolveGitRoot(repoDir);
-        expect(result).toBe(resolve(repoDir));
-    });
-    it("returns the repo root when called from a subdirectory", () => {
-        const subDir = join(repoDir, "src", "deep", "path");
-        mkdirSync(subDir, { recursive: true });
-        const result = resolveGitRoot(subDir);
-        expect(result).toBe(resolve(repoDir));
-    });
-    it("returns null when not inside a git repo", () => {
-        const nonRepoDir = join(tmpdir(), `no-git-${Date.now()}`);
-        mkdirSync(nonRepoDir, { recursive: true });
-        const result = resolveGitRoot(nonRepoDir);
-        cleanup(nonRepoDir);
-        expect(result).toBeNull();
-    });
-    it("returns null for a non-existent directory", () => {
-        const result = resolveGitRoot(join(tmpdir(), "does-not-exist-12345"));
-        expect(result).toBeNull();
-    });
-});
-// ---------------------------------------------------------------------------
-// findExistingConfig tests
-// ---------------------------------------------------------------------------
-describe("findExistingConfig", () => {
-    let tempDir;
-    beforeEach(() => {
-        tempDir = join(tmpdir(), `letagents-cfg-test-${Date.now()}`);
-        mkdirSync(tempDir, { recursive: true });
-    });
-    afterEach(() => cleanup(tempDir));
-    it("returns null when no .letagents.json exists anywhere", () => {
-        const subDir = join(tempDir, "a", "b", "c");
-        mkdirSync(subDir, { recursive: true });
-        expect(findExistingConfig(subDir)).toBeNull();
-    });
-    it("finds config in the start directory", () => {
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "test" }));
-        expect(findExistingConfig(tempDir)).toBe(tempDir);
-    });
-    it("finds config in a parent directory when called from subdirectory", () => {
-        const subDir = join(tempDir, "nested", "path");
-        mkdirSync(subDir, { recursive: true });
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "test" }));
-        expect(findExistingConfig(subDir)).toBe(tempDir);
-    });
-    it("returns the closest config when multiple exist in the tree", () => {
-        const subDir = join(tempDir, "nested");
-        mkdirSync(subDir, { recursive: true });
-        // Config at root and at nested level — should find nested first
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "root" }));
-        writeFileSync(join(subDir, ".letagents.json"), JSON.stringify({ room: "nested" }));
-        expect(findExistingConfig(subDir)).toBe(subDir);
-    });
-});