@pipeline-builder/pipeline-manager 4.5.3 → 4.5.4

package/dist/commands/pipeline-remove.js

@@ -0,0 +1,84 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import { createAuthenticatedClientAsync, printCommandHeader, printSslWarning, validateEntityId, withSslOptions } from '../utils/command-utils.js';
+import { ERROR_CODES, handleError, ValidationError } from '../utils/error-handler.js';
+import { printInfo, printSuccess, printWarning } from '../utils/output-utils.js';
+/** `--yes` is required: both verbs are destructive and the CLI never prompts. */
+function requireYes(yes, what) {
+    if (!yes)
+        throw new ValidationError(`Refusing to ${what} without --yes`, 'yes');
+}
+/**
+ * Registers `pipeline delete`: delete a pipeline configuration
+ * (`DELETE /api/pipelines/:id`). It does NOT touch AWS — a deployed stack keeps
+ * running until it is destroyed, and the stack then shows up in `audit stacks`
+ * as orphaned.
+ *
+ * @example
+ * ```bash
+ * pipeline-manager pipeline delete --id <pipelineId> --yes
+ * ```
+ */
+export function deletePipeline(program) {
+    withSslOptions(program
+        .command('delete')
+        .description('Delete a pipeline configuration from the platform (the deployed stack, if any, is left in AWS)')
+        .requiredOption('-i, --id <id>', 'Pipeline ID')
+        .option('-y, --yes', 'Confirm the deletion (required)', false))
+        .action(async (options) => {
+        const executionId = printCommandHeader('Delete Pipeline');
+        try {
+            printSslWarning(options.verifySsl);
+            const id = validateEntityId(options.id, 'Pipeline');
+            requireYes(options.yes, 'delete a pipeline');
+            const client = await createAuthenticatedClientAsync(options);
+            await client.delete(`${client.getConfig().api.pipelineUrl}/${encodeURIComponent(id)}`);
+            printSuccess('Pipeline deleted', { id });
+            printWarning('A deployed stack is not removed — destroy it in AWS, or it will be reported by "audit stacks" as orphaned');
+        }
+        catch (error) {
+            handleError(error, ERROR_CODES.API_REQUEST, {
+                exit: true,
+                context: { command: 'pipeline-delete', executionId, pipelineId: options.id },
+            });
+        }
+    });
+}
+/**
+ * Registers `pipeline deregister`: remove one pipeline_registry row
+ * (`DELETE /api/pipelines/registry/:id`, by the row's UUID — the `registryId`
+ * an `audit stacks` missing-stack finding prints). The supported way to clear a
+ * row whose CloudFormation stack was deleted out of band.
+ *
+ * @example
+ * ```bash
+ * pipeline-manager pipeline deregister --id <registryId> --yes
+ * ```
+ */
+export function deregisterPipeline(program) {
+    withSslOptions(program
+        .command('deregister')
+        .description('Remove a pipeline_registry row (by registry id) — reconciles an "audit stacks" missing-stack finding')
+        .requiredOption('-i, --id <registryId>', 'Registry row ID (the registryId "audit stacks" prints)')
+        .option('-y, --yes', 'Confirm the removal (required)', false))
+        .action(async (options) => {
+        const executionId = printCommandHeader('Deregister Pipeline');
+        try {
+            printSslWarning(options.verifySsl);
+            const id = validateEntityId(options.id, 'Registry');
+            requireYes(options.yes, 'remove a registry row');
+            const client = await createAuthenticatedClientAsync(options);
+            await client.delete(`${client.getConfig().api.pipelineUrl}/registry/${encodeURIComponent(id)}`);
+            printSuccess('Registry row removed', { id });
+            printInfo('Event reporting for that deployment stops; "pipeline register" adds it back');
+        }
+        catch (error) {
+            handleError(error, ERROR_CODES.API_REQUEST, {
+                exit: true,
+                context: { command: 'pipeline-deregister', executionId, registryId: options.id },
+            });
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline-remove.js","sources":["../../src/commands/pipeline-remove.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Command } from 'commander';\nimport { createAuthenticatedClientAsync, printCommandHeader, printSslWarning, validateEntityId, withSslOptions } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError, ValidationError } from '../utils/error-handler.js';\nimport { printInfo, printSuccess, printWarning } from '../utils/output-utils.js';\n\n/** `--yes` is required: both verbs are destructive and the CLI never prompts. */\nfunction requireYes(yes: boolean | undefined, what: string): void {\n  if (!yes) throw new ValidationError(`Refusing to ${what} without --yes`, 'yes');\n}\n\n/**\n * Registers `pipeline delete`: delete a pipeline configuration\n * (`DELETE /api/pipelines/:id`). It does NOT touch AWS — a deployed stack keeps\n * running until it is destroyed, and the stack then shows up in `audit stacks`\n * as orphaned.\n *\n * @example\n * ```bash\n * pipeline-manager pipeline delete --id <pipelineId> --yes\n * ```\n */\nexport function deletePipeline(program: Command): void {\n  withSslOptions(program\n    .command('delete')\n    .description('Delete a pipeline configuration from the platform (the deployed stack, if any, is left in AWS)')\n    .requiredOption('-i, --id <id>', 'Pipeline ID')\n    .option('-y, --yes', 'Confirm the deletion (required)', false))\n    .action(async (options) => {\n      const executionId = printCommandHeader('Delete Pipeline');\n      try {\n        printSslWarning(options.verifySsl);\n        const id = validateEntityId(options.id, 'Pipeline');\n        requireYes(options.yes, 'delete a pipeline');\n        const client = await createAuthenticatedClientAsync(options);\n        await client.delete(`${client.getConfig().api.pipelineUrl}/${encodeURIComponent(id)}`);\n        printSuccess('Pipeline deleted', { id });\n        printWarning('A deployed stack is not removed — destroy it in AWS, or it will be reported by \"audit stacks\" as orphaned');\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          exit: true,\n          context: { command: 'pipeline-delete', executionId, pipelineId: options.id },\n        });\n      }\n    });\n}\n\n/**\n * Registers `pipeline deregister`: remove one pipeline_registry row\n * (`DELETE /api/pipelines/registry/:id`, by the row's UUID — the `registryId`\n * an `audit stacks` missing-stack finding prints). The supported way to clear a\n * row whose CloudFormation stack was deleted out of band.\n *\n * @example\n * ```bash\n * pipeline-manager pipeline deregister --id <registryId> --yes\n * ```\n */\nexport function deregisterPipeline(program: Command): void {\n  withSslOptions(program\n    .command('deregister')\n    .description('Remove a pipeline_registry row (by registry id) — reconciles an \"audit stacks\" missing-stack finding')\n    .requiredOption('-i, --id <registryId>', 'Registry row ID (the registryId \"audit stacks\" prints)')\n    .option('-y, --yes', 'Confirm the removal (required)', false))\n    .action(async (options) => {\n      const executionId = printCommandHeader('Deregister Pipeline');\n      try {\n        printSslWarning(options.verifySsl);\n        const id = validateEntityId(options.id, 'Registry');\n        requireYes(options.yes, 'remove a registry row');\n        const client = await createAuthenticatedClientAsync(options);\n        await client.delete(`${client.getConfig().api.pipelineUrl}/registry/${encodeURIComponent(id)}`);\n        printSuccess('Registry row removed', { id });\n        printInfo('Event reporting for that deployment stops; \"pipeline register\" adds it back');\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          exit: true,\n          context: { command: 'pipeline-deregister', executionId, registryId: options.id },\n        });\n      }\n    });\n}\n"]}

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":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEnD;;;;;;;GAOG;AACH,MAAM,UAAU,MAAM,CAAC,OAAgB;IACrC,OAAO;SACJ,OAAO,CAAC,QAAQ,CAAC;SACjB,WAAW,CAAC,0CAA0C,CAAC;SACvD,MAAM,CAAC,QAAQ,EAAE,uBAAuB,EAAE,KAAK,CAAC;SAChD,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;QACxB,MAAM,WAAW,GAAG,kBAAkB,CAAC,QAAQ,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;QAErF,IAAI,CAAC;YACH,MAAM,OAAO,GAA2B,EAAE,CAAC;YAE3C,0BAA0B;YAC1B,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;YACnD,OAAO,CAAC,cAAc,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;YAEnD,gCAAgC;YAChC,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC;YACpD,OAAO,CAAC,oBAAoB,GAAG,UAAU,IAAI,SAAS,CAAC;YAEvD,4BAA4B;YAC5B,OAAO,CAAC,eAAe,CAAC,GAAG,iBAAiB,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;YAE9D,2BAA2B;YAC3B,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,iBAAiB,CAAC,IAAI,wBAAwB,CAAC;YACpF,OAAO,CAAC,iBAAiB,GAAG,OAAO,CAAC;YAEpC,IAAI,CAAC;gBACH,gFAAgF;gBAChF,MAAM,KAAK,CAAC,GAAG,CAAC,GAAG,OAAO,SAAS,EAAE;oBACnC,OAAO,EAAE,QAAQ,CAAC,YAAY;oBAC9B,UAAU,EAAE,gBAAgB,CAAC,OAAO,CAAC;iBACtC,CAAC,CAAC;gBACH,OAAO,CAAC,iBAAiB,CAAC,GAAG,WAAW,CAAC;YAC3C,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,CAAC,iBAAiB,CAAC,GAAG,aAAa,CAAC;YAC7C,CAAC;YAED,sEAAsE;YACtE,yEAAyE;YACzE,yEAAyE;YACzE,iCAAiC;YACjC,IAAI,KAAK,EAAE,CAAC;gBACV,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAAC;gBAC1C,IAAI,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;oBAC1B,OAAO,CAAC,eAAe,CAAC,GAAG,+CAA+C,CAAC;gBAC7E,CAAC;qBAAM,IAAI,CAAC,OAAO,EAAE,CAAC;oBACpB,OAAO,CAAC,eAAe,CAAC,GAAG,kBAAkB,CAAC;gBAChD,CAAC;qBAAM,IAAI,OAAO,OAAO,CAAC,GAAG,KAAK,QAAQ,EAAE,CAAC;oBAC3C,MAAM,SAAS,GAAG,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC;oBAC/C,OAAO,CAAC,eAAe,CAAC,GAAG,SAAS,CAAC,WAAW,EAAE,CAAC;oBACnD,OAAO,CAAC,eAAe,CAAC,GAAG,SAAS,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;gBAC7E,CAAC;YACH,CAAC;YAED,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;gBACjB,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,GAAG,OAAO,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;YACnF,CAAC;iBAAM,CAAC;gBACN,YAAY,CAAC,oBAAoB,CAAC,CAAC;gBACnC,aAAa,CAAC,OAAO,CAAC,CAAC;YACzB,CAAC;QAEH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,WAAW,CAAC,KAAK,EAAE,WAAW,CAAC,OAAO,EAAE;gBACtC,KAAK,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,KAAK;gBAC3B,IAAI,EAAE,IAAI;gBACV,OAAO,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE;aAC5C,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC,CAAC;AACP,CAAC","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.map

@@ -1 +1 @@
-{"version":3,"file":"toolchain.d.ts","sources":["../../src/commands/toolchain.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAwChD"}
+{"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

@@ -2,6 +2,7 @@
 // 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';
@@ -51,8 +52,8 @@ export function toolchain(program) {
             printKeyValue({
                 'Release': file.releaseVersion,
                 'Resolved via': file.resolvedVia,
-                'pipeline-bootstrap': `${file.bootstrap.imageRepository}@${file.bootstrap.imageDigest}`,
-                'cdk-synth': `${file.synth.imageRepository}@${file.synth.imageDigest}`,
+                [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}` });
@@ -66,4 +67,4 @@ export function toolchain(program) {
         }
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# 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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"}