@pipeline-builder/pipeline-manager 4.4.19 → 4.5.0

package/dist/commands/upgrade.js

@@ -0,0 +1,342 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * `pipeline-manager --upgrade [version]`: replace this CLI with the latest
+ * release (or a named version / dist-tag) in place; `--upgrade-check [version]`
+ * reports what that would do without doing it.
+ *
+ * It only acts on an install it can prove it owns: a GLOBAL npm or pnpm
+ * install whose package directory is the one running now. Anything else (npx,
+ * a project dependency, a workspace checkout, Volta, Homebrew) is refused with
+ * the command that would update it, because reinstalling globally would leave
+ * the copy actually being run untouched and report a success that changed nothing.
+ *
+ * Before installing it checks, in order: the target's `engines.node` against
+ * the running Node; that a downgrade does not go below the first release with
+ * `--upgrade` (which would strand the user); that the global directory
+ * is writable; and that the downloaded tarball matches the registry's
+ * `dist.integrity` AND carries a valid registry ECDSA signature over it. The
+ * verified tarball itself is what gets installed.
+ *
+ * Synchronous on purpose: it runs from Commander's `option:upgrade` listener,
+ * like `--version`, and exits before any command would.
+ */
+import { spawnSync } from 'node:child_process';
+import { createHash, createPublicKey, verify } from 'node:crypto';
+import { accessSync, constants as fsConstants, existsSync, mkdtempSync, readFileSync, realpathSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { compareSemver, satisfiesRange } from '@pipeline-builder/api-core';
+import { APP_NAME, APP_VERSION } from '../config/cli.constants.js';
+import { ERROR_CODES } from '../utils/error-handler.js';
+import { printError, printInfo, printSuccess, printWarning } from '../utils/output-utils.js';
+export const PACKAGE_NAME = '@pipeline-builder/pipeline-manager';
+/** The first release that has `--upgrade`: moving below it would leave no way back but a manual install. */
+export const UPGRADE_SINCE = '4.4.21';
+const REPO_URL = 'https://github.com/mwashburn160/pipeline-builder';
+/** Opt out of the registry-signature check (a mirror that doesn't serve npm's signing keys). */
+export const SKIP_VERIFY_ENV = 'PIPELINE_MANAGER_UPGRADE_SKIP_VERIFY';
+/** A semver (`4.4.19`, `5.0.0-rc.1`) or a dist-tag (`latest`, `next`); nothing a shell could read as syntax. */
+const VERSION_SPEC = /^(?:\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?|[A-Za-z][0-9A-Za-z.-]*)$/;
+/**
+ * The npm that belongs to the RUNNING Node (next to `process.execPath`), so a
+ * version manager or Homebrew putting a different Node's npm first on PATH
+ * can't make the ownership check look at the wrong global root. Falls back to
+ * whatever `npm` is on PATH.
+ */
+export function npmBinFor(execPath, platform, exists) {
+    const sibling = join(dirname(execPath), platform === 'win32' ? 'npm.cmd' : 'npm');
+    return exists(sibling) ? sibling : 'npm';
+}
+/** Quote an argument for the win32 shell when it holds a space (temp paths under `C:\Users\First Last`). */
+const winQuote = (a) => (/\s/.test(a) ? `"${a}"` : a);
+export const systemDeps = () => {
+    const npmBin = npmBinFor(process.execPath, process.platform, existsSync);
+    const win = process.platform === 'win32';
+    return {
+        run: (cmd, args, inherit) => {
+            // Windows ships the managers as .cmd shims, which Node only spawns through
+            // a shell; every argument is fixed, checked against VERSION_SPEC, or a
+            // temp path we created (quoted).
+            const r = spawnSync(cmd === 'npm' ? npmBin : cmd, win ? args.map(winQuote) : args, {
+                encoding: 'utf8', stdio: inherit ? 'inherit' : ['ignore', 'pipe', 'pipe'], shell: win,
+            });
+            return { status: r.error ? null : r.status, stdout: r.stdout ?? '' };
+        },
+        // dist/commands/upgrade.js → the package root.
+        packageRoot: fileURLToPath(new URL('../../', import.meta.url)),
+        currentVersion: APP_VERSION,
+        nodeVersion: process.version,
+        env: process.env,
+        realpath: (p) => { try {
+            return realpathSync(p);
+        }
+        catch {
+            return null;
+        } },
+        readVersion: (dir) => {
+            try {
+                return JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8')).version ?? null;
+            }
+            catch {
+                return null;
+            }
+        },
+        writable: (dir) => { try {
+            accessSync(dir, fsConstants.W_OK);
+            return true;
+        }
+        catch {
+            return false;
+        } },
+        // Synchronous GET via a short-lived Node child (this module must stay sync).
+        fetchText: (url) => {
+            const script = 'const r = await fetch(process.argv[1]); if (!r.ok) process.exit(1); process.stdout.write(await r.text());';
+            const r = spawnSync(process.execPath, ['--input-type=module', '-e', script, url], { encoding: 'utf8', timeout: 30_000 });
+            return r.status === 0 ? r.stdout : null;
+        },
+        integrityOf: (file) => `sha512-${createHash('sha512').update(readFileSync(file)).digest('base64')}`,
+        makeTempDir: () => mkdtempSync(join(tmpdir(), 'pipeline-manager-upgrade-')),
+        removeDir: (dir) => rmSync(dir, { recursive: true, force: true }),
+    };
+};
+/** Where this package would live under `manager`'s global root, or null when that manager is absent. */
+function globalRoot(manager, deps) {
+    const r = deps.run(manager, ['root', '-g'], false);
+    const root = r.status === 0 ? r.stdout.trim() : '';
+    return root || null;
+}
+/** The global manager that owns the running copy (compared by realpath: pnpm links into its store). */
+function owningManager(deps) {
+    const self = deps.realpath(deps.packageRoot);
+    if (!self)
+        return null;
+    for (const manager of ['npm', 'pnpm']) {
+        const root = globalRoot(manager, deps);
+        const dir = root ? join(root, ...PACKAGE_NAME.split('/')) : null;
+        if (root && dir && deps.realpath(dir) === self)
+            return { manager, root, dir };
+    }
+    return null;
+}
+/** What `spec` resolves to on the registry: the version plus what the install checks need. */
+function resolveRelease(spec, deps) {
+    const r = deps.run('npm', ['view', `${PACKAGE_NAME}@${spec}`, 'version', 'engines', 'dist.integrity', 'dist.signatures', '--json'], false);
+    let body;
+    try {
+        body = JSON.parse(r.stdout || 'null');
+    }
+    catch {
+        body = null;
+    }
+    // On failure `--json` prints `{"error":{"code":"E404",…}}`: a missing version
+    // or tag is the caller's mistake, not the network's.
+    if (r.status !== 0) {
+        const code = body?.error?.code;
+        return { ok: false, notFound: code === 'E404' };
+    }
+    const o = body;
+    const version = o?.version;
+    if (typeof version !== 'string')
+        return { ok: false, notFound: o === null };
+    const engines = o?.engines;
+    const signatures = Array.isArray(o?.['dist.signatures']) ? o['dist.signatures'] : [];
+    return {
+        ok: true,
+        release: {
+            version,
+            nodeRange: typeof engines?.node === 'string' ? engines.node : undefined,
+            integrity: typeof o?.['dist.integrity'] === 'string' ? o['dist.integrity'] : undefined,
+            signatures,
+        },
+    };
+}
+/**
+ * npm's signing keys, ALWAYS from the public registry that issued them — never
+ * from the configured registry. `dist.signatures` are npm's own, so a mirror
+ * passes them through unchanged; fetching keys from the mirror would let a
+ * malicious or compromised mirror sign its own tarball with its own key.
+ */
+export const NPM_KEYS_URL = 'https://registry.npmjs.org/-/npm/v1/keys';
+/** npm's signing keys, by keyid. */
+function registryKeys(deps) {
+    const text = deps.fetchText(NPM_KEYS_URL);
+    if (!text)
+        return null;
+    try {
+        const keys = JSON.parse(text).keys ?? [];
+        return new Map(keys.filter((k) => typeof k.keyid === 'string' && typeof k.key === 'string').map((k) => [k.keyid, k.key]));
+    }
+    catch {
+        return null;
+    }
+}
+/** Does any registry signature verify `<name>@<version>:<integrity>`? */
+export function signatureValid(release, keys) {
+    if (!release.integrity)
+        return false;
+    const message = Buffer.from(`${PACKAGE_NAME}@${release.version}:${release.integrity}`);
+    return release.signatures.some(({ keyid, sig }) => {
+        const key = keys.get(keyid);
+        if (!key)
+            return false;
+        try {
+            return verify('sha256', message, createPublicKey({ key: Buffer.from(key, 'base64'), format: 'der', type: 'spki' }), Buffer.from(sig, 'base64'));
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/**
+ * Download the target with `npm pack` and prove it is the registry's signed
+ * artifact. Returns the tarball path, or an error message.
+ */
+function fetchVerifiedTarball(release, dir, deps) {
+    const pack = deps.run('npm', ['pack', `${PACKAGE_NAME}@${release.version}`, '--pack-destination', dir, '--json'], false);
+    let filename;
+    try {
+        filename = JSON.parse(pack.stdout)[0]?.filename;
+    }
+    catch {
+        filename = undefined;
+    }
+    if (pack.status !== 0 || typeof filename !== 'string')
+        return { error: `npm could not download ${PACKAGE_NAME}@${release.version}` };
+    const tarball = join(dir, filename);
+    if (deps.env[SKIP_VERIFY_ENV] === '1') {
+        printWarning(`${SKIP_VERIFY_ENV}=1: installing without checking the registry signature`);
+        return { tarball };
+    }
+    if (!release.integrity)
+        return { error: `the registry gave no dist.integrity for ${release.version}` };
+    const actual = deps.integrityOf(tarball);
+    if (actual !== release.integrity)
+        return { error: `the downloaded tarball's hash (${actual}) is not the registry's (${release.integrity})` };
+    const keys = registryKeys(deps);
+    if (!keys)
+        return { error: `could not fetch npm's signing keys from ${NPM_KEYS_URL} (no route to registry.npmjs.org? set ${SKIP_VERIFY_ENV}=1 to install unverified)` };
+    if (!signatureValid(release, keys))
+        return { error: `no valid registry signature over ${PACKAGE_NAME}@${release.version}` };
+    return { tarball };
+}
+/** Link to what changed between two releases. */
+export function changesUrl(from, to) {
+    const tag = (v) => `release/${PACKAGE_NAME}/${v}`;
+    return `${REPO_URL}/compare/${tag(from)}...${tag(to)}`;
+}
+/**
+ * Upgrade (or move) this CLI to `requested` (`true` = latest). Returns the
+ * process exit code; never throws for an expected failure.
+ */
+export function selfUpgrade(requested, deps = systemDeps(), opts = {}) {
+    const spec = requested === true ? 'latest' : requested;
+    if (!VERSION_SPEC.test(spec)) {
+        printError(`Invalid version "${spec}": use a version like 4.4.21, or a dist-tag like latest`);
+        return ERROR_CODES.VALIDATION;
+    }
+    const owner = owningManager(deps);
+    if (!owner && !opts.check) {
+        printError(`${APP_NAME} ${deps.currentVersion} at ${deps.packageRoot} is not a global npm or pnpm install, so --upgrade cannot replace it`);
+        printInfo(`Update it with whatever installed it: npm install -g ${PACKAGE_NAME}@${spec} (global), `
+            + `a version bump in your project, npx ${PACKAGE_NAME}@${spec}, or your Node manager (Volta: volta install ${PACKAGE_NAME}@${spec})`);
+        return ERROR_CODES.CONFIGURATION;
+    }
+    const resolved = resolveRelease(spec, deps);
+    if (!resolved.ok) {
+        if (resolved.notFound) {
+            printError(`${PACKAGE_NAME} has no version or dist-tag "${spec}"`);
+            return ERROR_CODES.VALIDATION;
+        }
+        printError(`Could not reach the npm registry to resolve ${PACKAGE_NAME}@${spec}`);
+        return ERROR_CODES.NETWORK;
+    }
+    const { release } = resolved;
+    const target = release.version;
+    const order = compareSemver(target, deps.currentVersion);
+    if (order === 0) {
+        printSuccess(`${APP_NAME} ${deps.currentVersion} is already ${requested === true ? 'the latest release' : 'installed'}`);
+        return 0;
+    }
+    // A bare --upgrade never moves backwards; naming a version is how to downgrade.
+    if (order < 0 && requested === true) {
+        printSuccess(`${APP_NAME} ${deps.currentVersion} is newer than the latest release (${target}); nothing to do`);
+        return 0;
+    }
+    // Only a DOWNGRADE can strand the user; moving up from a pre-flag build is fine.
+    if (order < 0 && compareSemver(target, UPGRADE_SINCE) < 0) {
+        printError(`${target} predates --upgrade (added in ${UPGRADE_SINCE}), so moving to it would leave no way back but a manual install`);
+        printInfo(`If that is what you want: npm install -g ${PACKAGE_NAME}@${target}`);
+        return ERROR_CODES.VALIDATION;
+    }
+    if (release.nodeRange) {
+        const fits = satisfiesRange(deps.nodeVersion, release.nodeRange);
+        if (fits === false) {
+            printError(`${APP_NAME} ${target} needs Node ${release.nodeRange}, but this is Node ${deps.nodeVersion}; upgrade Node first`);
+            return ERROR_CODES.CONFIGURATION;
+        }
+        if (fits === null)
+            printWarning(`Could not check ${target}'s Node requirement "${release.nodeRange}" against ${deps.nodeVersion}`);
+    }
+    const verb = order > 0 ? 'Upgrading' : 'Downgrading';
+    if (opts.check) {
+        printInfo(`${APP_NAME} ${deps.currentVersion} → ${target} is available${owner ? '' : ' (not a global npm/pnpm install: update it with whatever installed it)'}`);
+        printInfo(`Changes: ${changesUrl(deps.currentVersion, target)}`);
+        return 1;
+    }
+    // `owner` is non-null past the !check guard above.
+    const own = owner;
+    if (!deps.writable(own.root)) {
+        printError(`${own.root} is not writable by this user, so ${own.manager} cannot replace ${APP_NAME} there`);
+        // Never "re-run pipeline-manager with sudo": that runs the whole CLI (its
+        // credential store, its config) as root. Name the one command that needs it.
+        printInfo(`Either install just the package as root: sudo npm install -g ${PACKAGE_NAME}@${target}`);
+        printInfo('or move npm globals into your home directory (npm config set prefix ~/.npm-global, then add ~/.npm-global/bin to PATH) and re-run --upgrade');
+        return ERROR_CODES.FILE_SYSTEM;
+    }
+    printInfo(`${verb} ${APP_NAME} ${deps.currentVersion} → ${target} (${own.manager} global install)`);
+    const tmp = deps.makeTempDir();
+    try {
+        const fetched = fetchVerifiedTarball(release, tmp, deps);
+        if ('error' in fetched) {
+            printError(`Not installing ${target}: ${fetched.error}; ${APP_NAME} ${deps.currentVersion} is unchanged`);
+            return ERROR_CODES.GENERAL;
+        }
+        const install = own.manager === 'npm'
+            ? deps.run('npm', ['install', '-g', fetched.tarball], true)
+            : deps.run('pnpm', ['add', '-g', fetched.tarball], true);
+        if (install.status !== 0) {
+            printError(`${own.manager} could not install ${PACKAGE_NAME}@${target}; ${APP_NAME} ${deps.currentVersion} is unchanged`);
+            return ERROR_CODES.FILE_SYSTEM;
+        }
+    }
+    finally {
+        deps.removeDir(tmp);
+    }
+    // Read the version back from disk rather than trusting the exit code.
+    const installed = deps.readVersion(own.dir);
+    if (installed !== target) {
+        printWarning(`${own.manager} reported success, but ${own.dir} holds ${installed ?? 'no readable package'} instead of ${target}`);
+        return ERROR_CODES.GENERAL;
+    }
+    printSuccess(`${APP_NAME} is now ${target} (was ${deps.currentVersion}); signature verified`);
+    printInfo(`What changed: ${changesUrl(deps.currentVersion, target)}`);
+    return 0;
+}
+/**
+ * Register the top-level `--upgrade [version]` and `--upgrade-check [version]`
+ * flags. Handled the way Commander handles `--version`: the option listener
+ * runs and exits, so each works on its own without a root action that would
+ * change how unknown commands are reported.
+ */
+export function registerUpgradeOption(program, upgrade = (r, o) => selfUpgrade(r, systemDeps(), o)) {
+    program.option('--upgrade [version]', 'Upgrade this CLI in place to the latest release (or the given version / dist-tag)');
+    program.option('--upgrade-check [version]', 'Report whether --upgrade would change anything (exit 0 = current, 1 = available)');
+    // Commander's listener gets the value as given, or null/undefined for a bare
+    // flag (not `true`, unlike the parsed opts), so anything not a string means latest.
+    const latestOr = (value) => (typeof value === 'string' ? value : true);
+    program.on('option:upgrade', (value) => process.exit(upgrade(latestOr(value), {})));
+    program.on('option:upgrade-check', (value) => process.exit(upgrade(latestOr(value), { check: true })));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upgrade.js","sources":["../../src/commands/upgrade.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * `pipeline-manager --upgrade [version]`: replace this CLI with the latest\n * release (or a named version / dist-tag) in place; `--upgrade-check [version]`\n * reports what that would do without doing it.\n *\n * It only acts on an install it can prove it owns: a GLOBAL npm or pnpm\n * install whose package directory is the one running now. Anything else (npx,\n * a project dependency, a workspace checkout, Volta, Homebrew) is refused with\n * the command that would update it, because reinstalling globally would leave\n * the copy actually being run untouched and report a success that changed nothing.\n *\n * Before installing it checks, in order: the target's `engines.node` against\n * the running Node; that a downgrade does not go below the first release with\n * `--upgrade` (which would strand the user); that the global directory\n * is writable; and that the downloaded tarball matches the registry's\n * `dist.integrity` AND carries a valid registry ECDSA signature over it. The\n * verified tarball itself is what gets installed.\n *\n * Synchronous on purpose: it runs from Commander's `option:upgrade` listener,\n * like `--version`, and exits before any command would.\n */\n\nimport { spawnSync } from 'node:child_process';\nimport { createHash, createPublicKey, verify } from 'node:crypto';\nimport { accessSync, constants as fsConstants, existsSync, mkdtempSync, readFileSync, realpathSync, rmSync } from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { dirname, join } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { compareSemver, satisfiesRange } from '@pipeline-builder/api-core';\nimport type { Command } from 'commander';\nimport { APP_NAME, APP_VERSION } from '../config/cli.constants.js';\nimport { ERROR_CODES } from '../utils/error-handler.js';\nimport { printError, printInfo, printSuccess, printWarning } from '../utils/output-utils.js';\n\nexport const PACKAGE_NAME = '@pipeline-builder/pipeline-manager';\n/** The first release that has `--upgrade`: moving below it would leave no way back but a manual install. */\nexport const UPGRADE_SINCE = '4.4.21';\nconst REPO_URL = 'https://github.com/mwashburn160/pipeline-builder';\n/** Opt out of the registry-signature check (a mirror that doesn't serve npm's signing keys). */\nexport const SKIP_VERIFY_ENV = 'PIPELINE_MANAGER_UPGRADE_SKIP_VERIFY';\n\n/** A semver (`4.4.19`, `5.0.0-rc.1`) or a dist-tag (`latest`, `next`); nothing a shell could read as syntax. */\nconst VERSION_SPEC = /^(?:\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?|[A-Za-z][0-9A-Za-z.-]*)$/;\n\ntype Manager = 'npm' | 'pnpm';\n\nexport interface RunResult { status: number | null; stdout: string }\n\n/** The process seams, injectable so tests never touch a real registry or global install. */\nexport interface UpgradeDeps {\n  /** Run a package-manager command; `inherit` streams its output to the terminal. */\n  run: (cmd: Manager, args: string[], inherit: boolean) => RunResult;\n  /** This package's installed directory. */\n  packageRoot: string;\n  currentVersion: string;\n  /** The running Node's version (`process.version`). */\n  nodeVersion: string;\n  env: NodeJS.ProcessEnv;\n  /** realpath, or null when the path does not exist. */\n  realpath: (p: string) => string | null;\n  /** The `version` field of `<dir>/package.json`, or null when unreadable. */\n  readVersion: (dir: string) => string | null;\n  /** Whether this process may write into `dir`. */\n  writable: (dir: string) => boolean;\n  /** GET `url` and return the body, or null on any failure. */\n  fetchText: (url: string) => string | null;\n  /** `sha512-<base64>` of a file (the registry's `dist.integrity` form). */\n  integrityOf: (file: string) => string;\n  makeTempDir: () => string;\n  removeDir: (dir: string) => void;\n}\n\n/**\n * The npm that belongs to the RUNNING Node (next to `process.execPath`), so a\n * version manager or Homebrew putting a different Node's npm first on PATH\n * can't make the ownership check look at the wrong global root. Falls back to\n * whatever `npm` is on PATH.\n */\nexport function npmBinFor(execPath: string, platform: NodeJS.Platform, exists: (p: string) => boolean): string {\n  const sibling = join(dirname(execPath), platform === 'win32' ? 'npm.cmd' : 'npm');\n  return exists(sibling) ? sibling : 'npm';\n}\n\n/** Quote an argument for the win32 shell when it holds a space (temp paths under `C:\\Users\\First Last`). */\nconst winQuote = (a: string) => (/\\s/.test(a) ? `\"${a}\"` : a);\n\nexport const systemDeps = (): UpgradeDeps => {\n  const npmBin = npmBinFor(process.execPath, process.platform, existsSync);\n  const win = process.platform === 'win32';\n  return {\n    run: (cmd, args, inherit) => {\n      // Windows ships the managers as .cmd shims, which Node only spawns through\n      // a shell; every argument is fixed, checked against VERSION_SPEC, or a\n      // temp path we created (quoted).\n      const r = spawnSync(cmd === 'npm' ? npmBin : cmd, win ? args.map(winQuote) : args, {\n        encoding: 'utf8', stdio: inherit ? 'inherit' : ['ignore', 'pipe', 'pipe'], shell: win,\n      });\n      return { status: r.error ? null : r.status, stdout: r.stdout ?? '' };\n    },\n    // dist/commands/upgrade.js → the package root.\n    packageRoot: fileURLToPath(new URL('../../', import.meta.url)),\n    currentVersion: APP_VERSION,\n    nodeVersion: process.version,\n    env: process.env,\n    realpath: (p) => { try { return realpathSync(p); } catch { return null; } },\n    readVersion: (dir) => {\n      try { return (JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8')) as { version?: string }).version ?? null; } catch { return null; }\n    },\n    writable: (dir) => { try { accessSync(dir, fsConstants.W_OK); return true; } catch { return false; } },\n    // Synchronous GET via a short-lived Node child (this module must stay sync).\n    fetchText: (url) => {\n      const script = 'const r = await fetch(process.argv[1]); if (!r.ok) process.exit(1); process.stdout.write(await r.text());';\n      const r = spawnSync(process.execPath, ['--input-type=module', '-e', script, url], { encoding: 'utf8', timeout: 30_000 });\n      return r.status === 0 ? r.stdout : null;\n    },\n    integrityOf: (file) => `sha512-${createHash('sha512').update(readFileSync(file)).digest('base64')}`,\n    makeTempDir: () => mkdtempSync(join(tmpdir(), 'pipeline-manager-upgrade-')),\n    removeDir: (dir) => rmSync(dir, { recursive: true, force: true }),\n  };\n};\n\n/** Where this package would live under `manager`'s global root, or null when that manager is absent. */\nfunction globalRoot(manager: Manager, deps: UpgradeDeps): string | null {\n  const r = deps.run(manager, ['root', '-g'], false);\n  const root = r.status === 0 ? r.stdout.trim() : '';\n  return root || null;\n}\n\n/** The global manager that owns the running copy (compared by realpath: pnpm links into its store). */\nfunction owningManager(deps: UpgradeDeps): { manager: Manager; root: string; dir: string } | null {\n  const self = deps.realpath(deps.packageRoot);\n  if (!self) return null;\n  for (const manager of ['npm', 'pnpm'] as const) {\n    const root = globalRoot(manager, deps);\n    const dir = root ? join(root, ...PACKAGE_NAME.split('/')) : null;\n    if (root && dir && deps.realpath(dir) === self) return { manager, root, dir };\n  }\n  return null;\n}\n\ninterface Release { version: string; nodeRange?: string; integrity?: string; signatures: Array<{ keyid: string; sig: string }> }\n\ntype Resolution = { ok: true; release: Release } | { ok: false; notFound: boolean };\n\n/** What `spec` resolves to on the registry: the version plus what the install checks need. */\nfunction resolveRelease(spec: string, deps: UpgradeDeps): Resolution {\n  const r = deps.run('npm', ['view', `${PACKAGE_NAME}@${spec}`, 'version', 'engines', 'dist.integrity', 'dist.signatures', '--json'], false);\n  let body: unknown;\n  try { body = JSON.parse(r.stdout || 'null'); } catch { body = null; }\n  // On failure `--json` prints `{\"error\":{\"code\":\"E404\",…}}`: a missing version\n  // or tag is the caller's mistake, not the network's.\n  if (r.status !== 0) {\n    const code = (body as { error?: { code?: unknown } } | null)?.error?.code;\n    return { ok: false, notFound: code === 'E404' };\n  }\n  const o = body as Record<string, unknown> | null;\n  const version = o?.version;\n  if (typeof version !== 'string') return { ok: false, notFound: o === null };\n  const engines = o?.engines as { node?: unknown } | undefined;\n  const signatures = Array.isArray(o?.['dist.signatures']) ? (o['dist.signatures'] as Array<{ keyid: string; sig: string }>) : [];\n  return {\n    ok: true,\n    release: {\n      version,\n      nodeRange: typeof engines?.node === 'string' ? engines.node : undefined,\n      integrity: typeof o?.['dist.integrity'] === 'string' ? (o['dist.integrity'] as string) : undefined,\n      signatures,\n    },\n  };\n}\n\n/**\n * npm's signing keys, ALWAYS from the public registry that issued them — never\n * from the configured registry. `dist.signatures` are npm's own, so a mirror\n * passes them through unchanged; fetching keys from the mirror would let a\n * malicious or compromised mirror sign its own tarball with its own key.\n */\nexport const NPM_KEYS_URL = 'https://registry.npmjs.org/-/npm/v1/keys';\n\n/** npm's signing keys, by keyid. */\nfunction registryKeys(deps: UpgradeDeps): Map<string, string> | null {\n  const text = deps.fetchText(NPM_KEYS_URL);\n  if (!text) return null;\n  try {\n    const keys = (JSON.parse(text) as { keys?: Array<{ keyid?: unknown; key?: unknown }> }).keys ?? [];\n    return new Map(keys.filter((k) => typeof k.keyid === 'string' && typeof k.key === 'string').map((k) => [k.keyid as string, k.key as string]));\n  } catch {\n    return null;\n  }\n}\n\n/** Does any registry signature verify `<name>@<version>:<integrity>`? */\nexport function signatureValid(release: Release, keys: Map<string, string>): boolean {\n  if (!release.integrity) return false;\n  const message = Buffer.from(`${PACKAGE_NAME}@${release.version}:${release.integrity}`);\n  return release.signatures.some(({ keyid, sig }) => {\n    const key = keys.get(keyid);\n    if (!key) return false;\n    try {\n      return verify('sha256', message, createPublicKey({ key: Buffer.from(key, 'base64'), format: 'der', type: 'spki' }), Buffer.from(sig, 'base64'));\n    } catch {\n      return false;\n    }\n  });\n}\n\n/**\n * Download the target with `npm pack` and prove it is the registry's signed\n * artifact. Returns the tarball path, or an error message.\n */\nfunction fetchVerifiedTarball(release: Release, dir: string, deps: UpgradeDeps): { tarball: string } | { error: string } {\n  const pack = deps.run('npm', ['pack', `${PACKAGE_NAME}@${release.version}`, '--pack-destination', dir, '--json'], false);\n  let filename: unknown;\n  try { filename = (JSON.parse(pack.stdout) as Array<{ filename?: unknown }>)[0]?.filename; } catch { filename = undefined; }\n  if (pack.status !== 0 || typeof filename !== 'string') return { error: `npm could not download ${PACKAGE_NAME}@${release.version}` };\n  const tarball = join(dir, filename);\n\n  if (deps.env[SKIP_VERIFY_ENV] === '1') {\n    printWarning(`${SKIP_VERIFY_ENV}=1: installing without checking the registry signature`);\n    return { tarball };\n  }\n  if (!release.integrity) return { error: `the registry gave no dist.integrity for ${release.version}` };\n  const actual = deps.integrityOf(tarball);\n  if (actual !== release.integrity) return { error: `the downloaded tarball's hash (${actual}) is not the registry's (${release.integrity})` };\n  const keys = registryKeys(deps);\n  if (!keys) return { error: `could not fetch npm's signing keys from ${NPM_KEYS_URL} (no route to registry.npmjs.org? set ${SKIP_VERIFY_ENV}=1 to install unverified)` };\n  if (!signatureValid(release, keys)) return { error: `no valid registry signature over ${PACKAGE_NAME}@${release.version}` };\n  return { tarball };\n}\n\n/** Link to what changed between two releases. */\nexport function changesUrl(from: string, to: string): string {\n  const tag = (v: string) => `release/${PACKAGE_NAME}/${v}`;\n  return `${REPO_URL}/compare/${tag(from)}...${tag(to)}`;\n}\n\nexport interface UpgradeOptions {\n  /** Report what would happen (exit 0 = current, 1 = a move is available) without installing. */\n  check?: boolean;\n}\n\n/**\n * Upgrade (or move) this CLI to `requested` (`true` = latest). Returns the\n * process exit code; never throws for an expected failure.\n */\nexport function selfUpgrade(requested: string | true, deps: UpgradeDeps = systemDeps(), opts: UpgradeOptions = {}): number {\n  const spec = requested === true ? 'latest' : requested;\n  if (!VERSION_SPEC.test(spec)) {\n    printError(`Invalid version \"${spec}\": use a version like 4.4.21, or a dist-tag like latest`);\n    return ERROR_CODES.VALIDATION;\n  }\n\n  const owner = owningManager(deps);\n  if (!owner && !opts.check) {\n    printError(`${APP_NAME} ${deps.currentVersion} at ${deps.packageRoot} is not a global npm or pnpm install, so --upgrade cannot replace it`);\n    printInfo(`Update it with whatever installed it: npm install -g ${PACKAGE_NAME}@${spec} (global), `\n      + `a version bump in your project, npx ${PACKAGE_NAME}@${spec}, or your Node manager (Volta: volta install ${PACKAGE_NAME}@${spec})`);\n    return ERROR_CODES.CONFIGURATION;\n  }\n\n  const resolved = resolveRelease(spec, deps);\n  if (!resolved.ok) {\n    if (resolved.notFound) {\n      printError(`${PACKAGE_NAME} has no version or dist-tag \"${spec}\"`);\n      return ERROR_CODES.VALIDATION;\n    }\n    printError(`Could not reach the npm registry to resolve ${PACKAGE_NAME}@${spec}`);\n    return ERROR_CODES.NETWORK;\n  }\n  const { release } = resolved;\n  const target = release.version;\n\n  const order = compareSemver(target, deps.currentVersion);\n  if (order === 0) {\n    printSuccess(`${APP_NAME} ${deps.currentVersion} is already ${requested === true ? 'the latest release' : 'installed'}`);\n    return 0;\n  }\n  // A bare --upgrade never moves backwards; naming a version is how to downgrade.\n  if (order < 0 && requested === true) {\n    printSuccess(`${APP_NAME} ${deps.currentVersion} is newer than the latest release (${target}); nothing to do`);\n    return 0;\n  }\n  // Only a DOWNGRADE can strand the user; moving up from a pre-flag build is fine.\n  if (order < 0 && compareSemver(target, UPGRADE_SINCE) < 0) {\n    printError(`${target} predates --upgrade (added in ${UPGRADE_SINCE}), so moving to it would leave no way back but a manual install`);\n    printInfo(`If that is what you want: npm install -g ${PACKAGE_NAME}@${target}`);\n    return ERROR_CODES.VALIDATION;\n  }\n  if (release.nodeRange) {\n    const fits = satisfiesRange(deps.nodeVersion, release.nodeRange);\n    if (fits === false) {\n      printError(`${APP_NAME} ${target} needs Node ${release.nodeRange}, but this is Node ${deps.nodeVersion}; upgrade Node first`);\n      return ERROR_CODES.CONFIGURATION;\n    }\n    if (fits === null) printWarning(`Could not check ${target}'s Node requirement \"${release.nodeRange}\" against ${deps.nodeVersion}`);\n  }\n\n  const verb = order > 0 ? 'Upgrading' : 'Downgrading';\n  if (opts.check) {\n    printInfo(`${APP_NAME} ${deps.currentVersion} → ${target} is available${owner ? '' : ' (not a global npm/pnpm install: update it with whatever installed it)'}`);\n    printInfo(`Changes: ${changesUrl(deps.currentVersion, target)}`);\n    return 1;\n  }\n  // `owner` is non-null past the !check guard above.\n  const own = owner!;\n\n  if (!deps.writable(own.root)) {\n    printError(`${own.root} is not writable by this user, so ${own.manager} cannot replace ${APP_NAME} there`);\n    // Never \"re-run pipeline-manager with sudo\": that runs the whole CLI (its\n    // credential store, its config) as root. Name the one command that needs it.\n    printInfo(`Either install just the package as root: sudo npm install -g ${PACKAGE_NAME}@${target}`);\n    printInfo('or move npm globals into your home directory (npm config set prefix ~/.npm-global, then add ~/.npm-global/bin to PATH) and re-run --upgrade');\n    return ERROR_CODES.FILE_SYSTEM;\n  }\n\n  printInfo(`${verb} ${APP_NAME} ${deps.currentVersion} → ${target} (${own.manager} global install)`);\n  const tmp = deps.makeTempDir();\n  try {\n    const fetched = fetchVerifiedTarball(release, tmp, deps);\n    if ('error' in fetched) {\n      printError(`Not installing ${target}: ${fetched.error}; ${APP_NAME} ${deps.currentVersion} is unchanged`);\n      return ERROR_CODES.GENERAL;\n    }\n    const install = own.manager === 'npm'\n      ? deps.run('npm', ['install', '-g', fetched.tarball], true)\n      : deps.run('pnpm', ['add', '-g', fetched.tarball], true);\n    if (install.status !== 0) {\n      printError(`${own.manager} could not install ${PACKAGE_NAME}@${target}; ${APP_NAME} ${deps.currentVersion} is unchanged`);\n      return ERROR_CODES.FILE_SYSTEM;\n    }\n  } finally {\n    deps.removeDir(tmp);\n  }\n\n  // Read the version back from disk rather than trusting the exit code.\n  const installed = deps.readVersion(own.dir);\n  if (installed !== target) {\n    printWarning(`${own.manager} reported success, but ${own.dir} holds ${installed ?? 'no readable package'} instead of ${target}`);\n    return ERROR_CODES.GENERAL;\n  }\n  printSuccess(`${APP_NAME} is now ${target} (was ${deps.currentVersion}); signature verified`);\n  printInfo(`What changed: ${changesUrl(deps.currentVersion, target)}`);\n  return 0;\n}\n\n/**\n * Register the top-level `--upgrade [version]` and `--upgrade-check [version]`\n * flags. Handled the way Commander handles `--version`: the option listener\n * runs and exits, so each works on its own without a root action that would\n * change how unknown commands are reported.\n */\nexport function registerUpgradeOption(\n  program: Command,\n  upgrade: (requested: string | true, opts: UpgradeOptions) => number = (r, o) => selfUpgrade(r, systemDeps(), o),\n): void {\n  program.option('--upgrade [version]', 'Upgrade this CLI in place to the latest release (or the given version / dist-tag)');\n  program.option('--upgrade-check [version]', 'Report whether --upgrade would change anything (exit 0 = current, 1 = available)');\n  // Commander's listener gets the value as given, or null/undefined for a bare\n  // flag (not `true`, unlike the parsed opts), so anything not a string means latest.\n  const latestOr = (value: unknown): string | true => (typeof value === 'string' ? value : true);\n  program.on('option:upgrade', (value: unknown) => process.exit(upgrade(latestOr(value), {})));\n  program.on('option:upgrade-check', (value: unknown) => process.exit(upgrade(latestOr(value), { check: true })));\n}\n"]}

package/dist/utils/error-handler.js

@@ -176,6 +176,10 @@ function resolveExitCode(err, fallback) {
             return ERROR_CODES.NOT_FOUND;
         if (status === 408 || status === 504)
             return ERROR_CODES.TIMEOUT;
+        // CLIENT_UPGRADE_REQUIRED: this CLI is below the platform's minimum — a
+        // local-install problem (fix: --upgrade), so scripts can tell it apart.
+        if (status === 426)
+            return ERROR_CODES.CONFIGURATION;
         if (status && status >= 500)
             return ERROR_CODES.API_REQUEST;
         // A request that got no HTTP response never reached the server (DNS / refused
@@ -306,4 +310,4 @@ function isAxiosError(err) {
         'isAxiosError' in err &&
         err.isAxiosError === true);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-handler.js","sources":["../../src/utils/error-handler.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { isQuotaExceededBody } from '@pipeline-builder/pipeline-core';\nimport pico from 'picocolors';\nimport { generateExecutionId } from '../config/cli.constants.js';\nimport {\n  ERROR_CODES,\n  type ErrorCode,\n  type ErrorHandlerOptions,\n  type AxiosErrorLike,\n} from '../types/index.js';\n\nconst { bold, dim, red, yellow, cyan } = pico;\n\n// Re-export for convenience\nexport { ERROR_CODES };\nexport type { ErrorCode };\n\n/**\n * Format and handle errors with colored output\n */\nexport function handleError(\n  err: unknown,\n  code: ErrorCode = ERROR_CODES.GENERAL,\n  options: ErrorHandlerOptions = {},\n): never {\n  const {\n    debug = false,\n    exit = true,\n    logToConsole = true,\n    context,\n    correlationId = generateExecutionId(),\n  } = options;\n\n  // Derive the canonical exit code from the ACTUAL error (see resolveExitCode),\n  // falling back to the caller's `code` for anything unclassifiable. This is what\n  // makes every command emit the SAME exit code for the same class of failure,\n  // rather than a blanket API_REQUEST/GENERAL. Used for display, the suggestion,\n  // and the process exit below.\n  const resolvedCode = resolveExitCode(err, code);\n\n  if (logToConsole) {\n    const divider = '─'.repeat(process.stdout.columns || 80);\n    const errorId = `ERR-${correlationId}`;\n\n    console.error('\\n' + red(bold('✗ ERROR')) + dim(` [${errorId}]`) + '\\n');\n    console.error(dim(divider));\n\n    if (err instanceof Error) {\n      console.error(red(bold('Message:')), err.message);\n\n      if (err.name !== 'Error') {\n        console.error(red('Type:'), err.name);\n      }\n\n      // Show Validation error details\n      if (err instanceof ValidationError) {\n        if (err.field) console.error(red('Field:'), err.field);\n        if (err.value !== undefined) console.error(red('Value:'), sanitizeValue(err.value));\n        if (err.rule) console.error(red('Rule:'), err.rule);\n        if (err.expected) console.error(red('Expected:'), err.expected);\n      }\n\n      // Show Network error details\n      if (err instanceof NetworkError) {\n        if (err.url) console.error(red('URL:'), sanitizeUrl(err.url));\n        if (err.timeout) console.error(red('Timeout:'), `${err.timeout}ms`);\n        console.error(red('Request Made:'), err.requestMade ? 'Yes' : 'No');\n        console.error(red('Response Received:'), err.responseReceived ? 'Yes' : 'No');\n        if (err.cause) console.error(red('Caused by:'), err.cause.message);\n      }\n\n      // Show Axios error details\n      if (isAxiosError(err)) {\n        const status = err.response?.status;\n        const url = err.config?.url;\n        if (status) {\n          console.error(red('Status:'), status);\n          console.error(red('Status Text:'), getHttpStatusText(status));\n        }\n        if (url) console.error(red('URL:'), sanitizeUrl(url));\n        if (err.response?.data) {\n          console.error(red('Response:'));\n          console.error(dim(sanitizeErrorData(err.response.data)));\n        }\n      }\n\n      // Show CDK/execSync error details (stderr captured from child process)\n      if ('stderr' in err && err.stderr) {\n        const stderr = (err.stderr as Buffer | string).toString().trim();\n        if (stderr) {\n          console.error(red('CDK Output:'));\n          console.error(dim(stderr));\n        }\n      }\n\n      console.error(red('Code:'), getErrorCodeName(resolvedCode));\n      console.error(dim('Error ID:'), dim(errorId));\n\n      if (context && Object.keys(context).length > 0) {\n        console.error('');\n        console.error(red('Context:'));\n        Object.entries(context).forEach(([key, value]) => {\n          console.error(`  ${cyan(key)}:`, dim(sanitizeValue(value)));\n        });\n      }\n\n      if (debug && err.stack) {\n        console.error('');\n        console.error(dim('Stack trace:'));\n        console.error(dim(sanitizeStackTrace(err.stack)));\n      }\n    } else {\n      console.error(red('Error:'), String(err));\n      console.error(red('Code:'), getErrorCodeName(resolvedCode));\n      console.error(dim('Error ID:'), dim(errorId));\n    }\n\n    console.error(dim(divider));\n\n    if (!debug) {\n      console.error(yellow('💡 Tip:'), dim('Run with --debug flag to see full stack trace'));\n    }\n\n    const suggestion = getErrorSuggestion(err, resolvedCode);\n    if (suggestion) {\n      console.error(yellow('💡 Suggestion:'), dim(suggestion));\n    }\n\n    console.error('');\n  }\n\n  if (exit) {\n    process.exitCode = resolvedCode;\n    process.exit(resolvedCode);\n  }\n\n  throw err;\n}\n\n// --- Error classes (only those actually used) ---\n\n/**\n * Validation error class\n */\nexport class ValidationError extends Error {\n  constructor(\n    message: string,\n    public field?: string,\n    public value?: unknown,\n    public rule?: string,\n    public expected?: string,\n  ) {\n    super(message);\n    this.name = 'ValidationError';\n    Error.captureStackTrace(this, this.constructor);\n  }\n}\n\n/**\n * Network error class\n */\nexport class NetworkError extends Error {\n  constructor(\n    message: string,\n    public url?: string,\n    public cause?: Error,\n    public timeout?: number,\n    public requestMade: boolean = true,\n    public responseReceived: boolean = false,\n  ) {\n    super(message);\n    this.name = 'NetworkError';\n    Error.captureStackTrace(this, this.constructor);\n  }\n}\n\n// --- Private helpers ---\n\n/**\n * Map the ACTUAL error to a canonical exit code so every command exits with the\n * SAME code for the same class of failure. The caller-supplied `fallback` (e.g.\n * API_REQUEST) is used only for errors this can't classify. Codes (src/types/error.ts):\n *\n *   1 GENERAL · 2 VALIDATION · 3 API_REQUEST · 4 AUTHENTICATION · 5 AUTHORIZATION\n *   6 NOT_FOUND · 7 NETWORK · 8 CONFIGURATION · 9 FILE_SYSTEM · 10 TIMEOUT\n *\n * Precedence: typed CLI errors → HTTP status → Node system error `code` → fallback.\n */\nfunction resolveExitCode(err: unknown, fallback: ErrorCode): ErrorCode {\n  if (err instanceof ValidationError) return ERROR_CODES.VALIDATION;\n  if (err instanceof NetworkError) return err.timeout ? ERROR_CODES.TIMEOUT : ERROR_CODES.NETWORK;\n\n  if (isAxiosError(err)) {\n    const status = err.response?.status;\n    if (status === 400 || status === 422) return ERROR_CODES.VALIDATION;\n    if (status === 401) return ERROR_CODES.AUTHENTICATION;\n    if (status === 403) return ERROR_CODES.AUTHORIZATION;\n    if (status === 404) return ERROR_CODES.NOT_FOUND;\n    if (status === 408 || status === 504) return ERROR_CODES.TIMEOUT;\n    if (status && status >= 500) return ERROR_CODES.API_REQUEST;\n    // A request that got no HTTP response never reached the server (DNS / refused\n    // / reset) — that's a network failure, not an API-response error.\n    if (!err.response) return ERROR_CODES.NETWORK;\n    return fallback;\n  }\n\n  // Node system errors (fs + sockets) carry a string `code`.\n  const sysCode = (err as { code?: unknown } | null)?.code;\n  if (typeof sysCode === 'string') {\n    if (['ENOENT', 'EACCES', 'EISDIR', 'ENOTDIR', 'EEXIST', 'EPERM', 'ENOSPC', 'EMFILE'].includes(sysCode)) {\n      return ERROR_CODES.FILE_SYSTEM;\n    }\n    if (sysCode === 'ETIMEDOUT') return ERROR_CODES.TIMEOUT;\n    if (['ECONNREFUSED', 'ENOTFOUND', 'ECONNRESET', 'EHOSTUNREACH', 'ENETUNREACH', 'EAI_AGAIN', 'EPIPE'].includes(sysCode)) {\n      return ERROR_CODES.NETWORK;\n    }\n  }\n\n  return fallback;\n}\n\nfunction getErrorCodeName(code: ErrorCode): string {\n  const entry = Object.entries(ERROR_CODES).find(([_, value]) => value === code);\n  return entry ? `${entry[0]} (${code})` : String(code);\n}\n\nfunction getHttpStatusText(status: number): string {\n  const statusTexts: Record<number, string> = {\n    400: 'Bad Request',\n    401: 'Unauthorized',\n    403: 'Forbidden',\n    404: 'Not Found',\n    408: 'Request Timeout',\n    409: 'Conflict',\n    422: 'Unprocessable Entity',\n    429: 'Too Many Requests',\n    500: 'Internal Server Error',\n    502: 'Bad Gateway',\n    503: 'Service Unavailable',\n    504: 'Gateway Timeout',\n  };\n  return statusTexts[status] || 'Unknown';\n}\n\nfunction getErrorSuggestion(err: unknown, code: ErrorCode): string | null {\n  if (code === ERROR_CODES.AUTHENTICATION) {\n    return 'Check that PLATFORM_TOKEN environment variable is set correctly';\n  }\n  if (code === ERROR_CODES.NETWORK) {\n    return 'Check your internet connection and API endpoint URL';\n  }\n  if (code === ERROR_CODES.CONFIGURATION) {\n    return 'Run \"cli version --check-config\" to verify configuration';\n  }\n  if (code === ERROR_CODES.NOT_FOUND) {\n    return 'Verify the resource ID exists and you have access to it';\n  }\n  if (err instanceof Error && err.message.includes('cdk')) {\n    return 'Check the CDK output above for CloudFormation errors. Run with --debug for full details';\n  }\n  if (err instanceof ValidationError && err.field) {\n    return `Check the value provided for \"${err.field}\"`;\n  }\n  if (isAxiosError(err)) {\n    const status = err.response?.status;\n    if (status === 401 || status === 403) return 'Check your authentication token and permissions';\n    // A quota refusal won't clear by waiting a moment: the message already names\n    // the reset date and the upgrade link (api-client). Only a plain 429 is a\n    // rate limit.\n    if (status === 429 && isQuotaExceededBody(err.response?.data)) {\n      return 'Retrying will not help until the quota resets — raise the limit at the upgrade link above';\n    }\n    if (status === 429) return 'Rate limit exceeded - wait a moment before retrying';\n    if (status && status >= 500) return 'Server error - try again later or contact support';\n  }\n  return null;\n}\n\nfunction sanitizeErrorData(data: unknown): string {\n  if (typeof data === 'string') return data;\n  if (typeof data === 'object' && data !== null) {\n    const sanitized = { ...data } as Record<string, unknown>;\n    ['token', 'password', 'secret', 'apiKey', 'authorization', 'jwt', 'credential', 'bearer'].forEach(field => {\n      if (field in sanitized) sanitized[field] = '[REDACTED]';\n    });\n    return JSON.stringify(sanitized, null, 2);\n  }\n  return String(data);\n}\n\nfunction sanitizeUrl(url: string): string {\n  try {\n    const urlObj = new URL(url);\n    ['token', 'key', 'secret', 'password', 'apiKey'].forEach(param => {\n      if (urlObj.searchParams.has(param)) urlObj.searchParams.set(param, '[REDACTED]');\n    });\n    return urlObj.toString();\n  } catch {\n    return url;\n  }\n}\n\nfunction sanitizeValue(value: unknown): string {\n  if (value === null) return 'null';\n  if (value === undefined) return 'undefined';\n  if (typeof value === 'string') {\n    if (value.length > 20 && /^[A-Za-z0-9+/=_-]+$/.test(value)) {\n      return `${value.substring(0, 8)}...[REDACTED]`;\n    }\n    return value.length > 100 ? value.substring(0, 97) + '...' : value;\n  }\n  if (typeof value === 'object') return sanitizeErrorData(value);\n  const str = String(value);\n  return str.length > 100 ? str.substring(0, 97) + '...' : str;\n}\n\nfunction sanitizeStackTrace(stack: string): string {\n  return stack.split('\\n').slice(0, 10).map(line => line.replace(/\\/.*?\\//g, '.../')).join('\\n');\n}\n\nfunction isAxiosError(err: unknown): err is AxiosErrorLike {\n  return (\n    typeof err === 'object' &&\n    err !== null &&\n    'isAxiosError' in err &&\n    (err as Record<string, unknown>).isAxiosError === true\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-handler.js","sources":["../../src/utils/error-handler.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,IAAI,MAAM,YAAY,CAAC;AAC9B,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EACL,WAAW,GAIZ,MAAM,mBAAmB,CAAC;AAE3B,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC;AAE9C,4BAA4B;AAC5B,OAAO,EAAE,WAAW,EAAE,CAAC;AAGvB;;GAEG;AACH,MAAM,UAAU,WAAW,CACzB,GAAY,EACZ,IAAI,GAAc,WAAW,CAAC,OAAO,EACrC,OAAO,GAAwB,EAAE;IAEjC,MAAM,EACJ,KAAK,GAAG,KAAK,EACb,IAAI,GAAG,IAAI,EACX,YAAY,GAAG,IAAI,EACnB,OAAO,EACP,aAAa,GAAG,mBAAmB,EAAE,GACtC,GAAG,OAAO,CAAC;IAEZ,8EAA8E;IAC9E,gFAAgF;IAChF,6EAA6E;IAC7E,+EAA+E;IAC/E,8BAA8B;IAC9B,MAAM,YAAY,GAAG,eAAe,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IAEhD,IAAI,YAAY,EAAE,CAAC;QACjB,MAAM,OAAO,GAAG,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC;QACzD,MAAM,OAAO,GAAG,OAAO,aAAa,EAAE,CAAC;QAEvC,OAAO,CAAC,KAAK,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,GAAG,CAAC,KAAK,OAAO,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;QACzE,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;QAE5B,IAAI,GAAG,YAAY,KAAK,EAAE,CAAC;YACzB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;YAElD,IAAI,GAAG,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;gBACzB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;YACxC,CAAC;YAED,gCAAgC;YAChC,IAAI,GAAG,YAAY,eAAe,EAAE,CAAC;gBACnC,IAAI,GAAG,CAAC,KAAK;oBAAE,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;gBACvD,IAAI,GAAG,CAAC,KAAK,KAAK,SAAS;oBAAE,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;gBACpF,IAAI,GAAG,CAAC,IAAI;oBAAE,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;gBACpD,IAAI,GAAG,CAAC,QAAQ;oBAAE,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAC;YAClE,CAAC;YAED,6BAA6B;YAC7B,IAAI,GAAG,YAAY,YAAY,EAAE,CAAC;gBAChC,IAAI,GAAG,CAAC,GAAG;oBAAE,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;gBAC9D,IAAI,GAAG,CAAC,OAAO;oBAAE,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,GAAG,GAAG,CAAC,OAAO,IAAI,CAAC,CAAC;gBACpE,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,eAAe,CAAC,EAAE,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;gBACpE,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,oBAAoB,CAAC,EAAE,GAAG,CAAC,gBAAgB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;gBAC9E,IAAI,GAAG,CAAC,KAAK;oBAAE,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YACrE,CAAC;YAED,2BAA2B;YAC3B,IAAI,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC;gBACtB,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC;gBACpC,MAAM,GAAG,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC;gBAC5B,IAAI,MAAM,EAAE,CAAC;oBACX,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC,CAAC;oBACtC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,cAAc,CAAC,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC;gBAChE,CAAC;gBACD,IAAI,GAAG;oBAAE,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC;gBACtD,IAAI,GAAG,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC;oBACvB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC;oBAChC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBAC3D,CAAC;YACH,CAAC;YAED,uEAAuE;YACvE,IAAI,QAAQ,IAAI,GAAG,IAAI,GAAG,CAAC,MAAM,EAAE,CAAC;gBAClC,MAAM,MAAM,GAAI,GAAG,CAAC,MAA0B,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC;gBACjE,IAAI,MAAM,EAAE,CAAC;oBACX,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC;oBAClC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;gBAC7B,CAAC;YACH,CAAC;YAED,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,gBAAgB,CAAC,YAAY,CAAC,CAAC,CAAC;YAC5D,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;YAE9C,IAAI,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC/C,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;gBAClB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC;gBAC/B,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;oBAC/C,OAAO,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBAC9D,CAAC,CAAC,CAAC;YACL,CAAC;YAED,IAAI,KAAK,IAAI,GAAG,CAAC,KAAK,EAAE,CAAC;gBACvB,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;gBAClB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC;gBACnC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,kBAAkB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACpD,CAAC;QACH,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;YAC1C,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,gBAAgB,CAAC,YAAY,CAAC,CAAC,CAAC;YAC5D,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;QAChD,CAAC;QAED,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;QAE5B,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,+CAA+C,CAAC,CAAC,CAAC;QACzF,CAAC;QAED,MAAM,UAAU,GAAG,kBAAkB,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;QACzD,IAAI,UAAU,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,gBAAgB,CAAC,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC;QAC3D,CAAC;QAED,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACpB,CAAC;IAED,IAAI,IAAI,EAAE,CAAC;QACT,OAAO,CAAC,QAAQ,GAAG,YAAY,CAAC;QAChC,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAC7B,CAAC;IAED,MAAM,GAAG,CAAC;AACZ,CAAC;AAED,mDAAmD;AAEnD;;GAEG;AACH,MAAM,OAAO,eAAgB,SAAQ,KAAK;IAG/B,KAAK;IACL,KAAK;IACL,IAAI;IACJ,QAAQ;IALjB,YACE,OAAe,EACR,KAAc,EACd,KAAe,EACf,IAAa,EACb,QAAiB;QAExB,KAAK,CAAC,OAAO,CAAC,CAAC;qBALR,KAAK;qBACL,KAAK;oBACL,IAAI;wBACJ,QAAQ;QAGf,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;QAC9B,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;IAClD,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,YAAa,SAAQ,KAAK;IAG5B,GAAG;IACH,KAAK;IACL,OAAO;IACP,WAAW;IACX,gBAAgB;IANzB,YACE,OAAe,EACR,GAAY,EACZ,KAAa,EACb,OAAgB,EAChB,WAAW,GAAY,IAAI,EAC3B,gBAAgB,GAAY,KAAK;QAExC,KAAK,CAAC,OAAO,CAAC,CAAC;mBANR,GAAG;qBACH,KAAK;uBACL,OAAO;2BACP,WAAW;gCACX,gBAAgB;QAGvB,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC;QAC3B,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;IAClD,CAAC;CACF;AAED,0BAA0B;AAE1B;;;;;;;;;GASG;AACH,SAAS,eAAe,CAAC,GAAY,EAAE,QAAmB;IACxD,IAAI,GAAG,YAAY,eAAe;QAAE,OAAO,WAAW,CAAC,UAAU,CAAC;IAClE,IAAI,GAAG,YAAY,YAAY;QAAE,OAAO,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC;IAEhG,IAAI,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC;QACtB,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC;QACpC,IAAI,MAAM,KAAK,GAAG,IAAI,MAAM,KAAK,GAAG;YAAE,OAAO,WAAW,CAAC,UAAU,CAAC;QACpE,IAAI,MAAM,KAAK,GAAG;YAAE,OAAO,WAAW,CAAC,cAAc,CAAC;QACtD,IAAI,MAAM,KAAK,GAAG;YAAE,OAAO,WAAW,CAAC,aAAa,CAAC;QACrD,IAAI,MAAM,KAAK,GAAG;YAAE,OAAO,WAAW,CAAC,SAAS,CAAC;QACjD,IAAI,MAAM,KAAK,GAAG,IAAI,MAAM,KAAK,GAAG;YAAE,OAAO,WAAW,CAAC,OAAO,CAAC;QACjE,wEAAwE;QACxE,wEAAwE;QACxE,IAAI,MAAM,KAAK,GAAG;YAAE,OAAO,WAAW,CAAC,aAAa,CAAC;QACrD,IAAI,MAAM,IAAI,MAAM,IAAI,GAAG;YAAE,OAAO,WAAW,CAAC,WAAW,CAAC;QAC5D,8EAA8E;QAC9E,kEAAkE;QAClE,IAAI,CAAC,GAAG,CAAC,QAAQ;YAAE,OAAO,WAAW,CAAC,OAAO,CAAC;QAC9C,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,2DAA2D;IAC3D,MAAM,OAAO,GAAI,GAAiC,EAAE,IAAI,CAAC;IACzD,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;QAChC,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YACvG,OAAO,WAAW,CAAC,WAAW,CAAC;QACjC,CAAC;QACD,IAAI,OAAO,KAAK,WAAW;YAAE,OAAO,WAAW,CAAC,OAAO,CAAC;QACxD,IAAI,CAAC,cAAc,EAAE,WAAW,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YACvH,OAAO,WAAW,CAAC,OAAO,CAAC;QAC7B,CAAC;IACH,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,SAAS,gBAAgB,CAAC,IAAe;IACvC,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC;IAC/E,OAAO,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AACxD,CAAC;AAED,SAAS,iBAAiB,CAAC,MAAc;IACvC,MAAM,WAAW,GAA2B;QAC1C,GAAG,EAAE,aAAa;QAClB,GAAG,EAAE,cAAc;QACnB,GAAG,EAAE,WAAW;QAChB,GAAG,EAAE,WAAW;QAChB,GAAG,EAAE,iBAAiB;QACtB,GAAG,EAAE,UAAU;QACf,GAAG,EAAE,sBAAsB;QAC3B,GAAG,EAAE,mBAAmB;QACxB,GAAG,EAAE,uBAAuB;QAC5B,GAAG,EAAE,aAAa;QAClB,GAAG,EAAE,qBAAqB;QAC1B,GAAG,EAAE,iBAAiB;KACvB,CAAC;IACF,OAAO,WAAW,CAAC,MAAM,CAAC,IAAI,SAAS,CAAC;AAC1C,CAAC;AAED,SAAS,kBAAkB,CAAC,GAAY,EAAE,IAAe;IACvD,IAAI,IAAI,KAAK,WAAW,CAAC,cAAc,EAAE,CAAC;QACxC,OAAO,iEAAiE,CAAC;IAC3E,CAAC;IACD,IAAI,IAAI,KAAK,WAAW,CAAC,OAAO,EAAE,CAAC;QACjC,OAAO,qDAAqD,CAAC;IAC/D,CAAC;IACD,IAAI,IAAI,KAAK,WAAW,CAAC,aAAa,EAAE,CAAC;QACvC,OAAO,0DAA0D,CAAC;IACpE,CAAC;IACD,IAAI,IAAI,KAAK,WAAW,CAAC,SAAS,EAAE,CAAC;QACnC,OAAO,yDAAyD,CAAC;IACnE,CAAC;IACD,IAAI,GAAG,YAAY,KAAK,IAAI,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACxD,OAAO,yFAAyF,CAAC;IACnG,CAAC;IACD,IAAI,GAAG,YAAY,eAAe,IAAI,GAAG,CAAC,KAAK,EAAE,CAAC;QAChD,OAAO,iCAAiC,GAAG,CAAC,KAAK,GAAG,CAAC;IACvD,CAAC;IACD,IAAI,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC;QACtB,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC;QACpC,IAAI,MAAM,KAAK,GAAG,IAAI,MAAM,KAAK,GAAG;YAAE,OAAO,iDAAiD,CAAC;QAC/F,6EAA6E;QAC7E,0EAA0E;QAC1E,cAAc;QACd,IAAI,MAAM,KAAK,GAAG,IAAI,mBAAmB,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,EAAE,CAAC;YAC9D,OAAO,2FAA2F,CAAC;QACrG,CAAC;QACD,IAAI,MAAM,KAAK,GAAG;YAAE,OAAO,qDAAqD,CAAC;QACjF,IAAI,MAAM,IAAI,MAAM,IAAI,GAAG;YAAE,OAAO,mDAAmD,CAAC;IAC1F,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,iBAAiB,CAAC,IAAa;IACtC,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IAC1C,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;QAC9C,MAAM,SAAS,GAAG,EAAE,GAAG,IAAI,EAA6B,CAAC;QACzD,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAE,KAAK,EAAE,YAAY,EAAE,QAAQ,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACxG,IAAI,KAAK,IAAI,SAAS;gBAAE,SAAS,CAAC,KAAK,CAAC,GAAG,YAAY,CAAC;QAC1D,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IAC5C,CAAC;IACD,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC;AACtB,CAAC;AAED,SAAS,WAAW,CAAC,GAAW;IAC9B,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;QAC5B,CAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YAC/D,IAAI,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC;gBAAE,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;QACnF,CAAC,CAAC,CAAC;QACH,OAAO,MAAM,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,GAAG,CAAC;IACb,CAAC;AACH,CAAC;AAED,SAAS,aAAa,CAAC,KAAc;IACnC,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,MAAM,CAAC;IAClC,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,WAAW,CAAC;IAC5C,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,IAAI,KAAK,CAAC,MAAM,GAAG,EAAE,IAAI,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YAC3D,OAAO,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,eAAe,CAAC;QACjD,CAAC;QACD,OAAO,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;IACrE,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,iBAAiB,CAAC,KAAK,CAAC,CAAC;IAC/D,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1B,OAAO,GAAG,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC;AAC/D,CAAC;AAED,SAAS,kBAAkB,CAAC,KAAa;IACvC,OAAO,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACjG,CAAC;AAED,SAAS,YAAY,CAAC,GAAY;IAChC,OAAO,CACL,OAAO,GAAG,KAAK,QAAQ;QACvB,GAAG,KAAK,IAAI;QACZ,cAAc,IAAI,GAAG;QACpB,GAA+B,CAAC,YAAY,KAAK,IAAI,CACvD,CAAC;AACJ,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { isQuotaExceededBody } from '@pipeline-builder/pipeline-core';\nimport pico from 'picocolors';\nimport { generateExecutionId } from '../config/cli.constants.js';\nimport {\n  ERROR_CODES,\n  type ErrorCode,\n  type ErrorHandlerOptions,\n  type AxiosErrorLike,\n} from '../types/index.js';\n\nconst { bold, dim, red, yellow, cyan } = pico;\n\n// Re-export for convenience\nexport { ERROR_CODES };\nexport type { ErrorCode };\n\n/**\n * Format and handle errors with colored output\n */\nexport function handleError(\n  err: unknown,\n  code: ErrorCode = ERROR_CODES.GENERAL,\n  options: ErrorHandlerOptions = {},\n): never {\n  const {\n    debug = false,\n    exit = true,\n    logToConsole = true,\n    context,\n    correlationId = generateExecutionId(),\n  } = options;\n\n  // Derive the canonical exit code from the ACTUAL error (see resolveExitCode),\n  // falling back to the caller's `code` for anything unclassifiable. This is what\n  // makes every command emit the SAME exit code for the same class of failure,\n  // rather than a blanket API_REQUEST/GENERAL. Used for display, the suggestion,\n  // and the process exit below.\n  const resolvedCode = resolveExitCode(err, code);\n\n  if (logToConsole) {\n    const divider = '─'.repeat(process.stdout.columns || 80);\n    const errorId = `ERR-${correlationId}`;\n\n    console.error('\\n' + red(bold('✗ ERROR')) + dim(` [${errorId}]`) + '\\n');\n    console.error(dim(divider));\n\n    if (err instanceof Error) {\n      console.error(red(bold('Message:')), err.message);\n\n      if (err.name !== 'Error') {\n        console.error(red('Type:'), err.name);\n      }\n\n      // Show Validation error details\n      if (err instanceof ValidationError) {\n        if (err.field) console.error(red('Field:'), err.field);\n        if (err.value !== undefined) console.error(red('Value:'), sanitizeValue(err.value));\n        if (err.rule) console.error(red('Rule:'), err.rule);\n        if (err.expected) console.error(red('Expected:'), err.expected);\n      }\n\n      // Show Network error details\n      if (err instanceof NetworkError) {\n        if (err.url) console.error(red('URL:'), sanitizeUrl(err.url));\n        if (err.timeout) console.error(red('Timeout:'), `${err.timeout}ms`);\n        console.error(red('Request Made:'), err.requestMade ? 'Yes' : 'No');\n        console.error(red('Response Received:'), err.responseReceived ? 'Yes' : 'No');\n        if (err.cause) console.error(red('Caused by:'), err.cause.message);\n      }\n\n      // Show Axios error details\n      if (isAxiosError(err)) {\n        const status = err.response?.status;\n        const url = err.config?.url;\n        if (status) {\n          console.error(red('Status:'), status);\n          console.error(red('Status Text:'), getHttpStatusText(status));\n        }\n        if (url) console.error(red('URL:'), sanitizeUrl(url));\n        if (err.response?.data) {\n          console.error(red('Response:'));\n          console.error(dim(sanitizeErrorData(err.response.data)));\n        }\n      }\n\n      // Show CDK/execSync error details (stderr captured from child process)\n      if ('stderr' in err && err.stderr) {\n        const stderr = (err.stderr as Buffer | string).toString().trim();\n        if (stderr) {\n          console.error(red('CDK Output:'));\n          console.error(dim(stderr));\n        }\n      }\n\n      console.error(red('Code:'), getErrorCodeName(resolvedCode));\n      console.error(dim('Error ID:'), dim(errorId));\n\n      if (context && Object.keys(context).length > 0) {\n        console.error('');\n        console.error(red('Context:'));\n        Object.entries(context).forEach(([key, value]) => {\n          console.error(`  ${cyan(key)}:`, dim(sanitizeValue(value)));\n        });\n      }\n\n      if (debug && err.stack) {\n        console.error('');\n        console.error(dim('Stack trace:'));\n        console.error(dim(sanitizeStackTrace(err.stack)));\n      }\n    } else {\n      console.error(red('Error:'), String(err));\n      console.error(red('Code:'), getErrorCodeName(resolvedCode));\n      console.error(dim('Error ID:'), dim(errorId));\n    }\n\n    console.error(dim(divider));\n\n    if (!debug) {\n      console.error(yellow('💡 Tip:'), dim('Run with --debug flag to see full stack trace'));\n    }\n\n    const suggestion = getErrorSuggestion(err, resolvedCode);\n    if (suggestion) {\n      console.error(yellow('💡 Suggestion:'), dim(suggestion));\n    }\n\n    console.error('');\n  }\n\n  if (exit) {\n    process.exitCode = resolvedCode;\n    process.exit(resolvedCode);\n  }\n\n  throw err;\n}\n\n// --- Error classes (only those actually used) ---\n\n/**\n * Validation error class\n */\nexport class ValidationError extends Error {\n  constructor(\n    message: string,\n    public field?: string,\n    public value?: unknown,\n    public rule?: string,\n    public expected?: string,\n  ) {\n    super(message);\n    this.name = 'ValidationError';\n    Error.captureStackTrace(this, this.constructor);\n  }\n}\n\n/**\n * Network error class\n */\nexport class NetworkError extends Error {\n  constructor(\n    message: string,\n    public url?: string,\n    public cause?: Error,\n    public timeout?: number,\n    public requestMade: boolean = true,\n    public responseReceived: boolean = false,\n  ) {\n    super(message);\n    this.name = 'NetworkError';\n    Error.captureStackTrace(this, this.constructor);\n  }\n}\n\n// --- Private helpers ---\n\n/**\n * Map the ACTUAL error to a canonical exit code so every command exits with the\n * SAME code for the same class of failure. The caller-supplied `fallback` (e.g.\n * API_REQUEST) is used only for errors this can't classify. Codes (src/types/error.ts):\n *\n *   1 GENERAL · 2 VALIDATION · 3 API_REQUEST · 4 AUTHENTICATION · 5 AUTHORIZATION\n *   6 NOT_FOUND · 7 NETWORK · 8 CONFIGURATION · 9 FILE_SYSTEM · 10 TIMEOUT\n *\n * Precedence: typed CLI errors → HTTP status → Node system error `code` → fallback.\n */\nfunction resolveExitCode(err: unknown, fallback: ErrorCode): ErrorCode {\n  if (err instanceof ValidationError) return ERROR_CODES.VALIDATION;\n  if (err instanceof NetworkError) return err.timeout ? ERROR_CODES.TIMEOUT : ERROR_CODES.NETWORK;\n\n  if (isAxiosError(err)) {\n    const status = err.response?.status;\n    if (status === 400 || status === 422) return ERROR_CODES.VALIDATION;\n    if (status === 401) return ERROR_CODES.AUTHENTICATION;\n    if (status === 403) return ERROR_CODES.AUTHORIZATION;\n    if (status === 404) return ERROR_CODES.NOT_FOUND;\n    if (status === 408 || status === 504) return ERROR_CODES.TIMEOUT;\n    // CLIENT_UPGRADE_REQUIRED: this CLI is below the platform's minimum — a\n    // local-install problem (fix: --upgrade), so scripts can tell it apart.\n    if (status === 426) return ERROR_CODES.CONFIGURATION;\n    if (status && status >= 500) return ERROR_CODES.API_REQUEST;\n    // A request that got no HTTP response never reached the server (DNS / refused\n    // / reset) — that's a network failure, not an API-response error.\n    if (!err.response) return ERROR_CODES.NETWORK;\n    return fallback;\n  }\n\n  // Node system errors (fs + sockets) carry a string `code`.\n  const sysCode = (err as { code?: unknown } | null)?.code;\n  if (typeof sysCode === 'string') {\n    if (['ENOENT', 'EACCES', 'EISDIR', 'ENOTDIR', 'EEXIST', 'EPERM', 'ENOSPC', 'EMFILE'].includes(sysCode)) {\n      return ERROR_CODES.FILE_SYSTEM;\n    }\n    if (sysCode === 'ETIMEDOUT') return ERROR_CODES.TIMEOUT;\n    if (['ECONNREFUSED', 'ENOTFOUND', 'ECONNRESET', 'EHOSTUNREACH', 'ENETUNREACH', 'EAI_AGAIN', 'EPIPE'].includes(sysCode)) {\n      return ERROR_CODES.NETWORK;\n    }\n  }\n\n  return fallback;\n}\n\nfunction getErrorCodeName(code: ErrorCode): string {\n  const entry = Object.entries(ERROR_CODES).find(([_, value]) => value === code);\n  return entry ? `${entry[0]} (${code})` : String(code);\n}\n\nfunction getHttpStatusText(status: number): string {\n  const statusTexts: Record<number, string> = {\n    400: 'Bad Request',\n    401: 'Unauthorized',\n    403: 'Forbidden',\n    404: 'Not Found',\n    408: 'Request Timeout',\n    409: 'Conflict',\n    422: 'Unprocessable Entity',\n    429: 'Too Many Requests',\n    500: 'Internal Server Error',\n    502: 'Bad Gateway',\n    503: 'Service Unavailable',\n    504: 'Gateway Timeout',\n  };\n  return statusTexts[status] || 'Unknown';\n}\n\nfunction getErrorSuggestion(err: unknown, code: ErrorCode): string | null {\n  if (code === ERROR_CODES.AUTHENTICATION) {\n    return 'Check that PLATFORM_TOKEN environment variable is set correctly';\n  }\n  if (code === ERROR_CODES.NETWORK) {\n    return 'Check your internet connection and API endpoint URL';\n  }\n  if (code === ERROR_CODES.CONFIGURATION) {\n    return 'Run \"cli version --check-config\" to verify configuration';\n  }\n  if (code === ERROR_CODES.NOT_FOUND) {\n    return 'Verify the resource ID exists and you have access to it';\n  }\n  if (err instanceof Error && err.message.includes('cdk')) {\n    return 'Check the CDK output above for CloudFormation errors. Run with --debug for full details';\n  }\n  if (err instanceof ValidationError && err.field) {\n    return `Check the value provided for \"${err.field}\"`;\n  }\n  if (isAxiosError(err)) {\n    const status = err.response?.status;\n    if (status === 401 || status === 403) return 'Check your authentication token and permissions';\n    // A quota refusal won't clear by waiting a moment: the message already names\n    // the reset date and the upgrade link (api-client). Only a plain 429 is a\n    // rate limit.\n    if (status === 429 && isQuotaExceededBody(err.response?.data)) {\n      return 'Retrying will not help until the quota resets — raise the limit at the upgrade link above';\n    }\n    if (status === 429) return 'Rate limit exceeded - wait a moment before retrying';\n    if (status && status >= 500) return 'Server error - try again later or contact support';\n  }\n  return null;\n}\n\nfunction sanitizeErrorData(data: unknown): string {\n  if (typeof data === 'string') return data;\n  if (typeof data === 'object' && data !== null) {\n    const sanitized = { ...data } as Record<string, unknown>;\n    ['token', 'password', 'secret', 'apiKey', 'authorization', 'jwt', 'credential', 'bearer'].forEach(field => {\n      if (field in sanitized) sanitized[field] = '[REDACTED]';\n    });\n    return JSON.stringify(sanitized, null, 2);\n  }\n  return String(data);\n}\n\nfunction sanitizeUrl(url: string): string {\n  try {\n    const urlObj = new URL(url);\n    ['token', 'key', 'secret', 'password', 'apiKey'].forEach(param => {\n      if (urlObj.searchParams.has(param)) urlObj.searchParams.set(param, '[REDACTED]');\n    });\n    return urlObj.toString();\n  } catch {\n    return url;\n  }\n}\n\nfunction sanitizeValue(value: unknown): string {\n  if (value === null) return 'null';\n  if (value === undefined) return 'undefined';\n  if (typeof value === 'string') {\n    if (value.length > 20 && /^[A-Za-z0-9+/=_-]+$/.test(value)) {\n      return `${value.substring(0, 8)}...[REDACTED]`;\n    }\n    return value.length > 100 ? value.substring(0, 97) + '...' : value;\n  }\n  if (typeof value === 'object') return sanitizeErrorData(value);\n  const str = String(value);\n  return str.length > 100 ? str.substring(0, 97) + '...' : str;\n}\n\nfunction sanitizeStackTrace(stack: string): string {\n  return stack.split('\\n').slice(0, 10).map(line => line.replace(/\\/.*?\\//g, '.../')).join('\\n');\n}\n\nfunction isAxiosError(err: unknown): err is AxiosErrorLike {\n  return (\n    typeof err === 'object' &&\n    err !== null &&\n    'isAxiosError' in err &&\n    (err as Record<string, unknown>).isAxiosError === true\n  );\n}\n"]}

package/dist/utils/request-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"request-context.d.ts","sources":["../../src/utils/request-context.ts"],"names":[],"mappings":"AA8BA,2EAA2E;AAC3E,eAAO,MAAM,kBAAkB,kBAAkB,CAAC;AAElD,gGAAgG;AAChG,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAE1D;AAED,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAEhD;AAED,0FAA0F;AAC1F,wBAAgB,eAAe,IAAI,MAAM,CAGxC;AAED,2FAA2F;AAC3F,wBAAgB,yBAAyB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAYtG"}
+{"version":3,"file":"request-context.d.ts","sources":["../../src/utils/request-context.ts"],"names":[],"mappings":"AAkCA,2EAA2E;AAC3E,eAAO,MAAM,kBAAkB,kBAAkB,CAAC;AAElD,gGAAgG;AAChG,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAE1D;AAED,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAEhD;AAED,0FAA0F;AAC1F,wBAAgB,eAAe,IAAI,MAAM,CAGxC;AAED,2FAA2F;AAC3F,wBAAgB,yBAAyB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAatG"}