@pipeline-builder/pipeline-manager 0.0.1

package/dist/agent/health.js

@@ -0,0 +1,109 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Post-deploy health verification. A CloudFormation CREATE_COMPLETE (or a
+ * finished setup.sh) does NOT mean the app is serving — the ALB targets stay
+ * unhealthy until tasks/pods come up. The real done-signal is the platform's
+ * `/health` + `/ready` endpoints, so the executor polls them with backoff.
+ */
+import { spawn } from 'child_process';
+import axios from 'axios';
+import { httpsAgentForUrl } from '../utils/tls.js';
+/**
+ * Derive the URL the platform should be reachable at. Local/minikube front the
+ * stack on localhost:8443; EC2/EKS use the deploy domain. Returns null when
+ * it can't be determined (caller surfaces a "verify manually" note).
+ */
+export function deriveHealthUrl(target, params) {
+    if (target === 'docker' || target === 'minikube')
+        return 'https://localhost:8443';
+    const domain = params.domain;
+    return typeof domain === 'string' && domain ? `https://${domain}` : null;
+}
+async function probe(url) {
+    try {
+        // Skip cert verification only for local/self-signed hosts (docker/minikube);
+        // a real ec2/eks domain presents a valid ACM cert and IS verified.
+        const res = await axios.get(url, { timeout: 5000, httpsAgent: httpsAgentForUrl(url), validateStatus: () => true });
+        return res.status >= 200 && res.status < 300;
+    }
+    catch {
+        return false;
+    }
+}
+const delay = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * Poll `<url>/health` then `<url>/ready` until both pass or the timeout elapses.
+ * Non-fatal by design: a timeout returns `healthy: false` with guidance, never throws.
+ */
+export async function waitHealthy(url, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? 300_000; // 5 min — services come up async
+    const intervalMs = opts.intervalMs ?? 10_000;
+    // Once /health is up, only wait this much longer for /ready before proceeding.
+    const readyGraceMs = opts.readyGraceMs ?? 90_000; // 90s covers normal warmup
+    const deadline = Date.now() + timeoutMs;
+    // Wait for /health, then give /ready a BOUNDED grace window. /health flips first
+    // (the process is up); /ready also requires every backend dependency to be up.
+    // We prefer /ready (post-install register hits a not-yet-ready platform → 502),
+    // but if a dependency is DOWN (e.g. a crash-looping service) /ready never flips —
+    // so we must not block the full timeout on it. Once /health is up we wait at most
+    // `readyGraceMs` more, then proceed with a warning (register only needs the
+    // platform service, which /health already confirms is up).
+    let healthSeenAt = 0;
+    while (Date.now() < deadline) {
+        if (await probe(`${url}/health`)) {
+            if (healthSeenAt === 0)
+                healthSeenAt = Date.now();
+            if (await probe(`${url}/ready`)) {
+                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.`,
+                };
+            }
+            opts.onTick?.(`Health OK — waiting up to ${Math.ceil(leftMs / 1000)}s for ${url}/ready (dependencies warming up) …`);
+        }
+        else {
+            opts.onTick?.(`Waiting for ${url}/health …`);
+        }
+        await delay(intervalMs);
+    }
+    // Overall timeout. If /health came up but /ready never did, proceed (non-fatal).
+    return healthSeenAt > 0
+        ? { 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
+ * `kubectl port-forward svc/nginx` that setup.sh backgrounds — which can die or
+ * fail to bind (e.g. a busy port) while the pods stay healthy, leaving the gateway
+ * unreachable so the health poll just times out. Before polling, probe the gateway;
+ * if it's down, (re)start the forward DETACHED so it outlives this CLI, then give
+ * it a moment to bind. Best-effort: never throws; on no-kubectl it logs the manual
+ * command. (setup.sh now forwards 8443 only, so a busy 8080 can't take it down.)
+ */
+export async function ensureMinikubeGateway(url, opts = {}) {
+    const ns = opts.ns ?? 'pipeline-builder';
+    const port = opts.port ?? 8443;
+    if (await probe(`${url}/health`))
+        return; // forward already up — nothing to do
+    opts.onInfo?.(`Gateway unreachable — (re)starting the nginx port-forward (svc/nginx ${port}:${port}, ns ${ns}) …`);
+    // A missing kubectl surfaces as an async 'error' event (ENOENT), NOT a synchronous
+    // throw — a try/catch would miss it and the unhandled event would crash the CLI. Attach
+    // an 'error' listener so this stays best-effort (logs the manual command, never throws).
+    const child = spawn('kubectl', ['port-forward', '-n', ns, 'svc/nginx', `${port}:${port}`], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.on('error', () => {
+        opts.onInfo?.(`Couldn't start it (is kubectl on PATH?). Start it manually: kubectl port-forward -n ${ns} svc/nginx ${port}:${port}`);
+    });
+    child.unref(); // detached + unref → survives this CLI so the user keeps the gateway
+    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 axios from 'axios';\nimport type { TargetId } from './targets.js';\nimport { httpsAgentForUrl } from '../utils/tls.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/EKS 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 === 'docker' || target === 'minikube') return 'https://localhost:8443';\n  const domain = params.domain;\n  return typeof domain === 'string' && domain ? `https://${domain}` : null;\n}\n\nasync function probe(url: string): Promise<boolean> {\n  try {\n    // Skip cert verification only for local/self-signed hosts (docker/minikube);\n    // a real ec2/eks domain presents a valid ACM cert and IS verified.\n    const res = await axios.get(url, { timeout: 5000, httpsAgent: httpsAgentForUrl(url), 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  // A missing kubectl surfaces as an async 'error' event (ENOENT), NOT a synchronous\n  // throw — a try/catch would miss it and the unhandled event would crash the CLI. Attach\n  // an 'error' listener so this stays best-effort (logs the manual command, never throws).\n  const child = spawn('kubectl', ['port-forward', '-n', ns, 'svc/nginx', `${port}:${port}`], {\n    detached: true,\n    stdio: 'ignore',\n  });\n  child.on('error', () => {\n    opts.onInfo?.(`Couldn't start it (is kubectl on PATH?). Start it manually: kubectl port-forward -n ${ns} svc/nginx ${port}:${port}`);\n  });\n  child.unref(); // detached + unref → survives this CLI so the user keeps the gateway\n  await delay(2000); // let it bind before the caller polls\n}\n"]}

package/dist/agent/ports.d.ts

@@ -0,0 +1,26 @@
+import type { TargetId, TargetSpec } from './targets.js';
+export interface HostPort {
+    readonly service: string;
+    readonly port: number;
+}
+export interface PortCheck extends HostPort {
+    readonly available: boolean;
+}
+/**
+ * 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/eks → 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

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

@@ -0,0 +1,132 @@
+// 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 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/eks 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) => {
+        const srv = net.createServer();
+        srv.once('error', () => resolve(false));
+        srv.once('listening', () => srv.close(() => resolve(true)));
+        srv.listen(port, host);
+    });
+}
+/**
+ * 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;
+}
+/**
+ * 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/eks → 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 === 'docker')
+            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/eks 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 !== 'docker')
+        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,{"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/eks 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/eks → 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 === 'docker') 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/eks 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 !== 'docker') 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

@@ -0,0 +1,61 @@
+/**
+ * Post-install steps.
+ *
+ * After the platform is deployed + health-checked, provision runs an ordered set
+ * of post-install steps: **register** (the admin, via `init-platform.sh`, driven
+ * non-interactively by env — which also performs any opt-in plugin/compliance/
+ * sample loads), then an optional **smoke-test**, **events** (AWS), and any
+ * operator **--post-step** commands. Pure, deterministic assembly here — provision
+ * runs each via the same gated `runScript()` as the deploy.
+ */
+import { type TargetId } from './targets.js';
+export interface PostStep {
+    /** Stable id (`register` / `smoke-test` / `events`) or `custom-N`. */
+    readonly id: string;
+    /** Human label shown in the plan. */
+    readonly label: string;
+    /** The exact command to run. */
+    readonly command: string;
+    /** Non-secret env applied to the child for this step (e.g. LOAD_* for register). */
+    readonly env?: Readonly<Record<string, string>>;
+}
+/** A requested step that doesn't apply to the chosen target. */
+export interface SkippedStep {
+    readonly id: string;
+    readonly reason: string;
+}
+export interface ResolvedPostSteps {
+    readonly steps: PostStep[];
+    readonly skipped: SkippedStep[];
+}
+export interface PostStepOptions {
+    readonly target: TargetId;
+    /** Base URL of the deployed platform (from deriveHealthUrl), or null. */
+    readonly url: string | null;
+    /** AWS region (ec2/eks), if provided. */
+    readonly region?: string;
+    /** Load-step ids enabled via `--with-*` (drive init-platform's LOAD_* envs + sparse paths). */
+    readonly enabledLoadIds: readonly string[];
+    /** `--build-bootstrap`: build the CodeBuild bootstrap image during register. */
+    readonly buildBootstrap: boolean;
+    /** False when `--no-init` — skips the register step entirely. */
+    readonly init: boolean;
+    /** True for `--init auto` (the default mode). On the AWS targets the deploy self-runs
+     *  init-platform (ec2 on first boot, eks in setup.sh's final phase), so the register step is
+     *  NOT surfaced here — it would duplicate that deploy-managed run. (minikube/local run init
+     *  via provision, not a deploy-managed init.) */
+    readonly autoInit?: boolean;
+    readonly smokeTest: boolean;
+    /** `--with-events`: the AWS event-ingestion bundle (store-token → setup-events). */
+    readonly events: boolean;
+    /** Raw operator `--post-step` commands, in order. */
+    readonly steps: readonly string[];
+}
+/**
+ * Resolve the ordered post-install step list: register → smoke-test → events →
+ * custom. `register` carries the load + BUILD_BOOTSTRAP env so init-platform runs
+ * the enabled loads non-interactively. Requested-but-inapplicable steps land in
+ * `skipped` so the caller can warn rather than silently drop them.
+ */
+export declare function resolvePostSteps(opts: PostStepOptions): ResolvedPostSteps;
+//# sourceMappingURL=post-steps.d.ts.map

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

@@ -0,0 +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,yCAAyC;IACzC,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;;;qDAGiD;IACjD,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,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,CA0GzE"}

package/dist/agent/post-steps.js

@@ -0,0 +1,131 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Post-install steps.
+ *
+ * After the platform is deployed + health-checked, provision runs an ordered set
+ * of post-install steps: **register** (the admin, via `init-platform.sh`, driven
+ * non-interactively by env — which also performs any opt-in plugin/compliance/
+ * sample loads), then an optional **smoke-test**, **events** (AWS), and any
+ * operator **--post-step** commands. Pure, deterministic assembly here — provision
+ * runs each via the same gated `runScript()` as the deploy.
+ */
+import { LOAD_STEPS } from './targets.js';
+/** Compute the non-interactive env that drives init-platform's prompts. */
+function registerEnv(enabledLoadIds, buildBootstrap) {
+    const env = { BUILD_BOOTSTRAP: buildBootstrap ? 'y' : 'n' };
+    for (const step of LOAD_STEPS)
+        env[step.env] = enabledLoadIds.includes(step.id) ? 'y' : 'n';
+    return env;
+}
+/**
+ * Resolve the ordered post-install step list: register → smoke-test → events →
+ * custom. `register` carries the load + BUILD_BOOTSTRAP env so init-platform runs
+ * the enabled loads non-interactively. Requested-but-inapplicable steps land in
+ * `skipped` so the caller can warn rather than silently drop them.
+ */
+export function resolvePostSteps(opts) {
+    const steps = [];
+    const skipped = [];
+    // `--init auto` (the default) on the AWS targets: the deploy runs init-platform itself —
+    // ec2 on the instance on first boot, eks in setup.sh's final phase — so DON'T add a register
+    // step here; it would duplicate the deploy-managed run. (minikube/local run init via provision.)
+    const autoInitManaged = opts.init && opts.autoInit === true && (opts.target === 'ec2' || opts.target === 'eks');
+    if (opts.init && !autoInitManaged) {
+        const enabled = LOAD_STEPS.filter((s) => opts.enabledLoadIds.includes(s.id)).map((s) => s.id);
+        const loads = enabled.length > 0 ? ` (+ ${enabled.join(', ')})` : '';
+        // Register is surfaced as a manual next-step on AWS (see runPostSteps). The command differs:
+        //  - ec2: runs ON the box as the minikube user, where the in-VPC URL resolves → bake PLATFORM_BASE_URL.
+        //  - eks: init-platform port-forwards to svc/nginx, so it runs from anywhere with kubectl access —
+        //    do NOT bake PLATFORM_BASE_URL (that would force the public URL and wait on the ALB/DNS).
+        //  - local/minikube: plain command (the URL is localhost).
+        const registerCommand = opts.target === 'ec2' && opts.url
+            ? `PLATFORM_BASE_URL=${opts.url} ./deploy/bin/init-platform.sh ec2`
+            : `./deploy/bin/init-platform.sh ${opts.target}`;
+        steps.push({
+            id: 'register',
+            label: `Register admin${loads}`,
+            command: registerCommand,
+            env: registerEnv(opts.enabledLoadIds, opts.buildBootstrap),
+        });
+    }
+    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 — gateway/API reachability',
+                command: `curl -fsSk ${opts.url}/health && echo 'smoke-test: API reachable'`,
+            });
+        }
+        else {
+            skipped.push({ id: 'smoke-test', reason: 'no platform URL to probe for this target' });
+        }
+    }
+    if (opts.events) {
+        if (opts.target === 'ec2' || opts.target === 'eks') {
+            // Event ingestion is a THREE-step bundle, in this order:
+            //   1. store-token          — the full-privilege platform JWT (synth/deploy
+            //                             callbacks read it; --schedule auto-renews it).
+            //   2. store-token --scope reporting:ingest --schedule
+            //                           — a DISTINCT least-privilege token whose `scope`
+            //                             claim is exactly `reporting:ingest`. The ingest
+            //                             endpoint requires this scope and `hasScope` is a
+            //                             single-value equality check, so the platform
+            //                             token (no scope) can NEVER ingest — the Lambda
+            //                             must read this dedicated token. Stored at
+            //                             `.../reporting-ingest`. --schedule deploys its OWN
+            //                             renewal stack (named `-reporting-ingest`, distinct
+            //                             from the platform one) whose handler preserves the
+            //                             scope on re-mint, so it auto-renews and never lapses.
+            //                             See setup-events --scoped-ingest.
+            //   3. setup-events --scoped-ingest
+            //                           — deploys the EventBridge → SQS → Lambda and points
+            //                             the Lambda at the reporting-ingest secret from #2.
+            //                             WITHOUT --scoped-ingest the Lambda reads the
+            //                             platform secret and every ingest 403s
+            //                             ("Token must carry the 'reporting:ingest' scope").
+            // provision surfaces (does not auto-run) the bundle on AWS — it needs a
+            // registered, in-VPC platform.
+            const region = opts.region ? ` --region ${opts.region}` : '';
+            // Mirror the register branch's target rule: bake PLATFORM_BASE_URL only on
+            // ec2 (the in-VPC URL resolves on the box). On eks the public ALB/DNS isn't
+            // up yet, so baking it would point store-token/setup-events at an
+            // unresolvable host — the operator sets PLATFORM_BASE_URL when running the
+            // surfaced bundle, once the ALB is ready.
+            const env = opts.target === 'ec2' && opts.url ? { PLATFORM_BASE_URL: opts.url } : undefined;
+            steps.push({
+                id: 'store-token',
+                label: 'Store platform token in AWS Secrets Manager (+ daily auto-renewal)',
+                // --schedule: synth/deploy callbacks read this token, so install the
+                // renewal stack so it never lapses (store-token no longer deploys it by default).
+                command: `pipeline-manager infra store-token --schedule${region}`,
+                env,
+            });
+            steps.push({
+                id: 'store-token-ingest',
+                label: 'Store reporting-ingest (scoped) token in AWS Secrets Manager (+ auto-renewal)',
+                command: `pipeline-manager infra store-token --scope reporting:ingest --schedule${region}`,
+                env,
+            });
+            steps.push({
+                id: 'events',
+                label: 'EventBridge ingestion (setup-events, scoped-ingest)',
+                command: `pipeline-manager infra setup-events --scoped-ingest${region}`,
+                env,
+            });
+        }
+        else {
+            skipped.push({ id: 'events', reason: `not applicable to target '${opts.target}' (ec2/eks only)` });
+        }
+    }
+    opts.steps.forEach((command, i) => {
+        if (command.trim() !== '')
+            steps.push({ id: `custom-${i + 1}`, label: `Custom step ${i + 1}`, command });
+    });
+    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/eks), 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  /** True for `--init auto` (the default mode). On the AWS targets the deploy self-runs\n   *  init-platform (ec2 on first boot, eks in setup.sh's final phase), so the register step is\n   *  NOT surfaced here — it would duplicate that deploy-managed run. (minikube/local run init\n   *  via provision, not a deploy-managed init.) */\n  readonly autoInit?: 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  // `--init auto` (the default) on the AWS targets: the deploy runs init-platform itself —\n  // ec2 on the instance on first boot, eks in setup.sh's final phase — so DON'T add a register\n  // step here; it would duplicate the deploy-managed run. (minikube/local run init via provision.)\n  const autoInitManaged =\n    opts.init && opts.autoInit === true && (opts.target === 'ec2' || opts.target === 'eks');\n  if (opts.init && !autoInitManaged) {\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    // Register is surfaced as a manual next-step on AWS (see runPostSteps). The command differs:\n    //  - ec2: runs ON the box as the minikube user, where the in-VPC URL resolves → bake PLATFORM_BASE_URL.\n    //  - eks: init-platform port-forwards to svc/nginx, so it runs from anywhere with kubectl access —\n    //    do NOT bake PLATFORM_BASE_URL (that would force the public URL and wait on the ALB/DNS).\n    //  - local/minikube: plain command (the URL is localhost).\n    const registerCommand = opts.target === 'ec2' && opts.url\n      ? `PLATFORM_BASE_URL=${opts.url} ./deploy/bin/init-platform.sh ec2`\n      : `./deploy/bin/init-platform.sh ${opts.target}`;\n    steps.push({\n      id: 'register',\n      label: `Register admin${loads}`,\n      command: registerCommand,\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 === 'eks') {\n      // Event ingestion is a THREE-step bundle, in this order:\n      //   1. store-token          — the full-privilege platform JWT (synth/deploy\n      //                             callbacks read it; --schedule auto-renews it).\n      //   2. store-token --scope reporting:ingest --schedule\n      //                           — a DISTINCT least-privilege token whose `scope`\n      //                             claim is exactly `reporting:ingest`. The ingest\n      //                             endpoint requires this scope and `hasScope` is a\n      //                             single-value equality check, so the platform\n      //                             token (no scope) can NEVER ingest — the Lambda\n      //                             must read this dedicated token. Stored at\n      //                             `.../reporting-ingest`. --schedule deploys its OWN\n      //                             renewal stack (named `-reporting-ingest`, distinct\n      //                             from the platform one) whose handler preserves the\n      //                             scope on re-mint, so it auto-renews and never lapses.\n      //                             See setup-events --scoped-ingest.\n      //   3. setup-events --scoped-ingest\n      //                           — deploys the EventBridge → SQS → Lambda and points\n      //                             the Lambda at the reporting-ingest secret from #2.\n      //                             WITHOUT --scoped-ingest the Lambda reads the\n      //                             platform secret and every ingest 403s\n      //                             (\"Token must carry the 'reporting:ingest' scope\").\n      // provision surfaces (does not auto-run) the bundle on AWS — it needs a\n      // registered, in-VPC platform.\n      const region = opts.region ? ` --region ${opts.region}` : '';\n      // Mirror the register branch's target rule: bake PLATFORM_BASE_URL only on\n      // ec2 (the in-VPC URL resolves on the box). On eks the public ALB/DNS isn't\n      // up yet, so baking it would point store-token/setup-events at an\n      // unresolvable host — the operator sets PLATFORM_BASE_URL when running the\n      // surfaced bundle, once the ALB is ready.\n      const env = opts.target === 'ec2' && opts.url ? { PLATFORM_BASE_URL: opts.url } : undefined;\n      steps.push({\n        id: 'store-token',\n        label: 'Store platform token in AWS Secrets Manager (+ daily auto-renewal)',\n        // --schedule: synth/deploy callbacks read this token, so install the\n        // renewal stack so it never lapses (store-token no longer deploys it by default).\n        command: `pipeline-manager infra store-token --schedule${region}`,\n        env,\n      });\n      steps.push({\n        id: 'store-token-ingest',\n        label: 'Store reporting-ingest (scoped) token in AWS Secrets Manager (+ auto-renewal)',\n        command: `pipeline-manager infra store-token --scope reporting:ingest --schedule${region}`,\n        env,\n      });\n      steps.push({\n        id: 'events',\n        label: 'EventBridge ingestion (setup-events, scoped-ingest)',\n        command: `pipeline-manager infra setup-events --scoped-ingest${region}`,\n        env,\n      });\n    } else {\n      skipped.push({ id: 'events', reason: `not applicable to target '${opts.target}' (ec2/eks 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

@@ -0,0 +1,26 @@
+import type { TargetId } from './targets.js';
+export interface PrereqCheck {
+    readonly name: string;
+    readonly ok: boolean;
+    readonly detail: string;
+    /** A failing required check blocks deployment; advisory ones are warnings. */
+    readonly required: boolean;
+}
+/** True when git is on PATH (required to bootstrap a clone at all). */
+export declare function gitAvailable(): boolean;
+/**
+ * Cone `sparse-checkout` (+ `--filter=blob:none`) needs git ≥ 2.27. Below that,
+ * the bootstrap falls back to a (correct, just larger) full clone.
+ */
+export declare function gitSupportsSparseCheckout(): boolean;
+/**
+ * Run the read-only prerequisite checks for a target. Pure inspection — safe to
+ * run unconditionally (the plan assembles this before the gated execution).
+ */
+export declare function checkPrereqs(target: TargetId, opts?: {
+    bootstrap?: boolean;
+    withPlugins?: boolean;
+}): PrereqCheck[];
+/** True when every REQUIRED prerequisite passed. */
+export declare function prereqsSatisfied(checks: readonly PrereqCheck[]): boolean;
+//# sourceMappingURL=prereqs.d.ts.map

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

@@ -0,0 +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;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,CAgEvH;AAED,oDAAoD;AACpD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,GAAG,OAAO,CAExE"}