@docmana/sdk 0.2.1

package/dist/cli.mjs

@@ -0,0 +1,772 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { existsSync, realpathSync } from "fs";
+import { mkdir, readFile as readFile2, rm, writeFile } from "fs/promises";
+import { dirname, resolve } from "path";
+import { createInterface } from "readline/promises";
+import { fileURLToPath } from "url";
+import { Command, CommanderError } from "commander";
+
+// src/errors.ts
+var DocmanaError = class extends Error {
+  status;
+  requestId;
+  code;
+  constructor(message, opts = {}) {
+    super(message);
+    this.name = new.target.name;
+    this.status = opts.status;
+    this.requestId = opts.requestId;
+    this.code = opts.code ?? "docmana_error";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var DocmanaAuthError = class extends DocmanaError {
+  constructor(message, opts = {}) {
+    super(message, { ...opts, code: "auth_error" });
+  }
+};
+var DocmanaPermissionError = class extends DocmanaError {
+  constructor(message, opts = {}) {
+    super(message, { ...opts, code: "permission_error" });
+  }
+};
+var DocmanaNotFoundError = class extends DocmanaError {
+  constructor(message, opts = {}) {
+    super(message, { ...opts, code: "not_found" });
+  }
+};
+var DocmanaRequestError = class extends DocmanaError {
+  constructor(message, opts = {}) {
+    super(message, { ...opts, code: "bad_request" });
+  }
+};
+var DocmanaExecutionError = class extends DocmanaError {
+  errors;
+  constructor(message, errors = []) {
+    super(message, { code: "execution_failed" });
+    this.errors = errors;
+  }
+};
+var DocmanaTimeoutError = class extends DocmanaError {
+  constructor(message) {
+    super(message, { code: "timeout" });
+  }
+};
+var DocmanaAbortError = class extends DocmanaError {
+  constructor(message) {
+    super(message, { code: "aborted" });
+  }
+};
+function errorFromResponse(status, message, requestId) {
+  const opts = { status, requestId };
+  switch (status) {
+    case 400:
+      return new DocmanaRequestError(message, opts);
+    case 401:
+      return new DocmanaAuthError(message, opts);
+    case 403:
+      return new DocmanaPermissionError(message, opts);
+    case 404:
+      return new DocmanaNotFoundError(message, opts);
+    default:
+      return new DocmanaError(message, opts);
+  }
+}
+
+// src/auth/token-manager.ts
+var SAFETY_MARGIN_MS = 6e4;
+var TokenManager = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  token = null;
+  expiresAt = 0;
+  inflight = null;
+  invalidate() {
+    this.token = null;
+    this.expiresAt = 0;
+    void this.opts.tokenCache?.clear().catch(() => void 0);
+  }
+  async getToken() {
+    if (this.token && Date.now() < this.expiresAt) return this.token;
+    const cached = await this.readCachedToken();
+    if (cached) return cached;
+    if (this.inflight) return this.inflight;
+    this.inflight = this.acquire().finally(() => {
+      this.inflight = null;
+    });
+    return this.inflight;
+  }
+  async acquire() {
+    const body = new URLSearchParams({
+      grant_type: "client_credentials",
+      client_id: this.opts.clientId,
+      client_secret: this.opts.clientSecret,
+      scope: this.opts.scope
+    });
+    const res = await this.opts.fetchImpl(this.opts.tokenEndpoint, {
+      method: "POST",
+      headers: { "content-type": "application/x-www-form-urlencoded" },
+      body: body.toString()
+    });
+    if (!res.ok) {
+      throw new DocmanaAuthError("Failed to acquire Docmana access token", { status: res.status });
+    }
+    const json = await res.json();
+    if (typeof json.access_token !== "string" || json.access_token.length === 0 || typeof json.expires_in !== "number" || !Number.isFinite(json.expires_in)) {
+      throw new DocmanaAuthError("Malformed token response from Docmana CIAM", {
+        status: res.status
+      });
+    }
+    this.token = json.access_token;
+    this.expiresAt = Date.now() + json.expires_in * 1e3 - SAFETY_MARGIN_MS;
+    await this.writeCachedToken().catch(() => void 0);
+    return this.token;
+  }
+  async readCachedToken() {
+    if (!this.opts.tokenCache) return null;
+    let entry;
+    try {
+      entry = await this.opts.tokenCache.read();
+    } catch {
+      return null;
+    }
+    if (!entry) return null;
+    if (entry.clientId !== this.opts.clientId || entry.tokenEndpoint !== this.opts.tokenEndpoint || entry.scope !== this.opts.scope || Date.now() >= entry.expiresAt) {
+      await this.opts.tokenCache.clear().catch(() => void 0);
+      return null;
+    }
+    this.token = entry.accessToken;
+    this.expiresAt = entry.expiresAt;
+    return this.token;
+  }
+  async writeCachedToken() {
+    if (!this.opts.tokenCache || !this.token) return;
+    await this.opts.tokenCache.write({
+      accessToken: this.token,
+      expiresAt: this.expiresAt,
+      clientId: this.opts.clientId,
+      tokenEndpoint: this.opts.tokenEndpoint,
+      scope: this.opts.scope
+    });
+  }
+};
+
+// src/config.ts
+var DEFAULTS = {
+  apiBaseUrl: "https://api.docmana.ai",
+  tokenEndpoint: "https://4fe70f5b-e013-4f65-9fa7-3109a33beba5.ciamlogin.com/4fe70f5b-e013-4f65-9fa7-3109a33beba5/oauth2/v2.0/token",
+  scope: "api://d781e6ba-cc08-4618-8099-ad968abd2b9e/.default",
+  timeoutMs: 3e5,
+  pollIntervalMs: 2e3
+};
+function resolveConfig(config) {
+  if (!config.clientId) throw new Error("DocmanaConfig.clientId is required");
+  if (!config.clientSecret) throw new Error("DocmanaConfig.clientSecret is required");
+  const apiBaseUrl = (config.apiBaseUrl ?? DEFAULTS.apiBaseUrl).replace(/\/+$/, "");
+  return {
+    clientId: config.clientId,
+    clientSecret: config.clientSecret,
+    apiBaseUrl,
+    tokenEndpoint: config.tokenEndpoint ?? DEFAULTS.tokenEndpoint,
+    scope: config.scope ?? DEFAULTS.scope,
+    timeoutMs: config.timeoutMs ?? DEFAULTS.timeoutMs,
+    pollIntervalMs: config.pollIntervalMs ?? DEFAULTS.pollIntervalMs,
+    fetchImpl: config.fetch ?? fetch,
+    headers: config.headers ?? {},
+    tokenCache: config.tokenCache
+  };
+}
+
+// src/http/http-client.ts
+var HttpClient = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  async requestJson(method, path, options = {}) {
+    const res = await this.requestRaw(method, path, options);
+    const text = await res.text();
+    if (!text) return {};
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new DocmanaError("Invalid JSON response from Docmana", { status: res.status });
+    }
+  }
+  async requestRaw(method, path, options = {}) {
+    let res = await this.send(method, path, options);
+    if (res.status === 401) {
+      this.opts.tokenManager.invalidate();
+      res = await this.send(method, path, options);
+    }
+    if (!res.ok) {
+      const requestId = res.headers.get("x-request-id") ?? void 0;
+      const message = await this.extractMessage(res);
+      throw errorFromResponse(res.status, message, requestId);
+    }
+    return res;
+  }
+  async send(method, path, options) {
+    const token = await this.opts.tokenManager.getToken();
+    const url = new URL(this.opts.apiBaseUrl + path);
+    for (const [k, v] of Object.entries(options.query ?? {})) url.searchParams.set(k, v);
+    const headers = {
+      ...this.opts.headers ?? {},
+      authorization: `Bearer ${token}`,
+      ...options.headers ?? {}
+    };
+    try {
+      return await this.opts.fetchImpl(url, {
+        method,
+        headers,
+        body: options.body,
+        signal: options.signal
+      });
+    } catch (err) {
+      if (options.signal?.aborted || err instanceof Error && err.name === "AbortError") {
+        throw new DocmanaAbortError("Request aborted");
+      }
+      throw err;
+    }
+  }
+  async extractMessage(res) {
+    try {
+      const data = await res.clone().json();
+      return data.message ?? data.error ?? res.statusText ?? `HTTP ${res.status}`;
+    } catch {
+      return res.statusText ?? `HTTP ${res.status}`;
+    }
+  }
+};
+
+// src/files/resolve-input.ts
+import { readFile } from "fs/promises";
+import { basename } from "path";
+var CONTENT_TYPES = {
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".tif": "image/tiff",
+  ".tiff": "image/tiff",
+  ".txt": "text/plain",
+  ".json": "application/json"
+};
+function contentTypeFor(name) {
+  const dot = name.lastIndexOf(".");
+  if (dot < 0) return "application/octet-stream";
+  const ext = name.slice(dot).toLowerCase();
+  return CONTENT_TYPES[ext] ?? "application/octet-stream";
+}
+function isReadable(x) {
+  return typeof x === "object" && x !== null && typeof x.pipe === "function";
+}
+function isPathInput(x) {
+  return typeof x === "object" && x !== null && typeof x.path === "string";
+}
+async function streamToBuffer(stream) {
+  const chunks = [];
+  for await (const chunk of stream) chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks);
+}
+async function resolveOne(input, fallbackName) {
+  if (typeof input === "string" || isPathInput(input)) {
+    const path = typeof input === "string" ? input : input.path;
+    const data = await readFile(path);
+    const filename = basename(path);
+    return { data: new Blob([data]), filename, contentType: contentTypeFor(filename) };
+  }
+  if (input instanceof Uint8Array) {
+    return {
+      data: new Blob([input]),
+      filename: fallbackName,
+      contentType: contentTypeFor(fallbackName)
+    };
+  }
+  if (isReadable(input)) {
+    const buf = await streamToBuffer(input);
+    return {
+      data: new Blob([buf]),
+      filename: fallbackName,
+      contentType: contentTypeFor(fallbackName)
+    };
+  }
+  throw new Error("Unsupported file input type");
+}
+async function resolveInputs(input) {
+  const list = input.files ?? (input.file !== void 0 ? [input.file] : []);
+  if (list.length === 0) throw new Error("runFlow requires `file` or `files`");
+  const fallback = input.fileName ?? "upload.bin";
+  return Promise.all(list.map((item) => resolveOne(item, fallback)));
+}
+
+// src/api/upload.ts
+async function uploadFiles(http, parts, signal) {
+  const ids = [];
+  for (const part of parts) {
+    const form = new FormData();
+    form.append("files", new File([part.data], part.filename, { type: part.contentType }));
+    const res = await http.requestJson("POST", "/upload", { body: form, signal });
+    ids.push(res.id);
+  }
+  return ids;
+}
+
+// src/api/run-flow.ts
+async function runFlow(http, flowId, uuidFiles, signal, once = false) {
+  const path = once ? `/flows/run_once_flow/${flowId}` : `/flows/run_flow/${flowId}`;
+  const res = await http.requestJson("POST", path, {
+    query: { async_mode: "true" },
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ uuid_files: uuidFiles }),
+    signal
+  });
+  return res.execution_result_id;
+}
+
+// src/api/execution-status.ts
+async function getStatus(http, executionResultId, signal) {
+  return http.requestJson("GET", `/flows/execution-status/${executionResultId}`, { signal });
+}
+
+// src/api/execution-result.ts
+async function getResult(http, executionResultId, signal) {
+  return http.requestJson("GET", `/flows/execution-result/${executionResultId}`, { signal });
+}
+
+// src/polling/poll.ts
+var TERMINAL = /* @__PURE__ */ new Set(["Completed", "Failed"]);
+var defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function pollUntilTerminal(opts) {
+  const sleep = opts.sleep ?? defaultSleep;
+  const start = Date.now();
+  const elapsed = opts.elapsed ?? (() => Date.now() - start);
+  for (; ; ) {
+    if (opts.signal?.aborted) throw new DocmanaAbortError("Polling aborted");
+    const status = await opts.check();
+    if (TERMINAL.has(status)) return status;
+    if (elapsed() >= opts.timeoutMs) {
+      throw new DocmanaTimeoutError(`Execution did not finish within ${opts.timeoutMs}ms`);
+    }
+    await sleep(opts.intervalMs);
+  }
+}
+
+// src/client.ts
+var Docmana = class {
+  config;
+  http;
+  constructor(config) {
+    this.config = resolveConfig(config);
+    const tokenManager = new TokenManager({
+      clientId: this.config.clientId,
+      clientSecret: this.config.clientSecret,
+      tokenEndpoint: this.config.tokenEndpoint,
+      scope: this.config.scope,
+      fetchImpl: this.config.fetchImpl,
+      tokenCache: this.config.tokenCache
+    });
+    this.http = new HttpClient({
+      apiBaseUrl: this.config.apiBaseUrl,
+      fetchImpl: this.config.fetchImpl,
+      tokenManager,
+      headers: this.config.headers
+    });
+  }
+  async runFlowAsync(flowId, input) {
+    const parts = await resolveInputs(input);
+    const fileIds = await uploadFiles(this.http, parts, input.signal);
+    const executionResultId = await runFlow(
+      this.http,
+      flowId,
+      fileIds,
+      input.signal,
+      input.once ?? false
+    );
+    return { executionResultId, fileIds };
+  }
+  async getStatus(executionResultId, signal) {
+    return getStatus(this.http, executionResultId, signal);
+  }
+  async getResult(executionResultId, signal) {
+    return getResult(this.http, executionResultId, signal);
+  }
+  async runFlow(flowId, input) {
+    const { executionResultId } = await this.runFlowAsync(flowId, input);
+    await pollUntilTerminal({
+      check: async () => (await this.getStatus(executionResultId, input.signal)).status,
+      intervalMs: input.pollIntervalMs ?? this.config.pollIntervalMs,
+      timeoutMs: input.timeoutMs ?? this.config.timeoutMs,
+      signal: input.signal
+    });
+    const result = await this.getResult(executionResultId, input.signal);
+    if (result.status === "Failed") {
+      throw new DocmanaExecutionError(`Flow ${flowId} execution failed`, result.errors ?? []);
+    }
+    return result;
+  }
+};
+
+// src/cli.ts
+var CliUsageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CliUsageError";
+  }
+};
+var HELP = {
+  root: "Run Docmana document-analysis flows.",
+  flow: "Manage and run Docmana flows.",
+  config: "Manage Docmana CLI configuration.",
+  configInit: "Create or update a local Docmana CLI config file.",
+  login: "Acquire and cache a Docmana OAuth2 access token.",
+  run: "Upload documents, run a Docmana flow, wait for completion, and print the result."
+};
+var DEFAULT_CONFIG_FILE = "docmana.config.json";
+var DEFAULT_TOKEN_CACHE_FILE = "docmana.token.json";
+async function runCli(argv = process.argv.slice(2), env = process.env, io = {
+  stdout: (text) => process.stdout.write(text),
+  stderr: (text) => process.stderr.write(text)
+}, clientFactory = (config) => new Docmana(config), deps = {}) {
+  const program = buildProgram(env, io, clientFactory, deps);
+  if (argv.length === 0) {
+    io.stdout(program.helpInformation());
+    return 0;
+  }
+  try {
+    await program.parseAsync(argv, { from: "user" });
+    return 0;
+  } catch (err) {
+    if (err instanceof CliUsageError) {
+      io.stderr(`Error: ${err.message}
+`);
+      return 2;
+    }
+    if (err instanceof CommanderError) {
+      return err.exitCode === 0 ? 0 : 2;
+    }
+    io.stderr(`${formatRuntimeError(err)}
+`);
+    return 1;
+  }
+}
+function buildProgram(env, io, clientFactory, deps) {
+  const program = new Command();
+  program.name("docmana").description(HELP.root).showHelpAfterError().configureOutput({
+    writeOut: io.stdout,
+    writeErr: io.stderr,
+    outputError: (str, write) => write(str)
+  }).exitOverride();
+  program.command("login").description(HELP.login).option("--client-id <id>", "OAuth2 client id; defaults to DOCMANA_CLIENT_ID").option("--client-secret <secret>", "OAuth2 client secret; defaults to DOCMANA_CLIENT_SECRET").option("--token-url <url>", "OAuth2 token endpoint; defaults to DOCMANA_TOKEN_URL").option("--scope <scope>", "OAuth2 scope; defaults to DOCMANA_SCOPE").option("--config <path>", `Config file path; defaults to ./${DEFAULT_CONFIG_FILE}`).option("--token-cache <path>", `Token cache path; defaults to ./${DEFAULT_TOKEN_CACHE_FILE}`).action(async (options) => {
+    await loginCommand(options, env, io, deps);
+  });
+  const flow = program.command("flow").description(HELP.flow).action(() => {
+    io.stdout(flow.helpInformation());
+  });
+  flow.command("run").description(HELP.run).argument("<flow-id>", "Docmana flow id").requiredOption("--files <csv>", "Comma-separated file paths to upload").option("--client-id <id>", "OAuth2 client id; defaults to DOCMANA_CLIENT_ID").option("--client-secret <secret>", "OAuth2 client secret; defaults to DOCMANA_CLIENT_SECRET").option("--api-url <url>", "Docmana API base URL; defaults to DOCMANA_API_URL").option("--token-url <url>", "OAuth2 token endpoint; defaults to DOCMANA_TOKEN_URL").option("--scope <scope>", "OAuth2 scope; defaults to DOCMANA_SCOPE").option("--organisation <id>", "Docmana organisation id; defaults to DOCMANA_ORGANISATION").option("--config <path>", `Config file path; defaults to ./${DEFAULT_CONFIG_FILE}`).option("--token-cache <path>", `Token cache path; defaults to ./${DEFAULT_TOKEN_CACHE_FILE}`).option("--json", "Print the raw JSON result").action(async (flowId, options) => {
+    await runFlowCommand(flowId, options, env, io, clientFactory, deps);
+  });
+  const config = program.command("config").description(HELP.config).action(() => {
+    io.stdout(config.helpInformation());
+  });
+  config.command("init").description(HELP.configInit).option("--config <path>", `Config file path; defaults to ./${DEFAULT_CONFIG_FILE}`).action(async (options) => {
+    await configInitCommand(options, io, deps);
+  });
+  return program;
+}
+async function runFlowCommand(flowId, options, env, io, clientFactory, deps) {
+  const files = parseFiles(options.files);
+  const cliConfig = await loadCliConfig(options.config, getCwd(deps), Boolean(options.config));
+  const clientId = firstNonEmpty(options.clientId, env.DOCMANA_CLIENT_ID, cliConfig.clientId);
+  const clientSecret = firstNonEmpty(
+    options.clientSecret,
+    env.DOCMANA_CLIENT_SECRET,
+    cliConfig.clientSecret
+  );
+  const organisation = firstNonEmpty(
+    options.organisation,
+    env.DOCMANA_ORGANISATION,
+    cliConfig.organisation
+  );
+  const apiBaseUrl = firstNonEmpty(options.apiUrl, env.DOCMANA_API_URL, cliConfig.apiBaseUrl);
+  const tokenEndpoint = firstNonEmpty(
+    options.tokenUrl,
+    env.DOCMANA_TOKEN_URL,
+    cliConfig.tokenEndpoint
+  );
+  const scope = firstNonEmpty(options.scope, env.DOCMANA_SCOPE, cliConfig.scope);
+  if (!clientId)
+    throw new CliUsageError("Missing client id. Use --client-id or DOCMANA_CLIENT_ID.");
+  if (!clientSecret) {
+    throw new CliUsageError("Missing client secret. Use --client-secret or DOCMANA_CLIENT_SECRET.");
+  }
+  if (!organisation) {
+    throw new CliUsageError("Missing organisation. Use --organisation or DOCMANA_ORGANISATION.");
+  }
+  const client = clientFactory({
+    clientId,
+    clientSecret,
+    apiBaseUrl,
+    tokenEndpoint,
+    scope,
+    headers: { "X-Selected-Organization": organisation },
+    tokenCache: createFileTokenCache(resolveTokenCachePath(options.tokenCache, getCwd(deps)))
+  });
+  const result = await client.runFlow(flowId, { files: files.map((path) => ({ path })) });
+  if (options.json) {
+    io.stdout(`${JSON.stringify(result, null, 2)}
+`);
+    return;
+  }
+  io.stdout(formatHumanResult(result));
+}
+async function loginCommand(options, env, io, deps) {
+  const auth = await resolveAuthConfig(options, env, deps);
+  const tokenCachePath = resolveTokenCachePath(options.tokenCache, getCwd(deps));
+  const tokenCache = createFileTokenCache(tokenCachePath);
+  const tokenManager = new TokenManager({
+    clientId: auth.clientId,
+    clientSecret: auth.clientSecret,
+    tokenEndpoint: auth.tokenEndpoint,
+    scope: auth.scope,
+    fetchImpl: deps.fetch ?? fetch,
+    tokenCache
+  });
+  await tokenManager.getToken();
+  const cached = await tokenCache.read();
+  io.stdout(`Logged in. Token cached at ${tokenCachePath}
+`);
+  if (cached) io.stdout(formatTokenExpiry(cached.expiresAt));
+}
+function formatTokenExpiry(expiresAt) {
+  const expiresAtDate = new Date(expiresAt);
+  return [
+    `Token expires at local time ${expiresAtDate.toLocaleString()}`,
+    `Token expires at UTC ${expiresAtDate.toISOString()}`
+  ].join("\n") + "\n";
+}
+async function resolveAuthConfig(options, env, deps) {
+  const cliConfig = await loadCliConfig(options.config, getCwd(deps), Boolean(options.config));
+  const clientId = firstNonEmpty(options.clientId, env.DOCMANA_CLIENT_ID, cliConfig.clientId);
+  const clientSecret = firstNonEmpty(
+    options.clientSecret,
+    env.DOCMANA_CLIENT_SECRET,
+    cliConfig.clientSecret
+  );
+  const tokenEndpoint = firstNonEmpty(options.tokenUrl, env.DOCMANA_TOKEN_URL, cliConfig.tokenEndpoint) ?? DEFAULTS.tokenEndpoint;
+  const scope = firstNonEmpty(options.scope, env.DOCMANA_SCOPE, cliConfig.scope) ?? DEFAULTS.scope;
+  if (!clientId)
+    throw new CliUsageError("Missing client id. Use --client-id or DOCMANA_CLIENT_ID.");
+  if (!clientSecret) {
+    throw new CliUsageError("Missing client secret. Use --client-secret or DOCMANA_CLIENT_SECRET.");
+  }
+  return { clientId, clientSecret, tokenEndpoint, scope };
+}
+async function configInitCommand(options, io, deps) {
+  const cwd = getCwd(deps);
+  const configPath = resolveConfigPath(options.config, cwd);
+  const existing = await loadCliConfig(options.config, cwd, false);
+  const defaultPrompt = deps.prompt ? void 0 : createDefaultPrompt();
+  const prompt = deps.prompt ?? defaultPrompt?.prompt;
+  if (!prompt) throw new CliUsageError("Unable to initialize interactive prompt");
+  try {
+    const config = {
+      apiBaseUrl: await prompt("API base URL", {
+        defaultValue: existing.apiBaseUrl ?? DEFAULTS.apiBaseUrl
+      }),
+      tokenEndpoint: await prompt("OAuth2 token endpoint", {
+        defaultValue: existing.tokenEndpoint ?? DEFAULTS.tokenEndpoint
+      }),
+      scope: await prompt("OAuth2 scope", {
+        defaultValue: existing.scope ?? DEFAULTS.scope
+      }),
+      organisation: await prompt("Organisation", {
+        defaultValue: existing.organisation
+      }),
+      clientId: await prompt("Client id", {
+        defaultValue: existing.clientId
+      }),
+      clientSecret: await prompt("Client secret", {
+        defaultValue: existing.clientSecret,
+        secret: true
+      })
+    };
+    await mkdir(dirname(configPath), { recursive: true });
+    await writeFile(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+    io.stdout(`Wrote ${configPath}
+`);
+    io.stdout(
+      `Warning: ${DEFAULT_CONFIG_FILE} contains credentials and should stay ignored by Git.
+`
+    );
+  } finally {
+    defaultPrompt?.close();
+  }
+}
+async function loadCliConfig(configPathOption, cwd, requireExisting) {
+  const configPath = resolveConfigPath(configPathOption, cwd);
+  if (!existsSync(configPath)) {
+    if (requireExisting) throw new CliUsageError(`Config file not found: ${configPath}`);
+    return {};
+  }
+  let raw;
+  try {
+    raw = await readFile2(configPath, "utf8");
+  } catch {
+    throw new CliUsageError(`Unable to read config file: ${configPath}`);
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("Config must be a JSON object");
+    }
+    return normalizeCliConfig(parsed);
+  } catch {
+    throw new CliUsageError(`Invalid config file: ${configPath}`);
+  }
+}
+function normalizeCliConfig(config) {
+  return {
+    apiBaseUrl: stringValue(config.apiBaseUrl),
+    tokenEndpoint: stringValue(config.tokenEndpoint),
+    scope: stringValue(config.scope),
+    organisation: stringValue(config.organisation),
+    clientId: stringValue(config.clientId),
+    clientSecret: stringValue(config.clientSecret)
+  };
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function resolveConfigPath(configPathOption, cwd) {
+  return resolve(cwd, configPathOption ?? DEFAULT_CONFIG_FILE);
+}
+function resolveTokenCachePath(tokenCachePathOption, cwd) {
+  return resolve(cwd, tokenCachePathOption ?? DEFAULT_TOKEN_CACHE_FILE);
+}
+function getCwd(deps) {
+  return deps.cwd ?? process.cwd();
+}
+function createFileTokenCache(path) {
+  return {
+    async read() {
+      if (!existsSync(path)) return null;
+      try {
+        const parsed = JSON.parse(await readFile2(path, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+        const value = parsed;
+        if (typeof value.accessToken !== "string" || typeof value.expiresAt !== "number" || typeof value.clientId !== "string" || typeof value.tokenEndpoint !== "string" || typeof value.scope !== "string") {
+          return null;
+        }
+        return {
+          accessToken: value.accessToken,
+          expiresAt: value.expiresAt,
+          clientId: value.clientId,
+          tokenEndpoint: value.tokenEndpoint,
+          scope: value.scope
+        };
+      } catch {
+        return null;
+      }
+    },
+    async write(entry) {
+      await mkdir(dirname(path), { recursive: true });
+      await writeFile(path, `${JSON.stringify(entry, null, 2)}
+`, "utf8");
+    },
+    async clear() {
+      await rm(path, { force: true });
+    }
+  };
+}
+function createDefaultPrompt() {
+  if (!process.stdin.isTTY) {
+    let index = 0;
+    const linesPromise = readStdinLines();
+    return {
+      prompt: async (label, options = {}) => {
+        process.stdout.write(formatPrompt(label, options));
+        const lines = await linesPromise;
+        const answer = lines[index++] ?? "";
+        return firstNonEmpty(answer, options.defaultValue) ?? "";
+      },
+      close: () => void 0
+    };
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return {
+    prompt: async (label, options = {}) => {
+      const answer = await rl.question(formatPrompt(label, options));
+      return firstNonEmpty(answer, options.defaultValue) ?? "";
+    },
+    close: () => rl.close()
+  };
+}
+function formatPrompt(label, options) {
+  const defaultHint = options.defaultValue && !options.secret ? ` [${options.defaultValue}]` : options.defaultValue && options.secret ? " [current value hidden]" : "";
+  return `${label}${defaultHint}: `;
+}
+async function readStdinLines() {
+  let input = "";
+  for await (const chunk of process.stdin) input += String(chunk);
+  return input.split(/\r?\n/);
+}
+function parseFiles(filesCsv) {
+  const files = filesCsv?.split(",").map((file) => file.trim()).filter(Boolean) ?? [];
+  if (files.length === 0) throw new CliUsageError("Missing files. Use --files <path[,path]>.");
+  return files;
+}
+function firstNonEmpty(...values) {
+  return values.map((value) => value?.trim()).find(Boolean);
+}
+function formatHumanResult(result) {
+  const lines = ["Docmana flow completed", `Status: ${String(result.status ?? "Unknown")}`];
+  const executionId = result.execution_id ?? result.executionResultId ?? result.execution_result_id;
+  if (executionId) lines.push(`Execution id: ${String(executionId)}`);
+  if (Array.isArray(result.results)) lines.push(`Results: ${result.results.length}`);
+  if (Array.isArray(result.errors)) lines.push(`Errors: ${result.errors.length}`);
+  const preview = formatResultsPreview(result.results);
+  if (preview) lines.push("", "Result preview:", preview);
+  lines.push("", "Use --json to print the complete result payload.");
+  return `${lines.join("\n")}
+`;
+}
+function formatResultsPreview(results) {
+  if (!Array.isArray(results) || results.length === 0) return void 0;
+  const preview = JSON.stringify(results.slice(0, 3), null, 2);
+  if (!preview) return void 0;
+  return preview.length > 2e3 ? `${preview.slice(0, 2e3)}
+...` : preview;
+}
+function formatRuntimeError(err) {
+  if (err instanceof DocmanaExecutionError) {
+    const details = err.errors.length > 0 ? ` (${err.errors.length} error(s))` : "";
+    return `${err.message}${details}`;
+  }
+  if (err instanceof DocmanaError) return err.message;
+  if (err instanceof Error) return err.message;
+  return "Unexpected error";
+}
+function isDirectRun() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    return realpathSync(resolve(entry)) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
+if (isDirectRun()) {
+  runCli().then((code) => {
+    process.exitCode = code;
+  });
+}
+export {
+  runCli
+};
+//# sourceMappingURL=cli.mjs.map