@pipeline-builder/pipeline-manager 3.4.178 → 3.4.180

package/dist/utils/platform-secret.js

@@ -28,22 +28,22 @@ export function resolveSecretName(token) {
 }
 /**
  * Ensure `process.env.PLATFORM_TOKEN` is set. No-op if it already is. Otherwise,
- * if login creds are available (`--email/--password` or `PLATFORM_IDENTIFIER`/
+ * if login creds are available (`--identifier/--password` or `PLATFORM_IDENTIFIER`/
  * `PLATFORM_PASSWORD` env — the env path lets `provision` pass creds without
  * putting the password on the command line), log in and set PLATFORM_TOKEN.
  */
 export async function ensurePlatformToken(options) {
     if (process.env.PLATFORM_TOKEN)
         return;
-    const loginEmail = options.email || process.env.PLATFORM_IDENTIFIER;
+    const loginIdentifier = options.identifier || process.env.PLATFORM_IDENTIFIER;
     const loginPassword = options.password || process.env.PLATFORM_PASSWORD;
-    if (!loginEmail || !loginPassword)
+    if (!loginIdentifier || !loginPassword)
         return;
     if (options.password) {
         printWarning('Passing --password on the command line can expose it via shell history; prefer the PLATFORM_PASSWORD env var.');
     }
     printSection('Login');
-    printInfo('Authenticating with email/password...');
+    printInfo('Authenticating with identifier/password...');
     // Resolve the base URL WITHOUT demanding a token — this login step runs
     // pre-auth (no PLATFORM_TOKEN yet), so `getConfig()` would throw here. The
     // token-optional loader still honors config files + PLATFORM_BASE_URL/TLS env.
@@ -55,7 +55,11 @@ export async function ensurePlatformToken(options) {
         assertSslDisableAllowed('inline login');
     }
     const rejectUnauthorized = options.verifySsl === false ? false : apiConfig.api.rejectUnauthorized;
-    const loginResponse = await axios.post(`${apiConfig.api.baseUrl}/api/auth/login`, { email: loginEmail, password: loginPassword }, {
+    const loginResponse = await axios.post(`${apiConfig.api.baseUrl}/api/auth/login`, 
+    // The server's loginSchema requires `identifier` (email OR username), not
+    // `email` — sending `email` fails zod validation with a 400. Mirror the
+    // canonical `postLogin` body.
+    { identifier: loginIdentifier, password: loginPassword }, {
         httpsAgent: rejectUnauthorized === false
             ? new (await import('https')).Agent({ rejectUnauthorized: false })
             : undefined,
@@ -81,8 +85,8 @@ export async function resolvePlatformSecretName(options) {
     if (!process.env.PLATFORM_TOKEN) {
         throw new Error('Cannot derive the platform secret name: no PLATFORM_TOKEN and no login creds. '
             + 'Set PLATFORM_SECRET_NAME, or provide login creds '
-            + '(--email/--password or PLATFORM_IDENTIFIER/PLATFORM_PASSWORD).');
+            + '(--identifier/--password or PLATFORM_IDENTIFIER/PLATFORM_PASSWORD).');
     }
     return resolveSecretName(process.env.PLATFORM_TOKEN);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"platform-secret.js","sourceRoot":"","sources":["../../src/utils/platform-secret.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared platform-token → secret-name resolution, used by both `store-token`\n * (which WRITES the JWT to Secrets Manager) and `setup-events` (which deploys the\n * Lambda that READS it). Both must agree on the same secret path, so the logic\n * lives here once: derive `{SECRETS_PATH_PREFIX}/{orgId}/platform` from the JWT's\n * organizationId, logging in first if needed to obtain the token.\n */\n\nimport { CoreConstants } from '@pipeline-builder/pipeline-core';\nimport axios from 'axios';\nimport { decodeTokenPayload } from './auth-guard.js';\nimport { getApiConfig } from './config-loader.js';\nimport { printInfo, printSection, printSuccess, printWarning } from './output-utils.js';\nimport { assertSslDisableAllowed } from './tls.js';\n\n/** Login/secret options shared across the platform-secret helpers. */\nexport interface PlatformSecretOptions {\n  readonly email?: string;\n  readonly password?: string;\n  readonly verifySsl?: boolean;\n}\n\n/**\n * Derive the platform secret path from a JWT's organizationId.\n * Pattern: `{SECRETS_PATH_PREFIX}/{orgId}/platform`.\n * @throws if the token carries no organizationId (caller should fall back to PLATFORM_SECRET_NAME).\n */\nexport function resolveSecretName(token: string): string {\n  const payload = decodeTokenPayload(token);\n  const orgId = payload?.organizationId;\n  if (!orgId) {\n    throw new Error('Token does not contain organizationId — cannot derive secret name. Set PLATFORM_SECRET_NAME to specify it explicitly.');\n  }\n  return `${CoreConstants.SECRETS_PATH_PREFIX}/${orgId}/platform`;\n}\n\n/**\n * Ensure `process.env.PLATFORM_TOKEN` is set. No-op if it already is. Otherwise,\n * if login creds are available (`--email/--password` or `PLATFORM_IDENTIFIER`/\n * `PLATFORM_PASSWORD` env — the env path lets `provision` pass creds without\n * putting the password on the command line), log in and set PLATFORM_TOKEN.\n */\nexport async function ensurePlatformToken(options: PlatformSecretOptions): Promise<void> {\n  if (process.env.PLATFORM_TOKEN) return;\n  const loginEmail = options.email || process.env.PLATFORM_IDENTIFIER;\n  const loginPassword = options.password || process.env.PLATFORM_PASSWORD;\n  if (!loginEmail || !loginPassword) return;\n\n  if (options.password) {\n    printWarning('Passing --password on the command line can expose it via shell history; prefer the PLATFORM_PASSWORD env var.');\n  }\n\n  printSection('Login');\n  printInfo('Authenticating with email/password...');\n  // Resolve the base URL WITHOUT demanding a token — this login step runs\n  // pre-auth (no PLATFORM_TOKEN yet), so `getConfig()` would throw here. The\n  // token-optional loader still honors config files + PLATFORM_BASE_URL/TLS env.\n  const apiConfig = getApiConfig();\n  // SECURITY: this inline login POSTs the password. Refuse to disable cert\n  // verification in production (mirrors config-loader / login) so a MITM can't\n  // harvest it; honored in non-production for self-signed dev platforms.\n  if (options.verifySsl === false) {\n    assertSslDisableAllowed('inline login');\n  }\n  const rejectUnauthorized = options.verifySsl === false ? false : apiConfig.api.rejectUnauthorized;\n  const loginResponse = await axios.post(\n    `${apiConfig.api.baseUrl}/api/auth/login`,\n    { email: loginEmail, password: loginPassword },\n    {\n      httpsAgent: rejectUnauthorized === false\n        ? new (await import('https')).Agent({ rejectUnauthorized: false })\n        : undefined,\n    },\n  );\n  const loginData = loginResponse.data?.data ?? loginResponse.data;\n  const loginToken = loginData?.accessToken;\n  if (!loginToken || typeof loginToken !== 'string') {\n    throw new Error('Login failed — no access token in response');\n  }\n  process.env.PLATFORM_TOKEN = loginToken;\n  printSuccess('Login successful');\n}\n\n/**\n * Resolve the platform secret name: an explicit `PLATFORM_SECRET_NAME` env wins;\n * otherwise log in if needed and derive it from the platform token's org — the\n * same token `init-platform.sh` (register) mints, so writer and reader agree.\n */\nexport async function resolvePlatformSecretName(options: PlatformSecretOptions): Promise<string> {\n  const explicit = process.env.PLATFORM_SECRET_NAME;\n  if (explicit) return explicit;\n  await ensurePlatformToken(options);\n  if (!process.env.PLATFORM_TOKEN) {\n    throw new Error(\n      'Cannot derive the platform secret name: no PLATFORM_TOKEN and no login creds. '\n      + 'Set PLATFORM_SECRET_NAME, or provide login creds '\n      + '(--email/--password or PLATFORM_IDENTIFIER/PLATFORM_PASSWORD).',\n    );\n  }\n  return resolveSecretName(process.env.PLATFORM_TOKEN);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"platform-secret.js","sourceRoot":"","sources":["../../src/utils/platform-secret.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared platform-token → secret-name resolution, used by both `store-token`\n * (which WRITES the JWT to Secrets Manager) and `setup-events` (which deploys the\n * Lambda that READS it). Both must agree on the same secret path, so the logic\n * lives here once: derive `{SECRETS_PATH_PREFIX}/{orgId}/platform` from the JWT's\n * organizationId, logging in first if needed to obtain the token.\n */\n\nimport { CoreConstants } from '@pipeline-builder/pipeline-core';\nimport axios from 'axios';\nimport { decodeTokenPayload } from './auth-guard.js';\nimport { getApiConfig } from './config-loader.js';\nimport { printInfo, printSection, printSuccess, printWarning } from './output-utils.js';\nimport { assertSslDisableAllowed } from './tls.js';\n\n/** Login/secret options shared across the platform-secret helpers. */\nexport interface PlatformSecretOptions {\n  /** Login identifier (username OR email) — matches `auth login` / `auth pat`. */\n  readonly identifier?: string;\n  readonly password?: string;\n  readonly verifySsl?: boolean;\n}\n\n/**\n * Derive the platform secret path from a JWT's organizationId.\n * Pattern: `{SECRETS_PATH_PREFIX}/{orgId}/platform`.\n * @throws if the token carries no organizationId (caller should fall back to PLATFORM_SECRET_NAME).\n */\nexport function resolveSecretName(token: string): string {\n  const payload = decodeTokenPayload(token);\n  const orgId = payload?.organizationId;\n  if (!orgId) {\n    throw new Error('Token does not contain organizationId — cannot derive secret name. Set PLATFORM_SECRET_NAME to specify it explicitly.');\n  }\n  return `${CoreConstants.SECRETS_PATH_PREFIX}/${orgId}/platform`;\n}\n\n/**\n * Ensure `process.env.PLATFORM_TOKEN` is set. No-op if it already is. Otherwise,\n * if login creds are available (`--identifier/--password` or `PLATFORM_IDENTIFIER`/\n * `PLATFORM_PASSWORD` env — the env path lets `provision` pass creds without\n * putting the password on the command line), log in and set PLATFORM_TOKEN.\n */\nexport async function ensurePlatformToken(options: PlatformSecretOptions): Promise<void> {\n  if (process.env.PLATFORM_TOKEN) return;\n  const loginIdentifier = options.identifier || process.env.PLATFORM_IDENTIFIER;\n  const loginPassword = options.password || process.env.PLATFORM_PASSWORD;\n  if (!loginIdentifier || !loginPassword) return;\n\n  if (options.password) {\n    printWarning('Passing --password on the command line can expose it via shell history; prefer the PLATFORM_PASSWORD env var.');\n  }\n\n  printSection('Login');\n  printInfo('Authenticating with identifier/password...');\n  // Resolve the base URL WITHOUT demanding a token — this login step runs\n  // pre-auth (no PLATFORM_TOKEN yet), so `getConfig()` would throw here. The\n  // token-optional loader still honors config files + PLATFORM_BASE_URL/TLS env.\n  const apiConfig = getApiConfig();\n  // SECURITY: this inline login POSTs the password. Refuse to disable cert\n  // verification in production (mirrors config-loader / login) so a MITM can't\n  // harvest it; honored in non-production for self-signed dev platforms.\n  if (options.verifySsl === false) {\n    assertSslDisableAllowed('inline login');\n  }\n  const rejectUnauthorized = options.verifySsl === false ? false : apiConfig.api.rejectUnauthorized;\n  const loginResponse = await axios.post(\n    `${apiConfig.api.baseUrl}/api/auth/login`,\n    // The server's loginSchema requires `identifier` (email OR username), not\n    // `email` — sending `email` fails zod validation with a 400. Mirror the\n    // canonical `postLogin` body.\n    { identifier: loginIdentifier, password: loginPassword },\n    {\n      httpsAgent: rejectUnauthorized === false\n        ? new (await import('https')).Agent({ rejectUnauthorized: false })\n        : undefined,\n    },\n  );\n  const loginData = loginResponse.data?.data ?? loginResponse.data;\n  const loginToken = loginData?.accessToken;\n  if (!loginToken || typeof loginToken !== 'string') {\n    throw new Error('Login failed — no access token in response');\n  }\n  process.env.PLATFORM_TOKEN = loginToken;\n  printSuccess('Login successful');\n}\n\n/**\n * Resolve the platform secret name: an explicit `PLATFORM_SECRET_NAME` env wins;\n * otherwise log in if needed and derive it from the platform token's org — the\n * same token `init-platform.sh` (register) mints, so writer and reader agree.\n */\nexport async function resolvePlatformSecretName(options: PlatformSecretOptions): Promise<string> {\n  const explicit = process.env.PLATFORM_SECRET_NAME;\n  if (explicit) return explicit;\n  await ensurePlatformToken(options);\n  if (!process.env.PLATFORM_TOKEN) {\n    throw new Error(\n      'Cannot derive the platform secret name: no PLATFORM_TOKEN and no login creds. '\n      + 'Set PLATFORM_SECRET_NAME, or provide login creds '\n      + '(--identifier/--password or PLATFORM_IDENTIFIER/PLATFORM_PASSWORD).',\n    );\n  }\n  return resolveSecretName(process.env.PLATFORM_TOKEN);\n}\n"]}

package/dist/utils/preflight.d.ts

@@ -0,0 +1,26 @@
+import { type Command } from 'commander';
+export type LocalTool = 'cdk' | 'bundler';
+/**
+ * Per-command local-tool requirements, checked by the CLI's `preAction` hook
+ * BEFORE a command's action runs — so a missing tool fails fast with an
+ * actionable message instead of deep inside a CDK bundle. Keyed by full command
+ * path (e.g. "pipeline deploy").
+ *
+ * Only `pipeline synth`/`deploy` shell out to cdk (+ esbuild/pnpm for the
+ * PluginLookup Lambda bundle). Every other command is API-only and requires
+ * nothing local, so it's absent here and never gated — as are version / help /
+ * completions. (`infra provision` runs its own target-specific prereq checks.)
+ */
+export declare const COMMAND_TOOL_REQUIREMENTS: Record<string, LocalTool[]>;
+/** Full space-joined command path for a Commander command, e.g. "pipeline deploy". */
+export declare function commandPath(cmd: Command): string;
+/** The local tools a command declares it needs (empty when it needs nothing). */
+export declare function requiredToolsFor(cmd: Command): LocalTool[];
+/**
+ * Preflight the local tools an about-to-run command declares. Reuses the tools'
+ * `ensureX` helpers (which print the actionable message + install hint on
+ * failure), then exits non-zero so the command body never runs. No-op for any
+ * command without requirements (API-only commands, version/help/completions).
+ */
+export declare function preflightCommandTools(actionCommand: Command): void;
+//# sourceMappingURL=preflight.d.ts.map

package/dist/utils/preflight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preflight.d.ts","sourceRoot":"","sources":["../../src/utils/preflight.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAGzC,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,SAAS,CAAC;AAE1C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,CAMjE,CAAC;AAEF,sFAAsF;AACtF,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAQhD;AAED,iFAAiF;AACjF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,EAAE,CAE1D;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,OAAO,GAAG,IAAI,CAWlE"}

package/dist/utils/preflight.js

@@ -0,0 +1,59 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import {} from 'commander';
+import { ensureBundlerAvailable, ensureCdkAvailable } from './cdk-utils.js';
+/**
+ * Per-command local-tool requirements, checked by the CLI's `preAction` hook
+ * BEFORE a command's action runs — so a missing tool fails fast with an
+ * actionable message instead of deep inside a CDK bundle. Keyed by full command
+ * path (e.g. "pipeline deploy").
+ *
+ * Only `pipeline synth`/`deploy` shell out to cdk (+ esbuild/pnpm for the
+ * PluginLookup Lambda bundle). Every other command is API-only and requires
+ * nothing local, so it's absent here and never gated — as are version / help /
+ * completions. (`infra provision` runs its own target-specific prereq checks.)
+ */
+export const COMMAND_TOOL_REQUIREMENTS = {
+    'pipeline synth': ['cdk', 'bundler'],
+    'pipeline deploy': ['cdk', 'bundler'],
+    // `infra bootstrap` runs `cdk bootstrap` (AWS env bootstrap) — cdk only; it
+    // synthesizes no Lambda, so no esbuild/pnpm bundler is needed.
+    'infra bootstrap': ['cdk'],
+};
+/** Full space-joined command path for a Commander command, e.g. "pipeline deploy". */
+export function commandPath(cmd) {
+    const parts = [];
+    let c = cmd;
+    while (c && c.parent) {
+        parts.unshift(c.name());
+        c = c.parent ?? undefined;
+    }
+    return parts.join(' ');
+}
+/** The local tools a command declares it needs (empty when it needs nothing). */
+export function requiredToolsFor(cmd) {
+    return COMMAND_TOOL_REQUIREMENTS[commandPath(cmd)] ?? [];
+}
+/**
+ * Preflight the local tools an about-to-run command declares. Reuses the tools'
+ * `ensureX` helpers (which print the actionable message + install hint on
+ * failure), then exits non-zero so the command body never runs. No-op for any
+ * command without requirements (API-only commands, version/help/completions).
+ */
+export function preflightCommandTools(actionCommand) {
+    const reqs = requiredToolsFor(actionCommand);
+    if (reqs.length === 0)
+        return;
+    try {
+        if (reqs.includes('cdk'))
+            ensureCdkAvailable();
+        if (reqs.includes('bundler'))
+            ensureBundlerAvailable();
+    }
+    catch {
+        // Message already printed by ensureX. Halt before the action runs so the
+        // command doesn't proceed with a broken toolchain.
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/response-utils.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Unwrap a sendSuccess API envelope: { success, statusCode, data: { ... } }
+ * Returns the inner `data` object, or the original response if not wrapped.
+ */
+export declare function unwrapEnvelope(response: unknown): Record<string, unknown>;
+/**
+ * Extract a single entity from an API response, handling envelope formats.
+ * Tries: payload[entityKey], payload directly (if identifierKey exists), or undefined.
+ */
+export declare function extractSingleResponse<T>(response: unknown, entityKey: string, identifierKey: string): T | undefined;
+export interface ListResponseResult<T> {
+    items: T[];
+    total?: number;
+    hasMore: boolean;
+}
+/**
+ * Extract items from an API list response, handling multiple response formats.
+ * Supports: `{ <key>: T[] }`, `{ items: T[] }`, `T[]`, or invalid formats.
+ */
+export declare function extractListResponse<T>(response: unknown, itemsKey: string): ListResponseResult<T>;
+//# sourceMappingURL=response-utils.d.ts.map

package/dist/utils/response-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-utils.d.ts","sourceRoot":"","sources":["../../src/utils/response-utils.ts"],"names":[],"mappings":"AASA;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CASzE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAQnH;AAED,MAAM,WAAW,kBAAkB,CAAC,CAAC;IACnC,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,kBAAkB,CAAC,CAAC,CAAC,CAoCjG"}

package/dist/utils/response-utils.js

@@ -0,0 +1,70 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+// API response-envelope parsing. Split out of output-utils (which is about
+// rendering) — this is purely about reading the `{ success, data }` shapes the
+// platform returns and pulling out single entities / lists.
+import { printError, printWarning } from './output-utils.js';
+/**
+ * Unwrap a sendSuccess API envelope: { success, statusCode, data: { ... } }
+ * Returns the inner `data` object, or the original response if not wrapped.
+ */
+export function unwrapEnvelope(response) {
+    if (response && typeof response === 'object') {
+        const obj = response;
+        if ('success' in obj && 'data' in obj && obj.data && typeof obj.data === 'object') {
+            return obj.data;
+        }
+        return obj;
+    }
+    return {};
+}
+/**
+ * Extract a single entity from an API response, handling envelope formats.
+ * Tries: payload[entityKey], payload directly (if identifierKey exists), or undefined.
+ */
+export function extractSingleResponse(response, entityKey, identifierKey) {
+    const payload = unwrapEnvelope(response);
+    // Direct entity: payload has the identifier (e.g. payload.id, payload.props, payload.name)
+    if (identifierKey in payload)
+        return payload;
+    // Nested under entity key: payload.pipeline, payload.plugin
+    const nested = payload[entityKey];
+    if (nested && typeof nested === 'object' && identifierKey in nested)
+        return nested;
+    return undefined;
+}
+/**
+ * Extract items from an API list response, handling multiple response formats.
+ * Supports: `{ <key>: T[] }`, `{ items: T[] }`, `T[]`, or invalid formats.
+ */
+export function extractListResponse(response, itemsKey) {
+    if (Array.isArray(response)) {
+        return { items: response, total: undefined, hasMore: false };
+    }
+    if (response && typeof response === 'object') {
+        const obj = unwrapEnvelope(response);
+        // A `{ success, data: [...] }` envelope unwraps to the bare array — return it directly
+        // (the `itemsKey in obj` / `'items' in obj` checks below are false for an array, so
+        // without this such list envelopes would silently yield zero items).
+        if (Array.isArray(obj)) {
+            return { items: obj, total: undefined, hasMore: false };
+        }
+        // Extract pagination metadata if present
+        const pagination = obj.pagination;
+        const total = (pagination?.total ?? obj.total);
+        const hasMore = (pagination?.hasMore ?? obj.hasMore) || false;
+        // Try primary key (e.g. 'pipelines', 'plugins')
+        if (itemsKey in obj && Array.isArray(obj[itemsKey])) {
+            return { items: obj[itemsKey], total, hasMore };
+        }
+        // Try generic 'items' key
+        if ('items' in obj && Array.isArray(obj.items)) {
+            return { items: obj.items, total, hasMore };
+        }
+        printWarning('Unexpected response format, attempting to handle');
+        return { items: [], total: undefined, hasMore: false };
+    }
+    printError('Invalid response format from API');
+    throw new Error('Unexpected API response format');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -43,9 +43,9 @@
     "typescript": "npm:@typescript/typescript6@^6.0.2",
     "yaml": "2.9.0",
     "zod": "4.4.3",
+    "@pipeline-builder/pipeline-core": "3.4.138",
     "@pipeline-builder/ai-core": "3.4.118",
-    "@pipeline-builder/api-core": "3.4.118",
-    "@pipeline-builder/pipeline-core": "3.4.138"
+    "@pipeline-builder/api-core": "3.4.118"
   },
   "keywords": [
     "ci-cd",
@@ -100,7 +100,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "3.4.178",
+  "version": "3.4.180",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },