@pipeline-builder/pipeline-manager 4.1.4 → 4.1.5

package/dist/lambda/token-renew-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"token-renew-handler.d.ts","sourceRoot":"","sources":["../../src/lambda/token-renew-handler.ts"],"names":[],"mappings":"AA4DA,eAAO,MAAM,OAAO,QAAa,OAAO,CAAC,IAAI,CAyE5C,CAAC"}
+{"version":3,"file":"token-renew-handler.d.ts","sourceRoot":"","sources":["../../src/lambda/token-renew-handler.ts"],"names":[],"mappings":"AAgHA,eAAO,MAAM,OAAO,QAAa,OAAO,CAAC,IAAI,CA+E5C,CAAC"}

package/dist/lambda/token-renew-handler.js

@@ -1,125 +1,162 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 /**
- * Lambda handler that re-mints the platform JWT in Secrets Manager so it never
- * lapses. Deployed + scheduled (once a day) by `pipeline-manager infra store-token
- * --schedule`. Rather than re-implementing the token flow, it is a thin
- * orchestrator that reuses the tested CLI — each run:
+ * Scheduled KEY ROTATOR for the service-account credential in Secrets Manager
+ * (#N2). Deployed + scheduled (once a day) by `pipeline-manager infra store-token
+ * --schedule`.
  *
- *   1. Point the `@pipeline-builder` npm scope at public npm.
- *   2. Download `@pipeline-builder/pipeline-manager` from npm into /tmp.
- *   3. Read the current platform JWT from the secret.
- *   4. Run `pipeline-manager infra store-token`, which mints a fresh long-lived token
- *      via /api/user/generate-token and writes it back to the same secret.
+ * It used to re-mint a person's machine-session JWT by npm-installing the CLI at
+ * runtime and shelling out to `store-token`. There is nothing left to re-mint:
+ * the stored credential is an opaque `pb_sa_…` key, and platform rotates it
+ * through two small pre-auth endpoints where the KEY ITSELF is the authorization
+ * (an unattended machine has no password and cannot step up). So this handler is
+ * three HTTP calls and a secret write, with no npm install, no CLI, no `/tmp`.
  *
- * `/tmp` is the only writable path in Lambda, so npm's HOME/cache/prefix all live
- * there. store-token does NOT deploy the renewal stack by default (no --schedule),
- * so the renewal run never redeploys/recurses into its own stack.
+ * THE ORDER IS THE WHOLE DESIGN. At no point may the secret name a credential
+ * that does not work:
+ *
+ *   1. ROTATE — mint a sibling key on the same account. The current key stays
+ *      LIVE. Fail here and the secret is untouched: the old key still works.
+ *   2. STORE  — write the new key to the secret. Fail here and the secret still
+ *      holds the old key, which is still live; the new key is an orphan that
+ *      expires on its own (and the next run's rotate prunes it at the cap).
+ *   3. REVOKE — retire the old key, authenticated with the NEW one. Fail here
+ *      and BOTH keys work; the credential is healthy and the stale key expires
+ *      on its own. Logged at ERROR so it is visible, but it does not fail the
+ *      invocation: a retry would rotate again and churn keys for no gain.
+ *
+ * Revoke-then-create would invert every one of those: a failure after the revoke
+ * leaves the deployment with no working credential at all.
  *
  * Env: PLATFORM_SECRET_NAME, PLATFORM_BASE_URL, RENEW_DAYS (default 30),
- *      PIPELINE_MANAGER_VERSION (default "latest"), PLATFORM_VERIFY_SSL ("false"
- *      to disable TLS verification).
+ *      PLATFORM_VERIFY_SSL ("false" to disable TLS verification — refused in
+ *      production).
  */
-import { execFileSync } from 'node:child_process';
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { SecretsManagerClient, GetSecretValueCommand } from '@aws-sdk/client-secrets-manager';
-const PM_PACKAGE = '@pipeline-builder/pipeline-manager';
-const TMP = '/tmp';
-const PM_PREFIX = `${TMP}/pm`;
-const NPM_CACHE = `${TMP}/.npm`;
-const NPMRC = `${TMP}/.npmrc`;
-const CLI = `${PM_PREFIX}/node_modules/${PM_PACKAGE}/dist/cli.js`;
+import { SecretsManagerClient, GetSecretValueCommand, PutSecretValueCommand } from '@aws-sdk/client-secrets-manager';
+/** Per-request timeout for the platform calls. */
+const HTTP_TIMEOUT_MS = 10_000;
+/** Access-key prefixes platform issues. A stored JWT is not one of them. */
+const ACCESS_KEY_PREFIXES = ['pb_sa_', 'pb_pat_'];
 function required(name) {
     const v = process.env[name];
     if (!v)
         throw new Error(`${name} environment variable is required`);
     return v;
 }
-/**
- * Read the `scope` claim from a JWT payload without verifying the signature
- * (the platform re-verifies on use; this only decides whether to re-mint WITH
- * a scope). A scoped credential (e.g. `reporting:ingest`) must renew with the
- * same scope or the fresh token would be a full-privilege platform token and
- * the scoped consumer's calls would break. Returns undefined for an unscoped
- * (platform) token or any decode failure.
- */
-function decodeJwtScope(jwt) {
+function log(level, msg, data) {
+    const line = JSON.stringify({ level, msg, ...data });
+    // eslint-disable-next-line no-console
+    if (level === 'ERROR')
+        console.error(line);
+    else
+        console.log(line);
+}
+/** POST JSON to the platform, returning the parsed body plus the status. */
+async function post(baseUrl, route, body) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), HTTP_TIMEOUT_MS);
     try {
-        const payload = jwt.split('.')[1];
-        if (!payload)
-            return undefined;
-        const json = Buffer.from(payload.replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString('utf8');
-        const claims = JSON.parse(json);
-        return typeof claims.scope === 'string' && claims.scope ? claims.scope : undefined;
+        const res = await fetch(`${baseUrl}${route}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        const parsed = await res.json().catch(() => ({}));
+        return { status: res.status, body: parsed };
+    }
+    finally {
+        clearTimeout(timer);
     }
-    catch {
-        return undefined;
+}
+/**
+ * SECURITY: these calls carry a live credential. Refuse to disable TLS
+ * verification in production so a MITM can't harvest it. Production is this
+ * Lambda's normal mode (the rotation stack sets NODE_ENV=production), so
+ * PLATFORM_VERIFY_SSL=false is honored ONLY outside production. This inlines the
+ * same `NODE_ENV==='production'` policy as utils/tls.ts#assertSslDisableAllowed
+ * (the handler ships as a single self-contained index.mjs and can't import it).
+ */
+function applyTlsPolicy() {
+    if (process.env.PLATFORM_VERIFY_SSL !== 'false')
+        return;
+    if (process.env.NODE_ENV === 'production') {
+        log('WARN', 'Refusing PLATFORM_VERIFY_SSL=false in production (NODE_ENV=production) — TLS verification stays enabled');
+        return;
     }
+    process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
 }
 export const handler = async () => {
     const secretName = required('PLATFORM_SECRET_NAME');
-    const platformUrl = required('PLATFORM_BASE_URL').replace(/\/$/, '');
-    const days = process.env.RENEW_DAYS || '30';
-    const version = process.env.PIPELINE_MANAGER_VERSION || 'latest';
+    const envUrl = required('PLATFORM_BASE_URL').replace(/\/+$/, '');
+    const days = Number(process.env.RENEW_DAYS || '30');
+    if (!Number.isFinite(days) || days < 1 || days > 365) {
+        throw new Error(`RENEW_DAYS must be between 1 and 365 (got "${process.env.RENEW_DAYS}")`);
+    }
     const region = process.env.AWS_REGION || 'us-east-1';
-    // npm in Lambda can only write under /tmp; HOME/cache/userconfig point there.
-    const npmEnv = { ...process.env, HOME: TMP, npm_config_cache: NPM_CACHE };
-    // 1. Scope config: resolve @pipeline-builder from public npm regardless of any
-    //    inherited registry. Written as a userconfig file (env mapping of scoped
-    //    keys is unreliable).
-    writeFileSync(NPMRC, '@pipeline-builder:registry=https://registry.npmjs.org/\n');
-    // 2. Download pipeline-manager into /tmp.
-    mkdirSync(PM_PREFIX, { recursive: true });
-    // eslint-disable-next-line no-console
-    console.log(JSON.stringify({ level: 'INFO', msg: 'installing pipeline-manager', package: `${PM_PACKAGE}@${version}` }));
-    execFileSync('npm', ['install', '--prefix', PM_PREFIX, '--no-audit', '--no-fund', '--userconfig', NPMRC, `${PM_PACKAGE}@${version}`], { env: npmEnv, stdio: 'inherit' });
-    // 3. Read the current platform JWT — it authenticates the renewal request.
+    applyTlsPolicy();
     const sm = new SecretsManagerClient({ region });
     const current = await sm.send(new GetSecretValueCommand({ SecretId: secretName }));
     if (!current.SecretString)
         throw new Error(`Secret "${secretName}" is empty`);
-    const jwt = JSON.parse(current.SecretString).password;
-    if (!jwt)
-        throw new Error(`Secret "${secretName}" missing password (JWT)`);
-    // 4. Run store-token (without --schedule, the default) so it ONLY re-mints and
-    //    writes the secret — it must not redeploy this stack (would recurse). The
-    //    write uses the Lambda role's creds.
-    // store-token no longer takes --secret-name; it reads PLATFORM_SECRET_NAME from
-    // the environment (else derives it from the token's org).
-    const args = ['infra', 'store-token', '--region', region, '--days', days];
-    // Preserve the token's capability scope on renewal (else a scoped ingest
-    // credential re-mints as a scopeless platform token and ingest starts 403ing).
-    // The re-mint authenticates with THIS token, and a scoped token still carries
-    // a userId, so /user/generate-token accepts it and re-issues the same scope.
-    const tokenScope = decodeJwtScope(jwt);
-    if (tokenScope) {
-        args.push('--scope', tokenScope);
-        // eslint-disable-next-line no-console
-        console.log(JSON.stringify({ level: 'INFO', msg: 'renewing scoped token', scope: tokenScope, secretName }));
+    const stored = JSON.parse(current.SecretString);
+    const oldKey = stored.password;
+    if (!oldKey)
+        throw new Error(`Secret "${secretName}" missing password (service-account key)`);
+    if (!ACCESS_KEY_PREFIXES.some((p) => oldKey.startsWith(p))) {
+        throw new Error(`Secret "${secretName}" does not hold an opaque service-account key. `
+            + 'Re-run "pipeline-manager infra store-token" to reissue it as a key (see docs/runbooks/access-key-cutover.md).');
     }
-    // SECURITY: the spawned store-token POSTs the JWT to the platform. Refuse to
-    // disable TLS verification in production so a MITM can't harvest it. Production
-    // is this Lambda's normal mode (the renew stack sets NODE_ENV=production), so
-    // PLATFORM_VERIFY_SSL=false is honored ONLY outside production. This inlines the
-    // same `NODE_ENV==='production'` policy as utils/tls.ts#assertSslDisableAllowed
-    // (the handler ships as a single self-contained index.mjs and can't import it).
-    const isProduction = process.env.NODE_ENV === 'production';
-    if (process.env.PLATFORM_VERIFY_SSL === 'false') {
-        if (isProduction) {
-            // eslint-disable-next-line no-console
-            console.log(JSON.stringify({ level: 'WARN', msg: 'Refusing PLATFORM_VERIFY_SSL=false in production (NODE_ENV=production) — TLS verification stays enabled' }));
-        }
-        else {
-            args.push('--no-verify-ssl');
-        }
-    }
-    execFileSync('node', [CLI, ...args], {
-        // NODE_ENV is inherited via npmEnv (spread of process.env), so the spawned CLI
-        // enforces the same production TLS-disable refusal as this handler.
-        env: { ...npmEnv, PLATFORM_TOKEN: jwt, PLATFORM_BASE_URL: platformUrl, PLATFORM_SECRET_NAME: secretName },
-        stdio: 'inherit',
+    // The platform this credential belongs to is recorded IN the secret; the env
+    // var is the fallback for a secret written before that field existed.
+    const platformUrl = (stored.platformUrl || envUrl).replace(/\/+$/, '');
+    // ── 1. ROTATE — mint the replacement. The old key stays live. ──────────────
+    const rotate = await post(platformUrl, '/api/auth/key/rotate', {
+        key: oldKey,
+        name: `${stored.serviceAccountName || 'rotated'}-${new Date().toISOString().slice(0, 10)}`,
+        expiresIn: days * 24 * 60 * 60,
     });
-    // eslint-disable-next-line no-console
-    console.log(JSON.stringify({ level: 'INFO', msg: 'platform token renewed', secretName }));
+    if (rotate.status < 200 || rotate.status >= 300) {
+        throw new Error(`Key rotation refused (${rotate.status}): ${rotate.body.message || 'unknown reason'}. `
+            + 'The stored key is unchanged and still live.');
+    }
+    const newKey = rotate.body.data?.key;
+    const newKeyId = rotate.body.data?.keyId;
+    if (!newKey || !newKeyId)
+        throw new Error('Key rotation returned no replacement key — the stored key is unchanged');
+    const pruned = rotate.body.data?.prunedKeyIds ?? [];
+    if (pruned.length > 0) {
+        log('WARN', 'Platform retired stale sibling keys to stay under the active-key cap', { secretName, prunedKeyIds: pruned });
+    }
+    log('INFO', 'Minted the replacement key', { secretName, keyId: newKeyId });
+    // ── 2. STORE — the secret now names a live credential. ─────────────────────
+    const next = {
+        ...stored,
+        password: newKey,
+        keyId: newKeyId,
+        platformUrl,
+        expiresIn: days * 24 * 60 * 60,
+        ...(rotate.body.data?.expiresAt ? { expiresAt: rotate.body.data.expiresAt } : {}),
+        createdAt: new Date().toISOString(),
+    };
+    await sm.send(new PutSecretValueCommand({ SecretId: secretName, SecretString: JSON.stringify(next) }));
+    log('INFO', 'Stored the rotated key', { secretName, keyId: newKeyId });
+    // ── 3. REVOKE — retire the predecessor, using the key that replaced it. ────
+    // Best-effort by design: the credential is already healthy, and failing the
+    // invocation here would only make the next retry rotate again.
+    const oldKeyId = stored.keyId;
+    if (!oldKeyId) {
+        log('WARN', 'Secret recorded no previous keyId — nothing to revoke (it expires on its own)', { secretName });
+        return;
+    }
+    const revoke = await post(platformUrl, '/api/auth/key/revoke', { key: newKey, keyId: oldKeyId })
+        .catch((err) => ({ status: 0, body: { message: err instanceof Error ? err.message : String(err) } }));
+    if (revoke.status < 200 || revoke.status >= 300) {
+        log('ERROR', 'Rotated and stored the new key, but could NOT revoke its predecessor — it stays valid until it expires', {
+            secretName, staleKeyId: oldKeyId, status: revoke.status, reason: revoke.body.message,
+        });
+        return;
+    }
+    log('INFO', 'Rotation complete', { secretName, keyId: newKeyId, revokedKeyId: oldKeyId });
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token-renew-handler.js","sourceRoot":"","sources":["../../src/lambda/token-renew-handler.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Lambda handler that re-mints the platform JWT in Secrets Manager so it never\n * lapses. Deployed + scheduled (once a day) by `pipeline-manager infra store-token\n * --schedule`. Rather than re-implementing the token flow, it is a thin\n * orchestrator that reuses the tested CLI — each run:\n *\n *   1. Point the `@pipeline-builder` npm scope at public npm.\n *   2. Download `@pipeline-builder/pipeline-manager` from npm into /tmp.\n *   3. Read the current platform JWT from the secret.\n *   4. Run `pipeline-manager infra store-token`, which mints a fresh long-lived token\n *      via /api/user/generate-token and writes it back to the same secret.\n *\n * `/tmp` is the only writable path in Lambda, so npm's HOME/cache/prefix all live\n * there. store-token does NOT deploy the renewal stack by default (no --schedule),\n * so the renewal run never redeploys/recurses into its own stack.\n *\n * Env: PLATFORM_SECRET_NAME, PLATFORM_BASE_URL, RENEW_DAYS (default 30),\n *      PIPELINE_MANAGER_VERSION (default \"latest\"), PLATFORM_VERIFY_SSL (\"false\"\n *      to disable TLS verification).\n */\nimport { execFileSync } from 'node:child_process';\nimport { mkdirSync, writeFileSync } from 'node:fs';\nimport { SecretsManagerClient, GetSecretValueCommand } from '@aws-sdk/client-secrets-manager';\n\nconst PM_PACKAGE = '@pipeline-builder/pipeline-manager';\nconst TMP = '/tmp';\nconst PM_PREFIX = `${TMP}/pm`;\nconst NPM_CACHE = `${TMP}/.npm`;\nconst NPMRC = `${TMP}/.npmrc`;\nconst CLI = `${PM_PREFIX}/node_modules/${PM_PACKAGE}/dist/cli.js`;\n\nfunction required(name: string): string {\n  const v = process.env[name];\n  if (!v) throw new Error(`${name} environment variable is required`);\n  return v;\n}\n\n/**\n * Read the `scope` claim from a JWT payload without verifying the signature\n * (the platform re-verifies on use; this only decides whether to re-mint WITH\n * a scope). A scoped credential (e.g. `reporting:ingest`) must renew with the\n * same scope or the fresh token would be a full-privilege platform token and\n * the scoped consumer's calls would break. Returns undefined for an unscoped\n * (platform) token or any decode failure.\n */\nfunction decodeJwtScope(jwt: string): string | undefined {\n  try {\n    const payload = jwt.split('.')[1];\n    if (!payload) return undefined;\n    const json = Buffer.from(payload.replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString('utf8');\n    const claims = JSON.parse(json) as { scope?: unknown };\n    return typeof claims.scope === 'string' && claims.scope ? claims.scope : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nexport const handler = async (): Promise<void> => {\n  const secretName = required('PLATFORM_SECRET_NAME');\n  const platformUrl = required('PLATFORM_BASE_URL').replace(/\\/$/, '');\n  const days = process.env.RENEW_DAYS || '30';\n  const version = process.env.PIPELINE_MANAGER_VERSION || 'latest';\n  const region = process.env.AWS_REGION || 'us-east-1';\n\n  // npm in Lambda can only write under /tmp; HOME/cache/userconfig point there.\n  const npmEnv = { ...process.env, HOME: TMP, npm_config_cache: NPM_CACHE };\n\n  // 1. Scope config: resolve @pipeline-builder from public npm regardless of any\n  //    inherited registry. Written as a userconfig file (env mapping of scoped\n  //    keys is unreliable).\n  writeFileSync(NPMRC, '@pipeline-builder:registry=https://registry.npmjs.org/\\n');\n\n  // 2. Download pipeline-manager into /tmp.\n  mkdirSync(PM_PREFIX, { recursive: true });\n  // eslint-disable-next-line no-console\n  console.log(JSON.stringify({ level: 'INFO', msg: 'installing pipeline-manager', package: `${PM_PACKAGE}@${version}` }));\n  execFileSync(\n    'npm',\n    ['install', '--prefix', PM_PREFIX, '--no-audit', '--no-fund', '--userconfig', NPMRC, `${PM_PACKAGE}@${version}`],\n    { env: npmEnv, stdio: 'inherit' },\n  );\n\n  // 3. Read the current platform JWT — it authenticates the renewal request.\n  const sm = new SecretsManagerClient({ region });\n  const current = await sm.send(new GetSecretValueCommand({ SecretId: secretName }));\n  if (!current.SecretString) throw new Error(`Secret \"${secretName}\" is empty`);\n  const jwt = (JSON.parse(current.SecretString) as { password?: string }).password;\n  if (!jwt) throw new Error(`Secret \"${secretName}\" missing password (JWT)`);\n\n  // 4. Run store-token (without --schedule, the default) so it ONLY re-mints and\n  //    writes the secret — it must not redeploy this stack (would recurse). The\n  //    write uses the Lambda role's creds.\n  // store-token no longer takes --secret-name; it reads PLATFORM_SECRET_NAME from\n  // the environment (else derives it from the token's org).\n  const args = ['infra', 'store-token', '--region', region, '--days', days];\n  // Preserve the token's capability scope on renewal (else a scoped ingest\n  // credential re-mints as a scopeless platform token and ingest starts 403ing).\n  // The re-mint authenticates with THIS token, and a scoped token still carries\n  // a userId, so /user/generate-token accepts it and re-issues the same scope.\n  const tokenScope = decodeJwtScope(jwt);\n  if (tokenScope) {\n    args.push('--scope', tokenScope);\n    // eslint-disable-next-line no-console\n    console.log(JSON.stringify({ level: 'INFO', msg: 'renewing scoped token', scope: tokenScope, secretName }));\n  }\n  // SECURITY: the spawned store-token POSTs the JWT to the platform. Refuse to\n  // disable TLS verification in production so a MITM can't harvest it. Production\n  // is this Lambda's normal mode (the renew stack sets NODE_ENV=production), so\n  // PLATFORM_VERIFY_SSL=false is honored ONLY outside production. This inlines the\n  // same `NODE_ENV==='production'` policy as utils/tls.ts#assertSslDisableAllowed\n  // (the handler ships as a single self-contained index.mjs and can't import it).\n  const isProduction = process.env.NODE_ENV === 'production';\n  if (process.env.PLATFORM_VERIFY_SSL === 'false') {\n    if (isProduction) {\n      // eslint-disable-next-line no-console\n      console.log(JSON.stringify({ level: 'WARN', msg: 'Refusing PLATFORM_VERIFY_SSL=false in production (NODE_ENV=production) — TLS verification stays enabled' }));\n    } else {\n      args.push('--no-verify-ssl');\n    }\n  }\n\n  execFileSync('node', [CLI, ...args], {\n    // NODE_ENV is inherited via npmEnv (spread of process.env), so the spawned CLI\n    // enforces the same production TLS-disable refusal as this handler.\n    env: { ...npmEnv, PLATFORM_TOKEN: jwt, PLATFORM_BASE_URL: platformUrl, PLATFORM_SECRET_NAME: secretName },\n    stdio: 'inherit',\n  });\n\n  // eslint-disable-next-line no-console\n  console.log(JSON.stringify({ level: 'INFO', msg: 'platform token renewed', secretName }));\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token-renew-handler.js","sourceRoot":"","sources":["../../src/lambda/token-renew-handler.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Scheduled KEY ROTATOR for the service-account credential in Secrets Manager\n * (#N2). Deployed + scheduled (once a day) by `pipeline-manager infra store-token\n * --schedule`.\n *\n * It used to re-mint a person's machine-session JWT by npm-installing the CLI at\n * runtime and shelling out to `store-token`. There is nothing left to re-mint:\n * the stored credential is an opaque `pb_sa_…` key, and platform rotates it\n * through two small pre-auth endpoints where the KEY ITSELF is the authorization\n * (an unattended machine has no password and cannot step up). So this handler is\n * three HTTP calls and a secret write, with no npm install, no CLI, no `/tmp`.\n *\n * THE ORDER IS THE WHOLE DESIGN. At no point may the secret name a credential\n * that does not work:\n *\n *   1. ROTATE — mint a sibling key on the same account. The current key stays\n *      LIVE. Fail here and the secret is untouched: the old key still works.\n *   2. STORE  — write the new key to the secret. Fail here and the secret still\n *      holds the old key, which is still live; the new key is an orphan that\n *      expires on its own (and the next run's rotate prunes it at the cap).\n *   3. REVOKE — retire the old key, authenticated with the NEW one. Fail here\n *      and BOTH keys work; the credential is healthy and the stale key expires\n *      on its own. Logged at ERROR so it is visible, but it does not fail the\n *      invocation: a retry would rotate again and churn keys for no gain.\n *\n * Revoke-then-create would invert every one of those: a failure after the revoke\n * leaves the deployment with no working credential at all.\n *\n * Env: PLATFORM_SECRET_NAME, PLATFORM_BASE_URL, RENEW_DAYS (default 30),\n *      PLATFORM_VERIFY_SSL (\"false\" to disable TLS verification — refused in\n *      production).\n */\nimport { SecretsManagerClient, GetSecretValueCommand, PutSecretValueCommand } from '@aws-sdk/client-secrets-manager';\n\n/** Per-request timeout for the platform calls. */\nconst HTTP_TIMEOUT_MS = 10_000;\n\n/** Access-key prefixes platform issues. A stored JWT is not one of them. */\nconst ACCESS_KEY_PREFIXES = ['pb_sa_', 'pb_pat_'];\n\nfunction required(name: string): string {\n  const v = process.env[name];\n  if (!v) throw new Error(`${name} environment variable is required`);\n  return v;\n}\n\nfunction log(level: 'INFO' | 'WARN' | 'ERROR', msg: string, data?: Record<string, unknown>): void {\n  const line = JSON.stringify({ level, msg, ...data });\n  // eslint-disable-next-line no-console\n  if (level === 'ERROR') console.error(line); else console.log(line);\n}\n\n/** The stored secret, as `store-token` writes it. */\ninterface StoredCredential {\n  username?: string;\n  /** The canonical credential field — an opaque `pb_sa_…` key after the cutover. */\n  password?: string;\n  platformUrl?: string;\n  organizationId?: string;\n  serviceAccountId?: string;\n  serviceAccountName?: string;\n  /** Record id of the key in `password`; what step 3 retires. */\n  keyId?: string;\n  scope?: string | null;\n  expiresIn?: number;\n  expiresAt?: string;\n  createdAt?: string;\n  [key: string]: unknown;\n}\n\n/** POST JSON to the platform, returning the parsed body plus the status. */\nasync function post(\n  baseUrl: string,\n  route: string,\n  body: Record<string, unknown>,\n): Promise<{ status: number; body: { data?: Record<string, unknown>; message?: string } }> {\n  const controller = new AbortController();\n  const timer = setTimeout(() => controller.abort(), HTTP_TIMEOUT_MS);\n  try {\n    const res = await fetch(`${baseUrl}${route}`, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },\n      body: JSON.stringify(body),\n      signal: controller.signal,\n    });\n    const parsed = await res.json().catch(() => ({})) as { data?: Record<string, unknown>; message?: string };\n    return { status: res.status, body: parsed };\n  } finally {\n    clearTimeout(timer);\n  }\n}\n\n/**\n * SECURITY: these calls carry a live credential. Refuse to disable TLS\n * verification in production so a MITM can't harvest it. Production is this\n * Lambda's normal mode (the rotation stack sets NODE_ENV=production), so\n * PLATFORM_VERIFY_SSL=false is honored ONLY outside production. This inlines the\n * same `NODE_ENV==='production'` policy as utils/tls.ts#assertSslDisableAllowed\n * (the handler ships as a single self-contained index.mjs and can't import it).\n */\nfunction applyTlsPolicy(): void {\n  if (process.env.PLATFORM_VERIFY_SSL !== 'false') return;\n  if (process.env.NODE_ENV === 'production') {\n    log('WARN', 'Refusing PLATFORM_VERIFY_SSL=false in production (NODE_ENV=production) — TLS verification stays enabled');\n    return;\n  }\n  process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';\n}\n\nexport const handler = async (): Promise<void> => {\n  const secretName = required('PLATFORM_SECRET_NAME');\n  const envUrl = required('PLATFORM_BASE_URL').replace(/\\/+$/, '');\n  const days = Number(process.env.RENEW_DAYS || '30');\n  if (!Number.isFinite(days) || days < 1 || days > 365) {\n    throw new Error(`RENEW_DAYS must be between 1 and 365 (got \"${process.env.RENEW_DAYS}\")`);\n  }\n  const region = process.env.AWS_REGION || 'us-east-1';\n\n  applyTlsPolicy();\n\n  const sm = new SecretsManagerClient({ region });\n  const current = await sm.send(new GetSecretValueCommand({ SecretId: secretName }));\n  if (!current.SecretString) throw new Error(`Secret \"${secretName}\" is empty`);\n  const stored = JSON.parse(current.SecretString) as StoredCredential;\n\n  const oldKey = stored.password;\n  if (!oldKey) throw new Error(`Secret \"${secretName}\" missing password (service-account key)`);\n  if (!ACCESS_KEY_PREFIXES.some((p) => oldKey.startsWith(p))) {\n    throw new Error(\n      `Secret \"${secretName}\" does not hold an opaque service-account key. `\n      + 'Re-run \"pipeline-manager infra store-token\" to reissue it as a key (see docs/runbooks/access-key-cutover.md).',\n    );\n  }\n  // The platform this credential belongs to is recorded IN the secret; the env\n  // var is the fallback for a secret written before that field existed.\n  const platformUrl = (stored.platformUrl || envUrl).replace(/\\/+$/, '');\n\n  // ── 1. ROTATE — mint the replacement. The old key stays live. ──────────────\n  const rotate = await post(platformUrl, '/api/auth/key/rotate', {\n    key: oldKey,\n    name: `${stored.serviceAccountName || 'rotated'}-${new Date().toISOString().slice(0, 10)}`,\n    expiresIn: days * 24 * 60 * 60,\n  });\n  if (rotate.status < 200 || rotate.status >= 300) {\n    throw new Error(\n      `Key rotation refused (${rotate.status}): ${rotate.body.message || 'unknown reason'}. `\n      + 'The stored key is unchanged and still live.',\n    );\n  }\n  const newKey = rotate.body.data?.key as string | undefined;\n  const newKeyId = rotate.body.data?.keyId as string | undefined;\n  if (!newKey || !newKeyId) throw new Error('Key rotation returned no replacement key — the stored key is unchanged');\n  const pruned = (rotate.body.data?.prunedKeyIds as string[] | undefined) ?? [];\n  if (pruned.length > 0) {\n    log('WARN', 'Platform retired stale sibling keys to stay under the active-key cap', { secretName, prunedKeyIds: pruned });\n  }\n  log('INFO', 'Minted the replacement key', { secretName, keyId: newKeyId });\n\n  // ── 2. STORE — the secret now names a live credential. ─────────────────────\n  const next: StoredCredential = {\n    ...stored,\n    password: newKey,\n    keyId: newKeyId,\n    platformUrl,\n    expiresIn: days * 24 * 60 * 60,\n    ...(rotate.body.data?.expiresAt ? { expiresAt: rotate.body.data.expiresAt as string } : {}),\n    createdAt: new Date().toISOString(),\n  };\n  await sm.send(new PutSecretValueCommand({ SecretId: secretName, SecretString: JSON.stringify(next) }));\n  log('INFO', 'Stored the rotated key', { secretName, keyId: newKeyId });\n\n  // ── 3. REVOKE — retire the predecessor, using the key that replaced it. ────\n  // Best-effort by design: the credential is already healthy, and failing the\n  // invocation here would only make the next retry rotate again.\n  const oldKeyId = stored.keyId;\n  if (!oldKeyId) {\n    log('WARN', 'Secret recorded no previous keyId — nothing to revoke (it expires on its own)', { secretName });\n    return;\n  }\n  const revoke = await post(platformUrl, '/api/auth/key/revoke', { key: newKey, keyId: oldKeyId })\n    .catch((err) => ({ status: 0, body: { message: err instanceof Error ? err.message : String(err) } }));\n  if (revoke.status < 200 || revoke.status >= 300) {\n    log('ERROR', 'Rotated and stored the new key, but could NOT revoke its predecessor — it stays valid until it expires', {\n      secretName, staleKeyId: oldKeyId, status: revoke.status, reason: revoke.body.message,\n    });\n    return;\n  }\n  log('INFO', 'Rotation complete', { secretName, keyId: newKeyId, revokedKeyId: oldKeyId });\n};\n"]}

package/dist/templates/events-stack.json

@@ -8,7 +8,7 @@
     },
     "PlatformSecretName": {
       "Type": "String",
-      "Description": "Secrets Manager secret name containing the platform JWT token (e.g. pipeline-builder/{orgId}/platform)"
+      "Description": "Secrets Manager secret name containing the reporting:ingest service-account key (e.g. pipeline-builder/{orgId}/reporting-ingest)"
     },
     "DoraEnabled": {
       "Type": "String",

package/dist/templates/token-renew-stack.json

@@ -1,6 +1,6 @@
 {
   "AWSTemplateFormatVersion": "2010-09-09",
-  "Description": "Pipeline Builder platform-token renewal — a scheduled Lambda that re-mints the platform JWT in Secrets Manager before it expires, so CodeBuild/Lambda credentials never lapse. Lambda code is deployed separately via pipeline-manager infra store-token.",
+  "Description": "Pipeline Builder service-account KEY ROTATION — a scheduled Lambda that replaces the pb_sa_ key in Secrets Manager before it expires (rotate, store, then revoke the predecessor), so CodeBuild/Lambda credentials never lapse. Lambda code is deployed separately via pipeline-manager infra store-token.",
   "Parameters": {
     "PlatformBaseUrl": {
       "Type": "String",
@@ -8,29 +8,29 @@
     },
     "PlatformSecretName": {
       "Type": "String",
-      "Description": "Secrets Manager secret name holding the platform JWT (e.g. pipeline-builder/{orgId}/platform)"
+      "Description": "Secrets Manager secret name holding the service-account key (e.g. pipeline-builder/{orgId}/platform)"
     },
     "RenewDays": {
       "Type": "Number",
       "Default": 30,
       "MinValue": 1,
       "MaxValue": 365,
-      "Description": "Lifetime in days requested for each renewed token"
+      "Description": "Lifetime in days requested for each rotated key"
     },
     "ScheduleExpression": {
       "Type": "String",
       "Default": "cron(0 0 * * ? *)",
-      "Description": "EventBridge schedule expression for the renewal (default: daily at 00:00 UTC)"
+      "Description": "EventBridge schedule expression for the rotation (default: daily at 00:00 UTC)"
     },
     "PipelineManagerVersion": {
       "Type": "String",
       "Default": "latest",
-      "Description": "Version of @pipeline-builder/pipeline-manager the handler installs from npm at runtime (pin for reproducible renewals)"
+      "Description": "Version of @pipeline-builder/pipeline-manager that deployed this stack. Provenance only — the rotator calls the platform directly and installs nothing at runtime."
     },
     "NameSuffix": {
       "Type": "String",
       "Default": "",
-      "Description": "Suffix appended to the renewal stack's resource names so a scoped-token renewal (e.g. '-reporting-ingest') coexists with the platform-token stack instead of clobbering its role/function/rule. Empty for the platform secret."
+      "Description": "Suffix appended to the rotation stack's resource names so a scoped-token renewal (e.g. '-reporting-ingest') coexists with the platform-token stack instead of clobbering its role/function/rule. Empty for the platform secret."
     }
   },
   "Resources": {
@@ -77,9 +77,8 @@
           "ZipFile": "exports.handler=async()=>{console.log('Placeholder handler — run pipeline-manager infra store-token to deploy real code');return{statusCode:200}}"
         },
         "Role": { "Fn::GetAtt": ["LambdaRole", "Arn"] },
-        "Timeout": 300,
-        "MemorySize": 1024,
-        "EphemeralStorage": { "Size": 1024 },
+        "Timeout": 60,
+        "MemorySize": 256,
         "Environment": {
           "Variables": {
             "PLATFORM_BASE_URL": { "Ref": "PlatformBaseUrl" },
@@ -95,7 +94,7 @@
       "Type": "AWS::Events::Rule",
       "Properties": {
         "Name": { "Fn::Sub": "pipeline-builder-token-renew${NameSuffix}" },
-        "Description": "Scheduled platform-token renewal",
+        "Description": "Scheduled service-account key rotation",
         "State": "ENABLED",
         "ScheduleExpression": { "Ref": "ScheduleExpression" },
         "Targets": [{

package/dist/utils/auth-utils.d.ts

@@ -1,19 +1,23 @@
 import https from 'https';
 /**
- * Login / refresh / switch-org response — every platform auth endpoint returns
- * the session tokens under this envelope.
+ * Session payload as a NON-BROWSER client receives it: the refresh token rides
+ * in the body (the browser's goes out as an HttpOnly cookie instead).
  */
+export interface SessionTokens {
+    accessToken: string;
+    refreshToken?: string;
+    expiresIn?: number;
+}
+/** Envelope every platform auth endpoint wraps its session tokens in. */
 export interface AuthResponse {
     success: boolean;
-    data: {
-        accessToken: string;
-        refreshToken: string;
-    };
+    data: SessionTokens;
 }
 /**
- * Guard the credential-transmitting commands (`login`, `create-pat`) against
- * disabling TLS verification in production. These POST plaintext passwords/JWTs,
- * so a MITM on a `prod + --no-verify-ssl` run would harvest them.
+ * Guard the credential-transmitting commands (`login`, `pat`) against disabling
+ * TLS verification in production. The device flow keeps passwords off the wire
+ * entirely, but the session tokens it returns are bearer credentials — a MITM on
+ * a `prod + --no-verify-ssl` run would harvest them just the same.
  *
  * Unlike {@link assertSslDisableAllowed} (which throws — for paths already inside
  * a try/catch), this prints and hard-exits, matching the pre-flight checks these
@@ -21,18 +25,6 @@ export interface AuthResponse {
  * `--no-verify-ssl` still works against self-signed dev platforms.
  */
 export declare function assertCredentialTlsAllowed(verifySsl: boolean | undefined): void;
-/**
- * Resolve credentials from flags, falling back to the
- * PLATFORM_IDENTIFIER / PLATFORM_PASSWORD env vars (so the password need not
- * appear in shell history / `ps`).
- */
-export declare function resolveCredentials(options: {
-    identifier?: string;
-    password?: string;
-}): {
-    identifier?: string;
-    password?: string;
-};
 /**
  * Build the https agent used by the credential commands. `--verify-ssl`
  * defaults to on; only an explicit `--no-verify-ssl` relaxes it (and only
@@ -40,22 +32,13 @@ export declare function resolveCredentials(options: {
  */
 export declare function credentialHttpsAgent(verifySsl: boolean | undefined): https.Agent;
 /**
- * POST /api/auth/login and return the access token (or `undefined` if the
- * response carried none). Rate-limit accounting (record success/failure) and
- * the no-token exit are intentionally left to the caller so each command keeps
- * its exact lockout semantics.
- */
-export declare function postLogin(params: {
-    url: string;
-    identifier: string;
-    password: string;
-    httpsAgent: https.Agent;
-    timeout: number;
-}): Promise<string | undefined>;
-/**
- * POST /api/auth/switch-org with the current access token and return the new,
- * org-scoped access token. Prints a success line (unless `quiet`) and hard-exits
- * on a missing token — both credential commands treat a failed switch the same.
+ * POST /api/auth/switch-org with the current access token and return the WHOLE
+ * re-issued session.
+ *
+ * The switch re-issues the same session slot, which ROTATES its refresh token —
+ * so a caller that keeps only the access token is left holding a dead refresh
+ * token. Prints a success line (unless `quiet`) and hard-exits on a missing
+ * token, since both credential commands treat a failed switch the same.
  */
 export declare function switchOrganization(params: {
     url: string;
@@ -64,5 +47,5 @@ export declare function switchOrganization(params: {
     httpsAgent: https.Agent;
     timeout: number;
     quiet: boolean;
-}): Promise<string>;
+}): Promise<SessionTokens>;
 //# sourceMappingURL=auth-utils.d.ts.map

package/dist/utils/auth-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth-utils.d.ts","sourceRoot":"","sources":["../../src/utils/auth-utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,OAAO,CAAC;AAM1B;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE;QACJ,WAAW,EAAE,MAAM,CAAC;QACpB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;CACH;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAK/E;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IACvF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAKA;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,GAAG,KAAK,CAAC,KAAK,CAEhF;AAED;;;;;GAKG;AACH,wBAAsB,SAAS,CAAC,MAAM,EAAE;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAS9B;AAED;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC/C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,OAAO,CAAC,MAAM,CAAC,CAmBlB"}
+{"version":3,"file":"auth-utils.d.ts","sourceRoot":"","sources":["../../src/utils/auth-utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,OAAO,CAAC;AAM1B;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,yEAAyE;AACzE,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,aAAa,CAAC;CACrB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAK/E;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,GAAG,KAAK,CAAC,KAAK,CAEhF;AAED;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC/C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,OAAO,CAAC,aAAa,CAAC,CAwBzB"}