a2a-exposed 0.8.17 → 0.8.19

package/worker/test/owner-rpc.test.ts

@@ -12,9 +12,11 @@ test("owner RPC allowlist is the management reads and the calls that do not retu
 	assert.equal(ok("GET", "/owner/inbox")?.name, "GET /owner/inbox");
 	assert.equal(ok("GET", "/owner/summary")?.name, "GET /owner/summary");
 	assert.equal(ok("GET", "/owner/inbox", { context: "ctx-1", all: "1" })?.search, "?context=ctx-1&all=1");
+	assert.equal(ok("GET", "/owner/inbox", { from: "ada" })?.search, "?from=ada");
 	assert.equal(ok("GET", "/owner/inbox", { limit: "20", cursor: "abc_DEF-012" })?.search, "?limit=20&cursor=abc_DEF-012");
 	assert.equal(ok("GET", "/owner/tasks/task-1")?.path, "/owner/tasks/task-1");
 	assert.equal(ok("GET", "/owner/history/ctx-1", { n: "50" })?.search, "?n=50");
+	assert.equal(ok("GET", "/owner/history/ctx-1", { n: "50", from: "ada" })?.search, "?n=50&from=ada");
 	assert.equal(ok("GET", "/owner/outbound/task-1")?.name, "GET /owner/outbound/:id");
 	assert.equal(ok("GET", "/owner/peers")?.name, "GET /owner/peers");
 	assert.equal(ok("DELETE", "/owner/peers/ada")?.path, "/owner/peers/ada");
@@ -63,6 +65,8 @@ test("owner RPC allowlist is the management reads and the calls that do not retu
 	assert.deepEqual(refused("GET", "/owner/inbox", { limit: "201" }), { ok: false, reason: "query" });
 	assert.deepEqual(refused("GET", "/owner/inbox", { limit: "0" }), { ok: false, reason: "query" });
 	assert.deepEqual(refused("GET", "/owner/inbox", { cursor: "bad+cursor" }), { ok: false, reason: "query" });
+	assert.deepEqual(refused("GET", "/owner/inbox", { from: "bad peer" }), { ok: false, reason: "query" });
+	assert.deepEqual(refused("GET", "/owner/history/ctx-1", { from: "../x" }), { ok: false, reason: "query" });
 	assert.deepEqual(refused("GET", "/owner/summary", { all: "1" }), { ok: false, reason: "query" });
 	assert.deepEqual(refused("GET", "/owner/history/ctx-1", { n: "1001" }), { ok: false, reason: "query" });
 	assert.deepEqual(refused("GET", "/owner/history/.."), { ok: false, reason: "path" });

package/worker/test/push-config.test.ts

@@ -0,0 +1,161 @@
+// The inbox lists and deletes the push configs stored on a task, for the calling peer only.
+// Run: npm test
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import worker from "../src/index.ts";
+import { sha256 } from "../src/a2a.ts";
+import { d1 } from "./d1.ts";
+
+const BASE = "https://agent.example.com";
+
+function setup() {
+	const DB = d1(new URL("../migrations/", import.meta.url));
+	const env: any = {
+		DB, PUBLIC_URL: BASE, OWNER_TOKEN: "owner-secret", AGENT_NAME: "Test Inbox", WAKE_PRESET: "generic",
+	};
+	const logs: string[] = [];
+	const secrets: string[] = [];
+	const orig = console.log;
+	console.log = (...args: unknown[]) => {
+		const line = args.map((a) => String(a)).join(" ");
+		logs.push(line);
+		if (secrets.some((secret) => secret && line.includes(secret))) return;
+		orig(...args);
+	};
+	const call = async (token: string, method: string, params: unknown, headers: Record<string, string> = {}) => {
+		const res = await worker.fetch(new Request(BASE + "/", {
+			method: "POST",
+			headers: { authorization: `Bearer ${token}`, "content-type": "application/json", ...headers },
+			body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+		}) as any, env, { waitUntil() {}, passThroughOnException() {} } as any);
+		const text = await res.text();
+		let data: any = text;
+		try { data = text ? JSON.parse(text) : null; } catch { /* not json */ }
+		return { status: res.status, data, text };
+	};
+	const owner = async (method: string, path: string, json?: unknown) => {
+		const res = await worker.fetch(new Request(BASE + path, {
+			method, headers: { authorization: "Bearer owner-secret", "content-type": "application/json" },
+			body: json === undefined ? undefined : JSON.stringify(json),
+		}) as any, env, { waitUntil() {}, passThroughOnException() {} } as any);
+		return res.json() as Promise<any>;
+	};
+	return {
+		DB, call, owner, logs, secrets,
+		restore: () => { console.log = orig; },
+	};
+}
+
+function hides(body: string, secret: string) {
+	assert.equal(body.includes(secret), false);
+}
+
+test("list and delete return the caller's push config and hide it from other peers", async (t) => {
+	const s = setup();
+	t.after(s.restore);
+	const ada = (await s.owner("POST", "/owner/peers", { label: "ada" })).token as string;
+	const bob = (await s.owner("POST", "/owner/peers", { label: "bob" })).token as string;
+	const token = `pt_${crypto.randomUUID()}`;
+	s.secrets.push(token);
+	const tokenHash = await sha256(token);
+	const sent = await s.call(ada, "message/send", {
+		message: { kind: "message", role: "user", messageId: crypto.randomUUID(), parts: [{ kind: "text", text: "hello" }] },
+	});
+	assert.equal(sent.status, 200);
+	const taskId = sent.data.result.id as string;
+	const set = await s.call(ada, "tasks/pushNotificationConfig/set", {
+		taskId, pushNotificationConfig: { id: "cfg-1", url: "https://hooks.example.net/ada", token },
+	});
+	assert.equal(set.status, 200);
+	assert.equal(set.data.result.taskId, taskId);
+	assert.equal(await sha256(String(set.data.result.pushNotificationConfig.token)), tokenHash);
+
+	const listed = await s.call(ada, "ListTaskPushNotificationConfig", { taskId });
+	assert.equal(listed.status, 200);
+	assert.equal(listed.data.result.nextPageToken, "");
+	assert.equal(listed.data.result.configs.length, 1);
+	assert.equal(listed.data.result.configs[0].id, "cfg-1");
+	assert.equal(listed.data.result.configs[0].taskId, taskId);
+	assert.equal(await sha256(String(listed.data.result.configs[0].token)), tokenHash);
+	const plural = await s.call(ada, "ListTaskPushNotificationConfigs", { taskId });
+	assert.equal(await sha256(String(plural.data.result.configs[0].token)), tokenHash);
+
+	const as03 = await s.call(ada, "tasks/pushNotificationConfig/list", { id: taskId });
+	assert.equal(Array.isArray(as03.data.result), true);
+	assert.equal(as03.data.result.length, 1);
+	assert.equal(as03.data.result[0].pushNotificationConfig.id, "cfg-1");
+	assert.equal(await sha256(String(as03.data.result[0].pushNotificationConfig.token)), tokenHash);
+
+	const missing = await s.call(bob, "ListTaskPushNotificationConfig", { taskId: "missing-task-id" });
+	const foreign = await s.call(bob, "ListTaskPushNotificationConfig", { taskId });
+	assert.deepEqual(foreign.data.error, { code: -32001, message: "Task not found" });
+	assert.deepEqual(missing.data.error, foreign.data.error);
+	hides(foreign.text, token);
+	hides(missing.text, token);
+	const foreignDel = await s.call(bob, "DeleteTaskPushNotificationConfig", { taskId, id: "cfg-1" });
+	assert.deepEqual(foreignDel.data.error, { code: -32001, message: "Task not found" });
+	hides(foreignDel.text, token);
+	const foreign03 = await s.call(bob, "tasks/pushNotificationConfig/list", { id: taskId });
+	assert.deepEqual(foreign03.data.error, { code: -32001, message: "Task not found" });
+	hides(foreign03.text, token);
+
+	const gone = await s.call(ada, "DeleteTaskPushNotificationConfig", { taskId, id: "cfg-1" });
+	assert.deepEqual(gone.data.result, {});
+	const again = await s.call(ada, "DeleteTaskPushNotificationConfig", { taskId, id: "cfg-1" });
+	assert.deepEqual(again.data.result, {});
+	const after = await s.call(ada, "ListTaskPushNotificationConfig", { taskId });
+	assert.deepEqual(after.data.result, { configs: [], nextPageToken: "" });
+
+	const noId = await s.call(ada, "DeleteTaskPushNotificationConfig", { taskId });
+	assert.equal(noId.data.error?.code, -32602);
+	assert.equal(noId.data.error?.message, "Invalid params: push notification config id");
+
+	const bad = "page-token-secret-value";
+	const rejected = await s.call(ada, "ListTaskPushNotificationConfig", { taskId, pageToken: bad });
+	assert.equal(rejected.data.error?.message, "Invalid params: pageToken");
+	hides(rejected.text, bad);
+	hides(rejected.text, token);
+
+	assert.equal(s.logs.some((line) => line.includes(token)), false);
+});
+
+test("1.0 list pages configs and 0.3 delete returns null", async (t) => {
+	const s = setup();
+	t.after(s.restore);
+	const ada = (await s.owner("POST", "/owner/peers", { label: "ada" })).token as string;
+	const token = `pt_${crypto.randomUUID()}`;
+	s.secrets.push(token);
+	const sent = await s.call(ada, "SendMessage", {
+		message: { role: "ROLE_USER", messageId: crypto.randomUUID(), parts: [{ text: "hello" }] },
+	});
+	const taskId = sent.data.result.task.id as string;
+	for (const id of ["c-1", "c-2", "c-3"]) {
+		const cfgToken = id === "c-2" ? token : `other-${id}`;
+		s.secrets.push(cfgToken);
+		const set = await s.call(ada, "CreateTaskPushNotificationConfig", {
+			taskId, pushNotificationConfig: { id, url: `https://hooks.example.net/${id}`, token: cfgToken },
+		});
+		assert.equal(set.data.error, undefined);
+	}
+	const seen: string[] = [];
+	let pageToken = "";
+	do {
+		const page = await s.call(ada, "ListTaskPushNotificationConfigs", { taskId, pageSize: 1, ...(pageToken ? { pageToken } : {}) });
+		assert.equal(page.data.result.configs.length, 1);
+		seen.push(page.data.result.configs[0].id);
+		if (page.data.result.configs[0].id === "c-2") assert.equal(await sha256(String(page.data.result.configs[0].token)), await sha256(token));
+		pageToken = page.data.result.nextPageToken;
+		if (!pageToken) assert.equal(pageToken, "");
+	} while (pageToken);
+	assert.deepEqual(seen, ["c-1", "c-2", "c-3"]);
+
+	const del = await s.call(ada, "tasks/pushNotificationConfig/delete", { id: taskId, pushNotificationConfigId: "c-2" });
+	assert.equal(del.data.result, null);
+	const delAgain = await s.call(ada, "tasks/pushNotificationConfig/delete", { id: taskId, pushNotificationConfigId: "c-2" });
+	assert.equal(delAgain.data.result, null);
+	const left = await s.call(ada, "tasks/pushNotificationConfig/list", { id: taskId });
+	assert.deepEqual(left.data.result.map((row: { pushNotificationConfig: { id: string } }) => row.pushNotificationConfig.id), ["c-1", "c-3"]);
+	hides(left.text, token);
+	hides(del.text, token);
+	assert.equal(s.logs.some((line) => line.includes(token)), false);
+});

package/worker/test/wake-retry.test.ts

@@ -72,3 +72,31 @@ test("a 429 is due at Retry-After when the debounce is longer", async (t) => {
 	const at = await nextCronAt(resolveTenant(env), Date.now());
 	assert.ok(at != null && at >= before + 25_000 && at <= before + 35_000, `alarm ${at} is Retry-After, not the 120s debounce`);
 });
+
+test("OpenBot preview masks signing credentials and wake test accepts HTTP 202", async (t) => {
+	const env: any = { DB: d1(new URL("../migrations/", import.meta.url)), PUBLIC_URL: BASE, OWNER_TOKEN: "owner-secret",
+		WAKE_PRESET: "openbot", WAKE_WEBHOOK_URL: "https://hooks.example.com/a2a", WAKE_HMAC_SECRET: "dummy-openbot-secret" };
+	const pending: Promise<unknown>[] = [];
+	const call = (method: string, path: string) => worker.fetch(new Request(BASE + path, { method, headers: { authorization: "Bearer owner-secret" } }) as any,
+		env, { waitUntil: (p: Promise<unknown>) => pending.push(p), passThroughOnException() {} } as any);
+	const preview = await (await call("GET", "/owner/wake/preview")).json() as any;
+	assert.equal(preview.preset, "openbot");
+	assert.equal(preview.signingInput, "<timestamp>.<delivery-id>.<exact-body-bytes>");
+	assert.equal(preview.request.headers["x-openbot-delivery-id"], "preview");
+	assert.equal(preview.request.headers["x-openbot-signature"], "••••");
+	assert.ok(!JSON.stringify(preview).includes(env.WAKE_HMAC_SECRET));
+	const original = globalThis.fetch;
+	let sent = false;
+	globalThis.fetch = (async (_url: any, init: any) => {
+		sent = true;
+		assert.equal(JSON.parse(init.body).type, "a2a_wake");
+		assert.match(init.headers["x-openbot-signature"], /^sha256=[0-9a-f]{64}$/);
+		assert.ok(init.headers["x-openbot-delivery-id"]);
+		return new Response("{}", { status: 202 });
+	}) as any;
+	t.after(() => { globalThis.fetch = original; });
+	const result = await (await call("POST", "/owner/wake/test")).json() as any;
+	assert.equal(result.status, 202);
+	assert.equal(sent, true);
+	await Promise.allSettled(pending);
+});

package/worker/test/wake.test.ts

@@ -2,7 +2,7 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import { createHmac } from "node:crypto";
-import { renderWake, renderTemplate, wakeSummary, redact, addAccessHeaders, cloudflareErrorHint, PRESETS, type WakeEvent } from "../src/wake.ts";
+import { renderWake, renderTemplate, wakeSummary, redact, addAccessHeaders, cloudflareErrorHint, PRESETS, wakePayload, type WakeEvent } from "../src/wake.ts";
 
 const ev: WakeEvent = {
 	contextId: "ctx-1", taskId: "t-2", taskIds: ["t-1", "t-2"], from: "peer-a",
@@ -19,7 +19,7 @@ test("grok-bot: bearer + JSON payload", async () => {
 	const b = JSON.parse(r.body);
 	assert.deepEqual([b.contextId, b.taskId, b.from, b.kind], ["ctx-1", "t-2", "peer-a", "inbound"]);
 	assert.deepEqual(b.taskIds, ["t-1", "t-2"]);
-	assert.match(b.hint, /inbox --context ctx-1/);
+	assert.match(b.hint, /inbox --context ctx-1 --from peer-a/);
 });
 
 test("claude-code: anthropic-version + text body", async () => {
@@ -106,7 +106,7 @@ test("redact masks credentials", async () => {
 });
 
 test("summary for outbound updates points at history", () => {
-	assert.match(wakeSummary({ ...ev, kind: "outbound_update" }, "a2a"), /a2a history ctx-1/);
+	assert.match(wakeSummary({ ...ev, kind: "outbound_update" }, "a2a"), /a2a history ctx-1 --from peer-a/);
 });
 
 test("generic custom key header is rendered with prefix and redacted in previews", async () => {
@@ -144,6 +144,7 @@ test("Access service-token headers are added for every preset, next to the prese
 		assert.equal(r.headers["CF-Access-Client-Id"], "abc123.access", preset);
 		assert.equal(r.headers["CF-Access-Client-Secret"], "s3cr3t-value-0123456789", preset);
 		if (preset === "hermes") assert.ok(r.headers["X-Webhook-Signature-V2"], "hermes keeps its HMAC");
+		else if (preset === "openbot") assert.ok(r.headers["x-openbot-signature"], "openbot keeps its HMAC");
 		else assert.ok(r.headers["authorization"], `${preset} keeps its bearer`);
 	}
 });
@@ -180,3 +181,24 @@ test("cloudflareErrorHint explains tunnel / Access failures", () => {
 	assert.match(cloudflareErrorHint(530, "error code: 1016", { tunnel: true }), /tunnel hostname has no matching DNS record/);
 });
 
+
+// Fixed vector independently generated with Python hashlib/hmac.
+test("openbot: envelope and signature cover the exact body and delivery ID", async () => {
+	assert.ok(PRESETS.includes("openbot"));
+	const req = (await renderWake({ preset: "openbot", url: "https://hooks.example.com/a2a", hmacSecret: "openbot-test-secret", key: "unused-key" }, ev,
+		{ nowMs: 1760000000000, requestId: "delivery-1" }))!;
+	assert.deepEqual(JSON.parse(req.body), { type: "a2a_wake", occurredAt: "2025-10-09T08:53:20.000Z", data: wakePayload(ev, "npx -y a2a-exposed@latest") });
+	assert.equal(req.headers["x-openbot-timestamp"], "1760000000");
+	assert.equal(req.headers["x-openbot-delivery-id"], "delivery-1");
+	assert.equal(req.headers["x-openbot-signature"], "sha256=8d28056bd4d5f700fd49865a0cc240bd769462d6e75aac4aa15fc7051c3ecc26");
+	assert.equal(req.headers["authorization"], undefined);
+	assert.equal(req.headers["X-Webhook-Signature-V2"], undefined);
+	const preview = redact(req);
+	assert.equal(preview.headers["x-openbot-delivery-id"], "delivery-1");
+	assert.equal(preview.headers["x-openbot-timestamp"], "1760000000");
+	assert.equal(preview.headers["x-openbot-signature"], "••••");
+	assert.ok(!JSON.stringify(preview).includes("openbot-test-secret"));
+	const unicode = (await renderWake({ preset: "openbot", url: req.url, hmacSecret: "s" }, { ...ev, preview: '雪 "quoted"\ntext' },
+		{ nowMs: 1760000000000, requestId: "delivery-2" }))!;
+	assert.equal(unicode.headers["x-openbot-signature"], "sha256=" + createHmac("sha256", "s").update(`1760000000.delivery-2.${unicode.body}`).digest("hex"));
+});