@superblocksteam/gateway 2.0.155-next.0

package/dist/resume/memory-progress-store.js

@@ -0,0 +1,82 @@
+import { cursorKey, lastActivityKey, liveEditKey } from "./progress-key.js";
+import { DEFAULT_LIVE_EDIT_POINTER_TTL_MS, DEFAULT_PROGRESS_CURSOR_TTL_MS, } from "./types.js";
+/**
+ * Cap on how many cursors and pointers a single process will hold.
+ *
+ * Redis expires keys on its own; a plain Map does not, and a gateway that ran
+ * for a week would hold one entry per (caller, application) it had ever
+ * served. Insertion order is iteration order for a Map, so the oldest write
+ * is the one dropped — a caller evicted this way re-reads the retained
+ * history rather than losing anything, which is the same outcome as its
+ * cursor having expired.
+ */
+export const MAX_MEMORY_PROGRESS_ENTRIES = 2_048;
+/**
+ * Local-only fallback, matching the other in-memory stores.
+ *
+ * Not a second source of truth: two replicas with private maps would hand the
+ * same caller two different positions in the same stream, which is exactly
+ * the divergence Redis is required outside local to prevent.
+ */
+export class MemoryProgressStore {
+    cursors = new Map();
+    lastActivity = new Map();
+    liveEdits = new Map();
+    async getCursor(key) {
+        return read(this.cursors, cursorKey(key));
+    }
+    async getLastActivityAtMs(key) {
+        return read(this.lastActivity, lastActivityKey(key));
+    }
+    async getLiveEditId(key) {
+        return read(this.liveEdits, liveEditKey(key));
+    }
+    async setCursor(input) {
+        write(this.cursors, cursorKey(input), input.record, {
+            ttlMs: input.ttlMs ?? DEFAULT_PROGRESS_CURSOR_TTL_MS,
+        });
+    }
+    async setLastActivityAtMs(input) {
+        // Same retention as a cursor: past that, there is no history left to
+        // measure a quiet spell against anyway.
+        write(this.lastActivity, lastActivityKey(input), input.atMs, {
+            ttlMs: input.ttlMs ?? DEFAULT_PROGRESS_CURSOR_TTL_MS,
+        });
+    }
+    async setLiveEditId(input) {
+        write(this.liveEdits, liveEditKey(input), input.liveEditId, {
+            ttlMs: input.ttlMs ?? DEFAULT_LIVE_EDIT_POINTER_TTL_MS,
+        });
+    }
+}
+function read(entries, key) {
+    const entry = entries.get(key);
+    if (!entry) {
+        return undefined;
+    }
+    if (entry.expiresAtMs <= Date.now()) {
+        entries.delete(key);
+        return undefined;
+    }
+    return entry.value;
+}
+function write(entries, key, value, options) {
+    const now = Date.now();
+    for (const [candidate, entry] of entries) {
+        if (entry.expiresAtMs <= now) {
+            entries.delete(candidate);
+        }
+    }
+    // Re-inserting moves the key to the end, so a cursor being written is never
+    // the next one evicted.
+    entries.delete(key);
+    entries.set(key, { expiresAtMs: now + options.ttlMs, value });
+    while (entries.size > MAX_MEMORY_PROGRESS_ENTRIES) {
+        const oldest = entries.keys().next();
+        if (oldest.done) {
+            return;
+        }
+        entries.delete(oldest.value);
+    }
+}
+//# sourceMappingURL=memory-progress-store.js.map

package/dist/resume/memory-progress-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-progress-store.js","sourceRoot":"","sources":["../../src/resume/memory-progress-store.ts"],"names":[],"mappings":"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"}

package/dist/resume/memory-recent-app-store.d.ts

@@ -0,0 +1,14 @@
+import { type RecentApp, type RecentAppStore } from "./types.js";
+export declare class MemoryRecentAppStore implements RecentAppStore {
+    private readonly byPrincipal;
+    get(input: {
+        organizationId: string;
+        userId: string;
+    }): Promise<RecentApp | undefined>;
+    set(input: {
+        applicationId: string;
+        organizationId: string;
+        ttlMs?: number;
+        userId: string;
+    }): Promise<void>;
+}

package/dist/resume/memory-recent-app-store.js

@@ -0,0 +1,27 @@
+import { DEFAULT_RECENT_APP_TTL_MS, } from "./types.js";
+function principalKey(organizationId, userId) {
+    return `${organizationId}:${userId}`;
+}
+export class MemoryRecentAppStore {
+    byPrincipal = new Map();
+    async get(input) {
+        const key = principalKey(input.organizationId, input.userId);
+        const entry = this.byPrincipal.get(key);
+        if (!entry) {
+            return undefined;
+        }
+        if (entry.expiresAtMs <= Date.now()) {
+            this.byPrincipal.delete(key);
+            return undefined;
+        }
+        return { applicationId: entry.applicationId };
+    }
+    async set(input) {
+        const ttlMs = input.ttlMs ?? DEFAULT_RECENT_APP_TTL_MS;
+        this.byPrincipal.set(principalKey(input.organizationId, input.userId), {
+            applicationId: input.applicationId,
+            expiresAtMs: Date.now() + ttlMs,
+        });
+    }
+}
+//# sourceMappingURL=memory-recent-app-store.js.map

package/dist/resume/memory-recent-app-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-recent-app-store.js","sourceRoot":"","sources":["../../src/resume/memory-recent-app-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,yBAAyB,GAC1B,MAAM,YAAY,CAAC;AAOpB,SAAS,YAAY,CAAC,cAAsB,EAAE,MAAc;IAC1D,OAAO,GAAG,cAAc,IAAI,MAAM,EAAE,CAAC;AACvC,CAAC;AAED,MAAM,OAAO,oBAAoB;IACd,WAAW,GAAG,IAAI,GAAG,EAAgC,CAAC;IAEvE,KAAK,CAAC,GAAG,CAAC,KAGT;QACC,MAAM,GAAG,GAAG,YAAY,CAAC,KAAK,CAAC,cAAc,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QAC7D,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACxC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,IAAI,KAAK,CAAC,WAAW,IAAI,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;YACpC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAC7B,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,OAAO,EAAE,aAAa,EAAE,KAAK,CAAC,aAAa,EAAE,CAAC;IAChD,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,KAKT;QACC,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,IAAI,yBAAyB,CAAC;QACvD,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,YAAY,CAAC,KAAK,CAAC,cAAc,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE;YACrE,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,WAAW,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK;SAChC,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/resume/memory-turn-store.d.ts

@@ -0,0 +1,18 @@
+import { type SuspendedTurn, type TurnStore } from "./types.js";
+export declare class MemoryTurnStore implements TurnStore {
+    private readonly byId;
+    private readonly byIdempotency;
+    create(input: {
+        authUrl: string;
+        callbackToken?: string;
+        idempotencyKey: string;
+        reason: SuspendedTurn["reason"];
+        ttlMs?: number;
+        turnId?: string;
+    }): Promise<SuspendedTurn>;
+    get(turnId: string): Promise<SuspendedTurn | undefined>;
+    getByIdempotencyKey(idempotencyKey: string): Promise<SuspendedTurn | undefined>;
+    complete(turnId: string, callbackToken: string): Promise<SuspendedTurn | undefined>;
+}
+/** Stable Redis-safe segment for caller-controlled idempotency keys. */
+export declare function hashIdempotencyKey(idempotencyKey: string): string;

package/dist/resume/memory-turn-store.js

@@ -0,0 +1,73 @@
+import { createHash, randomUUID } from "node:crypto";
+import { constantTimeEquals } from "../security/constant-time.js";
+import { DEFAULT_TURN_TTL_MS, } from "./types.js";
+export class MemoryTurnStore {
+    byId = new Map();
+    byIdempotency = new Map();
+    async create(input) {
+        const existingId = this.byIdempotency.get(input.idempotencyKey);
+        if (existingId) {
+            const existing = await this.get(existingId);
+            if (existing && existing.status !== "expired") {
+                return existing;
+            }
+        }
+        const ttlMs = input.ttlMs ?? DEFAULT_TURN_TTL_MS;
+        const now = Date.now();
+        const turn = {
+            authUrl: input.authUrl,
+            callbackToken: input.callbackToken ?? randomUUID(),
+            createdAtMs: now,
+            idempotencyKey: input.idempotencyKey,
+            reason: input.reason,
+            status: "pending",
+            turnId: input.turnId ?? randomUUID(),
+        };
+        this.byId.set(turn.turnId, { expiresAtMs: now + ttlMs, turn });
+        this.byIdempotency.set(input.idempotencyKey, turn.turnId);
+        return turn;
+    }
+    async get(turnId) {
+        const entry = this.byId.get(turnId);
+        if (!entry) {
+            return undefined;
+        }
+        if (Date.now() >= entry.expiresAtMs) {
+            this.byId.delete(turnId);
+            this.byIdempotency.delete(entry.turn.idempotencyKey);
+            return { ...entry.turn, status: "expired" };
+        }
+        return entry.turn;
+    }
+    async getByIdempotencyKey(idempotencyKey) {
+        const turnId = this.byIdempotency.get(idempotencyKey);
+        if (!turnId) {
+            return undefined;
+        }
+        return this.get(turnId);
+    }
+    async complete(turnId, callbackToken) {
+        const entry = this.byId.get(turnId);
+        if (!entry) {
+            return undefined;
+        }
+        if (Date.now() >= entry.expiresAtMs) {
+            this.byId.delete(turnId);
+            this.byIdempotency.delete(entry.turn.idempotencyKey);
+            return { ...entry.turn, status: "expired" };
+        }
+        if (!constantTimeEquals(entry.turn.callbackToken, callbackToken)) {
+            return undefined;
+        }
+        if (entry.turn.status === "expired") {
+            return entry.turn;
+        }
+        entry.turn = { ...entry.turn, status: "ready" };
+        return entry.turn;
+    }
+}
+/** Stable Redis-safe segment for caller-controlled idempotency keys. */
+export function hashIdempotencyKey(idempotencyKey) {
+    return createHash("sha256").update(idempotencyKey).digest("hex");
+}
+//# sourceMappingURL=memory-turn-store.js.map

package/dist/resume/memory-turn-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-turn-store.js","sourceRoot":"","sources":["../../src/resume/memory-turn-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAErD,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAGL,mBAAmB,GACpB,MAAM,YAAY,CAAC;AAOpB,MAAM,OAAO,eAAe;IACT,IAAI,GAAG,IAAI,GAAG,EAAuB,CAAC;IACtC,aAAa,GAAG,IAAI,GAAG,EAAkB,CAAC;IAE3D,KAAK,CAAC,MAAM,CAAC,KAOZ;QACC,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;QAChE,IAAI,UAAU,EAAE,CAAC;YACf,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;YAC5C,IAAI,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;gBAC9C,OAAO,QAAQ,CAAC;YAClB,CAAC;QACH,CAAC;QAED,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,IAAI,mBAAmB,CAAC;QACjD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,MAAM,IAAI,GAAkB;YAC1B,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,aAAa,EAAE,KAAK,CAAC,aAAa,IAAI,UAAU,EAAE;YAClD,WAAW,EAAE,GAAG;YAChB,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,MAAM,EAAE,SAAS;YACjB,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,UAAU,EAAE;SACrC,CAAC;QACF,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,WAAW,EAAE,GAAG,GAAG,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QAC/D,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,cAAc,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QAC1D,OAAO,IAAI,CAAC;IACd,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,MAAc;QACtB,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACpC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;YACpC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YACzB,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YACrD,OAAO,EAAE,GAAG,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;QAC9C,CAAC;QACD,OAAO,KAAK,CAAC,IAAI,CAAC;IACpB,CAAC;IAED,KAAK,CAAC,mBAAmB,CACvB,cAAsB;QAEtB,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QACtD,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;IAED,KAAK,CAAC,QAAQ,CACZ,MAAc,EACd,aAAqB;QAErB,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACpC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;YACpC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YACzB,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YACrD,OAAO,EAAE,GAAG,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;QAC9C,CAAC;QACD,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,IAAI,CAAC,aAAa,EAAE,aAAa,CAAC,EAAE,CAAC;YACjE,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YACpC,OAAO,KAAK,CAAC,IAAI,CAAC;QACpB,CAAC;QACD,KAAK,CAAC,IAAI,GAAG,EAAE,GAAG,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;QAChD,OAAO,KAAK,CAAC,IAAI,CAAC;IACpB,CAAC;CACF;AAED,wEAAwE;AACxE,MAAM,UAAU,kBAAkB,CAAC,cAAsB;IACvD,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AACnE,CAAC"}

package/dist/resume/progress-key.d.ts

@@ -0,0 +1,21 @@
+import type { AppScopeKey, ProgressCursorKey } from "./types.js";
+export declare const CURSOR_KEY_PREFIX = "gateway:progress:cursor:";
+export declare const LAST_ACTIVITY_KEY_PREFIX = "gateway:progress:last-activity:";
+export declare const LIVE_EDIT_KEY_PREFIX = "gateway:progress:live-edit:";
+/**
+ * One caller's cursor for one application.
+ *
+ * The channel stays in the clear: it is one of three constant strings, it
+ * cannot identify anybody, and being able to tell an MCP cursor from a Slack
+ * one by looking at a key is worth more than the nothing it discloses.
+ */
+export declare function cursorKey(key: ProgressCursorKey): string;
+/**
+ * When an application's build last said anything.
+ *
+ * App-scoped rather than per-caller: whether a build has gone quiet is a fact
+ * about the build, and keying it by reader would let two callers disagree
+ * about the same turn at the same instant.
+ */
+export declare function lastActivityKey(key: AppScopeKey): string;
+export declare function liveEditKey(key: AppScopeKey): string;

package/dist/resume/progress-key.js

@@ -0,0 +1,58 @@
+import { createHash } from "node:crypto";
+export const CURSOR_KEY_PREFIX = "gateway:progress:cursor:";
+export const LAST_ACTIVITY_KEY_PREFIX = "gateway:progress:last-activity:";
+export const LIVE_EDIT_KEY_PREFIX = "gateway:progress:live-edit:";
+/**
+ * Collapses the identifying parts of a key to a fixed-width digest.
+ *
+ * Two things at once. It bounds the key: organization, application and caller
+ * identifiers are all caller-influenced and none has a length limit here, so
+ * a raw key would be as long as whatever was sent. And it keeps the caller's
+ * identity out of storage — a Slack user id or an OAuth subject in a Redis
+ * key is a record of who used the product, readable by anyone who can list
+ * keys, for a value that only ever needs to be compared for equality.
+ */
+function digest(parts) {
+    const hash = createHash("sha256");
+    for (const part of parts) {
+        // Length-prefixed for the same reason the event stream keys are: the
+        // parts come from claims and command bodies, so no separator is safe to
+        // assume absent, and `a|b` + `c` must not address `a` + `b|c`.
+        hash.update(`${part.length}:${part}`);
+    }
+    return hash.digest("hex");
+}
+/**
+ * One caller's cursor for one application.
+ *
+ * The channel stays in the clear: it is one of three constant strings, it
+ * cannot identify anybody, and being able to tell an MCP cursor from a Slack
+ * one by looking at a key is worth more than the nothing it discloses.
+ */
+export function cursorKey(key) {
+    return `${CURSOR_KEY_PREFIX}${key.caller.channel}:${digest([
+        key.organizationId,
+        key.applicationId,
+        key.caller.id,
+    ])}`;
+}
+/**
+ * When an application's build last said anything.
+ *
+ * App-scoped rather than per-caller: whether a build has gone quiet is a fact
+ * about the build, and keying it by reader would let two callers disagree
+ * about the same turn at the same instant.
+ */
+export function lastActivityKey(key) {
+    return `${LAST_ACTIVITY_KEY_PREFIX}${digest([
+        key.organizationId,
+        key.applicationId,
+    ])}`;
+}
+export function liveEditKey(key) {
+    return `${LIVE_EDIT_KEY_PREFIX}${digest([
+        key.organizationId,
+        key.applicationId,
+    ])}`;
+}
+//# sourceMappingURL=progress-key.js.map

package/dist/resume/progress-key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress-key.js","sourceRoot":"","sources":["../../src/resume/progress-key.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAIzC,MAAM,CAAC,MAAM,iBAAiB,GAAG,0BAA0B,CAAC;AAC5D,MAAM,CAAC,MAAM,wBAAwB,GAAG,iCAAiC,CAAC;AAC1E,MAAM,CAAC,MAAM,oBAAoB,GAAG,6BAA6B,CAAC;AAElE;;;;;;;;;GASG;AACH,SAAS,MAAM,CAAC,KAAwB;IACtC,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;IAClC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,qEAAqE;QACrE,wEAAwE;QACxE,+DAA+D;QAC/D,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,IAAI,IAAI,EAAE,CAAC,CAAC;IACxC,CAAC;IACD,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC5B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAAC,GAAsB;IAC9C,OAAO,GAAG,iBAAiB,GAAG,GAAG,CAAC,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC;QACzD,GAAG,CAAC,cAAc;QAClB,GAAG,CAAC,aAAa;QACjB,GAAG,CAAC,MAAM,CAAC,EAAE;KACd,CAAC,EAAE,CAAC;AACP,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,GAAgB;IAC9C,OAAO,GAAG,wBAAwB,GAAG,MAAM,CAAC;QAC1C,GAAG,CAAC,cAAc;QAClB,GAAG,CAAC,aAAa;KAClB,CAAC,EAAE,CAAC;AACP,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,GAAgB;IAC1C,OAAO,GAAG,oBAAoB,GAAG,MAAM,CAAC;QACtC,GAAG,CAAC,cAAc;QAClB,GAAG,CAAC,aAAa;KAClB,CAAC,EAAE,CAAC;AACP,CAAC"}

package/dist/resume/stores.d.ts

@@ -0,0 +1,14 @@
+import type { EventStore } from "../events/types.js";
+import type { ProgressStore, RecentAppStore, TurnStore } from "./types.js";
+export type Stores = {
+    close: () => Promise<void>;
+    events: EventStore;
+    progressCursors: ProgressStore;
+    recentApps: RecentAppStore;
+    turns: TurnStore;
+};
+/**
+ * In-process stores for the local-agent gateway. Suspended turns and progress
+ * cursors do not survive a restart.
+ */
+export declare function createStores(): Promise<Stores>;

package/dist/resume/stores.js

@@ -0,0 +1,18 @@
+import { MemoryEventStore } from "../events/memory-event-store.js";
+import { MemoryProgressStore } from "./memory-progress-store.js";
+import { MemoryRecentAppStore } from "./memory-recent-app-store.js";
+import { MemoryTurnStore } from "./memory-turn-store.js";
+/**
+ * In-process stores for the local-agent gateway. Suspended turns and progress
+ * cursors do not survive a restart.
+ */
+export async function createStores() {
+    return {
+        close: async () => undefined,
+        events: new MemoryEventStore(),
+        progressCursors: new MemoryProgressStore(),
+        recentApps: new MemoryRecentAppStore(),
+        turns: new MemoryTurnStore(),
+    };
+}
+//# sourceMappingURL=stores.js.map

package/dist/resume/stores.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stores.js","sourceRoot":"","sources":["../../src/resume/stores.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAEnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAWzD;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY;IAChC,OAAO;QACL,KAAK,EAAE,KAAK,IAAI,EAAE,CAAC,SAAS;QAC5B,MAAM,EAAE,IAAI,gBAAgB,EAAE;QAC9B,eAAe,EAAE,IAAI,mBAAmB,EAAE;QAC1C,UAAU,EAAE,IAAI,oBAAoB,EAAE;QACtC,KAAK,EAAE,IAAI,eAAe,EAAE;KAC7B,CAAC;AACJ,CAAC"}

package/dist/resume/types.d.ts

@@ -0,0 +1,124 @@
+import type { EventCursor } from "../events/cursor.js";
+export type TurnStatus = "pending" | "ready" | "expired";
+export type SuspendedTurn = {
+    authUrl: string;
+    callbackToken: string;
+    createdAtMs: number;
+    idempotencyKey: string;
+    reason: "idp_step_up";
+    status: TurnStatus;
+    turnId: string;
+};
+export type TurnStore = {
+    complete(turnId: string, callbackToken: string): Promise<SuspendedTurn | undefined>;
+    create(input: {
+        authUrl: string;
+        callbackToken?: string;
+        idempotencyKey: string;
+        reason: SuspendedTurn["reason"];
+        ttlMs?: number;
+        turnId?: string;
+    }): Promise<SuspendedTurn>;
+    get(turnId: string): Promise<SuspendedTurn | undefined>;
+    getByIdempotencyKey(idempotencyKey: string): Promise<SuspendedTurn | undefined>;
+};
+export type RecentApp = {
+    applicationId: string;
+};
+export type RecentAppStore = {
+    get(input: {
+        organizationId: string;
+        userId: string;
+    }): Promise<RecentApp | undefined>;
+    set(input: {
+        applicationId: string;
+        organizationId: string;
+        ttlMs?: number;
+        userId: string;
+    }): Promise<void>;
+};
+/**
+ * Which channel a caller reached the gateway through. Part of a cursor's
+ * identity: two hosts polling the same build are two readers, and neither may
+ * consume the other's position.
+ */
+export type CallerChannel = "http" | "mcp";
+/**
+ * A caller, as far as resume is concerned.
+ *
+ * `id` is whatever the transport can name the caller by that stays the same
+ * across its reconnects: a CLI user id or MCP session id. It is hashed
+ * before it reaches storage and never appears in a log line or a metric
+ * label, so nothing here needs to be, or may be, a name or an address.
+ */
+export type CallerRef = {
+    channel: CallerChannel;
+    id: string;
+};
+export type ProgressCursorKey = {
+    applicationId: string;
+    caller: CallerRef;
+    organizationId: string;
+};
+export type AppScopeKey = {
+    applicationId: string;
+    organizationId: string;
+};
+/**
+ * One caller's place in a live edit's history.
+ *
+ * The cursor itself is the public part, handed back to the caller. The stall
+ * bookkeeping is not: it exists so a long-quiet hint fires once per quiet
+ * spell rather than on every poll, and a caller that edited it could only
+ * silence or spam its own hint.
+ */
+export type ProgressCursorRecord = {
+    cursor: EventCursor;
+    /**
+     * When this caller was last told the build had gone quiet, cleared as soon
+     * as it hears anything new.
+     */
+    stallHintedAtMs?: number;
+};
+/**
+ * Where a resumed reader picks up.
+ *
+ * Facts about the application — which live edit is serving it, when its build
+ * last said anything — are app-scoped, because any caller may ask them and
+ * every caller must get the same answer. How far a reader has got is the one
+ * per-caller thing here.
+ *
+ * Reads never consume. Two callers resuming the same build advance only their
+ * own cursor, so neither can take events away from the other.
+ */
+export type ProgressStore = {
+    getCursor(key: ProgressCursorKey): Promise<ProgressCursorRecord | undefined>;
+    /** When this application's build last emitted activity, if it has. */
+    getLastActivityAtMs(key: AppScopeKey): Promise<number | undefined>;
+    /** The live edit currently serving an application, if one is known. */
+    getLiveEditId(key: AppScopeKey): Promise<string | undefined>;
+    setCursor(input: ProgressCursorKey & {
+        record: ProgressCursorRecord;
+        ttlMs?: number;
+    }): Promise<void>;
+    setLastActivityAtMs(input: AppScopeKey & {
+        atMs: number;
+        ttlMs?: number;
+    }): Promise<void>;
+    setLiveEditId(input: AppScopeKey & {
+        liveEditId: string;
+        ttlMs?: number;
+    }): Promise<void>;
+};
+export declare const DEFAULT_TURN_TTL_MS = 180000;
+export declare const DEFAULT_RECENT_APP_TTL_MS = 86400000;
+/**
+ * How long a caller's cursor outlives its last read.
+ *
+ * Matched to the event stream's own retention rather than to a session: a
+ * cursor into a stream the gateway has already reclaimed can only produce a
+ * stale read, and keeping it costs a key per caller per app for nothing.
+ */
+export declare const DEFAULT_PROGRESS_CURSOR_TTL_MS = 3600000;
+/** How long an application's live-edit pointer survives without a write. */
+export declare const DEFAULT_LIVE_EDIT_POINTER_TTL_MS = 86400000;

package/dist/resume/types.js

@@ -0,0 +1,13 @@
+export const DEFAULT_TURN_TTL_MS = 180_000;
+export const DEFAULT_RECENT_APP_TTL_MS = 86_400_000;
+/**
+ * How long a caller's cursor outlives its last read.
+ *
+ * Matched to the event stream's own retention rather than to a session: a
+ * cursor into a stream the gateway has already reclaimed can only produce a
+ * stale read, and keeping it costs a key per caller per app for nothing.
+ */
+export const DEFAULT_PROGRESS_CURSOR_TTL_MS = 3_600_000;
+/** How long an application's live-edit pointer survives without a write. */
+export const DEFAULT_LIVE_EDIT_POINTER_TTL_MS = 86_400_000;
+//# sourceMappingURL=types.js.map

package/dist/resume/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/resume/types.ts"],"names":[],"mappings":"AA8HA,MAAM,CAAC,MAAM,mBAAmB,GAAG,OAAO,CAAC;AAC3C,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,SAAS,CAAC;AAExD,4EAA4E;AAC5E,MAAM,CAAC,MAAM,gCAAgC,GAAG,UAAU,CAAC"}

package/dist/sabs/agent-facing-text.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Sanitize text that may be echoed into Claude / MCP tool results.
+ *
+ * Downstream orchestrator and integration payloads can carry secrets, control
+ * characters, and prompt-injection wrappers. Strip those before any agent sees
+ * the string.
+ */
+/**
+ * Removes C0 control characters (keeps tab/LF/CR) so logs and prompts stay printable.
+ * Implemented without a control-character regex so eslint no-control-regex stays clean.
+ */
+export declare function stripUnsafeChars(text: string): string;
+/**
+ * Replaces common secret-shaped substrings with a fixed redaction token.
+ */
+export declare function scrubSecrets(text: string): string;
+/**
+ * Full agent-facing sanitize: scrub secrets, strip controls, neutralize backticks.
+ */
+export declare function sanitizeAgentFacingText(text: string): string;
+/**
+ * Deep-sanitize string leaves in tool results returned to Clark / MCP.
+ *
+ * A secret-named field is redacted whole, since the value need not look like a
+ * secret to be one, and a wrapper around it is no safer than the bare value: an
+ * object or array under `password` is replaced rather than walked, or its leaves
+ * would pass under names of their own that read as harmless.
+ *
+ * Booleans are the exception. A flag such as `hasPassword` reports whether a
+ * credential exists rather than carrying it, and redacting it hides state Clark
+ * needs without hiding a secret.
+ */
+export declare function sanitizeAgentFacingValue(value: unknown): unknown;

package/dist/sabs/agent-facing-text.js

@@ -0,0 +1,125 @@
+/**
+ * Sanitize text that may be echoed into Claude / MCP tool results.
+ *
+ * Downstream orchestrator and integration payloads can carry secrets, control
+ * characters, and prompt-injection wrappers. Strip those before any agent sees
+ * the string.
+ */
+/** JWT / opaque bearer-ish tokens and common vendor API key shapes. */
+const SECRET_PATTERNS = [
+    /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g,
+    // Vendor keys often embed hyphens inside the secret (sk-proj-..., sk-ant-...).
+    /\b(?:sk|rk|pk)[-_][A-Za-z0-9_-]{16,}\b/gi,
+    /\bsbp_[A-Za-z0-9]{16,}\b/g,
+    /\bAKIA[0-9A-Z]{16}\b/g,
+    /\bBearer\s+[A-Za-z0-9._~+/=-]{16,}\b/gi,
+    // Plain assignments: password=... / api_key: ...
+    /(?<=(?:password|passwd|secret|token|api[_-]?key)\s*[:=]\s*)["']?[^\s"',;]{8,}["']?/gi,
+    // JSON-ish quoted keys: "password": "..."
+    /(?<=["'](?:password|passwd|secret|token|api[_-]?key)["']\s*:\s*)["'][^"']{4,}["']/gi,
+];
+const SECRET_FIELD_KEYS = new Set([
+    "api_key",
+    "apikey",
+    "authorization",
+    "password",
+    "passwd",
+    "secret",
+    "token",
+]);
+/**
+ * Field names that end in a credential word but carry a cursor or a count.
+ * Redacting these would hide the paging state Clark needs to keep listing.
+ */
+const CURSOR_FIELD_KEYS = new Set([
+    "continuationtoken",
+    "nextpagetoken",
+    "nexttoken",
+    "pagetoken",
+    "pagingtoken",
+    "resumetoken",
+    "synctoken",
+    "tokencount",
+]);
+const REDACTED = "[REDACTED]";
+/**
+ * Removes C0 control characters (keeps tab/LF/CR) so logs and prompts stay printable.
+ * Implemented without a control-character regex so eslint no-control-regex stays clean.
+ */
+export function stripUnsafeChars(text) {
+    let out = "";
+    for (let i = 0; i < text.length; i += 1) {
+        const code = text.charCodeAt(i);
+        if (code === 9 || code === 10 || code === 13) {
+            out += text[i];
+            continue;
+        }
+        if (code < 32 || code === 127) {
+            continue;
+        }
+        out += text[i];
+    }
+    return out;
+}
+/**
+ * Replaces common secret-shaped substrings with a fixed redaction token.
+ */
+export function scrubSecrets(text) {
+    let next = text;
+    for (const pattern of SECRET_PATTERNS) {
+        next = next.replace(pattern, REDACTED);
+    }
+    return next;
+}
+/**
+ * Full agent-facing sanitize: scrub secrets, strip controls, neutralize backticks.
+ */
+export function sanitizeAgentFacingText(text) {
+    return scrubSecrets(stripUnsafeChars(text)).replace(/`/g, "'");
+}
+function isSecretFieldKey(key) {
+    const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, "");
+    if (CURSOR_FIELD_KEYS.has(normalized)) {
+        return false;
+    }
+    return (SECRET_FIELD_KEYS.has(key.toLowerCase()) ||
+        SECRET_FIELD_KEYS.has(normalized) ||
+        normalized.endsWith("password") ||
+        normalized.endsWith("secret") ||
+        normalized.endsWith("token") ||
+        normalized.endsWith("apikey"));
+}
+/**
+ * Deep-sanitize string leaves in tool results returned to Clark / MCP.
+ *
+ * A secret-named field is redacted whole, since the value need not look like a
+ * secret to be one, and a wrapper around it is no safer than the bare value: an
+ * object or array under `password` is replaced rather than walked, or its leaves
+ * would pass under names of their own that read as harmless.
+ *
+ * Booleans are the exception. A flag such as `hasPassword` reports whether a
+ * credential exists rather than carrying it, and redacting it hides state Clark
+ * needs without hiding a secret.
+ */
+export function sanitizeAgentFacingValue(value) {
+    if (typeof value === "string") {
+        return sanitizeAgentFacingText(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => sanitizeAgentFacingValue(entry));
+    }
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [key, entry] of Object.entries(value)) {
+            const carriesNoSecret = typeof entry === "boolean" || entry == null;
+            if (!carriesNoSecret && isSecretFieldKey(key)) {
+                out[key] = REDACTED;
+                continue;
+            }
+            out[key] = sanitizeAgentFacingValue(entry);
+        }
+        return out;
+    }
+    return value;
+}
+//# sourceMappingURL=agent-facing-text.js.map