Multiplayer agent harness for work.
Read only the current session's approvals (#2419)
Regan Bell2323c59ef96c
diff --git a/src/api/app-helpers.ts b/src/api/app-helpers.tsindex c0d73c97d..d95f6cc98 100644--- a/src/api/app-helpers.ts+++ b/src/api/app-helpers.ts@@ -152,7 +152,10 @@ export function createAppHelpers(deps: AppDeps, app: App) {opts: { blockingOnly: boolean; viewer?: string },): Promise<PendingApproval[]> {if (!deps.approvals) return [];- const [entries, session] = await Promise.all([deps.approvals.entries(), deps.sessions.get(sessionId)]);+ const [entries, session] = await Promise.all([+ deps.approvals.selectEntries({ where: { field: "sessionId", anyOfFold: [sessionId] } }),+ deps.sessions.get(sessionId),+ ]);if (!session) return [];const candidates: Array<{ key: string; record: PendingApprovalRecord }> = [];for (const [key, record] of entries) {diff --git a/src/api/app-sessions.ts b/src/api/app-sessions.tsindex cab9c94a0..6ecd5efd8 100644--- a/src/api/app-sessions.ts+++ b/src/api/app-sessions.ts@@ -439,7 +439,10 @@ export function createSessionMethods(const all = await sessionsForViewer(principalId);const visibleById = new Map(all.map((session) => [session.id, session]));const approvalRows: PendingApprovalRecord[] = [];- for (const [, record] of (await deps.approvals?.entries()) ?? []) {+ const approvals = visibleById.size+ ? await deps.approvals?.selectEntries({ where: { field: "sessionId", anyOfFold: [...visibleById.keys()] } })+ : [];+ for (const [, record] of approvals ?? []) {const session = visibleById.get(record.sessionId);if (session && (await approvalRecordIsCurrent(record, session))) approvalRows.push(record);}diff --git a/src/persistence/durable-map.ts b/src/persistence/durable-map.tsindex fbc40891d..7e3a49cb8 100644--- a/src/persistence/durable-map.ts+++ b/src/persistence/durable-map.ts@@ -13,6 +13,9 @@ export interface DurableMap<T> {all(): Promise<T[]>;entries(): Promise<Array<[string, T]>>;select<K extends Extract<keyof T, string> = never>(query: DurableMapSelect<T, K>): Promise<Array<Omit<T, K>>>;+ selectEntries<K extends Extract<keyof T, string> = never>(+ query: DurableMapSelect<T, K>,+ ): Promise<Array<[string, Omit<T, K>]>>;get(id: string): Promise<T | null>;put(id: string, value: T): Promise<void>;putIfAbsent(id: string, value: T): Promise<T>;@@ -59,14 +62,15 @@ function isAscii(text: string): boolean {return true;}-export function selectValues<T, K extends Extract<keyof T, string>>(- values: readonly T[],+export function selectEntries<T, K extends Extract<keyof T, string>>(+ entries: ReadonlyArray<readonly [string, T]>,query: DurableMapSelect<T, K>,-): Array<Omit<T, K>> {+): Array<[string, Omit<T, K>]> {const folded = query.where ? new Set(query.where.anyOfFold.map((v) => v.toLowerCase())) : null;- const out: Array<Omit<T, K>> = [];- for (const value of values) {+ const out: Array<[string, Omit<T, K>]> = [];+ for (const [id, value] of entries) {if (query.limit !== undefined && out.length >= query.limit) break;+ if (query.afterId !== undefined && id <= query.afterId) continue;if (folded && query.where) {const text = fieldText((value as Record<string, unknown>)[query.where.field]);if (text === null || !(folded.has(text.toLowerCase()) || !isAscii(text))) continue;@@ -78,7 +82,7 @@ export function selectValues<T, K extends Extract<keyof T, string>>(projected[field] = Object.fromEntries(Object.entries(nested).filter(([key]) => keys.includes(key)));}for (const key of query.omit ?? []) delete projected[key];- out.push(projected as Omit<T, K>);+ out.push([id, projected as Omit<T, K>]);}return out;}@@ -108,12 +112,10 @@ export function createMemoryMap<T>(): DurableMap<T> {return sortedEntries();},async select(query) {- return selectValues(- sortedEntries()- .filter(([id]) => query.afterId === undefined || id > query.afterId)- .map(([, v]) => v),- query,- );+ return selectEntries(sortedEntries(), query).map(([, value]) => value);+ },+ async selectEntries(query) {+ return selectEntries(sortedEntries(), query);},async get(id) {return m.get(id) ?? null;@@ -267,6 +269,44 @@ export function createPostgresMap<T>(}return structuredClone(cache.entries);}+ async function selectRows<K extends Extract<keyof T, string>>(+ query: DurableMapSelect<T, K>,+ ): Promise<Array<[string, Omit<T, K>]>> {+ await ready();+ const params: unknown[] = [[...(query.omit ?? [])]];+ let projection = "json";+ for (const [field, keys] of Object.entries(query.pickNested ?? {})) {+ params.push(field, keys);+ const fieldParam = `$${params.length - 1}`;+ const keysParam = `$${params.length}`;+ const nested = `CASE WHEN jsonb_typeof(json->${fieldParam}) = 'object' THEN+ COALESCE((SELECT jsonb_object_agg(key, value) FROM jsonb_each(json->${fieldParam})+ WHERE key = ANY(${keysParam}::text[])), '{}'::jsonb) ELSE json->${fieldParam} END`;+ projection = `(${projection} || CASE WHEN json ? ${fieldParam} THEN+ jsonb_build_object(${fieldParam}::text, ${nested}) ELSE '{}'::jsonb END)`;+ }+ let sql = `SELECT id, ${projection} - $1::text[] AS json FROM ${table}`;+ if (query.where) {+ const field = query.where.field;+ if (!/^[a-z_][a-z0-9_]*$/i.test(field)) throw new Error(`invalid select field: ${field}`);+ params.push(query.where.anyOfFold.map((v) => v.toLowerCase()));+ sql += ` WHERE id IN (+ SELECT id FROM ${table} WHERE lower(json->>'${field}') = ANY($${params.length}::text[])+ UNION+ SELECT id FROM ${table} WHERE json->>'${field}' ~ '[^\\x01-\\x7f]')`;+ }+ if (query.afterId !== undefined) {+ params.push(query.afterId);+ sql += `${query.where ? " AND" : " WHERE"} id > $${params.length}`;+ }+ sql += " ORDER BY id";+ if (query.limit !== undefined) {+ params.push(query.limit);+ sql += ` LIMIT $${params.length}`;+ }+ const rows = await pg.q(sql, params);+ return rows.map((row) => [row.id as string, row.json as Omit<T, K>]);+ }return {async all() {return (await snapshot()).map(([, value]) => value);@@ -275,41 +315,9 @@ export function createPostgresMap<T>(return snapshot();},async select<K extends Extract<keyof T, string> = never>(query: DurableMapSelect<T, K>) {- await ready();- const params: unknown[] = [[...(query.omit ?? [])]];- let projection = "json";- for (const [field, keys] of Object.entries(query.pickNested ?? {})) {- params.push(field, keys);- const fieldParam = `$${params.length - 1}`;- const keysParam = `$${params.length}`;- const nested = `CASE WHEN jsonb_typeof(json->${fieldParam}) = 'object' THEN- COALESCE((SELECT jsonb_object_agg(key, value) FROM jsonb_each(json->${fieldParam})- WHERE key = ANY(${keysParam}::text[])), '{}'::jsonb) ELSE json->${fieldParam} END`;- projection = `(${projection} || CASE WHEN json ? ${fieldParam} THEN- jsonb_build_object(${fieldParam}::text, ${nested}) ELSE '{}'::jsonb END)`;- }- let sql = `SELECT ${projection} - $1::text[] AS json FROM ${table}`;- if (query.where) {- const field = query.where.field;- if (!/^[a-z_][a-z0-9_]*$/i.test(field)) throw new Error(`invalid select field: ${field}`);- params.push(query.where.anyOfFold.map((v) => v.toLowerCase()));- sql += ` WHERE id IN (- SELECT id FROM ${table} WHERE lower(json->>'${field}') = ANY($${params.length}::text[])- UNION- SELECT id FROM ${table} WHERE json->>'${field}' ~ '[^\\x01-\\x7f]')`;- }- if (query.afterId !== undefined) {- params.push(query.afterId);- sql += `${query.where ? " AND" : " WHERE"} id > $${params.length}`;- }- sql += " ORDER BY id";- if (query.limit !== undefined) {- params.push(query.limit);- sql += ` LIMIT $${params.length}`;- }- const rows = await pg.q(sql, params);- return rows.map((row) => row.json as Omit<T, K>);+ return (await selectRows(query)).map(([, value]) => value);},+ selectEntries: selectRows,async get(id) {await ready();const rows = await pg.q(`SELECT json FROM ${table} WHERE id = $1`, [id]);diff --git a/src/wiring.ts b/src/wiring.tsindex 60bee61cc..c071cc1ca 100644--- a/src/wiring.ts+++ b/src/wiring.ts@@ -1576,15 +1576,21 @@ export function buildApp(runStoreKind === "postgres"? createPostgresRunStore(requireDbUrl("RUN_STORE"), { maxClaims: config.maxClaims }): createMemoryRunStore({ maxClaims: config.maxClaims });- const blockingApprovalSessions = async (): Promise<Set<string>> =>- new Set(- (await approvals.entries())- .filter(([, r]) => r.blocksInput !== false && actorAssertionActive(identity, r.request?.actor))- .map(([, r]) => r.sessionId),+ const blockingApprovalSessions = async (sessionIds: readonly string[]): Promise<Set<string>> => {+ if (!sessionIds.length) return new Set();+ const wanted = new Set(sessionIds);+ return new Set(+ (await approvals.select({ where: { field: "sessionId", anyOfFold: sessionIds } }))+ .filter(+ (r) => wanted.has(r.sessionId) && r.blocksInput !== false && actorAssertionActive(identity, r.request?.actor),+ )+ .map((r) => r.sessionId),);+ };const workingAncestors = async (session: Session) => {- const awaiting = await blockingApprovalSessions();- const ancestors = (await stoppableAncestors(sessions, session)).filter((ancestor) => !awaiting.has(ancestor.id));+ const candidates = await stoppableAncestors(sessions, session);+ const awaiting = await blockingApprovalSessions(candidates.map((ancestor) => ancestor.id));+ const ancestors = candidates.filter((ancestor) => !awaiting.has(ancestor.id));return Promise.all(ancestors.map(async (ancestor) => ({session: ancestor,@@ -1975,7 +1981,7 @@ export function buildApp(`UPDATE webhooks SET json = jsonb_set(json, '{enabled}', 'false'::jsonb) WHERE (json ->> 'enabled')::boolean`,],});- const approvals = createApprovalStore(artifactMap<PendingApprovalRecord>("approvals"), deliveries);+ const approvals = createApprovalStore(artifactMap<PendingApprovalRecord>("approvals", ["sessionId"]), deliveries);let securityScreener = overrides.securityScreener;if (!securityScreener && config.securityScreen !== "off" && config.securityScreenProxy) {securityScreener = createSecurityScreenProxy({@@ -2415,10 +2421,9 @@ export function buildApp(sessionStateBus.emit({ threadRef: run.sessionId, state: "idle", at });return;}- const awaiting = await blockingApprovalSessions();const settle = async (target: Session): Promise<boolean> => {if (await runs.activeForThread(target.threadRef)) return false;- const waiting = awaiting.has(target.id);+ const waiting = (await blockingApprovalSessions([target.id])).has(target.id);if (!waiting && (await sessionTreeWorking(sessions, runs, target))) return false;const participants = await sessions.participantsOf(target.id);sessionStateBus.emit({diff --git a/test/approvals-session-scope.test.ts b/test/approvals-session-scope.test.tsnew file mode 100644index 000000000..8cf7d0e5d--- /dev/null+++ b/test/approvals-session-scope.test.ts@@ -0,0 +1,74 @@+import { test } from "node:test";+import assert from "node:assert/strict";+import { createApp } from "../src/api/app.ts";+import { createIdentityService } from "../src/identity/identity-service.ts";+import { createMemoryMap, type DurableMap } from "../src/persistence/durable-map.ts";+import { createMemorySessionStore } from "../src/sessions/memory-session-store.ts";+import type { PendingApprovalRecord } from "../src/types.ts";++const approval = (sessionId: string, actor: string, command: string, blocksInput = true): PendingApprovalRecord => ({+ sessionId,+ command,+ createdAt: 1,+ blocksInput,+ request: {+ surface: "web",+ actor: { externalId: actor },+ conversation: { kind: "dm", threadRef: `dm:${actor}` },+ text: command,+ },+});++test("session approvals are read by session id, never by scanning every approval", async () => {+ const sessions = createMemorySessionStore();+ const mine = await sessions.getOrCreateByThread("dm:alice:t1", "dm", "personal:alice");+ const other = await sessions.getOrCreateByThread("dm:bob:t1", "dm", "personal:bob");+ await sessions.addParticipant(mine.id, "alice");+ await sessions.addParticipant(mine.id, "bob");+ const backing = createMemoryMap<PendingApprovalRecord>();+ await backing.put("a-blocking", approval(mine.id, "alice", "git push --force"));+ await backing.put("a-input", approval(mine.id, "alice", "ask", false));+ await backing.put("b-blocking", approval(other.id, "bob", "rm -rf /"));+ await backing.put("orphan", approval("no-such-session", "alice", "noop"));+ await backing.put("unicode", approval("sesión-ü", "alice", "echo"));+ const expectedFromFullScan = (await backing.entries()).filter(([, r]) => r.sessionId === mine.id).map(([id]) => id);++ let fullReads = 0;+ const approvals: DurableMap<PendingApprovalRecord> = {+ ...backing,+ async entries() {+ fullReads++;+ return backing.entries();+ },+ async all() {+ fullReads++;+ return backing.all();+ },+ };+ const app = createApp({+ sessions,+ approvals,+ identity: createIdentityService(),+ } as unknown as Parameters<typeof createApp>[0]);++ const listed = await app.listSessionApprovals(mine.id, "alice");+ assert.deepEqual(+ listed.map((a) => a.requestId),+ expectedFromFullScan,+ "the filtered read returns exactly what the old full scan + filter did",+ );+ assert.deepEqual(+ listed.map((a) => a.blocksInput),+ [true, false],+ );+ assert.deepEqual(await app.listSessionApprovals(mine.id, "bob"), [], "viewer visibility still applies");++ const blocking = await app.pendingApprovalForThread(mine.threadRef);+ assert.equal(blocking?.status, "pending_approval");+ assert.deepEqual(+ blocking?.pendingApprovals?.map((a) => a.requestId),+ ["a-blocking"],+ "blockingOnly still drops non-blocking approvals",+ );+ assert.equal(fullReads, 0, "no caller read the whole approvals map");+});diff --git a/test/connectors.test.ts b/test/connectors.test.tsindex 553f90653..d5eb953e9 100644--- a/test/connectors.test.ts+++ b/test/connectors.test.ts@@ -11,7 +11,7 @@ import {import { deriveConnectorKey } from "../src/connectors/connector-client-store.ts";import {createMemoryMap,- selectValues,+ selectEntries,type DurableMap,type DurableMapSelect,} from "../src/persistence/durable-map.ts";@@ -295,7 +295,12 @@ test("connector token keys are Postgres-safe (no NUL byte) — round-trip througasync select<K extends Extract<keyof KeychainCredential, string> = never>(query: DurableMapSelect<KeychainCredential, K>,) {- return selectValues([...store.values()], query);+ return selectEntries([...store.entries()], query).map(([, value]) => value);+ },+ async selectEntries<K extends Extract<keyof KeychainCredential, string> = never>(+ query: DurableMapSelect<KeychainCredential, K>,+ ) {+ return selectEntries([...store.entries()], query);},async get(k: string) {rejectNul(k);diff --git a/test/durable-stores.test.ts b/test/durable-stores.test.tsindex ab29d586b..1f0d4f00e 100644--- a/test/durable-stores.test.ts+++ b/test/durable-stores.test.ts@@ -179,12 +179,12 @@ test("the Postgres map select projects and filters inside SQL, never fetching thassert.equal(reads.length, 1);assert.match(reads[0]!.sql,- /^SELECT json - \$1::text\[\] AS json FROM select_probe WHERE id IN \(\s+SELECT id FROM select_probe WHERE lower\(json->>'owner'\) = ANY\(\$2::text\[\]\)\s+UNION\s+SELECT id FROM select_probe WHERE json->>'owner' ~ '\[\^\\x01-\\x7f\]'\) ORDER BY id$/,+ /^SELECT id, json - \$1::text\[\] AS json FROM select_probe WHERE id IN \(\s+SELECT id FROM select_probe WHERE lower\(json->>'owner'\) = ANY\(\$2::text\[\]\)\s+UNION\s+SELECT id FROM select_probe WHERE json->>'owner' ~ '\[\^\\x01-\\x7f\]'\) ORDER BY id$/,);assert.deepEqual(reads[0]!.params, [["secretEnc"], ["u1", "[email protected]"]]);await map.select({});- assert.match(reads[1]!.sql, /^SELECT json - \$1::text\[\] AS json FROM select_probe ORDER BY id$/);+ assert.match(reads[1]!.sql, /^SELECT id, json - \$1::text\[\] AS json FROM select_probe ORDER BY id$/);assert.deepEqual(reads[1]!.params, [[]]);await map.select({ where: { field: "owner", anyOfFold: ["U1"] }, limit: 16, afterId: "previous" });assert.match(reads[2]!.sql, /\) AND id > \$3 ORDER BY id LIMIT \$4$/);diff --git a/test/postgres-map.test.ts b/test/postgres-map.test.tsindex b256eb03c..3d8d337bc 100644--- a/test/postgres-map.test.ts+++ b/test/postgres-map.test.ts@@ -202,6 +202,19 @@ test("pg map: select mirrors the memory map — folded field filter, projection,"the omitted key is gone from every row",);assert.deepEqual(mine[0]!.nested, { n: 1 }, "nested fields survive the projection");+ const mineEntries = await pgMap.selectEntries({+ omit: ["secretEnc"],+ where: { field: "owner", anyOfFold: ["U7"] },+ });+ assert.deepEqual(+ mineEntries,+ await memMap.selectEntries({ omit: ["secretEnc"], where: { field: "owner", anyOfFold: ["U7"] } }),+ );+ assert.deepEqual(+ mineEntries,+ mine.map((row) => [row.name, row]),+ "selectEntries pairs each selected row with its key",+ );for (const limit of [0, 1, 2]) {const query = { limit, afterId: "sel-a", where: { field: "owner" as const, anyOfFold: ["u7"] } };assert.deepEqual(await pgMap.select(query), await memMap.select(query));diff --git a/test/postgres-swarms.test.ts b/test/postgres-swarms.test.tsindex c102d0eed..e3070e4ac 100644--- a/test/postgres-swarms.test.ts+++ b/test/postgres-swarms.test.ts@@ -124,7 +124,7 @@ test("Postgres pending selection retains one live query across sweep timeouts",const waiting = async (): Promise<number> => {const result = await observer.query<{ count: number }>("SELECT count(*)::int AS count FROM pg_stat_activity WHERE datname = current_database() AND wait_event_type = 'Lock' AND query LIKE $1",- ["SELECT json% FROM swarms%"],+ ["SELECT id, json% FROM swarms%"],);return result.rows[0]!.count;};