letagents 0.12.12 → 0.12.13

package/dist/mcp/server/tools/tasks/board-tools.js

@@ -4,6 +4,34 @@ import { createTask, listTasks } from "./api.js";
 import { resolveTaskToolIdentity, resolveTaskToolTarget, taskActorPayload, } from "./context.js";
 import { jsonToolResponse, taskToolError } from "./response.js";
 import { boardIntentApprovalSchema, TASK_STATUSES, workerTaskIdentitySchema } from "./schemas.js";
+export const MAX_BOARD_WORKFLOW_ARTIFACTS_PER_TASK = 4;
+export const MAX_BOARD_WORKFLOW_REFS_PER_TASK = 4;
+function compactBoardWorkflowArtifact(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const artifact = value;
+    // A change-summary detail may itself contain hundreds of files. The board is
+    // an index; callers that need complete artifact detail use get_room_artifacts.
+    return Object.fromEntries(Object.entries(artifact).filter(([key]) => key !== "detail"));
+}
+export function compactTaskForBoard(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const task = value;
+    const artifacts = Array.isArray(task.workflow_artifacts) ? task.workflow_artifacts : [];
+    const refs = Array.isArray(task.workflow_refs) ? task.workflow_refs : [];
+    return {
+        ...task,
+        workflow_artifacts: artifacts
+            .slice(-MAX_BOARD_WORKFLOW_ARTIFACTS_PER_TASK)
+            .map(compactBoardWorkflowArtifact),
+        workflow_refs: refs.slice(-MAX_BOARD_WORKFLOW_REFS_PER_TASK),
+        workflow_artifact_count: artifacts.length,
+        workflow_ref_count: refs.length,
+        workflow_artifacts_truncated: artifacts.length > MAX_BOARD_WORKFLOW_ARTIFACTS_PER_TASK,
+        workflow_refs_truncated: refs.length > MAX_BOARD_WORKFLOW_REFS_PER_TASK,
+    };
+}
 export function registerTaskBoardTools(server) {
     server.tool("add_task", "Add a new task to the room board. Tasks normally start as 'proposed' and must be " +
         "accepted before an agent can claim them. Agent-created tasks require coordinator " +
@@ -59,7 +87,7 @@ export function registerTaskBoardTools(server) {
             const qs = pageParams.toString();
             const result = await listTasks(target, qs);
             const tasks = result.tasks ?? [];
-            allTasks.push(...tasks);
+            allTasks.push(...tasks.map(compactTaskForBoard));
             if (!result.has_more || tasks.length === 0)
                 break;
             const lastTask = tasks[tasks.length - 1];
@@ -68,6 +96,10 @@ export function registerTaskBoardTools(server) {
             afterCursor = lastTask.id;
         }
         await heartbeatRoomPresence(target.effectiveRoomId, await ensureAgentIdentity());
-        return jsonToolResponse({ success: true, tasks: allTasks }, 2);
+        return jsonToolResponse({
+            success: true,
+            tasks: allTasks,
+            artifact_detail_instruction: "Board tasks contain bounded artifact summaries. Use get_room_artifacts for complete workflow artifact detail.",
+        }, 2);
     });
 }

package/dist/mcp/sse-client.js

@@ -1,19 +1,33 @@
 import { encodeRoomIdPath } from "./room-id.js";
+const MAX_SSE_FRAME_BYTES = 1024 * 1024;
+class SseFrameOverflowError extends Error {
+    constructor() {
+        super("SSE frame exceeded bounded size");
+        this.name = "SseFrameOverflowError";
+    }
+}
+class SseFrameMalformedError extends Error {
+    constructor(options) {
+        super("SSE frame was malformed", options);
+        this.name = "SseFrameMalformedError";
+    }
+}
 export class SseClient {
     apiUrl;
     getAccessToken;
     subscriptions = new Map();
+    eventCursors = new Map();
     constructor(apiUrl, getAccessToken) {
         this.apiUrl = apiUrl.replace(/\/$/, "");
         this.getAccessToken = getAccessToken;
     }
-    subscribe(target, onMessage) {
+    subscribe(target, onMessage, onGap) {
         const subscriptionKey = target.roomId;
         if (this.subscriptions.has(subscriptionKey)) {
             return;
         }
         const controller = new AbortController();
-        const promise = this.consumeStream(target, controller.signal, onMessage)
+        const promise = this.consumeStream(target, controller.signal, onMessage, onGap)
             .catch((error) => {
             if (controller.signal.aborted) {
                 return;
@@ -51,17 +65,41 @@ export class SseClient {
             Authorization: `Bearer ${token}`,
         };
     }
-    async consumeStream(target, signal, onMessage) {
-        try {
-            await this.openStream(this.withIncludePromptOnly(this.withAgentIdentityQuery(`${this.apiUrl}/rooms/${encodeRoomIdPath(target.roomId)}/messages/stream`, target)), signal, onMessage);
-            return;
-        }
-        catch (error) {
-            if (!target.projectId || !this.isMissingRouteError(error)) {
-                throw error;
+    async consumeStream(target, signal, onMessage, onGap) {
+        let lastEventId = this.eventCursors.get(target.roomId) ?? null;
+        let useLegacyRoute = false;
+        let retryMs = 1_000;
+        while (!signal.aborted) {
+            const baseUrl = useLegacyRoute && target.projectId
+                ? `${this.apiUrl}/projects/${encodeURIComponent(target.projectId)}/messages/stream`
+                : `${this.apiUrl}/rooms/${encodeRoomIdPath(target.roomId)}/messages/stream`;
+            const url = this.withIncludePromptOnly(this.withAgentIdentityQuery(baseUrl, target));
+            try {
+                lastEventId = await this.openStream(url, signal, target.roomId, lastEventId, onMessage, onGap);
+                retryMs = 1_000;
             }
+            catch (error) {
+                if (signal.aborted)
+                    return;
+                if (error instanceof SseFrameOverflowError || error instanceof SseFrameMalformedError) {
+                    lastEventId = null;
+                }
+                if (this.isMissingRouteError(error)) {
+                    if (!useLegacyRoute && target.projectId) {
+                        useLegacyRoute = true;
+                        continue;
+                    }
+                    // A missing room/route is terminal. Retrying it forever creates
+                    // background traffic and can never heal without a new room join.
+                    throw error;
+                }
+                console.error(`SSE stream disconnected for room ${target.roomId}:`, error);
+            }
+            if (signal.aborted)
+                return;
+            await waitForRetry(signal, retryMs);
+            retryMs = Math.min(Math.ceil(retryMs * 1.5), 30_000);
         }
-        await this.openStream(this.withIncludePromptOnly(this.withAgentIdentityQuery(`${this.apiUrl}/projects/${encodeURIComponent(target.projectId)}/messages/stream`, target)), signal, onMessage);
     }
     withIncludePromptOnly(url) {
         return `${url}${url.includes("?") ? "&" : "?"}include_prompt_only=1`;
@@ -80,9 +118,14 @@ export class SseClient {
         }
         return `${url}${url.includes("?") ? "&" : "?"}${params.toString()}`;
     }
-    async openStream(url, signal, onMessage) {
+    async openStream(url, signal, roomId, lastEventId, onMessage, onGap) {
+        const headers = await this.getHeaders();
+        if (signal.aborted)
+            return lastEventId;
+        if (lastEventId)
+            headers["Last-Event-ID"] = lastEventId;
         const response = await fetch(url, {
-            headers: await this.getHeaders(),
+            headers,
             signal,
         });
         if (!response.ok) {
@@ -94,43 +137,143 @@ export class SseClient {
         const reader = response.body.getReader();
         const decoder = new TextDecoder();
         let buffer = "";
+        let bufferBytes = 0;
         while (!signal.aborted) {
             const { value, done } = await reader.read();
             if (done) {
                 break;
             }
             buffer += decoder.decode(value, { stream: true });
+            bufferBytes += value.byteLength;
+            if (bufferBytes > MAX_SSE_FRAME_BYTES) {
+                // The cursor is no longer safe: an unterminated/oversize frame may
+                // contain an event we could not parse. Force pull-state repair before
+                // reconnecting and never retain attacker-controlled remainder bytes.
+                this.eventCursors.delete(roomId);
+                try {
+                    onGap?.({ room_id: roomId, event_cursor: null, gap: true });
+                }
+                catch (error) {
+                    console.error("SSE gap callback failed:", error);
+                }
+                await reader.cancel("SSE frame exceeded bounded size").catch(() => undefined);
+                throw new SseFrameOverflowError();
+            }
             let boundaryIndex = buffer.indexOf("\n\n");
+            let consumedFrame = false;
             while (boundaryIndex !== -1) {
                 const rawEvent = buffer.slice(0, boundaryIndex);
                 buffer = buffer.slice(boundaryIndex + 2);
-                this.handleEvent(rawEvent, onMessage);
+                try {
+                    lastEventId = this.handleEvent(rawEvent, lastEventId, onMessage, onGap);
+                }
+                catch (error) {
+                    // A complete but malformed typed frame is the same lost-boundary
+                    // condition as an oversized frame. Never reconnect from its cursor
+                    // and replay it forever; force the authorized pull-state repair.
+                    this.eventCursors.delete(roomId);
+                    try {
+                        onGap?.({ room_id: roomId, event_cursor: null, gap: true });
+                    }
+                    catch (gapError) {
+                        console.error("SSE gap callback failed:", gapError);
+                    }
+                    await reader.cancel("SSE frame was malformed").catch(() => undefined);
+                    throw new SseFrameMalformedError({ cause: error });
+                }
+                this.rememberEventCursor(roomId, lastEventId);
+                consumedFrame = true;
                 boundaryIndex = buffer.indexOf("\n\n");
             }
+            if (consumedFrame)
+                bufferBytes = new TextEncoder().encode(buffer).byteLength;
         }
         const trailing = buffer + decoder.decode();
         if (trailing.trim()) {
-            this.handleEvent(trailing, onMessage);
+            try {
+                lastEventId = this.handleEvent(trailing, lastEventId, onMessage, onGap);
+            }
+            catch (error) {
+                this.eventCursors.delete(roomId);
+                try {
+                    onGap?.({ room_id: roomId, event_cursor: null, gap: true });
+                }
+                catch (gapError) {
+                    console.error("SSE gap callback failed:", gapError);
+                }
+                throw new SseFrameMalformedError({ cause: error });
+            }
+            this.rememberEventCursor(roomId, lastEventId);
         }
+        return lastEventId;
     }
-    handleEvent(rawEvent, onMessage) {
+    handleEvent(rawEvent, lastEventId, onMessage, onGap) {
         const normalizedEvent = rawEvent.replace(/\r/g, "");
-        const dataLines = normalizedEvent
-            .split("\n")
+        const lines = normalizedEvent.split("\n");
+        const eventName = lines.find((line) => line.startsWith("event:"))?.slice(6).trim() || "message";
+        const frameId = lines.find((line) => line.startsWith("id:"))?.slice(3).trim() || null;
+        const dataLines = lines
             .filter((line) => line.startsWith("data:"))
             .map((line) => line.slice(5).trimStart());
         if (dataLines.length === 0) {
-            return;
+            return frameId ?? lastEventId;
         }
         // No prompt enrichment here: the only SSE subscriber (room-state.ts) discards
         // the message body, and expanding the room-agent prompt on this background
         // path would consume the once-per-session full-prompt delivery before the
         // agent ever sees it. Prompt expansion happens only on visible tool
         // responses (runtime/messages.ts).
-        onMessage(JSON.parse(dataLines.join("\n")));
+        const payload = JSON.parse(dataLines.join("\n"));
+        if (eventName === "room_sync") {
+            if (payload.gap === true) {
+                try {
+                    onGap?.(payload);
+                }
+                catch (error) {
+                    console.error("SSE gap callback failed:", error);
+                }
+            }
+            if (Object.prototype.hasOwnProperty.call(payload, "event_cursor")) {
+                return typeof payload.event_cursor === "string" ? payload.event_cursor : null;
+            }
+            return frameId ?? lastEventId;
+        }
+        try {
+            onMessage(payload);
+        }
+        catch (error) {
+            console.error("SSE message callback failed:", error);
+        }
+        return frameId ?? lastEventId;
     }
     isMissingRouteError(error) {
         return (error instanceof Error &&
             /status 404|status 405|Cannot (GET|POST|PATCH)/.test(error.message));
     }
+    rememberEventCursor(roomId, cursor) {
+        this.eventCursors.delete(roomId);
+        if (!cursor)
+            return;
+        this.eventCursors.set(roomId, cursor);
+        while (this.eventCursors.size > 32) {
+            const oldestRoomId = this.eventCursors.keys().next().value;
+            if (!oldestRoomId)
+                break;
+            this.eventCursors.delete(oldestRoomId);
+        }
+    }
+}
+function waitForRetry(signal, delayMs) {
+    if (signal.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const timer = setTimeout(finish, delayMs);
+        timer.unref?.();
+        function finish() {
+            signal.removeEventListener("abort", finish);
+            clearTimeout(timer);
+            resolve();
+        }
+        signal.addEventListener("abort", finish, { once: true });
+    });
 }

package/dist/shared/activation-routing.js

@@ -1,3 +1,13 @@
+import { normalizeRoutingHandle, normalizeRoutingSender, routingIdentityAliases, routingSenderAliasRows, routingSenderAliases, } from "../../shared/routing-aliases.mjs";
+import { parsePositivePgIntegerScopedId } from "./scoped-ids.js";
+/**
+ * Repository events can contain text written by any external contributor.
+ * They remain visible room activity, but their text is never an instruction
+ * channel for a managed local worker.
+ */
+export function isUntrustedExternalActivationSource(source) {
+    return normalizeSender(source) === "github";
+}
 const NON_AGENT_AT_HANDLES = new Set([
     "charset",
     "container",
@@ -47,8 +57,8 @@ export function attachAgentMessageActivationsFromReceipts(messages, identity, re
     }
     return messages.map((message) => {
         const msgIdStr = String(message.id ?? "");
-        const msgNum = parseInt(msgIdStr.replace(/^msg_/, ""), 10);
-        const receipt = !isNaN(msgNum) ? receiptsMap.get(msgNum) || receiptsMap.get(msgIdStr) : null;
+        const msgNum = parsePositivePgIntegerScopedId(msgIdStr, "msg");
+        const receipt = msgNum !== null ? receiptsMap.get(msgNum) || receiptsMap.get(msgIdStr) : null;
         if (receipt) {
             const reason = receipt.activation_reason;
             return {
@@ -62,7 +72,11 @@ export function attachAgentMessageActivationsFromReceipts(messages, identity, re
                 },
             };
         }
-        if (!isNaN(msgNum) && snapshotNumbers.has(msgNum)) {
+        // System failure rows are canonical silent control events. A routing
+        // snapshot with no receipt must not erase their diagnostic reason.
+        if (msgNum !== null
+            && snapshotNumbers.has(msgNum)
+            && normalizeSender(message.source) !== "managed_agent_failure") {
             return {
                 ...message,
                 activation: {
@@ -84,17 +98,27 @@ export function attachAgentMessageActivations(messages, identity, context = {})
     return messages.map((message) => attachAgentMessageActivation(message, identity, context));
 }
 export function decideAgentMessageActivation(message, identity, context = {}) {
-    if (normalizeSender(message.source) === "managed_agent_failure") {
+    if (normalizeSender(message.source) === "managed_agent_failure"
+        || isUntrustedExternalActivationSource(message.source)) {
         return decision("silent", "system_event");
     }
-    if (senderMatchesIdentity(message.sender, identity)) {
+    const messageId = normalizedString(message.id);
+    const authoritativeLegacyDecision = context.authoritativeLegacyDecisions?.get(messageId);
+    if (authoritativeLegacyDecision)
+        return authoritativeLegacyDecision;
+    if (context.selfMessageIds !== undefined
+        ? context.selfMessageIds.has(messageId)
+        : senderMatchesIdentity(message.sender, identity)) {
         return decision("silent", "self_message");
     }
     const mentions = extractMentionHandles(message.text);
     if (mentions.some(isBroadcastHandle)) {
         return decision("activate", "broadcast");
     }
-    if (mentions.some((mention) => identityAliases(identity).has(normalizeMentionIdentityHandle(mention)))) {
+    const authoritativeExplicitMentions = context.explicitMentionMessageIds;
+    if (authoritativeExplicitMentions !== undefined
+        ? authoritativeExplicitMentions.has(messageId)
+        : mentions.some((mention) => activationIdentityAliases(identity).has(normalizeMentionIdentityHandle(mention)))) {
         return decision("activate", "explicit_mention");
     }
     if (hasBroadcastAddress(message.text)) {
@@ -103,13 +127,22 @@ export function decideAgentMessageActivation(message, identity, context = {}) {
     if (mentions.some(isLikelyAgentMentionHandle)) {
         return decision("silent", "explicit_other_mention");
     }
-    if (senderMatchesIdentity(message.reply_to?.sender, identity)) {
+    const authoritativeThreadParticipantRootIds = context.threadParticipantRootIds;
+    const authoritativeReplyTargets = context.replyTargetMessageIds;
+    const hasAuthoritativeThreadMembership = isThreadReply(message)
+        && authoritativeThreadParticipantRootIds !== undefined;
+    if (authoritativeReplyTargets !== undefined
+        ? authoritativeReplyTargets.has(messageId)
+        : !hasAuthoritativeThreadMembership && senderMatchesIdentity(message.reply_to?.sender, identity)) {
         return decision("activate", "reply_target");
     }
     if (isAgentReplyTarget(message.reply_to) && !isThreadReply(message)) {
         return decision("silent", "other_reply_target");
     }
-    if (isThreadReply(message) && threadParticipantsIncludeIdentity(message, identity)) {
+    if (isThreadReply(message)
+        && (hasAuthoritativeThreadMembership
+            ? authoritativeThreadParticipantRootIds.has(threadRootId(message))
+            : threadParticipantsIncludeIdentity(message, identity))) {
         return decision("activate", "thread_participant");
     }
     const taskOwnerDecision = decideTaskOwnerActivation(message, identity, context);
@@ -127,9 +160,12 @@ function decision(decisionValue, reason) {
 }
 function isThreadReply(message) {
     const ownId = normalizedString(message.id);
-    const rootId = normalizedString(message.thread_root_id) || normalizedString(message.thread?.root_message_id);
+    const rootId = threadRootId(message);
     return Boolean(ownId && rootId && ownId !== rootId);
 }
+function threadRootId(message) {
+    return normalizedString(message.thread_root_id) || normalizedString(message.thread?.root_message_id);
+}
 function isAgentReplyTarget(replyTo) {
     return normalizeSender(replyTo?.source) === "agent";
 }
@@ -248,24 +284,111 @@ function senderMatchesIdentity(sender, identity) {
     const normalizedSender = normalizeSender(sender);
     if (!normalizedSender)
         return false;
-    const aliases = identityAliases(identity);
+    const aliases = activationIdentityAliases(identity);
     if (aliases.has(normalizedSender))
         return true;
     return String(sender || "")
         .split("|")
         .some((part) => aliases.has(normalizeSender(part)));
 }
-function identityAliases(identity) {
-    const aliases = new Set();
-    const values = [
-        identity.actor_label,
-        identity.display_name,
-        identity.agent_key,
-        identity.agent_key.split("/").pop(),
-    ];
-    for (const alias of aliasesForValues(values))
-        aliases.add(alias);
-    return aliases;
+export function activationIdentityAliases(identity) {
+    return routingIdentityAliases(identity);
+}
+/** Canonical aliases materialized from a historical message sender. */
+export function activationSenderAliases(sender, segmentLimit = 16) {
+    return routingSenderAliases(sender, segmentLimit);
+}
+/**
+ * Resolve identity-bearing addresses against the complete active room
+ * population. A display alias is authority only when it names one durable
+ * agent key globally; account/provider filtering happens after this step.
+ * Full historical sender labels take precedence over their pipe-delimited
+ * compatibility segments.
+ */
+export function resolveGloballyAddressedAgentKeys(message, identities) {
+    return createGlobalAgentAddressResolver(identities)(message);
+}
+/**
+ * Build the room-wide alias authority once, then resolve a page of legacy
+ * messages without rebuilding every active worker alias set per message.
+ */
+export function createGlobalAgentAddressResolver(identities) {
+    const keysByAlias = new Map();
+    for (const identity of identities) {
+        const key = normalizedString(identity.agent_key);
+        if (!key)
+            continue;
+        for (const alias of activationIdentityAliases(identity)) {
+            const keys = keysByAlias.get(alias) ?? new Set();
+            keys.add(key);
+            keysByAlias.set(alias, keys);
+        }
+    }
+    return (message) => {
+        const mentions = extractMentionHandles(message.text);
+        const broadcast = mentions.some(isBroadcastHandle) || hasBroadcastAddress(message.text);
+        const hasMention = mentions.some((mention) => !isBroadcastHandle(mention));
+        const hasAgentMention = mentions.some(isLikelyAgentMentionHandle);
+        const explicitMentionKeys = new Set();
+        for (const mention of mentions) {
+            if (isBroadcastHandle(mention))
+                continue;
+            const alias = normalizeMentionIdentityHandle(mention);
+            if (!alias)
+                continue;
+            const keys = keysByAlias.get(alias);
+            if (keys?.size === 1)
+                explicitMentionKeys.add(keys.values().next().value);
+        }
+        const replyTargetKeys = new Set();
+        const replyAliases = normalizedString(message.reply_to?.source) === "agent"
+            ? routingSenderAliasRows(message.reply_to?.sender)
+            : [];
+        const matchingKeys = (full) => {
+            const keys = new Set();
+            for (const row of replyAliases) {
+                if (row.isFull !== full)
+                    continue;
+                for (const key of keysByAlias.get(row.alias) ?? [])
+                    keys.add(key);
+            }
+            return keys;
+        };
+        const fullMatches = matchingKeys(true);
+        const replyMatches = fullMatches.size > 0 ? fullMatches : matchingKeys(false);
+        if (replyMatches.size === 1)
+            replyTargetKeys.add(replyMatches.values().next().value);
+        const senderKeys = new Set();
+        const senderAliases = routingSenderAliasRows(message.sender);
+        const senderMatchingKeys = (full) => {
+            const keys = new Set();
+            for (const row of senderAliases) {
+                if (row.isFull !== full)
+                    continue;
+                for (const key of keysByAlias.get(row.alias) ?? [])
+                    keys.add(key);
+            }
+            return keys;
+        };
+        const senderFullMatches = senderMatchingKeys(true);
+        const senderMatches = senderFullMatches.size > 0
+            ? senderFullMatches
+            : senderMatchingKeys(false);
+        if (senderMatches.size === 1)
+            senderKeys.add(senderMatches.values().next().value);
+        return {
+            broadcast,
+            hasMention,
+            hasAgentMention,
+            explicitMentionKeys,
+            replyTargetKeys,
+            senderKeys,
+        };
+    };
+}
+/** Shared legacy task-follow-up classifier used by API and desktop overlays. */
+export function isTaskOwnerFollowUpMessageText(text) {
+    return isTaskOwnerFollowUp(text);
 }
 function extractMentionHandles(text) {
     const raw = typeof text === "string" ? text : "";
@@ -305,10 +428,10 @@ function normalizedString(value) {
     return typeof value === "string" ? value.trim() : "";
 }
 function normalizeSender(value) {
-    return normalizedString(value).toLowerCase().replace(/\s+/g, " ");
+    return normalizeRoutingSender(value);
 }
 function normalizeHandle(value) {
-    return normalizedString(value).toLowerCase().replace(/[^a-z0-9_.:/-]+/g, "");
+    return normalizeRoutingHandle(value);
 }
 function normalizeMentionIdentityHandle(value) {
     const normalized = normalizeHandle(value);

package/dist/shared/agent-presence.js

@@ -21,6 +21,12 @@ export const ROOM_AGENT_SESSION_KINDS = [
     "controller",
     "worker",
 ];
+export function isRoomAgentDeliveryCredentialExpired(fence, now = Date.now()) {
+    if (fence?.kind !== "bearer" || !fence.expires_at)
+        return false;
+    const expiresAt = Date.parse(fence.expires_at);
+    return Number.isFinite(expiresAt) && expiresAt <= now;
+}
 export function normalizeRoomAgentSessionKind(value) {
     return String(value || "").trim().toLowerCase() === "worker" ? "worker" : "controller";
 }

package/dist/shared/desktop-release-manifest.js

@@ -0,0 +1,63 @@
+export const MAC_DESKTOP_PUBLIC_BASE_URL = "https://downloads.letagents.chat";
+function record(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${label} must be an object.`);
+    }
+    return value;
+}
+function numericVersion(value) {
+    if (!/^\d+\.\d+\.\d+$/.test(value)) {
+        throw new Error("Desktop release manifest version must be numeric x.y.z.");
+    }
+    return value.split(".").map(Number);
+}
+function compareVersions(left, right) {
+    const leftParts = numericVersion(left);
+    const rightParts = numericVersion(right);
+    for (let index = 0; index < leftParts.length; index += 1) {
+        if (leftParts[index] !== rightParts[index])
+            return leftParts[index] - rightParts[index];
+    }
+    return 0;
+}
+export function parseMacDesktopPublicReleaseManifest(value, minimumVersion) {
+    const manifest = record(value, "Desktop release manifest");
+    const version = manifest.version;
+    if (manifest.schemaVersion !== 1 || manifest.channel !== "beta") {
+        throw new Error("Desktop release manifest has an unsupported contract.");
+    }
+    if (typeof version !== "string") {
+        throw new Error("Desktop release manifest version must be numeric x.y.z.");
+    }
+    numericVersion(version);
+    if (compareVersions(version, minimumVersion) < 0) {
+        throw new Error(`Desktop release manifest ${version} is older than ${minimumVersion}.`);
+    }
+    const rawAssets = record(manifest.assets, "Desktop release assets");
+    const checksumsUrl = `${MAC_DESKTOP_PUBLIC_BASE_URL}/desktop/v${version}/checksums.txt`;
+    if (manifest.checksumsUrl !== checksumsUrl) {
+        throw new Error("Desktop release manifest does not use the immutable public checksum URL.");
+    }
+    const assets = {};
+    for (const architecture of ["arm64", "x64"]) {
+        const rawAsset = record(rawAssets[architecture], `${architecture} desktop release asset`);
+        const fileName = `LetAgents-${version}-darwin-${architecture}.dmg`;
+        const publicUrl = `${MAC_DESKTOP_PUBLIC_BASE_URL}/desktop/v${version}/${fileName}`;
+        if (rawAsset.fileName !== fileName || rawAsset.publicUrl !== publicUrl) {
+            throw new Error(`${architecture} desktop release asset does not use the immutable public URL.`);
+        }
+        if (!Number.isSafeInteger(rawAsset.bytes) || Number(rawAsset.bytes) <= 0) {
+            throw new Error(`${architecture} desktop release asset must have a positive byte size.`);
+        }
+        if (typeof rawAsset.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(rawAsset.sha256)) {
+            throw new Error(`${architecture} desktop release asset must have a lowercase SHA-256 digest.`);
+        }
+        assets[architecture] = {
+            fileName,
+            publicUrl,
+            bytes: Number(rawAsset.bytes),
+            sha256: rawAsset.sha256,
+        };
+    }
+    return { schemaVersion: 1, channel: "beta", version, checksumsUrl, assets };
+}