a2a-exposed 0.7.14 → 0.7.15

package/lib/main.mjs

@@ -192,6 +192,7 @@ Control plane account (only when that deployment's login is on)
                                 that token after a confirmation and a recent sign-in. The new token is
                                 shown once on that agent's page. The previous one stops working immediately.
                                 The token is shown only when the stored hash is still that token.
+                                Deleting an agent asks for its name and a recent sign-in. A self-hosted inbox has no such delete.
                                 That page is not stored.
                                 FREE_AGENT_LIMIT=2 caps a free account at 2 agents. An account's own limit overrides it.
                                 Unset, there is no limit. The database rejects another insert.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "a2a-exposed",
-	"version": "0.7.14",
+	"version": "0.7.15",
 	"description": "Give any AI agent a public A2A (Agent2Agent) endpoint: Cloudflare Worker inbox + wake webhook or scheduled inbox checks",
 	"type": "module",
 	"bin": {

package/worker/src/export.ts

@@ -100,7 +100,7 @@ const OMIT_COLUMNS: Record<string, readonly string[]> = {
 	outbound: ["push_token_hash"],
 	mcp_grants: ["access_hash", "refresh_hash"],
 	outbound_peers: ["token_enc"],
-	device_requests: ["replaces_hash"],
+	device_requests: ["replaces_hash", "ip", "country"],
 };
 
 const SETUP_SUB = /([?&])t=[A-Za-z0-9_-]{16,}/g;
@@ -120,7 +120,7 @@ function placeholder(table: string, row: Record<string, unknown>, index: number)
 
 /**
  * A copy of `file` safe to show on the dashboard.
- * Nullable credential columns are removed, including `device_requests.replaces_hash` (the hash of the token a re-pair would replace).
+ * Nullable credential columns are removed, including `device_requests.replaces_hash` (the hash of the token a re-pair would replace) and `device_requests.ip` and `device_requests.country` (the requester's address).
  * `peers.token_hash` and `device_requests.device_hash` are NOT NULL, so they become `redacted:…` (not the hash, and not a token that authenticates).
  * `oauth_codes` and `oidc_txns` are emptied. The approval-password row and the password-setup row (its value is the hash of the live setup token) are removed.
  * Token-shaped text, including a hosted owner token (`a2aot_`), is scrubbed. The input is not changed: the CLI dump stays complete.

package/worker/src/hosted.ts

@@ -269,6 +269,9 @@ export class TenantStore extends DurableObject<WorkerBindings> {
 	async pushConfig(body: TenantConfigPush): Promise<{ version: number; applied: boolean }> {
 		return await this.ctx.blockConcurrencyWhile(async () => {
 			checkPush(body);
+			const deleted = await (this.ctx.storage as unknown as { get(key: string): Promise<unknown> }).get("tenant_deleted");
+			// deleteStorage leaves this key after wiping SQL. A later push must not recreate the agent.
+			if (deleted != null) return { version: 0, applied: false };
 			const current = this.#row ?? readRow(this.#sql);
 			if (current && body.version <= current.version) {
 				// A previous push may have stored this version and then failed while migrating. Catch up; don't rewrite the row.
@@ -322,6 +325,30 @@ export class TenantStore extends DurableObject<WorkerBindings> {
 		return { configured: this.#row !== null, version: this.#row?.version ?? 0, tables: appTables(this.#sql) };
 	}
 
+	/**
+	 * Drop this object's alarm and storage. A second call on an empty object succeeds.
+	 * Not an owner HTTP route. Self-host never calls it.
+	 */
+	async deleteStorage(): Promise<{ deleted: true }> {
+		return await this.ctx.blockConcurrencyWhile(async () => {
+			const storage = this.ctx.storage as unknown as {
+				deleteAlarm(): Promise<void>;
+				deleteAll(): Promise<void>;
+				put(key: string, value: string): Promise<void>;
+			};
+			const tenantId = this.#row?.tenantId ?? null;
+			await storage.deleteAlarm();
+			await storage.deleteAll();
+			const left = readRow(this.#sql);
+			if (left) throw new Error("deleteStorage: data remains");
+			// After SQL is gone. A later pushConfig sees this and does not recreate the agent.
+			await storage.put("tenant_deleted", "1");
+			this.#row = null;
+			console.log(JSON.stringify({ ts: new Date().toISOString(), event: "tenant_storage_deleted", tenant: tenantId }));
+			return { deleted: true };
+		});
+	}
+
 	/** SQL dump of the application tables. Refuses an object that has no config row. */
 	async exportSql(): Promise<{ sql: string; exportedAt: string }> {
 		return await this.ctx.blockConcurrencyWhile(async () => {

package/worker/test/export.test.ts

@@ -88,7 +88,7 @@ test("redactExport drops credential material and leaves the full dump unchanged"
 	await DB.prepare("INSERT INTO settings (key, value) VALUES ('approval_password', ?)").bind(JSON.stringify({ hash: "x".repeat(40) })).run();
 	await DB.prepare("INSERT INTO settings (key, value) VALUES ('password_setup', ?)").bind(JSON.stringify({ hash: setupHash, createdMs: 1, expiresMs: 2, failures: 0 })).run();
 	await DB.prepare("INSERT INTO settings (key, value) VALUES ('theme', 'kept')").run();
-	await DB.prepare("INSERT INTO device_requests (device_hash, user_code, status, created_ms, expires_ms, interval_s, replaces_label, replaces_hash) VALUES ('device-hash-secret', 'WDJB4827', 'pending', 1, 2, 5, 'ada', ?)").bind(replaces).run();
+	await DB.prepare("INSERT INTO device_requests (device_hash, user_code, status, created_ms, expires_ms, interval_s, replaces_label, replaces_hash, ip, country) VALUES ('device-hash-secret', 'WDJB4827', 'pending', 1, 2, 5, 'ada', ?, '203.0.113.50', 'XQ')").bind(replaces).run();
 	await DB.prepare("INSERT INTO oauth_codes (code_hash, client_id, redirect_uri, code_challenge, scope, resource, created_ms, expires_ms) VALUES ('code-hash', 'client', 'https://client.example/cb', 'challenge-secret-value', 'mcp', 'https://agent.example/mcp', 1, 2)").run();
 	await DB.prepare("INSERT INTO mcp_grants (label, client_id, scope, access_hash, refresh_hash, created_at) VALUES ('mcp-claude', 'client', 'mcp', 'access-hash-secret', 'refresh-hash-secret', ?)").bind(now).run();
 	await DB.prepare("INSERT INTO outbound_peers (alias, url, token_enc, created_at, updated_at) VALUES ('ada', 'https://ada.example', 'ciphertext-secret-value', ?, ?)").bind(now, now).run();
@@ -97,12 +97,16 @@ test("redactExport drops credential material and leaves the full dump unchanged"
 	const redacted = redactExport(file);
 	assert.equal(file.tables.peers?.[0]?.token_hash, hash, "the CLI dump still has the hash");
 	assert.equal(file.tables.device_requests?.[0]?.replaces_hash, replaces);
+	assert.equal(file.tables.device_requests?.[0]?.ip, "203.0.113.50");
+	assert.equal(file.tables.device_requests?.[0]?.country, "XQ");
 	assert.equal(file.tables.settings?.some((row) => row.key === "password_setup"), true);
 	assert.equal(file.tables.oidc_txns?.[0]?.verifier, "verifier-secret-value");
 	assert.equal(redacted.tables.peers?.[0]?.token_hash, "redacted:ada");
 	assert.equal(redacted.tables.peers?.[0]?.label, "ada");
 	assert.equal(redacted.tables.device_requests?.[0]?.device_hash, "redacted:WDJB4827");
 	assert.equal(redacted.tables.device_requests?.[0]?.replaces_hash, undefined);
+	assert.equal(Object.hasOwn(redacted.tables.device_requests?.[0] ?? {}, "ip"), false);
+	assert.equal(Object.hasOwn(redacted.tables.device_requests?.[0] ?? {}, "country"), false);
 	assert.equal(redacted.tables.device_requests?.[0]?.replaces_label, "ada");
 	assert.equal(redacted.tables.device_requests?.[0]?.user_code, "WDJB4827");
 	assert.equal(redacted.tables.tasks?.[0]?.push_configs_json, undefined);
@@ -130,6 +134,8 @@ test("redactExport drops credential material and leaves the full dump unchanged"
 	assert.equal(sql.includes("oauth_codes"), false);
 	assert.equal(sql.includes("oidc_txns"), false);
 	assert.equal(sql.includes("replaces_hash"), false);
+	assert.equal(sql.includes("203.0.113.50"), false);
+	assert.equal(sql.includes("XQ"), false);
 	assert.equal(sql.includes("password_setup"), false);
 	assert.equal(ownerResponseLeaks({ sql }), false);
 	for (const secret of [token, owner, hash, replaces, setupHash]) {
@@ -138,6 +144,8 @@ test("redactExport drops credential material and leaves the full dump unchanged"
 	assert.match(toSql(file), /verifier-secret-value/);
 	assert.match(toSql(file), new RegExp(hash));
 	assert.match(toSql(file), /replaces_hash/);
+	assert.match(toSql(file), /203\.0\.113\.50/);
+	assert.match(toSql(file), /'XQ'/);
 });
 
 test("scrubSecretText redacts a hosted owner token on the log and export paths", () => {
@@ -173,19 +181,36 @@ test("redactExport removes device_requests.replaces_hash", () => {
 				status: "pending",
 				replaces_label: "ada",
 				replaces_hash: replaces,
+				ip: "203.0.113.50",
+				country: "XQ",
 			}],
 		},
 	});
 	const row = redacted.tables.device_requests?.[0] ?? {};
 	assert.equal(Object.hasOwn(row, "replaces_hash"), false);
+	assert.equal(Object.hasOwn(row, "ip"), false);
+	assert.equal(Object.hasOwn(row, "country"), false);
 	assert.equal(row.replaces_label, "ada");
 	assert.equal(row.device_hash, "redacted:WDJB4827");
 	const sql = toSql(redacted, { skip: REDACTED_SQL_SKIP });
 	assert.equal(sql.includes("replaces_hash"), false);
+	assert.equal(sql.includes("203.0.113.50"), false);
 	assert.equal(sql.includes(replaces), false);
 	assert.equal(JSON.stringify(redacted).includes(replaces), false);
 });
 
+test("self-host owner HTTP has no delete route", async () => {
+	const DB = db();
+	const env = { DB, PUBLIC_URL: BASE, OWNER_TOKEN: "owner-secret" };
+	const res = await worker.fetch(new Request(BASE + "/owner/delete", {
+		method: "POST",
+		headers: { authorization: "Bearer owner-secret" },
+	}) as never, env as never, ectx as never);
+	assert.equal(res.status, 404);
+	const tables = await DB.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'peers'").all<{ name: string }>();
+	assert.equal(tables.results.length, 1);
+});
+
 test("exportRows reads every application table in one batch", async () => {
 	const DB = db();
 	await DB.prepare("INSERT INTO peers (label, token_hash, created_at) VALUES ('ada', 'h', 't')").run();

package/worker/test/hosted.test.ts

@@ -750,3 +750,58 @@ test("TenantStore.owner runs an allowlisted owner call and does not return a pee
 	assert.equal(await saw('"reason":"account"'), true);
 	assert.equal(lines.some((l) => l.includes("../acct")), false);
 });
+
+test("TenantStore.deleteStorage wipes the object and a second call succeeds", async (t) => {
+	const mf = await start({
+		bindings: {
+			TENANCY: "host",
+			TENANT_DOMAIN: "example.com",
+			OWNER_TOKEN: "platform-owner",
+		},
+		kvNamespaces: { TENANT_DIRECTORY: "tenants-delete" },
+		durableObjects: { TENANT_DO: { className: "TenantStore", useSQLite: true } },
+	});
+	t.after(() => mf.dispose());
+	await mf.ready;
+	const kv = await mf.getKVNamespace("TENANT_DIRECTORY");
+	const ns = await mf.getDurableObjectNamespace("TENANT_DO");
+	const hash = await sha256("owner-delta");
+	type Stub = {
+		pushConfig(body: Record<string, unknown>): Promise<{ version: number; applied: boolean }>;
+		deleteStorage(): Promise<{ deleted: boolean }>;
+		storageStatus(): Promise<{ configured: boolean; tables: string[] }>;
+	};
+	const stub = ns.get(ns.idFromName("id-delta")) as unknown as Stub;
+	await stub.pushConfig({
+		version: 1, tenantId: "id-delta", name: "delta", status: "active", ownerTokenHash: hash,
+		config: { AGENT_NAME: "delta" },
+	});
+	await kv.put("tenant:delta", JSON.stringify({ id: "id-delta", status: "active", region: "default", version: 1 }));
+	const before = await stub.storageStatus();
+	assert.equal(before.configured, true);
+	assert.ok(before.tables.includes("tenant_config"));
+	const http = await mf.dispatchFetch("https://delta.example.com/owner/delete", {
+		method: "POST",
+		headers: { authorization: "Bearer owner-delta" },
+	});
+	assert.equal(http.status, 404);
+	assert.equal((await stub.storageStatus()).configured, true, "the owner HTTP API does not wipe storage");
+	const wiped = await stub.deleteStorage();
+	assert.equal(wiped.deleted, true);
+	const after = await stub.storageStatus();
+	assert.equal(after.configured, false);
+	assert.deepEqual(after.tables, []);
+	const again = await stub.deleteStorage();
+	assert.equal(again.deleted, true);
+	assert.equal((await stub.storageStatus()).configured, false);
+	assert.deepEqual((await stub.storageStatus()).tables, []);
+	const refused = await stub.pushConfig({
+		version: 2, tenantId: "id-delta", name: "delta", status: "active", ownerTokenHash: hash,
+		config: { AGENT_NAME: "delta" },
+	});
+	assert.equal(refused.applied, false);
+	assert.equal(refused.version, 0);
+	const stayed = await stub.storageStatus();
+	assert.equal(stayed.configured, false);
+	assert.deepEqual(stayed.tables, []);
+});