letagents 0.12.9 → 0.12.10

package/dist/mcp/server/tools/rooms/repo-initialization-tool.js

@@ -0,0 +1,113 @@
+import { existsSync, writeFileSync } from "fs";
+import { join } from "path";
+import { z } from "zod";
+import { getGitRemoteIdentity } from "../../../git-remote.js";
+import { joinRoomIdentifier, } from "../../runtime.js";
+import { findExistingConfig, resolveGitRoot, } from "../../repo-context.js";
+import { jsonToolResponse } from "./response.js";
+export function registerRepoInitializationTool(server) {
+    server.tool("initialize_repo", "Initialize the current repo for Let Agents Chat by creating a .letagents.json config file. " +
+        "This explicitly sets up repo-based room auto-join. Reads git remote to derive the room name, " +
+        "or accepts a custom room name. Will NOT overwrite an existing .letagents.json. " +
+        "Always writes to the repo root, not the current working directory.", {
+        room: z
+            .string()
+            .optional()
+            .describe("Custom room name. If omitted, auto-derived from git remote (e.g. 'github.com/owner/repo')"),
+        cwd: z
+            .string()
+            .optional()
+            .describe("Working directory hint for repo detection. Defaults to the current process directory."),
+    }, async ({ room, cwd: targetDir }) => {
+        const startDir = targetDir || process.cwd();
+        const repoRoot = resolveGitRoot(startDir);
+        if (!repoRoot) {
+            return jsonToolResponse({
+                success: false,
+                error: "Not inside a git repository",
+                hint: "Run this tool from inside a git repo, or pass a 'cwd' pointing to one.",
+            });
+        }
+        const existingConfigResponse = getExistingConfigResponse(startDir, repoRoot);
+        if (existingConfigResponse)
+            return jsonToolResponse(existingConfigResponse);
+        const roomNameResult = resolveRoomName(room, repoRoot);
+        if (!roomNameResult.success)
+            return jsonToolResponse(roomNameResult);
+        const configPath = join(repoRoot, ".letagents.json");
+        try {
+            writeFileSync(configPath, JSON.stringify({ room: roomNameResult.roomName }, null, 2) + "\n", "utf-8");
+        }
+        catch (err) {
+            return jsonToolResponse({
+                success: false,
+                error: `Failed to write config: ${err instanceof Error ? err.message : err}`,
+                path: configPath,
+            });
+        }
+        return jsonToolResponse(await joinInitializedRoom({
+            configPath,
+            roomName: roomNameResult.roomName,
+        }));
+    });
+}
+function getExistingConfigResponse(startDir, repoRoot) {
+    const existingConfigDir = findExistingConfig(startDir);
+    if (existingConfigDir) {
+        const existingPath = join(existingConfigDir, ".letagents.json");
+        return {
+            success: false,
+            error: ".letagents.json already exists",
+            path: existingPath,
+            hint: existingConfigDir === repoRoot
+                ? "Delete the existing file first if you want to reinitialize."
+                : `Found a config in a parent directory (${existingConfigDir}). Delete it or move it to ${repoRoot} to reinitialize.`,
+        };
+    }
+    const configPath = join(repoRoot, ".letagents.json");
+    if (existsSync(configPath)) {
+        return {
+            success: false,
+            error: ".letagents.json already exists",
+            path: configPath,
+            hint: "Delete the existing file first if you want to reinitialize.",
+        };
+    }
+    return null;
+}
+function resolveRoomName(room, repoRoot) {
+    if (room)
+        return { success: true, roomName: room };
+    const gitRoom = getGitRemoteIdentity(repoRoot);
+    if (!gitRoom) {
+        return {
+            success: false,
+            error: "Cannot derive room name: no git remote found and no custom room name provided",
+            hint: "Pass a 'room' parameter or run from inside a git repo with a remote configured.",
+        };
+    }
+    return { success: true, roomName: gitRoom };
+}
+async function joinInitializedRoom(input) {
+    try {
+        const joined = await joinRoomIdentifier(input.roomName, "config");
+        return {
+            success: true,
+            created: input.configPath,
+            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.",
+        };
+    }
+    catch (err) {
+        return {
+            success: true,
+            created: input.configPath,
+            room_id: input.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.",
+        };
+    }
+}

package/dist/mcp/server/tools/rooms/repo-visibility-tool.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { autoDetectRepo } from "../../../repo-visibility.js";
+import { jsonToolResponse } from "./response.js";
+export function registerRepoVisibilityTool(server) {
+    server.tool("check_repo_visibility", "Auto-detect the current repo's git remote and check whether its Git Room should be public/discoverable or private/auth-gated. Returns the canonical key, provider, visibility, accessMode, and legacy roomType hint.", {
+        cwd: z
+            .string()
+            .optional()
+            .describe("Working directory to detect git remote from. Defaults to the MCP server's working directory."),
+    }, async ({ cwd }) => {
+        const result = await autoDetectRepo(cwd);
+        if (!result) {
+            return jsonToolResponse({
+                error: "Not in a git repository or no remote configured",
+                suggestion: "Pass cwd inside a git repo for Git Room detection, or join/create an ad-hoc room manually.",
+            });
+        }
+        return jsonToolResponse(result);
+    });
+}

package/dist/mcp/server/tools/rooms/response.js

@@ -0,0 +1,10 @@
+export function jsonToolResponse(value) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(value, null, 2),
+            },
+        ],
+    };
+}

package/dist/mcp/server/tools/rooms/resume-tool.js

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import { ApiError, RepoRoomAuthRequiredError, ensureAgentIdentity, getStoredCurrentRoom, getStoredRoomSession, parseApiErrorPayload, joinRoomIdentifierWithoutImplicitGitRefCreate, toPublicAgentIdentity, toPublicRoomState, toRepoRoomAuthRequiredResult, withJoinRoomAgentPrompt, } from "../../runtime.js";
+import { jsonToolResponse } from "./response.js";
+export function registerRoomResumeTool(server) {
+    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 jsonToolResponse({ success: false, error: "No saved room session found." });
+        }
+        try {
+            const joined = await joinRoomIdentifierWithoutImplicitGitRefCreate(savedRoom.room_id, savedRoom.joined_via);
+            const agentIdentity = await ensureAgentIdentity();
+            return jsonToolResponse(withJoinRoomAgentPrompt({
+                success: true,
+                rejoined_from_local_state: true,
+                server_session_resumed: false,
+                last_message_id_before_restart: savedRoom.last_message_id ?? null,
+                room: toPublicRoomState(joined.room),
+                agent_identity: toPublicAgentIdentity(agentIdentity),
+            }));
+        }
+        catch (error) {
+            if (error instanceof RepoRoomAuthRequiredError) {
+                return jsonToolResponse(toRepoRoomAuthRequiredResult(error));
+            }
+            const payload = parseApiErrorPayload(error);
+            if (error instanceof ApiError &&
+                error.status === 404 &&
+                payload?.code === "ROOM_NOT_FOUND") {
+                return jsonToolResponse({
+                    success: false,
+                    error: "Saved room no longer exists. Join the repository room or ask a human to create the branch room again.",
+                    code: "ROOM_NOT_FOUND",
+                    room_id: savedRoom.room_id,
+                    rejoined_from_local_state: false,
+                    server_session_resumed: false,
+                });
+            }
+            throw error;
+        }
+    });
+}

package/dist/mcp/server/tools/rooms.js

@@ -0,0 +1 @@
+export { registerRepoInitializationTool, registerRepoVisibilityTool, registerRoomInspectionTools, registerRoomJoinTools, registerRoomResumeTool, } from "./rooms/index.js";

package/dist/mcp/server/tools/tasks/api.js

@@ -0,0 +1,222 @@
+import { encodeRoomIdPath } from "../../../room-id.js";
+import { addLocalTask, apiCall, claimLocalTaskReviewLease, getLocalTask, isLocalRoomStorageEnabled, listLocalTasks, releaseLocalTaskReviewLease, resolveLocalRoomStorageIdentifiers, roomScopedApiCall, updateLocalTask, } from "../../runtime.js";
+export function taskCollectionRoomPath(roomId) {
+    return `/rooms/${encodeRoomIdPath(roomId)}/tasks`;
+}
+export function taskDetailRoomPath(roomId, taskId) {
+    return `${taskCollectionRoomPath(roomId)}/${encodeURIComponent(taskId)}`;
+}
+export function boardSettingsRoomPath(roomId) {
+    return `/rooms/${encodeRoomIdPath(roomId)}/board-settings`;
+}
+export function boardManagersRoomPath(roomId) {
+    return `/rooms/${encodeRoomIdPath(roomId)}/board-managers`;
+}
+export function activeBoardManagerRoomPath(roomId) {
+    return `${boardManagersRoomPath(roomId)}/active`;
+}
+export function boardIntentsRoomPath(roomId) {
+    return `/rooms/${encodeRoomIdPath(roomId)}/board-intents`;
+}
+export function boardIntentDecisionRoomPath(roomId, intentId, decision) {
+    return `${boardIntentsRoomPath(roomId)}/${encodeURIComponent(intentId)}/${decision}`;
+}
+export function taskCollectionProjectPath(projectId) {
+    return `/projects/${encodeURIComponent(projectId)}/tasks`;
+}
+export function taskDetailProjectPath(projectId, taskId) {
+    return `${taskCollectionProjectPath(projectId)}/${encodeURIComponent(taskId)}`;
+}
+function localRoomIdForTarget(target) {
+    return target.effectiveRoomId ?? target.roomId ?? target.projectId ?? null;
+}
+export async function createTask(target, body) {
+    const localRoomId = localRoomIdForTarget(target);
+    if (localRoomId && await isLocalRoomStorageEnabled(localRoomId)) {
+        const { localRoomId: sqliteRoomId } = await resolveLocalRoomStorageIdentifiers(localRoomId);
+        return addLocalTask(sqliteRoomId || localRoomId, {
+            title: String(body.title || ""),
+            description: typeof body.description === "string" ? body.description : null,
+            created_by: typeof body.created_by === "string" ? body.created_by : null,
+        });
+    }
+    return roomScopedApiCall({
+        room_id: target.roomId,
+        project_id: target.projectId,
+        room_path: taskCollectionRoomPath,
+        project_path: taskCollectionProjectPath,
+        options: {
+            method: "POST",
+            body: JSON.stringify(body),
+        },
+    });
+}
+export async function listTasks(target, queryString) {
+    const localRoomId = localRoomIdForTarget(target);
+    if (localRoomId && await isLocalRoomStorageEnabled(localRoomId)) {
+        const { localRoomId: sqliteRoomId } = await resolveLocalRoomStorageIdentifiers(localRoomId);
+        const params = new URLSearchParams(queryString);
+        return listLocalTasks(sqliteRoomId || localRoomId, {
+            status: params.get("status"),
+            openOnly: params.get("open") !== "false",
+        });
+    }
+    return roomScopedApiCall({
+        room_id: target.roomId,
+        project_id: target.projectId,
+        room_path: (roomId) => `${taskCollectionRoomPath(roomId)}${queryString ? `?${queryString}` : ""}`,
+        project_path: (projectId) => `${taskCollectionProjectPath(projectId)}${queryString ? `?${queryString}` : ""}`,
+    });
+}
+export async function getCanonicalTask(roomId, taskId) {
+    return apiCall(taskDetailRoomPath(roomId, taskId));
+}
+export async function patchTask(target, taskId, body) {
+    const localRoomId = localRoomIdForTarget(target);
+    if (localRoomId && await isLocalRoomStorageEnabled(localRoomId)) {
+        const { localRoomId: sqliteRoomId } = await resolveLocalRoomStorageIdentifiers(localRoomId);
+        return updateLocalTask(sqliteRoomId || localRoomId, taskId, body);
+    }
+    return roomScopedApiCall({
+        room_id: target.roomId,
+        project_id: target.projectId,
+        room_path: (roomId) => taskDetailRoomPath(roomId, taskId),
+        project_path: (projectId) => taskDetailProjectPath(projectId, taskId),
+        options: {
+            method: "PATCH",
+            body: JSON.stringify(body),
+        },
+    });
+}
+export async function postCanonicalTaskAction(roomId, taskId, actionPath, body) {
+    if (await isLocalRoomStorageEnabled(roomId)) {
+        const { localRoomId } = await resolveLocalRoomStorageIdentifiers(roomId);
+        const sqliteRoomId = localRoomId || roomId;
+        const action = typeof body.action === "string" ? body.action : "noop";
+        const existingTask = await getLocalTask(sqliteRoomId, taskId);
+        if (!existingTask) {
+            throw new Error("Task not found.");
+        }
+        if (actionPath === "review-lease-action") {
+            if (action === "claim") {
+                const result = await claimLocalTaskReviewLease(sqliteRoomId, taskId, {
+                    holder_label: typeof body.actor_label === "string" ? body.actor_label : null,
+                    agent_key: typeof body.actor_key === "string" ? body.actor_key : null,
+                    agent_session_id: typeof body.agent_session_id === "string"
+                        ? body.agent_session_id
+                        : null,
+                });
+                return {
+                    action,
+                    task: result.task,
+                    lease: result.lease,
+                };
+            }
+            if (action === "release") {
+                const result = await releaseLocalTaskReviewLease(sqliteRoomId, taskId, {
+                    lease_id: typeof body.lease_id === "string" ? body.lease_id : null,
+                });
+                return {
+                    action,
+                    task: result.task,
+                    released_lease: result.released_lease,
+                };
+            }
+            return {
+                action,
+                task: existingTask,
+                lease: null,
+                released_lease: null,
+            };
+        }
+        if (action === "handoff") {
+            const targetActorKey = typeof body.target_actor_key === "string" && body.target_actor_key.trim()
+                ? body.target_actor_key.trim()
+                : null;
+            const targetAgentSessionId = typeof body.target_agent_session_id === "string" && body.target_agent_session_id.trim()
+                ? body.target_agent_session_id.trim()
+                : null;
+            const targetActorInstanceId = typeof body.target_actor_instance_id === "string" && body.target_actor_instance_id.trim()
+                ? body.target_actor_instance_id.trim()
+                : null;
+            const task = targetActorKey
+                ? await updateLocalTask(sqliteRoomId, taskId, {
+                    ...(existingTask.status === "accepted" ? { status: "assigned" } : {}),
+                    assignee: targetActorKey,
+                    assignee_agent_key: targetActorKey,
+                    assignee_agent_instance_id: targetActorInstanceId,
+                    assignee_agent_session_id: targetAgentSessionId,
+                })
+                : existingTask;
+            return {
+                action,
+                task,
+                released_lease: null,
+                new_lease: null,
+            };
+        }
+        if (action === "release") {
+            const releasableStatuses = new Set(["assigned", "in_progress", "blocked", "in_review"]);
+            const patch = {
+                assignee: null,
+                assignee_agent_key: null,
+            };
+            if (releasableStatuses.has(existingTask.status)) {
+                patch.status = "accepted";
+                patch.skip_transition_validation = true;
+            }
+            const task = await updateLocalTask(sqliteRoomId, taskId, patch);
+            return {
+                action,
+                task,
+                released_lease: null,
+            };
+        }
+        return {
+            action,
+            task: existingTask,
+            released_lease: null,
+        };
+    }
+    const { cloudRoomId } = await resolveLocalRoomStorageIdentifiers(roomId);
+    return apiCall(`${taskDetailRoomPath(cloudRoomId || roomId, taskId)}/${actionPath}`, {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+}
+export async function getBoardSettings(roomId) {
+    return apiCall(boardSettingsRoomPath(roomId));
+}
+export async function patchBoardSettings(roomId, body) {
+    return apiCall(boardSettingsRoomPath(roomId), {
+        method: "PATCH",
+        body: JSON.stringify(body),
+    });
+}
+export async function postBoardManager(roomId, body) {
+    return apiCall(boardManagersRoomPath(roomId), {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+}
+export async function deleteActiveBoardManager(roomId, body) {
+    return apiCall(activeBoardManagerRoomPath(roomId), {
+        method: "DELETE",
+        body: JSON.stringify(body),
+    });
+}
+export async function getBoardIntents(roomId, queryString) {
+    return apiCall(`${boardIntentsRoomPath(roomId)}${queryString ? `?${queryString}` : ""}`);
+}
+export async function postBoardIntent(roomId, body) {
+    return apiCall(boardIntentsRoomPath(roomId), {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+}
+export async function postBoardIntentDecision(roomId, intentId, decision, body) {
+    return apiCall(boardIntentDecisionRoomPath(roomId, intentId, decision), {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+}

package/dist/mcp/server/tools/tasks/artifact-tools.js

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { encodeRoomIdPath } from "../../../room-id.js";
+import { roomScopedApiCall } from "../../runtime.js";
+import { resolveTaskToolTarget } from "./context.js";
+import { jsonToolResponse, taskToolError } from "./response.js";
+import { workflowArtifactSchema } from "./schemas.js";
+function buildRoomArtifactsQueryString(input) {
+    const params = new URLSearchParams();
+    if (input.task_id)
+        params.set("task_id", input.task_id);
+    if (input.limit)
+        params.set("limit", String(input.limit));
+    return params.toString();
+}
+export function registerTaskArtifactTools(server) {
+    server.tool("get_room_artifacts", "Get shared workflow artifacts for the room. Returns provider-neutral artifacts such as PRs, branches, issues, checks, and their linked task IDs.", {
+        task_id: z.string().optional().describe("Optional task ID to filter artifacts linked to that task."),
+        limit: z.number().int().min(1).max(250).optional().describe("Max artifacts to return (default 100, max 250)."),
+        room_id: z.string().optional().describe("Canonical room ID. Defaults to current room."),
+    }, async ({ task_id, limit, room_id }) => {
+        const target = resolveTaskToolTarget(room_id);
+        if (!target)
+            return taskToolError("Not in a room. Join one first.");
+        const qs = buildRoomArtifactsQueryString({ task_id, limit });
+        const result = await roomScopedApiCall({
+            room_id: target.roomId,
+            project_id: target.projectId,
+            room_path: (roomId) => `/rooms/${encodeRoomIdPath(roomId)}/artifacts${qs ? `?${qs}` : ""}`,
+            project_path: (projectId) => `/rooms/${encodeURIComponent(projectId)}/artifacts${qs ? `?${qs}` : ""}`,
+        });
+        return jsonToolResponse({
+            success: true,
+            room_id: result.room_id ?? target.projectId,
+            artifacts: result.artifacts ?? [],
+        }, 2);
+    });
+    server.tool("publish_room_artifact", "Publish a provider-neutral Git workflow artifact into the shared room artifact list. Use this for branches, PRs, issues, reviews, checks, or merges that should be visible to the room even if they were not created through a task update or GitHub webhook.", {
+        artifact: workflowArtifactSchema.describe("Artifact to publish. It must include provider, kind, and at least one stable identity: url, id, number, or ref."),
+        task_id: z.string().optional().describe("Optional task ID to link to this artifact."),
+        linked_task_ids: z
+            .array(z.string())
+            .max(32)
+            .optional()
+            .describe("Optional task IDs to link to this artifact."),
+        room_id: z.string().optional().describe("Canonical room ID. Defaults to current room."),
+    }, async ({ artifact, task_id, linked_task_ids, room_id }) => {
+        const target = resolveTaskToolTarget(room_id);
+        if (!target)
+            return taskToolError("Not in a room. Join one first.");
+        try {
+            const result = await roomScopedApiCall({
+                room_id: target.roomId,
+                project_id: target.projectId,
+                room_path: (roomId) => `/rooms/${encodeRoomIdPath(roomId)}/artifacts`,
+                project_path: (projectId) => `/rooms/${encodeURIComponent(projectId)}/artifacts`,
+                options: {
+                    method: "POST",
+                    body: JSON.stringify({
+                        artifact,
+                        task_id,
+                        linked_task_ids,
+                    }),
+                },
+            });
+            return jsonToolResponse({
+                success: true,
+                room_id: result.room_id ?? target.projectId,
+                artifact: result.artifact ?? null,
+            }, 2);
+        }
+        catch (error) {
+            return taskToolError(String(error));
+        }
+    });
+}