letagents 0.6.0 → 0.8.0

package/dist/mcp/server.js

@@ -8,11 +8,16 @@ import { execSync } from "child_process";
 import { SseClient } from "./sse-client.js";
 import { getRoomFromConfig } from "./config-reader.js";
 import { getGitRemoteIdentity } from "./git-remote.js";
+import { clearPendingDeviceAuth, clearStoredAuth, getLocalStatePath, getPendingDeviceAuth, getStoredAuth, getStoredCurrentRoom, getStoredRoomSession, saveRoomSession, setPendingDeviceAuth, setStoredAuth, touchRoomSession, } from "./local-state.js";
+import { encodeRoomIdPath, looksLikeInviteCode, normalizeInviteCode, } from "./room-id.js";
 let currentRoom = null;
 // ---------------------------------------------------------------------------
 // Config
 // ---------------------------------------------------------------------------
-const API_URL = process.env.LETAGENTS_API_URL || "http://localhost:3001";
+const API_URL = (process.env.LETAGENTS_API_URL || "http://localhost:3001").replace(/\/+$/, "");
+const AGENT_NAME = (process.env.LETAGENTS_AGENT_NAME || process.env.AGENT_NAME || "").trim();
+const AGENT_DISPLAY_NAME = (process.env.LETAGENTS_AGENT_DISPLAY_NAME || "").trim();
+const AGENT_OWNER_LABEL = (process.env.LETAGENTS_AGENT_OWNER_LABEL || "").trim();
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -49,19 +54,282 @@ function findExistingConfig(startDir) {
     }
     return null;
 }
+class ApiError extends Error {
+    status;
+    body;
+    constructor(status, body) {
+        super(`API error ${status}: ${body}`);
+        this.name = "ApiError";
+        this.status = status;
+        this.body = body;
+    }
+}
+function getLetagentsToken() {
+    return process.env.LETAGENTS_TOKEN || getStoredAuth()?.token || "";
+}
+function getAuthorizationHeader() {
+    const letagentsToken = getLetagentsToken();
+    if (letagentsToken) {
+        return `Bearer ${letagentsToken}`;
+    }
+    return null;
+}
+function isMissingRouteError(error) {
+    return (error instanceof ApiError &&
+        (error.status === 404 || error.status === 405) &&
+        /Cannot (GET|POST|PATCH)|Not Found|Cannot GET \/rooms|Cannot POST \/rooms/i.test(error.body));
+}
 async function apiCall(path, options) {
+    const headers = {
+        "Content-Type": "application/json",
+        ...options?.headers,
+    };
+    const authorizationHeader = getAuthorizationHeader();
+    if (authorizationHeader && !headers.Authorization) {
+        headers.Authorization = authorizationHeader;
+    }
     const res = await fetch(`${API_URL}${path}`, {
         ...options,
-        headers: {
-            "Content-Type": "application/json",
-            ...options?.headers,
-        },
+        headers,
     });
     if (!res.ok) {
         const body = await res.text();
-        throw new Error(`API error ${res.status}: ${body}`);
+        if (res.status === 401) {
+            // Only clear on 401 (invalid/expired credential), NOT on 403
+            // (valid credential but insufficient permissions, e.g., private repo access)
+            clearStoredAuth();
+        }
+        throw new ApiError(res.status, body);
+    }
+    const body = await res.text();
+    if (!body) {
+        return null;
+    }
+    return JSON.parse(body);
+}
+function toRoomState(input) {
+    return {
+        room_id: input.room_id,
+        project_id: input.project_id ?? null,
+        code: input.code ?? null,
+        joined_via: input.joined_via,
+    };
+}
+function toPublicRoomState(state) {
+    if (!state) {
+        return null;
+    }
+    return {
+        room_id: state.room_id,
+        code: state.code ?? null,
+        joined_via: state.joined_via,
+    };
+}
+function toPublicStoredRoomSession(session) {
+    if (!session) {
+        return null;
+    }
+    return {
+        room_id: session.room_id,
+        code: session.code ?? null,
+        joined_via: session.joined_via,
+        joined_at: session.joined_at,
+        last_seen_at: session.last_seen_at,
+        last_message_id: session.last_message_id ?? null,
+    };
+}
+function toPublicRoomResponse(response, fallbackRoomId) {
+    const { id: _legacyId, project_id: _legacyProjectId, ...rest } = response;
+    return {
+        ...rest,
+        room_id: typeof rest.room_id === "string" ? rest.room_id : fallbackRoomId,
+    };
+}
+function rememberRoom(state, lastMessageId) {
+    currentRoom = state;
+    saveRoomSession({
+        room_id: state.room_id,
+        project_id: state.project_id ?? null,
+        code: state.code ?? null,
+        joined_via: state.joined_via,
+        last_message_id: lastMessageId,
+    });
+    sseClient.unsubscribeAll();
+    sseClient.subscribe({
+        roomId: state.room_id,
+        projectId: state.project_id ?? null,
+    }, (_message) => {
+        touchRoomSession(state.room_id);
+        server.server.sendResourceListChanged();
+    });
+    return state;
+}
+function touchCurrentRoom(lastMessageId) {
+    if (!currentRoom) {
+        return;
+    }
+    touchRoomSession(currentRoom.room_id, lastMessageId);
+}
+function getTargetRoomId(roomId) {
+    return roomId || currentRoom?.room_id || null;
+}
+function getFallbackProjectId() {
+    return currentRoom?.project_id ?? null;
+}
+function getLastMessageId(payload) {
+    if (!payload || typeof payload !== "object") {
+        return undefined;
+    }
+    const messages = payload.messages;
+    const lastMessage = messages?.at(-1);
+    return typeof lastMessage?.id === "string" ? lastMessage.id : undefined;
+}
+async function roomScopedApiCall(input) {
+    if (input.room_id) {
+        try {
+            const result = await apiCall(input.room_path(input.room_id), input.options);
+            touchRoomSession(input.room_id, getLastMessageId(result));
+            return result;
+        }
+        catch (error) {
+            if (!input.project_id || !isMissingRouteError(error)) {
+                throw error;
+            }
+        }
+    }
+    if (!input.project_id) {
+        throw new Error("No room is available for this request.");
+    }
+    const result = await apiCall(input.project_path(input.project_id), input.options);
+    if (input.room_id) {
+        touchRoomSession(input.room_id, getLastMessageId(result));
+    }
+    return result;
+}
+async function joinRoomIdentifier(identifier, joinedVia) {
+    const roomId = joinedVia === "join_code" ? normalizeInviteCode(identifier) : identifier.trim();
+    try {
+        const response = await apiCall(`/rooms/${encodeRoomIdPath(roomId)}/join`, { method: "POST" });
+        const joinedRoomId = typeof response.room_id === "string"
+            ? response.room_id
+            : roomId;
+        const room = rememberRoom(toRoomState({
+            room_id: joinedRoomId,
+            project_id: typeof response.project_id === "string" ? response.project_id : null,
+            code: typeof response.code === "string"
+                ? response.code
+                : looksLikeInviteCode(joinedRoomId)
+                    ? joinedRoomId
+                    : null,
+            joined_via: joinedVia,
+        }));
+        return {
+            room,
+            response: { ...response, room_id: joinedRoomId },
+        };
+    }
+    catch (error) {
+        if (!isMissingRouteError(error)) {
+            throw error;
+        }
+    }
+    if (joinedVia === "join_code") {
+        const project = await apiCall(`/projects/join/${encodeURIComponent(roomId)}`);
+        const legacyRoomId = typeof project.code === "string"
+            ? project.code
+            : roomId;
+        const room = rememberRoom(toRoomState({
+            room_id: legacyRoomId,
+            project_id: typeof project.id === "string" ? project.id : null,
+            code: typeof project.code === "string" ? project.code : legacyRoomId,
+            joined_via: joinedVia,
+        }));
+        return {
+            room,
+            response: {
+                ...project,
+                room_id: legacyRoomId,
+                project_id: typeof project.id === "string" ? project.id : null,
+            },
+        };
+    }
+    const project = await apiCall(`/projects/room/${encodeURIComponent(roomId)}`, { method: "POST" });
+    const legacyRoomId = typeof project.name === "string" && project.name.trim()
+        ? project.name
+        : typeof project.code === "string" && project.code.trim()
+            ? project.code
+            : roomId;
+    const room = rememberRoom(toRoomState({
+        room_id: legacyRoomId,
+        project_id: typeof project.id === "string" ? project.id : null,
+        code: typeof project.code === "string"
+            ? project.code
+            : looksLikeInviteCode(legacyRoomId)
+                ? legacyRoomId
+                : null,
+        joined_via: joinedVia,
+    }));
+    return {
+        room,
+        response: {
+            ...project,
+            room_id: legacyRoomId,
+            project_id: typeof project.id === "string" ? project.id : null,
+        },
+    };
+}
+async function createInviteRoom() {
+    const project = await apiCall("/projects", { method: "POST" });
+    const roomId = typeof project.code === "string"
+        ? project.code
+        : typeof project.id === "string"
+            ? project.id
+            : "unknown-room";
+    const room = rememberRoom(toRoomState({
+        room_id: roomId,
+        project_id: typeof project.id === "string" ? project.id : null,
+        code: typeof project.code === "string" ? project.code : roomId,
+        joined_via: "join_code",
+    }));
+    await autoRegisterAgentIdentity();
+    return {
+        room,
+        response: toPublicRoomResponse(project, roomId),
+    };
+}
+async function joinInviteCode(code) {
+    const joined = await joinRoomIdentifier(code, "join_code");
+    await autoRegisterAgentIdentity();
+    return {
+        ...toPublicRoomResponse(joined.response, joined.room.room_id),
+        joined_via: "join_code",
+    };
+}
+async function joinNamedRoom(name) {
+    const joined = await joinRoomIdentifier(name, "join_room");
+    await autoRegisterAgentIdentity();
+    return {
+        ...toPublicRoomResponse(joined.response, joined.room.room_id),
+        joined_via: "join_room",
+    };
+}
+async function autoRegisterAgentIdentity() {
+    if (!AGENT_NAME || !currentRoom) {
+        return;
+    }
+    try {
+        await apiCall("/agents", {
+            method: "POST",
+            body: JSON.stringify({
+                name: AGENT_NAME,
+                display_name: AGENT_DISPLAY_NAME || AGENT_NAME,
+                owner_label: AGENT_OWNER_LABEL || undefined,
+            }),
+        });
+    }
+    catch (error) {
+        console.error("Agent identity registration failed:", error);
     }
-    return res.json();
 }
 // ---------------------------------------------------------------------------
 // MCP Server
@@ -70,14 +338,22 @@ const server = new McpServer({
     name: "letagents",
     version: "0.2.0",
 });
-const sseClient = new SseClient(API_URL);
+const sseClient = new SseClient(API_URL, () => getLetagentsToken());
 // ---------------------------------------------------------------------------
 // MCP Resources
 // ---------------------------------------------------------------------------
-server.resource("project_messages", new ResourceTemplate("letagents://projects/{project_id}/messages", {
+server.resource("room_messages", new ResourceTemplate("letagents://rooms/{room_id}/messages", {
     list: undefined,
-}), async (uri, { project_id }) => {
-    const result = await apiCall(`/projects/${encodeURIComponent(project_id)}/messages`);
+}), async (uri, { room_id }) => {
+    const normalizedRoomId = String(room_id);
+    const storedSession = getStoredRoomSession(normalizedRoomId) ??
+        (currentRoom?.room_id === normalizedRoomId ? getStoredCurrentRoom() : null);
+    const result = await roomScopedApiCall({
+        room_id: normalizedRoomId,
+        project_id: storedSession?.project_id ?? null,
+        room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/messages`,
+        project_path: (projectId) => `/projects/${encodeURIComponent(projectId)}/messages`,
+    });
     return {
         contents: [
             {
@@ -88,43 +364,52 @@ server.resource("project_messages", new ResourceTemplate("letagents://projects/{
         ],
     };
 });
+// -- create_room ------------------------------------------------------------
+server.tool("create_room", "Create a new invite room on Let Agents Chat. Returns the room ID and join code.", {}, async () => {
+    const created = await createInviteRoom();
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(created.response, null, 2),
+            },
+        ],
+    };
+});
 // -- create_project ---------------------------------------------------------
-server.tool("create_project", "Create a new project on Let Agents Chat. Returns a project ID and a join code that other agents can use to join.", {}, async () => {
-    const project = await apiCall("/projects", { method: "POST" });
-    // Auto-subscribe to SSE for this project
-    sseClient.subscribe(project.id, (_message) => {
-        server.server.sendResourceListChanged();
-    });
+server.tool("create_project", "Legacy alias for create_room. Creates a new invite room and returns its join code.", {}, async () => {
+    const created = await createInviteRoom();
     return {
         content: [
             {
                 type: "text",
-                text: JSON.stringify(project, null, 2),
+                text: JSON.stringify(created.response, null, 2),
             },
         ],
     };
 });
-// -- join_project -----------------------------------------------------------
-server.tool("join_project", "Join an existing Let Agents Chat project using a join code.", {
-    code: z.string().describe("The join code shared by the project creator (e.g. 'ABCX-7291')"),
+// -- join_code --------------------------------------------------------------
+server.tool("join_code", "Join an existing room using an invite code.", {
+    code: z.string().describe("The invite code shared for the room (e.g. 'ABCX-7291')"),
 }, async ({ code }) => {
-    const project = await apiCall(`/projects/join/${encodeURIComponent(code)}`);
-    // Track room state
-    currentRoom = {
-        room: project.name || code,
-        project_id: project.id,
-        code: project.code || code,
-        joined_via: "join_code",
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(await joinInviteCode(code), null, 2),
+            },
+        ],
     };
-    // Auto-subscribe to SSE for this project
-    sseClient.subscribe(project.id, (_message) => {
-        server.server.sendResourceListChanged();
-    });
+});
+// -- join_project -----------------------------------------------------------
+server.tool("join_project", "Legacy alias for join_code. Join an existing room using an invite code.", {
+    code: z.string().describe("The invite code shared for the room (e.g. 'ABCX-7291')"),
+}, async ({ code }) => {
     return {
         content: [
             {
                 type: "text",
-                text: JSON.stringify({ ...project, joined_via: "join_code" }, null, 2),
+                text: JSON.stringify(await joinInviteCode(code), null, 2),
             },
         ],
     };
@@ -133,23 +418,11 @@ server.tool("join_project", "Join an existing Let Agents Chat project using a jo
 server.tool("join_room", "Join a named room on Let Agents Chat. Creates the room if it doesn't exist. Use this for repo-based room joining.", {
     name: z.string().describe("The room name to join (e.g. 'github.com/owner/repo')"),
 }, async ({ name }) => {
-    const project = await apiCall(`/projects/room/${encodeURIComponent(name)}`, { method: "POST" });
-    // Track room state
-    currentRoom = {
-        room: name,
-        project_id: project.id,
-        code: project.code,
-        joined_via: "join_room",
-    };
-    // Auto-subscribe to SSE
-    sseClient.subscribe(project.id, (_message) => {
-        server.server.sendResourceListChanged();
-    });
     return {
         content: [
             {
                 type: "text",
-                text: JSON.stringify({ ...project, joined_via: "join_room" }, null, 2),
+                text: JSON.stringify(await joinNamedRoom(name), null, 2),
             },
         ],
     };
@@ -170,7 +443,17 @@ server.tool("get_current_room", "Get information about the currently joined room
         content: [
             {
                 type: "text",
-                text: JSON.stringify({ connected: true, ...currentRoom }, null, 2),
+                text: JSON.stringify({
+                    connected: true,
+                    ...toPublicRoomState(currentRoom),
+                    auth: getStoredAuth()
+                        ? {
+                            source: process.env.LETAGENTS_TOKEN ? "env" : "local_state",
+                            expires_at: getStoredAuth()?.expires_at ?? null,
+                            account: getStoredAuth()?.account ?? null,
+                        }
+                        : null,
+                }, null, 2),
             },
         ],
     };
@@ -209,11 +492,11 @@ server.tool("check_repo", "Inspect the current repository context for Let Agents
                     config_file: configPath ?? null,
                     config_contents: configContents,
                     derived_room_from_git: derivedRoom ?? null,
-                    current_room: currentRoom ?? null,
+                    current_room: toPublicRoomState(currentRoom),
                     join_hint: !currentRoom
                         ? repoRoot
-                            ? "Run initialize_repo to set up .letagents.json, or join_room/join_project to connect."
-                            : "Not inside a git repo. Use join_project or join_room to connect manually."
+                            ? "Run initialize_repo to set up .letagents.json, or use join_room/join_code to connect."
+                            : "Not inside a git repo. Use create_room, join_code, or join_room to connect manually."
                         : null,
                 }, null, 2),
             },
@@ -227,21 +510,22 @@ server.tool("post_status", "Broadcast a lightweight status update to the current
     "Status updates are distinct from chat messages and can be filtered separately.", {
     sender: z.string().describe("Name of the agent posting the status (e.g. 'codex-agent')"),
     status: z.string().describe("Short status description (e.g. 'reviewing PR #2', 'idle', 'thinking...')"),
-    project_id: z
+    room_id: z
         .string()
         .optional()
-        .describe("Project ID to post status to. Defaults to the current room if joined."),
-}, async ({ sender, status, project_id }) => {
-    const targetProjectId = project_id || currentRoom?.project_id;
-    if (!targetProjectId) {
+        .describe("Canonical room ID. Defaults to the current room."),
+}, async ({ sender, status, room_id }) => {
+    const targetRoomId = getTargetRoomId(room_id);
+    const targetProjectId = getFallbackProjectId();
+    if (!targetRoomId && !targetProjectId) {
         return {
             content: [
                 {
                     type: "text",
                     text: JSON.stringify({
                         success: false,
-                        error: "No project_id provided and not currently in a room.",
-                        hint: "Join a room first with join_project or join_room, or pass project_id explicitly.",
+                        error: "No room_id provided and not currently in a room.",
+                        hint: "Join or create a room first, or pass room_id explicitly.",
                     }, null, 2),
                 },
             ],
@@ -250,10 +534,17 @@ server.tool("post_status", "Broadcast a lightweight status update to the current
     // Status messages use a reserved prefix so the UI (and agents) can distinguish
     // them from normal chat messages without changing the data model.
     const statusText = `[status] ${status}`;
-    const message = await apiCall(`/projects/${encodeURIComponent(targetProjectId)}/messages`, {
-        method: "POST",
-        body: JSON.stringify({ sender, text: statusText }),
+    const message = await roomScopedApiCall({
+        room_id: targetRoomId,
+        project_id: targetProjectId,
+        room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/messages`,
+        project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/messages`,
+        options: {
+            method: "POST",
+            body: JSON.stringify({ sender, text: statusText }),
+        },
     });
+    touchCurrentRoom(typeof message.id === "string" ? message.id : undefined);
     return {
         content: [
             {
@@ -262,8 +553,8 @@ server.tool("post_status", "Broadcast a lightweight status update to the current
                     success: true,
                     status_posted: status,
                     sender,
-                    message_id: message.id,
-                    timestamp: message.timestamp,
+                    message_id: typeof message.id === "string" ? message.id : null,
+                    timestamp: typeof message.timestamp === "string" ? message.timestamp : null,
                 }, null, 2),
             },
         ],
@@ -274,7 +565,7 @@ const TASK_STATUSES = [
     "proposed", "accepted", "assigned", "in_progress",
     "blocked", "in_review", "merged", "done", "cancelled",
 ];
-server.tool("add_task", "Add a new task to the project board. Tasks normally start as 'proposed' and must be " +
+server.tool("add_task", "Add a new task to the room board. Tasks normally start as 'proposed' and must be " +
     "accepted before an agent can claim them, but tasks created by trusted agents already " +
     "active in the room may be auto-accepted. Use this when a human or agent identifies " +
     "work that needs to be done.", {
@@ -282,31 +573,39 @@ server.tool("add_task", "Add a new task to the project board. Tasks normally sta
     description: z.string().optional().describe("Longer description of what needs to be done"),
     created_by: z.string().describe("Name of the agent or human creating the task"),
     source_message_id: z.string().optional().describe("Optional message ID where task was agreed, e.g. 'msg_42'"),
-    project_id: z.string().optional().describe("Project ID. Defaults to current room."),
-}, async ({ title, description, created_by, source_message_id, project_id }) => {
-    const targetProjectId = project_id || currentRoom?.project_id;
-    if (!targetProjectId) {
+    room_id: z.string().optional().describe("Canonical room ID. Defaults to current room."),
+}, async ({ title, description, created_by, source_message_id, 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 task = await apiCall(`/projects/${encodeURIComponent(targetProjectId)}/tasks`, {
-        method: "POST",
-        body: JSON.stringify({ title, description, created_by, source_message_id }),
+    const task = await roomScopedApiCall({
+        room_id: targetRoomId,
+        project_id: targetProjectId,
+        room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/tasks`,
+        project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/tasks`,
+        options: {
+            method: "POST",
+            body: JSON.stringify({ title, description, created_by, source_message_id }),
+        },
     });
     return {
         content: [{ type: "text", text: JSON.stringify({ success: true, task }, null, 2) }],
     };
 });
-server.tool("get_board", "Get the current task board for the project. By default shows only open tasks " +
+server.tool("get_board", "Get the current task board for the room. By default shows only open tasks " +
     "(not done/cancelled). Agents should check this on startup and when idle to " +
     "see if there is unassigned work to claim.", {
     status: z.enum(TASK_STATUSES).optional().describe("Filter by specific status"),
     open_only: z.boolean().optional().describe("If true (default), only show tasks not done/cancelled"),
-    project_id: z.string().optional().describe("Project ID. Defaults to current room."),
-}, async ({ status, open_only, project_id }) => {
-    const targetProjectId = project_id || currentRoom?.project_id;
-    if (!targetProjectId) {
+    room_id: z.string().optional().describe("Canonical room ID. Defaults to current room."),
+}, async ({ status, open_only, 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." }) }],
         };
@@ -317,7 +616,12 @@ server.tool("get_board", "Get the current task board for the project. By default
     if (open_only !== false)
         params.set("open", "true");
     const qs = params.toString();
-    const result = await apiCall(`/projects/${encodeURIComponent(targetProjectId)}/tasks${qs ? `?${qs}` : ""}`);
+    const result = await roomScopedApiCall({
+        room_id: targetRoomId,
+        project_id: targetProjectId,
+        room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/tasks${qs ? `?${qs}` : ""}`,
+        project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/tasks${qs ? `?${qs}` : ""}`,
+    });
     return {
         content: [{ type: "text", text: JSON.stringify({ success: true, ...result }, null, 2) }],
     };
@@ -327,18 +631,25 @@ server.tool("claim_task", "Claim an accepted task. The task must be in 'accepted
     "Do NOT claim proposed tasks — they need to be accepted first.", {
     task_id: z.string().describe("The task ID to claim, e.g. 'task_1'"),
     assignee: z.string().describe("Your agent name, e.g. 'antigravity'"),
-    project_id: z.string().optional().describe("Project ID. Defaults to current room."),
-}, async ({ task_id, assignee, project_id }) => {
-    const targetProjectId = project_id || currentRoom?.project_id;
-    if (!targetProjectId) {
+    room_id: z.string().optional().describe("Canonical room ID. Defaults to current room."),
+}, async ({ task_id, assignee, 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." }) }],
         };
     }
     try {
-        const updated = await apiCall(`/projects/${encodeURIComponent(targetProjectId)}/tasks/${encodeURIComponent(task_id)}`, {
-            method: "PATCH",
-            body: JSON.stringify({ status: "assigned", assignee }),
+        const updated = await roomScopedApiCall({
+            room_id: targetRoomId,
+            project_id: targetProjectId,
+            room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/tasks/${encodeURIComponent(task_id)}`,
+            project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/tasks/${encodeURIComponent(task_id)}`,
+            options: {
+                method: "PATCH",
+                body: JSON.stringify({ status: "assigned", assignee }),
+            },
         });
         return {
             content: [{ type: "text", text: JSON.stringify({ success: true, task: updated }, null, 2) }],
@@ -357,18 +668,25 @@ server.tool("update_task", "Update a task's status or assignee. Status transitio
     status: z.enum(TASK_STATUSES).optional().describe("New status for the task"),
     assignee: z.string().optional().describe("New assignee for the task"),
     pr_url: z.string().optional().describe("PR URL to link to the task"),
-    project_id: z.string().optional().describe("Project ID. Defaults to current room."),
-}, async ({ task_id, status, assignee, pr_url, project_id }) => {
-    const targetProjectId = project_id || currentRoom?.project_id;
-    if (!targetProjectId) {
+    room_id: z.string().optional().describe("Canonical room ID. Defaults to current room."),
+}, async ({ task_id, status, assignee, pr_url, 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." }) }],
         };
     }
     try {
-        const updated = await apiCall(`/projects/${encodeURIComponent(targetProjectId)}/tasks/${encodeURIComponent(task_id)}`, {
-            method: "PATCH",
-            body: JSON.stringify({ status, assignee, pr_url }),
+        const updated = await roomScopedApiCall({
+            room_id: targetRoomId,
+            project_id: targetProjectId,
+            room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/tasks/${encodeURIComponent(task_id)}`,
+            project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/tasks/${encodeURIComponent(task_id)}`,
+            options: {
+                method: "PATCH",
+                body: JSON.stringify({ status, assignee, pr_url }),
+            },
         });
         return {
             content: [{ type: "text", text: JSON.stringify({ success: true, task: updated }, null, 2) }],
@@ -385,18 +703,25 @@ server.tool("complete_task", "Submit a task for review. Moves the task to 'in_re
     "the work is merged before it can be marked done.", {
     task_id: z.string().describe("The task ID to submit for review"),
     pr_url: z.string().optional().describe("GitHub PR URL for the work"),
-    project_id: z.string().optional().describe("Project ID. Defaults to current room."),
-}, async ({ task_id, pr_url, project_id }) => {
-    const targetProjectId = project_id || currentRoom?.project_id;
-    if (!targetProjectId) {
+    room_id: z.string().optional().describe("Canonical room ID. Defaults to current room."),
+}, async ({ task_id, pr_url, 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." }) }],
         };
     }
     try {
-        const updated = await apiCall(`/projects/${encodeURIComponent(targetProjectId)}/tasks/${encodeURIComponent(task_id)}`, {
-            method: "PATCH",
-            body: JSON.stringify({ status: "in_review", pr_url }),
+        const updated = await roomScopedApiCall({
+            room_id: targetRoomId,
+            project_id: targetProjectId,
+            room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/tasks/${encodeURIComponent(task_id)}`,
+            project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/tasks/${encodeURIComponent(task_id)}`,
+            options: {
+                method: "PATCH",
+                body: JSON.stringify({ status: "in_review", pr_url }),
+            },
         });
         return {
             content: [{ type: "text", text: JSON.stringify({ success: true, task: updated }, null, 2) }],
@@ -516,16 +841,7 @@ server.tool("initialize_repo", "Initialize the current repo for Let Agents Chat
     }
     // Auto-join the room after creating config
     try {
-        const project = await apiCall(`/projects/room/${encodeURIComponent(roomName)}`, { method: "POST" });
-        currentRoom = {
-            room: roomName,
-            project_id: project.id,
-            code: project.code,
-            joined_via: "config",
-        };
-        sseClient.subscribe(project.id, (_message) => {
-            server.server.sendResourceListChanged();
-        });
+        const joined = await joinRoomIdentifier(roomName, "config");
         return {
             content: [
                 {
@@ -533,9 +849,8 @@ server.tool("initialize_repo", "Initialize the current repo for Let Agents Chat
                     text: JSON.stringify({
                         success: true,
                         created: configPath,
-                        room: roomName,
-                        project_id: project.id,
-                        code: project.code,
+                        room_id: joined.room.room_id,
+                        code: joined.room.code ?? null,
                         joined: true,
                         hint: "Consider adding .letagents.json to git so other contributors auto-join the same room.",
                     }, null, 2),
@@ -552,7 +867,7 @@ server.tool("initialize_repo", "Initialize the current repo for Let Agents Chat
                     text: JSON.stringify({
                         success: true,
                         created: configPath,
-                        room: roomName,
+                        room_id: roomName,
                         joined: false,
                         error: `Config created but auto-join failed: ${err instanceof Error ? err.message : err}`,
                         hint: "The .letagents.json was created. Use join_room to manually connect.",
@@ -563,15 +878,27 @@ 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 project.", {
-    project_id: z.string().describe("The project ID to send the message to"),
+server.tool("send_message", "Send a message to a Let Agents Chat room.", {
+    room_id: z.string().optional().describe("Canonical room ID. Defaults to the current room."),
     sender: z.string().describe("Name identifying the sending agent (e.g. 'antigravity-agent')"),
     text: z.string().describe("The message text to send"),
-}, async ({ project_id, sender, text }) => {
-    const message = await apiCall(`/projects/${encodeURIComponent(project_id)}/messages`, {
-        method: "POST",
-        body: JSON.stringify({ sender, text }),
+}, async ({ room_id, sender, text }) => {
+    const targetRoomId = getTargetRoomId(room_id);
+    const targetProjectId = getFallbackProjectId();
+    if (!targetRoomId && !targetProjectId) {
+        throw new Error("No room is currently selected. Join a room first or pass room_id.");
+    }
+    const message = await roomScopedApiCall({
+        room_id: targetRoomId,
+        project_id: targetProjectId,
+        room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/messages`,
+        project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/messages`,
+        options: {
+            method: "POST",
+            body: JSON.stringify({ sender, text }),
+        },
     });
+    touchCurrentRoom(typeof message.id === "string" ? message.id : undefined);
     return {
         content: [
             {
@@ -582,10 +909,17 @@ server.tool("send_message", "Send a message to a Let Agents Chat project.", {
     };
 });
 // -- read_messages ----------------------------------------------------------
-server.tool("read_messages", "Read all messages from a Let Agents Chat project.", {
-    project_id: z.string().describe("The project ID to read messages from"),
-}, async ({ project_id }) => {
-    const result = await apiCall(`/projects/${encodeURIComponent(project_id)}/messages`);
+server.tool("read_messages", "Read all messages from a Let Agents Chat room.", {
+    room_id: z.string().optional().describe("Canonical room ID. Defaults to the current room."),
+}, async ({ room_id }) => {
+    const targetRoomId = getTargetRoomId(room_id);
+    const targetProjectId = getFallbackProjectId();
+    const result = await roomScopedApiCall({
+        room_id: targetRoomId,
+        project_id: targetProjectId,
+        room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/messages`,
+        project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/messages`,
+    });
     return {
         content: [
             {
@@ -598,8 +932,8 @@ server.tool("read_messages", "Read all messages from a Let Agents Chat project."
 // -- 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 project. Blocks until new messages arrive or 30 seconds elapse. Use the after_message_id parameter to only receive messages newer than a specific message.", {
-    project_id: z.string().describe("The project ID to wait for messages in"),
+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.", {
+    room_id: z.string().optional().describe("Canonical room ID. Defaults to the current room."),
     after_message_id: z
         .string()
         .optional()
@@ -608,7 +942,9 @@ server.tool("wait_for_messages", "Wait for new messages in a Let Agents Chat pro
         .number()
         .optional()
         .describe("Maximum wait time in milliseconds. If set to 0, the default timeout will be used."),
-}, async ({ project_id, after_message_id, timeout }) => {
+}, 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 params = new URLSearchParams();
@@ -616,7 +952,304 @@ server.tool("wait_for_messages", "Wait for new messages in a Let Agents Chat pro
         params.set("after", after_message_id);
     params.set("timeout", String(serverTimeout));
     const queryString = params.toString();
-    const result = await apiCall(`/projects/${encodeURIComponent(project_id)}/messages/poll?${queryString}`, { signal: AbortSignal.timeout(clientTimeout) });
+    const result = await roomScopedApiCall({
+        room_id: targetRoomId,
+        project_id: targetProjectId,
+        room_path: (targetRoomId) => `/rooms/${encodeRoomIdPath(targetRoomId)}/messages/poll?${queryString}`,
+        project_path: (targetProjectId) => `/projects/${encodeURIComponent(targetProjectId)}/messages/poll?${queryString}`,
+        options: { signal: AbortSignal.timeout(clientTimeout) },
+    });
+    if (targetRoomId) {
+        touchRoomSession(targetRoomId, getLastMessageId(result));
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(result, null, 2),
+            },
+        ],
+    };
+});
+// -- onboarding -------------------------------------------------------------
+server.tool("get_onboarding_status", "Inspect local Let Agents MCP auth and room-session state so a user can finish onboarding without guessing what is missing.", {
+    cwd: z
+        .string()
+        .optional()
+        .describe("Working directory to inspect for repo context. Defaults to the current process directory."),
+}, async ({ cwd }) => {
+    const workingDir = cwd || process.cwd();
+    const repoRoot = resolveGitRoot(workingDir);
+    const configRoom = getRoomFromConfig(workingDir);
+    const gitRoom = repoRoot ? getGitRemoteIdentity(repoRoot) : null;
+    const storedAuth = getStoredAuth();
+    const pendingAuth = getPendingDeviceAuth();
+    const savedCurrentRoom = getStoredCurrentRoom();
+    const detectedRoom = configRoom || gitRoom;
+    let nextStep = "join_room";
+    if (!storedAuth && pendingAuth) {
+        nextStep = "poll_device_auth";
+    }
+    else if (savedCurrentRoom && !currentRoom) {
+        nextStep = "resume_room_session";
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    api_url: API_URL,
+                    local_state_path: getLocalStatePath(),
+                    authenticated: Boolean(process.env.LETAGENTS_TOKEN || storedAuth),
+                    auth_source: process.env.LETAGENTS_TOKEN
+                        ? "env"
+                        : storedAuth
+                            ? "local_state"
+                            : "none",
+                    account: storedAuth?.account ?? null,
+                    token_expires_at: storedAuth?.expires_at ?? null,
+                    pending_device_auth: pendingAuth,
+                    current_room: toPublicRoomState(currentRoom),
+                    saved_current_room: toPublicStoredRoomSession(savedCurrentRoom),
+                    detected_room_from_context: detectedRoom,
+                    repo_root: repoRoot,
+                    next_step: nextStep,
+                }, null, 2),
+            },
+        ],
+    };
+});
+server.tool("start_device_auth", "Start GitHub Device Flow for Let Agents Chat and persist the pending request locally. Use this when private repo access or explicit LetAgents auth is needed.", {
+    room_id: z
+        .string()
+        .optional()
+        .describe("Optional room to associate with this auth request for later auto-join."),
+    force: z
+        .boolean()
+        .optional()
+        .describe("If true, replaces any existing pending device auth request."),
+}, async ({ room_id, force }) => {
+    const existing = getPendingDeviceAuth();
+    if (existing && !force) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        reused_existing_request: true,
+                        ...existing,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    const response = await apiCall("/auth/device/start", {
+        method: "POST",
+    });
+    const pendingAuth = setPendingDeviceAuth({
+        request_id: response.request_id,
+        user_code: response.user_code,
+        verification_uri: response.verification_uri,
+        interval_seconds: response.interval,
+        expires_at: new Date(Date.now() + response.expires_in * 1000).toISOString(),
+        started_at: new Date().toISOString(),
+        suggested_room_id: room_id ?? currentRoom?.room_id ?? getRoomFromConfig() ?? undefined,
+    });
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    success: true,
+                    ...pendingAuth,
+                }, null, 2),
+            },
+        ],
+    };
+});
+server.tool("poll_device_auth", "Poll a pending GitHub Device Flow request. On success this stores the LetAgents token locally and can optionally join a room immediately.", {
+    request_id: z
+        .string()
+        .optional()
+        .describe("The device auth request to poll. Defaults to the locally saved pending request."),
+    room_id: z
+        .string()
+        .optional()
+        .describe("Optional room to auto-join after authorization succeeds."),
+    auto_join: z
+        .boolean()
+        .optional()
+        .describe("If true, tries to join the room immediately after the auth succeeds."),
+}, async ({ request_id, room_id, auto_join }) => {
+    const pendingAuth = request_id
+        ? getPendingDeviceAuth()?.request_id === request_id
+            ? getPendingDeviceAuth()
+            : null
+        : getPendingDeviceAuth();
+    if (!pendingAuth && !request_id) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ success: false, error: "No pending device auth request found." }, null, 2),
+                },
+            ],
+        };
+    }
+    const requestId = request_id || pendingAuth?.request_id;
+    if (!requestId) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ success: false, error: "A request_id is required when nothing is saved locally." }, null, 2),
+                },
+            ],
+        };
+    }
+    const result = await apiCall(`/auth/device/poll/${encodeURIComponent(requestId)}`);
+    if (result.status === "pending" || result.status === "slow_down") {
+        if (pendingAuth) {
+            setPendingDeviceAuth({
+                ...pendingAuth,
+                interval_seconds: result.interval ?? pendingAuth.interval_seconds,
+                expires_at: result.expires_in !== undefined
+                    ? new Date(Date.now() + result.expires_in * 1000).toISOString()
+                    : pendingAuth.expires_at,
+            });
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ success: true, ...result }, null, 2),
+                },
+            ],
+        };
+    }
+    if (result.status === "denied" || result.status === "expired") {
+        clearPendingDeviceAuth();
+        clearStoredAuth();
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ success: false, ...result }, null, 2),
+                },
+            ],
+        };
+    }
+    if (!result.letagents_token) {
+        throw new Error("Device auth completed without a LetAgents token.");
+    }
+    clearPendingDeviceAuth();
+    const storedAuth = setStoredAuth({
+        token: result.letagents_token,
+        expires_at: result.expires_at,
+        account: result.account,
+        stored_at: new Date().toISOString(),
+        source: "device_flow",
+    });
+    let joinedRoom = null;
+    const roomToJoin = room_id ||
+        pendingAuth?.suggested_room_id ||
+        currentRoom?.room_id ||
+        getRoomFromConfig() ||
+        undefined;
+    if (auto_join && roomToJoin) {
+        const joinedVia = looksLikeInviteCode(roomToJoin) ? "join_code" : "join_room";
+        const joined = await joinRoomIdentifier(roomToJoin, joinedVia);
+        joinedRoom = joined.room;
+        await autoRegisterAgentIdentity();
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    success: true,
+                    status: "authorized",
+                    account: storedAuth.account ?? null,
+                    expires_at: storedAuth.expires_at ?? null,
+                    auto_joined_room: joinedRoom,
+                }, null, 2),
+            },
+        ],
+    };
+});
+server.tool("clear_saved_auth", "Clear any locally saved LetAgents auth token and pending device auth request.", {}, async () => {
+    clearPendingDeviceAuth();
+    clearStoredAuth();
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    success: true,
+                    env_token_still_present: Boolean(process.env.LETAGENTS_TOKEN),
+                }, null, 2),
+            },
+        ],
+    };
+});
+server.tool("resume_room_session", "Rejoin the last locally saved room context, or a specific saved room, after a restart. This recreates participation in the room; it does not preserve a prior server-side session ID.", {
+    room_id: z
+        .string()
+        .optional()
+        .describe("Optional saved room ID to resume. Defaults to the last current room."),
+}, async ({ room_id }) => {
+    const savedRoom = (room_id ? getStoredRoomSession(room_id) : null) ??
+        getStoredCurrentRoom();
+    if (!savedRoom) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ success: false, error: "No saved room session found." }, null, 2),
+                },
+            ],
+        };
+    }
+    const joined = await joinRoomIdentifier(savedRoom.room_id, savedRoom.joined_via);
+    await autoRegisterAgentIdentity();
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    success: true,
+                    rejoined_from_local_state: true,
+                    server_session_resumed: false,
+                    last_message_id_before_restart: savedRoom.last_message_id ?? null,
+                    room: joined.room,
+                }, null, 2),
+            },
+        ],
+    };
+});
+// -- check_repo_visibility --------------------------------------------------
+server.tool("check_repo_visibility", "Auto-detect the current repo's git remote and check if it's public or private. Returns the canonical key, provider, visibility, and suggested room type (discoverable for public, invite for private/unknown). Useful for deciding whether to auto-join a discoverable room or create an invite room.", {
+    cwd: z
+        .string()
+        .optional()
+        .describe("Working directory to detect git remote from. Defaults to the MCP server's working directory."),
+}, async ({ cwd }) => {
+    const { autoDetectRepo } = await import("./repo-visibility.js");
+    const result = await autoDetectRepo(cwd);
+    if (!result) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: "Not in a git repository or no remote configured",
+                        suggestion: "Use create_room to create an invite room instead",
+                    }, null, 2),
+                },
+            ],
+        };
+    }
     return {
         content: [
             {
@@ -638,23 +1271,26 @@ async function main() {
         // 1. Try .letagents.json config
         const configRoom = getRoomFromConfig();
         if (configRoom) {
-            const project = await apiCall(`/projects/room/${encodeURIComponent(configRoom)}`, { method: "POST" });
-            currentRoom = { room: configRoom, project_id: project.id, code: project.code, joined_via: "config" };
-            sseClient.subscribe(project.id, (_message) => { server.server.sendResourceListChanged(); });
+            await joinRoomIdentifier(configRoom, "config");
             console.error(`🏠 Auto-joined room '${configRoom}' (from .letagents.json)`);
             return;
         }
         // 2. Try git remote URL
         const gitRoom = getGitRemoteIdentity();
         if (gitRoom) {
-            const project = await apiCall(`/projects/room/${encodeURIComponent(gitRoom)}`, { method: "POST" });
-            currentRoom = { room: gitRoom, project_id: project.id, code: project.code, joined_via: "git-remote" };
-            sseClient.subscribe(project.id, (_message) => { server.server.sendResourceListChanged(); });
+            await joinRoomIdentifier(gitRoom, "git-remote");
             console.error(`🏠 Auto-joined room '${gitRoom}' (inferred from git remote — consider adding a .letagents.json)`);
             return;
         }
-        // 3. No context found
-        console.error("ℹ️ No .letagents.json or git remote found — use join_project or join_room to connect.");
+        // 3. Fall back to the most recent saved room session
+        const savedCurrentRoom = getStoredCurrentRoom();
+        if (savedCurrentRoom) {
+            await joinRoomIdentifier(savedCurrentRoom.room_id, savedCurrentRoom.joined_via);
+            console.error(`🏠 Rejoined saved room '${savedCurrentRoom.room_id}' (from local state)`);
+            return;
+        }
+        // 4. No context found
+        console.error("ℹ️ No .letagents.json, git remote, or saved room found — use create_room, join_code, or join_room to connect.");
     }
     catch (err) {
         // Auto-join failure should never block the MCP server