@hediet/linkrpc-cli 0.0.3-next.20261006.1 → 0.0.3-next.20261006.2

package/README.md

@@ -267,6 +267,17 @@ Every endpoint is a valid `new URL()` — safe in env vars and logs:
 | `cmd:?command=…` / `cmd:?argv=…&argv=…`   | spawn-as-server (`--endpoint-cmd`)         |
 | `cmd-stdio:?command=…` / `?argv=…&argv=…` | spawn over stdio (`--endpoint-cmd-stdio`)  |
 
+`cmd:` children can use `startEndpoint({ onConnection })` without parsing any
+transport flags: the parent injects `LINKRPC_ENDPOINT` and `LINKRPC_TOKEN`.
+The CLI accepts one authenticated callback connection and exposes the child's
+interfaces directly. It does not wait for a hub service-namespace claim.
+The existing root overlay still supplies namespace (`local`) and optional
+provisioned-identity services for hub-aware children. Full routing-hub startup
+remains a separate `connectViaLocalHub` helper.
+Child stdout/stderr are diagnostics and appear on the CLI's stderr; parent stdout
+remains reserved for command results. Startup fails if the child exits, cannot
+spawn, or does not connect within 10 seconds.
+
 The command payload is either a single verbatim string (`?command=node%20server.js`,
 split by the OS shell) or repeated, structure-preserving `argv` params
 (`?argv=node&argv=server.js`).
@@ -411,7 +422,7 @@ initial document:
 | `call <method> [--param k=v]... [--params <json>\|-]` | Invoke a request. Method is form 1/2/3 (`send`, `iface::send`, `svc::iface::send`). Validates params against the live schema by default; pass `--no-validate` to skip. Use `@hash` on the method ref (e.g. `iface::send@a3f2b1`) to look up a pinned schema version for local validation. Reads stdin for `--params -`. |
 | `notify <method> ...`                                 | Fire-and-forget notification. Same flags as `call`.                                                                                                                                                                                                                                                                     |
 | `batch --call <method> ... [--notify <method> ...]`   | Run multiple calls and notifications sequentially on one connection. `--params`, repeatable `--param`, and `--no-validate` apply to the preceding operation. Fails fast unless `--continue-on-error` is set. Results are one JSON array; stream chunks are labeled on stderr. |
-| `connection create [--timeout 30s] [--ttl 5min] [--schema source]` | Open the configured remote once in a detached broker and print its authenticated local `unix:` / `npipe:` endpoint. `--timeout` is transport inactivity; `--ttl` is an absolute lifetime. `--schema` overlays static LinkRPC reflection from a local JSON file or an HTTP(S) URL. |
+| `connection create --timeout <duration\|inf> [--ttl <duration\|inf>] [--schema source]` | Open the configured remote once in a detached broker and print its authenticated local `unix:` / `npipe:` endpoint. Explicitly supply at least one of `--timeout` (transport inactivity) or `--ttl` (absolute lifetime). Omitted limits are `inf`. `--schema` overlays static LinkRPC reflection from a local JSON file or an HTTP(S) URL. |
 | `connection status`                                   | Read lifecycle and buffer status from the broker configured by the effective endpoint. |
 | `connection notifications [--after n] [--wait 25s] [--follow]` | Read incoming remote notifications from the broker's bounded buffer. `--follow` emits one JSON object per line and can run alongside calls. |
 | `connection destroy`                                  | Stop the configured connection broker through its local overlay. |
@@ -490,6 +501,45 @@ hub batch \
 
 ### Persistent connections
 
+Every `connection create` (including the legacy `connect` alias and context-owned
+connections) requires an explicit `--timeout` or `--ttl`. Stored context limits
+do not satisfy this requirement or supply omitted limits: each omitted limit is
+`inf`. Both flags accept durations such as `250ms`, `30s`, `5min`, or `2h`, or the
+literal `inf`. Finite limits must fit a Node timer (1 through 2147483647 ms).
+Unlimited limits schedule no timer; status reports their `timeoutMs`/`ttlMs` as
+the JSON string `"inf"`, while finite values remain millisecond numbers.
+Broker startup has a separate 60-second readiness deadline; `inf` does not
+disable startup error detection.
+Command-environment endpoints also retain their existing 10-second deadline for
+the spawned application to connect back. This is distinct from the transport
+initialize handshake and the broker's lifetime limits. A slow application must
+establish its endpoint before that deadline. Startup failures report the broker's
+underlying error, including the last 16384 characters of command-environment child
+stdout/stderr, rather than only the broker process's exit code.
+
+Use a folder context to own the broker without environment overrides:
+
+```sh
+rpc --endpoint-cmd "node ./server.js" connection create --timeout inf --new-context .
+rpc call example::ping --no-validate
+rpc context remove --context .
+```
+
+Only `connection create --new-context <selector>` assigns ownership. Removing
+that context, replacing its endpoint/token/config, or unsetting the owned endpoint
+or token stops the owned broker before saving the mutation. This also applies to
+persisted `--context-set` overrides. Unrelated edits and temporary overrides do
+not stop it. Saving an existing endpoint or deriving another context with
+`--new-context` does not transfer or duplicate ownership.
+
+Already-stopped local brokers permit cleanup. Authentication, RPC, permission,
+and other shutdown errors fail explicitly and preserve the context for retry.
+The shutdown RPC has a five-second response deadline.
+If saving fails after shutdown, the old context remains available for cleanup.
+Contexts created by older versions have no ownership metadata and are not
+automatically stopped. An unlimited broker without an owning context must be
+stopped explicitly with `connection destroy`.
+
 `connection create` keeps one remote transport open in a detached process. It prints the
 actual local socket endpoint; store that endpoint in `LINKRPC_ENDPOINT` for later
 commands:

package/dist/chunks/{cli-yDtBqjCT.js → cli-JE4URhh3.js}

@@ -1,4 +1,4 @@
-import { A as connectViaRootOverlay, C as findMethodInSchema, D as formatPrincipalSource, E as logoutCliIdentity, F as describeSchema, H as mcpForwardInterface, I as explainValidation, L as validateValueAgainstSchema, M as resolveTargetEndpoint, N as resolvedEndpointToConfig, O as parsePrincipalSpec, P as describeObjectParams, S as fetchSchema$1, V as MethodRefWithOptHash, a as resolveStaticHubSchemaSource, b as setupSigning, c as resolveInvocationEndpoint, d as formatContextReference, i as loadStaticHubSchema, j as connectViaTransport, k as connect, l as validationDefault, n as StaticHubReflection, o as mutationReference, p as resolveCliInvocation, r as withStaticHubReflection, s as resolveInvocationContext, t as completeForLine, u as ContextStore, v as requestReflectionAccess, w as walkHub, x as fetchDefaults, y as requestTopologyAccess, z as mergeParams } from "./runComplete-CM1sMWnI.js";
+import { A as fetchSchema$1, B as resolveTargetEndpoint, D as requestTopologyAccess, E as requestReflectionAccess, F as formatPrincipalSource, G as validateValueAgainstSchema, H as describeObjectParams, I as parsePrincipalSpec, L as connect, M as walkHub, O as setupSigning, P as logoutCliIdentity, R as connectViaRootOverlay, U as describeSchema, V as resolvedEndpointToConfig, W as explainValidation, X as mcpForwardInterface, Y as MethodRefWithOptHash, _ as parseConnectionLimit, a as resolveInvocationContext, c as ContextStore, d as getBrokerStatus, f as readBrokerNotifications, g as withStaticHubReflection, h as tunnelCommand, i as mutationReference, j as findMethodInSchema, k as fetchDefaults, l as formatContextReference, m as ConnectionBroker, n as loadStaticHubSchema, o as resolveInvocationEndpoint, p as stopConnectionBroker, q as mergeParams, r as resolveStaticHubSchemaSource, s as validationDefault, t as completeForLine, u as disconnectBroker, v as parseConnectionLimitMilliseconds, x as resolveCliInvocation, y as parseDuration, z as connectViaTransport } from "./runComplete-DvUneaDU.js";
 import { a as derived, i as autorun, r as observableValue } from "./dist-BOcSU4-O.js";
 import { ErrorCode, INTERFACE_TEMPLATES_EXTENSION, LinkRpcConnection, RpcError, computeInterfaceHash, connectTransports, createSchemaToZod, exportStaticHubSchema, generateTsContract, generateTsInterface, interfaceTemplateArgumentsEquivalent, interfaceTemplateMemberName, isAssignable, jcsCanonicalize } from "@hediet/linkrpc";
 import { WebSocketTransport, connectNdjson, formatEndpointUri, isHubEndpoint, openWebSocket, parseEndpointUri, runInitializeHandshake, traceMessageTransport as traceMessageTransport$1 } from "@hediet/linkrpc/node";
@@ -11,7 +11,7 @@ import { spawnCommand } from "@hediet/linkrpc-hub/spawn";
 import { tapTransport } from "@hediet/linkrpc-hub/hub/server/transit";
 import * as net from "node:net";
 import { mkdir, open, readFile, writeFile } from "node:fs/promises";
-import { DEFAULT_WALK_DEPTH, HubDirectoryExplorer, fetchSchema, hubGrantedServiceIdInterface, hubServiceIdRegistryInterface } from "@hediet/linkrpc/hub/common";
+import { DEFAULT_WALK_DEPTH, HubDirectoryExplorer, fetchSchema, hubGrantedServiceIdInterface } from "@hediet/linkrpc/hub/common";
 import { Command, InvalidArgumentError } from "commander";
 import { bootstrapApprovalCapability, createHubApprovalClient } from "@hediet/linkrpc-infra/approval";
 import { connectionTokenBinderInterface } from "@hediet/linkrpc-hub/hub/server/connection-token-binder";
@@ -717,340 +717,6 @@ function getErrorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 //#endregion
-//#region src/commands/tunnel.ts
-/**
-* The wire method for the provenance claim front door. Mirrors
-* `Hub.registerServiceIdNamespace`, which calls
-* `connection.get(hubGrantedServiceIdInterface).register({ serviceId })`
-* with no serviceId prefix — i.e. interface-form
-* `hubGrantedServiceId::register`. The claimed serviceId must be
-* within the connection's granted namespace.
-*/
-const CLAIM_METHOD$1 = `${hubGrantedServiceIdInterface.info.id}::register`;
-const GET_CLAIM_NAMESPACE_METHOD = `${hubGrantedServiceIdInterface.info.id}::get`;
-const GET_HUB_SERVICE_ID_METHOD = `${hubGrantedServiceIdInterface.info.id}::getHubServiceId`;
-/**
-* Run a transparent service tunnel until stopped.
-*
-* Claims `serviceId` on {@link TunnelOptions.local} via the hub claim
-* interface, then forwards every inbound request/notification verbatim onto
-* {@link TunnelOptions.remote} and pipes the response back. Forwarding is
-* signature-preserving: the original caller's `$hubrpc` envelope rides inside
-* `params`, so the remote send is issued unsigned (`signerOverride: null`) to
-* avoid re-wrapping it. The streaming sub-protocol is bridged both ways, so
-* long-running / streaming calls forward their in-flight stream messages and
-* cancellation, not just the final response.
-*
-* When {@link TunnelOptions.bidi} is set, the mirror forwarder is also bound on
-* {@link TunnelOptions.remote}, so every request/notification the endpoint
-* emits is forwarded verbatim back to the hub.
-*
-* Resolves when {@link TunnelOptions.stop} resolves (or on `SIGINT`/`SIGTERM`).
-*/
-async function tunnelCommand(opts) {
-	const log = opts.log ?? ((line) => process.stderr.write(line + "\n"));
-	opts.local.setRequestHandler(createForwardingHandler(opts.remote));
-	if (opts.bidi) opts.remote.setRequestHandler(createForwardingHandler(opts.local));
-	await _claimServiceId(opts.local, opts.serviceId);
-	log(opts.bidi ? `tunnel: claimed '${opts.serviceId}' — forwarding requests to remote (bidirectional)` : `tunnel: claimed '${opts.serviceId}' — forwarding requests to remote`);
-	await (opts.stop ?? _untilSignalled$2());
-	log("tunnel: stopping");
-}
-/**
-* Build the inbound handler that forwards every request/notification received
-* on one connection onto `to`, bridging the streaming sub-protocol both ways
-* (see {@link _forwardRequest}). Used for the source→target direction and, in
-* bidirectional mode, the mirror.
-*/
-function createForwardingHandler(to) {
-	return {
-		handleRequest: (call) => _forwardRequest(to, call),
-		handleNotification: (call) => _forwardNotification(to, call)
-	};
-}
-async function _claimServiceId(local, serviceId) {
-	const namespaceRes = await local.channel.sendRequest(GET_CLAIM_NAMESPACE_METHOD, {});
-	if (_isServiceIdUnder(serviceId, typeof namespaceRes === "object" && namespaceRes !== null && "grantedServiceIdNamespace" in namespaceRes && typeof namespaceRes.grantedServiceIdNamespace === "string" ? namespaceRes.grantedServiceIdNamespace : "")) {
-		await local.channel.sendRequest(CLAIM_METHOD$1, { serviceId });
-		return;
-	}
-	const hubIdRes = await local.channel.sendRequest(GET_HUB_SERVICE_ID_METHOD, {});
-	const hubServiceId = typeof hubIdRes === "object" && hubIdRes !== null && "hubServiceId" in hubIdRes && typeof hubIdRes.hubServiceId === "string" ? hubIdRes.hubServiceId : void 0;
-	if (!hubServiceId) throw new Error("tunnel: failed to resolve hub service id for out-of-namespace claim");
-	const registerMethod = `${hubServiceId}::${hubServiceIdRegistryInterface.info.id}::registerServiceId`;
-	await local.channel.sendRequest(registerMethod, { requestedPrefix: serviceId });
-}
-function _isServiceIdUnder(serviceId, namespace) {
-	if (namespace === "") return false;
-	return serviceId === namespace || serviceId.startsWith(`${namespace}/`);
-}
-/** Resolve on the next `SIGINT` / `SIGTERM`. */
-function _untilSignalled$2() {
-	return new Promise((resolve) => {
-		const done = () => {
-			process.removeListener("SIGINT", done);
-			process.removeListener("SIGTERM", done);
-			resolve();
-		};
-		process.once("SIGINT", done);
-		process.once("SIGTERM", done);
-	});
-}
-async function _forwardRequest(remote, call) {
-	const rc = remote.channel.sendRequestWithStream(call.method, call.params, {
-		ctx: { signerOverride: null },
-		onStreamMessage: (payload) => {
-			call.stream.send(payload);
-		}
-	});
-	call.stream.onMessage((payload) => rc.send(payload));
-	const cancelRemote = () => rc.cancel(call.signal.reason?.message);
-	if (call.signal.aborted) cancelRemote();
-	else call.signal.addEventListener("abort", cancelRemote, { once: true });
-	try {
-		return { result: await rc.result };
-	} catch (err) {
-		if (err instanceof RpcError) return { error: {
-			code: err.code,
-			message: err.message,
-			data: err.data
-		} };
-		return { error: {
-			code: ErrorCode.internalError,
-			message: err.message
-		} };
-	}
-}
-function _forwardNotification(remote, call) {
-	remote.channel.sendNotification(call.method, call.params, { ctx: { signerOverride: null } }).catch(() => {});
-}
-//#endregion
-//#region src/commands/connectionBroker.ts
-const BROKER_INTERFACE_ID = "hubrpc.connectionBroker";
-const BROKER_STATUS_METHOD = `${BROKER_INTERFACE_ID}::status`;
-const BROKER_READ_NOTIFICATIONS_METHOD = `${BROKER_INTERFACE_ID}::readNotifications`;
-const BROKER_DISCONNECT_METHOD = `${BROKER_INTERFACE_ID}::disconnect`;
-var ConnectionBroker = class {
-	_remote;
-	_options;
-	_now;
-	_notificationLimit;
-	_notifications = [];
-	_waiters = /* @__PURE__ */ new Set();
-	_remoteForwarder;
-	_staticReflection;
-	_startedAt;
-	_nextNotificationSequence = 1;
-	_locals = /* @__PURE__ */ new Set();
-	_timeoutTimer;
-	_ttlTimer;
-	_lastActivityAt;
-	_resolveStopped;
-	_disposed = false;
-	stopped = new Promise((resolve) => {
-		this._resolveStopped = resolve;
-	});
-	stoppedReason;
-	constructor(_remote, _options) {
-		this._remote = _remote;
-		this._options = _options;
-		this._now = _options.now ?? Date.now;
-		this._notificationLimit = _options.notificationLimit ?? 1e3;
-		this._startedAt = _options.startedAt;
-		this._lastActivityAt = _options.startedAt;
-		this._remoteForwarder = createForwardingHandler(_remote);
-		this._staticReflection = _options.staticHubSchema === void 0 ? void 0 : new StaticHubReflection(_options.staticHubSchema);
-		this._remote.setRequestHandler({
-			handleRequest: (call) => this._handleRemoteRequest(call),
-			handleNotification: (call) => this._bufferNotification(call)
-		});
-		this._resetTimeout();
-		this._ttlTimer = setTimeout(() => this._stop("ttl"), Math.max(0, this._options.ttlMs - (this._now() - this._startedAt)));
-		this._ttlTimer.unref?.();
-	}
-	attach(local) {
-		if (this._disposed) throw new Error("connection broker is stopped");
-		this._locals.add(local);
-		local.setRequestHandler({
-			handleRequest: (call) => this._handleLocalRequest(call),
-			handleNotification: (call) => this._handleLocalNotification(call)
-		});
-		this.recordActivity();
-	}
-	detach(local) {
-		if (!this._locals.delete(local)) return;
-		local.setRequestHandler(void 0);
-	}
-	recordActivity() {
-		if (this._disposed) return;
-		this._lastActivityAt = this._now();
-		this._resetTimeout();
-	}
-	dispose() {
-		this._stop("disposed");
-	}
-	async _handleLocalRequest(call) {
-		this.recordActivity();
-		switch (call.method) {
-			case BROKER_STATUS_METHOD: return { result: this._status() };
-			case BROKER_READ_NOTIFICATIONS_METHOD: return { result: await this._readNotifications(call.params, call.signal) };
-			case BROKER_DISCONNECT_METHOD:
-				setTimeout(() => this._stop("disconnect"), 0);
-				return { result: { disconnected: true } };
-			default:
-				if (call.method.startsWith(`hubrpc.connectionBroker::`)) return { error: {
-					code: ErrorCode.methodNotFound,
-					message: `Unknown connection broker method: ${call.method}`
-				} };
-				const reflected = this._staticReflection?.tryHandleRequest(call);
-				if (reflected !== void 0) return reflected;
-				return this._remoteForwarder.handleRequest(call);
-		}
-	}
-	_handleLocalNotification(call) {
-		this.recordActivity();
-		if (call.method.startsWith(`hubrpc.connectionBroker::`)) return;
-		this._remoteForwarder.handleNotification(call);
-	}
-	_handleRemoteRequest(call) {
-		this.recordActivity();
-		if (this._locals.size !== 1) return Promise.resolve({ error: {
-			code: ErrorCode.peerDisconnected,
-			message: this._locals.size === 0 ? "No local broker client is attached" : "Cannot route a reverse request while multiple local broker clients are attached"
-		} });
-		const local = this._locals.values().next().value;
-		return createForwardingHandler(local).handleRequest(call);
-	}
-	_bufferNotification(call) {
-		this.recordActivity();
-		const notification = {
-			sequence: this._nextNotificationSequence++,
-			receivedAt: this._now(),
-			method: call.method,
-			...call.params === void 0 ? {} : { params: call.params }
-		};
-		this._notifications.push(notification);
-		if (this._notifications.length > this._notificationLimit) this._notifications.splice(0, this._notifications.length - this._notificationLimit);
-		this._settleReadyWaiters();
-	}
-	_status() {
-		return {
-			id: this._options.id,
-			mode: this._options.mode,
-			remoteEndpoint: this._options.remoteEndpoint,
-			startedAt: this._startedAt,
-			lastActivityAt: this._lastActivityAt,
-			timeoutMs: this._options.timeoutMs,
-			ttlMs: this._options.ttlMs,
-			notificationCount: this._notifications.length,
-			nextNotificationSequence: this._nextNotificationSequence,
-			localClientCount: this._locals.size
-		};
-	}
-	_readNotifications(params, signal) {
-		const parsed = parseReadParams(params);
-		const immediate = this._collectNotifications(parsed.after);
-		if (immediate.notifications.length > 0 || parsed.waitMs === 0) return Promise.resolve(immediate);
-		return new Promise((resolve) => {
-			const waiter = {
-				after: parsed.after,
-				resolve,
-				timer: setTimeout(() => this._settleWaiter(waiter), parsed.waitMs),
-				signal,
-				onAbort: () => this._settleWaiter(waiter)
-			};
-			waiter.timer.unref?.();
-			signal.addEventListener("abort", waiter.onAbort, { once: true });
-			this._waiters.add(waiter);
-		});
-	}
-	_collectNotifications(after) {
-		const notifications = this._notifications.filter((item) => item.sequence > after);
-		return {
-			notifications,
-			next: notifications.at(-1)?.sequence ?? after,
-			droppedBefore: this._notifications[0]?.sequence ?? this._nextNotificationSequence
-		};
-	}
-	_settleReadyWaiters() {
-		for (const waiter of [...this._waiters]) if (this._notifications.some((item) => item.sequence > waiter.after)) this._settleWaiter(waiter);
-	}
-	_settleWaiter(waiter) {
-		if (!this._waiters.delete(waiter)) return;
-		clearTimeout(waiter.timer);
-		waiter.signal.removeEventListener("abort", waiter.onAbort);
-		waiter.resolve(this._collectNotifications(waiter.after));
-	}
-	_resetTimeout() {
-		if (this._timeoutTimer !== void 0) clearTimeout(this._timeoutTimer);
-		this._timeoutTimer = setTimeout(() => this._stop("timeout"), this._options.timeoutMs);
-		this._timeoutTimer.unref?.();
-	}
-	_stop(reason) {
-		if (this._disposed) return;
-		this._disposed = true;
-		this.stoppedReason = reason;
-		if (this._timeoutTimer !== void 0) clearTimeout(this._timeoutTimer);
-		if (this._ttlTimer !== void 0) clearTimeout(this._ttlTimer);
-		for (const waiter of [...this._waiters]) this._settleWaiter(waiter);
-		for (const local of this._locals) local.close();
-		this._locals.clear();
-		this._remote.close();
-		this._resolveStopped(reason);
-		this._options.onStop?.(reason);
-	}
-};
-function parseReadParams(params) {
-	if (params === void 0) return {
-		after: 0,
-		waitMs: 0
-	};
-	if (typeof params !== "object" || params === null || Array.isArray(params)) throw new Error("readNotifications params must be an object");
-	const after = "after" in params ? params.after : 0;
-	const waitMs = "waitMs" in params ? params.waitMs : 0;
-	if (typeof after !== "number" || !Number.isSafeInteger(after) || after < 0) throw new Error("readNotifications after must be a non-negative integer");
-	if (typeof waitMs !== "number" || !Number.isSafeInteger(waitMs) || waitMs < 0 || waitMs > 3e4) throw new Error("readNotifications waitMs must be an integer between 0 and 30000");
-	return {
-		after,
-		waitMs
-	};
-}
-//#endregion
-//#region src/commands/connectionBrokerClient.ts
-function getBrokerStatus(channel) {
-	return channel.sendRequest(BROKER_STATUS_METHOD, {});
-}
-async function disconnectBroker(channel) {
-	await channel.sendRequest(BROKER_DISCONNECT_METHOD, {});
-}
-async function readBrokerNotifications(channel, options = {}) {
-	const value = await channel.sendRequest(BROKER_READ_NOTIFICATIONS_METHOD, {
-		after: options.after ?? 0,
-		waitMs: options.waitMs ?? 0
-	});
-	if (!isRecord(value) || !Array.isArray(value.notifications)) throw new Error("connection broker returned an invalid notification batch");
-	const next = value.next;
-	const droppedBefore = value.droppedBefore;
-	if (typeof next !== "number" || !Number.isSafeInteger(next) || typeof droppedBefore !== "number" || !Number.isSafeInteger(droppedBefore)) throw new Error("connection broker returned invalid notification sequence metadata");
-	return {
-		notifications: value.notifications.map(parseNotification),
-		next,
-		droppedBefore
-	};
-}
-function parseNotification(value) {
-	if (!isRecord(value) || typeof value.sequence !== "number" || !Number.isSafeInteger(value.sequence) || typeof value.receivedAt !== "number" || !Number.isSafeInteger(value.receivedAt) || typeof value.method !== "string") throw new Error("connection broker returned an invalid notification");
-	return {
-		sequence: value.sequence,
-		receivedAt: value.receivedAt,
-		method: value.method,
-		..."params" in value ? { params: value.params } : {}
-	};
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-//#endregion
 //#region src/commands/connectionBrokerProcess.ts
 async function runConnectionBroker(options) {
 	const startedAt = Date.now();
@@ -1139,7 +805,7 @@ async function spawnConnectionBroker(options) {
 		throw new Error("connection broker child exposes no stdout");
 	}
 	try {
-		const endpoint = await readReadyEndpoint(child, stdout, options.readyTimeoutMs ?? 15e3);
+		const endpoint = await readReadyEndpoint(child, stdout, options.readyTimeoutMs ?? 6e4);
 		stdout.destroy();
 		child.unref();
 		return endpoint;
@@ -1162,6 +828,11 @@ function readReadyEndpoint(child, stdout, timeoutMs) {
 			const endpoint = buffer.slice(0, newline).trim();
 			cleanup();
 			try {
+				if (endpoint.startsWith("{")) {
+					const response = JSON.parse(endpoint);
+					if (typeof response === "object" && response !== null && "error" in response && typeof response.error === "string") throw new Error(`connection broker failed to start: ${response.error}`);
+					throw new Error("connection broker returned an invalid startup response");
+				}
 				const parsed = new URL(endpoint);
 				if (parsed.protocol !== "unix:" && parsed.protocol !== "npipe:") throw new Error(`unexpected broker endpoint '${endpoint}'`);
 				resolve(endpoint);
@@ -1181,31 +852,14 @@ function readReadyEndpoint(child, stdout, timeoutMs) {
 			clearTimeout(timer);
 			stdout.removeListener("data", onData);
 			child.removeListener("error", onError);
-			child.removeListener("exit", onExit);
+			child.removeListener("close", onExit);
 		};
 		stdout.on("data", onData);
 		child.once("error", onError);
-		child.once("exit", onExit);
+		child.once("close", onExit);
 	});
 }
 //#endregion
-//#region src/duration.ts
-const DURATION_PATTERN = /^(\d+)(ms|s|m|min|h)$/;
-const UNIT_MS = {
-	ms: 1,
-	s: 1e3,
-	m: 6e4,
-	min: 6e4,
-	h: 36e5
-};
-function parseDuration(value) {
-	const match = DURATION_PATTERN.exec(value.trim());
-	if (match === null) throw new Error(`invalid duration '${value}' (expected e.g. 250ms, 30s, 5min, or 2h)`);
-	const durationMs = Number.parseInt(match[1], 10) * UNIT_MS[match[2]];
-	if (!Number.isSafeInteger(durationMs) || durationMs <= 0) throw new Error(`invalid duration '${value}' (must be greater than zero)`);
-	return durationMs;
-}
-//#endregion
 //#region src/commands/checkCompat.ts
 async function checkCompatCommand(channel, opts) {
 	return diffSchemas(JSON.parse(readFileSync(opts.localPath, "utf8")), await fetchSchema$1(channel, opts.interfaceId, void 0));
@@ -6584,17 +6238,18 @@ Batch options:
 		}, { requestReflectionAccess: effectiveValidation(profile) !== "off" && plan.operations.some((operation) => !operation.noValidate) });
 	});
 	const connection = program.command("connection").description("Create, inspect, consume, and destroy persistent RPC connections.");
-	connection.command("create").description("Create a detached persistent connection and print its local endpoint.").option("--timeout <duration>", "exit after this much transport inactivity").option("--ttl <duration>", "hard maximum broker lifetime").option("--notification-limit <count>", "maximum buffered incoming notifications", (value) => parsePositiveInteger(value, "--notification-limit")).action(async (opts) => {
+	connection.command("create").description("Create a detached persistent connection and print its local endpoint.").option("--timeout <duration>", "transport inactivity limit (duration or inf; omitted: inf)").option("--ttl <duration>", "hard lifetime limit (duration or inf; omitted: inf)").option("--notification-limit <count>", "maximum buffered incoming notifications", (value) => parsePositiveInteger(value, "--notification-limit")).action(async (opts) => {
+		if (opts.timeout === void 0 && opts.ttl === void 0) throw new Error("connection create requires an explicit --timeout or --ttl (use inf for unlimited)");
 		if (g_hubConfigPath !== void 0) throw new Error("connection create does not support --config; use an endpoint URI or command endpoint");
 		const schemaSource = g_invocation?.values.schema === void 0 ? void 0 : resolveStaticHubSchemaSource(g_invocation.values.schema);
 		if (schemaSource !== void 0) await loadStaticHubSchema(schemaSource);
-		const timeout = opts.timeout ?? g_invocation?.values.connectionTimeout ?? "30s";
-		const ttl = opts.ttl ?? g_invocation?.values.connectionTtl ?? "5min";
+		const timeout = opts.timeout ?? "inf";
+		const ttl = opts.ttl ?? "inf";
 		const notificationLimit = opts.notificationLimit ?? g_invocation?.values.notificationLimit ?? 1e3;
 		const brokerEndpoint = await spawnConnectionBroker({
 			remote: needEndpoint(endpoint),
-			timeoutMs: parseDuration(timeout),
-			ttlMs: parseDuration(ttl),
+			timeoutMs: parseConnectionLimit(timeout),
+			ttlMs: parseConnectionLimit(ttl),
 			notificationLimit,
 			schemaSource
 		});
@@ -6659,14 +6314,14 @@ Batch options:
 		process.stdout.write(`Updated context ${formatContextReference(target)}.\n`);
 		if (result !== void 0) printContextValues(result.values, false);
 	});
-	context.command("remove").description("Remove the selected context from the global store.").action(async () => {
+	context.command("remove").description("Stop any owned connection and remove the selected context from the global store.").action(async () => {
 		if (g_contextStore === void 0 || g_invocation === void 0) throw new Error("context resolver is unavailable");
 		const reference = g_invocation.selected.reference;
 		if (reference.kind === "empty" || reference.kind === "root" && explicitOption(program, "context") === void 0) throw new Error("select the context to remove explicitly with --context");
 		if (!await g_contextStore.remove(reference)) throw new Error(`context ${formatContextReference(reference)} does not exist`);
 		process.stdout.write(`Removed context ${formatContextReference(reference)}.\n`);
 	});
-	program.command("_connection-broker").description("(internal) Run a persistent connection broker.").requiredOption("--remote-endpoint <uri>").requiredOption("--timeout-ms <milliseconds>", "", (value) => parsePositiveInteger(value, "--timeout-ms")).requiredOption("--ttl-ms <milliseconds>", "", (value) => parsePositiveInteger(value, "--ttl-ms")).option("--notification-limit <count>", "", (value) => parsePositiveInteger(value, "--notification-limit"), 1e3).option("--schema <path-or-url>").action(async (opts) => {
+	program.command("_connection-broker").description("(internal) Run a persistent connection broker.").requiredOption("--remote-endpoint <uri>").requiredOption("--timeout-ms <milliseconds-or-inf>", "", parseConnectionLimitMilliseconds).requiredOption("--ttl-ms <milliseconds-or-inf>", "", parseConnectionLimitMilliseconds).option("--notification-limit <count>", "", (value) => parsePositiveInteger(value, "--notification-limit"), 1e3).option("--schema <path-or-url>").action(async (opts) => {
 		const running = await runConnectionBroker({
 			remote: parseEndpointUri(opts.remoteEndpoint),
 			timeoutMs: opts.timeoutMs,
@@ -6919,7 +6574,7 @@ Batch options:
 				process.once("SIGINT", onSignal);
 				process.once("SIGTERM", onSignal);
 				try {
-					const { runApprovalUi } = await import("./runApprovalUi-eLDf_5ZN.js");
+					const { runApprovalUi } = await import("./runApprovalUi-BFI84eck.js");
 					await runApprovalUi({
 						client,
 						signal: stop.signal
@@ -6934,7 +6589,7 @@ Batch options:
 	registerViewCommands(program, (action) => withChannel(endpoint, getPrincipalSpec(), action));
 	program.command("ui").description("Launch the terminal UI (form-based browser of services + methods).").action(async () => {
 		const acquired = await acquireConnection(endpoint);
-		const { runUi } = await import("./runUi-DF_HTMk9.js");
+		const { runUi } = await import("./runUi-BNCT8zwR.js");
 		try {
 			await runUi({
 				endpoint: acquired.ep,
@@ -7011,8 +6666,11 @@ function copyExplicit(command, source, target, optionName, contextName = optionN
 function explicitOption(command, name) {
 	return command.getOptionValueSource(name) === "cli" ? command.opts()[name] : void 0;
 }
-async function createContextFromInvocation(store, reference, values) {
-	await store.replace(reference, values, { createOnly: true });
+async function createContextFromInvocation(store, reference, values, ownedConnection) {
+	await store.replace(reference, values, {
+		createOnly: true,
+		ownedConnection
+	});
 	process.stderr.write(`linkrpc: created context ${formatContextReference(reference)}.\n`);
 }
 async function createConnectionContext(store, reference, values, brokerEndpoint) {
@@ -7021,7 +6679,7 @@ async function createConnectionContext(store, reference, values, brokerEndpoint)
 	await createContextFromInvocation(store, reference, {
 		...rest,
 		...connectionEndpoint
-	});
+	}, { endpoint: brokerEndpoint });
 }
 function splitEndpointToken(endpoint) {
 	const parsed = parseEndpointUri(endpoint);
@@ -7033,14 +6691,6 @@ function splitEndpointToken(endpoint) {
 		endpointToken: token
 	};
 }
-async function stopConnectionBroker(endpoint) {
-	const connection = await connect(parseEndpointUri(endpoint));
-	try {
-		await disconnectBroker(connection.channel);
-	} finally {
-		connection.close();
-	}
-}
 function mutableReference(reference) {
 	if (reference.kind === "empty") throw new Error(":empty is immutable and cannot be modified");
 	return reference;
@@ -7344,8 +6994,15 @@ function parseInterfaceRef(raw) {
 	};
 }
 function runCli(executableName) {
-	main(process.argv.slice(2), executableName).catch((e) => {
-		process.stderr.write(`linkrpc: ${formatCliError(e)}\n`);
+	main(process.argv.slice(2), executableName).catch(async (e) => {
+		const message = formatCliError(e);
+		process.stderr.write(`linkrpc: ${message}\n`);
+		if (process.argv[2] === "_connection-broker") await new Promise((resolve, reject) => {
+			process.stdout.write(JSON.stringify({ error: message }) + "\n", (error) => {
+				if (error) reject(error);
+				else resolve();
+			});
+		});
 		process.exit(1);
 	});
 }
@@ -7367,4 +7024,4 @@ function safeJson(value) {
 //#endregion
 export { formatCommandLegend as a, safeTerminalText as c, interfaceTarget as d, matchesTarget as f, dispatchHostKey as i, resolveViewTarget as l, approvalDetailLines as m, views as n, hostCommands as o, targetId as p, ViewFrame as r, matchesKey as s, runCli as t, formatCondition as u };
 
-//# sourceMappingURL=cli-yDtBqjCT.js.map
+//# sourceMappingURL=cli-JE4URhh3.js.map