@camstack/types 0.1.14 → 0.1.16

package/dist/capabilities/local-network.cap.d.ts

@@ -0,0 +1,216 @@
+/**
+ * local-network — hub-only singleton.
+ *
+ * Enumerates the host's network interfaces and ranks them so that:
+ *
+ *  • Addons that need a "where do we listen / point a tunnel at" answer
+ *    (cloudflare-tunnel, ngrok, RTSP restream, cluster join URL, TLS
+ *    cert SAN) consume `getPreferred()` instead of hard-coding
+ *    `localhost`. Critical for docker-sidecar setups where the addon
+ *    process needs the container's eth0 (not 127.0.0.1).
+ *
+ *  • The SDK (mobile / web client) consumes `getConnectionEndpoints()`
+ *    to receive an ordered list of candidate base URLs it should race
+ *    on connect — LAN IPv4 first (lowest latency when on same network),
+ *    then public hostname (if a tunnel is up), then IPv6. The SDK can
+ *    race them with short timeouts and stick with the winner for the
+ *    session.
+ *
+ * Why hub-only: agents are not directly addressable by the operator's
+ * clients — they reverse-connect to the hub. Exposing their interfaces
+ * via the same surface would leak internal topology with no upside.
+ *
+ * Implementation in `@camstack/core/builtins/local-network/`.
+ */
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+declare const LocalInterfaceSchema: z.ZodObject<{
+    name: z.ZodString;
+    family: z.ZodEnum<{
+        IPv4: "IPv4";
+        IPv6: "IPv6";
+    }>;
+    address: z.ZodString;
+    cidr: z.ZodString;
+    netmask: z.ZodString;
+    internal: z.ZodBoolean;
+    mac: z.ZodString;
+    kind: z.ZodEnum<{
+        other: "other";
+        lan: "lan";
+        vpn: "vpn";
+        wifi: "wifi";
+        docker: "docker";
+        loopback: "loopback";
+    }>;
+    preferred: z.ZodBoolean;
+    plausible: z.ZodBoolean;
+    plausibleReason: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Candidate base URL for the SDK to race on connect. Order matters —
+ * the SDK should attempt these top-to-bottom with a short per-candidate
+ * timeout (e.g. 1500ms) and cache the winner for the session.
+ */
+declare const ConnectionEndpointSchema: z.ZodObject<{
+    label: z.ZodString;
+    baseUrl: z.ZodString;
+    kind: z.ZodEnum<{
+        public: "public";
+        loopback: "loopback";
+        "lan-ipv4": "lan-ipv4";
+        "lan-ipv6": "lan-ipv6";
+    }>;
+    interfaceKind: z.ZodEnum<{
+        public: "public";
+        other: "other";
+        lan: "lan";
+        vpn: "vpn";
+        wifi: "wifi";
+        docker: "docker";
+        loopback: "loopback";
+    }>;
+    plausible: z.ZodBoolean;
+    plausibleReason: z.ZodString;
+    priority: z.ZodNumber;
+}, z.core.$strip>;
+export declare const localNetworkCapability: {
+    readonly name: "local-network";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        /** Return the current interface snapshot. */
+        readonly list: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            interfaces: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                family: z.ZodEnum<{
+                    IPv4: "IPv4";
+                    IPv6: "IPv6";
+                }>;
+                address: z.ZodString;
+                cidr: z.ZodString;
+                netmask: z.ZodString;
+                internal: z.ZodBoolean;
+                mac: z.ZodString;
+                kind: z.ZodEnum<{
+                    other: "other";
+                    lan: "lan";
+                    vpn: "vpn";
+                    wifi: "wifi";
+                    docker: "docker";
+                    loopback: "loopback";
+                }>;
+                preferred: z.ZodBoolean;
+                plausible: z.ZodBoolean;
+                plausibleReason: z.ZodString;
+            }, z.core.$strip>>>;
+            probedAt: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Auto-selected outbound interface. Heuristic:
+         *   1. Skip internal / link-local / 169.254.*.
+         *   2. Prefer LAN/wifi (real Ethernet) over docker/vpn.
+         *   3. IPv4 wins over IPv6 (compat with legacy consumers).
+         *   4. Tie-break on lowest CIDR mask (most-specific subnet).
+         * Returns `null` only when the host has zero non-loopback addresses.
+         * Honours `getAllowedAddresses()` — if the operator pinned an
+         * allowlist, only those addresses are candidates.
+         */
+        readonly getPreferred: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodNullable<z.ZodObject<{
+            name: z.ZodString;
+            family: z.ZodEnum<{
+                IPv4: "IPv4";
+                IPv6: "IPv6";
+            }>;
+            address: z.ZodString;
+            cidr: z.ZodString;
+            netmask: z.ZodString;
+            internal: z.ZodBoolean;
+            mac: z.ZodString;
+            kind: z.ZodEnum<{
+                other: "other";
+                lan: "lan";
+                vpn: "vpn";
+                wifi: "wifi";
+                docker: "docker";
+                loopback: "loopback";
+            }>;
+            preferred: z.ZodBoolean;
+            plausible: z.ZodBoolean;
+            plausibleReason: z.ZodString;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Ordered candidate base URLs the SDK should try on connect.
+         * Includes LAN IPs (one per non-internal interface), the public
+         * tunnel hostname (when active), and loopback as a last-resort
+         * fallback. Filterable by `includeLoopback` / `ipv4Only`.
+         * Honours `getAllowedAddresses()` when set — addresses outside
+         * the allowlist are dropped (the public tunnel + loopback are
+         * always included as escape hatches).
+         */
+        readonly getConnectionEndpoints: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            port: z.ZodNumber;
+            includeLoopback: z.ZodOptional<z.ZodBoolean>;
+            ipv4Only: z.ZodOptional<z.ZodBoolean>;
+            scheme: z.ZodOptional<z.ZodEnum<{
+                http: "http";
+                https: "https";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            endpoints: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                baseUrl: z.ZodString;
+                kind: z.ZodEnum<{
+                    public: "public";
+                    loopback: "loopback";
+                    "lan-ipv4": "lan-ipv4";
+                    "lan-ipv6": "lan-ipv6";
+                }>;
+                interfaceKind: z.ZodEnum<{
+                    public: "public";
+                    other: "other";
+                    lan: "lan";
+                    vpn: "vpn";
+                    wifi: "wifi";
+                    docker: "docker";
+                    loopback: "loopback";
+                }>;
+                plausible: z.ZodBoolean;
+                plausibleReason: z.ZodString;
+                priority: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Read the operator's allowlist. Empty = "auto" (no filter). Used
+         * by the admin UI's address selector to seed its checkbox state.
+         */
+        readonly getAllowedAddresses: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            addresses: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Replace the allowlist atomically. Persisted via the addon store
+         * (kernel-managed) so it survives restarts. Pass `[]` to revert to
+         * auto mode.
+         */
+        readonly setAllowedAddresses: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addresses: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Re-run the boot heuristic over the current interface snapshot
+         * and atomically replace the allowlist with the result. Useful
+         * after a major network change (new dock, new VPN, IP rebound)
+         * when the operator wants to wipe their manual edits and start
+         * over from the auto-detected best matches.
+         */
+        readonly resetAllowlistToBestMatch: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            addresses: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>, "mutation">;
+    };
+};
+export type ILocalNetworkProvider = InferProvider<typeof localNetworkCapability>;
+export type LocalInterface = z.infer<typeof LocalInterfaceSchema>;
+export type ConnectionEndpoint = z.infer<typeof ConnectionEndpointSchema>;
+export {};
+//# sourceMappingURL=local-network.cap.d.ts.map

package/dist/capabilities/local-network.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-network.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/local-network.cap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAYlG,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;iBAoCxB,CAAA;AAUF;;;;GAIG;AACH,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;iBAmC5B,CAAA;AAgBF,eAAO,MAAM,sBAAsB;;;;;QAK/B,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;QAG7C;;;;;;;;;WASG;;;;;;;;;;;;;;;;;;;;;;;;QAGH;;;;;;;;WAQG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoBH;;;WAGG;;;;QAGH;;;;WAIG;;;;;;QAOH;;;;;;WAMG;;;;;CAOkC,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAChF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACjE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA"}

package/dist/capabilities/log-destination.cap.d.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+declare const LogLevelSchema: z.ZodEnum<{
+    info: "info";
+    error: "error";
+    debug: "debug";
+    warn: "warn";
+}>;
+declare const LogEntrySchema: z.ZodObject<{
+    timestamp: z.ZodDate;
+    level: z.ZodEnum<{
+        info: "info";
+        error: "error";
+        debug: "debug";
+        warn: "warn";
+    }>;
+    scope: z.ZodArray<z.ZodString>;
+    message: z.ZodString;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export declare const logDestinationCapability: {
+    readonly name: "log-destination";
+    readonly scope: "system";
+    readonly mode: "collection";
+    readonly internal: true;
+    readonly methods: {
+        readonly write: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            timestamp: z.ZodDate;
+            level: z.ZodEnum<{
+                info: "info";
+                error: "error";
+                debug: "debug";
+                warn: "warn";
+            }>;
+            scope: z.ZodArray<z.ZodString>;
+            message: z.ZodString;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly query: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            level: z.ZodOptional<z.ZodEnum<{
+                info: "info";
+                error: "error";
+                debug: "debug";
+                warn: "warn";
+            }>>;
+            since: z.ZodOptional<z.ZodDate>;
+            until: z.ZodOptional<z.ZodDate>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            timestamp: z.ZodDate;
+            level: z.ZodEnum<{
+                info: "info";
+                error: "error";
+                debug: "debug";
+                warn: "warn";
+            }>;
+            scope: z.ZodArray<z.ZodString>;
+            message: z.ZodString;
+            meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type ILogDestinationProvider = InferProvider<typeof logDestinationCapability>;
+export { LogEntrySchema, LogLevelSchema };
+//# sourceMappingURL=log-destination.cap.d.ts.map

package/dist/capabilities/log-destination.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-destination.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/log-destination.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG,QAAA,MAAM,cAAc;;;;;EAA6C,CAAA;AAEjE,QAAA,MAAM,cAAc;;;;;;;;;;;;iBAOlB,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBI,CAAA;AAEzC,MAAM,MAAM,uBAAuB,GAAG,aAAa,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEpF,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,CAAA"}

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

@@ -0,0 +1,160 @@
+/**
+ * mesh-network — collection cap for mesh-VPN providers.
+ *
+ * Different shape from `network-access` (public tunnels):
+ *
+ *   • `network-access` exposes ONE public URL the operator hands to
+ *     external clients. start/stop spawns a single edge process.
+ *
+ *   • `mesh-network` joins the host into a private mesh (Tailscale,
+ *     Headscale, ZeroTier). The result is one or more *private*
+ *     endpoints (mesh IP `100.x.x.x`, MagicDNS hostname) reachable
+ *     only by peers on the same mesh. Optionally, providers that
+ *     support it (Tailscale Funnel / Serve) also expose a public
+ *     ingress for select ports.
+ *
+ * Singleton facade lives in `mesh-orchestrator.cap.ts`.
+ */
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * A reachable endpoint on the mesh. A single provider may expose
+ * multiple (mesh IP + MagicDNS hostname + Funnel public URL).
+ */
+declare const MeshEndpointSchema: 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>;
+export type MeshEndpoint = z.infer<typeof MeshEndpointSchema>;
+declare const MeshPeerSchema: z.ZodObject<{
+    id: z.ZodString;
+    hostname: z.ZodString;
+    addresses: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    os: z.ZodOptional<z.ZodString>;
+    online: z.ZodBoolean;
+    lastSeenMs: z.ZodNumber;
+    isSelf: z.ZodBoolean;
+}, z.core.$strip>;
+export type MeshPeer = z.infer<typeof MeshPeerSchema>;
+declare const MeshStatusSchema: z.ZodObject<{
+    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>;
+}, z.core.$strip>;
+export type MeshStatus = z.infer<typeof MeshStatusSchema>;
+/**
+ * `mesh-network` — per-provider implementation. Tailscale registers
+ * one (and only one) entry. Future Headscale / ZeroTier addons would
+ * register their own entries.
+ */
+export declare const meshNetworkCapability: {
+    readonly name: "mesh-network";
+    readonly scope: "system";
+    readonly mode: "collection";
+    readonly methods: {
+        /** Return the current join state + endpoints + peer count. Cheap
+         *  poll-target — admin UI hits this every few seconds. */
+        readonly getStatus: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            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>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Join the host to the provider's mesh using a one-time auth key
+         * (generated by the operator in the provider's admin dashboard).
+         * Implementations should be idempotent — re-calling with the same
+         * key while already joined is a no-op + success.
+         */
+        readonly join: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            authKey: z.ZodString;
+            hostname: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            joined: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /** Leave the mesh. After this the meshIp/magicDnsHostname/etc.
+         *  vanish until the next `join`. */
+        readonly leave: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            left: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /** Enumerate every peer the daemon currently knows about. */
+        readonly listPeers: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            peers: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                hostname: z.ZodString;
+                addresses: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                os: z.ZodOptional<z.ZodString>;
+                online: z.ZodBoolean;
+                lastSeenMs: z.ZodNumber;
+                isSelf: z.ZodBoolean;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Toggle the public ingress (e.g. Tailscale Funnel) that maps a
+         * local port to the open internet via the provider's edge. Idempotent.
+         */
+        readonly setPublicIngress: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            port: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Toggle the in-mesh HTTPS ingress (e.g. Tailscale Serve) so peers
+         * inside the mesh hit a valid TLS endpoint instead of the raw IP.
+         */
+        readonly setMeshIngress: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            port: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+    };
+};
+export type IMeshNetworkProvider = InferProvider<typeof meshNetworkCapability>;
+export {};
+//# sourceMappingURL=mesh-network.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-network.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/mesh-network.cap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;;GAGG;AACH,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;iBAmBtB,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,QAAA,MAAM,cAAc;;;;;;;;iBAelB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAErD,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;iBAapB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAmBzD;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;;QAK9B;kEAC0D;;;;;;;;;;;;;;;;;;;;;;;QAG1D;;;;;WAKG;;;;;;;QAaH;4CACoC;;;;QAOpC,6DAA6D;;;;;;;;;;;;QAK7D;;;WAGG;;;;;;;QAOH;;;WAGG;;;;;;;;CAOkC,CAAA;AAEzC,MAAM,MAAM,oBAAoB,GAAG,aAAa,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

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

@@ -0,0 +1,96 @@
+/**
+ * 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;
+    kind: z.ZodEnum<{
+        other: "other";
+        tailscale: "tailscale";
+        headscale: "headscale";
+        zerotier: "zerotier";
+    }>;
+    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>;
+}, 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;
+            kind: z.ZodEnum<{
+                other: "other";
+                tailscale: "tailscale";
+                headscale: "headscale";
+                zerotier: "zerotier";
+            }>;
+            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>;
+        }, 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">;
+    };
+};
+export type IMeshOrchestrator = InferProvider<typeof meshOrchestratorCapability>;
+export {};
+//# sourceMappingURL=mesh-orchestrator.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"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;AAYlG,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmB1B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,0BAA0B;;;;;QAKnC,2DAA2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAE3D;;;WAGG;;;;;;;;;;;;;;CAgBkC,CAAA;AAEzC,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC,OAAO,0BAA0B,CAAC,CAAA"}