@pipeline-builder/pipeline-manager 3.4.125 → 3.4.126

package/dist/commands/store-token.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-token.d.ts","sourceRoot":"","sources":["../../src/commands/store-token.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAUpC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA+KjD"}
+{"version":3,"file":"store-token.d.ts","sourceRoot":"","sources":["../../src/commands/store-token.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAuFpC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAuMjD"}

package/dist/commands/store-token.js

@@ -1,14 +1,84 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+import { execFileSync } from 'child_process';
+import * as fs from 'fs';
+import { fileURLToPath } from 'node:url';
+import * as os from 'os';
+import path from 'path';
+import { LambdaClient, UpdateFunctionCodeCommand } from '@aws-sdk/client-lambda';
 import { Command } from 'commander';
 import { validateNumber } from '../config/cli.constants.js';
 import { auditLog } from '../utils/audit-log.js';
 import { decodeTokenPayload } from '../utils/auth-guard.js';
 import { upsertSecret, getSecretArn } from '../utils/aws-secrets.js';
 import { createAuthenticatedClientAsync, printCommandHeader, printSslWarning } from '../utils/command-utils.js';
+import { toEventBridgeCron } from '../utils/cron.js';
 import { ERROR_CODES, handleError } from '../utils/error-handler.js';
 import { printInfo, printKeyValue, printSection, printSuccess } from '../utils/output-utils.js';
 import { ensurePlatformToken, resolveSecretName } from '../utils/platform-secret.js';
+// ESM has no __dirname; derive it from this module's URL.
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const RENEW_STACK_NAME = 'pipeline-builder-token-renew';
+// CFN-managed Lambda function name — keep in sync with token-renew-stack.json.
+const RENEW_LAMBDA_NAME = 'pipeline-builder-token-renew';
+// Default 5-field cron (daily at midnight) when neither --cron nor TOKEN_RENEW_SCHEDULE is set.
+const DEFAULT_RENEW_CRON = '0 0 * * *';
+/**
+ * Deploy (or update) the once-a-day token-renewal stack: a scheduled Lambda that
+ * re-mints the platform JWT in this same secret before it expires. Mirrors
+ * setup-events — `aws cloudformation deploy` for the infra, then a direct
+ * UpdateFunctionCode with the self-contained handler compiled alongside this CLI.
+ */
+async function deployRenewSchedule(opts) {
+    const scheduleExpression = toEventBridgeCron(opts.fiveFieldCron); // validates + 15-min guard
+    printSection('Schedule Renewal');
+    printInfo('Parameters', {
+        stack: RENEW_STACK_NAME,
+        schedule: opts.fiveFieldCron,
+        eventbridge: scheduleExpression,
+        renewDays: opts.days,
+    });
+    // Step 1: infra (Lambda gets placeholder code on first create).
+    const templatePath = path.join(__dirname, '../templates/token-renew-stack.json');
+    const cfnArgs = [
+        'cloudformation', 'deploy',
+        '--stack-name', RENEW_STACK_NAME,
+        '--template-file', templatePath,
+        '--parameter-overrides',
+        `PlatformBaseUrl=${opts.platformUrl}`,
+        `PlatformSecretName=${opts.secretName}`,
+        `RenewDays=${opts.days}`,
+        `ScheduleExpression=${scheduleExpression}`,
+        '--capabilities', 'CAPABILITY_NAMED_IAM',
+        '--no-fail-on-empty-changeset',
+        '--region', opts.region,
+    ];
+    if (opts.profile)
+        cfnArgs.push('--profile', opts.profile);
+    execFileSync('aws', cfnArgs, { stdio: 'inherit' });
+    // Step 2: upload the real handler. It's ESM, so the zip entry must be index.mjs
+    // (Handler stays index.handler — nodejs24.x resolves the .mjs extension).
+    const handlerSrc = path.join(__dirname, '../lambda/token-renew-handler.js');
+    if (!fs.existsSync(handlerSrc)) {
+        throw new Error(`Token-renew handler not found at ${handlerSrc} — was the package built?`);
+    }
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'token-renew-'));
+    try {
+        fs.copyFileSync(handlerSrc, path.join(tmpDir, 'index.mjs'));
+        const zipPath = path.join(tmpDir, 'index.zip');
+        execFileSync('zip', ['-j', zipPath, 'index.mjs'], { cwd: tmpDir, stdio: 'pipe' });
+        const lambdaClient = new LambdaClient({ region: opts.region });
+        await lambdaClient.send(new UpdateFunctionCodeCommand({
+            FunctionName: RENEW_LAMBDA_NAME,
+            ZipFile: fs.readFileSync(zipPath),
+        }));
+    }
+    finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+    printSuccess(`Renewal scheduled (${scheduleExpression})`);
+    return scheduleExpression;
+}
 /**
  * Registers the `store-token` command with the CLI program.
  *
@@ -37,6 +107,8 @@ export function storeToken(program) {
         .option('--secret-name <name>', 'Secrets Manager secret name (default: derived from token org)')
         .option('--region <region>', 'AWS region (defaults to AWS_REGION env)')
         .option('--profile <profile>', 'AWS CLI profile', 'default')
+        .option('--cron <expr>', 'Renewal schedule as a 5-field cron (default: TOKEN_RENEW_SCHEDULE env or "0 0 * * *"; min every 15 minutes)')
+        .option('--no-schedule', 'Skip deploying the daily token-renewal stack (it is installed by default)')
         .option('--json', 'Output result as JSON', false)
         .option('--verify-ssl', 'Enable SSL certificate verification')
         .option('--no-verify-ssl', 'Disable SSL certificate verification')
@@ -135,6 +207,21 @@ export function storeToken(program) {
             const description = `Platform JWT token (renew by ${expiresAt})`;
             await upsertSecret(secretName, secretValue, description, { region, profile: options.profile });
             const arn = await getSecretArn(secretName, { region, profile: options.profile });
+            // Install the once-a-day renewal stack so this token never lapses (default
+            // on; opt out with --no-schedule). commander sets options.schedule=false for
+            // --no-schedule, true otherwise.
+            let scheduleExpression;
+            if (options.schedule !== false) {
+                const fiveFieldCron = options.cron || process.env.TOKEN_RENEW_SCHEDULE || DEFAULT_RENEW_CRON;
+                scheduleExpression = await deployRenewSchedule({
+                    platformUrl: client.getBaseUrl(),
+                    secretName,
+                    days,
+                    fiveFieldCron,
+                    region,
+                    profile: options.profile,
+                });
+            }
             if (options.json) {
                 console.log(JSON.stringify({
                     success: true,
@@ -143,6 +230,7 @@ export function storeToken(program) {
                     region,
                     expiresInDays: days,
                     expiresAt,
+                    schedule: scheduleExpression ?? null,
                 }, null, 2));
             }
             else {
@@ -154,6 +242,7 @@ export function storeToken(program) {
                     'Region': region,
                     'Expires In': `${days} days`,
                     'Renew By': expiresAt,
+                    'Auto-Renew': scheduleExpression ? `✓ ${scheduleExpression}` : 'disabled (--no-schedule)',
                     'Status': '✓ Stored',
                 });
                 console.log('');
@@ -161,7 +250,12 @@ export function storeToken(program) {
                 printInfo(`  export PLATFORM_SECRET_NAME=${secretName}`);
                 printInfo('  pipeline-manager synth --id <pipeline-id> --store-tokens');
                 console.log('');
-                printInfo(`Renew before ${expiresAt} with: pipeline-manager store-token --days ${days}`);
+                if (scheduleExpression) {
+                    printInfo(`Auto-renewal is active (${scheduleExpression}); the secret refreshes before ${expiresAt}.`);
+                }
+                else {
+                    printInfo(`Renew before ${expiresAt} with: pipeline-manager store-token --days ${days}`);
+                }
             }
         }
         catch (error) {
@@ -177,4 +271,4 @@ export function storeToken(program) {
         }
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store-token.js","sourceRoot":"","sources":["../../src/commands/store-token.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 { validateNumber } from '../config/cli.constants.js';\nimport { auditLog } from '../utils/audit-log.js';\nimport { decodeTokenPayload } from '../utils/auth-guard.js';\nimport { upsertSecret, getSecretArn } from '../utils/aws-secrets.js';\nimport { createAuthenticatedClientAsync, printCommandHeader, printSslWarning } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printInfo, printKeyValue, printSection, printSuccess } from '../utils/output-utils.js';\nimport { ensurePlatformToken, resolveSecretName } from '../utils/platform-secret.js';\n\n/**\n * Registers the `store-token` command with the CLI program.\n *\n * Generates a long-lived JWT token via the platform API and stores it\n * in AWS Secrets Manager for use by the synth/deploy --store-tokens flag.\n *\n * Requires PLATFORM_TOKEN to be set, or use --email/--password to login inline.\n *\n * @example\n * ```bash\n * pipeline-manager store-token --region us-east-1\n * pipeline-manager store-token --days 90 --region us-east-1\n * pipeline-manager store-token --days 7 --secret-name my-custom-secret --no-verify-ssl\n * pipeline-manager store-token --dry-run\n * pipeline-manager store-token -e admin -p '***' --region us-east-1\n * ```\n */\nexport function storeToken(program: Command): void {\n  program\n    .command('store-token')\n    .description('Generate JWT token and store in AWS Secrets Manager for CDK deployments')\n    .option('-e, --email <email>', 'Login email (skips PLATFORM_TOKEN requirement)')\n    .option('-p, --password <password>', 'Login password (used with --email)')\n    .option('--days <days>', 'Token lifetime in days', '30')\n    .option('--dry-run', 'Show what would be stored without writing to Secrets Manager', false)\n    .option('--secret-name <name>', 'Secrets Manager secret name (default: derived from token org)')\n    .option('--region <region>', 'AWS region (defaults to AWS_REGION env)')\n    .option('--profile <profile>', 'AWS CLI profile', 'default')\n    .option('--json', 'Output result as JSON', false)\n    .option('--verify-ssl', 'Enable SSL certificate verification')\n    .option('--no-verify-ssl', 'Disable SSL certificate verification')\n    .action(async (options) => {\n      const executionId = printCommandHeader('Store Token');\n\n      try {\n        printSslWarning(options.verifySsl);\n\n        const region = options.region || process.env.AWS_REGION || process.env.CDK_DEFAULT_REGION || 'us-east-1';\n\n        const days = validateNumber(options.days, 'days', 1, 365);\n        const expiresInSeconds = days * 24 * 60 * 60;\n\n        // Step 0: log in first when creds are available and no PLATFORM_TOKEN is set\n        // (shared with setup-events). Creds come from --email/--password OR the env\n        // vars PLATFORM_IDENTIFIER/PLATFORM_PASSWORD — the env path lets callers like\n        // `provision --with-events` pass them without putting the password on the\n        // command line (where it would show in plans/logs).\n        await ensurePlatformToken(options);\n\n        // Step 1: Authenticate and generate long-lived token\n        printSection('Generate Token');\n\n        const client = await createAuthenticatedClientAsync(options);\n\n        // Resolve secret name from token's organizationId (unless --secret-name was explicitly set)\n        const secretName = options.secretName || resolveSecretName(process.env.PLATFORM_TOKEN!);\n\n        auditLog('store-token', { executionId, secretName, days: options.days, dryRun: options.dryRun });\n\n        printInfo('Parameters', {\n          secretName,\n          region,\n          days,\n          expiresIn: `${expiresInSeconds}s`,\n          dryRun: options.dryRun,\n        });\n\n        printInfo('Requesting token', { expiresIn: `${expiresInSeconds}s (${days} days)` });\n\n        const tokenResponse = await client.post<Record<string, unknown>>(\n          '/api/user/generate-token',\n          { expiresIn: expiresInSeconds },\n        );\n\n        const tokenData = (tokenResponse as Record<string, unknown>)?.data ?? tokenResponse;\n        const accessToken = (tokenData as Record<string, unknown>)?.accessToken as string | undefined;\n        const refreshToken = (tokenData as Record<string, unknown>)?.refreshToken as string | undefined;\n        const actualExpiresIn = ((tokenData as Record<string, unknown>)?.expiresIn as number) ?? expiresInSeconds;\n\n        if (!accessToken) {\n          throw new Error('Token generation failed — no access token in response');\n        }\n\n        printSuccess(`Token generated (expires in ${actualExpiresIn}s)`);\n\n        const expiresAt = new Date(Date.now() + actualExpiresIn * 1000).toISOString();\n\n        // Schema: { username: orgId, password: JWT, ...metadata }\n        // - username/password fields satisfy CodeBuild's `secretsManagerCredentials`\n        //   (HTTP Basic, sent to pipeline-image-registry's /token endpoint)\n        // - The same JWT is consumed by the plugin-lookup Lambda by reading\n        //   the `password` field\n        // - One Secret per customer account replaces the previous two-secret model\n        // Decode JWT for orgId — it's a stable identifier for the username field;\n        // the actual auth uses the password (JWT) which the token service verifies.\n        // `||` (not `??`): an EMPTY-string organizationId must also fall back. A\n        // sysadmin/system token often carries organizationId=\"\", and CodeBuild\n        // rejects a registry credential whose `username` field is empty with\n        // \"AuthorizationData is malformed, empty field\" — so username must always\n        // be a non-empty value.\n        const payload = decodeTokenPayload(accessToken);\n        const orgId = payload?.organizationId?.trim() || 'unknown-org';\n\n        const secretValue = JSON.stringify({\n          username: orgId,\n          password: accessToken,\n          ...(refreshToken && { refreshToken }),\n          platformUrl: client.getBaseUrl(),\n          expiresIn: actualExpiresIn,\n          expiresAt,\n          createdAt: new Date().toISOString(),\n        });\n\n        // Dry-run: show what would be stored\n        if (options.dryRun) {\n          if (options.json) {\n            console.log(JSON.stringify({\n              success: true,\n              dryRun: true,\n              secretName,\n              region,\n              expiresInDays: days,\n              expiresAt,\n              tokenLength: accessToken.length,\n              hasRefreshToken: !!refreshToken,\n            }, null, 2));\n          } else {\n            console.log('');\n            printSection('Dry Run — No Changes Made');\n            printKeyValue({\n              'Secret Name': secretName,\n              'Region': region,\n              'Expires In': `${days} days`,\n              'Renew By': expiresAt,\n              'Token Length': `${accessToken.length} chars`,\n              'Has Refresh Token': refreshToken ? 'Yes' : 'No',\n            });\n            printSuccess('Dry run complete — no secret was created or updated');\n          }\n          return;\n        }\n\n        // Step 2: Store token in Secrets Manager\n        printSection('Store Token');\n\n        const description = `Platform JWT token (renew by ${expiresAt})`;\n        await upsertSecret(secretName, secretValue, description, { region, profile: options.profile });\n\n        const arn = await getSecretArn(secretName, { region, profile: options.profile });\n\n        if (options.json) {\n          console.log(JSON.stringify({\n            success: true,\n            secretName,\n            secretArn: arn,\n            region,\n            expiresInDays: days,\n            expiresAt,\n          }, null, 2));\n        } else {\n          console.log('');\n          printSection('Token Stored');\n\n          printKeyValue({\n            'Secret Name': secretName,\n            'Secret ARN': arn,\n            'Region': region,\n            'Expires In': `${days} days`,\n            'Renew By': expiresAt,\n            'Status': '✓ Stored',\n          });\n\n          console.log('');\n          printSuccess('Token stored. To use with synth/deploy:');\n          printInfo(`  export PLATFORM_SECRET_NAME=${secretName}`);\n          printInfo('  pipeline-manager synth --id <pipeline-id> --store-tokens');\n          console.log('');\n          printInfo(`Renew before ${expiresAt} with: pipeline-manager store-token --days ${days}`);\n        }\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: {\n            command: 'store-token',\n            executionId,\n            secretName: options.secretName || '(derived from token)',\n          },\n        });\n      }\n    });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store-token.js","sourceRoot":"","sources":["../../src/commands/store-token.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { execFileSync } from 'child_process';\nimport * as fs from 'fs';\nimport { fileURLToPath } from 'node:url';\nimport * as os from 'os';\nimport path from 'path';\nimport { LambdaClient, UpdateFunctionCodeCommand } from '@aws-sdk/client-lambda';\nimport { Command } from 'commander';\nimport { validateNumber } from '../config/cli.constants.js';\nimport { auditLog } from '../utils/audit-log.js';\nimport { decodeTokenPayload } from '../utils/auth-guard.js';\nimport { upsertSecret, getSecretArn } from '../utils/aws-secrets.js';\nimport { createAuthenticatedClientAsync, printCommandHeader, printSslWarning } from '../utils/command-utils.js';\nimport { toEventBridgeCron } from '../utils/cron.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printInfo, printKeyValue, printSection, printSuccess } from '../utils/output-utils.js';\nimport { ensurePlatformToken, resolveSecretName } from '../utils/platform-secret.js';\n\n// ESM has no __dirname; derive it from this module's URL.\nconst __dirname = path.dirname(fileURLToPath(import.meta.url));\n\nconst RENEW_STACK_NAME = 'pipeline-builder-token-renew';\n// CFN-managed Lambda function name — keep in sync with token-renew-stack.json.\nconst RENEW_LAMBDA_NAME = 'pipeline-builder-token-renew';\n// Default 5-field cron (daily at midnight) when neither --cron nor TOKEN_RENEW_SCHEDULE is set.\nconst DEFAULT_RENEW_CRON = '0 0 * * *';\n\n/**\n * Deploy (or update) the once-a-day token-renewal stack: a scheduled Lambda that\n * re-mints the platform JWT in this same secret before it expires. Mirrors\n * setup-events — `aws cloudformation deploy` for the infra, then a direct\n * UpdateFunctionCode with the self-contained handler compiled alongside this CLI.\n */\nasync function deployRenewSchedule(opts: {\n  platformUrl: string;\n  secretName: string;\n  days: number;\n  fiveFieldCron: string;\n  region: string;\n  profile?: string;\n}): Promise<string> {\n  const scheduleExpression = toEventBridgeCron(opts.fiveFieldCron); // validates + 15-min guard\n\n  printSection('Schedule Renewal');\n  printInfo('Parameters', {\n    stack: RENEW_STACK_NAME,\n    schedule: opts.fiveFieldCron,\n    eventbridge: scheduleExpression,\n    renewDays: opts.days,\n  });\n\n  // Step 1: infra (Lambda gets placeholder code on first create).\n  const templatePath = path.join(__dirname, '../templates/token-renew-stack.json');\n  const cfnArgs = [\n    'cloudformation', 'deploy',\n    '--stack-name', RENEW_STACK_NAME,\n    '--template-file', templatePath,\n    '--parameter-overrides',\n    `PlatformBaseUrl=${opts.platformUrl}`,\n    `PlatformSecretName=${opts.secretName}`,\n    `RenewDays=${opts.days}`,\n    `ScheduleExpression=${scheduleExpression}`,\n    '--capabilities', 'CAPABILITY_NAMED_IAM',\n    '--no-fail-on-empty-changeset',\n    '--region', opts.region,\n  ];\n  if (opts.profile) cfnArgs.push('--profile', opts.profile);\n  execFileSync('aws', cfnArgs, { stdio: 'inherit' });\n\n  // Step 2: upload the real handler. It's ESM, so the zip entry must be index.mjs\n  // (Handler stays index.handler — nodejs24.x resolves the .mjs extension).\n  const handlerSrc = path.join(__dirname, '../lambda/token-renew-handler.js');\n  if (!fs.existsSync(handlerSrc)) {\n    throw new Error(`Token-renew handler not found at ${handlerSrc} — was the package built?`);\n  }\n  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'token-renew-'));\n  try {\n    fs.copyFileSync(handlerSrc, path.join(tmpDir, 'index.mjs'));\n    const zipPath = path.join(tmpDir, 'index.zip');\n    execFileSync('zip', ['-j', zipPath, 'index.mjs'], { cwd: tmpDir, stdio: 'pipe' });\n\n    const lambdaClient = new LambdaClient({ region: opts.region });\n    await lambdaClient.send(new UpdateFunctionCodeCommand({\n      FunctionName: RENEW_LAMBDA_NAME,\n      ZipFile: fs.readFileSync(zipPath),\n    }));\n  } finally {\n    fs.rmSync(tmpDir, { recursive: true, force: true });\n  }\n\n  printSuccess(`Renewal scheduled (${scheduleExpression})`);\n  return scheduleExpression;\n}\n\n/**\n * Registers the `store-token` command with the CLI program.\n *\n * Generates a long-lived JWT token via the platform API and stores it\n * in AWS Secrets Manager for use by the synth/deploy --store-tokens flag.\n *\n * Requires PLATFORM_TOKEN to be set, or use --email/--password to login inline.\n *\n * @example\n * ```bash\n * pipeline-manager store-token --region us-east-1\n * pipeline-manager store-token --days 90 --region us-east-1\n * pipeline-manager store-token --days 7 --secret-name my-custom-secret --no-verify-ssl\n * pipeline-manager store-token --dry-run\n * pipeline-manager store-token -e admin -p '***' --region us-east-1\n * ```\n */\nexport function storeToken(program: Command): void {\n  program\n    .command('store-token')\n    .description('Generate JWT token and store in AWS Secrets Manager for CDK deployments')\n    .option('-e, --email <email>', 'Login email (skips PLATFORM_TOKEN requirement)')\n    .option('-p, --password <password>', 'Login password (used with --email)')\n    .option('--days <days>', 'Token lifetime in days', '30')\n    .option('--dry-run', 'Show what would be stored without writing to Secrets Manager', false)\n    .option('--secret-name <name>', 'Secrets Manager secret name (default: derived from token org)')\n    .option('--region <region>', 'AWS region (defaults to AWS_REGION env)')\n    .option('--profile <profile>', 'AWS CLI profile', 'default')\n    .option('--cron <expr>', 'Renewal schedule as a 5-field cron (default: TOKEN_RENEW_SCHEDULE env or \"0 0 * * *\"; min every 15 minutes)')\n    .option('--no-schedule', 'Skip deploying the daily token-renewal stack (it is installed by default)')\n    .option('--json', 'Output result as JSON', false)\n    .option('--verify-ssl', 'Enable SSL certificate verification')\n    .option('--no-verify-ssl', 'Disable SSL certificate verification')\n    .action(async (options) => {\n      const executionId = printCommandHeader('Store Token');\n\n      try {\n        printSslWarning(options.verifySsl);\n\n        const region = options.region || process.env.AWS_REGION || process.env.CDK_DEFAULT_REGION || 'us-east-1';\n\n        const days = validateNumber(options.days, 'days', 1, 365);\n        const expiresInSeconds = days * 24 * 60 * 60;\n\n        // Step 0: log in first when creds are available and no PLATFORM_TOKEN is set\n        // (shared with setup-events). Creds come from --email/--password OR the env\n        // vars PLATFORM_IDENTIFIER/PLATFORM_PASSWORD — the env path lets callers like\n        // `provision --with-events` pass them without putting the password on the\n        // command line (where it would show in plans/logs).\n        await ensurePlatformToken(options);\n\n        // Step 1: Authenticate and generate long-lived token\n        printSection('Generate Token');\n\n        const client = await createAuthenticatedClientAsync(options);\n\n        // Resolve secret name from token's organizationId (unless --secret-name was explicitly set)\n        const secretName = options.secretName || resolveSecretName(process.env.PLATFORM_TOKEN!);\n\n        auditLog('store-token', { executionId, secretName, days: options.days, dryRun: options.dryRun });\n\n        printInfo('Parameters', {\n          secretName,\n          region,\n          days,\n          expiresIn: `${expiresInSeconds}s`,\n          dryRun: options.dryRun,\n        });\n\n        printInfo('Requesting token', { expiresIn: `${expiresInSeconds}s (${days} days)` });\n\n        const tokenResponse = await client.post<Record<string, unknown>>(\n          '/api/user/generate-token',\n          { expiresIn: expiresInSeconds },\n        );\n\n        const tokenData = (tokenResponse as Record<string, unknown>)?.data ?? tokenResponse;\n        const accessToken = (tokenData as Record<string, unknown>)?.accessToken as string | undefined;\n        const refreshToken = (tokenData as Record<string, unknown>)?.refreshToken as string | undefined;\n        const actualExpiresIn = ((tokenData as Record<string, unknown>)?.expiresIn as number) ?? expiresInSeconds;\n\n        if (!accessToken) {\n          throw new Error('Token generation failed — no access token in response');\n        }\n\n        printSuccess(`Token generated (expires in ${actualExpiresIn}s)`);\n\n        const expiresAt = new Date(Date.now() + actualExpiresIn * 1000).toISOString();\n\n        // Schema: { username: orgId, password: JWT, ...metadata }\n        // - username/password fields satisfy CodeBuild's `secretsManagerCredentials`\n        //   (HTTP Basic, sent to pipeline-image-registry's /token endpoint)\n        // - The same JWT is consumed by the plugin-lookup Lambda by reading\n        //   the `password` field\n        // - One Secret per customer account replaces the previous two-secret model\n        // Decode JWT for orgId — it's a stable identifier for the username field;\n        // the actual auth uses the password (JWT) which the token service verifies.\n        // `||` (not `??`): an EMPTY-string organizationId must also fall back. A\n        // sysadmin/system token often carries organizationId=\"\", and CodeBuild\n        // rejects a registry credential whose `username` field is empty with\n        // \"AuthorizationData is malformed, empty field\" — so username must always\n        // be a non-empty value.\n        const payload = decodeTokenPayload(accessToken);\n        const orgId = payload?.organizationId?.trim() || 'unknown-org';\n\n        const secretValue = JSON.stringify({\n          username: orgId,\n          password: accessToken,\n          ...(refreshToken && { refreshToken }),\n          platformUrl: client.getBaseUrl(),\n          expiresIn: actualExpiresIn,\n          expiresAt,\n          createdAt: new Date().toISOString(),\n        });\n\n        // Dry-run: show what would be stored\n        if (options.dryRun) {\n          if (options.json) {\n            console.log(JSON.stringify({\n              success: true,\n              dryRun: true,\n              secretName,\n              region,\n              expiresInDays: days,\n              expiresAt,\n              tokenLength: accessToken.length,\n              hasRefreshToken: !!refreshToken,\n            }, null, 2));\n          } else {\n            console.log('');\n            printSection('Dry Run — No Changes Made');\n            printKeyValue({\n              'Secret Name': secretName,\n              'Region': region,\n              'Expires In': `${days} days`,\n              'Renew By': expiresAt,\n              'Token Length': `${accessToken.length} chars`,\n              'Has Refresh Token': refreshToken ? 'Yes' : 'No',\n            });\n            printSuccess('Dry run complete — no secret was created or updated');\n          }\n          return;\n        }\n\n        // Step 2: Store token in Secrets Manager\n        printSection('Store Token');\n\n        const description = `Platform JWT token (renew by ${expiresAt})`;\n        await upsertSecret(secretName, secretValue, description, { region, profile: options.profile });\n\n        const arn = await getSecretArn(secretName, { region, profile: options.profile });\n\n        // Install the once-a-day renewal stack so this token never lapses (default\n        // on; opt out with --no-schedule). commander sets options.schedule=false for\n        // --no-schedule, true otherwise.\n        let scheduleExpression: string | undefined;\n        if (options.schedule !== false) {\n          const fiveFieldCron = options.cron || process.env.TOKEN_RENEW_SCHEDULE || DEFAULT_RENEW_CRON;\n          scheduleExpression = await deployRenewSchedule({\n            platformUrl: client.getBaseUrl(),\n            secretName,\n            days,\n            fiveFieldCron,\n            region,\n            profile: options.profile,\n          });\n        }\n\n        if (options.json) {\n          console.log(JSON.stringify({\n            success: true,\n            secretName,\n            secretArn: arn,\n            region,\n            expiresInDays: days,\n            expiresAt,\n            schedule: scheduleExpression ?? null,\n          }, null, 2));\n        } else {\n          console.log('');\n          printSection('Token Stored');\n\n          printKeyValue({\n            'Secret Name': secretName,\n            'Secret ARN': arn,\n            'Region': region,\n            'Expires In': `${days} days`,\n            'Renew By': expiresAt,\n            'Auto-Renew': scheduleExpression ? `✓ ${scheduleExpression}` : 'disabled (--no-schedule)',\n            'Status': '✓ Stored',\n          });\n\n          console.log('');\n          printSuccess('Token stored. To use with synth/deploy:');\n          printInfo(`  export PLATFORM_SECRET_NAME=${secretName}`);\n          printInfo('  pipeline-manager synth --id <pipeline-id> --store-tokens');\n          console.log('');\n          if (scheduleExpression) {\n            printInfo(`Auto-renewal is active (${scheduleExpression}); the secret refreshes before ${expiresAt}.`);\n          } else {\n            printInfo(`Renew before ${expiresAt} with: pipeline-manager store-token --days ${days}`);\n          }\n        }\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: {\n            command: 'store-token',\n            executionId,\n            secretName: options.secretName || '(derived from token)',\n          },\n        });\n      }\n    });\n}\n"]}

package/dist/lambda/token-renew-handler.d.ts

@@ -0,0 +1,2 @@
+export declare const handler: () => Promise<void>;
+//# sourceMappingURL=token-renew-handler.d.ts.map

package/dist/lambda/token-renew-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-renew-handler.d.ts","sourceRoot":"","sources":["../../src/lambda/token-renew-handler.ts"],"names":[],"mappings":"AA4FA,eAAO,MAAM,OAAO,QAAa,OAAO,CAAC,IAAI,CAqD5C,CAAC"}

package/dist/lambda/token-renew-handler.js

@@ -0,0 +1,126 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Lambda handler that re-mints the platform JWT in Secrets Manager so it never
+ * lapses. Deployed + scheduled by `pipeline-manager store-token` (default once a
+ * day). Self-contained on purpose — only `@aws-sdk/client-secrets-manager` (which
+ * the Lambda Node runtime provides) and node built-ins — so it can be zipped and
+ * uploaded as a single file with no bundling.
+ *
+ * Each run: read the secret's current JWT → ask the platform for a fresh
+ * long-lived token (`/api/user/generate-token`, falling back to `/auth/refresh`
+ * if the current token has expired) → write it back in store-token's schema.
+ * The new token is validated before it overwrites the still-valid one.
+ *
+ * Env: PLATFORM_SECRET_NAME, PLATFORM_BASE_URL, RENEW_DAYS (default 30).
+ */
+import { request as httpsRequest } from 'node:https';
+import { SecretsManagerClient, GetSecretValueCommand, PutSecretValueCommand, } from '@aws-sdk/client-secrets-manager';
+/** Minimal JSON POST. Honours NODE_TLS_REJECT_UNAUTHORIZED via the node runtime. */
+function postJson(url, body, bearer) {
+    const u = new URL(url);
+    const payload = JSON.stringify(body);
+    return new Promise((resolve, reject) => {
+        const req = httpsRequest({
+            method: 'POST',
+            hostname: u.hostname,
+            port: u.port || 443,
+            path: u.pathname + u.search,
+            headers: {
+                'content-type': 'application/json',
+                'content-length': Buffer.byteLength(payload),
+                ...(bearer ? { authorization: `Bearer ${bearer}` } : {}),
+            },
+            timeout: 20_000,
+        }, (res) => {
+            let data = '';
+            res.on('data', (c) => (data += c));
+            res.on('end', () => {
+                let json = undefined;
+                try {
+                    json = data ? JSON.parse(data) : undefined;
+                }
+                catch { /* leave undefined */ }
+                resolve({ status: res.statusCode ?? 0, json });
+            });
+        });
+        req.on('error', reject);
+        req.on('timeout', () => req.destroy(new Error('request timed out')));
+        req.write(payload);
+        req.end();
+    });
+}
+/** Unwrap the platform's `{ success, data: {...} }` envelope (or a bare body). */
+function unwrap(json) {
+    const j = json;
+    return (j?.data ?? j);
+}
+/** Basic JWT sanity: decodes, must carry an org and a future `exp`. */
+function looksValid(jwt) {
+    const parts = jwt.split('.');
+    if (parts.length !== 3)
+        return false;
+    try {
+        const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf-8'));
+        if (!payload.exp || payload.exp * 1000 <= Date.now())
+            return false;
+        return typeof payload.organizationId === 'string';
+    }
+    catch {
+        return false;
+    }
+}
+export const handler = async () => {
+    const secretName = required('PLATFORM_SECRET_NAME');
+    const platformUrl = required('PLATFORM_BASE_URL').replace(/\/$/, '');
+    const days = parseInt(process.env.RENEW_DAYS || '30', 10);
+    const expiresIn = days * 24 * 60 * 60;
+    const region = process.env.AWS_REGION;
+    const sm = new SecretsManagerClient({ region });
+    const current = await sm.send(new GetSecretValueCommand({ SecretId: secretName }));
+    if (!current.SecretString)
+        throw new Error(`Secret "${secretName}" is empty`);
+    const secret = JSON.parse(current.SecretString);
+    if (!secret.password)
+        throw new Error(`Secret "${secretName}" missing password (JWT)`);
+    // 1. Try generate-token with the current JWT.
+    let bearer = secret.password;
+    let res = await postJson(`${platformUrl}/api/user/generate-token`, { expiresIn }, bearer);
+    // 2. If unauthorized, refresh the access token first, then retry.
+    if (res.status === 401 && secret.refreshToken) {
+        const refreshed = unwrap((await postJson(`${platformUrl}/auth/refresh`, { refreshToken: secret.refreshToken })).json);
+        if (refreshed.accessToken) {
+            bearer = refreshed.accessToken;
+            res = await postJson(`${platformUrl}/api/user/generate-token`, { expiresIn }, bearer);
+        }
+    }
+    if (res.status < 200 || res.status >= 300) {
+        throw new Error(`generate-token failed (HTTP ${res.status})`);
+    }
+    const token = unwrap(res.json);
+    if (!token.accessToken || !looksValid(token.accessToken)) {
+        // Do NOT overwrite a still-valid secret with a bad response.
+        throw new Error('generate-token returned no usable access token; leaving existing secret untouched');
+    }
+    // 3. Write the renewed secret in store-token's schema.
+    const actualExpiresIn = token.expiresIn ?? expiresIn;
+    const next = {
+        username: secret.username,
+        password: token.accessToken,
+        ...(token.refreshToken ? { refreshToken: token.refreshToken } : (secret.refreshToken ? { refreshToken: secret.refreshToken } : {})),
+        platformUrl: secret.platformUrl ?? platformUrl,
+        expiresIn: actualExpiresIn,
+        expiresAt: new Date(Date.now() + actualExpiresIn * 1000).toISOString(),
+        createdAt: new Date().toISOString(),
+    };
+    await sm.send(new PutSecretValueCommand({ SecretId: secretName, SecretString: JSON.stringify(next) }));
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify({ level: 'INFO', msg: 'platform token renewed', secretName, expiresAt: next.expiresAt }));
+};
+function required(name) {
+    const v = process.env[name];
+    if (!v)
+        throw new Error(`${name} environment variable is required`);
+    return v;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token-renew-handler.js","sourceRoot":"","sources":["../../src/lambda/token-renew-handler.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Lambda handler that re-mints the platform JWT in Secrets Manager so it never\n * lapses. Deployed + scheduled by `pipeline-manager store-token` (default once a\n * day). Self-contained on purpose — only `@aws-sdk/client-secrets-manager` (which\n * the Lambda Node runtime provides) and node built-ins — so it can be zipped and\n * uploaded as a single file with no bundling.\n *\n * Each run: read the secret's current JWT → ask the platform for a fresh\n * long-lived token (`/api/user/generate-token`, falling back to `/auth/refresh`\n * if the current token has expired) → write it back in store-token's schema.\n * The new token is validated before it overwrites the still-valid one.\n *\n * Env: PLATFORM_SECRET_NAME, PLATFORM_BASE_URL, RENEW_DAYS (default 30).\n */\nimport { request as httpsRequest } from 'node:https';\nimport {\n  SecretsManagerClient,\n  GetSecretValueCommand,\n  PutSecretValueCommand,\n} from '@aws-sdk/client-secrets-manager';\n\ninterface SecretPayload {\n  username?: string;\n  password?: string;       // the platform JWT\n  refreshToken?: string;\n  platformUrl?: string;\n  [k: string]: unknown;\n}\n\ninterface TokenResponse {\n  accessToken?: string;\n  refreshToken?: string;\n  expiresIn?: number;\n}\n\n/** Minimal JSON POST. Honours NODE_TLS_REJECT_UNAUTHORIZED via the node runtime. */\nfunction postJson(url: string, body: unknown, bearer?: string): Promise<{ status: number; json: unknown }> {\n  const u = new URL(url);\n  const payload = JSON.stringify(body);\n  return new Promise((resolve, reject) => {\n    const req = httpsRequest(\n      {\n        method: 'POST',\n        hostname: u.hostname,\n        port: u.port || 443,\n        path: u.pathname + u.search,\n        headers: {\n          'content-type': 'application/json',\n          'content-length': Buffer.byteLength(payload),\n          ...(bearer ? { authorization: `Bearer ${bearer}` } : {}),\n        },\n        timeout: 20_000,\n      },\n      (res) => {\n        let data = '';\n        res.on('data', (c) => (data += c));\n        res.on('end', () => {\n          let json: unknown = undefined;\n          try { json = data ? JSON.parse(data) : undefined; } catch { /* leave undefined */ }\n          resolve({ status: res.statusCode ?? 0, json });\n        });\n      },\n    );\n    req.on('error', reject);\n    req.on('timeout', () => req.destroy(new Error('request timed out')));\n    req.write(payload);\n    req.end();\n  });\n}\n\n/** Unwrap the platform's `{ success, data: {...} }` envelope (or a bare body). */\nfunction unwrap<T>(json: unknown): T {\n  const j = json as { data?: T } | T;\n  return ((j as { data?: T })?.data ?? j) as T;\n}\n\n/** Basic JWT sanity: decodes, must carry an org and a future `exp`. */\nfunction looksValid(jwt: string): boolean {\n  const parts = jwt.split('.');\n  if (parts.length !== 3) return false;\n  try {\n    const payload = JSON.parse(Buffer.from(parts[1]!, 'base64url').toString('utf-8')) as { exp?: number; organizationId?: string };\n    if (!payload.exp || payload.exp * 1000 <= Date.now()) return false;\n    return typeof payload.organizationId === 'string';\n  } catch {\n    return false;\n  }\n}\n\nexport const handler = async (): Promise<void> => {\n  const secretName = required('PLATFORM_SECRET_NAME');\n  const platformUrl = required('PLATFORM_BASE_URL').replace(/\\/$/, '');\n  const days = parseInt(process.env.RENEW_DAYS || '30', 10);\n  const expiresIn = days * 24 * 60 * 60;\n  const region = process.env.AWS_REGION;\n\n  const sm = new SecretsManagerClient({ region });\n  const current = await sm.send(new GetSecretValueCommand({ SecretId: secretName }));\n  if (!current.SecretString) throw new Error(`Secret \"${secretName}\" is empty`);\n  const secret = JSON.parse(current.SecretString) as SecretPayload;\n  if (!secret.password) throw new Error(`Secret \"${secretName}\" missing password (JWT)`);\n\n  // 1. Try generate-token with the current JWT.\n  let bearer = secret.password;\n  let res = await postJson(`${platformUrl}/api/user/generate-token`, { expiresIn }, bearer);\n\n  // 2. If unauthorized, refresh the access token first, then retry.\n  if (res.status === 401 && secret.refreshToken) {\n    const refreshed = unwrap<TokenResponse>(\n      (await postJson(`${platformUrl}/auth/refresh`, { refreshToken: secret.refreshToken })).json,\n    );\n    if (refreshed.accessToken) {\n      bearer = refreshed.accessToken;\n      res = await postJson(`${platformUrl}/api/user/generate-token`, { expiresIn }, bearer);\n    }\n  }\n\n  if (res.status < 200 || res.status >= 300) {\n    throw new Error(`generate-token failed (HTTP ${res.status})`);\n  }\n\n  const token = unwrap<TokenResponse>(res.json);\n  if (!token.accessToken || !looksValid(token.accessToken)) {\n    // Do NOT overwrite a still-valid secret with a bad response.\n    throw new Error('generate-token returned no usable access token; leaving existing secret untouched');\n  }\n\n  // 3. Write the renewed secret in store-token's schema.\n  const actualExpiresIn = token.expiresIn ?? expiresIn;\n  const next: SecretPayload = {\n    username: secret.username,\n    password: token.accessToken,\n    ...(token.refreshToken ? { refreshToken: token.refreshToken } : (secret.refreshToken ? { refreshToken: secret.refreshToken } : {})),\n    platformUrl: secret.platformUrl ?? platformUrl,\n    expiresIn: actualExpiresIn,\n    expiresAt: new Date(Date.now() + actualExpiresIn * 1000).toISOString(),\n    createdAt: new Date().toISOString(),\n  };\n  await sm.send(new PutSecretValueCommand({ SecretId: secretName, SecretString: JSON.stringify(next) }));\n\n  // eslint-disable-next-line no-console\n  console.log(JSON.stringify({ level: 'INFO', msg: 'platform token renewed', secretName, expiresAt: next.expiresAt }));\n};\n\nfunction required(name: string): string {\n  const v = process.env[name];\n  if (!v) throw new Error(`${name} environment variable is required`);\n  return v;\n}\n"]}

package/dist/templates/token-renew-stack.json

@@ -0,0 +1,103 @@
+{
+  "AWSTemplateFormatVersion": "2010-09-09",
+  "Description": "Pipeline Builder platform-token renewal — a scheduled Lambda that re-mints the platform JWT in Secrets Manager before it expires, so CodeBuild/Lambda credentials never lapse. Lambda code is deployed separately via pipeline-manager store-token.",
+  "Parameters": {
+    "PlatformBaseUrl": {
+      "Type": "String",
+      "Description": "Base URL of the platform (e.g. https://app.example.com)"
+    },
+    "PlatformSecretName": {
+      "Type": "String",
+      "Description": "Secrets Manager secret name holding the platform JWT (e.g. pipeline-builder/{orgId}/platform)"
+    },
+    "RenewDays": {
+      "Type": "Number",
+      "Default": 30,
+      "MinValue": 1,
+      "MaxValue": 365,
+      "Description": "Lifetime in days requested for each renewed token"
+    },
+    "ScheduleExpression": {
+      "Type": "String",
+      "Default": "cron(0 0 * * ? *)",
+      "Description": "EventBridge schedule expression for the renewal (default: daily at 00:00 UTC)"
+    }
+  },
+  "Resources": {
+    "LambdaRole": {
+      "Type": "AWS::IAM::Role",
+      "Properties": {
+        "RoleName": "pipeline-builder-token-renew",
+        "AssumeRolePolicyDocument": {
+          "Version": "2012-10-17",
+          "Statement": [{
+            "Effect": "Allow",
+            "Principal": { "Service": "lambda.amazonaws.com" },
+            "Action": "sts:AssumeRole"
+          }]
+        },
+        "ManagedPolicyArns": [
+          "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
+        ],
+        "Policies": [{
+          "PolicyName": "token-renew",
+          "PolicyDocument": {
+            "Statement": [{
+              "Effect": "Allow",
+              "Action": ["secretsmanager:GetSecretValue", "secretsmanager:PutSecretValue"],
+              "Resource": { "Fn::Sub": "arn:aws:secretsmanager:${AWS::Region}:${AWS::AccountId}:secret:pipeline-builder/*/platform-*" }
+            }]
+          }
+        }]
+      }
+    },
+    "TokenRenewHandler": {
+      "Type": "AWS::Lambda::Function",
+      "Properties": {
+        "FunctionName": "pipeline-builder-token-renew",
+        "Runtime": "nodejs24.x",
+        "Handler": "index.handler",
+        "Code": {
+          "ZipFile": "exports.handler=async()=>{console.log('Placeholder handler — run pipeline-manager store-token to deploy real code');return{statusCode:200}}"
+        },
+        "Role": { "Fn::GetAtt": ["LambdaRole", "Arn"] },
+        "Timeout": 60,
+        "MemorySize": 256,
+        "Environment": {
+          "Variables": {
+            "PLATFORM_BASE_URL": { "Ref": "PlatformBaseUrl" },
+            "PLATFORM_SECRET_NAME": { "Ref": "PlatformSecretName" },
+            "RENEW_DAYS": { "Ref": "RenewDays" }
+          }
+        }
+      }
+    },
+    "ScheduleRule": {
+      "Type": "AWS::Events::Rule",
+      "Properties": {
+        "Name": "pipeline-builder-token-renew",
+        "Description": "Scheduled platform-token renewal",
+        "State": "ENABLED",
+        "ScheduleExpression": { "Ref": "ScheduleExpression" },
+        "Targets": [{
+          "Id": "token-renew-lambda",
+          "Arn": { "Fn::GetAtt": ["TokenRenewHandler", "Arn"] }
+        }]
+      }
+    },
+    "InvokePermission": {
+      "Type": "AWS::Lambda::Permission",
+      "Properties": {
+        "FunctionName": { "Ref": "TokenRenewHandler" },
+        "Action": "lambda:InvokeFunction",
+        "Principal": "events.amazonaws.com",
+        "SourceArn": { "Fn::GetAtt": ["ScheduleRule", "Arn"] }
+      }
+    }
+  },
+  "Outputs": {
+    "LambdaFunctionArn": { "Value": { "Fn::GetAtt": ["TokenRenewHandler", "Arn"] } },
+    "ScheduleRuleName": { "Value": { "Ref": "ScheduleRule" } },
+    "ScheduleExpression": { "Value": { "Ref": "ScheduleExpression" } }
+  }
+}

package/dist/utils/cron.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Convert a standard 5-field cron expression into an AWS EventBridge cron
+ * expression, and guard against schedules that fire more often than every
+ * 15 minutes.
+ *
+ * Standard cron:    `minute hour day-of-month month day-of-week`
+ * EventBridge cron: `cron(minute hour day-of-month month day-of-week year)`
+ *
+ * The non-obvious differences EventBridge imposes:
+ *  - a 6th field (year), which we always set to `*`;
+ *  - day-of-month and day-of-week may NOT both be `*` — exactly one must be `?`;
+ *  - day-of-week is 1–7 with 1 = Sunday, whereas standard cron is 0–6 (or 7)
+ *    with 0/7 = Sunday — so numeric day-of-week values must be remapped.
+ */
+/** Minimum allowed spacing between fires, in minutes. */
+export declare const MIN_SCHEDULE_INTERVAL_MIN = 15;
+/**
+ * Throw if `fiveField` would fire more often than every {@link MIN_SCHEDULE_INTERVAL_MIN}
+ * minutes. Conservative: the smallest cyclic gap in the minute field is the worst-case
+ * spacing (it's only ever larger once the hour/day fields restrict things further).
+ */
+export declare function assertScheduleInterval(fiveField: string): void;
+/**
+ * Convert a validated 5-field cron expression to an AWS EventBridge `cron(...)`
+ * expression. Also enforces the 15-minute guard.
+ */
+export declare function toEventBridgeCron(fiveField: string): string;
+//# sourceMappingURL=cron.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cron.d.ts","sourceRoot":"","sources":["../../src/utils/cron.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AAEH,yDAAyD;AACzD,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAgC5C;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAuB9D;AAaD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAmB3D"}

package/dist/utils/cron.js

@@ -0,0 +1,115 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Convert a standard 5-field cron expression into an AWS EventBridge cron
+ * expression, and guard against schedules that fire more often than every
+ * 15 minutes.
+ *
+ * Standard cron:    `minute hour day-of-month month day-of-week`
+ * EventBridge cron: `cron(minute hour day-of-month month day-of-week year)`
+ *
+ * The non-obvious differences EventBridge imposes:
+ *  - a 6th field (year), which we always set to `*`;
+ *  - day-of-month and day-of-week may NOT both be `*` — exactly one must be `?`;
+ *  - day-of-week is 1–7 with 1 = Sunday, whereas standard cron is 0–6 (or 7)
+ *    with 0/7 = Sunday — so numeric day-of-week values must be remapped.
+ */
+/** Minimum allowed spacing between fires, in minutes. */
+export const MIN_SCHEDULE_INTERVAL_MIN = 15;
+/** Expand a cron minute field (wildcard, step "/n", ranges "a-b", lists "a,b") to the sorted set of minutes it fires on. */
+function expandMinuteField(field) {
+    const out = new Set();
+    for (const part of field.split(',')) {
+        const slash = part.split('/');
+        const rangePart = slash[0] ?? '';
+        const stepPart = slash[1];
+        const step = stepPart !== undefined ? parseInt(stepPart, 10) : 1;
+        if (stepPart !== undefined && (!Number.isInteger(step) || step < 1)) {
+            throw new Error(`Invalid step in minute field: "${part}"`);
+        }
+        let lo;
+        let hi;
+        if (rangePart === '*') {
+            lo = 0;
+            hi = 59;
+        }
+        else if (rangePart.includes('-')) {
+            const ends = rangePart.split('-');
+            lo = parseInt(ends[0] ?? '', 10);
+            hi = parseInt(ends[1] ?? '', 10);
+        }
+        else {
+            lo = hi = parseInt(rangePart, 10);
+        }
+        if (!Number.isInteger(lo) || !Number.isInteger(hi) || lo < 0 || hi > 59 || lo > hi) {
+            throw new Error(`Invalid minute field: "${part}"`);
+        }
+        for (let m = lo; m <= hi; m += step)
+            out.add(m);
+    }
+    return [...out].sort((a, b) => a - b);
+}
+/**
+ * Throw if `fiveField` would fire more often than every {@link MIN_SCHEDULE_INTERVAL_MIN}
+ * minutes. Conservative: the smallest cyclic gap in the minute field is the worst-case
+ * spacing (it's only ever larger once the hour/day fields restrict things further).
+ */
+export function assertScheduleInterval(fiveField) {
+    const parts = fiveField.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error(`Schedule must be a 5-field cron ("minute hour day-of-month month day-of-week"), got: "${fiveField}"`);
+    }
+    const minutes = expandMinuteField(parts[0]);
+    if (minutes.length === 0)
+        throw new Error(`Minute field matches nothing: "${parts[0]}"`);
+    // Smallest cyclic gap across the hour boundary (e.g. {0,50} → gaps 50 and 10).
+    let minGap = 60;
+    if (minutes.length > 1) {
+        for (let i = 0; i < minutes.length; i++) {
+            const cur = minutes[i];
+            const next = minutes[(i + 1) % minutes.length];
+            const gap = (next - cur + 60) % 60 || 60;
+            minGap = Math.min(minGap, gap);
+        }
+    }
+    if (minGap < MIN_SCHEDULE_INTERVAL_MIN) {
+        throw new Error(`Schedule "${fiveField}" fires every ${minGap} minute(s); the minimum is ${MIN_SCHEDULE_INTERVAL_MIN}. ` +
+            `Use a sparser schedule (e.g. "0 0 * * *" for daily, "*/15 * * * *" for the densest allowed).`);
+    }
+}
+/** Remap a standard cron day-of-week token (0–7, 0/7=Sun) to EventBridge (1–7, 1=Sun). Passes through names and `*`/`?`. */
+function remapDayOfWeek(field) {
+    if (field === '*' || field === '?')
+        return field;
+    // Token may contain lists/ranges/steps of numbers and/or 3-letter names.
+    return field.replace(/\d+/g, (n) => {
+        const v = parseInt(n, 10);
+        if (v < 0 || v > 7)
+            throw new Error(`Invalid day-of-week value: "${n}"`);
+        return String((v % 7) + 1); // 0→1 (Sun), 6→7 (Sat), 7→1 (Sun)
+    });
+}
+/**
+ * Convert a validated 5-field cron expression to an AWS EventBridge `cron(...)`
+ * expression. Also enforces the 15-minute guard.
+ */
+export function toEventBridgeCron(fiveField) {
+    assertScheduleInterval(fiveField); // also validates the 5-field shape
+    const f = fiveField.trim().split(/\s+/);
+    const [minute, hour, domRaw, month, dowRaw] = [f[0], f[1], f[2], f[3], f[4]];
+    let dom = domRaw;
+    let dow = remapDayOfWeek(dowRaw);
+    // EventBridge: exactly one of day-of-month / day-of-week must be `?`.
+    if (dom === '*' && dow === '*') {
+        dow = '?'; // unrestricted both → pin day-of-week to ?
+    }
+    else if (dom !== '*' && dow === '*') {
+        dow = '?'; // specific day-of-month → day-of-week must be ?
+    }
+    else if (dom === '*' && dow !== '*') {
+        dom = '?'; // specific day-of-week → day-of-month must be ?
+    }
+    // (both specific is left as-is; EventBridge rejects it, surfacing a clear error)
+    return `cron(${minute} ${hour} ${dom} ${month} ${dow} *)`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cron.js","sourceRoot":"","sources":["../../src/utils/cron.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Convert a standard 5-field cron expression into an AWS EventBridge cron\n * expression, and guard against schedules that fire more often than every\n * 15 minutes.\n *\n * Standard cron:    `minute hour day-of-month month day-of-week`\n * EventBridge cron: `cron(minute hour day-of-month month day-of-week year)`\n *\n * The non-obvious differences EventBridge imposes:\n *  - a 6th field (year), which we always set to `*`;\n *  - day-of-month and day-of-week may NOT both be `*` — exactly one must be `?`;\n *  - day-of-week is 1–7 with 1 = Sunday, whereas standard cron is 0–6 (or 7)\n *    with 0/7 = Sunday — so numeric day-of-week values must be remapped.\n */\n\n/** Minimum allowed spacing between fires, in minutes. */\nexport const MIN_SCHEDULE_INTERVAL_MIN = 15;\n\n/** Expand a cron minute field (wildcard, step \"/n\", ranges \"a-b\", lists \"a,b\") to the sorted set of minutes it fires on. */\nfunction expandMinuteField(field: string): number[] {\n  const out = new Set<number>();\n  for (const part of field.split(',')) {\n    const slash = part.split('/');\n    const rangePart = slash[0] ?? '';\n    const stepPart = slash[1];\n    const step = stepPart !== undefined ? parseInt(stepPart, 10) : 1;\n    if (stepPart !== undefined && (!Number.isInteger(step) || step < 1)) {\n      throw new Error(`Invalid step in minute field: \"${part}\"`);\n    }\n    let lo: number;\n    let hi: number;\n    if (rangePart === '*') {\n      lo = 0; hi = 59;\n    } else if (rangePart.includes('-')) {\n      const ends = rangePart.split('-');\n      lo = parseInt(ends[0] ?? '', 10);\n      hi = parseInt(ends[1] ?? '', 10);\n    } else {\n      lo = hi = parseInt(rangePart, 10);\n    }\n    if (!Number.isInteger(lo) || !Number.isInteger(hi) || lo < 0 || hi > 59 || lo > hi) {\n      throw new Error(`Invalid minute field: \"${part}\"`);\n    }\n    for (let m = lo; m <= hi; m += step) out.add(m);\n  }\n  return [...out].sort((a, b) => a - b);\n}\n\n/**\n * Throw if `fiveField` would fire more often than every {@link MIN_SCHEDULE_INTERVAL_MIN}\n * minutes. Conservative: the smallest cyclic gap in the minute field is the worst-case\n * spacing (it's only ever larger once the hour/day fields restrict things further).\n */\nexport function assertScheduleInterval(fiveField: string): void {\n  const parts = fiveField.trim().split(/\\s+/);\n  if (parts.length !== 5) {\n    throw new Error(`Schedule must be a 5-field cron (\"minute hour day-of-month month day-of-week\"), got: \"${fiveField}\"`);\n  }\n  const minutes = expandMinuteField(parts[0]!);\n  if (minutes.length === 0) throw new Error(`Minute field matches nothing: \"${parts[0]}\"`);\n  // Smallest cyclic gap across the hour boundary (e.g. {0,50} → gaps 50 and 10).\n  let minGap = 60;\n  if (minutes.length > 1) {\n    for (let i = 0; i < minutes.length; i++) {\n      const cur = minutes[i]!;\n      const next = minutes[(i + 1) % minutes.length]!;\n      const gap = (next - cur + 60) % 60 || 60;\n      minGap = Math.min(minGap, gap);\n    }\n  }\n  if (minGap < MIN_SCHEDULE_INTERVAL_MIN) {\n    throw new Error(\n      `Schedule \"${fiveField}\" fires every ${minGap} minute(s); the minimum is ${MIN_SCHEDULE_INTERVAL_MIN}. ` +\n      `Use a sparser schedule (e.g. \"0 0 * * *\" for daily, \"*/15 * * * *\" for the densest allowed).`,\n    );\n  }\n}\n\n/** Remap a standard cron day-of-week token (0–7, 0/7=Sun) to EventBridge (1–7, 1=Sun). Passes through names and `*`/`?`. */\nfunction remapDayOfWeek(field: string): string {\n  if (field === '*' || field === '?') return field;\n  // Token may contain lists/ranges/steps of numbers and/or 3-letter names.\n  return field.replace(/\\d+/g, (n) => {\n    const v = parseInt(n, 10);\n    if (v < 0 || v > 7) throw new Error(`Invalid day-of-week value: \"${n}\"`);\n    return String((v % 7) + 1); // 0→1 (Sun), 6→7 (Sat), 7→1 (Sun)\n  });\n}\n\n/**\n * Convert a validated 5-field cron expression to an AWS EventBridge `cron(...)`\n * expression. Also enforces the 15-minute guard.\n */\nexport function toEventBridgeCron(fiveField: string): string {\n  assertScheduleInterval(fiveField); // also validates the 5-field shape\n  const f = fiveField.trim().split(/\\s+/);\n  const [minute, hour, domRaw, month, dowRaw] = [f[0]!, f[1]!, f[2]!, f[3]!, f[4]!];\n\n  let dom = domRaw;\n  let dow = remapDayOfWeek(dowRaw);\n\n  // EventBridge: exactly one of day-of-month / day-of-week must be `?`.\n  if (dom === '*' && dow === '*') {\n    dow = '?'; // unrestricted both → pin day-of-week to ?\n  } else if (dom !== '*' && dow === '*') {\n    dow = '?'; // specific day-of-month → day-of-week must be ?\n  } else if (dom === '*' && dow !== '*') {\n    dom = '?'; // specific day-of-week → day-of-month must be ?\n  }\n  // (both specific is left as-is; EventBridge rejects it, surfacing a clear error)\n\n  return `cron(${minute} ${hour} ${dom} ${month} ${dow} *)`;\n}\n"]}

package/package.json

@@ -41,8 +41,8 @@
     "typescript": "6.0.3",
     "yaml": "2.9.0",
     "zod": "4.4.3",
-    "@pipeline-builder/ai-core": "3.4.80",
-    "@pipeline-builder/pipeline-core": "3.4.94"
+    "@pipeline-builder/pipeline-core": "3.4.94",
+    "@pipeline-builder/ai-core": "3.4.80"
   },
   "keywords": [
     "ci-cd",
@@ -97,7 +97,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "3.4.125",
+  "version": "3.4.126",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },