letagents 0.12.9 → 0.12.10

package/dist/mcp/local-state/room-sessions.js

@@ -0,0 +1,51 @@
+import { readLocalState, updateLocalState } from "./storage.js";
+export function getStoredCurrentRoom() {
+    const state = readLocalState();
+    return state.current_room ?? null;
+}
+export function getStoredRoomSession(roomId) {
+    const state = readLocalState();
+    return state.room_sessions?.[roomId] ?? null;
+}
+export function saveRoomSession(input) {
+    const now = new Date().toISOString();
+    const existing = getStoredRoomSession(input.room_id);
+    const session = {
+        room_id: input.room_id,
+        project_id: input.project_id ?? existing?.project_id ?? null,
+        code: input.code ?? existing?.code ?? null,
+        display_name: input.display_name ?? existing?.display_name ?? null,
+        git_room: input.git_room !== undefined ? input.git_room : existing?.git_room ?? null,
+        joined_via: input.joined_via,
+        joined_at: existing?.joined_at ?? now,
+        last_seen_at: now,
+        last_message_id: input.last_message_id ?? existing?.last_message_id,
+    };
+    updateLocalState((state) => {
+        state.room_sessions = state.room_sessions ?? {};
+        state.room_sessions[input.room_id] = session;
+        state.current_room = session;
+        return state;
+    });
+    return session;
+}
+export function touchRoomSession(roomId, lastMessageId) {
+    const existing = getStoredRoomSession(roomId);
+    if (!existing) {
+        return null;
+    }
+    const updated = {
+        ...existing,
+        last_seen_at: new Date().toISOString(),
+        last_message_id: lastMessageId ?? existing.last_message_id,
+    };
+    updateLocalState((state) => {
+        state.room_sessions = state.room_sessions ?? {};
+        state.room_sessions[roomId] = updated;
+        if (state.current_room?.room_id === roomId) {
+            state.current_room = updated;
+        }
+        return state;
+    });
+    return updated;
+}

package/dist/mcp/local-state/storage.js

@@ -0,0 +1,95 @@
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "fs";
+import { randomBytes } from "crypto";
+import { homedir } from "os";
+import { dirname, join } from "path";
+const DEFAULT_STATE_PATH = join(homedir(), ".letagents", "mcp-state.json");
+const STATE_LOCK_WAIT_MS = 25;
+const STATE_LOCK_TIMEOUT_MS = 2_000;
+const STATE_LOCK_STALE_MS = 10_000;
+const STATE_LOCK_SLEEP_BUFFER = new Int32Array(new SharedArrayBuffer(4));
+export function getLocalStatePath() {
+    return process.env.LETAGENTS_STATE_PATH || DEFAULT_STATE_PATH;
+}
+function readLocalStateFromPath(statePath) {
+    if (!existsSync(statePath)) {
+        return {};
+    }
+    try {
+        const raw = readFileSync(statePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed === "object" && parsed ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function readLocalState() {
+    return readLocalStateFromPath(getLocalStatePath());
+}
+function sleepSync(ms) {
+    if (ms > 0) {
+        Atomics.wait(STATE_LOCK_SLEEP_BUFFER, 0, 0, ms);
+    }
+}
+function writeLocalStateUnlocked(statePath, state) {
+    const tempPath = `${statePath}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+    try {
+        writeFileSync(tempPath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+        renameSync(tempPath, statePath);
+    }
+    finally {
+        rmSync(tempPath, { force: true });
+    }
+}
+function withStateLock(callback) {
+    const statePath = getLocalStatePath();
+    mkdirSync(dirname(statePath), { recursive: true });
+    const lockPath = `${statePath}.lock`;
+    const startedAt = Date.now();
+    while (true) {
+        let lockFd = null;
+        try {
+            lockFd = openSync(lockPath, "wx");
+            return callback(statePath);
+        }
+        catch (error) {
+            const err = error;
+            if (err.code !== "EEXIST") {
+                throw error;
+            }
+            try {
+                const stats = statSync(lockPath);
+                if (Date.now() - stats.mtimeMs > STATE_LOCK_STALE_MS) {
+                    rmSync(lockPath, { force: true });
+                    continue;
+                }
+            }
+            catch {
+                continue;
+            }
+            if (Date.now() - startedAt >= STATE_LOCK_TIMEOUT_MS) {
+                throw new Error(`Timed out acquiring local state lock at ${lockPath}`);
+            }
+            sleepSync(STATE_LOCK_WAIT_MS);
+        }
+        finally {
+            if (lockFd !== null) {
+                closeSync(lockFd);
+                rmSync(lockPath, { force: true });
+            }
+        }
+    }
+}
+export function writeLocalState(state) {
+    withStateLock((statePath) => {
+        writeLocalStateUnlocked(statePath, state);
+    });
+}
+export function updateLocalState(updater) {
+    return withStateLock((statePath) => {
+        const current = readLocalStateFromPath(statePath);
+        const updated = updater(current) ?? current;
+        writeLocalStateUnlocked(statePath, updated);
+        return updated;
+    });
+}

package/dist/mcp/local-state/types.js

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

package/dist/mcp/local-state.js

@@ -1,351 +1 @@
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "fs";
-import { randomBytes } from "crypto";
-import { homedir } from "os";
-import { dirname, join } from "path";
-const DEFAULT_STATE_PATH = join(homedir(), ".letagents", "mcp-state.json");
-const STATE_LOCK_WAIT_MS = 25;
-const STATE_LOCK_TIMEOUT_MS = 2_000;
-const STATE_LOCK_STALE_MS = 10_000;
-const STATE_LOCK_SLEEP_BUFFER = new Int32Array(new SharedArrayBuffer(4));
-export function getLocalStatePath() {
-    return process.env.LETAGENTS_STATE_PATH || DEFAULT_STATE_PATH;
-}
-function readLocalStateFromPath(statePath) {
-    if (!existsSync(statePath)) {
-        return {};
-    }
-    try {
-        const raw = readFileSync(statePath, "utf-8");
-        const parsed = JSON.parse(raw);
-        return typeof parsed === "object" && parsed ? parsed : {};
-    }
-    catch {
-        return {};
-    }
-}
-export function readLocalState() {
-    const statePath = getLocalStatePath();
-    return readLocalStateFromPath(statePath);
-}
-function sleepSync(ms) {
-    if (ms > 0) {
-        Atomics.wait(STATE_LOCK_SLEEP_BUFFER, 0, 0, ms);
-    }
-}
-function writeLocalStateUnlocked(statePath, state) {
-    const tempPath = `${statePath}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
-    try {
-        writeFileSync(tempPath, JSON.stringify(state, null, 2) + "\n", "utf-8");
-        renameSync(tempPath, statePath);
-    }
-    finally {
-        rmSync(tempPath, { force: true });
-    }
-}
-function withStateLock(callback) {
-    const statePath = getLocalStatePath();
-    mkdirSync(dirname(statePath), { recursive: true });
-    const lockPath = `${statePath}.lock`;
-    const startedAt = Date.now();
-    while (true) {
-        let lockFd = null;
-        try {
-            lockFd = openSync(lockPath, "wx");
-            return callback(statePath);
-        }
-        catch (error) {
-            const err = error;
-            if (err.code !== "EEXIST") {
-                throw error;
-            }
-            try {
-                const stats = statSync(lockPath);
-                if (Date.now() - stats.mtimeMs > STATE_LOCK_STALE_MS) {
-                    rmSync(lockPath, { force: true });
-                    continue;
-                }
-            }
-            catch {
-                continue;
-            }
-            if (Date.now() - startedAt >= STATE_LOCK_TIMEOUT_MS) {
-                throw new Error(`Timed out acquiring local state lock at ${lockPath}`);
-            }
-            sleepSync(STATE_LOCK_WAIT_MS);
-        }
-        finally {
-            if (lockFd !== null) {
-                closeSync(lockFd);
-                rmSync(lockPath, { force: true });
-            }
-        }
-    }
-}
-export function writeLocalState(state) {
-    withStateLock((statePath) => {
-        writeLocalStateUnlocked(statePath, state);
-    });
-}
-export function updateLocalState(updater) {
-    return withStateLock((statePath) => {
-        const current = readLocalStateFromPath(statePath);
-        const updated = updater(current) ?? current;
-        writeLocalStateUnlocked(statePath, updated);
-        return updated;
-    });
-}
-function isExpired(expiresAt) {
-    if (!expiresAt) {
-        return false;
-    }
-    const expiresAtMs = Date.parse(expiresAt);
-    return Number.isFinite(expiresAtMs) && expiresAtMs <= Date.now();
-}
-export function getStoredAuth() {
-    const state = readLocalState();
-    if (!state.auth) {
-        return null;
-    }
-    if (isExpired(state.auth.expires_at)) {
-        clearStoredAuth();
-        return null;
-    }
-    return state.auth;
-}
-export function setStoredAuth(auth) {
-    updateLocalState((state) => {
-        state.auth = auth;
-        delete state.pending_device_auth;
-        return state;
-    });
-    return auth;
-}
-export function clearStoredAuth() {
-    updateLocalState((state) => {
-        delete state.auth;
-        return state;
-    });
-}
-export function getPendingDeviceAuth() {
-    const state = readLocalState();
-    if (!state.pending_device_auth) {
-        return null;
-    }
-    if (isExpired(state.pending_device_auth.expires_at)) {
-        clearPendingDeviceAuth();
-        return null;
-    }
-    return state.pending_device_auth;
-}
-export function setPendingDeviceAuth(pendingDeviceAuth) {
-    updateLocalState((state) => {
-        state.pending_device_auth = pendingDeviceAuth;
-        return state;
-    });
-    return pendingDeviceAuth;
-}
-export function clearPendingDeviceAuth() {
-    updateLocalState((state) => {
-        delete state.pending_device_auth;
-        return state;
-    });
-}
-export function getStoredAgentIdentity(identityKey) {
-    const state = readLocalState();
-    if (identityKey?.trim()) {
-        const scoped = state.agent_identities?.[identityKey.trim()];
-        if (scoped) {
-            return scoped;
-        }
-        // For UUID-based identity keys, do NOT fall back to the shared global
-        // agent_identity — that would cause different processes to inherit each
-        // other's identity. Only legacy (non-UUID) keys use the global fallback.
-        if (identityKey.startsWith("instance:")) {
-            return null;
-        }
-    }
-    return state.agent_identity ?? null;
-}
-export function setStoredAgentIdentity(agentIdentity, identityKey) {
-    updateLocalState((state) => {
-        state.agent_identity = agentIdentity;
-        if (identityKey?.trim()) {
-            state.agent_identities = state.agent_identities ?? {};
-            state.agent_identities[identityKey.trim()] = agentIdentity;
-        }
-        return state;
-    });
-    return agentIdentity;
-}
-export function getStoredAgentSession(sessionId) {
-    if (!sessionId) {
-        return null;
-    }
-    const state = readLocalState();
-    return state.agent_sessions?.[sessionId] ?? null;
-}
-export function getCurrentAgentSession(roomId) {
-    const state = readLocalState();
-    const sessionIds = state.current_agent_session_ids;
-    if (!sessionIds) {
-        return null;
-    }
-    if (roomId) {
-        const sessionId = sessionIds[roomId];
-        const session = sessionId ? (state.agent_sessions?.[sessionId] ?? null) : null;
-        return session && !session.ended_at ? session : null;
-    }
-    let best = null;
-    for (const id of Object.values(sessionIds)) {
-        const session = state.agent_sessions?.[id];
-        if (session && !session.ended_at && (!best || session.updated_at > best.updated_at)) {
-            best = session;
-        }
-    }
-    return best;
-}
-export function saveAgentSession(session, makeCurrent = true) {
-    updateLocalState((state) => {
-        state.agent_sessions = state.agent_sessions ?? {};
-        state.agent_sessions[session.session_id] = session;
-        if (makeCurrent) {
-            state.current_agent_session_ids = state.current_agent_session_ids ?? {};
-            state.current_agent_session_ids[session.room_id] = session.session_id;
-        }
-        return state;
-    });
-    return session;
-}
-export function endStoredAgentSession(sessionId, endedAt = new Date().toISOString()) {
-    let endedSession = null;
-    updateLocalState((state) => {
-        const session = state.agent_sessions?.[sessionId];
-        if (!session) {
-            return state;
-        }
-        endedSession = {
-            ...session,
-            ended_at: endedAt,
-            updated_at: endedAt,
-            last_seen_at: endedAt,
-        };
-        state.agent_sessions = state.agent_sessions ?? {};
-        state.agent_sessions[sessionId] = endedSession;
-        if (state.current_agent_session_ids) {
-            for (const [roomId, currentSessionId] of Object.entries(state.current_agent_session_ids)) {
-                if (currentSessionId === sessionId) {
-                    delete state.current_agent_session_ids[roomId];
-                }
-            }
-        }
-        return state;
-    });
-    return endedSession;
-}
-export function getStoredCurrentRoom() {
-    const state = readLocalState();
-    return state.current_room ?? null;
-}
-export function getStoredRoomSession(roomId) {
-    const state = readLocalState();
-    return state.room_sessions?.[roomId] ?? null;
-}
-export function saveRoomSession(input) {
-    const now = new Date().toISOString();
-    const existing = getStoredRoomSession(input.room_id);
-    const session = {
-        room_id: input.room_id,
-        project_id: input.project_id ?? existing?.project_id ?? null,
-        code: input.code ?? existing?.code ?? null,
-        display_name: input.display_name ?? existing?.display_name ?? null,
-        joined_via: input.joined_via,
-        joined_at: existing?.joined_at ?? now,
-        last_seen_at: now,
-        last_message_id: input.last_message_id ?? existing?.last_message_id,
-    };
-    updateLocalState((state) => {
-        state.room_sessions = state.room_sessions ?? {};
-        state.room_sessions[input.room_id] = session;
-        state.current_room = session;
-        return state;
-    });
-    return session;
-}
-export function touchRoomSession(roomId, lastMessageId) {
-    const existing = getStoredRoomSession(roomId);
-    if (!existing) {
-        return null;
-    }
-    const updated = {
-        ...existing,
-        last_seen_at: new Date().toISOString(),
-        last_message_id: lastMessageId ?? existing.last_message_id,
-    };
-    updateLocalState((state) => {
-        state.room_sessions = state.room_sessions ?? {};
-        state.room_sessions[roomId] = updated;
-        if (state.current_room?.room_id === roomId) {
-            state.current_room = updated;
-        }
-        return state;
-    });
-    return updated;
-}
-export function getCurrentCodexLiveSession(roomId) {
-    const state = readLocalState();
-    const sessionIds = state.current_codex_live_session_ids;
-    if (!sessionIds) {
-        return null;
-    }
-    if (roomId) {
-        const sessionId = sessionIds[roomId];
-        return sessionId ? (state.codex_live_sessions?.[sessionId] ?? null) : null;
-    }
-    let best = null;
-    for (const id of Object.values(sessionIds)) {
-        const session = state.codex_live_sessions?.[id];
-        if (session && (!best || session.updated_at > best.updated_at)) {
-            best = session;
-        }
-    }
-    return best;
-}
-export function getStoredCodexLiveSession(sessionId) {
-    const state = readLocalState();
-    return state.codex_live_sessions?.[sessionId] ?? null;
-}
-export function listStoredCodexLiveSessions() {
-    const state = readLocalState();
-    return Object.values(state.codex_live_sessions ?? {}).sort((left, right) => right.updated_at.localeCompare(left.updated_at));
-}
-export function saveCodexLiveSession(session, makeCurrent = true) {
-    updateLocalState((state) => {
-        state.codex_live_sessions = state.codex_live_sessions ?? {};
-        state.codex_live_sessions[session.session_id] = session;
-        if (makeCurrent) {
-            state.current_codex_live_session_ids = state.current_codex_live_session_ids ?? {};
-            state.current_codex_live_session_ids[session.room_id] = session.session_id;
-        }
-        return state;
-    });
-    return session;
-}
-export function updateCodexLiveSession(sessionId, updater) {
-    let updatedSession = null;
-    updateLocalState((state) => {
-        const existing = state.codex_live_sessions?.[sessionId];
-        if (!existing) {
-            return state;
-        }
-        const updated = updater(existing);
-        state.codex_live_sessions = state.codex_live_sessions ?? {};
-        state.codex_live_sessions[sessionId] = updated;
-        state.current_codex_live_session_ids = state.current_codex_live_session_ids ?? {};
-        if (!state.current_codex_live_session_ids[updated.room_id]) {
-            state.current_codex_live_session_ids[updated.room_id] = sessionId;
-        }
-        updatedSession = updated;
-        return state;
-    });
-    return updatedSession;
-}
+export * from "./local-state/index.js";

package/dist/mcp/managed-agent-providers.js

@@ -0,0 +1,65 @@
+import { getCurrentCodexLiveSession, } from "./local-state.js";
+import { inspectLocalCodexSession, startLocalCodexSession, stopLocalCodexSession, toPublicCodexLiveSession, } from "./codex-session.js";
+const providers = new Map();
+let defaultProviderId = "codex";
+function createCodexManagedAgentProvider() {
+    return {
+        id: "codex",
+        displayName: "Codex",
+        responseKeys: {
+            localSession: "local_codex_session",
+            localSessionStarted: "local_codex_session_started",
+            localSessionReused: "local_codex_session_reused",
+        },
+        getCurrentLiveSessionPayload(roomId) {
+            const session = getCurrentCodexLiveSession(roomId);
+            return session ? toPublicCodexLiveSession(session) : null;
+        },
+        startLocalSession: startLocalCodexSession,
+        inspectLocalSession: inspectLocalCodexSession,
+        stopLocalSession: stopLocalCodexSession,
+        toPublicLiveSession(session) {
+            return toPublicCodexLiveSession(session);
+        },
+    };
+}
+function installBuiltinManagedAgentProviders() {
+    providers.clear();
+    const codexProvider = createCodexManagedAgentProvider();
+    providers.set(codexProvider.id, codexProvider);
+    defaultProviderId = codexProvider.id;
+}
+installBuiltinManagedAgentProviders();
+export function registerManagedAgentProvider(provider, options = {}) {
+    const id = provider.id.trim();
+    if (!id) {
+        throw new Error("Managed agent provider id is required.");
+    }
+    if (providers.has(id) && !options.replace) {
+        throw new Error(`Managed agent provider '${id}' is already registered.`);
+    }
+    providers.set(id, { ...provider, id });
+    if (options.setDefault) {
+        defaultProviderId = id;
+    }
+}
+export function getManagedAgentProvider(id) {
+    const provider = providers.get(id);
+    if (!provider) {
+        throw new Error(`Managed agent provider '${id}' is not registered.`);
+    }
+    return provider;
+}
+export function getDefaultManagedAgentProvider() {
+    return getManagedAgentProvider(defaultProviderId);
+}
+export function toManagedAgentStartResponse(provider, result) {
+    return {
+        [provider.responseKeys.localSession]: provider.toPublicLiveSession(result.session),
+        [provider.responseKeys.localSessionStarted]: !result.reused,
+        [provider.responseKeys.localSessionReused]: result.reused,
+    };
+}
+export function resetManagedAgentProvidersForTest() {
+    installBuiltinManagedAgentProviders();
+}

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

@@ -0,0 +1,37 @@
+import { encodeSessionId, errorMessage, validateSessionId } from "./shared.js";
+export async function rentalEmitActivity(deps, input) {
+    const sessionIdError = validateSessionId(input);
+    if (sessionIdError)
+        return { success: false, error: sessionIdError };
+    if (typeof input.event_type !== "string" || !input.event_type.trim()) {
+        return { success: false, error: "event_type is required" };
+    }
+    const body = {
+        event_type: input.event_type.trim(),
+        source: typeof input.source === "string" && input.source.trim()
+            ? input.source.trim()
+            : "agent",
+        payload: typeof input.payload === "object" &&
+            input.payload !== null &&
+            !Array.isArray(input.payload)
+            ? input.payload
+            : {},
+    };
+    if (typeof input.verified === "boolean") {
+        body.verified = input.verified;
+    }
+    try {
+        const event = await deps.apiCall(`/api/rental/sessions/${encodeSessionId(input.session_id)}/activity`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        return { success: true, event };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: errorMessage(err),
+        };
+    }
+}

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

@@ -0,0 +1,36 @@
+import { encodeSessionId, errorMessage, isPositiveInteger, validateSessionId, } from "./shared.js";
+export async function rentalRequestBudgetExtension(deps, input) {
+    const sessionIdError = validateSessionId(input);
+    if (sessionIdError)
+        return { success: false, error: sessionIdError };
+    if (!isPositiveInteger(input.requested_additional_lrt)) {
+        return {
+            success: false,
+            error: "requested_additional_lrt must be a finite positive integer",
+        };
+    }
+    const bodyPayload = {
+        requestedAdditionalLrt: input.requested_additional_lrt,
+    };
+    if (typeof input.reason === "string" && input.reason.trim()) {
+        bodyPayload.reason = input.reason.trim();
+    }
+    try {
+        const body = await deps.apiCall(`/api/rental/sessions/${encodeSessionId(input.session_id)}/budget-extension-requests`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(bodyPayload),
+        });
+        return {
+            success: true,
+            request: body?.request ?? null,
+            session: body?.session ?? null,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: errorMessage(err),
+        };
+    }
+}