@hediet/linkrpc-cli 0.0.3-next.20261025.3 → 0.0.3-next.20261026.1

package/README.md

@@ -794,7 +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. |
+| `http-export [--port <n>] [--host <address>]... [--base-domain <domain>] [--auth browser\|none]` | In the Hub profile, serve loopback ports of Hub compute nodes at `<port>.<service>.localhost` over HTTP and WebSocket; browsers must be approved once unless `--auth none`. |
 
 The inherited `--schema <path-or-url>` option also overlays static
 `hubrpc.defaults`, `hubrpc.directory`, and `hubrpc.schemas` reflection for
@@ -848,7 +848,7 @@ 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` (needs `linkrpc.computeNode.ports`). |
+| `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
@@ -880,6 +880,43 @@ 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.
 
+**Browser approval (prototype, on by default).** Browsers must be approved once
+before they can use the gateway; `--auth none` restores the behavior above.
+
+- A browser without approval is redirected to `http://localhost/.linkrpc/login`.
+  The gateway creates a signing key for that browser and asks the Hub's
+  approvers (`hubAccess::requestAccess`) to let it call `tcpForward` and
+  `ports::listListening` on the compute nodes. The page shows a code, the first
+  eight characters of the browser key (`id:key:AbCdEfGh…` → `AbCd-EfGh`),
+  and continues by itself once approved. Approve only requests whose principal
+  starts with the code your browser shows.
+- The gateway then signs that browser's calls with the browser's key and
+  granted capabilities, so compute nodes authorize the browser, not the
+  gateway. A browser approved for some machines only reaches those.
+- `localhost` keeps the browser's session cookie. Each service site
+  (`<service>.localhost`) gets its own cookie on first visit through a
+  single-use, 30-second ticket from `localhost`, bound to that site and to a
+  state cookie set by the site. Cookies are `HttpOnly`, `Secure`
+  (Chromium treats `http://*.localhost` as secure), and never reach forwarded
+  apps; apps cannot set them either.
+- Requests without `Sec-Fetch-*` and `Origin` headers (curl, scripts, agents)
+  are not affected and keep using the gateway's identity. Browser requests
+  other than page navigations get `401` until the browser is approved.
+- Approved sessions are kept in `--session-file` (default
+  `%LOCALAPPDATA%\linkrpc\http-export\browser-sessions-<port>.json` or
+  `$XDG_STATE_HOME/linkrpc/http-export/…`); it contains the browser keys.
+
+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.

package/dist/chunks/{cli-D_nbiyek.js → cli-CvfXZUzx.js}

@@ -6,12 +6,13 @@ import { SocketServer } from "@hediet/linkrpc-hub/hub/server/node";
 import { randomBytes, randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import { readFileSync } from "node:fs";
-import path, { dirname } from "node:path";
+import { homedir, hostname } from "node:os";
+import path, { dirname, join } from "node:path";
 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, findCoveringCapabilities, hubGrantedServiceIdInterface } from "@hediet/linkrpc/hub/common";
+import { DEFAULT_WALK_DEPTH, HubDirectoryExplorer, fetchSchema, findCoveringCapabilities, hubAccessInterface, hubGrantedServiceIdInterface } from "@hediet/linkrpc/hub/common";
 import { CONSOLE_INTERFACE_TAG, ConsoleTemplate, consoleAttachResultSchema, consoleServerMessageSchema, decodeConsoleData, encodeConsoleData } from "@hediet/linkrpc-infra/console";
 import { createInterface } from "node:readline/promises";
 import { Command, InvalidArgumentError, Option } from "commander";
@@ -3556,12 +3557,54 @@ async function httpExportCommand(options) {
 			port: options.port
 		})),
 		baseDomain: options.baseDomain,
-		getTcpForward: (serviceId) => connection.service(serviceId).get(computeNodeTcpForwardInterface),
+		getTcpForward: (serviceId, caller) => connection.service(serviceId).get(computeNodeTcpForwardInterface, signedAs(caller)),
 		listServices: () => services.get(),
-		listPorts: async (serviceId) => (await connection.service(serviceId).get(computeNodePortsInterface).listListening({})).ports,
+		listPorts: async (serviceId, caller) => (await connection.service(serviceId).get(computeNodePortsInterface, signedAs(caller)).listListening({})).ports,
+		...options.auth === "browser" ? { approval: {
+			gatewayName: hostname(),
+			...options.sessionFile === void 0 ? {} : { stateFile: options.sessionFile },
+			requestAccess: (request) => requestBrowserAccess(connection, request)
+		} } : {},
 		onError: options.onError
 	});
 }
+/** Per-user state file for approved browser sessions of a gateway on `port`. */
+function defaultHttpExportSessionFile(port) {
+	const base = process.platform === "win32" ? process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local") : process.env.XDG_STATE_HOME ?? join(homedir(), ".local", "state");
+	return join(base, "linkrpc", "http-export", `browser-sessions-${port}.json`);
+}
+/** Signs a browser's calls with its own key and approved capabilities instead of the gateway's identity. */
+function signedAs(caller) {
+	return caller ? {
+		signerOverride: caller.signer,
+		capsOverride: caller.capabilities
+	} : {};
+}
+/** Asks the Hub's approvers to grant `request.permissions` to the browser's principal; resolves once decided. */
+async function requestBrowserAccess(connection, request) {
+	const result = await connection.get(hubAccessInterface).requestAccess({
+		consumer: {
+			name: request.name,
+			purpose: request.purpose,
+			principal: request.principal
+		},
+		permissions: request.permissions.map((permission) => ({
+			...permission,
+			target: {
+				...permission.target,
+				members: [...permission.target.members]
+			}
+		})),
+		duration: "persistent"
+	});
+	return result.status === "granted" ? {
+		status: "granted",
+		capabilities: result.capabilities
+	} : {
+		status: result.status,
+		..."reason" in result && result.reason ? { reason: result.reason } : {}
+	};
+}
 /** Caches the services that implement `tcpForward`; a slow or partial walk returns what it found. */
 var ForwardableServices = class {
 	_channel;
@@ -9090,7 +9133,7 @@ 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) => {
+		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").addOption(new Option("--auth <mode>", "browser: browsers must be approved once through the Hub consent flow (tools without browser headers are not affected); none: no approval").choices(["browser", "none"]).default("browser")).option("--session-file <path>", "Where approved browser sessions are kept across restarts (contains browser keys)").action(async (opts) => {
 			const localEp = needEndpoint(endpoint);
 			const local = await connect(localEp, wireLog("hub"));
 			try {
@@ -9102,10 +9145,12 @@ Batch options:
 					port: opts.port,
 					hosts: opts.host ?? ["127.0.0.1", "::1"],
 					baseDomain: opts.baseDomain,
+					auth: opts.auth,
+					sessionFile: opts.sessionFile ?? defaultHttpExportSessionFile(opts.port),
 					onError: (error) => process.stderr.write(`linkrpc: ${error.message}\n`)
 				});
 				try {
-					process.stderr.write(`linkrpc: HTTP export listening at ${server.urls.join(", ")}\n`);
+					process.stderr.write(`linkrpc: HTTP export listening at ${server.urls.join(", ")}${opts.auth === "browser" ? " (browsers need approval; --auth none disables it)" : ""}\n`);
 					await _untilSignalled();
 				} finally {
 					await server.close();
@@ -9352,7 +9397,7 @@ Batch options:
 				process.once("SIGINT", onSignal);
 				process.once("SIGTERM", onSignal);
 				try {
-					const { runApprovalUi } = await import("./runApprovalUi-Diol5P5a.js");
+					const { runApprovalUi } = await import("./runApprovalUi-B8Gb0cg3.js");
 					await runApprovalUi({
 						client,
 						signal: stop.signal
@@ -9367,7 +9412,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-DDJrDeBg.js");
+		const { runUi } = await import("./runUi-BYS9ZvbD.js");
 		try {
 			await runUi({
 				endpoint: acquired.ep,
@@ -9930,4 +9975,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-D_nbiyek.js.map
+//# sourceMappingURL=cli-CvfXZUzx.js.map