@hediet/linkrpc-cli 0.0.3-next.20261022.1 → 0.0.3-next.20261022.3

package/README.md

@@ -800,27 +800,33 @@ process's stdin/stdout (`--stdio`) or a `--target-endpoint*`. It keeps full
 LinkRPC semantics (service ids, streaming, cancellation) and adds what the
 participant cannot do itself:
 
-- `--outbound signed` (default) re-signs every call the participant emits as
-  the CLI's `--principal` and negotiates capabilities, so a participant without
-  signing support can call services behind `forwardChecking`.
-  `--outbound verbatim` forwards calls unsigned (keeping any `$hubrpc` envelope
-  the participant attached); `--outbound none` drops them.
-- `--claim <serviceId>` claims the service id and forwards requests the hub
-  routes to it to the participant, verbatim (callers' signatures are kept).
+- By default the proxy signs nothing: calls the participant makes are
+  forwarded to the hub as they are (unsigned, or keeping the `$hubrpc`
+  envelope the participant attached). `--sign-as [principal]` re-signs every
+  such call as `principal` (`managed`, `user:<id>`, or `file:<path>`; default:
+  `--principal`, i.e. the managed Hub identity) and requests capabilities for
+  those calls, so a participant without signing support can call services
+  behind `forwardChecking`. This lends the participant that identity.
+  `--no-outbound` drops the participant's calls instead. The global `--sign`
+  is rejected here to keep this choice explicit.
+- `--claim <serviceId>` registers the service id (that registration is signed
+  as `--principal`) and forwards requests the hub routes to it to the
+  participant unchanged, keeping callers' signatures.
 
 ```sh
 # A Rust client that cannot sign yet reaches a gated remote service.
 # Point it at this cmd-stdio endpoint and address calls to the remote service id:
-#   cmd-stdio:?argv=linkrpc&argv=hub&argv=proxy&argv=--stdio
-hub proxy --stdio
+#   cmd-stdio:?argv=linkrpc&argv=hub&argv=proxy&argv=--stdio&argv=--sign-as
+hub proxy --stdio --sign-as
+hub proxy --stdio --sign-as user:automation
 
 # Serve a stdio program under a service id (equivalent to `tunnel`).
-hub proxy --claim my/service --outbound none --target-endpoint-cmd-stdio "my-server --stdio"
+hub proxy --claim my/service --no-outbound --target-endpoint-cmd-stdio "my-server --stdio"
 ```
 
 With `--stdio`, the proxy exits when stdin closes. `tunnel <serviceId>` is
-`proxy --claim <serviceId>` with `--bidi` selecting `--outbound verbatim`
-instead of `none`.
+`proxy --claim <serviceId> --no-outbound`; with `--bidi` it forwards the
+target's calls unsigned.
 
 ### Capabilities
 

package/dist/chunks/{cli-Cw9kg0Dt.js → cli-DJREb0Dm.js}

@@ -1,4 +1,4 @@
-import { $ as requestTopologyAccess, B as proxyCommand, 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 mcpForwardInterface, U as parseConnectionLimit, V as tunnelCommand, W as parseConnectionLimitMilliseconds, _t as validateValueAgainstSchema, a as resolveInvocationEndpoint, bt as parseParamOverride, c as resolveLocalEndpoint, ct as parsePrincipalSpec, dt as connectViaTransport, et as setupSigning, ft as resolveTargetEndpoint, gt as explainValidation, ht as describeSchema, i as resolveInvocationContext, it as walkHub, lt as connect, m as managedEndpointsInterface, mt as describeObjectParams, n as loadStaticHubSchema, nt as fetchSchema$1, o as resolveSigning, ot as logoutCliIdentity, pt as resolvedEndpointToConfig, q as resolveCliInvocation, r as resolveStaticHubSchemaSource, rt as findMethodInSchema, s as validationDefault, st as formatPrincipalSource, t as completeForLine, tt as fetchDefaults, ut as connectViaRootOverlay, xt as MethodRefWithOptHash, y as HubHome, yt as mergeParams, z as ConnectionBroker } from "./runComplete-HH0NuvsL.js";
+import { $ as requestTopologyAccess, B as proxyCommand, 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 mcpForwardInterface, U as parseConnectionLimit, V as tunnelCommand, W as parseConnectionLimitMilliseconds, _t as validateValueAgainstSchema, a as resolveInvocationEndpoint, bt as parseParamOverride, c as resolveLocalEndpoint, ct as parsePrincipalSpec, dt as connectViaTransport, et as setupSigning, ft as resolveTargetEndpoint, gt as explainValidation, ht as describeSchema, i as resolveInvocationContext, it as walkHub, lt as connect, m as managedEndpointsInterface, mt as describeObjectParams, n as loadStaticHubSchema, nt as fetchSchema$1, o as resolveSigning, ot as logoutCliIdentity, pt as resolvedEndpointToConfig, q as resolveCliInvocation, r as resolveStaticHubSchemaSource, rt as findMethodInSchema, s as validationDefault, st as formatPrincipalSource, t as completeForLine, tt as fetchDefaults, ut as connectViaRootOverlay, xt as MethodRefWithOptHash, y as HubHome, yt as mergeParams, z as ConnectionBroker } from "./runComplete-C9LMCMk7.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";
@@ -406,7 +406,7 @@ function contextNamespace(reference) {
 async function useLocalManagement(start, action) {
 	const home = HubHome.resolve();
 	if (start) {
-		const { startDaemon, nodeDaemonLaunch } = await import("./src-CCHXMIFR.js");
+		const { startDaemon, nodeDaemonLaunch } = await import("./src-CCyOTeN5.js");
 		if (await startDaemon({
 			home,
 			launch: nodeDaemonLaunch(home)
@@ -426,7 +426,7 @@ async function useLocalManagement(start, action) {
 	}
 }
 async function restartLocalDaemon() {
-	const { startDaemon, stopDaemon, nodeDaemonLaunch } = await import("./src-CCHXMIFR.js");
+	const { startDaemon, stopDaemon, nodeDaemonLaunch } = await import("./src-CCyOTeN5.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);
@@ -8967,19 +8967,26 @@ Batch options:
 				local.close();
 			}
 		});
-		addTargetEndpointOptions(program.command("proxy").description("Stand in for a participant on the hub (--endpoint*). The participant is this process's stdin/stdout (--stdio) or a target endpoint (--target-endpoint*). Calls the participant emits are forwarded to the hub per --outbound: `signed` (default) re-signs them as this CLI's --principal with capability negotiation, so participants that cannot sign can call gated services; `verbatim` forwards them unsigned; `none` drops them. With --claim, requests the hub routes to <serviceId> are forwarded to the participant. Runs until the participant disconnects or Ctrl-C.")).option("--stdio", "use this process's stdin/stdout as the participant").option("--claim <serviceId>", "claim <serviceId> on the hub and forward its requests to the participant").addOption(new Option("--outbound <mode>", "how participant calls reach the hub").choices([
-			"signed",
-			"verbatim",
-			"none"
-		]).default("signed")).action(async (cmdOpts) => {
+		addTargetEndpointOptions(program.command("proxy").description("Connect a participant to the hub (--endpoint*) through this process. The participant is this process's stdin/stdout (--stdio) or a target endpoint (--target-endpoint*). By default the proxy does not sign anything: calls the participant makes are forwarded to the hub as they are (unsigned, or with the signature the participant attached). --sign-as re-signs them with an identity of this machine, --no-outbound drops them, and --claim makes the hub route a service id to the participant. Runs until the participant disconnects or Ctrl-C.")).option("--stdio", "use this process's stdin/stdout as the participant").option("--sign-as [principal]", "sign every call the participant makes as <principal> (\"managed\", \"user:<id>\" or \"file:<path>\"; default: --principal, i.e. the managed Hub identity falling back to user:hubrpc-cli) and request capabilities for those calls, prompting for approval when needed. This lends the participant that identity; use it for participants that cannot sign but must call services behind forwardChecking").option("--claim <serviceId>", "register <serviceId> on the hub (this registration is signed as --principal) and forward requests for it to the participant unchanged, keeping callers' signatures").option("--no-outbound", "drop calls the participant makes instead of forwarding them to the hub").action(async (cmdOpts) => {
 			const localEp = needEndpoint(endpoint);
 			if (cmdOpts.stdio === hasTargetEndpoint(cmdOpts)) {
 				process.stderr.write("linkrpc: proxy requires exactly one of --stdio or --target-endpoint*.\n");
 				process.exit(2);
 			}
+			if (g_invocation?.cliOverrides.sign === true) {
+				process.stderr.write("linkrpc: proxy does not use --sign; pass --sign-as [principal] to sign participant calls.\n");
+				process.exit(2);
+			}
+			if (cmdOpts.signAs !== void 0 && !cmdOpts.outbound) {
+				process.stderr.write("linkrpc: proxy --sign-as has no effect with --no-outbound.\n");
+				process.exit(2);
+			}
 			const targetEp = cmdOpts.stdio ? void 0 : resolveTargetEndpointOrExit(cmdOpts, program.opts(), "proxy");
 			const hub = await connect(localEp, wireLog("hub"));
-			reportIdentity(await setupSigning(hub.channel, hub.signing, getPrincipalSpec(), { negotiateHubCaps: isHubEndpoint(localEp) }));
+			if (cmdOpts.signAs !== void 0 || cmdOpts.claim !== void 0) {
+				const principal = typeof cmdOpts.signAs === "string" ? parsePrincipalSpec(cmdOpts.signAs) : getPrincipalSpec();
+				reportIdentity(await setupSigning(hub.channel, hub.signing, principal, { negotiateHubCaps: isHubEndpoint(localEp) }));
+			}
 			const participant = targetEp === void 0 ? await connectStdioParticipant() : {
 				connection: await connectTargetEndpoint(targetEp, cmdOpts.claim ?? ""),
 				closed: void 0
@@ -8988,7 +8995,7 @@ Batch options:
 				await proxyCommand({
 					hub,
 					participant: participant.connection,
-					outbound: cmdOpts.outbound,
+					outbound: !cmdOpts.outbound ? "none" : cmdOpts.signAs !== void 0 ? "signed" : "verbatim",
 					...cmdOpts.claim !== void 0 ? { claimServiceId: cmdOpts.claim } : {},
 					...participant.closed !== void 0 ? { stop: participant.closed } : {}
 				});
@@ -9118,7 +9125,7 @@ Batch options:
 				process.once("SIGINT", onSignal);
 				process.once("SIGTERM", onSignal);
 				try {
-					const { runApprovalUi } = await import("./runApprovalUi-DpoUwBpd.js");
+					const { runApprovalUi } = await import("./runApprovalUi-CdC5_Qoo.js");
 					await runApprovalUi({
 						client,
 						signal: stop.signal
@@ -9133,7 +9140,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-BbiA5lOP.js");
+		const { runUi } = await import("./runUi-Bb6VATfB.js");
 		try {
 			await runUi({
 				endpoint: acquired.ep,
@@ -9669,4 +9676,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-Cw9kg0Dt.js.map
+//# sourceMappingURL=cli-DJREb0Dm.js.map