@hediet/linkrpc 0.0.1

package/dist/chunks/hubAccess-DwTZPiI8.d.ts

@@ -0,0 +1,79 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { Pn as SignedCapability } from "./linkRpcConnection-CtlQmetO.js";
+//#region src/hub/common/hubAccess.d.ts
+/**
+ * The client-facing wire shapes of the hub's capability-negotiation protocol
+ * (`hubAccess::requestAccess`, see {@link hubAccessInterface}). Any hub client —
+ * the CLI, the MCP server, or an embedder — speaks these shapes to ask a hub
+ * for authority in a single consent prompt.
+ */
+/** How long a granted capability should live. */
+type HubAccessDuration = 'once' | 'shortLived' | 'longLived' | 'persistent';
+/** A `serviceId` / `interfaceId` / member matcher (wire shape of `TargetPattern`). */
+type HubAccessPattern = {
+  readonly exact: string;
+} | {
+  readonly prefix: string;
+};
+/** One authority the consumer wants — the wire shape of a `requestAccess` permission. */
+interface HubAccessPermission {
+  readonly target: {
+    readonly serviceId: HubAccessPattern;
+    readonly interfaceId: HubAccessPattern;
+    readonly interfaceHash?: string;
+    readonly members: readonly HubAccessPattern[];
+  };
+  /** Default false (fail closed). Set true to actually call the members. */
+  readonly canInvoke?: boolean;
+  /** Default false. Set true to let the consumer re-delegate this authority. */
+  readonly canDelegate?: boolean;
+  readonly params?: Record<string, unknown>;
+}
+/** A batched, explicit access request — possibly many permissions in one prompt. */
+interface HubAccessRequest {
+  readonly consumer: {
+    readonly name: string;
+    readonly origin?: string;
+    readonly purpose?: string;
+  };
+  /** One or more authorities to request together (single consent prompt). */
+  readonly permissions: readonly HubAccessPermission[];
+  /** `once` (short-lived), `session` (this connection), or `persistent` (saved). */
+  readonly duration?: HubAccessDuration;
+}
+/**
+ * Outcome of a `requestAccess` call. `granted` carries every capability the hub
+ * minted plus how many of them were durable and added to the connection's cap
+ * bag (a client-side augmentation over the pure wire result).
+ */
+type HubAccessResult = {
+  readonly status: 'granted';
+  /** Every capability the hub minted for this request. */
+  readonly capabilities: readonly SignedCapability[];
+  /** How many of them were durable and added to the connection's cap bag. */
+  readonly addedDurable: number;
+} | {
+  readonly status: 'denied';
+  readonly reason?: string;
+} | {
+  readonly status: string;
+  readonly reason?: string;
+};
+/**
+ * Return fresh durable capabilities that collectively cover an explicit access
+ * request, or `undefined` when the caller must ask the hub for more authority.
+ *
+ * This is the broad-request counterpart to checking whether a cap bag covers
+ * one concrete call. Clients use it before opening consent so persisted grants
+ * are reused without weakening any service/interface/member pattern.
+ */
+declare function findCoveringCapabilities(capabilities: readonly SignedCapability[], requested: readonly HubAccessPermission[], options?: {
+  readonly nowMs?: number;
+  readonly freshnessMarginMs?: number;
+}): readonly SignedCapability[] | undefined;
+//#endregion
+export { HubAccessResult as a, HubAccessRequest as i, HubAccessPattern as n, findCoveringCapabilities as o, HubAccessPermission as r, HubAccessDuration as t };
+//# sourceMappingURL=hubAccess-DwTZPiI8.d.ts.map

package/dist/chunks/hubAccess-DwTZPiI8.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hubAccess-DwTZPiI8.d.ts","names":[],"sources":["../../src/hub/common/hubAccess.ts"],"mappings":";;;;;;;;;;;;;KAqBY;;KAGA;WAA8B;;WAA8B;;;UAGvD;WACJ;aACI,WAAW;aACX,aAAa;aACb;aACA,kBAAkB;;;WAGtB;;WAEA;WACA,SAAS;;;UAIL;WACJ;aAAqB;aAAuB;aAA0B;;;WAEtE,sBAAsB;;WAEtB,WAAW;;;;;;;KAQZ;WAEK;;WAEA,uBAAuB;;WAEvB;;WAEA;WAA2B;;WAC3B;WAAyB;;;;;;;;;;iBAU1B,yBACZ,uBAAuB,oBACvB,oBAAoB,uBACpB;WACa;WACA;aAEL"}

package/dist/chunks/hubFacade-CQflVkVC.js

@@ -0,0 +1,85 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+import { r as hubGrantedServiceIdInterface } from "./hub.interfaces-BzWfsVT2.js";
+//#region src/hub/client/hubFacade.ts
+/**
+* Thin façade over the hub's own serviceId-routed services
+* (`hubGrantedServiceId`, `hubAccess`, …). The hub is not a single object on
+* the wire — it is a set of services the connection can `get`. This groups the
+* common connection calls so callers don't hand-route interface clients.
+*/
+var Hub = class {
+	_connection;
+	constructor(_connection) {
+		this._connection = _connection;
+	}
+	/** `hubGrantedServiceId::get` — where am I and which serviceId namespace may I claim. */
+	getConnectionInfo() {
+		return this._connection.get(hubGrantedServiceIdInterface).get({});
+	}
+	/**
+	* Reserve the slots a consumer will need so the user can approve them
+	* ahead of the first call. NOT YET IMPLEMENTED by the hub — the
+	* returned reservation throws on {@link SlotReservation.resolve}.
+	*/
+	prerequestSlots(_request) {
+		return { resolve: async () => {
+			throw new Error("not implemented: hub.prerequestSlots / slot resolution");
+		} };
+	}
+	/**
+	* Claim a serviceId namespace for this connection so it may register
+	* services under it, via `hubGrantedServiceId::register`.
+	*
+	* The claim is auto-granted from the connection's provenance when
+	* `serviceIdNamespace` is at/under the connection's
+	* `grantedServiceIdNamespace` (see {@link getConnectionInfo}) — no
+	* signature or capability needed. Claims **outside** the granted namespace
+	* are rejected here; route those through the admin-gated
+	* `<hubServiceId>::hubServiceIdRegistry::registerServiceId` door instead.
+	*
+	* Resolves once the namespace is owned by this connection (idempotent for
+	* a namespace this connection already owns). Rejects when the hub denies
+	* the claim — e.g. the namespace is owned by another identity, or the
+	* caller lacks admin authority outside its granted namespace.
+	*
+	* `requestPermissionIfDenied` is a hint for the future interactive
+	* admin-approval flow; the hub does not yet expose one, so denial always
+	* surfaces as a rejection regardless of the flag.
+	*/
+	async registerServiceIdNamespace(serviceIdNamespace, _opts) {
+		await this._connection.get(hubGrantedServiceIdInterface).register({ serviceId: serviceIdNamespace });
+	}
+	/**
+	* Claim this connection's provenance-granted serviceId namespace in one
+	* step: read `grantedServiceIdNamespace` via {@link getConnectionInfo},
+	* then {@link registerServiceIdNamespace} it, returning the claimed
+	* `serviceId` so the caller can mount services under it.
+	*
+	* This is the batteries-included version of the
+	* `hubGrantedServiceId::get` → `hubGrantedServiceId::register` dance a
+	* service-exposing participant performs right after connecting.
+	*
+	* Throws when the hub granted this connection no namespace (an empty
+	* `grantedServiceIdNamespace`, meaning "claim nothing freely") — there is
+	* nothing to register, and any service prefix would have to be claimed
+	* through the admin-gated
+	* `<hubServiceId>::hubServiceIdRegistry::registerServiceId` door instead.
+	*/
+	async claimGrantedServiceIdNamespace() {
+		const { grantedServiceIdNamespace } = await this.getConnectionInfo();
+		if (!grantedServiceIdNamespace) throw new Error("hubGrantedServiceId::get returned an empty granted namespace; nothing to claim (register a prefix through the admin-gated hubServiceIdRegistry::registerServiceId door instead)");
+		await this.registerServiceIdNamespace(grantedServiceIdNamespace);
+		return { serviceId: grantedServiceIdNamespace };
+	}
+};
+/** Wrap a connection in a {@link Hub} façade. */
+function hubFromConnection(connection) {
+	return new Hub(connection);
+}
+//#endregion
+export { hubFromConnection as n, Hub as t };
+
+//# sourceMappingURL=hubFacade-CQflVkVC.js.map

package/dist/chunks/hubFacade-CQflVkVC.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hubFacade-CQflVkVC.js","names":[],"sources":["../../src/hub/client/hubFacade.ts"],"sourcesContent":["import type { LinkRpcConnection } from '../../connection/linkRpcConnection';\nimport { hubGrantedServiceIdInterface } from '../common/hub.interfaces';\n\n/**\n * Description of the services a consumer will need, presented to the user\n * up-front so access can be approved before the first call. Each named\n * *dependency* (\"slot\") lists the interfaces the chosen service must\n * implement and the members the consumer intends to call.\n */\nexport interface SlotPrerequest {\n    readonly consumer: { readonly name: string; readonly purpose: string; };\n    readonly dependencies: Readonly<\n        Record<string, {\n            readonly interfaces: readonly { readonly id: string; }[];\n            readonly members: readonly {\n                readonly interfaceId: string;\n                readonly member: { readonly exact: string; };\n            }[];\n        }>\n    >;\n}\n\n/** Handle for a set of slots reserved via {@link Hub.prerequestSlots}. */\nexport interface SlotReservation {\n    /** Resolve the reserved slots into connected service clients. */\n    resolve(): Promise<never>;\n}\n\n/**\n * Thin façade over the hub's own serviceId-routed services\n * (`hubGrantedServiceId`, `hubAccess`, …). The hub is not a single object on\n * the wire — it is a set of services the connection can `get`. This groups the\n * common connection calls so callers don't hand-route interface clients.\n */\nexport class Hub {\n    constructor(private readonly _connection: LinkRpcConnection) { }\n\n    /** `hubGrantedServiceId::get` — where am I and which serviceId namespace may I claim. */\n    public getConnectionInfo() {\n        return this._connection.get(hubGrantedServiceIdInterface).get({});\n    }\n\n    /**\n     * Reserve the slots a consumer will need so the user can approve them\n     * ahead of the first call. NOT YET IMPLEMENTED by the hub — the\n     * returned reservation throws on {@link SlotReservation.resolve}.\n     */\n    public prerequestSlots(_request: SlotPrerequest): SlotReservation {\n        return {\n            resolve: async (): Promise<never> => {\n                throw new Error('not implemented: hub.prerequestSlots / slot resolution');\n            },\n        };\n    }\n\n    /**\n     * Claim a serviceId namespace for this connection so it may register\n     * services under it, via `hubGrantedServiceId::register`.\n     *\n     * The claim is auto-granted from the connection's provenance when\n     * `serviceIdNamespace` is at/under the connection's\n     * `grantedServiceIdNamespace` (see {@link getConnectionInfo}) — no\n     * signature or capability needed. Claims **outside** the granted namespace\n     * are rejected here; route those through the admin-gated\n     * `<hubServiceId>::hubServiceIdRegistry::registerServiceId` door instead.\n     *\n     * Resolves once the namespace is owned by this connection (idempotent for\n     * a namespace this connection already owns). Rejects when the hub denies\n     * the claim — e.g. the namespace is owned by another identity, or the\n     * caller lacks admin authority outside its granted namespace.\n     *\n     * `requestPermissionIfDenied` is a hint for the future interactive\n     * admin-approval flow; the hub does not yet expose one, so denial always\n     * surfaces as a rejection regardless of the flag.\n     */\n    public async registerServiceIdNamespace(\n        serviceIdNamespace: string,\n        _opts?: { readonly requestPermissionIfDenied?: boolean; },\n    ): Promise<void> {\n        await this._connection\n            .get(hubGrantedServiceIdInterface)\n            .register({ serviceId: serviceIdNamespace });\n    }\n\n    /**\n     * Claim this connection's provenance-granted serviceId namespace in one\n     * step: read `grantedServiceIdNamespace` via {@link getConnectionInfo},\n     * then {@link registerServiceIdNamespace} it, returning the claimed\n     * `serviceId` so the caller can mount services under it.\n     *\n     * This is the batteries-included version of the\n     * `hubGrantedServiceId::get` → `hubGrantedServiceId::register` dance a\n     * service-exposing participant performs right after connecting.\n     *\n     * Throws when the hub granted this connection no namespace (an empty\n     * `grantedServiceIdNamespace`, meaning \"claim nothing freely\") — there is\n     * nothing to register, and any service prefix would have to be claimed\n     * through the admin-gated\n     * `<hubServiceId>::hubServiceIdRegistry::registerServiceId` door instead.\n     */\n    public async claimGrantedServiceIdNamespace(): Promise<{ readonly serviceId: string; }> {\n        const { grantedServiceIdNamespace } = await this.getConnectionInfo();\n        if (!grantedServiceIdNamespace) {\n            throw new Error(\n                'hubGrantedServiceId::get returned an empty granted namespace; ' +\n                'nothing to claim (register a prefix through the admin-gated ' +\n                'hubServiceIdRegistry::registerServiceId door instead)',\n            );\n        }\n        await this.registerServiceIdNamespace(grantedServiceIdNamespace);\n        return { serviceId: grantedServiceIdNamespace };\n    }\n}\n\n/** Wrap a connection in a {@link Hub} façade. */\nexport function hubFromConnection(connection: LinkRpcConnection): Hub {\n    return new Hub(connection);\n}\n"],"mappings":";;;;;;;;;;;;AAkCA,IAAa,MAAb,MAAiB;CACgB;CAA7B,YAAY,aAAiD;EAAhC,KAAA,cAAA;CAAkC;;CAG/D,oBAA2B;EACvB,OAAO,KAAK,YAAY,IAAI,4BAA4B,CAAC,CAAC,IAAI,CAAC,CAAC;CACpE;;;;;;CAOA,gBAAuB,UAA2C;EAC9D,OAAO,EACH,SAAS,YAA4B;GACjC,MAAM,IAAI,MAAM,wDAAwD;EAC5E,EACJ;CACJ;;;;;;;;;;;;;;;;;;;;;CAsBA,MAAa,2BACT,oBACA,OACa;EACb,MAAM,KAAK,YACN,IAAI,4BAA4B,CAAC,CACjC,SAAS,EAAE,WAAW,mBAAmB,CAAC;CACnD;;;;;;;;;;;;;;;;;CAkBA,MAAa,iCAA2E;EACpF,MAAM,EAAE,8BAA8B,MAAM,KAAK,kBAAkB;EACnE,IAAI,CAAC,2BACD,MAAM,IAAI,MACN,iLAGJ;EAEJ,MAAM,KAAK,2BAA2B,yBAAyB;EAC/D,OAAO,EAAE,WAAW,0BAA0B;CAClD;AACJ;;AAGA,SAAgB,kBAAkB,YAAoC;CAClE,OAAO,IAAI,IAAI,UAAU;AAC7B"}

package/dist/chunks/hubFacade-Dkgw2pTi.d.ts

@@ -0,0 +1,101 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { a as LinkRpcConnection } from "./linkRpcConnection-CtlQmetO.js";
+//#region src/hub/client/hubFacade.d.ts
+/**
+ * Description of the services a consumer will need, presented to the user
+ * up-front so access can be approved before the first call. Each named
+ * *dependency* ("slot") lists the interfaces the chosen service must
+ * implement and the members the consumer intends to call.
+ */
+interface SlotPrerequest {
+  readonly consumer: {
+    readonly name: string;
+    readonly purpose: string;
+  };
+  readonly dependencies: Readonly<Record<string, {
+    readonly interfaces: readonly {
+      readonly id: string;
+    }[];
+    readonly members: readonly {
+      readonly interfaceId: string;
+      readonly member: {
+        readonly exact: string;
+      };
+    }[];
+  }>>;
+}
+/** Handle for a set of slots reserved via {@link Hub.prerequestSlots}. */
+interface SlotReservation {
+  /** Resolve the reserved slots into connected service clients. */
+  resolve(): Promise<never>;
+}
+/**
+ * Thin façade over the hub's own serviceId-routed services
+ * (`hubGrantedServiceId`, `hubAccess`, …). The hub is not a single object on
+ * the wire — it is a set of services the connection can `get`. This groups the
+ * common connection calls so callers don't hand-route interface clients.
+ */
+declare class Hub {
+  private readonly _connection;
+  constructor(_connection: LinkRpcConnection);
+  /** `hubGrantedServiceId::get` — where am I and which serviceId namespace may I claim. */
+  getConnectionInfo(): Promise<{
+    grantedServiceIdNamespace: string;
+  }>;
+  /**
+   * Reserve the slots a consumer will need so the user can approve them
+   * ahead of the first call. NOT YET IMPLEMENTED by the hub — the
+   * returned reservation throws on {@link SlotReservation.resolve}.
+   */
+  prerequestSlots(_request: SlotPrerequest): SlotReservation;
+  /**
+   * Claim a serviceId namespace for this connection so it may register
+   * services under it, via `hubGrantedServiceId::register`.
+   *
+   * The claim is auto-granted from the connection's provenance when
+   * `serviceIdNamespace` is at/under the connection's
+   * `grantedServiceIdNamespace` (see {@link getConnectionInfo}) — no
+   * signature or capability needed. Claims **outside** the granted namespace
+   * are rejected here; route those through the admin-gated
+   * `<hubServiceId>::hubServiceIdRegistry::registerServiceId` door instead.
+   *
+   * Resolves once the namespace is owned by this connection (idempotent for
+   * a namespace this connection already owns). Rejects when the hub denies
+   * the claim — e.g. the namespace is owned by another identity, or the
+   * caller lacks admin authority outside its granted namespace.
+   *
+   * `requestPermissionIfDenied` is a hint for the future interactive
+   * admin-approval flow; the hub does not yet expose one, so denial always
+   * surfaces as a rejection regardless of the flag.
+   */
+  registerServiceIdNamespace(serviceIdNamespace: string, _opts?: {
+    readonly requestPermissionIfDenied?: boolean;
+  }): Promise<void>;
+  /**
+   * Claim this connection's provenance-granted serviceId namespace in one
+   * step: read `grantedServiceIdNamespace` via {@link getConnectionInfo},
+   * then {@link registerServiceIdNamespace} it, returning the claimed
+   * `serviceId` so the caller can mount services under it.
+   *
+   * This is the batteries-included version of the
+   * `hubGrantedServiceId::get` → `hubGrantedServiceId::register` dance a
+   * service-exposing participant performs right after connecting.
+   *
+   * Throws when the hub granted this connection no namespace (an empty
+   * `grantedServiceIdNamespace`, meaning "claim nothing freely") — there is
+   * nothing to register, and any service prefix would have to be claimed
+   * through the admin-gated
+   * `<hubServiceId>::hubServiceIdRegistry::registerServiceId` door instead.
+   */
+  claimGrantedServiceIdNamespace(): Promise<{
+    readonly serviceId: string;
+  }>;
+}
+/** Wrap a connection in a {@link Hub} façade. */
+declare function hubFromConnection(connection: LinkRpcConnection): Hub;
+//#endregion
+export { hubFromConnection as i, SlotPrerequest as n, SlotReservation as r, Hub as t };
+//# sourceMappingURL=hubFacade-Dkgw2pTi.d.ts.map

package/dist/chunks/hubFacade-Dkgw2pTi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hubFacade-Dkgw2pTi.d.ts","names":[],"sources":["../../src/hub/client/hubFacade.ts"],"mappings":";;;;;;;;;;;;UASiB;WACJ;aAAqB;aAAuB;;WAC5C,cAAc,SACnB;aACa;eAAgC;;aAChC;eACI;eACA;iBAAmB;;;;;;UAO3B;;EAEb,WAAW;;;;;;;;cASF;mBACoB;EAAA,YAAA,aAAa;;EAGnC,qBAAiB;;;;;;;;EASjB,gBAAgB,UAAU,iBAAiB;;;;;;;;;;;;;;;;;;;;;EA4BrC,2BACT,4BACA;aAAmB;MACpB;;;;;;;;;;;;;;;;;EAsBU,kCAAkC;aAAmB;;;;iBAetD,kBAAkB,YAAY,oBAAoB"}