@pipeline-builder/pipeline-manager 3.4.70 → 3.4.72

package/dist/agent/health.js

@@ -0,0 +1,55 @@
+// 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 https from 'https';
+import axios from 'axios';
+/**
+ * Derive the URL the platform should be reachable at. Local/minikube front the
+ * stack on localhost:8443; EC2/Fargate 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 === 'local' || target === 'minikube')
+        return 'https://localhost:8443';
+    const domain = params.domain;
+    return typeof domain === 'string' && domain ? `https://${domain}` : null;
+}
+const agent = new https.Agent({ rejectUnauthorized: false }); // local uses a self-signed cert
+async function probe(url) {
+    try {
+        const res = await axios.get(url, { timeout: 5000, httpsAgent: agent, 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;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (await probe(`${url}/health`)) {
+            const ready = await probe(`${url}/ready`);
+            return {
+                url,
+                healthy: true,
+                detail: ready ? 'health + ready OK' : 'health OK (ready not yet — dependencies still warming up)',
+            };
+        }
+        opts.onTick?.(`waiting for ${url}/health …`);
+        await delay(intervalMs);
+    }
+    return { url, healthy: false, detail: `not reachable within ${Math.round(timeoutMs / 1000)}s — check the stack / DNS / health logs` };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,55 @@
+/**
+ * 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/fargate), 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;
+    readonly smokeTest: boolean;
+    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,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,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,CA+CzE"}

package/dist/agent/post-steps.js

@@ -0,0 +1,73 @@
+// 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 = [];
+    if (opts.init) {
+        const enabled = LOAD_STEPS.filter((s) => opts.enabledLoadIds.includes(s.id)).map((s) => s.id);
+        const loads = enabled.length > 0 ? ` (+ ${enabled.join(', ')})` : '';
+        steps.push({
+            id: 'register',
+            label: `Register admin${loads}`,
+            command: `./deploy/bin/init-platform.sh ${opts.target}`,
+            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.
+            steps.push({
+                id: 'smoke-test',
+                label: 'Smoke test — read-only API check',
+                command: `curl -fsSk ${opts.url}/api/version && 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 === 'fargate') {
+            // Requires the pipeline-manager CLI on PATH; reads PLATFORM_BASE_URL /
+            // PLATFORM_SECRET_NAME from the environment (the command validates them).
+            steps.push({
+                id: 'events',
+                label: 'EventBridge ingestion (setup-events)',
+                command: `pipeline-manager setup-events${opts.region ? ` --region ${opts.region}` : ''}`,
+            });
+        }
+        else {
+            skipped.push({ id: 'events', reason: `not applicable to target '${opts.target}' (ec2/fargate 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/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  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      // Requires the pipeline-manager CLI on PATH; reads PLATFORM_BASE_URL /\n      // PLATFORM_SECRET_NAME from the environment (the command validates them).\n      steps.push({\n        id: 'events',\n        label: 'EventBridge ingestion (setup-events)',\n        command: `pipeline-manager setup-events${opts.region ? ` --region ${opts.region}` : ''}`,\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

@@ -0,0 +1,25 @@
+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 (Phase-1 advisor calls this before assembling the command).
+ */
+export declare function checkPrereqs(target: TargetId, opts?: {
+    bootstrap?: 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;AAqCD,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,CAAA;CAAO,GAAG,WAAW,EAAE,CAwChG;AAED,oDAAoD;AACpD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,GAAG,OAAO,CAExE"}

package/dist/agent/prereqs.js

@@ -0,0 +1,100 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Deterministic, READ-ONLY prerequisite checks per target. No LLM, no mutation —
+ * every command here only inspects (presence checks, `aws sts get-caller-identity`,
+ * `docker info`). This is the kind of thing a script does better than an agent,
+ * so it stays deterministic; the LLM is reserved for NL parsing + diagnosis.
+ */
+import { execSync } from 'child_process';
+/** True if `cmd` is on PATH. */
+function has(cmd) {
+    try {
+        execSync(`command -v ${cmd}`, { stdio: 'ignore', timeout: 5000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Run a read-only command; return its trimmed stdout or null on failure. */
+function read(cmd) {
+    try {
+        return execSync(cmd, { stdio: ['ignore', 'pipe', 'ignore'], timeout: 15000 }).toString().trim();
+    }
+    catch {
+        return null;
+    }
+}
+function dockerRunning() {
+    return has('docker') && read('docker info --format "{{.ServerVersion}}"') !== null;
+}
+function awsIdentity() {
+    if (!has('aws'))
+        return null;
+    return read('aws sts get-caller-identity --query Account --output text');
+}
+/** Parsed `git --version` as [major, minor], or null if git is absent/unparseable. */
+function gitVersion() {
+    const out = read('git --version');
+    const m = out?.match(/(\d+)\.(\d+)/);
+    return m ? [Number(m[1]), Number(m[2])] : null;
+}
+/** True when git is on PATH (required to bootstrap a clone at all). */
+export function gitAvailable() {
+    return gitVersion() !== null;
+}
+/**
+ * Cone `sparse-checkout` (+ `--filter=blob:none`) needs git ≥ 2.27. Below that,
+ * the bootstrap falls back to a (correct, just larger) full clone.
+ */
+export function gitSupportsSparseCheckout() {
+    const v = gitVersion();
+    return v !== null && (v[0] > 2 || (v[0] === 2 && v[1] >= 27));
+}
+/**
+ * Run the read-only prerequisite checks for a target. Pure inspection — safe to
+ * run unconditionally (Phase-1 advisor calls this before assembling the command).
+ */
+export function checkPrereqs(target, opts = {}) {
+    const checks = [];
+    // `--repo` bootstrap git-clones the platform repo first → git is required. A
+    // git below 2.27 still works (full-clone fallback), so the version is advisory.
+    if (opts.bootstrap) {
+        const v = gitVersion();
+        checks.push({ name: 'git', ok: v !== null, detail: v ? `on PATH (${v[0]}.${v[1]})` : 'install git', required: true });
+        if (v !== null && !gitSupportsSparseCheckout()) {
+            checks.push({ name: 'git ≥ 2.27', ok: false, detail: 'sparse clone needs git ≥ 2.27 — falling back to a full clone', required: false });
+        }
+    }
+    if (target === 'local') {
+        checks.push({
+            name: 'Docker',
+            ok: dockerRunning(),
+            detail: dockerRunning() ? 'daemon reachable' : 'install Docker and start the daemon',
+            required: true,
+        });
+        return checks;
+    }
+    if (target === 'minikube') {
+        checks.push({ name: 'Docker', ok: dockerRunning(), detail: dockerRunning() ? 'daemon reachable' : 'install Docker and start the daemon', required: true });
+        checks.push({ name: 'minikube', ok: has('minikube'), detail: has('minikube') ? 'on PATH' : 'install minikube', required: true });
+        checks.push({ name: 'kubectl', ok: has('kubectl'), detail: has('kubectl') ? 'on PATH' : 'install kubectl', required: true });
+        return checks;
+    }
+    // ec2 + fargate — both need the AWS CLI with working credentials.
+    const account = awsIdentity();
+    checks.push({ name: 'AWS CLI', ok: has('aws'), detail: has('aws') ? 'on PATH' : 'install the AWS CLI v2', required: true });
+    checks.push({
+        name: 'AWS credentials',
+        ok: account !== null,
+        detail: account ? `authenticated (account ${account})` : 'run `aws configure` / set AWS_PROFILE',
+        required: true,
+    });
+    return checks;
+}
+/** True when every REQUIRED prerequisite passed. */
+export function prereqsSatisfied(checks) {
+    return checks.every((c) => c.ok || !c.required);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prereqs.js","sourceRoot":"","sources":["../../src/agent/prereqs.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Deterministic, READ-ONLY prerequisite checks per target. No LLM, no mutation —\n * every command here only inspects (presence checks, `aws sts get-caller-identity`,\n * `docker info`). This is the kind of thing a script does better than an agent,\n * so it stays deterministic; the LLM is reserved for NL parsing + diagnosis.\n */\n\nimport { execSync } from 'child_process';\nimport type { TargetId } from './targets.js';\n\nexport interface PrereqCheck {\n  readonly name: string;\n  readonly ok: boolean;\n  readonly detail: string;\n  /** A failing required check blocks deployment; advisory ones are warnings. */\n  readonly required: boolean;\n}\n\n/** True if `cmd` is on PATH. */\nfunction has(cmd: string): boolean {\n  try {\n    execSync(`command -v ${cmd}`, { stdio: 'ignore', timeout: 5000 });\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/** Run a read-only command; return its trimmed stdout or null on failure. */\nfunction read(cmd: string): string | null {\n  try {\n    return execSync(cmd, { stdio: ['ignore', 'pipe', 'ignore'], timeout: 15000 }).toString().trim();\n  } catch {\n    return null;\n  }\n}\n\nfunction dockerRunning(): boolean {\n  return has('docker') && read('docker info --format \"{{.ServerVersion}}\"') !== null;\n}\n\nfunction awsIdentity(): string | null {\n  if (!has('aws')) return null;\n  return read('aws sts get-caller-identity --query Account --output text');\n}\n\n/** Parsed `git --version` as [major, minor], or null if git is absent/unparseable. */\nfunction gitVersion(): [number, number] | null {\n  const out = read('git --version');\n  const m = out?.match(/(\\d+)\\.(\\d+)/);\n  return m ? [Number(m[1]), Number(m[2])] : null;\n}\n\n/** True when git is on PATH (required to bootstrap a clone at all). */\nexport function gitAvailable(): boolean {\n  return gitVersion() !== null;\n}\n\n/**\n * Cone `sparse-checkout` (+ `--filter=blob:none`) needs git ≥ 2.27. Below that,\n * the bootstrap falls back to a (correct, just larger) full clone.\n */\nexport function gitSupportsSparseCheckout(): boolean {\n  const v = gitVersion();\n  return v !== null && (v[0] > 2 || (v[0] === 2 && v[1] >= 27));\n}\n\n/**\n * Run the read-only prerequisite checks for a target. Pure inspection — safe to\n * run unconditionally (Phase-1 advisor calls this before assembling the command).\n */\nexport function checkPrereqs(target: TargetId, opts: { bootstrap?: boolean } = {}): PrereqCheck[] {\n  const checks: PrereqCheck[] = [];\n\n  // `--repo` bootstrap git-clones the platform repo first → git is required. A\n  // git below 2.27 still works (full-clone fallback), so the version is advisory.\n  if (opts.bootstrap) {\n    const v = gitVersion();\n    checks.push({ name: 'git', ok: v !== null, detail: v ? `on PATH (${v[0]}.${v[1]})` : 'install git', required: true });\n    if (v !== null && !gitSupportsSparseCheckout()) {\n      checks.push({ name: 'git ≥ 2.27', ok: false, detail: 'sparse clone needs git ≥ 2.27 — falling back to a full clone', required: false });\n    }\n  }\n\n  if (target === 'local') {\n    checks.push({\n      name: 'Docker',\n      ok: dockerRunning(),\n      detail: dockerRunning() ? 'daemon reachable' : 'install Docker and start the daemon',\n      required: true,\n    });\n    return checks;\n  }\n\n  if (target === 'minikube') {\n    checks.push({ name: 'Docker', ok: dockerRunning(), detail: dockerRunning() ? 'daemon reachable' : 'install Docker and start the daemon', required: true });\n    checks.push({ name: 'minikube', ok: has('minikube'), detail: has('minikube') ? 'on PATH' : 'install minikube', required: true });\n    checks.push({ name: 'kubectl', ok: has('kubectl'), detail: has('kubectl') ? 'on PATH' : 'install kubectl', required: true });\n    return checks;\n  }\n\n  // ec2 + fargate — both need the AWS CLI with working credentials.\n  const account = awsIdentity();\n  checks.push({ name: 'AWS CLI', ok: has('aws'), detail: has('aws') ? 'on PATH' : 'install the AWS CLI v2', required: true });\n  checks.push({\n    name: 'AWS credentials',\n    ok: account !== null,\n    detail: account ? `authenticated (account ${account})` : 'run `aws configure` / set AWS_PROFILE',\n    required: true,\n  });\n  return checks;\n}\n\n/** True when every REQUIRED prerequisite passed. */\nexport function prereqsSatisfied(checks: readonly PrereqCheck[]): boolean {\n  return checks.every((c) => c.ok || !c.required);\n}\n"]}

package/dist/agent/targets.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Deterministic registry of platform deploy targets — the source of truth the
+ * `provision` advisor uses to assemble the EXACT deploy command. The agent is a
+ * thin wrapper over the existing deploy scripts; it never reimplements
+ * deployment, only validates inputs and assembles the command to run.
+ *
+ * Keep this in lock-step with the flags the scripts accept — every target's
+ * operator entrypoint is `bin/setup.sh` (deploy/<target>/bin/setup.sh).
+ */
+export type TargetId = 'local' | 'minikube' | 'ec2' | 'fargate';
+/** A single input the underlying deploy script accepts. */
+export interface InputSpec {
+    /** Flag name passed to the script (without the leading `--`). */
+    readonly flag: string;
+    /** Key on the provision params object. */
+    readonly key: string;
+    /** Human description — shown when a required input is missing. */
+    readonly description: string;
+    /** Secret — never printed in the assembled command (masked as `***`). */
+    readonly secret?: boolean;
+    /** Boolean flag with no value (e.g. `--email`). */
+    readonly boolean?: boolean;
+}
+export interface TargetSpec {
+    readonly id: TargetId;
+    readonly label: string;
+    /** Directory the entrypoint runs from (relative to repo root). */
+    readonly dir: string;
+    /** Entrypoint script (relative to `dir`). */
+    readonly entrypoint: string;
+    /** Inputs the script REQUIRES — the advisor reports any that are missing. */
+    readonly required: readonly InputSpec[];
+    /** Optional inputs, passed through only when provided. */
+    readonly optional: readonly InputSpec[];
+    /**
+     * Repo folder(s) this target's deploy needs, for a sparse `--repo` bootstrap.
+     * Combined with COMMON_SPARSE_PATHS and any selected load steps' paths.
+     */
+    readonly sparsePaths: readonly string[];
+    /** Post-deploy step to surface (registers admin + loads plugins). */
+    readonly postDeploy?: string;
+    /** Rough monthly cost (from docs). */
+    readonly cost: string;
+    /** One-line "best for". */
+    readonly bestFor: string;
+    /** What a teardown of this target destroys — shown before a (gated) teardown. */
+    readonly destroys: string;
+}
+export declare const TARGETS: Readonly<Record<TargetId, TargetSpec>>;
+export declare const TARGET_IDS: readonly TargetId[];
+export declare function isTargetId(value: unknown): value is TargetId;
+/**
+ * Folders every `--repo` bootstrap needs regardless of target: the orchestration
+ * scripts. Each target's setup.sh + init-platform.sh live in / drive these.
+ * Deliberately minimal — heavier folders (plugins/compliance/samples) are pulled
+ * in only when their post-install option is selected (see LOAD_STEPS).
+ */
+export declare const COMMON_SPARSE_PATHS: readonly string[];
+/**
+ * Opt-in post-install load steps. Each maps a provision `--with-*` flag to the
+ * init-platform env var that enables it AND the repo folder(s) it reads — so the
+ * sparse checkout grows exactly with the selected options.
+ */
+export declare const LOAD_STEPS: readonly [{
+    readonly id: "plugins";
+    readonly flag: "withPlugins";
+    readonly env: "LOAD_PLUGINS";
+    readonly paths: readonly ["deploy/plugins", "deploy/codebuild"];
+}, {
+    readonly id: "compliance";
+    readonly flag: "withCompliance";
+    readonly env: "LOAD_COMPLIANCE";
+    readonly paths: readonly ["deploy/compliance"];
+}, {
+    readonly id: "samples";
+    readonly flag: "withSamples";
+    readonly env: "LOAD_PIPELINES";
+    readonly paths: readonly ["deploy/samples"];
+}];
+export type LoadStepId = (typeof LOAD_STEPS)[number]['id'];
+/**
+ * The de-duplicated set of sparse paths for a target plus the enabled load
+ * steps: common base ∪ target folder(s) ∪ each enabled step's folder(s).
+ */
+export declare function sparsePathsFor(target: TargetId, enabledLoadIds: readonly string[]): string[];
+export interface AssembleResult {
+    /** The exact command to run — secrets masked as `***`. */
+    readonly command: string;
+    /** Required inputs that were not supplied. */
+    readonly missing: readonly InputSpec[];
+}
+/**
+ * Assemble the deploy command for a target from the provided params. Pure and
+ * deterministic — no shell, no LLM. Missing required inputs are reported (never
+ * guessed). By default secrets are masked (`***`) for DISPLAY; pass `mask: false`
+ * to build the real command for EXECUTION — that string must never be logged or
+ * shown to the model.
+ */
+export declare function assembleCommand(target: TargetSpec, params: Record<string, unknown>, opts?: {
+    mask?: boolean;
+}): AssembleResult;
+export interface TeardownResult {
+    /** The exact teardown command to run. */
+    readonly command: string;
+    /** Whether this teardown irreversibly destroys data (AWS targets). */
+    readonly destructive: boolean;
+}
+/**
+ * Assemble the teardown command for a target. Pure and deterministic — mirrors
+ * `assembleCommand` for the destroy path. local/minikube STOP the stack
+ * (non-destructive — on-disk / PVC data survives); ec2/fargate DELETE their
+ * CloudFormation stacks and are irreversible. For Fargate, `assumeYes` forwards
+ * the native script's own `--yes` (the agent runs its own typed confirmation
+ * first, so the script must not also block on stdin); EC2 `delete-stack` has no
+ * native prompt, which is exactly why the agent gate is mandatory there.
+ */
+export declare function teardownCommand(target: TargetId, opts?: {
+    stackName?: string;
+    region?: string;
+    assumeYes?: boolean;
+}): TeardownResult;
+//# sourceMappingURL=targets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"targets.d.ts","sourceRoot":"","sources":["../../src/agent/targets.ts"],"names":[],"mappings":"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"}