letagents 0.12.8 → 0.12.10

package/dist/mcp/rental-tools/metering.js

@@ -0,0 +1,73 @@
+import { encodeSessionId, errorMessage, validateSessionId, } from "./shared.js";
+export async function rentalHeartbeat(deps, input) {
+    const sessionIdError = validateSessionId(input);
+    if (sessionIdError)
+        return { success: false, error: sessionIdError };
+    try {
+        const body = await deps.apiCall(`/api/rental/sessions/${encodeSessionId(input.session_id)}/heartbeat`, { method: "POST" });
+        return {
+            success: true,
+            ok: body?.ok ?? true,
+            status: typeof body?.status === "string" ? body.status : undefined,
+            heartbeat_count: typeof body?.heartbeatCount === "number" ? body.heartbeatCount : undefined,
+            transitioned: body?.transitioned ?? false,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: errorMessage(err),
+        };
+    }
+}
+export async function rentalReportUsage(deps, input) {
+    const sessionIdError = validateSessionId(input);
+    if (sessionIdError)
+        return { success: false, error: sessionIdError };
+    if (typeof input.report !== "object" ||
+        input.report === null ||
+        Array.isArray(input.report)) {
+        return { success: false, error: "report must be a JSON object" };
+    }
+    try {
+        const meter = await deps.apiCall(`/api/rental/sessions/${encodeSessionId(input.session_id)}/usage`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(input.report),
+        });
+        return { success: true, meter };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: errorMessage(err),
+        };
+    }
+}
+export async function rentalRefreshQuota(deps, input) {
+    const sessionIdError = validateSessionId(input);
+    if (sessionIdError)
+        return { success: false, error: sessionIdError };
+    const bodyPayload = {};
+    if (typeof input.provider === "string" && input.provider.trim()) {
+        bodyPayload.provider = input.provider.trim();
+    }
+    try {
+        const body = await deps.apiCall(`/api/rental/sessions/${encodeSessionId(input.session_id)}/refresh-quota`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(bodyPayload),
+        });
+        return {
+            success: true,
+            snapshot: body?.snapshot ?? null,
+            refreshed: body?.refreshed ?? true,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: errorMessage(err),
+        };
+    }
+}

package/dist/mcp/rental-tools/patches.js

@@ -0,0 +1,100 @@
+import { encodeSessionId, errorMessage, isPositiveInteger, validateSessionId, } from "./shared.js";
+export async function rentalProposeEdit(deps, input) {
+    const sessionIdError = validateSessionId(input);
+    if (sessionIdError)
+        return { success: false, error: sessionIdError };
+    if (typeof input.idempotency_key !== "string" || !input.idempotency_key.trim()) {
+        return { success: false, error: "idempotency_key is required" };
+    }
+    if (typeof input.path !== "string" || !input.path.trim()) {
+        return { success: false, error: "path is required" };
+    }
+    if (typeof input.before_content !== "string" || typeof input.after_content !== "string") {
+        return { success: false, error: "before_content and after_content are required" };
+    }
+    const body = {
+        idempotencyKey: input.idempotency_key.trim(),
+        path: input.path.trim(),
+        beforeContent: input.before_content,
+        afterContent: input.after_content,
+    };
+    if (typeof input.summary === "string" && input.summary.trim()) {
+        body.summary = input.summary.trim();
+    }
+    try {
+        return await deps.apiCall(`/api/rental/sessions/${encodeSessionId(input.session_id)}/patches/propose-edit`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+        });
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: errorMessage(err),
+        };
+    }
+}
+export async function rentalProposePatch(deps, input) {
+    const sessionIdError = validateSessionId(input);
+    if (sessionIdError)
+        return { success: false, error: sessionIdError };
+    if (typeof input.idempotency_key !== "string" || !input.idempotency_key.trim()) {
+        return { success: false, error: "idempotency_key is required" };
+    }
+    if (!Array.isArray(input.files) || input.files.length === 0) {
+        return { success: false, error: "files must be a non-empty array" };
+    }
+    const body = {
+        idempotencyKey: input.idempotency_key.trim(),
+        files: input.files,
+    };
+    if (typeof input.summary === "string" && input.summary.trim()) {
+        body.summary = input.summary.trim();
+    }
+    try {
+        return await deps.apiCall(`/api/rental/sessions/${encodeSessionId(input.session_id)}/patches/propose-patch`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+        });
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: errorMessage(err),
+        };
+    }
+}
+export async function rentalRunCommand(deps, input) {
+    const sessionIdError = validateSessionId(input);
+    if (sessionIdError)
+        return { success: false, error: sessionIdError };
+    if (!Array.isArray(input.argv) || input.argv.length === 0) {
+        return { success: false, error: "argv must be a non-empty array" };
+    }
+    if (input.argv.some((part) => typeof part !== "string" || !part.trim())) {
+        return { success: false, error: "argv entries must be non-empty strings" };
+    }
+    if (input.timeout_ms !== undefined && !isPositiveInteger(input.timeout_ms)) {
+        return { success: false, error: "timeout_ms must be a positive integer" };
+    }
+    const body = {
+        argv: input.argv.map((part) => part.trim()),
+    };
+    if (input.timeout_ms !== undefined)
+        body.timeoutMs = input.timeout_ms;
+    try {
+        return await deps.apiCall(`/api/rental/sessions/${encodeSessionId(input.session_id)}/commands/run`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+        });
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: errorMessage(err),
+        };
+    }
+}

package/dist/mcp/rental-tools/provider.js

@@ -0,0 +1,117 @@
+import { encodeSessionId, errorMessage, validateSessionId } from "./shared.js";
+export async function rentalListRequests(deps) {
+    try {
+        const body = await deps.apiCall("/api/rental/provider/requests", { method: "GET" });
+        const requests = Array.isArray(body)
+            ? body
+            : Array.isArray(body?.requests)
+                ? body.requests
+                : [];
+        return { success: true, requests, count: requests.length };
+    }
+    catch (err) {
+        return {
+            success: false,
+            requests: [],
+            count: 0,
+            error: errorMessage(err),
+        };
+    }
+}
+export async function rentalAccept(deps, input) {
+    const sessionIdError = validateSessionId(input);
+    if (sessionIdError)
+        return { success: false, error: sessionIdError };
+    const path = `/api/rental/provider/sessions/${encodeSessionId(input.session_id)}/accept`;
+    const idemKey = input.idempotency_key?.trim() || undefined;
+    const headers = {};
+    const bodyPayload = {};
+    if (idemKey) {
+        headers["Idempotency-Key"] = idemKey;
+        bodyPayload.idempotency_key = idemKey;
+    }
+    try {
+        const session = await deps.apiCall(path, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(bodyPayload),
+        });
+        return {
+            success: true,
+            session,
+            ...(idemKey ? { idempotency_key: idemKey } : {}),
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: errorMessage(err),
+            ...(idemKey ? { idempotency_key: idemKey } : {}),
+        };
+    }
+}
+export async function rentalProvision(deps, input) {
+    const sessionIdError = validateSessionId(input);
+    if (sessionIdError)
+        return { success: false, error: sessionIdError };
+    const parentRoomId = input.parent_room_id?.trim();
+    if (!parentRoomId) {
+        return { success: false, error: "parent_room_id is required" };
+    }
+    const body = { parentRoomId };
+    const displayName = input.provider_display_name?.trim();
+    if (displayName)
+        body.providerDisplayName = displayName;
+    try {
+        const result = await deps.apiCall(`/api/rental/provider/sessions/${encodeSessionId(input.session_id)}/provision`, {
+            method: "POST",
+            body: JSON.stringify(body),
+        });
+        return {
+            success: true,
+            room_id: typeof result?.roomId === "string" ? result.roomId : undefined,
+            participant_id: typeof result?.participantId === "string" ? result.participantId : undefined,
+            session: result?.session,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: errorMessage(err),
+        };
+    }
+}
+export async function rentalDecline(deps, input) {
+    const sessionIdError = validateSessionId(input);
+    if (sessionIdError)
+        return { success: false, error: sessionIdError };
+    const idemKey = input.idempotency_key?.trim() || undefined;
+    const headers = {};
+    const payload = {};
+    if (idemKey) {
+        headers["Idempotency-Key"] = idemKey;
+        payload.idempotency_key = idemKey;
+    }
+    if (typeof input.reason === "string" && input.reason.trim()) {
+        payload.reason = input.reason.trim();
+    }
+    try {
+        const session = await deps.apiCall(`/api/rental/provider/sessions/${encodeSessionId(input.session_id)}/decline`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(payload),
+        });
+        return {
+            success: true,
+            session,
+            ...(idemKey ? { idempotency_key: idemKey } : {}),
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: errorMessage(err),
+            ...(idemKey ? { idempotency_key: idemKey } : {}),
+        };
+    }
+}

package/dist/mcp/rental-tools/shared.js

@@ -0,0 +1,19 @@
+export function validateSessionId(input) {
+    const sessionId = input.session_id;
+    if (typeof sessionId !== "string" || !sessionId.trim()) {
+        return "session_id is required";
+    }
+    return null;
+}
+export function encodeSessionId(sessionId) {
+    return encodeURIComponent(sessionId.trim());
+}
+export function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+export function isPositiveInteger(value) {
+    return (typeof value === "number" &&
+        Number.isFinite(value) &&
+        Number.isInteger(value) &&
+        value > 0);
+}

package/dist/mcp/rental-tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/mcp/rental-tools.js

@@ -0,0 +1,7 @@
+export * from "./rental-tools/activity.js";
+export * from "./rental-tools/budget.js";
+export * from "./rental-tools/context.js";
+export * from "./rental-tools/lifecycle.js";
+export * from "./rental-tools/metering.js";
+export * from "./rental-tools/patches.js";
+export * from "./rental-tools/provider.js";

package/dist/mcp/repo-visibility.js

@@ -6,8 +6,8 @@
 //
 // Used in the MCP auto-join flow:
 //   1. Detect git remote → normalize to canonical form
-//   2. Check visibility → public = discoverable room, private = invite room
-//   3. Auto-join or prompt for invite code
+//   2. Check visibility → public/private Git Room access mode
+//   3. Auto-join the active Git Room derived from repo + branch
 //
 // Rate limits (unauthenticated):
 //   - GitHub:    60 requests/hour
@@ -144,12 +144,13 @@ async function checkBitbucket(owner, repo) {
 export async function checkRepoVisibility(canonicalKey) {
     const provider = detectProvider(canonicalKey);
     const ownerRepo = extractOwnerRepo(canonicalKey);
-    // Unknown provider — default to invite room (safe fallback)
+    // Unknown provider — default to an invite/private-style access hint.
     if (provider === "unknown" || !ownerRepo) {
         return {
             canonicalKey,
             provider,
             visibility: "unknown",
+            accessMode: "unknown",
             roomType: "invite",
             error: provider === "unknown"
                 ? `Unknown git provider for host: ${canonicalKey.split("/")[0]}`
@@ -172,15 +173,16 @@ export async function checkRepoVisibility(canonicalKey) {
         default:
             visibility = "unknown";
     }
-    // Determine room type from visibility
+    // Keep roomType for older callers; accessMode is the Git Room-facing field.
     const roomType = visibility === "public" ? "discoverable" : "invite";
     return {
         canonicalKey,
         provider,
         visibility,
+        accessMode: visibility,
         roomType,
         ...(visibility === "unknown" && {
-            error: "Could not determine visibility — defaulting to invite room",
+            error: "Could not determine visibility — treating Git Room access as private/unknown",
         }),
     };
 }
@@ -189,7 +191,7 @@ export async function checkRepoVisibility(canonicalKey) {
 // ---------------------------------------------------------------------------
 /**
  * Complete auto-detection: read git remote → normalize → check visibility.
- * This is the main entry point for the MCP auto-join flow.
+ * This is the main entry point for visibility checks before Git Room auto-join.
  *
  * @param cwd - Working directory to detect git remote from
  * @returns VisibilityResult or null if not in a git repo

package/dist/mcp/server/register-tools.js

@@ -0,0 +1,19 @@
+import { registerAgentSessionTools } from "./tools/agent-sessions.js";
+import { registerMessageTools, registerStatusTools } from "./tools/messages.js";
+import { registerOnboardingTools } from "./tools/onboarding.js";
+import { registerRentalTools } from "./tools/rental.js";
+import { registerRepoInitializationTool, registerRepoVisibilityTool, registerRoomInspectionTools, registerRoomJoinTools, registerRoomResumeTool, } from "./tools/rooms.js";
+import { registerTaskTools } from "./tools/tasks.js";
+export function registerTools(server) {
+    registerRoomJoinTools(server);
+    registerAgentSessionTools(server);
+    registerRoomInspectionTools(server);
+    registerStatusTools(server);
+    registerTaskTools(server);
+    registerRepoInitializationTool(server);
+    registerMessageTools(server);
+    registerOnboardingTools(server);
+    registerRoomResumeTool(server);
+    registerRentalTools(server);
+    registerRepoVisibilityTool(server);
+}

package/dist/mcp/server/repo-context.js

@@ -0,0 +1,28 @@
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { dirname, join } from "path";
+export 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;
+    }
+}
+export function findExistingConfig(startDir) {
+    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;
+}

package/dist/mcp/server/resources.js

@@ -0,0 +1,77 @@
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { appendIncludePromptOnly, currentRoom, getLocalChatMessages, getStoredCurrentRoom, getStoredRoomSession, getTargetRoomId, isLocalRoomStorageEnabled, resolveLocalRoomStorageIdentifiers, roomScopedApiCall, toAgentReadableMessages, } from "./runtime.js";
+import { encodeRoomIdPath } from "../room-id.js";
+export function registerRoomResources(server) {
+    // ---------------------------------------------------------------------------
+    // MCP Resources
+    // ---------------------------------------------------------------------------
+    server.resource("room_messages", new ResourceTemplate("letagents://rooms/{room_id}/messages", {
+        list: undefined,
+    }), async (uri, { room_id }) => {
+        const normalizedRoomId = String(room_id);
+        const targetRoomId = getTargetRoomId(normalizedRoomId) ?? normalizedRoomId;
+        if (targetRoomId && await isLocalRoomStorageEnabled(targetRoomId)) {
+            const { localRoomId } = await resolveLocalRoomStorageIdentifiers(targetRoomId);
+            const effectiveLocalRoomId = localRoomId || targetRoomId;
+            const allMessages = [];
+            let afterCursor;
+            for (;;) {
+                const result = await getLocalChatMessages(effectiveLocalRoomId, {
+                    after: afterCursor,
+                    include_prompt_only: true,
+                });
+                const msgs = result.messages ?? [];
+                allMessages.push(...msgs);
+                if (!result.has_more || msgs.length === 0)
+                    break;
+                const lastMsg = msgs[msgs.length - 1];
+                if (!lastMsg?.id)
+                    break;
+                afterCursor = lastMsg.id;
+            }
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        mimeType: "application/json",
+                        text: JSON.stringify({ messages: toAgentReadableMessages(allMessages) }, null, 2),
+                    },
+                ],
+            };
+        }
+        const storedSession = getStoredRoomSession(normalizedRoomId) ??
+            (currentRoom?.room_id === normalizedRoomId ? getStoredCurrentRoom() : null);
+        // Paginate through all pages to return full message history
+        const allMessages = [];
+        let afterCursor;
+        for (;;) {
+            const query = new URLSearchParams();
+            if (afterCursor)
+                query.set("after", afterCursor);
+            const qs = query.toString();
+            const result = await roomScopedApiCall({
+                room_id: normalizedRoomId,
+                project_id: storedSession?.project_id ?? null,
+                room_path: (targetRoomId) => appendIncludePromptOnly(`/rooms/${encodeRoomIdPath(targetRoomId)}/messages${qs ? `?${qs}` : ""}`),
+                project_path: (projectId) => appendIncludePromptOnly(`/projects/${encodeURIComponent(projectId)}/messages${qs ? `?${qs}` : ""}`),
+            });
+            const msgs = result.messages ?? [];
+            allMessages.push(...msgs);
+            if (!result.has_more || msgs.length === 0)
+                break;
+            const lastMsg = msgs[msgs.length - 1];
+            if (!lastMsg?.id)
+                break;
+            afterCursor = lastMsg.id;
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify({ messages: toAgentReadableMessages(allMessages) }, null, 2),
+                },
+            ],
+        };
+    });
+}

package/dist/mcp/server/runtime/agent-sessions.js

@@ -0,0 +1,134 @@
+import { getStoredAgentSession, isLocalRoomStorageEnabled, saveAgentSession, } from "../../local-state.js";
+import { getGitCurrentBranch } from "../../git-remote.js";
+import { randomUUID } from "node:crypto";
+import { normalizeAgentBaseName } from "../../../shared/codenames.js";
+import { formatOwnerAttribution } from "../../../shared/agent-identity.js";
+import { LETAGENTS_AGENT_SESSION_ID_HEADER, LETAGENTS_AGENT_SESSION_TOKEN_HEADER, } from "../../../shared/request-headers.js";
+import { AGENT_INSTANCE_UUID, detectAgentIdeLabel, detectAgentRuntimeLabel, ensureAgentIdentity, } from "./identity.js";
+export function buildAgentDeliveryHeaders(agentSession) {
+    if (!agentSession) {
+        return {};
+    }
+    return {
+        [LETAGENTS_AGENT_SESSION_ID_HEADER]: agentSession.session_id,
+        [LETAGENTS_AGENT_SESSION_TOKEN_HEADER]: agentSession.session_token,
+    };
+}
+export function toPublicAgentSession(session) {
+    if (!session) {
+        return null;
+    }
+    return {
+        session_id: session.session_id,
+        room_id: session.room_id,
+        session_kind: session.session_kind,
+        runtime: session.runtime,
+        host_id: session.host_id ?? null,
+        host_kind: session.host_kind ?? null,
+        host_label: session.host_label ?? null,
+        liveness_capability: session.liveness_capability ?? null,
+        tool_bridge_id: session.tool_bridge_id ?? null,
+        actor_label: session.actor_label,
+        agent_key: session.agent_key,
+        agent_instance_id: session.agent_instance_id ?? null,
+        display_name: session.display_name,
+        owner_label: session.owner_label,
+        ide_label: session.ide_label,
+        repo_branch: session.repo_branch ?? null,
+        created_at: session.created_at,
+        updated_at: session.updated_at,
+        last_seen_at: session.last_seen_at,
+        ended_at: session.ended_at ?? null,
+    };
+}
+export function resolveAgentSession(roomId, sessionId) {
+    if (!sessionId) {
+        return null;
+    }
+    const session = getStoredAgentSession(sessionId);
+    if (!session) {
+        throw new Error(`Unknown agent_session_id: ${sessionId}`);
+    }
+    if (session.ended_at) {
+        throw new Error(`agent_session_id ${sessionId} ended at ${session.ended_at}`);
+    }
+    if (roomId && session.room_id !== roomId) {
+        throw new Error(`agent_session_id ${sessionId} is registered for ${session.room_id}, not ${roomId}`);
+    }
+    return session;
+}
+export function identityFromAgentSession(session) {
+    return {
+        name: normalizeAgentBaseName(session.display_name),
+        display_name: session.display_name,
+        owner_label: session.owner_label,
+        owner_attribution: formatOwnerAttribution(session.owner_label),
+        ide_label: session.ide_label,
+        actor_label: session.actor_label,
+        canonical_key: session.agent_key,
+        runtime_key: `agent_session:${session.session_id}`,
+        source: "api",
+        resolved_at: session.updated_at,
+    };
+}
+export function requireWorkerAgentSession(roomId, sessionId) {
+    const session = resolveAgentSession(roomId, sessionId);
+    if (!session) {
+        throw new Error("Registered worker agent_session_id is required for this write action. " +
+            "Call register_agent_session for this room first, then pass the returned agent_session_id explicitly.");
+    }
+    if (session.session_kind !== "worker") {
+        throw new Error("Worker agent_session_id is required for this write action.");
+    }
+    return session;
+}
+export async function resolveWorkerToolIdentity(input) {
+    const agentSession = input.agentSessionId
+        ? requireWorkerAgentSession(input.roomId, input.agentSessionId)
+        : input.roomId && await isLocalRoomStorageEnabled(input.roomId)
+            ? await ensureLocalWorkerAgentSession(input.roomId)
+            : requireWorkerAgentSession(input.roomId, input.agentSessionId);
+    return {
+        identity: identityFromAgentSession(agentSession),
+        agentSession,
+    };
+}
+export async function ensureLocalWorkerAgentSession(roomId, input = {}) {
+    const identity = await ensureAgentIdentity();
+    const now = new Date().toISOString();
+    const runtime = input.runtime?.trim() || detectAgentRuntimeLabel();
+    const displayName = input.displayName?.trim() || identity.display_name;
+    return saveAgentSession({
+        session_id: `local_${randomUUID()}`,
+        session_token: `local_${randomUUID()}`,
+        room_id: roomId,
+        session_kind: input.sessionKind ?? "worker",
+        runtime,
+        host_id: null,
+        host_kind: "local",
+        host_label: "Local device",
+        liveness_capability: null,
+        tool_bridge_id: null,
+        actor_label: identity.actor_label,
+        agent_key: identity.canonical_key || identity.runtime_key || identity.actor_label,
+        agent_instance_id: AGENT_INSTANCE_UUID,
+        display_name: displayName,
+        owner_label: identity.owner_label,
+        ide_label: identity.ide_label ?? detectAgentIdeLabel(),
+        repo_branch: input.repoBranch ?? null,
+        created_at: now,
+        updated_at: now,
+        last_seen_at: now,
+        ended_at: null,
+    });
+}
+export function getAgentSessionRepoBranch(cwd) {
+    const workingDir = cwd?.trim() || process.cwd();
+    return getGitCurrentBranch(workingDir);
+}
+export function agentSessionCredentials(agentSession) {
+    return {
+        agent_session_id: agentSession.session_id,
+        agent_session_token: agentSession.session_token,
+    };
+}