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

package/README.md

@@ -581,7 +581,7 @@ it**. Pick one of:
 | `--endpoint <uri>`               | A strict endpoint URI (see below).                                                                         |
 | `--endpoint-cmd <command>`       | Spawn a _server_, hand it a fresh socket + token via `LINKRPC_ENDPOINT`/`LINKRPC_TOKEN`, then connect to it. |
 | `--endpoint-cmd-stdio <command>` | Spawn a child and talk linkrpc over its stdio.                                                              |
-| `LINKRPC_ENDPOINT` (env)          | A URI, or a legacy bare socket path / `ws://` URL. Token from `LINKRPC_TOKEN`; enabled by default in the Hub profile. |
+| `LINKRPC_ENDPOINT` (env)          | A URI, or a legacy bare socket path / `ws://` URL. Token from `LINKRPC_TOKEN`; enabled by default in the Hub profile and with `--use-env` in the RPC profile. |
 
 Legacy `HUBRPC_ENDPOINT` and `HUBRPC_TOKEN` remain supported when the
 corresponding `LINKRPC_*` variable is absent.

package/dist/chunks/{cli-CXAAnZDA.js → cli-BZ-4lHyj.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-M-eKaNkI.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-1DjMsU_0.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";
@@ -13,15 +13,15 @@ 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 { 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";
 import * as readline from "node:readline";
-import { createInterface, emitKeypressEvents } from "node:readline";
+import { createInterface as createInterface$1, emitKeypressEvents } from "node:readline";
 import { parse, unknown } from "zod/mini";
 import { bootstrapApprovalCapability, createHubApprovalClient } from "@hediet/linkrpc-infra/approval";
 import { connectionTokenBinderInterface } from "@hediet/linkrpc-hub/hub/server/connection-token-binder";
 import { spawn } from "node:child_process";
 import { TopologyClient, TopologyNetworkClient, TrafficClient } from "@hediet/linkrpc-infra/inspection";
-import { createInterface as createInterface$1 } from "node:readline/promises";
 import { stdin, stdout } from "node:process";
 import { TrafficFlowAggregator, createTerminalConsentPrompt, formatFlowSummary } from "@hediet/linkrpc-hub";
 import { loadHubConfig, printHubConfigSchema } from "@hediet/linkrpc-hub/config-file";
@@ -49,7 +49,7 @@ var ServiceConsoleInput = class {
 		this._close = _close;
 		this._wasRaw = _input.isRaw ?? false;
 		if (_input.isTTY) {
-			this._readline = createInterface({
+			this._readline = createInterface$1({
 				input: _input,
 				output,
 				terminal: true,
@@ -407,7 +407,7 @@ function contextNamespace(reference) {
 async function useLocalManagement(start, action) {
 	const home = HubHome.resolve();
 	if (start) {
-		const { startDaemon, nodeDaemonLaunch } = await import("./src-yrqRWXzG.js");
+		const { startDaemon, nodeDaemonLaunch } = await import("./src-DPg65Jd1.js");
 		if (await startDaemon({
 			home,
 			launch: nodeDaemonLaunch(home)
@@ -427,7 +427,7 @@ async function useLocalManagement(start, action) {
 	}
 }
 async function restartLocalDaemon() {
-	const { startDaemon, stopDaemon, nodeDaemonLaunch } = await import("./src-yrqRWXzG.js");
+	const { startDaemon, stopDaemon, nodeDaemonLaunch } = await import("./src-DPg65Jd1.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);
@@ -3040,7 +3040,7 @@ function selectParticipant(participants, nodeId) {
 	return participants.length === 1 ? participants[0] : void 0;
 }
 async function promptForParticipant(participants, search) {
-	const readline = createInterface$1({
+	const readline = createInterface({
 		input: stdin,
 		output: stdout
 	});
@@ -8734,7 +8734,8 @@ async function main(rawArgv, executableName = "linkrpc") {
 			return;
 		}
 		if (endpoint === void 0) {
-			process.stdout.write("\n(No endpoint configured: pass --endpoint / --endpoint-cmd or set LINKRPC_ENDPOINT\nto see method-specific --p:<name> flags here.)\n");
+			const ignoredEnvironmentHint = ignoredEndpointEnvironmentHint();
+			process.stdout.write(`\n(No endpoint configured: pass ${endpointOptionsDescription()}.\n` + (ignoredEnvironmentHint === void 0 ? "" : `${ignoredEnvironmentHint}.\n`) + "To see method-specific --p:<name> flags here.)\n");
 			return;
 		}
 		let ref;
@@ -9256,7 +9257,7 @@ Batch options:
 				process.once("SIGINT", onSignal);
 				process.once("SIGTERM", onSignal);
 				try {
-					const { runApprovalUi } = await import("./runApprovalUi-BdPp7WNP.js");
+					const { runApprovalUi } = await import("./runApprovalUi-DTSdmhod.js");
 					await runApprovalUi({
 						client,
 						signal: stop.signal
@@ -9271,7 +9272,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-Deeox_Ef.js");
+		const { runUi } = await import("./runUi-C8VfjCWT.js");
 		try {
 			await runUi({
 				endpoint: acquired.ep,
@@ -9283,13 +9284,27 @@ Batch options:
 			acquired.running?.dispose();
 		}
 	});
-	if (profile === "hub") program.command("logout").description("Delete the stored CLI identity and cached capabilities. Next call will mint a fresh keypair and prompt for consent again.").action(async () => {
-		const removed = await logoutCliIdentity();
-		if (removed.length === 0) {
-			process.stdout.write("linkrpc: no stored identity found.\n");
+	if (profile === "hub") program.command("logout").description("Delete the stored keypair and cached capabilities of the identity selected by --principal (default: the user:hubrpc-cli fallback). Asks for confirmation unless --yes is given. The next call mints a fresh keypair, which hubs that trusted the old key do not accept.").option("-y, --yes", "delete without asking for confirmation").action(async (opts) => {
+		const target = cliIdentityTarget(getPrincipalSpec());
+		const principal = await readCliIdentity(target);
+		if (principal === void 0) {
+			process.stdout.write(`linkrpc: no stored identity for ${target.label} (${target.file}).\n`);
 			return;
 		}
-		for (const f of removed) process.stdout.write(`removed ${f}\n`);
+		const description = `identity ${target.label} (${principal}) at ${target.file}`;
+		if (opts.yes !== true) {
+			if (process.stdin.isTTY !== true || process.stderr.isTTY !== true) throw new Error(`Refusing to delete ${description} without confirmation; pass --yes.`);
+			const readline = createInterface({
+				input: process.stdin,
+				output: process.stderr
+			});
+			const answer = await readline.question(`Delete ${description} and its cached capabilities? This cannot be undone. [y/N] `).finally(() => readline.close());
+			if (!/^y(es)?$/i.test(answer.trim())) {
+				process.stderr.write("linkrpc: logout cancelled.\n");
+				return;
+			}
+		}
+		for (const f of await deleteCliIdentity(target)) process.stdout.write(`removed ${f}\n`);
 	});
 	program.command("completions <shell>").description("Print a shell completion script. Supported: powershell. Install with `hub completions powershell | Out-String | Invoke-Expression` (one-shot) or append to $PROFILE.").action((shell) => {
 		try {
@@ -9639,7 +9654,8 @@ async function acquireConnection(endpoint) {
 	if (endpoint === void 0 && g_invocation?.profile === "hub") try {
 		return { ep: resolveLocalEndpoint() };
 	} catch {
-		throw new Error("No endpoint configured through flags, environment, or context, and the local Hub daemon is not running. Pass --endpoint, or start the daemon (any `hub services run` starts it).");
+		const ignoredEnvironmentHint = ignoredEndpointEnvironmentHint();
+		throw new Error(`No endpoint configured through flags, environment, or context, and the local Hub daemon is not running. Pass ${endpointOptionsDescription()}, or start the daemon (any \`hub services run\` starts it).` + (ignoredEnvironmentHint === void 0 ? "" : ` ${ignoredEnvironmentHint}.`));
 	}
 	return { ep: needEndpoint(endpoint) };
 }
@@ -9649,11 +9665,23 @@ function reportIdentity(session) {
 }
 function needEndpoint(endpoint) {
 	if (!endpoint) {
-		process.stderr.write("linkrpc: this command requires --endpoint / --endpoint-cmd / --endpoint-cmd-stdio or the LINKRPC_ENDPOINT env var to be set.\n");
+		const ignoredEnvironmentHint = ignoredEndpointEnvironmentHint();
+		process.stderr.write(`linkrpc: this command requires ${endpointOptionsDescription()}.\n` + (ignoredEnvironmentHint === void 0 ? "" : `linkrpc: ${ignoredEnvironmentHint}.\n`));
 		process.exit(2);
 	}
 	return endpoint;
 }
+function endpointOptionsDescription() {
+	const options = "--endpoint / --endpoint-cmd / --endpoint-cmd-stdio or a configured context";
+	return g_invocation?.profile === "hub" && g_invocation.environmentApplied ? `${options} or LINKRPC_ENDPOINT` : options;
+}
+function ignoredEndpointEnvironmentHint() {
+	const invocation = g_invocation;
+	if (invocation === void 0 || invocation.environmentApplied) return void 0;
+	const variable = process.env.LINKRPC_ENDPOINT !== void 0 ? "LINKRPC_ENDPOINT" : process.env.HUBRPC_ENDPOINT !== void 0 ? "HUBRPC_ENDPOINT" : void 0;
+	if (variable === void 0) return void 0;
+	return invocation.profile === "rpc" ? `${variable} is set but only used by hub commands: run \`linkrpc hub <command>\` (or pass --use-env)` : `${variable} is set but ignored because environment overrides are disabled; pass --use-env to apply it`;
+}
 /** The `--target-endpoint*` options shared by `tunnel` and `proxy`. */
 function addTargetEndpointOptions(command) {
 	return command.option("--target-endpoint <uri>", "target endpoint URI (unix:/path?token=…, npipe://./pipe/…, ws[s]://host?token=…, cmd:?command=… or cmd-stdio:?command=…)").option("--target-endpoint-cmd <command>", "spawn the target as a server, connect via an injected env socket; the child sees the claimed service id as grantedServiceIdNamespace via hubGrantedServiceId::get").option("--target-endpoint-cmd-stdio <command>", "spawn the target and talk linkrpc over its stdio").option("--target-endpoint-cmd-env <key=value>", "env var for the --target-endpoint-cmd / --target-endpoint-cmd-stdio child (repeatable)", (val, acc) => {
@@ -9807,4 +9835,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-CXAAnZDA.js.map
+//# sourceMappingURL=cli-BZ-4lHyj.js.map