@pipeline-builder/pipeline-manager 4.5.2 → 4.5.4

package/dist/commands/register.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"register.d.ts","sources":["../../src/commands/register.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAcpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAwG/C"}
+{"version":3,"file":"register.d.ts","sources":["../../src/commands/register.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAcpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAuG/C"}

package/dist/commands/register.js

@@ -4,7 +4,7 @@ import { errorMessage } from '@pipeline-builder/api-core';
 import { Command } from 'commander';
 import {} from '../types/index.js';
 import { createAuthenticatedClient, printCommandHeader, printSslWarning, withRegionOption, withSslOptions } from '../utils/command-utils.js';
-import { ERROR_CODES, handleError } from '../utils/error-handler.js';
+import { ERROR_CODES, reportError } from '../utils/error-handler.js';
 import { printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';
 import { buildRegistryPayload, clearPendingIntent, readPendingIntents, writePendingIntent, } from '../utils/registry.js';
 import { extractSingleResponse } from '../utils/response-utils.js';
@@ -131,9 +131,8 @@ export function register(program) {
             process.exit(anyFailed ? 1 : 0);
         }
         catch (error) {
-            handleError(error, ERROR_CODES.API_REQUEST, {
+            reportError(error, ERROR_CODES.API_REQUEST, {
                 debug: program.opts().debug,
-                exit: false,
                 context: { command: 'register', executionId, pipelineId: options.id },
             });
             process.exit(1);
@@ -158,4 +157,4 @@ async function postRegistration(client, pipelineUrl, payload, pipelineId) {
         return false;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"register.js","sources":["../../src/commands/register.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { errorMessage } from '@pipeline-builder/api-core';\nimport { Command } from 'commander';\nimport { type Pipeline, type PipelineResponse } from '../types/index.js';\nimport { createAuthenticatedClient, printCommandHeader, printSslWarning, withRegionOption, withSslOptions } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';\nimport {\n  buildRegistryPayload,\n  clearPendingIntent,\n  readPendingIntents,\n  writePendingIntent,\n  type RegistryPayload,\n} from '../utils/registry.js';\nimport { extractSingleResponse } from '../utils/response-utils.js';\n\n/**\n * Registers the `register` command with the CLI program.\n *\n * Two purposes — both targeted at recovering from a deploy whose registration\n * step didn't land:\n *\n *   1. Explicit re-register (`--id <pipelineId>`) — recomputes the ARN from\n *      STS + region and POSTs it to the platform. Useful when the platform\n *      was unreachable during `deploy`, when the registry row was deleted by\n *      mistake, or for any other reason a deployed stack has no registry row.\n *\n *   2. Drain pending intents (every invocation) — `deploy` writes a local\n *      file under `~/.pipeline-manager/pending-registrations/` whenever its\n *      registration POST fails. Each `register` invocation tries to drain\n *      every such file. On success the file is deleted; on failure it stays\n *      and surfaces as a warning.\n *\n * Flags:\n *   - `--id <pipelineId>` — re-register a specific pipeline by ID\n *   - `--region <region>` — AWS region (default: AWS_REGION env / us-east-1)\n *   - `--no-drain` — skip draining pending intents\n *\n * Exit codes:\n *   - 0: requested registration succeeded AND no pending intents remain\n *   - 1: at least one registration (explicit or pending) still failed\n *\n * @example\n * ```bash\n * # Retry a registration that failed during deploy\n * pipeline-manager pipeline register --id pipe-123\n *\n * # Just drain pending intents from disk, no specific registration\n * pipeline-manager pipeline register\n * ```\n */\nexport function register(program: Command): void {\n  withSslOptions(withRegionOption(program\n    .command('register')\n    .description('Register a deployed pipeline ARN with the platform (retry path for failed registrations)')\n    .option('-i, --id <id>', 'Pipeline ID to register (re-derives ARN from STS)'))\n    .option('--no-drain', 'Skip draining pending intents from prior failed deploys'))\n    .action(async (options) => {\n      const executionId = printCommandHeader('Register Pipeline');\n      printSslWarning(options.verifySsl);\n\n      let anyFailed = false;\n      let registeredCount = 0;\n\n      try {\n        const client = createAuthenticatedClient(options);\n        const pipelineUrl = client.getConfig().api.pipelineUrl;\n\n        // ── Drain pending intents first ──\n        // We drain before the explicit registration so a queued failure for\n        // the same pipelineId is replaced (not double-applied) by the fresh\n        // payload below.\n        const drained = new Set<string>();\n        if (options.drain !== false) {\n          const intents = await readPendingIntents();\n          if (intents.length > 0) {\n            printSection('Draining pending intents');\n            printInfo('Found pending registrations from prior failed deploys', {\n              count: String(intents.length),\n            });\n            for (const intent of intents) {\n              // Skip the explicit pipeline — we'll re-build a fresh payload below.\n              if (options.id && intent.pipelineId === options.id) continue;\n              const ok = await postRegistration(client, pipelineUrl, intent, intent.pipelineId);\n              if (ok) {\n                await clearPendingIntent(intent.pipelineId);\n                drained.add(intent.pipelineId);\n                registeredCount++;\n              } else {\n                anyFailed = true;\n              }\n            }\n          }\n        }\n\n        // ── Explicit registration ──\n        if (options.id) {\n          printSection('Re-registering pipeline');\n          const pipelineRes = await client.get<PipelineResponse>(`${pipelineUrl}/${options.id}`);\n          const pipeline = extractSingleResponse<Pipeline>(pipelineRes, 'pipeline', 'id');\n          if (!pipeline) {\n            printError('Pipeline not found in platform');\n            throw new Error(`No pipeline returned for id ${options.id}`);\n          }\n\n          if (!pipeline.orgId) {\n            printError('Pipeline has no orgId — cannot register');\n            throw new Error(`Pipeline ${pipeline.id} is missing orgId`);\n          }\n          const payload = await buildRegistryPayload(\n            {\n              id: pipeline.id,\n              orgId: pipeline.orgId,\n              pipelineName: pipeline.pipelineName,\n              project: pipeline.project,\n              organization: pipeline.organization,\n            },\n            options.region,\n          );\n\n          // Clear any stale intent for this pipelineId before retrying so we\n          // don't leave a duplicate file behind on success.\n          await clearPendingIntent(payload.pipelineId);\n\n          const ok = await postRegistration(client, pipelineUrl, payload, payload.pipelineId);\n          if (ok) {\n            registeredCount++;\n            printSuccess('Pipeline registered for event reporting', {\n              pipelineId: payload.pipelineId,\n            });\n          } else {\n            anyFailed = true;\n            const path = await writePendingIntent(payload);\n            printWarning('Registration failed; intent saved for retry', { intent: path });\n          }\n        }\n\n        printSection('Summary');\n        printKeyValue({\n          'Registered': String(registeredCount),\n          'Drained from queue': String(drained.size),\n          'Status': anyFailed ? 'Some registrations still pending' : 'All clear',\n          'Execution ID': executionId,\n        });\n\n        process.exit(anyFailed ? 1 : 0);\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: false,\n          context: { command: 'register', executionId, pipelineId: options.id },\n        });\n        process.exit(1);\n      }\n    });\n}\n\n/**\n * POST a registration payload to the platform. On failure, the caller decides\n * whether to write/preserve a pending intent — this helper just reports.\n */\nasync function postRegistration(\n  client: ReturnType<typeof createAuthenticatedClient>,\n  pipelineUrl: string,\n  payload: RegistryPayload,\n  pipelineId: string,\n): Promise<boolean> {\n  try {\n    await client.post(`${pipelineUrl}/registry`, payload);\n    printInfo('Registered', { pipelineId });\n    return true;\n  } catch (err) {\n    printWarning('Registration failed', {\n      pipelineId,\n      error: errorMessage(err),\n    });\n    return false;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"register.js","sources":["../../src/commands/register.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { errorMessage } from '@pipeline-builder/api-core';\nimport { Command } from 'commander';\nimport { type Pipeline, type PipelineResponse } from '../types/index.js';\nimport { createAuthenticatedClient, printCommandHeader, printSslWarning, withRegionOption, withSslOptions } from '../utils/command-utils.js';\nimport { ERROR_CODES, reportError } from '../utils/error-handler.js';\nimport { printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';\nimport {\n  buildRegistryPayload,\n  clearPendingIntent,\n  readPendingIntents,\n  writePendingIntent,\n  type RegistryPayload,\n} from '../utils/registry.js';\nimport { extractSingleResponse } from '../utils/response-utils.js';\n\n/**\n * Registers the `register` command with the CLI program.\n *\n * Two purposes — both targeted at recovering from a deploy whose registration\n * step didn't land:\n *\n *   1. Explicit re-register (`--id <pipelineId>`) — recomputes the ARN from\n *      STS + region and POSTs it to the platform. Useful when the platform\n *      was unreachable during `deploy`, when the registry row was deleted by\n *      mistake, or for any other reason a deployed stack has no registry row.\n *\n *   2. Drain pending intents (every invocation) — `deploy` writes a local\n *      file under `~/.pipeline-manager/pending-registrations/` whenever its\n *      registration POST fails. Each `register` invocation tries to drain\n *      every such file. On success the file is deleted; on failure it stays\n *      and surfaces as a warning.\n *\n * Flags:\n *   - `--id <pipelineId>` — re-register a specific pipeline by ID\n *   - `--region <region>` — AWS region (default: AWS_REGION env / us-east-1)\n *   - `--no-drain` — skip draining pending intents\n *\n * Exit codes:\n *   - 0: requested registration succeeded AND no pending intents remain\n *   - 1: at least one registration (explicit or pending) still failed\n *\n * @example\n * ```bash\n * # Retry a registration that failed during deploy\n * pipeline-manager pipeline register --id pipe-123\n *\n * # Just drain pending intents from disk, no specific registration\n * pipeline-manager pipeline register\n * ```\n */\nexport function register(program: Command): void {\n  withSslOptions(withRegionOption(program\n    .command('register')\n    .description('Register a deployed pipeline ARN with the platform (retry path for failed registrations)')\n    .option('-i, --id <id>', 'Pipeline ID to register (re-derives ARN from STS)'))\n    .option('--no-drain', 'Skip draining pending intents from prior failed deploys'))\n    .action(async (options) => {\n      const executionId = printCommandHeader('Register Pipeline');\n      printSslWarning(options.verifySsl);\n\n      let anyFailed = false;\n      let registeredCount = 0;\n\n      try {\n        const client = createAuthenticatedClient(options);\n        const pipelineUrl = client.getConfig().api.pipelineUrl;\n\n        // ── Drain pending intents first ──\n        // We drain before the explicit registration so a queued failure for\n        // the same pipelineId is replaced (not double-applied) by the fresh\n        // payload below.\n        const drained = new Set<string>();\n        if (options.drain !== false) {\n          const intents = await readPendingIntents();\n          if (intents.length > 0) {\n            printSection('Draining pending intents');\n            printInfo('Found pending registrations from prior failed deploys', {\n              count: String(intents.length),\n            });\n            for (const intent of intents) {\n              // Skip the explicit pipeline — we'll re-build a fresh payload below.\n              if (options.id && intent.pipelineId === options.id) continue;\n              const ok = await postRegistration(client, pipelineUrl, intent, intent.pipelineId);\n              if (ok) {\n                await clearPendingIntent(intent.pipelineId);\n                drained.add(intent.pipelineId);\n                registeredCount++;\n              } else {\n                anyFailed = true;\n              }\n            }\n          }\n        }\n\n        // ── Explicit registration ──\n        if (options.id) {\n          printSection('Re-registering pipeline');\n          const pipelineRes = await client.get<PipelineResponse>(`${pipelineUrl}/${options.id}`);\n          const pipeline = extractSingleResponse<Pipeline>(pipelineRes, 'pipeline', 'id');\n          if (!pipeline) {\n            printError('Pipeline not found in platform');\n            throw new Error(`No pipeline returned for id ${options.id}`);\n          }\n\n          if (!pipeline.orgId) {\n            printError('Pipeline has no orgId — cannot register');\n            throw new Error(`Pipeline ${pipeline.id} is missing orgId`);\n          }\n          const payload = await buildRegistryPayload(\n            {\n              id: pipeline.id,\n              orgId: pipeline.orgId,\n              pipelineName: pipeline.pipelineName,\n              project: pipeline.project,\n              organization: pipeline.organization,\n            },\n            options.region,\n          );\n\n          // Clear any stale intent for this pipelineId before retrying so we\n          // don't leave a duplicate file behind on success.\n          await clearPendingIntent(payload.pipelineId);\n\n          const ok = await postRegistration(client, pipelineUrl, payload, payload.pipelineId);\n          if (ok) {\n            registeredCount++;\n            printSuccess('Pipeline registered for event reporting', {\n              pipelineId: payload.pipelineId,\n            });\n          } else {\n            anyFailed = true;\n            const path = await writePendingIntent(payload);\n            printWarning('Registration failed; intent saved for retry', { intent: path });\n          }\n        }\n\n        printSection('Summary');\n        printKeyValue({\n          'Registered': String(registeredCount),\n          'Drained from queue': String(drained.size),\n          'Status': anyFailed ? 'Some registrations still pending' : 'All clear',\n          'Execution ID': executionId,\n        });\n\n        process.exit(anyFailed ? 1 : 0);\n      } catch (error) {\n        reportError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          context: { command: 'register', executionId, pipelineId: options.id },\n        });\n        process.exit(1);\n      }\n    });\n}\n\n/**\n * POST a registration payload to the platform. On failure, the caller decides\n * whether to write/preserve a pending intent — this helper just reports.\n */\nasync function postRegistration(\n  client: ReturnType<typeof createAuthenticatedClient>,\n  pipelineUrl: string,\n  payload: RegistryPayload,\n  pipelineId: string,\n): Promise<boolean> {\n  try {\n    await client.post(`${pipelineUrl}/registry`, payload);\n    printInfo('Registered', { pipelineId });\n    return true;\n  } catch (err) {\n    printWarning('Registration failed', {\n      pipelineId,\n      error: errorMessage(err),\n    });\n    return false;\n  }\n}\n"]}

package/dist/commands/status.d.ts

@@ -2,8 +2,11 @@ import { Command } from 'commander';
 /**
  * Registers the `status` command with the CLI program.
  *
- * Checks environment variables, CDK availability, platform connectivity,
- * and token expiry to give a quick overview of the current setup.
+ * Reports the CLI's setup, not a deployment: which platform it talks to (the
+ * same base-URL layers every command resolves), which credential it would use
+ * and when that expires, CDK availability, whether the platform answers
+ * `/health`, and — with a usable credential — whether the platform ACCEPTS it,
+ * and as whom (`GET /api/user/profile`).
  *
  * @param program - The root Commander program instance to attach the command to.
  */

package/dist/commands/status.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"status.d.ts","sources":["../../src/commands/status.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAqE7C"}
+{"version":3,"file":"status.d.ts","sources":["../../src/commands/status.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAyBpC;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAoF7C"}

package/dist/commands/status.js

@@ -7,53 +7,71 @@ import { ENV_VARS, TIMEOUTS } from '../config/cli.constants.js';
 import { decodeTokenPayload } from '../utils/auth-guard.js';
 import { checkCdkAvailable } from '../utils/cdk-utils.js';
 import { printCommandHeader } from '../utils/command-utils.js';
+import { getApiConfig } from '../utils/config-loader.js';
+import { isSessionUsable, loadSession } from '../utils/credential-store.js';
 import { ERROR_CODES, handleError } from '../utils/error-handler.js';
 import { printKeyValue, printSection } from '../utils/output-utils.js';
+import { requestCorrelationHeaders } from '../utils/request-context.js';
 import { httpsAgentForUrl } from '../utils/tls.js';
+/** Which credential later commands would use, in `resolveToken`'s order. */
+function credentialSource(baseUrl) {
+    const envToken = process.env[ENV_VARS.PLATFORM_TOKEN];
+    if (envToken)
+        return { label: 'PLATFORM_TOKEN (environment)', token: envToken };
+    const stored = loadSession(baseUrl);
+    if (!stored)
+        return { label: 'none — run "pipeline-manager auth login"' };
+    const { accessToken, refreshToken, expiresAt } = stored;
+    if (isSessionUsable(stored))
+        return { label: 'stored session ("auth login")', token: accessToken, expiresAt };
+    return refreshToken
+        ? { label: 'stored session ("auth login", expired — renewed on the next command)', expiresAt }
+        : { label: 'stored session ("auth login", expired — run "auth login" again)', expiresAt };
+}
 /**
  * Registers the `status` command with the CLI program.
  *
- * Checks environment variables, CDK availability, platform connectivity,
- * and token expiry to give a quick overview of the current setup.
+ * Reports the CLI's setup, not a deployment: which platform it talks to (the
+ * same base-URL layers every command resolves), which credential it would use
+ * and when that expires, CDK availability, whether the platform answers
+ * `/health`, and — with a usable credential — whether the platform ACCEPTS it,
+ * and as whom (`GET /api/user/profile`).
  *
  * @param program - The root Commander program instance to attach the command to.
  */
 export function status(program) {
     program
         .command('status')
-        .description('Show environment and connectivity status')
+        .description('Show the CLI setup: platform, credential, sign-in check, CDK and platform reachability')
         .option('--json', 'Output result as JSON', false)
         .action(async (options) => {
         const executionId = printCommandHeader('Status', undefined, { quiet: options.json });
         try {
             const results = {};
-            // 1. Check PLATFORM_TOKEN
-            const token = process.env[ENV_VARS.PLATFORM_TOKEN];
-            results.PLATFORM_TOKEN = token ? 'set' : 'not set';
-            // 2. Check PLATFORM_SECRET_NAME
-            const secretName = process.env.PLATFORM_SECRET_NAME;
-            results.PLATFORM_SECRET_NAME = secretName || 'not set';
-            // 3. Check CDK availability
+            const baseUrl = getApiConfig().api.baseUrl;
+            results.Platform = baseUrl;
+            const credential = credentialSource(baseUrl);
+            results.Credential = credential.label;
+            results.PLATFORM_SECRET_NAME = process.env.PLATFORM_SECRET_NAME || 'not set';
             results['CDK Available'] = checkCdkAvailable() ? 'yes' : 'no';
-            // 4. Check platform health
-            const baseUrl = process.env[ENV_VARS.PLATFORM_BASE_URL] || 'https://localhost:8443';
-            results.PLATFORM_BASE_URL = baseUrl;
+            // Skip cert verification only for local/self-signed hosts; verify real domains.
+            const httpsAgent = httpsAgentForUrl(baseUrl);
             try {
-                // Skip cert verification only for local/self-signed hosts; verify real domains.
-                await axios.get(`${baseUrl}/health`, {
-                    timeout: TIMEOUTS.HEALTH_CHECK,
-                    httpsAgent: httpsAgentForUrl(baseUrl),
-                });
+                await axios.get(`${baseUrl}/health`, { timeout: TIMEOUTS.HEALTH_CHECK, httpsAgent });
                 results['Platform Health'] = 'reachable';
             }
             catch {
                 results['Platform Health'] = 'unreachable';
             }
-            // 5. Decode token expiry (shared decoder — same base64url + exp logic
-            // used by audit-tokens / api-client). An ACCESS KEY carries no claims at
-            // all, so there is nothing local to read: its expiry lives on its record
-            // and is shown on the keys page.
-            if (token) {
+            // Expiry: a stored session records it; a JWT carries it; an ACCESS KEY
+            // carries no claims at all — its expiry lives on its record and is shown
+            // on the keys page.
+            const token = credential.token;
+            if (credential.expiresAt !== undefined) {
+                results['Token Expires'] = new Date(credential.expiresAt).toISOString();
+                results['Token Expired'] = credential.expiresAt < Date.now() ? 'yes' : 'no';
+            }
+            else if (token) {
                 const payload = decodeTokenPayload(token);
                 if (isOpaqueApiKey(token)) {
                     results['Token Expires'] = 'n/a (access key — see Dashboard → API Tokens)';
@@ -67,11 +85,33 @@ export function status(program) {
                     results['Token Expired'] = expiresAt.getTime() < Date.now() ? 'yes' : 'no';
                 }
             }
+            // The check that matters: does the platform accept the credential?
+            if (token) {
+                try {
+                    const res = await axios.get(`${baseUrl}/api/user/profile`, { timeout: TIMEOUTS.HEALTH_CHECK, httpsAgent, headers: { Authorization: `Bearer ${token}`, ...requestCorrelationHeaders() } });
+                    const user = res.data?.data?.user;
+                    results['Signed In'] = 'yes';
+                    if (user?.email)
+                        results['Signed In As'] = user.email;
+                    const org = user?.activeOrgName ?? user?.organizationId;
+                    if (org)
+                        results.Organization = org;
+                }
+                catch (error) {
+                    const code = axios.isAxiosError(error) ? error.response?.status : undefined;
+                    results['Signed In'] = code === 401 || code === 403
+                        ? `no — the platform rejected the credential (${code})`
+                        : 'unknown — the platform could not be reached';
+                }
+            }
+            else {
+                results['Signed In'] = credential.expiresAt !== undefined ? 'session expired' : 'no';
+            }
             if (options.json) {
                 console.log(JSON.stringify({ success: true, executionId, ...results }, null, 2));
             }
             else {
-                printSection('Environment Status');
+                printSection('CLI Status');
                 printKeyValue(results);
             }
         }
@@ -84,4 +124,4 @@ export function status(program) {
         }
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"status.js","sources":["../../src/commands/status.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { isOpaqueApiKey } from '@pipeline-builder/api-core';\nimport axios from 'axios';\nimport { Command } from 'commander';\nimport { ENV_VARS, TIMEOUTS } from '../config/cli.constants.js';\nimport { decodeTokenPayload } from '../utils/auth-guard.js';\nimport { checkCdkAvailable } from '../utils/cdk-utils.js';\nimport { printCommandHeader } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printKeyValue, printSection } from '../utils/output-utils.js';\nimport { httpsAgentForUrl } from '../utils/tls.js';\n\n/**\n * Registers the `status` command with the CLI program.\n *\n * Checks environment variables, CDK availability, platform connectivity,\n * and token expiry to give a quick overview of the current setup.\n *\n * @param program - The root Commander program instance to attach the command to.\n */\nexport function status(program: Command): void {\n  program\n    .command('status')\n    .description('Show environment and connectivity status')\n    .option('--json', 'Output result as JSON', false)\n    .action(async (options) => {\n      const executionId = printCommandHeader('Status', undefined, { quiet: options.json });\n\n      try {\n        const results: Record<string, string> = {};\n\n        // 1. Check PLATFORM_TOKEN\n        const token = process.env[ENV_VARS.PLATFORM_TOKEN];\n        results.PLATFORM_TOKEN = token ? 'set' : 'not set';\n\n        // 2. Check PLATFORM_SECRET_NAME\n        const secretName = process.env.PLATFORM_SECRET_NAME;\n        results.PLATFORM_SECRET_NAME = secretName || 'not set';\n\n        // 3. Check CDK availability\n        results['CDK Available'] = checkCdkAvailable() ? 'yes' : 'no';\n\n        // 4. Check platform health\n        const baseUrl = process.env[ENV_VARS.PLATFORM_BASE_URL] || 'https://localhost:8443';\n        results.PLATFORM_BASE_URL = baseUrl;\n\n        try {\n          // Skip cert verification only for local/self-signed hosts; verify real domains.\n          await axios.get(`${baseUrl}/health`, {\n            timeout: TIMEOUTS.HEALTH_CHECK,\n            httpsAgent: httpsAgentForUrl(baseUrl),\n          });\n          results['Platform Health'] = 'reachable';\n        } catch {\n          results['Platform Health'] = 'unreachable';\n        }\n\n        // 5. Decode token expiry (shared decoder — same base64url + exp logic\n        // used by audit-tokens / api-client). An ACCESS KEY carries no claims at\n        // all, so there is nothing local to read: its expiry lives on its record\n        // and is shown on the keys page.\n        if (token) {\n          const payload = decodeTokenPayload(token);\n          if (isOpaqueApiKey(token)) {\n            results['Token Expires'] = 'n/a (access key — see Dashboard → API Tokens)';\n          } else if (!payload) {\n            results['Token Expires'] = 'unable to decode';\n          } else if (typeof payload.exp === 'number') {\n            const expiresAt = new Date(payload.exp * 1000);\n            results['Token Expires'] = expiresAt.toISOString();\n            results['Token Expired'] = expiresAt.getTime() < Date.now() ? 'yes' : 'no';\n          }\n        }\n\n        if (options.json) {\n          console.log(JSON.stringify({ success: true, executionId, ...results }, null, 2));\n        } else {\n          printSection('Environment Status');\n          printKeyValue(results);\n        }\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.GENERAL, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'status', executionId },\n        });\n      }\n    });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"status.js","sources":["../../src/commands/status.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { isOpaqueApiKey } from '@pipeline-builder/api-core';\nimport axios from 'axios';\nimport { Command } from 'commander';\nimport { ENV_VARS, TIMEOUTS } from '../config/cli.constants.js';\nimport { decodeTokenPayload } from '../utils/auth-guard.js';\nimport { checkCdkAvailable } from '../utils/cdk-utils.js';\nimport { printCommandHeader } from '../utils/command-utils.js';\nimport { getApiConfig } from '../utils/config-loader.js';\nimport { isSessionUsable, loadSession } from '../utils/credential-store.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printKeyValue, printSection } from '../utils/output-utils.js';\nimport { requestCorrelationHeaders } from '../utils/request-context.js';\nimport { httpsAgentForUrl } from '../utils/tls.js';\n\n/** Which credential later commands would use, in `resolveToken`'s order. */\nfunction credentialSource(baseUrl: string): { label: string; token?: string; expiresAt?: number } {\n  const envToken = process.env[ENV_VARS.PLATFORM_TOKEN];\n  if (envToken) return { label: 'PLATFORM_TOKEN (environment)', token: envToken };\n  const stored = loadSession(baseUrl);\n  if (!stored) return { label: 'none — run \"pipeline-manager auth login\"' };\n  const { accessToken, refreshToken, expiresAt } = stored;\n  if (isSessionUsable(stored)) return { label: 'stored session (\"auth login\")', token: accessToken, expiresAt };\n  return refreshToken\n    ? { label: 'stored session (\"auth login\", expired — renewed on the next command)', expiresAt }\n    : { label: 'stored session (\"auth login\", expired — run \"auth login\" again)', expiresAt };\n}\n\n/**\n * Registers the `status` command with the CLI program.\n *\n * Reports the CLI's setup, not a deployment: which platform it talks to (the\n * same base-URL layers every command resolves), which credential it would use\n * and when that expires, CDK availability, whether the platform answers\n * `/health`, and — with a usable credential — whether the platform ACCEPTS it,\n * and as whom (`GET /api/user/profile`).\n *\n * @param program - The root Commander program instance to attach the command to.\n */\nexport function status(program: Command): void {\n  program\n    .command('status')\n    .description('Show the CLI setup: platform, credential, sign-in check, CDK and platform reachability')\n    .option('--json', 'Output result as JSON', false)\n    .action(async (options) => {\n      const executionId = printCommandHeader('Status', undefined, { quiet: options.json });\n\n      try {\n        const results: Record<string, string> = {};\n        const baseUrl = getApiConfig().api.baseUrl;\n        results.Platform = baseUrl;\n\n        const credential = credentialSource(baseUrl);\n        results.Credential = credential.label;\n        results.PLATFORM_SECRET_NAME = process.env.PLATFORM_SECRET_NAME || 'not set';\n        results['CDK Available'] = checkCdkAvailable() ? 'yes' : 'no';\n\n        // Skip cert verification only for local/self-signed hosts; verify real domains.\n        const httpsAgent = httpsAgentForUrl(baseUrl);\n        try {\n          await axios.get(`${baseUrl}/health`, { timeout: TIMEOUTS.HEALTH_CHECK, httpsAgent });\n          results['Platform Health'] = 'reachable';\n        } catch {\n          results['Platform Health'] = 'unreachable';\n        }\n\n        // Expiry: a stored session records it; a JWT carries it; an ACCESS KEY\n        // carries no claims at all — its expiry lives on its record and is shown\n        // on the keys page.\n        const token = credential.token;\n        if (credential.expiresAt !== undefined) {\n          results['Token Expires'] = new Date(credential.expiresAt).toISOString();\n          results['Token Expired'] = credential.expiresAt < Date.now() ? 'yes' : 'no';\n        } else if (token) {\n          const payload = decodeTokenPayload(token);\n          if (isOpaqueApiKey(token)) {\n            results['Token Expires'] = 'n/a (access key — see Dashboard → API Tokens)';\n          } else if (!payload) {\n            results['Token Expires'] = 'unable to decode';\n          } else if (typeof payload.exp === 'number') {\n            const expiresAt = new Date(payload.exp * 1000);\n            results['Token Expires'] = expiresAt.toISOString();\n            results['Token Expired'] = expiresAt.getTime() < Date.now() ? 'yes' : 'no';\n          }\n        }\n\n        // The check that matters: does the platform accept the credential?\n        if (token) {\n          try {\n            const res = await axios.get<{ data?: { user?: { email?: string; activeOrgName?: string | null; organizationId?: string } } }>(\n              `${baseUrl}/api/user/profile`,\n              { timeout: TIMEOUTS.HEALTH_CHECK, httpsAgent, headers: { Authorization: `Bearer ${token}`, ...requestCorrelationHeaders() } },\n            );\n            const user = res.data?.data?.user;\n            results['Signed In'] = 'yes';\n            if (user?.email) results['Signed In As'] = user.email;\n            const org = user?.activeOrgName ?? user?.organizationId;\n            if (org) results.Organization = org;\n          } catch (error) {\n            const code = axios.isAxiosError(error) ? error.response?.status : undefined;\n            results['Signed In'] = code === 401 || code === 403\n              ? `no — the platform rejected the credential (${code})`\n              : 'unknown — the platform could not be reached';\n          }\n        } else {\n          results['Signed In'] = credential.expiresAt !== undefined ? 'session expired' : 'no';\n        }\n\n        if (options.json) {\n          console.log(JSON.stringify({ success: true, executionId, ...results }, null, 2));\n        } else {\n          printSection('CLI Status');\n          printKeyValue(results);\n        }\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.GENERAL, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'status', executionId },\n        });\n      }\n    });\n}\n"]}

package/dist/commands/toolchain.d.ts

@@ -0,0 +1,21 @@
+import { Command } from 'commander';
+/**
+ * `pipeline-manager toolchain …` — the pipeline toolchain release
+ * (pipeline-bootstrap + cdk-synth, one version).
+ *
+ * `toolchain export [--release <V>] [--output <file>]` resolves both halves the
+ * way a synth does — `--release` as the pin, else whatever your org resolves
+ * to now (its default, a canary, or the platform default) — and writes the
+ * JSON `pipeline deploy --local-spec --toolchain-file` deploys from: both
+ * images' repositories and signed digests, the release version and its tool
+ * versions. Read-only; nothing on the platform changes.
+ *
+ * @example
+ * ```bash
+ * pipeline-manager toolchain export --output toolchain.json
+ * pipeline-manager toolchain export --release 1.4.0 --output toolchain-1.4.0.json
+ * pipeline-manager pipeline deploy --local-spec pipeline.json --toolchain-file toolchain.json
+ * ```
+ */
+export declare function toolchain(program: Command): void;
+//# sourceMappingURL=toolchain.d.ts.map

package/dist/commands/toolchain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolchain.d.ts","sources":["../../src/commands/toolchain.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAwChD"}

package/dist/commands/toolchain.js

@@ -0,0 +1,70 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { MANAGED_TOOLCHAIN } from '@pipeline-builder/api-core';
+import { Command } from 'commander';
+import { createAuthenticatedClientAsync, printCommandHeader, printSslWarning, withSslOptions } from '../utils/command-utils.js';
+import { ERROR_CODES, handleError } from '../utils/error-handler.js';
+import { printInfo, printKeyValue, printSuccess } from '../utils/output-utils.js';
+import { exportToolchain } from '../utils/toolchain.js';
+/**
+ * `pipeline-manager toolchain …` — the pipeline toolchain release
+ * (pipeline-bootstrap + cdk-synth, one version).
+ *
+ * `toolchain export [--release <V>] [--output <file>]` resolves both halves the
+ * way a synth does — `--release` as the pin, else whatever your org resolves
+ * to now (its default, a canary, or the platform default) — and writes the
+ * JSON `pipeline deploy --local-spec --toolchain-file` deploys from: both
+ * images' repositories and signed digests, the release version and its tool
+ * versions. Read-only; nothing on the platform changes.
+ *
+ * @example
+ * ```bash
+ * pipeline-manager toolchain export --output toolchain.json
+ * pipeline-manager toolchain export --release 1.4.0 --output toolchain-1.4.0.json
+ * pipeline-manager pipeline deploy --local-spec pipeline.json --toolchain-file toolchain.json
+ * ```
+ */
+export function toolchain(program) {
+    const group = program.command('toolchain').description('Inspect and export the pipeline toolchain release (pipeline-bootstrap + cdk-synth)');
+    withSslOptions(group
+        .command('export')
+        .description('Write the resolved toolchain release (both images\' digests, repositories and tool versions) as JSON, for `pipeline deploy --local-spec --toolchain-file`')
+        .option('--release <version>', 'Export this release (default: the release your organization resolves to now)')
+        .option('-o, --output <file>', 'Output file (default: stdout)'))
+        .action(async (options) => {
+        // With no --output the JSON goes to stdout, so the header goes nowhere near it.
+        const toStdout = !options.output;
+        const executionId = printCommandHeader('Toolchain Export', undefined, { quiet: toStdout });
+        try {
+            printSslWarning(options.verifySsl);
+            const client = await createAuthenticatedClientAsync(options);
+            const file = await exportToolchain(client, options.release);
+            const json = `${JSON.stringify(file, null, 2)}\n`;
+            if (toStdout) {
+                process.stdout.write(json);
+                return;
+            }
+            const out = path.resolve(options.output);
+            fs.writeFileSync(out, json, { mode: 0o644 });
+            printSuccess('Toolchain release exported');
+            printKeyValue({
+                'Release': file.releaseVersion,
+                'Resolved via': file.resolvedVia,
+                [MANAGED_TOOLCHAIN.bootstrap]: `${file.bootstrap.imageRepository}@${file.bootstrap.imageDigest}`,
+                [MANAGED_TOOLCHAIN.synth]: `${file.synth.imageRepository}@${file.synth.imageDigest}`,
+                'File': out,
+            });
+            printInfo('Deploy with', { command: `pipeline-manager pipeline deploy --local-spec <pipeline.json> --toolchain-file ${options.output}` });
+        }
+        catch (error) {
+            handleError(error, ERROR_CODES.API_REQUEST, {
+                debug: program.opts().debug,
+                exit: true,
+                context: { command: 'toolchain export', executionId, release: options.release },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commands/validate-templates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-templates.d.ts","sources":["../../src/commands/validate-templates.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAkF/D"}
+{"version":3,"file":"validate-templates.d.ts","sources":["../../src/commands/validate-templates.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAcpC;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAgF/D"}

package/dist/commands/validate-templates.js

@@ -8,6 +8,7 @@ import YAML from 'yaml';
 import { printCommandHeader, printSslWarning, createAuthenticatedClientAsync, withSslOptions } from '../utils/command-utils.js';
 import { ERROR_CODES, handleError } from '../utils/error-handler.js';
 import { printError, printInfo, printSuccess, printWarning } from '../utils/output-utils.js';
+import { extractSingleResponse } from '../utils/response-utils.js';
 /**
  * Register the `validate-templates` command.
  *
@@ -49,8 +50,7 @@ export function validateTemplatesCommand(program) {
                 const client = await createAuthenticatedClientAsync(options);
                 const cfg = client.getConfig();
                 const res = await client.get(`${cfg.api.pipelineUrl}/${options.pipeline}`);
-                const doc = res.pipeline?.props
-                    ?? res.data?.pipeline?.props;
+                const doc = extractSingleResponse(res, 'pipeline', 'props')?.props;
                 if (!doc)
                     throw new Error(`Pipeline ${options.pipeline} not found`);
                 const errors = validatePipelineDoc(core, doc);
@@ -65,8 +65,7 @@ export function validateTemplatesCommand(program) {
                 const client = await createAuthenticatedClientAsync(options);
                 const cfg = client.getConfig();
                 const res = await client.get(`${cfg.api.pluginUrl}/find?name=${encodeURIComponent(name)}&version=${encodeURIComponent(version)}`);
-                const doc = res.plugin
-                    ?? res.data?.plugin;
+                const doc = extractSingleResponse(res, 'plugin', 'name');
                 if (!doc)
                     throw new Error(`Plugin ${name}:${version} not found`);
                 const errors = validatePluginDoc(core, doc);
@@ -112,4 +111,4 @@ function validatePipelineDoc(core, doc) {
     const cycles = core.detectCycles(doc, isTpl, (f) => isTpl(f) ? f : null);
     return [...errors, ...cycles];
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validate-templates.js","sources":["../../src/commands/validate-templates.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport fs from 'fs';\nimport path from 'path';\nimport { checkPluginTemplates, type PluginTemplateEngine } from '@pipeline-builder/api-core';\nimport { Command } from 'commander';\nimport YAML from 'yaml';\nimport { printCommandHeader, printSslWarning, createAuthenticatedClientAsync, withSslOptions } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printError, printInfo, printSuccess, printWarning } from '../utils/output-utils.js';\n\ninterface ValidateOptions {\n  pipeline?: string;\n  plugin?: string;\n  file?: string;\n  verifySsl?: boolean;\n}\n\n/**\n * Register the `validate-templates` command.\n *\n * Usage:\n *   pipeline-manager template validate --pipeline <uuid>\n *   pipeline-manager template validate --plugin <name:version>\n *   pipeline-manager template validate --file ./plugin-spec.yaml\n */\nexport function validateTemplatesCommand(program: Command): void {\n  withSslOptions(program\n    .command('validate')\n    .description('Parse and validate {{ ... }} templates in a pipeline or plugin spec')\n    .option('--pipeline <id>', 'Validate the pipeline with this ID')\n    .option('--plugin <name:version>', 'Validate the plugin with this name and version')\n    .option('--file <path>', 'Validate a local plugin-spec.yaml or pipeline.json file'))\n    .action(async (options: ValidateOptions) => {\n      const executionId = printCommandHeader('Validate Templates');\n      try {\n        printSslWarning(options.verifySsl);\n\n        if (!options.pipeline && !options.plugin && !options.file) {\n          throw new Error('One of --pipeline, --plugin, or --file is required');\n        }\n\n        const core = await import('@pipeline-builder/pipeline-core');\n\n        const problems: Array<{ source: string; errors: { field?: string; message: string; code?: string }[] }> = [];\n\n        if (options.file) {\n          const filePath = path.resolve(options.file);\n          const text = fs.readFileSync(filePath, 'utf-8');\n          const doc = filePath.endsWith('.json') ? JSON.parse(text) : YAML.parse(text);\n\n          // Guess: if `pluginType` is present, treat as plugin spec; else pipeline\n          const isPlugin = typeof (doc as { pluginType?: unknown }).pluginType === 'string';\n          const errors = isPlugin\n            ? validatePluginDoc(core, doc)\n            : validatePipelineDoc(core, doc);\n          if (errors.length) problems.push({ source: filePath, errors });\n        }\n\n        if (options.pipeline) {\n          printInfo('Fetching pipeline', { id: options.pipeline });\n          const client = await createAuthenticatedClientAsync(options);\n          const cfg = client.getConfig();\n          const res = await client.get<{ pipeline?: { props: unknown } }>(`${cfg.api.pipelineUrl}/${options.pipeline}`);\n          const doc = (res as { pipeline?: { props: unknown } }).pipeline?.props\n            ?? (res as { data?: { pipeline?: { props: unknown } } }).data?.pipeline?.props;\n          if (!doc) throw new Error(`Pipeline ${options.pipeline} not found`);\n          const errors = validatePipelineDoc(core, doc);\n          if (errors.length) problems.push({ source: `pipeline/${options.pipeline}`, errors });\n        }\n\n        if (options.plugin) {\n          const [name, version] = options.plugin.split(':');\n          if (!name || !version) throw new Error('--plugin requires <name:version> format');\n          printInfo('Fetching plugin', { name, version });\n          const client = await createAuthenticatedClientAsync(options);\n          const cfg = client.getConfig();\n          const res = await client.get<{ plugin: unknown }>(\n            `${cfg.api.pluginUrl}/find?name=${encodeURIComponent(name)}&version=${encodeURIComponent(version)}`,\n          );\n          const doc = (res as { plugin?: unknown }).plugin\n            ?? (res as { data?: { plugin?: unknown } }).data?.plugin;\n          if (!doc) throw new Error(`Plugin ${name}:${version} not found`);\n          const errors = validatePluginDoc(core, doc);\n          if (errors.length) problems.push({ source: `plugin/${name}:${version}`, errors });\n        }\n\n        if (problems.length === 0) {\n          printSuccess('All templates valid', { executionId });\n          return;\n        }\n\n        printWarning(`Found ${problems.reduce((a, p) => a + p.errors.length, 0)} template error(s):`);\n        for (const p of problems) {\n          printError(p.source);\n          for (const e of p.errors) {\n            console.log(`    [${e.field ?? '?'}] ${e.message}${e.code ? ` (${e.code})` : ''}`);\n          }\n        }\n        process.exit(1);\n      } catch (err) {\n        handleError(err, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'validate-templates', executionId },\n        });\n      }\n    });\n}\n\n/** The plugin template contract the upload applies (api-core's shared check). */\nfunction validatePluginDoc(core: PluginTemplateEngine, doc: unknown): Array<{ field?: string; message: string; code?: string }> {\n  return checkPluginTemplates(doc as object, core).map((issue) => ({\n    field: issue.line !== undefined ? `${issue.field}:${issue.line}:${issue.col}` : issue.field,\n    message: issue.message,\n    code: issue.kind,\n  }));\n}\n\nfunction validatePipelineDoc(core: Record<string, any>, doc: unknown): Array<{ field?: string; message: string; code?: string }> {\n  const isTpl = (f: string) =>\n    f === 'projectName' ||\n    f.startsWith('metadata.') || f.startsWith('metadata[') ||\n    f.startsWith('vars.') || f.startsWith('vars[');\n  const isKnown = core.allowedScopeRoots(['metadata', 'vars']);\n  const { errors } = core.validateTemplates(doc, isTpl, isKnown);\n  const cycles = core.detectCycles(doc, isTpl, (f: string) => isTpl(f) ? f : null);\n  return [...errors, ...cycles];\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validate-templates.js","sources":["../../src/commands/validate-templates.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport fs from 'fs';\nimport path from 'path';\nimport { checkPluginTemplates, type PluginTemplateEngine } from '@pipeline-builder/api-core';\nimport { Command } from 'commander';\nimport YAML from 'yaml';\nimport { printCommandHeader, printSslWarning, createAuthenticatedClientAsync, withSslOptions } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printError, printInfo, printSuccess, printWarning } from '../utils/output-utils.js';\nimport { extractSingleResponse } from '../utils/response-utils.js';\n\ninterface ValidateOptions {\n  pipeline?: string;\n  plugin?: string;\n  file?: string;\n  verifySsl?: boolean;\n}\n\n/**\n * Register the `validate-templates` command.\n *\n * Usage:\n *   pipeline-manager template validate --pipeline <uuid>\n *   pipeline-manager template validate --plugin <name:version>\n *   pipeline-manager template validate --file ./plugin-spec.yaml\n */\nexport function validateTemplatesCommand(program: Command): void {\n  withSslOptions(program\n    .command('validate')\n    .description('Parse and validate {{ ... }} templates in a pipeline or plugin spec')\n    .option('--pipeline <id>', 'Validate the pipeline with this ID')\n    .option('--plugin <name:version>', 'Validate the plugin with this name and version')\n    .option('--file <path>', 'Validate a local plugin-spec.yaml or pipeline.json file'))\n    .action(async (options: ValidateOptions) => {\n      const executionId = printCommandHeader('Validate Templates');\n      try {\n        printSslWarning(options.verifySsl);\n\n        if (!options.pipeline && !options.plugin && !options.file) {\n          throw new Error('One of --pipeline, --plugin, or --file is required');\n        }\n\n        const core = await import('@pipeline-builder/pipeline-core');\n\n        const problems: Array<{ source: string; errors: { field?: string; message: string; code?: string }[] }> = [];\n\n        if (options.file) {\n          const filePath = path.resolve(options.file);\n          const text = fs.readFileSync(filePath, 'utf-8');\n          const doc = filePath.endsWith('.json') ? JSON.parse(text) : YAML.parse(text);\n\n          // Guess: if `pluginType` is present, treat as plugin spec; else pipeline\n          const isPlugin = typeof (doc as { pluginType?: unknown }).pluginType === 'string';\n          const errors = isPlugin\n            ? validatePluginDoc(core, doc)\n            : validatePipelineDoc(core, doc);\n          if (errors.length) problems.push({ source: filePath, errors });\n        }\n\n        if (options.pipeline) {\n          printInfo('Fetching pipeline', { id: options.pipeline });\n          const client = await createAuthenticatedClientAsync(options);\n          const cfg = client.getConfig();\n          const res = await client.get<{ pipeline?: { props: unknown } }>(`${cfg.api.pipelineUrl}/${options.pipeline}`);\n          const doc = extractSingleResponse<{ props: unknown }>(res, 'pipeline', 'props')?.props;\n          if (!doc) throw new Error(`Pipeline ${options.pipeline} not found`);\n          const errors = validatePipelineDoc(core, doc);\n          if (errors.length) problems.push({ source: `pipeline/${options.pipeline}`, errors });\n        }\n\n        if (options.plugin) {\n          const [name, version] = options.plugin.split(':');\n          if (!name || !version) throw new Error('--plugin requires <name:version> format');\n          printInfo('Fetching plugin', { name, version });\n          const client = await createAuthenticatedClientAsync(options);\n          const cfg = client.getConfig();\n          const res = await client.get<{ plugin: unknown }>(\n            `${cfg.api.pluginUrl}/find?name=${encodeURIComponent(name)}&version=${encodeURIComponent(version)}`,\n          );\n          const doc = extractSingleResponse<Record<string, unknown>>(res, 'plugin', 'name');\n          if (!doc) throw new Error(`Plugin ${name}:${version} not found`);\n          const errors = validatePluginDoc(core, doc);\n          if (errors.length) problems.push({ source: `plugin/${name}:${version}`, errors });\n        }\n\n        if (problems.length === 0) {\n          printSuccess('All templates valid', { executionId });\n          return;\n        }\n\n        printWarning(`Found ${problems.reduce((a, p) => a + p.errors.length, 0)} template error(s):`);\n        for (const p of problems) {\n          printError(p.source);\n          for (const e of p.errors) {\n            console.log(`    [${e.field ?? '?'}] ${e.message}${e.code ? ` (${e.code})` : ''}`);\n          }\n        }\n        process.exit(1);\n      } catch (err) {\n        handleError(err, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'validate-templates', executionId },\n        });\n      }\n    });\n}\n\n/** The plugin template contract the upload applies (api-core's shared check). */\nfunction validatePluginDoc(core: PluginTemplateEngine, doc: unknown): Array<{ field?: string; message: string; code?: string }> {\n  return checkPluginTemplates(doc as object, core).map((issue) => ({\n    field: issue.line !== undefined ? `${issue.field}:${issue.line}:${issue.col}` : issue.field,\n    message: issue.message,\n    code: issue.kind,\n  }));\n}\n\nfunction validatePipelineDoc(core: Record<string, any>, doc: unknown): Array<{ field?: string; message: string; code?: string }> {\n  const isTpl = (f: string) =>\n    f === 'projectName' ||\n    f.startsWith('metadata.') || f.startsWith('metadata[') ||\n    f.startsWith('vars.') || f.startsWith('vars[');\n  const isKnown = core.allowedScopeRoots(['metadata', 'vars']);\n  const { errors } = core.validateTemplates(doc, isTpl, isKnown);\n  const cycles = core.detectCycles(doc, isTpl, (f: string) => isTpl(f) ? f : null);\n  return [...errors, ...cycles];\n}\n"]}

package/dist/config/cli.constants.d.ts

@@ -1,3 +1,11 @@
+/**
+ * The lowest Node.js version the CLI supports, read from package.json
+ * `engines.node` (a `>= x.y.z` floor) so the start-up warning can never name a
+ * different floor than the one npm enforces.
+ */
+export declare const NODE_VERSION_FLOOR: string;
+/** Whether `nodeVersion` (`v26.13.1` or `26.13.1`) is at or above `floor` (`26.13.1`). */
+export declare function meetsNodeVersionFloor(nodeVersion: string, floor?: string): boolean;
 /**
  * Application metadata
  */

package/dist/config/cli.constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.constants.d.ts","sources":["../../src/config/cli.constants.ts"],"names":[],"mappings":"AAaA;;GAEG;AACH,eAAO,MAAM,QAAQ,qBAAqB,CAAC;AAC3C,eAAO,MAAM,WAAW,QAAU,CAAC;AACnC,eAAO,MAAM,eAAe,+CAA+C,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,cAAc;aACzB,IAAI,EAAE,MAAM;aACZ,gBAAgB,EAAE,QAAQ;aAC1B,QAAQ;CACA,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;AAE7D;;GAEG;AACH,eAAO,MAAM,QAAQ;aACnB,YAAY,EAAE,KAAK;aACnB,YAAY,EAAE,IAAI;CACV,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,gBAAgB;aAC3B,MAAM;aACN,cAAc;CACN,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,QAAQ;aACnB,cAAc,EAAE,gBAAgB;aAChC,iBAAiB,EAAE,mBAAmB;aACtC,eAAe,EAAE,iBAAiB;aAClC,uBAAuB,EAAE,yBAAyB;aAClD,UAAU,EAAE,YAAY;aACxB,KAAK,EAAE,OAAO;CACN,CAAC;AAEX;;GAEG;AACH,wBAAgB,WAAW,CAAC,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAElE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMpD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAMjD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAED;;GAEG;AACH,eAAO,MAAM,aAAa;aACxB,MAAM;iBACJ,OAAO,EAAE,GAAG;iBACZ,OAAO,EAAE,GAAG;iBACZ,OAAO,EAAE,GAAG;iBACZ,QAAQ,EAAE,GAAG;iBACb,UAAU,EAAE,GAAG;iBACf,UAAU,EAAE,GAAG;iBACf,UAAU,EAAE,GAAG;iBACf,WAAW,EAAE,GAAG;iBAChB,QAAQ,EAAE,GAAG;iBACb,SAAS,EAAE,GAAG;iBACd,QAAQ,EAAE,GAAG;iBACb,QAAQ,EAAE,GAAG;iBACb,QAAQ,EAAE,GAAG;iBACb,SAAS,EAAE,GAAG;iBACd,QAAQ,EAAE,GAAG;;CAEP,CAAC;AAEX;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAKzE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAuB/H;AAQD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAM1E;AAQD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,IAAI,GAAE;IAAE,WAAW,CAAC,EAAE,OAAO,CAAA;CAAO,GACnC,IAAI,CAON;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAGjF;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,4BAA4B,CAAC"}
+{"version":3,"file":"cli.constants.d.ts","sources":["../../src/config/cli.constants.ts"],"names":[],"mappings":"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"}