letagents 0.8.1 → 0.10.0

package/dist/mcp/local-state.js

@@ -1,12 +1,16 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+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;
 }
-export function readLocalState() {
-    const statePath = getLocalStatePath();
+function readLocalStateFromPath(statePath) {
     if (!existsSync(statePath)) {
         return {};
     }
@@ -19,18 +23,76 @@ export function readLocalState() {
         return {};
     }
 }
-export function writeLocalState(state) {
+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 tempPath = `${statePath}.tmp`;
-    writeFileSync(tempPath, JSON.stringify(state, null, 2) + "\n", "utf-8");
-    renameSync(tempPath, statePath);
+    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) {
-    const current = readLocalState();
-    const updated = updater(current) ?? current;
-    writeLocalState(updated);
-    return updated;
+    return withStateLock((statePath) => {
+        const current = readLocalStateFromPath(statePath);
+        const updated = updater(current) ?? current;
+        writeLocalStateUnlocked(statePath, updated);
+        return updated;
+    });
 }
 function isExpired(expiresAt) {
     if (!expiresAt) {
@@ -88,6 +150,27 @@ export function clearPendingDeviceAuth() {
         return state;
     });
 }
+export function getStoredAgentIdentity(identityKey) {
+    const state = readLocalState();
+    if (identityKey?.trim()) {
+        const scoped = state.agent_identities?.[identityKey.trim()];
+        if (scoped) {
+            return scoped;
+        }
+    }
+    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 getStoredCurrentRoom() {
     const state = readLocalState();
     return state.current_room ?? null;

package/dist/mcp/room-id.js

@@ -4,6 +4,9 @@ export function encodeRoomIdPath(roomId) {
         .map((segment) => encodeURIComponent(segment))
         .join("/");
 }
+export function getCanonicalRoomWebPath(roomId) {
+    return `/in/${encodeRoomIdPath(roomId)}`;
+}
 export function looksLikeInviteCode(value) {
     return /^[A-Z0-9]{4}(?:-[A-Z0-9]{4})+$/.test(value.trim().toUpperCase());
 }