@pipeline-builder/pipeline-manager 4.1.3 → 4.1.5

package/dist/commands/create-pat.js

@@ -4,68 +4,71 @@ import axios from 'axios';
 import { Command } from 'commander';
 import pico from 'picocolors';
 import { TIMEOUTS } from '../config/cli.constants.js';
-import { assertCredentialTlsAllowed, credentialHttpsAgent, postLogin, resolveCredentials, switchOrganization } from '../utils/auth-utils.js';
+import { assertCredentialTlsAllowed, credentialHttpsAgent, switchOrganization } from '../utils/auth-utils.js';
 import { printCommandHeader, withSslOptions } from '../utils/command-utils.js';
+import { DeviceAuthError, openInBrowser, pollForDeviceToken, requestDeviceCode } from '../utils/device-auth.js';
 import { ERROR_CODES, handleError } from '../utils/error-handler.js';
-import { printDebug, printError, printInfo, printKeyValue, printSuccess, printWarning } from '../utils/output-utils.js';
-import { checkAuthRateLimit, recordAuthFailure, recordAuthSuccess } from '../utils/rate-limiter.js';
-const { bold, green, yellow } = pico;
+import { printDebug, printError, printInfo, printKeyValue, printSuccess } from '../utils/output-utils.js';
+const { bold, cyan, dim, green, yellow } = pico;
 const MAX_EXPIRES_DAYS = 365;
 /**
- * Registers the `create-pat` command with the CLI program.
+ * Registers the `pat` command with the CLI program.
  *
- * Mints a named Personal Access Token — a durable, individually-revocable API
- * credential — for CI/automation. Unlike `login` (which returns a short-lived
- * session token), a PAT is the right long-lived credential for scripts.
+ * Mints a named ACCESS KEY (`pb_pat_…`) — a durable, individually-revocable API
+ * credential — for CI/automation. Unlike a session, a key is the right
+ * long-lived credential for scripts.
  *
- * The platform gates PAT creation behind step-up re-authentication, so this
- * command chains three calls: login (→ access token), step-up with the same
- * password (→ step-up token), then POST /user/pats. The PAT binds to the user's
- * active org; pass `--org` to switch first (persists as the active org).
+ * The key is OPAQUE: it carries no claims, and each service trades it at
+ * platform's /auth/token/exchange for a 5-minute token, so revoking it takes
+ * effect everywhere within five minutes.
  *
- * The raw token is printed ONCE. `--quiet` prints only `export PLATFORM_TOKEN=…`
- * so it can be `eval`'d — the PAT is itself a valid Bearer credential.
+ * Creating one is step-up gated server-side, which used to mean the CLI had to
+ * hold a password (it POSTed it twice — sign-in, then step-up). It no longer
+ * has one: the device flow asks for the step-up IN THE BROWSER, where the
+ * account's real factors live, and the approved poll returns both the session
+ * and a short-lived step-up token. The key binds to the user's active org; pass
+ * `--org` to switch first (which persists as the active org).
+ *
+ * The raw key is printed ONCE — only its hash is stored, so it can never be read
+ * back. `--quiet` prints only `export PLATFORM_TOKEN=…` so it can be `eval`'d;
+ * the key is itself a valid Bearer credential.
  *
  * @param program - The root Commander program instance to attach the command to.
  *
  * @example
  * ```bash
- * PLATFORM_PASSWORD=secret pipeline-manager auth pat --name ci-deploy -u ci@example.com
- * pipeline-manager auth pat --name ci --expires-days 30 -u ci@example.com -p secret
- * eval $(PLATFORM_PASSWORD=secret pipeline-manager auth pat --name ci -u ci@example.com --quiet)
+ * pipeline-manager auth pat --name ci-deploy
+ * pipeline-manager auth pat --name ci --expires-days 30 --org <orgId>
+ * eval $(pipeline-manager auth pat --name ci --quiet)
  * ```
  */
 export function createPat(program) {
     withSslOptions(program
         .command('pat')
-        .description('Create a named Personal Access Token (long-lived CLI/automation credential)')
-        .requiredOption('--name <name>', 'Human-readable token name (e.g. ci-deploy)')
-        .option('--expires-days <days>', `Token lifetime in days (1-${MAX_EXPIRES_DAYS})`, '90')
-        .option('--scope <scope>', 'Optional token scope')
-        .option('-u, --identifier <identifier>', 'Username or email')
-        .option('-p, --password <password>', 'Password (prefer PLATFORM_PASSWORD env)')
-        .option('--org <orgId>', 'Bind the token to a specific organization (switches active org)')
+        .description('Create a named access key (long-lived, opaque CLI/automation credential)')
+        .requiredOption('--name <name>', 'Human-readable key name (e.g. ci-deploy)')
+        .option('--expires-days <days>', `Key lifetime in days (1-${MAX_EXPIRES_DAYS})`, '90')
+        .option('--scope <scope>', 'Optional capability scope (least-privilege key)')
+        .option('--org <orgId>', 'Bind the key to a specific organization (switches active org)')
+        .option('--no-browser', 'Never open a browser — print the verification URL instead')
         .option('--url <url>', 'Platform base URL', process.env.PLATFORM_BASE_URL || 'https://localhost:8443'))
         .option('--quiet', 'Only print the export statement (useful for eval)')
         .action(async (options) => {
-        // SECURITY: this POSTs a plaintext password (login + step-up). Never send it
-        // over an unverified TLS connection in production — a MITM would harvest it.
-        // Mirrors the guard in `login`. Non-production still honors --no-verify-ssl.
+        // SECURITY: the poll returns a session AND a step-up token, and the response
+        // below carries the raw key. None of that may cross an unverified connection
+        // in production. Mirrors the guard in `login`.
         assertCredentialTlsAllowed(options.verifySsl);
-        // Credentials from flags OR PLATFORM_IDENTIFIER/PLATFORM_PASSWORD env (so the
-        // password need not appear in shell history / `ps`).
-        const { identifier, password } = resolveCredentials(options);
         const quiet = options.quiet ?? false;
-        const executionId = printCommandHeader('Create Personal Access Token', 'Create Personal Access Token', { quiet });
+        const executionId = printCommandHeader('Create Access Key', 'Create Access Key', { quiet });
         try {
             // Validate name.
             const name = typeof options.name === 'string' ? options.name.trim() : '';
             if (!name) {
-                printError('Token name is required (--name)');
+                printError('Key name is required (--name)');
                 process.exit(ERROR_CODES.VALIDATION);
             }
             if (name.length > 100) {
-                printError('Token name must be 100 characters or fewer');
+                printError('Key name must be 100 characters or fewer');
                 process.exit(ERROR_CODES.VALIDATION);
             }
             // Validate expiry → seconds.
@@ -75,68 +78,55 @@ export function createPat(program) {
                 process.exit(ERROR_CODES.VALIDATION);
             }
             const expiresIn = days * 86400;
-            // Credentials required — step-up needs a password, so --refresh can't work here.
-            if (!identifier || !password) {
-                printError('create-pat requires --identifier and --password (or PLATFORM_IDENTIFIER/PLATFORM_PASSWORD env)');
-                process.exit(ERROR_CODES.AUTHENTICATION);
-            }
-            if (options.password) {
-                printWarning('Passing --password on the command line can expose it via shell history; prefer the PLATFORM_PASSWORD env var.');
-            }
-            // Rate limiting — prevent brute force (keyed to identifier + url, like login).
-            const rateLimitMsg = checkAuthRateLimit(identifier, options.url);
-            if (rateLimitMsg) {
-                printError(rateLimitMsg);
-                process.exit(ERROR_CODES.AUTHENTICATION);
-            }
-            if (!quiet) {
-                printInfo('Authenticating', { identifier, url: options.url, verifySsl: options.verifySsl });
-            }
             const httpsAgent = credentialHttpsAgent(options.verifySsl);
             const timeout = TIMEOUTS.HTTP_REQUEST;
-            // 1) Login → session access token.
-            let accessToken;
-            try {
-                accessToken = await postLogin({ url: options.url, identifier, password, httpsAgent, timeout });
-            }
-            catch (error) {
-                recordAuthFailure(identifier, options.url);
-                throw error;
-            }
-            if (!accessToken) {
-                recordAuthFailure(identifier, options.url);
-                printError('Login failed: no access token in response');
+            const transport = { url: options.url, httpsAgent, timeout };
+            // 1) Device sign-in, asking for the step-up the create call needs.
+            if (!quiet)
+                printInfo('Starting browser sign-in', { url: options.url, verifySsl: options.verifySsl });
+            const code = await requestDeviceCode(transport, { stepUp: true });
+            const approvalUrl = code.verification_uri_complete || code.verification_uri;
+            const opened = options.browser !== false && openInBrowser(approvalUrl);
+            // The prompt goes to STDERR under `--quiet`: stdout is captured by
+            // `eval $(…)`, so printing the code there would swallow the one thing
+            // the user has to read before anything can proceed.
+            const say = quiet ? console.error : console.log;
+            say('');
+            say(`  Your code:  ${bold(cyan(code.user_code))}`);
+            say(`  Approve at: ${green(approvalUrl)}`);
+            say('');
+            say(dim(opened
+                ? '  Opening your browser… approve the code there, then come back.'
+                : '  Open that URL in a browser, check the code matches, and approve.'));
+            if (!quiet)
+                printInfo('Waiting for approval…');
+            const session = await pollForDeviceToken(transport, code);
+            let accessToken = session.access_token;
+            const stepUpToken = session.step_up_token;
+            if (!stepUpToken) {
+                printError('The approval did not return a step-up confirmation — approve the code promptly and try again.');
                 process.exit(ERROR_CODES.AUTHENTICATION);
             }
-            recordAuthSuccess(identifier, options.url);
-            // 2) Optionally bind to a specific org (persists as the active org, which the
-            //    PAT inherits).
+            // 2) Optionally bind to a specific org (persists as the active org, which
+            //    the key inherits). Rotates the session, but the step-up token is
+            //    bound to the user, not the session, so it survives the switch.
             if (options.org) {
                 if (!quiet)
                     printInfo('Switching to organization', { orgId: options.org });
-                accessToken = await switchOrganization({
+                accessToken = (await switchOrganization({
                     url: options.url,
                     orgId: options.org,
                     accessToken,
                     httpsAgent,
                     timeout,
                     quiet,
-                });
-            }
-            // 3) Step-up — re-verify the password to unlock the gated create call.
-            //    The returned token is short-lived (~60s), so we use it immediately.
-            const stepUpUrl = `${options.url}/api/auth/step-up`;
-            printDebug('POST', { url: stepUpUrl });
-            const stepUpRes = await axios.post(stepUpUrl, { password }, { headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${accessToken}` }, httpsAgent, timeout });
-            const stepUpToken = stepUpRes.data?.data?.stepUpToken;
-            if (!stepUpToken) {
-                printError('Step-up verification failed: no step-up token in response');
-                process.exit(ERROR_CODES.AUTHENTICATION);
+                })).accessToken;
             }
-            // 4) Create the PAT.
-            const patUrl = `${options.url}/api/user/pats`;
-            printDebug('POST', { url: patUrl });
-            const patRes = await axios.post(patUrl, { name, expiresIn, ...(options.scope ? { scope: options.scope } : {}) }, {
+            // 3) Create the access key. The step-up token is short-lived (~60s) and
+            //    single-use, so it is spent immediately.
+            const keyUrl = `${options.url}/api/user/keys`;
+            printDebug('POST', { url: keyUrl });
+            const keyRes = await axios.post(keyUrl, { name, expiresIn, ...(options.scope ? { scope: options.scope } : {}) }, {
                 headers: {
                     'Content-Type': 'application/json',
                     'Authorization': `Bearer ${accessToken}`,
@@ -145,39 +135,44 @@ export function createPat(program) {
                 httpsAgent,
                 timeout,
             });
-            const token = patRes.data?.data?.token;
-            const pat = patRes.data?.data?.pat;
-            if (!token) {
-                printError('Create token failed: no token in response');
+            const key = keyRes.data?.data?.key;
+            const meta = keyRes.data?.data?.accessKey;
+            if (!key) {
+                printError('Create key failed: no key in response');
                 process.exit(ERROR_CODES.API_REQUEST);
             }
-            // Quiet mode: emit only the export line (the PAT is a valid Bearer token).
+            // Quiet mode: emit only the export line (the key is a valid Bearer credential).
             if (quiet) {
-                console.log(`export PLATFORM_TOKEN=${token}`);
+                console.log(`export PLATFORM_TOKEN=${key}`);
                 return;
             }
             console.log('');
-            printSuccess('Personal access token created');
+            printSuccess('Access key created');
             console.log('');
             printKeyValue({
-                'Name': pat?.name ?? name,
-                'Token ID (jti)': pat?.jti ?? '(unknown)',
-                'Expires': pat?.expiresAt ?? `${days} day(s)`,
-                ...(pat?.scope ? { Scope: pat.scope } : {}),
+                'Name': meta?.name ?? name,
+                'Key ID': meta?.id ?? '(unknown)',
+                'Key': meta?.display ?? '(unknown)',
+                'Expires': meta?.expiresAt ?? `${days} day(s)`,
+                ...(meta?.scope ? { Scope: meta.scope } : {}),
             });
             console.log('');
-            console.log(yellow(bold('Copy your token now — it will not be shown again:')));
-            console.log(green(token));
+            console.log(yellow(bold('Copy your key now — only its hash is stored, so it will not be shown again:')));
+            console.log(green(key));
             console.log('');
             printInfo('Tip: use it as PLATFORM_TOKEN for subsequent commands:');
             console.log(green('  export PLATFORM_TOKEN=<token>'));
-            console.log(green(`  # or:  eval $(pipeline-manager auth pat --name ${name} -u ${identifier} --quiet)`));
+            console.log(green(`  # or:  eval $(pipeline-manager auth pat --name ${name} --quiet)`));
         }
         catch (error) {
+            if (error instanceof DeviceAuthError) {
+                printError(`Create key failed: ${error.message}`, { reason: error.code });
+                process.exit(ERROR_CODES.AUTHENTICATION);
+            }
             if (axios.isAxiosError(error)) {
                 const status = error.response?.status;
                 const message = error.response?.data?.message;
-                printError('Create token failed', {
+                printError('Create key failed', {
                     status: status ?? 'no response',
                     ...(message ? { message } : {}),
                 });
@@ -186,9 +181,9 @@ export function createPat(program) {
             handleError(error, ERROR_CODES.API_REQUEST, {
                 debug: program.opts().debug,
                 exit: true,
-                context: { command: 'create-pat', executionId, identifier: options.identifier, url: options.url },
+                context: { command: 'create-pat', executionId, url: options.url },
             });
         }
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-pat.js","sourceRoot":"","sources":["../../src/commands/create-pat.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 { Command } from 'commander';\nimport pico from 'picocolors';\nimport { TIMEOUTS } from '../config/cli.constants.js';\nimport { assertCredentialTlsAllowed, credentialHttpsAgent, postLogin, resolveCredentials, switchOrganization } from '../utils/auth-utils.js';\nimport { printCommandHeader, withSslOptions } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printDebug, printError, printInfo, printKeyValue, printSuccess, printWarning } from '../utils/output-utils.js';\nimport { checkAuthRateLimit, recordAuthFailure, recordAuthSuccess } from '../utils/rate-limiter.js';\n\nconst { bold, green, yellow } = pico;\n\n/** Step-up response — a short-lived (60s) JWT bound to the user's sub. */\ninterface StepUpResponse {\n  success: boolean;\n  data: { stepUpToken: string };\n}\n\n/** Create-PAT response — the raw token is returned exactly once. */\ninterface CreatePatResponse {\n  success: boolean;\n  data: {\n    token: string;\n    pat: { jti: string; name: string; expiresAt: string; scope?: string | null };\n  };\n}\n\nconst MAX_EXPIRES_DAYS = 365;\n\n/**\n * Registers the `create-pat` command with the CLI program.\n *\n * Mints a named Personal Access Token — a durable, individually-revocable API\n * credential — for CI/automation. Unlike `login` (which returns a short-lived\n * session token), a PAT is the right long-lived credential for scripts.\n *\n * The platform gates PAT creation behind step-up re-authentication, so this\n * command chains three calls: login (→ access token), step-up with the same\n * password (→ step-up token), then POST /user/pats. The PAT binds to the user's\n * active org; pass `--org` to switch first (persists as the active org).\n *\n * The raw token is printed ONCE. `--quiet` prints only `export PLATFORM_TOKEN=…`\n * so it can be `eval`'d — the PAT is itself a valid Bearer credential.\n *\n * @param program - The root Commander program instance to attach the command to.\n *\n * @example\n * ```bash\n * PLATFORM_PASSWORD=secret pipeline-manager auth pat --name ci-deploy -u ci@example.com\n * pipeline-manager auth pat --name ci --expires-days 30 -u ci@example.com -p secret\n * eval $(PLATFORM_PASSWORD=secret pipeline-manager auth pat --name ci -u ci@example.com --quiet)\n * ```\n */\nexport function createPat(program: Command): void {\n  withSslOptions(program\n    .command('pat')\n    .description('Create a named Personal Access Token (long-lived CLI/automation credential)')\n    .requiredOption('--name <name>', 'Human-readable token name (e.g. ci-deploy)')\n    .option('--expires-days <days>', `Token lifetime in days (1-${MAX_EXPIRES_DAYS})`, '90')\n    .option('--scope <scope>', 'Optional token scope')\n    .option('-u, --identifier <identifier>', 'Username or email')\n    .option('-p, --password <password>', 'Password (prefer PLATFORM_PASSWORD env)')\n    .option('--org <orgId>', 'Bind the token to a specific organization (switches active org)')\n    .option('--url <url>', 'Platform base URL', process.env.PLATFORM_BASE_URL || 'https://localhost:8443'))\n    .option('--quiet', 'Only print the export statement (useful for eval)')\n    .action(async (options) => {\n      // SECURITY: this POSTs a plaintext password (login + step-up). Never send it\n      // over an unverified TLS connection in production — a MITM would harvest it.\n      // Mirrors the guard in `login`. Non-production still honors --no-verify-ssl.\n      assertCredentialTlsAllowed(options.verifySsl);\n\n      // Credentials from flags OR PLATFORM_IDENTIFIER/PLATFORM_PASSWORD env (so the\n      // password need not appear in shell history / `ps`).\n      const { identifier, password } = resolveCredentials(options);\n      const quiet = options.quiet ?? false;\n      const executionId = printCommandHeader(\n        'Create Personal Access Token',\n        'Create Personal Access Token',\n        { quiet },\n      );\n\n      try {\n        // Validate name.\n        const name = typeof options.name === 'string' ? options.name.trim() : '';\n        if (!name) {\n          printError('Token name is required (--name)');\n          process.exit(ERROR_CODES.VALIDATION);\n        }\n        if (name.length > 100) {\n          printError('Token name must be 100 characters or fewer');\n          process.exit(ERROR_CODES.VALIDATION);\n        }\n\n        // Validate expiry → seconds.\n        const days = Math.floor(Number(options.expiresDays));\n        if (!Number.isFinite(days) || days < 1 || days > MAX_EXPIRES_DAYS) {\n          printError(`--expires-days must be an integer between 1 and ${MAX_EXPIRES_DAYS}`);\n          process.exit(ERROR_CODES.VALIDATION);\n        }\n        const expiresIn = days * 86400;\n\n        // Credentials required — step-up needs a password, so --refresh can't work here.\n        if (!identifier || !password) {\n          printError('create-pat requires --identifier and --password (or PLATFORM_IDENTIFIER/PLATFORM_PASSWORD env)');\n          process.exit(ERROR_CODES.AUTHENTICATION);\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        // Rate limiting — prevent brute force (keyed to identifier + url, like login).\n        const rateLimitMsg = checkAuthRateLimit(identifier, options.url);\n        if (rateLimitMsg) {\n          printError(rateLimitMsg);\n          process.exit(ERROR_CODES.AUTHENTICATION);\n        }\n\n        if (!quiet) {\n          printInfo('Authenticating', { identifier, url: options.url, verifySsl: options.verifySsl });\n        }\n\n        const httpsAgent = credentialHttpsAgent(options.verifySsl);\n        const timeout = TIMEOUTS.HTTP_REQUEST;\n\n        // 1) Login → session access token.\n        let accessToken: string | undefined;\n        try {\n          accessToken = await postLogin({ url: options.url, identifier, password, httpsAgent, timeout });\n        } catch (error) {\n          recordAuthFailure(identifier, options.url);\n          throw error;\n        }\n        if (!accessToken) {\n          recordAuthFailure(identifier, options.url);\n          printError('Login failed: no access token in response');\n          process.exit(ERROR_CODES.AUTHENTICATION);\n        }\n        recordAuthSuccess(identifier, options.url);\n\n        // 2) Optionally bind to a specific org (persists as the active org, which the\n        //    PAT inherits).\n        if (options.org) {\n          if (!quiet) printInfo('Switching to organization', { orgId: options.org });\n          accessToken = await switchOrganization({\n            url: options.url,\n            orgId: options.org,\n            accessToken,\n            httpsAgent,\n            timeout,\n            quiet,\n          });\n        }\n\n        // 3) Step-up — re-verify the password to unlock the gated create call.\n        //    The returned token is short-lived (~60s), so we use it immediately.\n        const stepUpUrl = `${options.url}/api/auth/step-up`;\n        printDebug('POST', { url: stepUpUrl });\n        const stepUpRes = await axios.post<StepUpResponse>(\n          stepUpUrl,\n          { password },\n          { headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${accessToken}` }, httpsAgent, timeout },\n        );\n        const stepUpToken = stepUpRes.data?.data?.stepUpToken;\n        if (!stepUpToken) {\n          printError('Step-up verification failed: no step-up token in response');\n          process.exit(ERROR_CODES.AUTHENTICATION);\n        }\n\n        // 4) Create the PAT.\n        const patUrl = `${options.url}/api/user/pats`;\n        printDebug('POST', { url: patUrl });\n        const patRes = await axios.post<CreatePatResponse>(\n          patUrl,\n          { name, expiresIn, ...(options.scope ? { scope: options.scope } : {}) },\n          {\n            headers: {\n              'Content-Type': 'application/json',\n              'Authorization': `Bearer ${accessToken}`,\n              'X-Step-Up-Token': stepUpToken,\n            },\n            httpsAgent,\n            timeout,\n          },\n        );\n\n        const token = patRes.data?.data?.token;\n        const pat = patRes.data?.data?.pat;\n        if (!token) {\n          printError('Create token failed: no token in response');\n          process.exit(ERROR_CODES.API_REQUEST);\n        }\n\n        // Quiet mode: emit only the export line (the PAT is a valid Bearer token).\n        if (quiet) {\n          console.log(`export PLATFORM_TOKEN=${token}`);\n          return;\n        }\n\n        console.log('');\n        printSuccess('Personal access token created');\n        console.log('');\n        printKeyValue({\n          'Name': pat?.name ?? name,\n          'Token ID (jti)': pat?.jti ?? '(unknown)',\n          'Expires': pat?.expiresAt ?? `${days} day(s)`,\n          ...(pat?.scope ? { Scope: pat.scope } : {}),\n        });\n        console.log('');\n        console.log(yellow(bold('Copy your token now — it will not be shown again:')));\n        console.log(green(token));\n        console.log('');\n        printInfo('Tip: use it as PLATFORM_TOKEN for subsequent commands:');\n        console.log(green('  export PLATFORM_TOKEN=<token>'));\n        console.log(green(`  # or:  eval $(pipeline-manager auth pat --name ${name} -u ${identifier} --quiet)`));\n      } catch (error) {\n        if (axios.isAxiosError(error)) {\n          const status = error.response?.status;\n          const message = (error.response?.data as { message?: string })?.message;\n          printError('Create token failed', {\n            status: status ?? 'no response',\n            ...(message ? { message } : {}),\n          });\n          process.exit(ERROR_CODES.AUTHENTICATION);\n        }\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'create-pat', executionId, identifier: options.identifier, url: options.url },\n        });\n      }\n    });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-pat.js","sourceRoot":"","sources":["../../src/commands/create-pat.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 { Command } from 'commander';\nimport pico from 'picocolors';\nimport { TIMEOUTS } from '../config/cli.constants.js';\nimport { assertCredentialTlsAllowed, credentialHttpsAgent, switchOrganization } from '../utils/auth-utils.js';\nimport { printCommandHeader, withSslOptions } from '../utils/command-utils.js';\nimport { DeviceAuthError, openInBrowser, pollForDeviceToken, requestDeviceCode } from '../utils/device-auth.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printDebug, printError, printInfo, printKeyValue, printSuccess } from '../utils/output-utils.js';\n\nconst { bold, cyan, dim, green, yellow } = pico;\n\n/** Create-key response — the raw key is returned exactly once. */\ninterface CreateAccessKeyResponse {\n  success: boolean;\n  data: {\n    /** The opaque key (`pb_pat_…`). Only its hash is stored server-side. */\n    key: string;\n    accessKey: { id: string; name: string; display: string; expiresAt: string; scope?: string | null };\n  };\n}\n\nconst MAX_EXPIRES_DAYS = 365;\n\n/**\n * Registers the `pat` command with the CLI program.\n *\n * Mints a named ACCESS KEY (`pb_pat_…`) — a durable, individually-revocable API\n * credential — for CI/automation. Unlike a session, a key is the right\n * long-lived credential for scripts.\n *\n * The key is OPAQUE: it carries no claims, and each service trades it at\n * platform's /auth/token/exchange for a 5-minute token, so revoking it takes\n * effect everywhere within five minutes.\n *\n * Creating one is step-up gated server-side, which used to mean the CLI had to\n * hold a password (it POSTed it twice — sign-in, then step-up). It no longer\n * has one: the device flow asks for the step-up IN THE BROWSER, where the\n * account's real factors live, and the approved poll returns both the session\n * and a short-lived step-up token. The key binds to the user's active org; pass\n * `--org` to switch first (which persists as the active org).\n *\n * The raw key is printed ONCE — only its hash is stored, so it can never be read\n * back. `--quiet` prints only `export PLATFORM_TOKEN=…` so it can be `eval`'d;\n * the key is itself a valid Bearer credential.\n *\n * @param program - The root Commander program instance to attach the command to.\n *\n * @example\n * ```bash\n * pipeline-manager auth pat --name ci-deploy\n * pipeline-manager auth pat --name ci --expires-days 30 --org <orgId>\n * eval $(pipeline-manager auth pat --name ci --quiet)\n * ```\n */\nexport function createPat(program: Command): void {\n  withSslOptions(program\n    .command('pat')\n    .description('Create a named access key (long-lived, opaque CLI/automation credential)')\n    .requiredOption('--name <name>', 'Human-readable key name (e.g. ci-deploy)')\n    .option('--expires-days <days>', `Key lifetime in days (1-${MAX_EXPIRES_DAYS})`, '90')\n    .option('--scope <scope>', 'Optional capability scope (least-privilege key)')\n    .option('--org <orgId>', 'Bind the key to a specific organization (switches active org)')\n    .option('--no-browser', 'Never open a browser — print the verification URL instead')\n    .option('--url <url>', 'Platform base URL', process.env.PLATFORM_BASE_URL || 'https://localhost:8443'))\n    .option('--quiet', 'Only print the export statement (useful for eval)')\n    .action(async (options) => {\n      // SECURITY: the poll returns a session AND a step-up token, and the response\n      // below carries the raw key. None of that may cross an unverified connection\n      // in production. Mirrors the guard in `login`.\n      assertCredentialTlsAllowed(options.verifySsl);\n\n      const quiet = options.quiet ?? false;\n      const executionId = printCommandHeader('Create Access Key', 'Create Access Key', { quiet });\n\n      try {\n        // Validate name.\n        const name = typeof options.name === 'string' ? options.name.trim() : '';\n        if (!name) {\n          printError('Key name is required (--name)');\n          process.exit(ERROR_CODES.VALIDATION);\n        }\n        if (name.length > 100) {\n          printError('Key name must be 100 characters or fewer');\n          process.exit(ERROR_CODES.VALIDATION);\n        }\n\n        // Validate expiry → seconds.\n        const days = Math.floor(Number(options.expiresDays));\n        if (!Number.isFinite(days) || days < 1 || days > MAX_EXPIRES_DAYS) {\n          printError(`--expires-days must be an integer between 1 and ${MAX_EXPIRES_DAYS}`);\n          process.exit(ERROR_CODES.VALIDATION);\n        }\n        const expiresIn = days * 86400;\n\n        const httpsAgent = credentialHttpsAgent(options.verifySsl);\n        const timeout = TIMEOUTS.HTTP_REQUEST;\n        const transport = { url: options.url, httpsAgent, timeout };\n\n        // 1) Device sign-in, asking for the step-up the create call needs.\n        if (!quiet) printInfo('Starting browser sign-in', { url: options.url, verifySsl: options.verifySsl });\n        const code = await requestDeviceCode(transport, { stepUp: true });\n        const approvalUrl = code.verification_uri_complete || code.verification_uri;\n        const opened = options.browser !== false && openInBrowser(approvalUrl);\n\n        // The prompt goes to STDERR under `--quiet`: stdout is captured by\n        // `eval $(…)`, so printing the code there would swallow the one thing\n        // the user has to read before anything can proceed.\n        const say = quiet ? console.error : console.log;\n        say('');\n        say(`  Your code:  ${bold(cyan(code.user_code))}`);\n        say(`  Approve at: ${green(approvalUrl)}`);\n        say('');\n        say(dim(opened\n          ? '  Opening your browser… approve the code there, then come back.'\n          : '  Open that URL in a browser, check the code matches, and approve.'));\n        if (!quiet) printInfo('Waiting for approval…');\n\n        const session = await pollForDeviceToken(transport, code);\n        let accessToken = session.access_token;\n        const stepUpToken = session.step_up_token;\n        if (!stepUpToken) {\n          printError('The approval did not return a step-up confirmation — approve the code promptly and try again.');\n          process.exit(ERROR_CODES.AUTHENTICATION);\n        }\n\n        // 2) Optionally bind to a specific org (persists as the active org, which\n        //    the key inherits). Rotates the session, but the step-up token is\n        //    bound to the user, not the session, so it survives the switch.\n        if (options.org) {\n          if (!quiet) printInfo('Switching to organization', { orgId: options.org });\n          accessToken = (await switchOrganization({\n            url: options.url,\n            orgId: options.org,\n            accessToken,\n            httpsAgent,\n            timeout,\n            quiet,\n          })).accessToken;\n        }\n\n        // 3) Create the access key. The step-up token is short-lived (~60s) and\n        //    single-use, so it is spent immediately.\n        const keyUrl = `${options.url}/api/user/keys`;\n        printDebug('POST', { url: keyUrl });\n        const keyRes = await axios.post<CreateAccessKeyResponse>(\n          keyUrl,\n          { name, expiresIn, ...(options.scope ? { scope: options.scope } : {}) },\n          {\n            headers: {\n              'Content-Type': 'application/json',\n              'Authorization': `Bearer ${accessToken}`,\n              'X-Step-Up-Token': stepUpToken,\n            },\n            httpsAgent,\n            timeout,\n          },\n        );\n\n        const key = keyRes.data?.data?.key;\n        const meta = keyRes.data?.data?.accessKey;\n        if (!key) {\n          printError('Create key failed: no key in response');\n          process.exit(ERROR_CODES.API_REQUEST);\n        }\n\n        // Quiet mode: emit only the export line (the key is a valid Bearer credential).\n        if (quiet) {\n          console.log(`export PLATFORM_TOKEN=${key}`);\n          return;\n        }\n\n        console.log('');\n        printSuccess('Access key created');\n        console.log('');\n        printKeyValue({\n          'Name': meta?.name ?? name,\n          'Key ID': meta?.id ?? '(unknown)',\n          'Key': meta?.display ?? '(unknown)',\n          'Expires': meta?.expiresAt ?? `${days} day(s)`,\n          ...(meta?.scope ? { Scope: meta.scope } : {}),\n        });\n        console.log('');\n        console.log(yellow(bold('Copy your key now — only its hash is stored, so it will not be shown again:')));\n        console.log(green(key));\n        console.log('');\n        printInfo('Tip: use it as PLATFORM_TOKEN for subsequent commands:');\n        console.log(green('  export PLATFORM_TOKEN=<token>'));\n        console.log(green(`  # or:  eval $(pipeline-manager auth pat --name ${name} --quiet)`));\n      } catch (error) {\n        if (error instanceof DeviceAuthError) {\n          printError(`Create key failed: ${error.message}`, { reason: error.code });\n          process.exit(ERROR_CODES.AUTHENTICATION);\n        }\n        if (axios.isAxiosError(error)) {\n          const status = error.response?.status;\n          const message = (error.response?.data as { message?: string })?.message;\n          printError('Create key failed', {\n            status: status ?? 'no response',\n            ...(message ? { message } : {}),\n          });\n          process.exit(ERROR_CODES.AUTHENTICATION);\n        }\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'create-pat', executionId, url: options.url },\n        });\n      }\n    });\n}\n"]}

package/dist/commands/login.d.ts

@@ -2,19 +2,25 @@ import { Command } from 'commander';
 /**
  * Registers the `login` command with the CLI program.
  *
- * Authenticates against the platform API and prints an export statement
- * for `PLATFORM_TOKEN` on success.  Does NOT require `PLATFORM_TOKEN`
- * to be set beforehand (unlike other commands).
+ * Signs in with the OAuth 2.0 device authorization grant (RFC 8628): the CLI
+ * shows a short code, the person approves it in a browser, and the CLI receives
+ * an ordinary session. There is no password flag and no way to hand the CLI a
+ * refresh token — both used to end up in shell history, `ps` output and CI logs,
+ * and both skipped the SSO / step-up / MFA the browser already enforces.
+ *
+ * The session is written to the credential store (`~/.pipeline-manager/
+ * credentials.json`, owner-only), so subsequent commands authenticate with no
+ * environment variable at all. `PLATFORM_TOKEN` still wins when it is set, which
+ * is what CI uses — an access key from `auth pat`.
  *
  * @param program - The root Commander program instance to attach the command to.
  *
  * @example
  * ```bash
- * pipeline-manager auth login --identifier admin@example.com --password secret
- * pipeline-manager auth login -u admin@example.com -p secret
- * pipeline-manager auth login -u admin@example.com -p secret --url https://myhost:8443
- * eval $(pipeline-manager auth login -u admin@example.com -p secret --quiet)
- * pipeline-manager auth login --refresh <refresh-token>
+ * pipeline-manager auth login
+ * pipeline-manager auth login --url https://platform.example.com --org <orgId>
+ * pipeline-manager auth login --no-browser      # print the URL instead of opening it
+ * eval $(pipeline-manager auth login --quiet)   # also export PLATFORM_TOKEN
  * ```
  */
 export declare function login(program: Command): void;

package/dist/commands/login.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../src/commands/login.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAWpC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAoK5C"}
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../src/commands/login.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAYpC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA4G5C"}