@hanphone/dsh-a2a 0.1.0 → 0.2.0

package/lib/index.js

@@ -175,7 +175,8 @@ const a2aDomainSpec = defineDomain({
 	tables: {
 		tasks: domainTable(json$1),
 		contexts: domainTable(json$1),
-		agents: domainTable(json$1)
+		agents: domainTable(json$1),
+		identity: domainTable(json$1)
 	}
 });
 /**
@@ -214,6 +215,9 @@ var A2aDomain = class {
 	get agents() {
 		return this.handle.table("agents");
 	}
+	get identity() {
+		return this.handle.table("identity");
+	}
 	async close() {
 		await this.handle.close();
 	}
@@ -329,6 +333,172 @@ function withState(current, state, message, timestamp) {
 	};
 }
 //#endregion
+//#region lib/types/server/inbound-registry.js
+/**
+* Inbound connection registry: which remote peers are talking to this DSH's
+* A2A server. Fed by the A2A server's `onInbound` hook (every JSON-RPC
+* request / SSE open), surfaced through the dashboard API, and disconnectable
+* (`closePeer` cancels the peer's active tasks and drops the record).
+* @module dsh-a2a/server/inbound-registry
+*/
+function newPeerId() {
+	return `peer-${crypto.randomUUID()}`;
+}
+/** In-memory inbound peer registry. */
+var LiveInboundRegistry = class {
+	peers = /* @__PURE__ */ new Map();
+	findBySource(source) {
+		if (source === null) return void 0;
+		for (const peer of this.peers.values()) if (peer.source === source) return peer;
+	}
+	/** Observe one inbound event: method, source, task ids, streaming flag. */
+	note(input) {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const source = input.source ?? null;
+		let peer = this.findBySource(source);
+		if (peer === void 0) {
+			peer = {
+				id: newPeerId(),
+				label: source ?? "unknown",
+				source,
+				firstSeen: now,
+				lastSeen: now,
+				taskCount: 0,
+				active: /* @__PURE__ */ new Set(),
+				streamingCount: 0
+			};
+			this.peers.set(peer.id, peer);
+		}
+		peer.lastSeen = now;
+		peer.taskCount += input.taskIds.length;
+		for (const id of input.taskIds) peer.active.add(id);
+		if (input.streaming) peer.streamingCount += 1;
+	}
+	/** A task settled: drop it from every peer's active set. */
+	settle(taskId) {
+		for (const peer of this.peers.values()) if (peer.active.delete(taskId)) peer.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+	}
+	/** Decrement streaming count when an SSE connection closes. */
+	endStream(source) {
+		const peer = this.findBySource(source ?? null);
+		if (peer !== void 0 && peer.streamingCount > 0) {
+			peer.streamingCount -= 1;
+			peer.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+		}
+	}
+	list() {
+		return [...this.peers.values()].map((p) => ({
+			id: p.id,
+			label: p.label,
+			source: p.source,
+			firstSeen: p.firstSeen,
+			lastSeen: p.lastSeen,
+			taskCount: p.taskCount,
+			activeTaskIds: [...p.active],
+			streaming: p.streamingCount > 0
+		})).sort((a, b) => a.lastSeen < b.lastSeen ? 1 : -1);
+	}
+	closePeer(peerId) {
+		const peer = this.peers.get(peerId);
+		if (peer === void 0) return {
+			ok: false,
+			message: `inbound peer ${peerId} not found`
+		};
+		this.peers.delete(peerId);
+		return {
+			ok: true,
+			message: `inbound peer ${peer.label} closed`
+		};
+	}
+	activeTasksOf(peerId) {
+		return [...this.peers.get(peerId)?.active ?? []];
+	}
+};
+//#endregion
+//#region lib/types/server/identity.js
+/**
+* Service identity: the inbound AgentCard's name/description/version,
+* editable at runtime from the GUI dashboard and persisted in the `a2a`
+* domain's `identity` table. Skills stay derived from the live tool registry
+* (the "card derives from ctx.tools" design); identity editing builds a fresh
+* card preserving the endpoint URL and swaps it onto the server, so routes
+* and the facade see the new value immediately.
+* @module dsh-a2a/server/identity
+*/
+const IDENTITY_KEY = "service";
+function decode(raw) {
+	if (raw === void 0) return void 0;
+	try {
+		const parsed = JSON.parse(raw);
+		if (typeof parsed.name !== "string" || typeof parsed.description !== "string" || typeof parsed.version !== "string") return;
+		return {
+			name: parsed.name,
+			description: parsed.description,
+			version: parsed.version
+		};
+	} catch {
+		return;
+	}
+}
+function encode(value) {
+	return JSON.stringify(value);
+}
+/** Read the persisted identity (undefined when never configured). */
+function readIdentity(domain) {
+	return decode(domain.identity.get(IDENTITY_KEY));
+}
+/** Persist a new identity (fire-and-forget like the task store writes). */
+function writeIdentity(domain, identity) {
+	domain.identity.put(IDENTITY_KEY, encode(identity)).catch((err) => {
+		throw new Error(`a2a: identity persistence failed: ${String(err)}`);
+	});
+}
+/**
+* Build the AgentCard options for a given base URL/path and the override
+* identity. `identity` (persisted) wins over the composition `defaults`; when
+* no identity is stored, the composition defaults stand.
+*/
+function cardOptionsFor(baseUrl, endpointPath, defaults, identity, skills, authToken) {
+	return {
+		baseUrl,
+		endpointPath,
+		name: identity?.name ?? defaults.name,
+		description: identity?.description ?? defaults.description,
+		version: identity?.version ?? defaults.version,
+		skills,
+		...authToken !== void 0 ? { authToken } : {}
+	};
+}
+/**
+* Build a fresh AgentCard from an existing one plus a new identity and skill
+* list, preserving the endpoint URL (baseUrl/path) and security scheme.
+*/
+function rebuildCardWithIdentity(card, identity, skills) {
+	return buildCard({
+		baseUrl: endpointBaseOf(card),
+		endpointPath: endpointPathOf$1(card),
+		name: identity.name,
+		description: identity.description,
+		version: identity.version,
+		skills,
+		...card.securitySchemes !== void 0 ? { authToken: "preserved-scheme" } : {}
+	});
+}
+function endpointBaseOf(card) {
+	const url = card.supportedInterfaces?.[0]?.url;
+	if (!url) return "http://127.0.0.1";
+	return url.replace(/\/[^/]*$/, "");
+}
+function endpointPathOf$1(card) {
+	const url = card.supportedInterfaces?.[0]?.url;
+	if (!url) return "/a2a";
+	try {
+		return new URL(url).pathname;
+	} catch {
+		return "/a2a";
+	}
+}
+//#endregion
 //#region lib/types/server/executor.js
 /**
 * Executor abstraction for inbound tasks: an executor turns one task into
@@ -621,6 +791,10 @@ var A2AServer = class {
 		this.opts = opts;
 		this.card = opts.card;
 	}
+	/** Swap the served AgentCard (runtime identity edits). Routes re-read `server.card` on every request. */
+	setCard(next) {
+		this.card = next;
+	}
 	/**
 	* Abort a running task by control path (facade /a2a task cancel): abort the
 	* executor's signal, settle the task CANCELED, and wake stream waiters.
@@ -790,7 +964,6 @@ var A2AServer = class {
 				const gateOutcome = await this.opts.gate(gateInputFrom(message, null));
 				if (!gateOutcome.ok) throw rpcFault(A2A_ERROR_CODES.INVALID_PARAMS, gateOutcome.reason);
 				const record = this.ensureTask(message, null);
-				this.noteInbound({ method }, method, [record.taskId], false);
 				await this.runTask(record);
 				return toTask(this.opts.store.get(record.taskId) ?? record);
 			}
@@ -1198,10 +1371,12 @@ async function handleApiRequest(req, res, impl) {
 	res.end("Method Not Allowed");
 }
 function snapshotOf(impl) {
+	const status = impl.status();
 	return {
-		server: impl.status().server,
+		server: status.server,
 		tasks: impl.listTasks(),
-		agents: impl.agents()
+		agents: impl.agents(),
+		inbounds: status.inbounds ?? []
 	};
 }
 async function dispatch(payload, impl) {
@@ -1218,6 +1393,12 @@ async function dispatch(payload, impl) {
 		case "agent.disable": return impl.setAgentEnabled(payload.id, false);
 		case "agent.refresh": return impl.refreshAgentCard(payload.id);
 		case "task.cancel": return impl.cancelTask(payload.id);
+		case "identity.update": return impl.updateIdentity({
+			...payload.name !== void 0 ? { name: payload.name } : {},
+			...payload.description !== void 0 ? { description: payload.description } : {},
+			...payload.version !== void 0 ? { version: payload.version } : {}
+		});
+		case "inbound.close": return impl.closeInbound(payload.id);
 		default: return {
 			ok: false,
 			message: `unknown action ${String(payload.action)}`
@@ -1708,6 +1889,18 @@ var A2AService = class extends Service {
 	async refreshAgentCard(id) {
 		return this.impl.refreshAgentCard(id);
 	}
+	identity() {
+		return this.impl.identity();
+	}
+	async updateIdentity(patch) {
+		return this.impl.updateIdentity(patch);
+	}
+	async closeInbound(peerId) {
+		return this.impl.closeInbound(peerId);
+	}
+	inbounds() {
+		return this.impl.inbounds();
+	}
 };
 //#endregion
 //#region lib/types/commands.js
@@ -1860,11 +2053,17 @@ function apply(ctx, config) {
 				domain,
 				store,
 				registry: void 0,
+				inbound: void 0,
 				server: void 0,
 				routes: void 0,
 				card: void 0,
 				executors: void 0,
-				enabled: serverConfig.enabled
+				enabled: serverConfig.enabled,
+				identityDefaults: {
+					name: serverConfig.name ?? "My DSH Agent",
+					description: serverConfig.description ?? "A DeepSeek Harness agent exposed over A2A v1.0",
+					version: serverConfig.version ?? "0.1.0"
+				}
 			};
 			const webServer = probeService(ctx, "webServer", "register");
 			if (webServer === void 0) logger.warn("a2a: webServer not mounted; inbound server idle");
@@ -1873,16 +2072,13 @@ function apply(ctx, config) {
 					ids: serverConfig.skills.ids,
 					exclude: serverConfig.skills.exclude
 				});
-				const card = buildCard({
-					baseUrl: serverConfig.baseUrl ?? `http://127.0.0.1:${process.env["DSH_A2A_PORT"] ?? "3000"}`,
-					endpointPath: serverConfig.endpointPath ?? "/a2a",
-					name: serverConfig.name ?? "My DSH Agent",
-					description: serverConfig.description ?? "A DeepSeek Harness agent exposed over A2A v1.0",
-					version: serverConfig.version ?? "0.1.0",
-					skills,
-					...authToken ? { authToken } : {}
-				});
+				const baseUrl = serverConfig.baseUrl ?? `http://127.0.0.1:${process.env["DSH_A2A_PORT"] ?? "3000"}`;
+				const endpointPath = serverConfig.endpointPath ?? "/a2a";
+				const persistedIdentity = readIdentity(domain);
+				const card = buildCard(cardOptionsFor(baseUrl, endpointPath, holder.identityDefaults, persistedIdentity, skills, authToken));
 				holder.card = card;
+				const inbound = new LiveInboundRegistry();
+				holder.inbound = inbound;
 				const agents = probeService(ctx, "agents", "create");
 				const presets = probeService(ctx, "agentPresets", "resolve");
 				const sessionPool = agents ? new ContextSessionPool(agents, {
@@ -1925,7 +2121,16 @@ function apply(ctx, config) {
 					executors,
 					...authToken ? { authToken } : {},
 					gate,
-					onTaskSettled: (taskId) => logger.info(`[a2a] task settled ${taskId}`)
+					onInbound: (facts) => inbound.note({
+						method: facts.method,
+						...facts.source !== void 0 ? { source: facts.source } : {},
+						taskIds: facts.taskIds,
+						streaming: facts.streaming
+					}),
+					onTaskSettled: (taskId) => {
+						logger.info(`[a2a] task settled ${taskId}`);
+						inbound.settle(taskId);
+					}
 				});
 				holder.server = server;
 				const routes = new A2aRoutes(webServer, server);
@@ -1978,10 +2183,15 @@ function makeFacade(holder, log) {
 					enabled: serverEnabled(),
 					cardUrl: holder.card?.supportedInterfaces?.[0]?.url,
 					skills: holder.card?.skills?.map((s) => s.id) ?? [],
-					executors: holder.executors ? ["session", ...holder.executors["subagent"] !== void 0 ? ["subagent"] : []] : []
+					executors: holder.executors ? ["session", ...holder.executors["subagent"] !== void 0 ? ["subagent"] : []] : [],
+					name: holder.card?.name,
+					description: holder.card?.description,
+					version: holder.card?.version,
+					configured: readIdentity(holder.domain) !== void 0
 				},
 				tasks: holder.store.list().length,
-				agents: holder.registry?.list() ?? []
+				agents: holder.registry?.list() ?? [],
+				inbounds: holder.inbound?.list() ?? []
 			};
 		},
 		async enableServer(enable) {
@@ -2045,6 +2255,51 @@ function makeFacade(holder, log) {
 				ok: false,
 				message: "outbound client not mounted"
 			};
+		},
+		identity() {
+			const current = holder.card;
+			return {
+				...readIdentity(holder.domain) ?? {},
+				defaults: holder.identityDefaults,
+				name: current?.name ?? holder.identityDefaults.name,
+				description: current?.description ?? holder.identityDefaults.description,
+				version: current?.version ?? holder.identityDefaults.version
+			};
+		},
+		async updateIdentity(patch) {
+			const card = holder.card;
+			const server = holder.server;
+			if (card === void 0 || server === void 0) return {
+				ok: false,
+				message: "inbound server not mounted (no card)"
+			};
+			const base = readIdentity(holder.domain) ?? holder.identityDefaults;
+			const next = {
+				name: patch.name?.trim() || base.name,
+				description: patch.description?.trim() || base.description,
+				version: patch.version?.trim() || base.version
+			};
+			writeIdentity(holder.domain, next);
+			const rebuilt = rebuildCardWithIdentity(card, next, card.skills ?? []);
+			server.setCard(rebuilt);
+			holder.card = rebuilt;
+			log(`[a2a] identity updated: ${next.name}`);
+			return {
+				ok: true,
+				message: `service identity updated (${next.name})`
+			};
+		},
+		async closeInbound(peerId) {
+			const inbound = holder.inbound;
+			if (inbound === void 0) return {
+				ok: false,
+				message: "inbound registry not mounted"
+			};
+			for (const taskId of inbound.activeTasksOf(peerId)) await holder.server?.abort?.(taskId);
+			return inbound.closePeer(peerId);
+		},
+		inbounds() {
+			return holder.inbound?.list() ?? [];
 		}
 	};
 }