@pipeline-builder/pipeline-manager 3.4.89 → 3.4.91

package/dist/agent/bootstrap.js

@@ -54,23 +54,16 @@ export function bootstrapCommand(spec) {
     const originRef = shellQuote(`origin/${spec.ref}`);
     const dir = shellQuote(spec.workdir);
     const paths = spec.paths.map(shellQuote).join(' ');
+    // Shared re-sync tail: prefer the remote-tracking ref, fall back to the local ref.
+    const reset = `{ git -C ${dir} reset --hard ${originRef} 2>/dev/null || git -C ${dir} reset --hard ${ref}; }`;
+    // Shared idempotent frame: re-sync an existing checkout, else fresh-clone.
+    const frame = (existing, fresh) => [`if [ -d ${dir}/.git ]; then`, `  ${existing}`, 'else', `  ${fresh}`, 'fi'].join('\n');
     if (spec.full) {
         // Full-clone fallback (no partial/sparse) for git < 2.27.
-        return [
-            `if [ -d ${dir}/.git ]; then`,
-            `  git -C ${dir} fetch --all --tags --prune && git -C ${dir} checkout ${ref} && { git -C ${dir} reset --hard ${originRef} 2>/dev/null || git -C ${dir} reset --hard ${ref}; };`,
-            'else',
-            `  git clone ${repo} ${dir} && git -C ${dir} checkout ${ref};`,
-            'fi',
-        ].join('\n');
+        return frame(`git -C ${dir} fetch --all --tags --prune && git -C ${dir} checkout ${ref} && ${reset};`, `git clone ${repo} ${dir} && git -C ${dir} checkout ${ref};`);
     }
-    return [
-        `if [ -d ${dir}/.git ]; then`,
-        // Additive: keep folders from earlier targets/options already in the cone.
-        `  git -C ${dir} sparse-checkout add ${paths} && git -C ${dir} fetch --filter=blob:none --depth 1 origin ${ref} && git -C ${dir} checkout ${ref} && { git -C ${dir} reset --hard ${originRef} 2>/dev/null || git -C ${dir} reset --hard ${ref}; };`,
-        'else',
-        `  git clone --filter=blob:none --no-checkout --depth 1 ${repo} ${dir} && git -C ${dir} sparse-checkout set --cone ${paths} && git -C ${dir} checkout ${ref};`,
-        'fi',
-    ].join('\n');
+    return frame(
+    // Additive: keep folders from earlier targets/options already in the cone.
+    `git -C ${dir} sparse-checkout add ${paths} && git -C ${dir} fetch --filter=blob:none --depth 1 origin ${ref} && git -C ${dir} checkout ${ref} && ${reset};`, `git clone --filter=blob:none --no-checkout --depth 1 ${repo} ${dir} && git -C ${dir} sparse-checkout set --cone ${paths} && git -C ${dir} checkout ${ref};`);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../src/agent/bootstrap.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;;GAcG;AAEH,qFAAqF;AACrF,MAAM,CAAC,MAAM,YAAY,GAAG,sDAAsD,CAAC;AACnF,iFAAiF;AACjF,MAAM,CAAC,MAAM,WAAW,GAAG,MAAM,CAAC;AAClC,kDAAkD;AAClD,MAAM,CAAC,MAAM,eAAe,GAAG,kBAAkB,CAAC;AAelD,sFAAsF;AACtF,MAAM,UAAU,gBAAgB,CAC9B,IAAuE,EACvE,KAAwB;IAExB,MAAM,IAAI,GAAG,CAAC,CAAqB,EAAE,QAAgB,EAAU,EAAE,CAC/D,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;IACjE,OAAO;QACL,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,YAAY,CAAC;QACnC,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,WAAW,CAAC;QAChC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,eAAe,CAAC;QAC5C,KAAK;QACL,IAAI,EAAE,IAAI,CAAC,IAAI,IAAI,KAAK;KACzB,CAAC;AACJ,CAAC;AAED,mFAAmF;AACnF,SAAS,UAAU,CAAC,KAAa;IAC/B,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC;AAC7C,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAmB;IAClD,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACnC,MAAM,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACjC,MAAM,SAAS,GAAG,UAAU,CAAC,UAAU,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;IACnD,MAAM,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACrC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAEnD,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;QACd,0DAA0D;QAC1D,OAAO;YACL,WAAW,GAAG,eAAe;YAC7B,YAAY,GAAG,yCAAyC,GAAG,aAAa,GAAG,gBAAgB,GAAG,iBAAiB,SAAS,0BAA0B,GAAG,iBAAiB,GAAG,MAAM;YAC/K,MAAM;YACN,eAAe,IAAI,IAAI,GAAG,cAAc,GAAG,aAAa,GAAG,GAAG;YAC9D,IAAI;SACL,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACf,CAAC;IAED,OAAO;QACL,WAAW,GAAG,eAAe;QAC7B,2EAA2E;QAC3E,YAAY,GAAG,wBAAwB,KAAK,cAAc,GAAG,8CAA8C,GAAG,cAAc,GAAG,aAAa,GAAG,gBAAgB,GAAG,iBAAiB,SAAS,0BAA0B,GAAG,iBAAiB,GAAG,MAAM;QACnP,MAAM;QACN,0DAA0D,IAAI,IAAI,GAAG,cAAc,GAAG,+BAA+B,KAAK,cAAc,GAAG,aAAa,GAAG,GAAG;QAC9J,IAAI;KACL,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Bootstrap the platform repo (sparse, partial clone).\n *\n * `provision` normally runs from a checkout of this repo, because the deploy\n * scripts live under `deploy/`. To provision a fresh machine in one command, the\n * operator passes `--repo`: provision git-clones the platform repo first, then\n * runs every subsequent step (deploy, init-platform, post-steps) from the clone.\n *\n * A full clone is wasteful — the repo carries `packages/`, `api/`, `platform/`,\n * `frontend/`, … none of which the deploy stack needs. So the clone is a\n * **partial** (`--filter=blob:none`) + **cone sparse-checkout** that materializes\n * only the deploy folders the selected target + options actually use. Pure\n * command assembly here — no git is run; the caller executes the command via the\n * same gated `runScript()` as the deploy.\n */\n\n/** Canonical upstream platform repo, used when `--repo` is given without a value. */\nexport const DEFAULT_REPO = 'https://github.com/mwashburn160/pipeline-builder.git';\n/** Default ref to check out when bootstrapping (a branch or tag — see below). */\nexport const DEFAULT_REF = 'main';\n/** Default directory to clone into / run from. */\nexport const DEFAULT_WORKDIR = 'pipeline-builder';\n\nexport interface BootstrapSpec {\n  /** Git URL to clone. */\n  readonly repo: string;\n  /** Branch or tag to check out. (Arbitrary SHAs may not fetch under --depth 1.) */\n  readonly ref: string;\n  /** Directory to clone into / run from (relative to the launch cwd). */\n  readonly workdir: string;\n  /** Deploy folders to materialize (cone sparse-checkout paths). */\n  readonly paths: readonly string[];\n  /** When true, skip the partial/sparse flags and do a plain full clone (git < 2.27). */\n  readonly full?: boolean;\n}\n\n/** Fill partial bootstrap inputs with defaults; `paths` is supplied by the caller. */\nexport function resolveBootstrap(\n  opts: { repo?: string; ref?: string; workdir?: string; full?: boolean },\n  paths: readonly string[],\n): BootstrapSpec {\n  const pick = (v: string | undefined, fallback: string): string =>\n    typeof v === 'string' && v.trim() !== '' ? v.trim() : fallback;\n  return {\n    repo: pick(opts.repo, DEFAULT_REPO),\n    ref: pick(opts.ref, DEFAULT_REF),\n    workdir: pick(opts.workdir, DEFAULT_WORKDIR),\n    paths,\n    full: opts.full ?? false,\n  };\n}\n\n/** Single-quote a value for safe shell interpolation (handles embedded quotes). */\nfunction shellQuote(value: string): string {\n  return `'${value.replace(/'/g, \"'\\\\''\")}'`;\n}\n\n/**\n * Assemble the idempotent bootstrap command. Re-runnable, and **additive** across\n * runs: if `<workdir>` is already a checkout it `sparse-checkout add`s the current\n * paths (so folders from previously-provisioned targets/options are retained) and\n * re-syncs to `<ref>`; otherwise it partial-clones, sets the cone, and checks out.\n *\n * - `--filter=blob:none` lazily fetches blobs; `--no-checkout` + cone sparse-checkout\n *   ⇒ only the listed deploy folders land on disk (git ≥ 2.27).\n * - `spec.full` falls back to a plain full clone (older git).\n * - All interpolated values are single-quoted, so a hostile repo/ref/workdir/path\n *   cannot break out of the command.\n */\nexport function bootstrapCommand(spec: BootstrapSpec): string {\n  const repo = shellQuote(spec.repo);\n  const ref = shellQuote(spec.ref);\n  const originRef = shellQuote(`origin/${spec.ref}`);\n  const dir = shellQuote(spec.workdir);\n  const paths = spec.paths.map(shellQuote).join(' ');\n\n  if (spec.full) {\n    // Full-clone fallback (no partial/sparse) for git < 2.27.\n    return [\n      `if [ -d ${dir}/.git ]; then`,\n      `  git -C ${dir} fetch --all --tags --prune && git -C ${dir} checkout ${ref} && { git -C ${dir} reset --hard ${originRef} 2>/dev/null || git -C ${dir} reset --hard ${ref}; };`,\n      'else',\n      `  git clone ${repo} ${dir} && git -C ${dir} checkout ${ref};`,\n      'fi',\n    ].join('\\n');\n  }\n\n  return [\n    `if [ -d ${dir}/.git ]; then`,\n    // Additive: keep folders from earlier targets/options already in the cone.\n    `  git -C ${dir} sparse-checkout add ${paths} && git -C ${dir} fetch --filter=blob:none --depth 1 origin ${ref} && git -C ${dir} checkout ${ref} && { git -C ${dir} reset --hard ${originRef} 2>/dev/null || git -C ${dir} reset --hard ${ref}; };`,\n    'else',\n    `  git clone --filter=blob:none --no-checkout --depth 1 ${repo} ${dir} && git -C ${dir} sparse-checkout set --cone ${paths} && git -C ${dir} checkout ${ref};`,\n    'fi',\n  ].join('\\n');\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../src/agent/bootstrap.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;;GAcG;AAEH,qFAAqF;AACrF,MAAM,CAAC,MAAM,YAAY,GAAG,sDAAsD,CAAC;AACnF,iFAAiF;AACjF,MAAM,CAAC,MAAM,WAAW,GAAG,MAAM,CAAC;AAClC,kDAAkD;AAClD,MAAM,CAAC,MAAM,eAAe,GAAG,kBAAkB,CAAC;AAelD,sFAAsF;AACtF,MAAM,UAAU,gBAAgB,CAC9B,IAAuE,EACvE,KAAwB;IAExB,MAAM,IAAI,GAAG,CAAC,CAAqB,EAAE,QAAgB,EAAU,EAAE,CAC/D,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;IACjE,OAAO;QACL,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,YAAY,CAAC;QACnC,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,WAAW,CAAC;QAChC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,eAAe,CAAC;QAC5C,KAAK;QACL,IAAI,EAAE,IAAI,CAAC,IAAI,IAAI,KAAK;KACzB,CAAC;AACJ,CAAC;AAED,mFAAmF;AACnF,SAAS,UAAU,CAAC,KAAa;IAC/B,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC;AAC7C,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAmB;IAClD,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACnC,MAAM,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACjC,MAAM,SAAS,GAAG,UAAU,CAAC,UAAU,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;IACnD,MAAM,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACrC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAEnD,mFAAmF;IACnF,MAAM,KAAK,GAAG,YAAY,GAAG,iBAAiB,SAAS,0BAA0B,GAAG,iBAAiB,GAAG,KAAK,CAAC;IAC9G,2EAA2E;IAC3E,MAAM,KAAK,GAAG,CAAC,QAAgB,EAAE,KAAa,EAAU,EAAE,CACxD,CAAC,WAAW,GAAG,eAAe,EAAE,KAAK,QAAQ,EAAE,EAAE,MAAM,EAAE,KAAK,KAAK,EAAE,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAE1F,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;QACd,0DAA0D;QAC1D,OAAO,KAAK,CACV,UAAU,GAAG,yCAAyC,GAAG,aAAa,GAAG,OAAO,KAAK,GAAG,EACxF,aAAa,IAAI,IAAI,GAAG,cAAc,GAAG,aAAa,GAAG,GAAG,CAC7D,CAAC;IACJ,CAAC;IAED,OAAO,KAAK;IACV,2EAA2E;IAC3E,UAAU,GAAG,wBAAwB,KAAK,cAAc,GAAG,8CAA8C,GAAG,cAAc,GAAG,aAAa,GAAG,OAAO,KAAK,GAAG,EAC5J,wDAAwD,IAAI,IAAI,GAAG,cAAc,GAAG,+BAA+B,KAAK,cAAc,GAAG,aAAa,GAAG,GAAG,CAC7J,CAAC;AACJ,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Bootstrap the platform repo (sparse, partial clone).\n *\n * `provision` normally runs from a checkout of this repo, because the deploy\n * scripts live under `deploy/`. To provision a fresh machine in one command, the\n * operator passes `--repo`: provision git-clones the platform repo first, then\n * runs every subsequent step (deploy, init-platform, post-steps) from the clone.\n *\n * A full clone is wasteful — the repo carries `packages/`, `api/`, `platform/`,\n * `frontend/`, … none of which the deploy stack needs. So the clone is a\n * **partial** (`--filter=blob:none`) + **cone sparse-checkout** that materializes\n * only the deploy folders the selected target + options actually use. Pure\n * command assembly here — no git is run; the caller executes the command via the\n * same gated `runScript()` as the deploy.\n */\n\n/** Canonical upstream platform repo, used when `--repo` is given without a value. */\nexport const DEFAULT_REPO = 'https://github.com/mwashburn160/pipeline-builder.git';\n/** Default ref to check out when bootstrapping (a branch or tag — see below). */\nexport const DEFAULT_REF = 'main';\n/** Default directory to clone into / run from. */\nexport const DEFAULT_WORKDIR = 'pipeline-builder';\n\nexport interface BootstrapSpec {\n  /** Git URL to clone. */\n  readonly repo: string;\n  /** Branch or tag to check out. (Arbitrary SHAs may not fetch under --depth 1.) */\n  readonly ref: string;\n  /** Directory to clone into / run from (relative to the launch cwd). */\n  readonly workdir: string;\n  /** Deploy folders to materialize (cone sparse-checkout paths). */\n  readonly paths: readonly string[];\n  /** When true, skip the partial/sparse flags and do a plain full clone (git < 2.27). */\n  readonly full?: boolean;\n}\n\n/** Fill partial bootstrap inputs with defaults; `paths` is supplied by the caller. */\nexport function resolveBootstrap(\n  opts: { repo?: string; ref?: string; workdir?: string; full?: boolean },\n  paths: readonly string[],\n): BootstrapSpec {\n  const pick = (v: string | undefined, fallback: string): string =>\n    typeof v === 'string' && v.trim() !== '' ? v.trim() : fallback;\n  return {\n    repo: pick(opts.repo, DEFAULT_REPO),\n    ref: pick(opts.ref, DEFAULT_REF),\n    workdir: pick(opts.workdir, DEFAULT_WORKDIR),\n    paths,\n    full: opts.full ?? false,\n  };\n}\n\n/** Single-quote a value for safe shell interpolation (handles embedded quotes). */\nfunction shellQuote(value: string): string {\n  return `'${value.replace(/'/g, \"'\\\\''\")}'`;\n}\n\n/**\n * Assemble the idempotent bootstrap command. Re-runnable, and **additive** across\n * runs: if `<workdir>` is already a checkout it `sparse-checkout add`s the current\n * paths (so folders from previously-provisioned targets/options are retained) and\n * re-syncs to `<ref>`; otherwise it partial-clones, sets the cone, and checks out.\n *\n * - `--filter=blob:none` lazily fetches blobs; `--no-checkout` + cone sparse-checkout\n *   ⇒ only the listed deploy folders land on disk (git ≥ 2.27).\n * - `spec.full` falls back to a plain full clone (older git).\n * - All interpolated values are single-quoted, so a hostile repo/ref/workdir/path\n *   cannot break out of the command.\n */\nexport function bootstrapCommand(spec: BootstrapSpec): string {\n  const repo = shellQuote(spec.repo);\n  const ref = shellQuote(spec.ref);\n  const originRef = shellQuote(`origin/${spec.ref}`);\n  const dir = shellQuote(spec.workdir);\n  const paths = spec.paths.map(shellQuote).join(' ');\n\n  // Shared re-sync tail: prefer the remote-tracking ref, fall back to the local ref.\n  const reset = `{ git -C ${dir} reset --hard ${originRef} 2>/dev/null || git -C ${dir} reset --hard ${ref}; }`;\n  // Shared idempotent frame: re-sync an existing checkout, else fresh-clone.\n  const frame = (existing: string, fresh: string): string =>\n    [`if [ -d ${dir}/.git ]; then`, `  ${existing}`, 'else', `  ${fresh}`, 'fi'].join('\\n');\n\n  if (spec.full) {\n    // Full-clone fallback (no partial/sparse) for git < 2.27.\n    return frame(\n      `git -C ${dir} fetch --all --tags --prune && git -C ${dir} checkout ${ref} && ${reset};`,\n      `git clone ${repo} ${dir} && git -C ${dir} checkout ${ref};`,\n    );\n  }\n\n  return frame(\n    // Additive: keep folders from earlier targets/options already in the cone.\n    `git -C ${dir} sparse-checkout add ${paths} && git -C ${dir} fetch --filter=blob:none --depth 1 origin ${ref} && git -C ${dir} checkout ${ref} && ${reset};`,\n    `git clone --filter=blob:none --no-checkout --depth 1 ${repo} ${dir} && git -C ${dir} sparse-checkout set --cone ${paths} && git -C ${dir} checkout ${ref};`,\n  );\n}\n"]}

package/dist/agent/health.d.ts

@@ -2,6 +2,12 @@ import type { TargetId } from './targets.js';
 export interface HealthResult {
     readonly url: string;
     readonly healthy: boolean;
+    /**
+     * True only when BOTH /health and /ready passed. Distinguishes a fully-ready
+     * platform from the degraded "health OK but /ready never came, proceeding anyway"
+     * state — both have healthy:true, so callers should style success on `ready`.
+     */
+    readonly ready: boolean;
     readonly detail: string;
 }
 /**

package/dist/agent/health.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../../src/agent/health.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI,CAIhG;AAeD;;;GAGG;AACH,wBAAsB,WAAW,CAC/B,GAAG,EAAE,MAAM,EACX,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;CAAO,GAC5G,OAAO,CAAC,YAAY,CAAC,CAuCvB;AAED;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,MAAM,EACX,IAAI,GAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;CAAO,GACxE,OAAO,CAAC,IAAI,CAAC,CAef"}
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../../src/agent/health.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI,CAIhG;AAeD;;;GAGG;AACH,wBAAsB,WAAW,CAC/B,GAAG,EAAE,MAAM,EACX,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;CAAO,GAC5G,OAAO,CAAC,YAAY,CAAC,CAwCvB;AAED;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,MAAM,EACX,IAAI,GAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;CAAO,GACxE,OAAO,CAAC,IAAI,CAAC,CAef"}

package/dist/agent/health.js

@@ -54,13 +54,14 @@ export async function waitHealthy(url, opts = {}) {
             if (healthSeenAt === 0)
                 healthSeenAt = Date.now();
             if (await probe(`${url}/ready`)) {
-                return { url, healthy: true, detail: 'health + ready OK' };
+                return { url, healthy: true, ready: true, detail: 'health + ready OK' };
             }
             const leftMs = readyGraceMs - (Date.now() - healthSeenAt);
             if (leftMs <= 0) {
                 return {
                     url,
                     healthy: true,
+                    ready: false,
                     detail: `health OK, but /ready didn't pass within ${Math.round(readyGraceMs / 1000)}s — a backend service is likely down (check \`docker compose ps\` / its logs). Continuing; routes for that service may 502 until it's healthy.`,
                 };
             }
@@ -73,8 +74,8 @@ export async function waitHealthy(url, opts = {}) {
     }
     // Overall timeout. If /health came up but /ready never did, proceed (non-fatal).
     return healthSeenAt > 0
-        ? { url, healthy: true, detail: 'health OK but /ready not reached — the platform is still warming up; post-install steps (register) may need a re-run' }
-        : { url, healthy: false, detail: `not reachable within ${Math.round(timeoutMs / 1000)}s — check the stack / DNS / health logs` };
+        ? { url, healthy: true, ready: false, detail: 'health OK but /ready not reached — the platform is still warming up; post-install steps (register) may need a re-run' }
+        : { url, healthy: false, ready: false, detail: `not reachable within ${Math.round(timeoutMs / 1000)}s — check the stack / DNS / health logs` };
 }
 /**
  * Minikube only: the gateway (https://localhost:8443) is reached through a
@@ -103,4 +104,4 @@ export async function ensureMinikubeGateway(url, opts = {}) {
     }
     await delay(2000); // let it bind before the caller polls
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"health.js","sourceRoot":"","sources":["../../src/agent/health.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Post-deploy health verification. A CloudFormation CREATE_COMPLETE (or a\n * finished setup.sh) does NOT mean the app is serving — the ALB targets stay\n * unhealthy until tasks/pods come up. The real done-signal is the platform's\n * `/health` + `/ready` endpoints, so the executor polls them with backoff.\n */\n\nimport { spawn } from 'child_process';\nimport https from 'https';\nimport axios from 'axios';\nimport type { TargetId } from './targets.js';\n\nexport interface HealthResult {\n  readonly url: string;\n  readonly healthy: boolean;\n  readonly detail: string;\n}\n\n/**\n * Derive the URL the platform should be reachable at. Local/minikube front the\n * stack on localhost:8443; EC2/Fargate use the deploy domain. Returns null when\n * it can't be determined (caller surfaces a \"verify manually\" note).\n */\nexport function deriveHealthUrl(target: TargetId, params: Record<string, unknown>): string | null {\n  if (target === 'local' || target === 'minikube') return 'https://localhost:8443';\n  const domain = params.domain;\n  return typeof domain === 'string' && domain ? `https://${domain}` : null;\n}\n\nconst agent = new https.Agent({ rejectUnauthorized: false }); // local uses a self-signed cert\n\nasync function probe(url: string): Promise<boolean> {\n  try {\n    const res = await axios.get(url, { timeout: 5000, httpsAgent: agent, validateStatus: () => true });\n    return res.status >= 200 && res.status < 300;\n  } catch {\n    return false;\n  }\n}\n\nconst delay = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));\n\n/**\n * Poll `<url>/health` then `<url>/ready` until both pass or the timeout elapses.\n * Non-fatal by design: a timeout returns `healthy: false` with guidance, never throws.\n */\nexport async function waitHealthy(\n  url: string,\n  opts: { timeoutMs?: number; intervalMs?: number; readyGraceMs?: number; onTick?: (msg: string) => void } = {},\n): Promise<HealthResult> {\n  const timeoutMs = opts.timeoutMs ?? 300_000; // 5 min — services come up async\n  const intervalMs = opts.intervalMs ?? 10_000;\n  // Once /health is up, only wait this much longer for /ready before proceeding.\n  const readyGraceMs = opts.readyGraceMs ?? 90_000; // 90s covers normal warmup\n  const deadline = Date.now() + timeoutMs;\n\n  // Wait for /health, then give /ready a BOUNDED grace window. /health flips first\n  // (the process is up); /ready also requires every backend dependency to be up.\n  // We prefer /ready (post-install register hits a not-yet-ready platform → 502),\n  // but if a dependency is DOWN (e.g. a crash-looping service) /ready never flips —\n  // so we must not block the full timeout on it. Once /health is up we wait at most\n  // `readyGraceMs` more, then proceed with a warning (register only needs the\n  // platform service, which /health already confirms is up).\n  let healthSeenAt = 0;\n  while (Date.now() < deadline) {\n    if (await probe(`${url}/health`)) {\n      if (healthSeenAt === 0) healthSeenAt = Date.now();\n      if (await probe(`${url}/ready`)) {\n        return { url, healthy: true, detail: 'health + ready OK' };\n      }\n      const leftMs = readyGraceMs - (Date.now() - healthSeenAt);\n      if (leftMs <= 0) {\n        return {\n          url,\n          healthy: true,\n          detail: `health OK, but /ready didn't pass within ${Math.round(readyGraceMs / 1000)}s — a backend service is likely down (check \\`docker compose ps\\` / its logs). Continuing; routes for that service may 502 until it's healthy.`,\n        };\n      }\n      opts.onTick?.(`health OK — waiting up to ${Math.ceil(leftMs / 1000)}s for ${url}/ready (dependencies warming up) …`);\n    } else {\n      opts.onTick?.(`waiting for ${url}/health …`);\n    }\n    await delay(intervalMs);\n  }\n  // Overall timeout. If /health came up but /ready never did, proceed (non-fatal).\n  return healthSeenAt > 0\n    ? { url, healthy: true, detail: 'health OK but /ready not reached — the platform is still warming up; post-install steps (register) may need a re-run' }\n    : { url, healthy: false, detail: `not reachable within ${Math.round(timeoutMs / 1000)}s — check the stack / DNS / health logs` };\n}\n\n/**\n * Minikube only: the gateway (https://localhost:8443) is reached through a\n * `kubectl port-forward svc/nginx` that setup.sh backgrounds — which can die or\n * fail to bind (e.g. a busy port) while the pods stay healthy, leaving the gateway\n * unreachable so the health poll just times out. Before polling, probe the gateway;\n * if it's down, (re)start the forward DETACHED so it outlives this CLI, then give\n * it a moment to bind. Best-effort: never throws; on no-kubectl it logs the manual\n * command. (setup.sh now forwards 8443 only, so a busy 8080 can't take it down.)\n */\nexport async function ensureMinikubeGateway(\n  url: string,\n  opts: { ns?: string; port?: number; onInfo?: (msg: string) => void } = {},\n): Promise<void> {\n  const ns = opts.ns ?? 'pipeline-builder';\n  const port = opts.port ?? 8443;\n  if (await probe(`${url}/health`)) return; // forward already up — nothing to do\n  opts.onInfo?.(`Gateway unreachable — (re)starting the nginx port-forward (svc/nginx ${port}:${port}, ns ${ns}) …`);\n  try {\n    spawn('kubectl', ['port-forward', '-n', ns, 'svc/nginx', `${port}:${port}`], {\n      detached: true,\n      stdio: 'ignore',\n    }).unref(); // detached + unref → survives this CLI so the user keeps the gateway\n  } catch {\n    opts.onInfo?.(`Couldn't start it (is kubectl on PATH?). Start it manually: kubectl port-forward -n ${ns} svc/nginx ${port}:${port}`);\n    return;\n  }\n  await delay(2000); // let it bind before the caller polls\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"health.js","sourceRoot":"","sources":["../../src/agent/health.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Post-deploy health verification. A CloudFormation CREATE_COMPLETE (or a\n * finished setup.sh) does NOT mean the app is serving — the ALB targets stay\n * unhealthy until tasks/pods come up. The real done-signal is the platform's\n * `/health` + `/ready` endpoints, so the executor polls them with backoff.\n */\n\nimport { spawn } from 'child_process';\nimport https from 'https';\nimport axios from 'axios';\nimport type { TargetId } from './targets.js';\n\nexport interface HealthResult {\n  readonly url: string;\n  readonly healthy: boolean;\n  /**\n   * True only when BOTH /health and /ready passed. Distinguishes a fully-ready\n   * platform from the degraded \"health OK but /ready never came, proceeding anyway\"\n   * state — both have healthy:true, so callers should style success on `ready`.\n   */\n  readonly ready: boolean;\n  readonly detail: string;\n}\n\n/**\n * Derive the URL the platform should be reachable at. Local/minikube front the\n * stack on localhost:8443; EC2/Fargate use the deploy domain. Returns null when\n * it can't be determined (caller surfaces a \"verify manually\" note).\n */\nexport function deriveHealthUrl(target: TargetId, params: Record<string, unknown>): string | null {\n  if (target === 'local' || target === 'minikube') return 'https://localhost:8443';\n  const domain = params.domain;\n  return typeof domain === 'string' && domain ? `https://${domain}` : null;\n}\n\nconst agent = new https.Agent({ rejectUnauthorized: false }); // local uses a self-signed cert\n\nasync function probe(url: string): Promise<boolean> {\n  try {\n    const res = await axios.get(url, { timeout: 5000, httpsAgent: agent, validateStatus: () => true });\n    return res.status >= 200 && res.status < 300;\n  } catch {\n    return false;\n  }\n}\n\nconst delay = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));\n\n/**\n * Poll `<url>/health` then `<url>/ready` until both pass or the timeout elapses.\n * Non-fatal by design: a timeout returns `healthy: false` with guidance, never throws.\n */\nexport async function waitHealthy(\n  url: string,\n  opts: { timeoutMs?: number; intervalMs?: number; readyGraceMs?: number; onTick?: (msg: string) => void } = {},\n): Promise<HealthResult> {\n  const timeoutMs = opts.timeoutMs ?? 300_000; // 5 min — services come up async\n  const intervalMs = opts.intervalMs ?? 10_000;\n  // Once /health is up, only wait this much longer for /ready before proceeding.\n  const readyGraceMs = opts.readyGraceMs ?? 90_000; // 90s covers normal warmup\n  const deadline = Date.now() + timeoutMs;\n\n  // Wait for /health, then give /ready a BOUNDED grace window. /health flips first\n  // (the process is up); /ready also requires every backend dependency to be up.\n  // We prefer /ready (post-install register hits a not-yet-ready platform → 502),\n  // but if a dependency is DOWN (e.g. a crash-looping service) /ready never flips —\n  // so we must not block the full timeout on it. Once /health is up we wait at most\n  // `readyGraceMs` more, then proceed with a warning (register only needs the\n  // platform service, which /health already confirms is up).\n  let healthSeenAt = 0;\n  while (Date.now() < deadline) {\n    if (await probe(`${url}/health`)) {\n      if (healthSeenAt === 0) healthSeenAt = Date.now();\n      if (await probe(`${url}/ready`)) {\n        return { url, healthy: true, ready: true, detail: 'health + ready OK' };\n      }\n      const leftMs = readyGraceMs - (Date.now() - healthSeenAt);\n      if (leftMs <= 0) {\n        return {\n          url,\n          healthy: true,\n          ready: false,\n          detail: `health OK, but /ready didn't pass within ${Math.round(readyGraceMs / 1000)}s — a backend service is likely down (check \\`docker compose ps\\` / its logs). Continuing; routes for that service may 502 until it's healthy.`,\n        };\n      }\n      opts.onTick?.(`health OK — waiting up to ${Math.ceil(leftMs / 1000)}s for ${url}/ready (dependencies warming up) …`);\n    } else {\n      opts.onTick?.(`waiting for ${url}/health …`);\n    }\n    await delay(intervalMs);\n  }\n  // Overall timeout. If /health came up but /ready never did, proceed (non-fatal).\n  return healthSeenAt > 0\n    ? { url, healthy: true, ready: false, detail: 'health OK but /ready not reached — the platform is still warming up; post-install steps (register) may need a re-run' }\n    : { url, healthy: false, ready: false, detail: `not reachable within ${Math.round(timeoutMs / 1000)}s — check the stack / DNS / health logs` };\n}\n\n/**\n * Minikube only: the gateway (https://localhost:8443) is reached through a\n * `kubectl port-forward svc/nginx` that setup.sh backgrounds — which can die or\n * fail to bind (e.g. a busy port) while the pods stay healthy, leaving the gateway\n * unreachable so the health poll just times out. Before polling, probe the gateway;\n * if it's down, (re)start the forward DETACHED so it outlives this CLI, then give\n * it a moment to bind. Best-effort: never throws; on no-kubectl it logs the manual\n * command. (setup.sh now forwards 8443 only, so a busy 8080 can't take it down.)\n */\nexport async function ensureMinikubeGateway(\n  url: string,\n  opts: { ns?: string; port?: number; onInfo?: (msg: string) => void } = {},\n): Promise<void> {\n  const ns = opts.ns ?? 'pipeline-builder';\n  const port = opts.port ?? 8443;\n  if (await probe(`${url}/health`)) return; // forward already up — nothing to do\n  opts.onInfo?.(`Gateway unreachable — (re)starting the nginx port-forward (svc/nginx ${port}:${port}, ns ${ns}) …`);\n  try {\n    spawn('kubectl', ['port-forward', '-n', ns, 'svc/nginx', `${port}:${port}`], {\n      detached: true,\n      stdio: 'ignore',\n    }).unref(); // detached + unref → survives this CLI so the user keeps the gateway\n  } catch {\n    opts.onInfo?.(`Couldn't start it (is kubectl on PATH?). Start it manually: kubectl port-forward -n ${ns} svc/nginx ${port}:${port}`);\n    return;\n  }\n  await delay(2000); // let it bind before the caller polls\n}\n"]}

package/dist/agent/ports.d.ts

@@ -1,9 +1,26 @@
-import type { TargetSpec } from './targets.js';
-export interface PortCheck {
+import type { TargetId, TargetSpec } from './targets.js';
+export interface HostPort {
     readonly service: string;
     readonly port: number;
+}
+export interface PortCheck extends HostPort {
     readonly available: boolean;
 }
-/** Probe every host port a target binds; returns one PortCheck per port. */
-export declare function checkHostPorts(spec: TargetSpec): Promise<PortCheck[]>;
+/**
+ * Derive the host ports a target binds from its ACTUAL (cloned) deploy source, so the
+ * list can't drift from the deploy. local → docker-compose.yml; minikube → setup.sh;
+ * ec2/fargate → none (CloudFormation binds nothing on the operator's machine). Needs
+ * the deploy files on disk (run post-clone); falls back to the target's static
+ * `hostPorts` if the source is missing/unreadable.
+ */
+export declare function discoverHostPorts(target: TargetId, cwd: string, spec: TargetSpec): HostPort[];
+/** Probe each host port; returns one PortCheck per port (probed in parallel). */
+export declare function checkHostPorts(ports: readonly HostPort[]): Promise<PortCheck[]>;
+/**
+ * Is the target's OWN deploy stack already running? (local docker-compose only.) Used
+ * so the port pre-flight doesn't block an idempotent RE-RUN: if the "taken" ports are
+ * held by the stack you already have up, `docker compose up` just no-ops them — that's
+ * not a conflict. Read-only `docker compose ps`; false on any error / non-local target.
+ */
+export declare function stackRunning(target: TargetId, cwd: string, spec: TargetSpec): boolean;
 //# sourceMappingURL=ports.d.ts.map

package/dist/agent/ports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../../src/agent/ports.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAwBD,4EAA4E;AAC5E,wBAAsB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAI3E"}
+{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../../src/agent/ports.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAEzD,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,SAAU,SAAQ,QAAQ;IACzC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAqED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,QAAQ,EAAE,CAQ7F;AAED,iFAAiF;AACjF,wBAAsB,cAAc,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAErF;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAWrF"}

package/dist/agent/ports.js

@@ -1,13 +1,24 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 /**
- * Host-port pre-flight. Local (Docker-published) and minikube (kubectl
- * port-forward) deploys bind fixed ports on the operator's machine; if one is
- * already taken, the container/forward fails to bind — and for the gateway that
- * surfaces as a silent "/health never reachable" hang. We probe the ports up
- * front so provision can stop with a clear summary instead of failing mid-deploy.
+ * Host-port pre-flight. Local (Docker-published) and minikube (kubectl port-forward)
+ * deploys bind fixed ports on the operator's machine; if one is already taken, the
+ * container/forward fails to bind — and for the gateway that surfaces as a silent
+ * "/health never reachable" hang. We probe the ports before deploying so provision
+ * can stop with a clear summary instead of failing mid-deploy.
+ *
+ * The port list is DERIVED from each target's actual (cloned) deploy source — so it
+ * can't drift from the deploy: local from `docker-compose.yml`'s published ports,
+ * minikube from `setup.sh`'s kubectl port-forwards. ec2/fargate deploy via
+ * CloudFormation and bind NOTHING on the operator's machine (only the remote ALB),
+ * so they yield no host ports. `targets.hostPorts` is only a fallback when the source
+ * file can't be read.
  */
+import { execSync } from 'child_process';
+import { readFileSync } from 'fs';
 import net from 'net';
+import path from 'path';
+import { parse as parseYaml } from 'yaml';
 /** Try to bind <host>:<port>; true if free, false on EADDRINUSE/EACCES. */
 function canBind(port, host) {
     return new Promise((resolve) => {
@@ -18,18 +29,104 @@ function canBind(port, host) {
     });
 }
 /**
- * Is `port` free? Probes BOTH interfaces the deploy paths bind: `0.0.0.0` (Docker
- * publishes `0.0.0.0:<port>`) and `127.0.0.1` (kubectl port-forward, Docker Desktop
- * localhost). A holder on either makes the matching bind fail, so requiring both to
- * succeed catches the real conflict (e.g. macOS AirPlay on 5000) without
- * SO_REUSEADDR false-negatives.
+ * Is `port` free? Probes BOTH `0.0.0.0` (where Docker publishes `0.0.0.0:<port>`)
+ * AND `127.0.0.1` (where kubectl port-forward / Docker Desktop bind), requiring both.
+ *
+ * This is NOT redundant — do not "simplify" to one bind. Verified empirically on
+ * macOS (Node sets SO_REUSEADDR): neither interface subsumes the other. With a holder
+ * on 127.0.0.1, binding 0.0.0.0 still SUCCEEDS (a single 0.0.0.0 probe would MISS a
+ * port-forward squatting the gateway on loopback); with a holder on 0.0.0.0, binding
+ * 127.0.0.1 still succeeds. Only checking both reliably catches the real conflict (a
+ * port-forward on 8443, AirPlay on 5000, …). For a pre-flight, a false positive
+ * (over-cautious) beats a false negative (miss it → the deploy fails mid-way).
  */
 async function isPortFree(port) {
     const [allIfaces, loopback] = await Promise.all([canBind(port, '0.0.0.0'), canBind(port, '127.0.0.1')]);
     return allIfaces && loopback;
 }
-/** Probe every host port a target binds; returns one PortCheck per port. */
-export async function checkHostPorts(spec) {
-    return Promise.all(spec.hostPorts.map(async ({ service, port }) => ({ service, port, available: await isPortFree(port) })));
+/**
+ * Host (left-side) ports a docker-compose.yml publishes, keyed by service. Handles
+ * the short forms "HOST:CONTAINER", "HOST:CONTAINER/proto", "IP:HOST:CONTAINER" and
+ * the long form `{ published, target }`. Bare "CONTAINER" (random host port) is
+ * skipped — it can't conflict on a fixed port.
+ */
+function composeHostPorts(file) {
+    const doc = parseYaml(readFileSync(file, 'utf8'));
+    const out = [];
+    for (const [service, def] of Object.entries(doc?.services ?? {})) {
+        for (const entry of def?.ports ?? []) {
+            let host;
+            if (typeof entry === 'string') {
+                const parts = (entry.split('/')[0] ?? '').split(':'); // strip /proto, split ip:host:container
+                if (parts.length >= 2)
+                    host = Number(parts[parts.length - 2] ?? ''); // host is second-from-last
+            }
+            else if (entry && typeof entry === 'object' && 'published' in entry) {
+                host = Number(entry.published);
+            }
+            if (host !== undefined && Number.isInteger(host))
+                out.push({ service, port: host });
+        }
+    }
+    return out;
+}
+/** Host ports from minikube setup.sh's `port_forward "Name" svc "HOST:CONTAINER …"` calls. */
+function forwardHostPorts(file) {
+    const out = [];
+    const re = /port_forward\s+"([^"]+)"\s+\S+\s+"([^"]+)"/g;
+    const text = readFileSync(file, 'utf8');
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        const service = m[1] ?? '';
+        for (const pair of (m[2] ?? '').trim().split(/\s+/)) {
+            const host = Number(pair.split(':')[0] ?? '');
+            if (Number.isInteger(host))
+                out.push({ service, port: host });
+        }
+    }
+    return out;
+}
+/**
+ * Derive the host ports a target binds from its ACTUAL (cloned) deploy source, so the
+ * list can't drift from the deploy. local → docker-compose.yml; minikube → setup.sh;
+ * ec2/fargate → none (CloudFormation binds nothing on the operator's machine). Needs
+ * the deploy files on disk (run post-clone); falls back to the target's static
+ * `hostPorts` if the source is missing/unreadable.
+ */
+export function discoverHostPorts(target, cwd, spec) {
+    try {
+        if (target === 'local')
+            return composeHostPorts(path.join(cwd, spec.dir, 'docker-compose.yml'));
+        if (target === 'minikube')
+            return forwardHostPorts(path.join(cwd, spec.dir, 'bin', 'setup.sh'));
+        return []; // ec2/fargate deploy remotely — nothing binds locally
+    }
+    catch {
+        return spec.hostPorts.map((p) => ({ ...p }));
+    }
+}
+/** Probe each host port; returns one PortCheck per port (probed in parallel). */
+export async function checkHostPorts(ports) {
+    return Promise.all(ports.map(async ({ service, port }) => ({ service, port, available: await isPortFree(port) })));
+}
+/**
+ * Is the target's OWN deploy stack already running? (local docker-compose only.) Used
+ * so the port pre-flight doesn't block an idempotent RE-RUN: if the "taken" ports are
+ * held by the stack you already have up, `docker compose up` just no-ops them — that's
+ * not a conflict. Read-only `docker compose ps`; false on any error / non-local target.
+ */
+export function stackRunning(target, cwd, spec) {
+    if (target !== 'local')
+        return false;
+    try {
+        const compose = path.join(cwd, spec.dir, 'docker-compose.yml');
+        const out = execSync(`docker compose -f '${compose}' ps -q`, { stdio: ['ignore', 'pipe', 'ignore'], timeout: 10000 })
+            .toString()
+            .trim();
+        return out.length > 0;
+    }
+    catch {
+        return false;
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ports.js","sourceRoot":"","sources":["../../src/agent/ports.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Host-port pre-flight. Local (Docker-published) and minikube (kubectl port-forward)\n * deploys bind fixed ports on the operator's machine; if one is already taken, the\n * container/forward fails to bind — and for the gateway that surfaces as a silent\n * \"/health never reachable\" hang. We probe the ports before deploying so provision\n * can stop with a clear summary instead of failing mid-deploy.\n *\n * The port list is DERIVED from each target's actual (cloned) deploy source — so it\n * can't drift from the deploy: local from `docker-compose.yml`'s published ports,\n * minikube from `setup.sh`'s kubectl port-forwards. ec2/fargate deploy via\n * CloudFormation and bind NOTHING on the operator's machine (only the remote ALB),\n * so they yield no host ports. `targets.hostPorts` is only a fallback when the source\n * file can't be read.\n */\n\nimport { execSync } from 'child_process';\nimport { readFileSync } from 'fs';\nimport net from 'net';\nimport path from 'path';\nimport { parse as parseYaml } from 'yaml';\nimport type { TargetId, TargetSpec } from './targets.js';\n\nexport interface HostPort {\n  readonly service: string;\n  readonly port: number;\n}\n\nexport interface PortCheck extends HostPort {\n  readonly available: boolean;\n}\n\n/** Try to bind <host>:<port>; true if free, false on EADDRINUSE/EACCES. */\nfunction canBind(port: number, host: string): Promise<boolean> {\n  return new Promise((resolve) => {\n    const srv = net.createServer();\n    srv.once('error', () => resolve(false));\n    srv.once('listening', () => srv.close(() => resolve(true)));\n    srv.listen(port, host);\n  });\n}\n\n/**\n * Is `port` free? Probes BOTH `0.0.0.0` (where Docker publishes `0.0.0.0:<port>`)\n * AND `127.0.0.1` (where kubectl port-forward / Docker Desktop bind), requiring both.\n *\n * This is NOT redundant — do not \"simplify\" to one bind. Verified empirically on\n * macOS (Node sets SO_REUSEADDR): neither interface subsumes the other. With a holder\n * on 127.0.0.1, binding 0.0.0.0 still SUCCEEDS (a single 0.0.0.0 probe would MISS a\n * port-forward squatting the gateway on loopback); with a holder on 0.0.0.0, binding\n * 127.0.0.1 still succeeds. Only checking both reliably catches the real conflict (a\n * port-forward on 8443, AirPlay on 5000, …). For a pre-flight, a false positive\n * (over-cautious) beats a false negative (miss it → the deploy fails mid-way).\n */\nasync function isPortFree(port: number): Promise<boolean> {\n  const [allIfaces, loopback] = await Promise.all([canBind(port, '0.0.0.0'), canBind(port, '127.0.0.1')]);\n  return allIfaces && loopback;\n}\n\n/**\n * Host (left-side) ports a docker-compose.yml publishes, keyed by service. Handles\n * the short forms \"HOST:CONTAINER\", \"HOST:CONTAINER/proto\", \"IP:HOST:CONTAINER\" and\n * the long form `{ published, target }`. Bare \"CONTAINER\" (random host port) is\n * skipped — it can't conflict on a fixed port.\n */\nfunction composeHostPorts(file: string): HostPort[] {\n  const doc = parseYaml(readFileSync(file, 'utf8')) as { services?: Record<string, { ports?: unknown[] }> };\n  const out: HostPort[] = [];\n  for (const [service, def] of Object.entries(doc?.services ?? {})) {\n    for (const entry of def?.ports ?? []) {\n      let host: number | undefined;\n      if (typeof entry === 'string') {\n        const parts = (entry.split('/')[0] ?? '').split(':'); // strip /proto, split ip:host:container\n        if (parts.length >= 2) host = Number(parts[parts.length - 2] ?? ''); // host is second-from-last\n      } else if (entry && typeof entry === 'object' && 'published' in entry) {\n        host = Number((entry as { published: unknown }).published);\n      }\n      if (host !== undefined && Number.isInteger(host)) out.push({ service, port: host });\n    }\n  }\n  return out;\n}\n\n/** Host ports from minikube setup.sh's `port_forward \"Name\" svc \"HOST:CONTAINER …\"` calls. */\nfunction forwardHostPorts(file: string): HostPort[] {\n  const out: HostPort[] = [];\n  const re = /port_forward\\s+\"([^\"]+)\"\\s+\\S+\\s+\"([^\"]+)\"/g;\n  const text = readFileSync(file, 'utf8');\n  let m: RegExpExecArray | null;\n  while ((m = re.exec(text)) !== null) {\n    const service = m[1] ?? '';\n    for (const pair of (m[2] ?? '').trim().split(/\\s+/)) {\n      const host = Number(pair.split(':')[0] ?? '');\n      if (Number.isInteger(host)) out.push({ service, port: host });\n    }\n  }\n  return out;\n}\n\n/**\n * Derive the host ports a target binds from its ACTUAL (cloned) deploy source, so the\n * list can't drift from the deploy. local → docker-compose.yml; minikube → setup.sh;\n * ec2/fargate → none (CloudFormation binds nothing on the operator's machine). Needs\n * the deploy files on disk (run post-clone); falls back to the target's static\n * `hostPorts` if the source is missing/unreadable.\n */\nexport function discoverHostPorts(target: TargetId, cwd: string, spec: TargetSpec): HostPort[] {\n  try {\n    if (target === 'local') return composeHostPorts(path.join(cwd, spec.dir, 'docker-compose.yml'));\n    if (target === 'minikube') return forwardHostPorts(path.join(cwd, spec.dir, 'bin', 'setup.sh'));\n    return []; // ec2/fargate deploy remotely — nothing binds locally\n  } catch {\n    return spec.hostPorts.map((p) => ({ ...p }));\n  }\n}\n\n/** Probe each host port; returns one PortCheck per port (probed in parallel). */\nexport async function checkHostPorts(ports: readonly HostPort[]): Promise<PortCheck[]> {\n  return Promise.all(ports.map(async ({ service, port }) => ({ service, port, available: await isPortFree(port) })));\n}\n\n/**\n * Is the target's OWN deploy stack already running? (local docker-compose only.) Used\n * so the port pre-flight doesn't block an idempotent RE-RUN: if the \"taken\" ports are\n * held by the stack you already have up, `docker compose up` just no-ops them — that's\n * not a conflict. Read-only `docker compose ps`; false on any error / non-local target.\n */\nexport function stackRunning(target: TargetId, cwd: string, spec: TargetSpec): boolean {\n  if (target !== 'local') return false;\n  try {\n    const compose = path.join(cwd, spec.dir, 'docker-compose.yml');\n    const out = execSync(`docker compose -f '${compose}' ps -q`, { stdio: ['ignore', 'pipe', 'ignore'], timeout: 10000 })\n      .toString()\n      .trim();\n    return out.length > 0;\n  } catch {\n    return false;\n  }\n}\n"]}

package/dist/agent/post-steps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"post-steps.d.ts","sourceRoot":"","sources":["../../src/agent/post-steps.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AAEH,OAAO,EAAc,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AAEzD,MAAM,WAAW,QAAQ;IACvB,sEAAsE;IACtE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,qCAAqC;IACrC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,gCAAgC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,oFAAoF;IACpF,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACjD;AAED,gEAAgE;AAChE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,CAAC;CACjC;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,yEAAyE;IACzE,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,+FAA+F;IAC/F,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,gFAAgF;IAChF,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,oFAAoF;IACpF,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,qDAAqD;IACrD,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AASD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,GAAG,iBAAiB,CA6DzE"}
+{"version":3,"file":"post-steps.d.ts","sourceRoot":"","sources":["../../src/agent/post-steps.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AAEH,OAAO,EAAc,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AAEzD,MAAM,WAAW,QAAQ;IACvB,sEAAsE;IACtE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,qCAAqC;IACrC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,gCAAgC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,oFAAoF;IACpF,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACjD;AAED,gEAAgE;AAChE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,CAAC;CACjC;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,yEAAyE;IACzE,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,+FAA+F;IAC/F,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,gFAAgF;IAChF,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,oFAAoF;IACpF,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,qDAAqD;IACrD,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AASD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,GAAG,iBAAiB,CAiEzE"}

package/dist/agent/post-steps.js

@@ -40,10 +40,13 @@ export function resolvePostSteps(opts) {
     if (opts.smokeTest) {
         if (opts.url) {
             // -k: local/minikube front a self-signed cert; harmless against real-cert AWS URLs.
+            // Probe /health — the one route guaranteed to exist and serve unauthenticated
+            // through nginx (every /api/* route requires auth → 401; /api/version doesn't
+            // exist and would fall through to the SPA, making `curl -f` meaningless).
             steps.push({
                 id: 'smoke-test',
-                label: 'Smoke test — read-only API check',
-                command: `curl -fsSk ${opts.url}/api/version && echo 'smoke-test: API reachable'`,
+                label: 'Smoke test — gateway/API reachability',
+                command: `curl -fsSk ${opts.url}/health && echo 'smoke-test: API reachable'`,
             });
         }
         else {
@@ -55,10 +58,11 @@ export function resolvePostSteps(opts) {
             // Event ingestion needs a platform JWT in Secrets Manager BEFORE the Lambda
             // is wired up, so this is a two-step bundle: store-token writes the token,
             // then setup-events deploys the EventBridge → SQS → Lambda that reads it.
-            // Neither takes a secret name — both derive pipeline-builder's own pattern
-            // (CoreConstants.secretPath → pipeline-builder/{orgId}/platform) from the
-            // org, so they agree automatically. They get PLATFORM_BASE_URL (step env) +
-            // admin creds (merged by the caller) to resolve the org.
+            // store-token derives the secret path from the JWT's org (CoreConstants pattern
+            // → pipeline-builder/{orgId}/platform). NOTE: setup-events still REQUIRES that
+            // name via --secret-name / PLATFORM_SECRET_NAME (it does not yet derive it), so
+            // the operator supplies it when running this bundle. provision surfaces (does not
+            // auto-run) the bundle on AWS — it needs a registered, in-VPC platform.
             const region = opts.region ? ` --region ${opts.region}` : '';
             const env = opts.url ? { PLATFORM_BASE_URL: opts.url } : undefined;
             steps.push({
@@ -84,4 +88,4 @@ export function resolvePostSteps(opts) {
     });
     return { steps, skipped };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"post-steps.js","sourceRoot":"","sources":["../../src/agent/post-steps.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Post-install steps.\n *\n * After the platform is deployed + health-checked, provision runs an ordered set\n * of post-install steps: **register** (the admin, via `init-platform.sh`, driven\n * non-interactively by env — which also performs any opt-in plugin/compliance/\n * sample loads), then an optional **smoke-test**, **events** (AWS), and any\n * operator **--post-step** commands. Pure, deterministic assembly here — provision\n * runs each via the same gated `runScript()` as the deploy.\n */\n\nimport { LOAD_STEPS, type TargetId } from './targets.js';\n\nexport interface PostStep {\n  /** Stable id (`register` / `smoke-test` / `events`) or `custom-N`. */\n  readonly id: string;\n  /** Human label shown in the plan. */\n  readonly label: string;\n  /** The exact command to run. */\n  readonly command: string;\n  /** Non-secret env applied to the child for this step (e.g. LOAD_* for register). */\n  readonly env?: Readonly<Record<string, string>>;\n}\n\n/** A requested step that doesn't apply to the chosen target. */\nexport interface SkippedStep {\n  readonly id: string;\n  readonly reason: string;\n}\n\nexport interface ResolvedPostSteps {\n  readonly steps: PostStep[];\n  readonly skipped: SkippedStep[];\n}\n\nexport interface PostStepOptions {\n  readonly target: TargetId;\n  /** Base URL of the deployed platform (from deriveHealthUrl), or null. */\n  readonly url: string | null;\n  /** AWS region (ec2/fargate), if provided. */\n  readonly region?: string;\n  /** Load-step ids enabled via `--with-*` (drive init-platform's LOAD_* envs + sparse paths). */\n  readonly enabledLoadIds: readonly string[];\n  /** `--build-bootstrap`: build the CodeBuild bootstrap image during register. */\n  readonly buildBootstrap: boolean;\n  /** False when `--no-init` — skips the register step entirely. */\n  readonly init: boolean;\n  readonly smokeTest: boolean;\n  /** `--with-events`: the AWS event-ingestion bundle (store-token → setup-events). */\n  readonly events: boolean;\n  /** Raw operator `--post-step` commands, in order. */\n  readonly steps: readonly string[];\n}\n\n/** Compute the non-interactive env that drives init-platform's prompts. */\nfunction registerEnv(enabledLoadIds: readonly string[], buildBootstrap: boolean): Record<string, string> {\n  const env: Record<string, string> = { BUILD_BOOTSTRAP: buildBootstrap ? 'y' : 'n' };\n  for (const step of LOAD_STEPS) env[step.env] = enabledLoadIds.includes(step.id) ? 'y' : 'n';\n  return env;\n}\n\n/**\n * Resolve the ordered post-install step list: register → smoke-test → events →\n * custom. `register` carries the load + BUILD_BOOTSTRAP env so init-platform runs\n * the enabled loads non-interactively. Requested-but-inapplicable steps land in\n * `skipped` so the caller can warn rather than silently drop them.\n */\nexport function resolvePostSteps(opts: PostStepOptions): ResolvedPostSteps {\n  const steps: PostStep[] = [];\n  const skipped: SkippedStep[] = [];\n\n  if (opts.init) {\n    const enabled = LOAD_STEPS.filter((s) => opts.enabledLoadIds.includes(s.id)).map((s) => s.id);\n    const loads = enabled.length > 0 ? ` (+ ${enabled.join(', ')})` : '';\n    steps.push({\n      id: 'register',\n      label: `Register admin${loads}`,\n      command: `./deploy/bin/init-platform.sh ${opts.target}`,\n      env: registerEnv(opts.enabledLoadIds, opts.buildBootstrap),\n    });\n  }\n\n  if (opts.smokeTest) {\n    if (opts.url) {\n      // -k: local/minikube front a self-signed cert; harmless against real-cert AWS URLs.\n      steps.push({\n        id: 'smoke-test',\n        label: 'Smoke test — read-only API check',\n        command: `curl -fsSk ${opts.url}/api/version && echo 'smoke-test: API reachable'`,\n      });\n    } else {\n      skipped.push({ id: 'smoke-test', reason: 'no platform URL to probe for this target' });\n    }\n  }\n\n  if (opts.events) {\n    if (opts.target === 'ec2' || opts.target === 'fargate') {\n      // Event ingestion needs a platform JWT in Secrets Manager BEFORE the Lambda\n      // is wired up, so this is a two-step bundle: store-token writes the token,\n      // then setup-events deploys the EventBridge → SQS → Lambda that reads it.\n      // Neither takes a secret name — both derive pipeline-builder's own pattern\n      // (CoreConstants.secretPath → pipeline-builder/{orgId}/platform) from the\n      // org, so they agree automatically. They get PLATFORM_BASE_URL (step env) +\n      // admin creds (merged by the caller) to resolve the org.\n      const region = opts.region ? ` --region ${opts.region}` : '';\n      const env = opts.url ? { PLATFORM_BASE_URL: opts.url } : undefined;\n      steps.push({\n        id: 'store-token',\n        label: 'Store platform token in AWS Secrets Manager',\n        command: `pipeline-manager store-token${region}`,\n        env,\n      });\n      steps.push({\n        id: 'events',\n        label: 'EventBridge ingestion (setup-events)',\n        command: `pipeline-manager setup-events${region}`,\n        env,\n      });\n    } else {\n      skipped.push({ id: 'events', reason: `not applicable to target '${opts.target}' (ec2/fargate only)` });\n    }\n  }\n\n  opts.steps.forEach((command, i) => {\n    if (command.trim() !== '') steps.push({ id: `custom-${i + 1}`, label: `Custom step ${i + 1}`, command });\n  });\n\n  return { steps, skipped };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"post-steps.js","sourceRoot":"","sources":["../../src/agent/post-steps.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Post-install steps.\n *\n * After the platform is deployed + health-checked, provision runs an ordered set\n * of post-install steps: **register** (the admin, via `init-platform.sh`, driven\n * non-interactively by env — which also performs any opt-in plugin/compliance/\n * sample loads), then an optional **smoke-test**, **events** (AWS), and any\n * operator **--post-step** commands. Pure, deterministic assembly here — provision\n * runs each via the same gated `runScript()` as the deploy.\n */\n\nimport { LOAD_STEPS, type TargetId } from './targets.js';\n\nexport interface PostStep {\n  /** Stable id (`register` / `smoke-test` / `events`) or `custom-N`. */\n  readonly id: string;\n  /** Human label shown in the plan. */\n  readonly label: string;\n  /** The exact command to run. */\n  readonly command: string;\n  /** Non-secret env applied to the child for this step (e.g. LOAD_* for register). */\n  readonly env?: Readonly<Record<string, string>>;\n}\n\n/** A requested step that doesn't apply to the chosen target. */\nexport interface SkippedStep {\n  readonly id: string;\n  readonly reason: string;\n}\n\nexport interface ResolvedPostSteps {\n  readonly steps: PostStep[];\n  readonly skipped: SkippedStep[];\n}\n\nexport interface PostStepOptions {\n  readonly target: TargetId;\n  /** Base URL of the deployed platform (from deriveHealthUrl), or null. */\n  readonly url: string | null;\n  /** AWS region (ec2/fargate), if provided. */\n  readonly region?: string;\n  /** Load-step ids enabled via `--with-*` (drive init-platform's LOAD_* envs + sparse paths). */\n  readonly enabledLoadIds: readonly string[];\n  /** `--build-bootstrap`: build the CodeBuild bootstrap image during register. */\n  readonly buildBootstrap: boolean;\n  /** False when `--no-init` — skips the register step entirely. */\n  readonly init: boolean;\n  readonly smokeTest: boolean;\n  /** `--with-events`: the AWS event-ingestion bundle (store-token → setup-events). */\n  readonly events: boolean;\n  /** Raw operator `--post-step` commands, in order. */\n  readonly steps: readonly string[];\n}\n\n/** Compute the non-interactive env that drives init-platform's prompts. */\nfunction registerEnv(enabledLoadIds: readonly string[], buildBootstrap: boolean): Record<string, string> {\n  const env: Record<string, string> = { BUILD_BOOTSTRAP: buildBootstrap ? 'y' : 'n' };\n  for (const step of LOAD_STEPS) env[step.env] = enabledLoadIds.includes(step.id) ? 'y' : 'n';\n  return env;\n}\n\n/**\n * Resolve the ordered post-install step list: register → smoke-test → events →\n * custom. `register` carries the load + BUILD_BOOTSTRAP env so init-platform runs\n * the enabled loads non-interactively. Requested-but-inapplicable steps land in\n * `skipped` so the caller can warn rather than silently drop them.\n */\nexport function resolvePostSteps(opts: PostStepOptions): ResolvedPostSteps {\n  const steps: PostStep[] = [];\n  const skipped: SkippedStep[] = [];\n\n  if (opts.init) {\n    const enabled = LOAD_STEPS.filter((s) => opts.enabledLoadIds.includes(s.id)).map((s) => s.id);\n    const loads = enabled.length > 0 ? ` (+ ${enabled.join(', ')})` : '';\n    steps.push({\n      id: 'register',\n      label: `Register admin${loads}`,\n      command: `./deploy/bin/init-platform.sh ${opts.target}`,\n      env: registerEnv(opts.enabledLoadIds, opts.buildBootstrap),\n    });\n  }\n\n  if (opts.smokeTest) {\n    if (opts.url) {\n      // -k: local/minikube front a self-signed cert; harmless against real-cert AWS URLs.\n      // Probe /health — the one route guaranteed to exist and serve unauthenticated\n      // through nginx (every /api/* route requires auth → 401; /api/version doesn't\n      // exist and would fall through to the SPA, making `curl -f` meaningless).\n      steps.push({\n        id: 'smoke-test',\n        label: 'Smoke test — gateway/API reachability',\n        command: `curl -fsSk ${opts.url}/health && echo 'smoke-test: API reachable'`,\n      });\n    } else {\n      skipped.push({ id: 'smoke-test', reason: 'no platform URL to probe for this target' });\n    }\n  }\n\n  if (opts.events) {\n    if (opts.target === 'ec2' || opts.target === 'fargate') {\n      // Event ingestion needs a platform JWT in Secrets Manager BEFORE the Lambda\n      // is wired up, so this is a two-step bundle: store-token writes the token,\n      // then setup-events deploys the EventBridge → SQS → Lambda that reads it.\n      // store-token derives the secret path from the JWT's org (CoreConstants pattern\n      // → pipeline-builder/{orgId}/platform). NOTE: setup-events still REQUIRES that\n      // name via --secret-name / PLATFORM_SECRET_NAME (it does not yet derive it), so\n      // the operator supplies it when running this bundle. provision surfaces (does not\n      // auto-run) the bundle on AWS — it needs a registered, in-VPC platform.\n      const region = opts.region ? ` --region ${opts.region}` : '';\n      const env = opts.url ? { PLATFORM_BASE_URL: opts.url } : undefined;\n      steps.push({\n        id: 'store-token',\n        label: 'Store platform token in AWS Secrets Manager',\n        command: `pipeline-manager store-token${region}`,\n        env,\n      });\n      steps.push({\n        id: 'events',\n        label: 'EventBridge ingestion (setup-events)',\n        command: `pipeline-manager setup-events${region}`,\n        env,\n      });\n    } else {\n      skipped.push({ id: 'events', reason: `not applicable to target '${opts.target}' (ec2/fargate only)` });\n    }\n  }\n\n  opts.steps.forEach((command, i) => {\n    if (command.trim() !== '') steps.push({ id: `custom-${i + 1}`, label: `Custom step ${i + 1}`, command });\n  });\n\n  return { steps, skipped };\n}\n"]}

package/dist/agent/prereqs.d.ts

@@ -15,7 +15,7 @@ export declare function gitAvailable(): boolean;
 export declare function gitSupportsSparseCheckout(): boolean;
 /**
  * Run the read-only prerequisite checks for a target. Pure inspection — safe to
- * run unconditionally (Phase-1 advisor calls this before assembling the command).
+ * run unconditionally (the plan assembles this before the gated execution).
  */
 export declare function checkPrereqs(target: TargetId, opts?: {
     bootstrap?: boolean;

package/dist/agent/prereqs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prereqs.d.ts","sourceRoot":"","sources":["../../src/agent/prereqs.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AA0CD,uEAAuE;AACvE,wBAAgB,YAAY,IAAI,OAAO,CAEtC;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,OAAO,CAGnD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,WAAW,EAAE,CAkFvH;AAED,oDAAoD;AACpD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,GAAG,OAAO,CAExE"}
+{"version":3,"file":"prereqs.d.ts","sourceRoot":"","sources":["../../src/agent/prereqs.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AA0CD,uEAAuE;AACvE,wBAAgB,YAAY,IAAI,OAAO,CAEtC;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,OAAO,CAGnD;AAWD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,WAAW,EAAE,CAoDvH;AAED,oDAAoD;AACpD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,GAAG,OAAO,CAExE"}