@makaio/contracts 1.0.0-dev-1779051654000

package/dist/config/config-namespace.d.ts

@@ -0,0 +1,189 @@
+/**
+ * Config namespace definition.
+ * Defines the `config` subjects for explicit registration by composition roots.
+ * @example
+ * ```typescript
+ * // Get current config
+ * const result = await bus.request(ConfigSubjects.get, {});
+ * console.log(result.config);
+ *
+ * // Update config
+ * await bus.request(ConfigSubjects.update, { config: newConfig });
+ * ```
+ */
+export declare const ConfigNamespace: import("@makaio/framework/core").BusNamespaceDefinition<"config", {
+    get: {
+        request: import("zod").ZodObject<{}, import("zod/v4/core").$strip>;
+        response: import("zod").ZodObject<{
+            config: import("zod").ZodObject<{
+                $schema: import("zod").ZodDefault<import("zod").ZodLiteral<"makaio/config/v1">>;
+                mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+                    hybrid: "hybrid";
+                    local: "local";
+                    remote: "remote";
+                }>>;
+                role: import("zod").ZodDefault<import("zod").ZodEnum<{
+                    "main-dev-machine": "main-dev-machine";
+                    server: "server";
+                }>>;
+                bus: import("zod").ZodOptional<import("zod").ZodObject<{
+                    remote: import("zod").ZodOptional<import("zod").ZodObject<{
+                        url: import("zod").ZodOptional<import("zod").ZodString>;
+                        secret: import("zod").ZodOptional<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>>;
+                relay: import("zod").ZodOptional<import("zod").ZodObject<{
+                    url: import("zod").ZodOptional<import("zod").ZodString>;
+                    token: import("zod").ZodOptional<import("zod").ZodString>;
+                    autoReconnect: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+                    maxReconnectAttempts: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+                    heartbeatInterval: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+                }, import("zod/v4/core").$strip>>;
+                features: import("zod").ZodOptional<import("zod").ZodObject<{
+                    voiceBridge: import("zod").ZodDefault<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>>;
+                fileWatcher: import("zod").ZodOptional<import("zod").ZodObject<{
+                    backend: import("zod").ZodDefault<import("zod").ZodEnum<{
+                        auto: "auto";
+                        chokidar: "chokidar";
+                        parcel: "parcel";
+                        watchman: "watchman";
+                    }>>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>;
+    };
+    update: {
+        request: import("zod").ZodObject<{
+            config: import("zod").ZodObject<{
+                $schema: import("zod").ZodDefault<import("zod").ZodLiteral<"makaio/config/v1">>;
+                mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+                    hybrid: "hybrid";
+                    local: "local";
+                    remote: "remote";
+                }>>;
+                role: import("zod").ZodDefault<import("zod").ZodEnum<{
+                    "main-dev-machine": "main-dev-machine";
+                    server: "server";
+                }>>;
+                bus: import("zod").ZodOptional<import("zod").ZodObject<{
+                    remote: import("zod").ZodOptional<import("zod").ZodObject<{
+                        url: import("zod").ZodOptional<import("zod").ZodString>;
+                        secret: import("zod").ZodOptional<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>>;
+                relay: import("zod").ZodOptional<import("zod").ZodObject<{
+                    url: import("zod").ZodOptional<import("zod").ZodString>;
+                    token: import("zod").ZodOptional<import("zod").ZodString>;
+                    autoReconnect: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+                    maxReconnectAttempts: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+                    heartbeatInterval: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+                }, import("zod/v4/core").$strip>>;
+                features: import("zod").ZodOptional<import("zod").ZodObject<{
+                    voiceBridge: import("zod").ZodDefault<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>>;
+                fileWatcher: import("zod").ZodOptional<import("zod").ZodObject<{
+                    backend: import("zod").ZodDefault<import("zod").ZodEnum<{
+                        auto: "auto";
+                        chokidar: "chokidar";
+                        parcel: "parcel";
+                        watchman: "watchman";
+                    }>>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodObject<{
+            success: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>;
+    };
+}>;
+/**
+ * Config subjects for type-safe bus communication.
+ */
+export declare const ConfigSubjects: import("@makaio/framework/core").BusSubjects<import("@makaio/framework/core").FlatSubjectDefinitions<"config", {
+    get: {
+        request: import("zod").ZodObject<{}, import("zod/v4/core").$strip>;
+        response: import("zod").ZodObject<{
+            config: import("zod").ZodObject<{
+                $schema: import("zod").ZodDefault<import("zod").ZodLiteral<"makaio/config/v1">>;
+                mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+                    hybrid: "hybrid";
+                    local: "local";
+                    remote: "remote";
+                }>>;
+                role: import("zod").ZodDefault<import("zod").ZodEnum<{
+                    "main-dev-machine": "main-dev-machine";
+                    server: "server";
+                }>>;
+                bus: import("zod").ZodOptional<import("zod").ZodObject<{
+                    remote: import("zod").ZodOptional<import("zod").ZodObject<{
+                        url: import("zod").ZodOptional<import("zod").ZodString>;
+                        secret: import("zod").ZodOptional<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>>;
+                relay: import("zod").ZodOptional<import("zod").ZodObject<{
+                    url: import("zod").ZodOptional<import("zod").ZodString>;
+                    token: import("zod").ZodOptional<import("zod").ZodString>;
+                    autoReconnect: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+                    maxReconnectAttempts: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+                    heartbeatInterval: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+                }, import("zod/v4/core").$strip>>;
+                features: import("zod").ZodOptional<import("zod").ZodObject<{
+                    voiceBridge: import("zod").ZodDefault<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>>;
+                fileWatcher: import("zod").ZodOptional<import("zod").ZodObject<{
+                    backend: import("zod").ZodDefault<import("zod").ZodEnum<{
+                        auto: "auto";
+                        chokidar: "chokidar";
+                        parcel: "parcel";
+                        watchman: "watchman";
+                    }>>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>;
+    };
+    update: {
+        request: import("zod").ZodObject<{
+            config: import("zod").ZodObject<{
+                $schema: import("zod").ZodDefault<import("zod").ZodLiteral<"makaio/config/v1">>;
+                mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+                    hybrid: "hybrid";
+                    local: "local";
+                    remote: "remote";
+                }>>;
+                role: import("zod").ZodDefault<import("zod").ZodEnum<{
+                    "main-dev-machine": "main-dev-machine";
+                    server: "server";
+                }>>;
+                bus: import("zod").ZodOptional<import("zod").ZodObject<{
+                    remote: import("zod").ZodOptional<import("zod").ZodObject<{
+                        url: import("zod").ZodOptional<import("zod").ZodString>;
+                        secret: import("zod").ZodOptional<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>>;
+                relay: import("zod").ZodOptional<import("zod").ZodObject<{
+                    url: import("zod").ZodOptional<import("zod").ZodString>;
+                    token: import("zod").ZodOptional<import("zod").ZodString>;
+                    autoReconnect: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+                    maxReconnectAttempts: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+                    heartbeatInterval: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+                }, import("zod/v4/core").$strip>>;
+                features: import("zod").ZodOptional<import("zod").ZodObject<{
+                    voiceBridge: import("zod").ZodDefault<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strip>>;
+                fileWatcher: import("zod").ZodOptional<import("zod").ZodObject<{
+                    backend: import("zod").ZodDefault<import("zod").ZodEnum<{
+                        auto: "auto";
+                        chokidar: "chokidar";
+                        parcel: "parcel";
+                        watchman: "watchman";
+                    }>>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>;
+        response: import("zod").ZodObject<{
+            success: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>;
+    };
+}>, "config">;
+//# sourceMappingURL=config-namespace.d.ts.map

package/dist/config/config-namespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-namespace.d.ts","sourceRoot":"","sources":["../../src/config/config-namespace.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA8C,CAAC;AAE3E;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAA2B,CAAC"}

package/dist/config/config-schema.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+/**
+ * Bootstrap config schema for Makaio runtime configuration.
+ *
+ * This is the minimal config needed to bootstrap the system - stored in
+ * `~/.makaio/config.json`. It controls:
+ * - Runtime mode (local/remote/hybrid)
+ * - Bus connectivity for remote/hybrid modes
+ * - Relay connection settings
+ * @example
+ * ```json
+ * {
+ *   "$schema": "makaio/config/v1",
+ *   "mode": "local"
+ * }
+ * ```
+ */
+export declare const ConfigSchema: z.ZodObject<{
+    $schema: z.ZodDefault<z.ZodLiteral<"makaio/config/v1">>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        hybrid: "hybrid";
+        local: "local";
+        remote: "remote";
+    }>>;
+    role: z.ZodDefault<z.ZodEnum<{
+        "main-dev-machine": "main-dev-machine";
+        server: "server";
+    }>>;
+    bus: z.ZodOptional<z.ZodObject<{
+        remote: z.ZodOptional<z.ZodObject<{
+            url: z.ZodOptional<z.ZodString>;
+            secret: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    relay: z.ZodOptional<z.ZodObject<{
+        url: z.ZodOptional<z.ZodString>;
+        token: z.ZodOptional<z.ZodString>;
+        autoReconnect: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        maxReconnectAttempts: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        heartbeatInterval: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    features: z.ZodOptional<z.ZodObject<{
+        voiceBridge: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    fileWatcher: z.ZodOptional<z.ZodObject<{
+        backend: z.ZodDefault<z.ZodEnum<{
+            auto: "auto";
+            chokidar: "chokidar";
+            parcel: "parcel";
+            watchman: "watchman";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Inferred type for the bootstrap config.
+ */
+export type Config = z.infer<typeof ConfigSchema>;
+/**
+ * Relay connection configuration type, derived from the bootstrap config schema.
+ */
+export type RelayConfig = NonNullable<Config['relay']>;
+//# sourceMappingURL=config-schema.d.ts.map

package/dist/config/config-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-schema.d.ts","sourceRoot":"","sources":["../../src/config/config-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqHvB,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC"}

package/dist/config/config-subjects.d.ts

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+/**
+ * Config domain schemas.
+ *
+ * Subjects for config-related bus communication.
+ * Each key becomes a subject identifier as: `config.{key}`
+ *
+ * **Bus subjects:**
+ * - `config.get` - Request to get current config
+ * - `config.update` - Request to update config
+ * @example
+ * ```typescript
+ * // Get current config
+ * const config = await bus.request(ConfigSubjects.get, {});
+ *
+ * // Update config
+ * await bus.request(ConfigSubjects.update, { config: newConfig });
+ * ```
+ */
+export declare const ConfigSchemas: {
+    /**
+     * Get current config request.
+     * Empty request payload, returns full config.
+     */
+    get: {
+        request: z.ZodObject<{}, z.core.$strip>;
+        response: z.ZodObject<{
+            config: z.ZodObject<{
+                $schema: z.ZodDefault<z.ZodLiteral<"makaio/config/v1">>;
+                mode: z.ZodDefault<z.ZodEnum<{
+                    hybrid: "hybrid";
+                    local: "local";
+                    remote: "remote";
+                }>>;
+                role: z.ZodDefault<z.ZodEnum<{
+                    "main-dev-machine": "main-dev-machine";
+                    server: "server";
+                }>>;
+                bus: z.ZodOptional<z.ZodObject<{
+                    remote: z.ZodOptional<z.ZodObject<{
+                        url: z.ZodOptional<z.ZodString>;
+                        secret: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                relay: z.ZodOptional<z.ZodObject<{
+                    url: z.ZodOptional<z.ZodString>;
+                    token: z.ZodOptional<z.ZodString>;
+                    autoReconnect: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                    maxReconnectAttempts: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+                    heartbeatInterval: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+                }, z.core.$strip>>;
+                features: z.ZodOptional<z.ZodObject<{
+                    voiceBridge: z.ZodDefault<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                fileWatcher: z.ZodOptional<z.ZodObject<{
+                    backend: z.ZodDefault<z.ZodEnum<{
+                        auto: "auto";
+                        chokidar: "chokidar";
+                        parcel: "parcel";
+                        watchman: "watchman";
+                    }>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    };
+    /**
+     * Update config request.
+     * Accepts full config object, validates and saves it.
+     */
+    update: {
+        request: z.ZodObject<{
+            config: z.ZodObject<{
+                $schema: z.ZodDefault<z.ZodLiteral<"makaio/config/v1">>;
+                mode: z.ZodDefault<z.ZodEnum<{
+                    hybrid: "hybrid";
+                    local: "local";
+                    remote: "remote";
+                }>>;
+                role: z.ZodDefault<z.ZodEnum<{
+                    "main-dev-machine": "main-dev-machine";
+                    server: "server";
+                }>>;
+                bus: z.ZodOptional<z.ZodObject<{
+                    remote: z.ZodOptional<z.ZodObject<{
+                        url: z.ZodOptional<z.ZodString>;
+                        secret: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                relay: z.ZodOptional<z.ZodObject<{
+                    url: z.ZodOptional<z.ZodString>;
+                    token: z.ZodOptional<z.ZodString>;
+                    autoReconnect: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                    maxReconnectAttempts: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+                    heartbeatInterval: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+                }, z.core.$strip>>;
+                features: z.ZodOptional<z.ZodObject<{
+                    voiceBridge: z.ZodDefault<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                fileWatcher: z.ZodOptional<z.ZodObject<{
+                    backend: z.ZodDefault<z.ZodEnum<{
+                        auto: "auto";
+                        chokidar: "chokidar";
+                        parcel: "parcel";
+                        watchman: "watchman";
+                    }>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        response: z.ZodObject<{
+            success: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Type for config.get response.
+ */
+export type ConfigGetResponse = z.infer<typeof ConfigSchemas.get.response>;
+/**
+ * Type for config.update request.
+ */
+export type ConfigUpdateRequest = z.infer<typeof ConfigSchemas.update.request>;
+/**
+ * Type for config.update response.
+ */
+export type ConfigUpdateResponse = z.infer<typeof ConfigSchemas.update.response>;
+//# sourceMappingURL=config-subjects.d.ts.map

package/dist/config/config-subjects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-subjects.d.ts","sourceRoot":"","sources":["../../src/config/config-subjects.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,aAAa;IACxB;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CASmB,CAAC;AAEzB;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AAE/E;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC"}

package/dist/config/credential-ref.d.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+/**
+ * Check whether a credential ref was issued by the account-manager.
+ *
+ * Account-manager refs bind a provider config to a specific managed account
+ * and are not resolvable to a raw credential. Callers that need to derive a
+ * source ref from the credential map should use this guard.
+ * @param ref - Raw credential ref string
+ * @returns `true` when the ref was issued by the account-manager
+ */
+export declare function isAccountManagerRef(ref: string): boolean;
+export declare const CredentialRefSchema: z.core.$ZodBranded<z.ZodString, "CredentialRef", "out">;
+export type CredentialRef = z.infer<typeof CredentialRefSchema>;
+/**
+ * Build a stored credential reference keyed by provider config ID.
+ *
+ * The format is `stored:providerConfig:<configId>:<key>`. The last colon in the
+ * string acts as the configId/key separator, so `configId` may contain colons
+ * (e.g. `github:oauth-default`) but `key` must be a colon-free identifier.
+ * @param configId - Provider config ID; may contain colons (e.g. `github:oauth-default`)
+ * @param key - Credential key — must not contain colons (e.g. `apiKey`, `pat`)
+ * @returns Stored credential reference string
+ */
+export declare function buildStoredCredentialRef(configId: string, key: string): CredentialRef;
+/**
+ * Build an account-manager credential reference keyed by client/account IDs.
+ *
+ * The payload is a JSON tuple prefixed by `account-manager:` so both IDs stay
+ * opaque and may contain delimiters.
+ * @param clientId - Account-manager client identifier
+ * @param accountId - Stable account identifier
+ * @returns Account-manager credential reference string
+ */
+export declare function buildAccountManagerCredentialRef(clientId: string, accountId: string): CredentialRef;
+/**
+ * Parse a stored credential reference into its parts.
+ * @param ref - Credential reference string
+ * @returns Parsed parts, or `null` when the ref is not a stored credential ref
+ */
+export declare function parseStoredCredentialRef(ref: CredentialRef): {
+    configId: string;
+    key: string;
+} | null;
+/**
+ * Brand a plain string record as a credential-ref record.
+ *
+ * Used by storage handlers to convert persisted JSON values into the branded API type.
+ * @param creds - Plain string record from storage
+ * @returns Branded credential-ref record, or `undefined` when input is nullish
+ */
+export declare function brandCredentialRecord(creds: Record<string, string> | null | undefined): Record<string, CredentialRef> | undefined;
+/**
+ * Strip the `CredentialRef` brand from a credential map for use in a
+ * `ProviderConfigInput` upsert.
+ *
+ * `CredentialRef` is a type-level brand only — at runtime the values are
+ * plain ref strings (e.g. `stored:providerConfig:xxx:apiKey`). The storage
+ * tier stores and re-brands them on read; this helper makes the type system
+ * aware of the cast without changing values.
+ * @param credentials - Branded credential map from a storage record, or `undefined`.
+ * @returns Plain string credential map, or `undefined` when absent.
+ */
+export declare function unbrandCredentials(credentials: Record<string, CredentialRef> | undefined): Record<string, string> | undefined;
+//# sourceMappingURL=credential-ref.d.ts.map

package/dist/config/credential-ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credential-ref.d.ts","sourceRoot":"","sources":["../../src/config/credential-ref.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA6HxB;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAExD;AAED,eAAO,MAAM,mBAAmB,yDAGL,CAAC;AAC5B,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,CAKrF;AAED;;;;;;;;GAQG;AACH,wBAAgB,gCAAgC,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,aAAa,CAEnG;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,aAAa,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAErG;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,GAAG,SAAS,GAC/C,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,SAAS,CAW3C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,SAAS,GACrD,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAGpC"}

package/dist/config/index.d.ts

@@ -0,0 +1,10 @@
+export { ConfigSchema, type Config, type RelayConfig } from './config-schema.js';
+export { CredentialRefSchema, buildAccountManagerCredentialRef, buildStoredCredentialRef, parseStoredCredentialRef, brandCredentialRecord, unbrandCredentials, isAccountManagerRef, type CredentialRef, } from './credential-ref.js';
+export { AIModelSchema, ProviderDefaultsSchema, ProviderConfigSchema, BaseAdapterConfigSchema, } from './provider-defaults.js';
+export { ProviderConfigFileSchema, PROVIDER_CONFIG_SCHEMA_VERSION, type ProviderConfigFile, } from './provider-config-file.js';
+export { AdapterFileSchema, ADAPTER_FILE_SCHEMA_VERSION, type AdapterFile } from './adapter-file.js';
+export { isCanonicalProviderConfigName, resolveCanonicalProviderConfigName, slugifyProviderConfigName, } from './provider-config-name.js';
+export { ConfigSchemas, type ConfigGetResponse, type ConfigUpdateRequest, type ConfigUpdateResponse, } from './config-subjects.js';
+export { ConfigNamespace, ConfigSubjects } from './config-namespace.js';
+export { AdaptersFileSchema, AdaptersFileAdapterSchema, AdaptersFileProviderSchema, type AdaptersFile, type AdaptersFileAdapter, type AdaptersFileProvider, } from './adapters-file.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjF,OAAO,EACL,mBAAmB,EACnB,gCAAgC,EAChC,wBAAwB,EACxB,wBAAwB,EACxB,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,KAAK,aAAa,GACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,aAAa,EACb,sBAAsB,EACtB,oBAAoB,EACpB,uBAAuB,GACxB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,wBAAwB,EACxB,8BAA8B,EAC9B,KAAK,kBAAkB,GACxB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,iBAAiB,EAAE,2BAA2B,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrG,OAAO,EACL,6BAA6B,EAC7B,kCAAkC,EAClC,yBAAyB,GAC1B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,aAAa,EACb,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,GAC1B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACxE,OAAO,EACL,kBAAkB,EAClB,yBAAyB,EACzB,0BAA0B,EAC1B,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,GAC1B,MAAM,oBAAoB,CAAC"}

package/dist/config/index.mjs

@@ -0,0 +1 @@
+import{p as e}from"../shared-CE23KND3.mjs";import{i as t,n,t as r}from"../visibility-D4i0fywT.mjs";import{a as i,i as a,n as o,o as s,r as c,s as l,t as u}from"../credential-ref-DAVeyQ2h.mjs";import{a as d,i as f,n as p,r as m,t as h}from"../config-namespace-B-nWOYn1.mjs";import{z as g}from"zod";const _=g.object({anthropic:g.string().url(),openai:g.string().url()}).partial().strict(),v=g.object({model:g.string().optional().describe(`Model identifier (adapter-specific, e.g., sonnet, opus)`),timeouts:f.optional().describe(`Timeout overrides for this provider`),cwd:g.string().optional().describe(`Working directory for agent execution`),env:g.record(g.string(),g.string()).optional().describe(`Environment variables to pass to agent execution`),credentials:g.record(g.string(),u).optional().describe(`Credential references resolved at runtime (e.g., keychain:service:account)`),providerSettings:g.record(g.string(),g.unknown()).optional().describe(`Provider-specific configuration (non-credential settings only)`)}),y=v.safeExtend({providerId:g.string().optional().describe(`FK to the providers table (stable provider ID, e.g. "anthropic")`),definitionId:g.string().optional().describe(`Provider definition identifier for schema lookup`),name:g.string().describe(`Display name for UI`),baseUrl:g.string().url().optional().describe(`Provider endpoint URL`),availableModels:g.array(t).optional().describe(`Models from this provider`),modelFilterMode:r.optional().describe(`Controls default visibility for models without explicit overrides`),modelVisibility:g.record(g.string(),n).optional().describe(`Sparse per-model visibility overrides`),isDefault:g.boolean().default(!1).describe(`Whether this is the default provider for inheritance`),enabled:g.boolean().default(!0).describe(`Whether this provider is enabled (disabled providers are not loaded)`)}),b=g.object({$schema:g.literal(`makaio/adapter-config/v2`),defaults:v.optional(),providers:g.record(g.string(),y).default(()=>({}))}),x=`makaio/provider-config/v1`,S=g.object({$schema:g.literal(x),definitionId:g.string().trim().min(1),name:g.string().trim().min(1).optional(),credentials:g.record(g.string(),u).optional(),endpointOverrides:_.optional(),modelFilterMode:r.optional(),modelVisibility:g.record(g.string(),n).optional(),isDefault:g.boolean().optional(),enabled:g.boolean().optional(),isSentinel:g.boolean().optional()}).strict(),C=`makaio/adapter-config/v1`,w=g.object({label:g.string().min(1),url:g.string().url()}).strict(),T=g.object({providerConfigId:g.string().trim().min(1),isDefault:g.boolean().optional()}).strict(),E=g.array(T).superRefine((e,t)=>{let n=new Set,r=null;for(let[i,a]of e.entries())if(n.has(a.providerConfigId)?t.addIssue({code:g.ZodIssueCode.custom,message:`Duplicate adapter binding for providerConfigId "${a.providerConfigId}".`,path:[i,`providerConfigId`]}):n.add(a.providerConfigId),a.isDefault){if(r!==null){t.addIssue({code:g.ZodIssueCode.custom,message:`Adapter config files may declare at most one default binding.`,path:[i,`isDefault`]});continue}r=i}}),D=g.object({$schema:g.literal(C),enabled:g.boolean().optional(),displayName:g.string().optional(),description:g.string().optional(),helpLinks:g.array(w).optional(),instructions:g.string().optional(),clientId:g.string().optional(),protocol:g.string().optional(),providerDefinitionIds:g.array(g.string()).optional(),settings:e.optional(),bindings:E.optional()}).strict();function O(e){return e.trim().toLowerCase().replace(/\s+/g,`-`)}function k(e){if(e.includes(`::`)||e.includes(`~`)||e.includes(`/`))return!1;let t=O(e);return t.length>0&&/^[a-z0-9][a-z0-9._-]*$/.test(t)}function A(e){let t=e.requestedName?.trim();if(t)return t;let n=e.providerName?.trim();if(n&&k(n))return n;if(k(e.definitionId))return e.definitionId}const j=g.object({name:g.string().optional(),providerId:g.string().optional(),credentials:g.record(g.string(),u).optional(),baseUrl:g.string().url().optional(),isDefault:g.boolean().optional(),enabled:g.boolean().optional(),modelFilterMode:r.optional(),modelVisibility:g.record(g.string(),n).optional()}),M=g.object({providers:g.record(g.string(),j)}),N=g.object({$schema:g.literal(`makaio/adapters-config/v1`),adapters:g.record(g.string(),M)});export{C as ADAPTER_FILE_SCHEMA_VERSION,t as AIModelSchema,D as AdapterFileSchema,M as AdaptersFileAdapterSchema,j as AdaptersFileProviderSchema,N as AdaptersFileSchema,b as BaseAdapterConfigSchema,h as ConfigNamespace,d as ConfigSchema,m as ConfigSchemas,p as ConfigSubjects,u as CredentialRefSchema,x as PROVIDER_CONFIG_SCHEMA_VERSION,S as ProviderConfigFileSchema,y as ProviderConfigSchema,v as ProviderDefaultsSchema,o as brandCredentialRecord,c as buildAccountManagerCredentialRef,a as buildStoredCredentialRef,i as isAccountManagerRef,k as isCanonicalProviderConfigName,s as parseStoredCredentialRef,A as resolveCanonicalProviderConfigName,O as slugifyProviderConfigName,l as unbrandCredentials};

package/dist/config/provider-config-file.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+/**
+ * Canonical schema version string for provider config files.
+ */
+export declare const PROVIDER_CONFIG_SCHEMA_VERSION: "makaio/provider-config/v1";
+/**
+ * Schema for `.makaio/provider-configs/<providerConfigId>.json`.
+ *
+ * The file stem is the canonical `providerConfigId`; the payload only stores
+ * the entity fields that belong to the provider config itself. Credential
+ * entries are ref-only; plaintext secrets must stay behind the credential
+ * service boundary.
+ */
+export declare const ProviderConfigFileSchema: z.ZodObject<{
+    $schema: z.ZodLiteral<"makaio/provider-config/v1">;
+    definitionId: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.core.$ZodBranded<z.ZodString, "CredentialRef", "out">>>;
+    endpointOverrides: z.ZodOptional<z.ZodObject<{
+        anthropic: z.ZodOptional<z.ZodString>;
+        openai: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    modelFilterMode: z.ZodOptional<z.ZodEnum<{
+        allowlist: "allowlist";
+        "show-all": "show-all";
+    }>>;
+    modelVisibility: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        disabled: "disabled";
+        enabled: "enabled";
+        visible: "visible";
+    }>>>;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    isSentinel: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+/**
+ * Inferred type for a file-canonical provider config record.
+ */
+export type ProviderConfigFile = z.infer<typeof ProviderConfigFileSchema>;
+//# sourceMappingURL=provider-config-file.d.ts.map

package/dist/config/provider-config-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-config-file.d.ts","sourceRoot":"","sources":["../../src/config/provider-config-file.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;GAEG;AACH,eAAO,MAAM,8BAA8B,6BAAuC,CAAC;AAEnF;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;kBAa1B,CAAC;AAEZ;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/config/provider-config-name.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Convert a provider-config display name into its canonical routing slug.
+ *
+ * Trims surrounding whitespace, lowercases, and collapses interior whitespace
+ * runs to hyphens so case-insensitive matching and uniqueness checks share one
+ * normalization rule.
+ * @param value - Provider-config display name.
+ * @returns Canonical lowercase slug.
+ */
+export declare function slugifyProviderConfigName(value: string): string;
+/**
+ * Returns true when the given provider-config name can serve as a canonical
+ * routing name.
+ *
+ * Canonical names must not contain `::`, `~`, or `/`, and their slugified form
+ * must match `^[a-z0-9][a-z0-9._-]*$`.
+ * @param value - Candidate provider-config name.
+ * @returns `true` when the value is canonical.
+ */
+export declare function isCanonicalProviderConfigName(value: string): boolean;
+/**
+ * Resolve the canonical display name a provider-config create flow should use.
+ *
+ * Preference order:
+ * 1. explicit user-supplied name (trimmed only; canonical validation happens in
+ *    the caller's input schema)
+ * 2. provider definition display name when it is already canonical
+ * 3. provider definition id when it is canonical
+ *
+ * Returns `undefined` when no derived fallback satisfies the canonical-name
+ * contract.
+ * @param options - Candidate name inputs.
+ * @returns Trimmed explicit name or a canonical derived fallback, or `undefined`
+ * when no candidate fits.
+ */
+export declare function resolveCanonicalProviderConfigName(options: {
+    requestedName?: string;
+    providerName?: string;
+    definitionId: string;
+}): string | undefined;
+//# sourceMappingURL=provider-config-name.d.ts.map

package/dist/config/provider-config-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-config-name.d.ts","sourceRoot":"","sources":["../../src/config/provider-config-name.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAOpE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kCAAkC,CAAC,OAAO,EAAE;IAC1D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,MAAM,GAAG,SAAS,CAgBrB"}