@quickengine/cli 0.2.0

package/dist/index.js

@@ -0,0 +1,1849 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/index.ts
+import { QuickApiError as QuickApiError2 } from "@quickengine/quick";
+import { Command } from "commander";
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { createQuick } from "@quickengine/quick";
+var CONFIG_DIR = join(homedir(), ".quick");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function credentialFromKey(key) {
+  if (key.startsWith("qpk_")) return { type: "publishable", key };
+  if (key.startsWith("qsk_")) return { type: "secret", token: key };
+  if (key.startsWith("qsc_")) return { type: "scoped", token: key };
+  throw new Error(
+    "Unrecognized key format. Expected a key starting with qpk_, qsk_, or qsc_."
+  );
+}
+function readConfigFile() {
+  if (!existsSync(CONFIG_PATH)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+    if (typeof parsed !== "object" || parsed === null) return {};
+    return parsed;
+  } catch (e) {
+    return {};
+  }
+}
+function resolveConfig(env = process.env) {
+  var _a, _b, _c;
+  const file = readConfigFile();
+  return {
+    baseUrl: (_a = env.QUICK_BASE_URL) != null ? _a : file.baseUrl,
+    workspaceId: (_b = env.QUICK_WORKSPACE) != null ? _b : file.workspaceId,
+    key: (_c = env.QUICK_KEY) != null ? _c : file.key
+  };
+}
+function prune(patch) {
+  return Object.fromEntries(
+    Object.entries(patch).filter(
+      ([, value]) => value !== void 0 && value !== ""
+    )
+  );
+}
+function writeConfigFile(patch) {
+  const next = __spreadValues(__spreadValues({}, readConfigFile()), prune(patch));
+  mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+  writeFileSync(CONFIG_PATH, `${JSON.stringify(next, null, 2)}
+`, {
+    mode: 384
+  });
+  return next;
+}
+var MissingConfigError = class extends Error {
+  constructor(missing) {
+    super(
+      `Missing configuration: ${missing.join(
+        ", "
+      )}. Run \`quick config set\`, or set QUICK_BASE_URL / QUICK_WORKSPACE / QUICK_KEY.`
+    );
+    this.missing = missing;
+    this.name = "MissingConfigError";
+  }
+};
+function buildClient(env) {
+  const config = resolveConfig(env);
+  const missing = [];
+  if (!config.baseUrl) missing.push("baseUrl");
+  if (!config.workspaceId) missing.push("workspaceId");
+  if (!config.key) missing.push("key");
+  if (missing.length > 0) throw new MissingConfigError(missing);
+  const resolved = config;
+  const client = createQuick({
+    baseUrl: resolved.baseUrl,
+    workspaceId: resolved.workspaceId,
+    credential: credentialFromKey(resolved.key)
+  });
+  return { client, config: resolved };
+}
+function maskKey(key) {
+  const [prefix] = key.split("_");
+  return `${prefix}_${"\u2022".repeat(8)}`;
+}
+
+// src/output.ts
+function line(text4 = "") {
+  process.stdout.write(`${text4}
+`);
+}
+function errorLine(text4) {
+  process.stderr.write(`${text4}
+`);
+}
+function printJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+
+// src/commands/activity.ts
+var stamp = (iso) => iso.replace("T", " ").replace(/\.\d+Z$/, "");
+function registerActivityCommands(program2) {
+  const activity = program2.command("activity").description("Read the workspace's event history");
+  activity.command("list").description("The most recent events, newest first").option("--limit <n>", "How many to show").option("--json", "Output JSON").action(async (options) => {
+    const { data } = await buildClient().client.activity.list({
+      limit: options.limit ? Number(options.limit) : void 0
+    });
+    if (options.json) return printJson(data);
+    if (!data.events.length) return line("No activity yet.");
+    for (const event of data.events) {
+      line(`  ${stamp(event.occurredAt)}  ${event.name}  ${event.recordId}`);
+    }
+    line("");
+    line(`cursor: ${data.cursor}`);
+  });
+  activity.command("since <cursor>").description("Everything after a cursor, oldest first").option("--limit <n>", "How many to show").option("--json", "Output JSON").action(
+    async (cursor, options) => {
+      const { data } = await buildClient().client.activity.since(
+        Number(cursor),
+        { limit: options.limit ? Number(options.limit) : void 0 }
+      );
+      if (options.json) return printJson(data);
+      if (!data.events.length) return line(`Nothing new since ${cursor}.`);
+      for (const event of data.events) {
+        line(
+          `  ${stamp(event.occurredAt)}  ${event.name}  ${event.recordId}`
+        );
+      }
+      line("");
+      line(`cursor: ${data.cursor}`);
+    }
+  );
+}
+
+// src/commands/bookings.ts
+import { randomUUID } from "crypto";
+function registerBookingCommands(program2) {
+  const bookings = program2.command("bookings").description("Manage the workspace's bookings");
+  bookings.command("list").description("List bookings").option("--json", "Output JSON").option("--limit <number>", "Page size", "25").option("--schedule <key>", "Only this schedule (room, person, resource)").option(
+    "--status <status>",
+    "Filter by requested, confirmed, checked_in, completed, cancelled, or no_show"
+  ).option("--from <iso>", "Only bookings starting at or after this time").option("--to <iso>", "Only bookings starting at or before this time").action(
+    async (options) => {
+      const { data } = await buildClient().client.bookings.list({
+        limit: Number(options.limit),
+        scheduleKey: options.schedule,
+        status: options.status,
+        from: options.from,
+        to: options.to
+      });
+      if (options.json) return printJson(data);
+      if (!data.items.length) return line("No bookings.");
+      for (const item of data.items)
+        line(
+          `${item.id}  [${item.status}]  ${item.startsAt}  ${item.scheduleKey}  ${item.title}`
+        );
+    }
+  );
+  bookings.command("get <id>").description("Show one booking").option("--json", "Output JSON").action(async (id, options) => {
+    const { data } = await buildClient().client.bookings.get(id);
+    if (options.json) return printJson(data);
+    line(`${data.title}  (${data.id})`);
+    line(`  status:   ${data.status}`);
+    line(`  schedule: ${data.scheduleKey}`);
+    line(`  when:     ${data.startsAt} to ${data.endsAt} (${data.timeZone})`);
+    if (data.clientName) line(`  client:   ${data.clientName}`);
+    if (data.cancellationReason)
+      line(`  cancelled: ${data.cancellationReason}`);
+  });
+  bookings.command("create").description("Book a slot").requiredOption("--client <id>", "Client id").requiredOption("--title <text>", "What the booking is for").requiredOption("--starts <iso>", "Start time, ISO 8601").requiredOption("--ends <iso>", "End time, ISO 8601").option("--time-zone <zone>", "IANA time zone", "UTC").option("--schedule <key>", "Schedule this booking competes for", "default").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (options) => {
+      var _a;
+      const { data } = await buildClient().client.bookings.create(
+        {
+          clientId: options.client,
+          title: options.title,
+          startsAt: options.starts,
+          endsAt: options.ends,
+          timeZone: options.timeZone,
+          scheduleKey: options.schedule
+        },
+        (_a = options.idempotencyKey) != null ? _a : randomUUID()
+      );
+      if (options.json) return printJson(data);
+      line(`Booked ${data.title} (${data.id}) at ${data.startsAt}`);
+    }
+  );
+  bookings.command("status <id> <status>").description(
+    "Move a booking between requested, confirmed, checked_in, completed, cancelled, and no_show"
+  ).option("--reason <text>", "Cancellation reason (when cancelling)").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (id, status2, options) => {
+      var _a, _b;
+      const { data } = await buildClient().client.bookings.setStatus(
+        id,
+        status2,
+        (_a = options.idempotencyKey) != null ? _a : randomUUID(),
+        { cancellationReason: (_b = options.reason) != null ? _b : null }
+      );
+      if (options.json) return printJson(data);
+      line(`${data.title} is now ${data.status}`);
+    }
+  );
+}
+
+// src/commands/catalog.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function formatPrice(item) {
+  if (item.priceCents == null) return item.pricingModel;
+  return `${(item.priceCents / 100).toFixed(2)} ${item.currency}`;
+}
+function registerCatalogCommands(program2) {
+  const catalog = program2.command("catalog").description("Manage the workspace's catalog of products and services");
+  catalog.command("list").description("List catalog items").option("--json", "Output JSON").option("--limit <number>", "Page size", "25").option("--status <status>", "Filter by draft, active, or archived").action(
+    async (options) => {
+      const { data } = await buildClient().client.catalog.list({
+        limit: Number(options.limit),
+        status: options.status
+      });
+      if (options.json) return printJson(data);
+      if (!data.items.length) return line("No catalog items.");
+      for (const item of data.items)
+        line(
+          `${item.id}  ${item.name}  [${item.type}/${item.status}]  ${formatPrice(item)}`
+        );
+    }
+  );
+  catalog.command("get <id>").description("Show one catalog item with its variants").option("--json", "Output JSON").action(async (id, options) => {
+    const { client } = buildClient();
+    const { data } = await client.catalog.get(id);
+    const variants = await client.catalog.listVariants(id);
+    if (options.json) return printJson(__spreadProps(__spreadValues({}, data), { variants: variants.data }));
+    line(`${data.name}  (${data.id})`);
+    line(`  type:   ${data.type}`);
+    line(`  status: ${data.status}`);
+    line(`  price:  ${formatPrice(data)}`);
+    if (data.description) line(`  ${data.description}`);
+    if (variants.data.length > 0) {
+      line("  variants:");
+      for (const variant of variants.data) {
+        const opts = variant.options.map((option) => `${option.name}=${option.value}`).join(", ");
+        line(
+          `    ${variant.id}  ${opts}${variant.sku ? `  (${variant.sku})` : ""}`
+        );
+      }
+    }
+  });
+  catalog.command("create").description("Create a catalog item").requiredOption("--name <name>", "Item name").requiredOption(
+    "--type <type>",
+    "physical, digital, service, package, or rental"
+  ).option(
+    "--pricing-model <model>",
+    "fixed, starting_at, hourly, custom_quote, or free"
+  ).option("--price-cents <cents>", "Price in integer cents").option("--sku <sku>", "Stock keeping unit").option("--currency <currency>", "ISO currency code").option("--description <text>", "Description").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (options) => {
+      var _a;
+      const { data } = await buildClient().client.catalog.create(
+        {
+          name: options.name,
+          type: options.type,
+          pricingModel: options.pricingModel,
+          priceCents: options.priceCents != null ? Number(options.priceCents) : void 0,
+          sku: options.sku,
+          currency: options.currency,
+          description: options.description
+        },
+        (_a = options.idempotencyKey) != null ? _a : randomUUID2()
+      );
+      if (options.json) return printJson(data);
+      line(`Created ${data.name} (${data.id})`);
+    }
+  );
+}
+
+// src/commands/clients.ts
+import { randomUUID as randomUUID3 } from "crypto";
+function registerClientCommands(program2) {
+  const clients = program2.command("clients").description("Manage workspace client records");
+  clients.command("list").option("--json", "Output JSON").option("--limit <number>", "Page size", "25").action(async (options) => {
+    const { data } = await buildClient().client.clients.list({
+      limit: Number(options.limit)
+    });
+    if (options.json) return printJson(data);
+    if (!data.items.length) return line("No clients.");
+    for (const item of data.items)
+      line(`${item.id}  ${item.name}${item.email ? `  ${item.email}` : ""}`);
+  });
+  clients.command("get <id>").option("--json", "Output JSON").action(async (id, options) => {
+    const { data } = await buildClient().client.clients.get(id);
+    if (options.json) return printJson(data);
+    line(`${data.name}  (${data.id})`);
+    if (data.email) line(`  email: ${data.email}`);
+    if (data.phone) line(`  phone: ${data.phone}`);
+    if (data.company) line(`  company: ${data.company}`);
+  });
+  clients.command("create").requiredOption("--name <name>", "Client name").option("--email <email>", "Email").option("--phone <phone>", "Phone").option("--company <company>", "Company").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (options) => {
+      var _a;
+      const { data } = await buildClient().client.clients.create(
+        {
+          name: options.name,
+          email: options.email,
+          phone: options.phone,
+          company: options.company
+        },
+        (_a = options.idempotencyKey) != null ? _a : randomUUID3()
+      );
+      if (options.json) return printJson(data);
+      line(`Created ${data.name} (${data.id})`);
+    }
+  );
+}
+
+// src/commands/config.ts
+function registerConfigCommands(program2) {
+  const config = program2.command("config").description("Manage the CLI's stored connection settings");
+  config.command("set").description("Save base URL, workspace, and/or API key").option(
+    "--base-url <url>",
+    "Product API origin, e.g. https://api.quickdash.xyz"
+  ).option("--workspace <id>", "Workspace id to scope requests to").option(
+    "--key <key>",
+    "An API key (qpk_/qsk_/qsc_) from Account \u2192 workspace \u2192 API keys"
+  ).action(
+    (options) => {
+      var _a, _b;
+      const saved = writeConfigFile({
+        baseUrl: options.baseUrl,
+        workspaceId: options.workspace,
+        key: options.key
+      });
+      line(`Saved to ${CONFIG_PATH}`);
+      line(`  base URL:  ${(_a = saved.baseUrl) != null ? _a : "(unset)"}`);
+      line(`  workspace: ${(_b = saved.workspaceId) != null ? _b : "(unset)"}`);
+      line(`  key:       ${saved.key ? maskKey(saved.key) : "(unset)"}`);
+    }
+  );
+  config.command("show").description("Show the resolved settings (key masked)").option("--json", "Output JSON").action((options) => {
+    var _a, _b, _c, _d, _e;
+    const resolved = resolveConfig();
+    const view = {
+      baseUrl: (_a = resolved.baseUrl) != null ? _a : null,
+      workspaceId: (_b = resolved.workspaceId) != null ? _b : null,
+      key: resolved.key ? maskKey(resolved.key) : null
+    };
+    if (options.json) {
+      printJson(view);
+      return;
+    }
+    line(`base URL:  ${(_c = view.baseUrl) != null ? _c : "(unset)"}`);
+    line(`workspace: ${(_d = view.workspaceId) != null ? _d : "(unset)"}`);
+    line(`key:       ${(_e = view.key) != null ? _e : "(unset)"}`);
+  });
+}
+
+// src/commands/contracts.ts
+import { randomUUID as randomUUID4 } from "crypto";
+function registerContractCommands(program2) {
+  const contracts = program2.command("contracts").description("Manage the workspace's contracts and e-signatures");
+  contracts.command("list").description("List contracts").option("--json", "Output JSON").option("--limit <number>", "Page size", "25").option("--client <id>", "Only this client").option(
+    "--status <status>",
+    "draft, sent, partially_signed, completed, declined, expired, voided, or superseded"
+  ).action(
+    async (options) => {
+      const { data } = await buildClient().client.contracts.list({
+        limit: Number(options.limit),
+        clientId: options.client,
+        status: options.status
+      });
+      if (options.json) return printJson(data);
+      if (!data.items.length) return line("No contracts.");
+      for (const item of data.items)
+        line(`${item.id}  ${item.number}  [${item.status}]  ${item.title}`);
+    }
+  );
+  contracts.command("get <id>").description("Show one contract with its signers").option("--json", "Output JSON").action(async (id, options) => {
+    var _a;
+    const { data } = await buildClient().client.contracts.get(id);
+    if (options.json) return printJson(data);
+    line(`${data.number}  ${data.title}  (${data.id})`);
+    line(`  status: ${data.status}`);
+    line(`  client: ${data.clientName}`);
+    for (const signer of (_a = data.signers) != null ? _a : [])
+      line(
+        `    ${signer.position}. ${signer.name} <${signer.email}>  [${signer.status}]`
+      );
+  });
+  contracts.command("create").description("Create a draft contract").requiredOption("--title <text>", "Contract title").option("--client <id>", "Client id").option("--version <id>", "File version id of the document to sign").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (options) => {
+      var _a, _b, _c;
+      const { data } = await buildClient().client.contracts.create(
+        {
+          title: options.title,
+          clientId: (_a = options.client) != null ? _a : null,
+          fileVersionId: (_b = options.version) != null ? _b : null
+        },
+        (_c = options.idempotencyKey) != null ? _c : randomUUID4()
+      );
+      if (options.json) return printJson(data);
+      line(`Created ${data.number} (${data.id})`);
+    }
+  );
+  contracts.command("send <id>").description("Send a contract for signature").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (id, options) => {
+      var _a;
+      const { data } = await buildClient().client.contracts.send(
+        id,
+        (_a = options.idempotencyKey) != null ? _a : randomUUID4()
+      );
+      if (options.json) return printJson(data);
+      line(`Sent ${data.number} to ${data.invitations.length} signer(s):`);
+      for (const invitation of data.invitations)
+        line(`  ${invitation.name} <${invitation.email}>`);
+      line("Signing links are emailed to each signer, not shown here.");
+    }
+  );
+  contracts.command("void <id>").description("Void a contract").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (id, options) => {
+      var _a;
+      const { data } = await buildClient().client.contracts.void(
+        id,
+        (_a = options.idempotencyKey) != null ? _a : randomUUID4()
+      );
+      if (options.json) return printJson(data);
+      line(`${data.number} is now ${data.status}`);
+    }
+  );
+  contracts.command("revise <id>").description("Supersede a contract with a new revision").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (id, options) => {
+      var _a;
+      const { data } = await buildClient().client.contracts.revise(
+        id,
+        (_a = options.idempotencyKey) != null ? _a : randomUUID4()
+      );
+      if (options.json) return printJson(data);
+      line(`Created revision ${data.number} (${data.id})`);
+    }
+  );
+}
+
+// src/commands/create.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2, resolve } from "path";
+import {
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  log,
+  note,
+  outro,
+  text
+} from "@clack/prompts";
+
+// src/defaults.ts
+import { createRequire } from "module";
+var import_meta = {};
+var DEFAULT_API_URL = "https://api.quickdash.xyz";
+var require2 = createRequire(import_meta.url);
+var QUICK_SDK_VERSION = require2("@quickengine/quick/package.json").version;
+
+// src/scaffold.ts
+var packageJson = (input) => `${JSON.stringify(
+  {
+    name: input.name,
+    private: true,
+    type: "module",
+    scripts: {
+      start: "node --env-file=.env index.js"
+    },
+    dependencies: {
+      "@quickengine/quick": `^${input.sdkVersion}`
+    }
+  },
+  null,
+  2
+)}
+`;
+var entrypoint = () => `import { createQuickServer } from "@quickengine/quick";
+
+// A secret key must never reach a browser. This runs on a server, so it is safe
+// here \u2014 and \`createQuickServer\` is the entry point that expects one.
+const quick = createQuickServer({
+  baseUrl: process.env.QUICKENGINE_API_URL,
+  workspaceId: process.env.QUICKENGINE_WORKSPACE_ID,
+  credential: { type: "secret", token: process.env.QUICKENGINE_KEY },
+});
+
+// Read something real, to prove the connection end to end.
+const { data } = await quick.clients.list();
+console.log(\`Connected. This workspace has \${data.items.length} client record(s).\`);
+
+// Create one. Every write is idempotent: repeating a request with the same key
+// returns the original result instead of creating a duplicate \u2014 which is what
+// makes retrying safe.
+const created = await quick.clients.create(
+  { name: "Ada Lovelace", email: "ada@example.com" },
+  \`seed-\${new Date().toISOString().slice(0, 10)}\`,
+);
+console.log("Created client:", created.data.id);
+`;
+var envFile = (input) => {
+  var _a;
+  return `QUICKENGINE_API_URL=${input.baseUrl}
+QUICKENGINE_WORKSPACE_ID=${input.workspaceId}
+QUICKENGINE_KEY=${(_a = input.key) != null ? _a : ""}
+`;
+};
+var envExample = (input) => `QUICKENGINE_API_URL=${input.baseUrl}
+QUICKENGINE_WORKSPACE_ID=${input.workspaceId}
+# Create a secret key in Account \u2192 API keys. Never commit this value.
+QUICKENGINE_KEY=
+`;
+var gitignore = () => `node_modules/
+.env
+`;
+var readme = (input) => `# ${input.name}
+
+A minimal QuickEngine app: one file, one dependency, one working call.
+
+## Run it
+
+\`\`\`sh
+npm install
+npm start
+\`\`\`
+
+\`.env\` needs a secret key (\`qsk_\u2026\`) from Account \u2192 API keys.${input.key ? " One has already been written for you." : ""}
+
+## What \`index.js\` shows
+
+- **Reading** \u2014 \`quick.clients.list()\` proves the credential and workspace resolve.
+- **Writing idempotently** \u2014 the create passes an \`idempotencyKey\`, so running
+  \`npm start\` twice does not produce two Adas. Retrying is safe by construction.
+
+## Where to go next
+
+- \`quick\` \u2014 the CLI, for inspecting the same workspace from a terminal.
+- \`quick.invoices\`, \`quick.quotes\`, \`quick.orders\`, \u2026 \u2014 same shape as \`clients\`.
+- \`quick.activity.since(cursor)\` \u2014 everything that happened while you were away.
+- Webhooks \u2014 have QuickEngine call *you* when something changes.
+`;
+function scaffoldFiles(input) {
+  const files = [
+    { path: "package.json", contents: packageJson(input) },
+    { path: "index.js", contents: entrypoint() },
+    { path: ".env.example", contents: envExample(input) },
+    { path: ".gitignore", contents: gitignore() },
+    { path: "README.md", contents: readme(input) }
+  ];
+  files.push({ path: ".env", contents: envFile(input), mode: 384 });
+  return files;
+}
+
+// src/commands/create.ts
+function ensure(value) {
+  if (isCancel(value)) {
+    cancel("Cancelled \u2014 nothing was written.");
+    process.exit(0);
+  }
+  return value;
+}
+var NAME = /^[a-z0-9][a-z0-9._-]*$/;
+function registerCreateCommands(program2) {
+  const create = program2.command("create").description("Generate a new project wired to a workspace");
+  create.command("app [name]").description("A minimal app with the SDK installed and one working call").option("--base-url <url>", "API URL to target").option("--workspace <id>", "Workspace id to target").option("--yes", "Accept defaults without prompting").action(
+    async (name, options) => {
+      var _a, _b, _c, _d;
+      const existing = resolveConfig();
+      intro("Create a QuickEngine app");
+      const appName = name != null ? name : options.yes ? "quickengine-app" : ensure(
+        await text({
+          message: "Project name",
+          placeholder: "my-backend",
+          defaultValue: "quickengine-app",
+          initialValue: "quickengine-app",
+          validate: (value) => NAME.test((value != null ? value : "").trim()) ? void 0 : "Lowercase letters, digits, dots, dashes, underscores."
+        })
+      );
+      if (!NAME.test(appName)) {
+        cancel(`"${appName}" is not a usable project name.`);
+        process.exitCode = 1;
+        return;
+      }
+      const directory = resolve(process.cwd(), appName);
+      if (existsSync2(directory) && readdirSync(directory).length > 0) {
+        cancel(`${directory} already exists and is not empty.`);
+        process.exitCode = 1;
+        return;
+      }
+      const baseUrl = (_b = (_a = options.baseUrl) != null ? _a : existing.baseUrl) != null ? _b : DEFAULT_API_URL;
+      const workspaceId = (_d = (_c = options.workspace) != null ? _c : existing.workspaceId) != null ? _d : "";
+      if (!workspaceId) {
+        log.warn(
+          "No workspace configured \u2014 .env will need one. Run `quick init` first to skip this."
+        );
+      }
+      let key;
+      if (existing.key && !options.yes) {
+        const reuse = ensure(
+          await confirm({
+            message: "Write your current API key into the project's .env?",
+            initialValue: true
+          })
+        );
+        if (reuse) key = existing.key;
+      }
+      const files = scaffoldFiles({
+        name: appName,
+        baseUrl,
+        workspaceId,
+        key,
+        sdkVersion: QUICK_SDK_VERSION
+      });
+      mkdirSync2(directory, { recursive: true });
+      for (const file of files) {
+        writeFileSync2(join2(directory, file.path), file.contents, {
+          mode: file.mode
+        });
+      }
+      note(
+        [
+          `cd ${appName}`,
+          "npm install",
+          key ? "npm start" : "# add QUICKENGINE_KEY to .env, then:\nnpm start"
+        ].join("\n"),
+        "Next"
+      );
+      log.success(`Created ${files.length} files in ${appName}/`);
+      outro(
+        key ? "Ready to run." : "Add a secret key from Account \u2192 API keys to .env, then `npm start`."
+      );
+    }
+  );
+}
+
+// src/verify.ts
+import { QuickApiError } from "@quickengine/quick";
+async function verifyConnection(config, connect = buildClient) {
+  try {
+    if (config == null ? void 0 : config.key) credentialFromKey(config.key);
+  } catch (error) {
+    return {
+      ok: false,
+      reason: "key",
+      detail: error instanceof Error ? error.message : "unrecognized key format"
+    };
+  }
+  try {
+    const { client } = connect(
+      config ? {
+        QUICK_BASE_URL: config.baseUrl,
+        QUICK_WORKSPACE: config.workspaceId,
+        QUICK_KEY: config.key
+      } : void 0
+    );
+    const { data } = await client.clients.list();
+    return { ok: true, detail: `read ${data.items.length} client record(s)` };
+  } catch (error) {
+    if (!(error instanceof QuickApiError)) {
+      return {
+        ok: false,
+        reason: "network",
+        detail: error instanceof Error ? error.message : "unknown error"
+      };
+    }
+    switch (error.code) {
+      // The key was accepted; it simply may not read clients. Connection proven.
+      case "CAPABILITY_DENIED":
+      case "MODULE_DISABLED":
+        return {
+          ok: true,
+          detail: `connected (this key cannot read clients: ${error.code})`
+        };
+      case "AUTHENTICATION_REQUIRED":
+      case "INVALID_API_KEY":
+      case "CREDENTIAL_CHANNEL_MISMATCH":
+        return {
+          ok: false,
+          reason: "key",
+          detail: `${error.code} \u2014 check the API key`
+        };
+      case "WORKSPACE_NOT_FOUND":
+      case "WORKSPACE_MISMATCH":
+      case "WORKSPACE_REQUIRED":
+        return {
+          ok: false,
+          reason: "workspace",
+          detail: `${error.code} \u2014 check the workspace id`
+        };
+      default:
+        return {
+          ok: false,
+          reason: "network",
+          detail: `${error.code} (HTTP ${error.status})`
+        };
+    }
+  }
+}
+
+// src/commands/doctor.ts
+function check(label, passed, detail) {
+  line(`${passed ? "\u2713" : "\u2717"} ${label}${detail ? ` \u2014 ${detail}` : ""}`);
+  return passed;
+}
+function registerDoctorCommand(program2) {
+  program2.command("doctor").description("Check configuration and connectivity").action(async () => {
+    const config = resolveConfig();
+    let ok = true;
+    ok = check("base URL set", Boolean(config.baseUrl)) && ok;
+    ok = check("workspace set", Boolean(config.workspaceId)) && ok;
+    ok = check("key set", Boolean(config.key)) && ok;
+    if (config.key) {
+      try {
+        const credential = credentialFromKey(config.key);
+        check(`key format (${credential.type})`, true);
+      } catch (error) {
+        ok = false;
+        check(
+          "key format",
+          false,
+          error instanceof Error ? error.message : void 0
+        );
+      }
+    }
+    if (config.baseUrl && config.workspaceId && config.key) {
+      const result = await verifyConnection();
+      ok = check("API reachable", result.ok, result.detail) && ok;
+    }
+    line("");
+    line(ok ? "All checks passed." : "Some checks failed \u2014 see above.");
+    if (!ok) process.exitCode = 1;
+  });
+}
+
+// src/commands/files.ts
+import { randomUUID as randomUUID5 } from "crypto";
+var size = (bytes) => bytes < 1024 ? `${bytes}B` : bytes < 1024 * 1024 ? `${(bytes / 1024).toFixed(1)}KB` : `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+function registerFileCommands(program2) {
+  const files = program2.command("files").description("Manage the workspace's folders and documents");
+  files.command("folders").description("List folders").option("--json", "Output JSON").option("--limit <number>", "Page size", "25").option("--parent <id>", "Only folders inside this one").option("--root", "Only top-level folders").action(
+    async (options) => {
+      const { data } = await buildClient().client.files.listFolders({
+        limit: Number(options.limit),
+        parentId: options.parent,
+        rootOnly: options.root
+      });
+      if (options.json) return printJson(data);
+      if (!data.items.length) return line("No folders.");
+      for (const folder of data.items)
+        line(`${folder.id}  ${folder.parentId ? "\u2514 " : ""}${folder.name}`);
+    }
+  );
+  files.command("new-folder <name>").description("Create a folder").option("--parent <id>", "Parent folder id").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (name, options) => {
+      var _a, _b;
+      const { data } = await buildClient().client.files.createFolder(
+        { name, parentId: (_a = options.parent) != null ? _a : null },
+        (_b = options.idempotencyKey) != null ? _b : randomUUID5()
+      );
+      if (options.json) return printJson(data);
+      line(`Created folder ${data.name} (${data.id})`);
+    }
+  );
+  files.command("list").description("List documents").option("--json", "Output JSON").option("--limit <number>", "Page size", "25").option("--folder <id>", "Only documents in this folder").option("--status <status>", "active, archived, trashed, or deleting").action(
+    async (options) => {
+      var _a;
+      const { data } = await buildClient().client.files.list({
+        limit: Number(options.limit),
+        folderId: options.folder,
+        status: options.status
+      });
+      if (options.json) return printJson(data);
+      if (!data.items.length) return line("No documents.");
+      for (const doc of data.items)
+        line(
+          `${doc.id}  [${doc.status}]  v${(_a = doc.currentVersionNumber) != null ? _a : "-"}  ${doc.title}`
+        );
+    }
+  );
+  files.command("get <id>").description("Show one document with its version history").option("--json", "Output JSON").action(async (id, options) => {
+    var _a, _b;
+    const { data } = await buildClient().client.files.get(id);
+    if (options.json) return printJson(data);
+    line(`${data.title}  (${data.id})`);
+    line(`  status:  ${data.status}`);
+    line(`  current: v${(_a = data.currentVersionNumber) != null ? _a : "none"}`);
+    for (const version of (_b = data.versions) != null ? _b : [])
+      line(
+        `    v${version.versionNumber}  [${version.status}]  ${version.originalName}  ${size(version.sizeBytes)}`
+      );
+  });
+  files.command("status <id> <status>").description(
+    "Move a document between active, archived, trashed, and deleting (trash before deleting)"
+  ).option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (id, status2, options) => {
+      var _a;
+      const { data } = await buildClient().client.files.setStatus(
+        id,
+        status2,
+        (_a = options.idempotencyKey) != null ? _a : randomUUID5()
+      );
+      if (options.json) return printJson(data);
+      line(`${data.title} is now ${data.status}`);
+    }
+  );
+  files.command("release <versionId>").description("Release a quarantined version for use").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (versionId, options) => {
+      var _a;
+      const { data } = await buildClient().client.files.releaseVersion(
+        versionId,
+        (_a = options.idempotencyKey) != null ? _a : randomUUID5()
+      );
+      if (options.json) return printJson(data);
+      line(`Version v${data.versionNumber} is now ${data.status}`);
+    }
+  );
+}
+
+// src/commands/fulfillments.ts
+import { randomUUID as randomUUID6 } from "crypto";
+function registerFulfillmentCommands(program2) {
+  const fulfillments = program2.command("fulfillments").description("Manage the workspace's deliveries");
+  fulfillments.command("list").description("List deliveries").option("--json", "Output JSON").option("--limit <number>", "Page size", "25").option(
+    "--status <status>",
+    "Filter by pending, in_progress, fulfilled, failed, or cancelled"
+  ).action(
+    async (options) => {
+      const { data } = await buildClient().client.fulfillments.list({
+        limit: Number(options.limit),
+        status: options.status
+      });
+      if (options.json) return printJson(data);
+      if (!data.items.length) return line("No deliveries.");
+      for (const item of data.items)
+        line(`${item.id}  [${item.status}]  ${item.kind}  ${item.title}`);
+    }
+  );
+  fulfillments.command("get <id>").description("Show one delivery").option("--json", "Output JSON").action(async (id, options) => {
+    var _a;
+    const { data } = await buildClient().client.fulfillments.get(id);
+    if (options.json) return printJson(data);
+    line(`${data.title}  (${data.id})`);
+    line(`  status: ${data.status}`);
+    line(`  kind:   ${data.kind}`);
+    if (data.clientName) line(`  client: ${data.clientName}`);
+    if (data.sourceModule)
+      line(`  source: ${data.sourceModule} ${(_a = data.sourceRecordId) != null ? _a : ""}`);
+  });
+  fulfillments.command("status <id> <status>").description(
+    "Move a delivery between pending, in_progress, fulfilled, failed, and cancelled"
+  ).option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (id, status2, options) => {
+      var _a;
+      const { data } = await buildClient().client.fulfillments.setStatus(
+        id,
+        status2,
+        (_a = options.idempotencyKey) != null ? _a : randomUUID6()
+      );
+      if (options.json) return printJson(data);
+      line(`${data.title} is now ${data.status}`);
+    }
+  );
+}
+
+// src/commands/init.ts
+import {
+  cancel as cancel2,
+  confirm as confirm2,
+  intro as intro2,
+  isCancel as isCancel2,
+  log as log2,
+  outro as outro2,
+  password,
+  spinner,
+  text as text2
+} from "@clack/prompts";
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function ensure2(value) {
+  if (isCancel2(value)) {
+    cancel2("Setup cancelled \u2014 nothing was saved.");
+    process.exit(0);
+  }
+  return value;
+}
+function registerInitCommand(program2) {
+  program2.command("init").description("Set up the CLI: API URL, workspace, and key").option("--force", "Reconfigure even if settings already exist").action(async (options) => {
+    var _a, _b, _c;
+    const existing = resolveConfig();
+    intro2("QuickEngine CLI setup");
+    if (!options.force && existing.baseUrl && existing.workspaceId && existing.key) {
+      log2.info(
+        `Already configured \u2014 ${existing.workspaceId} at ${existing.baseUrl}`
+      );
+      const again = ensure2(
+        await confirm2({
+          message: "Reconfigure?",
+          initialValue: false
+        })
+      );
+      if (!again) {
+        outro2("Left unchanged. Run `quick doctor` to check it still works.");
+        return;
+      }
+    }
+    const baseUrl = ensure2(
+      await text2({
+        message: "API URL",
+        placeholder: DEFAULT_API_URL,
+        defaultValue: (_a = existing.baseUrl) != null ? _a : DEFAULT_API_URL,
+        initialValue: (_b = existing.baseUrl) != null ? _b : DEFAULT_API_URL,
+        validate: (value) => {
+          try {
+            new URL(value != null ? value : "");
+          } catch (e) {
+            return "That is not a valid URL.";
+          }
+        }
+      })
+    );
+    const workspaceId = ensure2(
+      await text2({
+        message: "Workspace id",
+        placeholder: "00000000-0000-4000-8000-000000000000",
+        initialValue: (_c = existing.workspaceId) != null ? _c : "",
+        // Caught here rather than as a confusing WORKSPACE_NOT_FOUND later.
+        validate: (value) => UUID.test((value != null ? value : "").trim()) ? void 0 : "A workspace id is a UUID \u2014 copy it from Account."
+      })
+    );
+    const key = ensure2(
+      await password({
+        message: "API key",
+        // Never echoed: this is a live credential, and terminals keep scrollback.
+        validate: (value) => /^(qpk|qsk|qsc)_/.test((value != null ? value : "").trim()) ? void 0 : "Keys start with qpk_, qsk_, or qsc_."
+      })
+    );
+    const config = {
+      baseUrl: baseUrl.trim(),
+      workspaceId: workspaceId.trim(),
+      key: key.trim()
+    };
+    const checking = spinner();
+    checking.start("Checking the connection");
+    const result = await verifyConnection(config);
+    checking.stop(
+      result.ok ? `Connected \u2014 ${result.detail}` : "Could not connect"
+    );
+    if (!result.ok) {
+      log2.error(result.detail);
+      const save = ensure2(
+        await confirm2({
+          message: "Save these settings anyway?",
+          initialValue: false
+        })
+      );
+      if (!save) {
+        cancel2("Nothing was saved. Run `quick init` again when ready.");
+        return;
+      }
+    }
+    writeConfigFile(config);
+    log2.success(`Saved to ${CONFIG_PATH} (owner-only)`);
+    log2.info(`workspace ${config.workspaceId} \xB7 key ${maskKey(config.key)}`);
+    outro2(
+      "Ready. Try `quick clients list`, or run `quick` for a guided menu."
+    );
+  });
+}
+
+// src/commands/inventory.ts
+import { randomUUID as randomUUID7 } from "crypto";
+function registerInventoryCommands(program2) {
+  const inventory = program2.command("inventory").description("Manage the workspace's stock");
+  inventory.command("list").description("List tracked stock records").option("--json", "Output JSON").option("--limit <number>", "Page size", "25").option("--status <status>", "Filter by active or archived").action(
+    async (options) => {
+      const { data } = await buildClient().client.inventory.list({
+        limit: Number(options.limit),
+        status: options.status
+      });
+      if (options.json) return printJson(data);
+      if (!data.items.length) return line("No stock records.");
+      for (const item of data.items) {
+        const low = item.onHand <= item.lowStockThreshold ? "  \u26A0 low" : "";
+        line(
+          `${item.id}  [${item.status}]  on hand ${item.onHand}  reserved ${item.reserved}${low}`
+        );
+      }
+    }
+  );
+  inventory.command("get <id>").description("Show one stock record").option("--json", "Output JSON").action(async (id, options) => {
+    const { data } = await buildClient().client.inventory.get(id);
+    if (options.json) return printJson(data);
+    line(`${data.id}`);
+    line(`  status:    ${data.status}`);
+    line(`  on hand:   ${data.onHand}`);
+    line(`  reserved:  ${data.reserved}`);
+    line(`  available: ${data.onHand - data.reserved}`);
+    line(`  low at:    ${data.lowStockThreshold}`);
+  });
+  inventory.command("history <id>").description("Show recent stock movements, newest first").option("--json", "Output JSON").option("--limit <number>", "How many movements", "25").action(async (id, options) => {
+    const { data } = await buildClient().client.inventory.listAdjustments(
+      id,
+      { limit: Number(options.limit) }
+    );
+    if (options.json) return printJson(data);
+    if (!data.items.length) return line("No movements.");
+    for (const move of data.items)
+      line(
+        `${move.createdAt}  ${move.kind}  ${move.quantity}  -> on hand ${move.resultingOnHand}, reserved ${move.resultingReserved}`
+      );
+  });
+  inventory.command("adjust <id> <kind> <quantity>").description(
+    "Record a movement: receive, sale, customer_return, damage, correction_in, correction_out, reserve, release, or fulfill_reserved"
+  ).option("--note <text>", "Why this movement happened").option("--reference <id>", "Linked record in another module").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (id, kind, quantity, options) => {
+      var _a, _b, _c;
+      const { data } = await buildClient().client.inventory.adjust(
+        id,
+        {
+          kind,
+          quantity: Number(quantity),
+          note: (_a = options.note) != null ? _a : null,
+          referenceId: (_b = options.reference) != null ? _b : null
+        },
+        (_c = options.idempotencyKey) != null ? _c : randomUUID7()
+      );
+      if (options.json) return printJson(data);
+      line(
+        `Recorded ${data.kind} ${data.quantity}: on hand ${data.resultingOnHand}, reserved ${data.resultingReserved}`
+      );
+    }
+  );
+}
+
+// src/commands/invoices.ts
+import { randomUUID as randomUUID8 } from "crypto";
+function registerInvoiceCommands(program2) {
+  const invoices = program2.command("invoices").description("Manage the workspace's invoices");
+  invoices.command("list").description("List invoices").option("--json", "Output JSON").option("--limit <number>", "Page size", "25").option("--status <status>", "Filter by draft, sent, paid, or void").action(
+    async (options) => {
+      const { data } = await buildClient().client.invoices.list({
+        limit: Number(options.limit),
+        status: options.status
+      });
+      if (options.json) return printJson(data);
+      if (!data.items.length) return line("No invoices.");
+      for (const invoice of data.items)
+        line(
+          `${invoice.id}  ${invoice.number}  [${invoice.status}]  ${(invoice.totalCents / 100).toFixed(2)} ${invoice.currency}`
+        );
+    }
+  );
+  invoices.command("get <id>").description("Show one invoice with its line items").option("--json", "Output JSON").action(async (id, options) => {
+    var _a;
+    const { data } = await buildClient().client.invoices.get(id);
+    if (options.json) return printJson(data);
+    line(`${data.number}  (${data.id})`);
+    line(`  status: ${data.status}`);
+    line(`  total:  ${(data.totalCents / 100).toFixed(2)} ${data.currency}`);
+    for (const item of (_a = data.lineItems) != null ? _a : [])
+      line(
+        `    ${item.quantity} x ${item.description}  ${(item.unitPriceCents / 100).toFixed(2)} ${data.currency}`
+      );
+  });
+  invoices.command("create").description("Create a single-line invoice").requiredOption("--description <text>", "Line item description").requiredOption("--price-cents <cents>", "Unit price in integer cents").option("--quantity <quantity>", "Quantity", "1").option("--client <id>", "Client id").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (options) => {
+      var _a, _b;
+      const { data } = await buildClient().client.invoices.create(
+        {
+          clientId: (_a = options.client) != null ? _a : null,
+          lineItems: [
+            {
+              description: options.description,
+              quantity: Number(options.quantity),
+              unitPriceCents: Number(options.priceCents)
+            }
+          ]
+        },
+        (_b = options.idempotencyKey) != null ? _b : randomUUID8()
+      );
+      if (options.json) return printJson(data);
+      line(`Created ${data.number} (${data.id})`);
+    }
+  );
+}
+
+// src/commands/orders.ts
+import { randomUUID as randomUUID9 } from "crypto";
+function registerOrderCommands(program2) {
+  const orders = program2.command("orders").description("Manage the workspace's orders");
+  orders.command("list").description("List orders").option("--json", "Output JSON").option("--limit <number>", "Page size", "25").option(
+    "--status <status>",
+    "Filter by draft, placed, confirmed, processing, fulfilled, or cancelled"
+  ).action(
+    async (options) => {
+      const { data } = await buildClient().client.orders.list({
+        limit: Number(options.limit),
+        status: options.status
+      });
+      if (options.json) return printJson(data);
+      if (!data.items.length) return line("No orders.");
+      for (const order of data.items)
+        line(
+          `${order.id}  ${order.number}  [${order.status}]  ${(order.totalCents / 100).toFixed(2)} ${order.currency}  ${order.clientName}`
+        );
+    }
+  );
+  orders.command("get <id>").description("Show one order with its purchased lines").option("--json", "Output JSON").action(async (id, options) => {
+    var _a;
+    const { data } = await buildClient().client.orders.get(id);
+    if (options.json) return printJson(data);
+    line(`${data.number}  (${data.id})`);
+    line(`  status: ${data.status}`);
+    line(`  client: ${data.clientName}`);
+    line(`  total:  ${(data.totalCents / 100).toFixed(2)} ${data.currency}`);
+    for (const item of (_a = data.lineItems) != null ? _a : [])
+      line(
+        `    ${item.quantity} x ${item.name}  ${(item.unitPriceCents / 100).toFixed(2)} ${data.currency}`
+      );
+  });
+  orders.command("create").description("Create a single-line order").requiredOption("--client <id>", "Client id").requiredOption("--name <text>", "Purchased item name").requiredOption("--price-cents <cents>", "Unit price in integer cents").option("--quantity <quantity>", "Quantity", "1").option(
+    "--type <type>",
+    "physical, digital, service, or rental",
+    "physical"
+  ).option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (options) => {
+      var _a;
+      const { data } = await buildClient().client.orders.create(
+        {
+          clientId: options.client,
+          lines: [
+            {
+              name: options.name,
+              type: options.type,
+              quantity: Number(options.quantity),
+              unitPriceCents: Number(options.priceCents)
+            }
+          ]
+        },
+        (_a = options.idempotencyKey) != null ? _a : randomUUID9()
+      );
+      if (options.json) return printJson(data);
+      line(`Created ${data.number} (${data.id})`);
+    }
+  );
+  orders.command("status <id> <status>").description(
+    "Move an order between draft, placed, confirmed, processing, fulfilled, and cancelled"
+  ).option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (id, status2, options) => {
+      var _a;
+      const { data } = await buildClient().client.orders.setStatus(
+        id,
+        status2,
+        (_a = options.idempotencyKey) != null ? _a : randomUUID9()
+      );
+      if (options.json) return printJson(data);
+      line(`${data.number} is now ${data.status}`);
+    }
+  );
+}
+
+// src/commands/payments.ts
+import { randomUUID as randomUUID10 } from "crypto";
+function registerPaymentCommands(program2) {
+  const payments = program2.command("payments").description("Manage the workspace's payments");
+  payments.command("list").description("List payments").option("--json", "Output JSON").option("--limit <number>", "Page size", "25").option("--status <status>", "Filter by status (pending, succeeded, \u2026)").action(
+    async (options) => {
+      const { data } = await buildClient().client.payments.list({
+        limit: Number(options.limit),
+        status: options.status
+      });
+      if (options.json) return printJson(data);
+      if (!data.items.length) return line("No payments.");
+      for (const payment of data.items)
+        line(
+          `${payment.id}  [${payment.status}]  ${(payment.amountCents / 100).toFixed(2)} ${payment.currency}`
+        );
+    }
+  );
+  payments.command("get <id>").description("Show one payment with its refunds").option("--json", "Output JSON").action(async (id, options) => {
+    var _a;
+    const { data } = await buildClient().client.payments.get(id);
+    if (options.json) return printJson(data);
+    line(`${data.id}`);
+    line(`  status:   ${data.status}`);
+    line(
+      `  amount:   ${(data.amountCents / 100).toFixed(2)} ${data.currency}`
+    );
+    for (const refund of (_a = data.refunds) != null ? _a : [])
+      line(
+        `    refund ${(refund.amountCents / 100).toFixed(2)} ${data.currency}`
+      );
+  });
+  payments.command("record").description("Record a payment").requiredOption("--amount-cents <cents>", "Amount in integer cents").option("--invoice <id>", "Invoice id this payment applies to").option("--status <status>", "pending, processing, succeeded, or failed").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (options) => {
+      var _a, _b;
+      const { data } = await buildClient().client.payments.record(
+        {
+          amountCents: Number(options.amountCents),
+          invoiceId: (_a = options.invoice) != null ? _a : null,
+          status: options.status
+        },
+        (_b = options.idempotencyKey) != null ? _b : randomUUID10()
+      );
+      if (options.json) return printJson(data);
+      line(`Recorded payment ${data.id} (${data.status})`);
+    }
+  );
+}
+
+// src/commands/projects.ts
+import { randomUUID as randomUUID11 } from "crypto";
+function registerProjectCommands(program2) {
+  const projects = program2.command("projects").description("Manage the workspace's projects, milestones, and tasks");
+  projects.command("list").description("List projects").option("--json", "Output JSON").option("--limit <number>", "Page size", "25").option(
+    "--status <status>",
+    "Filter by draft, active, on_hold, completed, or cancelled"
+  ).option("--include-archived", "Include archived projects").action(
+    async (options) => {
+      const { data } = await buildClient().client.projects.list({
+        limit: Number(options.limit),
+        status: options.status,
+        includeArchived: options.includeArchived
+      });
+      if (options.json) return printJson(data);
+      if (!data.items.length) return line("No projects.");
+      for (const item of data.items)
+        line(
+          `${item.id}  [${item.status}]${item.archivedAt ? " (archived)" : ""}  ${item.name}`
+        );
+    }
+  );
+  projects.command("get <id>").description("Show one project").option("--json", "Output JSON").action(async (id, options) => {
+    const { data } = await buildClient().client.projects.get(id);
+    if (options.json) return printJson(data);
+    line(`${data.name}  (${data.id})`);
+    line(`  status: ${data.status}${data.archivedAt ? "  (archived)" : ""}`);
+    if (data.dueDate) line(`  due:    ${data.dueDate}`);
+  });
+  projects.command("create").description("Create a project").requiredOption("--name <text>", "Project name").option("--client <id>", "Client id").option("--due <date>", "Due date (YYYY-MM-DD)").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (options) => {
+      var _a, _b, _c;
+      const { data } = await buildClient().client.projects.create(
+        {
+          name: options.name,
+          clientId: (_a = options.client) != null ? _a : null,
+          dueDate: (_b = options.due) != null ? _b : null
+        },
+        (_c = options.idempotencyKey) != null ? _c : randomUUID11()
+      );
+      if (options.json) return printJson(data);
+      line(`Created ${data.name} (${data.id})`);
+    }
+  );
+  projects.command("status <id> <status>").description(
+    "Move a project between draft, active, on_hold, completed, and cancelled"
+  ).option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (id, status2, options) => {
+      var _a;
+      const { data } = await buildClient().client.projects.setStatus(
+        id,
+        status2,
+        (_a = options.idempotencyKey) != null ? _a : randomUUID11()
+      );
+      if (options.json) return printJson(data);
+      line(`${data.name} is now ${data.status}`);
+    }
+  );
+  projects.command("tasks <projectId>").description("List a project's tasks").option("--json", "Output JSON").option("--limit <number>", "Page size", "25").option(
+    "--status <status>",
+    "Filter by todo, in_progress, blocked, completed, or cancelled"
+  ).action(
+    async (projectId, options) => {
+      const { data } = await buildClient().client.projects.tasks.list({
+        projectId,
+        limit: Number(options.limit),
+        status: options.status
+      });
+      if (options.json) return printJson(data);
+      if (!data.items.length) return line("No tasks.");
+      for (const task of data.items)
+        line(
+          `${task.id}  [${task.status}]  ${task.priority}  ${task.parentTaskId ? "\u2514 " : ""}${task.title}`
+        );
+    }
+  );
+  projects.command("add-task <projectId> <title>").description("Add a task to a project").option("--milestone <id>", "Milestone id").option("--parent <id>", "Parent task id (same project and milestone)").option("--priority <level>", "low, normal, high, or urgent", "normal").option("--due <date>", "Due date (YYYY-MM-DD)").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (projectId, title, options) => {
+      var _a, _b, _c, _d;
+      const { data } = await buildClient().client.projects.tasks.create(
+        {
+          projectId,
+          title,
+          milestoneId: (_a = options.milestone) != null ? _a : null,
+          parentTaskId: (_b = options.parent) != null ? _b : null,
+          priority: options.priority,
+          dueDate: (_c = options.due) != null ? _c : null
+        },
+        (_d = options.idempotencyKey) != null ? _d : randomUUID11()
+      );
+      if (options.json) return printJson(data);
+      line(`Created task ${data.title} (${data.id})`);
+    }
+  );
+  projects.command("task-status <id> <status>").description(
+    "Move a task between todo, in_progress, blocked, completed, and cancelled"
+  ).option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (id, status2, options) => {
+      var _a;
+      const { data } = await buildClient().client.projects.tasks.setStatus(
+        id,
+        status2,
+        (_a = options.idempotencyKey) != null ? _a : randomUUID11()
+      );
+      if (options.json) return printJson(data);
+      line(`${data.title} is now ${data.status}`);
+    }
+  );
+}
+
+// src/commands/quotes.ts
+import { randomUUID as randomUUID12 } from "crypto";
+function registerQuoteCommands(program2) {
+  const quotes = program2.command("quotes").description("Manage the workspace's quotes and estimates");
+  quotes.command("list").description("List quotes").option("--json", "Output JSON").option("--limit <number>", "Page size", "25").option("--status <status>", "Filter by status (draft, sent, accepted, \u2026)").action(
+    async (options) => {
+      const { data } = await buildClient().client.quotes.list({
+        limit: Number(options.limit),
+        status: options.status
+      });
+      if (options.json) return printJson(data);
+      if (!data.items.length) return line("No quotes.");
+      for (const quote2 of data.items)
+        line(
+          `${quote2.id}  ${quote2.number}  ${quote2.title}  [${quote2.status}]  ${(quote2.totalCents / 100).toFixed(2)} ${quote2.currency}`
+        );
+    }
+  );
+  quotes.command("get <id>").description("Show one quote with its line items").option("--json", "Output JSON").action(async (id, options) => {
+    var _a;
+    const { data } = await buildClient().client.quotes.get(id);
+    if (options.json) return printJson(data);
+    line(`${data.number}  ${data.title}  (${data.id})`);
+    line(`  status:   ${data.status}`);
+    line(`  client:   ${data.clientName}`);
+    line(
+      `  total:    ${(data.totalCents / 100).toFixed(2)} ${data.currency}`
+    );
+    for (const item of (_a = data.lines) != null ? _a : [])
+      line(
+        `    ${item.quantity} x ${item.name}  ${(item.lineTotalCents / 100).toFixed(2)} ${data.currency}`
+      );
+  });
+  quotes.command("create").description("Create a single-line quote").requiredOption("--client <id>", "Client id").requiredOption("--title <title>", "Quote title").requiredOption("--line-name <name>", "Line item name").requiredOption("--price-cents <cents>", "Unit price in integer cents").option("--quantity <quantity>", "Quantity", "1").option("--kind <kind>", "quote, estimate, or proposal").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (options) => {
+      var _a;
+      const { data } = await buildClient().client.quotes.create(
+        {
+          clientId: options.client,
+          title: options.title,
+          kind: options.kind,
+          lines: [
+            {
+              name: options.lineName,
+              quantity: Number(options.quantity),
+              unitPriceCents: Number(options.priceCents)
+            }
+          ]
+        },
+        (_a = options.idempotencyKey) != null ? _a : randomUUID12()
+      );
+      if (options.json) return printJson(data);
+      line(`Created ${data.number} (${data.id})`);
+    }
+  );
+}
+
+// src/commands/reports.ts
+var money = (cents, currency) => `${(cents / 100).toFixed(2)} ${currency}`;
+var withRange = (command) => command.option("--from <iso>", "Range start (defaults to 30 days before --to)").option("--to <iso>", "Range end (defaults to now)").option("--time-zone <zone>", "IANA time zone the range is bucketed in").option("--granularity <unit>", "day, week, or month");
+var range = (options) => ({
+  from: options.from,
+  to: options.to,
+  timeZone: options.timeZone,
+  granularity: options.granularity
+});
+function registerReportCommands(program2) {
+  const reports = program2.command("reports").description("Read the workspace's reports and analytics");
+  withRange(
+    reports.command("workspace").description("Cross-module snapshot for a date range").option("--json", "Output JSON")
+  ).action(async (options) => {
+    const { data } = await buildClient().client.reports.workspace(
+      range(options)
+    );
+    if (options.json) return printJson(data);
+    line(`${data.workspace.name}  (${data.range.from} \u2192 ${data.range.to})`);
+    for (const [name, value] of Object.entries(data)) {
+      if (name === "workspace" || name === "range") continue;
+      const s = value;
+      if (!s || typeof s.available !== "boolean") continue;
+      line(
+        s.available ? `  ${name}: ${JSON.stringify(s.data)}` : `  ${name}: (module not enabled)`
+      );
+    }
+  });
+  withRange(
+    reports.command("revenue").description("Collected and refunded revenue, split by currency").option("--json", "Output JSON")
+  ).action(async (options) => {
+    var _a, _b, _c, _d;
+    const { data } = await buildClient().client.reports.revenue(range(options));
+    if (options.json) return printJson(data);
+    if (!data.collected.length && !data.refunded.length)
+      return line("No revenue in range.");
+    for (const point of data.collected)
+      line(
+        `  collected  ${point.bucket}  ${money(Number((_a = point.amountCents) != null ? _a : 0), String((_b = point.currency) != null ? _b : ""))}`
+      );
+    for (const point of data.refunded)
+      line(
+        `  refunded   ${point.bucket}  ${money(Number((_c = point.amountCents) != null ? _c : 0), String((_d = point.currency) != null ? _d : ""))}`
+      );
+  });
+  withRange(
+    reports.command("traffic").description("Self-reported site traffic over time").option("--json", "Output JSON").option("--summary", "Show totals instead of the series")
+  ).action(async (options) => {
+    var _a;
+    const client = buildClient().client;
+    if (options.summary) {
+      const { data: data2 } = await client.reports.trafficSummary(range(options));
+      if (options.json) return printJson(data2);
+      line(
+        `views ${data2.views}  visitors ${data2.visitors}  sessions ${data2.sessions}`
+      );
+      return;
+    }
+    const { data } = await client.reports.traffic(range(options));
+    if (options.json) return printJson(data);
+    if (!data.length) return line("No traffic in range.");
+    for (const point of data)
+      line(`  ${point.bucket}  ${(_a = point.count) != null ? _a : 0} views`);
+  });
+}
+
+// src/commands/shipments.ts
+import { randomUUID as randomUUID13 } from "crypto";
+function registerShipmentCommands(program2) {
+  const shipments = program2.command("shipments").description("Manage the workspace's shipments");
+  shipments.command("list").description("List shipments").option("--json", "Output JSON").option("--limit <number>", "Page size", "25").option("--order <id>", "Only shipments for this order").option(
+    "--status <status>",
+    "Filter by draft, ready, shipped, in_transit, delivered, exception, or cancelled"
+  ).action(
+    async (options) => {
+      var _a, _b;
+      const { data } = await buildClient().client.shipments.list({
+        limit: Number(options.limit),
+        orderId: options.order,
+        status: options.status
+      });
+      if (options.json) return printJson(data);
+      if (!data.items.length) return line("No shipments.");
+      for (const item of data.items)
+        line(
+          `${item.id}  [${item.status}]  ${(_a = item.carrier) != null ? _a : "no carrier"}  ${(_b = item.trackingNumber) != null ? _b : "no tracking"}`
+        );
+    }
+  );
+  shipments.command("get <id>").description("Show one shipment with its lines and parcels").option("--json", "Output JSON").action(async (id, options) => {
+    var _a, _b, _c;
+    const { data } = await buildClient().client.shipments.get(id);
+    if (options.json) return printJson(data);
+    line(`${data.id}`);
+    line(`  status:   ${data.status}`);
+    line(`  order:    ${data.orderId}`);
+    line(
+      `  to:       ${data.destination.recipientName}, ${data.destination.city}`
+    );
+    line(`  carrier:  ${(_a = data.carrier) != null ? _a : "not set"}`);
+    line(`  tracking: ${(_b = data.trackingNumber) != null ? _b : "not set"}`);
+    for (const parcel of (_c = data.parcels) != null ? _c : [])
+      line(`    parcel ${parcel.weightGrams}g`);
+  });
+  shipments.command("status <id> <status>").description(
+    "Move a shipment between draft, ready, shipped, in_transit, delivered, exception, and cancelled"
+  ).option("--require-tracking", "Refuse to ship without a tracking number").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (id, status2, options) => {
+      var _a;
+      const { data } = await buildClient().client.shipments.setStatus(
+        id,
+        status2,
+        (_a = options.idempotencyKey) != null ? _a : randomUUID13(),
+        { requireTracking: options.requireTracking }
+      );
+      if (options.json) return printJson(data);
+      line(`Shipment ${data.id} is now ${data.status}`);
+    }
+  );
+  shipments.command("track <id>").description("Set or correct carrier tracking details").option("--carrier <name>", "Carrier name").option("--service <level>", "Service level").option("--number <tracking>", "Tracking number").option("--url <url>", "Tracking URL").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (id, options) => {
+      var _a, _b, _c, _d, _e, _f, _g;
+      const { data } = await buildClient().client.shipments.updateTracking(
+        id,
+        {
+          carrier: (_a = options.carrier) != null ? _a : null,
+          serviceLevel: (_b = options.service) != null ? _b : null,
+          trackingNumber: (_c = options.number) != null ? _c : null,
+          trackingUrl: (_d = options.url) != null ? _d : null
+        },
+        (_e = options.idempotencyKey) != null ? _e : randomUUID13()
+      );
+      if (options.json) return printJson(data);
+      line(
+        `Tracking for ${data.id}: ${(_f = data.carrier) != null ? _f : "no carrier"} ${(_g = data.trackingNumber) != null ? _g : ""}`
+      );
+    }
+  );
+}
+
+// src/commands/time.ts
+import { randomUUID as randomUUID14 } from "crypto";
+var hours = (seconds) => (seconds / 3600).toFixed(2);
+function registerTimeCommands(program2) {
+  const time = program2.command("time").description("Track, approve, and invoice the workspace's time");
+  time.command("list").description("List time entries").option("--json", "Output JSON").option("--limit <number>", "Page size", "25").option("--project <id>", "Only this project").option("--tracker <key>", "Only this tracker").option(
+    "--status <status>",
+    "Filter by running, draft, approved, invoiced, or void"
+  ).action(
+    async (options) => {
+      const { data } = await buildClient().client.time.list({
+        limit: Number(options.limit),
+        projectId: options.project,
+        trackerKey: options.tracker,
+        status: options.status
+      });
+      if (options.json) return printJson(data);
+      if (!data.items.length) return line("No time entries.");
+      for (const item of data.items)
+        line(
+          `${item.id}  [${item.status}]  ${hours(item.durationSeconds)}h  ${item.trackerKey}${item.billable ? "" : "  (non-billable)"}`
+        );
+    }
+  );
+  time.command("log").description("Log time after the fact").requiredOption("--project <id>", "Project id").requiredOption("--date <YYYY-MM-DD>", "Work date").requiredOption("--minutes <number>", "Duration in minutes").option("--description <text>", "What the time was for").option("--tracker <key>", "Tracker this belongs to").option("--non-billable", "Mark the time non-billable").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (options) => {
+      var _a, _b;
+      const { data } = await buildClient().client.time.log(
+        {
+          projectId: options.project,
+          workDate: options.date,
+          durationSeconds: Number(options.minutes) * 60,
+          description: (_a = options.description) != null ? _a : null,
+          trackerKey: options.tracker,
+          billable: !options.nonBillable
+        },
+        (_b = options.idempotencyKey) != null ? _b : randomUUID14()
+      );
+      if (options.json) return printJson(data);
+      line(`Logged ${hours(data.durationSeconds)}h (${data.id})`);
+    }
+  );
+  time.command("start").description("Start a timer").requiredOption("--project <id>", "Project id").option("--tracker <key>", "Tracker this timer is exclusive on").option("--time-zone <zone>", "IANA time zone", "UTC").option("--description <text>", "What you're working on").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (options) => {
+      var _a, _b;
+      const { data } = await buildClient().client.time.startTimer(
+        {
+          projectId: options.project,
+          startedAt: /* @__PURE__ */ new Date(),
+          timeZone: options.timeZone,
+          trackerKey: options.tracker,
+          description: (_a = options.description) != null ? _a : null
+        },
+        (_b = options.idempotencyKey) != null ? _b : randomUUID14()
+      );
+      if (options.json) return printJson(data);
+      line(`Timer started (${data.id}) on ${data.trackerKey}`);
+    }
+  );
+  time.command("stop <id>").description("Stop a running timer").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (id, options) => {
+      var _a;
+      const { data } = await buildClient().client.time.stopTimer(
+        id,
+        /* @__PURE__ */ new Date(),
+        (_a = options.idempotencyKey) != null ? _a : randomUUID14()
+      );
+      if (options.json) return printJson(data);
+      line(`Timer stopped: ${hours(data.durationSeconds)}h recorded`);
+    }
+  );
+  time.command("approve <id>").description("Approve time, applying the workspace's billing rounding").option("--mode <mode>", "nearest, up, or down").option("--increment <minutes>", "Rounding increment in minutes").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (id, options) => {
+      var _a;
+      const { data } = await buildClient().client.time.approve(
+        id,
+        (_a = options.idempotencyKey) != null ? _a : randomUUID14(),
+        {
+          mode: options.mode,
+          incrementMinutes: options.increment ? Number(options.increment) : void 0
+        }
+      );
+      if (options.json) return printJson(data);
+      line(`Approved ${hours(data.durationSeconds)}h (${data.id})`);
+    }
+  );
+  time.command("invoice <invoiceId> <entryIds...>").description("Attach approved billable time to a draft invoice").option("--idempotency-key <key>", "Stable retry key").option("--json", "Output JSON").action(
+    async (invoiceId, entryIds, options) => {
+      var _a;
+      const { data } = await buildClient().client.time.attachToInvoice(
+        invoiceId,
+        entryIds,
+        (_a = options.idempotencyKey) != null ? _a : randomUUID14()
+      );
+      if (options.json) return printJson(data);
+      line(`Attached ${data.entryIds.length} entries to ${data.invoiceId}`);
+    }
+  );
+}
+
+// src/commands/webhooks.ts
+var status = (delivery) => delivery.responseStatus ? `${delivery.status} (${delivery.responseStatus})` : delivery.status;
+function registerWebhookCommands(program2) {
+  const webhooks = program2.command("webhooks").description("Manage outbound webhook endpoints and inspect deliveries");
+  webhooks.command("list").description("List this workspace's webhook endpoints").option("--json", "Output JSON").action(async (options) => {
+    const { data } = await buildClient().client.webhooks.list();
+    if (options.json) return printJson(data);
+    if (!data.length) return line("No webhook endpoints yet.");
+    for (const endpoint of data) {
+      const events = endpoint.eventTypes.length ? endpoint.eventTypes.join(", ") : "all events";
+      line(`  ${endpoint.enabled ? "\u25CF" : "\u25CB"} ${endpoint.url}  ${events}`);
+      line(`     ${endpoint.id}`);
+      if (endpoint.disabledReason) line(`     ${endpoint.disabledReason}`);
+    }
+  });
+  webhooks.command("create <url>").description("Register a webhook endpoint").option("--events <names...>", "Only these events (default: all)").option("--description <text>", "What this endpoint is for").option("--json", "Output JSON").action(
+    async (url, options) => {
+      var _a;
+      const { data } = await buildClient().client.webhooks.create({
+        url,
+        eventTypes: (_a = options.events) != null ? _a : [],
+        description: options.description
+      });
+      if (options.json) return printJson(data);
+      line(`Created ${data.id}`);
+      line("");
+      line(`  Signing secret: ${data.secret}`);
+      line("  Store it now \u2014 it cannot be retrieved again.");
+    }
+  );
+  webhooks.command("delete <id>").description("Delete a webhook endpoint and its delivery history").action(async (id) => {
+    await buildClient().client.webhooks.delete(id);
+    line(`Deleted ${id}`);
+  });
+  webhooks.command("disable <id>").description("Stop delivering to an endpoint without deleting it").action(async (id) => {
+    await buildClient().client.webhooks.update(id, { enabled: false });
+    line(`Disabled ${id}`);
+  });
+  webhooks.command("enable <id>").description("Resume delivering to an endpoint").action(async (id) => {
+    await buildClient().client.webhooks.update(id, { enabled: true });
+    line(`Enabled ${id}`);
+  });
+  webhooks.command("deliveries <endpointId>").description("Recent deliveries for an endpoint, newest first").option("--limit <n>", "How many to show (max 100)").option("--json", "Output JSON").action(
+    async (endpointId, options) => {
+      const { data } = await buildClient().client.webhooks.deliveries(
+        endpointId,
+        { limit: options.limit ? Number(options.limit) : void 0 }
+      );
+      if (options.json) return printJson(data);
+      if (!data.length) return line("No deliveries yet.");
+      for (const delivery of data) {
+        line(
+          `  ${delivery.createdAt}  ${delivery.eventName}  ${status(delivery)}  attempts ${delivery.attempts}`
+        );
+        if (delivery.error) line(`     ${delivery.error}`);
+      }
+    }
+  );
+  webhooks.command("replay <deliveryId>").description("Attempt a delivery again").action(async (deliveryId) => {
+    await buildClient().client.webhooks.replay(deliveryId);
+    line(`Queued ${deliveryId} for another attempt.`);
+  });
+}
+
+// src/guided.ts
+import {
+  cancel as cancel3,
+  intro as intro3,
+  isCancel as isCancel3,
+  log as log3,
+  note as note2,
+  outro as outro3,
+  select,
+  text as text3
+} from "@clack/prompts";
+function ensure3(value) {
+  if (isCancel3(value)) {
+    cancel3("Cancelled.");
+    process.exit(0);
+  }
+  return value;
+}
+var selectable = (command) => command.commands.filter(
+  (child) => !child._hidden
+);
+var takesValue = (option) => option.flags.includes("<") || option.flags.includes("[");
+var quote = (value) => /[\s"'$`\\]/.test(value) ? `'${value.replace(/'/g, "'\\''")}'` : value;
+async function collectArguments(command) {
+  const parts = [];
+  for (const argument of command.registeredArguments) {
+    const value = ensure3(
+      await text3({
+        message: `${argument.name()}${argument.required ? "" : " (optional)"}`,
+        placeholder: argument.description || void 0,
+        validate: (input) => argument.required && !(input != null ? input : "").trim() ? "Required." : void 0
+      })
+    );
+    if (value.trim()) parts.push(quote(value.trim()));
+  }
+  const options = command.options.filter((option) => option.long !== "--help");
+  for (const option of options) {
+    if (!takesValue(option)) {
+      const enable = ensure3(
+        await select({
+          message: `${option.long}${option.description ? ` \u2014 ${option.description}` : ""}`,
+          options: [
+            { value: false, label: "no" },
+            { value: true, label: "yes" }
+          ],
+          initialValue: false
+        })
+      );
+      if (enable) parts.push(option.long);
+      continue;
+    }
+    const value = ensure3(
+      await text3({
+        message: `${option.long} (optional)`,
+        placeholder: option.description || void 0
+      })
+    );
+    if (value.trim()) parts.push(`${option.long} ${quote(value.trim())}`);
+  }
+  return parts;
+}
+async function runGuided(program2) {
+  intro3("QuickEngine CLI");
+  const groups = selectable(program2);
+  if (groups.length === 0) {
+    outro3("No commands are registered.");
+    return;
+  }
+  const group = ensure3(
+    await select({
+      message: "What do you want to work with?",
+      options: groups.map((command2) => ({
+        value: command2,
+        label: command2.name(),
+        hint: command2.description() || void 0
+      }))
+    })
+  );
+  const children = selectable(group);
+  const command = children.length ? ensure3(
+    await select({
+      message: `${group.name()} \u2014 which action?`,
+      options: children.map((child) => ({
+        value: child,
+        label: child.name(),
+        hint: child.description() || void 0
+      }))
+    })
+  ) : group;
+  const parts = await collectArguments(command);
+  const path = command === group ? [group.name()] : [group.name(), command.name()];
+  const line2 = ["quick", ...path, ...parts].join(" ");
+  note2(line2, "Running");
+  try {
+    await program2.parseAsync([...path, ...parts], { from: "user" });
+    outro3("Done.");
+  } catch (error) {
+    log3.error(error instanceof Error ? error.message : String(error));
+    outro3("That command failed.");
+    process.exitCode = 1;
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("quick").description(
+  "The QuickEngine command-line tool. Configure a workspace credential and read product APIs."
+).version("0.1.0");
+registerConfigCommands(program);
+registerClientCommands(program);
+registerCatalogCommands(program);
+registerQuoteCommands(program);
+registerInvoiceCommands(program);
+registerPaymentCommands(program);
+registerOrderCommands(program);
+registerFulfillmentCommands(program);
+registerInventoryCommands(program);
+registerShipmentCommands(program);
+registerProjectCommands(program);
+registerBookingCommands(program);
+registerTimeCommands(program);
+registerContractCommands(program);
+registerFileCommands(program);
+registerInitCommand(program);
+registerCreateCommands(program);
+registerActivityCommands(program);
+registerReportCommands(program);
+registerWebhookCommands(program);
+registerDoctorCommand(program);
+async function main() {
+  try {
+    if (process.argv.length <= 2 && process.stdin.isTTY && process.stdout.isTTY) {
+      await runGuided(program);
+      return;
+    }
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    if (error instanceof QuickApiError2) {
+      errorLine(`Error: ${error.message} (${error.code})`);
+      if (error.requestId) errorLine(`Request id: ${error.requestId}`);
+    } else if (error instanceof Error) {
+      errorLine(`Error: ${error.message}`);
+    } else {
+      errorLine("An unknown error occurred.");
+    }
+    process.exitCode = 1;
+  }
+}
+void main();