bailian-cli-runtime 0.0.0-beta-46d8474-20260626

package/dist/index.d.mts

@@ -0,0 +1,563 @@
+import { Command, Command as Command$1, Config, GlobalFlags, OptionDef, OptionDef as OptionDef$1, OutputFormat, ResolvedCredential } from "bailian-cli-core";
+
+//#region src/create-cli.d.ts
+/** Per-product identity injected by each CLI entrypoint (bl / rag / …). */
+interface CliOptions {
+  /** Binary name shown in help/usage/version output (e.g. "bl", "rag"). */
+  binName: string;
+  /** Product version for `--version` output, telemetry and update checks. */
+  version: string;
+  /** Telemetry client name (e.g. "bailian-cli", "rag-cli"). Defaults to `binName`. */
+  clientName?: string;
+  /** npm package name for self-update (e.g. "bailian-cli", "bailian-cli-rag"). */
+  npmPackage: string;
+}
+interface Cli {
+  run(argv?: string[]): Promise<void>;
+}
+/**
+ * Build a CLI from an injected command set. The runtime is agnostic to *which*
+ * commands exist — each product (bailian-cli, rag-cli, …) passes its own map and
+ * identity. No module-level singleton: the registry is scoped to this instance.
+ */
+declare function createCli(commands: Record<string, Command$1>, opts: CliOptions): Cli;
+//#endregion
+//#region src/registry.d.ts
+declare class CommandRegistry {
+  private root;
+  /** Binary name shown in usage/help/error strings (e.g. "bl", "rag"). */
+  private readonly cliName;
+  constructor(commands: Record<string, Command$1>, cliName: string);
+  private register;
+  getAllCommands(): Command$1[];
+  /** First registered command path, for the "Getting Help" example (e.g. "knowledge retrieve"). */
+  private helpExample;
+  isGroupPath(commandPath: string[]): boolean;
+  resolve(commandPath: string[]): {
+    command: Command$1;
+    extra: string[];
+  };
+  private buildResourceLines;
+  private buildGlobalFlagLines;
+  private bold;
+  private accent;
+  private dim;
+  printHelp(commandPath: string[], out?: NodeJS.WriteStream): void;
+  private printPipelineQuickStart;
+  private printRootHelp;
+  private printCommandHelp;
+  private printChildren;
+}
+//#endregion
+//#region src/args.d.ts
+/**
+ * Quick scan: collect positional (non-dash) args to determine the command path.
+ * Skips global flags and their values so that e.g. `--output json text chat`
+ * correctly produces ['text', 'chat'] instead of ['json', 'text', 'chat'].
+ */
+declare function scanCommandPath(argv: string[], globalOptions?: OptionDef$1[]): string[];
+/**
+ * Full flag parse. Types are derived entirely from the provided OptionDef schema:
+ *   - boolean: no <value> placeholder in flag string (or type: 'boolean')
+ *   - number:  type: 'number'
+ *   - array:   type: 'array'  (repeatable via multiple --flag occurrences)
+ *   - default: string
+ */
+declare function parseFlags(argv: string[], options: OptionDef$1[]): GlobalFlags;
+//#endregion
+//#region src/proxy.d.ts
+declare function setupProxyFromEnv(): void;
+//#endregion
+//#region src/error-handler.d.ts
+declare function handleError(err: unknown, cliName: string): never;
+//#endregion
+//#region src/version.d.ts
+declare const CLI_VERSION: string;
+//#endregion
+//#region src/urls.d.ts
+/**
+ * User-facing Aliyun Bailian / Model Studio console URLs.
+ *
+ * Single source of truth for all `bailian.console.aliyun.com/*` references
+ * across cli source. Currently pinned to cn-beijing — expand to a region map
+ * if/when overseas console support is added.
+ */
+/** Root entry — generic console landing, region picker. */
+declare const BAILIAN_CONSOLE_ROOT = "https://bailian.console.aliyun.com";
+/** Region-pinned console base. Add a region map if/when overseas is supported. */
+declare const BAILIAN_CONSOLE = "https://bailian.console.aliyun.com/cn-beijing";
+/** Direct deep link to API key management page. */
+declare const API_KEY_PAGE = "https://bailian.console.aliyun.com/cn-beijing/?tab=app#/api-key";
+//#endregion
+//#region src/output/output.d.ts
+/**
+ * Emit the primary result of a command.
+ *
+ * Design principle:
+ *   stdout  → structured data only (JSON when piped, text when TTY)
+ *   stderr  → human info (progress, logs, tips) — handled elsewhere
+ *
+ * This ensures `bl cmd ... | jq .` always receives clean JSON,
+ * while interactive users see human-readable text.
+ */
+declare function emitResult(data: unknown, format: OutputFormat): void;
+/**
+ * Emit a bare value (file path, plain text) to stdout.
+ * Used in --quiet mode or when the result is a single scalar.
+ */
+declare function emitBare(value: string): void;
+//#endregion
+//#region src/output/prompt.d.ts
+/**
+ * Build a command-usage string for the running command: `<binName> <path> <args>`.
+ * Both the product binary name and the command path come from the runtime, so
+ * callers never hardcode "bl" or their own path — the same code renders as
+ * `bl knowledge retrieve …` under bl and `rag retrieve …` under rag.
+ */
+declare function cmdUsage(config: Config, args?: string): string;
+/**
+ * Prompt the user for a text value.
+ * Only call this when isInteractive() is true; otherwise the function returns
+ * undefined immediately so the caller can fail fast.
+ */
+declare function promptText(options: {
+  message: string;
+  defaultValue?: string;
+}): Promise<string | undefined>;
+/**
+ * Like promptText but confirms with y/N before proceeding.
+ */
+declare function promptConfirm(options: {
+  message: string;
+  initialValue?: boolean;
+}): Promise<boolean | undefined>;
+/**
+ * Prompt the user to select one value from a list.
+ * Only call this when isInteractive() is true; otherwise the function returns
+ * undefined immediately so the caller can fail fast.
+ */
+declare function promptSelect(options: {
+  message: string;
+  choices: Array<{
+    value: string;
+    label: string;
+    hint?: string;
+  }>;
+  defaultValue?: string;
+}): Promise<string | undefined>;
+/**
+ * Fail fast with a user-friendly error when a required option is missing
+ * in non-interactive (agent / CI) mode.
+ */
+declare function failIfMissing(flagName: string, context: string): never;
+//#endregion
+//#region src/output/progress.d.ts
+interface Spinner {
+  start(): void;
+  update(text: string): void;
+  stop(finalText?: string): void;
+}
+declare function createSpinner(label: string): Spinner;
+interface ProgressBar {
+  update(current: number): void;
+  finish(): void;
+}
+declare function createProgressBar(total: number, label?: string): ProgressBar;
+//#endregion
+//#region src/output/banner.d.ts
+declare function printWelcomeBanner(cliName: string): void;
+declare function printQuickStart(): void;
+//#endregion
+//#region src/output/status-bar.d.ts
+declare function maybeShowStatusBar(config: Config, token: string, resolved?: ResolvedCredential): void;
+//#endregion
+//#region src/output/cjk-width.d.ts
+declare function displayWidth(text: string): number;
+declare function padEnd(text: string, targetWidth: number): string;
+//#endregion
+//#region src/utils/polling.d.ts
+interface PollOptions {
+  url: string;
+  intervalSec: number;
+  timeoutSec: number;
+  isComplete: (data: unknown) => boolean;
+  isFailed: (data: unknown) => boolean;
+  getStatus?: (data: unknown) => string;
+  getErrorMessage?: (data: unknown) => string | undefined;
+}
+declare function poll<T>(config: Config, opts: PollOptions): Promise<T>;
+//#endregion
+//#region src/utils/download.d.ts
+declare function downloadFile(url: string, destPath: string, opts?: {
+  quiet?: boolean;
+}): Promise<{
+  size: number;
+}>;
+declare function formatBytes(bytes: number): string;
+//#endregion
+//#region src/utils/concurrent.d.ts
+/** Resolve concurrency from flags (defaults to 1). */
+declare function getConcurrency(flags: GlobalFlags): number;
+/**
+ * Run an async task N times concurrently.
+ * Returns all resolved results in order.
+ * If any single task fails, the error propagates (Promise.all semantics).
+ *
+ * @param n       Number of concurrent executions
+ * @param config  CLI config (for logging)
+ * @param task    Async factory to execute
+ * @param label   Optional label for status output (e.g. "requests", "tasks")
+ */
+declare function runConcurrent<T>(n: number, config: Config, task: (index: number) => Promise<T>, label?: string): Promise<T[]>;
+/**
+ * Parallel download helper — downloads multiple URLs concurrently.
+ *
+ * @param items  Array of { url, destPath } pairs
+ * @param downloadFn  Download function (url, destPath, opts) => Promise
+ * @param opts   Options passed to download function
+ * @returns Array of saved file paths in order
+ */
+declare function downloadParallel(items: Array<{
+  url: string;
+  destPath: string;
+}>, downloadFn: (url: string, destPath: string, opts?: {
+  quiet?: boolean;
+}) => Promise<unknown>, opts?: {
+  quiet?: boolean;
+}): Promise<string[]>;
+//#endregion
+//#region src/utils/image-size.d.ts
+/** Resolve `--size` value: accept ratio (3:4) or pixel (W*H) format. */
+declare function resolveImageSize(input: string, useSync: boolean): string;
+declare function resolveImageSize(input: string | undefined, useSync: boolean): string | undefined;
+//#endregion
+//#region src/utils/ensure-key.d.ts
+declare function ensureApiKey(config: Config): Promise<void>;
+//#endregion
+//#region src/utils/command-help.d.ts
+declare function setExecutingCommandPath(path: string[]): void;
+declare function getExecutingCommandPath(): string[];
+declare function registerCommandHelpPrinter(fn: (commandPath: string[], out: NodeJS.WriteStream) => void): void;
+/** Print help for the command currently being executed (must call `setExecutingCommandPath` first). */
+declare function printCurrentCommandHelp(out?: NodeJS.WriteStream): void;
+//#endregion
+//#region src/utils/update-checker.d.ts
+declare const NPM_REGISTRY = "https://registry.npmjs.org";
+/** Default npm package; products override per-call via the `npmPackage` argument. */
+declare const NPM_PACKAGE = "bailian-cli";
+declare function fetchLatestVersion(timeoutMs?: number, npmPackage?: string): Promise<string | null>;
+declare function getPendingUpdateNotification(): string | null;
+declare function checkForUpdate(currentVersion: string, npmPackage?: string): Promise<void>;
+//#endregion
+//#region src/utils/flag-descriptions.d.ts
+/** Shared --foo <bool> help text; keep wording consistent with actual CLI/request behavior. */
+declare const BOOL_FLAG_WATERMARK = "Enable watermark (true/false). Omit flag to use CLI default (true).";
+/** CLI sends prompt_extend=true when flag omitted (qwen-image edit, etc.). */
+declare const BOOL_FLAG_PROMPT_EXTEND_CLI_TRUE = "Enable prompt extend (true/false). Omit flag to use CLI default (true).";
+/** Sync qwen-image defaults on; async models omit the field unless flag is set. */
+declare const BOOL_FLAG_PROMPT_EXTEND_IMAGE_GENERATE = "Enable prompt extend (true/false). Omit flag: true for qwen-image sync; parameter omitted on async models (API default).";
+/** CLI omits prompt_extend in the request when flag is unset (video commands). */
+declare const BOOL_FLAG_PROMPT_EXTEND_API_DEFAULT = "Enable prompt extend (true/false). Omit flag to omit the parameter (DashScope default).";
+//#endregion
+//#region src/pipeline/types.d.ts
+declare const WORKFLOW_VERSION = "workflow/v1";
+interface StepArtifact {
+  id?: string;
+  path?: string;
+  url?: string;
+  mediaType?: string;
+  taskId?: string;
+  kind?: string;
+  expiresAt?: string;
+  metadata?: Record<string, unknown>;
+}
+interface StepWarning {
+  code: string;
+  message: string;
+  details?: Record<string, unknown>;
+}
+interface StepResult {
+  data?: unknown;
+  artifacts?: StepArtifact[];
+  warnings?: StepWarning[];
+  metadata?: Record<string, unknown>;
+}
+interface StructuredStepErrorShape {
+  code: string;
+  message: string;
+  step?: string;
+  details?: Record<string, unknown>;
+}
+type JsonSchemaPrimitiveType = "string" | "number" | "integer" | "boolean" | "array" | "object" | "null";
+interface JsonSchema {
+  type?: JsonSchemaPrimitiveType | JsonSchemaPrimitiveType[];
+  properties?: Record<string, JsonSchema>;
+  items?: JsonSchema;
+  required?: string[];
+  enum?: unknown[];
+  default?: unknown;
+  description?: string;
+  format?: string;
+  additionalProperties?: boolean | JsonSchema;
+}
+type PipelineInputExpression = unknown | {
+  $input: string;
+} | {
+  $from: string;
+  path?: string;
+} | {
+  $env: string;
+} | {
+  $secret: string;
+} | {
+  $concat: PipelineInputExpression[];
+} | {
+  $coalesce: PipelineInputExpression[];
+} | {
+  $js: string;
+  args?: Record<string, PipelineInputExpression>;
+};
+type PipelineConditionExpression = boolean | PipelineInputExpression | {
+  $exists: PipelineInputExpression;
+} | {
+  $eq: [PipelineInputExpression, PipelineInputExpression];
+} | {
+  $ne: [PipelineInputExpression, PipelineInputExpression];
+} | {
+  $gt: [PipelineInputExpression, PipelineInputExpression];
+} | {
+  $gte: [PipelineInputExpression, PipelineInputExpression];
+} | {
+  $lt: [PipelineInputExpression, PipelineInputExpression];
+} | {
+  $lte: [PipelineInputExpression, PipelineInputExpression];
+} | {
+  $in: [PipelineInputExpression, PipelineInputExpression];
+} | {
+  $contains: [PipelineInputExpression, PipelineInputExpression];
+} | {
+  $and: PipelineConditionExpression[];
+} | {
+  $or: PipelineConditionExpression[];
+} | {
+  $not: PipelineConditionExpression;
+};
+interface PipelineRetryPolicy {
+  maxAttempts?: number;
+  backoff?: "none" | "linear" | "exponential";
+}
+interface PipelineBinding {
+  from?: "env";
+  name: string;
+  required?: boolean;
+  default?: unknown;
+}
+interface PipelineStep {
+  id: string;
+  type: string;
+  input: Record<string, PipelineInputExpression>;
+  dependsOn?: string[];
+  when?: PipelineConditionExpression;
+  retry?: PipelineRetryPolicy;
+  timeout?: string | number;
+}
+interface PipelineDefinition {
+  version: typeof WORKFLOW_VERSION;
+  inputs?: JsonSchema;
+  env?: Record<string, string | PipelineBinding>;
+  secrets?: Record<string, string | PipelineBinding>;
+  steps: PipelineStep[];
+}
+interface PipelineStepReport {
+  id: string;
+  type: string;
+  status: "planned" | "succeeded" | "failed" | "skipped";
+  dependencies?: string[];
+  input?: Record<string, unknown>;
+  output?: StepResult;
+  error?: StructuredStepErrorShape;
+  startedAt?: string;
+  finishedAt?: string;
+  attempts?: number;
+  skipReason?: string;
+  condition?: "pending" | "true" | "false";
+}
+interface PipelineExecutionReport {
+  status: "planned" | "succeeded" | "failed";
+  version: typeof WORKFLOW_VERSION;
+  steps: PipelineStepReport[];
+  artifacts: StepArtifact[];
+}
+interface PipelineEventStep {
+  id: string;
+  type: string;
+  dependencies?: string[];
+  index?: number;
+  total?: number;
+}
+interface PipelineEventTiming {
+  startedAt?: string;
+  finishedAt?: string;
+  durationMs?: number;
+}
+interface PipelineEventInputSummary {
+  keys: string[];
+  redactedKeys?: string[];
+}
+interface PipelineEventOutputSummary {
+  dataType?: string;
+  artifactCount: number;
+  warningCount: number;
+  metadata?: Record<string, unknown>;
+}
+type PipelineLifecycleEvent = {
+  type: "pipeline.started";
+  timestamp: string;
+  status: "running" | "planned";
+  stepCount: number;
+  dryRun: boolean;
+} | {
+  type: "step.input.resolved";
+  timestamp: string;
+  status: "running" | "planned";
+  step: PipelineEventStep;
+  input: PipelineEventInputSummary;
+} | {
+  type: "step.planned";
+  timestamp: string;
+  status: "planned";
+  step: PipelineEventStep;
+  input: PipelineEventInputSummary;
+  condition?: "pending";
+} | {
+  type: "step.started";
+  timestamp: string;
+  status: "running";
+  step: PipelineEventStep;
+  timing: PipelineEventTiming;
+  attempt: number;
+} | {
+  type: "step.retrying";
+  timestamp: string;
+  status: "running";
+  step: PipelineEventStep;
+  attempt: number;
+  nextAttempt: number;
+  error: StructuredStepErrorShape;
+} | {
+  type: "artifact.created";
+  timestamp: string;
+  status: "running";
+  step: PipelineEventStep;
+  artifact: StepArtifact;
+} | {
+  type: "step.succeeded";
+  timestamp: string;
+  status: "running";
+  step: PipelineEventStep;
+  timing: PipelineEventTiming;
+  output: PipelineEventOutputSummary;
+  attempt: number;
+  warnings?: StepWarning[];
+} | {
+  type: "step.skipped";
+  timestamp: string;
+  status: "running" | "planned";
+  step: PipelineEventStep;
+  reason: string;
+} | {
+  type: "step.failed";
+  timestamp: string;
+  status: "failed";
+  step: PipelineEventStep;
+  timing: PipelineEventTiming;
+  attempt: number;
+  error: StructuredStepErrorShape;
+} | {
+  type: "pipeline.planned";
+  timestamp: string;
+  status: "planned";
+  stepCount: number;
+  artifactCount: number;
+} | {
+  type: "pipeline.succeeded";
+  timestamp: string;
+  status: "succeeded";
+  stepCount: number;
+  artifactCount: number;
+} | {
+  type: "step.polling";
+  timestamp: string;
+  status: "running";
+  step: PipelineEventStep;
+  taskId: string;
+  taskStatus: string;
+  elapsedMs: number;
+  pollAttempt: number;
+} | {
+  type: "pipeline.failed";
+  timestamp: string;
+  status: "failed";
+  stepCount: number;
+  artifactCount: number;
+  failedStep: PipelineEventStep;
+  error: StructuredStepErrorShape;
+};
+type PipelineEventHandler = (event: PipelineLifecycleEvent) => void | Promise<void>;
+interface ExecutePipelineOptions {
+  onEvent?: PipelineEventHandler;
+  concurrency?: number;
+  retryDelayBaseMs?: number;
+  sleep?: (ms: number) => Promise<void>;
+  basePath?: string;
+  dryRun?: boolean;
+  signal?: AbortSignal;
+  timeoutSeconds?: number;
+  blRequestTimeoutSeconds?: number;
+  stepDispatcher?: StepDispatcher;
+}
+interface StepOutputPath {
+  path: string;
+  description: string;
+}
+interface StepOutputSchema {
+  description?: string;
+  paths: StepOutputPath[];
+}
+type StepHandler = (input: Record<string, unknown>, ctx: StepContext) => Promise<StepResult> | StepResult;
+interface StepContext {
+  dryRun: boolean;
+  signal?: AbortSignal;
+  timeoutSeconds?: number;
+  blRequestTimeoutSeconds?: number;
+  emitEvent?: (event: Record<string, unknown>) => void | Promise<void>;
+  blConfig?: unknown;
+}
+//#endregion
+//#region src/pipeline/dispatcher.d.ts
+declare class StepDispatcher {
+  private readonly handlers;
+  private readonly outputSchemas;
+  registerStep(id: string, handler: StepHandler, outputSchema?: StepOutputSchema): void;
+  executeStep(id: string, input: Record<string, unknown>, ctx: StepContext): Promise<StepResult> | StepResult;
+  hasStep(id: string): boolean;
+  listSteps(): string[];
+  getOutputSchema(id: string): StepOutputSchema | undefined;
+}
+//#endregion
+//#region src/pipeline/init.d.ts
+declare function initPipelineSteps(dispatcher?: StepDispatcher): StepDispatcher;
+//#endregion
+//#region src/pipeline/validation.d.ts
+declare function collectPipelineIssues(pipeline: PipelineDefinition, dispatcher?: StepDispatcher): string[];
+/**
+ * Collect non-blocking hints about potentially invalid $from paths.
+ * These do not prevent execution but help workflow authors catch typos.
+ */
+declare function collectPipelineHints(pipeline: PipelineDefinition, dispatcher?: StepDispatcher): string[];
+//#endregion
+//#region src/pipeline/executor.d.ts
+declare function executePipeline(pipeline: PipelineDefinition, runtimeInput?: Record<string, unknown>, options?: ExecutePipelineOptions): Promise<PipelineExecutionReport>;
+declare function streamPipelineEvents(pipeline: PipelineDefinition, runtimeInput?: Record<string, unknown>, options?: Pick<ExecutePipelineOptions, "concurrency" | "basePath" | "dryRun" | "signal" | "timeoutSeconds" | "blRequestTimeoutSeconds" | "stepDispatcher">): AsyncGenerator<PipelineLifecycleEvent>;
+//#endregion
+export { API_KEY_PAGE, BAILIAN_CONSOLE, BAILIAN_CONSOLE_ROOT, BOOL_FLAG_PROMPT_EXTEND_API_DEFAULT, BOOL_FLAG_PROMPT_EXTEND_CLI_TRUE, BOOL_FLAG_PROMPT_EXTEND_IMAGE_GENERATE, BOOL_FLAG_WATERMARK, CLI_VERSION, type Cli, type CliOptions, type Command, CommandRegistry, NPM_PACKAGE, NPM_REGISTRY, type OptionDef, type PipelineDefinition, type PipelineLifecycleEvent, checkForUpdate, cmdUsage, collectPipelineHints, collectPipelineIssues, createCli, createProgressBar, createSpinner, displayWidth, downloadFile, downloadParallel, emitBare, emitResult, ensureApiKey, executePipeline, failIfMissing, fetchLatestVersion, formatBytes, getConcurrency, getExecutingCommandPath, getPendingUpdateNotification, handleError, initPipelineSteps, maybeShowStatusBar, padEnd, parseFlags, poll, printCurrentCommandHelp, printQuickStart, printWelcomeBanner, promptConfirm, promptSelect, promptText, registerCommandHelpPrinter, resolveImageSize, runConcurrent, scanCommandPath, setExecutingCommandPath, setupProxyFromEnv, streamPipelineEvents };