@camstack/types 0.1.34 → 0.1.36

package/dist/capabilities/mesh-orchestrator.cap.d.ts

@@ -1,151 +0,0 @@
-/**
- * mesh-orchestrator — singleton facade over the `mesh-network`
- * collection. Mirrors the `remote-access` / `turn-orchestrator`
- * pattern: the admin UI talks to ONE cap, the cap walks the
- * collection and aggregates per-provider status.
- */
-import { z } from 'zod';
-import { type InferProvider } from './capability-definition.js';
-declare const MeshProviderInfoSchema: z.ZodObject<{
-    addonId: z.ZodString;
-    displayName: z.ZodString;
-    joined: z.ZodBoolean;
-    meshIp: z.ZodString;
-    magicDnsHostname: z.ZodString;
-    peerCount: z.ZodNumber;
-    endpoints: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        label: z.ZodString;
-        scope: z.ZodEnum<{
-            public: "public";
-            mesh: "mesh";
-        }>;
-        url: z.ZodString;
-        hostname: z.ZodString;
-        port: z.ZodNumber;
-        protocol: z.ZodEnum<{
-            http: "http";
-            https: "https";
-        }>;
-    }, z.core.$strip>>>;
-    error: z.ZodOptional<z.ZodString>;
-    tenantName: z.ZodString;
-    magicDnsSuffix: z.ZodString;
-    userLogin: z.ZodNullable<z.ZodString>;
-    controlPlaneUrl: z.ZodString;
-    keyExpiry: z.ZodNullable<z.ZodNumber>;
-}, z.core.$strip>;
-export type MeshProviderInfo = z.infer<typeof MeshProviderInfoSchema>;
-export declare const meshOrchestratorCapability: {
-    readonly name: "mesh-orchestrator";
-    readonly scope: "system";
-    readonly mode: "singleton";
-    readonly methods: {
-        /** All registered mesh-network providers + live status. */
-        readonly listProviders: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
-            addonId: z.ZodString;
-            displayName: z.ZodString;
-            joined: z.ZodBoolean;
-            meshIp: z.ZodString;
-            magicDnsHostname: z.ZodString;
-            peerCount: z.ZodNumber;
-            endpoints: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                label: z.ZodString;
-                scope: z.ZodEnum<{
-                    public: "public";
-                    mesh: "mesh";
-                }>;
-                url: z.ZodString;
-                hostname: z.ZodString;
-                port: z.ZodNumber;
-                protocol: z.ZodEnum<{
-                    http: "http";
-                    https: "https";
-                }>;
-            }, z.core.$strip>>>;
-            error: z.ZodOptional<z.ZodString>;
-            tenantName: z.ZodString;
-            magicDnsSuffix: z.ZodString;
-            userLogin: z.ZodNullable<z.ZodString>;
-            controlPlaneUrl: z.ZodString;
-            keyExpiry: z.ZodNullable<z.ZodNumber>;
-        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
-        /**
-         * Join the mesh of a specific provider. Per-provider config still
-         * lives on its settings panel; the orchestrator forwards.
-         */
-        readonly joinProvider: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            addonId: z.ZodString;
-            authKey: z.ZodString;
-            hostname: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            joined: z.ZodLiteral<true>;
-        }, z.core.$strip>, "mutation">;
-        readonly leaveProvider: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            addonId: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            success: z.ZodLiteral<true>;
-        }, z.core.$strip>, "mutation">;
-        /**
-         * Browser-redirect login flow. Forwards to the named provider's
-         * `mesh-network.startLogin` and returns the URL the daemon
-         * prints. UI opens it in a new tab, then polls `listProviders`
-         * for `joined: true`.
-         */
-        readonly startLoginProvider: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            addonId: z.ZodString;
-            hostname: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodObject<{
-            loginUrl: z.ZodString;
-        }, z.core.$strip>, "mutation">;
-        /**
-         * Sign out of the provider's account entirely (`mesh-network.logout`).
-         * Distinct from `leaveProvider` which only takes the host off-mesh;
-         * `logoutProvider` wipes credentials so the next start requires a
-         * fresh login.
-         */
-        readonly logoutProvider: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            addonId: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            loggedOut: z.ZodLiteral<true>;
-        }, z.core.$strip>, "mutation">;
-        /**
-         * Per-provider peer list. Forwards to `mesh-network.listPeers` on
-         * the addressed provider. Separate from `listProviders` because
-         * peer payloads can be large on a heavily-populated tailnet —
-         * fetch only when the operator opens the Peers tab.
-         */
-        readonly listProviderPeers: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            addonId: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            peers: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                hostname: z.ZodString;
-                magicDns: z.ZodString;
-                addresses: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-                os: z.ZodOptional<z.ZodString>;
-                online: z.ZodBoolean;
-                lastSeenMs: z.ZodNumber;
-                isSelf: z.ZodBoolean;
-                connection: z.ZodEnum<{
-                    idle: "idle";
-                    direct: "direct";
-                    relay: "relay";
-                }>;
-                relay: z.ZodNullable<z.ZodString>;
-                lastHandshakeMs: z.ZodNumber;
-                rxBytes: z.ZodNumber;
-                txBytes: z.ZodNumber;
-                tags: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-                exitNodeOption: z.ZodBoolean;
-                advertisedRoutes: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-                userLogin: z.ZodNullable<z.ZodString>;
-                keyExpiry: z.ZodNullable<z.ZodNumber>;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
-    };
-};
-export type IMeshOrchestrator = InferProvider<typeof meshOrchestratorCapability>;
-export {};
-//# sourceMappingURL=mesh-orchestrator.cap.d.ts.map

package/dist/capabilities/mesh-orchestrator.cap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mesh-orchestrator.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/mesh-orchestrator.cap.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAalG,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6B1B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,0BAA0B;;;;;QAKnC,2DAA2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAE3D;;;WAGG;;;;;;;;;;;;;QAgBH;;;;;WAKG;;;;;;;QAUH;;;;;WAKG;;;;;;QAOH;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQkC,CAAA;AAEzC,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC,OAAO,0BAA0B,CAAC,CAAA"}

package/dist/capabilities/remote-access.cap.d.ts

@@ -1,91 +0,0 @@
-import { z } from 'zod';
-import { type InferProvider } from './capability-definition.js';
-declare const RemoteAccessEndpointSchema: z.ZodObject<{
-    url: z.ZodString;
-    hostname: z.ZodString;
-    port: z.ZodNumber;
-    protocol: z.ZodEnum<{
-        http: "http";
-        https: "https";
-    }>;
-}, z.core.$strip>;
-/**
- * Remote-access provider summary, surfaced to the admin UI's
- * "Remote Access" page. One row per registered `network-access`
- * provider (Cloudflare Tunnel, ngrok, Tailscale, etc.).
- */
-declare const RemoteAccessProviderInfoSchema: z.ZodObject<{
-    addonId: z.ZodString;
-    displayName: z.ZodString;
-    enabled: z.ZodBoolean;
-    connected: z.ZodBoolean;
-    endpoint: z.ZodNullable<z.ZodObject<{
-        url: z.ZodString;
-        hostname: z.ZodString;
-        port: z.ZodNumber;
-        protocol: z.ZodEnum<{
-            http: "http";
-            https: "https";
-        }>;
-    }, z.core.$strip>>;
-    error: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type RemoteAccessProviderInfo = z.infer<typeof RemoteAccessProviderInfoSchema>;
-/**
- * `remote-access` — singleton facade over the `network-access`
- * collection. Consumed by the admin UI's Remote Access page so an
- * operator can see at a glance which providers are configured, which
- * are connected, and which public endpoint each exposes.
- *
- * Mirrors the `authentication` / `turn-orchestrator` patterns: the
- * UI talks to the singleton, the singleton walks the collection.
- */
-export declare const remoteAccessCapability: {
-    readonly name: "remote-access";
-    readonly scope: "system";
-    readonly mode: "singleton";
-    readonly methods: {
-        /** All registered remote-access providers + their live status. */
-        readonly listProviders: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
-            addonId: z.ZodString;
-            displayName: z.ZodString;
-            enabled: z.ZodBoolean;
-            connected: z.ZodBoolean;
-            endpoint: z.ZodNullable<z.ZodObject<{
-                url: z.ZodString;
-                hostname: z.ZodString;
-                port: z.ZodNumber;
-                protocol: z.ZodEnum<{
-                    http: "http";
-                    https: "https";
-                }>;
-            }, z.core.$strip>>;
-            error: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
-        /**
-         * Start a specific provider's tunnel. Per-provider config still
-         * lives on the addon's settings panel; this is just the on/off
-         * trigger so the admin UI can manage the lifecycle from one place.
-         */
-        readonly startProvider: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            addonId: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            url: z.ZodString;
-            hostname: z.ZodString;
-            port: z.ZodNumber;
-            protocol: z.ZodEnum<{
-                http: "http";
-                https: "https";
-            }>;
-        }, z.core.$strip>, "mutation">;
-        /** Stop a specific provider's tunnel (idempotent on already-stopped). */
-        readonly stopProvider: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            addonId: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            success: z.ZodLiteral<true>;
-        }, z.core.$strip>, "mutation">;
-    };
-};
-export type IRemoteAccessOrchestrator = InferProvider<typeof remoteAccessCapability>;
-export { RemoteAccessEndpointSchema, RemoteAccessProviderInfoSchema };
-//# sourceMappingURL=remote-access.cap.d.ts.map

package/dist/capabilities/remote-access.cap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"remote-access.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/remote-access.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG,QAAA,MAAM,0BAA0B;;;;;;;;iBAK9B,CAAA;AAEF;;;;GAIG;AACH,QAAA,MAAM,8BAA8B;;;;;;;;;;;;;;;iBAalC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAErF;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB;;;;;QAK/B,kEAAkE;;;;;;;;;;;;;;;;;QAElE;;;;WAIG;;;;;;;;;;;;QAMH,yEAAyE;;;;;;;CAOpC,CAAA;AAEzC,MAAM,MAAM,yBAAyB,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEpF,OAAO,EAAE,0BAA0B,EAAE,8BAA8B,EAAE,CAAA"}

package/dist/capabilities/turn-orchestrator.cap.d.ts

@@ -1,64 +0,0 @@
-import { z } from 'zod';
-import { type InferProvider } from './capability-definition.js';
-declare const TurnProviderInfoSchema: z.ZodObject<{
-    addonId: z.ZodString;
-    displayName: z.ZodString;
-    enabled: z.ZodBoolean;
-    serverCount: z.ZodNumber;
-    urls: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-    error: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type TurnProviderInfo = z.infer<typeof TurnProviderInfoSchema>;
-/**
- * `turn-orchestrator` — singleton facade over the `turn-provider`
- * collection. Provides:
- *   - listProviders() — admin UI inventory
- *   - getAllServers() — combined list of TURN/STUN URLs across all
- *     enabled providers (what the WebRTC layer actually consumes)
- *
- * Mirrors `authentication` / `remote-access` — UI consumers go
- * through the singleton, the singleton walks the collection.
- *
- * The WebRTC layer (broker / addon-go2rtc) historically called
- * `turn-provider` collection methods directly to build the ICE
- * server list per session. Going through this orchestrator instead
- * gives a single throughput point + lets the admin disable a
- * provider without uninstalling it.
- */
-export declare const turnOrchestratorCapability: {
-    readonly name: "turn-orchestrator";
-    readonly scope: "system";
-    readonly mode: "singleton";
-    readonly methods: {
-        /** All registered TURN providers + per-provider stats. */
-        readonly listProviders: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
-            addonId: z.ZodString;
-            displayName: z.ZodString;
-            enabled: z.ZodBoolean;
-            serverCount: z.ZodNumber;
-            urls: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-            error: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
-        /**
-         * Combined list of TURN/STUN servers from all ENABLED providers.
-         * Consumed by the WebRTC layer at session-creation time —
-         * implementations may fetch fresh short-lived credentials each
-         * call (e.g. Cloudflare API), so consumers SHOULD call per-session.
-         */
-        readonly getAllServers: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
-            urls: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
-            username: z.ZodOptional<z.ZodString>;
-            credential: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
-        /** Toggle a provider's enabled flag. */
-        readonly setProviderEnabled: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            addonId: z.ZodString;
-            enabled: z.ZodBoolean;
-        }, z.core.$strip>, z.ZodObject<{
-            success: z.ZodLiteral<true>;
-        }, z.core.$strip>, "mutation">;
-    };
-};
-export type ITurnOrchestratorProvider = InferProvider<typeof turnOrchestratorCapability>;
-export { TurnProviderInfoSchema };
-//# sourceMappingURL=turn-orchestrator.cap.d.ts.map

package/dist/capabilities/turn-orchestrator.cap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"turn-orchestrator.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/turn-orchestrator.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAGlG,QAAA,MAAM,sBAAsB;;;;;;;iBAmB1B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,0BAA0B;;;;;QAKnC,0DAA0D;;;;;;;;;QAE1D;;;;;WAKG;;;;;;QAEH,wCAAwC;;;;;;;;CAOH,CAAA;AAEzC,MAAM,MAAM,yBAAyB,GAAG,aAAa,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAExF,OAAO,EAAE,sBAAsB,EAAE,CAAA"}