@cronvello/sdk 0.1.0 → 0.1.2

package/dist/cli.js

@@ -0,0 +1,874 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { pathToFileURL } from 'url';
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+
+// src/internal/errors.ts
+var CronvelloError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CronvelloError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var CronvelloApiError = class extends CronvelloError {
+  /** HTTP status code. */
+  status;
+  /** Machine-readable error code from the API body, when present. */
+  code;
+  /** The method + path that failed, e.g. `POST /v1/jobs`. */
+  endpoint;
+  /** Parsed response body (best effort). */
+  body;
+  /** Seconds to wait before retrying, parsed from `Retry-After` / rate-limit payload (429 only). */
+  retryAfterSeconds;
+  constructor(args) {
+    super(`[${args.status}] ${args.endpoint}: ${args.message}`);
+    this.name = "CronvelloApiError";
+    this.status = args.status;
+    this.code = args.code;
+    this.endpoint = args.endpoint;
+    this.body = args.body;
+    this.retryAfterSeconds = args.retryAfterSeconds;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  get isRateLimited() {
+    return this.status === 429;
+  }
+  get isAuthError() {
+    return this.status === 401 || this.status === 403;
+  }
+  get isNotFound() {
+    return this.status === 404;
+  }
+};
+var CronvelloNetworkError = class extends CronvelloError {
+  endpoint;
+  cause;
+  constructor(endpoint, cause) {
+    super(`Network error calling ${endpoint}: ${describe(cause)}`);
+    this.name = "CronvelloNetworkError";
+    this.endpoint = endpoint;
+    this.cause = cause;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var CronvelloConfigError = class extends CronvelloError {
+  constructor(message) {
+    super(message);
+    this.name = "CronvelloConfigError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+function describe(cause) {
+  if (cause instanceof Error) return cause.message;
+  return String(cause);
+}
+
+// src/internal/http.ts
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var Transport = class {
+  baseUrl;
+  apiKey;
+  timeoutMs;
+  maxRetries;
+  fetchImpl;
+  defaultHeaders;
+  onRequest;
+  constructor(opts) {
+    if (!opts.apiKey) throw new CronvelloConfigError("apiKey is required");
+    if (!opts.baseUrl) throw new CronvelloConfigError("baseUrl is required");
+    const resolvedFetch = opts.fetch ?? globalThis.fetch;
+    if (!resolvedFetch) {
+      throw new CronvelloConfigError(
+        "No global fetch found. Use Node 18+ or pass a `fetch` implementation in the client options."
+      );
+    }
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.apiKey = opts.apiKey;
+    this.timeoutMs = opts.timeoutMs ?? 3e4;
+    this.maxRetries = opts.maxRetries ?? 2;
+    this.fetchImpl = resolvedFetch;
+    this.defaultHeaders = opts.defaultHeaders ?? {};
+    this.onRequest = opts.onRequest;
+  }
+  async request(opts) {
+    const url = this.buildUrl(opts.path, opts.query);
+    const endpoint = `${opts.method} ${opts.path}`;
+    const headers = {
+      authorization: `Bearer ${this.apiKey}`,
+      accept: "application/json",
+      ...this.defaultHeaders
+    };
+    let payload;
+    if (opts.body !== void 0) {
+      headers["content-type"] = "application/json";
+      payload = JSON.stringify(opts.body);
+    }
+    if (opts.idempotencyKey) headers["idempotency-key"] = opts.idempotencyKey;
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      const startedAt = Date.now();
+      const { signal, cancel } = this.withTimeout(opts.signal);
+      try {
+        const res = await this.fetchImpl(url, {
+          method: opts.method,
+          headers,
+          ...payload !== void 0 ? { body: payload } : {},
+          signal
+        });
+        cancel();
+        const durationMs = Date.now() - startedAt;
+        this.onRequest?.({ method: opts.method, path: opts.path, status: res.status, attempt, durationMs });
+        const text = await res.text();
+        const parsed = text ? safeJson(text) : null;
+        if (res.ok) return unwrapEnvelope(parsed);
+        const retryAfter = parseRetryAfter(res, parsed);
+        if (RETRYABLE_STATUS.has(res.status) && attempt < this.maxRetries) {
+          await sleep(this.backoff(attempt, retryAfter));
+          continue;
+        }
+        throw new CronvelloApiError({
+          status: res.status,
+          endpoint,
+          message: extractMessage(parsed) ?? `Request failed`,
+          code: extractCode(parsed),
+          body: parsed,
+          ...retryAfter !== void 0 ? { retryAfterSeconds: retryAfter } : {}
+        });
+      } catch (err) {
+        cancel();
+        if (err instanceof CronvelloApiError) throw err;
+        lastError = err;
+        if (attempt < this.maxRetries) {
+          await sleep(this.backoff(attempt));
+          continue;
+        }
+        throw new CronvelloNetworkError(endpoint, err);
+      }
+    }
+    throw new CronvelloNetworkError(endpoint, lastError);
+  }
+  buildUrl(path, query) {
+    const base = `${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+    if (!query) return base;
+    const params = Object.entries(query).filter(([, v]) => v !== void 0).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+    return params.length ? `${base}?${params.join("&")}` : base;
+  }
+  withTimeout(external) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    const onExternalAbort = () => controller.abort();
+    if (external) {
+      if (external.aborted) controller.abort();
+      else external.addEventListener("abort", onExternalAbort, { once: true });
+    }
+    return {
+      signal: controller.signal,
+      cancel: () => {
+        clearTimeout(timer);
+        external?.removeEventListener("abort", onExternalAbort);
+      }
+    };
+  }
+  backoff(attempt, retryAfterSeconds) {
+    if (retryAfterSeconds !== void 0) return Math.min(retryAfterSeconds * 1e3, 3e4);
+    const base = Math.min(300 * 2 ** attempt, 5e3);
+    return Math.floor(Math.random() * base);
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function safeJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function unwrapEnvelope(body) {
+  if (body !== null && typeof body === "object" && "success" in body && typeof body.success === "boolean" && "data" in body) {
+    return body.data;
+  }
+  return body;
+}
+function extractMessage(body) {
+  if (body && typeof body === "object" && "message" in body) {
+    const m = body.message;
+    if (typeof m === "string") return m;
+  }
+  return void 0;
+}
+function extractCode(body) {
+  if (body && typeof body === "object" && "code" in body) {
+    const c2 = body.code;
+    if (typeof c2 === "string") return c2;
+  }
+  return void 0;
+}
+function parseRetryAfter(res, body) {
+  const header2 = res.headers.get("retry-after");
+  if (header2) {
+    const n = Number(header2);
+    if (Number.isFinite(n)) return n;
+  }
+  if (body && typeof body === "object" && "data" in body) {
+    const data = body.data;
+    if (data && typeof data.retryAfterSeconds === "number") return data.retryAfterSeconds;
+  }
+  return void 0;
+}
+
+// src/client/client.ts
+var CRONVELLO_DEFAULT_BASE_URL = "https://api.cronvello.com";
+var CronvelloClient = class {
+  transport;
+  /** The resolved base URL in use. */
+  baseUrl;
+  /** Job container operations. */
+  jobs;
+  /** Scheduled task operations. */
+  tasks;
+  /** Execution-history (run) operations. */
+  runs;
+  /** Account identity + usage. */
+  account;
+  constructor(options) {
+    if (!options || !options.apiKey) {
+      throw new CronvelloConfigError("CronvelloClient requires an `apiKey` (crn_live_\u2026).");
+    }
+    this.baseUrl = (options.baseUrl ?? CRONVELLO_DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.transport = new Transport({
+      baseUrl: this.baseUrl,
+      apiKey: options.apiKey,
+      ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {},
+      ...options.maxRetries !== void 0 ? { maxRetries: options.maxRetries } : {},
+      ...options.fetch ? { fetch: options.fetch } : {},
+      ...options.onRequest ? { onRequest: options.onRequest } : {},
+      defaultHeaders: { "user-agent": "cronvello-sdk" }
+    });
+    this.jobs = new JobsResource(this.transport);
+    this.tasks = new TasksResource(this.transport);
+    this.runs = new RunsResource(this.transport);
+    this.account = new AccountResource(this.transport);
+  }
+  /**
+   * Atomically reconcile a whole code registry server-side (`PUT /v1/registry`): one job
+   * container + its tasks, created/updated/pruned/started in a single call. This is what
+   * `defineCronvello().sync()` prefers; the high-level API builds the body for you.
+   */
+  reconcileRegistry(body, opts) {
+    return this.transport.request({
+      method: "PUT",
+      path: "/v1/registry",
+      body,
+      ...opts?.idempotencyKey ? { idempotencyKey: opts.idempotencyKey } : {}
+    });
+  }
+  /**
+   * Escape hatch for endpoints not yet wrapped by a typed method (heartbeat monitors,
+   * maintenance windows, DLQ, notification channels, audit log, API-key self-service …).
+   * `T` is the response shape you expect.
+   */
+  request(method, path, opts) {
+    return this.transport.request({
+      method,
+      path,
+      ...opts?.query ? { query: opts.query } : {},
+      ...opts?.body !== void 0 ? { body: opts.body } : {},
+      ...opts?.idempotencyKey ? { idempotencyKey: opts.idempotencyKey } : {}
+    });
+  }
+};
+var JobsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  list() {
+    return this.t.request({ method: "GET", path: "/v1/jobs" });
+  }
+  get(jobId) {
+    return this.t.request({ method: "GET", path: `/v1/jobs/${enc(jobId)}` });
+  }
+  create(body, opts) {
+    return this.t.request({ method: "POST", path: "/v1/jobs", body, ...opts?.idempotencyKey ? { idempotencyKey: opts.idempotencyKey } : {} });
+  }
+  update(jobId, body) {
+    return this.t.request({ method: "PATCH", path: `/v1/jobs/${enc(jobId)}`, body });
+  }
+  delete(jobId) {
+    return this.t.request({ method: "DELETE", path: `/v1/jobs/${enc(jobId)}` });
+  }
+  start(jobId) {
+    return this.t.request({ method: "POST", path: `/v1/jobs/${enc(jobId)}/start` });
+  }
+  stop(jobId) {
+    return this.t.request({ method: "POST", path: `/v1/jobs/${enc(jobId)}/stop` });
+  }
+  listTasks(jobId) {
+    return this.t.request({ method: "GET", path: `/v1/jobs/${enc(jobId)}/tasks` });
+  }
+  createTask(jobId, body, opts) {
+    return this.t.request({ method: "POST", path: `/v1/jobs/${enc(jobId)}/tasks`, body, ...opts?.idempotencyKey ? { idempotencyKey: opts.idempotencyKey } : {} });
+  }
+};
+var TasksResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  /** Account-wide paginated task table. */
+  list(query) {
+    return this.t.request({ method: "GET", path: "/v1/tasks", ...query ? { query } : {} });
+  }
+  get(taskId) {
+    return this.t.request({ method: "GET", path: `/v1/tasks/${enc(taskId)}` });
+  }
+  update(taskId, body) {
+    return this.t.request({ method: "PATCH", path: `/v1/tasks/${enc(taskId)}`, body });
+  }
+  delete(taskId) {
+    return this.t.request({ method: "DELETE", path: `/v1/tasks/${enc(taskId)}` });
+  }
+  start(taskId) {
+    return this.t.request({ method: "POST", path: `/v1/tasks/${enc(taskId)}/start` });
+  }
+  stop(taskId) {
+    return this.t.request({ method: "POST", path: `/v1/tasks/${enc(taskId)}/stop` });
+  }
+  /** Trigger a one-off manual execution (does not change the schedule). */
+  runNow(taskId) {
+    return this.t.request({ method: "POST", path: `/v1/tasks/${enc(taskId)}/run` });
+  }
+  listRuns(taskId, query) {
+    return this.t.request({ method: "GET", path: `/v1/tasks/${enc(taskId)}/runs`, ...query ? { query } : {} });
+  }
+};
+var RunsResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  /** Account-wide paginated activity feed. */
+  list(query) {
+    return this.t.request({ method: "GET", path: "/v1/runs", ...query ? { query } : {} });
+  }
+  get(runId) {
+    return this.t.request({ method: "GET", path: `/v1/runs/${enc(runId)}` });
+  }
+};
+var AccountResource = class {
+  constructor(t) {
+    this.t = t;
+  }
+  t;
+  me() {
+    return this.t.request({ method: "GET", path: "/v1/me" });
+  }
+  usage() {
+    return this.t.request({ method: "GET", path: "/v1/usage" });
+  }
+};
+function enc(segment) {
+  return encodeURIComponent(segment);
+}
+
+// src/registry/format.ts
+var ESC = String.fromCharCode(27);
+var ANSI = {
+  reset: `${ESC}[0m`,
+  dim: `${ESC}[2m`,
+  bold: `${ESC}[1m`,
+  green: `${ESC}[32m`,
+  yellow: `${ESC}[33m`,
+  red: `${ESC}[31m`,
+  cyan: `${ESC}[36m`,
+  gray: `${ESC}[90m`
+};
+var GLYPH = {
+  created: { sign: "+", color: "green" },
+  updated: { sign: "~", color: "yellow" },
+  unchanged: { sign: "=", color: "gray" },
+  deleted: { sign: "-", color: "red" },
+  skipped: { sign: "\xB7", color: "cyan" }
+};
+function formatSyncResult(result, options = {}) {
+  const paint = (s, c2) => options.color ? `${ANSI[c2]}${s}${ANSI.reset}` : s;
+  const verb = options.dryRun ? "would sync" : "synced";
+  const lines = [];
+  lines.push(
+    `${paint("Cronvello", "cyan")} ${verb} ${paint(`"${result.jobName}"`, "bold")} ${paint(`(${result.jobId})`, "gray")}`
+  );
+  const order = ["created", "updated", "deleted", "skipped", "unchanged"];
+  const sorted = [...result.changes].sort((a, b) => order.indexOf(a.action) - order.indexOf(b.action));
+  for (const c2 of sorted) {
+    const g = GLYPH[c2.action];
+    const detail = c2.changedFields && c2.changedFields.length ? paint(` (${c2.changedFields.join(", ")})`, "gray") : c2.reason ? paint(` (${c2.reason})`, "gray") : "";
+    lines.push(`  ${paint(g.sign, g.color)} ${paint(c2.action.padEnd(9), g.color)} ${c2.key}${detail}`);
+  }
+  const tally = [
+    result.created && `${result.created} created`,
+    result.updated && `${result.updated} updated`,
+    result.unchanged && `${result.unchanged} unchanged`,
+    result.deleted && `${result.deleted} deleted`,
+    result.skipped && `${result.skipped} skipped`
+  ].filter(Boolean);
+  const summary = tally.length ? tally.join(", ") : "no changes";
+  const containerNote = result.jobCreated ? paint("  \xB7  container created", "gray") : "";
+  lines.push(`  ${paint(summary, "bold")}${containerNote}`);
+  return lines.join("\n");
+}
+
+// src/index.ts
+function generateDispatchSecret(bytes = 32) {
+  const buf = new Uint8Array(bytes);
+  crypto.getRandomValues(buf);
+  return Array.from(buf).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/cli/ui.ts
+var E = String.fromCharCode(27);
+var ENV = typeof process !== "undefined" && process.env ? process.env : {};
+var COLOR = !ENV["NO_COLOR"] && (!!ENV["FORCE_COLOR"] || !!(typeof process !== "undefined" && process.stdout && process.stdout.isTTY));
+function setColor(on) {
+  COLOR = on;
+}
+function wrap(code, close, s) {
+  return COLOR ? `${E}[${code}m${s}${E}[${close}m` : s;
+}
+var c = {
+  bold: (s) => wrap(1, 22, s),
+  dim: (s) => wrap(2, 22, s),
+  red: (s) => wrap(31, 39, s),
+  green: (s) => wrap(32, 39, s),
+  yellow: (s) => wrap(33, 39, s),
+  blue: (s) => wrap(34, 39, s),
+  magenta: (s) => wrap(35, 39, s),
+  cyan: (s) => wrap(36, 39, s),
+  gray: (s) => wrap(90, 39, s)
+};
+function brand(s) {
+  return COLOR ? `${E}[38;5;63m${s}${E}[39m` : s;
+}
+var sym = {
+  ok: c.green("\u2714"),
+  fail: c.red("\u2717"),
+  warn: c.yellow("\u25B2"),
+  info: c.cyan("\u2139"),
+  dot: c.gray("\xB7"),
+  arrow: c.gray("\u2192")
+};
+function visibleLength(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+function padEndVisible(s, width) {
+  const pad = width - visibleLength(s);
+  return pad > 0 ? s + " ".repeat(pad) : s;
+}
+function table(columns, rows) {
+  const widths = columns.map(
+    (col, i) => Math.max(visibleLength(col.header), ...rows.map((r) => visibleLength(r[i] ?? "")))
+  );
+  const fmtRow = (cells) => cells.map((cell, i) => {
+    const w = widths[i];
+    if (columns[i]?.align === "right") {
+      const pad = w - visibleLength(cell);
+      return (pad > 0 ? " ".repeat(pad) : "") + cell;
+    }
+    return padEndVisible(cell, w);
+  }).join("  ");
+  const head = fmtRow(columns.map((col) => c.dim(col.header)));
+  const body = rows.map(fmtRow);
+  return [head, ...body].join("\n");
+}
+function box(title, lines) {
+  const inner = [title, "", ...lines];
+  const width = Math.max(...inner.map(visibleLength));
+  const top = c.gray("\u256D\u2500 ") + brand(title) + c.gray(" " + "\u2500".repeat(Math.max(0, width - visibleLength(title) - 1)) + "\u256E");
+  const mid = lines.map((l) => c.gray("\u2502 ") + padEndVisible(l, width) + c.gray(" \u2502"));
+  const bot = c.gray("\u2570" + "\u2500".repeat(width + 2) + "\u256F");
+  return [top, ...mid, bot].join("\n");
+}
+function relativeTime(iso, nowMs) {
+  if (!iso) return c.gray("\u2014");
+  const then = Date.parse(iso);
+  if (Number.isNaN(then)) return c.gray("\u2014");
+  const deltaSec = Math.round((then - nowMs) / 1e3);
+  const future = deltaSec > 0;
+  const abs = Math.abs(deltaSec);
+  const unit = abs < 60 ? `${abs}s` : abs < 3600 ? `${Math.round(abs / 60)}m` : abs < 86400 ? `${Math.round(abs / 3600)}h` : `${Math.round(abs / 86400)}d`;
+  return c.gray(future ? `in ${unit}` : `${unit} ago`);
+}
+var ICON = brand("\u25F7");
+
+// src/cli/index.ts
+var require2 = createRequire(import.meta.url);
+var VERSION = (() => {
+  try {
+    return require2("../package.json").version;
+  } catch {
+    return "0.0.0";
+  }
+})();
+function parseArgs(argv) {
+  const positionals = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const key = a.slice(2);
+      const next = argv[i + 1];
+      if (next !== void 0 && !next.startsWith("-") && ["limit", "status", "job", "type", "runType"].includes(key)) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else if (a.startsWith("-") && a.length > 1) {
+      flags[a.slice(1)] = true;
+    } else {
+      positionals.push(a);
+    }
+  }
+  return { command: positionals[0] ?? "", positionals: positionals.slice(1), flags };
+}
+var out = (s = "") => void process.stdout.write(s + "\n");
+var json = (v) => out(JSON.stringify(v, null, 2));
+function makeClient() {
+  const apiKey = process.env["CRONVELLO_API_KEY"];
+  if (!apiKey) {
+    throw new CronvelloConfigError("CRONVELLO_API_KEY is not set. Export your crn_live_\u2026 key first.");
+  }
+  const baseUrl = process.env["CRONVELLO_API_URL"];
+  return new CronvelloClient({ apiKey, ...baseUrl ? { baseUrl } : {} });
+}
+function statusColor(status) {
+  const s = status.toUpperCase();
+  if (s === "ACTIVE" || s === "COMPLETED") return c.green(status);
+  if (s === "DISABLED" || s === "QUEUED" || s === "RUNNING") return c.cyan(status);
+  if (s.startsWith("ERROR") || s === "FAILED") return c.red(status);
+  return c.yellow(status);
+}
+function header(subtitle) {
+  out(`${ICON} ${brand("Cronvello")} ${c.gray(subtitle)}`);
+  out();
+}
+async function cmdWhoami(useJson) {
+  const me = await makeClient().account.me();
+  if (useJson) return json(me);
+  const u = me.usage;
+  const quota = u.executionQuota == null ? "\u221E" : String(u.executionQuota);
+  out(
+    box(`${me.accountName}`, [
+      `${c.dim("account")}   #${me.accountId}  ${me.isActive ? sym.ok : sym.fail} ${me.email}`,
+      `${c.dim("plan")}      ${brand(me.plan?.displayName ?? "\u2014")}`,
+      `${c.dim("limits")}    ${me.limits.maxJobs ?? "\u221E"} jobs \xB7 ${me.limits.maxTasksPerJob ?? "\u221E"} tasks/job \xB7 ${me.limits.rateLimitPerMinute ?? "\u221E"}/min`,
+      `${c.dim("usage")}     ${c.bold(String(u.executionCount))} / ${quota} executions  ${c.gray(`(${u.jobsUsed} jobs)`)}`,
+      `${c.dim("attention")} ${me.summary.openDlqCount} DLQ \xB7 ${me.summary.heartbeatNeedsAttention} heartbeats \xB7 ${me.summary.activeMaintenanceWindows} maintenance`
+    ])
+  );
+}
+async function cmdList(jobName, useJson) {
+  const client = makeClient();
+  if (jobName) {
+    const container = (await client.jobs.list()).find((j) => j.name === jobName);
+    if (!container) throw new CronvelloConfigError(`No job container named "${jobName}".`);
+    const tasks = await client.jobs.listTasks(container.id);
+    if (useJson) return json(tasks);
+    header(`tasks in "${container.name}"`);
+    out(renderTasks(tasks));
+    return;
+  }
+  const jobs = await client.jobs.list();
+  if (useJson) return json(jobs);
+  header("job containers");
+  out(
+    table(
+      [{ header: "NAME" }, { header: "STATUS" }, { header: "TASKS", align: "right" }, { header: "ACTIVE", align: "right" }, { header: "ERRORS", align: "right" }, { header: "ID" }],
+      jobs.map((j) => [
+        c.bold(j.name),
+        statusColor(j.status),
+        String(j.taskCount),
+        String(j.activeTaskCount),
+        j.errorTaskCount ? c.red(String(j.errorTaskCount)) : c.gray("0"),
+        c.gray(j.id)
+      ])
+    )
+  );
+  out();
+  out(c.gray(`${jobs.length} container(s) \xB7 ${jobs.reduce((n, j) => n + j.taskCount, 0)} task(s)`));
+}
+function renderTasks(tasks) {
+  const now = Date.now();
+  return table(
+    [{ header: "TASK" }, { header: "STATUS" }, { header: "SCHEDULE" }, { header: "NEXT RUN" }, { header: "LAST" }],
+    tasks.map((t) => [
+      c.bold(t.name),
+      statusColor(t.status),
+      c.cyan(t.schedule),
+      relativeTime(t.nextRun, now),
+      t.lastRunStatus ? statusColor(t.lastRunStatus) : c.gray("\u2014")
+    ])
+  );
+}
+async function cmdTasks(flags, useJson) {
+  const client = makeClient();
+  const jobName = typeof flags["job"] === "string" ? flags["job"] : void 0;
+  let jobId;
+  if (jobName) {
+    const container = (await client.jobs.list()).find((j) => j.name === jobName);
+    if (!container) throw new CronvelloConfigError(`No job container named "${jobName}".`);
+    jobId = container.id;
+  }
+  const page = await client.tasks.list({ limit: 100, ...jobId ? { jobId } : {} });
+  if (useJson) return json(page);
+  header(jobName ? `tasks \xB7 ${jobName}` : "all tasks");
+  out(renderTasks(page.tasks));
+}
+async function cmdRuns(flags, useJson) {
+  const client = makeClient();
+  const limit = clampLimit(flags["limit"]);
+  const status = typeof flags["status"] === "string" ? flags["status"] : void 0;
+  const page = await client.runs.list({ limit, ...status ? { status } : {} });
+  if (useJson) return json(page);
+  header(`recent runs${status ? ` \xB7 ${status}` : ""}`);
+  const now = Date.now();
+  out(
+    table(
+      [{ header: "WHEN" }, { header: "TASK" }, { header: "JOB" }, { header: "STATUS" }, { header: "HTTP", align: "right" }, { header: "TOOK", align: "right" }],
+      page.runs.map((r) => [
+        relativeTime(r.startedAt, now),
+        c.bold(r.taskName),
+        c.gray(r.jobName),
+        statusColor(r.status),
+        r.httpStatusCode == null ? c.gray("\u2014") : String(r.httpStatusCode),
+        r.durationMs == null ? c.gray("\u2014") : `${r.durationMs}ms`
+      ])
+    )
+  );
+  out();
+  out(c.gray(`showing ${page.runs.length} of ${page.pagination.total} runs`));
+}
+async function cmdRun(positionals, useJson) {
+  const client = makeClient();
+  let taskId;
+  if (positionals.length >= 2) {
+    const [jobName, taskName] = positionals;
+    const container = (await client.jobs.list()).find((j) => j.name === jobName);
+    if (!container) throw new CronvelloConfigError(`No job container named "${jobName}".`);
+    const task = (await client.jobs.listTasks(container.id)).find((t) => t.name === taskName);
+    if (!task) throw new CronvelloConfigError(`No task "${taskName}" in "${jobName}".`);
+    taskId = task.id;
+  } else if (positionals.length === 1) {
+    taskId = positionals[0];
+  } else {
+    throw new CronvelloConfigError("Usage: cronvello run <taskId>  |  cronvello run <jobName> <taskName>");
+  }
+  const res = await client.tasks.runNow(taskId);
+  if (useJson) return json(res);
+  if (res.success) out(`${sym.ok} triggered ${c.bold(taskId)} ${res.runId ? c.gray(`\u2192 ${res.runId}`) : ""}`);
+  else out(`${sym.fail} ${c.red(res.error ?? "run failed")}`);
+}
+async function cmdStatus(useJson) {
+  const client = makeClient();
+  const [me, jobs, failures] = await Promise.all([
+    client.account.me(),
+    client.jobs.list(),
+    client.runs.list({ limit: 5, status: "failed" })
+  ]);
+  if (useJson) return json({ me, jobs, recentFailures: failures.runs });
+  const totalTasks = jobs.reduce((n, j) => n + j.taskCount, 0);
+  const activeTasks = jobs.reduce((n, j) => n + j.activeTaskCount, 0);
+  const errorTasks = jobs.reduce((n, j) => n + j.errorTaskCount, 0);
+  const healthy = errorTasks === 0 && me.summary.openDlqCount === 0;
+  header("status");
+  out(`${healthy ? sym.ok : sym.warn} ${healthy ? c.green("healthy") : c.yellow("needs attention")}`);
+  out();
+  out(`  ${c.dim("containers")}  ${jobs.length}`);
+  out(`  ${c.dim("tasks")}       ${activeTasks}/${totalTasks} active${errorTasks ? c.red(` \xB7 ${errorTasks} errored`) : ""}`);
+  out(`  ${c.dim("open DLQ")}    ${me.summary.openDlqCount ? c.red(String(me.summary.openDlqCount)) : c.gray("0")}`);
+  out(`  ${c.dim("executions")}  ${me.usage.executionCount} this period`);
+  if (failures.runs.length) {
+    out();
+    out(c.dim("  recent failures:"));
+    const now = Date.now();
+    for (const r of failures.runs) out(`   ${sym.fail} ${c.bold(r.taskName)} ${c.gray(r.jobName)} ${relativeTime(r.startedAt, now)} ${r.error ? c.red(truncate(r.error, 50)) : ""}`);
+  }
+}
+async function cmdSync(positionals, flags, useJson) {
+  const app = await loadApp(positionals[0]);
+  const dryRun = !!flags["dry"] || !!flags["dry-run"];
+  const result = await app.sync({ dryRun });
+  if (useJson) return json(result);
+  out(formatSyncResult(result, { color: true, dryRun }));
+}
+async function cmdDev(positionals, useJson) {
+  const jobKey = positionals[positionals.length - 1];
+  const configPath = positionals.length >= 2 ? positionals[0] : void 0;
+  if (!jobKey) throw new CronvelloConfigError("Usage: cronvello dev [configPath] <jobKey>");
+  const app = await loadApp(configPath);
+  if (!app.keys().includes(jobKey)) {
+    throw new CronvelloConfigError(`Unknown job "${jobKey}". Known: ${app.keys().join(", ") || "(none)"}`);
+  }
+  if (!useJson) out(`${sym.arrow} running ${c.bold(jobKey)} locally\u2026`);
+  const started = Date.now();
+  const result = await app.trigger(jobKey);
+  if (useJson) return json({ job: jobKey, result });
+  out(`${sym.ok} ${c.bold(jobKey)} ${c.gray(`done in ${Date.now() - started}ms`)}`);
+  if (result !== void 0 && result !== null) {
+    out(c.dim("  result:"));
+    out(JSON.stringify(result, null, 2).split("\n").map((l) => "  " + l).join("\n"));
+  }
+}
+function cmdSecret(useJson) {
+  const secret = generateDispatchSecret();
+  if (useJson) return json({ dispatchSecret: secret });
+  out(secret);
+}
+var DEFAULT_CONFIG_PATHS = [
+  "cronvello.config.ts",
+  "cronvello.config.js",
+  "cronvello.config.mjs",
+  "cronvello.ts",
+  "cronvello.js",
+  "src/cronvello.ts",
+  "src/cronvello.js"
+];
+function looksLikeApp(v) {
+  return !!v && typeof v === "object" && typeof v.sync === "function" && typeof v.trigger === "function";
+}
+async function loadApp(pathArg) {
+  const candidate = pathArg ?? DEFAULT_CONFIG_PATHS.find((p) => existsSync(resolve(process.cwd(), p)));
+  if (!candidate) {
+    throw new CronvelloConfigError(
+      `No config module found. Pass a path (cronvello sync ./cronvello.config.js) or add one of: ${DEFAULT_CONFIG_PATHS.join(", ")}.`
+    );
+  }
+  const abs = resolve(process.cwd(), candidate);
+  if (!existsSync(abs)) throw new CronvelloConfigError(`Config module not found: ${abs}`);
+  let mod;
+  try {
+    mod = await import(pathToFileURL(abs).href);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (/Unknown file extension|\.ts|ERR_UNKNOWN/.test(msg) && abs.endsWith(".ts")) {
+      throw new CronvelloConfigError(
+        `Could not import a TypeScript config directly. Run the CLI under a TS loader, e.g.
+  node --import tsx node_modules/@cronvello/sdk/dist/cli.js sync ${candidate}
+or point at a compiled .js file.`
+      );
+    }
+    throw new CronvelloConfigError(`Failed to import ${candidate}: ${msg}`);
+  }
+  const found = looksLikeApp(mod["default"]) ? mod["default"] : looksLikeApp(mod["cronvello"]) ? mod["cronvello"] : looksLikeApp(mod["app"]) ? mod["app"] : Object.values(mod).find(looksLikeApp);
+  if (!found) {
+    throw new CronvelloConfigError(`${candidate} does not export a Cronvello app (export default defineCronvello({\u2026}) or a named \`cronvello\`).`);
+  }
+  return found;
+}
+function printHelp() {
+  out(`${ICON} ${brand("Cronvello")} ${c.gray("\xB7 code-first cron")}  ${c.dim("v" + VERSION)}`);
+  out();
+  out(c.bold("USAGE"));
+  out(`  ${c.cyan("cronvello")} <command> [options]`);
+  out();
+  out(c.bold("COMMANDS"));
+  const cmds = [
+    ["whoami", "account, plan, limits & usage"],
+    ["list [jobName]", "job containers, or tasks inside one"],
+    ["tasks [--job <name>]", "account-wide task table"],
+    ["runs [--limit n] [--status s]", "recent execution feed"],
+    ["run <taskId>", "trigger a task now (or: run <jobName> <taskName>)"],
+    ["status", "health overview + recent failures"],
+    ["sync [path] [--dry]", "reconcile a code registry (loads your module)"],
+    ["dev [path] <jobKey>", "run a job handler locally, no deploy"],
+    ["secret", "generate a strong dispatch secret"]
+  ];
+  for (const [name, desc] of cmds) out(`  ${c.cyan(name.padEnd(30))} ${c.gray(desc)}`);
+  out();
+  out(c.bold("GLOBAL"));
+  out(`  ${c.cyan("--json".padEnd(30))} ${c.gray("machine-readable output")}`);
+  out(`  ${c.cyan("--no-color".padEnd(30))} ${c.gray("disable colour")}`);
+  out(`  ${c.cyan("-h, --help".padEnd(30))} ${c.gray("show this help")}`);
+  out(`  ${c.cyan("-v, --version".padEnd(30))} ${c.gray("print version")}`);
+  out();
+  out(c.gray("Auth: export CRONVELLO_API_KEY (crn_live_\u2026). Optional: CRONVELLO_API_URL."));
+}
+function clampLimit(v) {
+  const n = typeof v === "string" ? Number(v) : NaN;
+  if (!Number.isFinite(n)) return 20;
+  return Math.min(Math.max(Math.trunc(n), 1), 100);
+}
+function truncate(s, n) {
+  return s.length > n ? s.slice(0, n - 1) + "\u2026" : s;
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  if (args.flags["no-color"]) setColor(false);
+  const useJson = !!args.flags["json"];
+  if (args.flags["version"] || args.flags["v"]) {
+    out(VERSION);
+    return 0;
+  }
+  if (!args.command || args.flags["help"] || args.flags["h"] || args.command === "help") {
+    printHelp();
+    return 0;
+  }
+  try {
+    switch (args.command) {
+      case "whoami":
+        await cmdWhoami(useJson);
+        break;
+      case "list":
+        await cmdList(args.positionals[0], useJson);
+        break;
+      case "tasks":
+        await cmdTasks(args.flags, useJson);
+        break;
+      case "runs":
+        await cmdRuns(args.flags, useJson);
+        break;
+      case "run":
+        await cmdRun(args.positionals, useJson);
+        break;
+      case "status":
+        await cmdStatus(useJson);
+        break;
+      case "sync":
+        await cmdSync(args.positionals, args.flags, useJson);
+        break;
+      case "dev":
+        await cmdDev(args.positionals, useJson);
+        break;
+      case "secret":
+        cmdSecret(useJson);
+        break;
+      default:
+        out(`${sym.fail} Unknown command "${args.command}". Run ${c.cyan("cronvello --help")}.`);
+        return 1;
+    }
+    return 0;
+  } catch (err) {
+    if (err instanceof CronvelloApiError) {
+      out(`${sym.fail} ${c.red(`API ${err.status}`)} ${err.message}${err.isRateLimited && err.retryAfterSeconds ? c.gray(` (retry in ${err.retryAfterSeconds}s)`) : ""}`);
+    } else if (err instanceof CronvelloConfigError) {
+      out(`${sym.fail} ${err.message}`);
+    } else {
+      out(`${sym.fail} ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return 1;
+  }
+}
+var invokedDirectly = typeof process !== "undefined" && Array.isArray(process.argv) && /[\\/]cli\.(c?js|ts)$/.test(process.argv[1] ?? "");
+if (invokedDirectly) {
+  run(process.argv.slice(2)).then((code) => {
+    process.exitCode = code;
+  });
+}
+
+export { run };
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map