@decaf-ts/integrations 0.14.0 → 0.14.3

package/lib/esm/secrets/kubernetes/KubernetesSecretService.js

@@ -0,0 +1,474 @@
+import { ApiException, CoreV1Api, KubeConfig, } from "@kubernetes/client-node";
+import { AuthorizationError } from "@decaf-ts/core";
+import { ClientBasedSecretService, SecretError, } from "./../core/index.js";
+import { validateSecretName, normalizeSecretName } from "./../core/index.js";
+import { serializeSecretPayload, deserializeSecretPayload, } from "./../core/index.js";
+import { KubernetesSecretEnvironment } from "./KubernetesSecretEnvironment.js";
+import { envBoolean, envString } from "./../../shared/environmentValue.js";
+import { BadRequestError, BaseError, ConflictError, InternalError, NotFoundError, } from "@decaf-ts/db-decorators";
+const PAYLOAD_DATA_KEY = "payload";
+const MANAGED_LABEL = "decaf-ts.io/managed";
+const ANNOTATION_PREFIX = "decaf-ts.io/";
+const ENCODING_ANNOTATION = `${ANNOTATION_PREFIX}encoding`;
+const CONTENT_TYPE_ANNOTATION = `${ANNOTATION_PREFIX}content-type`;
+const TAGS_ANNOTATION = `${ANNOTATION_PREFIX}tags`;
+const VERSION_ANNOTATION = `${ANNOTATION_PREFIX}version`;
+const UPDATED_AT_ANNOTATION = `${ANNOTATION_PREFIX}updated-at`;
+const TENANT_ANNOTATION = `${ANNOTATION_PREFIX}tenant-id`;
+const ORG_UNIT_ANNOTATION = `${ANNOTATION_PREFIX}org-unit-id`;
+const OWNER_ANNOTATION = `${ANNOTATION_PREFIX}owner-principal-id`;
+const DNS_SUBDOMAIN_PATTERN = /^[a-z0-9]([-a-z0-9.]*[a-z0-9])?$/;
+const DNS_LABEL_PATTERN = /^[a-z0-9]([-a-z0-9]*[a-z0-9])?$/;
+function assertKubernetesName(name) {
+    if (name.length > 253 || !DNS_SUBDOMAIN_PATTERN.test(name)) {
+        throw new SecretError("SECRET_INVALID_NAME", `Invalid Kubernetes secret name: "${name}". Names must be lowercase DNS-1123 subdomains (letters, digits, '-', and '.').`);
+    }
+}
+function assertKubernetesNamespace(namespace) {
+    if (namespace.length > 63 || !DNS_LABEL_PATTERN.test(namespace)) {
+        throw new SecretError("SECRET_INVALID_NAME", `Invalid Kubernetes namespace: "${namespace}". Namespaces must be lowercase DNS-1123 labels.`);
+    }
+}
+function toDate(value) {
+    if (!value)
+        return undefined;
+    const date = value instanceof Date ? value : new Date(value);
+    return Number.isNaN(date.getTime()) ? undefined : date;
+}
+function parseTags(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object"
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * @class KubernetesSecretService
+ * @summary Native Kubernetes Secrets backend.
+ * @description Implements the {@link SecretService} contract on top of
+ * namespaced Kubernetes `Secret` objects. Each DECAF secret is stored as an
+ * `Opaque` Secret whose `payload` data key holds the serialized
+ * {@link SerializedSecretPayload} envelope, while encoding, content type, tags,
+ * logical version, and ownership hints live in `decaf-ts.io/*` annotations.
+ *
+ * Authentication uses the standard Kubernetes client resolution order:
+ * explicit `server` credentials, an explicit `kubeconfig` path, `KUBECONFIG`,
+ * `~/.kube/config`, and finally the in-cluster service account.
+ */
+export class KubernetesSecretService extends ClientBasedSecretService {
+    constructor() {
+        super(...arguments);
+        this.provider = "kubernetes";
+    }
+    configFromEnvironment() {
+        const env = KubernetesSecretEnvironment.secrets.kubernetes;
+        const namespace = envString(env?.namespace);
+        const kubeconfig = envString(env?.kubeconfig);
+        const context = envString(env?.context);
+        const server = envString(env?.server);
+        if (!namespace && !kubeconfig && !context && !server)
+            return undefined;
+        return {
+            provider: "kubernetes",
+            namespace,
+            kubeconfig,
+            context,
+            server,
+            token: envString(env.token),
+            tokenFile: envString(env.tokenFile),
+            caFile: envString(env.caFile),
+            caData: envString(env.caData),
+            certFile: envString(env.certFile),
+            keyFile: envString(env.keyFile),
+            certData: envString(env.certData),
+            keyData: envString(env.keyData),
+            skipTLSVerify: envBoolean(env.skipTLSVerify),
+            serviceAccount: envBoolean(env.serviceAccount),
+        };
+    }
+    async initialize(...args) {
+        const { log } = (await this.logCtx(args, "initialize", true)).for(this.initialize);
+        const config = this.getConfigFromArgs(...args);
+        const kubeConfig = this.buildKubeConfig(config);
+        const namespace = this.resolveNamespace(config, kubeConfig);
+        const resolved = { ...config, namespace };
+        const client = kubeConfig.makeApiClient(CoreV1Api);
+        this._config = resolved;
+        this._client = client;
+        log.verbose(`Initialized Kubernetes secret service for namespace "${namespace}"`);
+        return { config: resolved, client };
+    }
+    async store(name, value, options = {}, ...args) {
+        const { log } = (await this.logCtx(args, "store", true)).for(this.store);
+        const normalizedName = this.normalizeName(name);
+        const namespace = this.resolveNamespaceOption(options.namespace);
+        log.verbose(`Storing secret ${normalizedName} in namespace ${namespace}`);
+        const serialized = serializeSecretPayload(value);
+        const body = this.buildSecret(normalizedName, namespace, serialized, options);
+        try {
+            await this.client.createNamespacedSecret({ namespace, body });
+        }
+        catch (error) {
+            if (this.statusOf(error) === 409) {
+                try {
+                    const existing = await this.client.readNamespacedSecret({
+                        name: normalizedName,
+                        namespace,
+                    });
+                    body.metadata = {
+                        ...(body.metadata || {}),
+                        resourceVersion: existing.metadata?.resourceVersion,
+                    };
+                    await this.client.replaceNamespacedSecret({
+                        name: normalizedName,
+                        namespace,
+                        body,
+                    });
+                }
+                catch (replaceError) {
+                    throw this.parseError(replaceError);
+                }
+            }
+            else {
+                throw this.parseError(error);
+            }
+        }
+        return {
+            provider: this.provider,
+            name: normalizedName,
+            namespace,
+            version: options.version,
+            uri: `kubernetes://${namespace}/${normalizedName}`,
+        };
+    }
+    async retrieve(nameOrRef, options = {}, ...args) {
+        const { log } = (await this.logCtx(args, "retrieve", true)).for(this.retrieve);
+        const { name, namespace, version } = this.resolveReference(nameOrRef, options);
+        log.verbose(`Retrieving secret ${name} from namespace ${namespace}`);
+        const secret = await this.readSecret(name, namespace);
+        this.assertVersion(secret, version);
+        const raw = secret.data?.[PAYLOAD_DATA_KEY];
+        if (!raw) {
+            throw new NotFoundError(`No secret value found for "${name}" in namespace "${namespace}"`);
+        }
+        let payload;
+        try {
+            payload = JSON.parse(Buffer.from(raw, "base64").toString("utf8"));
+        }
+        catch (error) {
+            throw new SecretError("SECRET_DESERIALIZATION_FAILED", `Failed to parse secret payload for "${name}": ${error.message}`, error);
+        }
+        return deserializeSecretPayload(payload);
+    }
+    async delete(nameOrRef, options = {}, ...args) {
+        const { log } = (await this.logCtx(args, "delete", true)).for(this.delete);
+        const { name, namespace, version } = this.resolveReference(nameOrRef, options);
+        log.verbose(`Deleting secret ${name} from namespace ${namespace}`);
+        if (version) {
+            const secret = await this.readSecret(name, namespace);
+            this.assertVersion(secret, version);
+        }
+        try {
+            await this.client.deleteNamespacedSecret({ name, namespace });
+        }
+        catch (error) {
+            throw this.parseError(error);
+        }
+    }
+    async exists(nameOrRef, options = {}, ...args) {
+        const { log } = (await this.logCtx(args, "exists", true)).for(this.exists);
+        const { name, namespace, version } = this.resolveReference(nameOrRef, options);
+        log.verbose(`Checking if secret ${name} exists in namespace ${namespace}`);
+        try {
+            const secret = await this.readSecret(name, namespace);
+            this.assertVersion(secret, version);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof NotFoundError)
+                return false;
+            throw error;
+        }
+    }
+    async list(options = {}, ...args) {
+        const { log } = (await this.logCtx(args, "list", true)).for(this.list);
+        const namespace = this.resolveNamespaceOption(options.namespace);
+        log.verbose(`Listing secrets in namespace ${namespace}`);
+        const result = [];
+        let continueToken;
+        try {
+            do {
+                const response = await this.client.listNamespacedSecret({
+                    namespace,
+                    labelSelector: `${MANAGED_LABEL}=true`,
+                    limit: 100,
+                    _continue: continueToken,
+                });
+                for (const secret of response.items || []) {
+                    result.push(this.toMetadata(secret, namespace));
+                }
+                continueToken = response.metadata?._continue;
+            } while (continueToken);
+        }
+        catch (error) {
+            throw this.parseError(error);
+        }
+        const filtered = result.filter((meta) => {
+            if (options.enabled === false)
+                return false;
+            if (!options.tags)
+                return true;
+            return Object.entries(options.tags).every(([key, value]) => meta.tags?.[key] === value);
+        });
+        const offset = options.offset ?? 0;
+        const end = typeof options.limit === "number" ? offset + options.limit : undefined;
+        return filtered.slice(offset, end);
+    }
+    async metadata(nameOrRef, options = {}, ...args) {
+        const { log } = (await this.logCtx(args, "metadata", true)).for(this.metadata);
+        const { name, namespace, version } = this.resolveReference(nameOrRef, options);
+        log.verbose(`Getting metadata for secret ${name} in namespace ${namespace}`);
+        try {
+            const secret = await this.readSecret(name, namespace);
+            this.assertVersion(secret, version);
+            return this.toMetadata(secret, namespace);
+        }
+        catch (error) {
+            if (error instanceof NotFoundError)
+                return undefined;
+            throw error;
+        }
+    }
+    async rotate(nameOrRef, value, options = {}, ...args) {
+        const { name, namespace } = this.resolveReference(nameOrRef, options);
+        return this.store(name, value, { version: options.newVersion, namespace }, ...args);
+    }
+    buildKubeConfig(config) {
+        const kubeConfig = new KubeConfig();
+        try {
+            if (config.serviceAccount) {
+                kubeConfig.loadFromCluster();
+            }
+            else if (config.server) {
+                const clusterName = "decaf-cluster";
+                const userName = "decaf-user";
+                const contextName = "decaf-context";
+                kubeConfig.loadFromOptions({
+                    clusters: [
+                        {
+                            name: clusterName,
+                            server: config.server,
+                            caData: config.caData,
+                            caFile: config.caFile,
+                            skipTLSVerify: config.skipTLSVerify,
+                        },
+                    ],
+                    users: [
+                        {
+                            name: userName,
+                            token: config.token,
+                            tokenFile: config.tokenFile,
+                            certData: config.certData,
+                            certFile: config.certFile,
+                            keyData: config.keyData,
+                            keyFile: config.keyFile,
+                        },
+                    ],
+                    contexts: [
+                        {
+                            name: contextName,
+                            cluster: clusterName,
+                            user: userName,
+                            namespace: config.namespace,
+                        },
+                    ],
+                    currentContext: contextName,
+                });
+            }
+            else if (config.kubeconfig) {
+                kubeConfig.loadFromFile(config.kubeconfig);
+            }
+            else {
+                kubeConfig.loadFromDefault();
+            }
+            if (config.context) {
+                kubeConfig.setCurrentContext(config.context);
+            }
+        }
+        catch (error) {
+            throw this.parseError(error);
+        }
+        return kubeConfig;
+    }
+    resolveNamespace(config, kubeConfig) {
+        const namespace = config.namespace ||
+            kubeConfig.getContextObject(kubeConfig.getCurrentContext())?.namespace ||
+            "default";
+        assertKubernetesNamespace(namespace);
+        return namespace;
+    }
+    resolveNamespaceOption(namespace) {
+        const resolved = namespace || this.config.namespace || "default";
+        assertKubernetesNamespace(resolved);
+        return resolved;
+    }
+    resolveReference(nameOrRef, options) {
+        const name = typeof nameOrRef === "string" ? nameOrRef : nameOrRef.name;
+        const namespace = options.namespace ||
+            (typeof nameOrRef === "string" ? undefined : nameOrRef.namespace) ||
+            this.config.namespace ||
+            "default";
+        assertKubernetesNamespace(namespace);
+        const version = options.version ||
+            (typeof nameOrRef === "string" ? undefined : nameOrRef.version);
+        return { name: this.normalizeName(name), namespace, version };
+    }
+    normalizeName(name) {
+        try {
+            validateSecretName(name);
+        }
+        catch (error) {
+            throw this.parseError(error);
+        }
+        const normalizedName = normalizeSecretName(name);
+        assertKubernetesName(normalizedName);
+        return normalizedName;
+    }
+    buildSecret(name, namespace, serialized, options) {
+        const annotations = {
+            [ENCODING_ANNOTATION]: serialized.encoding,
+            [UPDATED_AT_ANNOTATION]: new Date().toISOString(),
+        };
+        if (options.contentType) {
+            annotations[CONTENT_TYPE_ANNOTATION] = options.contentType;
+        }
+        if (options.tags) {
+            annotations[TAGS_ANNOTATION] = JSON.stringify(options.tags);
+        }
+        if (options.version) {
+            annotations[VERSION_ANNOTATION] = options.version;
+        }
+        if (options.tenantId) {
+            annotations[TENANT_ANNOTATION] = options.tenantId;
+        }
+        if (options.orgUnitId) {
+            annotations[ORG_UNIT_ANNOTATION] = options.orgUnitId;
+        }
+        if (options.ownerPrincipalId) {
+            annotations[OWNER_ANNOTATION] = options.ownerPrincipalId;
+        }
+        return {
+            apiVersion: "v1",
+            kind: "Secret",
+            type: "Opaque",
+            metadata: {
+                name,
+                namespace,
+                labels: {
+                    [MANAGED_LABEL]: "true",
+                },
+                annotations,
+            },
+            stringData: {
+                [PAYLOAD_DATA_KEY]: JSON.stringify(serialized),
+            },
+        };
+    }
+    async readSecret(name, namespace) {
+        try {
+            return await this.client.readNamespacedSecret({ name, namespace });
+        }
+        catch (error) {
+            throw this.parseError(error);
+        }
+    }
+    assertVersion(secret, version) {
+        if (!version)
+            return;
+        const stored = secret.metadata?.annotations?.[VERSION_ANNOTATION];
+        if (stored !== version) {
+            throw new NotFoundError(`Secret "${secret.metadata?.name}" version "${version}" not found`);
+        }
+    }
+    toMetadata(secret, namespace) {
+        const annotations = secret.metadata?.annotations || {};
+        const updatedAt = annotations[UPDATED_AT_ANNOTATION];
+        const name = secret.metadata?.name || "";
+        return {
+            provider: this.provider,
+            name,
+            version: annotations[VERSION_ANNOTATION],
+            createdAt: toDate(secret.metadata?.creationTimestamp),
+            updatedAt: updatedAt
+                ? new Date(updatedAt)
+                : toDate(secret.metadata?.creationTimestamp),
+            enabled: true,
+            contentType: annotations[CONTENT_TYPE_ANNOTATION],
+            tags: parseTags(annotations[TAGS_ANNOTATION]),
+            externalId: secret.metadata?.uid,
+            uri: `kubernetes://${namespace}/${name}`,
+        };
+    }
+    statusOf(error) {
+        if (error instanceof ApiException)
+            return error.code;
+        const candidate = error;
+        if (typeof candidate?.code === "number")
+            return candidate.code;
+        if (typeof candidate?.statusCode === "number") {
+            return candidate.statusCode;
+        }
+        return undefined;
+    }
+    messageOf(error) {
+        const err = error;
+        return err?.body?.message || err?.body?.reason || err?.message || err?.name || "Unknown error";
+    }
+    parseError(error) {
+        if (error instanceof BaseError)
+            return error;
+        const status = this.statusOf(error);
+        const message = this.messageOf(error);
+        const lowerMessage = message.toLowerCase();
+        if (status === 404 ||
+            lowerMessage.includes("not found") ||
+            lowerMessage.includes("404")) {
+            return new NotFoundError(message);
+        }
+        if (status === 409 ||
+            lowerMessage.includes("already exists") ||
+            lowerMessage.includes("conflict") ||
+            lowerMessage.includes("409")) {
+            return new ConflictError(message);
+        }
+        if (status === 401 || lowerMessage.includes("unauthorized")) {
+            return new AuthorizationError(`Authentication failed: ${message}`);
+        }
+        if (status === 403 || lowerMessage.includes("forbidden")) {
+            return new AuthorizationError(`Permission denied: ${message}`);
+        }
+        if (status === 400 ||
+            status === 422 ||
+            lowerMessage.includes("bad request")) {
+            return new BadRequestError(message);
+        }
+        if (status === 429 || lowerMessage.includes("rate limit")) {
+            return new SecretError("SECRET_PROVIDER_RATE_LIMITED", `Rate limited: ${message}`, error);
+        }
+        if (status === undefined ||
+            (status !== undefined && status >= 500) ||
+            lowerMessage.includes("connection") ||
+            lowerMessage.includes("timeout") ||
+            lowerMessage.includes("unavailable")) {
+            return new SecretError("SECRET_PROVIDER_UNAVAILABLE", `Provider unavailable: ${message}`, error);
+        }
+        return new InternalError(message);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"KubernetesSecretService.js","sourceRoot":"","sources":["../../../../src/secrets/kubernetes/KubernetesSecretService.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ApiException,\n  CoreV1Api,\n  KubeConfig,\n  type V1Secret,\n} from \"@kubernetes/client-node\";\nimport { AuthorizationError, type MaybeContextualArg } from \"@decaf-ts/core\";\nimport {\n  ClientBasedSecretService,\n  SecretError,\n  SecretProvider,\n  SecretName,\n  SecretPayload,\n  SecretReference,\n  SecretMetadata,\n} from \"../../secrets/core\";\nimport {\n  StoreSecretOptions,\n  RetrieveSecretOptions,\n  DeleteSecretOptions,\n  ExistsSecretOptions,\n  ListSecretsOptions,\n  SecretMetadataOptions,\n  RotateSecretOptions,\n} from \"../../secrets/core\";\nimport { validateSecretName, normalizeSecretName } from \"../../secrets/core\";\nimport {\n  serializeSecretPayload,\n  deserializeSecretPayload,\n  type SerializedSecretPayload,\n} from \"../../secrets/core\";\nimport { KubernetesSecretServiceConfig } from \"./KubernetesSecretServiceConfig\";\nimport { KubernetesSecretEnvironment } from \"./KubernetesSecretEnvironment\";\nimport { envBoolean, envString } from \"../../shared/environmentValue\";\nimport {\n  BadRequestError,\n  BaseError,\n  ConflictError,\n  InternalError,\n  NotFoundError,\n} from \"@decaf-ts/db-decorators\";\n\nconst PAYLOAD_DATA_KEY = \"payload\";\nconst MANAGED_LABEL = \"decaf-ts.io/managed\";\nconst ANNOTATION_PREFIX = \"decaf-ts.io/\";\nconst ENCODING_ANNOTATION = `${ANNOTATION_PREFIX}encoding`;\nconst CONTENT_TYPE_ANNOTATION = `${ANNOTATION_PREFIX}content-type`;\nconst TAGS_ANNOTATION = `${ANNOTATION_PREFIX}tags`;\nconst VERSION_ANNOTATION = `${ANNOTATION_PREFIX}version`;\nconst UPDATED_AT_ANNOTATION = `${ANNOTATION_PREFIX}updated-at`;\nconst TENANT_ANNOTATION = `${ANNOTATION_PREFIX}tenant-id`;\nconst ORG_UNIT_ANNOTATION = `${ANNOTATION_PREFIX}org-unit-id`;\nconst OWNER_ANNOTATION = `${ANNOTATION_PREFIX}owner-principal-id`;\n\nconst DNS_SUBDOMAIN_PATTERN =\n  /^[a-z0-9]([-a-z0-9.]*[a-z0-9])?$/;\nconst DNS_LABEL_PATTERN = /^[a-z0-9]([-a-z0-9]*[a-z0-9])?$/;\n\nfunction assertKubernetesName(name: string): void {\n  if (name.length > 253 || !DNS_SUBDOMAIN_PATTERN.test(name)) {\n    throw new SecretError(\n      \"SECRET_INVALID_NAME\",\n      `Invalid Kubernetes secret name: \"${name}\". Names must be lowercase DNS-1123 subdomains (letters, digits, '-', and '.').`\n    );\n  }\n}\n\nfunction assertKubernetesNamespace(namespace: string): void {\n  if (namespace.length > 63 || !DNS_LABEL_PATTERN.test(namespace)) {\n    throw new SecretError(\n      \"SECRET_INVALID_NAME\",\n      `Invalid Kubernetes namespace: \"${namespace}\". Namespaces must be lowercase DNS-1123 labels.`\n    );\n  }\n}\n\nfunction toDate(value: Date | string | undefined): Date | undefined {\n  if (!value) return undefined;\n  const date = value instanceof Date ? value : new Date(value);\n  return Number.isNaN(date.getTime()) ? undefined : date;\n}\n\nfunction parseTags(raw: string | undefined): Record<string, string> | undefined {\n  if (!raw) return undefined;\n  try {\n    const parsed = JSON.parse(raw);\n    return parsed && typeof parsed === \"object\"\n      ? (parsed as Record<string, string>)\n      : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * @class KubernetesSecretService\n * @summary Native Kubernetes Secrets backend.\n * @description Implements the {@link SecretService} contract on top of\n * namespaced Kubernetes `Secret` objects. Each DECAF secret is stored as an\n * `Opaque` Secret whose `payload` data key holds the serialized\n * {@link SerializedSecretPayload} envelope, while encoding, content type, tags,\n * logical version, and ownership hints live in `decaf-ts.io/*` annotations.\n *\n * Authentication uses the standard Kubernetes client resolution order:\n * explicit `server` credentials, an explicit `kubeconfig` path, `KUBECONFIG`,\n * `~/.kube/config`, and finally the in-cluster service account.\n */\nexport class KubernetesSecretService extends ClientBasedSecretService<\n  CoreV1Api,\n  KubernetesSecretServiceConfig\n> {\n  readonly provider: SecretProvider = \"kubernetes\";\n\n  protected configFromEnvironment():\n    | KubernetesSecretServiceConfig\n    | undefined {\n    const env = KubernetesSecretEnvironment.secrets.kubernetes;\n    const namespace = envString(env?.namespace);\n    const kubeconfig = envString(env?.kubeconfig);\n    const context = envString(env?.context);\n    const server = envString(env?.server);\n    if (!namespace && !kubeconfig && !context && !server) return undefined;\n    return {\n      provider: \"kubernetes\",\n      namespace,\n      kubeconfig,\n      context,\n      server,\n      token: envString(env.token),\n      tokenFile: envString(env.tokenFile),\n      caFile: envString(env.caFile),\n      caData: envString(env.caData),\n      certFile: envString(env.certFile),\n      keyFile: envString(env.keyFile),\n      certData: envString(env.certData),\n      keyData: envString(env.keyData),\n      skipTLSVerify: envBoolean(env.skipTLSVerify),\n      serviceAccount: envBoolean(env.serviceAccount),\n    };\n  }\n\n  async initialize(\n    ...args: MaybeContextualArg<any>\n  ): Promise<{ config: KubernetesSecretServiceConfig; client: CoreV1Api }> {\n    const { log } = (await this.logCtx(args, \"initialize\", true)).for(\n      this.initialize\n    );\n    const config =\n      this.getConfigFromArgs<KubernetesSecretServiceConfig>(...args);\n    const kubeConfig = this.buildKubeConfig(config);\n    const namespace = this.resolveNamespace(config, kubeConfig);\n    const resolved: KubernetesSecretServiceConfig = { ...config, namespace };\n    const client = kubeConfig.makeApiClient(CoreV1Api);\n    this._config = resolved;\n    this._client = client;\n    log.verbose(\n      `Initialized Kubernetes secret service for namespace \"${namespace}\"`\n    );\n    return { config: resolved, client };\n  }\n\n  async store<T extends SecretPayload = SecretPayload>(\n    name: SecretName,\n    value: T,\n    options: StoreSecretOptions = {},\n    ...args: MaybeContextualArg<any>\n  ): Promise<SecretReference> {\n    const { log } = (await this.logCtx(args, \"store\", true)).for(this.store);\n    const normalizedName = this.normalizeName(name);\n    const namespace = this.resolveNamespaceOption(options.namespace);\n    log.verbose(`Storing secret ${normalizedName} in namespace ${namespace}`);\n\n    const serialized = serializeSecretPayload(value);\n    const body = this.buildSecret(normalizedName, namespace, serialized, options);\n\n    try {\n      await this.client.createNamespacedSecret({ namespace, body });\n    } catch (error) {\n      if (this.statusOf(error) === 409) {\n        try {\n          const existing = await this.client.readNamespacedSecret({\n            name: normalizedName,\n            namespace,\n          });\n          body.metadata = {\n            ...(body.metadata || {}),\n            resourceVersion: existing.metadata?.resourceVersion,\n          };\n          await this.client.replaceNamespacedSecret({\n            name: normalizedName,\n            namespace,\n            body,\n          });\n        } catch (replaceError) {\n          throw this.parseError(replaceError);\n        }\n      } else {\n        throw this.parseError(error);\n      }\n    }\n\n    return {\n      provider: this.provider,\n      name: normalizedName,\n      namespace,\n      version: options.version,\n      uri: `kubernetes://${namespace}/${normalizedName}`,\n    };\n  }\n\n  async retrieve<T extends SecretPayload = SecretPayload>(\n    nameOrRef: SecretName | SecretReference,\n    options: RetrieveSecretOptions = {},\n    ...args: MaybeContextualArg<any>\n  ): Promise<T> {\n    const { log } = (await this.logCtx(args, \"retrieve\", true)).for(\n      this.retrieve\n    );\n    const { name, namespace, version } = this.resolveReference(\n      nameOrRef,\n      options\n    );\n    log.verbose(`Retrieving secret ${name} from namespace ${namespace}`);\n\n    const secret = await this.readSecret(name, namespace);\n    this.assertVersion(secret, version);\n\n    const raw = secret.data?.[PAYLOAD_DATA_KEY];\n    if (!raw) {\n      throw new NotFoundError(\n        `No secret value found for \"${name}\" in namespace \"${namespace}\"`\n      );\n    }\n\n    let payload: SerializedSecretPayload;\n    try {\n      payload = JSON.parse(\n        Buffer.from(raw, \"base64\").toString(\"utf8\")\n      ) as SerializedSecretPayload;\n    } catch (error) {\n      throw new SecretError(\n        \"SECRET_DESERIALIZATION_FAILED\",\n        `Failed to parse secret payload for \"${name}\": ${(error as Error).message}`,\n        error as Error\n      );\n    }\n\n    return deserializeSecretPayload(payload) as T;\n  }\n\n  async delete(\n    nameOrRef: SecretName | SecretReference,\n    options: DeleteSecretOptions = {},\n    ...args: MaybeContextualArg<any>\n  ): Promise<void> {\n    const { log } = (await this.logCtx(args, \"delete\", true)).for(this.delete);\n    const { name, namespace, version } = this.resolveReference(\n      nameOrRef,\n      options\n    );\n    log.verbose(`Deleting secret ${name} from namespace ${namespace}`);\n\n    if (version) {\n      const secret = await this.readSecret(name, namespace);\n      this.assertVersion(secret, version);\n    }\n\n    try {\n      await this.client.deleteNamespacedSecret({ name, namespace });\n    } catch (error) {\n      throw this.parseError(error);\n    }\n  }\n\n  async exists(\n    nameOrRef: SecretName | SecretReference,\n    options: ExistsSecretOptions = {},\n    ...args: MaybeContextualArg<any>\n  ): Promise<boolean> {\n    const { log } = (await this.logCtx(args, \"exists\", true)).for(this.exists);\n    const { name, namespace, version } = this.resolveReference(\n      nameOrRef,\n      options\n    );\n    log.verbose(`Checking if secret ${name} exists in namespace ${namespace}`);\n\n    try {\n      const secret = await this.readSecret(name, namespace);\n      this.assertVersion(secret, version);\n      return true;\n    } catch (error) {\n      if (error instanceof NotFoundError) return false;\n      throw error;\n    }\n  }\n\n  async list(\n    options: ListSecretsOptions = {},\n    ...args: MaybeContextualArg<any>\n  ): Promise<SecretMetadata[]> {\n    const { log } = (await this.logCtx(args, \"list\", true)).for(this.list);\n    const namespace = this.resolveNamespaceOption(options.namespace);\n    log.verbose(`Listing secrets in namespace ${namespace}`);\n\n    const result: SecretMetadata[] = [];\n    let continueToken: string | undefined;\n\n    try {\n      do {\n        const response = await this.client.listNamespacedSecret({\n          namespace,\n          labelSelector: `${MANAGED_LABEL}=true`,\n          limit: 100,\n          _continue: continueToken,\n        });\n\n        for (const secret of response.items || []) {\n          result.push(this.toMetadata(secret, namespace));\n        }\n\n        continueToken = response.metadata?._continue;\n      } while (continueToken);\n    } catch (error) {\n      throw this.parseError(error);\n    }\n\n    const filtered = result.filter((meta) => {\n      if (options.enabled === false) return false;\n      if (!options.tags) return true;\n      return Object.entries(options.tags).every(\n        ([key, value]) => meta.tags?.[key] === value\n      );\n    });\n\n    const offset = options.offset ?? 0;\n    const end =\n      typeof options.limit === \"number\" ? offset + options.limit : undefined;\n    return filtered.slice(offset, end);\n  }\n\n  async metadata(\n    nameOrRef: SecretName | SecretReference,\n    options: SecretMetadataOptions = {},\n    ...args: MaybeContextualArg<any>\n  ): Promise<SecretMetadata | undefined> {\n    const { log } = (await this.logCtx(args, \"metadata\", true)).for(\n      this.metadata\n    );\n    const { name, namespace, version } = this.resolveReference(\n      nameOrRef,\n      options\n    );\n    log.verbose(`Getting metadata for secret ${name} in namespace ${namespace}`);\n\n    try {\n      const secret = await this.readSecret(name, namespace);\n      this.assertVersion(secret, version);\n      return this.toMetadata(secret, namespace);\n    } catch (error) {\n      if (error instanceof NotFoundError) return undefined;\n      throw error;\n    }\n  }\n\n  async rotate<T extends SecretPayload = SecretPayload>(\n    nameOrRef: SecretName | SecretReference,\n    value: T,\n    options: RotateSecretOptions = {},\n    ...args: MaybeContextualArg<any>\n  ): Promise<SecretReference> {\n    const { name, namespace } = this.resolveReference(nameOrRef, options);\n    return this.store(\n      name,\n      value,\n      { version: options.newVersion, namespace },\n      ...args\n    );\n  }\n\n  private buildKubeConfig(config: KubernetesSecretServiceConfig): KubeConfig {\n    const kubeConfig = new KubeConfig();\n    try {\n      if (config.serviceAccount) {\n        kubeConfig.loadFromCluster();\n      } else if (config.server) {\n        const clusterName = \"decaf-cluster\";\n        const userName = \"decaf-user\";\n        const contextName = \"decaf-context\";\n        kubeConfig.loadFromOptions({\n          clusters: [\n            {\n              name: clusterName,\n              server: config.server,\n              caData: config.caData,\n              caFile: config.caFile,\n              skipTLSVerify: config.skipTLSVerify,\n            },\n          ],\n          users: [\n            {\n              name: userName,\n              token: config.token,\n              tokenFile: config.tokenFile,\n              certData: config.certData,\n              certFile: config.certFile,\n              keyData: config.keyData,\n              keyFile: config.keyFile,\n            },\n          ],\n          contexts: [\n            {\n              name: contextName,\n              cluster: clusterName,\n              user: userName,\n              namespace: config.namespace,\n            },\n          ],\n          currentContext: contextName,\n        });\n      } else if (config.kubeconfig) {\n        kubeConfig.loadFromFile(config.kubeconfig);\n      } else {\n        kubeConfig.loadFromDefault();\n      }\n\n      if (config.context) {\n        kubeConfig.setCurrentContext(config.context);\n      }\n    } catch (error) {\n      throw this.parseError(error);\n    }\n    return kubeConfig;\n  }\n\n  private resolveNamespace(\n    config: KubernetesSecretServiceConfig,\n    kubeConfig: KubeConfig\n  ): string {\n    const namespace =\n      config.namespace ||\n      kubeConfig.getContextObject(kubeConfig.getCurrentContext())?.namespace ||\n      \"default\";\n    assertKubernetesNamespace(namespace);\n    return namespace;\n  }\n\n  private resolveNamespaceOption(namespace?: string): string {\n    const resolved = namespace || this.config.namespace || \"default\";\n    assertKubernetesNamespace(resolved);\n    return resolved;\n  }\n\n  private resolveReference(\n    nameOrRef: SecretName | SecretReference,\n    options: {\n      namespace?: string;\n      version?: string;\n    }\n  ): { name: string; namespace: string; version?: string } {\n    const name =\n      typeof nameOrRef === \"string\" ? nameOrRef : nameOrRef.name;\n    const namespace =\n      options.namespace ||\n      (typeof nameOrRef === \"string\" ? undefined : nameOrRef.namespace) ||\n      this.config.namespace ||\n      \"default\";\n    assertKubernetesNamespace(namespace);\n    const version =\n      options.version ||\n      (typeof nameOrRef === \"string\" ? undefined : nameOrRef.version);\n    return { name: this.normalizeName(name), namespace, version };\n  }\n\n  private normalizeName(name: string): string {\n    try {\n      validateSecretName(name);\n    } catch (error) {\n      throw this.parseError(error as Error);\n    }\n    const normalizedName = normalizeSecretName(name);\n    assertKubernetesName(normalizedName);\n    return normalizedName;\n  }\n\n  private buildSecret(\n    name: string,\n    namespace: string,\n    serialized: SerializedSecretPayload,\n    options: StoreSecretOptions\n  ): V1Secret {\n    const annotations: Record<string, string> = {\n      [ENCODING_ANNOTATION]: serialized.encoding,\n      [UPDATED_AT_ANNOTATION]: new Date().toISOString(),\n    };\n\n    if (options.contentType) {\n      annotations[CONTENT_TYPE_ANNOTATION] = options.contentType;\n    }\n    if (options.tags) {\n      annotations[TAGS_ANNOTATION] = JSON.stringify(options.tags);\n    }\n    if (options.version) {\n      annotations[VERSION_ANNOTATION] = options.version;\n    }\n    if (options.tenantId) {\n      annotations[TENANT_ANNOTATION] = options.tenantId;\n    }\n    if (options.orgUnitId) {\n      annotations[ORG_UNIT_ANNOTATION] = options.orgUnitId;\n    }\n    if (options.ownerPrincipalId) {\n      annotations[OWNER_ANNOTATION] = options.ownerPrincipalId;\n    }\n\n    return {\n      apiVersion: \"v1\",\n      kind: \"Secret\",\n      type: \"Opaque\",\n      metadata: {\n        name,\n        namespace,\n        labels: {\n          [MANAGED_LABEL]: \"true\",\n        },\n        annotations,\n      },\n      stringData: {\n        [PAYLOAD_DATA_KEY]: JSON.stringify(serialized),\n      },\n    };\n  }\n\n  private async readSecret(\n    name: string,\n    namespace: string\n  ): Promise<V1Secret> {\n    try {\n      return await this.client.readNamespacedSecret({ name, namespace });\n    } catch (error) {\n      throw this.parseError(error);\n    }\n  }\n\n  private assertVersion(secret: V1Secret, version?: string): void {\n    if (!version) return;\n    const stored = secret.metadata?.annotations?.[VERSION_ANNOTATION];\n    if (stored !== version) {\n      throw new NotFoundError(\n        `Secret \"${secret.metadata?.name}\" version \"${version}\" not found`\n      );\n    }\n  }\n\n  private toMetadata(secret: V1Secret, namespace: string): SecretMetadata {\n    const annotations = secret.metadata?.annotations || {};\n    const updatedAt = annotations[UPDATED_AT_ANNOTATION];\n    const name = secret.metadata?.name || \"\";\n    return {\n      provider: this.provider,\n      name,\n      version: annotations[VERSION_ANNOTATION],\n      createdAt: toDate(secret.metadata?.creationTimestamp),\n      updatedAt: updatedAt\n        ? new Date(updatedAt)\n        : toDate(secret.metadata?.creationTimestamp),\n      enabled: true,\n      contentType: annotations[CONTENT_TYPE_ANNOTATION],\n      tags: parseTags(annotations[TAGS_ANNOTATION]),\n      externalId: secret.metadata?.uid,\n      uri: `kubernetes://${namespace}/${name}`,\n    };\n  }\n\n  private statusOf(error: unknown): number | undefined {\n    if (error instanceof ApiException) return error.code;\n    const candidate = error as { code?: unknown; statusCode?: unknown };\n    if (typeof candidate?.code === \"number\") return candidate.code;\n    if (typeof candidate?.statusCode === \"number\") {\n      return candidate.statusCode;\n    }\n    return undefined;\n  }\n\n  private messageOf(error: unknown): string {\n    const err = error as {\n      message?: string;\n      name?: string;\n      body?: { message?: string; reason?: string };\n    };\n    return err?.body?.message || err?.body?.reason || err?.message || err?.name || \"Unknown error\";\n  }\n\n  protected parseError(error: unknown): Error {\n    if (error instanceof BaseError) return error;\n    const status = this.statusOf(error);\n    const message = this.messageOf(error);\n    const lowerMessage = message.toLowerCase();\n\n    if (\n      status === 404 ||\n      lowerMessage.includes(\"not found\") ||\n      lowerMessage.includes(\"404\")\n    ) {\n      return new NotFoundError(message);\n    }\n\n    if (\n      status === 409 ||\n      lowerMessage.includes(\"already exists\") ||\n      lowerMessage.includes(\"conflict\") ||\n      lowerMessage.includes(\"409\")\n    ) {\n      return new ConflictError(message);\n    }\n\n    if (status === 401 || lowerMessage.includes(\"unauthorized\")) {\n      return new AuthorizationError(`Authentication failed: ${message}`);\n    }\n\n    if (status === 403 || lowerMessage.includes(\"forbidden\")) {\n      return new AuthorizationError(`Permission denied: ${message}`);\n    }\n\n    if (\n      status === 400 ||\n      status === 422 ||\n      lowerMessage.includes(\"bad request\")\n    ) {\n      return new BadRequestError(message);\n    }\n\n    if (status === 429 || lowerMessage.includes(\"rate limit\")) {\n      return new SecretError(\n        \"SECRET_PROVIDER_RATE_LIMITED\",\n        `Rate limited: ${message}`,\n        error as Error\n      );\n    }\n\n    if (\n      status === undefined ||\n      (status !== undefined && status >= 500) ||\n      lowerMessage.includes(\"connection\") ||\n      lowerMessage.includes(\"timeout\") ||\n      lowerMessage.includes(\"unavailable\")\n    ) {\n      return new SecretError(\n        \"SECRET_PROVIDER_UNAVAILABLE\",\n        `Provider unavailable: ${message}`,\n        error as Error\n      );\n    }\n\n    return new InternalError(message);\n  }\n}\n"]}

package/lib/esm/secrets/kubernetes/KubernetesSecretServiceConfig.js

@@ -0,0 +1,9 @@
+/**
+ * @module integrations/secrets/kubernetes/config
+ * @summary Kubernetes secret service configuration.
+ * @description Configuration schema for the native Kubernetes Secrets integration,
+ * including kubeconfig selection, explicit API-server credentials, and the
+ * default namespace used by every operation.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/secrets/kubernetes/index.js

@@ -0,0 +1,10 @@
+/**
+ * @module integrations/secrets/kubernetes
+ * @summary Kubernetes secret service exports.
+ * @description Re-exports the native Kubernetes Secrets service, its configuration,
+ * and its environment slice.
+ */
+export * from "./KubernetesSecretService.js";
+export * from "./KubernetesSecretServiceConfig.js";
+export * from "./KubernetesSecretEnvironment.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc2VjcmV0cy9rdWJlcm5ldGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7OztHQUtHO0FBRUgsNkNBQTBDO0FBQzFDLG1EQUFnRDtBQUNoRCxpREFBOEMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBtb2R1bGUgaW50ZWdyYXRpb25zL3NlY3JldHMva3ViZXJuZXRlc1xuICogQHN1bW1hcnkgS3ViZXJuZXRlcyBzZWNyZXQgc2VydmljZSBleHBvcnRzLlxuICogQGRlc2NyaXB0aW9uIFJlLWV4cG9ydHMgdGhlIG5hdGl2ZSBLdWJlcm5ldGVzIFNlY3JldHMgc2VydmljZSwgaXRzIGNvbmZpZ3VyYXRpb24sXG4gKiBhbmQgaXRzIGVudmlyb25tZW50IHNsaWNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gXCIuL0t1YmVybmV0ZXNTZWNyZXRTZXJ2aWNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9LdWJlcm5ldGVzU2VjcmV0U2VydmljZUNvbmZpZ1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vS3ViZXJuZXRlc1NlY3JldEVudmlyb25tZW50XCI7XG4iXX0=

package/lib/esm/secrets/model/ModelSecretCrypto.js

@@ -70,4 +70,4 @@ export function extractKeyFromDerivedKey(derivedKey) {
     const key = buffer.slice(16).toString("base64");
     return { salt, key };
 }
-//# sourceMappingURL=ModelSecretCrypto.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ModelSecretCrypto.js","sourceRoot":"","sources":["../../../../src/secrets/model/ModelSecretCrypto.ts"],"names":[],"mappings":"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","sourcesContent":["// @ts-expect-error - crypto is a peer dependency with exports field\nimport { getCrypto, getSubtle } from \"@decaf-ts/crypto/integration\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport type { SecretEncryptionMetadata } from \"./Secret\";\n\nconst ALGORITHM = { name: \"AES-GCM\", length: 256 };\nconst IV_LENGTH = 12;\n\nexport async function encryptPayload(\n  payload: string,\n  keyId: string,\n  key: string\n): Promise<{ encryptedData: string; metadata: SecretEncryptionMetadata }> {\n  try {\n    const crypto = (await getCrypto()) as any;\n    const subtle = await getSubtle();\n\n    const salt = crypto.randomBytes(IV_LENGTH);\n    const keyBuffer = Buffer.from(key, \"base64\");\n    const importedKey = await subtle.importKey(\n      \"raw\",\n      keyBuffer,\n      ALGORITHM,\n      false,\n      [\"encrypt\"]\n    );\n\n    const encoder = new TextEncoder();\n    const data = encoder.encode(payload);\n    const encryptedBuffer = await subtle.encrypt(\n      {\n        ...ALGORITHM,\n        iv: salt,\n      },\n      importedKey,\n      data\n    );\n\n    const encryptedBytes = new Uint8Array(encryptedBuffer);\n    const combined = new Uint8Array(IV_LENGTH + encryptedBytes.length);\n    combined.set(salt);\n    combined.set(encryptedBytes, IV_LENGTH);\n\n    return {\n      encryptedData: Buffer.from(combined).toString(\"base64\"),\n      metadata: {\n        keyId,\n        iv: salt.toString(\"base64\"),\n      },\n    };\n  } catch (error) {\n    throw new InternalError(\n      `Failed to encrypt payload: ${(error as Error).message}`\n    );\n  }\n}\n\nexport async function decryptPayload(\n  encryptedData: string,\n  key: string\n): Promise<string> {\n  try {\n    const subtle = await getSubtle();\n\n    const combined = Buffer.from(encryptedData, \"base64\");\n    const iv = combined.slice(0, IV_LENGTH);\n    const cipherText = combined.slice(IV_LENGTH);\n\n    const keyBuffer = Buffer.from(key, \"base64\");\n    const importedKey = await subtle.importKey(\n      \"raw\",\n      keyBuffer,\n      ALGORITHM,\n      false,\n      [\"decrypt\"]\n    );\n\n    const decryptedBuffer = await subtle.decrypt(\n      {\n        ...ALGORITHM,\n        iv: iv,\n      },\n      importedKey,\n      cipherText\n    );\n\n    const decoder = new TextDecoder();\n    return decoder.decode(decryptedBuffer);\n  } catch (error) {\n    throw new InternalError(\n      `Failed to decrypt payload: ${(error as Error).message}`\n    );\n  }\n}\n\nexport async function deriveKeyFromSecret(\n  secret: string,\n  salt?: string\n): Promise<string> {\n  try {\n    const crypto = (await getCrypto()) as any;\n    const saltBuffer = salt\n      ? Buffer.from(salt, \"base64\")\n      : crypto.randomBytes(16);\n    const key = crypto.pbkdf2Sync(secret, saltBuffer, 100_000, 32, \"sha256\");\n    return Buffer.concat([saltBuffer, key]).toString(\"base64\");\n  } catch (error) {\n    throw new InternalError(\n      `Failed to derive key: ${(error as Error).message}`\n    );\n  }\n}\n\nexport function extractKeyFromDerivedKey(derivedKey: string): {\n  salt: string;\n  key: string;\n} {\n  const buffer = Buffer.from(derivedKey, \"base64\");\n  const salt = buffer.slice(0, 16).toString(\"base64\");\n  const key = buffer.slice(16).toString(\"base64\");\n  return { salt, key };\n}\n"]}

package/lib/esm/secrets/model/ModelSecretEnvironment.js

@@ -14,4 +14,4 @@ export const ModelSecretEnvironment = SecretEnvironment.accumulate({
         },
     },
 });
-//# sourceMappingURL=ModelSecretEnvironment.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTW9kZWxTZWNyZXRFbnZpcm9ubWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9zZWNyZXRzL21vZGVsL01vZGVsU2VjcmV0RW52aXJvbm1lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBQ0gsT0FBTyxFQUFFLGlCQUFpQixFQUFFLHVDQUFrQztBQWE5RCxNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRyxpQkFBaUIsQ0FBQyxVQUFVLENBQUM7SUFDakUsT0FBTyxFQUFFO1FBQ1AsS0FBSyxFQUFFO1lBQ0wsU0FBUyxFQUFFLEVBQUU7WUFDYixLQUFLLEVBQUUsRUFBRTtTQUNWO0tBQ0Y7Q0FDNkIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9zZWNyZXRzL21vZGVsL2Vudmlyb25tZW50XG4gKiBAc3VtbWFyeSBNb2RlbC1iYWNrZWQgc2VjcmV0IGVudmlyb25tZW50LlxuICogQGRlc2NyaXB0aW9uIEV4dGVuZHMgdGhlIGNvbW1vbiBzZWNyZXRzIGVudmlyb25tZW50IHdpdGggdGhlIGBzZWNyZXRzLm1vZGVsYCBzaGFwZVxuICogbWF0Y2hpbmcge0BsaW5rIE1vZGVsU2VjcmV0U2VydmljZUNvbmZpZ30sIHNvIHtAbGluayBNb2RlbFNlY3JldFNlcnZpY2V9IGNhbiBmYWxsXG4gKiBiYWNrIHRvIGl0IHdoZW4gbm8gY29uZmlnIGlzIHBhc3NlZCB0byBgaW5pdGlhbGl6ZWAuXG4gKi9cbmltcG9ydCB7IFNlY3JldEVudmlyb25tZW50IH0gZnJvbSBcIi4uL2NvcmUvU2VjcmV0RW52aXJvbm1lbnRcIjtcblxuZXhwb3J0IGludGVyZmFjZSBNb2RlbFNlY3JldEVudmlyb25tZW50Q29uZmlnIHtcbiAga2V5U2VjcmV0OiBzdHJpbmc7XG4gIGtleUlkPzogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIE1vZGVsU2VjcmV0RW52aXJvbm1lbnRTaGFwZSB7XG4gIHNlY3JldHM6IHtcbiAgICBtb2RlbDogTW9kZWxTZWNyZXRFbnZpcm9ubWVudENvbmZpZztcbiAgfTtcbn1cblxuZXhwb3J0IGNvbnN0IE1vZGVsU2VjcmV0RW52aXJvbm1lbnQgPSBTZWNyZXRFbnZpcm9ubWVudC5hY2N1bXVsYXRlKHtcbiAgc2VjcmV0czoge1xuICAgIG1vZGVsOiB7XG4gICAgICBrZXlTZWNyZXQ6IFwiXCIsXG4gICAgICBrZXlJZDogXCJcIixcbiAgICB9LFxuICB9LFxufSBhcyBNb2RlbFNlY3JldEVudmlyb25tZW50U2hhcGUpO1xuIl19