@pipeline-builder/pipeline-manager 4.1.4 → 4.1.6

package/dist/utils/service-account.js

@@ -0,0 +1,158 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { printInfo, printSuccess, printWarning } from './output-utils.js';
+/** Step-up header the platform reads (see api-core `requireStepUp`). */
+const STEP_UP_HEADER = 'X-Step-Up-Token';
+/** HTTP status of a failed CLI request, or undefined for a transport error.
+ *  `ApiError` carries it directly; a raw axios error only on the response. */
+function statusOf(err) {
+    const e = err;
+    const status = e?.status ?? e?.response?.status;
+    return typeof status === 'number' ? status : undefined;
+}
+/** The platform's error code on a failed request, when it sent one. */
+function errorCodeOf(err) {
+    const data = err?.response?.data;
+    return data?.error?.code ?? data?.code;
+}
+/** Unwrap api-core's `{ success, data }` envelope (some paths return data bare). */
+function unwrap(response) {
+    const body = response;
+    return (body?.data ?? response);
+}
+/**
+ * Mint a single-use step-up token for the signed-in operator. Short-lived by
+ * design, so callers mint one immediately before each gated write rather than
+ * holding one across the whole command.
+ */
+async function stepUp(client, password) {
+    try {
+        const res = await client.post('/api/auth/step-up', { password });
+        const token = unwrap(res)?.stepUpToken;
+        if (!token)
+            throw new Error('no stepUpToken in response');
+        return token;
+    }
+    catch (err) {
+        throw new Error('Could not re-verify your password (step-up). Creating a service account and issuing its key '
+            + 'are both step-up gated. Check the password passed via --password / PLATFORM_PASSWORD. '
+            + `(${err instanceof Error ? err.message : String(err)})`);
+    }
+}
+/** The org the operator's token is active in. */
+export async function resolveOrganizationId(client) {
+    const res = await client.get('/api/organization');
+    const orgId = unwrap(res)?.organization?.id;
+    if (!orgId) {
+        throw new Error('Could not resolve your active organization — the platform returned no organization for this token.');
+    }
+    return orgId;
+}
+/**
+ * The org Role to give a full-privilege machine account: its Super Admin role if
+ * the org has one (the system org does), else its Admin role. Both are subject to
+ * the ordinary assignment ceiling on the platform side, so this can never grant
+ * the account more than the operator holds.
+ */
+async function resolveAdminRoleId(client, orgId) {
+    const res = await client.get(`/api/organization/${orgId}/roles`);
+    const roles = unwrap(res)?.roles ?? [];
+    const role = roles.find((r) => r.grantsRole === 'superadmin') ?? roles.find((r) => r.grantsRole === 'admin');
+    if (!role) {
+        throw new Error(`Organization ${orgId} has no admin role to grant the machine service account.`);
+    }
+    return role.id;
+}
+/** Find an existing account by name (the name is the stable machine identifier). */
+async function findAccount(client, orgId, name) {
+    const res = await client.get(`/api/organization/${orgId}/service-accounts`);
+    const accounts = unwrap(res)?.serviceAccounts ?? [];
+    return accounts.find((a) => a.name === name);
+}
+/**
+ * Create the account if it isn't there yet, and return its id. IDEMPOTENT: a
+ * re-run reuses the existing account (including the 409 race where two runs
+ * create it at once), and never re-grants Roles — an operator who narrowed the
+ * account's Roles by hand must not have that undone by the next `store-token`.
+ */
+async function ensureAccount(opts, orgId) {
+    const existing = await findAccount(opts.client, orgId, opts.accountName);
+    if (existing) {
+        printInfo('Reusing the existing service account', { account: opts.accountName, id: existing.id });
+        return existing.id;
+    }
+    const roleIds = opts.roles === 'admin' ? [await resolveAdminRoleId(opts.client, orgId)] : [];
+    try {
+        const res = await opts.client.post(`/api/organization/${orgId}/service-accounts`, { name: opts.accountName, description: opts.description, roleIds }, { [STEP_UP_HEADER]: await stepUp(opts.client, opts.password) });
+        const account = unwrap(res)?.serviceAccount;
+        if (!account?.id)
+            throw new Error('service-account create returned no id');
+        printSuccess(`Created the '${opts.accountName}' service account`);
+        return account.id;
+    }
+    catch (err) {
+        if (statusOf(err) === 409) {
+            const raced = await findAccount(opts.client, orgId, opts.accountName);
+            if (raced)
+                return raced.id;
+        }
+        throw err;
+    }
+}
+/** Revoke one of an account's keys. Best-effort by contract — see the call sites. */
+export async function revokeServiceAccountKey(client, password, orgId, accountId, keyId) {
+    await client.delete(`/api/organization/${orgId}/service-accounts/${accountId}/keys/${keyId}`, { [STEP_UP_HEADER]: await stepUp(client, password) });
+}
+/**
+ * Issue a key, self-healing past the per-account active-key cap: at the cap the
+ * OLDEST active key is retired and the mint retried once. The cap exists to bound
+ * a compromise, not to make provisioning fail, and the credential a re-run is
+ * replacing is the very thing that should go.
+ */
+async function issueKey(opts, orgId, accountId) {
+    const body = {
+        name: opts.keyName,
+        expiresIn: opts.expiresInSeconds,
+        ...(opts.scope ? { scope: opts.scope } : {}),
+    };
+    const mint = async () => unwrap(await opts.client.post(`/api/organization/${orgId}/service-accounts/${accountId}/keys`, body, { [STEP_UP_HEADER]: await stepUp(opts.client, opts.password) }));
+    try {
+        return await mint();
+    }
+    catch (err) {
+        if (statusOf(err) !== 409 && errorCodeOf(err) !== 'SA_KEY_LIMIT')
+            throw err;
+        const account = await findAccount(opts.client, orgId, opts.accountName);
+        const oldest = (account?.keys ?? [])
+            .filter((k) => k.status === 'active')
+            .sort((a, b) => a.createdAt.localeCompare(b.createdAt))[0];
+        if (!oldest)
+            throw err;
+        printWarning(`Service account '${opts.accountName}' is at its active-key limit — retiring its oldest key (${oldest.id}).`);
+        await revokeServiceAccountKey(opts.client, opts.password, orgId, accountId, oldest.id);
+        return mint();
+    }
+}
+/**
+ * Ensure the named service account exists and issue it a fresh key.
+ *
+ * Deliberately does NOT revoke anything the caller was previously holding: the
+ * caller stores the new key first and retires the old one afterwards (see
+ * `store-token`), so a failure at any point leaves a working credential in the
+ * secret rather than an empty one.
+ */
+export async function provisionServiceAccountKey(opts) {
+    const organizationId = await resolveOrganizationId(opts.client);
+    const serviceAccountId = await ensureAccount(opts, organizationId);
+    const { key, accessKey } = await issueKey(opts, organizationId, serviceAccountId);
+    return {
+        key,
+        keyId: accessKey.id,
+        serviceAccountId,
+        serviceAccountName: opts.accountName,
+        organizationId,
+        expiresAt: accessKey.expiresAt,
+        scope: accessKey.scope ?? null,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service-account.js","sourceRoot":"","sources":["../../src/utils/service-account.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Provisioning the org's MACHINE identity for stored credentials (#12 / #N2).\n *\n * Every credential the CLI parks in AWS Secrets Manager used to be a machine\n * SESSION belonging to whoever ran the command: a person's JWT, renewed daily by\n * re-minting it under that person's session. It outlived their employment, it\n * carried their authority, and the audit trail read as if they had personally\n * pushed every image.\n *\n * What it writes instead is a `pb_sa_…` key on an org SERVICE ACCOUNT:\n *   - the account is the principal, so audit rows name it, not the operator;\n *   - its Roles are the narrowest that work — for a SCOPED credential that is no\n *     Roles at all, just the one capability (`reporting:ingest`, `registry:push`);\n *   - the key is opaque and short-lived at the point of use (5-minute exchanged\n *     tokens), so revoking it actually stops the automation;\n *   - it takes no seat and survives the operator leaving.\n *\n * Creating an account and issuing a key are BOTH step-up gated on the platform —\n * they mint durable bearer credentials, the same class of action a personal key\n * is gated for. So this module needs the operator's password (`--password` or\n * `PLATFORM_PASSWORD`), which is also the only reason `store-token` still has a\n * password path at all. A step-up token is single-use and lives about a minute,\n * so one is minted immediately before each gated call.\n */\n\nimport type { ApiClient } from './api-client.js';\nimport { printInfo, printSuccess, printWarning } from './output-utils.js';\n\n/** Step-up header the platform reads (see api-core `requireStepUp`). */\nconst STEP_UP_HEADER = 'X-Step-Up-Token';\n\n/** What the caller wants provisioned. */\nexport interface ProvisionKeyOptions {\n  /** An authenticated client for the operator's own session. */\n  client: ApiClient;\n  /** The operator's password — required, because every key write is step-up gated. */\n  password: string;\n  /** Machine name of the service account (`[a-z0-9][a-z0-9_-]{1,63}`). */\n  accountName: string;\n  /** Human description recorded on a newly created account. */\n  description: string;\n  /**\n   * Roles to grant a NEWLY created account: `'admin'` for the full-privilege\n   * platform credential (synth/deploy callbacks, plugin lookup, image push),\n   * `'none'` for a scoped credential, which needs no Roles at all.\n   */\n  roles: 'admin' | 'none';\n  /** Narrow capability scope stamped on the KEY (not the account). */\n  scope?: string;\n  /** Key lifetime in seconds (platform caps this at 365 days). */\n  expiresInSeconds: number;\n  /** Key label — shown on the org's service-accounts page. */\n  keyName: string;\n}\n\n/** A freshly minted key, plus everything the secret needs to record about it. */\nexport interface ProvisionedKey {\n  /** The raw `pb_sa_…` key — returned ONCE by the platform, never readable again. */\n  key: string;\n  keyId: string;\n  serviceAccountId: string;\n  serviceAccountName: string;\n  organizationId: string;\n  expiresAt: string;\n  scope: string | null;\n}\n\n/** Narrow shape of a service-account listing entry. */\ninterface AccountSummary {\n  id: string;\n  name: string;\n  keys?: Array<{ id: string; status: string; createdAt: string }>;\n}\n\n/** HTTP status of a failed CLI request, or undefined for a transport error.\n *  `ApiError` carries it directly; a raw axios error only on the response. */\nfunction statusOf(err: unknown): number | undefined {\n  const e = err as { status?: number; response?: { status?: number } };\n  const status = e?.status ?? e?.response?.status;\n  return typeof status === 'number' ? status : undefined;\n}\n\n/** The platform's error code on a failed request, when it sent one. */\nfunction errorCodeOf(err: unknown): string | undefined {\n  const data = (err as { response?: { data?: { error?: { code?: string }; code?: string } } })?.response?.data;\n  return data?.error?.code ?? data?.code;\n}\n\n/** Unwrap api-core's `{ success, data }` envelope (some paths return data bare). */\nfunction unwrap<T>(response: unknown): T {\n  const body = response as { data?: T };\n  return (body?.data ?? response) as T;\n}\n\n/**\n * Mint a single-use step-up token for the signed-in operator. Short-lived by\n * design, so callers mint one immediately before each gated write rather than\n * holding one across the whole command.\n */\nasync function stepUp(client: ApiClient, password: string): Promise<string> {\n  try {\n    const res = await client.post<unknown>('/api/auth/step-up', { password });\n    const token = unwrap<{ stepUpToken?: string }>(res)?.stepUpToken;\n    if (!token) throw new Error('no stepUpToken in response');\n    return token;\n  } catch (err) {\n    throw new Error(\n      'Could not re-verify your password (step-up). Creating a service account and issuing its key '\n      + 'are both step-up gated. Check the password passed via --password / PLATFORM_PASSWORD. '\n      + `(${err instanceof Error ? err.message : String(err)})`,\n    );\n  }\n}\n\n/** The org the operator's token is active in. */\nexport async function resolveOrganizationId(client: ApiClient): Promise<string> {\n  const res = await client.get<unknown>('/api/organization');\n  const orgId = unwrap<{ organization?: { id?: string } }>(res)?.organization?.id;\n  if (!orgId) {\n    throw new Error('Could not resolve your active organization — the platform returned no organization for this token.');\n  }\n  return orgId;\n}\n\n/**\n * The org Role to give a full-privilege machine account: its Super Admin role if\n * the org has one (the system org does), else its Admin role. Both are subject to\n * the ordinary assignment ceiling on the platform side, so this can never grant\n * the account more than the operator holds.\n */\nasync function resolveAdminRoleId(client: ApiClient, orgId: string): Promise<string> {\n  const res = await client.get<unknown>(`/api/organization/${orgId}/roles`);\n  const roles = unwrap<{ roles?: Array<{ id: string; grantsRole?: string }> }>(res)?.roles ?? [];\n  const role = roles.find((r) => r.grantsRole === 'superadmin') ?? roles.find((r) => r.grantsRole === 'admin');\n  if (!role) {\n    throw new Error(`Organization ${orgId} has no admin role to grant the machine service account.`);\n  }\n  return role.id;\n}\n\n/** Find an existing account by name (the name is the stable machine identifier). */\nasync function findAccount(client: ApiClient, orgId: string, name: string): Promise<AccountSummary | undefined> {\n  const res = await client.get<unknown>(`/api/organization/${orgId}/service-accounts`);\n  const accounts = unwrap<{ serviceAccounts?: AccountSummary[] }>(res)?.serviceAccounts ?? [];\n  return accounts.find((a) => a.name === name);\n}\n\n/**\n * Create the account if it isn't there yet, and return its id. IDEMPOTENT: a\n * re-run reuses the existing account (including the 409 race where two runs\n * create it at once), and never re-grants Roles — an operator who narrowed the\n * account's Roles by hand must not have that undone by the next `store-token`.\n */\nasync function ensureAccount(opts: ProvisionKeyOptions, orgId: string): Promise<string> {\n  const existing = await findAccount(opts.client, orgId, opts.accountName);\n  if (existing) {\n    printInfo('Reusing the existing service account', { account: opts.accountName, id: existing.id });\n    return existing.id;\n  }\n\n  const roleIds = opts.roles === 'admin' ? [await resolveAdminRoleId(opts.client, orgId)] : [];\n  try {\n    const res = await opts.client.post<unknown>(\n      `/api/organization/${orgId}/service-accounts`,\n      { name: opts.accountName, description: opts.description, roleIds },\n      { [STEP_UP_HEADER]: await stepUp(opts.client, opts.password) },\n    );\n    const account = unwrap<{ serviceAccount?: { id?: string } }>(res)?.serviceAccount;\n    if (!account?.id) throw new Error('service-account create returned no id');\n    printSuccess(`Created the '${opts.accountName}' service account`);\n    return account.id;\n  } catch (err) {\n    if (statusOf(err) === 409) {\n      const raced = await findAccount(opts.client, orgId, opts.accountName);\n      if (raced) return raced.id;\n    }\n    throw err;\n  }\n}\n\n/** Revoke one of an account's keys. Best-effort by contract — see the call sites. */\nexport async function revokeServiceAccountKey(\n  client: ApiClient,\n  password: string,\n  orgId: string,\n  accountId: string,\n  keyId: string,\n): Promise<void> {\n  await client.delete(\n    `/api/organization/${orgId}/service-accounts/${accountId}/keys/${keyId}`,\n    { [STEP_UP_HEADER]: await stepUp(client, password) },\n  );\n}\n\n/**\n * Issue a key, self-healing past the per-account active-key cap: at the cap the\n * OLDEST active key is retired and the mint retried once. The cap exists to bound\n * a compromise, not to make provisioning fail, and the credential a re-run is\n * replacing is the very thing that should go.\n */\nasync function issueKey(\n  opts: ProvisionKeyOptions,\n  orgId: string,\n  accountId: string,\n): Promise<{ key: string; accessKey: { id: string; expiresAt: string; scope: string | null } }> {\n  const body = {\n    name: opts.keyName,\n    expiresIn: opts.expiresInSeconds,\n    ...(opts.scope ? { scope: opts.scope } : {}),\n  };\n  const mint = async () => unwrap<{ key: string; accessKey: { id: string; expiresAt: string; scope: string | null } }>(\n    await opts.client.post<unknown>(\n      `/api/organization/${orgId}/service-accounts/${accountId}/keys`,\n      body,\n      { [STEP_UP_HEADER]: await stepUp(opts.client, opts.password) },\n    ),\n  );\n\n  try {\n    return await mint();\n  } catch (err) {\n    if (statusOf(err) !== 409 && errorCodeOf(err) !== 'SA_KEY_LIMIT') throw err;\n    const account = await findAccount(opts.client, orgId, opts.accountName);\n    const oldest = (account?.keys ?? [])\n      .filter((k) => k.status === 'active')\n      .sort((a, b) => a.createdAt.localeCompare(b.createdAt))[0];\n    if (!oldest) throw err;\n    printWarning(`Service account '${opts.accountName}' is at its active-key limit — retiring its oldest key (${oldest.id}).`);\n    await revokeServiceAccountKey(opts.client, opts.password, orgId, accountId, oldest.id);\n    return mint();\n  }\n}\n\n/**\n * Ensure the named service account exists and issue it a fresh key.\n *\n * Deliberately does NOT revoke anything the caller was previously holding: the\n * caller stores the new key first and retires the old one afterwards (see\n * `store-token`), so a failure at any point leaves a working credential in the\n * secret rather than an empty one.\n */\nexport async function provisionServiceAccountKey(opts: ProvisionKeyOptions): Promise<ProvisionedKey> {\n  const organizationId = await resolveOrganizationId(opts.client);\n  const serviceAccountId = await ensureAccount(opts, organizationId);\n  const { key, accessKey } = await issueKey(opts, organizationId, serviceAccountId);\n  return {\n    key,\n    keyId: accessKey.id,\n    serviceAccountId,\n    serviceAccountName: opts.accountName,\n    organizationId,\n    expiresAt: accessKey.expiresAt,\n    scope: accessKey.scope ?? null,\n  };\n}\n"]}

package/package.json

@@ -44,9 +44,9 @@
     "typescript": "npm:@typescript/typescript6@^6.0.2",
     "yaml": "2.9.0",
     "zod": "4.4.3",
-    "@pipeline-builder/api-core": "4.1.3",
-    "@pipeline-builder/pipeline-core": "4.1.4",
-    "@pipeline-builder/ai-core": "4.1.3"
+    "@pipeline-builder/ai-core": "4.1.5",
+    "@pipeline-builder/pipeline-core": "4.1.6",
+    "@pipeline-builder/api-core": "4.1.5"
   },
   "keywords": [
     "ci-cd",
@@ -101,7 +101,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "4.1.4",
+  "version": "4.1.6",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },

package/dist/utils/rate-limiter.d.ts

@@ -1,15 +0,0 @@
-/**
- * Check if auth attempts for this identifier are currently rate-limited.
- * @returns null if allowed, or a message string if blocked.
- */
-export declare function checkAuthRateLimit(identifier?: string, baseUrl?: string): string | null;
-/**
- * Record a successful auth for this identifier — clears its failure counter.
- */
-export declare function recordAuthSuccess(identifier?: string, baseUrl?: string): void;
-/**
- * Record a failed auth attempt for this identifier. After MAX_FAILURES, locks out
- * that identifier for COOLDOWN_MS.
- */
-export declare function recordAuthFailure(identifier?: string, baseUrl?: string): void;
-//# sourceMappingURL=rate-limiter.d.ts.map

package/dist/utils/rate-limiter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rate-limiter.d.ts","sourceRoot":"","sources":["../../src/utils/rate-limiter.ts"],"names":[],"mappings":"AAgHA;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAyBvF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAM7E;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAgB7E"}

package/dist/utils/rate-limiter.js

@@ -1,164 +0,0 @@
-// Copyright 2026 Pipeline Builder Contributors
-// SPDX-License-Identifier: Apache-2.0
-import crypto from 'crypto';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-/**
- * Simple file-based rate limiter for auth operations.
- * Tracks failed attempts and enforces a cooldown period after too many failures.
- * State is persisted in a temp file so it survives across CLI invocations.
- *
- * State is keyed per (baseUrl, identifier) so a failed login for one account does
- * NOT lock out another account on a shared workstation / CI host. Calls without an
- * identifier fall back to a shared `_default` bucket (coarse anti-bruteforce).
- */
-const STATE_FILE = path.join(os.tmpdir(), '.pipeline-manager-auth-state.json');
-// Directory-as-mutex guarding the read-modify-write. `mkdir` is atomic on every
-// platform, so concurrent CLI invocations serialize on it instead of racing (a
-// lost increment would under-count toward lockout — see withLock).
-const LOCK_DIR = `${STATE_FILE}.lock`;
-const MAX_FAILURES = 5;
-const COOLDOWN_MS = 60_000; // 1 minute
-const PRUNE_MS = 60 * 60_000; // drop buckets idle for >1h to bound file growth
-const LOCK_STALE_MS = 5_000; // reclaim a lock left by a crashed process
-const LOCK_WAIT_MS = 1_000; // give up waiting after this (best-effort: proceed unlocked)
-const LOCK_RETRY_MS = 15; // spin interval while the lock is held
-const EMPTY = { failures: 0, lastFailure: 0, lockedUntil: 0 };
-/** Stable, non-reversible bucket key for a (baseUrl, identifier) pair. */
-function keyFor(identifier, baseUrl) {
-    if (!identifier)
-        return '_default';
-    return crypto.createHash('sha256').update(`${baseUrl ?? ''}\n${identifier}`).digest('hex').slice(0, 16);
-}
-function readMap() {
-    try {
-        if (fs.existsSync(STATE_FILE)) {
-            const parsed = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
-            if (parsed && typeof parsed === 'object')
-                return parsed;
-        }
-    }
-    catch { /* ignore corrupt state */ }
-    return {};
-}
-function writeMap(map) {
-    const now = Date.now();
-    // Prune idle buckets so the file doesn't grow unbounded across many identifiers.
-    for (const [k, s] of Object.entries(map)) {
-        if (s.lockedUntil <= now && now - s.lastFailure > PRUNE_MS)
-            delete map[k];
-    }
-    try {
-        // Write to a per-process temp file then rename: rename is atomic on the same
-        // filesystem, so a concurrent reader never observes a torn/half-written file.
-        const tmp = `${STATE_FILE}.${process.pid}.tmp`;
-        fs.writeFileSync(tmp, JSON.stringify(map), { mode: 0o600 });
-        fs.renameSync(tmp, STATE_FILE);
-    }
-    catch { /* best-effort */ }
-}
-/** Block the current thread for `ms` without a busy-wait (CLI-only, short waits). */
-function sleep(ms) {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-/**
- * Run `fn` while holding a cross-process advisory lock so the read-modify-write in
- * recordAuthFailure/Success can't lose an update to a concurrent CLI invocation
- * (the TOCTOU that let parallel runs under-count toward lockout). Best-effort: if
- * the lock can't be acquired within LOCK_WAIT_MS we proceed anyway rather than
- * block the user — server-side rate limiting remains the real enforcement.
- */
-function withLock(fn) {
-    const deadline = Date.now() + LOCK_WAIT_MS;
-    let held = false;
-    while (Date.now() < deadline) {
-        try {
-            fs.mkdirSync(LOCK_DIR);
-            held = true;
-            break;
-        }
-        catch {
-            // Held elsewhere — reclaim it if it's stale (owner crashed without cleanup),
-            // otherwise wait a beat and retry.
-            try {
-                if (Date.now() - fs.statSync(LOCK_DIR).mtimeMs > LOCK_STALE_MS) {
-                    fs.rmdirSync(LOCK_DIR);
-                    continue;
-                }
-            }
-            catch { /* lock vanished between calls — just retry */ }
-            sleep(LOCK_RETRY_MS);
-        }
-    }
-    try {
-        return fn();
-    }
-    finally {
-        if (held) {
-            try {
-                fs.rmdirSync(LOCK_DIR);
-            }
-            catch { /* already gone */ }
-        }
-    }
-}
-/**
- * Check if auth attempts for this identifier are currently rate-limited.
- * @returns null if allowed, or a message string if blocked.
- */
-export function checkAuthRateLimit(identifier, baseUrl) {
-    const key = keyFor(identifier, baseUrl);
-    const map = readMap();
-    const state = map[key] ?? EMPTY;
-    const now = Date.now();
-    if (state.lockedUntil > now) {
-        const waitSec = Math.ceil((state.lockedUntil - now) / 1000);
-        return `Too many failed login attempts. Try again in ${waitSec}s.`;
-    }
-    // Reset this bucket once the cooldown window has passed. Re-read under the lock
-    // so we don't clobber a concurrent recordAuthFailure for another bucket.
-    if (state.lastFailure !== 0 && now - state.lastFailure > COOLDOWN_MS) {
-        withLock(() => {
-            const m = readMap();
-            const s = m[key];
-            if (s && s.lastFailure !== 0 && Date.now() - s.lastFailure > COOLDOWN_MS) {
-                delete m[key];
-                writeMap(m);
-            }
-        });
-    }
-    return null;
-}
-/**
- * Record a successful auth for this identifier — clears its failure counter.
- */
-export function recordAuthSuccess(identifier, baseUrl) {
-    withLock(() => {
-        const map = readMap();
-        delete map[keyFor(identifier, baseUrl)];
-        writeMap(map);
-    });
-}
-/**
- * Record a failed auth attempt for this identifier. After MAX_FAILURES, locks out
- * that identifier for COOLDOWN_MS.
- */
-export function recordAuthFailure(identifier, baseUrl) {
-    const key = keyFor(identifier, baseUrl);
-    // Read-modify-write under the lock: a concurrent CLI invocation must not read the
-    // same pre-increment count and overwrite this one (which would under-count).
-    withLock(() => {
-        const map = readMap();
-        const now = Date.now();
-        const state = { ...(map[key] ?? EMPTY) };
-        state.failures += 1;
-        state.lastFailure = now;
-        if (state.failures >= MAX_FAILURES) {
-            state.lockedUntil = now + COOLDOWN_MS;
-        }
-        map[key] = state;
-        writeMap(map);
-    });
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rate-limiter.js","sourceRoot":"","sources":["../../src/utils/rate-limiter.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport crypto from 'crypto';\nimport fs from 'fs';\nimport os from 'os';\nimport path from 'path';\n\n/**\n * Simple file-based rate limiter for auth operations.\n * Tracks failed attempts and enforces a cooldown period after too many failures.\n * State is persisted in a temp file so it survives across CLI invocations.\n *\n * State is keyed per (baseUrl, identifier) so a failed login for one account does\n * NOT lock out another account on a shared workstation / CI host. Calls without an\n * identifier fall back to a shared `_default` bucket (coarse anti-bruteforce).\n */\n\nconst STATE_FILE = path.join(os.tmpdir(), '.pipeline-manager-auth-state.json');\n// Directory-as-mutex guarding the read-modify-write. `mkdir` is atomic on every\n// platform, so concurrent CLI invocations serialize on it instead of racing (a\n// lost increment would under-count toward lockout — see withLock).\nconst LOCK_DIR = `${STATE_FILE}.lock`;\nconst MAX_FAILURES = 5;\nconst COOLDOWN_MS = 60_000; // 1 minute\nconst PRUNE_MS = 60 * 60_000; // drop buckets idle for >1h to bound file growth\nconst LOCK_STALE_MS = 5_000; // reclaim a lock left by a crashed process\nconst LOCK_WAIT_MS = 1_000; // give up waiting after this (best-effort: proceed unlocked)\nconst LOCK_RETRY_MS = 15; // spin interval while the lock is held\n\ninterface AuthState {\n  failures: number;\n  lastFailure: number;\n  lockedUntil: number;\n}\n\ntype StateMap = Record<string, AuthState>;\n\nconst EMPTY: AuthState = { failures: 0, lastFailure: 0, lockedUntil: 0 };\n\n/** Stable, non-reversible bucket key for a (baseUrl, identifier) pair. */\nfunction keyFor(identifier?: string, baseUrl?: string): string {\n  if (!identifier) return '_default';\n  return crypto.createHash('sha256').update(`${baseUrl ?? ''}\\n${identifier}`).digest('hex').slice(0, 16);\n}\n\nfunction readMap(): StateMap {\n  try {\n    if (fs.existsSync(STATE_FILE)) {\n      const parsed = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8')) as unknown;\n      if (parsed && typeof parsed === 'object') return parsed as StateMap;\n    }\n  } catch { /* ignore corrupt state */ }\n  return {};\n}\n\nfunction writeMap(map: StateMap): void {\n  const now = Date.now();\n  // Prune idle buckets so the file doesn't grow unbounded across many identifiers.\n  for (const [k, s] of Object.entries(map)) {\n    if (s.lockedUntil <= now && now - s.lastFailure > PRUNE_MS) delete map[k];\n  }\n  try {\n    // Write to a per-process temp file then rename: rename is atomic on the same\n    // filesystem, so a concurrent reader never observes a torn/half-written file.\n    const tmp = `${STATE_FILE}.${process.pid}.tmp`;\n    fs.writeFileSync(tmp, JSON.stringify(map), { mode: 0o600 });\n    fs.renameSync(tmp, STATE_FILE);\n  } catch { /* best-effort */ }\n}\n\n/** Block the current thread for `ms` without a busy-wait (CLI-only, short waits). */\nfunction sleep(ms: number): void {\n  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);\n}\n\n/**\n * Run `fn` while holding a cross-process advisory lock so the read-modify-write in\n * recordAuthFailure/Success can't lose an update to a concurrent CLI invocation\n * (the TOCTOU that let parallel runs under-count toward lockout). Best-effort: if\n * the lock can't be acquired within LOCK_WAIT_MS we proceed anyway rather than\n * block the user — server-side rate limiting remains the real enforcement.\n */\nfunction withLock<T>(fn: () => T): T {\n  const deadline = Date.now() + LOCK_WAIT_MS;\n  let held = false;\n  while (Date.now() < deadline) {\n    try {\n      fs.mkdirSync(LOCK_DIR);\n      held = true;\n      break;\n    } catch {\n      // Held elsewhere — reclaim it if it's stale (owner crashed without cleanup),\n      // otherwise wait a beat and retry.\n      try {\n        if (Date.now() - fs.statSync(LOCK_DIR).mtimeMs > LOCK_STALE_MS) {\n          fs.rmdirSync(LOCK_DIR);\n          continue;\n        }\n      } catch { /* lock vanished between calls — just retry */ }\n      sleep(LOCK_RETRY_MS);\n    }\n  }\n  try {\n    return fn();\n  } finally {\n    if (held) {\n      try { fs.rmdirSync(LOCK_DIR); } catch { /* already gone */ }\n    }\n  }\n}\n\n/**\n * Check if auth attempts for this identifier are currently rate-limited.\n * @returns null if allowed, or a message string if blocked.\n */\nexport function checkAuthRateLimit(identifier?: string, baseUrl?: string): string | null {\n  const key = keyFor(identifier, baseUrl);\n  const map = readMap();\n  const state = map[key] ?? EMPTY;\n  const now = Date.now();\n\n  if (state.lockedUntil > now) {\n    const waitSec = Math.ceil((state.lockedUntil - now) / 1000);\n    return `Too many failed login attempts. Try again in ${waitSec}s.`;\n  }\n\n  // Reset this bucket once the cooldown window has passed. Re-read under the lock\n  // so we don't clobber a concurrent recordAuthFailure for another bucket.\n  if (state.lastFailure !== 0 && now - state.lastFailure > COOLDOWN_MS) {\n    withLock(() => {\n      const m = readMap();\n      const s = m[key];\n      if (s && s.lastFailure !== 0 && Date.now() - s.lastFailure > COOLDOWN_MS) {\n        delete m[key];\n        writeMap(m);\n      }\n    });\n  }\n\n  return null;\n}\n\n/**\n * Record a successful auth for this identifier — clears its failure counter.\n */\nexport function recordAuthSuccess(identifier?: string, baseUrl?: string): void {\n  withLock(() => {\n    const map = readMap();\n    delete map[keyFor(identifier, baseUrl)];\n    writeMap(map);\n  });\n}\n\n/**\n * Record a failed auth attempt for this identifier. After MAX_FAILURES, locks out\n * that identifier for COOLDOWN_MS.\n */\nexport function recordAuthFailure(identifier?: string, baseUrl?: string): void {\n  const key = keyFor(identifier, baseUrl);\n  // Read-modify-write under the lock: a concurrent CLI invocation must not read the\n  // same pre-increment count and overwrite this one (which would under-count).\n  withLock(() => {\n    const map = readMap();\n    const now = Date.now();\n    const state = { ...(map[key] ?? EMPTY) };\n    state.failures += 1;\n    state.lastFailure = now;\n    if (state.failures >= MAX_FAILURES) {\n      state.lockedUntil = now + COOLDOWN_MS;\n    }\n    map[key] = state;\n    writeMap(map);\n  });\n}\n"]}