@hediet/linkrpc-hub 0.0.1

package/dist/config.js

@@ -0,0 +1,305 @@
+import { z } from "zod";
+//#region src/config.ts
+/**
+* Declarative hub configuration shared by the CLI (`serve`, `connect`,
+* `tunnel`, `-c, --config`), the server hub, and the VS Code extension. One
+* config describes a hub by its **transports**:
+*
+* - {@link HubConfig.listeners} — inbound: accept many peers (websocket / unix
+*   socket). Each peer is admitted by the listener's ordered {@link
+*   ConnectionHandlerSchema handlers} (keyed on the presented token), which also
+*   provision its root services (identity, granted namespace, minting).
+* - {@link HubConfig.endpoints} — outbound: dial a single far end (a remote
+*   hub over `ws`/`socket`, or a spawned child over `cmd-env`/`cmd-stdio`).
+*   Dial-out has no token, so an endpoint carries a single inline
+*   {@link provisionFields provision} instead of handlers.
+* - {@link HubConfig.namedEndpoints} — sugar over `endpoints`: the map key
+*   becomes the `grantedServiceId` and the `managedIdentity.slot`
+*   (`endpoint:<name>`) unless overridden.
+*/
+/**
+* A **provision**: the root services a connection is granted once admitted.
+* Shared by listener handlers (static/anonymous forms) and endpoints. Each
+* field is optional and names the root interface it enables.
+*/
+const ConnectionTokenBinderSchema = z.object({
+	/** Managed-identity slots this binder may mint (literal string prefix). */
+	identitySlotPrefix: z.string().min(1).optional(),
+	/** ServiceId namespaces this binder may grant (literal string prefix). */
+	serviceIdPrefix: z.string().min(1).optional()
+});
+const provisionFields = {
+	/**
+	* Managed identity for the connection (`identity::*`), provisioned under
+	* `slot`. Omit for no managed identity.
+	*/
+	managedIdentity: z.object({ slot: z.string().min(1) }).optional(),
+	/**
+	* ServiceId namespace the connection may claim freely
+	* (`hubGrantedServiceId::get`). Omit to grant no freely-claimable namespace.
+	*/
+	grantedServiceId: z.string().min(1).optional(),
+	/**
+	* Authorize the connection to mint single-use connection tokens by serving
+	* `connectionTokenBinder::bindConnectionToken` at its overlay root. The two
+	* prefixes bound **independent axes** of what a minted token may carry; set
+	* either, both, or neither.
+	*/
+	connectionTokenBinder: ConnectionTokenBinderSchema.optional()
+};
+/**
+* A listener **connection handler**: a token match + (for the static forms) the
+* provision to install when it claims. Discriminated by `token`:
+*
+* - `anonymous` — claims **any** connection (the catch-all "no auth"); provisions
+*   the inline fields.
+* - `static` — claims connections whose presented token equals `value`;
+*   provisions the inline fields.
+* - `bound` — claims connections whose token is live in the hub's
+*   connection-token store, **redeeming** it (single-use). The provision is
+*   **intrinsic** to the token's mint binding (identity slot and/or granted
+*   namespace), so it carries no inline provision.
+*/
+const ConnectionHandlerSchema = z.discriminatedUnion("token", [
+	z.object({
+		token: z.literal("anonymous"),
+		...provisionFields
+	}),
+	z.object({
+		token: z.literal("static"),
+		value: z.string().min(1),
+		...provisionFields
+	}),
+	z.object({ token: z.literal("bound") })
+]);
+/** Routing fields common to every endpoint (outbound transport). */
+const routingFields = {
+	/** The far end serves these service ids; route matching calls OUT to it. */
+	routeServiceIds: z.array(z.string().min(1)).default([]),
+	/** I serve these service ids; register them on the far end's hub. */
+	claimServiceIds: z.array(z.string().min(1)).default([]),
+	/** Catch-all: anything not otherwise routed goes to this transport. */
+	defaultRoute: z.boolean().default(false),
+	/**
+	* The root services the far end is provisioned with (`managedIdentity`,
+	* `grantedServiceId`, `connectionTokenBinder`). Only honored on `cmd-env`
+	* endpoints (the only outbound transport that gets an overlay-root front
+	* door); `connectionTokenBinder` is rejected on other endpoint kinds. Each
+	* binder prefix (e.g. `"docker/"`) is matched against the requested value as
+	* a literal string prefix — it grants an unbounded family, so scope it
+	* narrowly. The token minted here is later redeemed by a peer on a listener
+	* `{ token: "bound" }` handler.
+	*/
+	...provisionFields
+};
+/** Universal copy-paste form: a strict endpoint URI plus an optional token. */
+const uriEndpoint = z.object({
+	kind: z.literal("uri"),
+	/** e.g. `wss://host/?…`, `unix:/run/hub.sock`, `npipe://./pipe/x`. */
+	uri: z.string().min(1),
+	token: z.string().optional(),
+	...routingFields
+});
+/** A running WebSocket hub. */
+const wsEndpoint = z.object({
+	kind: z.literal("ws"),
+	url: z.string().min(1),
+	token: z.string().optional(),
+	...routingFields
+});
+/** A named pipe / unix-domain socket the far end already listens on. */
+const socketEndpoint = z.object({
+	kind: z.literal("socket"),
+	path: z.string().min(1),
+	token: z.string().optional(),
+	...routingFields
+});
+const commandFields = {
+	/** Verbatim command line (run through the shell). Use this or `argv`. */
+	cmd: z.string().optional(),
+	/** Pre-split argv (no shell). Use this or `cmd`. */
+	argv: z.array(z.string()).optional(),
+	/** Extra environment variables for the spawned child. */
+	env: z.record(z.string(), z.string()).optional(),
+	/** Working directory for the spawned child. */
+	cwd: z.string().optional()
+};
+/** Spawn a child against a private hub socket; it dials back as a participant. */
+const cmdEnvEndpoint = z.object({
+	kind: z.literal("cmd-env"),
+	...commandFields,
+	...routingFields
+});
+/** Spawn a child and talk linkrpc over its stdin/stdout. */
+const cmdStdioEndpoint = z.object({
+	kind: z.literal("cmd-stdio"),
+	...commandFields,
+	...routingFields
+});
+/**
+* Outbound participant kinds that can be attached to an already-running Hub
+* without host-specific admission or identity provisioning.
+*/
+const ParticipantConnectorConfigSchema = z.discriminatedUnion("kind", [
+	uriEndpoint,
+	wsEndpoint,
+	socketEndpoint,
+	cmdStdioEndpoint
+]);
+const EndpointConfigSchema = z.discriminatedUnion("kind", [
+	uriEndpoint,
+	wsEndpoint,
+	socketEndpoint,
+	cmdEnvEndpoint,
+	cmdStdioEndpoint
+]);
+/** Fields a listener shares regardless of transport type. */
+const listenerCommon = { 
+/**
+* Ordered connection handlers. Each accepted peer is admitted by the first
+* handler whose token check claims it (see {@link ConnectionHandlerSchema});
+* that handler also provisions the peer's root services. **Required** — an
+* empty array accepts no connection.
+*/
+handlers: z.array(ConnectionHandlerSchema).default([]) };
+const websocketListener = z.object({
+	type: z.literal("websocket"),
+	host: z.string().default("127.0.0.1"),
+	port: z.number().int().min(0).max(65535).default(7878),
+	path: z.string().startsWith("/").default("/"),
+	healthPath: z.string().startsWith("/").nullable().default("/healthz"),
+	maxPayload: z.number().int().positive().default(16777216),
+	/** Optional `Origin` allow-list for browser clients. */
+	allowedOrigins: z.array(z.string()).default([]),
+	...listenerCommon
+});
+const socketListener = z.object({
+	type: z.literal("socket"),
+	/** UDS path (posix) or named pipe (`\\.\pipe\…`, win32). */
+	path: z.string().min(1),
+	...listenerCommon
+});
+const ListenerConfigSchema = z.discriminatedUnion("type", [websocketListener, socketListener]);
+/**
+* Forward-checking policy for the hub's inbound listeners. When enabled, the
+* hub mints an admin signing identity, serves the signed
+* `hubServiceIdRegistry::registerServiceId` + `hubAccess` front doors, and gates
+* every forwarded (fully-qualified) call at each listener boundary:
+*
+* - `verifySignatures` — forwarded calls must carry a valid `$hubrpc`
+*   signature (authenticity).
+* - `requireCapability` — forwarded calls must additionally present a
+*   capability chain rooting at the hub admin (authorization). Granting
+*   capabilities is gated by the {@link HubAccessManifestHost} consent rendezvous.
+*
+* `true` is shorthand for both flags on; `false` disables forward checking
+* entirely (open hub, no consent surface).
+*/
+const ForwardCheckingSchema = z.union([z.boolean(), z.object({
+	verifySignatures: z.boolean().default(true),
+	requireCapability: z.boolean().default(true)
+})]).default(true);
+/**
+* Where the built-in terminal consent approver sources its pending requests
+* from. The approver consumes `hubAccessManifest::{getDesired,watchDesired,
+* setCurrent}` **over a connection** — never the in-process host object — so the
+* same loop works against a remote source unchanged.
+*
+* - `true` (default) — consume this hub's own manifest (served under
+*   {@link HubConfig.hubServiceId}). The common, local-operator case.
+* - `{ serviceId }` — consume the manifest served at `serviceId` (e.g. an
+*   upstream hub the operator approves on behalf of).
+* - `false` — install no built-in approver; rely entirely on external approvers
+*   (configured {@link HubConfig.rootPrincipalIds}) deciding via the manifest.
+*
+* The approver is only started when stdin is a TTY (it drives a terminal
+* prompt); a non-interactive hub is keyless regardless of this setting.
+*/
+const ConsentApproverSchema = z.union([z.boolean(), z.object({ serviceId: z.string().min(1) })]).default(true);
+const HubConfigSchema = z.object({
+	/**
+	* Conventional pointer to a JSON Schema. Ignored at runtime; present so
+	* editors validate against `--print-schema` output.
+	*/
+	$schema: z.string().optional(),
+	/**
+	* The hub's own service id: the prefix under which it mounts its global
+	* services (`hubAccess`, `hubrpc.directory`, reflection) and the target of
+	* each overlay's `hubrpc.directory` referral. Defaults to `'hub'`.
+	*/
+	hubServiceId: z.string().min(1).default("hub"),
+	/** Inbound transports: accept many peers. */
+	listeners: z.array(ListenerConfigSchema).default([]),
+	/** Outbound transports: dial a single far end each. */
+	endpoints: z.array(EndpointConfigSchema).default([]),
+	/**
+	* Sugar over {@link endpoints}: the map key becomes the entry's
+	* `grantedServiceId` and its `managedIdentity.slot` (`endpoint:<name>`)
+	* unless overridden.
+	*/
+	namedEndpoints: z.record(z.string().min(1), EndpointConfigSchema).default({}),
+	/**
+	* Gate forwarded calls on inbound listeners. Defaults to `true`: signatures
+	* are verified and a hub-admin-rooted capability is required, with consent
+	* driven through the CLI consent prompt. Set `false` for an open hub.
+	*/
+	forwardChecking: ForwardCheckingSchema,
+	/**
+	* Persistent identity slot used to mint the hub's admin signing identity
+	* (the capability root) when {@link forwardChecking} is enabled. Stored
+	* alongside other provisioned identities.
+	*/
+	adminIdentitySlot: z.string().min(1).default("hub-admin"),
+	/**
+	* Additional capability root principal ids the forwarded-call gate trusts,
+	* beyond the hub's own admin identity. Lets an external participant (e.g. a
+	* dedicated access-granting service) mint capabilities the hub honors
+	* without sharing the hub admin key. Only consulted when
+	* {@link forwardChecking} requires a capability.
+	*/
+	rootPrincipalIds: z.array(z.string().min(1)).default([]),
+	/**
+	* Source for the built-in terminal consent approver. See
+	* {@link ConsentApproverSchema}. Defaults to `true` (this hub's own manifest).
+	* Only takes effect when {@link forwardChecking} requires a capability and
+	* stdin is interactive.
+	*/
+	consentApprover: ConsentApproverSchema
+});
+/** Parse + validate an in-memory config object. Throws `ZodError` on failure. */
+function parseHubConfig(raw) {
+	return HubConfigSchema.parse(_applyNamedEndpointDefaults(raw));
+}
+/**
+* Apply `namedEndpoints` sugar before validation: each entry's key becomes its
+* `grantedServiceId` and its `managedIdentity.slot` (`endpoint:<name>`)
+* unless set. Done pre-parse so Zod's own defaults don't erase the
+* "was it omitted?" signal.
+*/
+function _applyNamedEndpointDefaults(raw) {
+	if (raw === null || typeof raw !== "object") return raw;
+	const r = raw;
+	const named = r.namedEndpoints;
+	if (named === null || typeof named !== "object") return raw;
+	const out = {};
+	for (const [key, value] of Object.entries(named)) if (value !== null && typeof value === "object") {
+		const v = value;
+		out[key] = {
+			...v,
+			grantedServiceId: v.grantedServiceId ?? key,
+			managedIdentity: v.managedIdentity ?? { slot: `endpoint:${key}` }
+		};
+	} else out[key] = value;
+	return {
+		...r,
+		namedEndpoints: out
+	};
+}
+/** JSON-Schema for the config file (for `--print-schema` / editor tooling). */
+function hubConfigJsonSchema() {
+	return z.toJSONSchema(HubConfigSchema, { target: "draft-2020-12" });
+}
+//#endregion
+export { ConnectionHandlerSchema, ConnectionTokenBinderSchema, ConsentApproverSchema, EndpointConfigSchema, ForwardCheckingSchema, HubConfigSchema, ListenerConfigSchema, ParticipantConnectorConfigSchema, hubConfigJsonSchema, parseHubConfig };
+
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","names":[],"sources":["../src/config.ts"],"sourcesContent":["/**\n * Declarative hub configuration shared by the CLI (`serve`, `connect`,\n * `tunnel`, `-c, --config`), the server hub, and the VS Code extension. One\n * config describes a hub by its **transports**:\n *\n * - {@link HubConfig.listeners} — inbound: accept many peers (websocket / unix\n *   socket). Each peer is admitted by the listener's ordered {@link\n *   ConnectionHandlerSchema handlers} (keyed on the presented token), which also\n *   provision its root services (identity, granted namespace, minting).\n * - {@link HubConfig.endpoints} — outbound: dial a single far end (a remote\n *   hub over `ws`/`socket`, or a spawned child over `cmd-env`/`cmd-stdio`).\n *   Dial-out has no token, so an endpoint carries a single inline\n *   {@link provisionFields provision} instead of handlers.\n * - {@link HubConfig.namedEndpoints} — sugar over `endpoints`: the map key\n *   becomes the `grantedServiceId` and the `managedIdentity.slot`\n *   (`endpoint:<name>`) unless overridden.\n */\nimport { z } from 'zod';\n\n/**\n * A **provision**: the root services a connection is granted once admitted.\n * Shared by listener handlers (static/anonymous forms) and endpoints. Each\n * field is optional and names the root interface it enables.\n */\nexport const ConnectionTokenBinderSchema = z.object({\n    /** Managed-identity slots this binder may mint (literal string prefix). */\n    identitySlotPrefix: z.string().min(1).optional(),\n    /** ServiceId namespaces this binder may grant (literal string prefix). */\n    serviceIdPrefix: z.string().min(1).optional(),\n});\nexport type ConnectionTokenBinderConfig = z.infer<typeof ConnectionTokenBinderSchema>;\n\nconst provisionFields = {\n    /**\n     * Managed identity for the connection (`identity::*`), provisioned under\n     * `slot`. Omit for no managed identity.\n     */\n    managedIdentity: z.object({ slot: z.string().min(1) }).optional(),\n    /**\n     * ServiceId namespace the connection may claim freely\n     * (`hubGrantedServiceId::get`). Omit to grant no freely-claimable namespace.\n     */\n    grantedServiceId: z.string().min(1).optional(),\n    /**\n     * Authorize the connection to mint single-use connection tokens by serving\n     * `connectionTokenBinder::bindConnectionToken` at its overlay root. The two\n     * prefixes bound **independent axes** of what a minted token may carry; set\n     * either, both, or neither.\n     */\n    connectionTokenBinder: ConnectionTokenBinderSchema.optional(),\n};\n\nexport type ProvisionConfig = z.infer<z.ZodObject<typeof provisionFields>>;\n\n/**\n * A listener **connection handler**: a token match + (for the static forms) the\n * provision to install when it claims. Discriminated by `token`:\n *\n * - `anonymous` — claims **any** connection (the catch-all \"no auth\"); provisions\n *   the inline fields.\n * - `static` — claims connections whose presented token equals `value`;\n *   provisions the inline fields.\n * - `bound` — claims connections whose token is live in the hub's\n *   connection-token store, **redeeming** it (single-use). The provision is\n *   **intrinsic** to the token's mint binding (identity slot and/or granted\n *   namespace), so it carries no inline provision.\n */\nexport const ConnectionHandlerSchema = z.discriminatedUnion('token', [\n    z.object({ token: z.literal('anonymous'), ...provisionFields }),\n    z.object({ token: z.literal('static'), value: z.string().min(1), ...provisionFields }),\n    z.object({ token: z.literal('bound') }),\n]);\nexport type ConnectionHandlerConfig = z.infer<typeof ConnectionHandlerSchema>;\n\n/** Routing fields common to every endpoint (outbound transport). */\nconst routingFields = {\n    /** The far end serves these service ids; route matching calls OUT to it. */\n    routeServiceIds: z.array(z.string().min(1)).default([]),\n    /** I serve these service ids; register them on the far end's hub. */\n    claimServiceIds: z.array(z.string().min(1)).default([]),\n    /** Catch-all: anything not otherwise routed goes to this transport. */\n    defaultRoute: z.boolean().default(false),\n    /**\n     * The root services the far end is provisioned with (`managedIdentity`,\n     * `grantedServiceId`, `connectionTokenBinder`). Only honored on `cmd-env`\n     * endpoints (the only outbound transport that gets an overlay-root front\n     * door); `connectionTokenBinder` is rejected on other endpoint kinds. Each\n     * binder prefix (e.g. `\"docker/\"`) is matched against the requested value as\n     * a literal string prefix — it grants an unbounded family, so scope it\n     * narrowly. The token minted here is later redeemed by a peer on a listener\n     * `{ token: \"bound\" }` handler.\n     */\n    ...provisionFields,\n};\n\n// ---- endpoints (outbound) -----------------------------------------------\n\n/** Universal copy-paste form: a strict endpoint URI plus an optional token. */\nconst uriEndpoint = z.object({\n    kind: z.literal('uri'),\n    /** e.g. `wss://host/?…`, `unix:/run/hub.sock`, `npipe://./pipe/x`. */\n    uri: z.string().min(1),\n    token: z.string().optional(),\n    ...routingFields,\n});\n\n/** A running WebSocket hub. */\nconst wsEndpoint = z.object({\n    kind: z.literal('ws'),\n    url: z.string().min(1),\n    token: z.string().optional(),\n    ...routingFields,\n});\n\n/** A named pipe / unix-domain socket the far end already listens on. */\nconst socketEndpoint = z.object({\n    kind: z.literal('socket'),\n    path: z.string().min(1),\n    token: z.string().optional(),\n    ...routingFields,\n});\n\nconst commandFields = {\n    /** Verbatim command line (run through the shell). Use this or `argv`. */\n    cmd: z.string().optional(),\n    /** Pre-split argv (no shell). Use this or `cmd`. */\n    argv: z.array(z.string()).optional(),\n    /** Extra environment variables for the spawned child. */\n    env: z.record(z.string(), z.string()).optional(),\n    /** Working directory for the spawned child. */\n    cwd: z.string().optional(),\n};\n\n/** Spawn a child against a private hub socket; it dials back as a participant. */\nconst cmdEnvEndpoint = z.object({\n    kind: z.literal('cmd-env'),\n    ...commandFields,\n    ...routingFields,\n});\n\n/** Spawn a child and talk linkrpc over its stdin/stdout. */\nconst cmdStdioEndpoint = z.object({\n    kind: z.literal('cmd-stdio'),\n    ...commandFields,\n    ...routingFields,\n});\n\n/**\n * Outbound participant kinds that can be attached to an already-running Hub\n * without host-specific admission or identity provisioning.\n */\nexport const ParticipantConnectorConfigSchema = z.discriminatedUnion('kind', [\n    uriEndpoint,\n    wsEndpoint,\n    socketEndpoint,\n    cmdStdioEndpoint,\n]);\nexport type ParticipantConnectorConfig = z.infer<typeof ParticipantConnectorConfigSchema>;\n\nexport const EndpointConfigSchema = z.discriminatedUnion('kind', [\n    uriEndpoint,\n    wsEndpoint,\n    socketEndpoint,\n    cmdEnvEndpoint,\n    cmdStdioEndpoint,\n]);\nexport type EndpointConfig = z.infer<typeof EndpointConfigSchema>;\n\n// ---- listeners (inbound) ------------------------------------------------\n\n/** Fields a listener shares regardless of transport type. */\nconst listenerCommon = {\n    /**\n     * Ordered connection handlers. Each accepted peer is admitted by the first\n     * handler whose token check claims it (see {@link ConnectionHandlerSchema});\n     * that handler also provisions the peer's root services. **Required** — an\n     * empty array accepts no connection.\n     */\n    handlers: z.array(ConnectionHandlerSchema).default([]),\n};\n\nconst websocketListener = z.object({\n    type: z.literal('websocket'),\n    host: z.string().default('127.0.0.1'),\n    port: z.number().int().min(0).max(65535).default(7878),\n    path: z.string().startsWith('/').default('/'),\n    healthPath: z.string().startsWith('/').nullable().default('/healthz'),\n    maxPayload: z.number().int().positive().default(16 * 1024 * 1024),\n    /** Optional `Origin` allow-list for browser clients. */\n    allowedOrigins: z.array(z.string()).default([]),\n    ...listenerCommon,\n});\n\nconst socketListener = z.object({\n    type: z.literal('socket'),\n    /** UDS path (posix) or named pipe (`\\\\.\\pipe\\…`, win32). */\n    path: z.string().min(1),\n    ...listenerCommon,\n});\n\nexport const ListenerConfigSchema = z.discriminatedUnion('type', [\n    websocketListener,\n    socketListener,\n]);\nexport type ListenerConfig = z.infer<typeof ListenerConfigSchema>;\n\n// ---- forward checking ---------------------------------------------------\n\n/**\n * Forward-checking policy for the hub's inbound listeners. When enabled, the\n * hub mints an admin signing identity, serves the signed\n * `hubServiceIdRegistry::registerServiceId` + `hubAccess` front doors, and gates\n * every forwarded (fully-qualified) call at each listener boundary:\n *\n * - `verifySignatures` — forwarded calls must carry a valid `$hubrpc`\n *   signature (authenticity).\n * - `requireCapability` — forwarded calls must additionally present a\n *   capability chain rooting at the hub admin (authorization). Granting\n *   capabilities is gated by the {@link HubAccessManifestHost} consent rendezvous.\n *\n * `true` is shorthand for both flags on; `false` disables forward checking\n * entirely (open hub, no consent surface).\n */\nexport const ForwardCheckingSchema = z.union([\n    z.boolean(),\n    z.object({\n        verifySignatures: z.boolean().default(true),\n        requireCapability: z.boolean().default(true),\n    }),\n]).default(true);\nexport type ForwardCheckingConfig = z.infer<typeof ForwardCheckingSchema>;\n\n/**\n * Where the built-in terminal consent approver sources its pending requests\n * from. The approver consumes `hubAccessManifest::{getDesired,watchDesired,\n * setCurrent}` **over a connection** — never the in-process host object — so the\n * same loop works against a remote source unchanged.\n *\n * - `true` (default) — consume this hub's own manifest (served under\n *   {@link HubConfig.hubServiceId}). The common, local-operator case.\n * - `{ serviceId }` — consume the manifest served at `serviceId` (e.g. an\n *   upstream hub the operator approves on behalf of).\n * - `false` — install no built-in approver; rely entirely on external approvers\n *   (configured {@link HubConfig.rootPrincipalIds}) deciding via the manifest.\n *\n * The approver is only started when stdin is a TTY (it drives a terminal\n * prompt); a non-interactive hub is keyless regardless of this setting.\n */\nexport const ConsentApproverSchema = z.union([\n    z.boolean(),\n    z.object({ serviceId: z.string().min(1) }),\n]).default(true);\nexport type ConsentApproverConfig = z.infer<typeof ConsentApproverSchema>;\n\n// ---- top level ----------------------------------------------------------\n\nexport const HubConfigSchema = z.object({\n    /**\n     * Conventional pointer to a JSON Schema. Ignored at runtime; present so\n     * editors validate against `--print-schema` output.\n     */\n    $schema: z.string().optional(),\n    /**\n     * The hub's own service id: the prefix under which it mounts its global\n     * services (`hubAccess`, `hubrpc.directory`, reflection) and the target of\n     * each overlay's `hubrpc.directory` referral. Defaults to `'hub'`.\n     */\n    hubServiceId: z.string().min(1).default('hub'),\n    /** Inbound transports: accept many peers. */\n    listeners: z.array(ListenerConfigSchema).default([]),\n    /** Outbound transports: dial a single far end each. */\n    endpoints: z.array(EndpointConfigSchema).default([]),\n    /**\n     * Sugar over {@link endpoints}: the map key becomes the entry's\n     * `grantedServiceId` and its `managedIdentity.slot` (`endpoint:<name>`)\n     * unless overridden.\n     */\n    namedEndpoints: z.record(z.string().min(1), EndpointConfigSchema).default({}),\n    /**\n     * Gate forwarded calls on inbound listeners. Defaults to `true`: signatures\n     * are verified and a hub-admin-rooted capability is required, with consent\n     * driven through the CLI consent prompt. Set `false` for an open hub.\n     */\n    forwardChecking: ForwardCheckingSchema,\n    /**\n     * Persistent identity slot used to mint the hub's admin signing identity\n     * (the capability root) when {@link forwardChecking} is enabled. Stored\n     * alongside other provisioned identities.\n     */\n    adminIdentitySlot: z.string().min(1).default('hub-admin'),\n    /**\n     * Additional capability root principal ids the forwarded-call gate trusts,\n     * beyond the hub's own admin identity. Lets an external participant (e.g. a\n     * dedicated access-granting service) mint capabilities the hub honors\n     * without sharing the hub admin key. Only consulted when\n     * {@link forwardChecking} requires a capability.\n     */\n    rootPrincipalIds: z.array(z.string().min(1)).default([]),\n    /**\n     * Source for the built-in terminal consent approver. See\n     * {@link ConsentApproverSchema}. Defaults to `true` (this hub's own manifest).\n     * Only takes effect when {@link forwardChecking} requires a capability and\n     * stdin is interactive.\n     */\n    consentApprover: ConsentApproverSchema,\n});\nexport type HubConfig = z.infer<typeof HubConfigSchema>;\n\n/** Parse + validate an in-memory config object. Throws `ZodError` on failure. */\nexport function parseHubConfig(raw: unknown): HubConfig {\n    return HubConfigSchema.parse(_applyNamedEndpointDefaults(raw));\n}\n\n/**\n * Apply `namedEndpoints` sugar before validation: each entry's key becomes its\n * `grantedServiceId` and its `managedIdentity.slot` (`endpoint:<name>`)\n * unless set. Done pre-parse so Zod's own defaults don't erase the\n * \"was it omitted?\" signal.\n */\nfunction _applyNamedEndpointDefaults(raw: unknown): unknown {\n    if (raw === null || typeof raw !== 'object') return raw;\n    const r = raw as Record<string, unknown>;\n    const named = r.namedEndpoints;\n    if (named === null || typeof named !== 'object') return raw;\n    const out: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(named as Record<string, unknown>)) {\n        if (value !== null && typeof value === 'object') {\n            const v = value as Record<string, unknown>;\n            out[key] = {\n                ...v,\n                grantedServiceId: v.grantedServiceId ?? key,\n                managedIdentity: v.managedIdentity ?? { slot: `endpoint:${key}` },\n            };\n        } else {\n            out[key] = value;\n        }\n    }\n    return { ...r, namedEndpoints: out };\n}\n\n/** JSON-Schema for the config file (for `--print-schema` / editor tooling). */\nexport function hubConfigJsonSchema(): unknown {\n    return z.toJSONSchema(HubConfigSchema, { target: 'draft-2020-12' });\n}\n"],"mappings":"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"}

package/dist/configFile.d.ts

@@ -0,0 +1,2 @@
+import { n as printHubConfigSchema, t as loadHubConfig } from "./chunks/configFile-y6Phntqu.js";
+export { loadHubConfig, printHubConfigSchema };

package/dist/configFile.js

@@ -0,0 +1,27 @@
+import { hubConfigJsonSchema, parseHubConfig } from "./config.js";
+import * as fs from "node:fs";
+//#region src/configFile.ts
+/** Read and validate a hub config file. */
+function loadHubConfig(configPath) {
+	let text;
+	try {
+		text = fs.readFileSync(configPath, "utf8");
+	} catch (error) {
+		throw new Error(`cannot read config '${configPath}': ${error.message}`);
+	}
+	let raw;
+	try {
+		raw = JSON.parse(text);
+	} catch (error) {
+		throw new Error(`invalid JSON in '${configPath}': ${error.message}`);
+	}
+	return parseHubConfig(raw);
+}
+/** The config JSON Schema, pretty-printed. */
+function printHubConfigSchema() {
+	return JSON.stringify(hubConfigJsonSchema(), null, 2);
+}
+//#endregion
+export { loadHubConfig, printHubConfigSchema };
+
+//# sourceMappingURL=configFile.js.map

package/dist/configFile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"configFile.js","names":[],"sources":["../src/configFile.ts"],"sourcesContent":["import * as fs from 'node:fs';\nimport { type HubConfig, hubConfigJsonSchema, parseHubConfig } from './config';\n\n/** Read and validate a hub config file. */\nexport function loadHubConfig(configPath: string): HubConfig {\n    let text: string;\n    try {\n        text = fs.readFileSync(configPath, 'utf8');\n    } catch (error) {\n        throw new Error(`cannot read config '${configPath}': ${(error as Error).message}`);\n    }\n    let raw: unknown;\n    try {\n        raw = JSON.parse(text);\n    } catch (error) {\n        throw new Error(`invalid JSON in '${configPath}': ${(error as Error).message}`);\n    }\n    return parseHubConfig(raw);\n}\n\n/** The config JSON Schema, pretty-printed. */\nexport function printHubConfigSchema(): string {\n    return JSON.stringify(hubConfigJsonSchema(), null, 2);\n}\n"],"mappings":";;;;AAIA,SAAgB,cAAc,YAA+B;CACzD,IAAI;CACJ,IAAI;EACA,OAAO,GAAG,aAAa,YAAY,MAAM;CAC7C,SAAS,OAAO;EACZ,MAAM,IAAI,MAAM,uBAAuB,WAAW,KAAM,MAAgB,SAAS;CACrF;CACA,IAAI;CACJ,IAAI;EACA,MAAM,KAAK,MAAM,IAAI;CACzB,SAAS,OAAO;EACZ,MAAM,IAAI,MAAM,oBAAoB,WAAW,KAAM,MAAgB,SAAS;CAClF;CACA,OAAO,eAAe,GAAG;AAC7B;;AAGA,SAAgB,uBAA+B;CAC3C,OAAO,KAAK,UAAU,oBAAoB,GAAG,MAAM,CAAC;AACxD"}

package/dist/engine/runHub.d.ts

@@ -0,0 +1,42 @@
+import { d as HubConfig, p as ListenerConfig } from "../chunks/config-BCvkg7jv.js";
+import "../chunks/index-CLIUrV88.js";
+import { Et as Hub } from "../chunks/hubConnectionAcceptor-BwydvFa4.js";
+//#region src/engine/runHub.d.ts
+interface RunHubOptions {
+  readonly config: HubConfig;
+  /** Sink for human log lines (child output, listener bindings). Default: stderr. */
+  readonly log?: (line: string) => void;
+  /**
+   * Forward this process's stdin to the single `cmd-*` endpoint. Throws at
+   * startup when more than one `cmd-*` endpoint is configured.
+   */
+  readonly cmdInteractive?: boolean;
+  /**
+   * Log every JSON-RPC message routed through the hub to {@link log}, one
+   * coalesced flow per line (the same rendering as the VS Code "linkrpc
+   * Flows" channel). Off by default — when omitted the hub installs no
+   * transit observer and pays no cost.
+   */
+  readonly logMessages?: boolean;
+}
+/** A bound listener, reported for logging / `serve` startup output. */
+interface ListenerInfo {
+  readonly type: ListenerConfig['type'];
+  readonly address: string;
+}
+/** A running hub. Connect a local client via {@link controlEndpoint}. */
+interface RunningHub {
+  readonly hub: Hub;
+  readonly listeners: readonly ListenerInfo[];
+  /** Private local socket (allow-all) for in-process CLI clients. */
+  readonly controlEndpoint: {
+    readonly path: string;
+    readonly token: string;
+  };
+  dispose(): void;
+}
+/** Build + start a hub from a config. Resolves once all transports are wired. */
+declare function runHub(opts: RunHubOptions): Promise<RunningHub>;
+//#endregion
+export { ListenerInfo, RunHubOptions, RunningHub, runHub };
+//# sourceMappingURL=runHub.d.ts.map

package/dist/engine/runHub.js

@@ -0,0 +1,2 @@
+import { t as runHub } from "../chunks/runHub-P3YUwwdv.js";
+export { runHub };

package/dist/hub/server/client.d.ts

@@ -0,0 +1,2 @@
+import { Et as Hub, Tt as AttachedLink, _ as RootProvision, _t as RootOverlay, ct as createHubServiceInterfaces, gt as registerIdentityServices, ht as registerHubServices, n as HubConnectionAcceptor, v as anonymousHandler } from "../../chunks/hubConnectionAcceptor-BwydvFa4.js";
+export { type AttachedLink, Hub, HubConnectionAcceptor, RootOverlay, type RootProvision, anonymousHandler, createHubServiceInterfaces, registerHubServices, registerIdentityServices };

package/dist/hub/server/client.js

@@ -0,0 +1,2 @@
+import { _ as RootOverlay, a as anonymousHandler, b as Hub, f as createHubServiceInterfaces, g as registerIdentityServices, h as registerHubServices, t as HubConnectionAcceptor } from "../../chunks/hubConnectionAcceptor-B5-8JsFY.js";
+export { Hub, HubConnectionAcceptor, RootOverlay, anonymousHandler, createHubServiceInterfaces, registerHubServices, registerIdentityServices };

package/dist/hub/server/connectionTokenBinder.d.ts

@@ -0,0 +1,2 @@
+import { t as connectionTokenBinderInterface } from "../../chunks/connectionTokenBinder.interfaces-BhzQ1DTS.js";
+export { connectionTokenBinderInterface };

package/dist/hub/server/connectionTokenBinder.js

@@ -0,0 +1,2 @@
+import { t as connectionTokenBinderInterface } from "../../chunks/connectionTokenBinder.interfaces-B-beCg06.js";
+export { connectionTokenBinderInterface };

package/dist/hub/server/index.d.ts

@@ -0,0 +1,5 @@
+import { C as validatePrefix, S as ForwardingTable, _ as withVerifiedSignature, a as IdentityKeystore, b as RegisteredServiceId, c as IdentitySnooze, d as SlotByIdAndTimeResult, f as SlotId, g as withFullyQualifiedCallGate, h as withForwardedCallGate, i as createSqliteIdentityKeystore, l as SlotAccessKey, m as ForwardedCallGateOptions, n as SqliteIdentityKeystoreOptions, o as IdentityKeystoreOptions, p as createIdentityKeystore, r as SqliteIdentitySlot, s as IdentitySlot, t as SqliteIdentityKeystore, u as SlotByIdAndKeyResult, v as MintCapabilityOptions, x as hubRegisterServiceId, y as mintCapability } from "../../chunks/index-CLIUrV88.js";
+import { _ as formatFlowSummary, a as FlowSummary, c as TrafficFlowAggregator, d as TransitDisposition, f as TransitEndpoint, g as createFlowLogger, h as WireTapOptions, i as FlowStreamMessage, l as TransitAggregator, m as TransitKind, n as FlowLoggerOptions, o as NodeTransit, p as TransitError, r as FlowStatus, s as NodeTransitObserver, t as FlowLogger, u as TransitAggregatorOptions, v as tapTransport } from "../../chunks/nodeTransit-cmtZgdpW.js";
+import { $ as AccessSlotRequest, A as AccessCallIntent, At as PendingRequestInfo, B as AccessRequestArgs, C as staticTokenHandler, Ct as HubTrafficSubscription, D as TokenIdentityBinding, Dt as HubOptions, E as MintedToken, Et as Hub, F as AccessDirectPermission, G as AccessDurationName, H as HubAccessHandlers, I as AccessDuration, J as ProposeArgs, K as CapabilityProposal, L as AccessExtendArgs, M as AccessDecision, N as AccessDirectArgs, O as TokenIdentityStore, Ot as IDisposable, P as AccessDirectDecision, Q as AccessSlotCandidate, R as AccessExtendDecision, S as resolveConnectionHandler, St as HubTrafficSource, T as registerConnectionTokenBinderService, Tt as AttachedLink, U as RegisterHubAccessOptions, V as AccessSlotBinding, W as registerHubAccessService, X as AccessInterfaceRequirement, Y as durationToExp, Z as AccessMemberRequirement, _ as RootProvision, _t as RootOverlay, a as PrefixPolicy, at as resolveAccessCandidates, b as fixedProvisionHandler, bt as OverlaySplitterInspection, c as ConnectionProvenance, ct as createHubServiceInterfaces, d as WithProvenance, dt as registerHubServiceIdRegistry, et as DirectoryEntry, f as WithProvenanceOptions, ft as withRequestIdContext, g as ConnectionHandlerFactory, gt as registerIdentityServices, h as ConnectionHandler, ht as registerHubServices, i as ClaimContext, it as fetchFullDirectory, j as AccessConsumer, k as TokenIdentityStoreOptions, kt as IHubLogger, l as ConnectionProvenanceProvider, lt as HubRegisterOptions, m as ConnectionContext, mt as RegisterIdentityServicesOptions, n as HubConnectionAcceptor, nt as ResolvedCandidates, o as PrincipalIdPrefixPolicy, ot as HubServices, p as withProvenance, pt as RegisterHubServicesOptions, q as CapabilityProposalIssuer, r as HubConnectionAcceptorOptions, rt as candidatesForSlot, s as PrincipalIdPrefixPolicyOptions, st as HubServicesOptions, t as HubAccessConfig, tt as ResolvedAccessSlot, u as ITransportWithProvenance, ut as RegisterCallContext, v as anonymousHandler, vt as RootOverlayOptions, w as RegisterConnectionTokenBinderOptions, wt as HubTrafficWatchOptions, x as provisionRoot, xt as HubInspector, y as boundTokenHandler, yt as OverlaySplitter, z as AccessExtendMember } from "../../chunks/hubConnectionAcceptor-BwydvFa4.js";
+import { t as connectionTokenBinderInterface } from "../../chunks/connectionTokenBinder.interfaces-BhzQ1DTS.js";
+export { type AccessCallIntent, type AccessConsumer, type AccessDecision, type AccessDirectArgs, type AccessDirectDecision, type AccessDirectPermission, type AccessDuration, type AccessDurationName, type AccessExtendArgs, type AccessExtendDecision, type AccessExtendMember, type AccessInterfaceRequirement, type AccessMemberRequirement, type AccessRequestArgs, type AccessSlotBinding, type AccessSlotCandidate, type AccessSlotRequest, type AttachedLink, type CapabilityProposal, CapabilityProposalIssuer, type ClaimContext, type ConnectionContext, type ConnectionHandler, type ConnectionHandlerFactory, type ConnectionProvenance, type ConnectionProvenanceProvider, type DirectoryEntry, type FlowLogger, type FlowLoggerOptions, type FlowStatus, type FlowStreamMessage, type FlowSummary, type ForwardedCallGateOptions, ForwardingTable, Hub, type HubAccessConfig, type HubAccessHandlers, HubConnectionAcceptor, type HubConnectionAcceptorOptions, HubInspector, type HubOptions, type HubRegisterOptions, type HubServices, type HubServicesOptions, type HubTrafficSource, type HubTrafficSubscription, type HubTrafficWatchOptions, type IDisposable, type IHubLogger, type ITransportWithProvenance, type IdentityKeystore, type IdentityKeystoreOptions, type IdentitySlot, type IdentitySnooze, type MintCapabilityOptions, type MintedToken, type NodeTransit, type NodeTransitObserver, OverlaySplitter, type OverlaySplitterInspection, type PendingRequestInfo, type PrefixPolicy, PrincipalIdPrefixPolicy, type PrincipalIdPrefixPolicyOptions, type ProposeArgs, type RegisterCallContext, type RegisterConnectionTokenBinderOptions, type RegisterHubAccessOptions, type RegisterHubServicesOptions, type RegisterIdentityServicesOptions, RegisteredServiceId, type ResolvedAccessSlot, type ResolvedCandidates, RootOverlay, type RootOverlayOptions, type RootProvision, type SlotAccessKey, type SlotByIdAndKeyResult, type SlotByIdAndTimeResult, type SlotId, type SqliteIdentityKeystore, type SqliteIdentityKeystoreOptions, type SqliteIdentitySlot, type TokenIdentityBinding, TokenIdentityStore, type TokenIdentityStoreOptions, TrafficFlowAggregator, TransitAggregator, type TransitAggregatorOptions, type TransitDisposition, type TransitEndpoint, type TransitError, type TransitKind, type WireTapOptions, type WithProvenance, type WithProvenanceOptions, anonymousHandler, boundTokenHandler, candidatesForSlot, connectionTokenBinderInterface, createFlowLogger, createHubServiceInterfaces, createIdentityKeystore, createSqliteIdentityKeystore, durationToExp, fetchFullDirectory, fixedProvisionHandler, formatFlowSummary, hubRegisterServiceId, mintCapability, provisionRoot, registerConnectionTokenBinderService, registerHubAccessService, registerHubServiceIdRegistry, registerHubServices, registerIdentityServices, resolveAccessCandidates, resolveConnectionHandler, staticTokenHandler, tapTransport, validatePrefix, withForwardedCallGate, withFullyQualifiedCallGate, withProvenance, withRequestIdContext, withVerifiedSignature };

package/dist/hub/server/index.js

@@ -0,0 +1,5 @@
+import { S as validatePrefix, _ as RootOverlay, a as anonymousHandler, b as Hub, c as provisionRoot, d as registerConnectionTokenBinderService, f as createHubServiceInterfaces, g as registerIdentityServices, h as registerHubServices, i as withVerifiedSignature, l as resolveConnectionHandler, m as withRequestIdContext, n as withForwardedCallGate, o as boundTokenHandler, p as registerHubServiceIdRegistry, r as withFullyQualifiedCallGate, s as fixedProvisionHandler, t as HubConnectionAcceptor, u as staticTokenHandler, v as OverlaySplitter, x as ForwardingTable, y as HubInspector } from "../../chunks/hubConnectionAcceptor-B5-8JsFY.js";
+import { a as tapTransport, i as formatFlowSummary, n as TransitAggregator, r as createFlowLogger, t as TrafficFlowAggregator } from "../../chunks/nodeTransit-CWeFnbwt.js";
+import { a as TokenIdentityStore, c as durationToExp, d as fetchFullDirectory, f as resolveAccessCandidates, i as withProvenance, l as mintCapability, m as hubRegisterServiceId, n as createSqliteIdentityKeystore, o as registerHubAccessService, p as RegisteredServiceId, r as PrincipalIdPrefixPolicy, s as CapabilityProposalIssuer, t as createIdentityKeystore, u as candidatesForSlot } from "../../chunks/server-BAxchQhy.js";
+import { t as connectionTokenBinderInterface } from "../../chunks/connectionTokenBinder.interfaces-B-beCg06.js";
+export { CapabilityProposalIssuer, ForwardingTable, Hub, HubConnectionAcceptor, HubInspector, OverlaySplitter, PrincipalIdPrefixPolicy, RegisteredServiceId, RootOverlay, TokenIdentityStore, TrafficFlowAggregator, TransitAggregator, anonymousHandler, boundTokenHandler, candidatesForSlot, connectionTokenBinderInterface, createFlowLogger, createHubServiceInterfaces, createIdentityKeystore, createSqliteIdentityKeystore, durationToExp, fetchFullDirectory, fixedProvisionHandler, formatFlowSummary, hubRegisterServiceId, mintCapability, provisionRoot, registerConnectionTokenBinderService, registerHubAccessService, registerHubServiceIdRegistry, registerHubServices, registerIdentityServices, resolveAccessCandidates, resolveConnectionHandler, staticTokenHandler, tapTransport, validatePrefix, withForwardedCallGate, withFullyQualifiedCallGate, withProvenance, withRequestIdContext, withVerifiedSignature };