@convilyn/sdk 0.2.0

package/dist/cli.js

@@ -0,0 +1,1019 @@
+#!/usr/bin/env node
+import { VERSION, AuthError, APIError, guessContentType, Convilyn, JobFailedError, JobTimeoutError, HttpClient, resolveAuth, isGoalEventTerminal, WebSocketError, DEFAULT_BASE_URL, GoalJobFailedError, GoalJobTimeoutError, PlanRequiredError, QuotaExceededError } from './chunk-UJHZKIP6.js';
+import { Command, Option } from 'commander';
+import { statSync, readFileSync, writeFileSync } from 'fs';
+import { basename, parse, join } from 'path';
+
+// src/cli/context.ts
+var ENV_API_KEY = "CONVILYN_API_KEY";
+var ENV_BASE_URL = "CONVILYN_BASE_URL";
+var ENV_WS_URL = "CONVILYN_WS_URL";
+function buildClient(env) {
+  return new Convilyn({
+    apiKey: env[ENV_API_KEY],
+    baseUrl: env[ENV_BASE_URL],
+    wsUrl: env[ENV_WS_URL]
+  });
+}
+function buildHttpClient(env) {
+  return new HttpClient({
+    auth: resolveAuth(env[ENV_API_KEY], { env }),
+    baseUrl: env[ENV_BASE_URL]
+  });
+}
+function processWriters() {
+  return {
+    stdout: (text) => process.stdout.write(text),
+    stderr: (text) => process.stderr.write(text)
+  };
+}
+function printError(writers, env, prefix, error) {
+  const detail = env.CONVILYN_DEBUG ? JSON.stringify(error instanceof Error ? { name: error.name, message: error.message } : error) : error instanceof Error ? error.message : String(error);
+  writers.stderr(`${prefix}: ${detail}
+`);
+}
+
+// src/cli/exitCodes.ts
+var EXIT_OK = 0;
+var EXIT_USAGE = 1;
+var EXIT_API_ERROR = 2;
+var EXIT_JOB_FAILED = 3;
+
+// src/cli/output.ts
+var GLYPHS = {
+  upload: "\u2191",
+  create: "\u25B6",
+  wait: "\u2026",
+  download: "\u2193",
+  ok: "\u2713",
+  warn: "!",
+  error: "\u2717"
+};
+function sortedJson(value, indent) {
+  return JSON.stringify(
+    value,
+    (_key, val) => {
+      if (val && typeof val === "object" && !Array.isArray(val)) {
+        const record = val;
+        return Object.fromEntries(
+          Object.keys(record).sort().map((key) => [key, record[key]])
+        );
+      }
+      return val;
+    },
+    indent
+  );
+}
+function humaniseSize(sizeBytes) {
+  if (sizeBytes == null || sizeBytes === 0) {
+    return "0 B";
+  }
+  let remaining = sizeBytes;
+  for (const unit of ["B", "KiB", "MiB", "GiB"]) {
+    if (remaining < 1024) {
+      return unit === "B" ? `${Math.round(remaining)} ${unit}` : `${remaining.toFixed(1)} ${unit}`;
+    }
+    remaining /= 1024;
+  }
+  return `${remaining.toFixed(1)} TiB`;
+}
+function formatEvent(kind, fields) {
+  if (kind === "upload" && "filename" in fields) {
+    const size = fields.size_bytes;
+    const sizeStr = size ? ` (${humaniseSize(size)})` : "";
+    return `Uploading ${String(fields.filename)}${sizeStr}`;
+  }
+  if (kind === "create" && "job_id" in fields) {
+    return `Created job ${String(fields.job_id)}`;
+  }
+  if (kind === "wait") {
+    const progress = fields.progress;
+    return progress != null ? `Converting\u2026 ${String(progress)}%` : "Waiting for job to finish";
+  }
+  if (kind === "download" && "path" in fields) {
+    return `Downloaded ${String(fields.path)}`;
+  }
+  const pairs = Object.entries(fields).map(([key, value]) => `${key}=${String(value)}`).join(", ");
+  return `${kind}: ${pairs}`;
+}
+function formatSummary(payload) {
+  const outputPath = payload.output_path;
+  const outputSize = payload.output_size_bytes;
+  if (outputPath && outputSize != null) {
+    return `\u2713 ${outputPath} (${humaniseSize(outputSize)})`;
+  }
+  if (outputPath) {
+    return `\u2713 ${outputPath}`;
+  }
+  const status = payload.status;
+  if (status) {
+    return `\u2713 status=${status}`;
+  }
+  return "\u2713 done";
+}
+var HumanRenderer = class {
+  #writers;
+  constructor(writers) {
+    this.#writers = writers;
+  }
+  event(kind, fields = {}) {
+    const glyph = GLYPHS[kind] ?? "\u2022";
+    const message = fields.message ?? formatEvent(kind, fields);
+    this.#writers.stderr(`${glyph} ${message}
+`);
+  }
+  final(payload) {
+    const summary = payload.summary ?? formatSummary(payload);
+    this.#writers.stdout(`${summary}
+`);
+  }
+};
+var JsonRenderer = class {
+  #writers;
+  constructor(writers) {
+    this.#writers = writers;
+  }
+  event(_kind, _fields) {
+  }
+  final(payload) {
+    this.#writers.stdout(`${sortedJson(payload)}
+`);
+  }
+};
+function makeRenderer(jsonOutput, writers) {
+  return jsonOutput ? new JsonRenderer(writers) : new HumanRenderer(writers);
+}
+
+// src/cli/account.ts
+async function runAccountPlan(options, deps2) {
+  const renderer = makeRenderer(Boolean(options.json), deps2.writers);
+  return runAccountAction(deps2, renderer, async (client) => {
+    const plan = await client.account.getPlan();
+    return { command: "account.plan", tier: plan.tier, summary: `tier=${plan.tier}` };
+  });
+}
+async function runAccountQuota(options, deps2) {
+  const renderer = makeRenderer(Boolean(options.json), deps2.writers);
+  return runAccountAction(deps2, renderer, async (client) => {
+    const estimate = await client.account.getQuota({
+      tools: options.tools ?? [],
+      maxIterations: options.maxIter
+    });
+    const quota = estimate.quotaCheck;
+    return {
+      command: "account.quota",
+      tier: quota.tier,
+      state: quota.state,
+      estimated_credits: estimate.estimatedCredits,
+      estimated_usd: estimate.estimatedUsd,
+      threshold_credits: quota.thresholdCredits,
+      upgrade_url: quota.upgradeUrl,
+      summary: `tier=${quota.tier} state=${quota.state} cost=${estimate.estimatedCredits}/${quota.thresholdCredits} credits`
+    };
+  });
+}
+async function runAccountAction(deps2, renderer, action) {
+  let client;
+  try {
+    client = (deps2.clientFactory ?? (() => buildClient(deps2.env)))();
+  } catch (error) {
+    printError(deps2.writers, deps2.env, "Authentication failed", error);
+    return EXIT_USAGE;
+  }
+  try {
+    const payload = await action(client);
+    renderer.event(String(payload.command), { summary: payload.summary });
+    renderer.final(payload);
+    return EXIT_OK;
+  } catch (error) {
+    if (error instanceof PlanRequiredError) {
+      deps2.writers.stderr(
+        `Plan required: ${error.message} (upgrade: ${error.upgradeUrl ?? "see /pricing"})
+`
+      );
+      return EXIT_USAGE;
+    }
+    if (error instanceof QuotaExceededError) {
+      deps2.writers.stderr(
+        `Quota exceeded: ${error.message} (needs ${error.costCredits ?? "?"} credits, balance ${error.balanceCredits ?? "?"})
+`
+      );
+      return EXIT_USAGE;
+    }
+    if (error instanceof AuthError) {
+      deps2.writers.stderr(`Authentication failed: ${error.message}
+`);
+      return EXIT_USAGE;
+    }
+    if (error instanceof APIError) {
+      deps2.writers.stderr(`API error: ${error.message}
+`);
+      return EXIT_API_ERROR;
+    }
+    throw error;
+  } finally {
+    try {
+      await client.close();
+    } catch {
+    }
+  }
+}
+function parseHeaders(items) {
+  const result = {};
+  for (const item of items) {
+    if (!item.includes(":")) {
+      throw new Error(`Bad --header value ${JSON.stringify(item)}; expected "Name: Value"`);
+    }
+    const index = item.indexOf(":");
+    result[item.slice(0, index).trim()] = item.slice(index + 1).trim();
+  }
+  return result;
+}
+function parseQuery(items) {
+  if (items.length === 0) {
+    return void 0;
+  }
+  const result = {};
+  for (const item of items) {
+    if (!item.includes("=")) {
+      throw new Error(`Bad --query value ${JSON.stringify(item)}; expected NAME=VALUE`);
+    }
+    const index = item.indexOf("=");
+    result[item.slice(0, index)] = item.slice(index + 1);
+  }
+  return result;
+}
+async function resolveBody(dataInline, inputFile, readStdin) {
+  let raw;
+  if (dataInline != null) {
+    raw = dataInline;
+  } else if (inputFile != null) {
+    raw = inputFile === "-" ? await readStdin() : readFileSync(inputFile, "utf8");
+  }
+  if (raw == null) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `Body is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  return new TextEncoder().encode(JSON.stringify(parsed));
+}
+async function formatBody(response, jsonOutput) {
+  const raw = await response.text();
+  if (!raw) {
+    return "";
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+  return jsonOutput ? sortedJson(parsed) : sortedJson(parsed, 2);
+}
+async function renderResponse(response, options, writers) {
+  const bodyText = await formatBody(response, Boolean(options.json));
+  if (options.output != null) {
+    writeFileSync(options.output, bodyText, "utf8");
+    return;
+  }
+  if (options.include) {
+    writers.stdout(`HTTP/1.1 ${response.status} ${response.statusText}
+`);
+    response.headers.forEach((value, name) => writers.stdout(`${name}: ${value}
+`));
+    writers.stdout("\n");
+  }
+  writers.stdout(`${bodyText}
+`);
+}
+function defaultReadStdin() {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    process.stdin.on("error", reject);
+  });
+}
+async function runApi(method, path, options, deps2) {
+  if (options.data != null && options.input != null) {
+    deps2.writers.stderr("--data and --input are mutually exclusive\n");
+    return EXIT_USAGE;
+  }
+  let body;
+  let headers;
+  let params;
+  try {
+    body = await resolveBody(options.data, options.input, deps2.readStdin ?? defaultReadStdin);
+    headers = parseHeaders(options.header ?? []);
+    params = parseQuery(options.query ?? []);
+  } catch (error) {
+    deps2.writers.stderr(`${error instanceof Error ? error.message : String(error)}
+`);
+    return EXIT_USAGE;
+  }
+  let httpClient;
+  try {
+    httpClient = (deps2.httpFactory ?? (() => buildHttpClient(deps2.env)))();
+  } catch (error) {
+    if (error instanceof AuthError) {
+      deps2.writers.stderr(`Authentication failed: ${error.message}
+`);
+      return EXIT_USAGE;
+    }
+    throw error;
+  }
+  try {
+    let response;
+    try {
+      response = await httpClient.rawRequest(method.toUpperCase(), path, {
+        headers: Object.keys(headers).length > 0 ? headers : void 0,
+        params,
+        content: body
+      });
+    } catch (error) {
+      if (error instanceof APIError) {
+        deps2.writers.stderr(`Transport error: ${error.message}
+`);
+        return EXIT_API_ERROR;
+      }
+      throw error;
+    }
+    await renderResponse(response, options, deps2.writers);
+    return response.status >= 400 ? EXIT_API_ERROR : EXIT_OK;
+  } finally {
+    try {
+      await httpClient.close();
+    } catch {
+    }
+  }
+}
+function resolveOutputPath(inputFile, explicit, targetFormat) {
+  if (explicit) {
+    return explicit;
+  }
+  const parsed = parse(inputFile);
+  return join(parsed.dir, `${parsed.name}.${targetFormat}`);
+}
+function guessSourceFormat(filename) {
+  const dot = filename.lastIndexOf(".");
+  if (dot < 0) {
+    return null;
+  }
+  return filename.slice(dot + 1).toLowerCase() || null;
+}
+async function runConvert(options, deps2) {
+  const renderer = makeRenderer(Boolean(options.json), deps2.writers);
+  const quality = options.quality ?? "standard";
+  const output = resolveOutputPath(options.inputFile, options.output, options.targetFormat);
+  const source = options.sourceFormat ?? guessSourceFormat(basename(options.inputFile)) ?? void 0;
+  if (options.dryRun) {
+    emitDryRun(renderer, options.inputFile, source, options.targetFormat, quality, output);
+    return EXIT_OK;
+  }
+  let client;
+  try {
+    client = (deps2.clientFactory ?? (() => buildClient(deps2.env)))();
+  } catch (error) {
+    printError(deps2.writers, deps2.env, "Authentication failed", error);
+    return EXIT_USAGE;
+  }
+  try {
+    const size = statSync(options.inputFile).size;
+    renderer.event("upload", { filename: basename(options.inputFile), size_bytes: size });
+    const file = await client.files.upload({ path: options.inputFile });
+    renderer.event("create", { message: `Creating conversion \u2192 ${options.targetFormat}` });
+    const job = await client.convert.createAndWait({
+      file,
+      targetFormat: options.targetFormat,
+      sourceFormat: source,
+      quality
+    });
+    renderer.event("wait", { progress: job.progress });
+    renderer.event("download", { path: output });
+    const written = await client.convert.downloadTo(job, { to: output });
+    const outputSize = statSync(written).size;
+    renderer.final({
+      command: "convert",
+      input_file: options.inputFile,
+      file_id: file.fileId,
+      job_id: job.jobId,
+      status: job.status,
+      output_path: written,
+      output_size_bytes: outputSize
+    });
+    return EXIT_OK;
+  } catch (error) {
+    return mapError(error, deps2);
+  } finally {
+    try {
+      await client.close();
+    } catch {
+    }
+  }
+}
+function mapError(error, deps2) {
+  if (error instanceof JobFailedError) {
+    printError(deps2.writers, deps2.env, "Conversion failed", error);
+    return EXIT_JOB_FAILED;
+  }
+  if (error instanceof JobTimeoutError) {
+    printError(deps2.writers, deps2.env, "Polling timed out", error);
+    return EXIT_API_ERROR;
+  }
+  if (error instanceof AuthError) {
+    printError(deps2.writers, deps2.env, "Authentication failed", error);
+    return EXIT_USAGE;
+  }
+  if (error instanceof APIError) {
+    printError(deps2.writers, deps2.env, "API error", error);
+    return EXIT_API_ERROR;
+  }
+  throw error;
+}
+function emitDryRun(renderer, inputFile, source, targetFormat, quality, output) {
+  const size = statSync(inputFile).size;
+  const contentType = guessContentType(basename(inputFile));
+  renderer.event("upload", {
+    message: `[dry-run] Would upload: ${basename(inputFile)} (${size} B, ${contentType})`
+  });
+  renderer.event("create", {
+    message: `[dry-run] Would POST /api/v1/jobs: {processor_type=document_conversion, source_format=${source ?? "null"}, target_format=${targetFormat}, quality=${quality}}`
+  });
+  renderer.event("download", { message: `[dry-run] Would download to: ${output}` });
+  renderer.final({
+    command: "convert",
+    dry_run: true,
+    input_file: inputFile,
+    source_format: source ?? null,
+    target_format: targetFormat,
+    quality,
+    output_path: output,
+    summary: "[dry-run] No API calls made."
+  });
+}
+
+// src/cli/goals.ts
+var EVENT_GLYPHS = {
+  tool_started: "\u25B6",
+  tool_finished: "\u2713",
+  agent_step_started: "\u25B6",
+  agent_step_finished: "\u2713",
+  orchestration_transition: "\u2194",
+  status: "\u2022",
+  progress: "\u2026",
+  completed: "\u2713",
+  failed: "\u2717",
+  slot_needed: "?",
+  keepalive: "\xB7",
+  agent_text: "\u203A",
+  agent_text_done: "\u203A"
+};
+function parseFileIds(raw) {
+  if (raw == null) {
+    return void 0;
+  }
+  const cleaned = raw.split(",").map((token) => token.trim()).filter((token) => token.length > 0);
+  return cleaned.length > 0 ? cleaned : void 0;
+}
+function parseSlotValue(raw) {
+  const stripped = raw.trim();
+  if (!stripped) {
+    throw new Error("--value cannot be empty");
+  }
+  try {
+    return JSON.parse(stripped);
+  } catch {
+    return raw;
+  }
+}
+function parseSlotPairs(pairs) {
+  const slots = {};
+  for (const raw of pairs) {
+    if (!raw.includes("=")) {
+      throw new Error(`--slot expects KEY=VALUE, got ${JSON.stringify(raw)}`);
+    }
+    const index = raw.indexOf("=");
+    const key = raw.slice(0, index).trim();
+    if (!key) {
+      throw new Error("--slot key cannot be empty");
+    }
+    slots[key] = parseSlotValue(raw.slice(index + 1));
+  }
+  return slots;
+}
+function summariseEvent(event) {
+  const data = event.data ?? {};
+  for (const key of ["name", "tool", "role", "message", "status"]) {
+    const value = data[key];
+    if (value) {
+      return ` ${String(value)}`;
+    }
+  }
+  if (event.type === "progress" && "progress" in data) {
+    return ` ${String(data.progress)}%`;
+  }
+  return "";
+}
+function terminalEventExitCode(event) {
+  return event.type === "failed" ? EXIT_JOB_FAILED : EXIT_OK;
+}
+function emitEvent(event, jsonOutput, writers) {
+  if (jsonOutput) {
+    writers.stdout(`${sortedJson(event)}
+`);
+    return;
+  }
+  const glyph = EVENT_GLYPHS[event.type] ?? "\u2022";
+  writers.stderr(`${glyph} ${event.type}${summariseEvent(event)}
+`);
+}
+function jobToPayload(commandName, job) {
+  return {
+    command: `goals.${commandName}`,
+    job_spec_id: job.jobSpecId,
+    status: job.status,
+    progress: job.progress,
+    pending_slots: job.pendingSlots,
+    filled_slots: job.filledSlots,
+    summary: `\u2713 ${commandName} job=${job.jobSpecId} status=${job.status}`
+  };
+}
+async function runGoalsStart(options, deps2) {
+  const renderer = makeRenderer(Boolean(options.json), deps2.writers);
+  const fileIds = parseFileIds(options.files);
+  let slots;
+  try {
+    slots = parseSlotPairs(options.slot ?? []);
+  } catch (error) {
+    deps2.writers.stderr(`${error instanceof Error ? error.message : String(error)}
+`);
+    return EXIT_USAGE;
+  }
+  if (options.dryRun) {
+    const payload = { fileIds: fileIds ?? [] };
+    if (options.workflowId != null) {
+      payload.workflowId = options.workflowId;
+    }
+    if (options.goalText != null) {
+      payload.goalText = options.goalText;
+    }
+    if (Object.keys(slots).length > 0) {
+      payload.slotAnswers = Object.entries(slots).map(([slotId, value]) => ({ slotId, value }));
+    }
+    renderer.event("create", {
+      message: `[dry-run] Would POST /api/v1/jobs/goal: ${sortedJson(payload)}`
+    });
+    renderer.final({
+      command: "goals.start",
+      dry_run: true,
+      payload,
+      summary: "[dry-run] No API calls made."
+    });
+    return EXIT_OK;
+  }
+  return runGoalAction(
+    deps2,
+    renderer,
+    "start",
+    (client) => client.goals.start({
+      workflowId: options.workflowId,
+      goalText: options.goalText,
+      files: fileIds,
+      slots: Object.keys(slots).length > 0 ? slots : void 0
+    })
+  );
+}
+async function runGoalsStatus(jobSpecId, options, deps2) {
+  const renderer = makeRenderer(Boolean(options.json), deps2.writers);
+  return runGoalAction(
+    deps2,
+    renderer,
+    "status",
+    (client) => options.watch ? client.goals.wait(jobSpecId, { timeout: options.timeout }) : client.goals.retrieve(jobSpecId)
+  );
+}
+async function runGoalsFillSlot(jobSpecId, options, deps2) {
+  const renderer = makeRenderer(Boolean(options.json), deps2.writers);
+  let value;
+  try {
+    value = parseSlotValue(options.value);
+  } catch (error) {
+    deps2.writers.stderr(`${error instanceof Error ? error.message : String(error)}
+`);
+    return EXIT_USAGE;
+  }
+  return runGoalAction(
+    deps2,
+    renderer,
+    "fill-slot",
+    (client) => client.goals.fillSlot(jobSpecId, {
+      slotId: options.slotId,
+      value,
+      expectedVersion: options.expectedVersion
+    })
+  );
+}
+async function runGoalsConfirm(jobSpecId, options, deps2) {
+  const renderer = makeRenderer(Boolean(options.json), deps2.writers);
+  return runGoalAction(
+    deps2,
+    renderer,
+    "confirm",
+    (client) => client.goals.confirm(jobSpecId, { expectedVersion: options.expectedVersion })
+  );
+}
+async function runGoalsCancel(jobSpecId, options, deps2) {
+  const renderer = makeRenderer(Boolean(options.json), deps2.writers);
+  return runGoalAction(deps2, renderer, "cancel", (client) => client.goals.cancel(jobSpecId));
+}
+async function runGoalsRetry(jobSpecId, options, deps2) {
+  const renderer = makeRenderer(Boolean(options.json), deps2.writers);
+  return runGoalAction(
+    deps2,
+    renderer,
+    "retry",
+    (client) => client.goals.retry(jobSpecId, { rerunMode: options.rerunMode, reason: options.reason })
+  );
+}
+async function runGoalsEvents(jobSpecId, options, deps2) {
+  let client;
+  try {
+    client = (deps2.clientFactory ?? (() => buildClient(deps2.env)))();
+  } catch (error) {
+    if (error instanceof AuthError) {
+      deps2.writers.stderr(`Authentication failed: ${error.message}
+`);
+      return EXIT_USAGE;
+    }
+    throw error;
+  }
+  try {
+    for await (const event of client.goals.events(jobSpecId, { wsUrl: options.wsUrl })) {
+      emitEvent(event, Boolean(options.json), deps2.writers);
+      if (isGoalEventTerminal(event)) {
+        return terminalEventExitCode(event);
+      }
+    }
+    deps2.writers.stderr("Event stream closed without a terminal event\n");
+    return EXIT_API_ERROR;
+  } catch (error) {
+    if (error instanceof WebSocketError) {
+      deps2.writers.stderr(`WebSocket error: ${error.message}
+`);
+      return EXIT_API_ERROR;
+    }
+    if (error instanceof APIError) {
+      deps2.writers.stderr(`API error: ${error.message}
+`);
+      return EXIT_API_ERROR;
+    }
+    if (error instanceof Error && /No WebSocket URL configured/.test(error.message)) {
+      deps2.writers.stderr(`Configuration error: ${error.message}
+`);
+      return EXIT_USAGE;
+    }
+    deps2.writers.stderr(
+      `Unexpected error: ${error instanceof Error ? error.message : String(error)}
+`
+    );
+    return EXIT_API_ERROR;
+  } finally {
+    try {
+      await client.close();
+    } catch {
+    }
+  }
+}
+async function runGoalAction(deps2, renderer, commandName, action) {
+  let client;
+  try {
+    client = (deps2.clientFactory ?? (() => buildClient(deps2.env)))();
+  } catch (error) {
+    printError(deps2.writers, deps2.env, "Authentication failed", error);
+    return EXIT_USAGE;
+  }
+  try {
+    const job = await action(client);
+    renderer.event(commandName, { status: job.status });
+    renderer.final(jobToPayload(commandName, job));
+    return EXIT_OK;
+  } catch (error) {
+    if (error instanceof GoalJobFailedError) {
+      printError(deps2.writers, deps2.env, "Goal job failed", error);
+      return EXIT_JOB_FAILED;
+    }
+    if (error instanceof GoalJobTimeoutError) {
+      printError(deps2.writers, deps2.env, "Polling timed out", error);
+      return EXIT_API_ERROR;
+    }
+    if (error instanceof AuthError) {
+      printError(deps2.writers, deps2.env, "Authentication failed", error);
+      return EXIT_USAGE;
+    }
+    if (error instanceof APIError) {
+      printError(deps2.writers, deps2.env, "API error", error);
+      return EXIT_API_ERROR;
+    }
+    throw error;
+  } finally {
+    try {
+      await client.close();
+    } catch {
+    }
+  }
+}
+
+// src/cli/doctor.ts
+function maskSecret(value) {
+  return value.length <= 10 ? "***" : `${value.slice(0, 6)}\u2026${value.slice(-4)}`;
+}
+function checkNode() {
+  const version = process.versions.node;
+  const major = Number(version.split(".")[0]);
+  if (Number.isFinite(major) && major < 18) {
+    return { name: "Node", status: "FAIL", detail: `need \u2265 18, got ${version}` };
+  }
+  return { name: "Node", status: "OK", detail: version };
+}
+function checkCapability(name, available, options = {}) {
+  if (available) {
+    return { name, status: "OK", detail: "available" };
+  }
+  const detail = `not available in this runtime${options.hint ? ` \u2014 ${options.hint}` : ""}`;
+  return { name, status: options.optional ? "WARN" : "FAIL", detail };
+}
+function checkApiKey(env) {
+  const key = env[ENV_API_KEY];
+  if (!key) {
+    return {
+      name: ENV_API_KEY,
+      status: "FAIL",
+      detail: `not set \u2014 export ${ENV_API_KEY}=ck_\u2026 first`
+    };
+  }
+  return { name: ENV_API_KEY, status: "OK", detail: maskSecret(key) };
+}
+function checkBaseUrl(env) {
+  const url = env[ENV_BASE_URL] || DEFAULT_BASE_URL;
+  const isDefault = url === DEFAULT_BASE_URL;
+  return { name: ENV_BASE_URL, status: "OK", detail: `${url}${isDefault ? " (default)" : ""}` };
+}
+async function checkBackendHealth(deps2) {
+  const base = (deps2.env[ENV_BASE_URL] || DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const url = `${base}/api/v1/health`;
+  const fetchImpl = deps2.fetchImpl ?? ((target) => fetch(target));
+  try {
+    const response = await fetchImpl(url);
+    if (response.status >= 400) {
+      return {
+        name: "Backend health",
+        status: "FAIL",
+        detail: `HTTP ${response.status} ${response.statusText}`
+      };
+    }
+    return {
+      name: "Backend health",
+      status: "OK",
+      detail: `${response.status} ${response.statusText}`
+    };
+  } catch (error) {
+    const detail = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+    return { name: "Backend health", status: "FAIL", detail };
+  }
+}
+async function checkAccountTier(deps2) {
+  try {
+    const client = (deps2.clientFactory ?? (() => buildClient(deps2.env)))();
+    try {
+      const plan = await client.account.getPlan();
+      return { name: "Account tier", status: "OK", detail: `tier=${plan.tier}` };
+    } finally {
+      try {
+        await client.close();
+      } catch {
+      }
+    }
+  } catch (error) {
+    if (error instanceof APIError) {
+      return {
+        name: "Account tier",
+        status: "WARN",
+        detail: `tier query failed: HTTP ${error.statusCode} ${error.code}`
+      };
+    }
+    return {
+      name: "Account tier",
+      status: "WARN",
+      detail: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function collectChecks(ping, deps2) {
+  const checks = [
+    checkNode(),
+    { name: "convilyn SDK", status: "OK", detail: VERSION },
+    checkCapability("fetch", typeof fetch !== "undefined"),
+    // Optional: only goals.events() streaming needs a global WebSocket (Node 22+);
+    // goals.wait() polling covers the same ground on older runtimes.
+    checkCapability("WebSocket", typeof WebSocket !== "undefined", {
+      optional: true,
+      hint: "needed only for goals.events(); goals.wait() polling works without it"
+    }),
+    checkCapability(
+      "crypto.randomUUID",
+      typeof crypto !== "undefined" && typeof crypto.randomUUID === "function"
+    ),
+    checkApiKey(deps2.env),
+    checkBaseUrl(deps2.env)
+  ];
+  if (ping) {
+    checks.push(await checkBackendHealth(deps2));
+    if (deps2.env[ENV_API_KEY]) {
+      checks.push(await checkAccountTier(deps2));
+    }
+  } else {
+    checks.push({
+      name: "Backend health",
+      status: "SKIP",
+      detail: "skipped (re-run with --ping to probe /api/v1/health)"
+    });
+  }
+  return checks;
+}
+function emitChecks(renderer, checks) {
+  for (const check of checks) {
+    renderer.event(check.status === "OK" ? "ok" : "warn", {
+      message: `[${check.status}] ${check.name}: ${check.detail}`
+    });
+  }
+  const failures = checks.filter((check) => check.status === "FAIL");
+  renderer.final({
+    command: "doctor",
+    checks: checks.map((check) => ({
+      name: check.name,
+      status: check.status,
+      detail: check.detail
+    })),
+    summary: failures.length === 0 ? "All checks passed." : `${failures.length} of ${checks.length} checks failed.`
+  });
+}
+async function runDoctor(options, deps2) {
+  const renderer = makeRenderer(Boolean(options.json), deps2.writers);
+  const checks = await collectChecks(Boolean(options.ping), deps2);
+  emitChecks(renderer, checks);
+  const failures = checks.filter((check) => check.status === "FAIL");
+  if (failures.length === 0) {
+    return EXIT_OK;
+  }
+  const backendFailed = failures.some((check) => check.name === "Backend health");
+  return backendFailed ? EXIT_API_ERROR : EXIT_USAGE;
+}
+
+// src/cli/main.ts
+function deps() {
+  return { writers: processWriters(), env: process.env };
+}
+async function finish(code) {
+  process.exitCode = await code;
+}
+function asInt(value) {
+  return value != null ? Number(value) : void 0;
+}
+function buildProgram() {
+  const program = new Command();
+  program.name("convilyn").description("Convert files and run AI workflows from the command line.").version(VERSION, "-v, --version");
+  program.command("convert").description("Convert a local file into a different format.").argument("<input-file>", "Path to the file to convert").requiredOption("--to <format>", "Target format token (e.g. pdf, docx, html)").option("-o, --output <path>", "Output path (defaults to <basename>.<format>)").option("--source-format <format>", "Override source-format auto-detection").option("--quality <quality>", "Conversion quality hint", "standard").option("--json", "Emit a single JSON object on stdout").option("--dry-run", "Show what would happen without making any API calls").action(
+    async (inputFile, opts) => finish(
+      runConvert(
+        {
+          inputFile,
+          targetFormat: opts.to,
+          output: opts.output,
+          sourceFormat: opts.sourceFormat,
+          quality: opts.quality,
+          json: opts.json,
+          dryRun: opts.dryRun
+        },
+        deps()
+      )
+    )
+  );
+  program.command("doctor").description("Show SDK environment + backend connectivity diagnostics.").option("--json", "Emit a single JSON object on stdout").option("--ping", "Probe the backend health endpoint").action(async (opts) => finish(runDoctor({ json: opts.json, ping: opts.ping }, deps())));
+  program.command("api").description("Call any Convilyn API endpoint (gh-style escape hatch).").argument("<method>", `HTTP method`).argument("<path>", "Request path, e.g. /api/v1/jobs/job_xyz").option("--data <json>", "JSON body inline (mutually exclusive with --input)").option("--input <file>", "Read JSON body from FILE ('-' for stdin)").option("--header <header...>", 'Extra header in "Name: Value" form (repeatable)').option("--query <param...>", "Query parameter NAME=VALUE (repeatable)").option("--include", "Print response status + headers + body").option("--json", "Single-line JSON (jq-friendly)").option("-o, --output <file>", "Write response body to FILE").action(
+    async (method, path, opts) => finish(
+      runApi(
+        method,
+        path,
+        {
+          data: opts.data,
+          input: opts.input,
+          header: opts.header,
+          query: opts.query,
+          include: opts.include,
+          json: opts.json,
+          output: opts.output
+        },
+        deps()
+      )
+    )
+  );
+  buildGoalsGroup(program);
+  buildAccountGroup(program);
+  return program;
+}
+function buildGoalsGroup(program) {
+  const goals = program.command("goals").description("Run agentic goal workflows.");
+  goals.command("start").option("--workflow-id <id>", "Workflow spec id (mutually exclusive with --goal-text)").option("--goal-text <text>", "Free-text goal (requires --files)").option("--files <ids>", "Comma-separated file ids").option("--slot <kv...>", "Pre-fill a slot KEY=VALUE (repeatable)").option("--json", "Emit the job as JSON on stdout").option("--dry-run", "Print the payload without hitting the network").action(
+    async (opts) => finish(
+      runGoalsStart(
+        {
+          workflowId: opts.workflowId,
+          goalText: opts.goalText,
+          files: opts.files,
+          slot: opts.slot,
+          json: opts.json,
+          dryRun: opts.dryRun
+        },
+        deps()
+      )
+    )
+  );
+  goals.command("status").argument("<job-spec-id>").option("--watch", "Poll until terminal status or HITL stop").option("--timeout <seconds>", "Watch-mode timeout in seconds", "300").option("--json", "Emit the job as JSON on stdout").action(
+    async (jobSpecId, opts) => finish(
+      runGoalsStatus(
+        jobSpecId,
+        { watch: opts.watch, timeout: asInt(opts.timeout), json: opts.json },
+        deps()
+      )
+    )
+  );
+  goals.command("events").argument("<job-spec-id>").option("--json", "Emit each event as NDJSON on stdout").option("--ws-url <url>", "Override the configured WebSocket URL").action(
+    async (jobSpecId, opts) => finish(runGoalsEvents(jobSpecId, { json: opts.json, wsUrl: opts.wsUrl }, deps()))
+  );
+  goals.command("fill-slot").argument("<job-spec-id>").requiredOption("--slot-id <id>", "Slot identifier to answer").requiredOption("--value <value>", "Slot value (JSON when possible, else literal)").option("--expected-version <n>", "Optimistic-locking item version").option("--json", "Emit the updated job as JSON on stdout").action(
+    async (jobSpecId, opts) => finish(
+      runGoalsFillSlot(
+        jobSpecId,
+        {
+          slotId: opts.slotId,
+          value: opts.value,
+          expectedVersion: asInt(opts.expectedVersion),
+          json: opts.json
+        },
+        deps()
+      )
+    )
+  );
+  goals.command("confirm").argument("<job-spec-id>").option("--expected-version <n>", "Optimistic-locking item version").option("--json", "Emit JSON on stdout").action(
+    async (jobSpecId, opts) => finish(
+      runGoalsConfirm(
+        jobSpecId,
+        { expectedVersion: asInt(opts.expectedVersion), json: opts.json },
+        deps()
+      )
+    )
+  );
+  goals.command("cancel").argument("<job-spec-id>").option("--json", "Emit JSON on stdout").action(
+    async (jobSpecId, opts) => finish(runGoalsCancel(jobSpecId, { json: opts.json }, deps()))
+  );
+  goals.command("retry").argument("<job-spec-id>").addOption(
+    new Option("--rerun-mode <mode>", "Resume the thread or start fresh").choices(["retry_same_thread", "fresh_rerun"]).default("retry_same_thread")
+  ).option("--reason <reason>", "Optional audit string").option("--json", "Emit JSON on stdout").action(
+    async (jobSpecId, opts) => finish(
+      runGoalsRetry(
+        jobSpecId,
+        { rerunMode: opts.rerunMode, reason: opts.reason, json: opts.json },
+        deps()
+      )
+    )
+  );
+}
+function buildAccountGroup(program) {
+  const account = program.command("account").description("Check your billing plan + quota.");
+  account.command("plan").option("--json", "Emit a single JSON object on stdout").action(async (opts) => finish(runAccountPlan({ json: opts.json }, deps())));
+  account.command("quota").option("--tool <tool...>", "Fully-qualified tool id (repeatable)").option("--max-iter <n>", "Iteration cap from the draft spec").option("--json", "Emit a single JSON object on stdout").action(
+    async (opts) => finish(
+      runAccountQuota({ tools: opts.tool, maxIter: asInt(opts.maxIter), json: opts.json }, deps())
+    )
+  );
+}
+async function main() {
+  await buildProgram().parseAsync(process.argv);
+}
+main().catch((error) => {
+  process.stderr.write(
+    `Unexpected error: ${error instanceof Error ? error.message : String(error)}
+`
+  );
+  process.exitCode = 2;
+});
+
+export { buildProgram };
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map