letagents 0.12.8 → 0.12.10

package/dist/mcp/server/runtime/api.js

@@ -0,0 +1,82 @@
+import { clearStoredAuth, getStoredAuth, } from "../../local-state.js";
+import { clearAuthenticatedAccountCache } from "./auth-cache.js";
+export const API_URL = (process.env.LETAGENTS_API_URL || "http://localhost:3001").replace(/\/+$/, "");
+export class ApiError extends Error {
+    status;
+    body;
+    constructor(status, body) {
+        super(`API error ${status}: ${body}`);
+        this.name = "ApiError";
+        this.status = status;
+        this.body = body;
+    }
+}
+export function getLetagentsToken() {
+    return process.env.LETAGENTS_TOKEN || getStoredAuth()?.token || "";
+}
+export function getAuthorizationHeader() {
+    const letagentsToken = getLetagentsToken();
+    return letagentsToken ? `Bearer ${letagentsToken}` : null;
+}
+export 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));
+}
+export function parseApiErrorPayload(error) {
+    if (!(error instanceof ApiError)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(error.body);
+        return parsed && typeof parsed === "object" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function resolveApiPath(urlOrPath) {
+    if (!urlOrPath) {
+        return "/auth/device/start";
+    }
+    try {
+        const parsed = new URL(urlOrPath, `${API_URL}/`);
+        const apiBase = new URL(`${API_URL}/`);
+        if (parsed.origin !== apiBase.origin) {
+            return "/auth/device/start";
+        }
+        return `${parsed.pathname}${parsed.search}`;
+    }
+    catch {
+        return "/auth/device/start";
+    }
+}
+export 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,
+    });
+    if (!res.ok) {
+        const body = await res.text();
+        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();
+            clearAuthenticatedAccountCache();
+        }
+        throw new ApiError(res.status, body);
+    }
+    const body = await res.text();
+    if (!body) {
+        return null;
+    }
+    return JSON.parse(body);
+}

package/dist/mcp/server/runtime/auth-cache.js

@@ -0,0 +1,20 @@
+let currentAuthenticatedAccount = undefined;
+let currentAuthenticatedAccountSource = null;
+let currentAuthenticatedEnvToken = null;
+export function clearAuthenticatedAccountCache() {
+    currentAuthenticatedAccount = undefined;
+    currentAuthenticatedAccountSource = null;
+    currentAuthenticatedEnvToken = null;
+}
+export function setAuthenticatedAccountCache(account, source, envToken) {
+    currentAuthenticatedAccount = account;
+    currentAuthenticatedAccountSource = source;
+    currentAuthenticatedEnvToken = envToken;
+}
+export function getAuthenticatedAccountCache() {
+    return {
+        account: currentAuthenticatedAccount,
+        source: currentAuthenticatedAccountSource,
+        envToken: currentAuthenticatedEnvToken,
+    };
+}

package/dist/mcp/server/runtime/device-auth.js

@@ -0,0 +1,48 @@
+import { getPendingDeviceAuth, setPendingDeviceAuth, } from "../../local-state.js";
+import { ApiError, apiCall, parseApiErrorPayload, resolveApiPath, } from "./api.js";
+export class RepoRoomAuthRequiredError extends Error {
+    roomId;
+    pendingAuth;
+    constructor(roomId, pendingAuth) {
+        super(`Repo room '${roomId}' requires authentication. Device flow started: open ${pendingAuth.verification_uri} and enter code ${pendingAuth.user_code}, then run poll_device_auth.`);
+        this.name = "RepoRoomAuthRequiredError";
+        this.roomId = roomId;
+        this.pendingAuth = pendingAuth;
+    }
+}
+export async function startPendingDeviceAuth(roomId, deviceFlowUrl) {
+    const existing = getPendingDeviceAuth();
+    if (existing?.suggested_room_id === roomId) {
+        return existing;
+    }
+    const response = await apiCall(resolveApiPath(deviceFlowUrl), {
+        method: "POST",
+    });
+    return 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: roomId,
+    });
+}
+export async function maybeHandleRepoRoomAuthRequired(error, roomId) {
+    const payload = parseApiErrorPayload(error);
+    if (!(error instanceof ApiError) || error.status !== 401 || payload?.error !== "auth_required") {
+        return;
+    }
+    const pendingAuth = await startPendingDeviceAuth(roomId, typeof payload.device_flow_url === "string" ? payload.device_flow_url : undefined);
+    throw new RepoRoomAuthRequiredError(roomId, pendingAuth);
+}
+export function toRepoRoomAuthRequiredResult(error) {
+    return {
+        success: false,
+        error: "auth_required",
+        room_id: error.roomId,
+        next_step: "poll_device_auth",
+        pending_device_auth: error.pendingAuth,
+        message: error.message,
+    };
+}

package/dist/mcp/server/runtime/identity/config.js

@@ -0,0 +1,58 @@
+import { execSync } from "child_process";
+import { inferAgentIdeLabel, toTitleCaseCodename, } from "../../../../shared/agent-identity.js";
+import { normalizeAgentBaseName } from "../../../../shared/codenames.js";
+export const AGENT_NAME = (process.env.LETAGENTS_AGENT_NAME ||
+    process.env.AGENT_NAME ||
+    "").trim();
+export const AGENT_DISPLAY_NAME = (process.env.LETAGENTS_AGENT_DISPLAY_NAME || "").trim();
+export const AGENT_IDE_LABEL = (process.env.LETAGENTS_AGENT_IDE ||
+    process.env.AGENT_IDE ||
+    "").trim();
+export const AGENT_OWNER_LABEL = (process.env.LETAGENTS_AGENT_OWNER_LABEL || "").trim();
+export const EXPLICIT_AGENT_IDENTITY_KEY = getExplicitAgentIdentityStorageKey();
+export function readCommandOutput(command, cwd = process.cwd()) {
+    try {
+        const output = execSync(command, {
+            cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+            encoding: "utf-8",
+        }).trim();
+        return output || null;
+    }
+    catch {
+        return null;
+    }
+}
+function isCodexRuntime() {
+    return Boolean(process.env.CODEX_THREAD_ID ||
+        process.env.CODEX_SHELL ||
+        process.env.CODEX_CI ||
+        process.env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE);
+}
+function getExplicitAgentIdentityStorageKey() {
+    const runtimeSignals = [
+        process.env.LETAGENTS_AGENT_INSTANCE_ID,
+        process.env.CODEX_THREAD_ID && `codex:${process.env.CODEX_THREAD_ID}`,
+        process.env.ANTIGRAVITY_THREAD_ID && `antigravity:${process.env.ANTIGRAVITY_THREAD_ID}`,
+        process.env.CLAUDECODE_SESSION_ID && `claude:${process.env.CLAUDECODE_SESSION_ID}`,
+        process.env.MCP_SESSION_ID && `mcp:${process.env.MCP_SESSION_ID}`,
+    ].filter((value) => Boolean(value?.trim()));
+    return runtimeSignals[0] ?? null;
+}
+export function detectAgentIdeLabel() {
+    if (AGENT_IDE_LABEL) {
+        return toTitleCaseCodename(AGENT_IDE_LABEL);
+    }
+    if (isCodexRuntime()) {
+        return "Codex";
+    }
+    const explicitName = normalizeAgentBaseName(AGENT_NAME || AGENT_DISPLAY_NAME);
+    const inferred = inferAgentIdeLabel(explicitName);
+    return inferred || "Agent";
+}
+export function detectAgentRuntimeLabel() {
+    if (isCodexRuntime()) {
+        return "codex";
+    }
+    return detectAgentIdeLabel().trim().toLowerCase() || "unknown";
+}

package/dist/mcp/server/runtime/identity/directory.js

@@ -0,0 +1,87 @@
+import { userInfo } from "os";
+import { getStoredAuth, } from "../../../local-state.js";
+import { normalizeSlugSegment } from "../../../../shared/codenames.js";
+import { apiCall, getLetagentsToken, } from "../api.js";
+import { getAuthenticatedAccountCache, setAuthenticatedAccountCache, } from "../auth-cache.js";
+import { AGENT_OWNER_LABEL, readCommandOutput, } from "./config.js";
+export async function getAuthenticatedAgentDirectory() {
+    try {
+        const result = await apiCall("/agents/me");
+        const account = result?.account;
+        if (!account?.login?.trim()) {
+            return null;
+        }
+        setAuthenticatedAccountCache(account, process.env.LETAGENTS_TOKEN?.trim() ? "env" : "stored", process.env.LETAGENTS_TOKEN?.trim() || null);
+        return {
+            account,
+            agents: Array.isArray(result?.agents) ? result.agents : [],
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function getAuthenticatedAccountProfile() {
+    const envToken = (process.env.LETAGENTS_TOKEN || "").trim();
+    const cache = getAuthenticatedAccountCache();
+    if (envToken) {
+        if (cache.source === "env" &&
+            cache.envToken === envToken &&
+            cache.account?.login?.trim()) {
+            return cache.account;
+        }
+        const directory = await getAuthenticatedAgentDirectory();
+        return directory?.account?.login?.trim() ? directory.account : null;
+    }
+    const storedAccount = getStoredAuth()?.account;
+    if (storedAccount?.login?.trim()) {
+        setAuthenticatedAccountCache(storedAccount, "stored", null);
+        return storedAccount;
+    }
+    if (!getLetagentsToken()) {
+        setAuthenticatedAccountCache(undefined, null, null);
+        return null;
+    }
+    if (cache.source === "stored" && cache.account?.login?.trim()) {
+        return cache.account;
+    }
+    const directory = await getAuthenticatedAgentDirectory();
+    return directory?.account?.login?.trim() ? directory.account : null;
+}
+export async function resolveOwnerContext() {
+    const account = await getAuthenticatedAccountProfile();
+    const authLogin = account?.login?.trim() || null;
+    const authLabel = account?.display_name?.trim() || authLogin;
+    if (authLogin || authLabel || AGENT_OWNER_LABEL) {
+        const label = AGENT_OWNER_LABEL || authLabel || authLogin || "Owner";
+        const slug = normalizeSlugSegment(authLogin || label, "owner");
+        return { slug, label, login: authLogin };
+    }
+    const gitUserName = readCommandOutput("git config --get user.name");
+    const gitUserEmail = readCommandOutput("git config --get user.email");
+    const gitIdentity = gitUserName || gitUserEmail?.split("@")[0] || null;
+    if (gitIdentity) {
+        return {
+            slug: normalizeSlugSegment(gitIdentity, "owner"),
+            label: gitIdentity,
+            login: null,
+        };
+    }
+    const osIdentity = process.env.USER ||
+        process.env.LOGNAME ||
+        process.env.USERNAME ||
+        (() => {
+            try {
+                return userInfo().username;
+            }
+            catch {
+                return null;
+            }
+        })() ||
+        "owner";
+    return {
+        slug: normalizeSlugSegment(osIdentity, "owner"),
+        label: osIdentity,
+        login: null,
+    };
+}

package/dist/mcp/server/runtime/identity/liveness.js

@@ -0,0 +1,32 @@
+import { randomUUID } from "crypto";
+import { readLocalState, updateLocalState, } from "../../../local-state.js";
+import { detectAgentIdeLabel, detectAgentRuntimeLabel, } from "./config.js";
+import { AGENT_INSTANCE_UUID } from "./state.js";
+function getOrCreateLocalHostId() {
+    const state = readLocalState();
+    if (typeof state.local_host_id === "string" && state.local_host_id.trim()) {
+        return state.local_host_id;
+    }
+    const hostId = `host_${randomUUID().replace(/-/g, "")}`;
+    updateLocalState((nextState) => {
+        nextState.local_host_id = typeof nextState.local_host_id === "string" && nextState.local_host_id.trim()
+            ? nextState.local_host_id
+            : hostId;
+        return nextState;
+    });
+    return readLocalState().local_host_id || hostId;
+}
+export function getSessionLivenessRegistration(runtime = detectAgentRuntimeLabel()) {
+    const hostId = getOrCreateLocalHostId();
+    const ideLabel = detectAgentIdeLabel();
+    const normalizedRuntime = runtime.trim().toLowerCase() || ideLabel.toLowerCase();
+    return {
+        host_id: hostId,
+        host_kind: process.platform === "darwin" ? "macos" : process.platform,
+        host_label: null,
+        liveness_capability: normalizedRuntime === "codex"
+            ? "codex_app_server_runtime_stream"
+            : "session_activity",
+        tool_bridge_id: `${hostId}:${normalizedRuntime}:${AGENT_INSTANCE_UUID}`,
+    };
+}

package/dist/mcp/server/runtime/identity/names.js

@@ -0,0 +1,74 @@
+import { createHash } from "crypto";
+import { toTitleCaseCodename } from "../../../../shared/agent-identity.js";
+import { AGENT_CODENAME_SPACE, normalizeAgentBaseName, pickLocalCodename, } from "../../../../shared/codenames.js";
+import { AGENT_DISPLAY_NAME, AGENT_NAME, } from "./config.js";
+import { getAuthenticatedAgentDirectory } from "./directory.js";
+function shouldReuseStoredIdentity(identity, identityKey) {
+    return Boolean(identity &&
+        identity.runtime_key === identityKey &&
+        identity.display_name?.trim() &&
+        identity.ide_label?.trim() &&
+        identity.owner_attribution?.trim());
+}
+function resolveExplicitAgentIdentity() {
+    if (AGENT_NAME) {
+        const name = normalizeAgentBaseName(AGENT_NAME);
+        return {
+            name,
+            display_name: AGENT_DISPLAY_NAME || toTitleCaseCodename(AGENT_NAME),
+        };
+    }
+    if (AGENT_DISPLAY_NAME) {
+        return {
+            name: normalizeAgentBaseName(AGENT_DISPLAY_NAME),
+            display_name: AGENT_DISPLAY_NAME.trim(),
+        };
+    }
+    return null;
+}
+export async function resolveAgentName(input) {
+    const explicit = resolveExplicitAgentIdentity();
+    if (explicit) {
+        return explicit;
+    }
+    if (shouldReuseStoredIdentity(input.currentIdentity, input.identityKey)) {
+        return {
+            name: input.currentIdentity.name,
+            display_name: input.currentIdentity.display_name,
+        };
+    }
+    if (!input.authAvailable) {
+        return pickLocalCodename(input.identityKey);
+    }
+    const directory = await getAuthenticatedAgentDirectory();
+    const existingNames = new Set((directory?.agents ?? [])
+        .map((agent) => normalizeAgentBaseName(agent.name || ""))
+        .filter(Boolean));
+    for (let offset = 0; offset < AGENT_CODENAME_SPACE; offset += 1) {
+        const candidate = pickLocalCodename(input.identityKey, offset);
+        if (!existingNames.has(candidate.name)) {
+            return candidate;
+        }
+    }
+    const fallbackHash = createHash("sha256")
+        .update(input.identityKey)
+        .digest("hex")
+        .slice(0, 4);
+    const fallback = pickLocalCodename(input.identityKey);
+    return {
+        name: `${fallback.name}-${fallbackHash}`,
+        display_name: `${fallback.display_name} ${fallbackHash.toUpperCase()}`,
+    };
+}
+export function sameAgentIdentity(left, right) {
+    return Boolean(left &&
+        left.name === right.name &&
+        left.display_name === right.display_name &&
+        left.owner_label === right.owner_label &&
+        left.owner_attribution === right.owner_attribution &&
+        left.ide_label === right.ide_label &&
+        left.actor_label === right.actor_label &&
+        left.canonical_key === right.canonical_key &&
+        left.runtime_key === right.runtime_key &&
+        left.source === right.source);
+}

package/dist/mcp/server/runtime/identity/public.js

@@ -0,0 +1,19 @@
+import { formatOwnerAttribution, inferAgentIdeLabel, } from "../../../../shared/agent-identity.js";
+import { AGENT_INSTANCE_UUID } from "./state.js";
+export function toPublicAgentIdentity(identity) {
+    if (!identity) {
+        return null;
+    }
+    return {
+        name: identity.name,
+        display_name: identity.display_name,
+        owner_label: identity.owner_label,
+        owner_attribution: identity.owner_attribution ?? formatOwnerAttribution(identity.owner_label),
+        ide_label: identity.ide_label ?? inferAgentIdeLabel(identity.display_name) ?? "Agent",
+        actor_label: identity.actor_label,
+        canonical_key: identity.canonical_key ?? null,
+        runtime_key: identity.runtime_key ?? null,
+        agent_instance_id: AGENT_INSTANCE_UUID,
+        source: identity.source,
+    };
+}

package/dist/mcp/server/runtime/identity/state.js

@@ -0,0 +1,32 @@
+import { randomUUID } from "crypto";
+import { getStoredAgentIdentity, setStoredAgentIdentity, } from "../../../local-state.js";
+import { EXPLICIT_AGENT_IDENTITY_KEY } from "./config.js";
+const MAX_CONVERSATION_IDENTITIES = 20;
+export const AGENT_INSTANCE_UUID = randomUUID();
+export let currentAgentIdentityKey = EXPLICIT_AGENT_IDENTITY_KEY ?? `instance:${AGENT_INSTANCE_UUID}`;
+export let currentAgentIdentity = getStoredAgentIdentity(currentAgentIdentityKey);
+const conversationIdentities = new Map();
+export function storeCurrentAgentIdentity(identity, identityKey = currentAgentIdentityKey) {
+    currentAgentIdentity = setStoredAgentIdentity(identity, identityKey);
+    return currentAgentIdentity;
+}
+export function getConversationIdentity(conversationId) {
+    if (!conversationId)
+        return currentAgentIdentity;
+    return conversationIdentities.get(conversationId) ?? currentAgentIdentity;
+}
+export function setConversationIdentity(conversationId, identity) {
+    if (!conversationIdentities.has(conversationId) &&
+        conversationIdentities.size >= MAX_CONVERSATION_IDENTITIES) {
+        const oldestKey = conversationIdentities.keys().next().value;
+        if (oldestKey !== undefined)
+            conversationIdentities.delete(oldestKey);
+    }
+    conversationIdentities.set(conversationId, identity);
+}
+export function ensureAgentIdentityKey() {
+    currentAgentIdentityKey =
+        EXPLICIT_AGENT_IDENTITY_KEY ?? `instance:${AGENT_INSTANCE_UUID}`;
+    currentAgentIdentity = getStoredAgentIdentity(currentAgentIdentityKey);
+    return currentAgentIdentityKey;
+}

package/dist/mcp/server/runtime/identity.js

@@ -0,0 +1,96 @@
+import { buildAgentActorLabel, formatOwnerAttribution, } from "../../../shared/agent-identity.js";
+import { apiCall, getLetagentsToken, } from "./api.js";
+import { detectAgentIdeLabel, detectAgentRuntimeLabel, } from "./identity/config.js";
+import { resolveOwnerContext } from "./identity/directory.js";
+import { getSessionLivenessRegistration } from "./identity/liveness.js";
+import { resolveAgentName, sameAgentIdentity, } from "./identity/names.js";
+import { toPublicAgentIdentity } from "./identity/public.js";
+import { currentAgentIdentity, currentAgentIdentityKey, ensureAgentIdentityKey, getConversationIdentity, setConversationIdentity, storeCurrentAgentIdentity, AGENT_INSTANCE_UUID, } from "./identity/state.js";
+export { AGENT_INSTANCE_UUID, currentAgentIdentity, currentAgentIdentityKey, detectAgentIdeLabel, detectAgentRuntimeLabel, getConversationIdentity, getSessionLivenessRegistration, resolveOwnerContext, setConversationIdentity, storeCurrentAgentIdentity, toPublicAgentIdentity, };
+export async function ensureAgentIdentity() {
+    const owner = await resolveOwnerContext();
+    const authAvailable = Boolean(getLetagentsToken());
+    const ideLabel = detectAgentIdeLabel();
+    const identityKey = ensureAgentIdentityKey();
+    const ownerAttribution = formatOwnerAttribution(owner.label);
+    const { name, display_name: displayName } = await resolveAgentName({
+        authAvailable,
+        identityKey,
+        currentIdentity: currentAgentIdentity,
+    });
+    const actorLabel = buildAgentActorLabel({
+        display_name: displayName,
+        owner_label: owner.label,
+        ide_label: ideLabel,
+    });
+    let resolved = {
+        name,
+        display_name: displayName,
+        owner_label: owner.label,
+        owner_attribution: ownerAttribution,
+        ide_label: ideLabel,
+        actor_label: actorLabel,
+        canonical_key: owner.login ? `${owner.login}/${name}` : null,
+        runtime_key: identityKey,
+        source: "local",
+        resolved_at: new Date().toISOString(),
+    };
+    if (currentAgentIdentity &&
+        currentAgentIdentity.name === resolved.name &&
+        currentAgentIdentity.display_name === resolved.display_name &&
+        currentAgentIdentity.owner_label === resolved.owner_label &&
+        currentAgentIdentity.owner_attribution === resolved.owner_attribution &&
+        currentAgentIdentity.ide_label === resolved.ide_label &&
+        currentAgentIdentity.actor_label === resolved.actor_label &&
+        currentAgentIdentity.runtime_key === resolved.runtime_key &&
+        (!authAvailable || currentAgentIdentity.source === "api")) {
+        return currentAgentIdentity;
+    }
+    if (authAvailable) {
+        try {
+            const registered = await apiCall("/agents", {
+                method: "POST",
+                body: JSON.stringify({
+                    name: resolved.name,
+                    display_name: resolved.display_name,
+                    owner_label: resolved.owner_label,
+                }),
+            });
+            resolved = {
+                ...resolved,
+                canonical_key: typeof registered.canonical_key === "string"
+                    ? registered.canonical_key
+                    : resolved.canonical_key,
+                display_name: typeof registered.display_name === "string"
+                    ? registered.display_name
+                    : resolved.display_name,
+                owner_label: typeof registered.owner_label === "string"
+                    ? registered.owner_label
+                    : resolved.owner_label,
+                source: "api",
+            };
+            resolved.owner_attribution = formatOwnerAttribution(resolved.owner_label);
+            resolved.actor_label = buildAgentActorLabel({
+                display_name: resolved.display_name,
+                owner_label: resolved.owner_label,
+                ide_label: resolved.ide_label,
+            });
+        }
+        catch (error) {
+            console.error("Agent identity registration failed:", error instanceof Error ? error.message : error);
+        }
+    }
+    if (sameAgentIdentity(currentAgentIdentity, resolved)) {
+        return currentAgentIdentity ?? resolved;
+    }
+    return storeCurrentAgentIdentity({
+        ...resolved,
+        resolved_at: new Date().toISOString(),
+    }, identityKey);
+}
+export async function withAgentIdentity(payload) {
+    return {
+        ...payload,
+        agent_identity: toPublicAgentIdentity(await ensureAgentIdentity()),
+    };
+}