@pipeline-builder/pipeline-manager 4.4.20 → 4.5.0

package/dist/utils/request-context.js

@@ -1,7 +1,9 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 import { randomUUID } from 'node:crypto';
+import { CLIENT_VERSION_HEADER } from '@pipeline-builder/api-core';
 import { correlationHeaders, sanitizeCorrelationValue } from '@pipeline-builder/pipeline-core';
+import { APP_VERSION } from '../config/cli.constants.js';
 /**
  * The audit-correlation headers every platform call from this CLI carries, so
  * a server-side audit row joins back to the run that caused it.
@@ -19,6 +21,8 @@ import { correlationHeaders, sanitizeCorrelationValue } from '@pipeline-builder/
  *   plugin verify, security-report), once the command knows it
  *   ({@link setPipelineId}). The quota service's usage ledger records it, so
  *   "what spent our calls?" can answer "this pipeline's builds".
+ * - `X-Pb-Client-Version` — this CLI's version, so a platform with
+ *   `PIPELINE_MANAGER_MIN_VERSION` set can answer 426 "run --upgrade".
  *
  * Never an ARN — nothing here can carry an AWS account id.
  */
@@ -52,6 +56,7 @@ export function requestCorrelationHeaders(env = process.env) {
     const pipeline = sanitizeCorrelationValue(pipelineId);
     if (pipeline)
         headers[PIPELINE_ID_HEADER] = pipeline;
+    headers[CLIENT_VERSION_HEADER] = APP_VERSION;
     return headers;
 }
 /** @internal Test-only: forget the invocation id. */
@@ -59,4 +64,4 @@ export function _resetInvocationIdForTests() {
     invocationId = undefined;
     pipelineId = undefined;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/update-notice.d.ts

@@ -0,0 +1,25 @@
+export declare const NO_UPDATE_CHECK_ENV = "PIPELINE_MANAGER_NO_UPDATE_CHECK";
+export declare const CHECK_INTERVAL_MS: number;
+export interface UpdateCache {
+    checkedAt: number;
+    latest?: string;
+}
+export interface NoticeContext {
+    argv: string[];
+    env: NodeJS.ProcessEnv;
+    isTTY: boolean;
+}
+/** Whether the notice (and its background refresh) may run at all. */
+export declare function updateCheckEnabled({ argv, env, isTTY }: NoticeContext): boolean;
+/** The notice line for `current` given the cache, or null when there is nothing newer. */
+export declare function noticeFor(current: string, cache: UpdateCache | null): string | null;
+/** Whether the cache is due for a refresh at `now`. */
+export declare function isStale(cache: UpdateCache | null, now: number): boolean;
+export declare function readCache(file: string): UpdateCache | null;
+export declare function defaultCacheFile(): string;
+/**
+ * Wire the notice for this process: read the cache now, refresh it in the
+ * background when stale, and print on exit when a newer release is known.
+ */
+export declare function scheduleUpdateNotice(ctx?: NoticeContext, file?: string, now?: number): void;
+//# sourceMappingURL=update-notice.d.ts.map

package/dist/utils/update-notice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-notice.d.ts","sources":["../../src/utils/update-notice.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,mBAAmB,qCAAqC,CAAC;AACtE,eAAO,MAAM,iBAAiB,QAAsB,CAAC;AAGrD,MAAM,WAAW,WAAW;IAAG,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE;AAEnE,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,sEAAsE;AACtE,wBAAgB,kBAAkB,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,aAAa,GAAG,OAAO,CAI/E;AAED,0FAA0F;AAC1F,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAMnF;AAED,uDAAuD;AACvD,wBAAgB,OAAO,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAEvE;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAO1D;AAsBD,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,GAAE,aAAuG,EAC5G,IAAI,GAAE,MAA2B,EACjC,GAAG,GAAE,MAAmB,GACvB,IAAI,CAgBN"}

package/dist/utils/update-notice.js

@@ -0,0 +1,100 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * "A newer pipeline-manager is available" — printed to stderr when a command
+ * exits, from a cache refreshed at most once a day by a DETACHED background
+ * process, so no command ever waits on the registry.
+ *
+ * Silent when: `PIPELINE_MANAGER_NO_UPDATE_CHECK` is set, `CI` is set, stderr
+ * is not a terminal, `--quiet` / `--token` output is wanted, or the command is
+ * itself `--upgrade` / `--upgrade-check`. It never fails a command: every
+ * error here is swallowed.
+ */
+import { spawn } from 'node:child_process';
+import { mkdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { compareSemver, isSemver } from '@pipeline-builder/api-core';
+import pico from 'picocolors';
+import { APP_NAME, APP_VERSION } from '../config/cli.constants.js';
+export const NO_UPDATE_CHECK_ENV = 'PIPELINE_MANAGER_NO_UPDATE_CHECK';
+export const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const PACKAGE_NAME = '@pipeline-builder/pipeline-manager';
+/** Whether the notice (and its background refresh) may run at all. */
+export function updateCheckEnabled({ argv, env, isTTY }) {
+    if (env[NO_UPDATE_CHECK_ENV] || env.CI || env.NODE_ENV === 'test')
+        return false;
+    if (!isTTY)
+        return false;
+    return !argv.some((a) => a === '--quiet' || a === '--token' || a === '--upgrade' || a === '--upgrade-check');
+}
+/** The notice line for `current` given the cache, or null when there is nothing newer. */
+export function noticeFor(current, cache) {
+    const latest = cache?.latest;
+    if (!latest || !isSemver(latest) || !isSemver(current))
+        return null;
+    if (compareSemver(latest, current) <= 0)
+        return null;
+    return `${pico.yellow('Update available')} ${current} → ${pico.green(latest)}: run ${pico.cyan(`${APP_NAME} --upgrade`)}`
+        + pico.dim(` (silence with ${NO_UPDATE_CHECK_ENV}=1)`);
+}
+/** Whether the cache is due for a refresh at `now`. */
+export function isStale(cache, now) {
+    return !cache || !Number.isFinite(cache.checkedAt) || now - cache.checkedAt >= CHECK_INTERVAL_MS || cache.checkedAt > now;
+}
+export function readCache(file) {
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        return typeof parsed.checkedAt === 'number' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The detached refresher: asks the registry for `latest` and writes the cache.
+ * It stamps `checkedAt` even when the lookup fails, so an offline machine
+ * retries tomorrow rather than on every command.
+ */
+const REFRESH_SCRIPT = `
+const { execFileSync } = require('node:child_process');
+const { writeFileSync, renameSync } = require('node:fs');
+const [file, pkg] = process.argv.slice(1);
+let latest;
+try {
+  const out = execFileSync('npm', ['view', pkg + '@latest', 'version', '--json'], { encoding: 'utf8', timeout: 20000, stdio: ['ignore', 'pipe', 'ignore'], shell: process.platform === 'win32' });
+  const v = JSON.parse(out);
+  if (typeof v === 'string') latest = v;
+} catch {}
+const tmp = file + '.' + process.pid;
+writeFileSync(tmp, JSON.stringify({ checkedAt: Date.now(), latest }));
+renameSync(tmp, file);
+`;
+export function defaultCacheFile() {
+    return join(homedir(), '.pipeline-manager', 'update-check.json');
+}
+/**
+ * Wire the notice for this process: read the cache now, refresh it in the
+ * background when stale, and print on exit when a newer release is known.
+ */
+export function scheduleUpdateNotice(ctx = { argv: process.argv.slice(2), env: process.env, isTTY: Boolean(process.stderr.isTTY) }, file = defaultCacheFile(), now = Date.now()) {
+    try {
+        if (!updateCheckEnabled(ctx))
+            return;
+        const cache = readCache(file);
+        if (isStale(cache, now)) {
+            // ~/.pipeline-manager is also the CREDENTIAL store (credential-store.ts
+            // makes it 0700, but only when creating it) — if this runs first it must
+            // not leave that directory world-readable.
+            mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
+            spawn(process.execPath, ['-e', REFRESH_SCRIPT, file, PACKAGE_NAME], { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+        }
+        const line = noticeFor(APP_VERSION, cache);
+        if (line)
+            process.once('exit', () => { process.stderr.write(`\n${line}\n`); });
+    }
+    catch {
+        // Never let the update notice break a command.
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"update-notice.js","sources":["../../src/utils/update-notice.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * \"A newer pipeline-manager is available\" — printed to stderr when a command\n * exits, from a cache refreshed at most once a day by a DETACHED background\n * process, so no command ever waits on the registry.\n *\n * Silent when: `PIPELINE_MANAGER_NO_UPDATE_CHECK` is set, `CI` is set, stderr\n * is not a terminal, `--quiet` / `--token` output is wanted, or the command is\n * itself `--upgrade` / `--upgrade-check`. It never fails a command: every\n * error here is swallowed.\n */\n\nimport { spawn } from 'node:child_process';\nimport { mkdirSync, readFileSync } from 'node:fs';\nimport { homedir } from 'node:os';\nimport { dirname, join } from 'node:path';\nimport { compareSemver, isSemver } from '@pipeline-builder/api-core';\nimport pico from 'picocolors';\nimport { APP_NAME, APP_VERSION } from '../config/cli.constants.js';\n\nexport const NO_UPDATE_CHECK_ENV = 'PIPELINE_MANAGER_NO_UPDATE_CHECK';\nexport const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;\nconst PACKAGE_NAME = '@pipeline-builder/pipeline-manager';\n\nexport interface UpdateCache { checkedAt: number; latest?: string }\n\nexport interface NoticeContext {\n  argv: string[];\n  env: NodeJS.ProcessEnv;\n  isTTY: boolean;\n}\n\n/** Whether the notice (and its background refresh) may run at all. */\nexport function updateCheckEnabled({ argv, env, isTTY }: NoticeContext): boolean {\n  if (env[NO_UPDATE_CHECK_ENV] || env.CI || env.NODE_ENV === 'test') return false;\n  if (!isTTY) return false;\n  return !argv.some((a) => a === '--quiet' || a === '--token' || a === '--upgrade' || a === '--upgrade-check');\n}\n\n/** The notice line for `current` given the cache, or null when there is nothing newer. */\nexport function noticeFor(current: string, cache: UpdateCache | null): string | null {\n  const latest = cache?.latest;\n  if (!latest || !isSemver(latest) || !isSemver(current)) return null;\n  if (compareSemver(latest, current) <= 0) return null;\n  return `${pico.yellow('Update available')} ${current} → ${pico.green(latest)}: run ${pico.cyan(`${APP_NAME} --upgrade`)}`\n    + pico.dim(` (silence with ${NO_UPDATE_CHECK_ENV}=1)`);\n}\n\n/** Whether the cache is due for a refresh at `now`. */\nexport function isStale(cache: UpdateCache | null, now: number): boolean {\n  return !cache || !Number.isFinite(cache.checkedAt) || now - cache.checkedAt >= CHECK_INTERVAL_MS || cache.checkedAt > now;\n}\n\nexport function readCache(file: string): UpdateCache | null {\n  try {\n    const parsed = JSON.parse(readFileSync(file, 'utf8')) as UpdateCache;\n    return typeof parsed.checkedAt === 'number' ? parsed : null;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * The detached refresher: asks the registry for `latest` and writes the cache.\n * It stamps `checkedAt` even when the lookup fails, so an offline machine\n * retries tomorrow rather than on every command.\n */\nconst REFRESH_SCRIPT = `\nconst { execFileSync } = require('node:child_process');\nconst { writeFileSync, renameSync } = require('node:fs');\nconst [file, pkg] = process.argv.slice(1);\nlet latest;\ntry {\n  const out = execFileSync('npm', ['view', pkg + '@latest', 'version', '--json'], { encoding: 'utf8', timeout: 20000, stdio: ['ignore', 'pipe', 'ignore'], shell: process.platform === 'win32' });\n  const v = JSON.parse(out);\n  if (typeof v === 'string') latest = v;\n} catch {}\nconst tmp = file + '.' + process.pid;\nwriteFileSync(tmp, JSON.stringify({ checkedAt: Date.now(), latest }));\nrenameSync(tmp, file);\n`;\n\nexport function defaultCacheFile(): string {\n  return join(homedir(), '.pipeline-manager', 'update-check.json');\n}\n\n/**\n * Wire the notice for this process: read the cache now, refresh it in the\n * background when stale, and print on exit when a newer release is known.\n */\nexport function scheduleUpdateNotice(\n  ctx: NoticeContext = { argv: process.argv.slice(2), env: process.env, isTTY: Boolean(process.stderr.isTTY) },\n  file: string = defaultCacheFile(),\n  now: number = Date.now(),\n): void {\n  try {\n    if (!updateCheckEnabled(ctx)) return;\n    const cache = readCache(file);\n    if (isStale(cache, now)) {\n      // ~/.pipeline-manager is also the CREDENTIAL store (credential-store.ts\n      // makes it 0700, but only when creating it) — if this runs first it must\n      // not leave that directory world-readable.\n      mkdirSync(dirname(file), { recursive: true, mode: 0o700 });\n      spawn(process.execPath, ['-e', REFRESH_SCRIPT, file, PACKAGE_NAME], { detached: true, stdio: 'ignore', windowsHide: true }).unref();\n    }\n    const line = noticeFor(APP_VERSION, cache);\n    if (line) process.once('exit', () => { process.stderr.write(`\\n${line}\\n`); });\n  } catch {\n    // Never let the update notice break a command.\n  }\n}\n"]}

package/package.json

@@ -33,9 +33,9 @@
     "@aws-sdk/client-secrets-manager": "3.1160.0",
     "@aws-sdk/client-sqs": "3.1160.0",
     "@aws-sdk/client-sts": "3.1160.0",
-    "@pipeline-builder/ai-core": "4.3.7",
-    "@pipeline-builder/api-core": "5.2.7",
-    "@pipeline-builder/pipeline-core": "4.4.8",
+    "@pipeline-builder/ai-core": "4.3.8",
+    "@pipeline-builder/api-core": "5.2.8",
+    "@pipeline-builder/pipeline-core": "4.4.9",
     "aws-cdk-lib": "2.275.0",
     "axios": "1.21.1",
     "commander": "15.1.0",
@@ -106,7 +106,7 @@
     "registry": "https://registry.npmjs.org/",
     "provenance": true
   },
-  "version": "4.4.20",
+  "version": "4.5.0",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },