@pipeline-builder/pipeline-manager 0.0.1

package/dist/types/plugin.js

@@ -0,0 +1,4 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/api-client.d.ts

@@ -0,0 +1,26 @@
+import FormData from 'form-data';
+import { type Config } from './config-loader.js';
+/**
+ * API Client for making HTTP requests to the platform API
+ */
+export declare class ApiClient {
+    private client;
+    private config;
+    constructor(config: Config);
+    private handleError;
+    get<T = unknown>(url: string, params?: Record<string, unknown>, headers?: Record<string, string>): Promise<T>;
+    post<T = unknown>(url: string, data?: unknown, headers?: Record<string, string>): Promise<T>;
+    postForm<T = unknown>(url: string, formData: FormData, headers?: Record<string, string>): Promise<T>;
+    put<T = unknown>(url: string, data?: unknown, headers?: Record<string, string>): Promise<T>;
+    delete<T = unknown>(url: string, headers?: Record<string, string>): Promise<T>;
+    patch<T = unknown>(url: string, data?: unknown, headers?: Record<string, string>): Promise<T>;
+    getConfig(): Config;
+    getBaseUrl(): string;
+    isAuthenticated(): boolean;
+    /**
+     * Advisory check: decode JWT exp claim and warn if expired.
+     * Does NOT verify signature — server handles that.
+     */
+    private checkTokenExpiry;
+}
+//# sourceMappingURL=api-client.d.ts.map

package/dist/utils/api-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-client.d.ts","sourceRoot":"","sources":["../../src/utils/api-client.ts"],"names":[],"mappings":"AAKA,OAAO,QAAQ,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAMjD;;GAEG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,MAAM,CAAS;IAEvB,YAAY,MAAM,EAAE,MAAM,EAsDzB;IAED,OAAO,CAAC,WAAW;IAkDb,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAGlH;IAEK,IAAI,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAGjG;IAEK,QAAQ,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CASzG;IAEK,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAGhG;IAEK,MAAM,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAGnF;IAEK,KAAK,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAGlG;IAED,SAAS,IAAI,MAAM,CAAwB;IAC3C,UAAU,IAAI,MAAM,CAAoC;IACxD,eAAe,IAAI,OAAO,CAAsC;IAEhE;;;OAGG;IACH,OAAO,CAAC,gBAAgB;CASzB"}

package/dist/utils/api-client.js

@@ -0,0 +1,151 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import https from 'https';
+import axios, { AxiosError } from 'axios';
+import FormData from 'form-data';
+import { decodeTokenPayload } from './auth-guard.js';
+import {} from './config-loader.js';
+import { NetworkError } from './error-handler.js';
+import { printDebug, printError, printWarning } from './output-utils.js';
+import { TIMEOUTS } from '../config/cli.constants.js';
+import { ApiError } from '../types/index.js';
+/**
+ * API Client for making HTTP requests to the platform API
+ */
+export class ApiClient {
+    client;
+    config;
+    constructor(config) {
+        this.config = config;
+        if (!config.auth?.token) {
+            throw new Error('Authentication token is required. Set PLATFORM_TOKEN environment variable.');
+        }
+        // Warn if token appears expired (advisory — server validates authoritatively)
+        this.checkTokenExpiry(config.auth.token);
+        const httpsAgent = new https.Agent({
+            rejectUnauthorized: config.api.rejectUnauthorized ?? true,
+        });
+        if (config.api.rejectUnauthorized === false) {
+            printWarning('Certificate validation is disabled');
+        }
+        this.client = axios.create({
+            baseURL: config.api.baseUrl,
+            timeout: config.api.timeout || TIMEOUTS.HTTP_REQUEST,
+            httpsAgent,
+            headers: { 'Content-Type': 'application/json' },
+        });
+        // Auth interceptor
+        this.client.interceptors.request.use((requestConfig) => {
+            requestConfig.headers.Authorization = `Bearer ${config.auth.token}`;
+            printDebug('API Request', {
+                method: requestConfig.method?.toUpperCase(),
+                url: requestConfig.url,
+                baseURL: requestConfig.baseURL,
+            });
+            return requestConfig;
+        }, (error) => {
+            printError('Request interceptor error', { error: error.message });
+            return Promise.reject(error);
+        });
+        // Response interceptor
+        this.client.interceptors.response.use((response) => {
+            printDebug('API Response', {
+                status: response.status,
+                statusText: response.statusText,
+                url: response.config.url,
+            });
+            return response;
+        }, (error) => this.handleError(error));
+    }
+    handleError(error) {
+        if (error.response) {
+            const { status, statusText, data } = error.response;
+            const url = error.config?.url;
+            // The response body (`data`) can carry tokens/PII, and printError always writes
+            // (not gated on DEBUG) — keep it out of the always-on line; surface it only under DEBUG.
+            printError('API request failed', { status, statusText, url });
+            printDebug('API error response body', { data });
+            let message = `API request failed with status ${status}`;
+            if (data && typeof data === 'object' && 'message' in data && typeof data.message === 'string') {
+                message = data.message;
+            }
+            return Promise.reject(new ApiError(message, status, error.response));
+        }
+        else if (error.request) {
+            const code = error.code || 'UNKNOWN';
+            const url = error.config?.url;
+            const timeout = error.config?.timeout;
+            const cause = error.cause;
+            printError('No response received from API', {
+                url,
+                timeout,
+                code,
+                ...(cause instanceof Error ? { cause: cause.message } : {}),
+            });
+            const hints = {
+                ECONNREFUSED: 'Server is not running or port is wrong',
+                ECONNRESET: 'Server closed the connection unexpectedly',
+                ETIMEDOUT: 'Connection timed out — server unreachable or too slow',
+                ENOTFOUND: 'DNS lookup failed — check the hostname in baseUrl',
+                ERR_BAD_REQUEST: 'Request was malformed — check the endpoint and payload',
+                CERT_HAS_EXPIRED: 'SSL certificate expired — use --no-verify-ssl for dev',
+                DEPTH_ZERO_SELF_SIGNED_CERT: 'Self-signed certificate — use --no-verify-ssl',
+                UNABLE_TO_VERIFY_LEAF_SIGNATURE: 'SSL chain incomplete — use --no-verify-ssl for dev',
+            };
+            const hint = hints[code] || 'Check network connectivity and server status';
+            const message = `${code}: ${hint} (url: ${url})`;
+            return Promise.reject(new NetworkError(message, url, error, timeout));
+        }
+        else {
+            printError('API request error', { error: error.message });
+            return Promise.reject(error);
+        }
+    }
+    async get(url, params, headers) {
+        const response = await this.client.get(url, { params, headers });
+        return response.data;
+    }
+    async post(url, data, headers) {
+        const response = await this.client.post(url, data, { headers });
+        return response.data;
+    }
+    async postForm(url, formData, headers) {
+        const uploadTimeout = this.config.api.uploadTimeout || 15 * 60 * 1000; // default 15 minutes
+        const response = await this.client.post(url, formData, {
+            headers: { ...formData.getHeaders(), ...headers },
+            maxContentLength: Infinity,
+            maxBodyLength: Infinity,
+            timeout: uploadTimeout,
+        });
+        return response.data;
+    }
+    async put(url, data, headers) {
+        const response = await this.client.put(url, data, { headers });
+        return response.data;
+    }
+    async delete(url, headers) {
+        const response = await this.client.delete(url, { headers });
+        return response.data;
+    }
+    async patch(url, data, headers) {
+        const response = await this.client.patch(url, data, { headers });
+        return response.data;
+    }
+    getConfig() { return this.config; }
+    getBaseUrl() { return this.config.api.baseUrl; }
+    isAuthenticated() { return !!this.config.auth?.token; }
+    /**
+     * Advisory check: decode JWT exp claim and warn if expired.
+     * Does NOT verify signature — server handles that.
+     */
+    checkTokenExpiry(token) {
+        const payload = decodeTokenPayload(token);
+        if (payload && typeof payload.exp === 'number') {
+            const expiresAt = new Date(payload.exp * 1000);
+            if (expiresAt.getTime() < Date.now()) {
+                printWarning(`Token expired at ${expiresAt.toISOString()} — run "pipeline-manager auth login" to refresh`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-client.js","sourceRoot":"","sources":["../../src/utils/api-client.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport https from 'https';\nimport axios, { type AxiosInstance, AxiosError } from 'axios';\nimport FormData from 'form-data';\nimport { decodeTokenPayload } from './auth-guard.js';\nimport { type Config } from './config-loader.js';\nimport { NetworkError } from './error-handler.js';\nimport { printDebug, printError, printWarning } from './output-utils.js';\nimport { TIMEOUTS } from '../config/cli.constants.js';\nimport { ApiError } from '../types/index.js';\n\n/**\n * API Client for making HTTP requests to the platform API\n */\nexport class ApiClient {\n  private client: AxiosInstance;\n  private config: Config;\n\n  constructor(config: Config) {\n    this.config = config;\n\n    if (!config.auth?.token) {\n      throw new Error('Authentication token is required. Set PLATFORM_TOKEN environment variable.');\n    }\n\n    // Warn if token appears expired (advisory — server validates authoritatively)\n    this.checkTokenExpiry(config.auth.token);\n\n    const httpsAgent = new https.Agent({\n      rejectUnauthorized: config.api.rejectUnauthorized ?? true,\n    });\n\n    if (config.api.rejectUnauthorized === false) {\n      printWarning('Certificate validation is disabled');\n    }\n\n    this.client = axios.create({\n      baseURL: config.api.baseUrl,\n      timeout: config.api.timeout || TIMEOUTS.HTTP_REQUEST,\n      httpsAgent,\n      headers: { 'Content-Type': 'application/json' },\n    });\n\n    // Auth interceptor\n    this.client.interceptors.request.use(\n      (requestConfig) => {\n        requestConfig.headers.Authorization = `Bearer ${config.auth.token}`;\n        printDebug('API Request', {\n          method: requestConfig.method?.toUpperCase(),\n          url: requestConfig.url,\n          baseURL: requestConfig.baseURL,\n        });\n        return requestConfig;\n      },\n      (error) => {\n        printError('Request interceptor error', { error: error.message });\n        return Promise.reject(error);\n      },\n    );\n\n    // Response interceptor\n    this.client.interceptors.response.use(\n      (response) => {\n        printDebug('API Response', {\n          status: response.status,\n          statusText: response.statusText,\n          url: response.config.url,\n        });\n        return response;\n      },\n      (error: AxiosError) => this.handleError(error),\n    );\n  }\n\n  private handleError(error: AxiosError): Promise<never> {\n    if (error.response) {\n      const { status, statusText, data } = error.response;\n      const url = error.config?.url;\n\n      // The response body (`data`) can carry tokens/PII, and printError always writes\n      // (not gated on DEBUG) — keep it out of the always-on line; surface it only under DEBUG.\n      printError('API request failed', { status, statusText, url });\n      printDebug('API error response body', { data });\n\n      let message = `API request failed with status ${status}`;\n      if (data && typeof data === 'object' && 'message' in data && typeof (data as { message: unknown }).message === 'string') {\n        message = (data as { message: string }).message;\n      }\n\n      return Promise.reject(new ApiError(message, status, error.response));\n    } else if (error.request) {\n      const code = error.code || 'UNKNOWN';\n      const url = error.config?.url;\n      const timeout = error.config?.timeout;\n      const cause = error.cause;\n\n      printError('No response received from API', {\n        url,\n        timeout,\n        code,\n        ...(cause instanceof Error ? { cause: cause.message } : {}),\n      });\n\n      const hints: Record<string, string> = {\n        ECONNREFUSED: 'Server is not running or port is wrong',\n        ECONNRESET: 'Server closed the connection unexpectedly',\n        ETIMEDOUT: 'Connection timed out — server unreachable or too slow',\n        ENOTFOUND: 'DNS lookup failed — check the hostname in baseUrl',\n        ERR_BAD_REQUEST: 'Request was malformed — check the endpoint and payload',\n        CERT_HAS_EXPIRED: 'SSL certificate expired — use --no-verify-ssl for dev',\n        DEPTH_ZERO_SELF_SIGNED_CERT: 'Self-signed certificate — use --no-verify-ssl',\n        UNABLE_TO_VERIFY_LEAF_SIGNATURE: 'SSL chain incomplete — use --no-verify-ssl for dev',\n      };\n\n      const hint = hints[code] || 'Check network connectivity and server status';\n      const message = `${code}: ${hint} (url: ${url})`;\n\n      return Promise.reject(new NetworkError(message, url, error, timeout));\n    } else {\n      printError('API request error', { error: error.message });\n      return Promise.reject(error);\n    }\n  }\n\n  async get<T = unknown>(url: string, params?: Record<string, unknown>, headers?: Record<string, string>): Promise<T> {\n    const response = await this.client.get<T>(url, { params, headers });\n    return response.data;\n  }\n\n  async post<T = unknown>(url: string, data?: unknown, headers?: Record<string, string>): Promise<T> {\n    const response = await this.client.post<T>(url, data, { headers });\n    return response.data;\n  }\n\n  async postForm<T = unknown>(url: string, formData: FormData, headers?: Record<string, string>): Promise<T> {\n    const uploadTimeout = this.config.api.uploadTimeout || 15 * 60 * 1000; // default 15 minutes\n    const response = await this.client.post<T>(url, formData, {\n      headers: { ...formData.getHeaders(), ...headers },\n      maxContentLength: Infinity,\n      maxBodyLength: Infinity,\n      timeout: uploadTimeout,\n    });\n    return response.data;\n  }\n\n  async put<T = unknown>(url: string, data?: unknown, headers?: Record<string, string>): Promise<T> {\n    const response = await this.client.put<T>(url, data, { headers });\n    return response.data;\n  }\n\n  async delete<T = unknown>(url: string, headers?: Record<string, string>): Promise<T> {\n    const response = await this.client.delete<T>(url, { headers });\n    return response.data;\n  }\n\n  async patch<T = unknown>(url: string, data?: unknown, headers?: Record<string, string>): Promise<T> {\n    const response = await this.client.patch<T>(url, data, { headers });\n    return response.data;\n  }\n\n  getConfig(): Config { return this.config; }\n  getBaseUrl(): string { return this.config.api.baseUrl; }\n  isAuthenticated(): boolean { return !!this.config.auth?.token; }\n\n  /**\n   * Advisory check: decode JWT exp claim and warn if expired.\n   * Does NOT verify signature — server handles that.\n   */\n  private checkTokenExpiry(token: string): void {\n    const payload = decodeTokenPayload(token);\n    if (payload && typeof payload.exp === 'number') {\n      const expiresAt = new Date(payload.exp * 1000);\n      if (expiresAt.getTime() < Date.now()) {\n        printWarning(`Token expired at ${expiresAt.toISOString()} — run \"pipeline-manager auth login\" to refresh`);\n      }\n    }\n  }\n}\n"]}

package/dist/utils/audit-log.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Log a sensitive operation to the local audit file.
+ *
+ * @param command - The command name (e.g., 'store-token', 'deploy', 'bootstrap')
+ * @param details - Non-sensitive metadata about the operation
+ */
+export declare function auditLog(command: string, details?: Record<string, unknown>): void;
+//# sourceMappingURL=audit-log.d.ts.map

package/dist/utils/audit-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-log.d.ts","sourceRoot":"","sources":["../../src/utils/audit-log.ts"],"names":[],"mappings":"AAqCA;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAwBjF"}

package/dist/utils/audit-log.js

@@ -0,0 +1,57 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { printDebug } from './output-utils.js';
+/**
+ * Local audit logger for sensitive CLI operations.
+ * Writes timestamped entries to ~/.pipeline-manager/audit.log.
+ * Never logs credentials or tokens — only operation metadata.
+ */
+const AUDIT_DIR = path.join(os.homedir(), '.pipeline-manager');
+const AUDIT_FILE = path.join(AUDIT_DIR, 'audit.log');
+const MAX_AUDIT_SIZE = 1024 * 1024; // 1MB — rotate when exceeded
+const MAX_ROTATED = 5; // keep audit.log.1 .. .5 (history isn't lost on repeated rotations)
+/** Shift audit.log.{n} → .{n+1} (dropping the oldest), then audit.log → .1. */
+function rotate() {
+    const oldest = `${AUDIT_FILE}.${MAX_ROTATED}`;
+    if (fs.existsSync(oldest))
+        fs.unlinkSync(oldest);
+    for (let i = MAX_ROTATED - 1; i >= 1; i--) {
+        const src = `${AUDIT_FILE}.${i}`;
+        if (fs.existsSync(src))
+            fs.renameSync(src, `${AUDIT_FILE}.${i + 1}`);
+    }
+    fs.renameSync(AUDIT_FILE, `${AUDIT_FILE}.1`);
+}
+/**
+ * Log a sensitive operation to the local audit file.
+ *
+ * @param command - The command name (e.g., 'store-token', 'deploy', 'bootstrap')
+ * @param details - Non-sensitive metadata about the operation
+ */
+export function auditLog(command, details) {
+    try {
+        if (!fs.existsSync(AUDIT_DIR)) {
+            fs.mkdirSync(AUDIT_DIR, { recursive: true, mode: 0o700 });
+        }
+        // Rotate if file is too large (keeps MAX_ROTATED archives)
+        if (fs.existsSync(AUDIT_FILE) && fs.statSync(AUDIT_FILE).size > MAX_AUDIT_SIZE) {
+            rotate();
+        }
+        const entry = {
+            timestamp: new Date().toISOString(),
+            command,
+            user: os.userInfo().username,
+            details,
+        };
+        fs.appendFileSync(AUDIT_FILE, JSON.stringify(entry) + '\n', { mode: 0o600 });
+    }
+    catch (err) {
+        // Audit logging is best-effort — never block the CLI — but surface the failure
+        // in debug so a silently-unrecorded sensitive op is at least diagnosable.
+        printDebug('Audit log write failed', { command, error: err instanceof Error ? err.message : String(err) });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/auth-guard.d.ts

@@ -0,0 +1,20 @@
+interface TokenPayload {
+    role?: string;
+    isAdmin?: boolean;
+    sub?: string;
+    organizationId?: string;
+    /** Standard JWT expiry claim, in seconds since epoch. */
+    exp?: number;
+    /** Standard JWT issued-at claim, in seconds since epoch. */
+    iat?: number;
+}
+/**
+ * Decode a JWT token payload without signature verification.
+ *
+ * SECURITY: NO signature verification. The decoded payload MUST NOT be used
+ * for authorization decisions — the server validates the token on every API
+ * call. Use only for advisory UX hints.
+ */
+export declare function decodeTokenPayload(token: string): TokenPayload | null;
+export {};
+//# sourceMappingURL=auth-guard.d.ts.map

package/dist/utils/auth-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-guard.d.ts","sourceRoot":"","sources":["../../src/utils/auth-guard.ts"],"names":[],"mappings":"AAGA,UAAU,YAAY;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,yDAAyD;IACzD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,4DAA4D;IAC5D,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CASrE"}

package/dist/utils/auth-guard.js

@@ -0,0 +1,22 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Decode a JWT token payload without signature verification.
+ *
+ * SECURITY: NO signature verification. The decoded payload MUST NOT be used
+ * for authorization decisions — the server validates the token on every API
+ * call. Use only for advisory UX hints.
+ */
+export function decodeTokenPayload(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3 || !parts[1])
+            return null;
+        const payload = Buffer.from(parts[1], 'base64url').toString('utf-8');
+        return JSON.parse(payload);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,68 @@
+import https from 'https';
+/**
+ * Login / refresh / switch-org response — every platform auth endpoint returns
+ * the session tokens under this envelope.
+ */
+export interface AuthResponse {
+    success: boolean;
+    data: {
+        accessToken: string;
+        refreshToken: string;
+    };
+}
+/**
+ * Guard the credential-transmitting commands (`login`, `create-pat`) against
+ * disabling TLS verification in production. These POST plaintext passwords/JWTs,
+ * so a MITM on a `prod + --no-verify-ssl` run would harvest them.
+ *
+ * Unlike {@link assertSslDisableAllowed} (which throws — for paths already inside
+ * a try/catch), this prints and hard-exits, matching the pre-flight checks these
+ * commands run before their try block. In non-production it is a no-op, so
+ * `--no-verify-ssl` still works against self-signed dev platforms.
+ */
+export declare function assertCredentialTlsAllowed(verifySsl: boolean | undefined): void;
+/**
+ * Resolve credentials from flags, falling back to the
+ * PLATFORM_IDENTIFIER / PLATFORM_PASSWORD env vars (so the password need not
+ * appear in shell history / `ps`).
+ */
+export declare function resolveCredentials(options: {
+    identifier?: string;
+    password?: string;
+}): {
+    identifier?: string;
+    password?: string;
+};
+/**
+ * Build the https agent used by the credential commands. `--verify-ssl`
+ * defaults to on; only an explicit `--no-verify-ssl` relaxes it (and only
+ * outside production, enforced by {@link assertCredentialTlsAllowed}).
+ */
+export declare function credentialHttpsAgent(verifySsl: boolean | undefined): https.Agent;
+/**
+ * POST /api/auth/login and return the access token (or `undefined` if the
+ * response carried none). Rate-limit accounting (record success/failure) and
+ * the no-token exit are intentionally left to the caller so each command keeps
+ * its exact lockout semantics.
+ */
+export declare function postLogin(params: {
+    url: string;
+    identifier: string;
+    password: string;
+    httpsAgent: https.Agent;
+    timeout: number;
+}): Promise<string | undefined>;
+/**
+ * POST /api/auth/switch-org with the current access token and return the new,
+ * org-scoped access token. Prints a success line (unless `quiet`) and hard-exits
+ * on a missing token — both credential commands treat a failed switch the same.
+ */
+export declare function switchOrganization(params: {
+    url: string;
+    orgId: string;
+    accessToken: string;
+    httpsAgent: https.Agent;
+    timeout: number;
+    quiet: boolean;
+}): Promise<string>;
+//# sourceMappingURL=auth-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auth-utils.d.ts","sourceRoot":"","sources":["../../src/utils/auth-utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,OAAO,CAAC;AAM1B;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE;QACJ,WAAW,EAAE,MAAM,CAAC;QACpB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;CACH;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAK/E;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IACvF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAKA;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,OAAO,GAAG,SAAS,GAAG,KAAK,CAAC,KAAK,CAEhF;AAED;;;;;GAKG;AACH,wBAAsB,SAAS,CAAC,MAAM,EAAE;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAS9B;AAED;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC/C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,OAAO,CAAC,MAAM,CAAC,CAmBlB"}

package/dist/utils/auth-utils.js

@@ -0,0 +1,77 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import https from 'https';
+import axios from 'axios';
+import { ERROR_CODES } from './error-handler.js';
+import { printDebug, printError, printSuccess } from './output-utils.js';
+import { isProductionEnv } from './tls.js';
+/**
+ * Guard the credential-transmitting commands (`login`, `create-pat`) against
+ * disabling TLS verification in production. These POST plaintext passwords/JWTs,
+ * so a MITM on a `prod + --no-verify-ssl` run would harvest them.
+ *
+ * Unlike {@link assertSslDisableAllowed} (which throws — for paths already inside
+ * a try/catch), this prints and hard-exits, matching the pre-flight checks these
+ * commands run before their try block. In non-production it is a no-op, so
+ * `--no-verify-ssl` still works against self-signed dev platforms.
+ */
+export function assertCredentialTlsAllowed(verifySsl) {
+    if (verifySsl === false && isProductionEnv()) {
+        printError('Refusing to disable TLS verification in production (NODE_ENV=production) — credentials must not be transmitted over an unverified connection. Use a valid certificate, or unset NODE_ENV for local/self-signed development.');
+        process.exit(ERROR_CODES.AUTHENTICATION);
+    }
+}
+/**
+ * Resolve credentials from flags, falling back to the
+ * PLATFORM_IDENTIFIER / PLATFORM_PASSWORD env vars (so the password need not
+ * appear in shell history / `ps`).
+ */
+export function resolveCredentials(options) {
+    return {
+        identifier: options.identifier || process.env.PLATFORM_IDENTIFIER,
+        password: options.password || process.env.PLATFORM_PASSWORD,
+    };
+}
+/**
+ * Build the https agent used by the credential commands. `--verify-ssl`
+ * defaults to on; only an explicit `--no-verify-ssl` relaxes it (and only
+ * outside production, enforced by {@link assertCredentialTlsAllowed}).
+ */
+export function credentialHttpsAgent(verifySsl) {
+    return new https.Agent({ rejectUnauthorized: verifySsl ?? true });
+}
+/**
+ * POST /api/auth/login and return the access token (or `undefined` if the
+ * response carried none). Rate-limit accounting (record success/failure) and
+ * the no-token exit are intentionally left to the caller so each command keeps
+ * its exact lockout semantics.
+ */
+export async function postLogin(params) {
+    const loginUrl = `${params.url}/api/auth/login`;
+    printDebug('POST', { url: loginUrl });
+    const response = await axios.post(loginUrl, { identifier: params.identifier, password: params.password }, { headers: { 'Content-Type': 'application/json' }, httpsAgent: params.httpsAgent, timeout: params.timeout });
+    return response.data?.data?.accessToken;
+}
+/**
+ * POST /api/auth/switch-org with the current access token and return the new,
+ * org-scoped access token. Prints a success line (unless `quiet`) and hard-exits
+ * on a missing token — both credential commands treat a failed switch the same.
+ */
+export async function switchOrganization(params) {
+    const switchUrl = `${params.url}/api/auth/switch-org`;
+    printDebug('POST', { url: switchUrl });
+    const response = await axios.post(switchUrl, { organizationId: params.orgId }, {
+        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${params.accessToken}` },
+        httpsAgent: params.httpsAgent,
+        timeout: params.timeout,
+    });
+    const switched = response.data?.data?.accessToken;
+    if (!switched) {
+        printError('Organization switch failed: no access token in response');
+        process.exit(ERROR_CODES.AUTHENTICATION);
+    }
+    if (!params.quiet)
+        printSuccess(`Switched to organization ${params.orgId}`);
+    return switched;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth-utils.js","sourceRoot":"","sources":["../../src/utils/auth-utils.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAc3C;;;;;;;;;GASG;AACH,MAAM,UAAU,0BAA0B,CAAC,SAA8B;IACvE,IAAI,SAAS,KAAK,KAAK,IAAI,eAAe,EAAE,EAAE,CAAC;QAC7C,UAAU,CAAC,6NAA6N,CAAC,CAAC;QAC1O,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;IAC3C,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,OAAmD;IAIpF,OAAO;QACL,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,OAAO,CAAC,GAAG,CAAC,mBAAmB;QACjE,QAAQ,EAAE,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,GAAG,CAAC,iBAAiB;KAC5D,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,SAA8B;IACjE,OAAO,IAAI,KAAK,CAAC,KAAK,CAAC,EAAE,kBAAkB,EAAE,SAAS,IAAI,IAAI,EAAE,CAAC,CAAC;AACpE,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,MAM/B;IACC,MAAM,QAAQ,GAAG,GAAG,MAAM,CAAC,GAAG,iBAAiB,CAAC;IAChD,UAAU,CAAC,MAAM,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC;IACtC,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,IAAI,CAC/B,QAAQ,EACR,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,EAC5D,EAAE,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,CAC5G,CAAC;IACF,OAAO,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,CAAC;AAC1C,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAAC,MAOxC;IACC,MAAM,SAAS,GAAG,GAAG,MAAM,CAAC,GAAG,sBAAsB,CAAC;IACtD,UAAU,CAAC,MAAM,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC,CAAC;IACvC,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,IAAI,CAC/B,SAAS,EACT,EAAE,cAAc,EAAE,MAAM,CAAC,KAAK,EAAE,EAChC;QACE,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE,eAAe,EAAE,UAAU,MAAM,CAAC,WAAW,EAAE,EAAE;QAChG,UAAU,EAAE,MAAM,CAAC,UAAU;QAC7B,OAAO,EAAE,MAAM,CAAC,OAAO;KACxB,CACF,CAAC;IACF,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,CAAC;IAClD,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,UAAU,CAAC,yDAAyD,CAAC,CAAC;QACtE,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;IAC3C,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,KAAK;QAAE,YAAY,CAAC,4BAA4B,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;IAC5E,OAAO,QAAQ,CAAC;AAClB,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport https from 'https';\nimport axios from 'axios';\nimport { ERROR_CODES } from './error-handler.js';\nimport { printDebug, printError, printSuccess } from './output-utils.js';\nimport { isProductionEnv } from './tls.js';\n\n/**\n * Login / refresh / switch-org response — every platform auth endpoint returns\n * the session tokens under this envelope.\n */\nexport interface AuthResponse {\n  success: boolean;\n  data: {\n    accessToken: string;\n    refreshToken: string;\n  };\n}\n\n/**\n * Guard the credential-transmitting commands (`login`, `create-pat`) against\n * disabling TLS verification in production. These POST plaintext passwords/JWTs,\n * so a MITM on a `prod + --no-verify-ssl` run would harvest them.\n *\n * Unlike {@link assertSslDisableAllowed} (which throws — for paths already inside\n * a try/catch), this prints and hard-exits, matching the pre-flight checks these\n * commands run before their try block. In non-production it is a no-op, so\n * `--no-verify-ssl` still works against self-signed dev platforms.\n */\nexport function assertCredentialTlsAllowed(verifySsl: boolean | undefined): void {\n  if (verifySsl === false && isProductionEnv()) {\n    printError('Refusing to disable TLS verification in production (NODE_ENV=production) — credentials must not be transmitted over an unverified connection. Use a valid certificate, or unset NODE_ENV for local/self-signed development.');\n    process.exit(ERROR_CODES.AUTHENTICATION);\n  }\n}\n\n/**\n * Resolve credentials from flags, falling back to the\n * PLATFORM_IDENTIFIER / PLATFORM_PASSWORD env vars (so the password need not\n * appear in shell history / `ps`).\n */\nexport function resolveCredentials(options: { identifier?: string; password?: string }): {\n  identifier?: string;\n  password?: string;\n} {\n  return {\n    identifier: options.identifier || process.env.PLATFORM_IDENTIFIER,\n    password: options.password || process.env.PLATFORM_PASSWORD,\n  };\n}\n\n/**\n * Build the https agent used by the credential commands. `--verify-ssl`\n * defaults to on; only an explicit `--no-verify-ssl` relaxes it (and only\n * outside production, enforced by {@link assertCredentialTlsAllowed}).\n */\nexport function credentialHttpsAgent(verifySsl: boolean | undefined): https.Agent {\n  return new https.Agent({ rejectUnauthorized: verifySsl ?? true });\n}\n\n/**\n * POST /api/auth/login and return the access token (or `undefined` if the\n * response carried none). Rate-limit accounting (record success/failure) and\n * the no-token exit are intentionally left to the caller so each command keeps\n * its exact lockout semantics.\n */\nexport async function postLogin(params: {\n  url: string;\n  identifier: string;\n  password: string;\n  httpsAgent: https.Agent;\n  timeout: number;\n}): Promise<string | undefined> {\n  const loginUrl = `${params.url}/api/auth/login`;\n  printDebug('POST', { url: loginUrl });\n  const response = await axios.post<AuthResponse>(\n    loginUrl,\n    { identifier: params.identifier, password: params.password },\n    { headers: { 'Content-Type': 'application/json' }, httpsAgent: params.httpsAgent, timeout: params.timeout },\n  );\n  return response.data?.data?.accessToken;\n}\n\n/**\n * POST /api/auth/switch-org with the current access token and return the new,\n * org-scoped access token. Prints a success line (unless `quiet`) and hard-exits\n * on a missing token — both credential commands treat a failed switch the same.\n */\nexport async function switchOrganization(params: {\n  url: string;\n  orgId: string;\n  accessToken: string;\n  httpsAgent: https.Agent;\n  timeout: number;\n  quiet: boolean;\n}): Promise<string> {\n  const switchUrl = `${params.url}/api/auth/switch-org`;\n  printDebug('POST', { url: switchUrl });\n  const response = await axios.post<AuthResponse>(\n    switchUrl,\n    { organizationId: params.orgId },\n    {\n      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${params.accessToken}` },\n      httpsAgent: params.httpsAgent,\n      timeout: params.timeout,\n    },\n  );\n  const switched = response.data?.data?.accessToken;\n  if (!switched) {\n    printError('Organization switch failed: no access token in response');\n    process.exit(ERROR_CODES.AUTHENTICATION);\n  }\n  if (!params.quiet) printSuccess(`Switched to organization ${params.orgId}`);\n  return switched;\n}\n"]}

package/dist/utils/aws-env.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Resolve the AWS region for an SDK/CLI call: explicit `--region` override →
+ * `AWS_REGION` → `CDK_DEFAULT_REGION` → `us-east-1`. Single source for the
+ * fallback that was previously copy-pasted across every AWS command and the
+ * secrets client.
+ */
+export declare function resolveAwsRegion(override?: string): string;
+/**
+ * Apply a `--profile` to the environment so the AWS SDK's default provider chain
+ * (which every client we build with `credentials` unset reads) selects that shared
+ * profile. **Call BEFORE constructing any SDK client**, or `--profile` is silently
+ * dropped and the client hits the default account — a silent split-brain when the
+ * accompanying CLI/`cdk` call *did* honor `--profile`.
+ *
+ * Precedence: ambient env credentials (`AWS_ACCESS_KEY_ID`) and an inherited
+ * `AWS_PROFILE` always win — we never clobber the caller's environment. An
+ * explicit non-default `--profile` that's overridden by ambient creds is surfaced
+ * as a warning so a silently-ignored flag isn't a surprise.
+ */
+export declare function applyAwsProfile(profile?: string): void;
+//# sourceMappingURL=aws-env.d.ts.map

package/dist/utils/aws-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aws-env.d.ts","sourceRoot":"","sources":["../../src/utils/aws-env.ts"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAStD"}

package/dist/utils/aws-env.js

@@ -0,0 +1,34 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { printWarning } from './output-utils.js';
+/**
+ * Resolve the AWS region for an SDK/CLI call: explicit `--region` override →
+ * `AWS_REGION` → `CDK_DEFAULT_REGION` → `us-east-1`. Single source for the
+ * fallback that was previously copy-pasted across every AWS command and the
+ * secrets client.
+ */
+export function resolveAwsRegion(override) {
+    return override || process.env.AWS_REGION || process.env.CDK_DEFAULT_REGION || 'us-east-1';
+}
+/**
+ * Apply a `--profile` to the environment so the AWS SDK's default provider chain
+ * (which every client we build with `credentials` unset reads) selects that shared
+ * profile. **Call BEFORE constructing any SDK client**, or `--profile` is silently
+ * dropped and the client hits the default account — a silent split-brain when the
+ * accompanying CLI/`cdk` call *did* honor `--profile`.
+ *
+ * Precedence: ambient env credentials (`AWS_ACCESS_KEY_ID`) and an inherited
+ * `AWS_PROFILE` always win — we never clobber the caller's environment. An
+ * explicit non-default `--profile` that's overridden by ambient creds is surfaced
+ * as a warning so a silently-ignored flag isn't a surprise.
+ */
+export function applyAwsProfile(profile) {
+    if (profile && !process.env.AWS_ACCESS_KEY_ID && !process.env.AWS_PROFILE) {
+        process.env.AWS_PROFILE = profile;
+    }
+    else if (profile && profile !== 'default') {
+        printWarning(`--profile ${profile} ignored: existing AWS credentials in the environment ` +
+            `(${process.env.AWS_ACCESS_KEY_ID ? 'AWS_ACCESS_KEY_ID' : 'AWS_PROFILE'}) take precedence.`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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