@pipeline-builder/pipeline-manager 0.0.1

package/dist/commands/instantiate-template.js

@@ -0,0 +1,274 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import * as fs from 'fs';
+import { Command } from 'commander';
+import ora from 'ora';
+import pico from 'picocolors';
+import {} from '../types/index.js';
+import { createAuthenticatedClient, printCommandHeader, printExecutionSummary, printSslWarning, withSslOptions } from '../utils/command-utils.js';
+import { ERROR_CODES, handleError, ValidationError } from '../utils/error-handler.js';
+import { outputData, printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';
+import { extractListResponse, extractSingleResponse } from '../utils/response-utils.js';
+const { bold, cyan, dim, green } = pico;
+/**
+ * Accumulate a repeatable `--input KEY=VALUE` flag. This only collects — it does
+ * NOT validate, because Commander runs `parseArg` before the action callback, so
+ * a throw here would escape the action's `handleError` and surface as an
+ * unhandled stack trace with the wrong exit code instead of a clean validation
+ * failure. Parsing happens in {@link parseInputPairs}, inside the action.
+ */
+function collectInput(pair, previous) {
+    return [...previous, pair];
+}
+/**
+ * Split collected `KEY=VALUE` pairs into a map. Values stay strings; the platform
+ * coerces each to its declared input type (and rejects what doesn't fit), so the
+ * CLI does not guess types locally. Only the FIRST `=` splits, so a value may
+ * itself contain `=`.
+ */
+function parseInputPairs(pairs) {
+    const out = {};
+    for (const pair of pairs) {
+        const eq = pair.indexOf('=');
+        if (eq < 1) {
+            throw new ValidationError(`Invalid --input "${pair}" — expected KEY=VALUE`, 'input', pair, 'key=value', 'e.g. --input orgId=1234abcd-...');
+        }
+        out[pair.slice(0, eq)] = pair.slice(eq + 1);
+    }
+    return out;
+}
+/** Read and parse `--inputs-file`, which holds a flat `{ name: value }` object. */
+function readInputsFile(file) {
+    if (!fs.existsSync(file)) {
+        throw new ValidationError(`Inputs file not found: ${file}`, 'inputs-file', file);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));
+    }
+    catch (error) {
+        throw new ValidationError(`Inputs file is not valid JSON: ${error instanceof Error ? error.message : String(error)}`, 'inputs-file', file);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new ValidationError('Inputs file must contain a JSON object of { "inputName": value }', 'inputs-file', file);
+    }
+    for (const [k, v] of Object.entries(parsed)) {
+        const t = typeof v;
+        if (t !== 'string' && t !== 'number' && t !== 'boolean') {
+            throw new ValidationError(`Input "${k}" must be a string, number, or boolean (got ${t})`, 'inputs-file', file);
+        }
+    }
+    return parsed;
+}
+/**
+ * Resolve a template `name` to its id through the catalog list endpoint. The list
+ * is visibility-scoped server-side, so this only ever sees templates the caller
+ * may read. Matching is exact on `name` — the `name` query param is a filter, not
+ * a unique lookup, so a fuzzy backend match must not silently instantiate a
+ * DIFFERENT template than the one asked for.
+ */
+async function resolveTemplateByName(client, name) {
+    const url = client.getConfig().api.pipelineTemplateUrl;
+    const response = await client.get(url, { name, limit: 100 });
+    const { items } = extractListResponse(response, 'templates');
+    const exact = items.filter((t) => t.name === name);
+    if (exact.length === 0) {
+        throw new ValidationError(`No pipeline template named "${name}" is visible to you.`, 'name', name, undefined, items.length > 0
+            ? `Did you mean one of: ${items.slice(0, 10).map((t) => t.name).join(', ')}`
+            : 'Load the sample catalog with deploy/bin/load-templates.sh, or pass --id.');
+    }
+    // A name is unique per org, but the visible set spans your org + parent + the
+    // system catalog, so the same name can legitimately appear more than once.
+    // Refuse to guess — the wrong pick would silently synth someone else's body.
+    if (exact.length > 1) {
+        throw new ValidationError(`"${name}" matches ${exact.length} visible templates — pass --id to choose one.`, 'name', name, undefined, `ids: ${exact.map((t) => t.id).join(', ')}`);
+    }
+    return exact[0];
+}
+/**
+ * Registers the `template instantiate` command.
+ *
+ * Renders a golden-path template into a concrete pipeline `props` document by
+ * supplying its declared inputs. It **creates nothing** — the rendered props are
+ * written to a file (or stdout) and go through the normal `pipeline create` path,
+ * where compliance and quota still apply.
+ *
+ * @example
+ * ```bash
+ * pipeline-manager template instantiate --name react-javascript \
+ *   --project react --organization AcmeCorp \
+ *   --input orgId=1234abcd-... --output pipeline-props.json
+ *
+ * pipeline-manager pipeline create --file pipeline-props.json --deploy
+ * ```
+ */
+export function instantiateTemplate(program) {
+    withSslOptions(program
+        .command('instantiate')
+        .description('Render a pipeline template into concrete pipeline props (creates nothing)')
+        .option('-n, --name <name>', 'Template name (resolved against the catalog you can see)')
+        .option('-i, --id <id>', 'Template ID (skips the name lookup)')
+        .requiredOption('-p, --project <project>', 'Project name for the pipeline this template will produce')
+        .requiredOption('-o, --organization <organization>', 'Organization name for the pipeline')
+        .option('--pipeline-name <name>', 'Pipeline name (defaults to <organization>-<project>-pipeline at synth)')
+        .option('--input <key=value>', 'Template input, repeatable (e.g. --input orgId=1234abcd-...)', collectInput, [])
+        .option('--inputs-file <file>', 'JSON file of { "inputName": value } — merged UNDER any --input flags')
+        .option('--output <file>', 'Write the rendered props to a file (default: stdout)')
+        .option('-f, --format <format>', 'Output format (json, yaml)', 'json'))
+        .option('--json', 'Print ONLY the rendered props as JSON (for piping); implies no decorative output', false)
+        .action(async (options) => {
+        // With --json (or props headed for stdout in any format) the payload IS the
+        // output, so the banner must not land on stdout ahead of it and break piping.
+        const toStdout = !options.output;
+        const quiet = options.json || toStdout;
+        const executionId = printCommandHeader('Instantiate Template', undefined, { quiet });
+        try {
+            if (!options.name && !options.id) {
+                throw new ValidationError('Provide --name or --id to select a template', 'name');
+            }
+            if (options.name && options.id) {
+                throw new ValidationError('Pass either --name or --id, not both', 'name');
+            }
+            // Only the round-trippable formats: the rendered props exist to be fed
+            // back to `pipeline create --file`, and `table`/`csv` would flatten them
+            // into something that can no longer be parsed as props.
+            if (!['json', 'yaml'].includes(options.format)) {
+                throw new ValidationError(`Unsupported --format "${options.format}" — rendered props must stay parseable`, 'format', options.format, 'json|yaml');
+            }
+            if (!quiet)
+                printSslWarning(options.verifySsl);
+            // --input flags win over --inputs-file so a file can hold shared defaults
+            // that a single flag overrides on the command line.
+            const inputs = {
+                ...(options.inputsFile ? readInputsFile(options.inputsFile) : {}),
+                ...parseInputPairs(options.input),
+            };
+            if (!quiet) {
+                printInfo('Request parameters', {
+                    template: options.name ?? options.id,
+                    project: options.project,
+                    organization: options.organization,
+                    pipelineName: options.pipelineName ?? '(default)',
+                    inputs: Object.keys(inputs).length > 0 ? Object.keys(inputs).join(', ') : '(none)',
+                    output: options.output ?? '(stdout)',
+                });
+                console.log('');
+                printSection('Rendering Template');
+            }
+            const client = createAuthenticatedClient(options);
+            const templateUrl = client.getConfig().api.pipelineTemplateUrl;
+            const startTime = Date.now();
+            const spinner = quiet ? null : ora('Resolving template...').start();
+            let templateId;
+            let templateName;
+            try {
+                if (options.id) {
+                    templateId = options.id;
+                }
+                else {
+                    const template = await resolveTemplateByName(client, options.name);
+                    templateId = template.id;
+                    templateName = template.name;
+                }
+                spinner?.succeed(`Template resolved${templateName ? ` (${templateName})` : ''}`);
+            }
+            catch (error) {
+                spinner?.fail('Template resolution failed');
+                throw error;
+            }
+            const body = {
+                project: options.project,
+                organization: options.organization,
+                ...(options.pipelineName ? { pipelineName: options.pipelineName } : {}),
+                ...(Object.keys(inputs).length > 0 ? { inputs } : {}),
+            };
+            const renderSpinner = quiet ? null : ora('Instantiating...').start();
+            let rendered;
+            try {
+                const response = await client.post(`${templateUrl}/${encodeURIComponent(templateId)}/instantiate`, body);
+                // `props` is the identifier key: the envelope's data IS { props, ... }.
+                rendered = extractSingleResponse(response, 'template', 'props');
+                renderSpinner?.succeed('Template instantiated');
+            }
+            catch (error) {
+                renderSpinner?.fail('Instantiate failed');
+                throw error;
+            }
+            const duration = Date.now() - startTime;
+            if (!rendered?.props) {
+                printError('No props returned from API', { templateId });
+                throw new Error(`Template ${templateId} rendered no props`);
+            }
+            const props = rendered.props;
+            // A leftover `{{ ... }}` in a *self-scope* field means an input was never
+            // supplied and the placeholder would fail opaquely at synth. `pipeline.*`
+            // tokens are expected here — they resolve at synth, not at instantiate.
+            const unresolved = unresolvedSelfVars(props);
+            if (unresolved.length > 0) {
+                printWarning('Rendered props still contain unresolved placeholders', {
+                    vars: unresolved.join(', '),
+                    hint: 'Supply them with --input <name>=<value>',
+                });
+            }
+            if (!quiet) {
+                console.log('');
+                printSection('Rendered Props');
+                printKeyValue({
+                    'Template': green(bold(templateName ?? templateId)),
+                    'Project': props.project,
+                    'Organization': props.organization,
+                    'Pipeline Name': props.pipelineName ?? dim('(default at synth)'),
+                    'Vars': Object.keys(props.vars ?? {}).join(', ') || dim('(none)'),
+                    'Stages': String(Array.isArray(props.stages) ? props.stages.length : 0),
+                });
+                printExecutionSummary(executionId, duration);
+            }
+            outputData(props, {
+                format: options.json ? 'json' : options.format,
+                file: options.output,
+                silent: quiet,
+            });
+            if (options.output && !quiet) {
+                console.log('');
+                printSuccess('Pipeline props saved', { path: options.output });
+                printInfo('Next step', {
+                    command: `pipeline-manager pipeline create --file ${options.output} --deploy`,
+                });
+                console.log(dim(`  ${cyan('Tip:')} instantiate only renders — nothing exists on the platform yet.`));
+            }
+        }
+        catch (error) {
+            handleError(error, ERROR_CODES.API_REQUEST, {
+                debug: program.opts().debug,
+                exit: true,
+                context: { command: 'instantiate-template', executionId, template: options.name ?? options.id },
+            });
+        }
+    });
+}
+/**
+ * Names of `{{ vars.X }}` placeholders still present in the rendered props' own
+ * self-scope fields (`project`, `metadata.*`, `vars.*`) — i.e. inputs the caller
+ * never supplied. `{{ pipeline.* }}` tokens are deliberately ignored: those are
+ * synth-time references (e.g. the GitHub source token) and are SUPPOSED to
+ * survive instantiation.
+ */
+function unresolvedSelfVars(props) {
+    const found = new Set();
+    const scan = (value) => {
+        if (typeof value === 'string') {
+            for (const m of value.matchAll(/\{\{\s*vars\.([A-Za-z_][A-Za-z0-9_]*)/g))
+                found.add(m[1]);
+            return;
+        }
+        if (Array.isArray(value))
+            return value.forEach(scan);
+        if (value && typeof value === 'object')
+            return Object.values(value).forEach(scan);
+    };
+    scan(props.project);
+    scan(props.metadata);
+    scan(props.vars);
+    return [...found];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instantiate-template.js","sourceRoot":"","sources":["../../src/commands/instantiate-template.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as fs from 'fs';\nimport { Command } from 'commander';\nimport ora from 'ora';\nimport pico from 'picocolors';\nimport {\n  type InstantiateTemplateRequest,\n  type InstantiateTemplateResponse,\n  type PipelineTemplate,\n  type PipelineProps,\n} from '../types/index.js';\nimport { createAuthenticatedClient, printCommandHeader, printExecutionSummary, printSslWarning, withSslOptions } from '../utils/command-utils.js';\nimport { ERROR_CODES, handleError, ValidationError } from '../utils/error-handler.js';\nimport { outputData, printError, printInfo, printKeyValue, printSection, printSuccess, printWarning } from '../utils/output-utils.js';\nimport { extractListResponse, extractSingleResponse } from '../utils/response-utils.js';\n\nconst { bold, cyan, dim, green } = pico;\n\n/**\n * Accumulate a repeatable `--input KEY=VALUE` flag. This only collects — it does\n * NOT validate, because Commander runs `parseArg` before the action callback, so\n * a throw here would escape the action's `handleError` and surface as an\n * unhandled stack trace with the wrong exit code instead of a clean validation\n * failure. Parsing happens in {@link parseInputPairs}, inside the action.\n */\nfunction collectInput(pair: string, previous: string[]): string[] {\n  return [...previous, pair];\n}\n\n/**\n * Split collected `KEY=VALUE` pairs into a map. Values stay strings; the platform\n * coerces each to its declared input type (and rejects what doesn't fit), so the\n * CLI does not guess types locally. Only the FIRST `=` splits, so a value may\n * itself contain `=`.\n */\nfunction parseInputPairs(pairs: string[]): Record<string, string> {\n  const out: Record<string, string> = {};\n  for (const pair of pairs) {\n    const eq = pair.indexOf('=');\n    if (eq < 1) {\n      throw new ValidationError(\n        `Invalid --input \"${pair}\" — expected KEY=VALUE`,\n        'input', pair, 'key=value', 'e.g. --input orgId=1234abcd-...',\n      );\n    }\n    out[pair.slice(0, eq)] = pair.slice(eq + 1);\n  }\n  return out;\n}\n\n/** Read and parse `--inputs-file`, which holds a flat `{ name: value }` object. */\nfunction readInputsFile(file: string): Record<string, string | number | boolean> {\n  if (!fs.existsSync(file)) {\n    throw new ValidationError(`Inputs file not found: ${file}`, 'inputs-file', file);\n  }\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));\n  } catch (error) {\n    throw new ValidationError(\n      `Inputs file is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,\n      'inputs-file', file,\n    );\n  }\n  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {\n    throw new ValidationError('Inputs file must contain a JSON object of { \"inputName\": value }', 'inputs-file', file);\n  }\n  for (const [k, v] of Object.entries(parsed as Record<string, unknown>)) {\n    const t = typeof v;\n    if (t !== 'string' && t !== 'number' && t !== 'boolean') {\n      throw new ValidationError(`Input \"${k}\" must be a string, number, or boolean (got ${t})`, 'inputs-file', file);\n    }\n  }\n  return parsed as Record<string, string | number | boolean>;\n}\n\n/**\n * Resolve a template `name` to its id through the catalog list endpoint. The list\n * is visibility-scoped server-side, so this only ever sees templates the caller\n * may read. Matching is exact on `name` — the `name` query param is a filter, not\n * a unique lookup, so a fuzzy backend match must not silently instantiate a\n * DIFFERENT template than the one asked for.\n */\nasync function resolveTemplateByName(\n  client: ReturnType<typeof createAuthenticatedClient>,\n  name: string,\n): Promise<PipelineTemplate> {\n  const url = client.getConfig().api.pipelineTemplateUrl;\n  const response = await client.get(url, { name, limit: 100 });\n  const { items } = extractListResponse<PipelineTemplate>(response, 'templates');\n\n  const exact = items.filter((t) => t.name === name);\n  if (exact.length === 0) {\n    throw new ValidationError(\n      `No pipeline template named \"${name}\" is visible to you.`,\n      'name', name, undefined,\n      items.length > 0\n        ? `Did you mean one of: ${items.slice(0, 10).map((t) => t.name).join(', ')}`\n        : 'Load the sample catalog with deploy/bin/load-templates.sh, or pass --id.',\n    );\n  }\n  // A name is unique per org, but the visible set spans your org + parent + the\n  // system catalog, so the same name can legitimately appear more than once.\n  // Refuse to guess — the wrong pick would silently synth someone else's body.\n  if (exact.length > 1) {\n    throw new ValidationError(\n      `\"${name}\" matches ${exact.length} visible templates — pass --id to choose one.`,\n      'name', name, undefined,\n      `ids: ${exact.map((t) => t.id).join(', ')}`,\n    );\n  }\n  return exact[0]!;\n}\n\n/**\n * Registers the `template instantiate` command.\n *\n * Renders a golden-path template into a concrete pipeline `props` document by\n * supplying its declared inputs. It **creates nothing** — the rendered props are\n * written to a file (or stdout) and go through the normal `pipeline create` path,\n * where compliance and quota still apply.\n *\n * @example\n * ```bash\n * pipeline-manager template instantiate --name react-javascript \\\n *   --project react --organization AcmeCorp \\\n *   --input orgId=1234abcd-... --output pipeline-props.json\n *\n * pipeline-manager pipeline create --file pipeline-props.json --deploy\n * ```\n */\nexport function instantiateTemplate(program: Command): void {\n  withSslOptions(\n    program\n      .command('instantiate')\n      .description('Render a pipeline template into concrete pipeline props (creates nothing)')\n      .option('-n, --name <name>', 'Template name (resolved against the catalog you can see)')\n      .option('-i, --id <id>', 'Template ID (skips the name lookup)')\n      .requiredOption('-p, --project <project>', 'Project name for the pipeline this template will produce')\n      .requiredOption('-o, --organization <organization>', 'Organization name for the pipeline')\n      .option('--pipeline-name <name>', 'Pipeline name (defaults to <organization>-<project>-pipeline at synth)')\n      .option('--input <key=value>', 'Template input, repeatable (e.g. --input orgId=1234abcd-...)', collectInput, [])\n      .option('--inputs-file <file>', 'JSON file of { \"inputName\": value } — merged UNDER any --input flags')\n      .option('--output <file>', 'Write the rendered props to a file (default: stdout)')\n      .option('-f, --format <format>', 'Output format (json, yaml)', 'json'),\n  )\n    .option('--json', 'Print ONLY the rendered props as JSON (for piping); implies no decorative output', false)\n    .action(async (options) => {\n      // With --json (or props headed for stdout in any format) the payload IS the\n      // output, so the banner must not land on stdout ahead of it and break piping.\n      const toStdout = !options.output;\n      const quiet = options.json || toStdout;\n      const executionId = printCommandHeader('Instantiate Template', undefined, { quiet });\n\n      try {\n        if (!options.name && !options.id) {\n          throw new ValidationError('Provide --name or --id to select a template', 'name');\n        }\n        if (options.name && options.id) {\n          throw new ValidationError('Pass either --name or --id, not both', 'name');\n        }\n        // Only the round-trippable formats: the rendered props exist to be fed\n        // back to `pipeline create --file`, and `table`/`csv` would flatten them\n        // into something that can no longer be parsed as props.\n        if (!['json', 'yaml'].includes(options.format)) {\n          throw new ValidationError(\n            `Unsupported --format \"${options.format}\" — rendered props must stay parseable`,\n            'format', options.format, 'json|yaml',\n          );\n        }\n        if (!quiet) printSslWarning(options.verifySsl);\n\n        // --input flags win over --inputs-file so a file can hold shared defaults\n        // that a single flag overrides on the command line.\n        const inputs: Record<string, string | number | boolean> = {\n          ...(options.inputsFile ? readInputsFile(options.inputsFile) : {}),\n          ...parseInputPairs(options.input as string[]),\n        };\n\n        if (!quiet) {\n          printInfo('Request parameters', {\n            template: options.name ?? options.id,\n            project: options.project,\n            organization: options.organization,\n            pipelineName: options.pipelineName ?? '(default)',\n            inputs: Object.keys(inputs).length > 0 ? Object.keys(inputs).join(', ') : '(none)',\n            output: options.output ?? '(stdout)',\n          });\n          console.log('');\n          printSection('Rendering Template');\n        }\n\n        const client = createAuthenticatedClient(options);\n        const templateUrl = client.getConfig().api.pipelineTemplateUrl;\n\n        const startTime = Date.now();\n        const spinner = quiet ? null : ora('Resolving template...').start();\n        let templateId: string;\n        let templateName: string | undefined;\n        try {\n          if (options.id) {\n            templateId = options.id;\n          } else {\n            const template = await resolveTemplateByName(client, options.name);\n            templateId = template.id;\n            templateName = template.name;\n          }\n          spinner?.succeed(`Template resolved${templateName ? ` (${templateName})` : ''}`);\n        } catch (error) {\n          spinner?.fail('Template resolution failed');\n          throw error;\n        }\n\n        const body: InstantiateTemplateRequest = {\n          project: options.project,\n          organization: options.organization,\n          ...(options.pipelineName ? { pipelineName: options.pipelineName } : {}),\n          ...(Object.keys(inputs).length > 0 ? { inputs } : {}),\n        };\n\n        const renderSpinner = quiet ? null : ora('Instantiating...').start();\n        let rendered: InstantiateTemplateResponse | undefined;\n        try {\n          const response = await client.post(`${templateUrl}/${encodeURIComponent(templateId)}/instantiate`, body);\n          // `props` is the identifier key: the envelope's data IS { props, ... }.\n          rendered = extractSingleResponse<InstantiateTemplateResponse>(response, 'template', 'props');\n          renderSpinner?.succeed('Template instantiated');\n        } catch (error) {\n          renderSpinner?.fail('Instantiate failed');\n          throw error;\n        }\n        const duration = Date.now() - startTime;\n\n        if (!rendered?.props) {\n          printError('No props returned from API', { templateId });\n          throw new Error(`Template ${templateId} rendered no props`);\n        }\n        const props = rendered.props as PipelineProps;\n\n        // A leftover `{{ ... }}` in a *self-scope* field means an input was never\n        // supplied and the placeholder would fail opaquely at synth. `pipeline.*`\n        // tokens are expected here — they resolve at synth, not at instantiate.\n        const unresolved = unresolvedSelfVars(props);\n        if (unresolved.length > 0) {\n          printWarning('Rendered props still contain unresolved placeholders', {\n            vars: unresolved.join(', '),\n            hint: 'Supply them with --input <name>=<value>',\n          });\n        }\n\n        if (!quiet) {\n          console.log('');\n          printSection('Rendered Props');\n          printKeyValue({\n            'Template': green(bold(templateName ?? templateId)),\n            'Project': props.project as string,\n            'Organization': props.organization as string,\n            'Pipeline Name': (props.pipelineName as string) ?? dim('(default at synth)'),\n            'Vars': Object.keys((props.vars as Record<string, unknown>) ?? {}).join(', ') || dim('(none)'),\n            'Stages': String(Array.isArray(props.stages) ? props.stages.length : 0),\n          });\n          printExecutionSummary(executionId, duration);\n        }\n\n        outputData(props, {\n          format: options.json ? 'json' : options.format,\n          file: options.output,\n          silent: quiet,\n        });\n\n        if (options.output && !quiet) {\n          console.log('');\n          printSuccess('Pipeline props saved', { path: options.output });\n          printInfo('Next step', {\n            command: `pipeline-manager pipeline create --file ${options.output} --deploy`,\n          });\n          console.log(dim(`  ${cyan('Tip:')} instantiate only renders — nothing exists on the platform yet.`));\n        }\n      } catch (error) {\n        handleError(error, ERROR_CODES.API_REQUEST, {\n          debug: program.opts().debug,\n          exit: true,\n          context: { command: 'instantiate-template', executionId, template: options.name ?? options.id },\n        });\n      }\n    });\n}\n\n/**\n * Names of `{{ vars.X }}` placeholders still present in the rendered props' own\n * self-scope fields (`project`, `metadata.*`, `vars.*`) — i.e. inputs the caller\n * never supplied. `{{ pipeline.* }}` tokens are deliberately ignored: those are\n * synth-time references (e.g. the GitHub source token) and are SUPPOSED to\n * survive instantiation.\n */\nfunction unresolvedSelfVars(props: PipelineProps): string[] {\n  const found = new Set<string>();\n  const scan = (value: unknown): void => {\n    if (typeof value === 'string') {\n      for (const m of value.matchAll(/\\{\\{\\s*vars\\.([A-Za-z_][A-Za-z0-9_]*)/g)) found.add(m[1]!);\n      return;\n    }\n    if (Array.isArray(value)) return value.forEach(scan);\n    if (value && typeof value === 'object') return Object.values(value).forEach(scan);\n  };\n  scan(props.project);\n  scan(props.metadata);\n  scan(props.vars);\n  return [...found];\n}\n"]}

package/dist/commands/list-pipelines.d.ts

@@ -0,0 +1,20 @@
+import { Command } from 'commander';
+/**
+ * Registers the `list-pipelines` command with the CLI program.
+ *
+ * Queries pipelines with filters for project, organization, name,
+ * access modifier, active/default status, plus pagination and sorting.
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ *
+ * @example
+ * ```bash
+ * cli pipeline list
+ * cli pipeline list --project my-app --is-active true
+ * cli pipeline list --organization my-org
+ * cli pipeline list --limit 50 --offset 100 --sort "pipelineName:asc"
+ * cli pipeline list --format json --output pipelines.json
+ * ```
+ */
+export declare function listPipelines(program: Command): void;
+//# sourceMappingURL=list-pipelines.d.ts.map

package/dist/commands/list-pipelines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-pipelines.d.ts","sourceRoot":"","sources":["../../src/commands/list-pipelines.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqBpC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAgEpD"}

package/dist/commands/list-pipelines.js

@@ -0,0 +1,99 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import { runListEntity } from './entity-list.js';
+import { validateBoolean } from '../config/cli.constants.js';
+import {} from '../types/index.js';
+import { withSslOptions } from '../utils/command-utils.js';
+import {} from '../utils/list-command-utils.js';
+/**
+ * Registers the `list-pipelines` command with the CLI program.
+ *
+ * Queries pipelines with filters for project, organization, name,
+ * access modifier, active/default status, plus pagination and sorting.
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ *
+ * @example
+ * ```bash
+ * cli pipeline list
+ * cli pipeline list --project my-app --is-active true
+ * cli pipeline list --organization my-org
+ * cli pipeline list --limit 50 --offset 100 --sort "pipelineName:asc"
+ * cli pipeline list --format json --output pipelines.json
+ * ```
+ */
+export function listPipelines(program) {
+    withSslOptions(program
+        .command('list')
+        .description('Query pipelines with comprehensive filters')
+        // Common filter options
+        .option('--id <id>', 'Filter by pipeline ID (can specify multiple with commas)')
+        .option('--visibility <rung>', 'Filter by sharing rung (private/org/public)')
+        .option('--is-default <boolean>', 'Filter by default status (true/false)')
+        .option('--is-active <boolean>', 'Filter by active status (true/false)')
+        .option('--limit <number>', 'Maximum number of results (1-1000)', (v) => parseInt(v, 10), 50)
+        .option('--offset <number>', 'Number of results to skip', (v) => parseInt(v, 10), 0)
+        .option('--sort <sort>', 'Sort format: field:direction (e.g., pipelineName:asc, createdAt:desc)')
+        // Pipeline-specific filter options
+        .option('--project <project>', 'Filter by exact project name')
+        .option('--organization <organization>', 'Filter by exact organization name')
+        .option('--pipeline-name <name>', 'Filter by exact pipeline name')
+        // Output options
+        .option('-f, --format <format>', 'Output format (json, yaml, table, csv)', 'table')
+        .option('-o, --output <file>', 'Save output to file')
+        .option('--show-props', 'Include pipeline properties in output (json/yaml only)', false))
+        .action((options) => runListEntity(program, options, {
+        labelPlural: 'Pipelines',
+        responseKey: 'pipelines',
+        listUrl: (config) => config.api.pipelineListUrl,
+        commandName: 'list-pipelines',
+        buildFilters: (options, base) => {
+            const filters = { ...base };
+            if (options.visibility)
+                filters.visibility = options.visibility;
+            if (options.isDefault !== undefined)
+                filters.isDefault = validateBoolean(options.isDefault, 'is-default');
+            if (options.project)
+                filters.project = options.project;
+            if (options.organization)
+                filters.organization = options.organization;
+            if (options.pipelineName)
+                filters.pipelineName = options.pipelineName;
+            return filters;
+        },
+        activeFilters: (filters) => {
+            const active = {};
+            if (filters.id)
+                active.ID = filters.id;
+            if (filters.visibility)
+                active.Visibility = filters.visibility;
+            if (filters.isDefault !== undefined)
+                active['Is Default'] = filters.isDefault;
+            if (filters.isActive !== undefined)
+                active['Is Active'] = filters.isActive;
+            if (filters.project)
+                active.Project = filters.project;
+            if (filters.organization)
+                active.Organization = filters.organization;
+            if (filters.pipelineName)
+                active['Pipeline Name'] = filters.pipelineName;
+            return active;
+        },
+        statistics: (pipelines) => ({
+            'Active Pipelines': `${pipelines.filter(p => p.isActive).length}/${pipelines.length}`,
+            'Default Pipelines': `${pipelines.filter(p => p.isDefault).length}/${pipelines.length}`,
+        }),
+        rows: (pipelines, options) => options.showProps ? pipelines : pipelines.map(p => ({
+            'ID': p.id,
+            'Project': p.project,
+            'Organization': p.organization,
+            'Name': p.pipelineName || 'N/A',
+            'Visibility': p.visibility || 'private',
+            'Default': p.isDefault ? 'Yes' : 'No',
+            'Active': p.isActive ? 'Yes' : 'No',
+            'Created At': p.createdAt || 'N/A',
+        })),
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list-pipelines.js","sourceRoot":"","sources":["../../src/commands/list-pipelines.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Command } from 'commander';\nimport { runListEntity } from './entity-list.js';\nimport { validateBoolean } from '../config/cli.constants.js';\nimport { type Pipeline } from '../types/index.js';\nimport { withSslOptions } from '../utils/command-utils.js';\nimport { type CommonFilterParams } from '../utils/list-command-utils.js';\n\n/**\n * Query parameters for the pipeline list API endpoint.\n * Combines common filters (pagination, sort, access) with pipeline-specific filters.\n */\ninterface PipelineFilterParams extends CommonFilterParams {\n  visibility?: string;\n  isDefault?: boolean;\n\n  // Pipeline-specific filters\n  project?: string;\n  organization?: string;\n  pipelineName?: string;\n}\n\n/**\n * Registers the `list-pipelines` command with the CLI program.\n *\n * Queries pipelines with filters for project, organization, name,\n * access modifier, active/default status, plus pagination and sorting.\n *\n * @param program - The root Commander program instance to attach the command to.\n *\n * @example\n * ```bash\n * cli pipeline list\n * cli pipeline list --project my-app --is-active true\n * cli pipeline list --organization my-org\n * cli pipeline list --limit 50 --offset 100 --sort \"pipelineName:asc\"\n * cli pipeline list --format json --output pipelines.json\n * ```\n */\nexport function listPipelines(program: Command): void {\n  withSslOptions(program\n    .command('list')\n    .description('Query pipelines with comprehensive filters')\n\n    // Common filter options\n    .option('--id <id>', 'Filter by pipeline ID (can specify multiple with commas)')\n    .option('--visibility <rung>', 'Filter by sharing rung (private/org/public)')\n    .option('--is-default <boolean>', 'Filter by default status (true/false)')\n    .option('--is-active <boolean>', 'Filter by active status (true/false)')\n    .option('--limit <number>', 'Maximum number of results (1-1000)', (v) => parseInt(v, 10), 50)\n    .option('--offset <number>', 'Number of results to skip', (v) => parseInt(v, 10), 0)\n    .option('--sort <sort>', 'Sort format: field:direction (e.g., pipelineName:asc, createdAt:desc)')\n\n    // Pipeline-specific filter options\n    .option('--project <project>', 'Filter by exact project name')\n    .option('--organization <organization>', 'Filter by exact organization name')\n    .option('--pipeline-name <name>', 'Filter by exact pipeline name')\n\n    // Output options\n    .option('-f, --format <format>', 'Output format (json, yaml, table, csv)', 'table')\n    .option('-o, --output <file>', 'Save output to file')\n    .option('--show-props', 'Include pipeline properties in output (json/yaml only)', false))\n\n    .action((options) => runListEntity<Pipeline, PipelineFilterParams>(program, options, {\n      labelPlural: 'Pipelines',\n      responseKey: 'pipelines',\n      listUrl: (config) => config.api.pipelineListUrl,\n      commandName: 'list-pipelines',\n      buildFilters: (options, base) => {\n        const filters: PipelineFilterParams = { ...base };\n        if (options.visibility) filters.visibility = options.visibility as string;\n        if (options.isDefault !== undefined) filters.isDefault = validateBoolean(options.isDefault as string, 'is-default');\n        if (options.project) filters.project = options.project as string;\n        if (options.organization) filters.organization = options.organization as string;\n        if (options.pipelineName) filters.pipelineName = options.pipelineName as string;\n        return filters;\n      },\n      activeFilters: (filters) => {\n        const active: Record<string, unknown> = {};\n        if (filters.id) active.ID = filters.id;\n        if (filters.visibility) active.Visibility = filters.visibility;\n        if (filters.isDefault !== undefined) active['Is Default'] = filters.isDefault;\n        if (filters.isActive !== undefined) active['Is Active'] = filters.isActive;\n        if (filters.project) active.Project = filters.project;\n        if (filters.organization) active.Organization = filters.organization;\n        if (filters.pipelineName) active['Pipeline Name'] = filters.pipelineName;\n        return active;\n      },\n      statistics: (pipelines) => ({\n        'Active Pipelines': `${pipelines.filter(p => p.isActive).length}/${pipelines.length}`,\n        'Default Pipelines': `${pipelines.filter(p => p.isDefault).length}/${pipelines.length}`,\n      }),\n      rows: (pipelines, options) => options.showProps ? pipelines : pipelines.map(p => ({\n        'ID': p.id,\n        'Project': p.project,\n        'Organization': p.organization,\n        'Name': p.pipelineName || 'N/A',\n        'Visibility': p.visibility || 'private',\n        'Default': p.isDefault ? 'Yes' : 'No',\n        'Active': p.isActive ? 'Yes' : 'No',\n        'Created At': p.createdAt || 'N/A',\n      })),\n    }));\n}\n"]}

package/dist/commands/list-plugins.d.ts

@@ -0,0 +1,20 @@
+import { Command } from 'commander';
+/**
+ * Registers the `list-plugins` command with the CLI program.
+ *
+ * Queries plugins with filters for name, version, image tag,
+ * active status, plus pagination and sorting.
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ *
+ * @example
+ * ```bash
+ * cli plugin list
+ * cli plugin list --name auth-plugin --is-active true
+ * cli plugin list --version "^1.0.0"
+ * cli plugin list --limit 50 --offset 100 --sort "name:asc"
+ * cli plugin list --format json --output plugins.json
+ * ```
+ */
+export declare function listPlugins(program: Command): void;
+//# sourceMappingURL=list-plugins.d.ts.map

package/dist/commands/list-plugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-plugins.d.ts","sourceRoot":"","sources":["../../src/commands/list-plugins.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAkBpC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA+DlD"}

package/dist/commands/list-plugins.js

@@ -0,0 +1,92 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import { runListEntity } from './entity-list.js';
+import { formatFileSize } from '../config/cli.constants.js';
+import {} from '../types/index.js';
+import { withSslOptions } from '../utils/command-utils.js';
+import {} from '../utils/list-command-utils.js';
+import { printWarning } from '../utils/output-utils.js';
+/**
+ * Registers the `list-plugins` command with the CLI program.
+ *
+ * Queries plugins with filters for name, version, image tag,
+ * active status, plus pagination and sorting.
+ *
+ * @param program - The root Commander program instance to attach the command to.
+ *
+ * @example
+ * ```bash
+ * cli plugin list
+ * cli plugin list --name auth-plugin --is-active true
+ * cli plugin list --version "^1.0.0"
+ * cli plugin list --limit 50 --offset 100 --sort "name:asc"
+ * cli plugin list --format json --output plugins.json
+ * ```
+ */
+export function listPlugins(program) {
+    withSslOptions(program
+        .command('list')
+        .description('Query plugins with comprehensive filters')
+        // Common filter options
+        .option('--id <id>', 'Filter by plugin ID (can specify multiple with commas)')
+        .option('--is-active <boolean>', 'Filter by active status (true/false)')
+        .option('--limit <number>', 'Maximum number of results (1-1000)', (v) => parseInt(v, 10), 50)
+        .option('--offset <number>', 'Number of results to skip', (v) => parseInt(v, 10), 0)
+        .option('--sort <sort>', 'Sort format: field:direction (e.g., name:asc, createdAt:desc)')
+        // Plugin-specific filter options
+        .option('--name <name>', 'Filter by exact plugin name')
+        .option('--version <version>', 'Filter by version (supports semver, e.g., "^1.0.0")')
+        // Output options
+        .option('-f, --format <format>', 'Output format (json, yaml, table, csv)', 'table')
+        .option('-o, --output <file>', 'Save output to file')
+        .option('--show-metadata', 'Include full metadata in output (json/yaml only)', false))
+        .action((options) => runListEntity(program, options, {
+        labelPlural: 'Plugins',
+        responseKey: 'plugins',
+        listUrl: (config) => config.api.pluginListUrl,
+        commandName: 'list-plugins',
+        buildFilters: (options, base) => {
+            const filters = { ...base };
+            if (options.name)
+                filters.name = options.name;
+            if (options.version) {
+                // Validate semver format
+                const versionPattern = /^(\^|~)?(\d+)\.(\d+)\.(\d+)(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/;
+                if (!versionPattern.test(options.version)) {
+                    printWarning(`Version "${options.version}" may not be valid semver format`);
+                }
+                filters.version = options.version;
+            }
+            return filters;
+        },
+        activeFilters: (filters) => {
+            const active = {};
+            if (filters.id)
+                active.ID = filters.id;
+            if (filters.isActive !== undefined)
+                active['Is Active'] = filters.isActive;
+            if (filters.name)
+                active.Name = filters.name;
+            if (filters.version)
+                active.Version = filters.version;
+            return active;
+        },
+        statistics: (plugins) => ({
+            'Active Plugins': `${plugins.filter(p => p.isActive).length}/${plugins.length}`,
+            'Public Plugins': `${plugins.filter(p => p.isPublic === true).length}/${plugins.length}`,
+            'Total Size': formatFileSize(plugins.reduce((sum, p) => sum + (p.fileSize || 0), 0)),
+        }),
+        rows: (plugins, options) => options.showMetadata ? plugins : plugins.map(p => ({
+            'ID': p.id,
+            'Name': p.name,
+            'Version': p.version,
+            'Organization': p.organization,
+            'Active': p.isActive ? 'Yes' : 'No',
+            'Public': p.isPublic ? 'Yes' : 'No',
+            'Size': p.fileSize ? formatFileSize(p.fileSize) : 'N/A',
+            'Created At': p.createdAt || 'N/A',
+        })),
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list-plugins.js","sourceRoot":"","sources":["../../src/commands/list-plugins.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAe,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAA2B,MAAM,gCAAgC,CAAC;AACzE,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAYxD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,WAAW,CAAC,OAAgB;IAC1C,cAAc,CAAC,OAAO;SACnB,OAAO,CAAC,MAAM,CAAC;SACf,WAAW,CAAC,0CAA0C,CAAC;QAExD,wBAAwB;SACvB,MAAM,CAAC,WAAW,EAAE,wDAAwD,CAAC;SAC7E,MAAM,CAAC,uBAAuB,EAAE,sCAAsC,CAAC;SACvE,MAAM,CAAC,kBAAkB,EAAE,oCAAoC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;SAC5F,MAAM,CAAC,mBAAmB,EAAE,2BAA2B,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;SACnF,MAAM,CAAC,eAAe,EAAE,+DAA+D,CAAC;QAEzF,iCAAiC;SAChC,MAAM,CAAC,eAAe,EAAE,6BAA6B,CAAC;SACtD,MAAM,CAAC,qBAAqB,EAAE,qDAAqD,CAAC;QAErF,iBAAiB;SAChB,MAAM,CAAC,uBAAuB,EAAE,wCAAwC,EAAE,OAAO,CAAC;SAClF,MAAM,CAAC,qBAAqB,EAAE,qBAAqB,CAAC;SACpD,MAAM,CAAC,iBAAiB,EAAE,kDAAkD,EAAE,KAAK,CAAC,CAAC;SAErF,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,aAAa,CAA6B,OAAO,EAAE,OAAO,EAAE;QAC/E,WAAW,EAAE,SAAS;QACtB,WAAW,EAAE,SAAS;QACtB,OAAO,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,aAAa;QAC7C,WAAW,EAAE,cAAc;QAC3B,YAAY,EAAE,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE;YAC9B,MAAM,OAAO,GAAuB,EAAE,GAAG,IAAI,EAAE,CAAC;YAChD,IAAI,OAAO,CAAC,IAAI;gBAAE,OAAO,CAAC,IAAI,GAAG,OAAO,CAAC,IAAc,CAAC;YACxD,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;gBACpB,yBAAyB;gBACzB,MAAM,cAAc,GAAG,mEAAmE,CAAC;gBAC3F,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,OAAiB,CAAC,EAAE,CAAC;oBACpD,YAAY,CAAC,YAAY,OAAO,CAAC,OAAO,kCAAkC,CAAC,CAAC;gBAC9E,CAAC;gBACD,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,OAAiB,CAAC;YAC9C,CAAC;YACD,OAAO,OAAO,CAAC;QACjB,CAAC;QACD,aAAa,EAAE,CAAC,OAAO,EAAE,EAAE;YACzB,MAAM,MAAM,GAA4B,EAAE,CAAC;YAC3C,IAAI,OAAO,CAAC,EAAE;gBAAE,MAAM,CAAC,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC;YACvC,IAAI,OAAO,CAAC,QAAQ,KAAK,SAAS;gBAAE,MAAM,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC;YAC3E,IAAI,OAAO,CAAC,IAAI;gBAAE,MAAM,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;YAC7C,IAAI,OAAO,CAAC,OAAO;gBAAE,MAAM,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;YACtD,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,UAAU,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;YACxB,gBAAgB,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,IAAI,OAAO,CAAC,MAAM,EAAE;YAC/E,gBAAgB,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC,MAAM,IAAI,OAAO,CAAC,MAAM,EAAE;YACxF,YAAY,EAAE,cAAc,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;SACrF,CAAC;QACF,IAAI,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YAC7E,IAAI,EAAE,CAAC,CAAC,EAAE;YACV,MAAM,EAAE,CAAC,CAAC,IAAI;YACd,SAAS,EAAE,CAAC,CAAC,OAAO;YACpB,cAAc,EAAE,CAAC,CAAC,YAAY;YAC9B,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI;YACnC,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI;YACnC,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK;YACvD,YAAY,EAAE,CAAC,CAAC,SAAS,IAAI,KAAK;SACnC,CAAC,CAAC;KACJ,CAAC,CAAC,CAAC;AACR,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Command } from 'commander';\nimport { runListEntity } from './entity-list.js';\nimport { formatFileSize } from '../config/cli.constants.js';\nimport { type Plugin } from '../types/index.js';\nimport { withSslOptions } from '../utils/command-utils.js';\nimport { type CommonFilterParams } from '../utils/list-command-utils.js';\nimport { printWarning } from '../utils/output-utils.js';\n\n/**\n * Query parameters for the plugin list API endpoint.\n * Combines common filters (pagination, sort) with plugin-specific filters.\n */\ninterface PluginFilterParams extends CommonFilterParams {\n  // Plugin-specific filters\n  name?: string;\n  version?: string;\n}\n\n/**\n * Registers the `list-plugins` command with the CLI program.\n *\n * Queries plugins with filters for name, version, image tag,\n * active status, plus pagination and sorting.\n *\n * @param program - The root Commander program instance to attach the command to.\n *\n * @example\n * ```bash\n * cli plugin list\n * cli plugin list --name auth-plugin --is-active true\n * cli plugin list --version \"^1.0.0\"\n * cli plugin list --limit 50 --offset 100 --sort \"name:asc\"\n * cli plugin list --format json --output plugins.json\n * ```\n */\nexport function listPlugins(program: Command): void {\n  withSslOptions(program\n    .command('list')\n    .description('Query plugins with comprehensive filters')\n\n    // Common filter options\n    .option('--id <id>', 'Filter by plugin ID (can specify multiple with commas)')\n    .option('--is-active <boolean>', 'Filter by active status (true/false)')\n    .option('--limit <number>', 'Maximum number of results (1-1000)', (v) => parseInt(v, 10), 50)\n    .option('--offset <number>', 'Number of results to skip', (v) => parseInt(v, 10), 0)\n    .option('--sort <sort>', 'Sort format: field:direction (e.g., name:asc, createdAt:desc)')\n\n    // Plugin-specific filter options\n    .option('--name <name>', 'Filter by exact plugin name')\n    .option('--version <version>', 'Filter by version (supports semver, e.g., \"^1.0.0\")')\n\n    // Output options\n    .option('-f, --format <format>', 'Output format (json, yaml, table, csv)', 'table')\n    .option('-o, --output <file>', 'Save output to file')\n    .option('--show-metadata', 'Include full metadata in output (json/yaml only)', false))\n\n    .action((options) => runListEntity<Plugin, PluginFilterParams>(program, options, {\n      labelPlural: 'Plugins',\n      responseKey: 'plugins',\n      listUrl: (config) => config.api.pluginListUrl,\n      commandName: 'list-plugins',\n      buildFilters: (options, base) => {\n        const filters: PluginFilterParams = { ...base };\n        if (options.name) filters.name = options.name as string;\n        if (options.version) {\n          // Validate semver format\n          const versionPattern = /^(\\^|~)?(\\d+)\\.(\\d+)\\.(\\d+)(-[a-zA-Z0-9.-]+)?(\\+[a-zA-Z0-9.-]+)?$/;\n          if (!versionPattern.test(options.version as string)) {\n            printWarning(`Version \"${options.version}\" may not be valid semver format`);\n          }\n          filters.version = options.version as string;\n        }\n        return filters;\n      },\n      activeFilters: (filters) => {\n        const active: Record<string, unknown> = {};\n        if (filters.id) active.ID = filters.id;\n        if (filters.isActive !== undefined) active['Is Active'] = filters.isActive;\n        if (filters.name) active.Name = filters.name;\n        if (filters.version) active.Version = filters.version;\n        return active;\n      },\n      statistics: (plugins) => ({\n        'Active Plugins': `${plugins.filter(p => p.isActive).length}/${plugins.length}`,\n        'Public Plugins': `${plugins.filter(p => p.isPublic === true).length}/${plugins.length}`,\n        'Total Size': formatFileSize(plugins.reduce((sum, p) => sum + (p.fileSize || 0), 0)),\n      }),\n      rows: (plugins, options) => options.showMetadata ? plugins : plugins.map(p => ({\n        'ID': p.id,\n        'Name': p.name,\n        'Version': p.version,\n        'Organization': p.organization,\n        'Active': p.isActive ? 'Yes' : 'No',\n        'Public': p.isPublic ? 'Yes' : 'No',\n        'Size': p.fileSize ? formatFileSize(p.fileSize) : 'N/A',\n        'Created At': p.createdAt || 'N/A',\n      })),\n    }));\n}\n"]}