Skip to content

armgit / qm

Public Imported from GitHub
0

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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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 throug
async 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.ts
index 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 th
assert.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.ts
index 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.ts
index 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;
};