@pipeline-builder/pipeline-manager 4.1.4 → 4.1.6

package/dist/utils/credential-store.js

@@ -0,0 +1,92 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * On-disk session store for `auth login`.
+ *
+ * `~/.pipeline-manager/credentials.json`, owner-only (0600 file inside the 0700
+ * directory the audit log already creates), keyed by platform base URL so one
+ * machine can hold sessions for several platforms at once.
+ *
+ * It holds a real session — the access token AND its refresh token — because
+ * that is what the device flow hands back and what lets the CLI keep working for
+ * days without another browser round trip. Nothing else about the account is
+ * stored: no password (the CLI no longer has one to store) and no identifier.
+ *
+ * Resolution order everywhere else in the CLI is unchanged in spirit: an
+ * explicit `PLATFORM_TOKEN` in the environment always wins, so CI keeps using an
+ * access key and is never affected by whatever a developer's laptop has cached.
+ */
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { printDebug, printWarning } from './output-utils.js';
+const STORE_DIR = path.join(os.homedir(), '.pipeline-manager');
+const STORE_FILE = path.join(STORE_DIR, 'credentials.json');
+/** Re-authenticate rather than hand out a token this close to expiry. */
+const EXPIRY_SKEW_MS = 60_000;
+/** Where the sessions live — surfaced in help text and errors. */
+export function credentialStorePath() {
+    return STORE_FILE;
+}
+/**
+ * Trailing slashes and case differences in the host would otherwise split one
+ * platform into several entries.
+ */
+function storeKey(baseUrl) {
+    return baseUrl.trim().replace(/\/+$/, '').toLowerCase();
+}
+function readStore() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(STORE_FILE, 'utf-8'));
+        if (parsed?.version === 1 && parsed.sessions && typeof parsed.sessions === 'object') {
+            return parsed;
+        }
+    }
+    catch {
+        // Missing or unreadable: treat as empty. A corrupt file must not break every
+        // command — the next successful login rewrites it.
+    }
+    return { version: 1, sessions: {} };
+}
+function writeStore(store) {
+    fs.mkdirSync(STORE_DIR, { recursive: true, mode: 0o700 });
+    // Write through a temp file so an interrupted write can't leave a truncated
+    // store behind, and create it 0600 from the start (never briefly world-readable).
+    const tmp = `${STORE_FILE}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify(store, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(tmp, STORE_FILE);
+}
+/** Persist the session for `baseUrl`, replacing any previous one. */
+export function saveSession(baseUrl, session) {
+    const store = readStore();
+    store.sessions[storeKey(baseUrl)] = { ...session, savedAt: new Date().toISOString() };
+    writeStore(store);
+    printDebug('Session stored', { path: STORE_FILE, platform: storeKey(baseUrl) });
+}
+/** The stored session for `baseUrl`, or undefined. Expiry is NOT checked here —
+ *  callers decide whether to use, refresh or ignore it. */
+export function loadSession(baseUrl) {
+    return readStore().sessions[storeKey(baseUrl)];
+}
+/** Forget the session for `baseUrl` (sign-out, or a refresh the platform rejected). */
+export function clearSession(baseUrl) {
+    const store = readStore();
+    if (!(storeKey(baseUrl) in store.sessions))
+        return;
+    delete store.sessions[storeKey(baseUrl)];
+    try {
+        writeStore(store);
+    }
+    catch (error) {
+        // Losing the ability to clear a dead session is a nuisance, not a failure.
+        printWarning('Could not update the stored credentials', {
+            path: STORE_FILE,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+/** True when the stored access token is still usable (with a little slack). */
+export function isSessionUsable(session) {
+    return !!session?.accessToken && session.expiresAt - EXPIRY_SKEW_MS > Date.now();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"credential-store.js","sourceRoot":"","sources":["../../src/utils/credential-store.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * On-disk session store for `auth login`.\n *\n * `~/.pipeline-manager/credentials.json`, owner-only (0600 file inside the 0700\n * directory the audit log already creates), keyed by platform base URL so one\n * machine can hold sessions for several platforms at once.\n *\n * It holds a real session — the access token AND its refresh token — because\n * that is what the device flow hands back and what lets the CLI keep working for\n * days without another browser round trip. Nothing else about the account is\n * stored: no password (the CLI no longer has one to store) and no identifier.\n *\n * Resolution order everywhere else in the CLI is unchanged in spirit: an\n * explicit `PLATFORM_TOKEN` in the environment always wins, so CI keeps using an\n * access key and is never affected by whatever a developer's laptop has cached.\n */\n\nimport fs from 'fs';\nimport os from 'os';\nimport path from 'path';\nimport { printDebug, printWarning } from './output-utils.js';\n\nconst STORE_DIR = path.join(os.homedir(), '.pipeline-manager');\nconst STORE_FILE = path.join(STORE_DIR, 'credentials.json');\n\n/** Re-authenticate rather than hand out a token this close to expiry. */\nconst EXPIRY_SKEW_MS = 60_000;\n\n/** One platform's stored session. */\nexport interface StoredSession {\n  accessToken: string;\n  /** Rotated on every refresh; absent only if the platform stopped issuing one. */\n  refreshToken?: string;\n  /** Epoch ms the access token expires. */\n  expiresAt: number;\n  /** The org the session was scoped to when it was stored (informational). */\n  organizationId?: string;\n  savedAt: string;\n}\n\ninterface StoreFile {\n  version: 1;\n  sessions: Record<string, StoredSession>;\n}\n\n/** Where the sessions live — surfaced in help text and errors. */\nexport function credentialStorePath(): string {\n  return STORE_FILE;\n}\n\n/**\n * Trailing slashes and case differences in the host would otherwise split one\n * platform into several entries.\n */\nfunction storeKey(baseUrl: string): string {\n  return baseUrl.trim().replace(/\\/+$/, '').toLowerCase();\n}\n\nfunction readStore(): StoreFile {\n  try {\n    const parsed = JSON.parse(fs.readFileSync(STORE_FILE, 'utf-8'));\n    if (parsed?.version === 1 && parsed.sessions && typeof parsed.sessions === 'object') {\n      return parsed as StoreFile;\n    }\n  } catch {\n    // Missing or unreadable: treat as empty. A corrupt file must not break every\n    // command — the next successful login rewrites it.\n  }\n  return { version: 1, sessions: {} };\n}\n\nfunction writeStore(store: StoreFile): void {\n  fs.mkdirSync(STORE_DIR, { recursive: true, mode: 0o700 });\n  // Write through a temp file so an interrupted write can't leave a truncated\n  // store behind, and create it 0600 from the start (never briefly world-readable).\n  const tmp = `${STORE_FILE}.tmp`;\n  fs.writeFileSync(tmp, `${JSON.stringify(store, null, 2)}\\n`, { mode: 0o600 });\n  fs.renameSync(tmp, STORE_FILE);\n}\n\n/** Persist the session for `baseUrl`, replacing any previous one. */\nexport function saveSession(baseUrl: string, session: Omit<StoredSession, 'savedAt'>): void {\n  const store = readStore();\n  store.sessions[storeKey(baseUrl)] = { ...session, savedAt: new Date().toISOString() };\n  writeStore(store);\n  printDebug('Session stored', { path: STORE_FILE, platform: storeKey(baseUrl) });\n}\n\n/** The stored session for `baseUrl`, or undefined. Expiry is NOT checked here —\n *  callers decide whether to use, refresh or ignore it. */\nexport function loadSession(baseUrl: string): StoredSession | undefined {\n  return readStore().sessions[storeKey(baseUrl)];\n}\n\n/** Forget the session for `baseUrl` (sign-out, or a refresh the platform rejected). */\nexport function clearSession(baseUrl: string): void {\n  const store = readStore();\n  if (!(storeKey(baseUrl) in store.sessions)) return;\n  delete store.sessions[storeKey(baseUrl)];\n  try {\n    writeStore(store);\n  } catch (error) {\n    // Losing the ability to clear a dead session is a nuisance, not a failure.\n    printWarning('Could not update the stored credentials', {\n      path: STORE_FILE,\n      error: error instanceof Error ? error.message : String(error),\n    });\n  }\n}\n\n/** True when the stored access token is still usable (with a little slack). */\nexport function isSessionUsable(session: StoredSession | undefined): session is StoredSession {\n  return !!session?.accessToken && session.expiresAt - EXPIRY_SKEW_MS > Date.now();\n}\n"]}

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

@@ -0,0 +1,59 @@
+import type https from 'https';
+/** `POST /auth/device/code` — RFC 8628 §3.2. */
+export interface DeviceCodeResponse {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    verification_uri_complete?: string;
+    expires_in: number;
+    interval: number;
+}
+/** `POST /auth/device/token` on success — RFC 8628 §3.5. */
+export interface DeviceTokenResponse {
+    access_token: string;
+    refresh_token?: string;
+    token_type: string;
+    expires_in: number;
+    /** Present only when the device asked for one at `/code` (`auth pat`). */
+    step_up_token?: string;
+}
+/** Connection settings shared by both calls. */
+export interface DeviceAuthTransport {
+    url: string;
+    httpsAgent: https.Agent;
+    timeout: number;
+}
+/** Raised for every terminal outcome, so callers can print one clear message. */
+export declare class DeviceAuthError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+/** Ask the platform to open a device authorization. */
+export declare function requestDeviceCode(transport: DeviceAuthTransport, options?: {
+    stepUp?: boolean;
+}): Promise<DeviceCodeResponse>;
+/**
+ * Poll `/auth/device/token` until the browser decides, the code expires, or
+ * `signal` says to stop.
+ *
+ * Interval handling is the RFC's: start at the advertised `interval`, and widen
+ * it by 5 seconds (or to whatever the platform names) on every `slow_down`. The
+ * platform also enforces the interval, so a client that ignores it is throttled
+ * rather than trusted.
+ */
+export declare function pollForDeviceToken(transport: DeviceAuthTransport, code: DeviceCodeResponse, hooks?: {
+    onPending?: () => void;
+}): Promise<DeviceTokenResponse>;
+/**
+ * Try to open `url` in the default browser. Returns false — never throws — when
+ * the environment has no browser to open (a CI runner, an SSH session, a
+ * non-interactive shell) or the opener isn't installed, so the caller falls back
+ * to printing the URL.
+ *
+ * The URL is passed as an ARGUMENT, never through a shell, and only http(s) is
+ * accepted: the value comes from the platform's response, and handing an
+ * arbitrary scheme to the OS opener is how "click this link" turns into "run
+ * this program".
+ */
+export declare function openInBrowser(url: string): boolean;
+//# sourceMappingURL=device-auth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"device-auth.d.ts","sourceRoot":"","sources":["../../src/utils/device-auth.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,gDAAgD;AAChD,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,4DAA4D;AAC5D,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,0EAA0E;IAC1E,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AASD,gDAAgD;AAChD,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,iFAAiF;AACjF,qBAAa,eAAgB,SAAQ,KAAK;IACX,QAAQ,CAAC,IAAI,EAAE,MAAM;IAAlD,YAAY,OAAO,EAAE,MAAM,EAAW,IAAI,EAAE,MAAM,EAGjD;CACF;AAED,uDAAuD;AACvD,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,mBAAmB,EAC9B,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GACjC,OAAO,CAAC,kBAAkB,CAAC,CAiB7B;AAOD;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,mBAAmB,EAC9B,IAAI,EAAE,kBAAkB,EACxB,KAAK,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,IAAI,CAAA;CAAO,GACrC,OAAO,CAAC,mBAAmB,CAAC,CAkD9B;AAUD;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAsBlD"}

package/dist/utils/device-auth.js

@@ -0,0 +1,139 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * OAuth 2.0 device authorization grant client (RFC 8628) — how the CLI signs in.
+ *
+ * The CLI asks the platform for a code, shows it (and opens the browser when it
+ * can), then polls until the person approves in that browser. No password and no
+ * long-lived token ever passes through the command line, shell history, `ps`
+ * output or a CI log; the browser is where SSO, step-up and later MFA already
+ * apply, so the terminal inherits all of it without implementing any of it.
+ */
+import { spawn } from 'child_process';
+import axios from 'axios';
+import { printDebug } from './output-utils.js';
+/** Raised for every terminal outcome, so callers can print one clear message. */
+export class DeviceAuthError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'DeviceAuthError';
+    }
+}
+/** Ask the platform to open a device authorization. */
+export async function requestDeviceCode(transport, options = {}) {
+    const codeUrl = `${transport.url}/api/auth/device/code`;
+    printDebug('POST', { url: codeUrl });
+    const response = await axios.post(codeUrl, { ...(options.stepUp ? { step_up: true } : {}) }, {
+        headers: { 'Content-Type': 'application/json', 'X-Pb-Client': 'cli' },
+        httpsAgent: transport.httpsAgent,
+        timeout: transport.timeout,
+    });
+    const data = response.data;
+    if (!data?.device_code || !data.user_code) {
+        throw new DeviceAuthError('The platform did not return a device code.', 'invalid_response');
+    }
+    return data;
+}
+/** Sleep, without pulling in a timers dependency. */
+function wait(ms) {
+    return new Promise((resolve) => { setTimeout(resolve, ms); });
+}
+/**
+ * Poll `/auth/device/token` until the browser decides, the code expires, or
+ * `signal` says to stop.
+ *
+ * Interval handling is the RFC's: start at the advertised `interval`, and widen
+ * it by 5 seconds (or to whatever the platform names) on every `slow_down`. The
+ * platform also enforces the interval, so a client that ignores it is throttled
+ * rather than trusted.
+ */
+export async function pollForDeviceToken(transport, code, hooks = {}) {
+    const tokenUrl = `${transport.url}/api/auth/device/token`;
+    const deadline = Date.now() + code.expires_in * 1000;
+    let intervalMs = Math.max(1, code.interval) * 1000;
+    while (Date.now() < deadline) {
+        await wait(intervalMs);
+        printDebug('POST', { url: tokenUrl });
+        const response = await axios.post(tokenUrl, { device_code: code.device_code }, {
+            headers: { 'Content-Type': 'application/json', 'X-Pb-Client': 'cli' },
+            httpsAgent: transport.httpsAgent,
+            timeout: transport.timeout,
+            // The RFC's pending/backoff signals arrive as HTTP 400, which axios would
+            // otherwise throw: they are protocol states, not failures.
+            validateStatus: (status) => (status >= 200 && status < 300) || status === 400,
+        });
+        if (response.status === 200) {
+            if (!response.data?.access_token) {
+                throw new DeviceAuthError('The platform approved the sign-in but returned no token.', 'invalid_response');
+            }
+            return response.data;
+        }
+        switch (response.data?.error) {
+            case 'authorization_pending':
+                hooks.onPending?.();
+                break;
+            case 'slow_down':
+                intervalMs = Math.max(intervalMs + 5_000, (response.data.interval ?? 0) * 1000);
+                printDebug('Polling slowed by the platform', { intervalMs });
+                break;
+            case 'access_denied':
+                throw new DeviceAuthError('The sign-in was denied in the browser.', 'access_denied');
+            case 'expired_token':
+                throw new DeviceAuthError('The sign-in code expired before it was approved.', 'expired_token');
+            default:
+                throw new DeviceAuthError(response.data?.error_description || 'The platform refused the device sign-in.', response.data?.error || 'invalid_request');
+        }
+    }
+    throw new DeviceAuthError('Timed out waiting for the sign-in to be approved.', 'expired_token');
+}
+/** The OS command that opens a URL in the default browser. */
+function openCommand() {
+    if (process.platform === 'darwin')
+        return { command: 'open', args: [] };
+    if (process.platform === 'win32')
+        return { command: 'cmd', args: ['/c', 'start', ''] };
+    if (process.platform === 'linux')
+        return { command: 'xdg-open', args: [] };
+    return null;
+}
+/**
+ * Try to open `url` in the default browser. Returns false — never throws — when
+ * the environment has no browser to open (a CI runner, an SSH session, a
+ * non-interactive shell) or the opener isn't installed, so the caller falls back
+ * to printing the URL.
+ *
+ * The URL is passed as an ARGUMENT, never through a shell, and only http(s) is
+ * accepted: the value comes from the platform's response, and handing an
+ * arbitrary scheme to the OS opener is how "click this link" turns into "run
+ * this program".
+ */
+export function openInBrowser(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:')
+        return false;
+    if (process.env.CI || process.env.SSH_CONNECTION || process.env.SSH_TTY)
+        return false;
+    if (!process.stdout.isTTY)
+        return false;
+    const opener = openCommand();
+    if (!opener)
+        return false;
+    try {
+        const child = spawn(opener.command, [...opener.args, url], { stdio: 'ignore', detached: true });
+        child.on('error', () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"device-auth.js","sourceRoot":"","sources":["../../src/utils/device-auth.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * OAuth 2.0 device authorization grant client (RFC 8628) — how the CLI signs in.\n *\n * The CLI asks the platform for a code, shows it (and opens the browser when it\n * can), then polls until the person approves in that browser. No password and no\n * long-lived token ever passes through the command line, shell history, `ps`\n * output or a CI log; the browser is where SSO, step-up and later MFA already\n * apply, so the terminal inherits all of it without implementing any of it.\n */\n\nimport { spawn } from 'child_process';\nimport type https from 'https';\nimport axios from 'axios';\nimport { printDebug } from './output-utils.js';\n\n/** `POST /auth/device/code` — RFC 8628 §3.2. */\nexport interface DeviceCodeResponse {\n  device_code: string;\n  user_code: string;\n  verification_uri: string;\n  verification_uri_complete?: string;\n  expires_in: number;\n  interval: number;\n}\n\n/** `POST /auth/device/token` on success — RFC 8628 §3.5. */\nexport interface DeviceTokenResponse {\n  access_token: string;\n  refresh_token?: string;\n  token_type: string;\n  expires_in: number;\n  /** Present only when the device asked for one at `/code` (`auth pat`). */\n  step_up_token?: string;\n}\n\n/** The RFC error body, plus the `interval` the platform sends with `slow_down`. */\ninterface DeviceErrorResponse {\n  error?: string;\n  error_description?: string;\n  interval?: number;\n}\n\n/** Connection settings shared by both calls. */\nexport interface DeviceAuthTransport {\n  url: string;\n  httpsAgent: https.Agent;\n  timeout: number;\n}\n\n/** Raised for every terminal outcome, so callers can print one clear message. */\nexport class DeviceAuthError extends Error {\n  constructor(message: string, readonly code: string) {\n    super(message);\n    this.name = 'DeviceAuthError';\n  }\n}\n\n/** Ask the platform to open a device authorization. */\nexport async function requestDeviceCode(\n  transport: DeviceAuthTransport,\n  options: { stepUp?: boolean } = {},\n): Promise<DeviceCodeResponse> {\n  const codeUrl = `${transport.url}/api/auth/device/code`;\n  printDebug('POST', { url: codeUrl });\n  const response = await axios.post<DeviceCodeResponse>(\n    codeUrl,\n    { ...(options.stepUp ? { step_up: true } : {}) },\n    {\n      headers: { 'Content-Type': 'application/json', 'X-Pb-Client': 'cli' },\n      httpsAgent: transport.httpsAgent,\n      timeout: transport.timeout,\n    },\n  );\n  const data = response.data;\n  if (!data?.device_code || !data.user_code) {\n    throw new DeviceAuthError('The platform did not return a device code.', 'invalid_response');\n  }\n  return data;\n}\n\n/** Sleep, without pulling in a timers dependency. */\nfunction wait(ms: number): Promise<void> {\n  return new Promise((resolve) => { setTimeout(resolve, ms); });\n}\n\n/**\n * Poll `/auth/device/token` until the browser decides, the code expires, or\n * `signal` says to stop.\n *\n * Interval handling is the RFC's: start at the advertised `interval`, and widen\n * it by 5 seconds (or to whatever the platform names) on every `slow_down`. The\n * platform also enforces the interval, so a client that ignores it is throttled\n * rather than trusted.\n */\nexport async function pollForDeviceToken(\n  transport: DeviceAuthTransport,\n  code: DeviceCodeResponse,\n  hooks: { onPending?: () => void } = {},\n): Promise<DeviceTokenResponse> {\n  const tokenUrl = `${transport.url}/api/auth/device/token`;\n  const deadline = Date.now() + code.expires_in * 1000;\n  let intervalMs = Math.max(1, code.interval) * 1000;\n\n  while (Date.now() < deadline) {\n    await wait(intervalMs);\n\n    printDebug('POST', { url: tokenUrl });\n    const response = await axios.post<DeviceTokenResponse & DeviceErrorResponse>(\n      tokenUrl,\n      { device_code: code.device_code },\n      {\n        headers: { 'Content-Type': 'application/json', 'X-Pb-Client': 'cli' },\n        httpsAgent: transport.httpsAgent,\n        timeout: transport.timeout,\n        // The RFC's pending/backoff signals arrive as HTTP 400, which axios would\n        // otherwise throw: they are protocol states, not failures.\n        validateStatus: (status) => (status >= 200 && status < 300) || status === 400,\n      },\n    );\n\n    if (response.status === 200) {\n      if (!response.data?.access_token) {\n        throw new DeviceAuthError('The platform approved the sign-in but returned no token.', 'invalid_response');\n      }\n      return response.data;\n    }\n\n    switch (response.data?.error) {\n      case 'authorization_pending':\n        hooks.onPending?.();\n        break;\n      case 'slow_down':\n        intervalMs = Math.max(intervalMs + 5_000, (response.data.interval ?? 0) * 1000);\n        printDebug('Polling slowed by the platform', { intervalMs });\n        break;\n      case 'access_denied':\n        throw new DeviceAuthError('The sign-in was denied in the browser.', 'access_denied');\n      case 'expired_token':\n        throw new DeviceAuthError('The sign-in code expired before it was approved.', 'expired_token');\n      default:\n        throw new DeviceAuthError(\n          response.data?.error_description || 'The platform refused the device sign-in.',\n          response.data?.error || 'invalid_request',\n        );\n    }\n  }\n\n  throw new DeviceAuthError('Timed out waiting for the sign-in to be approved.', 'expired_token');\n}\n\n/** The OS command that opens a URL in the default browser. */\nfunction openCommand(): { command: string; args: string[] } | null {\n  if (process.platform === 'darwin') return { command: 'open', args: [] };\n  if (process.platform === 'win32') return { command: 'cmd', args: ['/c', 'start', ''] };\n  if (process.platform === 'linux') return { command: 'xdg-open', args: [] };\n  return null;\n}\n\n/**\n * Try to open `url` in the default browser. Returns false — never throws — when\n * the environment has no browser to open (a CI runner, an SSH session, a\n * non-interactive shell) or the opener isn't installed, so the caller falls back\n * to printing the URL.\n *\n * The URL is passed as an ARGUMENT, never through a shell, and only http(s) is\n * accepted: the value comes from the platform's response, and handing an\n * arbitrary scheme to the OS opener is how \"click this link\" turns into \"run\n * this program\".\n */\nexport function openInBrowser(url: string): boolean {\n  let parsed: URL;\n  try {\n    parsed = new URL(url);\n  } catch {\n    return false;\n  }\n  if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') return false;\n  if (process.env.CI || process.env.SSH_CONNECTION || process.env.SSH_TTY) return false;\n  if (!process.stdout.isTTY) return false;\n\n  const opener = openCommand();\n  if (!opener) return false;\n\n  try {\n    const child = spawn(opener.command, [...opener.args, url], { stdio: 'ignore', detached: true });\n    child.on('error', () => { /* no browser here; the printed URL is the fallback */ });\n    child.unref();\n    return true;\n  } catch {\n    return false;\n  }\n}\n"]}

package/dist/utils/pipeline-config.js

@@ -43,7 +43,7 @@ export async function printResolvedOrExit(propsWithIds) {
     const { resolveSelfReferencing } = await import('@pipeline-builder/pipeline-core');
     const scope = { metadata: propsWithIds.metadata ?? {}, vars: propsWithIds.vars ?? {} };
     const isTpl = (f) => f === 'projectName' || f.startsWith('metadata.') || f.startsWith('vars.');
-    const result = resolveSelfReferencing(propsWithIds, scope, isTpl, (f) => (isTpl(f) ? f : null), 'pipeline');
+    const result = resolveSelfReferencing(propsWithIds, scope, isTpl, (f) => (isTpl(f) ? f : null));
     if (result.errors.length) {
         console.error('Resolution errors:');
         for (const e of result.errors)
@@ -52,4 +52,4 @@ export async function printResolvedOrExit(propsWithIds) {
     }
     console.log(JSON.stringify(propsWithIds, null, 2));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGlwZWxpbmUtY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL3BpcGVsaW5lLWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBU3RDLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUM5QyxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUM5RCxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDckQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFZNUQ7Ozs7Ozs7O0dBUUc7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLGtCQUFrQixDQUFDLE1BQWlCLEVBQUUsVUFBa0I7SUFDNUUsTUFBTSxNQUFNLEdBQUcsTUFBTSxDQUFDLFNBQVMsRUFBRSxDQUFDO0lBQ2xDLE1BQU0sUUFBUSxHQUFHLE1BQU0sTUFBTSxDQUFDLEdBQUcsQ0FBMEIsR0FBRyxNQUFNLENBQUMsR0FBRyxDQUFDLFdBQVcsSUFBSSxVQUFVLEVBQUUsQ0FBQyxDQUFDO0lBQ3RHLE1BQU0sUUFBUSxHQUFHLHFCQUFxQixDQUFXLFFBQVEsRUFBRSxVQUFVLEVBQUUsT0FBTyxDQUFDLENBQUM7SUFDaEYsSUFBSSxDQUFDLFFBQVEsRUFBRSxLQUFLLEVBQUUsQ0FBQztRQUNyQixNQUFNLElBQUksS0FBSyxDQUFDLDZDQUE2QyxVQUFVLEVBQUUsQ0FBQyxDQUFDO0lBQzdFLENBQUM7SUFFRCxNQUFNLFlBQVksR0FBNEI7UUFDNUMsR0FBSSxRQUFRLENBQUMsS0FBaUM7UUFDOUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxFQUFFLFFBQVEsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO1FBQ3BELFVBQVUsRUFBRSxRQUFRLENBQUMsRUFBRSxJQUFJLFVBQVU7S0FDdEMsQ0FBQztJQUVGLE1BQU0sZUFBZSxHQUFHLE1BQU0sc0JBQXNCLENBQUMsTUFBTSxFQUFFLFlBQVksQ0FBQyxDQUFDO0lBQzNFLElBQUksTUFBTSxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFLENBQUM7UUFDNUMsWUFBWSxDQUFDLGVBQWUsR0FBRyxlQUFlLENBQUM7UUFDL0MsU0FBUyxDQUFDLHNCQUFzQixFQUFFLEVBQUUsS0FBSyxFQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsZUFBZSxDQUFDLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQztJQUNwRixDQUFDO0lBRUQsb0JBQW9CLENBQUMsWUFBWSxFQUFFLE1BQU0sQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDdkQsT0FBTyxFQUFFLFFBQVEsRUFBRSxZQUFZLEVBQUUsT0FBTyxFQUFFLE1BQU0sQ0FBQyxHQUFHLENBQUMsT0FBTyxFQUFFLENBQUM7QUFDakUsQ0FBQztBQUVEOzs7OztHQUtHO0FBQ0gsTUFBTSxDQUFDLEtBQUssVUFBVSxtQkFBbUIsQ0FBQyxZQUFxQztJQUM3RSxNQUFNLEVBQUUsc0JBQXNCLEVBQUUsR0FBRyxNQUFNLE1BQU0sQ0FBQyxpQ0FBaUMsQ0FBQyxDQUFDO0lBQ25GLE1BQU0sS0FBSyxHQUFHLEVBQUUsUUFBUSxFQUFFLFlBQVksQ0FBQyxRQUFRLElBQUksRUFBRSxFQUFFLElBQUksRUFBRSxZQUFZLENBQUMsSUFBSSxJQUFJLEVBQUUsRUFBRSxDQUFDO0lBQ3ZGLE1BQU0sS0FBSyxHQUFHLENBQUMsQ0FBUyxFQUFFLEVBQUUsQ0FBQyxDQUFDLEtBQUssYUFBYSxJQUFJLENBQUMsQ0FBQyxVQUFVLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUN2RyxNQUFNLE1BQU0sR0FBRyxzQkFBc0IsQ0FBQyxZQUFZLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxDQUFDLENBQVMsRUFBRSxFQUFFLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztJQUN4RyxJQUFJLE1BQU0sQ0FBQyxNQUFNLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDekIsT0FBTyxDQUFDLEtBQUssQ0FBQyxvQkFBb0IsQ0FBQyxDQUFDO1FBQ3BDLEtBQUssTUFBTSxDQUFDLElBQUksTUFBTSxDQUFDLE1BQU07WUFBRSxPQUFPLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDLEtBQUssSUFBSSxHQUFHLEtBQUssQ0FBQyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7UUFDbkYsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNsQixDQUFDO0lBQ0QsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLFlBQVksRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUNyRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbi8qKlxuICogU2hhcmVkIHBpcGVsaW5lLWNvbmZpZyByZXNvbHV0aW9uIHVzZWQgYnkgYm90aCBgc3ludGhgIGFuZCBgZGVwbG95YCBzbyB0aGUgdHdvXG4gKiBjb21tYW5kcyBmZXRjaCwgcGx1Z2luLXJlc29sdmUsIHJlZ2lzdHJ5LWJha2UsIGFuZCB0ZW1wbGF0ZS1wcmV2aWV3IGlkZW50aWNhbGx5XG4gKiAodGhleSBwcmV2aW91c2x5IGtlcHQgbmVhci1kdXBsaWNhdGUgY29waWVzIHRoYXQgY291bGQgZHJpZnQpLlxuICovXG5cbmltcG9ydCB0eXBlIHsgQXBpQ2xpZW50IH0gZnJvbSAnLi9hcGktY2xpZW50LmpzJztcbmltcG9ydCB7IHByaW50SW5mbyB9IGZyb20gJy4vb3V0cHV0LXV0aWxzLmpzJztcbmltcG9ydCB7IHJlc29sdmVQbHVnaW5zRm9yUHJvcHMgfSBmcm9tICcuL3BsdWdpbi1yZXNvbHZlci5qcyc7XG5pbXBvcnQgeyBiYWtlUGxhdGZvcm1SZWdpc3RyeSB9IGZyb20gJy4vcmVnaXN0cnkuanMnO1xuaW1wb3J0IHsgZXh0cmFjdFNpbmdsZVJlc3BvbnNlIH0gZnJvbSAnLi9yZXNwb25zZS11dGlscy5qcyc7XG5pbXBvcnQgdHlwZSB7IFBpcGVsaW5lIH0gZnJvbSAnLi4vdHlwZXMvcGlwZWxpbmUuanMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIEZldGNoZWRQaXBlbGluZSB7XG4gIC8qKiBUaGUgcmF3IHBpcGVsaW5lIHJlY29yZCAoaWQvb3JnL3Byb2plY3QvZmxhZ3MpIGFzIHJldHVybmVkIGJ5IHRoZSBwbGF0Zm9ybS4gKi9cbiAgcmVhZG9ubHkgcGlwZWxpbmU6IFBpcGVsaW5lO1xuICAvKiogcHJvcHMgKyBwaXBlbGluZUlkICgrIG9yZ0lkKSArIHJlc29sdmVkUGx1Z2lucywgd2l0aCB0aGUgcmVnaXN0cnkgcHVsbC1ob3N0IGJha2VkIGluLiAqL1xuICByZWFkb25seSBwcm9wc1dpdGhJZHM6IFJlY29yZDxzdHJpbmcsIHVua25vd24+O1xuICAvKiogVGhlIHJlc29sdmVkIHBsYXRmb3JtIGJhc2UgVVJMIHRoZSBjb25maWcgd2FzIGZldGNoZWQgYWdhaW5zdC4gKi9cbiAgcmVhZG9ubHkgYmFzZVVybDogc3RyaW5nO1xufVxuXG4vKipcbiAqIEZldGNoIGEgcGlwZWxpbmUgYnkgaWQgYW5kIGJ1aWxkIHRoZSBzeW50aC9kZXBsb3kgcHJvcHM6XG4gKiAgLSBHRVQgdGhlIHBpcGVsaW5lIGFuZCB2YWxpZGF0ZSBpdCBoYXMgYHByb3BzYCxcbiAqICAtIGFzc2VtYmxlIGBwcm9wc1dpdGhJZHNgIChwcm9wcyArIHBpcGVsaW5lSWQgKyBvcmdJZCksXG4gKiAgLSBwcmUtcmVzb2x2ZSBwbHVnaW5zIHNvIHRoZSB0ZW1wbGF0ZSBzaGlwcyByZWFsIENvZGVCdWlsZCBpbWFnZSBVUklzXG4gKiAgICAob3RoZXJ3aXNlIENESyBmYWxscyBiYWNrIHRvIHN0YW5kYXJkOjcuMCBhdCBkZXBsb3kgdGltZSksXG4gKiAgLSBiYWtlIHRoZSByZWdpc3RyeSBwdWxsLWhvc3QgZnJvbSB0aGUgcGxhdGZvcm0gVVJMIChuby1vcCB3aGVuXG4gKiAgICBJTUFHRV9SRUdJU1RSWV9QVUxMX0hPU1QgaXMgc2V0KS5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGZldGNoUGlwZWxpbmVQcm9wcyhjbGllbnQ6IEFwaUNsaWVudCwgcGlwZWxpbmVJZDogc3RyaW5nKTogUHJvbWlzZTxGZXRjaGVkUGlwZWxpbmU+IHtcbiAgY29uc3QgY29uZmlnID0gY2xpZW50LmdldENvbmZpZygpO1xuICBjb25zdCByZXNwb25zZSA9IGF3YWl0IGNsaWVudC5nZXQ8UmVjb3JkPHN0cmluZywgdW5rbm93bj4+KGAke2NvbmZpZy5hcGkucGlwZWxpbmVVcmx9LyR7cGlwZWxpbmVJZH1gKTtcbiAgY29uc3QgcGlwZWxpbmUgPSBleHRyYWN0U2luZ2xlUmVzcG9uc2U8UGlwZWxpbmU+KHJlc3BvbnNlLCAncGlwZWxpbmUnLCAncHJvcHMnKTtcbiAgaWYgKCFwaXBlbGluZT8ucHJvcHMpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoYEZhaWxlZCB0byByZXRyaWV2ZSBwaXBlbGluZSBwcm9wcyBmb3IgSUQ6ICR7cGlwZWxpbmVJZH1gKTtcbiAgfVxuXG4gIGNvbnN0IHByb3BzV2l0aElkczogUmVjb3JkPHN0cmluZywgdW5rbm93bj4gPSB7XG4gICAgLi4uKHBpcGVsaW5lLnByb3BzIGFzIFJlY29yZDxzdHJpbmcsIHVua25vd24+KSxcbiAgICAuLi4ocGlwZWxpbmUub3JnSWQgPyB7IG9yZ0lkOiBwaXBlbGluZS5vcmdJZCB9IDoge30pLFxuICAgIHBpcGVsaW5lSWQ6IHBpcGVsaW5lLmlkIHx8IHBpcGVsaW5lSWQsXG4gIH07XG5cbiAgY29uc3QgcmVzb2x2ZWRQbHVnaW5zID0gYXdhaXQgcmVzb2x2ZVBsdWdpbnNGb3JQcm9wcyhjbGllbnQsIHByb3BzV2l0aElkcyk7XG4gIGlmIChPYmplY3Qua2V5cyhyZXNvbHZlZFBsdWdpbnMpLmxlbmd0aCA+IDApIHtcbiAgICBwcm9wc1dpdGhJZHMucmVzb2x2ZWRQbHVnaW5zID0gcmVzb2x2ZWRQbHVnaW5zO1xuICAgIHByaW50SW5mbygnUHJlLXJlc29sdmVkIHBsdWdpbnMnLCB7IGNvdW50OiBPYmplY3Qua2V5cyhyZXNvbHZlZFBsdWdpbnMpLmxlbmd0aCB9KTtcbiAgfVxuXG4gIGJha2VQbGF0Zm9ybVJlZ2lzdHJ5KHByb3BzV2l0aElkcywgY29uZmlnLmFwaS5iYXNlVXJsKTtcbiAgcmV0dXJuIHsgcGlwZWxpbmUsIHByb3BzV2l0aElkcywgYmFzZVVybDogY29uZmlnLmFwaS5iYXNlVXJsIH07XG59XG5cbi8qKlxuICogQXBwbHkgcGFzcy0xIHNlbGYtcmVmZXJlbmNpbmcgdGVtcGxhdGUgcmVzb2x1dGlvbiB0byBgcHJvcHNXaXRoSWRzYCBhbmQgcHJpbnQgaXRcbiAqIHRvIHN0ZG91dCAodXNlZCBieSBgc3ludGggLS1zaG93LXJlc29sdmVkYCAvIGBkZXBsb3kgLS1zaG93LXJlc29sdmVkYCkuIEV4aXRzIHdpdGhcbiAqIGNvZGUgMSBpZiByZXNvbHV0aW9uIHJlcG9ydHMgZXJyb3JzLiBgcmVzb2x2ZVNlbGZSZWZlcmVuY2luZ2AgbXV0YXRlcyB0aGUgb2JqZWN0XG4gKiBpbiBwbGFjZSwgc28gdGhlIHByaW50ZWQgSlNPTiByZWZsZWN0cyB0aGUgZXhwYW5kZWQgdGVtcGxhdGVzLlxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gcHJpbnRSZXNvbHZlZE9yRXhpdChwcm9wc1dpdGhJZHM6IFJlY29yZDxzdHJpbmcsIHVua25vd24+KTogUHJvbWlzZTx2b2lkPiB7XG4gIGNvbnN0IHsgcmVzb2x2ZVNlbGZSZWZlcmVuY2luZyB9ID0gYXdhaXQgaW1wb3J0KCdAcGlwZWxpbmUtYnVpbGRlci9waXBlbGluZS1jb3JlJyk7XG4gIGNvbnN0IHNjb3BlID0geyBtZXRhZGF0YTogcHJvcHNXaXRoSWRzLm1ldGFkYXRhID8/IHt9LCB2YXJzOiBwcm9wc1dpdGhJZHMudmFycyA/PyB7fSB9O1xuICBjb25zdCBpc1RwbCA9IChmOiBzdHJpbmcpID0+IGYgPT09ICdwcm9qZWN0TmFtZScgfHwgZi5zdGFydHNXaXRoKCdtZXRhZGF0YS4nKSB8fCBmLnN0YXJ0c1dpdGgoJ3ZhcnMuJyk7XG4gIGNvbnN0IHJlc3VsdCA9IHJlc29sdmVTZWxmUmVmZXJlbmNpbmcocHJvcHNXaXRoSWRzLCBzY29wZSwgaXNUcGwsIChmOiBzdHJpbmcpID0+IChpc1RwbChmKSA/IGYgOiBudWxsKSk7XG4gIGlmIChyZXN1bHQuZXJyb3JzLmxlbmd0aCkge1xuICAgIGNvbnNvbGUuZXJyb3IoJ1Jlc29sdXRpb24gZXJyb3JzOicpO1xuICAgIGZvciAoY29uc3QgZSBvZiByZXN1bHQuZXJyb3JzKSBjb25zb2xlLmVycm9yKGAgIFske2UuZmllbGQgPz8gJz8nfV0gJHtlLm1lc3NhZ2V9YCk7XG4gICAgcHJvY2Vzcy5leGl0KDEpO1xuICB9XG4gIGNvbnNvbGUubG9nKEpTT04uc3RyaW5naWZ5KHByb3BzV2l0aElkcywgbnVsbCwgMikpO1xufVxuIl19

package/dist/utils/platform-secret.d.ts

@@ -1,10 +1,28 @@
 /** Login/secret options shared across the platform-secret helpers. */
 export interface PlatformSecretOptions {
-    /** Login identifier (username OR email) — matches `auth login` / `auth pat`. */
+    /**
+     * Login identifier (username OR email) for the NON-INTERACTIVE machine login
+     * below. This is the only password path left in the CLI: `auth login` and
+     * `auth pat` sign in through the browser (device authorization), but
+     * `store-token` / `setup-events` run on hosts with nobody present to approve a
+     * code, and what they mint is a machine credential, not a person's session.
+     */
     readonly identifier?: string;
     readonly password?: string;
     readonly verifySsl?: boolean;
 }
+/**
+ * The Secrets Manager path a stored machine credential lives at:
+ * `{SECRETS_PATH_PREFIX}/{orgId}/{leaf}`.
+ *
+ * `leaf` is `platform` for the org's full-privilege automation credential, and
+ * the scope's slug (`reporting-ingest`, `registry-push`) for a least-privilege
+ * one — so a scoped credential can never clobber the platform one, and the
+ * events Lambda's secret is a different object from CodeBuild's.
+ */
+export declare function secretNameForOrg(orgId: string, leaf?: string): string;
+/** A capability scope as a secret-path leaf: `reporting:ingest` → `reporting-ingest`. */
+export declare function scopeSecretLeaf(scope: string): string;
 /**
  * Derive the platform secret path from a JWT's organizationId.
  * Pattern: `{SECRETS_PATH_PREFIX}/{orgId}/platform`.

package/dist/utils/platform-secret.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"platform-secret.d.ts","sourceRoot":"","sources":["../../src/utils/platform-secret.ts"],"names":[],"mappings":"AAkBA,sEAAsE;AACtE,MAAM,WAAW,qBAAqB;IACpC,gFAAgF;IAChF,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOvD;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CA0CvF;AAED;;;;GAIG;AACH,wBAAsB,yBAAyB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,CAAC,CAY/F"}
+{"version":3,"file":"platform-secret.d.ts","sourceRoot":"","sources":["../../src/utils/platform-secret.ts"],"names":[],"mappings":"AAmBA,sEAAsE;AACtE,MAAM,WAAW,qBAAqB;IACpC;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,MAAmB,GAAG,MAAM,CAEjF;AAED,yFAAyF;AACzF,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAevD;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyCvF;AAED;;;;GAIG;AACH,wBAAsB,yBAAyB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,CAAC,CAY/F"}

package/dist/utils/platform-secret.js

@@ -7,24 +7,47 @@
  * lives here once: derive `{SECRETS_PATH_PREFIX}/{orgId}/platform` from the JWT's
  * organizationId, logging in first if needed to obtain the token.
  */
+import { isOpaqueApiKey } from '@pipeline-builder/api-core';
 import { CoreConstants } from '@pipeline-builder/pipeline-core';
 import axios from 'axios';
 import { decodeTokenPayload } from './auth-guard.js';
 import { getApiConfig } from './config-loader.js';
 import { printInfo, printSection, printSuccess, printWarning } from './output-utils.js';
 import { assertSslDisableAllowed } from './tls.js';
+/**
+ * The Secrets Manager path a stored machine credential lives at:
+ * `{SECRETS_PATH_PREFIX}/{orgId}/{leaf}`.
+ *
+ * `leaf` is `platform` for the org's full-privilege automation credential, and
+ * the scope's slug (`reporting-ingest`, `registry-push`) for a least-privilege
+ * one — so a scoped credential can never clobber the platform one, and the
+ * events Lambda's secret is a different object from CodeBuild's.
+ */
+export function secretNameForOrg(orgId, leaf = 'platform') {
+    return `${CoreConstants.SECRETS_PATH_PREFIX}/${orgId}/${leaf}`;
+}
+/** A capability scope as a secret-path leaf: `reporting:ingest` → `reporting-ingest`. */
+export function scopeSecretLeaf(scope) {
+    return scope.replace(/[^a-z0-9]+/gi, '-');
+}
 /**
  * Derive the platform secret path from a JWT's organizationId.
  * Pattern: `{SECRETS_PATH_PREFIX}/{orgId}/platform`.
  * @throws if the token carries no organizationId (caller should fall back to PLATFORM_SECRET_NAME).
  */
 export function resolveSecretName(token) {
+    // An ACCESS KEY (`pb_pat_…`) is opaque — it carries no org claim to read, by
+    // design. Say so instead of the generic decode failure, since exporting a key
+    // as PLATFORM_TOKEN is now the normal way to authenticate the CLI.
+    if (isOpaqueApiKey(token)) {
+        throw new Error('PLATFORM_TOKEN is an opaque access key, which carries no organizationId — set PLATFORM_SECRET_NAME to name the secret explicitly.');
+    }
     const payload = decodeTokenPayload(token);
     const orgId = payload?.organizationId;
     if (!orgId) {
         throw new Error('Token does not contain organizationId — cannot derive secret name. Set PLATFORM_SECRET_NAME to specify it explicitly.');
     }
-    return `${CoreConstants.SECRETS_PATH_PREFIX}/${orgId}/platform`;
+    return secretNameForOrg(orgId);
 }
 /**
  * Ensure `process.env.PLATFORM_TOKEN` is set. No-op if it already is. Otherwise,
@@ -57,8 +80,7 @@ export async function ensurePlatformToken(options) {
     const rejectUnauthorized = options.verifySsl === false ? false : apiConfig.api.rejectUnauthorized;
     const loginResponse = await axios.post(`${apiConfig.api.baseUrl}/api/auth/login`, 
     // The server's loginSchema requires `identifier` (email OR username), not
-    // `email` — sending `email` fails zod validation with a 400. Mirror the
-    // canonical `postLogin` body.
+    // `email` — sending `email` fails zod validation with a 400.
     { identifier: loginIdentifier, password: loginPassword }, {
         httpsAgent: rejectUnauthorized === false
             ? new (await import('https')).Agent({ rejectUnauthorized: false })
@@ -89,4 +111,4 @@ export async function resolvePlatformSecretName(options) {
     }
     return resolveSecretName(process.env.PLATFORM_TOKEN);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"platform-secret.js","sourceRoot":"","sources":["../../src/utils/platform-secret.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared platform-token → secret-name resolution, used by both `store-token`\n * (which WRITES the JWT to Secrets Manager) and `setup-events` (which deploys the\n * Lambda that READS it). Both must agree on the same secret path, so the logic\n * lives here once: derive `{SECRETS_PATH_PREFIX}/{orgId}/platform` from the JWT's\n * organizationId, logging in first if needed to obtain the token.\n */\n\nimport { CoreConstants } from '@pipeline-builder/pipeline-core';\nimport axios from 'axios';\nimport { decodeTokenPayload } from './auth-guard.js';\nimport { getApiConfig } from './config-loader.js';\nimport { printInfo, printSection, printSuccess, printWarning } from './output-utils.js';\nimport { assertSslDisableAllowed } from './tls.js';\n\n/** Login/secret options shared across the platform-secret helpers. */\nexport interface PlatformSecretOptions {\n  /** Login identifier (username OR email) — matches `auth login` / `auth pat`. */\n  readonly identifier?: string;\n  readonly password?: string;\n  readonly verifySsl?: boolean;\n}\n\n/**\n * Derive the platform secret path from a JWT's organizationId.\n * Pattern: `{SECRETS_PATH_PREFIX}/{orgId}/platform`.\n * @throws if the token carries no organizationId (caller should fall back to PLATFORM_SECRET_NAME).\n */\nexport function resolveSecretName(token: string): string {\n  const payload = decodeTokenPayload(token);\n  const orgId = payload?.organizationId;\n  if (!orgId) {\n    throw new Error('Token does not contain organizationId — cannot derive secret name. Set PLATFORM_SECRET_NAME to specify it explicitly.');\n  }\n  return `${CoreConstants.SECRETS_PATH_PREFIX}/${orgId}/platform`;\n}\n\n/**\n * Ensure `process.env.PLATFORM_TOKEN` is set. No-op if it already is. Otherwise,\n * if login creds are available (`--identifier/--password` or `PLATFORM_IDENTIFIER`/\n * `PLATFORM_PASSWORD` env — the env path lets `provision` pass creds without\n * putting the password on the command line), log in and set PLATFORM_TOKEN.\n */\nexport async function ensurePlatformToken(options: PlatformSecretOptions): Promise<void> {\n  if (process.env.PLATFORM_TOKEN) return;\n  const loginIdentifier = options.identifier || process.env.PLATFORM_IDENTIFIER;\n  const loginPassword = options.password || process.env.PLATFORM_PASSWORD;\n  if (!loginIdentifier || !loginPassword) return;\n\n  if (options.password) {\n    printWarning('Passing --password on the command line can expose it via shell history; prefer the PLATFORM_PASSWORD env var.');\n  }\n\n  printSection('Login');\n  printInfo('Authenticating with identifier/password...');\n  // Resolve the base URL WITHOUT demanding a token — this login step runs\n  // pre-auth (no PLATFORM_TOKEN yet), so `getConfig()` would throw here. The\n  // token-optional loader still honors config files + PLATFORM_BASE_URL/TLS env.\n  const apiConfig = getApiConfig();\n  // SECURITY: this inline login POSTs the password. Refuse to disable cert\n  // verification in production (mirrors config-loader / login) so a MITM can't\n  // harvest it; honored in non-production for self-signed dev platforms.\n  if (options.verifySsl === false) {\n    assertSslDisableAllowed('inline login');\n  }\n  const rejectUnauthorized = options.verifySsl === false ? false : apiConfig.api.rejectUnauthorized;\n  const loginResponse = await axios.post(\n    `${apiConfig.api.baseUrl}/api/auth/login`,\n    // The server's loginSchema requires `identifier` (email OR username), not\n    // `email` — sending `email` fails zod validation with a 400. Mirror the\n    // canonical `postLogin` body.\n    { identifier: loginIdentifier, password: loginPassword },\n    {\n      httpsAgent: rejectUnauthorized === false\n        ? new (await import('https')).Agent({ rejectUnauthorized: false })\n        : undefined,\n    },\n  );\n  const loginData = loginResponse.data?.data ?? loginResponse.data;\n  const loginToken = loginData?.accessToken;\n  if (!loginToken || typeof loginToken !== 'string') {\n    throw new Error('Login failed — no access token in response');\n  }\n  process.env.PLATFORM_TOKEN = loginToken;\n  printSuccess('Login successful');\n}\n\n/**\n * Resolve the platform secret name: an explicit `PLATFORM_SECRET_NAME` env wins;\n * otherwise log in if needed and derive it from the platform token's org — the\n * same token `init-platform.sh` (register) mints, so writer and reader agree.\n */\nexport async function resolvePlatformSecretName(options: PlatformSecretOptions): Promise<string> {\n  const explicit = process.env.PLATFORM_SECRET_NAME;\n  if (explicit) return explicit;\n  await ensurePlatformToken(options);\n  if (!process.env.PLATFORM_TOKEN) {\n    throw new Error(\n      'Cannot derive the platform secret name: no PLATFORM_TOKEN and no login creds. '\n      + 'Set PLATFORM_SECRET_NAME, or provide login creds '\n      + '(--identifier/--password or PLATFORM_IDENTIFIER/PLATFORM_PASSWORD).',\n    );\n  }\n  return resolveSecretName(process.env.PLATFORM_TOKEN);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"platform-secret.js","sourceRoot":"","sources":["../../src/utils/platform-secret.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared platform-token → secret-name resolution, used by both `store-token`\n * (which WRITES the JWT to Secrets Manager) and `setup-events` (which deploys the\n * Lambda that READS it). Both must agree on the same secret path, so the logic\n * lives here once: derive `{SECRETS_PATH_PREFIX}/{orgId}/platform` from the JWT's\n * organizationId, logging in first if needed to obtain the token.\n */\n\nimport { isOpaqueApiKey } from '@pipeline-builder/api-core';\nimport { CoreConstants } from '@pipeline-builder/pipeline-core';\nimport axios from 'axios';\nimport { decodeTokenPayload } from './auth-guard.js';\nimport { getApiConfig } from './config-loader.js';\nimport { printInfo, printSection, printSuccess, printWarning } from './output-utils.js';\nimport { assertSslDisableAllowed } from './tls.js';\n\n/** Login/secret options shared across the platform-secret helpers. */\nexport interface PlatformSecretOptions {\n  /**\n   * Login identifier (username OR email) for the NON-INTERACTIVE machine login\n   * below. This is the only password path left in the CLI: `auth login` and\n   * `auth pat` sign in through the browser (device authorization), but\n   * `store-token` / `setup-events` run on hosts with nobody present to approve a\n   * code, and what they mint is a machine credential, not a person's session.\n   */\n  readonly identifier?: string;\n  readonly password?: string;\n  readonly verifySsl?: boolean;\n}\n\n/**\n * The Secrets Manager path a stored machine credential lives at:\n * `{SECRETS_PATH_PREFIX}/{orgId}/{leaf}`.\n *\n * `leaf` is `platform` for the org's full-privilege automation credential, and\n * the scope's slug (`reporting-ingest`, `registry-push`) for a least-privilege\n * one — so a scoped credential can never clobber the platform one, and the\n * events Lambda's secret is a different object from CodeBuild's.\n */\nexport function secretNameForOrg(orgId: string, leaf: string = 'platform'): string {\n  return `${CoreConstants.SECRETS_PATH_PREFIX}/${orgId}/${leaf}`;\n}\n\n/** A capability scope as a secret-path leaf: `reporting:ingest` → `reporting-ingest`. */\nexport function scopeSecretLeaf(scope: string): string {\n  return scope.replace(/[^a-z0-9]+/gi, '-');\n}\n\n/**\n * Derive the platform secret path from a JWT's organizationId.\n * Pattern: `{SECRETS_PATH_PREFIX}/{orgId}/platform`.\n * @throws if the token carries no organizationId (caller should fall back to PLATFORM_SECRET_NAME).\n */\nexport function resolveSecretName(token: string): string {\n  // An ACCESS KEY (`pb_pat_…`) is opaque — it carries no org claim to read, by\n  // design. Say so instead of the generic decode failure, since exporting a key\n  // as PLATFORM_TOKEN is now the normal way to authenticate the CLI.\n  if (isOpaqueApiKey(token)) {\n    throw new Error(\n      'PLATFORM_TOKEN is an opaque access key, which carries no organizationId — set PLATFORM_SECRET_NAME to name the secret explicitly.',\n    );\n  }\n  const payload = decodeTokenPayload(token);\n  const orgId = payload?.organizationId;\n  if (!orgId) {\n    throw new Error('Token does not contain organizationId — cannot derive secret name. Set PLATFORM_SECRET_NAME to specify it explicitly.');\n  }\n  return secretNameForOrg(orgId);\n}\n\n/**\n * Ensure `process.env.PLATFORM_TOKEN` is set. No-op if it already is. Otherwise,\n * if login creds are available (`--identifier/--password` or `PLATFORM_IDENTIFIER`/\n * `PLATFORM_PASSWORD` env — the env path lets `provision` pass creds without\n * putting the password on the command line), log in and set PLATFORM_TOKEN.\n */\nexport async function ensurePlatformToken(options: PlatformSecretOptions): Promise<void> {\n  if (process.env.PLATFORM_TOKEN) return;\n  const loginIdentifier = options.identifier || process.env.PLATFORM_IDENTIFIER;\n  const loginPassword = options.password || process.env.PLATFORM_PASSWORD;\n  if (!loginIdentifier || !loginPassword) return;\n\n  if (options.password) {\n    printWarning('Passing --password on the command line can expose it via shell history; prefer the PLATFORM_PASSWORD env var.');\n  }\n\n  printSection('Login');\n  printInfo('Authenticating with identifier/password...');\n  // Resolve the base URL WITHOUT demanding a token — this login step runs\n  // pre-auth (no PLATFORM_TOKEN yet), so `getConfig()` would throw here. The\n  // token-optional loader still honors config files + PLATFORM_BASE_URL/TLS env.\n  const apiConfig = getApiConfig();\n  // SECURITY: this inline login POSTs the password. Refuse to disable cert\n  // verification in production (mirrors config-loader / login) so a MITM can't\n  // harvest it; honored in non-production for self-signed dev platforms.\n  if (options.verifySsl === false) {\n    assertSslDisableAllowed('inline login');\n  }\n  const rejectUnauthorized = options.verifySsl === false ? false : apiConfig.api.rejectUnauthorized;\n  const loginResponse = await axios.post(\n    `${apiConfig.api.baseUrl}/api/auth/login`,\n    // The server's loginSchema requires `identifier` (email OR username), not\n    // `email` — sending `email` fails zod validation with a 400.\n    { identifier: loginIdentifier, password: loginPassword },\n    {\n      httpsAgent: rejectUnauthorized === false\n        ? new (await import('https')).Agent({ rejectUnauthorized: false })\n        : undefined,\n    },\n  );\n  const loginData = loginResponse.data?.data ?? loginResponse.data;\n  const loginToken = loginData?.accessToken;\n  if (!loginToken || typeof loginToken !== 'string') {\n    throw new Error('Login failed — no access token in response');\n  }\n  process.env.PLATFORM_TOKEN = loginToken;\n  printSuccess('Login successful');\n}\n\n/**\n * Resolve the platform secret name: an explicit `PLATFORM_SECRET_NAME` env wins;\n * otherwise log in if needed and derive it from the platform token's org — the\n * same token `init-platform.sh` (register) mints, so writer and reader agree.\n */\nexport async function resolvePlatformSecretName(options: PlatformSecretOptions): Promise<string> {\n  const explicit = process.env.PLATFORM_SECRET_NAME;\n  if (explicit) return explicit;\n  await ensurePlatformToken(options);\n  if (!process.env.PLATFORM_TOKEN) {\n    throw new Error(\n      'Cannot derive the platform secret name: no PLATFORM_TOKEN and no login creds. '\n      + 'Set PLATFORM_SECRET_NAME, or provide login creds '\n      + '(--identifier/--password or PLATFORM_IDENTIFIER/PLATFORM_PASSWORD).',\n    );\n  }\n  return resolveSecretName(process.env.PLATFORM_TOKEN);\n}\n"]}

package/dist/utils/service-account.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Provisioning the org's MACHINE identity for stored credentials (#12 / #N2).
+ *
+ * Every credential the CLI parks in AWS Secrets Manager used to be a machine
+ * SESSION belonging to whoever ran the command: a person's JWT, renewed daily by
+ * re-minting it under that person's session. It outlived their employment, it
+ * carried their authority, and the audit trail read as if they had personally
+ * pushed every image.
+ *
+ * What it writes instead is a `pb_sa_…` key on an org SERVICE ACCOUNT:
+ *   - the account is the principal, so audit rows name it, not the operator;
+ *   - its Roles are the narrowest that work — for a SCOPED credential that is no
+ *     Roles at all, just the one capability (`reporting:ingest`, `registry:push`);
+ *   - the key is opaque and short-lived at the point of use (5-minute exchanged
+ *     tokens), so revoking it actually stops the automation;
+ *   - it takes no seat and survives the operator leaving.
+ *
+ * Creating an account and issuing a key are BOTH step-up gated on the platform —
+ * they mint durable bearer credentials, the same class of action a personal key
+ * is gated for. So this module needs the operator's password (`--password` or
+ * `PLATFORM_PASSWORD`), which is also the only reason `store-token` still has a
+ * password path at all. A step-up token is single-use and lives about a minute,
+ * so one is minted immediately before each gated call.
+ */
+import type { ApiClient } from './api-client.js';
+/** What the caller wants provisioned. */
+export interface ProvisionKeyOptions {
+    /** An authenticated client for the operator's own session. */
+    client: ApiClient;
+    /** The operator's password — required, because every key write is step-up gated. */
+    password: string;
+    /** Machine name of the service account (`[a-z0-9][a-z0-9_-]{1,63}`). */
+    accountName: string;
+    /** Human description recorded on a newly created account. */
+    description: string;
+    /**
+     * Roles to grant a NEWLY created account: `'admin'` for the full-privilege
+     * platform credential (synth/deploy callbacks, plugin lookup, image push),
+     * `'none'` for a scoped credential, which needs no Roles at all.
+     */
+    roles: 'admin' | 'none';
+    /** Narrow capability scope stamped on the KEY (not the account). */
+    scope?: string;
+    /** Key lifetime in seconds (platform caps this at 365 days). */
+    expiresInSeconds: number;
+    /** Key label — shown on the org's service-accounts page. */
+    keyName: string;
+}
+/** A freshly minted key, plus everything the secret needs to record about it. */
+export interface ProvisionedKey {
+    /** The raw `pb_sa_…` key — returned ONCE by the platform, never readable again. */
+    key: string;
+    keyId: string;
+    serviceAccountId: string;
+    serviceAccountName: string;
+    organizationId: string;
+    expiresAt: string;
+    scope: string | null;
+}
+/** The org the operator's token is active in. */
+export declare function resolveOrganizationId(client: ApiClient): Promise<string>;
+/** Revoke one of an account's keys. Best-effort by contract — see the call sites. */
+export declare function revokeServiceAccountKey(client: ApiClient, password: string, orgId: string, accountId: string, keyId: string): Promise<void>;
+/**
+ * Ensure the named service account exists and issue it a fresh key.
+ *
+ * Deliberately does NOT revoke anything the caller was previously holding: the
+ * caller stores the new key first and retires the old one afterwards (see
+ * `store-token`), so a failure at any point leaves a working credential in the
+ * secret rather than an empty one.
+ */
+export declare function provisionServiceAccountKey(opts: ProvisionKeyOptions): Promise<ProvisionedKey>;
+//# sourceMappingURL=service-account.d.ts.map

package/dist/utils/service-account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-account.d.ts","sourceRoot":"","sources":["../../src/utils/service-account.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAMjD,yCAAyC;AACzC,MAAM,WAAW,mBAAmB;IAClC,8DAA8D;IAC9D,MAAM,EAAE,SAAS,CAAC;IAClB,oFAAoF;IACpF,QAAQ,EAAE,MAAM,CAAC;IACjB,wEAAwE;IACxE,WAAW,EAAE,MAAM,CAAC;IACpB,6DAA6D;IAC7D,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC;IACxB,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,gBAAgB,EAAE,MAAM,CAAC;IACzB,4DAA4D;IAC5D,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC7B,mFAAmF;IACnF,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,EAAE,MAAM,CAAC;IACzB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAiDD,iDAAiD;AACjD,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAO9E;AA0DD,qFAAqF;AACrF,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAKf;AAyCD;;;;;;;GAOG;AACH,wBAAsB,0BAA0B,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,cAAc,CAAC,CAanG"}