@pipeline-builder/pipeline-manager 4.1.14 → 4.1.16

package/dist/commands/publish-plugin.d.ts

@@ -0,0 +1,62 @@
+import { type PluginCatalogEdits } from '@pipeline-builder/api-core';
+import { Command } from 'commander';
+import { type ApiClient } from '../utils/api-client.js';
+import { type Ask } from '../utils/catalog-prompt.js';
+import { type Exec } from '../utils/plugin-docker.js';
+import { type ScanPreview } from '../utils/plugin-scan.js';
+export interface PublishPluginOptions {
+    dir: string;
+    yes?: boolean;
+    metadata?: string;
+    image?: string;
+    skipScan?: boolean;
+    dryRun?: boolean;
+    verifySsl?: boolean;
+}
+/** A publish refused before anything is uploaded. */
+export declare class PublishPreflightError extends Error {
+    constructor(message: string);
+}
+/** The server-side prerequisites a publish request needs: checked up front. */
+export declare function assertCanPublish(client: ApiClient): Promise<string>;
+/**
+ * The scan preview: build (or take) the image, SBOM it with syft and scan it
+ * with grype. Missing tools are a clear notice, never a silent pass; a
+ * critical finding refuses the publish (the platform's gate would).
+ */
+export declare function runScanPreview(exec: Exec, opts: {
+    dir: string;
+    dockerfile: string;
+    buildType: string;
+    name: string;
+    version: string;
+    image?: string;
+    buildArgs?: Record<string, string>;
+}): ScanPreview;
+/**
+ * The whole publish flow, minus the terminal: pre-flight (server checks, lint,
+ * catalog), scan preview, the accept-or-edit step, then one upload with
+ * `visibility=public` + `publishRequest=true` (+ the edits as `metadata`).
+ * Returns the server's response, or null for a dry run.
+ */
+export declare function runPublish(options: PublishPluginOptions, deps?: {
+    exec?: Exec;
+    ask?: Ask;
+    client?: () => ApiClient;
+}): Promise<{
+    edits: PluginCatalogEdits;
+    response: unknown;
+}>;
+/**
+ * Register `plugin publish` — pre-flight (the server's schemas, the catalog's
+ * Dockerfile rules, publish-required metadata), a local scan preview, the
+ * catalog accept-or-edit step, then the upload that submits a publish request
+ * once the version is built.
+ *
+ * Usage:
+ *   pipeline-manager plugin publish --dir ./my-linter
+ *   pipeline-manager plugin publish --dir ./my-linter --yes
+ *   pipeline-manager plugin publish --dir ./my-linter --metadata catalog.yaml
+ */
+export declare function publishPlugin(program: Command): void;
+//# sourceMappingURL=publish-plugin.d.ts.map

package/dist/commands/publish-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish-plugin.d.ts","sourceRoot":"","sources":["../../src/commands/publish-plugin.ts"],"names":[],"mappings":"AAKA,OAAO,EAA0B,KAAK,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAC7F,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAuB,KAAK,GAAG,EAAE,MAAM,4BAA4B,CAAC;AAI3E,OAAO,EAAoE,KAAK,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAExH,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAGxE,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,qDAAqD;AACrD,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAYD,+EAA+E;AAC/E,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAOzE;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,WAAW,CAqBvM;AAYD;;;;;GAKG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE,oBAAoB,EAC7B,IAAI,GAAE;IAAE,IAAI,CAAC,EAAE,IAAI,CAAC;IAAC,GAAG,CAAC,EAAE,GAAG,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,SAAS,CAAA;CAAO,GAC9D,OAAO,CAAC;IAAE,KAAK,EAAE,kBAAkB,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC,CAkF3D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAkCpD"}

package/dist/commands/publish-plugin.js

@@ -0,0 +1,224 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import path from 'path';
+import readline from 'readline/promises';
+import { resolveCatalogMetadata } from '@pipeline-builder/api-core';
+import { Command } from 'commander';
+import FormData from 'form-data';
+import { PUBLISH_REQUIRED_FIELDS, catalogIssues, formatHeuristic, printCatalogReport, validatePluginDir } from './validate-plugin.js';
+import { FILE_SIZE_LIMITS, formatFileSize } from '../config/cli.constants.js';
+import {} from '../utils/api-client.js';
+import { collectCatalogEdits } from '../utils/catalog-prompt.js';
+import { createAuthenticatedClient, printCommandHeader, printSslWarning, withSslOptions } from '../utils/command-utils.js';
+import { ERROR_CODES, handleError, ValidationError } from '../utils/error-handler.js';
+import { printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';
+import { buildPluginImage, hasTool, localImageTag, removeImage, spawnExec } from '../utils/plugin-docker.js';
+import { SOURCE_LABELS, formatCatalogValue } from '../utils/plugin-package.js';
+import { scanPreview } from '../utils/plugin-scan.js';
+import { collectPluginFiles, writeZip } from '../utils/plugin-zip.js';
+/** A publish refused before anything is uploaded. */
+export class PublishPreflightError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PublishPreflightError';
+    }
+}
+/** Unwrap the platform's `{ success, data }` envelope. */
+const dataOf = (body) => (body?.data ?? body);
+/** The server-side prerequisites a publish request needs: checked up front. */
+export async function assertCanPublish(client) {
+    const state = dataOf(await client.get(`${client.getConfig().api.pluginUrl}/publisher`));
+    if (!state.publishingEnabled)
+        throw new PublishPreflightError('Publishing is turned off on this instance (PLUGIN_PUBLISHING_DISABLED)');
+    if (!state.isRootOrg)
+        throw new PublishPreflightError('Teams publish through their root organization: switch to it (PUBLISHER_ROOT_ORG_REQUIRED)');
+    if (!state.publisher)
+        throw new PublishPreflightError('Create your publisher profile first: dashboard → Build → Publisher (PUBLISHER_REQUIRED)');
+    if (!state.terms.accepted)
+        throw new PublishPreflightError('Accept the current publisher terms on the Publisher page (PUBLISHER_TERMS_REQUIRED)');
+    return state.publisher.handle;
+}
+/**
+ * The scan preview: build (or take) the image, SBOM it with syft and scan it
+ * with grype. Missing tools are a clear notice, never a silent pass; a
+ * critical finding refuses the publish (the platform's gate would).
+ */
+export function runScanPreview(exec, opts) {
+    if (!opts.image && opts.buildType !== 'build_image') {
+        return { status: 'unavailable', reason: `a ${opts.buildType} plugin has no Dockerfile to build; pass --image to scan the image it runs` };
+    }
+    if (!hasTool(exec, 'docker'))
+        return { status: 'unavailable', reason: 'docker is not available to build the image' };
+    if (!hasTool(exec, 'syft', ['version']) || !hasTool(exec, 'grype', ['version'])) {
+        return { status: 'unavailable', reason: 'syft and grype are not both installed (https://github.com/anchore/syft, https://github.com/anchore/grype)' };
+    }
+    let image = opts.image;
+    let built = null;
+    try {
+        if (!image) {
+            built = localImageTag(opts.name, opts.version);
+            const error = buildPluginImage(exec, { dir: opts.dir, dockerfile: opts.dockerfile, tag: built, buildArgs: opts.buildArgs });
+            if (error)
+                return { status: 'failed', reason: error };
+            image = built;
+        }
+        return scanPreview(exec, image);
+    }
+    finally {
+        if (built)
+            removeImage(exec, built);
+    }
+}
+/** Print the resolved metadata with its provenance (the card the directory will render). */
+function printResolved(resolved) {
+    printSection('Catalog metadata to submit');
+    for (const [field, value] of Object.entries(resolved.values)) {
+        const source = resolved.sources[field];
+        console.log(`  ${field.padEnd(16)} ${formatCatalogValue(value)}${source ? `  [${SOURCE_LABELS[source]}]` : ''}`);
+    }
+    console.log('');
+}
+/**
+ * The whole publish flow, minus the terminal: pre-flight (server checks, lint,
+ * catalog), scan preview, the accept-or-edit step, then one upload with
+ * `visibility=public` + `publishRequest=true` (+ the edits as `metadata`).
+ * Returns the server's response, or null for a dry run.
+ */
+export async function runPublish(options, deps = {}) {
+    const exec = deps.exec ?? spawnExec;
+    printSection('Pre-flight', 'server checks + catalog lint + heuristics');
+    const report = await validatePluginDir(options.dir, { lint: true });
+    const { invalid } = catalogIssues(report.fields);
+    const lintErrors = report.lint.filter(l => l.level === 'error');
+    for (const w of report.lint.filter(l => l.level === 'warning'))
+        printWarning(w.message);
+    for (const h of report.heuristics.filter(x => x.severity === 'medium'))
+        printWarning(formatHeuristic(h));
+    const blocking = [
+        ...report.problems,
+        ...lintErrors.map(l => l.message),
+        ...report.heuristics.filter(x => x.severity === 'high').map(formatHeuristic),
+    ];
+    printCatalogReport(report.fields);
+    if (blocking.length) {
+        for (const p of blocking)
+            printError(`  • ${p}`);
+        throw new PublishPreflightError(`Pre-flight failed with ${blocking.length} problem(s)`);
+    }
+    printSuccess('Pre-flight passed');
+    const spec = report.pkg.spec;
+    printSection('Scan preview', 'syft SBOM + grype');
+    if (options.skipScan) {
+        printWarning('Scan preview skipped (--skip-scan). The platform scans the image after the build; a critical vulnerability fails the publish gate.');
+    }
+    else {
+        const scan = runScanPreview(exec, {
+            dir: report.pkg.dir,
+            dockerfile: path.join(report.pkg.dir, report.pkg.dockerfileName),
+            buildType: report.pkg.buildType,
+            name: String(spec.name),
+            version: String(spec.version),
+            image: options.image,
+            buildArgs: spec.buildArgs,
+        });
+        if (scan.status === 'unavailable') {
+            printWarning(`Scan preview NOT run: ${scan.reason}. The platform still scans the image after the build, and a critical vulnerability fails the publish gate.`);
+        }
+        else if (scan.status === 'failed') {
+            throw new PublishPreflightError(`Scan preview failed: ${scan.reason}`);
+        }
+        else {
+            printKeyValue(Object.fromEntries(Object.entries(scan.counts).map(([k, v]) => [k, String(v)])));
+            if (scan.critical.length) {
+                for (const c of scan.critical)
+                    printError(`  • ${c}`);
+                throw new PublishPreflightError(`${scan.critical.length} critical vulnerabilit${scan.critical.length === 1 ? 'y' : 'ies'}: the publish gate would refuse this version`);
+            }
+            printSuccess('No critical vulnerabilities');
+        }
+    }
+    if (invalid.length) {
+        printWarning(`Detected values that are invalid and would be blank: ${invalid.map(f => f.field).join(', ')} — edit them below or fix the package`);
+    }
+    printSection('Catalog details', 'accept or edit each detected value');
+    const edits = await collectCatalogEdits(report.fields, { yes: options.yes, metadataFile: options.metadata, ask: deps.ask });
+    const resolved = resolveCatalogMetadata(report.fields, edits);
+    printResolved(resolved);
+    const missing = [...PUBLISH_REQUIRED_FIELDS].filter(f => resolved.values[f] === null || resolved.values[f] === undefined);
+    if (missing.length)
+        throw new PublishPreflightError(`A publish request needs: ${missing.join(', ')} (add them to the package or supply them with --metadata)`);
+    const zip = writeZip(collectPluginFiles(report.pkg.dir, { includeImageTar: report.pkg.buildType === 'prebuilt' }));
+    if (zip.length > FILE_SIZE_LIMITS.PLUGIN)
+        throw new ValidationError(`Plugin package exceeds ${formatFileSize(FILE_SIZE_LIMITS.PLUGIN)}`);
+    printInfo('Package', { size: formatFileSize(zip.length), metadataEdits: Object.keys(edits) });
+    if (options.dryRun) {
+        printSuccess('Dry run: nothing uploaded');
+        return { edits, response: null };
+    }
+    if (!options.yes && deps.ask) {
+        const answer = (await deps.ask(`Upload ${String(spec.name)}@${String(spec.version)} as public and request publishing? [y/N] `)).trim().toLowerCase();
+        if (answer !== 'y' && answer !== 'yes')
+            throw new PublishPreflightError('Cancelled — nothing uploaded');
+    }
+    const client = (deps.client ?? (() => createAuthenticatedClient(options)))();
+    const handle = await assertCanPublish(client);
+    const form = new FormData();
+    form.append('plugin', zip, { filename: `${String(spec.name)}-${String(spec.version)}.zip`, contentType: 'application/zip' });
+    form.append('visibility', 'public');
+    form.append('publishRequest', 'true');
+    if (Object.keys(edits).length)
+        form.append('metadata', JSON.stringify(edits));
+    printSection('Uploading', `as @${handle}`);
+    const response = dataOf(await client.postForm(client.getConfig().api.pluginUploadUrl, form));
+    return { edits, response };
+}
+/**
+ * Register `plugin publish` — pre-flight (the server's schemas, the catalog's
+ * Dockerfile rules, publish-required metadata), a local scan preview, the
+ * catalog accept-or-edit step, then the upload that submits a publish request
+ * once the version is built.
+ *
+ * Usage:
+ *   pipeline-manager plugin publish --dir ./my-linter
+ *   pipeline-manager plugin publish --dir ./my-linter --yes
+ *   pipeline-manager plugin publish --dir ./my-linter --metadata catalog.yaml
+ */
+export function publishPlugin(program) {
+    withSslOptions(program
+        .command('publish')
+        .description('Pre-flight, scan-preview and upload a plugin, then request its listing in the plugin ecosystem')
+        .option('--dir <path>', 'Plugin directory', '.')
+        .option('-y, --yes', 'Accept every detected catalog value and skip the confirmation', false)
+        .option('--metadata <file>', 'Catalog edits (YAML/JSON: summary, description, links, icon, …); no prompt')
+        .option('--image <ref>', 'Scan this image instead of building the plugin\'s Dockerfile')
+        .option('--skip-scan', 'Skip the local scan preview (the platform still scans)', false)
+        .option('--dry-run', 'Run every local step, upload nothing', false))
+        .action(async (options) => {
+        const executionId = printCommandHeader('Publish Plugin');
+        printSslWarning(options.verifySsl);
+        const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+        const rl = interactive ? readline.createInterface({ input: process.stdin, output: process.stdout }) : null;
+        try {
+            const { response } = await runPublish(options, { ask: rl ? (q) => rl.question(q) : undefined });
+            if (!response)
+                return;
+            const r = response;
+            printSection('Submitted');
+            printKeyValue({
+                Plugin: `${r.pluginName ?? '?'}@${r.version ?? '?'}`,
+                ...(r.publishRequest?.requestId
+                    ? { 'Publish request': `${r.publishRequest.requestId} (${r.publishRequest.status ?? 'submitted'})` }
+                    : { 'Publish request': 'submitted automatically when the build completes' }),
+            });
+            printSuccess('Track the request on the Publisher page → Requests (or GET /api/plugins/publish-requests)', { executionId });
+        }
+        catch (err) {
+            const code = err instanceof ValidationError || err instanceof PublishPreflightError ? ERROR_CODES.VALIDATION : ERROR_CODES.API_REQUEST;
+            handleError(err, code, { debug: program.opts().debug, exit: true, context: { command: 'plugin publish', executionId } });
+        }
+        finally {
+            rl?.close();
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"publish-plugin.js","sourceRoot":"","sources":["../../src/commands/publish-plugin.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport path from 'path';\nimport readline from 'readline/promises';\nimport { resolveCatalogMetadata, type PluginCatalogEdits } from '@pipeline-builder/api-core';\nimport { Command } from 'commander';\nimport FormData from 'form-data';\nimport { PUBLISH_REQUIRED_FIELDS, catalogIssues, formatHeuristic, printCatalogReport, validatePluginDir } from './validate-plugin.js';\nimport { FILE_SIZE_LIMITS, formatFileSize } from '../config/cli.constants.js';\nimport { type ApiClient } from '../utils/api-client.js';\nimport { collectCatalogEdits, type Ask } from '../utils/catalog-prompt.js';\nimport { createAuthenticatedClient, printCommandHeader, printSslWarning, withSslOptions } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError, ValidationError } from '../utils/error-handler.js';\nimport { printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';\nimport { buildPluginImage, hasTool, localImageTag, removeImage, spawnExec, type Exec } from '../utils/plugin-docker.js';\nimport { SOURCE_LABELS, formatCatalogValue } from '../utils/plugin-package.js';\nimport { scanPreview, type ScanPreview } from '../utils/plugin-scan.js';\nimport { collectPluginFiles, writeZip } from '../utils/plugin-zip.js';\n\nexport interface PublishPluginOptions {\n  dir: string;\n  yes?: boolean;\n  metadata?: string;\n  image?: string;\n  skipScan?: boolean;\n  dryRun?: boolean;\n  verifySsl?: boolean;\n}\n\n/** A publish refused before anything is uploaded. */\nexport class PublishPreflightError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'PublishPreflightError';\n  }\n}\n\n/** Unwrap the platform's `{ success, data }` envelope. */\nconst dataOf = <T>(body: unknown): T => ((body as { data?: T })?.data ?? body) as T;\n\ninterface PublisherState {\n  publisher: { handle: string } | null;\n  isRootOrg: boolean;\n  terms: { accepted: boolean };\n  publishingEnabled: boolean;\n}\n\n/** The server-side prerequisites a publish request needs: checked up front. */\nexport async function assertCanPublish(client: ApiClient): Promise<string> {\n  const state = dataOf<PublisherState>(await client.get(`${client.getConfig().api.pluginUrl}/publisher`));\n  if (!state.publishingEnabled) throw new PublishPreflightError('Publishing is turned off on this instance (PLUGIN_PUBLISHING_DISABLED)');\n  if (!state.isRootOrg) throw new PublishPreflightError('Teams publish through their root organization: switch to it (PUBLISHER_ROOT_ORG_REQUIRED)');\n  if (!state.publisher) throw new PublishPreflightError('Create your publisher profile first: dashboard → Build → Publisher (PUBLISHER_REQUIRED)');\n  if (!state.terms.accepted) throw new PublishPreflightError('Accept the current publisher terms on the Publisher page (PUBLISHER_TERMS_REQUIRED)');\n  return state.publisher.handle;\n}\n\n/**\n * The scan preview: build (or take) the image, SBOM it with syft and scan it\n * with grype. Missing tools are a clear notice, never a silent pass; a\n * critical finding refuses the publish (the platform's gate would).\n */\nexport function runScanPreview(exec: Exec, opts: { dir: string; dockerfile: string; buildType: string; name: string; version: string; image?: string; buildArgs?: Record<string, string> }): ScanPreview {\n  if (!opts.image && opts.buildType !== 'build_image') {\n    return { status: 'unavailable', reason: `a ${opts.buildType} plugin has no Dockerfile to build; pass --image to scan the image it runs` };\n  }\n  if (!hasTool(exec, 'docker')) return { status: 'unavailable', reason: 'docker is not available to build the image' };\n  if (!hasTool(exec, 'syft', ['version']) || !hasTool(exec, 'grype', ['version'])) {\n    return { status: 'unavailable', reason: 'syft and grype are not both installed (https://github.com/anchore/syft, https://github.com/anchore/grype)' };\n  }\n  let image = opts.image;\n  let built: string | null = null;\n  try {\n    if (!image) {\n      built = localImageTag(opts.name, opts.version);\n      const error = buildPluginImage(exec, { dir: opts.dir, dockerfile: opts.dockerfile, tag: built, buildArgs: opts.buildArgs });\n      if (error) return { status: 'failed', reason: error };\n      image = built;\n    }\n    return scanPreview(exec, image);\n  } finally {\n    if (built) removeImage(exec, built);\n  }\n}\n\n/** Print the resolved metadata with its provenance (the card the directory will render). */\nfunction printResolved(resolved: ReturnType<typeof resolveCatalogMetadata>): void {\n  printSection('Catalog metadata to submit');\n  for (const [field, value] of Object.entries(resolved.values)) {\n    const source = resolved.sources[field as keyof typeof resolved.sources];\n    console.log(`  ${field.padEnd(16)} ${formatCatalogValue(value)}${source ? `  [${SOURCE_LABELS[source]}]` : ''}`);\n  }\n  console.log('');\n}\n\n/**\n * The whole publish flow, minus the terminal: pre-flight (server checks, lint,\n * catalog), scan preview, the accept-or-edit step, then one upload with\n * `visibility=public` + `publishRequest=true` (+ the edits as `metadata`).\n * Returns the server's response, or null for a dry run.\n */\nexport async function runPublish(\n  options: PublishPluginOptions,\n  deps: { exec?: Exec; ask?: Ask; client?: () => ApiClient } = {},\n): Promise<{ edits: PluginCatalogEdits; response: unknown }> {\n  const exec = deps.exec ?? spawnExec;\n\n  printSection('Pre-flight', 'server checks + catalog lint + heuristics');\n  const report = await validatePluginDir(options.dir, { lint: true });\n  const { invalid } = catalogIssues(report.fields);\n  const lintErrors = report.lint.filter(l => l.level === 'error');\n  for (const w of report.lint.filter(l => l.level === 'warning')) printWarning(w.message);\n  for (const h of report.heuristics.filter(x => x.severity === 'medium')) printWarning(formatHeuristic(h));\n  const blocking = [\n    ...report.problems,\n    ...lintErrors.map(l => l.message),\n    ...report.heuristics.filter(x => x.severity === 'high').map(formatHeuristic),\n  ];\n  printCatalogReport(report.fields);\n  if (blocking.length) {\n    for (const p of blocking) printError(`  • ${p}`);\n    throw new PublishPreflightError(`Pre-flight failed with ${blocking.length} problem(s)`);\n  }\n  printSuccess('Pre-flight passed');\n\n  const spec = report.pkg.spec!;\n  printSection('Scan preview', 'syft SBOM + grype');\n  if (options.skipScan) {\n    printWarning('Scan preview skipped (--skip-scan). The platform scans the image after the build; a critical vulnerability fails the publish gate.');\n  } else {\n    const scan = runScanPreview(exec, {\n      dir: report.pkg.dir,\n      dockerfile: path.join(report.pkg.dir, report.pkg.dockerfileName),\n      buildType: report.pkg.buildType,\n      name: String(spec.name),\n      version: String(spec.version),\n      image: options.image,\n      buildArgs: spec.buildArgs,\n    });\n    if (scan.status === 'unavailable') {\n      printWarning(`Scan preview NOT run: ${scan.reason}. The platform still scans the image after the build, and a critical vulnerability fails the publish gate.`);\n    } else if (scan.status === 'failed') {\n      throw new PublishPreflightError(`Scan preview failed: ${scan.reason}`);\n    } else {\n      printKeyValue(Object.fromEntries(Object.entries(scan.counts).map(([k, v]) => [k, String(v)])));\n      if (scan.critical.length) {\n        for (const c of scan.critical) printError(`  • ${c}`);\n        throw new PublishPreflightError(`${scan.critical.length} critical vulnerabilit${scan.critical.length === 1 ? 'y' : 'ies'}: the publish gate would refuse this version`);\n      }\n      printSuccess('No critical vulnerabilities');\n    }\n  }\n\n  if (invalid.length) {\n    printWarning(`Detected values that are invalid and would be blank: ${invalid.map(f => f.field).join(', ')} — edit them below or fix the package`);\n  }\n  printSection('Catalog details', 'accept or edit each detected value');\n  const edits = await collectCatalogEdits(report.fields, { yes: options.yes, metadataFile: options.metadata, ask: deps.ask });\n  const resolved = resolveCatalogMetadata(report.fields, edits);\n  printResolved(resolved);\n  const missing = [...PUBLISH_REQUIRED_FIELDS].filter(f => resolved.values[f] === null || resolved.values[f] === undefined);\n  if (missing.length) throw new PublishPreflightError(`A publish request needs: ${missing.join(', ')} (add them to the package or supply them with --metadata)`);\n\n  const zip = writeZip(collectPluginFiles(report.pkg.dir, { includeImageTar: report.pkg.buildType === 'prebuilt' }));\n  if (zip.length > FILE_SIZE_LIMITS.PLUGIN) throw new ValidationError(`Plugin package exceeds ${formatFileSize(FILE_SIZE_LIMITS.PLUGIN)}`);\n  printInfo('Package', { size: formatFileSize(zip.length), metadataEdits: Object.keys(edits) });\n\n  if (options.dryRun) {\n    printSuccess('Dry run: nothing uploaded');\n    return { edits, response: null };\n  }\n  if (!options.yes && deps.ask) {\n    const answer = (await deps.ask(`Upload ${String(spec.name)}@${String(spec.version)} as public and request publishing? [y/N] `)).trim().toLowerCase();\n    if (answer !== 'y' && answer !== 'yes') throw new PublishPreflightError('Cancelled — nothing uploaded');\n  }\n\n  const client = (deps.client ?? (() => createAuthenticatedClient(options)))();\n  const handle = await assertCanPublish(client);\n  const form = new FormData();\n  form.append('plugin', zip, { filename: `${String(spec.name)}-${String(spec.version)}.zip`, contentType: 'application/zip' });\n  form.append('visibility', 'public');\n  form.append('publishRequest', 'true');\n  if (Object.keys(edits).length) form.append('metadata', JSON.stringify(edits));\n  printSection('Uploading', `as @${handle}`);\n  const response = dataOf<Record<string, unknown>>(await client.postForm(client.getConfig().api.pluginUploadUrl, form));\n  return { edits, response };\n}\n\n/**\n * Register `plugin publish` — pre-flight (the server's schemas, the catalog's\n * Dockerfile rules, publish-required metadata), a local scan preview, the\n * catalog accept-or-edit step, then the upload that submits a publish request\n * once the version is built.\n *\n * Usage:\n *   pipeline-manager plugin publish --dir ./my-linter\n *   pipeline-manager plugin publish --dir ./my-linter --yes\n *   pipeline-manager plugin publish --dir ./my-linter --metadata catalog.yaml\n */\nexport function publishPlugin(program: Command): void {\n  withSslOptions(program\n    .command('publish')\n    .description('Pre-flight, scan-preview and upload a plugin, then request its listing in the plugin ecosystem')\n    .option('--dir <path>', 'Plugin directory', '.')\n    .option('-y, --yes', 'Accept every detected catalog value and skip the confirmation', false)\n    .option('--metadata <file>', 'Catalog edits (YAML/JSON: summary, description, links, icon, …); no prompt')\n    .option('--image <ref>', 'Scan this image instead of building the plugin\\'s Dockerfile')\n    .option('--skip-scan', 'Skip the local scan preview (the platform still scans)', false)\n    .option('--dry-run', 'Run every local step, upload nothing', false))\n    .action(async (options: PublishPluginOptions) => {\n      const executionId = printCommandHeader('Publish Plugin');\n      printSslWarning(options.verifySsl);\n      const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);\n      const rl = interactive ? readline.createInterface({ input: process.stdin, output: process.stdout }) : null;\n      try {\n        const { response } = await runPublish(options, { ask: rl ? (q: string) => rl.question(q) : undefined });\n        if (!response) return;\n        const r = response as { pluginName?: string; version?: string; pluginId?: string; publishRequest?: { requestId?: string; status?: string } };\n        printSection('Submitted');\n        printKeyValue({\n          Plugin: `${r.pluginName ?? '?'}@${r.version ?? '?'}`,\n          ...(r.publishRequest?.requestId\n            ? { 'Publish request': `${r.publishRequest.requestId} (${r.publishRequest.status ?? 'submitted'})` }\n            : { 'Publish request': 'submitted automatically when the build completes' }),\n        });\n        printSuccess('Track the request on the Publisher page → Requests (or GET /api/plugins/publish-requests)', { executionId });\n      } catch (err) {\n        const code = err instanceof ValidationError || err instanceof PublishPreflightError ? ERROR_CODES.VALIDATION : ERROR_CODES.API_REQUEST;\n        handleError(err, code, { debug: program.opts().debug, exit: true, context: { command: 'plugin publish', executionId } });\n      } finally {\n        rl?.close();\n      }\n    });\n}\n"]}

package/dist/commands/redrive-events.d.ts

@@ -2,7 +2,7 @@ import { Command } from 'commander';
 /**
  * Registers the `redrive-events` command with the CLI program.
  *
- * Manual fallback for the events Lambda's self-healing redrive (Phase 3): calls
+ * Manual fallback for the events Lambda's self-healing redrive: calls
  * SQS `StartMessageMoveTask(DLQ → main queue)` for the `pipeline-builder-events`
  * stack, moving messages that exhausted their receive count in the dead-letter
  * queue back onto `pipeline-builder-events` so the ingestion Lambda re-processes

package/dist/commands/redrive-events.js

@@ -13,7 +13,7 @@ const STACK_NAME = EVENTS_STACK_NAME;
 /**
  * Registers the `redrive-events` command with the CLI program.
  *
- * Manual fallback for the events Lambda's self-healing redrive (Phase 3): calls
+ * Manual fallback for the events Lambda's self-healing redrive: calls
  * SQS `StartMessageMoveTask(DLQ → main queue)` for the `pipeline-builder-events`
  * stack, moving messages that exhausted their receive count in the dead-letter
  * queue back onto `pipeline-builder-events` so the ingestion Lambda re-processes
@@ -124,4 +124,4 @@ export function redriveEvents(program) {
         }
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"redrive-events.js","sourceRoot":"","sources":["../../src/commands/redrive-events.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { CloudFormationClient, DescribeStacksCommand } from '@aws-sdk/client-cloudformation';\nimport {\n  SQSClient,\n  GetQueueAttributesCommand,\n  ListMessageMoveTasksCommand,\n  StartMessageMoveTaskCommand,\n} from '@aws-sdk/client-sqs';\nimport { Command } from 'commander';\nimport { EVENTS_STACK_NAME } from '../config/cli.constants.js';\nimport { applyAwsProfile, resolveAwsRegion } from '../utils/aws-env.js';\nimport { printCommandHeader, withProfileOption, withRegionOption } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';\n\n// CFN stack that setup-events deploys — the queues live here.\nconst STACK_NAME = EVENTS_STACK_NAME;\n\n/**\n * Registers the `redrive-events` command with the CLI program.\n *\n * Manual fallback for the events Lambda's self-healing redrive (Phase 3): calls\n * SQS `StartMessageMoveTask(DLQ → main queue)` for the `pipeline-builder-events`\n * stack, moving messages that exhausted their receive count in the dead-letter\n * queue back onto `pipeline-builder-events` so the ingestion Lambda re-processes\n * them. Idempotent ingest (dedupe on `idempotencyKey`) prevents double-counting.\n *\n * The Lambda already does this automatically after a successful batch; this\n * command is the operator escape hatch when the Lambda is down or the DLQ needs\n * to be drained on demand. Like the Lambda, it refuses to start a second move\n * task while one is already active (SQS allows only one in-flight task per\n * source queue anyway).\n *\n * @example\n * ```bash\n * pipeline-manager infra redrive-events --region us-east-1\n * pipeline-manager infra redrive-events --region us-east-1 --profile prod\n * ```\n */\nexport function redriveEvents(program: Command): void {\n  withProfileOption(\n    withRegionOption(program\n      .command('redrive-events')\n      .description('Redrive dead-lettered CodePipeline events back onto the ingestion queue (manual fallback for the Lambda self-healing redrive)')),\n  )\n    .action(async (options) => {\n      const executionId = printCommandHeader('Redrive Events');\n\n      try {\n        const region = resolveAwsRegion(options.region);\n        // Honor --profile for the SDK clients below (mirrors setup-events) — without\n        // this the SDK hits the DEFAULT account while any accompanying CLI call\n        // honored --profile (silent split-brain).\n        applyAwsProfile(options.profile);\n\n        printInfo('Parameters', { stack: STACK_NAME, region });\n\n        // Step 1: resolve the queue URLs from the stack outputs (source of truth —\n        // no hardcoded queue names). setup-events must have run first.\n        printSection('Resolve Queues');\n\n        const cfnClient = new CloudFormationClient({ region });\n        const describeResult = await cfnClient.send(new DescribeStacksCommand({ StackName: STACK_NAME }));\n        const outputs = describeResult.Stacks?.[0]?.Outputs ?? [];\n        const outputMap = Object.fromEntries(outputs.map(o => [o.OutputKey ?? '', o.OutputValue ?? '']));\n\n        const eventQueueArn = outputMap.EventQueueArn;\n        const eventQueueUrl = outputMap.EventQueueUrl;\n        const dlqUrl = outputMap.DeadLetterQueueUrl;\n\n        if (!eventQueueArn || !dlqUrl) {\n          printError(`Stack ${STACK_NAME} is missing expected outputs`, {\n            hint: 'Run `pipeline-manager infra setup-events` first.',\n          });\n          throw new Error('Stack outputs EventQueueArn / DeadLetterQueueUrl not found');\n        }\n\n        const sqs = new SQSClient({ region });\n\n        // The stack exposes the DLQ URL but not its ARN — StartMessageMoveTask needs\n        // the source ARN, so resolve it from the queue's attributes.\n        const dlqAttrs = await sqs.send(new GetQueueAttributesCommand({\n          QueueUrl: dlqUrl,\n          AttributeNames: ['QueueArn', 'ApproximateNumberOfMessages'],\n        }));\n        const dlqArn = dlqAttrs.Attributes?.QueueArn;\n        const dlqDepth = Number(dlqAttrs.Attributes?.ApproximateNumberOfMessages ?? '0');\n\n        if (!dlqArn) {\n          throw new Error(`Could not resolve the DLQ ARN from ${dlqUrl}`);\n        }\n\n        printKeyValue({\n          'Source (DLQ)': dlqArn,\n          'Destination (queue)': eventQueueArn,\n          'DLQ depth (approx)': String(dlqDepth),\n        });\n\n        // Nothing to move — bail early so the operator gets a clear signal instead\n        // of a no-op task.\n        if (dlqDepth === 0) {\n          printSuccess('Dead-letter queue is empty — nothing to redrive.');\n          return;\n        }\n\n        // Step 2: refuse to stack move tasks. SQS permits only one in-flight move\n        // task per source queue; surface any active one instead of erroring out.\n        printSection('Redrive');\n\n        const active = await sqs.send(new ListMessageMoveTasksCommand({ SourceArn: dlqArn }));\n        const running = (active.Results ?? []).find(t => t.Status === 'RUNNING');\n        if (running) {\n          printWarning('A message move task is already running for this DLQ — not starting another.', {\n            taskHandle: running.TaskHandle,\n            approxMovedSoFar: running.ApproximateNumberOfMessagesMoved,\n          });\n          return;\n        }\n\n        // Step 3: start the move (DLQ → main queue). DestinationArn is set explicitly\n        // even though SQS would default to the original source queue — the main\n        // ingestion queue is exactly that target.\n        const start = await sqs.send(new StartMessageMoveTaskCommand({\n          SourceArn: dlqArn,\n          DestinationArn: eventQueueArn,\n        }));\n\n        console.log('');\n        printSection('Redrive Started');\n        printKeyValue({\n          'Task Handle': start.TaskHandle ?? '(none returned)',\n          'Source (DLQ)': dlqArn,\n          'Destination (queue)': eventQueueUrl || eventQueueArn,\n          'Messages queued': String(dlqDepth),\n          'Status': '✓ Started',\n        });\n\n        console.log('');\n        printSuccess('Redrive task started. Messages will re-flow through the ingestion Lambda.');\n        printInfo('Idempotent ingest dedupes on idempotencyKey, so re-driven events are not double-counted.');\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'redrive-events', executionId, stack: STACK_NAME },\n        });\n      }\n    });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"redrive-events.js","sourceRoot":"","sources":["../../src/commands/redrive-events.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { CloudFormationClient, DescribeStacksCommand } from '@aws-sdk/client-cloudformation';\nimport {\n  SQSClient,\n  GetQueueAttributesCommand,\n  ListMessageMoveTasksCommand,\n  StartMessageMoveTaskCommand,\n} from '@aws-sdk/client-sqs';\nimport { Command } from 'commander';\nimport { EVENTS_STACK_NAME } from '../config/cli.constants.js';\nimport { applyAwsProfile, resolveAwsRegion } from '../utils/aws-env.js';\nimport { printCommandHeader, withProfileOption, withRegionOption } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError } from '../utils/error-handler.js';\nimport { printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';\n\n// CFN stack that setup-events deploys — the queues live here.\nconst STACK_NAME = EVENTS_STACK_NAME;\n\n/**\n * Registers the `redrive-events` command with the CLI program.\n *\n * Manual fallback for the events Lambda's self-healing redrive: calls\n * SQS `StartMessageMoveTask(DLQ → main queue)` for the `pipeline-builder-events`\n * stack, moving messages that exhausted their receive count in the dead-letter\n * queue back onto `pipeline-builder-events` so the ingestion Lambda re-processes\n * them. Idempotent ingest (dedupe on `idempotencyKey`) prevents double-counting.\n *\n * The Lambda already does this automatically after a successful batch; this\n * command is the operator escape hatch when the Lambda is down or the DLQ needs\n * to be drained on demand. Like the Lambda, it refuses to start a second move\n * task while one is already active (SQS allows only one in-flight task per\n * source queue anyway).\n *\n * @example\n * ```bash\n * pipeline-manager infra redrive-events --region us-east-1\n * pipeline-manager infra redrive-events --region us-east-1 --profile prod\n * ```\n */\nexport function redriveEvents(program: Command): void {\n  withProfileOption(\n    withRegionOption(program\n      .command('redrive-events')\n      .description('Redrive dead-lettered CodePipeline events back onto the ingestion queue (manual fallback for the Lambda self-healing redrive)')),\n  )\n    .action(async (options) => {\n      const executionId = printCommandHeader('Redrive Events');\n\n      try {\n        const region = resolveAwsRegion(options.region);\n        // Honor --profile for the SDK clients below (mirrors setup-events) — without\n        // this the SDK hits the DEFAULT account while any accompanying CLI call\n        // honored --profile (silent split-brain).\n        applyAwsProfile(options.profile);\n\n        printInfo('Parameters', { stack: STACK_NAME, region });\n\n        // Step 1: resolve the queue URLs from the stack outputs (source of truth —\n        // no hardcoded queue names). setup-events must have run first.\n        printSection('Resolve Queues');\n\n        const cfnClient = new CloudFormationClient({ region });\n        const describeResult = await cfnClient.send(new DescribeStacksCommand({ StackName: STACK_NAME }));\n        const outputs = describeResult.Stacks?.[0]?.Outputs ?? [];\n        const outputMap = Object.fromEntries(outputs.map(o => [o.OutputKey ?? '', o.OutputValue ?? '']));\n\n        const eventQueueArn = outputMap.EventQueueArn;\n        const eventQueueUrl = outputMap.EventQueueUrl;\n        const dlqUrl = outputMap.DeadLetterQueueUrl;\n\n        if (!eventQueueArn || !dlqUrl) {\n          printError(`Stack ${STACK_NAME} is missing expected outputs`, {\n            hint: 'Run `pipeline-manager infra setup-events` first.',\n          });\n          throw new Error('Stack outputs EventQueueArn / DeadLetterQueueUrl not found');\n        }\n\n        const sqs = new SQSClient({ region });\n\n        // The stack exposes the DLQ URL but not its ARN — StartMessageMoveTask needs\n        // the source ARN, so resolve it from the queue's attributes.\n        const dlqAttrs = await sqs.send(new GetQueueAttributesCommand({\n          QueueUrl: dlqUrl,\n          AttributeNames: ['QueueArn', 'ApproximateNumberOfMessages'],\n        }));\n        const dlqArn = dlqAttrs.Attributes?.QueueArn;\n        const dlqDepth = Number(dlqAttrs.Attributes?.ApproximateNumberOfMessages ?? '0');\n\n        if (!dlqArn) {\n          throw new Error(`Could not resolve the DLQ ARN from ${dlqUrl}`);\n        }\n\n        printKeyValue({\n          'Source (DLQ)': dlqArn,\n          'Destination (queue)': eventQueueArn,\n          'DLQ depth (approx)': String(dlqDepth),\n        });\n\n        // Nothing to move — bail early so the operator gets a clear signal instead\n        // of a no-op task.\n        if (dlqDepth === 0) {\n          printSuccess('Dead-letter queue is empty — nothing to redrive.');\n          return;\n        }\n\n        // Step 2: refuse to stack move tasks. SQS permits only one in-flight move\n        // task per source queue; surface any active one instead of erroring out.\n        printSection('Redrive');\n\n        const active = await sqs.send(new ListMessageMoveTasksCommand({ SourceArn: dlqArn }));\n        const running = (active.Results ?? []).find(t => t.Status === 'RUNNING');\n        if (running) {\n          printWarning('A message move task is already running for this DLQ — not starting another.', {\n            taskHandle: running.TaskHandle,\n            approxMovedSoFar: running.ApproximateNumberOfMessagesMoved,\n          });\n          return;\n        }\n\n        // Step 3: start the move (DLQ → main queue). DestinationArn is set explicitly\n        // even though SQS would default to the original source queue — the main\n        // ingestion queue is exactly that target.\n        const start = await sqs.send(new StartMessageMoveTaskCommand({\n          SourceArn: dlqArn,\n          DestinationArn: eventQueueArn,\n        }));\n\n        console.log('');\n        printSection('Redrive Started');\n        printKeyValue({\n          'Task Handle': start.TaskHandle ?? '(none returned)',\n          'Source (DLQ)': dlqArn,\n          'Destination (queue)': eventQueueUrl || eventQueueArn,\n          'Messages queued': String(dlqDepth),\n          'Status': '✓ Started',\n        });\n\n        console.log('');\n        printSuccess('Redrive task started. Messages will re-flow through the ingestion Lambda.');\n        printInfo('Idempotent ingest dedupes on idempotencyKey, so re-driven events are not double-counted.');\n\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'redrive-events', executionId, stack: STACK_NAME },\n        });\n      }\n    });\n}\n"]}

package/dist/commands/store-token.d.ts

@@ -1,11 +1,56 @@
 import { Command } from 'commander';
+import type { ApiClient } from '../utils/api-client.js';
+import { type ProvisionedKey } from '../utils/service-account.js';
+/** What a dry run reports it WOULD provision. */
+export interface StoreTokenPlan {
+    serviceAccount: string;
+    roles: string;
+    scope: string;
+    secretName: string;
+    region: string;
+    expiresInDays: number;
+}
+/** Print the dry-run plan (JSON or human). Stays entirely offline. */
+export declare function printDryRunPlan(plan: StoreTokenPlan, json: boolean): void;
+/**
+ * The Secrets Manager payload: `{ username: orgId, password: <pb_sa_ key>, ...metadata }`.
+ * - username/password satisfy CodeBuild's `secretsManagerCredentials` (HTTP
+ *   Basic, sent to pipeline-image-registry's /token endpoint, which exchanges
+ *   the opaque key like every other service does).
+ * - `password` is the canonical field: the plugin-lookup Lambda, the events
+ *   Lambda and `--store-tokens` all read it.
+ * - keyId / serviceAccountId are what the rotation Lambda needs to retire the
+ *   key it replaces.
+ */
+export declare function buildSecretValue(provisioned: ProvisionedKey, platformUrl: string, expiresInSeconds: number): string;
+/**
+ * Retire the credential this run replaced — AFTER the new one is stored, never
+ * before. A failure here leaves a superfluous key that expires on its own;
+ * doing it in the other order would leave the secret naming a revoked key if
+ * the write failed.
+ */
+export declare function retirePreviousKey(client: ApiClient, password: string, provisioned: ProvisionedKey, previous: {
+    keyId?: string;
+    serviceAccountId?: string;
+}): Promise<void>;
+/** Print the stored key's summary (JSON or human) plus the next steps. */
+export declare function printStoredKey(r: {
+    json: boolean;
+    secretName: string;
+    arn: string | undefined;
+    region: string;
+    accountName: string;
+    provisioned: ProvisionedKey;
+    days: number;
+    scheduleExpression: string | undefined;
+}): void;
 /**
  * Registers the `store-token` command with the CLI program.
  *
  * Provisions the org's machine identity — a SERVICE ACCOUNT and one `pb_sa_…`
  * key — and stores the key in AWS Secrets Manager for CDK deployments,
  * CodeBuild's registry credentials, the plugin-lookup Lambda and the event
- * ingestion Lambda (#12 / #N2). Nothing stored is tied to a person's session any
+ * ingestion Lambda. Nothing stored is tied to a person's session any
  * more: the account outlives its creator, takes no seat, and every audit row it
  * produces names the account.
  *

package/dist/commands/store-token.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-token.d.ts","sourceRoot":"","sources":["../../src/commands/store-token.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAiJpC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA2PjD"}
+{"version":3,"file":"store-token.d.ts","sourceRoot":"","sources":["../../src/commands/store-token.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AASxD,OAAO,EAAuD,KAAK,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAuIvH,iDAAiD;AACjD,MAAM,WAAW,cAAc;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,sEAAsE;AACtE,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAgBzE;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAcnH;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,cAAc,EAC3B,QAAQ,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAAE,GACtD,OAAO,CAAC,IAAI,CAAC,CAcf;AAED,0EAA0E;AAC1E,wBAAgB,cAAc,CAAC,CAAC,EAAE;IAChC,IAAI,EAAE,OAAO,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,cAAc,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAC;CACxC,GAAG,IAAI,CA6CP;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAqKjD"}