@pipeline-builder/pipeline-manager 4.1.3 → 4.1.5

package/dist/utils/auth-utils.js

@@ -6,9 +6,10 @@ 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.
+ * Guard the credential-transmitting commands (`login`, `pat`) against disabling
+ * TLS verification in production. The device flow keeps passwords off the wire
+ * entirely, but the session tokens it returns are bearer credentials — a MITM on
+ * a `prod + --no-verify-ssl` run would harvest them just the same.
  *
  * Unlike {@link assertSslDisableAllowed} (which throws — for paths already inside
  * a try/catch), this prints and hard-exits, matching the pre-flight checks these
@@ -21,17 +22,6 @@ export function assertCredentialTlsAllowed(verifySsl) {
         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
@@ -41,32 +31,29 @@ 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.
+ * POST /api/auth/switch-org with the current access token and return the WHOLE
+ * re-issued session.
+ *
+ * The switch re-issues the same session slot, which ROTATES its refresh token —
+ * so a caller that keeps only the access token is left holding a dead refresh
+ * token. Prints a success line (unless `quiet`) and hard-exits on a missing
+ * token, since 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}` },
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${params.accessToken}`,
+            // Declares the body transport for the re-issued refresh token.
+            'X-Pb-Client': 'cli',
+        },
         httpsAgent: params.httpsAgent,
         timeout: params.timeout,
     });
-    const switched = response.data?.data?.accessToken;
-    if (!switched) {
+    const switched = response.data?.data;
+    if (!switched?.accessToken) {
         printError('Organization switch failed: no access token in response');
         process.exit(ERROR_CODES.AUTHENTICATION);
     }
@@ -74,4 +61,4 @@ export async function switchOrganization(params) {
         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"]}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -32,12 +32,13 @@ export declare function printExecutionSummary(executionId: string, duration: num
  */
 export declare function printSslWarning(verifySsl?: boolean): void;
 /**
- * Resolve a platform auth token using two methods (in priority order):
+ * Resolve a platform credential using three methods (in priority order):
  *
- * 1. PLATFORM_TOKEN env var
- * 2. --store-tokens flag → fetch credentials from AWS Secrets Manager, then authenticate
+ * 1. PLATFORM_TOKEN env var (a JWT, or an opaque `pb_pat_…`/`pb_sa_…` key)
+ * 2. the session `auth login` stored for this platform (renewed if it has expired)
+ * 3. --store-tokens flag → the service-account key in AWS Secrets Manager
  *
- * @returns JWT token string
+ * @returns the bearer credential string
  */
 export declare function resolveToken(options: {
     storeTokens?: boolean;
@@ -48,9 +49,10 @@ export declare function resolveToken(options: {
 /**
  * Initialize and return an authenticated API client.
  *
- * Supports two auth methods:
+ * Supports three auth methods:
  * 1. PLATFORM_TOKEN env var
- * 2. --store-tokens + PLATFORM_SECRET_NAME env var → fetch token from Secrets Manager
+ * 2. the stored `auth login` session for this platform (renewed on expiry)
+ * 3. --store-tokens + PLATFORM_SECRET_NAME env var → fetch token from Secrets Manager
  */
 export declare function createAuthenticatedClientAsync(options: {
     storeTokens?: boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"command-utils.d.ts","sourceRoot":"","sources":["../../src/utils/command-utils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAQ5C;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAQvG;AAED;;mFAEmF;AACnF,wBAAgB,cAAc,CAAC,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAI3D;AAED;;gCAEgC;AAChC,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAE7D;AAED;;8EAE8E;AAC9E,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAE9D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAOjF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI,CAKzD;AAED;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE;IAC1C,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,MAAM,CAAC,CAmClB;AAED;;;;;;GAMG;AACH,wBAAsB,8BAA8B,CAAC,OAAO,EAAE;IAC5D,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,SAAS,CAAC,CAQrB;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,CAYrF;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAiBnF"}
+{"version":3,"file":"command-utils.d.ts","sourceRoot":"","sources":["../../src/utils/command-utils.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAS5C;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAQvG;AAED;;mFAEmF;AACnF,wBAAgB,cAAc,CAAC,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAI3D;AAED;;gCAEgC;AAChC,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAE7D;AAED;;8EAE8E;AAC9E,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAE9D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAOjF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI,CAKzD;AAmCD;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE;IAC1C,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,MAAM,CAAC,CAyDlB;AAED;;;;;;;GAOG;AACH,wBAAsB,8BAA8B,CAAC,OAAO,EAAE;IAC5D,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,SAAS,CAAC,CAQrB;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,CAYrF;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAiBnF"}

package/dist/utils/command-utils.js

@@ -1,10 +1,12 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+import axios from 'axios';
 import {} from 'commander';
 import pico from 'picocolors';
 import { ApiClient } from './api-client.js';
 import { getSecretValue } from './aws-secrets.js';
-import { getConfigWithOptions } from './config-loader.js';
+import { getApiConfig, getConfigWithOptions } from './config-loader.js';
+import { clearSession, isSessionUsable, loadSession, saveSession } from './credential-store.js';
 import { printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from './output-utils.js';
 import { formatDuration, generateExecutionId } from '../config/cli.constants.js';
 const { bold, cyan, green, magenta } = pico;
@@ -66,12 +68,44 @@ export function printSslWarning(verifySsl) {
     }
 }
 /**
- * Resolve a platform auth token using two methods (in priority order):
+ * Renew a stored session with its refresh token, persist the rotated pair, and
+ * return the new access token. Returns undefined (and forgets the session) when
+ * the platform refuses it — a rotated-away or revoked token is dead, and keeping
+ * it would make every later command fail the same way.
  *
- * 1. PLATFORM_TOKEN env var
- * 2. --store-tokens flag → fetch credentials from AWS Secrets Manager, then authenticate
+ * `X-Pb-Client` is mandatory on /auth/refresh (the CSRF gate) and its value also
+ * picks the transport: anything but `web` keeps the body flow the CLI uses.
+ */
+async function refreshStoredSession(baseUrl, session) {
+    if (!session.refreshToken)
+        return undefined;
+    try {
+        const response = await axios.post(`${baseUrl}/api/auth/refresh`, { refreshToken: session.refreshToken }, { headers: { 'Content-Type': 'application/json', 'X-Pb-Client': 'cli' }, timeout: 30_000 });
+        const renewed = response.data?.data;
+        if (!renewed?.accessToken)
+            return undefined;
+        saveSession(baseUrl, {
+            accessToken: renewed.accessToken,
+            ...(renewed.refreshToken ? { refreshToken: renewed.refreshToken } : {}),
+            expiresAt: Date.now() + (renewed.expiresIn ?? 900) * 1000,
+            ...(session.organizationId ? { organizationId: session.organizationId } : {}),
+        });
+        return renewed.accessToken;
+    }
+    catch {
+        clearSession(baseUrl);
+        printWarning('The stored session could not be renewed — run "pipeline-manager auth login" again');
+        return undefined;
+    }
+}
+/**
+ * Resolve a platform credential using three methods (in priority order):
+ *
+ * 1. PLATFORM_TOKEN env var (a JWT, or an opaque `pb_pat_…`/`pb_sa_…` key)
+ * 2. the session `auth login` stored for this platform (renewed if it has expired)
+ * 3. --store-tokens flag → the service-account key in AWS Secrets Manager
  *
- * @returns JWT token string
+ * @returns the bearer credential string
  */
 export async function resolveToken(options) {
     // Path 1: PLATFORM_TOKEN env var
@@ -79,7 +113,25 @@ export async function resolveToken(options) {
         printInfo('Using PLATFORM_TOKEN from environment');
         return process.env.PLATFORM_TOKEN;
     }
-    // Path 2: --store-tokens → read PLATFORM_SECRET_NAME from Secrets Manager
+    // Path 2: the stored browser sign-in. Skipped entirely when --store-tokens
+    // names a machine credential, so an operator's laptop session can never be
+    // used where the automation credential was asked for.
+    if (!options.storeTokens) {
+        const baseUrl = getApiConfig().api.baseUrl;
+        const stored = loadSession(baseUrl);
+        if (isSessionUsable(stored)) {
+            printInfo('Using the stored session from "auth login"');
+            return stored.accessToken;
+        }
+        if (stored) {
+            const renewed = await refreshStoredSession(baseUrl, stored);
+            if (renewed) {
+                printInfo('Renewed the stored session from "auth login"');
+                return renewed;
+            }
+        }
+    }
+    // Path 3: --store-tokens → read PLATFORM_SECRET_NAME from Secrets Manager
     if (options.storeTokens) {
         const secretName = process.env.PLATFORM_SECRET_NAME;
         if (!secretName) {
@@ -89,24 +141,28 @@ export async function resolveToken(options) {
         const secretJson = await getSecretValue(secretName, { region: options.region, profile: options.profile });
         const secret = JSON.parse(secretJson);
         printSuccess('Secret retrieved from Secrets Manager');
-        // store-token writes the JWT to the `password` field (schema: { username: orgId,
-        // password: JWT } — satisfies CodeBuild's secretsManagerCredentials), not `accessToken`.
+        // store-token writes the service-account KEY to the `password` field (schema:
+        // { username: orgId, password: pb_sa_… } — satisfies CodeBuild's
+        // secretsManagerCredentials), not `accessToken`. The key is presented as a
+        // bearer credential and exchanged server-side, so nothing here decodes it.
         if (!secret.password) {
-            throw new Error('Secret missing password (JWT) — run "pipeline-manager infra store-token" to generate');
+            throw new Error('Secret missing password (service-account key) — run "pipeline-manager infra store-token" to provision one');
         }
-        printInfo('Using stored JWT token');
+        printInfo('Using the stored service-account key');
         return secret.password;
     }
     throw new Error('Authentication required. Use one of:\n' +
-        '  - Set PLATFORM_TOKEN environment variable\n' +
+        '  - Run "pipeline-manager auth login" (browser sign-in, stored for this platform)\n' +
+        '  - Set PLATFORM_TOKEN to an access key from "pipeline-manager auth pat"\n' +
         '  - Pass --store-tokens with PLATFORM_SECRET_NAME env var');
 }
 /**
  * Initialize and return an authenticated API client.
  *
- * Supports two auth methods:
+ * Supports three auth methods:
  * 1. PLATFORM_TOKEN env var
- * 2. --store-tokens + PLATFORM_SECRET_NAME env var → fetch token from Secrets Manager
+ * 2. the stored `auth login` session for this platform (renewed on expiry)
+ * 3. --store-tokens + PLATFORM_SECRET_NAME env var → fetch token from Secrets Manager
  */
 export async function createAuthenticatedClientAsync(options) {
     // Resolve token and set it in env so ApiClient/getConfig can find it
@@ -125,7 +181,7 @@ export function createAuthenticatedClient(options) {
     printInfo('Initializing API client', { baseUrl: config.api.baseUrl });
     const client = new ApiClient(config);
     if (!client.isAuthenticated()) {
-        printError('Not authenticated', { hint: 'Set PLATFORM_TOKEN or use --store-tokens' });
+        printError('Not authenticated', { hint: 'Run "pipeline-manager auth login", set PLATFORM_TOKEN, or use --store-tokens' });
         throw new Error('Authentication required');
     }
     printSuccess('API client initialized');
@@ -152,4 +208,4 @@ export function validateEntityId(id, entityName) {
     }
     return trimmed;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"command-utils.js","sourceRoot":"","sources":["../../src/utils/command-utils.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { type Command } from 'commander';\nimport pico from 'picocolors';\nimport { ApiClient } from './api-client.js';\nimport { getSecretValue } from './aws-secrets.js';\nimport { type Config, getConfigWithOptions } from './config-loader.js';\nimport { printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from './output-utils.js';\nimport { formatDuration, generateExecutionId } from '../config/cli.constants.js';\n\nconst { bold, cyan, green, magenta } = pico;\n\n/**\n * Print command header with section title and execution ID.\n * Returns the execution ID for use in error handlers and summaries.\n *\n * Pass `{ quiet: true }` to suppress the decorative output while still getting the\n * id — used both by `--quiet` callers and by `--json` commands (so the banner\n * doesn't land on stdout ahead of the JSON payload and break `… --json | jq`).\n */\nexport function printCommandHeader(title: string, subtitle?: string, opts?: { quiet?: boolean }): string {\n  const executionId = generateExecutionId();\n  if (!opts?.quiet) {\n    printSection(title);\n    console.log(`${magenta(`[EXE-${executionId}]`)} ${cyan(bold(subtitle || title))}`);\n    console.log('');\n  }\n  return executionId;\n}\n\n/** Attach the standard `--verify-ssl` / `--no-verify-ssl` pair. The two together\n *  give Commander an explicit tri-state `options.verifySsl` (true/false/undefined).\n *  Returns the command so it composes: `withSslOptions(program.command('x'))…`. */\nexport function withSslOptions<T extends Command>(cmd: T): T {\n  return cmd\n    .option('--verify-ssl', 'Enable SSL certificate verification')\n    .option('--no-verify-ssl', 'Disable SSL certificate verification') as T;\n}\n\n/** Attach the standard `--region <region>` option (one canonical description).\n *  Region resolution (flag → AWS_REGION → CDK_DEFAULT_REGION → us-east-1) lives in\n *  aws-env.resolveAwsRegion. */\nexport function withRegionOption<T extends Command>(cmd: T): T {\n  return cmd.option('--region <region>', 'AWS region (defaults to AWS_REGION / CDK_DEFAULT_REGION / us-east-1)') as T;\n}\n\n/** Attach the standard `--profile <profile>` option (one canonical description).\n *  No default is pinned so the AWS default credential chain (env vars, SSO, roles)\n *  works out of the box; --profile only selects a shared profile when set. */\nexport function withProfileOption<T extends Command>(cmd: T): T {\n  return cmd.option('--profile <profile>', 'AWS CLI profile (defaults to the standard AWS credential chain)') as T;\n}\n\n/**\n * Print execution summary with ID, duration, and status.\n */\nexport function printExecutionSummary(executionId: string, duration: number): void {\n  console.log('');\n  printKeyValue({\n    'Execution ID': executionId,\n    'Duration': formatDuration(duration),\n    'Status': green('✓ Success'),\n  });\n}\n\n/**\n * Warn if SSL verification is disabled.\n */\nexport function printSslWarning(verifySsl?: boolean): void {\n  if (verifySsl === false) {\n    printWarning('SSL certificate verification is DISABLED');\n    console.log('');\n  }\n}\n\n/**\n * Resolve a platform auth token using two methods (in priority order):\n *\n * 1. PLATFORM_TOKEN env var\n * 2. --store-tokens flag → fetch credentials from AWS Secrets Manager, then authenticate\n *\n * @returns JWT token string\n */\nexport async function resolveToken(options: {\n  storeTokens?: boolean;\n  verifySsl?: boolean;\n  region?: string;\n  profile?: string;\n}): Promise<string> {\n  // Path 1: PLATFORM_TOKEN env var\n  if (process.env.PLATFORM_TOKEN) {\n    printInfo('Using PLATFORM_TOKEN from environment');\n    return process.env.PLATFORM_TOKEN;\n  }\n\n  // Path 2: --store-tokens → read PLATFORM_SECRET_NAME from Secrets Manager\n  if (options.storeTokens) {\n    const secretName = process.env.PLATFORM_SECRET_NAME;\n    if (!secretName) {\n      throw new Error('PLATFORM_SECRET_NAME env var is required with --store-tokens');\n    }\n\n    printInfo('Fetching secret from Secrets Manager', { secret: secretName });\n\n    const secretJson = await getSecretValue(secretName, { region: options.region, profile: options.profile });\n    const secret = JSON.parse(secretJson) as Record<string, string>;\n    printSuccess('Secret retrieved from Secrets Manager');\n\n    // store-token writes the JWT to the `password` field (schema: { username: orgId,\n    // password: JWT } — satisfies CodeBuild's secretsManagerCredentials), not `accessToken`.\n    if (!secret.password) {\n      throw new Error('Secret missing password (JWT) — run \"pipeline-manager infra store-token\" to generate');\n    }\n\n    printInfo('Using stored JWT token');\n    return secret.password;\n  }\n\n  throw new Error(\n    'Authentication required. Use one of:\\n' +\n    '  - Set PLATFORM_TOKEN environment variable\\n' +\n    '  - Pass --store-tokens with PLATFORM_SECRET_NAME env var',\n  );\n}\n\n/**\n * Initialize and return an authenticated API client.\n *\n * Supports two auth methods:\n * 1. PLATFORM_TOKEN env var\n * 2. --store-tokens + PLATFORM_SECRET_NAME env var → fetch token from Secrets Manager\n */\nexport async function createAuthenticatedClientAsync(options: {\n  storeTokens?: boolean;\n  verifySsl?: boolean;\n  region?: string;\n  profile?: string;\n}): Promise<ApiClient> {\n  // Resolve token and set it in env so ApiClient/getConfig can find it\n  if (!process.env.PLATFORM_TOKEN) {\n    const token = await resolveToken(options);\n    process.env.PLATFORM_TOKEN = token;\n  }\n\n  return createAuthenticatedClient(options);\n}\n\n/**\n * Initialize and return an authenticated API client (sync — requires PLATFORM_TOKEN).\n * Use createAuthenticatedClientAsync for --store-tokens support.\n */\nexport function createAuthenticatedClient(options: { verifySsl?: boolean }): ApiClient {\n  const config: Config = getConfigWithOptions(options);\n  printInfo('Initializing API client', { baseUrl: config.api.baseUrl });\n  const client = new ApiClient(config);\n\n  if (!client.isAuthenticated()) {\n    printError('Not authenticated', { hint: 'Set PLATFORM_TOKEN or use --store-tokens' });\n    throw new Error('Authentication required');\n  }\n\n  printSuccess('API client initialized');\n  return client;\n}\n\n/**\n * Validate a required entity ID (ULID or UUID format).\n * Returns trimmed ID.\n *\n * @throws Error if ID is empty\n */\nexport function validateEntityId(id: string | undefined, entityName: string): string {\n  if (!id || typeof id !== 'string' || id.trim().length === 0) {\n    printError(`Invalid ${entityName} ID`, { provided: id });\n    throw new Error(`${entityName} ID must be a non-empty string`);\n  }\n\n  const trimmed = id.trim();\n\n  if (trimmed.length !== 26 && trimmed.length !== 36) {\n    printWarning(`${entityName} ID format may be invalid`, {\n      provided: trimmed,\n      expectedLength: '26 characters (ULID) or 36 characters (UUID)',\n      actualLength: trimmed.length,\n    });\n  }\n\n  return trimmed;\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"command-utils.js","sourceRoot":"","sources":["../../src/utils/command-utils.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport axios from 'axios';\nimport { type Command } from 'commander';\nimport pico from 'picocolors';\nimport { ApiClient } from './api-client.js';\nimport { getSecretValue } from './aws-secrets.js';\nimport { type Config, getApiConfig, getConfigWithOptions } from './config-loader.js';\nimport { clearSession, isSessionUsable, loadSession, saveSession, type StoredSession } from './credential-store.js';\nimport { printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from './output-utils.js';\nimport { formatDuration, generateExecutionId } from '../config/cli.constants.js';\n\nconst { bold, cyan, green, magenta } = pico;\n\n/**\n * Print command header with section title and execution ID.\n * Returns the execution ID for use in error handlers and summaries.\n *\n * Pass `{ quiet: true }` to suppress the decorative output while still getting the\n * id — used both by `--quiet` callers and by `--json` commands (so the banner\n * doesn't land on stdout ahead of the JSON payload and break `… --json | jq`).\n */\nexport function printCommandHeader(title: string, subtitle?: string, opts?: { quiet?: boolean }): string {\n  const executionId = generateExecutionId();\n  if (!opts?.quiet) {\n    printSection(title);\n    console.log(`${magenta(`[EXE-${executionId}]`)} ${cyan(bold(subtitle || title))}`);\n    console.log('');\n  }\n  return executionId;\n}\n\n/** Attach the standard `--verify-ssl` / `--no-verify-ssl` pair. The two together\n *  give Commander an explicit tri-state `options.verifySsl` (true/false/undefined).\n *  Returns the command so it composes: `withSslOptions(program.command('x'))…`. */\nexport function withSslOptions<T extends Command>(cmd: T): T {\n  return cmd\n    .option('--verify-ssl', 'Enable SSL certificate verification')\n    .option('--no-verify-ssl', 'Disable SSL certificate verification') as T;\n}\n\n/** Attach the standard `--region <region>` option (one canonical description).\n *  Region resolution (flag → AWS_REGION → CDK_DEFAULT_REGION → us-east-1) lives in\n *  aws-env.resolveAwsRegion. */\nexport function withRegionOption<T extends Command>(cmd: T): T {\n  return cmd.option('--region <region>', 'AWS region (defaults to AWS_REGION / CDK_DEFAULT_REGION / us-east-1)') as T;\n}\n\n/** Attach the standard `--profile <profile>` option (one canonical description).\n *  No default is pinned so the AWS default credential chain (env vars, SSO, roles)\n *  works out of the box; --profile only selects a shared profile when set. */\nexport function withProfileOption<T extends Command>(cmd: T): T {\n  return cmd.option('--profile <profile>', 'AWS CLI profile (defaults to the standard AWS credential chain)') as T;\n}\n\n/**\n * Print execution summary with ID, duration, and status.\n */\nexport function printExecutionSummary(executionId: string, duration: number): void {\n  console.log('');\n  printKeyValue({\n    'Execution ID': executionId,\n    'Duration': formatDuration(duration),\n    'Status': green('✓ Success'),\n  });\n}\n\n/**\n * Warn if SSL verification is disabled.\n */\nexport function printSslWarning(verifySsl?: boolean): void {\n  if (verifySsl === false) {\n    printWarning('SSL certificate verification is DISABLED');\n    console.log('');\n  }\n}\n\n/**\n * Renew a stored session with its refresh token, persist the rotated pair, and\n * return the new access token. Returns undefined (and forgets the session) when\n * the platform refuses it — a rotated-away or revoked token is dead, and keeping\n * it would make every later command fail the same way.\n *\n * `X-Pb-Client` is mandatory on /auth/refresh (the CSRF gate) and its value also\n * picks the transport: anything but `web` keeps the body flow the CLI uses.\n */\nasync function refreshStoredSession(baseUrl: string, session: StoredSession): Promise<string | undefined> {\n  if (!session.refreshToken) return undefined;\n  try {\n    const response = await axios.post<{ data?: { accessToken?: string; refreshToken?: string; expiresIn?: number } }>(\n      `${baseUrl}/api/auth/refresh`,\n      { refreshToken: session.refreshToken },\n      { headers: { 'Content-Type': 'application/json', 'X-Pb-Client': 'cli' }, timeout: 30_000 },\n    );\n    const renewed = response.data?.data;\n    if (!renewed?.accessToken) return undefined;\n    saveSession(baseUrl, {\n      accessToken: renewed.accessToken,\n      ...(renewed.refreshToken ? { refreshToken: renewed.refreshToken } : {}),\n      expiresAt: Date.now() + (renewed.expiresIn ?? 900) * 1000,\n      ...(session.organizationId ? { organizationId: session.organizationId } : {}),\n    });\n    return renewed.accessToken;\n  } catch {\n    clearSession(baseUrl);\n    printWarning('The stored session could not be renewed — run \"pipeline-manager auth login\" again');\n    return undefined;\n  }\n}\n\n/**\n * Resolve a platform credential using three methods (in priority order):\n *\n * 1. PLATFORM_TOKEN env var (a JWT, or an opaque `pb_pat_…`/`pb_sa_…` key)\n * 2. the session `auth login` stored for this platform (renewed if it has expired)\n * 3. --store-tokens flag → the service-account key in AWS Secrets Manager\n *\n * @returns the bearer credential string\n */\nexport async function resolveToken(options: {\n  storeTokens?: boolean;\n  verifySsl?: boolean;\n  region?: string;\n  profile?: string;\n}): Promise<string> {\n  // Path 1: PLATFORM_TOKEN env var\n  if (process.env.PLATFORM_TOKEN) {\n    printInfo('Using PLATFORM_TOKEN from environment');\n    return process.env.PLATFORM_TOKEN;\n  }\n\n  // Path 2: the stored browser sign-in. Skipped entirely when --store-tokens\n  // names a machine credential, so an operator's laptop session can never be\n  // used where the automation credential was asked for.\n  if (!options.storeTokens) {\n    const baseUrl = getApiConfig().api.baseUrl;\n    const stored = loadSession(baseUrl);\n    if (isSessionUsable(stored)) {\n      printInfo('Using the stored session from \"auth login\"');\n      return stored.accessToken;\n    }\n    if (stored) {\n      const renewed = await refreshStoredSession(baseUrl, stored);\n      if (renewed) {\n        printInfo('Renewed the stored session from \"auth login\"');\n        return renewed;\n      }\n    }\n  }\n\n  // Path 3: --store-tokens → read PLATFORM_SECRET_NAME from Secrets Manager\n  if (options.storeTokens) {\n    const secretName = process.env.PLATFORM_SECRET_NAME;\n    if (!secretName) {\n      throw new Error('PLATFORM_SECRET_NAME env var is required with --store-tokens');\n    }\n\n    printInfo('Fetching secret from Secrets Manager', { secret: secretName });\n\n    const secretJson = await getSecretValue(secretName, { region: options.region, profile: options.profile });\n    const secret = JSON.parse(secretJson) as Record<string, string>;\n    printSuccess('Secret retrieved from Secrets Manager');\n\n    // store-token writes the service-account KEY to the `password` field (schema:\n    // { username: orgId, password: pb_sa_… } — satisfies CodeBuild's\n    // secretsManagerCredentials), not `accessToken`. The key is presented as a\n    // bearer credential and exchanged server-side, so nothing here decodes it.\n    if (!secret.password) {\n      throw new Error('Secret missing password (service-account key) — run \"pipeline-manager infra store-token\" to provision one');\n    }\n\n    printInfo('Using the stored service-account key');\n    return secret.password;\n  }\n\n  throw new Error(\n    'Authentication required. Use one of:\\n' +\n    '  - Run \"pipeline-manager auth login\" (browser sign-in, stored for this platform)\\n' +\n    '  - Set PLATFORM_TOKEN to an access key from \"pipeline-manager auth pat\"\\n' +\n    '  - Pass --store-tokens with PLATFORM_SECRET_NAME env var',\n  );\n}\n\n/**\n * Initialize and return an authenticated API client.\n *\n * Supports three auth methods:\n * 1. PLATFORM_TOKEN env var\n * 2. the stored `auth login` session for this platform (renewed on expiry)\n * 3. --store-tokens + PLATFORM_SECRET_NAME env var → fetch token from Secrets Manager\n */\nexport async function createAuthenticatedClientAsync(options: {\n  storeTokens?: boolean;\n  verifySsl?: boolean;\n  region?: string;\n  profile?: string;\n}): Promise<ApiClient> {\n  // Resolve token and set it in env so ApiClient/getConfig can find it\n  if (!process.env.PLATFORM_TOKEN) {\n    const token = await resolveToken(options);\n    process.env.PLATFORM_TOKEN = token;\n  }\n\n  return createAuthenticatedClient(options);\n}\n\n/**\n * Initialize and return an authenticated API client (sync — requires PLATFORM_TOKEN).\n * Use createAuthenticatedClientAsync for --store-tokens support.\n */\nexport function createAuthenticatedClient(options: { verifySsl?: boolean }): ApiClient {\n  const config: Config = getConfigWithOptions(options);\n  printInfo('Initializing API client', { baseUrl: config.api.baseUrl });\n  const client = new ApiClient(config);\n\n  if (!client.isAuthenticated()) {\n    printError('Not authenticated', { hint: 'Run \"pipeline-manager auth login\", set PLATFORM_TOKEN, or use --store-tokens' });\n    throw new Error('Authentication required');\n  }\n\n  printSuccess('API client initialized');\n  return client;\n}\n\n/**\n * Validate a required entity ID (ULID or UUID format).\n * Returns trimmed ID.\n *\n * @throws Error if ID is empty\n */\nexport function validateEntityId(id: string | undefined, entityName: string): string {\n  if (!id || typeof id !== 'string' || id.trim().length === 0) {\n    printError(`Invalid ${entityName} ID`, { provided: id });\n    throw new Error(`${entityName} ID must be a non-empty string`);\n  }\n\n  const trimmed = id.trim();\n\n  if (trimmed.length !== 26 && trimmed.length !== 36) {\n    printWarning(`${entityName} ID format may be invalid`, {\n      provided: trimmed,\n      expectedLength: '26 characters (ULID) or 36 characters (UUID)',\n      actualLength: trimmed.length,\n    });\n  }\n\n  return trimmed;\n}\n\n"]}

package/dist/utils/config-loader.d.ts

@@ -9,7 +9,8 @@ export type { Config };
  * 3. Project config file: CLI_CONFIG_PATH or ./config.yml
  * 4. Environment variables
  *
- * Auth token MUST come from PLATFORM_TOKEN env var (never from config file).
+ * Auth token comes from PLATFORM_TOKEN, else the stored `auth login` session —
+ * never from a config file.
  */
 /**
  * Resolve the API/connection config (base URL, SSL, timeouts) from files and

package/dist/utils/config-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config-loader.d.ts","sourceRoot":"","sources":["../../src/utils/config-loader.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAKhD,YAAY,EAAE,MAAM,EAAE,CAAC;AA6CvB;;;;;;;;;;GAUG;AACH;;;;;;;;GAQG;AACH,wBAAgB,YAAY,IAAI,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAoCnD;AAED,wBAAgB,SAAS,IAAI,MAAM,CAyBlC;AAaD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAU7E"}
+{"version":3,"file":"config-loader.d.ts","sourceRoot":"","sources":["../../src/utils/config-loader.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAKhD,YAAY,EAAE,MAAM,EAAE,CAAC;AA6CvB;;;;;;;;;;;GAWG;AACH;;;;;;;;GAQG;AACH,wBAAgB,YAAY,IAAI,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAuCnD;AAED,wBAAgB,SAAS,IAAI,MAAM,CA8BlC;AAaD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAU7E"}

package/dist/utils/config-loader.js

@@ -5,6 +5,7 @@ import { fileURLToPath } from 'node:url';
 import * as os from 'os';
 import * as path from 'path';
 import * as yaml from 'yaml';
+import { isSessionUsable, loadSession } from './credential-store.js';
 import { printDebug, printError, printWarning } from './output-utils.js';
 import { assertSslDisableAllowed, isProductionEnv } from './tls.js';
 import {} from '../types/index.js';
@@ -60,7 +61,8 @@ function loadConfigFile(filePath, config) {
  * 3. Project config file: CLI_CONFIG_PATH or ./config.yml
  * 4. Environment variables
  *
- * Auth token MUST come from PLATFORM_TOKEN env var (never from config file).
+ * Auth token comes from PLATFORM_TOKEN, else the stored `auth login` session —
+ * never from a config file.
  */
 /**
  * Resolve the API/connection config (base URL, SSL, timeouts) from files and
@@ -73,8 +75,11 @@ function loadConfigFile(filePath, config) {
  */
 export function getApiConfig() {
     const projectConfigPath = process.env.CLI_CONFIG_PATH || path.join(__dirname, '../config.yml');
-    // Layer 1: defaults → Layer 2: user config → Layer 3: project config
-    let config = loadConfigFile(USER_CONFIG_PATH, { ...defaultConfig });
+    // Layer 1: defaults → Layer 2: user config → Layer 3: project config.
+    // `api` is copied too: a shallow `{ ...defaultConfig }` shares the SAME `api`
+    // object, so the `PLATFORM_BASE_URL` assignment below mutated the module-level
+    // defaults and leaked one caller's base URL into every later resolution.
+    let config = loadConfigFile(USER_CONFIG_PATH, { api: { ...defaultConfig.api } });
     config = loadConfigFile(projectConfigPath, config);
     // Layer 4: environment variable overrides
     if (process.env.PLATFORM_BASE_URL) {
@@ -107,11 +112,16 @@ export function getApiConfig() {
 }
 export function getConfig() {
     const config = getApiConfig();
-    // Token is REQUIRED from environment
-    const token = process.env.PLATFORM_TOKEN;
+    // PLATFORM_TOKEN wins (an access key in CI, or an explicit export); otherwise
+    // fall back to the session `auth login` stored for THIS platform. A stored
+    // session that has already expired is ignored rather than sent and rejected —
+    // the async path (`resolveToken`) refreshes it, and everything else tells the
+    // user to sign in again.
+    const stored = loadSession(config.api.baseUrl);
+    const token = process.env.PLATFORM_TOKEN || (isSessionUsable(stored) ? stored.accessToken : undefined);
     if (!token) {
-        printError('PLATFORM_TOKEN environment variable is not set');
-        throw new Error('PLATFORM_TOKEN environment variable is required');
+        printError('Not signed in: no PLATFORM_TOKEN, and no valid stored session for this platform');
+        throw new Error('Run "pipeline-manager auth login", or set PLATFORM_TOKEN to an access key');
     }
     if (token.trim().length === 0) {
         throw new Error('PLATFORM_TOKEN must be a non-empty string');
@@ -151,4 +161,4 @@ export function getConfigWithOptions(options) {
     }
     return config;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config-loader.js","sourceRoot":"","sources":["../../src/utils/config-loader.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as fs from 'fs';\nimport { fileURLToPath } from 'node:url';\nimport * as os from 'os';\nimport * as path from 'path';\nimport * as yaml from 'yaml';\nimport { printDebug, printError, printWarning } from './output-utils.js';\nimport { assertSslDisableAllowed, isProductionEnv } from './tls.js';\nimport { type Config } from '../types/index.js';\n\n// ESM has no __dirname; derive it from this module's URL.\nconst __dirname = path.dirname(fileURLToPath(import.meta.url));\n\nexport type { Config };\n\n/**\n * Default configuration — API endpoint paths and connection settings.\n */\nconst defaultConfig: Omit<Config, 'auth'> = {\n  api: {\n    baseUrl: 'https://localhost:8443',\n    timeout: 30_000,\n    pipelineUrl: '/api/pipeline',\n    pipelineListUrl: '/api/pipelines',\n    pipelineTemplateUrl: '/api/pipeline-templates',\n    pluginUrl: '/api/plugin',\n    pluginListUrl: '/api/plugins',\n    pluginUploadUrl: '/api/plugin/upload',\n    rejectUnauthorized: true,\n  },\n};\n\n/** User config file path: ~/.pipeline-manager/config.yml */\nconst USER_CONFIG_PATH = path.join(os.homedir(), '.pipeline-manager', 'config.yml');\n\n/**\n * Load a YAML config file and merge its `api` section into the config.\n * Returns the merged config or the original if file doesn't exist or fails.\n */\nfunction loadConfigFile(filePath: string, config: Omit<Config, 'auth'>): Omit<Config, 'auth'> {\n  if (!fs.existsSync(filePath)) return config;\n\n  try {\n    printDebug('Loading configuration', { path: filePath });\n    const parsed = yaml.parse(fs.readFileSync(filePath, 'utf-8'));\n    if (parsed?.auth) {\n      printWarning('Auth section in config file is ignored — use PLATFORM_TOKEN env var');\n    }\n    return { api: { ...config.api, ...parsed?.api } };\n  } catch (error) {\n    printWarning('Failed to load config file, using defaults', {\n      path: filePath,\n      error: error instanceof Error ? error.message : String(error),\n    });\n    return config;\n  }\n}\n\n/**\n * Load configuration from files and environment.\n *\n * Priority (last wins):\n * 1. Built-in defaults\n * 2. User config file: ~/.pipeline-manager/config.yml\n * 3. Project config file: CLI_CONFIG_PATH or ./config.yml\n * 4. Environment variables\n *\n * Auth token MUST come from PLATFORM_TOKEN env var (never from config file).\n */\n/**\n * Resolve the API/connection config (base URL, SSL, timeouts) from files and\n * environment WITHOUT requiring `PLATFORM_TOKEN`.\n *\n * This is the token-optional slice of {@link getConfig}. The pre-auth login step\n * (`ensurePlatformToken`) needs the resolved base URL to POST `/api/auth/login`\n * *before* any token exists — calling `getConfig()` there would throw on the\n * missing token and make inline-login dead-on-arrival.\n */\nexport function getApiConfig(): Omit<Config, 'auth'> {\n  const projectConfigPath = process.env.CLI_CONFIG_PATH || path.join(__dirname, '../config.yml');\n\n  // Layer 1: defaults → Layer 2: user config → Layer 3: project config\n  let config = loadConfigFile(USER_CONFIG_PATH, { ...defaultConfig });\n  config = loadConfigFile(projectConfigPath, config);\n\n  // Layer 4: environment variable overrides\n  if (process.env.PLATFORM_BASE_URL) {\n    config.api.baseUrl = process.env.PLATFORM_BASE_URL;\n    printDebug('Using PLATFORM_BASE_URL from environment', { baseUrl: config.api.baseUrl });\n  }\n\n  if (process.env.TLS_REJECT_UNAUTHORIZED !== undefined) {\n    const disable = process.env.TLS_REJECT_UNAUTHORIZED === '0';\n    if (disable && isProductionEnv()) {\n      printWarning('Ignoring TLS_REJECT_UNAUTHORIZED=0 in production — SSL verification remains enabled');\n    } else {\n      config.api.rejectUnauthorized = !disable;\n      if (disable) {\n        printWarning('SSL certificate validation disabled via TLS_REJECT_UNAUTHORIZED=0');\n      }\n    }\n  }\n\n  if (process.env.UPLOAD_TIMEOUT) {\n    const parsed = parseInt(process.env.UPLOAD_TIMEOUT, 10);\n    if (!isNaN(parsed) && parsed > 0) {\n      config.api.uploadTimeout = parsed;\n      printDebug('Using UPLOAD_TIMEOUT from environment', { uploadTimeout: `${parsed}ms` });\n    } else {\n      printWarning('Invalid UPLOAD_TIMEOUT value, using default', { provided: process.env.UPLOAD_TIMEOUT });\n    }\n  }\n\n  return config;\n}\n\nexport function getConfig(): Config {\n  const config = getApiConfig();\n\n  // Token is REQUIRED from environment\n  const token = process.env.PLATFORM_TOKEN;\n\n  if (!token) {\n    printError('PLATFORM_TOKEN environment variable is not set');\n    throw new Error('PLATFORM_TOKEN environment variable is required');\n  }\n\n  if (token.trim().length === 0) {\n    throw new Error('PLATFORM_TOKEN must be a non-empty string');\n  }\n\n  if (token.includes(' ')) {\n    printWarning('PLATFORM_TOKEN contains whitespace — this may cause issues');\n  }\n\n  printDebug('Configuration loaded successfully');\n\n  return {\n    ...config,\n    auth: { token },\n  };\n}\n\n/**\n * Return a copy of `config` with SSL verification disabled. Module-private — the\n * only caller is `getConfigWithOptions` below.\n */\nfunction withSSLDisabled(config: Config): Config {\n  return {\n    ...config,\n    api: { ...config.api, rejectUnauthorized: false },\n  };\n}\n\n/**\n * Load configuration, optionally disabling SSL based on command options.\n * Replaces the repeated pattern:\n *   `options.verifySsl === false ? withSSLDisabled(getConfig()) : getConfig()`\n */\nexport function getConfigWithOptions(options: { verifySsl?: boolean }): Config {\n  const config = getConfig();\n  if (options.verifySsl === false) {\n    // Every authenticated command flows its token through here — refuse to\n    // disable cert verification in production (mirrors the login/renewal guards)\n    // so a MITM can't harvest the Bearer JWT. No-op in non-production.\n    assertSslDisableAllowed('authenticated API client (--no-verify-ssl)');\n    return withSSLDisabled(config);\n  }\n  return config;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config-loader.js","sourceRoot":"","sources":["../../src/utils/config-loader.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as fs from 'fs';\nimport { fileURLToPath } from 'node:url';\nimport * as os from 'os';\nimport * as path from 'path';\nimport * as yaml from 'yaml';\nimport { isSessionUsable, loadSession } from './credential-store.js';\nimport { printDebug, printError, printWarning } from './output-utils.js';\nimport { assertSslDisableAllowed, isProductionEnv } from './tls.js';\nimport { type Config } from '../types/index.js';\n\n// ESM has no __dirname; derive it from this module's URL.\nconst __dirname = path.dirname(fileURLToPath(import.meta.url));\n\nexport type { Config };\n\n/**\n * Default configuration — API endpoint paths and connection settings.\n */\nconst defaultConfig: Omit<Config, 'auth'> = {\n  api: {\n    baseUrl: 'https://localhost:8443',\n    timeout: 30_000,\n    pipelineUrl: '/api/pipeline',\n    pipelineListUrl: '/api/pipelines',\n    pipelineTemplateUrl: '/api/pipeline-templates',\n    pluginUrl: '/api/plugin',\n    pluginListUrl: '/api/plugins',\n    pluginUploadUrl: '/api/plugin/upload',\n    rejectUnauthorized: true,\n  },\n};\n\n/** User config file path: ~/.pipeline-manager/config.yml */\nconst USER_CONFIG_PATH = path.join(os.homedir(), '.pipeline-manager', 'config.yml');\n\n/**\n * Load a YAML config file and merge its `api` section into the config.\n * Returns the merged config or the original if file doesn't exist or fails.\n */\nfunction loadConfigFile(filePath: string, config: Omit<Config, 'auth'>): Omit<Config, 'auth'> {\n  if (!fs.existsSync(filePath)) return config;\n\n  try {\n    printDebug('Loading configuration', { path: filePath });\n    const parsed = yaml.parse(fs.readFileSync(filePath, 'utf-8'));\n    if (parsed?.auth) {\n      printWarning('Auth section in config file is ignored — use PLATFORM_TOKEN env var');\n    }\n    return { api: { ...config.api, ...parsed?.api } };\n  } catch (error) {\n    printWarning('Failed to load config file, using defaults', {\n      path: filePath,\n      error: error instanceof Error ? error.message : String(error),\n    });\n    return config;\n  }\n}\n\n/**\n * Load configuration from files and environment.\n *\n * Priority (last wins):\n * 1. Built-in defaults\n * 2. User config file: ~/.pipeline-manager/config.yml\n * 3. Project config file: CLI_CONFIG_PATH or ./config.yml\n * 4. Environment variables\n *\n * Auth token comes from PLATFORM_TOKEN, else the stored `auth login` session —\n * never from a config file.\n */\n/**\n * Resolve the API/connection config (base URL, SSL, timeouts) from files and\n * environment WITHOUT requiring `PLATFORM_TOKEN`.\n *\n * This is the token-optional slice of {@link getConfig}. The pre-auth login step\n * (`ensurePlatformToken`) needs the resolved base URL to POST `/api/auth/login`\n * *before* any token exists — calling `getConfig()` there would throw on the\n * missing token and make inline-login dead-on-arrival.\n */\nexport function getApiConfig(): Omit<Config, 'auth'> {\n  const projectConfigPath = process.env.CLI_CONFIG_PATH || path.join(__dirname, '../config.yml');\n\n  // Layer 1: defaults → Layer 2: user config → Layer 3: project config.\n  // `api` is copied too: a shallow `{ ...defaultConfig }` shares the SAME `api`\n  // object, so the `PLATFORM_BASE_URL` assignment below mutated the module-level\n  // defaults and leaked one caller's base URL into every later resolution.\n  let config = loadConfigFile(USER_CONFIG_PATH, { api: { ...defaultConfig.api } });\n  config = loadConfigFile(projectConfigPath, config);\n\n  // Layer 4: environment variable overrides\n  if (process.env.PLATFORM_BASE_URL) {\n    config.api.baseUrl = process.env.PLATFORM_BASE_URL;\n    printDebug('Using PLATFORM_BASE_URL from environment', { baseUrl: config.api.baseUrl });\n  }\n\n  if (process.env.TLS_REJECT_UNAUTHORIZED !== undefined) {\n    const disable = process.env.TLS_REJECT_UNAUTHORIZED === '0';\n    if (disable && isProductionEnv()) {\n      printWarning('Ignoring TLS_REJECT_UNAUTHORIZED=0 in production — SSL verification remains enabled');\n    } else {\n      config.api.rejectUnauthorized = !disable;\n      if (disable) {\n        printWarning('SSL certificate validation disabled via TLS_REJECT_UNAUTHORIZED=0');\n      }\n    }\n  }\n\n  if (process.env.UPLOAD_TIMEOUT) {\n    const parsed = parseInt(process.env.UPLOAD_TIMEOUT, 10);\n    if (!isNaN(parsed) && parsed > 0) {\n      config.api.uploadTimeout = parsed;\n      printDebug('Using UPLOAD_TIMEOUT from environment', { uploadTimeout: `${parsed}ms` });\n    } else {\n      printWarning('Invalid UPLOAD_TIMEOUT value, using default', { provided: process.env.UPLOAD_TIMEOUT });\n    }\n  }\n\n  return config;\n}\n\nexport function getConfig(): Config {\n  const config = getApiConfig();\n\n  // PLATFORM_TOKEN wins (an access key in CI, or an explicit export); otherwise\n  // fall back to the session `auth login` stored for THIS platform. A stored\n  // session that has already expired is ignored rather than sent and rejected —\n  // the async path (`resolveToken`) refreshes it, and everything else tells the\n  // user to sign in again.\n  const stored = loadSession(config.api.baseUrl);\n  const token = process.env.PLATFORM_TOKEN || (isSessionUsable(stored) ? stored.accessToken : undefined);\n\n  if (!token) {\n    printError('Not signed in: no PLATFORM_TOKEN, and no valid stored session for this platform');\n    throw new Error('Run \"pipeline-manager auth login\", or set PLATFORM_TOKEN to an access key');\n  }\n\n  if (token.trim().length === 0) {\n    throw new Error('PLATFORM_TOKEN must be a non-empty string');\n  }\n\n  if (token.includes(' ')) {\n    printWarning('PLATFORM_TOKEN contains whitespace — this may cause issues');\n  }\n\n  printDebug('Configuration loaded successfully');\n\n  return {\n    ...config,\n    auth: { token },\n  };\n}\n\n/**\n * Return a copy of `config` with SSL verification disabled. Module-private — the\n * only caller is `getConfigWithOptions` below.\n */\nfunction withSSLDisabled(config: Config): Config {\n  return {\n    ...config,\n    api: { ...config.api, rejectUnauthorized: false },\n  };\n}\n\n/**\n * Load configuration, optionally disabling SSL based on command options.\n * Replaces the repeated pattern:\n *   `options.verifySsl === false ? withSSLDisabled(getConfig()) : getConfig()`\n */\nexport function getConfigWithOptions(options: { verifySsl?: boolean }): Config {\n  const config = getConfig();\n  if (options.verifySsl === false) {\n    // Every authenticated command flows its token through here — refuse to\n    // disable cert verification in production (mirrors the login/renewal guards)\n    // so a MITM can't harvest the Bearer JWT. No-op in non-production.\n    assertSslDisableAllowed('authenticated API client (--no-verify-ssl)');\n    return withSSLDisabled(config);\n  }\n  return config;\n}\n"]}

package/dist/utils/credential-store.d.ts

@@ -0,0 +1,23 @@
+/** One platform's stored session. */
+export interface StoredSession {
+    accessToken: string;
+    /** Rotated on every refresh; absent only if the platform stopped issuing one. */
+    refreshToken?: string;
+    /** Epoch ms the access token expires. */
+    expiresAt: number;
+    /** The org the session was scoped to when it was stored (informational). */
+    organizationId?: string;
+    savedAt: string;
+}
+/** Where the sessions live — surfaced in help text and errors. */
+export declare function credentialStorePath(): string;
+/** Persist the session for `baseUrl`, replacing any previous one. */
+export declare function saveSession(baseUrl: string, session: Omit<StoredSession, 'savedAt'>): void;
+/** The stored session for `baseUrl`, or undefined. Expiry is NOT checked here —
+ *  callers decide whether to use, refresh or ignore it. */
+export declare function loadSession(baseUrl: string): StoredSession | undefined;
+/** Forget the session for `baseUrl` (sign-out, or a refresh the platform rejected). */
+export declare function clearSession(baseUrl: string): void;
+/** True when the stored access token is still usable (with a little slack). */
+export declare function isSessionUsable(session: StoredSession | undefined): session is StoredSession;
+//# sourceMappingURL=credential-store.d.ts.map

package/dist/utils/credential-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credential-store.d.ts","sourceRoot":"","sources":["../../src/utils/credential-store.ts"],"names":[],"mappings":"AA+BA,qCAAqC;AACrC,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,iFAAiF;IACjF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB;AAOD,kEAAkE;AAClE,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAgCD,qEAAqE;AACrE,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,aAAa,EAAE,SAAS,CAAC,GAAG,IAAI,CAK1F;AAED;2DAC2D;AAC3D,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAEtE;AAED,uFAAuF;AACvF,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAalD;AAED,+EAA+E;AAC/E,wBAAgB,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,GAAG,OAAO,IAAI,aAAa,CAE5F"}