@pipeline-builder/pipeline-manager 3.4.125 → 3.4.127

package/dist/utils/cron.js

@@ -0,0 +1,115 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Convert a standard 5-field cron expression into an AWS EventBridge cron
+ * expression, and guard against schedules that fire more often than every
+ * 15 minutes.
+ *
+ * Standard cron:    `minute hour day-of-month month day-of-week`
+ * EventBridge cron: `cron(minute hour day-of-month month day-of-week year)`
+ *
+ * The non-obvious differences EventBridge imposes:
+ *  - a 6th field (year), which we always set to `*`;
+ *  - day-of-month and day-of-week may NOT both be `*` — exactly one must be `?`;
+ *  - day-of-week is 1–7 with 1 = Sunday, whereas standard cron is 0–6 (or 7)
+ *    with 0/7 = Sunday — so numeric day-of-week values must be remapped.
+ */
+/** Minimum allowed spacing between fires, in minutes. */
+export const MIN_SCHEDULE_INTERVAL_MIN = 15;
+/** Expand a cron minute field (wildcard, step "/n", ranges "a-b", lists "a,b") to the sorted set of minutes it fires on. */
+function expandMinuteField(field) {
+    const out = new Set();
+    for (const part of field.split(',')) {
+        const slash = part.split('/');
+        const rangePart = slash[0] ?? '';
+        const stepPart = slash[1];
+        const step = stepPart !== undefined ? parseInt(stepPart, 10) : 1;
+        if (stepPart !== undefined && (!Number.isInteger(step) || step < 1)) {
+            throw new Error(`Invalid step in minute field: "${part}"`);
+        }
+        let lo;
+        let hi;
+        if (rangePart === '*') {
+            lo = 0;
+            hi = 59;
+        }
+        else if (rangePart.includes('-')) {
+            const ends = rangePart.split('-');
+            lo = parseInt(ends[0] ?? '', 10);
+            hi = parseInt(ends[1] ?? '', 10);
+        }
+        else {
+            lo = hi = parseInt(rangePart, 10);
+        }
+        if (!Number.isInteger(lo) || !Number.isInteger(hi) || lo < 0 || hi > 59 || lo > hi) {
+            throw new Error(`Invalid minute field: "${part}"`);
+        }
+        for (let m = lo; m <= hi; m += step)
+            out.add(m);
+    }
+    return [...out].sort((a, b) => a - b);
+}
+/**
+ * Throw if `fiveField` would fire more often than every {@link MIN_SCHEDULE_INTERVAL_MIN}
+ * minutes. Conservative: the smallest cyclic gap in the minute field is the worst-case
+ * spacing (it's only ever larger once the hour/day fields restrict things further).
+ */
+export function assertScheduleInterval(fiveField) {
+    const parts = fiveField.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error(`Schedule must be a 5-field cron ("minute hour day-of-month month day-of-week"), got: "${fiveField}"`);
+    }
+    const minutes = expandMinuteField(parts[0]);
+    if (minutes.length === 0)
+        throw new Error(`Minute field matches nothing: "${parts[0]}"`);
+    // Smallest cyclic gap across the hour boundary (e.g. {0,50} → gaps 50 and 10).
+    let minGap = 60;
+    if (minutes.length > 1) {
+        for (let i = 0; i < minutes.length; i++) {
+            const cur = minutes[i];
+            const next = minutes[(i + 1) % minutes.length];
+            const gap = (next - cur + 60) % 60 || 60;
+            minGap = Math.min(minGap, gap);
+        }
+    }
+    if (minGap < MIN_SCHEDULE_INTERVAL_MIN) {
+        throw new Error(`Schedule "${fiveField}" fires every ${minGap} minute(s); the minimum is ${MIN_SCHEDULE_INTERVAL_MIN}. ` +
+            `Use a sparser schedule (e.g. "0 0 * * *" for daily, "*/15 * * * *" for the densest allowed).`);
+    }
+}
+/** Remap a standard cron day-of-week token (0–7, 0/7=Sun) to EventBridge (1–7, 1=Sun). Passes through names and `*`/`?`. */
+function remapDayOfWeek(field) {
+    if (field === '*' || field === '?')
+        return field;
+    // Token may contain lists/ranges/steps of numbers and/or 3-letter names.
+    return field.replace(/\d+/g, (n) => {
+        const v = parseInt(n, 10);
+        if (v < 0 || v > 7)
+            throw new Error(`Invalid day-of-week value: "${n}"`);
+        return String((v % 7) + 1); // 0→1 (Sun), 6→7 (Sat), 7→1 (Sun)
+    });
+}
+/**
+ * Convert a validated 5-field cron expression to an AWS EventBridge `cron(...)`
+ * expression. Also enforces the 15-minute guard.
+ */
+export function toEventBridgeCron(fiveField) {
+    assertScheduleInterval(fiveField); // also validates the 5-field shape
+    const f = fiveField.trim().split(/\s+/);
+    const [minute, hour, domRaw, month, dowRaw] = [f[0], f[1], f[2], f[3], f[4]];
+    let dom = domRaw;
+    let dow = remapDayOfWeek(dowRaw);
+    // EventBridge: exactly one of day-of-month / day-of-week must be `?`.
+    if (dom === '*' && dow === '*') {
+        dow = '?'; // unrestricted both → pin day-of-week to ?
+    }
+    else if (dom !== '*' && dow === '*') {
+        dow = '?'; // specific day-of-month → day-of-week must be ?
+    }
+    else if (dom === '*' && dow !== '*') {
+        dom = '?'; // specific day-of-week → day-of-month must be ?
+    }
+    // (both specific is left as-is; EventBridge rejects it, surfacing a clear error)
+    return `cron(${minute} ${hour} ${dom} ${month} ${dow} *)`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cron.js","sourceRoot":"","sources":["../../src/utils/cron.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Convert a standard 5-field cron expression into an AWS EventBridge cron\n * expression, and guard against schedules that fire more often than every\n * 15 minutes.\n *\n * Standard cron:    `minute hour day-of-month month day-of-week`\n * EventBridge cron: `cron(minute hour day-of-month month day-of-week year)`\n *\n * The non-obvious differences EventBridge imposes:\n *  - a 6th field (year), which we always set to `*`;\n *  - day-of-month and day-of-week may NOT both be `*` — exactly one must be `?`;\n *  - day-of-week is 1–7 with 1 = Sunday, whereas standard cron is 0–6 (or 7)\n *    with 0/7 = Sunday — so numeric day-of-week values must be remapped.\n */\n\n/** Minimum allowed spacing between fires, in minutes. */\nexport const MIN_SCHEDULE_INTERVAL_MIN = 15;\n\n/** Expand a cron minute field (wildcard, step \"/n\", ranges \"a-b\", lists \"a,b\") to the sorted set of minutes it fires on. */\nfunction expandMinuteField(field: string): number[] {\n  const out = new Set<number>();\n  for (const part of field.split(',')) {\n    const slash = part.split('/');\n    const rangePart = slash[0] ?? '';\n    const stepPart = slash[1];\n    const step = stepPart !== undefined ? parseInt(stepPart, 10) : 1;\n    if (stepPart !== undefined && (!Number.isInteger(step) || step < 1)) {\n      throw new Error(`Invalid step in minute field: \"${part}\"`);\n    }\n    let lo: number;\n    let hi: number;\n    if (rangePart === '*') {\n      lo = 0; hi = 59;\n    } else if (rangePart.includes('-')) {\n      const ends = rangePart.split('-');\n      lo = parseInt(ends[0] ?? '', 10);\n      hi = parseInt(ends[1] ?? '', 10);\n    } else {\n      lo = hi = parseInt(rangePart, 10);\n    }\n    if (!Number.isInteger(lo) || !Number.isInteger(hi) || lo < 0 || hi > 59 || lo > hi) {\n      throw new Error(`Invalid minute field: \"${part}\"`);\n    }\n    for (let m = lo; m <= hi; m += step) out.add(m);\n  }\n  return [...out].sort((a, b) => a - b);\n}\n\n/**\n * Throw if `fiveField` would fire more often than every {@link MIN_SCHEDULE_INTERVAL_MIN}\n * minutes. Conservative: the smallest cyclic gap in the minute field is the worst-case\n * spacing (it's only ever larger once the hour/day fields restrict things further).\n */\nexport function assertScheduleInterval(fiveField: string): void {\n  const parts = fiveField.trim().split(/\\s+/);\n  if (parts.length !== 5) {\n    throw new Error(`Schedule must be a 5-field cron (\"minute hour day-of-month month day-of-week\"), got: \"${fiveField}\"`);\n  }\n  const minutes = expandMinuteField(parts[0]!);\n  if (minutes.length === 0) throw new Error(`Minute field matches nothing: \"${parts[0]}\"`);\n  // Smallest cyclic gap across the hour boundary (e.g. {0,50} → gaps 50 and 10).\n  let minGap = 60;\n  if (minutes.length > 1) {\n    for (let i = 0; i < minutes.length; i++) {\n      const cur = minutes[i]!;\n      const next = minutes[(i + 1) % minutes.length]!;\n      const gap = (next - cur + 60) % 60 || 60;\n      minGap = Math.min(minGap, gap);\n    }\n  }\n  if (minGap < MIN_SCHEDULE_INTERVAL_MIN) {\n    throw new Error(\n      `Schedule \"${fiveField}\" fires every ${minGap} minute(s); the minimum is ${MIN_SCHEDULE_INTERVAL_MIN}. ` +\n      `Use a sparser schedule (e.g. \"0 0 * * *\" for daily, \"*/15 * * * *\" for the densest allowed).`,\n    );\n  }\n}\n\n/** Remap a standard cron day-of-week token (0–7, 0/7=Sun) to EventBridge (1–7, 1=Sun). Passes through names and `*`/`?`. */\nfunction remapDayOfWeek(field: string): string {\n  if (field === '*' || field === '?') return field;\n  // Token may contain lists/ranges/steps of numbers and/or 3-letter names.\n  return field.replace(/\\d+/g, (n) => {\n    const v = parseInt(n, 10);\n    if (v < 0 || v > 7) throw new Error(`Invalid day-of-week value: \"${n}\"`);\n    return String((v % 7) + 1); // 0→1 (Sun), 6→7 (Sat), 7→1 (Sun)\n  });\n}\n\n/**\n * Convert a validated 5-field cron expression to an AWS EventBridge `cron(...)`\n * expression. Also enforces the 15-minute guard.\n */\nexport function toEventBridgeCron(fiveField: string): string {\n  assertScheduleInterval(fiveField); // also validates the 5-field shape\n  const f = fiveField.trim().split(/\\s+/);\n  const [minute, hour, domRaw, month, dowRaw] = [f[0]!, f[1]!, f[2]!, f[3]!, f[4]!];\n\n  let dom = domRaw;\n  let dow = remapDayOfWeek(dowRaw);\n\n  // EventBridge: exactly one of day-of-month / day-of-week must be `?`.\n  if (dom === '*' && dow === '*') {\n    dow = '?'; // unrestricted both → pin day-of-week to ?\n  } else if (dom !== '*' && dow === '*') {\n    dow = '?'; // specific day-of-month → day-of-week must be ?\n  } else if (dom === '*' && dow !== '*') {\n    dom = '?'; // specific day-of-week → day-of-month must be ?\n  }\n  // (both specific is left as-is; EventBridge rejects it, surfacing a clear error)\n\n  return `cron(${minute} ${hour} ${dom} ${month} ${dow} *)`;\n}\n"]}

package/dist/utils/pipeline-config.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared pipeline-config resolution used by both `synth` and `deploy` so the two
+ * commands fetch, plugin-resolve, registry-bake, and template-preview identically
+ * (they previously kept near-duplicate copies that could drift).
+ */
+import type { Pipeline } from '../types/pipeline.js';
+import type { ApiClient } from './api-client.js';
+export interface FetchedPipeline {
+    /** The raw pipeline record (id/org/project/flags) as returned by the platform. */
+    readonly pipeline: Pipeline;
+    /** props + pipelineId (+ orgId) + resolvedPlugins, with the registry pull-host baked in. */
+    readonly propsWithIds: Record<string, unknown>;
+    /** The resolved platform base URL the config was fetched against. */
+    readonly baseUrl: string;
+}
+/**
+ * Fetch a pipeline by id and build the synth/deploy props:
+ *  - GET the pipeline and validate it has `props`,
+ *  - assemble `propsWithIds` (props + pipelineId + orgId),
+ *  - pre-resolve plugins so the template ships real CodeBuild image URIs
+ *    (otherwise CDK falls back to standard:7.0 at deploy time),
+ *  - bake the registry pull-host from the platform URL (no-op when
+ *    IMAGE_REGISTRY_PULL_HOST is set).
+ */
+export declare function fetchPipelineProps(client: ApiClient, pipelineId: string): Promise<FetchedPipeline>;
+/**
+ * Apply pass-1 self-referencing template resolution to `propsWithIds` and print it
+ * to stdout (used by `synth --show-resolved` / `deploy --show-resolved`). Exits with
+ * code 1 if resolution reports errors. `resolveSelfReferencing` mutates the object
+ * in place, so the printed JSON reflects the expanded templates.
+ */
+export declare function printResolvedOrExit(propsWithIds: Record<string, unknown>): Promise<void>;
+//# sourceMappingURL=pipeline-config.d.ts.map

package/dist/utils/pipeline-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline-config.d.ts","sourceRoot":"","sources":["../../src/utils/pipeline-config.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAKjD,MAAM,WAAW,eAAe;IAC9B,kFAAkF;IAClF,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,4FAA4F;IAC5F,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/C,qEAAqE;IACrE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAsBxG;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAW9F"}

package/dist/utils/pipeline-config.js

@@ -0,0 +1,54 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { extractSingleResponse, printInfo } from './output-utils.js';
+import { resolvePluginsForProps } from './plugin-resolver.js';
+import { bakePlatformRegistry } from './registry.js';
+/**
+ * Fetch a pipeline by id and build the synth/deploy props:
+ *  - GET the pipeline and validate it has `props`,
+ *  - assemble `propsWithIds` (props + pipelineId + orgId),
+ *  - pre-resolve plugins so the template ships real CodeBuild image URIs
+ *    (otherwise CDK falls back to standard:7.0 at deploy time),
+ *  - bake the registry pull-host from the platform URL (no-op when
+ *    IMAGE_REGISTRY_PULL_HOST is set).
+ */
+export async function fetchPipelineProps(client, pipelineId) {
+    const config = client.getConfig();
+    const response = await client.get(`${config.api.pipelineUrl}/${pipelineId}`);
+    const pipeline = extractSingleResponse(response, 'pipeline', 'props');
+    if (!pipeline?.props) {
+        throw new Error(`Failed to retrieve pipeline props for ID: ${pipelineId}`);
+    }
+    const propsWithIds = {
+        ...pipeline.props,
+        ...(pipeline.orgId ? { orgId: pipeline.orgId } : {}),
+        pipelineId: pipeline.id || pipelineId,
+    };
+    const resolvedPlugins = await resolvePluginsForProps(client, propsWithIds);
+    if (Object.keys(resolvedPlugins).length > 0) {
+        propsWithIds.resolvedPlugins = resolvedPlugins;
+        printInfo('Pre-resolved plugins', { count: Object.keys(resolvedPlugins).length });
+    }
+    bakePlatformRegistry(propsWithIds, config.api.baseUrl);
+    return { pipeline, propsWithIds, baseUrl: config.api.baseUrl };
+}
+/**
+ * Apply pass-1 self-referencing template resolution to `propsWithIds` and print it
+ * to stdout (used by `synth --show-resolved` / `deploy --show-resolved`). Exits with
+ * code 1 if resolution reports errors. `resolveSelfReferencing` mutates the object
+ * in place, so the printed JSON reflects the expanded templates.
+ */
+export async function printResolvedOrExit(propsWithIds) {
+    const { resolveSelfReferencing } = await import('@pipeline-builder/pipeline-core');
+    const scope = { metadata: propsWithIds.metadata ?? {}, vars: propsWithIds.vars ?? {} };
+    const isTpl = (f) => f === 'projectName' || f.startsWith('metadata.') || f.startsWith('vars.');
+    const result = resolveSelfReferencing(propsWithIds, scope, isTpl, (f) => (isTpl(f) ? f : null), 'pipeline');
+    if (result.errors.length) {
+        console.error('Resolution errors:');
+        for (const e of result.errors)
+            console.error(`  [${e.field ?? '?'}] ${e.message}`);
+        process.exit(1);
+    }
+    console.log(JSON.stringify(propsWithIds, null, 2));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/platform-secret.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"platform-secret.d.ts","sourceRoot":"","sources":["../../src/utils/platform-secret.ts"],"names":[],"mappings":"AAiBA,sEAAsE;AACtE,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOvD;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyBvF;AAED;;;;GAIG;AACH,wBAAsB,yBAAyB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,CAAC,CAY/F"}
+{"version":3,"file":"platform-secret.d.ts","sourceRoot":"","sources":["../../src/utils/platform-secret.ts"],"names":[],"mappings":"AAiBA,sEAAsE;AACtE,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOvD;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6BvF;AAED;;;;GAIG;AACH,wBAAsB,yBAAyB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,CAAC,CAY/F"}

package/dist/utils/platform-secret.js

@@ -11,7 +11,7 @@ import { CoreConstants } from '@pipeline-builder/pipeline-core';
 import axios from 'axios';
 import { decodeTokenPayload } from './auth-guard.js';
 import { getConfigWithOptions } from './config-loader.js';
-import { printInfo, printSection, printSuccess } from './output-utils.js';
+import { printInfo, printSection, printSuccess, printWarning } from './output-utils.js';
 /**
  * Derive the platform secret path from a JWT's organizationId.
  * Pattern: `{SECRETS_PATH_PREFIX}/{orgId}/platform`.
@@ -38,6 +38,9 @@ export async function ensurePlatformToken(options) {
     const loginPassword = options.password || process.env.PLATFORM_PASSWORD;
     if (!loginEmail || !loginPassword)
         return;
+    if (options.password) {
+        printWarning('Passing --password on the command line can expose it via shell history; prefer the PLATFORM_PASSWORD env var.');
+    }
     printSection('Login');
     printInfo('Authenticating with email/password...');
     const config = getConfigWithOptions(options);
@@ -71,4 +74,4 @@ export async function resolvePlatformSecretName(options) {
     }
     return resolveSecretName(process.env.PLATFORM_TOKEN);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"platform-secret.js","sourceRoot":"","sources":["../../src/utils/platform-secret.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;GAMG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAU1E;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAa;IAC7C,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAAC;IAC1C,MAAM,KAAK,GAAG,OAAO,EAAE,cAAc,CAAC;IACtC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CAAC,6GAA6G,CAAC,CAAC;IACjI,CAAC;IACD,OAAO,GAAG,aAAa,CAAC,mBAAmB,IAAI,KAAK,WAAW,CAAC;AAClE,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,OAA8B;IACtE,IAAI,OAAO,CAAC,GAAG,CAAC,cAAc;QAAE,OAAO;IACvC,MAAM,UAAU,GAAG,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC;IACpE,MAAM,aAAa,GAAG,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC;IACxE,IAAI,CAAC,UAAU,IAAI,CAAC,aAAa;QAAE,OAAO;IAE1C,YAAY,CAAC,OAAO,CAAC,CAAC;IACtB,SAAS,CAAC,uCAAuC,CAAC,CAAC;IACnD,MAAM,MAAM,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC;IAC7C,MAAM,aAAa,GAAG,MAAM,KAAK,CAAC,IAAI,CACpC,GAAG,MAAM,CAAC,GAAG,CAAC,OAAO,iBAAiB,EACtC,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,aAAa,EAAE,EAC9C;QACE,UAAU,EAAE,MAAM,CAAC,GAAG,CAAC,kBAAkB,KAAK,KAAK;YACjD,CAAC,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,kBAAkB,EAAE,KAAK,EAAE,CAAC;YAClE,CAAC,CAAC,SAAS;KACd,CACF,CAAC;IACF,MAAM,SAAS,GAAG,aAAa,CAAC,IAAI,EAAE,IAAI,IAAI,aAAa,CAAC,IAAI,CAAC;IACjE,MAAM,UAAU,GAAG,SAAS,EAAE,WAAW,CAAC;IAC1C,IAAI,CAAC,UAAU,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;QAClD,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;IAChE,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,cAAc,GAAG,UAAU,CAAC;IACxC,YAAY,CAAC,kBAAkB,CAAC,CAAC;AACnC,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAAC,OAA8B;IAC5E,MAAM,QAAQ,GAAG,OAAO,CAAC,UAAU,IAAI,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC;IACxE,IAAI,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAC9B,MAAM,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACnC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CACb,gFAAgF;cAC9E,wEAAwE;cACxE,gEAAgE,CACnE,CAAC;IACJ,CAAC;IACD,OAAO,iBAAiB,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;AACvD,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared platform-token → secret-name resolution, used by both `store-token`\n * (which WRITES the JWT to Secrets Manager) and `setup-events` (which deploys the\n * Lambda that READS it). Both must agree on the same secret path, so the logic\n * lives here once: derive `{SECRETS_PATH_PREFIX}/{orgId}/platform` from the JWT's\n * organizationId, logging in first if needed to obtain the token.\n */\n\nimport { CoreConstants } from '@pipeline-builder/pipeline-core';\nimport axios from 'axios';\nimport { decodeTokenPayload } from './auth-guard.js';\nimport { getConfigWithOptions } from './config-loader.js';\nimport { printInfo, printSection, printSuccess } from './output-utils.js';\n\n/** Login/secret options shared across the platform-secret helpers. */\nexport interface PlatformSecretOptions {\n  readonly secretName?: string;\n  readonly email?: string;\n  readonly password?: string;\n  readonly verifySsl?: boolean;\n}\n\n/**\n * Derive the platform secret path from a JWT's organizationId.\n * Pattern: `{SECRETS_PATH_PREFIX}/{orgId}/platform`.\n * @throws if the token carries no organizationId (caller should fall back to --secret-name).\n */\nexport function resolveSecretName(token: string): string {\n  const payload = decodeTokenPayload(token);\n  const orgId = payload?.organizationId;\n  if (!orgId) {\n    throw new Error('Token does not contain organizationId — cannot derive secret name. Use --secret-name to specify explicitly.');\n  }\n  return `${CoreConstants.SECRETS_PATH_PREFIX}/${orgId}/platform`;\n}\n\n/**\n * Ensure `process.env.PLATFORM_TOKEN` is set. No-op if it already is. Otherwise,\n * if login creds are available (`--email/--password` or `PLATFORM_IDENTIFIER`/\n * `PLATFORM_PASSWORD` env — the env path lets `provision` pass creds without\n * putting the password on the command line), log in and set PLATFORM_TOKEN.\n */\nexport async function ensurePlatformToken(options: PlatformSecretOptions): Promise<void> {\n  if (process.env.PLATFORM_TOKEN) return;\n  const loginEmail = options.email || process.env.PLATFORM_IDENTIFIER;\n  const loginPassword = options.password || process.env.PLATFORM_PASSWORD;\n  if (!loginEmail || !loginPassword) return;\n\n  printSection('Login');\n  printInfo('Authenticating with email/password...');\n  const config = getConfigWithOptions(options);\n  const loginResponse = await axios.post(\n    `${config.api.baseUrl}/api/auth/login`,\n    { email: loginEmail, password: loginPassword },\n    {\n      httpsAgent: config.api.rejectUnauthorized === false\n        ? new (await import('https')).Agent({ rejectUnauthorized: false })\n        : undefined,\n    },\n  );\n  const loginData = loginResponse.data?.data ?? loginResponse.data;\n  const loginToken = loginData?.accessToken;\n  if (!loginToken || typeof loginToken !== 'string') {\n    throw new Error('Login failed — no access token in response');\n  }\n  process.env.PLATFORM_TOKEN = loginToken;\n  printSuccess('Login successful');\n}\n\n/**\n * Resolve the platform secret name: an explicit `--secret-name` / `PLATFORM_SECRET_NAME`\n * wins; otherwise log in if needed and derive it from the platform token's org — the\n * same token `init-platform.sh` (register) mints, so writer and reader agree.\n */\nexport async function resolvePlatformSecretName(options: PlatformSecretOptions): Promise<string> {\n  const explicit = options.secretName || process.env.PLATFORM_SECRET_NAME;\n  if (explicit) return explicit;\n  await ensurePlatformToken(options);\n  if (!process.env.PLATFORM_TOKEN) {\n    throw new Error(\n      'Cannot derive the platform secret name: no PLATFORM_TOKEN and no login creds. '\n      + 'Pass --secret-name / set PLATFORM_SECRET_NAME, or provide login creds '\n      + '(--email/--password or PLATFORM_IDENTIFIER/PLATFORM_PASSWORD).',\n    );\n  }\n  return resolveSecretName(process.env.PLATFORM_TOKEN);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"platform-secret.js","sourceRoot":"","sources":["../../src/utils/platform-secret.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared platform-token → secret-name resolution, used by both `store-token`\n * (which WRITES the JWT to Secrets Manager) and `setup-events` (which deploys the\n * Lambda that READS it). Both must agree on the same secret path, so the logic\n * lives here once: derive `{SECRETS_PATH_PREFIX}/{orgId}/platform` from the JWT's\n * organizationId, logging in first if needed to obtain the token.\n */\n\nimport { CoreConstants } from '@pipeline-builder/pipeline-core';\nimport axios from 'axios';\nimport { decodeTokenPayload } from './auth-guard.js';\nimport { getConfigWithOptions } from './config-loader.js';\nimport { printInfo, printSection, printSuccess, printWarning } from './output-utils.js';\n\n/** Login/secret options shared across the platform-secret helpers. */\nexport interface PlatformSecretOptions {\n  readonly secretName?: string;\n  readonly email?: string;\n  readonly password?: string;\n  readonly verifySsl?: boolean;\n}\n\n/**\n * Derive the platform secret path from a JWT's organizationId.\n * Pattern: `{SECRETS_PATH_PREFIX}/{orgId}/platform`.\n * @throws if the token carries no organizationId (caller should fall back to --secret-name).\n */\nexport function resolveSecretName(token: string): string {\n  const payload = decodeTokenPayload(token);\n  const orgId = payload?.organizationId;\n  if (!orgId) {\n    throw new Error('Token does not contain organizationId — cannot derive secret name. Use --secret-name to specify explicitly.');\n  }\n  return `${CoreConstants.SECRETS_PATH_PREFIX}/${orgId}/platform`;\n}\n\n/**\n * Ensure `process.env.PLATFORM_TOKEN` is set. No-op if it already is. Otherwise,\n * if login creds are available (`--email/--password` or `PLATFORM_IDENTIFIER`/\n * `PLATFORM_PASSWORD` env — the env path lets `provision` pass creds without\n * putting the password on the command line), log in and set PLATFORM_TOKEN.\n */\nexport async function ensurePlatformToken(options: PlatformSecretOptions): Promise<void> {\n  if (process.env.PLATFORM_TOKEN) return;\n  const loginEmail = options.email || process.env.PLATFORM_IDENTIFIER;\n  const loginPassword = options.password || process.env.PLATFORM_PASSWORD;\n  if (!loginEmail || !loginPassword) return;\n\n  if (options.password) {\n    printWarning('Passing --password on the command line can expose it via shell history; prefer the PLATFORM_PASSWORD env var.');\n  }\n\n  printSection('Login');\n  printInfo('Authenticating with email/password...');\n  const config = getConfigWithOptions(options);\n  const loginResponse = await axios.post(\n    `${config.api.baseUrl}/api/auth/login`,\n    { email: loginEmail, password: loginPassword },\n    {\n      httpsAgent: config.api.rejectUnauthorized === false\n        ? new (await import('https')).Agent({ rejectUnauthorized: false })\n        : undefined,\n    },\n  );\n  const loginData = loginResponse.data?.data ?? loginResponse.data;\n  const loginToken = loginData?.accessToken;\n  if (!loginToken || typeof loginToken !== 'string') {\n    throw new Error('Login failed — no access token in response');\n  }\n  process.env.PLATFORM_TOKEN = loginToken;\n  printSuccess('Login successful');\n}\n\n/**\n * Resolve the platform secret name: an explicit `--secret-name` / `PLATFORM_SECRET_NAME`\n * wins; otherwise log in if needed and derive it from the platform token's org — the\n * same token `init-platform.sh` (register) mints, so writer and reader agree.\n */\nexport async function resolvePlatformSecretName(options: PlatformSecretOptions): Promise<string> {\n  const explicit = options.secretName || process.env.PLATFORM_SECRET_NAME;\n  if (explicit) return explicit;\n  await ensurePlatformToken(options);\n  if (!process.env.PLATFORM_TOKEN) {\n    throw new Error(\n      'Cannot derive the platform secret name: no PLATFORM_TOKEN and no login creds. '\n      + 'Pass --secret-name / set PLATFORM_SECRET_NAME, or provide login creds '\n      + '(--email/--password or PLATFORM_IDENTIFIER/PLATFORM_PASSWORD).',\n    );\n  }\n  return resolveSecretName(process.env.PLATFORM_TOKEN);\n}\n"]}

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

@@ -1,14 +1,15 @@
 /**
- * Check if auth attempts are currently rate-limited.
+ * 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(): string | null;
+export declare function checkAuthRateLimit(identifier?: string, baseUrl?: string): string | null;
 /**
- * Record a successful auth — resets the failure counter.
+ * Record a successful auth for this identifier — clears its failure counter.
  */
-export declare function recordAuthSuccess(): void;
+export declare function recordAuthSuccess(identifier?: string, baseUrl?: string): void;
 /**
- * Record a failed auth attempt. After MAX_FAILURES, locks out for COOLDOWN_MS.
+ * Record a failed auth attempt for this identifier. After MAX_FAILURES, locks out
+ * that identifier for COOLDOWN_MS.
  */
-export declare function recordAuthFailure(): void;
+export declare function recordAuthFailure(identifier?: string, baseUrl?: string): void;
 //# sourceMappingURL=rate-limiter.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"rate-limiter.d.ts","sourceRoot":"","sources":["../../src/utils/rate-limiter.ts"],"names":[],"mappings":"AAsCA;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,GAAG,IAAI,CAelD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAExC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAWxC"}
+{"version":3,"file":"rate-limiter.d.ts","sourceRoot":"","sources":["../../src/utils/rate-limiter.ts"],"names":[],"mappings":"AA4DA;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAkBvF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAI7E;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAY7E"}

package/dist/utils/rate-limiter.js

@@ -1,5 +1,6 @@
 // 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';
@@ -7,59 +8,88 @@ 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');
 const MAX_FAILURES = 5;
 const COOLDOWN_MS = 60_000; // 1 minute
-function readState() {
+const PRUNE_MS = 60 * 60_000; // drop buckets idle for >1h to bound file growth
+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)) {
-            return JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+            const parsed = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+            if (parsed && typeof parsed === 'object')
+                return parsed;
         }
     }
     catch { /* ignore corrupt state */ }
-    return { failures: 0, lastFailure: 0, lockedUntil: 0 };
+    return {};
 }
-function writeState(state) {
+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 {
-        fs.writeFileSync(STATE_FILE, JSON.stringify(state), { mode: 0o600 });
+        fs.writeFileSync(STATE_FILE, JSON.stringify(map), { mode: 0o600 });
     }
     catch { /* best-effort */ }
 }
 /**
- * Check if auth attempts are currently rate-limited.
+ * Check if auth attempts for this identifier are currently rate-limited.
  * @returns null if allowed, or a message string if blocked.
  */
-export function checkAuthRateLimit() {
-    const state = readState();
+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 if cooldown has passed
-    if (now - state.lastFailure > COOLDOWN_MS) {
-        writeState({ failures: 0, lastFailure: 0, lockedUntil: 0 });
+    // Reset this bucket once the cooldown window has passed.
+    if (state.lastFailure !== 0 && now - state.lastFailure > COOLDOWN_MS) {
+        delete map[key];
+        writeMap(map);
     }
     return null;
 }
 /**
- * Record a successful auth — resets the failure counter.
+ * Record a successful auth for this identifier — clears its failure counter.
  */
-export function recordAuthSuccess() {
-    writeState({ failures: 0, lastFailure: 0, lockedUntil: 0 });
+export function recordAuthSuccess(identifier, baseUrl) {
+    const map = readMap();
+    delete map[keyFor(identifier, baseUrl)];
+    writeMap(map);
 }
 /**
- * Record a failed auth attempt. After MAX_FAILURES, locks out for COOLDOWN_MS.
+ * Record a failed auth attempt for this identifier. After MAX_FAILURES, locks out
+ * that identifier for COOLDOWN_MS.
  */
-export function recordAuthFailure() {
-    const state = readState();
+export function recordAuthFailure(identifier, baseUrl) {
+    const key = keyFor(identifier, baseUrl);
+    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;
     }
-    writeState(state);
+    map[key] = state;
+    writeMap(map);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# 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');\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\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    fs.writeFileSync(STATE_FILE, JSON.stringify(map), { mode: 0o600 });\n  } catch { /* best-effort */ }\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.\n  if (state.lastFailure !== 0 && now - state.lastFailure > COOLDOWN_MS) {\n    delete map[key];\n    writeMap(map);\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  const map = readMap();\n  delete map[keyFor(identifier, baseUrl)];\n  writeMap(map);\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  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"]}

package/dist/utils/tls.d.ts

@@ -0,0 +1,16 @@
+import https from 'https';
+/**
+ * Hosts that legitimately front a self-signed certificate — local dev stacks and
+ * kubectl port-forwards. Everything else (a real deploy domain) is expected to
+ * present a valid (ACM) certificate and MUST be verified, so a post-deploy probe
+ * can't be silently MITM'd.
+ */
+export declare function isLocalHttpsHost(url: string): boolean;
+/**
+ * Return an https.Agent that skips certificate verification ONLY for local /
+ * self-signed hosts; returns `undefined` (Node's default verification) for real
+ * domains. Pass the result straight to axios' `httpsAgent` — `undefined` keeps the
+ * default secure behavior.
+ */
+export declare function httpsAgentForUrl(url: string): https.Agent | undefined;
+//# sourceMappingURL=tls.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tls.d.ts","sourceRoot":"","sources":["../../src/utils/tls.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAgBrD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,KAAK,GAAG,SAAS,CAErE"}

package/dist/utils/tls.js

@@ -0,0 +1,35 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import https from 'https';
+/**
+ * Hosts that legitimately front a self-signed certificate — local dev stacks and
+ * kubectl port-forwards. Everything else (a real deploy domain) is expected to
+ * present a valid (ACM) certificate and MUST be verified, so a post-deploy probe
+ * can't be silently MITM'd.
+ */
+export function isLocalHttpsHost(url) {
+    let hostname;
+    try {
+        hostname = new URL(url).hostname;
+    }
+    catch {
+        return false;
+    }
+    return (hostname === 'localhost' ||
+        hostname === '127.0.0.1' ||
+        hostname === '::1' ||
+        hostname.endsWith('.local') ||
+        /^10\./.test(hostname) ||
+        /^192\.168\./.test(hostname) ||
+        /^172\.(1[6-9]|2\d|3[01])\./.test(hostname));
+}
+/**
+ * Return an https.Agent that skips certificate verification ONLY for local /
+ * self-signed hosts; returns `undefined` (Node's default verification) for real
+ * domains. Pass the result straight to axios' `httpsAgent` — `undefined` keeps the
+ * default secure behavior.
+ */
+export function httpsAgentForUrl(url) {
+    return isLocalHttpsHost(url) ? new https.Agent({ rejectUnauthorized: false }) : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -41,8 +41,8 @@
     "typescript": "6.0.3",
     "yaml": "2.9.0",
     "zod": "4.4.3",
-    "@pipeline-builder/ai-core": "3.4.80",
-    "@pipeline-builder/pipeline-core": "3.4.94"
+    "@pipeline-builder/pipeline-core": "3.4.94",
+    "@pipeline-builder/ai-core": "3.4.80"
   },
   "keywords": [
     "ci-cd",
@@ -97,7 +97,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "3.4.125",
+  "version": "3.4.127",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },