@pipeline-builder/api-core 3.4.36 → 3.4.38

package/lib/utils/org-aws-credentials.js

@@ -0,0 +1,159 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrgAwsCredentialsManager = void 0;
+exports.resolveOrgCredentialsOnce = resolveOrgCredentialsOnce;
+exports.withOrgAwsCredentials = withOrgAwsCredentials;
+/**
+ * Per-process manager that resolves and caches per-org credential providers.
+ * One instance per service; share it across handlers.
+ */
+class OrgAwsCredentialsManager {
+    resolver;
+    fallbackOverride;
+    region;
+    endpoint;
+    cache = new Map();
+    inFlight = new Map();
+    /** Lazy default chain. Built once per manager so we don't import the
+     *  credential-providers SDK in test environments that never touch the
+     *  fallback path. */
+    fallbackCache;
+    constructor(opts) {
+        this.resolver = opts.resolver;
+        this.fallbackOverride = opts.fallback;
+        this.region = opts.region ?? process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION;
+        this.endpoint = opts.endpoint ?? process.env.AWS_STS_ENDPOINT;
+    }
+    /**
+     * Return an AwsCredentialIdentityProvider scoped to `orgId`. Pass the
+     * returned value into any SDK v3 client's `credentials` option.
+     *
+     * Concurrent first-touch callers share one resolver invocation; later
+     * calls hit the cache. The provider itself caches and refreshes
+     * AssumeRole-derived credentials internally.
+     */
+    async getCredentials(orgId) {
+        if (!orgId)
+            throw new Error('OrgAwsCredentialsManager.getCredentials requires a non-empty orgId');
+        const cached = this.cache.get(orgId);
+        if (cached)
+            return cached.provider;
+        let pending = this.inFlight.get(orgId);
+        if (!pending) {
+            pending = this.resolveAndBuild(orgId);
+            this.inFlight.set(orgId, pending);
+            void pending.finally(() => {
+                if (this.inFlight.get(orgId) === pending)
+                    this.inFlight.delete(orgId);
+            });
+        }
+        return pending;
+    }
+    /** Drop the cached provider for an org. Call after the operator rotates
+     *  the role ARN or external id so the next request rebuilds. */
+    evict(orgId) {
+        this.cache.delete(orgId);
+    }
+    /** Drop every cached provider. Useful in tests; rarely in production. */
+    evictAll() {
+        this.cache.clear();
+    }
+    async resolveAndBuild(orgId) {
+        const cfg = await this.resolver(orgId);
+        if (!cfg || !cfg.assumeRoleArn) {
+            const fallback = await this.getFallback();
+            this.cache.set(orgId, { fingerprint: 'fallback', provider: fallback });
+            return fallback;
+        }
+        const provider = await this.buildAssumeRoleProvider(orgId, cfg);
+        this.cache.set(orgId, { fingerprint: fingerprintConfig(cfg), provider });
+        return provider;
+    }
+    async getFallback() {
+        if (this.fallbackOverride)
+            return this.fallbackOverride;
+        if (this.fallbackCache)
+            return this.fallbackCache;
+        // Lazy-import so test envs that supply their own resolver/fallback
+        // don't load the credential-providers SDK.
+        const { fromNodeProviderChain } = await import('@aws-sdk/credential-providers');
+        this.fallbackCache = fromNodeProviderChain();
+        return this.fallbackCache;
+    }
+    async buildAssumeRoleProvider(orgId, cfg) {
+        // Dynamic imports — STS + credential-providers are heavyweight and
+        // services that never have per-org roles configured shouldn't load them.
+        const [{ STSClient }, { fromTemporaryCredentials }] = await Promise.all([
+            import('@aws-sdk/client-sts'),
+            import('@aws-sdk/credential-providers'),
+        ]);
+        const masterCredentials = this.fallbackOverride ?? (await this.getFallback());
+        const sessionName = cfg.roleSessionName ?? `pipeline-builder-${orgId}`.slice(0, 64);
+        const region = cfg.region ?? this.region;
+        return fromTemporaryCredentials({
+            // Inner STS client uses the service's own credentials (the fallback
+            // chain). Those creds need `sts:AssumeRole` on the org's role.
+            masterCredentials,
+            clientConfig: {
+                region,
+                ...(this.endpoint ? { endpoint: this.endpoint } : {}),
+                // Cast to satisfy fromTemporaryCredentials' typing; STSClient
+                // matches the structural client shape it expects.
+            },
+            params: {
+                RoleArn: cfg.assumeRoleArn,
+                RoleSessionName: sessionName,
+                DurationSeconds: cfg.sessionDurationSeconds ?? 3600,
+                ...(cfg.externalId ? { ExternalId: cfg.externalId } : {}),
+            },
+        });
+    }
+}
+exports.OrgAwsCredentialsManager = OrgAwsCredentialsManager;
+/**
+ * Deterministic fingerprint of a config. Used by `getCredentials` to
+ * detect "the cache is stale because the operator changed the config" —
+ * not exposed publicly, just defense in depth against a missed `evict`.
+ */
+function fingerprintConfig(cfg) {
+    return [
+        cfg.assumeRoleArn,
+        cfg.externalId ?? '',
+        cfg.region ?? '',
+        cfg.sessionDurationSeconds ?? '',
+        cfg.roleSessionName ?? '',
+    ].join('|');
+}
+/** Convenience: directly resolve credentials for a single call. The manager
+ *  doesn't cache when called this way — useful in CLIs / one-shot scripts. */
+async function resolveOrgCredentialsOnce(orgId, resolver) {
+    const manager = new OrgAwsCredentialsManager({ resolver });
+    const provider = await manager.getCredentials(orgId);
+    return provider();
+}
+/**
+ * Adapter: resolve per-org credentials and construct an AWS SDK client
+ * pre-bound to them. The factory is async because credential resolution may
+ * need to make a network call (fetching org config + AssumeRole). Once
+ * resolved, the returned client is ready for normal SDK calls; the provider
+ * inside refreshes credentials automatically before they expire.
+ *
+ * Typical usage:
+ *   ```ts
+ *   const s3 = await withOrgAwsCredentials(manager, orgId, (creds) =>
+ *     new S3Client({ credentials: creds, region: 'us-west-2' }));
+ *   await s3.send(new ListObjectsV2Command({ Bucket: bucketFor(orgId) }));
+ *   ```
+ *
+ * The factory is invoked exactly once per call — callers that need a
+ * long-lived client should cache the result themselves rather than rebuilding
+ * on every operation. (Re-resolving on every op is fine for cold paths and
+ * a wasted couple of object allocations on hot paths.)
+ */
+async function withOrgAwsCredentials(manager, orgId, factory) {
+    const credentials = await manager.getCredentials(orgId);
+    return factory(credentials);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org-aws-credentials.js","sourceRoot":"","sources":["../../src/utils/org-aws-credentials.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Per-org IAM role assumption for build / runtime AWS API calls.\n *\n * The shared posture for AWS calls today is \"the service's IAM role, full\n * blast radius across every org.\" The operator-side mitigation operators\n * actually want is: each customer org gets its own IAM role in its own\n * account; build/runtime AWS calls for that org `sts:AssumeRole` into the\n * customer's role; a compromise of one org's role can't enumerate another\n * org's S3 buckets / ECR repos.\n *\n * This module is the credential-provider primitive. It's pluggable on the\n * org-config resolver so the same code path works whether config is read\n * from Mongo, Postgres, or env vars. Callers receive a standard SDK v3\n * `AwsCredentialIdentityProvider` and pass it to any SDK client\n * (`new CodeBuildClient({ credentials })`, etc.).\n *\n * No global state — callers construct one `OrgAwsCredentialsManager` per\n * process and `await manager.getCredentials(orgId)` before each AWS call.\n * The returned provider handles credential refresh internally (the\n * underlying `fromTemporaryCredentials` re-calls AssumeRole ~5 min before\n * the temporary credentials expire), so call sites don't manage TTL.\n *\n * Safety properties:\n *  - `externalId` is plumbed through to AssumeRole. Operators bake this\n *    into the IAM trust policy as the \"confused deputy\" mitigation; this\n *    module never silently omits it.\n *  - Orgs without a configured role fall through to the supplied\n *    `fallback` provider (typically the SDK default chain). Mixed-mode\n *    deployments where some orgs have per-org roles and others use the\n *    shared role are explicitly supported.\n *  - `evict(orgId)` drops the cached provider so the next call re-resolves\n *    from the resolver — use after the operator changes an org's role.\n *\n * Integration pattern for AWS SDK clients:\n *\n *   ```ts\n *   import { S3Client } from '@aws-sdk/client-s3';\n *   import { withOrgAwsCredentials } from '@pipeline-builder/api-core';\n *\n *   const manager = new OrgAwsCredentialsManager({ resolver });\n *\n *   async function s3ForOrg(orgId: string) {\n *     return withOrgAwsCredentials(manager, orgId, (creds) =>\n *       new S3Client({ credentials: creds, region: 'us-west-2' }));\n *   }\n *   ```\n *\n * Today's codebase: no platform-side service makes AWS API calls scoped to\n * a customer org (build runners use buildkitd; AWS Lambda handlers run in\n * customer territory with their own IAM). This primitive is in place for\n * when the architecture grows to add such call sites — per-org S3 buckets,\n * per-org ECR repos, per-org CodeBuild projects — without forcing an\n * insecure default.\n */\n\n/** Structural shape of an AWS credential. Matches `@smithy/types#AwsCredentialIdentity`\n *  exactly — defined locally so api-core doesn't need to declare @smithy/types\n *  as a direct dep (it's a transitive of every AWS SDK client we use). */\nexport interface AwsCredentialIdentity {\n  accessKeyId: string;\n  secretAccessKey: string;\n  sessionToken?: string;\n  expiration?: Date;\n  credentialScope?: string;\n  accountId?: string;\n}\n\n/** Standard credential-provider callable. Matches `@smithy/types#AwsCredentialIdentityProvider`. */\nexport type AwsCredentialIdentityProvider = () => Promise<AwsCredentialIdentity>;\n\n/** Operator-supplied per-org IAM role + region pinning. */\nexport interface OrgAwsConfig {\n  /** ARN of the role this org's build/runtime code should assume. */\n  assumeRoleArn: string;\n  /** External id baked into the role's trust policy (recommended). */\n  externalId?: string;\n  /** Region to use when the calling code doesn't pin one. */\n  region?: string;\n  /** AssumeRole session duration (seconds). AWS allows 900-43200; the\n   *  effective ceiling is the role's `MaxSessionDuration`. Default 3600. */\n  sessionDurationSeconds?: number;\n  /** Session name embedded in CloudTrail. Useful for incident-response\n   *  attribution. Default `pipeline-builder-<orgId>`. */\n  roleSessionName?: string;\n}\n\n/** Async resolver: orgId → config | null. Returning null means \"this org\n *  has no per-org role; use the fallback provider.\" */\nexport type OrgAwsConfigResolver = (orgId: string) => Promise<OrgAwsConfig | null>;\n\n/** Constructor options. */\nexport interface OrgAwsCredentialsManagerOptions {\n  resolver: OrgAwsConfigResolver;\n  /** Provider used for orgs whose resolver returns null. Default: the SDK\n   *  default chain via `@aws-sdk/credential-providers#fromNodeProviderChain`. */\n  fallback?: AwsCredentialIdentityProvider;\n  /** Region passed to the inner STS client when the org config doesn't\n   *  pin one. Default: `AWS_REGION` / `AWS_DEFAULT_REGION` env. */\n  region?: string;\n  /** STS endpoint override (LocalStack, VPC endpoint). Default: SDK default. */\n  endpoint?: string;\n}\n\ninterface CacheEntry {\n  /** Stable identity of the config we built this entry from. Lets `get`\n   *  detect that the operator changed the config and we should re-build\n   *  rather than serve a stale provider. */\n  fingerprint: string;\n  provider: AwsCredentialIdentityProvider;\n}\n\n/**\n * Per-process manager that resolves and caches per-org credential providers.\n * One instance per service; share it across handlers.\n */\nexport class OrgAwsCredentialsManager {\n  private readonly resolver: OrgAwsConfigResolver;\n  private readonly fallbackOverride?: AwsCredentialIdentityProvider;\n  private readonly region?: string;\n  private readonly endpoint?: string;\n  private readonly cache = new Map<string, CacheEntry>();\n  private readonly inFlight = new Map<string, Promise<AwsCredentialIdentityProvider>>();\n  /** Lazy default chain. Built once per manager so we don't import the\n   *  credential-providers SDK in test environments that never touch the\n   *  fallback path. */\n  private fallbackCache?: AwsCredentialIdentityProvider;\n\n  constructor(opts: OrgAwsCredentialsManagerOptions) {\n    this.resolver = opts.resolver;\n    this.fallbackOverride = opts.fallback;\n    this.region = opts.region ?? process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION;\n    this.endpoint = opts.endpoint ?? process.env.AWS_STS_ENDPOINT;\n  }\n\n  /**\n   * Return an AwsCredentialIdentityProvider scoped to `orgId`. Pass the\n   * returned value into any SDK v3 client's `credentials` option.\n   *\n   * Concurrent first-touch callers share one resolver invocation; later\n   * calls hit the cache. The provider itself caches and refreshes\n   * AssumeRole-derived credentials internally.\n   */\n  async getCredentials(orgId: string): Promise<AwsCredentialIdentityProvider> {\n    if (!orgId) throw new Error('OrgAwsCredentialsManager.getCredentials requires a non-empty orgId');\n\n    const cached = this.cache.get(orgId);\n    if (cached) return cached.provider;\n\n    let pending = this.inFlight.get(orgId);\n    if (!pending) {\n      pending = this.resolveAndBuild(orgId);\n      this.inFlight.set(orgId, pending);\n      void pending.finally(() => {\n        if (this.inFlight.get(orgId) === pending) this.inFlight.delete(orgId);\n      });\n    }\n    return pending;\n  }\n\n  /** Drop the cached provider for an org. Call after the operator rotates\n   *  the role ARN or external id so the next request rebuilds. */\n  evict(orgId: string): void {\n    this.cache.delete(orgId);\n  }\n\n  /** Drop every cached provider. Useful in tests; rarely in production. */\n  evictAll(): void {\n    this.cache.clear();\n  }\n\n  private async resolveAndBuild(orgId: string): Promise<AwsCredentialIdentityProvider> {\n    const cfg = await this.resolver(orgId);\n    if (!cfg || !cfg.assumeRoleArn) {\n      const fallback = await this.getFallback();\n      this.cache.set(orgId, { fingerprint: 'fallback', provider: fallback });\n      return fallback;\n    }\n\n    const provider = await this.buildAssumeRoleProvider(orgId, cfg);\n    this.cache.set(orgId, { fingerprint: fingerprintConfig(cfg), provider });\n    return provider;\n  }\n\n  private async getFallback(): Promise<AwsCredentialIdentityProvider> {\n    if (this.fallbackOverride) return this.fallbackOverride;\n    if (this.fallbackCache) return this.fallbackCache;\n    // Lazy-import so test envs that supply their own resolver/fallback\n    // don't load the credential-providers SDK.\n    const { fromNodeProviderChain } = await import('@aws-sdk/credential-providers');\n    this.fallbackCache = fromNodeProviderChain();\n    return this.fallbackCache;\n  }\n\n  private async buildAssumeRoleProvider(orgId: string, cfg: OrgAwsConfig): Promise<AwsCredentialIdentityProvider> {\n    // Dynamic imports — STS + credential-providers are heavyweight and\n    // services that never have per-org roles configured shouldn't load them.\n    const [{ STSClient }, { fromTemporaryCredentials }] = await Promise.all([\n      import('@aws-sdk/client-sts'),\n      import('@aws-sdk/credential-providers'),\n    ]);\n\n    const masterCredentials = this.fallbackOverride ?? (await this.getFallback());\n\n    const sessionName = cfg.roleSessionName ?? `pipeline-builder-${orgId}`.slice(0, 64);\n    const region = cfg.region ?? this.region;\n\n    return fromTemporaryCredentials({\n      // Inner STS client uses the service's own credentials (the fallback\n      // chain). Those creds need `sts:AssumeRole` on the org's role.\n      masterCredentials,\n      clientConfig: {\n        region,\n        ...(this.endpoint ? { endpoint: this.endpoint } : {}),\n        // Cast to satisfy fromTemporaryCredentials' typing; STSClient\n        // matches the structural client shape it expects.\n      } as unknown as ConstructorParameters<typeof STSClient>[0],\n      params: {\n        RoleArn: cfg.assumeRoleArn,\n        RoleSessionName: sessionName,\n        DurationSeconds: cfg.sessionDurationSeconds ?? 3600,\n        ...(cfg.externalId ? { ExternalId: cfg.externalId } : {}),\n      },\n    });\n  }\n}\n\n/**\n * Deterministic fingerprint of a config. Used by `getCredentials` to\n * detect \"the cache is stale because the operator changed the config\" —\n * not exposed publicly, just defense in depth against a missed `evict`.\n */\nfunction fingerprintConfig(cfg: OrgAwsConfig): string {\n  return [\n    cfg.assumeRoleArn,\n    cfg.externalId ?? '',\n    cfg.region ?? '',\n    cfg.sessionDurationSeconds ?? '',\n    cfg.roleSessionName ?? '',\n  ].join('|');\n}\n\n/** Convenience: directly resolve credentials for a single call. The manager\n *  doesn't cache when called this way — useful in CLIs / one-shot scripts. */\nexport async function resolveOrgCredentialsOnce(\n  orgId: string,\n  resolver: OrgAwsConfigResolver,\n): Promise<AwsCredentialIdentity> {\n  const manager = new OrgAwsCredentialsManager({ resolver });\n  const provider = await manager.getCredentials(orgId);\n  return provider();\n}\n\n/**\n * Adapter: resolve per-org credentials and construct an AWS SDK client\n * pre-bound to them. The factory is async because credential resolution may\n * need to make a network call (fetching org config + AssumeRole). Once\n * resolved, the returned client is ready for normal SDK calls; the provider\n * inside refreshes credentials automatically before they expire.\n *\n * Typical usage:\n *   ```ts\n *   const s3 = await withOrgAwsCredentials(manager, orgId, (creds) =>\n *     new S3Client({ credentials: creds, region: 'us-west-2' }));\n *   await s3.send(new ListObjectsV2Command({ Bucket: bucketFor(orgId) }));\n *   ```\n *\n * The factory is invoked exactly once per call — callers that need a\n * long-lived client should cache the result themselves rather than rebuilding\n * on every operation. (Re-resolving on every op is fine for cold paths and\n * a wasted couple of object allocations on hot paths.)\n */\nexport async function withOrgAwsCredentials<TClient>(\n  manager: OrgAwsCredentialsManager,\n  orgId: string,\n  factory: (credentials: AwsCredentialIdentityProvider) => TClient,\n): Promise<TClient> {\n  const credentials = await manager.getCredentials(orgId);\n  return factory(credentials);\n}\n"]}

package/lib/utils/secret-encryption.d.ts

@@ -0,0 +1,205 @@
+/** On-disk shape of an encrypted secret. JSON-serializable. */
+export interface EncryptedBlob {
+    /** Algorithm tag. Bump on format change so a future migration can detect old blobs. */
+    alg: 'aes-256-gcm-v1';
+    /** Base64-encoded 12-byte IV. */
+    iv: string;
+    /** Base64-encoded ciphertext + 16-byte authentication tag concatenated. */
+    ciphertext: string;
+    /** Optional key id  populated by KMS-backed providers, ignored by the env provider. */
+    kid?: string;
+}
+/** Pluggable key source. Env-backed by default; KMS-backed available. */
+export interface KeyProvider {
+    /** Derive a 32-byte symmetric key bound to `orgId`. */
+    deriveKey(orgId: string): Buffer;
+    /** Optional async variant for providers that need to do I/O (e.g.
+     *  per-org KMS lookup the first time an org is seen). Default
+     *  implementation forwards to the sync `deriveKey`. */
+    deriveKeyAsync?(orgId: string): Promise<Buffer>;
+    /** Optional KMS-key-id this provider used for `orgId`. Embedded in the
+     *  `EncryptedBlob.kid` field on write so decrypt can verify the right
+     *  KMS CMK is being used (defense against an attacker who swaps a blob
+     *  between orgs). Default returns undefined (env provider). */
+    kidFor?(orgId: string): string | undefined;
+}
+/**
+ * Default provider  derives a per-org key from `SECRET_ENCRYPTION_KEY` via
+ * HKDF-SHA256. Suitable for self-hosted / dev where operators don't have KMS.
+ *
+ * Fails fast if the env is missing or the key is the wrong length so misconfig
+ * surfaces at first use rather than silently fingerprinting all writes with
+ * a default zero key.
+ */
+export declare class EnvKeyProvider implements KeyProvider {
+    private readonly masterKey;
+    constructor(masterKeyOverride?: string);
+    deriveKey(orgId: string): Buffer;
+}
+/**
+ *  AWS-KMS-backed KeyProvider.
+ *
+ * Trade-off picked: store ONE master key encrypted under a KMS CMK; on
+ * first use, call `kms:Decrypt` to recover the master key bytes; HKDF-
+ * derive per-org from it (same as EnvKeyProvider). The process then holds
+ * the plaintext master key in memory until restart.
+ *
+ * PROS: one KMS call per process lifetime (cheap, low p99 impact),
+ * the encrypted-master-key blob is safe to commit/log/checkin,
+ * KMS audit log records when the master is recovered.
+ * CONS: process memory still holds the master key  same posture as
+ * EnvKeyProvider once warmed up. For stronger isolation an
+ * operator can move to per-record envelope encryption (call
+ * GenerateDataKey on every write); that's a follow-on.
+ *
+ * Operator setup * 1. Create a KMS CMK with key policy allowing the platform service's
+ * IAM role kms:Decrypt.
+ * 2. Generate a random 32-byte master * head -c 32 /dev/urandom | base64
+ * 3. Wrap it with KMS * aws kms encrypt --key-id <KEY_ID> \
+ * --plaintext <base64-from-step-2> --output text \
+ * --query CiphertextBlob
+ * 4. Set on the service * SECRET_ENCRYPTION_KMS_KEY_ID=<KEY_ID>
+ * SECRET_ENCRYPTION_KMS_CIPHERTEXT=<base64-output-of-step-3>
+ * 5. Pick this provider via `setKeyProvider(new KmsKeyProvider())`.
+ *
+ * Construct lazily  importing the AWS SDK has a non-trivial cold-start
+ * cost so envs that stay on EnvKeyProvider never load it.
+ */
+export declare class KmsKeyProvider implements KeyProvider {
+    private masterKeyCache;
+    private readonly keyId;
+    private readonly ciphertextB64;
+    private readonly region?;
+    private readonly endpoint?;
+    private decryptInFlight;
+    constructor(opts?: {
+        keyId?: string;
+        ciphertextBase64?: string;
+        region?: string;
+        endpoint?: string;
+    });
+    deriveKey(orgId: string): Buffer;
+    /**
+     * Eagerly recover the master key from KMS so subsequent `deriveKey`
+     * calls are sync. Idempotent  concurrent callers share the same in-
+     * flight promise so we don't spawn multiple KMS Decrypt requests at
+     * boot. Throws on any KMS failure; the caller (typically the service's
+     * onBeforeStart hook) decides whether to fall back to a different
+     * provider or fail-startup.
+     */
+    warmup(): Promise<void>;
+    private fetchAndDecrypt;
+}
+/** Read the active default provider. Exposed so service code (e.g. an
+ *  admin endpoint that just rotated an org's KMS config) can call
+ *  `provider.evict(orgId)` on the live provider rather than reconstructing
+ *  one. Triggers lazy initialization on first access, same as the internal
+ *  callers below. */
+export declare function getDefaultKeyProvider(): KeyProvider;
+/** Reset the cached default provider  for tests that mutate `process.env`. */
+export declare function resetDefaultKeyProvider(): void;
+/** Replace the default provider  services that opt into KMS call this
+ * once at startup with a warmed-up `KmsKeyProvider`. */
+export declare function setKeyProvider(provider: KeyProvider): void;
+/** Per-org KMS config the operator supplies. The `keyId` identifies the
+ *  KMS CMK to call Decrypt on; `ciphertextBase64` is the wrapped 32-byte
+ *  master generated by `aws kms encrypt` against that key. */
+export interface PerOrgKmsConfig {
+    keyId: string;
+    ciphertextBase64: string;
+}
+/**
+ * Async resolver that maps an org id to its KMS config. Returns `null` when
+ * the org has no per-org config — the provider then falls back to the
+ * `fallback` provider supplied at construction (usually an EnvKeyProvider
+ * or a default KmsKeyProvider).
+ */
+export type PerOrgKmsResolver = (orgId: string) => Promise<PerOrgKmsConfig | null>;
+/**
+ * Per-org KMS-backed KeyProvider. The blast radius of a KMS key compromise
+ * is one org instead of every org under a shared master.
+ *
+ * Each org has its own KMS CMK + its own wrapped master (stored in Mongo
+ * via the operator's setup script). On first encrypt/decrypt for an org,
+ * the provider:
+ *   1. Calls the resolver to fetch the org's KMS config.
+ *   2. Calls `kms:Decrypt` to recover the 32-byte master.
+ *   3. Caches the recovered master in-memory for the process lifetime.
+ *   4. HKDF-derives per-call from that master + the org id salt.
+ *
+ * Blobs encrypted by this provider carry `kid = <kms-key-id>` so the
+ * decrypt path detects a stale config (operator rotated the key but
+ * existing rows weren't re-encrypted) BEFORE AES-GCM throws an opaque
+ * authentication-tag error.
+ *
+ * Orgs without per-org config fall through to the `fallback` provider —
+ * mixed-mode deployments where some orgs have KMS isolation and others
+ * stay on the shared master are explicitly supported.
+ */
+export declare class PerOrgKmsKeyProvider implements KeyProvider {
+    /** Cached per-org master keys, keyed by orgId. */
+    private readonly masters;
+    /** Resolved per-org configs cached for the process lifetime. */
+    private readonly configs;
+    /** In-flight resolver promises so concurrent first-touch callers share one KMS Decrypt.
+     *  Resolves to `null` for orgs with no per-org config — caller treats null as
+     *  "fall through to the fallback provider", same as a cold cache miss. */
+    private readonly inFlight;
+    /** Provider used for orgs that have no per-org config. */
+    private readonly fallback;
+    private readonly resolver;
+    private readonly region?;
+    private readonly endpoint?;
+    constructor(opts: {
+        resolver: PerOrgKmsResolver;
+        fallback: KeyProvider;
+        region?: string;
+        endpoint?: string;
+    });
+    /** Sync `deriveKey` only works for already-warmed orgs. Cold orgs fall
+     *  through to the fallback provider. Callers that want per-org isolation
+     *  MUST `await deriveKeyAsync(orgId)` once first (e.g. during request setup
+     *  or as part of a warmup pass) — otherwise the org silently uses the
+     *  shared master. */
+    deriveKey(orgId: string): Buffer;
+    deriveKeyAsync(orgId: string): Promise<Buffer>;
+    kidFor(orgId: string): string | undefined;
+    /**
+     * Resolve the org's KMS config, call Decrypt, cache the master. Subsequent
+     * calls for the same org are no-ops. Concurrent callers share the in-flight
+     * Decrypt promise.
+     *
+     * Returns silently when the org has no per-org config — the fallback
+     * provider handles those orgs.
+     */
+    ensureWarmed(orgId: string): Promise<void>;
+    private resolveAndDecrypt;
+    private fetchAndDecrypt;
+    /** Evict a cached per-org master. Use after a key rotation so the next
+     *  touch re-fetches the new wrapped master from the resolver. */
+    evict(orgId: string): void;
+}
+/**
+ * Encrypt a plaintext string for storage. Returns an `EncryptedBlob` that
+ * can be JSON-serialized into the underlying column / Mongo document.
+ *
+ * Empty strings round-trip as `null` so the calling model layer can treat
+ * "no secret set" identically to "field absent".
+ */
+export declare function encryptSecret(plaintext: string, orgId: string, provider?: KeyProvider): EncryptedBlob;
+/**
+ * Decrypt an `EncryptedBlob` written by `encryptSecret`. Throws on * - unknown `alg` (forces an explicit migration when the format changes)
+ * - wrong orgId (HKDF binding mismatch fails the auth tag)
+ * - tampered ciphertext (GCM auth tag check fails)
+ *
+ * Callers handle the throw  masking the failure as `null` would hide
+ * silent corruption / wrong-org reads.
+ */
+export declare function decryptSecret(blob: EncryptedBlob, orgId: string, provider?: KeyProvider): string;
+/**
+ * Type guard  handy for model layers that hold a column whose value may be
+ * either a clear-text string (legacy / unencrypted) OR an encrypted blob
+ * (post-migration). Mixed states arise mid-migration; the model decides
+ * what to do (decrypt on read, encrypt on next write).
+ */
+export declare function isEncryptedBlob(value: unknown): value is EncryptedBlob;