letagents 0.12.12 → 0.12.13

package/dist/shared/desktop-release.js

@@ -0,0 +1,60 @@
+const MAC_DESKTOP_BETA_VERSION = "0.1.5";
+const MAC_DESKTOP_PUBLIC_BASE_URL = "https://downloads.letagents.chat/desktop";
+function macDesktopAsset(architecture, sha256) {
+    const fileName = `LetAgents-${MAC_DESKTOP_BETA_VERSION}-darwin-${architecture}.dmg`;
+    return {
+        fileName,
+        publicUrl: `${MAC_DESKTOP_PUBLIC_BASE_URL}/v${MAC_DESKTOP_BETA_VERSION}/${fileName}`,
+        sha256,
+    };
+}
+export const MAC_DESKTOP_BETA_RELEASE = {
+    version: MAC_DESKTOP_BETA_VERSION,
+    tag: `desktop-v${MAC_DESKTOP_BETA_VERSION}`,
+    assets: {
+        arm64: macDesktopAsset("arm64", "704355796cee5214a9cfbb79105a035e0e00dc3a3aa57be7d389b97cf35fc804"),
+        x64: macDesktopAsset("x64", "1e4b0b8b2c42ad8eaaf652fc887ab089445c8dd83233d763a6acdaa6617c2471"),
+    },
+};
+export const MAC_DESKTOP_BETA_CHECKSUM_RELEASES = [
+    MAC_DESKTOP_BETA_RELEASE,
+    {
+        version: "0.1.4",
+        assets: {
+            arm64: {
+                fileName: "LetAgents-0.1.4-darwin-arm64.dmg",
+                sha256: "27abe236232d33db10ed4533f4a7443a66f93568e9fa73a2ca472b6467fcf1cb",
+            },
+            x64: {
+                fileName: "LetAgents-0.1.4-darwin-x64.dmg",
+                sha256: "4c807ad0c799b4e46ab81d1098e5b65934d6b0b49f0a99ced2713897e1c2bc35",
+            },
+        },
+    },
+    {
+        version: "0.1.3",
+        assets: {
+            arm64: {
+                fileName: "LetAgents-0.1.3-darwin-arm64.dmg",
+                sha256: "6010454bc7375a38571d707f90c077207a7d2b49b01a1db1655b03f4def9b502",
+            },
+            x64: {
+                fileName: "LetAgents-0.1.3-darwin-x64.dmg",
+                sha256: "b7574e17ef87aebf418926478de10d9937fd1a96ca0c7a53b826a109302c5560",
+            },
+        },
+    },
+    {
+        version: "0.1.2",
+        assets: {
+            arm64: {
+                fileName: "LetAgents-0.1.2-darwin-arm64.dmg",
+                sha256: "e5355deced8383bc7d024ec60b109a38dde69dfeb6b6339352e1f5bc5c53bd43",
+            },
+            x64: {
+                fileName: "LetAgents-0.1.2-darwin-x64.dmg",
+                sha256: "67d2896b806695dae8c0224b3bc2780aee6902e897569c983ecc1bdb0330b6b0",
+            },
+        },
+    },
+];

package/dist/shared/scoped-ids.js

@@ -0,0 +1,6 @@
+import { POSTGRES_INTEGER_MAX, parsePositivePgIntegerScopedId as parseSharedPositivePgIntegerScopedId, } from "../../shared/message-contracts.mjs";
+export { POSTGRES_INTEGER_MAX };
+/** Parse the canonical `<prefix>_<positive PostgreSQL integer>` wire form. */
+export function parsePositivePgIntegerScopedId(value, prefix) {
+    return parseSharedPositivePgIntegerScopedId(value, prefix);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letagents",
-  "version": "0.12.12",
+  "version": "0.12.13",
   "description": "Let Agents Chat — MCP server for AI agent communication",
   "type": "module",
   "main": "dist/mcp/server.js",
@@ -11,6 +11,7 @@
     "dist/mcp/**",
     "dist/api/board-intent-payloads.js",
     "dist/shared/**",
+    "shared/**",
     "README.md"
   ],
   "scripts": {
@@ -24,6 +25,9 @@
     "test:orchestrator": "node --import tsx --test src/orchestrator/__tests__/*.test.ts",
     "test:web": "node --import tsx --test src/web/tests/*.test.ts src/web/src/composables/*.test.ts",
     "test:dependency-age": "node --test scripts/verify-dependency-age.test.mjs",
+    "test:docker-context": "node --test scripts/verify-docker-context.test.mjs",
+    "test:workflow-supply-chain": "node --test scripts/verify-workflow-supply-chain.test.mjs",
+    "test:notifications": "node --import tsx --test src/api/notifications/__tests__/*.test.ts",
     "verify:dependency-age": "node scripts/verify-dependency-age.mjs",
     "db:generate": "drizzle-kit generate",
     "db:migrate": "tsx src/api/migrate.ts",
@@ -31,7 +35,7 @@
     "prepublishOnly": "npm run build",
     "dev:api": "tsx src/api/server.ts",
     "dev:mcp": "tsx src/mcp/server.ts",
-    "dev:desktop": "npm --prefix apps/desktop run dev"
+    "dev:desktop": "node scripts/ensure-desktop-dependencies.mjs && npm --prefix apps/desktop run dev"
   },
   "keywords": [
     "mcp",

package/shared/message-contracts.d.mts

@@ -0,0 +1,32 @@
+export const POSTGRES_INTEGER_MAX: number;
+export const MESSAGE_SENDER_MAX_CODE_POINTS: number;
+export const MESSAGE_SENDER_MAX_UTF8_BYTES: number;
+export function parsePositivePgIntegerScopedId(value: unknown, prefix: string): number | null;
+export function isMessageSenderWithinBounds(sender: unknown): sender is string;
+export type ParsedAccountAgentRouting =
+  | { version: 1; authority: "invalid" }
+  | {
+      version: 1;
+      authority: "receipts";
+      recipientAgentKeys: string[];
+      recipientSessions: Array<{
+        agentKey: string;
+        agentSessionId: string;
+        successorAgentSessionId?: string;
+      }>;
+      controlAuthorized: boolean;
+    }
+  | {
+      version: 1;
+      authority: "legacy";
+      recipientAgentKeys: string[];
+      recipientSessions: Array<{
+        agentKey: string;
+        agentSessionId: string;
+        activationReason: string;
+      }>;
+      controlAuthorized: boolean;
+    };
+export function parseAccountAgentRoutingEnvelope(
+  routing: unknown,
+): ParsedAccountAgentRouting | undefined;

package/shared/message-contracts.mjs

@@ -0,0 +1,109 @@
+import { normalizeRoutingSender } from "./routing-aliases.mjs";
+
+export const POSTGRES_INTEGER_MAX = 2_147_483_647;
+export const MESSAGE_SENDER_MAX_CODE_POINTS = 512;
+export const MESSAGE_SENDER_MAX_UTF8_BYTES = 2_048;
+
+/** Parse the canonical `<prefix>_<positive PostgreSQL integer>` wire form. */
+export function parsePositivePgIntegerScopedId(value, prefix) {
+  if (typeof value !== "string" || typeof prefix !== "string" || !prefix) return null;
+  const marker = `${prefix}_`;
+  if (!value.startsWith(marker)) return null;
+  const decimal = value.slice(marker.length);
+  if (!/^[1-9]\d*$/.test(decimal)) return null;
+  const parsed = Number(decimal);
+  return Number.isSafeInteger(parsed) && parsed <= POSTGRES_INTEGER_MAX ? parsed : null;
+}
+
+/** Bound sender labels before routing projections duplicate their raw value. */
+export function isMessageSenderWithinBounds(sender) {
+  if (typeof sender !== "string") return false;
+  let codePoints = 0;
+  for (const _character of sender) {
+    codePoints += 1;
+    if (codePoints > MESSAGE_SENDER_MAX_CODE_POINTS) return false;
+  }
+  return new TextEncoder().encode(sender).byteLength <= MESSAGE_SENDER_MAX_UTF8_BYTES;
+}
+
+/**
+ * Parse the account-scoped routing envelope shared by Desktop and MCP.
+ * Undefined means an older/local message supplied no authority. Any present
+ * malformed shape returns explicit invalid authority and must never fall back
+ * to mutable display aliases.
+ */
+export function parseAccountAgentRoutingEnvelope(routing) {
+  if (routing === undefined) return undefined;
+  if (!routing || typeof routing !== "object" || routing.version !== 1) {
+    return { version: 1, authority: "invalid" };
+  }
+  if (routing.authority !== "receipts" && routing.authority !== "legacy") {
+    return { version: 1, authority: "invalid" };
+  }
+  if (
+    !Array.isArray(routing.recipient_agent_keys)
+    || !routing.recipient_agent_keys.every((value) => typeof value === "string")
+    || !Array.isArray(routing.recipient_agent_sessions)
+  ) {
+    return { version: 1, authority: "invalid" };
+  }
+  const recipientAgentKeys = routing.recipient_agent_keys.map(normalizeRoutingSender);
+  if (recipientAgentKeys.some((value) => !value)) {
+    return { version: 1, authority: "invalid" };
+  }
+  const uniqueKeys = new Set(recipientAgentKeys);
+  if (uniqueKeys.size !== recipientAgentKeys.length) {
+    return { version: 1, authority: "invalid" };
+  }
+  const targetKeys = new Set();
+  const recipientSessions = [];
+  for (const value of routing.recipient_agent_sessions) {
+    if (!value || typeof value !== "object") {
+      return { version: 1, authority: "invalid" };
+    }
+    const agentKey = typeof value.agent_key === "string"
+      ? normalizeRoutingSender(value.agent_key)
+      : "";
+    const agentSessionId = typeof value.agent_session_id === "string"
+      ? value.agent_session_id.trim()
+      : "";
+    if (!agentKey || !agentSessionId || targetKeys.has(agentKey)) {
+      return { version: 1, authority: "invalid" };
+    }
+    targetKeys.add(agentKey);
+    if (routing.authority === "receipts") {
+      const successorAgentSessionId = value.successor_agent_session_id === undefined
+        ? undefined
+        : typeof value.successor_agent_session_id === "string"
+          ? value.successor_agent_session_id.trim()
+          : "";
+      if (successorAgentSessionId !== undefined && !successorAgentSessionId) {
+        return { version: 1, authority: "invalid" };
+      }
+      recipientSessions.push({
+        agentKey,
+        agentSessionId,
+        ...(successorAgentSessionId ? { successorAgentSessionId } : {}),
+      });
+    } else {
+      const activationReason = typeof value.activation_reason === "string"
+        ? value.activation_reason.trim()
+        : "";
+      if (!activationReason) return { version: 1, authority: "invalid" };
+      recipientSessions.push({ agentKey, agentSessionId, activationReason });
+    }
+  }
+  if (
+    targetKeys.size !== uniqueKeys.size
+    || [...uniqueKeys].some((key) => !targetKeys.has(key))
+  ) {
+    return { version: 1, authority: "invalid" };
+  }
+  return {
+    version: 1,
+    authority: routing.authority,
+    recipientAgentKeys: [...uniqueKeys],
+    recipientSessions,
+    controlAuthorized: routing.control_authorized === true,
+  };
+}

package/shared/routing-aliases.d.mts

@@ -0,0 +1,18 @@
+export type RoutingIdentityLike = {
+  actorLabel?: string | null;
+  actor_label?: string | null;
+  displayName?: string | null;
+  display_name?: string | null;
+  agentKey?: string | null;
+  agent_key?: string | null;
+};
+
+export function normalizeRoutingSender(value: unknown): string;
+export function normalizeRoutingHandle(value: unknown): string;
+export function routingIdentityAliases(identity: RoutingIdentityLike): Set<string>;
+export function routingSenderAliasRows(
+  sender: unknown,
+  segmentLimit?: number,
+): Array<{ alias: string; isFull: boolean }>;
+export function routingSenderAliases(sender: unknown, segmentLimit?: number): Set<string>;
+export function routingAliasHash(alias: string): string;

package/shared/routing-aliases.mjs

@@ -0,0 +1,66 @@
+import { createHash } from "node:crypto";
+
+/**
+ * Stable cross-engine fold: ASCII A-Z only. Unicode case conversion varies by
+ * JS/ICU/PostgreSQL version and locale, so non-ASCII aliases are deliberately
+ * case-sensitive while exact non-ASCII labels still match everywhere.
+ */
+function foldRoutingText(value) {
+  return String(value ?? "").replace(/[A-Z]/g, (character) =>
+    String.fromCharCode(character.charCodeAt(0) + 32));
+}
+
+export function normalizeRoutingSender(value) {
+  return foldRoutingText(typeof value === "string" ? value.trim() : "")
+    .replace(/\s+/g, " ");
+}
+
+export function normalizeRoutingHandle(value) {
+  return foldRoutingText(typeof value === "string" ? value.trim() : "")
+    .replace(/[^a-z0-9_.:/-]+/g, "");
+}
+
+function routingIdentityAliasInputs(identity) {
+  const agentKey = typeof identity?.agentKey === "string"
+    ? identity.agentKey
+    : typeof identity?.agent_key === "string"
+      ? identity.agent_key
+      : "";
+  return Array.from(new Set([
+    identity?.actorLabel ?? identity?.actor_label,
+    identity?.displayName ?? identity?.display_name,
+    agentKey,
+    agentKey.split("/").pop(),
+  ].map((value) => typeof value === "string" ? value.trim() : "").filter(Boolean)));
+}
+
+export function routingIdentityAliases(identity) {
+  const aliases = new Set();
+  for (const value of routingIdentityAliasInputs(identity)) {
+    const senderAlias = normalizeRoutingSender(value);
+    if (senderAlias) aliases.add(senderAlias);
+    const handleAlias = normalizeRoutingHandle(value);
+    if (handleAlias) aliases.add(handleAlias);
+  }
+  return aliases;
+}
+
+export function routingSenderAliasRows(sender, segmentLimit = 16) {
+  const raw = typeof sender === "string" ? sender : "";
+  const fullAlias = normalizeRoutingSender(raw);
+  const byAlias = new Map();
+  if (fullAlias) byAlias.set(fullAlias, true);
+  for (const segment of raw.split("|").slice(0, Math.max(0, segmentLimit))) {
+    const alias = normalizeRoutingSender(segment);
+    if (alias && !byAlias.has(alias)) byAlias.set(alias, false);
+  }
+  return [...byAlias].map(([alias, isFull]) => ({ alias, isFull }));
+}
+
+export function routingSenderAliases(sender, segmentLimit = 16) {
+  return new Set(routingSenderAliasRows(sender, segmentLimit).map(({ alias }) => alias));
+}
+
+export function routingAliasHash(alias) {
+  return createHash("md5").update(alias).digest("hex");
+}

package/shared/sqlite-thread-routing.d.mts

@@ -0,0 +1,72 @@
+import type { RoutingIdentityLike } from "./routing-aliases.mjs";
+
+export type SqliteRoutingDatabase = {
+  exec(sql: string): void;
+  prepare(sql: string): {
+    all(...params: unknown[]): Record<string, unknown>[];
+    get(...params: unknown[]): Record<string, unknown> | undefined;
+    run(...params: unknown[]): unknown;
+  };
+};
+
+export const LOCAL_THREAD_ROUTING_BACKFILL_BATCH_SIZE: number;
+export const LOCAL_THREAD_ROUTING_LOOKUP_BATCH_SIZE: number;
+export const LOCAL_THREAD_ROUTING_BACKFILL_TIME_BUDGET_MS: number;
+export class LocalThreadRoutingProjectionUnavailableError extends Error {}
+export function ensureLocalThreadRoutingProjectionSchema(database: SqliteRoutingDatabase): void;
+export function ensureLocalThreadRoutingProjectionSchemaAsync(
+  database: SqliteRoutingDatabase,
+  options?: { maxWaitMs?: number; random?: () => number },
+): Promise<void>;
+export function runLocalSqliteWriteTransactionAsync<T>(
+  database: SqliteRoutingDatabase,
+  work: () => T,
+  options?: { maxWaitMs?: number; random?: () => number },
+): Promise<T>;
+export function projectLocalThreadRoutingMessage(
+  database: SqliteRoutingDatabase,
+  row: {
+    room_id: string;
+    number: number;
+    thread_root_number?: number | null;
+    reply_to_number?: number | null;
+    sender: string;
+    text?: string;
+    source?: string | null;
+    timestamp?: string;
+    [key: string]: unknown;
+  },
+): void;
+export function runLocalThreadRoutingBackfillBatch(
+  database: SqliteRoutingDatabase,
+  batchSize?: number,
+): { processed: number; completed: boolean };
+export function scheduleLocalThreadRoutingBackfill(
+  database: SqliteRoutingDatabase,
+  options?: {
+    onError?: (error: unknown, delayMs: number | null) => void;
+    setImmediate?: (callback: () => void) => { unref?(): void } | unknown;
+    setTimeout?: (callback: () => void, delayMs: number) => { unref?(): void } | unknown;
+  },
+): void;
+export function scheduleLocalThreadRoutingRootsRepair(
+  database: SqliteRoutingDatabase,
+  roomId: string,
+  rootNumbers: readonly number[],
+): void;
+export function invalidateLocalThreadRoutingRoots(
+  database: SqliteRoutingDatabase,
+  roomId: string,
+  rootNumbers: readonly number[],
+): void;
+export function getLocalThreadRoutingAgentKeysForRoots(
+  database: SqliteRoutingDatabase,
+  roomId: string,
+  rootNumbers: readonly number[],
+  identities: readonly RoutingIdentityLike[],
+  options?: {
+    foregroundTimeBudgetMs?: number;
+    scheduleOnTimeout?: boolean;
+    signal?: AbortSignal;
+  },
+): Promise<Map<number, Set<string>>>;