letagents 0.12.9 → 0.12.10

package/dist/mcp/git-remote.js

@@ -7,11 +7,11 @@
 //   host/owner/repo
 //
 // Examples:
-//   git@github.com:BrosInCode/letagents.git  → github.com/BrosInCode/letagents
-//   https://github.com/BrosInCode/letagents.git → github.com/BrosInCode/letagents
-//   https://github.com/BrosInCode/letagents → github.com/BrosInCode/letagents
+//   git@github.com:BrosInCode/letagents.git  → github.com/brosincode/letagents
+//   https://github.com/BrosInCode/letagents.git → github.com/brosincode/letagents
+//   https://github.com/BrosInCode/letagents → github.com/brosincode/letagents
 //   ssh://git@gitlab.com/team/project.git → gitlab.com/team/project
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 /**
  * Normalize a git remote URL to `host/owner/repo` format.
  * Strips protocol (SSH/HTTPS), user prefix, and `.git` suffix.
@@ -40,26 +40,102 @@ export function normalizeGitRemote(url) {
     normalized = normalized.replace(/\.git$/, "");
     // Strip trailing slashes
     normalized = normalized.replace(/\/+$/, "");
+    const parts = normalized.split("/");
+    const host = parts[0]?.toLowerCase();
+    if (host) {
+        parts[0] = host;
+        normalized = host === "github.com" ? parts.join("/").toLowerCase() : parts.join("/");
+    }
     return normalized;
 }
-/**
- * Get the normalized git remote URL for the current working directory.
- * Returns null if not in a git repo or no remote is configured.
- */
-export function getGitRemoteIdentity(cwd) {
+function execGit(args, cwd) {
     try {
-        const remoteUrl = execSync("git remote get-url origin", {
+        const output = execFileSync("git", args, {
             cwd: cwd || process.cwd(),
             encoding: "utf-8",
             timeout: 5000,
             stdio: ["pipe", "pipe", "pipe"],
         }).trim();
-        if (!remoteUrl)
-            return null;
-        return normalizeGitRemote(remoteUrl);
+        return output || null;
     }
     catch {
-        // Not a git repo, no remote, or git not installed
         return null;
     }
 }
+function encodeRefForRoomId(refName) {
+    return Buffer.from(refName, "utf8")
+        .toString("base64")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/g, "");
+}
+function githubRepositoryFullNameFromRoom(repoRoom) {
+    const parts = repoRoom.trim().replace(/\/+$/, "").split("/");
+    const host = parts[0]?.toLowerCase();
+    const owner = parts[1];
+    const repo = parts[2];
+    if (host !== "github.com" || !owner || !repo || parts.length !== 3) {
+        return null;
+    }
+    return `${owner}/${repo}`;
+}
+function isLikelyDefaultBranchName(branchName) {
+    return branchName === "main" || branchName === "master" || branchName === "trunk";
+}
+export function buildGitRefRoomIdentity(input) {
+    const repositoryFullName = githubRepositoryFullNameFromRoom(input.repoRoom);
+    const refName = input.refName.trim();
+    if (!repositoryFullName || !refName) {
+        return null;
+    }
+    return `git-room:github.com:${repositoryFullName.toLowerCase()}:${input.refType}:${encodeRefForRoomId(refName)}`;
+}
+export function getGitCurrentBranch(cwd) {
+    return execGit(["branch", "--show-current"], cwd);
+}
+export function getGitDefaultBranch(cwd) {
+    const originHead = execGit(["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"], cwd);
+    if (!originHead)
+        return null;
+    return originHead.replace(/^origin\//, "") || null;
+}
+export function buildActiveGitRoomContext(input) {
+    const currentBranch = input.currentBranch?.trim() || null;
+    const defaultBranch = input.defaultBranch?.trim() || null;
+    const shouldUseBranchRoom = Boolean(input.repoRoom
+        && currentBranch
+        && (defaultBranch
+            ? currentBranch !== defaultBranch
+            : !isLikelyDefaultBranchName(currentBranch)));
+    const activeRefRoom = input.repoRoom && currentBranch && shouldUseBranchRoom
+        ? buildGitRefRoomIdentity({
+            repoRoom: input.repoRoom,
+            refType: "branch",
+            refName: currentBranch,
+        })
+        : null;
+    return {
+        repoRoom: input.repoRoom,
+        currentBranch,
+        defaultBranch,
+        activeRefRoom,
+        activeRoom: activeRefRoom ?? input.repoRoom,
+        activeRoomKind: activeRefRoom ? "branch" : input.repoRoom ? "repo" : null,
+    };
+}
+export function getGitRoomContext(cwd) {
+    const repoRoom = getGitRemoteIdentity(cwd);
+    return buildActiveGitRoomContext({
+        repoRoom,
+        currentBranch: getGitCurrentBranch(cwd),
+        defaultBranch: getGitDefaultBranch(cwd),
+    });
+}
+/**
+ * Get the normalized git remote URL for the current working directory.
+ * Returns null if not in a git repo or no remote is configured.
+ */
+export function getGitRemoteIdentity(cwd) {
+    const remoteUrl = execGit(["remote", "get-url", "origin"], cwd);
+    return remoteUrl ? normalizeGitRemote(remoteUrl) : null;
+}

package/dist/mcp/local-state/agent-identity.js

@@ -0,0 +1,26 @@
+import { readLocalState, updateLocalState } from "./storage.js";
+export function getStoredAgentIdentity(identityKey) {
+    const state = readLocalState();
+    if (identityKey?.trim()) {
+        const scoped = state.agent_identities?.[identityKey.trim()];
+        if (scoped) {
+            return scoped;
+        }
+        // UUID-based identity keys must not inherit another process' shared identity.
+        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;
+}

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

@@ -0,0 +1,66 @@
+import { readLocalState, updateLocalState } from "./storage.js";
+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;
+}

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

@@ -0,0 +1,57 @@
+import { readLocalState, updateLocalState } from "./storage.js";
+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;
+    });
+}

package/dist/mcp/local-state/codex-live-sessions.js

@@ -0,0 +1,59 @@
+import { readLocalState, updateLocalState } from "./storage.js";
+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;
+}

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

@@ -0,0 +1,8 @@
+export * from "./types.js";
+export * from "./storage.js";
+export * from "./auth.js";
+export * from "./agent-identity.js";
+export * from "./agent-sessions.js";
+export * from "./room-sessions.js";
+export * from "./codex-live-sessions.js";
+export * from "./local-chat.js";