a2a-exposed 0.7.17 → 0.7.20

package/worker/test/feedback.test.ts

@@ -0,0 +1,190 @@
+// Feedback scrubbing, the owner discovery route, and the hosted post. No network.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import worker, { dispatch } from "../src/index.ts";
+import { sha256 } from "../src/a2a.ts";
+import { connectionOf, feedbackEndpoint, feedbackIssueUrl, feedbackResultText, feedbackToolDescription, scrubFeedbackText, sendFeedback, WORKER_VERSION } from "../src/feedback.ts";
+import { readFileSync } from "node:fs";
+import { hostedTenantContext, resolveTenant, type WorkerBindings } from "../src/tenancy.ts";
+import { d1 } from "./d1.ts";
+
+const BASE = "https://agent.example.com";
+
+function execution(): { ectx: ExecutionContext; done: () => Promise<unknown> } {
+	const pending: Promise<unknown>[] = [];
+	return {
+		ectx: { waitUntil(p: Promise<unknown>) { pending.push(p); }, passThroughOnException() {} } as ExecutionContext,
+		done: () => Promise.allSettled(pending),
+	};
+}
+
+function db() {
+	return d1(new URL("../migrations/", import.meta.url));
+}
+
+function selfEnv(over: Record<string, unknown> = {}): WorkerBindings {
+	return { DB: db(), PUBLIC_URL: BASE, OWNER_TOKEN: "owner-secret", AGENT_NAME: "Ada", ...over } as WorkerBindings;
+}
+
+async function call(env: WorkerBindings, path: string, headers: Record<string, string> = {}) {
+	const run = execution();
+	const res = await worker.fetch(new Request(BASE + path, { headers }), env, run.ectx);
+	await run.done();
+	const text = await res.text();
+	let data: any = text;
+	try { data = JSON.parse(text); } catch { /* html or empty */ }
+	return { status: res.status, data, text };
+}
+
+test("scrubFeedbackText removes token shapes and Bearer values", () => {
+	const token = "a2aow_" + "b".repeat(24);
+	const pem = "-----BEGIN RSA PRIVATE KEY-----\nSECRETKEYMATERIAL\n-----END RSA PRIVATE KEY-----";
+	const text = scrubFeedbackText(`token ${token} and Bearer supersecretvalue stay out ${pem} AKIAIOSFODNN7EXAMPLE`);
+	assert.equal(text.includes(token), false);
+	assert.equal(text.includes("supersecretvalue"), false);
+	assert.equal(text.includes("SECRETKEYMATERIAL"), false);
+	assert.equal(text.includes("AKIAIOSFODNN7EXAMPLE"), false);
+	assert.match(text, /\[redacted\]/);
+	assert.match(text, /Bearer \[redacted\]/);
+});
+
+test("the fallback URL prefills the bug report form", () => {
+	const url = new URL(feedbackIssueUrl({ title: "hi <there>", message: "line", logs: "Bearer supersecretvalue" }));
+	assert.equal(`${url.origin}${url.pathname}`, "https://github.com/telegraphic-dev/a2a-exposed/issues/new");
+	assert.equal(url.searchParams.get("template"), "bug_report.yml");
+	assert.equal(url.searchParams.get("body"), null);
+	assert.equal(url.searchParams.get("title"), "hi <there>");
+	assert.equal(url.searchParams.get("message"), "line");
+	assert.match(url.searchParams.get("logs") ?? "", /Bearer supersecretvalue/);
+});
+
+test("GET /owner/feedback is hosted only for a hosted tenant", async () => {
+	const env = selfEnv({ FEEDBACK_URL: "https://control.example.com" });
+	assert.equal((await call(env, "/owner/feedback")).status, 401);
+	const owned = await call(env, "/owner/feedback", { authorization: "Bearer owner-secret" });
+	assert.deepEqual(owned.data, { hosted: false, version: WORKER_VERSION, connection: "polling" });
+	assert.equal(feedbackEndpoint(resolveTenant(env)), "");
+	assert.equal(WORKER_VERSION, JSON.parse(readFileSync(new URL("../../cli/package.json", import.meta.url), "utf8")).version);
+	const waking = selfEnv({ WAKE_WEBHOOK_URL: "https://hooks.example/wake" });
+	const wakeFacts = await call(waking, "/owner/feedback", { authorization: "Bearer owner-secret" });
+	assert.equal(wakeFacts.data.connection, "webhook");
+	assert.equal(JSON.stringify(wakeFacts.data).includes("hooks.example"), false);
+	const proxy = selfEnv({ UPSTREAM_URL: "https://up.example", WAKE_WEBHOOK_URL: "https://hooks.example/wake" });
+	assert.equal(connectionOf(resolveTenant(proxy)), "proxy");
+	assert.equal(connectionOf(resolveTenant(selfEnv({ UPSTREAM_URL: "none", WAKE_WEBHOOK_URL: "https://hooks.example/wake" }))), "webhook");
+
+	const hash = await sha256("owner-secret");
+	const hostedEnv = selfEnv({
+		FEEDBACK_URL: "https://control.example.com",
+		TENANT_DOMAIN: "example.com",
+		PUBLIC_URL: "https://northwind.example.com",
+	});
+	const ctx = hostedTenantContext(hostedEnv, {
+		id: "t1", db: hostedEnv.DB, publicUrl: "https://northwind.example.com", ownerTokenHash: hash, config: { AGENT_NAME: "Ada" },
+	});
+	assert.equal(feedbackEndpoint(ctx), "https://control.example.com/api/feedback");
+	const run = execution();
+	const res = await dispatch(new Request("https://northwind.example.com/owner/feedback", {
+		headers: { authorization: "Bearer owner-secret" },
+	}), ctx, run.ectx);
+	await run.done();
+	assert.deepEqual(await res.json(), { hosted: true, url: "https://control.example.com/api/feedback", version: WORKER_VERSION, connection: "polling" });
+});
+
+test("the public-issue note names the repository in the issue URL", () => {
+	const filed = feedbackResultText({ filed: true, issue_url: "https://github.com/example-org/example-repo/issues/4" });
+	assert.match(filed, /public GitHub issue on example-org\/example-repo/);
+	assert.equal(filed.includes("telegraphic-dev/a2a-exposed"), false);
+	assert.match(filed, /Feedback filed: https:\/\/github.com\/example-org\/example-repo\/issues\/4/);
+	const form = feedbackResultText({ filed: false, issue_url: feedbackIssueUrl({ title: "hi" }) });
+	assert.match(form, /public GitHub issue on telegraphic-dev\/a2a-exposed/);
+	assert.match(feedbackToolDescription(""), /configured feedback repository/);
+	assert.equal(feedbackToolDescription("").includes("telegraphic-dev/a2a-exposed"), false);
+	assert.match(feedbackToolDescription("example-org/example-repo"), /public GitHub issue on example-org\/example-repo/);
+});
+
+test("sendFeedback does not call out from a self-hosted inbox", async () => {
+	const ctx = resolveTenant(selfEnv({ FEEDBACK_URL: "https://control.example.com" }));
+	const result = await sendFeedback(ctx, { message: "hello", kind: "other", contact: "", version: "" }, () => {
+		throw new Error("fetch should not run");
+	});
+	assert.equal(result.filed, false);
+	const fallback = new URL(result.issue_url);
+	assert.equal(`${fallback.origin}${fallback.pathname}`, "https://github.com/telegraphic-dev/a2a-exposed/issues/new");
+	assert.equal(fallback.searchParams.get("template"), "bug_report.yml");
+	assert.equal(fallback.searchParams.get("body"), null);
+	assert.equal(fallback.searchParams.get("deployment"), "self-hosted");
+	assert.equal(fallback.searchParams.get("connection"), "polling");
+	assert.equal(fallback.searchParams.get("version"), `worker ${WORKER_VERSION}`);
+	await assert.rejects(
+		() => sendFeedback(ctx, { message: "hello", kind: "bug", contact: "", version: "" }, () => {
+			throw new Error("fetch should not run");
+		}),
+		/reproduction steps/,
+	);
+});
+
+test("a hosted tenant posts through the control binding with the owner-token hash", async () => {
+	const hash = await sha256("owner-secret");
+	const seen: { host: string | null; auth: string | null; body: any }[] = [];
+	const binding = {
+		async fetch(input: RequestInfo | URL) {
+			const req = input instanceof Request ? input : new Request(String(input));
+			seen.push({ host: req.headers.get("host"), auth: req.headers.get("authorization"), body: await req.json() });
+			return Response.json({ ok: true, issue_url: "https://github.com/telegraphic-dev/a2a-exposed/issues/4" });
+		},
+	};
+	const token = "a2amcp_" + "c".repeat(24);
+	const env = selfEnv({
+		FEEDBACK_URL: "https://control.example.com",
+		TENANT_DOMAIN: "example.com",
+		PUBLIC_URL: "https://northwind.example.com",
+		CONTROL_SERVICE: binding,
+	});
+	const ctx = hostedTenantContext(env, {
+		id: "t1", db: env.DB, publicUrl: "https://northwind.example.com", ownerTokenHash: hash, config: { AGENT_NAME: "Ada" },
+	});
+	const result = await sendFeedback(ctx, {
+		message: `broke ${token}`, kind: "bug", contact: "", version: "1",
+		steps: `ran ${token}`, agent: "Claude Code", environment: "Cloudflare Worker",
+	}, () => {
+		throw new Error("public fetch should not run");
+	});
+	assert.equal(result.filed, true);
+	assert.equal(result.issue_url, "https://github.com/telegraphic-dev/a2a-exposed/issues/4");
+	assert.equal(seen.length, 1);
+	assert.equal(seen[0].host, "control.example.com");
+	assert.equal(seen[0].auth, `Bearer ${hash}`);
+	assert.equal(seen[0].body.source, "mcp");
+	assert.equal(seen[0].body.agent, "Claude Code");
+	assert.equal(seen[0].body.mode, "hosted");
+	assert.equal(seen[0].body.deployment, "hosted");
+	assert.equal(seen[0].body.connection, "polling");
+	assert.equal(seen[0].body.version, `1 (worker ${WORKER_VERSION})`);
+	assert.equal(seen[0].body.environment, "Cloudflare Worker");
+	assert.equal(seen[0].body.message.includes(token), false);
+	assert.equal(seen[0].body.steps.includes(token), false);
+	assert.match(seen[0].body.steps, /\[redacted\]/);
+
+	const missing = {
+		async fetch() { return new Response("no", { status: 404 }); },
+	};
+	const again = hostedTenantContext({ ...env, CONTROL_SERVICE: missing }, {
+		id: "t1", db: env.DB, publicUrl: "https://northwind.example.com", ownerTokenHash: hash,
+	});
+	const fell = await sendFeedback(again, { message: "still broken", kind: "bug", contact: "", version: "", steps: "open it" });
+	assert.equal(fell.filed, false);
+	const fellUrl = new URL(fell.issue_url);
+	assert.equal(fellUrl.searchParams.get("template"), "bug_report.yml");
+	assert.equal(fellUrl.searchParams.get("steps"), "open it");
+});
+
+test("the landing page footer links to the repository", async () => {
+	const env = selfEnv();
+	const run = execution();
+	const res = await worker.fetch(new Request(BASE + "/", { headers: { accept: "text/html" } }), env, run.ectx);
+	await run.done();
+	const html = await res.text();
+	assert.match(html, /<footer class="w">Served by <a href="https:\/\/github\.com\/telegraphic-dev\/a2a-exposed">a2a-exposed<\/a>\.<\/footer>/);
+	assert.equal(/<script|<link|<img|<iframe|src=/i.test(html), false);
+});

package/worker/test/mcp.test.ts

@@ -3,6 +3,7 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import worker from "../src/index.ts";
+import { WORKER_VERSION } from "../src/feedback.ts";
 import * as P from "../src/pairing.ts";
 import * as M from "../src/mcp.ts";
 import { d1 } from "./d1.ts";
@@ -327,12 +328,55 @@ test("scope: the MCP token is not an owner or peer token, and peer/owner tokens
 	assert.equal((await s.call("GET", "/mcp", { headers: { authorization: `Bearer ${a.access_token}` } })).status, 405);
 	// tools can't administer tokens or pairings
 	const names = (await s.mcp(a.access_token, "tools/list")).data.result.tools.map((x: any) => x.name);
-	assert.deepEqual(names, ["inbox", "show_task", "history", "mark_working", "reply", "send", "poll_outbound", "list_peers", "pairing_requests"]);
+	assert.deepEqual(names, ["inbox", "show_task", "history", "mark_working", "reply", "send", "poll_outbound", "list_peers", "pairing_requests", "send_feedback"]);
 	assert.ok(!names.some((n: string) => /approve|deny|token|revoke|issue|password/.test(n)));
 	const unknown = await s.mcp(a.access_token, "tools/call", { name: "approve_pairing", arguments: { code: "X" } });
 	assert.equal(unknown.data.error.code, -32602);
 });
 
+test("send_feedback returns a GitHub issue link and strips tokens", async (t) => {
+	const s = setup(); t.after(s.restore);
+	const a = await s.connect();
+	const token = "a2aot_" + "a".repeat(24);
+	const r = await s.tool(a.access_token, "send_feedback", {
+		message: `dropped a task ${token}`, kind: "bug", steps: `ran ${token}`, agent: "Claude Code", environment: "cloud agent sandbox",
+	});
+	assert.equal(r.isError, false);
+	assert.match(r.content[0].text, /public GitHub issue on telegraphic-dev\/a2a-exposed/);
+	assert.match(r.content[0].text, /confidential information/);
+	const link = r.content[0].text.split("\n").pop() ?? "";
+	const url = new URL(link);
+	assert.equal(`${url.origin}${url.pathname}`, "https://github.com/telegraphic-dev/a2a-exposed/issues/new");
+	assert.equal(url.searchParams.get("template"), "bug_report.yml");
+	assert.equal(url.searchParams.get("body"), null);
+	assert.equal((url.searchParams.get("message") ?? "").includes(token), false);
+	assert.match(url.searchParams.get("message") ?? "", /\[redacted\]/);
+	assert.match(url.searchParams.get("steps") ?? "", /ran \[redacted\]/);
+	assert.equal(url.searchParams.get("agent"), "Claude Code");
+	assert.equal(url.searchParams.get("environment"), "cloud agent sandbox");
+	assert.equal(url.searchParams.get("connection"), "webhook");
+	assert.equal(url.searchParams.get("deployment"), "self-hosted");
+	assert.equal(url.searchParams.get("version"), `worker ${WORKER_VERSION}`);
+	assert.equal((url.searchParams.get("message") ?? "").includes("hook.example.net"), false);
+	const listed = (await s.mcp(a.access_token, "tools/list")).data.result.tools.find((tool: { name: string }) => tool.name === "send_feedback");
+	assert.match(listed.description, /public GitHub issue on telegraphic-dev\/a2a-exposed/);
+	assert.match(listed.description, /Redact before sending/);
+	assert.match(listed.description, /exact commands/);
+	assert.match(listed.description, /filled by the inbox/);
+	assert.match(listed.inputSchema.properties.steps.description, /Remove tokens and secrets/);
+	assert.match(listed.inputSchema.properties.environment.description, /cloud agent sandbox/);
+	assert.match(listed.inputSchema.properties.connection.description, /webhook, proxy, or polling/);
+	assert.match(listed.inputSchema.properties.deployment.description, /self-hosted/);
+	assert.match(listed.inputSchema.properties.version.description, /Worker version/);
+	assert.equal((await s.tool(a.access_token, "send_feedback", {})).isError, true);
+	const missingSteps = await s.tool(a.access_token, "send_feedback", { message: "broke", kind: "bug" });
+	assert.equal(missingSteps.isError, true);
+	assert.match(missingSteps.content[0].text, /reproduction steps/);
+	const { token: peerTok } = await s.inbound("barry", "hello");
+	assert.equal((await s.mcp(peerTok, "tools/call", { name: "send_feedback", arguments: { message: "hi" } })).status, 401);
+	assert.equal((await s.mcp("owner-secret", "tools/call", { name: "send_feedback", arguments: { message: "hi" } })).status, 401);
+});
+
 test("JSON-RPC plumbing: notifications 202, batches and junk rejected, unknown method", async (t) => {
 	const s = setup(); t.after(s.restore);
 	const a = await s.connect();

package/worker/test/tenancy.test.ts

@@ -24,6 +24,7 @@ test("gates: unset is single-tenant and every reserved gate is off", () => {
 	assert.equal(g.wakeTargetPolicy, "");
 	assert.equal(g.signupUrl, "");
 	assert.equal(g.branding, "");
+	assert.equal(g.feedbackUrl, "");
 	assert.equal(g.dataRegion, "");
 	assert.equal(g.tenantDomain, "");
 	assert.deepEqual(g.approvalOidc, { issuer: "", clientId: "", hasClientSecret: false, allowedSubjects: [], methods: ["password"], methodsSpecified: false, label: "" });
@@ -42,6 +43,7 @@ test("gates: only exact values turn on; typos and non-https URLs stay off", () =
 	assert.equal(g.branding, "");
 	assert.equal(g.dataRegion, "");
 	assert.equal(g.signupUrl, "");
+	assert.equal(g.feedbackUrl, "");
 	assert.equal(g.approvalOidc.issuer, "");
 	assert.deepEqual(g.approvalOidc.methods, ["password"]);
 	assert.equal(g.approvalOidc.methodsSpecified, false);
@@ -50,7 +52,8 @@ test("gates: only exact values turn on; typos and non-https URLs stay off", () =
 	const on = parseGates({
 		DB: dummy, TENANCY: "host", TENANT_DO: {} as any, QUOTAS: "on", USAGE_SINK: "d1",
 		WAKE_TARGET_POLICY: "public-https", BRANDING: "hosted", DATA_REGION: "EU",
-		SIGNUP_URL: "https://example.com/start", APPROVAL_OIDC_ISSUER: "https://example.com",
+		SIGNUP_URL: "https://example.com/start", FEEDBACK_URL: "https://control.example.com",
+		APPROVAL_OIDC_ISSUER: "https://example.com",
 		APPROVAL_OIDC_CLIENT_ID: "client", APPROVAL_OIDC_CLIENT_SECRET: "secret",
 		APPROVAL_OIDC_ALLOWED_SUBJECTS: " acct_1 , acct_2 ", APPROVAL_METHODS: "oidc,password",
 		TENANT_DOMAIN: "example.com",
@@ -63,6 +66,9 @@ test("gates: only exact values turn on; typos and non-https URLs stay off", () =
 	assert.equal(on.branding, "hosted");
 	assert.equal(on.dataRegion, "eu");
 	assert.equal(on.signupUrl, "https://example.com/start");
+	assert.equal(on.feedbackUrl, "https://control.example.com");
+	assert.equal(parseGates({ DB: dummy, FEEDBACK_URL: "http://control.example.com" } as WorkerBindings).gates.feedbackUrl, "");
+	assert.equal(parseGates({ DB: dummy, FEEDBACK_URL: "https://control.example.com/api" } as WorkerBindings).gates.feedbackUrl, "");
 	assert.equal(on.approvalOidc.issuer, "https://example.com");
 	assert.equal(on.approvalOidc.hasClientSecret, true);
 	assert.deepEqual(on.approvalOidc.allowedSubjects, ["acct_1", "acct_2"]);