@pipeline-builder/pipeline-manager 0.0.1

package/dist/utils/plugin-resolver.js

@@ -0,0 +1,101 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { ApiClient } from './api-client.js';
+import { printWarning } from './output-utils.js';
+/**
+ * Cache key matching `PluginLookup.normalize()`: explicit alias when set,
+ * otherwise `${name}-alias`. Must stay in sync with the consumers in
+ * pipeline-core/plugin-lookup.ts and pipeline-builder.ts that read this map.
+ */
+function cacheKey(ref) {
+    return ref.alias || `${ref.name}-alias`;
+}
+/**
+ * Walk the pipeline props tree to collect every plugin reference. Plugins
+ * appear at `synth.plugin` and at `stages[].steps[].plugin`. Entries are
+ * de-duplicated by `cacheKey()` — the same key `PluginLookup.plugin()` uses,
+ * so the resolved-plugins map lookups match downstream.
+ */
+function collectPluginRefs(props) {
+    const refs = [];
+    const seen = new Set();
+    const push = (raw) => {
+        if (!raw || typeof raw !== 'object')
+            return;
+        const r = raw;
+        if (!r.name)
+            return;
+        const key = cacheKey(r);
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        refs.push(r);
+    };
+    const synth = props.synth;
+    push(synth?.plugin);
+    const stages = props.stages;
+    for (const stage of stages ?? []) {
+        for (const step of stage.steps ?? []) {
+            push(step.plugin);
+        }
+    }
+    return refs;
+}
+/**
+ * Pre-resolve plugins by calling the same `POST /api/plugins/lookup` endpoint
+ * the deploy-time custom resource Lambda uses. Returning the full Plugin
+ * record at synth time is what allows the resulting CFN template to ship
+ * with real CodeBuild image URIs (`<host>/<ns>/<name>:<version>`) rather than
+ * the `aws/codebuild/standard:7.0` fallback that the synth-time token path
+ * forces.
+ *
+ * Failures are non-fatal: a missing plugin or unreachable API logs a warning
+ * and falls through to the deploy-time custom resource path so partial
+ * platform outages don't block synth/deploy.
+ *
+ * Keyed by `alias || name` to match `PluginLookup.plugin()`.
+ */
+export async function resolvePluginsForProps(client, props) {
+    const refs = collectPluginRefs(props);
+    if (refs.length === 0)
+        return {};
+    const resolved = {};
+    await Promise.all(refs.map(async (ref) => {
+        const key = cacheKey(ref);
+        // The plugin NAME lives on the ref (a sibling of `filter`), NOT inside the
+        // filter object — but the lookup matches on the filter. A filter without
+        // `name` (e.g. `{version, visibility, isActive, isDefault}`) matches ANY
+        // plugin with those attributes, and the endpoint returns an arbitrary one
+        // (seen: `dockerfile-multi-provider`). That made the synth and every step
+        // resolve to the WRONG plugin. So when the filter omits `name`, fall back to
+        // the ref's plugin name; an explicit filter `name` still takes precedence.
+        const filter = { name: ref.name, ...(ref.filter ?? { isActive: true, isDefault: true }) };
+        try {
+            const res = await client.post('/api/plugins/lookup', { filter });
+            // Unwrap the plugin record from whatever envelope the response middleware
+            // applied. The platform's standard success envelope is
+            // `{ success, statusCode, data: { plugin: Plugin } }` (note the DOUBLE
+            // nesting: data.plugin), but tolerate `{ data: Plugin }`, `{ plugin }`,
+            // and a bare Plugin too. Only stopping at `res.data` (which is
+            // `{ plugin: ... }`) made `.name` undefined → every lookup fell back to
+            // deploy-time resolution even though the catalog had the plugin.
+            const data = res.data;
+            const plugin = data?.plugin // { data: { plugin } }
+                ?? res.plugin // { plugin }
+                ?? data // { data: Plugin }
+                ?? res; // bare Plugin
+            if (plugin && typeof plugin === 'object' && plugin.name) {
+                resolved[key] = plugin;
+            }
+            else {
+                printWarning(`Plugin "${ref.name}" lookup returned no record — falling back to deploy-time resolution`);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            printWarning(`Plugin "${ref.name}" pre-resolution failed (${msg}) — falling back to deploy-time resolution`);
+        }
+    }));
+    return resolved;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-resolver.js","sourceRoot":"","sources":["../../src/utils/plugin-resolver.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { ApiClient } from './api-client.js';\nimport { printWarning } from './output-utils.js';\n\n/** Minimal plugin reference shape — matches PluginOptions from pipeline-core. */\ninterface PluginRef {\n  name: string;\n  alias?: string;\n  filter?: Record<string, unknown>;\n}\n\n/**\n * Cache key matching `PluginLookup.normalize()`: explicit alias when set,\n * otherwise `${name}-alias`. Must stay in sync with the consumers in\n * pipeline-core/plugin-lookup.ts and pipeline-builder.ts that read this map.\n */\nfunction cacheKey(ref: PluginRef): string {\n  return ref.alias || `${ref.name}-alias`;\n}\n\n/**\n * Walk the pipeline props tree to collect every plugin reference. Plugins\n * appear at `synth.plugin` and at `stages[].steps[].plugin`. Entries are\n * de-duplicated by `cacheKey()` — the same key `PluginLookup.plugin()` uses,\n * so the resolved-plugins map lookups match downstream.\n */\nfunction collectPluginRefs(props: Record<string, unknown>): PluginRef[] {\n  const refs: PluginRef[] = [];\n  const seen = new Set<string>();\n\n  const push = (raw: unknown): void => {\n    if (!raw || typeof raw !== 'object') return;\n    const r = raw as PluginRef;\n    if (!r.name) return;\n    const key = cacheKey(r);\n    if (seen.has(key)) return;\n    seen.add(key);\n    refs.push(r);\n  };\n\n  const synth = props.synth as { plugin?: unknown } | undefined;\n  push(synth?.plugin);\n\n  const stages = props.stages as Array<{ steps?: Array<{ plugin?: unknown }> }> | undefined;\n  for (const stage of stages ?? []) {\n    for (const step of stage.steps ?? []) {\n      push(step.plugin);\n    }\n  }\n\n  return refs;\n}\n\n/**\n * Pre-resolve plugins by calling the same `POST /api/plugins/lookup` endpoint\n * the deploy-time custom resource Lambda uses. Returning the full Plugin\n * record at synth time is what allows the resulting CFN template to ship\n * with real CodeBuild image URIs (`<host>/<ns>/<name>:<version>`) rather than\n * the `aws/codebuild/standard:7.0` fallback that the synth-time token path\n * forces.\n *\n * Failures are non-fatal: a missing plugin or unreachable API logs a warning\n * and falls through to the deploy-time custom resource path so partial\n * platform outages don't block synth/deploy.\n *\n * Keyed by `alias || name` to match `PluginLookup.plugin()`.\n */\nexport async function resolvePluginsForProps(\n  client: ApiClient,\n  props: Record<string, unknown>,\n): Promise<Record<string, unknown>> {\n  const refs = collectPluginRefs(props);\n  if (refs.length === 0) return {};\n\n  const resolved: Record<string, unknown> = {};\n\n  await Promise.all(refs.map(async (ref) => {\n    const key = cacheKey(ref);\n    // The plugin NAME lives on the ref (a sibling of `filter`), NOT inside the\n    // filter object — but the lookup matches on the filter. A filter without\n    // `name` (e.g. `{version, visibility, isActive, isDefault}`) matches ANY\n    // plugin with those attributes, and the endpoint returns an arbitrary one\n    // (seen: `dockerfile-multi-provider`). That made the synth and every step\n    // resolve to the WRONG plugin. So when the filter omits `name`, fall back to\n    // the ref's plugin name; an explicit filter `name` still takes precedence.\n    const filter = { name: ref.name, ...(ref.filter ?? { isActive: true, isDefault: true }) };\n    try {\n      const res = await client.post<unknown>('/api/plugins/lookup', { filter });\n      // Unwrap the plugin record from whatever envelope the response middleware\n      // applied. The platform's standard success envelope is\n      // `{ success, statusCode, data: { plugin: Plugin } }` (note the DOUBLE\n      // nesting: data.plugin), but tolerate `{ data: Plugin }`, `{ plugin }`,\n      // and a bare Plugin too. Only stopping at `res.data` (which is\n      // `{ plugin: ... }`) made `.name` undefined → every lookup fell back to\n      // deploy-time resolution even though the catalog had the plugin.\n      const data = (res as { data?: unknown }).data;\n      const plugin =\n        (data as { plugin?: unknown } | undefined)?.plugin // { data: { plugin } }\n        ?? (res as { plugin?: unknown }).plugin // { plugin }\n        ?? data // { data: Plugin }\n        ?? res; // bare Plugin\n      if (plugin && typeof plugin === 'object' && (plugin as { name?: string }).name) {\n        resolved[key] = plugin;\n      } else {\n        printWarning(`Plugin \"${ref.name}\" lookup returned no record — falling back to deploy-time resolution`);\n      }\n    } catch (err) {\n      const msg = err instanceof Error ? err.message : String(err);\n      printWarning(`Plugin \"${ref.name}\" pre-resolution failed (${msg}) — falling back to deploy-time resolution`);\n    }\n  }));\n\n  return resolved;\n}\n"]}

package/dist/utils/preflight.d.ts

@@ -0,0 +1,26 @@
+import { type Command } from 'commander';
+export type LocalTool = 'cdk' | 'bundler';
+/**
+ * Per-command local-tool requirements, checked by the CLI's `preAction` hook
+ * BEFORE a command's action runs — so a missing tool fails fast with an
+ * actionable message instead of deep inside a CDK bundle. Keyed by full command
+ * path (e.g. "pipeline deploy").
+ *
+ * Only `pipeline synth`/`deploy` shell out to cdk (+ esbuild/pnpm for the
+ * PluginLookup Lambda bundle). Every other command is API-only and requires
+ * nothing local, so it's absent here and never gated — as are version / help /
+ * completions. (`infra provision` runs its own target-specific prereq checks.)
+ */
+export declare const COMMAND_TOOL_REQUIREMENTS: Record<string, LocalTool[]>;
+/** Full space-joined command path for a Commander command, e.g. "pipeline deploy". */
+export declare function commandPath(cmd: Command): string;
+/** The local tools a command declares it needs (empty when it needs nothing). */
+export declare function requiredToolsFor(cmd: Command): LocalTool[];
+/**
+ * Preflight the local tools an about-to-run command declares. Reuses the tools'
+ * `ensureX` helpers (which print the actionable message + install hint on
+ * failure), then exits non-zero so the command body never runs. No-op for any
+ * command without requirements (API-only commands, version/help/completions).
+ */
+export declare function preflightCommandTools(actionCommand: Command): void;
+//# sourceMappingURL=preflight.d.ts.map

package/dist/utils/preflight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preflight.d.ts","sourceRoot":"","sources":["../../src/utils/preflight.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAGzC,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,SAAS,CAAC;AAE1C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,CAMjE,CAAC;AAEF,sFAAsF;AACtF,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAQhD;AAED,iFAAiF;AACjF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,EAAE,CAE1D;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,OAAO,GAAG,IAAI,CAWlE"}

package/dist/utils/preflight.js

@@ -0,0 +1,59 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import {} from 'commander';
+import { ensureBundlerAvailable, ensureCdkAvailable } from './cdk-utils.js';
+/**
+ * Per-command local-tool requirements, checked by the CLI's `preAction` hook
+ * BEFORE a command's action runs — so a missing tool fails fast with an
+ * actionable message instead of deep inside a CDK bundle. Keyed by full command
+ * path (e.g. "pipeline deploy").
+ *
+ * Only `pipeline synth`/`deploy` shell out to cdk (+ esbuild/pnpm for the
+ * PluginLookup Lambda bundle). Every other command is API-only and requires
+ * nothing local, so it's absent here and never gated — as are version / help /
+ * completions. (`infra provision` runs its own target-specific prereq checks.)
+ */
+export const COMMAND_TOOL_REQUIREMENTS = {
+    'pipeline synth': ['cdk', 'bundler'],
+    'pipeline deploy': ['cdk', 'bundler'],
+    // `infra bootstrap` runs `cdk bootstrap` (AWS env bootstrap) — cdk only; it
+    // synthesizes no Lambda, so no esbuild/pnpm bundler is needed.
+    'infra bootstrap': ['cdk'],
+};
+/** Full space-joined command path for a Commander command, e.g. "pipeline deploy". */
+export function commandPath(cmd) {
+    const parts = [];
+    let c = cmd;
+    while (c && c.parent) {
+        parts.unshift(c.name());
+        c = c.parent ?? undefined;
+    }
+    return parts.join(' ');
+}
+/** The local tools a command declares it needs (empty when it needs nothing). */
+export function requiredToolsFor(cmd) {
+    return COMMAND_TOOL_REQUIREMENTS[commandPath(cmd)] ?? [];
+}
+/**
+ * Preflight the local tools an about-to-run command declares. Reuses the tools'
+ * `ensureX` helpers (which print the actionable message + install hint on
+ * failure), then exits non-zero so the command body never runs. No-op for any
+ * command without requirements (API-only commands, version/help/completions).
+ */
+export function preflightCommandTools(actionCommand) {
+    const reqs = requiredToolsFor(actionCommand);
+    if (reqs.length === 0)
+        return;
+    try {
+        if (reqs.includes('cdk'))
+            ensureCdkAvailable();
+        if (reqs.includes('bundler'))
+            ensureBundlerAvailable();
+    }
+    catch {
+        // Message already printed by ensureX. Halt before the action runs so the
+        // command doesn't proceed with a broken toolchain.
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,15 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,164 @@
+// 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"]}

package/dist/utils/registry.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Helpers for registering a deployed pipeline ARN with the platform.
+ *
+ * The registry table maps deployed CodePipeline ARNs back to pipeline records
+ * and orgs. It's how the dashboard's "Deployed pipelines" panel and the event
+ * reporting Lambda resolve incoming events to a pipeline definition.
+ *
+ * Two failure modes are handled here:
+ *
+ *   1. Platform unreachable at deploy time. The CDK stack lands in AWS but the
+ *      registry POST fails. Without retry the deploy command would have to
+ *      re-run cdk-deploy (slow, sometimes blocked by stack state) just to
+ *      record the ARN. Instead, we write a pending intent to a local file;
+ *      `pipeline-manager pipeline register` drains them.
+ *
+ *   2. User explicitly invokes `pipeline-manager pipeline register --id <pipelineId>`
+ *      after a successful deploy that didn't register. Same path: rebuilds
+ *      the ARN from STS, POSTs to the platform.
+ *
+ * Pending intents store ONLY the registration payload — never tokens or URLs.
+ * Auth is supplied by whichever command drains the intent (deploy or register),
+ * so a stale intent file is never an authentication risk.
+ */
+/**
+ * Platform-sourced registry pull target for the CDK synth, derived from the
+ * platform base URL the CLI deploys against (the same host that serves the
+ * registry `/v2/` data path via nginx). Reuses pipeline-core's
+ * `parsePlatformBaseUrl` so host/port parsing stays identical on both sides.
+ * Returns `undefined` for an unparseable/absent URL. (Only the pull host/port
+ * are returned — `registry.http` describes the in-cluster push hop, which the
+ * synth never reads, so deriving it from the public URL would be misleading.)
+ */
+export declare function registryOverrideFromBaseUrl(baseUrl: string | undefined): {
+    pullHost: string;
+    pullPort: number;
+} | undefined;
+/**
+ * Bake the platform-derived registry pull target into the synth props
+ * (`BuilderProps.registry`) so the CodeBuild image URIs use a host AWS CodeBuild
+ * can resolve — not the in-cluster `registry:5000` default. Shared by the
+ * `deploy` and `synth` commands.
+ *
+ * An explicit `IMAGE_REGISTRY_PULL_HOST` in the synth env takes precedence, so
+ * this is a no-op when it is set (the synth's `loadRegistryConfig` already
+ * honors it). Also a no-op for an unparseable/absent base URL.
+ */
+export declare function bakePlatformRegistry(props: Record<string, unknown>, baseUrl: string | undefined): void;
+/** Shape of the body POSTed to /api/pipelines/registry. */
+export interface RegistryPayload {
+    pipelineId: string;
+    orgId: string;
+    pipelineName: string;
+    region: string;
+    project: string;
+    organization: string;
+    stackName: string;
+}
+/** Pipeline fields needed to construct a RegistryPayload. */
+export interface PipelineForRegistry {
+    id: string;
+    orgId: string;
+    pipelineName?: string;
+    project: string;
+    organization: string;
+}
+/**
+ * Build a RegistryPayload from the platform's pipeline metadata. No AWS calls
+ * and no ARN/account: the events Lambda attributes events via the pipeline's
+ * `pb.pipeline-id` tag (= pipelineId), so the registry only needs the stable
+ * pipelineId + display metadata.
+ */
+export declare function buildRegistryPayload(pipeline: PipelineForRegistry, regionOverride?: string): Promise<RegistryPayload>;
+/**
+ * Persist a registration intent for later retry.
+ *
+ * Intent files are keyed by pipelineId so re-running deploy on the same
+ * pipeline overwrites rather than accumulates. We deliberately store the
+ * payload plain (not the full pipeline doc, not auth) so a stale file is
+ * safe to leave around indefinitely.
+ */
+export declare function writePendingIntent(payload: RegistryPayload): Promise<string>;
+/** Remove a pending intent after a successful drain. */
+export declare function clearPendingIntent(pipelineId: string): Promise<void>;
+/** Read all pending intents currently on disk. Empty array if dir doesn't exist. */
+export declare function readPendingIntents(): Promise<RegistryPayload[]>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/utils/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/utils/registry.ts"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,MAAM,GAAG,SAAS,GAC1B;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAGpD;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAMtG;AAED,2DAA2D;AAC3D,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,6DAA6D;AAC7D,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;CACtB;AAKD;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,mBAAmB,EAC7B,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,eAAe,CAAC,CAgB1B;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAKlF;AAED,wDAAwD;AACxD,wBAAsB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ1E;AAED,oFAAoF;AACpF,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC,CAqBrE"}