@camstack/types 0.1.15 → 0.1.16

package/dist/capabilities/addons.cap.d.ts

@@ -44,6 +44,11 @@ declare const AddonListItemSchema: z.ZodObject<{
         packageName: z.ZodString;
         packageVersion: z.ZodString;
         packageDisplayName: z.ZodOptional<z.ZodString>;
+        bundle: z.ZodOptional<z.ZodObject<{
+            displayName: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            icon: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
         protected: z.ZodOptional<z.ZodBoolean>;
         removable: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>;
@@ -55,6 +60,25 @@ declare const AddonListItemSchema: z.ZodObject<{
         mode: z.ZodString;
         state: z.ZodString;
     }, z.core.$strip>>;
+    hasBackup: z.ZodOptional<z.ZodBoolean>;
+    health: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        phase: z.ZodEnum<{
+            pending: "pending";
+            healthy: "healthy";
+            failed: "failed";
+        }>;
+        retryCount: z.ZodNumber;
+        firstFailureAt: z.ZodNullable<z.ZodNumber>;
+        lastAttemptAt: z.ZodNullable<z.ZodNumber>;
+        lastError: z.ZodNullable<z.ZodObject<{
+            message: z.ZodString;
+            stack: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        nextRetryAt: z.ZodNullable<z.ZodNumber>;
+        alertEmitted: z.ZodBoolean;
+        retrying: z.ZodBoolean;
+        inGracePeriod: z.ZodBoolean;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 declare const InstalledPackageSchema: z.ZodObject<{
     name: z.ZodString;
@@ -130,6 +154,11 @@ export declare const addonsCapability: {
                 packageName: z.ZodString;
                 packageVersion: z.ZodString;
                 packageDisplayName: z.ZodOptional<z.ZodString>;
+                bundle: z.ZodOptional<z.ZodObject<{
+                    displayName: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    icon: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
                 protected: z.ZodOptional<z.ZodBoolean>;
                 removable: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>;
@@ -141,6 +170,25 @@ export declare const addonsCapability: {
                 mode: z.ZodString;
                 state: z.ZodString;
             }, z.core.$strip>>;
+            hasBackup: z.ZodOptional<z.ZodBoolean>;
+            health: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                phase: z.ZodEnum<{
+                    pending: "pending";
+                    healthy: "healthy";
+                    failed: "failed";
+                }>;
+                retryCount: z.ZodNumber;
+                firstFailureAt: z.ZodNullable<z.ZodNumber>;
+                lastAttemptAt: z.ZodNullable<z.ZodNumber>;
+                lastError: z.ZodNullable<z.ZodObject<{
+                    message: z.ZodString;
+                    stack: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                nextRetryAt: z.ZodNullable<z.ZodNumber>;
+                alertEmitted: z.ZodBoolean;
+                retrying: z.ZodBoolean;
+                inGracePeriod: z.ZodBoolean;
+            }, z.core.$strip>>>;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         readonly getLogs: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             addonId: z.ZodString;
@@ -197,6 +245,23 @@ export declare const addonsCapability: {
             name: z.ZodString;
             version: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodUnknown, "mutation">;
+        /**
+         * Roll back an addon to the version it had before the most recent
+         * `updatePackage` call. The backup directory pointer is kept in the
+         * central addon manifest until the post-update health-check
+         * confirms the new install works (then it's cleared automatically),
+         * so this only succeeds when the most recent update either failed
+         * its restart or the user explicitly wants to revert.
+         *
+         * Returns `{ rolledBackTo: <version> }` on success, or
+         * `{ rolledBackTo: null }` when there's no backup to roll back to
+         * (caller can show a "no backup available" UI).
+         */
+        readonly rollbackPackage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            rolledBackTo: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>, "mutation">;
         readonly forceRefresh: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodUnknown, "mutation">;
         readonly restartServer: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             confirm: z.ZodLiteral<true>;
@@ -212,6 +277,17 @@ export declare const addonsCapability: {
         readonly restartAddon: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             addonId: z.ZodString;
         }, z.core.$strip>, z.ZodUnknown, "mutation">;
+        /**
+         * Force-retry a failed addon NOW. Resets the retry counter so the
+         * next failure starts from the 60s interval again. Used by the
+         * "Retry now" button in the Addons admin page row + AlertCenter
+         * alert action. Idempotent on healthy addons (no-op).
+         */
+        readonly retryLoad: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            packageName: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
         readonly getAutoUpdateSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
             channel: z.ZodEnum<{
                 off: "off";

package/dist/capabilities/addons.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"addons.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/addons.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;;;;;;;;;;;;;GAcG;AAYH,QAAA,MAAM,cAAc;;;;;EAA6C,CAAA;AACjE,QAAA,MAAM,aAAa;;;;EAAoC,CAAA;AACvD,QAAA,MAAM,wBAAwB;;;;;EAA+C,CAAA;AA+B7E,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;iBAMvB,CAAA;AAEF,QAAA,MAAM,sBAAsB;;;;;iBAK1B,CAAA;AAEF,QAAA,MAAM,mBAAmB;;;;;;;;;iBAMvB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;iBAK5B,CAAA;AAEF,QAAA,MAAM,kBAAkB;;;;;;;;;iBAStB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;;iBAG5B,CAAA;AAEF,QAAA,MAAM,qBAAqB;;;;;EAA2B,CAAA;AAQtD,QAAA,MAAM,oBAAoB;;;;;iBAKxB,CAAA;AAQF,QAAA,MAAM,uBAAuB;;;;iBAI3B,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0HY,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEpE,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,mBAAmB,EACnB,wBAAwB,EACxB,kBAAkB,EAClB,wBAAwB,EACxB,qBAAqB,EACrB,oBAAoB,EACpB,uBAAuB,EACvB,cAAc,EACd,aAAa,EACb,wBAAwB,GACzB,CAAA"}
+{"version":3,"file":"addons.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/addons.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;;;;;;;;;;;;;GAcG;AAYH,QAAA,MAAM,cAAc;;;;;EAA6C,CAAA;AACjE,QAAA,MAAM,aAAa;;;;EAAoC,CAAA;AACvD,QAAA,MAAM,wBAAwB;;;;;EAA+C,CAAA;AAiE7E,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAevB,CAAA;AAEF,QAAA,MAAM,sBAAsB;;;;;iBAK1B,CAAA;AAEF,QAAA,MAAM,mBAAmB;;;;;;;;;iBAMvB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;iBAK5B,CAAA;AAEF,QAAA,MAAM,kBAAkB;;;;;;;;;iBAStB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;;iBAG5B,CAAA;AAEF,QAAA,MAAM,qBAAqB;;;;;EAA2B,CAAA;AAQtD,QAAA,MAAM,oBAAoB;;;;;iBAKxB,CAAA;AAQF,QAAA,MAAM,uBAAuB;;;;iBAI3B,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA2DzB;;;;;;;;;;;WAWG;;;;;;;;;;;;;;;;;;;;;QAsBH;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsDkC,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEpE,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,mBAAmB,EACnB,wBAAwB,EACxB,kBAAkB,EAClB,wBAAwB,EACxB,qBAAqB,EACrB,oBAAoB,EACpB,uBAAuB,EACvB,cAAc,EACd,aAAa,EACb,wBAAwB,GACzB,CAAA"}

package/dist/capabilities/alerts.cap.d.ts

@@ -15,9 +15,9 @@ export declare const AlertSeveritySchema: z.ZodEnum<{
 }>;
 export declare const AlertStatusSchema: z.ZodEnum<{
     active: "active";
+    failed: "failed";
     "in-progress": "in-progress";
     completed: "completed";
-    failed: "failed";
     dismissed: "dismissed";
 }>;
 export declare const AlertSourceSchema: z.ZodObject<{
@@ -37,9 +37,9 @@ export declare const AlertSchema: z.ZodObject<{
     message: z.ZodString;
     status: z.ZodEnum<{
         active: "active";
+        failed: "failed";
         "in-progress": "in-progress";
         completed: "completed";
-        failed: "failed";
         dismissed: "dismissed";
     }>;
     progress: z.ZodOptional<z.ZodNumber>;
@@ -73,9 +73,9 @@ export declare const alertsCapability: {
             message: z.ZodString;
             status: z.ZodEnum<{
                 active: "active";
+                failed: "failed";
                 "in-progress": "in-progress";
                 completed: "completed";
-                failed: "failed";
                 dismissed: "dismissed";
             }>;
             progress: z.ZodOptional<z.ZodNumber>;
@@ -103,9 +103,9 @@ export declare const alertsCapability: {
                 message: z.ZodOptional<z.ZodString>;
                 status: z.ZodOptional<z.ZodEnum<{
                     active: "active";
+                    failed: "failed";
                     "in-progress": "in-progress";
                     completed: "completed";
-                    failed: "failed";
                     dismissed: "dismissed";
                 }>>;
                 progress: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
@@ -135,9 +135,9 @@ export declare const alertsCapability: {
             message: z.ZodString;
             status: z.ZodEnum<{
                 active: "active";
+                failed: "failed";
                 "in-progress": "in-progress";
                 completed: "completed";
-                failed: "failed";
                 dismissed: "dismissed";
             }>;
             progress: z.ZodOptional<z.ZodNumber>;

package/dist/capabilities/authentication.cap.d.ts

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * Authentication-provider summary metadata. Drives the admin UI's
+ * "Authentication Providers" page and the login screen's provider
+ * picker (Google / Microsoft / SAML / etc. buttons next to the
+ * username/password form).
+ *
+ * Keep the shape lean: the admin UI doesn't render runtime
+ * credentials, only enough to identify the provider and its UX
+ * affordances. Per-provider config still lives in the addon's own
+ * settings panel.
+ */
+declare const AuthProviderInfoSchema: z.ZodObject<{
+    addonId: z.ZodString;
+    displayName: z.ZodString;
+    kind: z.ZodEnum<{
+        other: "other";
+        local: "local";
+        oidc: "oidc";
+        saml: "saml";
+        ldap: "ldap";
+    }>;
+    icon: z.ZodOptional<z.ZodString>;
+    hasRedirectFlow: z.ZodBoolean;
+    hasCredentialFlow: z.ZodBoolean;
+    status: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodBoolean;
+}, z.core.$strip>;
+export type AuthProviderInfo = z.infer<typeof AuthProviderInfoSchema>;
+/**
+ * `authentication` — singleton facade over the `auth-provider`
+ * collection. Consumed by:
+ *   - Login page (enumerate provider buttons)
+ *   - Admin UI Authentication page (list/configure/enable/disable)
+ *
+ * Mirrors the pattern of `backup` (singleton facade over the
+ * `backup-destination` collection) — UI consumers don't need to know
+ * about individual `auth-provider` providers; they call this and
+ * receive a curated view.
+ *
+ * The actual login flow still goes through the `auth-provider`
+ * collection (validateCredentials / getLoginUrl / handleCallback);
+ * this cap only listing/orchestration.
+ */
+export declare const authenticationCapability: {
+    readonly name: "authentication";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        /** All registered auth providers, both enabled and disabled. */
+        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";
+                local: "local";
+                oidc: "oidc";
+                saml: "saml";
+                ldap: "ldap";
+            }>;
+            icon: z.ZodOptional<z.ZodString>;
+            hasRedirectFlow: z.ZodBoolean;
+            hasCredentialFlow: z.ZodBoolean;
+            status: z.ZodOptional<z.ZodString>;
+            enabled: z.ZodBoolean;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Toggle a provider's enabled flag. Disabled providers stay
+         * registered but aren't surfaced on the login page. The orchestrator
+         * persists the state in `addon-settings` so it survives restarts.
+         */
+        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 IAuthenticationProvider = InferProvider<typeof authenticationCapability>;
+export { AuthProviderInfoSchema };
+//# sourceMappingURL=authentication.cap.d.ts.map

package/dist/capabilities/authentication.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authentication.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/authentication.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;;;;;;;;;GAUG;AACH,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;iBA2B1B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,wBAAwB;;;;;QAKjC,gEAAgE;;;;;;;;;;;;;;;;;QAEhE;;;;WAIG;;;;;;;;CAOkC,CAAA;AAEzC,MAAM,MAAM,uBAAuB,GAAG,aAAa,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEpF,OAAO,EAAE,sBAAsB,EAAE,CAAA"}

package/dist/capabilities/backup.cap.d.ts

@@ -1,12 +1,116 @@
 import { z } from 'zod';
 import { type InferProvider } from './capability-definition.js';
+/**
+ * Per-destination metadata returned by `backup-destination.listDestinations`.
+ * Defined here (not in `backup-destination.cap.ts`) because both caps need
+ * it and `backup` is the foundation — the destination cap imports from us.
+ */
+/**
+ * Provider-side destination metadata. The addon returns a SHORT id
+ * (`subId`) — orchestrator-internal-only routing prepends the addon's
+ * manifest id to produce the externally-visible globally-unique id.
+ *
+ * Why split: the addon shouldn't have to know its own manifest id.
+ * That id is owned by `package.json` and the kernel's registry; making
+ * the addon repeat it leaks framework state into addon code and
+ * breaks if the manifest is ever renamed.
+ */
+declare const BackupSubDestinationInfoSchema: z.ZodObject<{
+    subId: z.ZodString;
+    displayName: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    kind: z.ZodString;
+    triggerSupported: z.ZodBoolean;
+    restoreSupported: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Orchestrator-side destination metadata. The orchestrator computes
+ * `id = <addonId>:<subId>` from its provider lookup so consumers
+ * (admin UI, restore flow) see one canonical key.
+ *
+ * Phase 4 (admin UI redesign) adds the per-destination policy fields
+ * (`enabled`, `retentionCount`, `label`) so the destinations table can
+ * render the joined view without a follow-up round-trip. The backend
+ * already joins these in `listDestinations` — we now surface them on
+ * the wire.
+ *
+ * `lastSuccessAt` / `lastSuccessSizeBytes` are computed from each
+ * location's `manifests.json` (newest archive). Optional — locations
+ * with no archives yet leave them undefined.
+ */
+declare const BackupDestinationInfoSchema: z.ZodObject<{
+    subId: z.ZodString;
+    displayName: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    kind: z.ZodString;
+    triggerSupported: z.ZodBoolean;
+    restoreSupported: z.ZodBoolean;
+    id: z.ZodString;
+    addonId: z.ZodString;
+    enabled: z.ZodBoolean;
+    retentionCount: z.ZodNumber;
+    label: z.ZodOptional<z.ZodString>;
+    lastSuccessAt: z.ZodOptional<z.ZodNumber>;
+    lastSuccessSizeBytes: z.ZodOptional<z.ZodNumber>;
+    cron: z.ZodOptional<z.ZodString>;
+    nextRunAt: z.ZodOptional<z.ZodNumber>;
+    lastRunAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Per-archive entry returned by `backup.listArchives({ destinationId })`.
+ * Same shape the destination drill-in renders. Sourced from the per-
+ * location `manifests.json` (no per-archive tarball read required).
+ */
+declare const BackupArchiveEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    filename: z.ZodString;
+    createdAt: z.ZodNumber;
+    sizeBytes: z.ZodNumber;
+    label: z.ZodOptional<z.ZodString>;
+    locations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
 declare const BackupEntrySchema: z.ZodObject<{
     id: z.ZodString;
+    destinationId: z.ZodOptional<z.ZodString>;
     label: z.ZodOptional<z.ZodString>;
     createdAt: z.ZodNumber;
     sizeBytes: z.ZodNumber;
     locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
+declare const ArchiveEntrySchema: z.ZodObject<{
+    path: z.ZodString;
+    kind: z.ZodEnum<{
+        file: "file";
+        dir: "dir";
+        symlink: "symlink";
+    }>;
+    sizeBytes: z.ZodNumber;
+    mtime: z.ZodNumber;
+}, z.core.$strip>;
+declare const ArchiveManifestSchema: z.ZodObject<{
+    archiveVersion: z.ZodLiteral<1>;
+    createdAt: z.ZodNumber;
+    dataDir: z.ZodString;
+    locations: z.ZodArray<z.ZodString>;
+    entries: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        kind: z.ZodEnum<{
+            file: "file";
+            dir: "dir";
+            symlink: "symlink";
+        }>;
+        sizeBytes: z.ZodNumber;
+        mtime: z.ZodNumber;
+    }, z.core.$strip>>;
+    totalBytes: z.ZodNumber;
+    totalFiles: z.ZodNumber;
+}, z.core.$strip>;
+declare const LocationStatSchema: z.ZodObject<{
+    name: z.ZodString;
+    sizeBytes: z.ZodNumber;
+    fileCount: z.ZodNumber;
+    present: z.ZodBoolean;
+}, z.core.$strip>;
 /**
  * backup — singleton capability for backup management.
  *
@@ -18,31 +122,148 @@ export declare const backupCapability: {
     readonly scope: "system";
     readonly mode: "singleton";
     readonly methods: {
+        /**
+         * Flat aggregate of every destination across every registered
+         * `backup-destination` provider. This is the orchestrator-side
+         * surface; it expands per-addon `listDestinations()` results into
+         * one list the UI can render directly.
+         */
+        readonly listDestinations: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            subId: z.ZodString;
+            displayName: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            kind: z.ZodString;
+            triggerSupported: z.ZodBoolean;
+            restoreSupported: z.ZodBoolean;
+            id: z.ZodString;
+            addonId: z.ZodString;
+            enabled: z.ZodBoolean;
+            retentionCount: z.ZodNumber;
+            label: z.ZodOptional<z.ZodString>;
+            lastSuccessAt: z.ZodOptional<z.ZodNumber>;
+            lastSuccessSizeBytes: z.ZodOptional<z.ZodNumber>;
+            cron: z.ZodOptional<z.ZodString>;
+            nextRunAt: z.ZodOptional<z.ZodNumber>;
+            lastRunAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Trigger a backup. Without `destinations` the orchestrator fans
+         * out to every destination flagged as enabled in the routing
+         * config; with it, only the listed addons receive the archive.
+         */
         readonly trigger: import("./capability-definition.js").CapabilityMethodSchema<z.ZodOptional<z.ZodObject<{
+            destinations: z.ZodOptional<z.ZodArray<z.ZodString>>;
             locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
             label: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>, z.ZodObject<{
+        }, z.core.$strip>>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
+            destinationId: z.ZodOptional<z.ZodString>;
             label: z.ZodOptional<z.ZodString>;
             createdAt: z.ZodNumber;
             sizeBytes: z.ZodNumber;
             locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>, "mutation">;
+        }, z.core.$strip>>>, "mutation">;
+        /** Union of every destination's archives, each tagged with `destinationId`. */
         readonly list: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
+            destinationId: z.ZodOptional<z.ZodString>;
             label: z.ZodOptional<z.ZodString>;
             createdAt: z.ZodNumber;
             sizeBytes: z.ZodNumber;
             locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Pre-backup snapshot of the well-known locations on disk — sizes
+         * + file counts. Powers the opt-in checklist that lets the
+         * operator pick which subsections of state get archived.
+         */
+        readonly listLocations: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            fileCount: z.ZodNumber;
+            present: z.ZodBoolean;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Read the embedded `.camstack-backup-manifest.json` from a
+         * previously-created archive. The manifest carries the full
+         * file/dir listing with sizes + mtimes — the readdir snapshot
+         * the UI shows in the "Contents" panel. Returns `null` when the
+         * archive predates manifests (created before this feature
+         * shipped).
+         */
+        readonly getEntries: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            destinationId: z.ZodString;
+            backupId: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            archiveVersion: z.ZodLiteral<1>;
+            createdAt: z.ZodNumber;
+            dataDir: z.ZodString;
+            locations: z.ZodArray<z.ZodString>;
+            entries: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                kind: z.ZodEnum<{
+                    file: "file";
+                    dir: "dir";
+                    symlink: "symlink";
+                }>;
+                sizeBytes: z.ZodNumber;
+                mtime: z.ZodNumber;
+            }, z.core.$strip>>;
+            totalBytes: z.ZodNumber;
+            totalFiles: z.ZodNumber;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
         readonly restore: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            destinationId: z.ZodString;
             backupId: z.ZodString;
+            locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>, z.ZodVoid, "mutation">;
         readonly delete: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            destinationId: z.ZodString;
             backupId: z.ZodString;
         }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /**
+         * List archives at a single destination. Reads the per-location
+         * `manifests.json` and returns one entry per archive (newest
+         * first). Powers the destinations-table drill-in in admin UI.
+         */
+        readonly listArchives: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            destinationId: z.ZodString;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            filename: z.ZodString;
+            createdAt: z.ZodNumber;
+            sizeBytes: z.ZodNumber;
+            label: z.ZodOptional<z.ZodString>;
+            locations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Upsert a per-destination policy row. The `locationId` MUST be
+         * the id of an existing `backups`-typed `StorageLocation`. Used
+         * by the admin-UI destinations table (enable toggle + retention
+         * input + optional label).
+         */
+        readonly upsertDestinationPolicy: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            locationId: z.ZodString;
+            enabled: z.ZodBoolean;
+            retentionCount: z.ZodNumber;
+            label: z.ZodOptional<z.ZodString>;
+            cron: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /**
+         * Validate a cron expression and peek the next N firing times.
+         * Used by the admin-UI CronEditor to render a live "next-run"
+         * preview as the operator edits the pattern.
+         */
+        readonly previewSchedule: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            cron: z.ZodString;
+            count: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            ok: z.ZodBoolean;
+            error: z.ZodOptional<z.ZodString>;
+            nextRuns: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
     };
 };
 export type IBackupProvider = InferProvider<typeof backupCapability>;
-export { BackupEntrySchema };
+export { BackupEntrySchema, BackupSubDestinationInfoSchema, BackupDestinationInfoSchema, BackupArchiveEntrySchema, ArchiveEntrySchema, ArchiveManifestSchema, LocationStatSchema, };
 //# sourceMappingURL=backup.cap.d.ts.map

package/dist/capabilities/backup.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"backup.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/backup.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG,QAAA,MAAM,iBAAiB;;;;;;iBAMrB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAcY,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEpE,OAAO,EAAE,iBAAiB,EAAE,CAAA"}
+{"version":3,"file":"backup.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/backup.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;;;GAIG;AACH;;;;;;;;;GASG;AACH,QAAA,MAAM,8BAA8B;;;;;;;iBAalC,CAAA;AAEF;;;;;;;;;;;;;;GAcG;AACH,QAAA,MAAM,2BAA2B;;;;;;;;;;;;;;;;;iBAwB/B,CAAA;AAEF;;;;GAIG;AACH,QAAA,MAAM,wBAAwB;;;;;;;iBAQ5B,CAAA;AAEF,QAAA,MAAM,iBAAiB;;;;;;;iBAQrB,CAAA;AAEF,QAAA,MAAM,kBAAkB;;;;;;;;;iBAKtB,CAAA;AAEF,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBAQzB,CAAA;AAEF,QAAA,MAAM,kBAAkB;;;;;iBAKtB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;;;QAKzB;;;;;WAKG;;;;;;;;;;;;;;;;;;;QAMH;;;;WAIG;;;;;;;;;;;;;QAWH,+EAA+E;;;;;;;;;QAE/E;;;;WAIG;;;;;;;QAEH;;;;;;;WAOG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA2BH;;;;WAIG;;;;;;;;;;;QAMH;;;;;WAKG;;;;;;;;QAmBH;;;;WAIG;;;;;;;;;;CAakC,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEpE,OAAO,EACL,iBAAiB,EACjB,8BAA8B,EAC9B,2BAA2B,EAC3B,wBAAwB,EACxB,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,GACnB,CAAA"}

package/dist/capabilities/index.d.ts

@@ -22,7 +22,8 @@ export { addonSettingsCapability, type IAddonSettingsProvider, SettingsSchemaWit
 export { alertsCapability, AlertSeveritySchema, AlertStatusSchema, AlertSourceSchema, AlertSchema } from './alerts.cap.js';
 export type { AlertSeverity, AlertStatus, Alert } from './alerts.cap.js';
 export { storageCapability, StorageLocationTypeSchema, type IStorageCapProvider } from './storage.cap.js';
-export { backupCapability, type IBackupProvider } from './backup.cap.js';
+export { storageProviderCapability, type IStorageProviderImpl, ProviderInfoSchema as StorageProviderInfoSchema, TestLocationResultSchema as StorageTestLocationResultSchema, BeginUploadInputSchema as StorageBeginUploadInputSchema, BeginUploadResultSchema as StorageBeginUploadResultSchema, WriteChunkInputSchema as StorageWriteChunkInputSchema, FinalizeUploadInputSchema as StorageFinalizeUploadInputSchema, AbortUploadInputSchema as StorageAbortUploadInputSchema, BeginDownloadInputSchema as StorageBeginDownloadInputSchema, BeginDownloadResultSchema as StorageBeginDownloadResultSchema, ReadChunkInputSchema as StorageReadChunkInputSchema, EndDownloadInputSchema as StorageEndDownloadInputSchema, } from './storage-provider.cap.js';
+export { backupCapability, type IBackupProvider, BackupEntrySchema, BackupDestinationInfoSchema, ArchiveEntrySchema, ArchiveManifestSchema, LocationStatSchema, } from './backup.cap.js';
 export { settingsStoreCapability, type ISettingsStoreProvider, type SettingsStoreClient, QueryFilterSchema, SettingsRecordSchema, CollectionColumnSchema, CollectionIndexSchema, type CollectionColumn, type CollectionIndex, } from './settings-store.cap.js';
 export { logDestinationCapability, LogEntrySchema, LogLevelSchema } from './log-destination.cap.js';
 export { adminUiCapability } from './admin-ui.cap.js';
@@ -62,9 +63,12 @@ export { deviceManagerCapability, type IDeviceManagerProvider, DeviceInfoSchema,
 export type { DeviceInfo } from './device-manager.cap.js';
 export { deviceStateCapability } from './device-state.cap.js';
 export { authProviderCapability, AuthResultSchema } from './auth-provider.cap.js';
+export { authenticationCapability, AuthProviderInfoSchema, type IAuthenticationProvider, type AuthProviderInfo } from './authentication.cap.js';
 export { networkAccessCapability, NetworkEndpointSchema, NetworkAccessStatusSchema } from './network-access.cap.js';
+export { remoteAccessCapability, RemoteAccessEndpointSchema, RemoteAccessProviderInfoSchema, type IRemoteAccessOrchestrator, type RemoteAccessProviderInfo } from './remote-access.cap.js';
 export { turnProviderCapability, TurnServerSchema } from './turn-provider.cap.js';
 export type { ITurnProvider } from './turn-provider.cap.js';
+export { turnOrchestratorCapability, TurnProviderInfoSchema, type ITurnOrchestratorProvider, type TurnProviderInfo } from './turn-orchestrator.cap.js';
 export { snapshotCapability, type ISnapshotOrchestrator, SnapshotImageSchema } from './snapshot.cap.js';
 export { snapshotProviderCapability, type ISnapshotProvider } from './snapshot-provider.cap.js';
 export { notificationOutputCapability, NotificationSchema } from './notification-output.cap.js';
@@ -99,6 +103,9 @@ export { intercomCapability, IntercomAbilitySchema, IntercomStatusSchema, type I
 export { doorbellCapability, DoorbellStatusSchema, DoorbellPressEventSchema, type DoorbellStatus, type DoorbellPressEvent, type IDoorbellProvider, } from './doorbell.cap.js';
 export { nativeObjectDetectionCapability, NativeObjectClassEnum, NativeDetectionSchema, NativeObjectDetectionStatusSchema, type NativeObjectClass, type NativeDetection, type NativeObjectDetectionStatus, type INativeObjectDetectionProvider, } from './native-object-detection.cap.js';
 export { platformProbeCapability, type IPlatformProbeProvider } from './platform-probe.cap.js';
+export { localNetworkCapability, type ILocalNetworkProvider, type LocalInterface, type ConnectionEndpoint, } from './local-network.cap.js';
+export { meshNetworkCapability, type IMeshNetworkProvider, type MeshEndpoint, type MeshPeer, type MeshStatus, } from './mesh-network.cap.js';
+export { meshOrchestratorCapability, type IMeshOrchestrator, type MeshProviderInfo, } from './mesh-orchestrator.cap.js';
 export { userManagementCapability, type IUserManagementProvider } from './user-management.cap.js';
 export { systemCapability, type ISystemProvider, FeatureManifestSchema, HealthStatusSchema, NetworkAddressSchema, } from './system.cap.js';
 export { networkQualityCapability, type INetworkQualityProvider, StreamNetworkStatsSchema, ClientNetworkStatsSchema, DeviceNetworkStatsSchema, } from './network-quality.cap.js';
@@ -110,6 +117,7 @@ export { UserSummarySchema, CreateUserInputSchema, UpdateUserInputSchema, ApiKey
 import type { addonSettingsCapability } from './addon-settings.cap.js';
 import type { alertsCapability } from './alerts.cap.js';
 import type { storageCapability } from './storage.cap.js';
+import type { storageProviderCapability } from './storage-provider.cap.js';
 import type { backupCapability } from './backup.cap.js';
 import type { settingsStoreCapability } from './settings-store.cap.js';
 import type { logDestinationCapability } from './log-destination.cap.js';
@@ -139,8 +147,11 @@ import type { deviceProviderCapability } from './device-provider.cap.js';
 import type { deviceManagerCapability } from './device-manager.cap.js';
 import type { deviceStateCapability } from './device-state.cap.js';
 import type { authProviderCapability } from './auth-provider.cap.js';
+import type { authenticationCapability } from './authentication.cap.js';
 import type { networkAccessCapability } from './network-access.cap.js';
+import type { remoteAccessCapability } from './remote-access.cap.js';
 import type { turnProviderCapability } from './turn-provider.cap.js';
+import type { turnOrchestratorCapability } from './turn-orchestrator.cap.js';
 import type { snapshotCapability } from './snapshot.cap.js';
 import type { snapshotProviderCapability } from './snapshot-provider.cap.js';
 import type { notificationOutputCapability } from './notification-output.cap.js';
@@ -163,6 +174,9 @@ import type { motionCapability } from './motion.cap.js';
 import type { recordingCapability } from './recording.cap.js';
 import type { deviceOpsCapability } from './device-ops.cap.js';
 import type { platformProbeCapability } from './platform-probe.cap.js';
+import type { localNetworkCapability } from './local-network.cap.js';
+import type { meshNetworkCapability } from './mesh-network.cap.js';
+import type { meshOrchestratorCapability } from './mesh-orchestrator.cap.js';
 import type { userManagementCapability } from './user-management.cap.js';
 import type { systemCapability } from './system.cap.js';
 import type { networkQualityCapability } from './network-quality.cap.js';
@@ -171,7 +185,7 @@ import type { nodesCapability } from './nodes.cap.js';
 import type { integrationsCapability } from './integrations.cap.js';
 import type { addonsCapability } from './addons.cap.js';
 import type { IReadinessRegistry } from '../interfaces/readiness.js';
-type AnyCapability = typeof addonSettingsCapability | typeof alertsCapability | typeof storageCapability | typeof backupCapability | typeof settingsStoreCapability | typeof logDestinationCapability | typeof adminUiCapability | typeof addonPagesCapability | typeof addonPagesSourceCapability | typeof addonWidgetsCapability | typeof addonWidgetsSourceCapability | typeof addonRoutesCapability | typeof streamBrokerCapability | typeof decoderCapability | typeof restreamerCapability | typeof webrtcCapability | typeof webrtcSessionCapability | typeof cameraStreamsCapability | typeof streamingEngineCapability | typeof motionDetectionCapability | typeof pipelineExecutorCapability | typeof detectionPipelineCapability | typeof pipelineRunnerCapability | typeof pipelineOrchestratorCapability | typeof audioAnalyzerCapability | typeof audioAnalysisCapability | typeof audioCodecCapability | typeof embeddingEncoderCapability | typeof deviceProviderCapability | typeof deviceManagerCapability | typeof deviceStateCapability | typeof authProviderCapability | typeof networkAccessCapability | typeof turnProviderCapability | typeof snapshotCapability | typeof snapshotProviderCapability | typeof notificationOutputCapability | typeof advancedNotifierCapability | typeof recordingEngineCapability | typeof pipelineAnalyticsCapability | typeof metricsProviderCapability | typeof ptzCapability | typeof ptzAutotrackCapability | typeof rebootCapability | typeof deviceDiscoveryCapability | typeof brightnessCapability | typeof motionTriggerCapability | typeof eventsCapability | typeof zonesCapability | typeof zoneRulesCapability | typeof zoneAnalyticsCapability | typeof audioMetricsCapability | typeof motionCapability | typeof recordingCapability | typeof deviceOpsCapability | typeof platformProbeCapability | typeof userManagementCapability | typeof systemCapability | typeof networkQualityCapability | typeof toastCapability | typeof nodesCapability | typeof integrationsCapability | typeof addonsCapability;
+type AnyCapability = typeof addonSettingsCapability | typeof alertsCapability | typeof storageCapability | typeof storageProviderCapability | typeof backupCapability | typeof settingsStoreCapability | typeof logDestinationCapability | typeof adminUiCapability | typeof addonPagesCapability | typeof addonPagesSourceCapability | typeof addonWidgetsCapability | typeof addonWidgetsSourceCapability | typeof addonRoutesCapability | typeof streamBrokerCapability | typeof decoderCapability | typeof restreamerCapability | typeof webrtcCapability | typeof webrtcSessionCapability | typeof cameraStreamsCapability | typeof streamingEngineCapability | typeof motionDetectionCapability | typeof pipelineExecutorCapability | typeof detectionPipelineCapability | typeof pipelineRunnerCapability | typeof pipelineOrchestratorCapability | typeof audioAnalyzerCapability | typeof audioAnalysisCapability | typeof audioCodecCapability | typeof embeddingEncoderCapability | typeof deviceProviderCapability | typeof deviceManagerCapability | typeof deviceStateCapability | typeof authProviderCapability | typeof authenticationCapability | typeof networkAccessCapability | typeof remoteAccessCapability | typeof turnProviderCapability | typeof turnOrchestratorCapability | typeof snapshotCapability | typeof snapshotProviderCapability | typeof notificationOutputCapability | typeof advancedNotifierCapability | typeof recordingEngineCapability | typeof pipelineAnalyticsCapability | typeof metricsProviderCapability | typeof ptzCapability | typeof ptzAutotrackCapability | typeof rebootCapability | typeof deviceDiscoveryCapability | typeof brightnessCapability | typeof motionTriggerCapability | typeof eventsCapability | typeof zonesCapability | typeof zoneRulesCapability | typeof zoneAnalyticsCapability | typeof audioMetricsCapability | typeof motionCapability | typeof recordingCapability | typeof deviceOpsCapability | typeof platformProbeCapability | typeof localNetworkCapability | typeof meshNetworkCapability | typeof meshOrchestratorCapability | typeof userManagementCapability | typeof systemCapability | typeof networkQualityCapability | typeof toastCapability | typeof nodesCapability | typeof integrationsCapability | typeof addonsCapability;
 export type CapabilityName = AnyCapability['name'];
 export type ITypedReadinessRegistry = IReadinessRegistry<CapabilityName>;
 //# sourceMappingURL=index.d.ts.map