@camstack/types 1.2.327 → 1.2.328

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

@@ -0,0 +1,180 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * `keychain` — the hub's encrypted store of secret values (D787).
+ *
+ * Settings blobs never hold a secret: they hold a marker
+ * `{"$secret":"secret://<owner>/<scope>/<fieldPath>","v":1}` and the value
+ * lives here, AES-256-GCM under a data key that a master key wraps. This cap
+ * is the OWNER's door to its own values: every method is owner-checked
+ * against the CALLER, never against anything the caller claims.
+ *
+ * Who the caller is: the transport stamps `callerAddonId` into the args of a
+ * call that crossed a process (the parent `LocalChildRegistry` from the UDS
+ * connection, the agent from its child's connection carried in
+ * `$hub-cap-fwd`'s envelope). A stamp always overwrites; a wire call with no
+ * stamp has its claim stripped. Only a hub in-process caller may state its own
+ * identity — `ctx.secrets` does that with the addon id closed over. This is
+ * identity against BUGS and misrouting, not against a malicious addon (every
+ * runner is the same OS user): see the threat model in
+ * `docs/design/2026-10-08-secrets-keychain.md`.
+ *
+ * `callerAddonId` is deliberately NOT in any input schema: the tRPC router
+ * parses the input, so a session can never supply it, and the internal mount
+ * floors every method to admin anyway (D240).
+ *
+ * Internal: addons reach it through `ctx.secrets`, never directly.
+ */
+/** Why a value cannot be served right now. Never folded into "missing". */
+export declare const KeychainUnavailableReasonSchema: z.ZodEnum<{
+    "key-missing": "key-missing";
+    "wrong-key": "wrong-key";
+    "key-file-unreadable": "key-file-unreadable";
+    "store-unavailable": "store-unavailable";
+    "not-initialized": "not-initialized";
+    "decrypt-failed": "decrypt-failed";
+}>;
+export type KeychainUnavailableReason = z.infer<typeof KeychainUnavailableReasonSchema>;
+export declare const KeychainStateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    state: z.ZodLiteral<"ready">;
+}, z.core.$strip>, z.ZodObject<{
+    state: z.ZodLiteral<"locked">;
+    reason: z.ZodEnum<{
+        "key-missing": "key-missing";
+        "wrong-key": "wrong-key";
+        "key-file-unreadable": "key-file-unreadable";
+        "store-unavailable": "store-unavailable";
+        "not-initialized": "not-initialized";
+        "decrypt-failed": "decrypt-failed";
+    }>;
+}, z.core.$strip>], "state">;
+export type KeychainState = z.infer<typeof KeychainStateSchema>;
+export declare const KeychainResolveEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"value">;
+    value: z.ZodString;
+    version: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"missing">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"unavailable">;
+    reason: z.ZodEnum<{
+        "key-missing": "key-missing";
+        "wrong-key": "wrong-key";
+        "key-file-unreadable": "key-file-unreadable";
+        "store-unavailable": "store-unavailable";
+        "not-initialized": "not-initialized";
+        "decrypt-failed": "decrypt-failed";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"forbidden">;
+}, z.core.$strip>], "kind">;
+export type KeychainResolveEntry = z.infer<typeof KeychainResolveEntrySchema>;
+export declare const KeychainResolveResultSchema: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"value">;
+    value: z.ZodString;
+    version: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"missing">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"unavailable">;
+    reason: z.ZodEnum<{
+        "key-missing": "key-missing";
+        "wrong-key": "wrong-key";
+        "key-file-unreadable": "key-file-unreadable";
+        "store-unavailable": "store-unavailable";
+        "not-initialized": "not-initialized";
+        "decrypt-failed": "decrypt-failed";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"forbidden">;
+}, z.core.$strip>], "kind">>;
+export type KeychainResolveResult = z.infer<typeof KeychainResolveResultSchema>;
+/** Metadata of one stored value — never the value. */
+export declare const KeychainSecretMetaSchema: z.ZodObject<{
+    ref: z.ZodString;
+    owner: z.ZodString;
+    scope: z.ZodString;
+    fieldPath: z.ZodString;
+    version: z.ZodNumber;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    updatedBy: z.ZodString;
+    lastReadAt: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type KeychainSecretMeta = z.infer<typeof KeychainSecretMetaSchema>;
+/** A batch bound: one `resolveConfig` resolves every marker of one blob at once. */
+export declare const KEYCHAIN_MAX_REFS_PER_CALL = 512;
+export declare const keychainCapability: {
+    readonly name: "keychain";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly internal: true;
+    readonly methods: {
+        /** Store (or replace) the caller's value at `ref`. Refused while locked. */
+        readonly put: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            ref: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            ref: z.ZodString;
+            version: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Resolve the caller's refs in one round-trip. A locked keychain answers
+         * `unavailable` per ref — never `missing`, never an empty value.
+         */
+        readonly resolve: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            refs: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"value">;
+            value: z.ZodString;
+            version: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"missing">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"unavailable">;
+            reason: z.ZodEnum<{
+                "key-missing": "key-missing";
+                "wrong-key": "wrong-key";
+                "key-file-unreadable": "key-file-unreadable";
+                "store-unavailable": "store-unavailable";
+                "not-initialized": "not-initialized";
+                "decrypt-failed": "decrypt-failed";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"forbidden">;
+        }, z.core.$strip>], "kind">>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Remove the caller's refs. Unknown refs are ignored. */
+        readonly delete: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            refs: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            deleted: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
+        /** The caller's own refs, metadata only. */
+        readonly listMeta: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            ref: z.ZodString;
+            owner: z.ZodString;
+            scope: z.ZodString;
+            fieldPath: z.ZodString;
+            version: z.ZodNumber;
+            createdAt: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+            updatedBy: z.ZodString;
+            lastReadAt: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Whether values can be served — the save path refuses a write while locked. */
+        readonly getState: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"ready">;
+        }, z.core.$strip>, z.ZodObject<{
+            state: z.ZodLiteral<"locked">;
+            reason: z.ZodEnum<{
+                "key-missing": "key-missing";
+                "wrong-key": "wrong-key";
+                "key-file-unreadable": "key-file-unreadable";
+                "store-unavailable": "store-unavailable";
+                "not-initialized": "not-initialized";
+                "decrypt-failed": "decrypt-failed";
+            }>;
+        }, z.core.$strip>], "state">, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IKeychainProvider = InferProvider<typeof keychainCapability>;

package/dist/capabilities/lawn-mower-control.cap.d.ts

@@ -22,8 +22,8 @@ export declare const LawnMowerActivitySchema: z.ZodEnum<{
 export type LawnMowerActivity = z.infer<typeof LawnMowerActivitySchema>;
 /** Severity of the current device/error code — info (status), warning, error. */
 export declare const DeviceCodeSeveritySchema: z.ZodEnum<{
-    error: "error";
     info: "info";
+    error: "error";
     warning: "warning";
 }>;
 export type DeviceCodeSeverity = z.infer<typeof DeviceCodeSeveritySchema>;
@@ -40,8 +40,8 @@ export declare const LawnMowerControlStatusSchema: z.ZodObject<{
     currentCode: z.ZodNullable<z.ZodNumber>;
     currentCodeLabel: z.ZodNullable<z.ZodString>;
     severity: z.ZodEnum<{
-        error: "error";
         info: "info";
+        error: "error";
         warning: "warning";
     }>;
     lastChangedAt: z.ZodNumber;
@@ -78,8 +78,8 @@ export declare const lawnMowerControlCapability: {
             currentCode: z.ZodNullable<z.ZodNumber>;
             currentCodeLabel: z.ZodNullable<z.ZodString>;
             severity: z.ZodEnum<{
-                error: "error";
                 info: "info";
+                error: "error";
                 warning: "warning";
             }>;
             lastChangedAt: z.ZodNumber;
@@ -103,8 +103,8 @@ export declare const lawnMowerControlCapability: {
         currentCode: z.ZodNullable<z.ZodNumber>;
         currentCodeLabel: z.ZodNullable<z.ZodString>;
         severity: z.ZodEnum<{
-            error: "error";
             info: "info";
+            error: "error";
             warning: "warning";
         }>;
         lastChangedAt: z.ZodNumber;

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

@@ -57,8 +57,8 @@ export declare const logChannelsCapability: {
             name: z.ZodString;
             description: z.ZodString;
             defaultLevel: z.ZodEnum<{
-                error: "error";
                 info: "info";
+                error: "error";
                 warn: "warn";
             }>;
             perDevice: z.ZodBoolean;

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

@@ -1,17 +1,17 @@
 import { z } from 'zod';
 import { type InferProvider } from './capability-definition.js';
 declare const LogLevelSchema: z.ZodEnum<{
+    info: "info";
     error: "error";
     debug: "debug";
-    info: "info";
     warn: "warn";
 }>;
 declare const LogEntrySchema: z.ZodObject<{
     timestamp: z.ZodDate;
     level: z.ZodEnum<{
+        info: "info";
         error: "error";
         debug: "debug";
-        info: "info";
         warn: "warn";
     }>;
     scope: z.ZodArray<z.ZodString>;
@@ -28,9 +28,9 @@ export declare const logDestinationCapability: {
         readonly write: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             timestamp: z.ZodDate;
             level: z.ZodEnum<{
+                info: "info";
                 error: "error";
                 debug: "debug";
-                info: "info";
                 warn: "warn";
             }>;
             scope: z.ZodArray<z.ZodString>;
@@ -41,9 +41,9 @@ export declare const logDestinationCapability: {
         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";
-                info: "info";
                 warn: "warn";
             }>>;
             since: z.ZodOptional<z.ZodDate>;
@@ -53,9 +53,9 @@ export declare const logDestinationCapability: {
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             timestamp: z.ZodDate;
             level: z.ZodEnum<{
+                info: "info";
                 error: "error";
                 debug: "debug";
-                info: "info";
                 warn: "warn";
             }>;
             scope: z.ZodArray<z.ZodString>;