@zvada/agent-server 0.3.2 → 0.3.4

package/src/server/agent-server.ts

@@ -111,16 +111,31 @@ export class AgentServer {
 		if (this.shuttingDown) return;
 		this.shuttingDown = true;
 		// Drain first so cancelled turns still broadcast their turn.ended.
-		await this.runtime.shutdown();
-		for (const transport of [...this.transports]) transport.close();
-		this.options.onShutdown?.();
+		// The drain (and each transport's close) is a library extension point
+		// that may throw; the finally still closes every transport and runs the
+		// host hook even then — every other external call in this file is
+		// defended the same way (broadcast/observers/sink/handleLine).
+		try {
+			await this.runtime.shutdown();
+		} finally {
+			for (const transport of [...this.transports]) {
+				try {
+					transport.close();
+				} catch {
+					// One faulty transport's close must not skip the others or the
+					// host's shutdown hook — same isolation broadcast uses for send.
+				}
+			}
+			this.options.onShutdown?.();
+		}
 	}
 
 	private async handleLine(transport: WireTransport, line: string): Promise<void> {
 		if (!line.trim()) return;
 		const msg = decodeWireMessage(line);
 		if (msg.kind === "invalid") {
-			transport.send(encodeErrorResponse(null, WIRE_ERROR_CODES.parseError, msg.error));
+			const code = msg.parseError ? WIRE_ERROR_CODES.parseError : WIRE_ERROR_CODES.invalidRequest;
+			transport.send(encodeErrorResponse(null, code, msg.error));
 			return;
 		}
 		// Clients only send requests on this wire; stray notifications/responses
@@ -375,7 +390,10 @@ export class AgentServer {
 
 			case WIRE_METHODS.shutdown: {
 				transport.send(encodeResponse(id, {}));
-				await this.shutdown();
+				// The success ack is already committed on the wire; a throw out of
+				// shutdown() must not reach handleLine's catch and emit a second
+				// response for this id (a JSON-RPC 2.0 violation).
+				await this.shutdown().catch(() => {});
 				return;
 			}
 

package/src/server/bin.ts

@@ -11,6 +11,7 @@
 //   agent-server install             # prefetch the pinned agent CLIs
 //
 // All logs go to stderr; stdout is reserved for the wire in stdio mode.
+import pkg from "../../package.json" with { type: "json" };
 import {
 	KNOWN_ACP_AGENTS,
 	type ProvisionMode,
@@ -19,13 +20,14 @@ import {
 } from "../core/index.ts";
 import { isAgentHarness } from "../protocol/index.ts";
 import { AgentServer } from "./agent-server.ts";
+import { runFeedback } from "./feedback.ts";
 import { runInstall } from "./install.ts";
 import { dial, listen, stdioTransport } from "./transports.ts";
 
-const VERSION = "0.1.0";
+const VERSION: string = pkg.version;
 
 interface Args {
-	command: "serve" | "install";
+	command: "serve" | "install" | "feedback";
 	mode: "stdio" | "listen" | "dial" | "acp";
 	listen?: { hostname?: string; port: number };
 	dialUrl?: string;
@@ -33,21 +35,27 @@ interface Args {
 	acpAgent?: string;
 	bufferSize?: number;
 	provisionMode?: ProvisionMode;
+	feedback?: { message?: string; category?: string; subject?: string; resume?: string };
 }
 
 function usage(exitCode: number): never {
 	console.error(
 		[
-			"usage: agent-server [install] [--listen [host:]port | --dial <ws-url>] [options]",
+			"usage: agent-server [install|feedback] [--listen [host:]port | --dial <ws-url>] [options]",
 			"",
 			"  (default)              serve NDJSON JSON-RPC on stdio",
 			"  --acp                  speak ACP v1 on stdio instead (be the agent)",
 			"  install                download the pinned agent CLIs into the managed cache",
 			"                         (always downloads — run at image build time to erase",
 			"                         sandbox cold starts; --provision applies to serving only)",
+			'  feedback "<report>"    report friction to the agent-server maintainers',
+			"                         (--category api|cli|docs|other, --subject <exact item>,",
+			"                         --resume <threadId>; no auth; structured eval reports",
+			"                         ride `npx hivenet --to agent-server --task ...`)",
 			"  --listen [host:]port   accept WebSocket clients",
 			"  --dial <ws-url>        dial out to a consumer (auto-reconnect)",
 			"  --harness <a,b>        restrict harnesses (default: all installed)",
+			"  --acp-agent <spec>     ACP agent: known name (pi|gemini) or launch command",
 			"  --provision <mode>     CLI provisioning: auto | pinned | system (default auto)",
 			"  --buffer <n>           replay buffer size per session (default 4096)",
 			"  --version, --help",
@@ -69,7 +77,17 @@ function parseArgs(argv: string[]): Args {
 			return v;
 		};
 		if (arg === "install" && i === 0) args.command = "install";
-		else if (arg === "--stdio") args.mode = "stdio";
+		else if (arg === "feedback" && i === 0) {
+			args.command = "feedback";
+			args.feedback = {};
+		} else if (args.command === "feedback" && args.feedback) {
+			if (arg === "--category") args.feedback.category = next();
+			else if (arg === "--subject") args.feedback.subject = next();
+			else if (arg === "--resume") args.feedback.resume = next();
+			else if (!arg.startsWith("--") && args.feedback.message === undefined)
+				args.feedback.message = arg;
+			else usage(1);
+		} else if (arg === "--stdio") args.mode = "stdio";
 		else if (arg === "--acp") args.mode = "acp";
 		else if (arg === "--listen") {
 			args.mode = "listen";
@@ -80,7 +98,11 @@ function parseArgs(argv: string[]): Args {
 			args.mode = "dial";
 			args.dialUrl = next();
 		} else if (arg === "--harness") args.harnesses = next().split(",").filter(Boolean);
-		else if (arg === "--provision") {
+		else if (arg === "--acp-agent" || arg.startsWith("--acp-agent=")) {
+			const spec = arg === "--acp-agent" ? next() : arg.slice(12);
+			if (!spec.trim() || spec.startsWith("-")) usage(1);
+			args.acpAgent = spec;
+		} else if (arg === "--provision") {
 			const mode = next();
 			if (mode !== "auto" && mode !== "pinned" && mode !== "system") usage(1);
 			args.provisionMode = mode;
@@ -98,6 +120,19 @@ function parseArgs(argv: string[]): Args {
 
 const args = parseArgs(process.argv.slice(2));
 
+if (args.command === "feedback") {
+	const message = args.feedback?.message;
+	if (!message) usage(1);
+	try {
+		const result = await runFeedback({ ...args.feedback, message, clientVersion: VERSION });
+		for (const line of result.lines) console.error(line);
+		process.exit(0);
+	} catch (error) {
+		console.error(`feedback failed: ${error instanceof Error ? error.message : String(error)}`);
+		process.exit(1);
+	}
+}
+
 const harnesses = args.harnesses?.map((h) => {
 	if (isAgentHarness(h)) return h;
 	if (KNOWN_ACP_AGENTS[h]) {

package/src/server/feedback.ts

@@ -0,0 +1,76 @@
+// `agent-server feedback` — report friction to the maintainers over hivenet.
+//
+// Deliberately zero-dep (raw fetch, no `hivenet` package): the compiled
+// single-binary deploys have no npm/npx, so this subcommand is the only
+// feedback path there. Wire shape per hivenet's v1 feedback API.
+
+const ENDPOINT = "https://hivenet.app/v1/feedback";
+const PROJECT = "agent-server";
+const TIMEOUT_MS = 10_000;
+
+export interface FeedbackOptions {
+	message: string;
+	/** Suggested: api | cli | docs | other. Defaults to cli. */
+	category?: string;
+	/** The exact item: export, error code, harness, or command. */
+	subject?: string;
+	/** Continue an existing thread instead of opening a new one. */
+	resume?: string;
+	clientVersion?: string;
+	/** Injectable transport boundary for tests. */
+	fetchImpl?: (url: string, init: RequestInit) => Promise<Response>;
+}
+
+export interface FeedbackResult {
+	threadId: string;
+	/** Human-readable lines to print (thread id, guidance, ask). */
+	lines: string[];
+}
+
+/** POST one feedback report; returns the lines the CLI should print. */
+export async function runFeedback(options: FeedbackOptions): Promise<FeedbackResult> {
+	const doFetch = options.fetchImpl ?? fetch;
+	const threadId = options.resume ?? crypto.randomUUID().replaceAll("-", "");
+	const response = await doFetch(ENDPOINT, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({
+			v: 1,
+			to: PROJECT,
+			feedback: options.message,
+			category: options.category ?? "cli",
+			...(options.subject ? { subject: options.subject } : {}),
+			thread: { id: threadId },
+			client: { name: "agent-server-cli", version: options.clientVersion ?? "0" },
+			consent: { telemetry: false },
+		}),
+		signal: AbortSignal.timeout(TIMEOUT_MS),
+	});
+	if (!response.ok) {
+		throw new Error(`feedback rejected: ${response.status} ${await safeText(response)}`);
+	}
+	const body = (await response.json()) as {
+		thread?: string;
+		guidance?: string;
+		ask?: { prompt?: string; command?: string };
+	};
+	const thread = body.thread ?? threadId;
+	const lines = [
+		`delivered to ${PROJECT} (thread ${thread})`,
+		`continue this thread: agent-server feedback --resume ${thread} "<follow-up>"`,
+	];
+	if (body.guidance) lines.push(`guidance from the maintainers: ${body.guidance}`);
+	if (body.ask?.prompt) {
+		lines.push(`the maintainers ask: ${body.ask.prompt}`);
+		if (body.ask.command) lines.push(`  answer (only if grounded): ${body.ask.command}`);
+	}
+	return { threadId: thread, lines };
+}
+
+async function safeText(response: Response): Promise<string> {
+	try {
+		return (await response.text()).slice(0, 200);
+	} catch {
+		return "";
+	}
+}