@marktiderman/genesis-connect 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mark Tiderman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,229 @@
-# Temporary Holding Version
+# @marktiderman/genesis-connect
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Connect an outside account, server side, in a few lines. Two primitives:
+
+- **Secrets with key versioning**: AES-256-GCM, a key per purpose (HKDF-SHA-256), each
+  secret bound to its row, and a keyring so keys can be rotated without a migration.
+- **An OAuth connector kit**: the authorization-code flow with PKCE on Web `Request` and
+  `Response`, Google built in, any other provider as a plain object. The app keeps the
+  rows; the kit does the flow, seals the refresh token and hands it over.
+
+fetch and WebCrypto only, no dependencies: Node 20+, edge runtimes and Cloudflare Workers.
+Server only: never import it into a browser bundle.
+
+## Connect Google Drive
+
+```ts
+// connect.server.ts: create it once, at module scope.
+import {
+  createConnector,
+  createSecrets,
+  googleProvider,
+  GOOGLE_SCOPES,
+} from "@marktiderman/genesis-connect";
+
+export const google = createConnector({
+  provider: googleProvider,
+  clientId: process.env.GOOGLE_OAUTH_CLIENT_ID!,
+  clientSecret: process.env.GOOGLE_OAUTH_CLIENT_SECRET!,
+  stateSecret: process.env.CONNECT_STATE_SECRET!, // openssl rand -base64 32
+  secrets: createSecrets(process.env.CONNECT_KEYRING!, {
+    purpose: "google-refresh-token",
+  }),
+  callbackPath: "/api/connect/google/callback",
+  scopes: [GOOGLE_SCOPES.driveFile],
+  store: async (account) => {
+    // Your table: id, user, sealed refresh token, scope. Never the plaintext.
+    // The user is account.subject (from start), never a session read from the callback.
+    await db.insert("google_grants", {
+      id: account.id,
+      user_id: account.subject,
+      refresh_token: account.sealedRefreshToken,
+      scope: account.scope,
+    });
+    return { grant: account.id }; // added to the way back: ?connect=connected&grant=…
+  },
+});
+
+// POST /api/connect/google/start (after your own sign-in check)
+export const start = async (request: Request) =>
+  (
+    await google.start(request, {
+      subject: await userId(request),
+      returnTo: "/settings/integrations",
+    })
+  ).redirect();
+
+// GET /api/connect/google/callback
+export const callback = (request: Request) => google.callback(request);
+
+// Later, anywhere on the server:
+const grant = await db.get("google_grants", grantId);
+const token = await google.accessToken(
+  grant.refresh_token,
+  `google-grant:${grant.id}`,
+);
+await fetch("https://www.googleapis.com/drive/v3/files", {
+  headers: { authorization: `Bearer ${token}` },
+});
+```
+
+On the way back the page reads `?connect=`: `connected`, `expired` (start again), `browser`
+(finished in another browser), `denied` (the person said no), `scope` (they unticked a scope
+the app needs) or `failed`. Register `https://<your origin>/api/connect/google/callback` as an
+authorized redirect URI in the Google Cloud console.
+
+## Secrets and key rotation
+
+```ts
+import { createSecrets } from "@marktiderman/genesis-connect/secrets";
+
+// CONNECT_KEYRING = {"active":"k2","keys":{"k1":"<32 bytes base64>","k2":"<32 bytes base64>"}}
+const secrets = createSecrets(process.env.CONNECT_KEYRING!, {
+  purpose: "webhook-url",
+});
+
+const sealed = await secrets.seal(url, `destination:${row.id}`); // v2.k2.<iv>.<ciphertext>
+const plain = await secrets.open(row.sealed, `destination:${row.id}`);
+
+// Rotate: add k3 to the keyring, make it active, deploy. Old secrets still open.
+// Then re-seal lazily on read, or in a job:
+if (secrets.needsRotation(row.sealed))
+  await save(row.id, await secrets.reseal(row.sealed, `destination:${row.id}`));
+// When no row names k2 any more, drop it from the keyring.
+```
+
+- **Associated data is required.** Use the row's id (`grant:<id>`): a secret copied onto
+  another row then refuses to open.
+- **One purpose per kind of secret.** It is the HKDF `info`; keep it (and an optional
+  `salt`) fixed once anything is sealed.
+- **A bare key is a keyring of one**, `k1`. That is how a single-key app moves on.
+- **Legacy `v1.` secrets** (genesis-forms' `sealSecret`) open with the key named by
+  `legacyKeyId` (default `"k1"`), with the same purpose and salt; `reseal` turns them into `v2.`.
+- **`v2` keys are derived apart from `v1`** (HKDF info `genesis-connect/v2:<purpose>`), so one
+  key and purpose never seal both formats under the same AES key. `v1` is unchanged.
+- **Errors are `SecretError`s** with a `code` (`key`, `format`, `unknown-key`, `decrypt`,
+  `usage`) and a message that never holds a key, a key id, a plaintext or a ciphertext. Check
+  them with `isSecretError(e)` rather than `instanceof`: it also matches the copy genesis-forms
+  bundles, and the ESM and CJS builds.
+
+## The OAuth connector
+
+`createConnector(config)` checks its config at boot and returns:
+
+| Call                                                                      | What it does                                                                                                                                                                                                                                                                                                  |
+| ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `start(request, { subject, intent?, returnTo, scopes?, data?, params? })` | The provider's sign-in URL and a `Set-Cookie`. `.redirect()` answers a 303; `.json()` answers `{ url }` for a page that navigates itself.                                                                                                                                                                     |
+| `callback(request)`                                                       | Checks the signed state (signature, age), that the cookie's nonce matches it, handles `error`, exchanges the code with the PKCE verifier, checks every scope asked for was granted, seals the refresh token and calls `store`. Always a 303 back to `returnTo` with `?connect=<result>`, clearing the cookie. |
+| `accessToken(sealed, aad)`                                                | A fresh access token, cached in memory until a minute before it expires.                                                                                                                                                                                                                                      |
+| `refresh(sealed, aad, { onRotate })`                                      | Uncached; when the provider rotates the refresh token, the new one comes back sealed.                                                                                                                                                                                                                         |
+| `revoke(sealed, aad)`                                                     | Revokes at the provider and forgets the cached token. True when it is gone. Google ends every token of the person's grant to your client, so only revoke the last connection that uses it.                                                                                                                    |
+
+`accessToken`, `refresh` and `revoke` throw a `ConnectError` (check with `isConnectError(e)`)
+with a `code`: `revoked` (the grant is gone, `invalid_grant`: connect again), `unavailable`
+(retryable: 429, 5xx, a timeout, an abort), `failed`, or a `SecretError` when the sealed token
+doesn't open for that row.
+
+#### Providers that rotate refresh tokens
+
+Some providers send a new refresh token on every refresh (Google does not). The kit never drops
+one:
+
+- `accessToken(sealed, aad, { onRotate })` needs `onRotate` for such a provider. A rotation
+  without it throws a `usage` `ConnectError` whose `sealedRefreshToken` holds the new token;
+  store it in place of the old one.
+- The access token is cached (under the old and the new refresh token) before `onRotate` runs.
+  If `onRotate` throws, a `failed` `ConnectError` carries the new token the same way.
+- `refresh()` returns it as `sealedRefreshToken` (and calls `onRotate` when given).
+- Concurrent `accessToken` calls for one grant share one refresh, so a cold start never
+  rotates twice. The first caller's `signal` aborts the shared refresh.
+
+```ts
+const token = await connector.accessToken(row.refresh_token, aad, {
+  onRotate: (sealed) => db.update("grants", row.id, { refresh_token: sealed }),
+});
+```
+
+### What it guarantees
+
+- **Only the browser that started can finish.** The state carries a nonce; the cookie
+  (HttpOnly, SameSite=Lax, Secure everywhere but localhost, scoped to the callback path)
+  carries the same nonce and the PKCE verifier. No cookie, or another attempt's, ends as
+  `browser`. Both cookie variants (host-only and shared-domain) are cleared on the way back.
+- **https only**, except on `localhost`, `127.0.0.1` and `[::1]`: `start` on plain http
+  anywhere else throws `config`. Behind a proxy that ends TLS, `request.url` may read `http://`:
+  pass a `Request` built with the public https URL (from `X-Forwarded-Proto` and `Host`, if
+  your proxy sets them and you trust it).
+- **The state is signed and short-lived** (HMAC-SHA-256 with a key derived from
+  `stateSecret`, 10 minutes by default). A forged, edited or old state ends as `expired`. It is
+  signed, not encrypted: `data` is for ids, never secrets, and `subject` is readable in the
+  sign-in URL (and by the provider), so pass an opaque user id, not an email address.
+- **No secret in a URL or a log.** Token requests are POSTs that never follow a redirect
+  (`redirect: "error"`) and time out after 10 seconds. `log` gets safe lines only: a step, a
+  result and a reason such as `token endpoint answered 400 (invalid_grant)`.
+- **`returnTo` is a path**, never a full URL, so the way back can't be pointed elsewhere.
+
+### One callback origin for many addresses
+
+When an app answers on many addresses (`team-a.example.com`, `team-b.example.com`) but
+registers one redirect URI with the provider:
+
+```ts
+createConnector({
+  ...config,
+  redirectOrigin: "https://app.example.com",
+  sharedDomain: "example.com",
+});
+```
+
+The cookie is scoped to `example.com`, the provider sends everyone to
+`https://app.example.com/api/connect/google/callback`, and the browser goes back to the address
+it started on, but only when that is exactly an https origin on `example.com` on the default
+port; anything else
+goes back to the callback's own origin. A start on an address the cookie can't carry to the
+pinned origin (a preview on `*.vercel.app`) throws a `config` error rather than failing later.
+A public suffix is refused as `sharedDomain`. The built-in list only knows common hosting
+suffixes (`vercel.app`, `netlify.app`, `pages.dev`, `workers.dev`, `ngrok-free.app`,
+`cloudfront.net`, `up.railway.app`, `co.uk`, `com.au`, …); pass `isPublicSuffix(domain)` (a
+Public Suffix List lookup) to cover every one.
+
+Google answers some short scopes with their full names (`email` is granted as
+`https://www.googleapis.com/auth/userinfo.email`); `googleProvider.scopeAliases` maps them so
+the granted-scope check compares like with like. A provider of your own can set
+`scopeAliases` too.
+
+### Another provider
+
+A provider is a plain object:
+
+```ts
+const acme: OAuthProvider = {
+  id: "acme",
+  authorizeUrl: "https://auth.acme.example/authorize",
+  tokenUrl: "https://auth.acme.example/token",
+  revokeUrl: "https://auth.acme.example/revoke",
+  defaultScopes: ["read"],
+  tokenAuth: "client_secret_basic", // or "client_secret_post", the default
+};
+```
+
+### Config
+
+| Option                                         | Default                         |                                                                                             |
+| ---------------------------------------------- | ------------------------------- | ------------------------------------------------------------------------------------------- |
+| `provider`, `clientId`, `clientSecret`         |                                 | The provider and your OAuth client.                                                         |
+| `stateSecret`                                  |                                 | 32 bytes, base64. Signs the state.                                                          |
+| `secrets`                                      |                                 | `createSecrets(keyring, { purpose })`: seals refresh tokens.                                |
+| `callbackPath`                                 |                                 | The callback route's path.                                                                  |
+| `store(account, { request })`                  |                                 | Keeps the account. May return query parameters for the way back. Throwing ends as `failed`. |
+| `scopes`                                       | `provider.defaultScopes`        | Scopes asked for when `start` names none.                                                   |
+| `redirectOrigin`, `sharedDomain`               |                                 | See above.                                                                                  |
+| `cookieName`                                   | `genesis_connect_<provider id>` |                                                                                             |
+| `cookiePath`                                   | `callbackPath`                  | `callbackPath` or a parent directory of it (RFC 6265 path-match).                           |
+| `stateTtlSeconds`                              | 600                             | 60 to 3600.                                                                                 |
+| `resultParam`                                  | `connect`                       | The query parameter the result comes back in.                                               |
+| `fallbackPath`                                 | `/`                             | Where `expired` goes when there is no state to read `returnTo` from.                        |
+| `aad(id)`                                      | `<provider id>-grant:<id>`      | The associated data a grant's refresh token is sealed to.                                   |
+| `requireRefreshToken`                          | true                            | Fail when the provider sends none.                                                          |
+| `isPublicSuffix(domain)`                       |                                 | A Public Suffix List lookup for the `sharedDomain` check.                                   |
+| `fetch`, `timeoutMs`, `now`, `randomId`, `log` |                                 | For tests and logging.                                                                      |

package/dist/chunk-D3SZFWBJ.js

@@ -0,0 +1,289 @@
+// src/encoding.ts
+var utf8 = new TextEncoder();
+function base64url(bytes) {
+  const raw = typeof bytes === "string" ? utf8.encode(bytes) : bytes;
+  let s = "";
+  for (let i = 0; i < raw.length; i++) s += String.fromCharCode(raw[i]);
+  return btoa(s).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromBase64(text) {
+  const plain = text.replace(/-/g, "+").replace(/_/g, "/").replace(/=+$/, "");
+  const bin = atob(plain + "=".repeat((4 - plain.length % 4) % 4));
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+function randomToken(bytes = 32) {
+  return base64url(crypto.getRandomValues(new Uint8Array(bytes)));
+}
+async function sha256Hex(text) {
+  const digest = await crypto.subtle.digest("SHA-256", utf8.encode(text));
+  return Array.from(
+    new Uint8Array(digest),
+    (b) => b.toString(16).padStart(2, "0")
+  ).join("");
+}
+
+// src/secrets.ts
+var SecretError = class extends Error {
+  name = "SecretError";
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+var SECRET_ERROR_CODES = [
+  "key",
+  "format",
+  "unknown-key",
+  "decrypt",
+  "usage"
+];
+function isSecretError(error) {
+  return error instanceof Error && error.name === "SecretError" && SECRET_ERROR_CODES.includes(error.code);
+}
+function secretKeyBytes(key) {
+  if (typeof key !== "string") {
+    if (key.length !== 32)
+      throw new SecretError("key", "The encryption key must be 32 bytes");
+    return new Uint8Array(key);
+  }
+  const text = key.trim();
+  if (!text) throw new SecretError("key", "The encryption key is not set");
+  let bytes;
+  try {
+    bytes = fromBase64(text);
+  } catch {
+    throw new SecretError("key", "The encryption key is not base64");
+  }
+  if (bytes.length !== 32)
+    throw new SecretError("key", "The encryption key must be 32 bytes");
+  return bytes;
+}
+async function deriveSecretKey(key, info, options = {}) {
+  if (!info)
+    throw new SecretError("usage", "A sealing key needs its purpose (info)");
+  const salt = typeof options.salt === "string" ? utf8.encode(options.salt) : new Uint8Array(options.salt ?? new Uint8Array(0));
+  const base = await crypto.subtle.importKey(
+    "raw",
+    secretKeyBytes(key),
+    "HKDF",
+    false,
+    ["deriveKey"]
+  );
+  return crypto.subtle.deriveKey(
+    { name: "HKDF", hash: "SHA-256", salt, info: utf8.encode(info) },
+    base,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+function requireAad(aad) {
+  if (typeof aad !== "string" || !aad) {
+    throw new SecretError(
+      "usage",
+      "Associated data (the row the secret belongs to) is required"
+    );
+  }
+}
+async function encrypt(key, plaintext, additionalData) {
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const sealed = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv, additionalData: utf8.encode(additionalData) },
+    key,
+    utf8.encode(plaintext)
+  );
+  return { iv: base64url(iv), body: base64url(new Uint8Array(sealed)) };
+}
+async function decrypt(key, iv, body, additionalData) {
+  try {
+    const plain = await crypto.subtle.decrypt(
+      {
+        name: "AES-GCM",
+        iv: fromBase64(iv),
+        additionalData: utf8.encode(additionalData)
+      },
+      key,
+      fromBase64(body)
+    );
+    return new TextDecoder().decode(plain);
+  } catch {
+    throw new SecretError(
+      "decrypt",
+      "The stored secret could not be decrypted"
+    );
+  }
+}
+async function sealWithKey(key, plaintext, aad) {
+  const { iv, body } = await encrypt(key, plaintext, aad);
+  return `v1.${iv}.${body}`;
+}
+async function openWithKey(key, sealed, aad) {
+  const parsed = parseSealed(sealed);
+  if (!parsed || parsed.version !== "v1")
+    throw new SecretError(
+      "format",
+      "The stored secret is not in a known format"
+    );
+  return decrypt(key, parsed.iv, parsed.body, aad);
+}
+var KEY_ID = /^[A-Za-z0-9_-]{1,32}$/;
+function parseKeyring(value) {
+  let input = value;
+  if (typeof value === "string") {
+    const text = value.trim();
+    if (!text) throw new SecretError("key", "The keyring is not set");
+    if (text.startsWith("{")) {
+      try {
+        input = JSON.parse(text);
+      } catch {
+        throw new SecretError("key", "The keyring is not valid JSON");
+      }
+    } else {
+      return { active: "k1", keys: /* @__PURE__ */ new Map([["k1", secretKeyBytes(text)]]) };
+    }
+  }
+  if (!input || typeof input !== "object")
+    throw new SecretError(
+      "key",
+      "The keyring must be an object with active and keys"
+    );
+  const { active, keys } = input;
+  if (typeof active !== "string" || !KEY_ID.test(active))
+    throw new SecretError(
+      "key",
+      "The keyring's active key id is missing or malformed"
+    );
+  const entries = keys instanceof Map ? [...keys.entries()] : keys && typeof keys === "object" ? Object.entries(keys) : [];
+  if (entries.length === 0)
+    throw new SecretError("key", "The keyring has no keys");
+  const out = /* @__PURE__ */ new Map();
+  for (const [index, [id, key]] of entries.entries()) {
+    const which = `A key in the keyring (#${index + 1})`;
+    if (!KEY_ID.test(id))
+      throw new SecretError(
+        "key",
+        `${which} has a malformed id (letters, digits, _ and -, at most 32)`
+      );
+    if (typeof key !== "string" && !(key instanceof Uint8Array))
+      throw new SecretError("key", `${which} is not a base64 string`);
+    try {
+      out.set(id, secretKeyBytes(key));
+    } catch (error) {
+      throw new SecretError(
+        "key",
+        `${which}: ${error.message.replace(/^The encryption key /, "")}`
+      );
+    }
+  }
+  if (!out.has(active))
+    throw new SecretError(
+      "key",
+      "The keyring's active key id is not among its keys"
+    );
+  return { active, keys: out };
+}
+var B64URL = /^[A-Za-z0-9_-]+$/;
+function parseSealed(sealed) {
+  if (typeof sealed !== "string") return null;
+  const parts = sealed.split(".");
+  if (parts[0] === "v1" && parts.length === 3) {
+    const [, iv, body] = parts;
+    return B64URL.test(iv) && B64URL.test(body) ? { version: "v1", keyId: null, iv, body } : null;
+  }
+  if (parts[0] === "v2" && parts.length === 4) {
+    const [, keyId, iv, body] = parts;
+    return KEY_ID.test(keyId) && B64URL.test(iv) && B64URL.test(body) ? { version: "v2", keyId, iv, body } : null;
+  }
+  return null;
+}
+var v2Aad = (keyId, aad) => `v2.${keyId}.${aad}`;
+var v2Info = (purpose) => `genesis-connect/v2:${purpose}`;
+function createSecrets(keyring, options) {
+  const ring = parseKeyring(keyring);
+  const { purpose, salt } = options;
+  if (!purpose)
+    throw new SecretError("usage", "A sealing key needs its purpose (info)");
+  const legacyKeyId = options.legacyKeyId ?? "k1";
+  const derived = /* @__PURE__ */ new Map();
+  const keyFor = (keyId, version) => {
+    const bytes = ring.keys.get(keyId);
+    if (!bytes)
+      throw new SecretError(
+        "unknown-key",
+        "The stored secret was sealed with a key the keyring no longer has"
+      );
+    const cacheKey = `${version}:${keyId}`;
+    let key = derived.get(cacheKey);
+    if (!key) {
+      key = deriveSecretKey(
+        bytes,
+        version === "v1" ? purpose : v2Info(purpose),
+        { salt }
+      );
+      derived.set(cacheKey, key);
+    }
+    return key;
+  };
+  const secrets = {
+    purpose,
+    activeKeyId: ring.active,
+    async seal(plaintext, aad) {
+      requireAad(aad);
+      if (typeof plaintext !== "string")
+        throw new SecretError("usage", "Only text can be sealed");
+      const { iv, body } = await encrypt(
+        await keyFor(ring.active, "v2"),
+        plaintext,
+        v2Aad(ring.active, aad)
+      );
+      return `v2.${ring.active}.${iv}.${body}`;
+    },
+    async open(sealed, aad) {
+      requireAad(aad);
+      const parsed = parseSealed(sealed);
+      if (!parsed)
+        throw new SecretError(
+          "format",
+          "The stored secret is not in a known format"
+        );
+      if (parsed.version === "v1")
+        return decrypt(
+          await keyFor(legacyKeyId, "v1"),
+          parsed.iv,
+          parsed.body,
+          aad
+        );
+      const keyId = parsed.keyId;
+      return decrypt(
+        await keyFor(keyId, "v2"),
+        parsed.iv,
+        parsed.body,
+        v2Aad(keyId, aad)
+      );
+    },
+    keyIdOf(sealed) {
+      const parsed = parseSealed(sealed);
+      if (!parsed) return null;
+      return parsed.version === "v1" ? legacyKeyId : parsed.keyId;
+    },
+    needsRotation(sealed) {
+      const parsed = parseSealed(sealed);
+      return !(parsed && parsed.version === "v2" && parsed.keyId === ring.active);
+    },
+    async reseal(sealed, aad) {
+      if (!secrets.needsRotation(sealed)) {
+        await secrets.open(sealed, aad);
+        return sealed;
+      }
+      return secrets.seal(await secrets.open(sealed, aad), aad);
+    }
+  };
+  return secrets;
+}
+
+export { KEY_ID, SecretError, base64url, createSecrets, deriveSecretKey, fromBase64, isSecretError, openWithKey, parseKeyring, randomToken, sealWithKey, secretKeyBytes, sha256Hex, utf8 };
+//# sourceMappingURL=chunk-D3SZFWBJ.js.map
+//# sourceMappingURL=chunk-D3SZFWBJ.js.map

package/dist/chunk-D3SZFWBJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/encoding.ts","../src/secrets.ts"],"names":[],"mappings":"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","file":"chunk-D3SZFWBJ.js","sourcesContent":["/** Small byte helpers on web APIs only (no Buffer), so the package runs on Node, edge and Workers. */\n\nexport const utf8 = new TextEncoder();\n\n/** Bytes (or UTF-8 text) as base64url, no padding. */\nexport function base64url(bytes: Uint8Array | string): string {\n  const raw = typeof bytes === \"string\" ? utf8.encode(bytes) : bytes;\n  let s = \"\";\n  for (let i = 0; i < raw.length; i++) s += String.fromCharCode(raw[i]!);\n  return btoa(s).replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/, \"\");\n}\n\n/** Standard base64 or base64url, padded or not, as bytes. Throws on anything else. */\nexport function fromBase64(text: string): Uint8Array<ArrayBuffer> {\n  const plain = text.replace(/-/g, \"+\").replace(/_/g, \"/\").replace(/=+$/, \"\");\n  const bin = atob(plain + \"=\".repeat((4 - (plain.length % 4)) % 4));\n  const out = new Uint8Array(bin.length);\n  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);\n  return out;\n}\n\n/** `bytes` random bytes as base64url. */\nexport function randomToken(bytes = 32): string {\n  return base64url(crypto.getRandomValues(new Uint8Array(bytes)));\n}\n\n/** SHA-256 of a text, as lowercase hex. */\nexport async function sha256Hex(text: string): Promise<string> {\n  const digest = await crypto.subtle.digest(\"SHA-256\", utf8.encode(text));\n  return Array.from(new Uint8Array(digest), (b) =>\n    b.toString(16).padStart(2, \"0\"),\n  ).join(\"\");\n}\n\n/** WebCrypto's key type, named without depending on the DOM lib. */\nexport type WebCryptoKey = Awaited<ReturnType<typeof crypto.subtle.importKey>>;\n","/**\n * Secrets at rest, with key versioning: a refresh token, a webhook URL, a\n * signing secret. AES-256-GCM (WebCrypto) under a key derived with\n * HKDF-SHA-256 from a 32-byte key and a purpose string, so no two purposes\n * share a key. Every ciphertext is bound to associated data (the row it\n * belongs to), so one copied onto another row does not decrypt.\n *\n * Keys live in a keyring, `{ active: \"k2\", keys: { k1: \"<32 bytes, base64>\", k2: \"…\" } }`,\n * usually one environment variable. New secrets are sealed with the active\n * key and name it: `v2.<key id>.<iv>.<ciphertext and tag>`, base64url. Any\n * key still listed opens what it sealed, so rotation is: add a key, make it\n * active, re-seal rows lazily (`needsRotation`, `reseal`) or in a job, then\n * drop the old key.\n *\n * The older single-key form, `v1.<iv>.<ciphertext>` (genesis-forms'\n * `sealSecret`), still opens, with the keyring key named by `legacyKeyId`.\n *\n * Errors are `SecretError`s whose messages never hold a key, a plaintext or\n * a ciphertext.\n */\nimport { base64url, fromBase64, utf8, type WebCryptoKey } from \"./encoding\";\n\nexport type { WebCryptoKey } from \"./encoding\";\n\n/** What went wrong, for code to branch on. */\nexport type SecretErrorCode =\n  /** A key is missing, not base64 or not 32 bytes, or the keyring is malformed. */\n  | \"key\"\n  /** The sealed text is not `v1.` or `v2.` in shape. */\n  | \"format\"\n  /** The sealed text names a key the keyring no longer has. */\n  | \"unknown-key\"\n  /** Wrong key, wrong associated data (another row's secret) or a tampered ciphertext. */\n  | \"decrypt\"\n  /** A required argument (purpose, associated data) is missing. */\n  | \"usage\";\n\n/** A failure whose message is safe to log: never a key, a plaintext or a ciphertext. */\nexport class SecretError extends Error {\n  override name = \"SecretError\";\n  readonly code: SecretErrorCode;\n  constructor(code: SecretErrorCode, message: string) {\n    super(message);\n    this.code = code;\n  }\n}\n\nconst SECRET_ERROR_CODES: readonly string[] = [\n  \"key\",\n  \"format\",\n  \"unknown-key\",\n  \"decrypt\",\n  \"usage\",\n];\n\n/**\n * Whether `error` is a `SecretError`, by its name and code rather than\n * `instanceof`, so it also matches a copy bundled into another package\n * (genesis-forms bundles one).\n */\nexport function isSecretError(error: unknown): error is SecretError {\n  return (\n    error instanceof Error &&\n    error.name === \"SecretError\" &&\n    SECRET_ERROR_CODES.includes((error as { code?: unknown }).code as string)\n  );\n}\n\n// Keys ---------------------------------------------------------------------------------------------\n\n/**\n * The 32 key bytes from base64 or base64url text (as `openssl rand -base64 32`\n * prints), or the bytes themselves.\n */\nexport function secretKeyBytes(\n  key: string | Uint8Array,\n): Uint8Array<ArrayBuffer> {\n  if (typeof key !== \"string\") {\n    if (key.length !== 32)\n      throw new SecretError(\"key\", \"The encryption key must be 32 bytes\");\n    return new Uint8Array(key);\n  }\n  const text = key.trim();\n  if (!text) throw new SecretError(\"key\", \"The encryption key is not set\");\n  let bytes: Uint8Array<ArrayBuffer>;\n  try {\n    bytes = fromBase64(text);\n  } catch {\n    throw new SecretError(\"key\", \"The encryption key is not base64\");\n  }\n  if (bytes.length !== 32)\n    throw new SecretError(\"key\", \"The encryption key must be 32 bytes\");\n  return bytes;\n}\n\n/** The HKDF salt: bytes, or text taken as its UTF-8 bytes. */\nexport type Salt = string | Uint8Array;\n\n/** Options for `deriveSecretKey`. */\nexport interface DeriveSecretKeyOptions {\n  /**\n   * The HKDF salt. Default empty. A fixed, app-wide random value is\n   * recommended for new keys (RFC 5869); it need not be secret, but must\n   * never change once anything is sealed with it.\n   */\n  salt?: Salt | undefined;\n}\n\n/**\n * An AES-GCM key for one purpose, derived from a 32-byte key with\n * HKDF-SHA-256 (`info` naming the purpose; the salt empty unless given).\n * Keep `info` and the salt fixed once anything is sealed with them.\n */\nexport async function deriveSecretKey(\n  key: string | Uint8Array,\n  info: string,\n  options: DeriveSecretKeyOptions = {},\n): Promise<WebCryptoKey> {\n  if (!info)\n    throw new SecretError(\"usage\", \"A sealing key needs its purpose (info)\");\n  const salt =\n    typeof options.salt === \"string\"\n      ? utf8.encode(options.salt)\n      : new Uint8Array(options.salt ?? new Uint8Array(0));\n  const base = await crypto.subtle.importKey(\n    \"raw\",\n    secretKeyBytes(key),\n    \"HKDF\",\n    false,\n    [\"deriveKey\"],\n  );\n  return crypto.subtle.deriveKey(\n    { name: \"HKDF\", hash: \"SHA-256\", salt, info: utf8.encode(info) },\n    base,\n    { name: \"AES-GCM\", length: 256 },\n    false,\n    [\"encrypt\", \"decrypt\"],\n  );\n}\n\n// The single-key v1 format -------------------------------------------------------------------------\n\nfunction requireAad(aad: string): void {\n  if (typeof aad !== \"string\" || !aad) {\n    throw new SecretError(\n      \"usage\",\n      \"Associated data (the row the secret belongs to) is required\",\n    );\n  }\n}\n\nasync function encrypt(\n  key: WebCryptoKey,\n  plaintext: string,\n  additionalData: string,\n): Promise<{ iv: string; body: string }> {\n  const iv = crypto.getRandomValues(new Uint8Array(12));\n  const sealed = await crypto.subtle.encrypt(\n    { name: \"AES-GCM\", iv, additionalData: utf8.encode(additionalData) },\n    key,\n    utf8.encode(plaintext),\n  );\n  return { iv: base64url(iv), body: base64url(new Uint8Array(sealed)) };\n}\n\nasync function decrypt(\n  key: WebCryptoKey,\n  iv: string,\n  body: string,\n  additionalData: string,\n): Promise<string> {\n  try {\n    const plain = await crypto.subtle.decrypt(\n      {\n        name: \"AES-GCM\",\n        iv: fromBase64(iv),\n        additionalData: utf8.encode(additionalData),\n      },\n      key,\n      fromBase64(body),\n    );\n    return new TextDecoder().decode(plain);\n  } catch {\n    throw new SecretError(\n      \"decrypt\",\n      \"The stored secret could not be decrypted\",\n    );\n  }\n}\n\n/**\n * Seals with one derived key in the single-key format, `v1.<iv>.<ciphertext>`.\n * Kept for genesis-forms' `sealSecret`; new code uses `createSecrets`, whose\n * `v2.` form names its key so the key can be rotated.\n */\nexport async function sealWithKey(\n  key: WebCryptoKey,\n  plaintext: string,\n  aad: string,\n): Promise<string> {\n  const { iv, body } = await encrypt(key, plaintext, aad);\n  return `v1.${iv}.${body}`;\n}\n\n/** Opens what `sealWithKey` sealed with the same key and `aad`. */\nexport async function openWithKey(\n  key: WebCryptoKey,\n  sealed: string,\n  aad: string,\n): Promise<string> {\n  const parsed = parseSealed(sealed);\n  if (!parsed || parsed.version !== \"v1\")\n    throw new SecretError(\n      \"format\",\n      \"The stored secret is not in a known format\",\n    );\n  return decrypt(key, parsed.iv, parsed.body, aad);\n}\n\n// The keyring --------------------------------------------------------------------------------------\n\n/** A key id: letters, digits, `_` and `-`, at most 32 (it is written into every sealed secret). */\nexport const KEY_ID = /^[A-Za-z0-9_-]{1,32}$/;\n\n/** A keyring as config: the active key's id and every key that may still be needed to open. */\nexport interface KeyringInput {\n  active: string;\n  keys: Readonly<Record<string, string | Uint8Array>>;\n}\n\n/** A checked keyring: every key 32 bytes, the active one listed. */\nexport interface Keyring {\n  readonly active: string;\n  readonly keys: ReadonlyMap<string, Uint8Array<ArrayBuffer>>;\n}\n\n/**\n * A keyring from config: an object, its JSON text (one environment\n * variable: `{\"active\":\"k2\",\"keys\":{\"k1\":\"…\",\"k2\":\"…\"}}`), or a single bare\n * key, which becomes `{ active: \"k1\", keys: { k1 } }` (how a single-key\n * secret moves onto a keyring). Errors never quote the text.\n */\nexport function parseKeyring(value: string | KeyringInput | Keyring): Keyring {\n  let input: unknown = value;\n  if (typeof value === \"string\") {\n    const text = value.trim();\n    if (!text) throw new SecretError(\"key\", \"The keyring is not set\");\n    if (text.startsWith(\"{\")) {\n      try {\n        input = JSON.parse(text) as unknown;\n      } catch {\n        // JSON.parse's own message quotes the text, which holds keys.\n        throw new SecretError(\"key\", \"The keyring is not valid JSON\");\n      }\n    } else {\n      return { active: \"k1\", keys: new Map([[\"k1\", secretKeyBytes(text)]]) };\n    }\n  }\n  if (!input || typeof input !== \"object\")\n    throw new SecretError(\n      \"key\",\n      \"The keyring must be an object with active and keys\",\n    );\n  const { active, keys } = input as { active?: unknown; keys?: unknown };\n  if (typeof active !== \"string\" || !KEY_ID.test(active))\n    throw new SecretError(\n      \"key\",\n      \"The keyring's active key id is missing or malformed\",\n    );\n  const entries: [string, unknown][] =\n    keys instanceof Map\n      ? [...(keys as Map<string, unknown>).entries()]\n      : keys && typeof keys === \"object\"\n        ? Object.entries(keys)\n        : [];\n  if (entries.length === 0)\n    throw new SecretError(\"key\", \"The keyring has no keys\");\n  const out = new Map<string, Uint8Array<ArrayBuffer>>();\n  // Errors name a key by its position, never its id or its value.\n  for (const [index, [id, key]] of entries.entries()) {\n    const which = `A key in the keyring (#${index + 1})`;\n    if (!KEY_ID.test(id))\n      throw new SecretError(\n        \"key\",\n        `${which} has a malformed id (letters, digits, _ and -, at most 32)`,\n      );\n    if (typeof key !== \"string\" && !(key instanceof Uint8Array))\n      throw new SecretError(\"key\", `${which} is not a base64 string`);\n    try {\n      out.set(id, secretKeyBytes(key));\n    } catch (error) {\n      throw new SecretError(\n        \"key\",\n        `${which}: ${(error as Error).message.replace(/^The encryption key /, \"\")}`,\n      );\n    }\n  }\n  if (!out.has(active))\n    throw new SecretError(\n      \"key\",\n      \"The keyring's active key id is not among its keys\",\n    );\n  return { active, keys: out };\n}\n\n/** Options for `createSecrets`. */\nexport interface SecretsOptions {\n  /**\n   * What these secrets are, as the HKDF `info`: `\"google-refresh-token\"`,\n   * `\"webhook-url\"`. One per kind of secret; fixed once anything is sealed.\n   */\n  purpose: string;\n  /** The HKDF salt (see `DeriveSecretKeyOptions.salt`). Fixed once anything is sealed. */\n  salt?: Salt | undefined;\n  /**\n   * The keyring key that sealed single-key `v1.` secrets (genesis-forms'\n   * `sealSecret`, with the same purpose and salt). Default `\"k1\"`, the id a\n   * bare key gets from `parseKeyring`.\n   */\n  legacyKeyId?: string | undefined;\n}\n\n/** Seals and opens one purpose's secrets with a keyring. */\nexport interface Secrets {\n  readonly purpose: string;\n  /** The key new secrets are sealed with. */\n  readonly activeKeyId: string;\n  /** `plaintext` sealed with the active key and bound to `aad`: `v2.<key id>.<iv>.<ciphertext>`. */\n  seal(plaintext: string, aad: string): Promise<string>;\n  /** Opens a `v2.` secret with the key it names, or a `v1.` one with `legacyKeyId`'s. Needs the same `aad`. */\n  open(sealed: string, aad: string): Promise<string>;\n  /** The key id a sealed secret names (`legacyKeyId` for `v1.`), or null when it is not one. */\n  keyIdOf(sealed: string): string | null;\n  /**\n   * Whether a sealed secret is anything but `v2.` under the active key: a\n   * `v1.` one, another key's, or unreadable (whose `reseal` then throws).\n   */\n  needsRotation(sealed: string): boolean;\n  /**\n   * The secret sealed again with the active key, or `sealed` itself when it\n   * already is. Store the result in place of the old one.\n   */\n  reseal(sealed: string, aad: string): Promise<string>;\n}\n\ninterface ParsedSealed {\n  version: \"v1\" | \"v2\";\n  keyId: string | null;\n  iv: string;\n  body: string;\n}\n\nconst B64URL = /^[A-Za-z0-9_-]+$/;\n\nfunction parseSealed(sealed: unknown): ParsedSealed | null {\n  if (typeof sealed !== \"string\") return null;\n  const parts = sealed.split(\".\");\n  if (parts[0] === \"v1\" && parts.length === 3) {\n    const [, iv, body] = parts as [string, string, string];\n    return B64URL.test(iv) && B64URL.test(body)\n      ? { version: \"v1\", keyId: null, iv, body }\n      : null;\n  }\n  if (parts[0] === \"v2\" && parts.length === 4) {\n    const [, keyId, iv, body] = parts as [string, string, string, string];\n    return KEY_ID.test(keyId) && B64URL.test(iv) && B64URL.test(body)\n      ? { version: \"v2\", keyId, iv, body }\n      : null;\n  }\n  return null;\n}\n\n/** The associated data a `v2.` ciphertext is bound to: its version and key id, then the app's. */\nconst v2Aad = (keyId: string, aad: string) => `v2.${keyId}.${aad}`;\n\n/**\n * The HKDF info for `v2.` keys: distinct from the bare purpose that `v1.`\n * (single-key) secrets use, so the same key and purpose never seal both\n * formats under one AES key.\n */\nconst v2Info = (purpose: string) => `genesis-connect/v2:${purpose}`;\n\n/**\n * Seals and opens secrets of one purpose with a keyring (see `parseKeyring`\n * for what it takes). Derived keys are cached on the returned object.\n */\nexport function createSecrets(\n  keyring: string | KeyringInput | Keyring,\n  options: SecretsOptions,\n): Secrets {\n  const ring = parseKeyring(keyring);\n  const { purpose, salt } = options;\n  if (!purpose)\n    throw new SecretError(\"usage\", \"A sealing key needs its purpose (info)\");\n  const legacyKeyId = options.legacyKeyId ?? \"k1\";\n  const derived = new Map<string, Promise<WebCryptoKey>>();\n\n  const keyFor = (\n    keyId: string,\n    version: \"v1\" | \"v2\",\n  ): Promise<WebCryptoKey> => {\n    const bytes = ring.keys.get(keyId);\n    if (!bytes)\n      throw new SecretError(\n        \"unknown-key\",\n        \"The stored secret was sealed with a key the keyring no longer has\",\n      );\n    const cacheKey = `${version}:${keyId}`;\n    let key = derived.get(cacheKey);\n    if (!key) {\n      key = deriveSecretKey(\n        bytes,\n        version === \"v1\" ? purpose : v2Info(purpose),\n        { salt },\n      );\n      derived.set(cacheKey, key);\n    }\n    return key;\n  };\n\n  const secrets: Secrets = {\n    purpose,\n    activeKeyId: ring.active,\n    async seal(plaintext, aad) {\n      requireAad(aad);\n      if (typeof plaintext !== \"string\")\n        throw new SecretError(\"usage\", \"Only text can be sealed\");\n      const { iv, body } = await encrypt(\n        await keyFor(ring.active, \"v2\"),\n        plaintext,\n        v2Aad(ring.active, aad),\n      );\n      return `v2.${ring.active}.${iv}.${body}`;\n    },\n    async open(sealed, aad) {\n      requireAad(aad);\n      const parsed = parseSealed(sealed);\n      if (!parsed)\n        throw new SecretError(\n          \"format\",\n          \"The stored secret is not in a known format\",\n        );\n      if (parsed.version === \"v1\")\n        return decrypt(\n          await keyFor(legacyKeyId, \"v1\"),\n          parsed.iv,\n          parsed.body,\n          aad,\n        );\n      const keyId = parsed.keyId!;\n      return decrypt(\n        await keyFor(keyId, \"v2\"),\n        parsed.iv,\n        parsed.body,\n        v2Aad(keyId, aad),\n      );\n    },\n    keyIdOf(sealed) {\n      const parsed = parseSealed(sealed);\n      if (!parsed) return null;\n      return parsed.version === \"v1\" ? legacyKeyId : parsed.keyId;\n    },\n    needsRotation(sealed) {\n      const parsed = parseSealed(sealed);\n      return !(\n        parsed &&\n        parsed.version === \"v2\" &&\n        parsed.keyId === ring.active\n      );\n    },\n    async reseal(sealed, aad) {\n      if (!secrets.needsRotation(sealed)) {\n        // Still checks it opens, so a job never reports a broken row as done.\n        await secrets.open(sealed, aad);\n        return sealed;\n      }\n      return secrets.seal(await secrets.open(sealed, aad), aad);\n    },\n  };\n  return secrets;\n}\n"]}