@hediet/linkrpc-cli 0.0.3-next.20261025.2 → 0.0.3-next.20261025.4

package/README.md

@@ -794,6 +794,7 @@ initial document:
 | `connection destroy`                                  | Stop the configured connection broker through its local overlay. |
 | `json-rpc-stdio <serviceId> [--params <json>]`         | In the Hub profile, expose `<serviceId>::jsonRpcConnection::connectRaw` as newline-delimited JSON-RPC on stdin/stdout. Diagnostics remain on stderr. |
 | `json-rpc-export --target-endpoint <uri> --serviceId <id> --path <path> ...` | In the Hub profile, export multiple JSON-RPC factories through one authenticated raw WebSocket listener. |
+| `http-export [--port <n>] [--host <address>]... [--base-domain <domain>]` | In the Hub profile, serve loopback ports of Hub compute nodes at `<port>.<service>.localhost` over HTTP and WebSocket. |
 
 The inherited `--schema <path-or-url>` option also overlays static
 `hubrpc.defaults`, `hubrpc.directory`, and `hubrpc.schemas` reflection for
@@ -834,6 +835,66 @@ Only `listen:ws://` TCP listeners are currently supported, not named pipes or TL
 
 The command stays in the foreground until SIGINT/SIGTERM, then closes clients and the listener. Use the existing Hub daemon/service lifecycle to supervise it; this command neither installs a service nor starts remote AHP hosts. Diagnostics and the bound address (including an assigned port when using port 0) go to stderr.
 
+### HTTP export
+
+`http-export` serves loopback TCP ports of Hub compute nodes (services offering
+`linkrpc.computeNode.tcpForward`) as `*.localhost` sites. `*.localhost` always
+resolves to this machine, so no DNS setup is needed:
+
+```sh
+linkrpc hub http-export            # listens on 127.0.0.1:80 and [::1]:80
+```
+
+| URL | Shows |
+| --- | --- |
+| `http://localhost/` | Services that can forward TCP (`?format=json` for JSON). |
+| `http://hediet--tablet--compute.localhost/` | Listening ports of `hediet/tablet/compute` with each owning process's name, command line, and working directory (needs `linkrpc.computeNode.ports`). |
+| `http://3000.hediet--tablet--compute.localhost/` | Port 3000 of that compute node, including WebSocket upgrades. |
+
+A service is always exactly one label directly below `localhost`, its
+segments joined with `--`. Browsers treat `localhost` as a public suffix, so
+each service is its own site: pages of one machine get no `SameSite` cookies
+from another machine's apps and cannot set cookies for them, as with direct
+access. The ports of one service share that site, as the ports of `localhost`
+do on its machine. A service ID whose segments are not plain lowercase DNS
+labels, or whose label would exceed 63 characters, is written as a hashed label
+instead, `<slug>--h<hash>`, which the gateway resolves against the services it
+can reach. The index pages link to the right form.
+
+There is no gateway credential and no origin check of its own. Instead, the
+gateway translates between a forwarded app's own origins
+(`http://localhost:<port>` on its machine) and their exported names, so the
+app's own Host, Origin, CORS, redirect, and cookie checks behave as they do for
+a browser on its machine:
+
+| Header | Translation |
+| --- | --- |
+| `Host` | Always `localhost:<port>`. The gateway itself only accepts `*.localhost` names, so DNS rebinding cannot reach it. |
+| `Origin`, `Referer` | Exported names of the same service map to `http://localhost:<port>`. Other services' exported names and foreign sites pass unchanged. This machine's own loopback origins have no counterpart on the target: `Origin` becomes `null` and `Referer` is dropped. |
+| `Location`, `Access-Control-Allow-Origin` | URLs naming the target machine's loopback map to their exported names. |
+| `Set-Cookie` | Host-only and `Domain=localhost` cookies get the service's domain (e.g. `Domain=hediet--tablet--compute.localhost`), which reaches that machine's exported ports, as such cookies reach all of its ports there. Cookies for other domains are dropped, as a browser there would reject them. `__Host-` cookies stay host-only, so they reach only one exported port. |
+
+WebSocket upgrades are translated the same way in both directions. No
+`X-Forwarded-*` headers are added. Absolute loopback URLs inside response
+bodies are not rewritten, so they fail rather than reach this machine. Bind
+loopback only: anyone who can reach the listener can use the export process's
+Hub identity to reach every forwarded port.
+
+The gateway's own pages (`localhost` and `<service>.localhost`, HTML and JSON)
+show command lines, which may contain secrets. They answer only top-level
+navigations, same-origin requests, and clients that send no `Sec-Fetch-*` or
+cross-origin `Origin` header (e.g. `curl`); other requests, including fetches,
+scripts, and iframes from forwarded apps of the same machine, get `403`. They
+send no CORS headers, forbid framing (`frame-ancestors 'none'`,
+`X-Frame-Options: DENY`), and set `nosniff`, `no-store`, `no-referrer`, and
+same-origin resource and opener policies. Command lines and working directories
+are only shown for processes the compute node may inspect, e.g. not for
+elevated or other users' processes on Windows.
+
+Each service and port shares one `tcpForward.multiplex` session (up to 10
+logical connections, 8 of them for pooled HTTP keep-alive), closed after five
+idle minutes.
+
 ### Participant proxy
 
 `proxy` stands in for a participant on the hub: the participant is either this
@@ -940,7 +1001,7 @@ Value-taking options support both `--option=value` and `--option value`.
 Parameter assignment itself still uses `key=value`, e.g.
 `--param path=/docs/a` or `--param=path=/docs/a`. Use the equals form for
 dash-prefixed values. Quote JSON and strings containing spaces.
-`--cap:request` and `--cap:allow-any` are switches with no value.
+`--cap:request`, `--cap:allow-any`, and `--cap:delegate` are switches with no value.
 The older `--request-cap`, `--allow-param`, and `--duration` spellings have
 been replaced by the `--cap:` options.
 
@@ -950,6 +1011,9 @@ Schema validation is mandatory for explicit requests: `--no-validate` and
 the permission; signed calls include that hash in their signed metadata.
 The default requested duration is `persistent`; `--cap:duration shortLived` and
 `--cap:duration longLived` are also supported. The Hub still decides what to grant.
+`--cap:delegate` also requests `canDelegate`, so the identity can issue narrower
+capabilities for that scope to other identities, e.g. a service it runs; a
+stored grant without delegation does not satisfy such a request.
 One-shot approval cannot satisfy a reusable scope and is rejected.
 
 Fresh durable grants for the selected principal are reused when they cover

package/dist/chunks/{cli-BZ-4lHyj.js → cli-D_nbiyek.js}

@@ -1,4 +1,4 @@
-import { $ as requestTopologyAccess, B as proxyCommand, Ct as MethodRefWithOptHash, F as disconnectBroker, G as parseDuration, H as withStaticHubReflection, I as getBrokerStatus, L as readBrokerNotifications, M as readEndpointDiscovery, N as ContextStore, P as formatContextReference, Q as requestReflectionAccess, R as stopConnectionBroker, St as parseParamOverride, U as parseConnectionLimit, V as tunnelCommand, W as parseConnectionLimitMilliseconds, _t as describeSchema, a as resolveInvocationEndpoint, c as resolveLocalEndpoint, ct as readCliIdentity, dt as connect, et as setupSigning, ft as connectViaRootOverlay, gt as describeObjectParams, ht as resolvedEndpointToConfig, i as resolveInvocationContext, it as walkHub, lt as formatPrincipalSource, m as managedEndpointsInterface, mt as resolveTargetEndpoint, n as loadStaticHubSchema, nt as fetchSchema$1, o as resolveSigning, ot as cliIdentityTarget, pt as connectViaTransport, q as resolveCliInvocation, r as resolveStaticHubSchemaSource, rt as findMethodInSchema, s as validationDefault, st as deleteCliIdentity, t as completeForLine, tt as fetchDefaults, ut as parsePrincipalSpec, vt as explainValidation, wt as mcpForwardInterface, xt as mergeParams, y as HubHome, yt as validateValueAgainstSchema, z as ConnectionBroker } from "./runComplete-1DjMsU_0.js";
+import { $ as requestTopologyAccess, B as proxyCommand, Ct as MethodRefWithOptHash, F as disconnectBroker, G as parseDuration, H as withStaticHubReflection, I as getBrokerStatus, L as readBrokerNotifications, M as readEndpointDiscovery, N as ContextStore, P as formatContextReference, Q as requestReflectionAccess, R as stopConnectionBroker, St as parseParamOverride, U as parseConnectionLimit, V as tunnelCommand, W as parseConnectionLimitMilliseconds, _t as describeSchema, a as resolveInvocationEndpoint, c as resolveLocalEndpoint, ct as readCliIdentity, dt as connect, et as setupSigning, ft as connectViaRootOverlay, gt as describeObjectParams, ht as resolvedEndpointToConfig, i as resolveInvocationContext, it as walkHub, lt as formatPrincipalSource, m as managedEndpointsInterface, mt as resolveTargetEndpoint, n as loadStaticHubSchema, nt as fetchSchema$1, o as resolveSigning, ot as cliIdentityTarget, pt as connectViaTransport, q as resolveCliInvocation, r as resolveStaticHubSchemaSource, rt as findMethodInSchema, s as validationDefault, st as deleteCliIdentity, t as completeForLine, tt as fetchDefaults, ut as parsePrincipalSpec, vt as explainValidation, wt as mcpForwardInterface, xt as mergeParams, y as HubHome, yt as validateValueAgainstSchema, z as ConnectionBroker } from "./runComplete-bFjlzR3Y.js";
 import { ErrorCode, INTERFACE_TEMPLATES_EXTENSION, LinkRpcConnection, RpcError, computeInterfaceHash, connectTransports, createSchemaToZod, directoryInterface, exportStaticHubSchema, generateTsContract, generateTsInterface, interfaceTemplateArgumentsEquivalent, interfaceTemplateMemberName, interfaceTemplatesEqual, isAssignable, jcsCanonicalize, matchParams, schemaToZod, validateInterfaceTemplates } from "@hediet/linkrpc";
 import { z } from "zod";
 import { WebSocketTransport, connectNdjson, connectToHub, formatEndpointUri, isHubEndpoint, openWebSocket, parseEndpointUri, runInitializeHandshake, traceMessageTransport as traceMessageTransport$1 } from "@hediet/linkrpc/node";
@@ -27,6 +27,8 @@ import { TrafficFlowAggregator, createTerminalConsentPrompt, formatFlowSummary }
 import { loadHubConfig, printHubConfigSchema } from "@hediet/linkrpc-hub/config-file";
 import { connectJsonRpcTransports, connectRawJsonRpcTransport, createNdjsonJsonRpcTransport, jsonRpcConnectionInterface } from "@hediet/linkrpc-infra/json-rpc";
 import { startJsonRpcWebSocketExport, validateJsonRpcExport } from "@hediet/linkrpc-infra/json-rpc/node";
+import { computeNodePortsInterface, computeNodeTcpForwardInterface } from "@hediet/linkrpc-infra/compute-node";
+import { startHttpExport } from "@hediet/linkrpc-infra/http-export/node";
 import { GRAPH_INTERFACE_TAG, IMMUTABLE_GRAPH_INTERFACE_ID, ROOT_WATCH_INTERFACE_ID, evaluateGraphPresentation, graphPresentationInterface, graphPresentationSchema, isGraphRef, standardGraphRuntimeOptions, validateGraphInterfaceSchema } from "@hediet/linkrpc-infra/graph";
 import React from "react";
 import { Box, Text, measureElement, render } from "ink";
@@ -407,7 +409,7 @@ function contextNamespace(reference) {
 async function useLocalManagement(start, action) {
 	const home = HubHome.resolve();
 	if (start) {
-		const { startDaemon, nodeDaemonLaunch } = await import("./src-DPg65Jd1.js");
+		const { startDaemon, nodeDaemonLaunch } = await import("./src-B71xYgEO.js");
 		if (await startDaemon({
 			home,
 			launch: nodeDaemonLaunch(home)
@@ -427,7 +429,7 @@ async function useLocalManagement(start, action) {
 	}
 }
 async function restartLocalDaemon() {
-	const { startDaemon, stopDaemon, nodeDaemonLaunch } = await import("./src-DPg65Jd1.js");
+	const { startDaemon, stopDaemon, nodeDaemonLaunch } = await import("./src-B71xYgEO.js");
 	const home = HubHome.resolve();
 	process.stderr.write("Restarting the local Hub daemon: clients will disconnect and managed workloads will stop. OS autostart settings are unchanged.\n");
 	await stopDaemon(home);
@@ -947,6 +949,7 @@ async function requestCallCapability(channel, session, ref, params, schema, opts
 			...ref.hash !== void 0 ? { interfaceHash: ref.hash } : {}
 		},
 		canInvoke: true,
+		...opts.delegate === true ? { canDelegate: true } : {},
 		params: matchers
 	};
 	const coverageOptions = {
@@ -3541,6 +3544,72 @@ async function jsonRpcExportCommand(options) {
 	});
 }
 //#endregion
+//#region src/commands/httpExport.ts
+const SERVICE_LIST_TTL_MS = 3e4;
+const SERVICE_LIST_TIMEOUT_MS = 2e4;
+async function httpExportCommand(options) {
+	const connection = new LinkRpcConnection(options.local.rpcChannel);
+	const services = new ForwardableServices(options.local.channel, options.requestDirectoryAccess, options.onError);
+	return startHttpExport({
+		listen: options.hosts.map((host) => ({
+			host,
+			port: options.port
+		})),
+		baseDomain: options.baseDomain,
+		getTcpForward: (serviceId) => connection.service(serviceId).get(computeNodeTcpForwardInterface),
+		listServices: () => services.get(),
+		listPorts: async (serviceId) => (await connection.service(serviceId).get(computeNodePortsInterface).listListening({})).ports,
+		onError: options.onError
+	});
+}
+/** Caches the services that implement `tcpForward`; a slow or partial walk returns what it found. */
+var ForwardableServices = class {
+	_channel;
+	_requestDirectoryAccess;
+	_onError;
+	_cached;
+	_pending;
+	constructor(_channel, _requestDirectoryAccess, _onError) {
+		this._channel = _channel;
+		this._requestDirectoryAccess = _requestDirectoryAccess;
+		this._onError = _onError;
+	}
+	get() {
+		if (this._cached && Date.now() - this._cached.at < SERVICE_LIST_TTL_MS) return Promise.resolve(this._cached.value);
+		this._pending ??= this._load().finally(() => {
+			this._pending = void 0;
+		});
+		return this._pending;
+	}
+	async _load() {
+		const explorer = new HubDirectoryExplorer(this._channel, {
+			interfaceId: computeNodeTcpForwardInterface.info.id,
+			timeoutMs: 5e3,
+			unlockGatedDirectory: this._requestDirectoryAccess,
+			log: (message) => this._onError(new Error(message))
+		});
+		let timer;
+		try {
+			const walked = await Promise.race([explorer.explore(), new Promise((resolve) => {
+				timer = setTimeout(() => resolve(void 0), SERVICE_LIST_TIMEOUT_MS);
+			})]);
+			const listings = (walked?.listings ?? explorer.result.listings).filter((listing) => listing.serviceId !== "");
+			const value = {
+				serviceIds: [...new Set(listings.map((listing) => listing.serviceId))],
+				complete: walked !== void 0 && walked.inaccessible.length === 0
+			};
+			this._cached = {
+				value,
+				at: Date.now()
+			};
+			return value;
+		} finally {
+			clearTimeout(timer);
+			explorer.dispose();
+		}
+	}
+};
+//#endregion
 //#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/observableInternal/logging/logging.js
 let globalObservableLogger;
 function addLogger(logger) {
@@ -8779,7 +8848,7 @@ async function main(rawArgv, executableName = "linkrpc") {
 		"shortLived",
 		"longLived",
 		"persistent"
-	]).default("persistent"));
+	]).default("persistent")).option("--cap:delegate", "also request the right to delegate this authority (canDelegate) to other identities");
 	const configureCall = (cmd, capabilityOnly) => {
 		cmd.description((capabilityOnly ? "Request a capability without executing a call. " : "Invoke a request. ") + "`<methodRef>` is `[svc::][iface::]method[@hash]`. Use `--p:<name> <value>` (or `--p:<name>=<value>`) as a shortcut for `--param <name>=<value>`. Run `hub call <methodRef> --help` to see the method-specific `--p:` flags derived from the live schema.").option("--params <json>", "inline params JSON, or \"-\" to read stdin").option("--param <kv...>", "param override, key=value (JSON or string)").option("--no-validate", "skip schema-based param validation").helpOption(false).option("-h, --help", "show help (includes method params when reachable)").action(async (methodRef, opts, cmd) => {
 			if (opts.help) {
@@ -8795,6 +8864,7 @@ async function main(rawArgv, executableName = "linkrpc") {
 			const allowParams = opts["cap:allowParam"];
 			if (!capabilityOnly && allowParams !== void 0 && !requestCap) throw new Error("--cap:allow-param requires --cap:request.");
 			if (!capabilityOnly && cmd.getOptionValueSource("cap:duration") === "cli" && !requestCap) throw new Error("--cap:duration requires --cap:request.");
+			if (!capabilityOnly && opts["cap:delegate"] === true && !requestCap) throw new Error("--cap:delegate requires --cap:request.");
 			resolveSigning(profile, g_invocation?.values ?? {}, capabilityOnly || requestCap);
 			const validation = opts.validate === false ? "off" : effectiveValidation(profile);
 			if ((capabilityOnly || requestCap) && validation === "off") throw new Error("Capability requests require schema validation; remove --no-validate/--validation off.");
@@ -8808,7 +8878,8 @@ async function main(rawArgv, executableName = "linkrpc") {
 					requestCap,
 					capabilityOnly,
 					signingSession: session,
-					duration: opts["cap:duration"]
+					duration: opts["cap:duration"],
+					delegate: opts["cap:delegate"] === true
 				});
 				process.stdout.write(out + "\n");
 			}, {
@@ -9019,6 +9090,30 @@ Batch options:
 				local.close();
 			}
 		});
+		program.command("http-export").description("Serve loopback ports of Hub compute nodes at <port>.<service>.localhost over HTTP and WebSocket.").option("--port <n>", "Local port to listen on", (value) => parsePositiveInteger(value, "--port"), 80).option("--host <address>", "Local address to bind (repeatable; default 127.0.0.1 and ::1)", collectOption).option("--base-domain <domain>", "Base domain of exported hostnames", "localhost").action(async (opts) => {
+			const localEp = needEndpoint(endpoint);
+			const local = await connect(localEp, wireLog("hub"));
+			try {
+				const session = await setupSigning(local.channel, local.signing, getPrincipalSpec(), { negotiateHubCaps: isHubEndpoint(localEp) });
+				reportIdentity(session);
+				const server = await httpExportCommand({
+					local,
+					requestDirectoryAccess: (serviceId) => requestDirectoryAccess(session, serviceId, {}),
+					port: opts.port,
+					hosts: opts.host ?? ["127.0.0.1", "::1"],
+					baseDomain: opts.baseDomain,
+					onError: (error) => process.stderr.write(`linkrpc: ${error.message}\n`)
+				});
+				try {
+					process.stderr.write(`linkrpc: HTTP export listening at ${server.urls.join(", ")}\n`);
+					await _untilSignalled();
+				} finally {
+					await server.close();
+				}
+			} finally {
+				local.close();
+			}
+		});
 		program.command("json-rpc-stdio <serviceId>").description("Expose <serviceId>::jsonRpcConnection::connectRaw as a newline-delimited JSON-RPC endpoint on this process's stdin/stdout.").option("--params <json>", "JSON value passed to the remote transport factory").action(async (serviceId, opts) => {
 			const localEp = needEndpoint(endpoint);
 			let params;
@@ -9257,7 +9352,7 @@ Batch options:
 				process.once("SIGINT", onSignal);
 				process.once("SIGTERM", onSignal);
 				try {
-					const { runApprovalUi } = await import("./runApprovalUi-DTSdmhod.js");
+					const { runApprovalUi } = await import("./runApprovalUi-Diol5P5a.js");
 					await runApprovalUi({
 						client,
 						signal: stop.signal
@@ -9272,7 +9367,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-C8VfjCWT.js");
+		const { runUi } = await import("./runUi-DDJrDeBg.js");
 		try {
 			await runUi({
 				endpoint: acquired.ep,
@@ -9835,4 +9930,4 @@ function safeJson(value) {
 //#endregion
 export { formatCondition as _, formatCommandLegend as a, targetId as b, safeTerminalText as c, ObservablePromise as d, observableValue as f, resolveViewTarget as g, Disposable as h, dispatchHostKey as i, approvalDetailLines as l, derived as m, views as n, hostCommands as o, autorun as p, ViewFrame as r, matchesKey as s, runCli as t, ObservableLazyPromise as u, interfaceTarget as v, matchesTarget as y };
 
-//# sourceMappingURL=cli-BZ-4lHyj.js.map
+//# sourceMappingURL=cli-D_nbiyek.js.map