fresh-squeezy 0.1.0

package/dist/cli.js

@@ -0,0 +1,954 @@
+#!/usr/bin/env node
+
+// src/cli/main.ts
+import { Command } from "commander";
+import dotenv from "dotenv";
+
+// src/core/errors.ts
+var FreshSqueezyError = class _FreshSqueezyError extends Error {
+  code;
+  status;
+  detail;
+  constructor(opts) {
+    super(opts.message);
+    this.name = "FreshSqueezyError";
+    this.code = opts.code;
+    this.status = opts.status;
+    this.detail = opts.detail;
+    Object.setPrototypeOf(this, _FreshSqueezyError.prototype);
+  }
+};
+
+// src/core/config.ts
+var DEFAULT_BASE_URL = "https://api.lemonsqueezy.com";
+var ENV_KEYS = {
+  apiKey: "LEMON_SQUEEZY_API_KEY",
+  storeId: "LEMON_SQUEEZY_STORE_ID",
+  mode: "LEMON_SQUEEZY_MODE"
+};
+function resolveConfig(input = {}) {
+  const apiKey = input.apiKey ?? process.env[ENV_KEYS.apiKey];
+  if (!apiKey) {
+    throw new FreshSqueezyError({
+      code: "MISSING_API_KEY",
+      message: `No API key provided. Pass \`apiKey\` or set ${ENV_KEYS.apiKey}.`
+    });
+  }
+  const mode = normalizeMode(input.mode ?? process.env[ENV_KEYS.mode] ?? "test");
+  const storeIdRaw = input.storeId ?? process.env[ENV_KEYS.storeId];
+  return {
+    apiKey,
+    storeId: storeIdRaw == null ? void 0 : String(storeIdRaw),
+    mode,
+    baseUrl: input.baseUrl ?? DEFAULT_BASE_URL,
+    fetch: input.fetch ?? globalThis.fetch
+  };
+}
+function normalizeMode(value) {
+  if (value === "test" || value === "live") return value;
+  throw new FreshSqueezyError({
+    code: "INVALID_MODE",
+    message: `Mode must be "test" or "live", got "${value}".`
+  });
+}
+
+// src/core/http.ts
+var HttpClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  async request(options) {
+    const url = this.buildUrl(options.path, options.query);
+    const headers = {
+      Authorization: `Bearer ${this.config.apiKey}`,
+      Accept: "application/vnd.api+json"
+    };
+    if (options.body !== void 0) {
+      headers["Content-Type"] = "application/vnd.api+json";
+    }
+    let response;
+    try {
+      response = await this.config.fetch(url, {
+        method: options.method ?? "GET",
+        headers,
+        body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
+        signal: options.signal
+      });
+    } catch (cause) {
+      throw new FreshSqueezyError({
+        code: "NETWORK_ERROR",
+        message: cause instanceof Error ? cause.message : "Network request failed",
+        detail: cause
+      });
+    }
+    const text = await response.text();
+    const parsed = text.length > 0 ? safeJsonParse(text) : void 0;
+    if (!response.ok) {
+      throw toApiError(response.status, parsed);
+    }
+    return parsed;
+  }
+  /**
+   * Fetch a single JSON:API resource and return its `data` object.
+   */
+  async getResource(path2) {
+    const doc = await this.request({ path: path2 });
+    return doc.data;
+  }
+  /**
+   * Fetch a JSON:API collection and return its `data` array.
+   * Pagination is the caller's responsibility — use `meta.page` on the raw
+   * request for multi-page traversal.
+   */
+  async getCollection(path2, query) {
+    const doc = await this.request({ path: path2, query });
+    return doc.data;
+  }
+  buildUrl(path2, query) {
+    const url = new URL(path2, this.config.baseUrl);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value === void 0) continue;
+        url.searchParams.append(key, String(value));
+      }
+    }
+    return url.toString();
+  }
+};
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function toApiError(status, body) {
+  const errors = extractJsonApiErrors(body);
+  const first = errors[0];
+  const code = status === 401 ? "UNAUTHORIZED" : status === 404 ? "NOT_FOUND" : status === 429 ? "RATE_LIMITED" : first?.code ?? `HTTP_${status}`;
+  const message = first?.detail ?? first?.title ?? `Lemon Squeezy request failed with status ${status}`;
+  return new FreshSqueezyError({ code, status, message, detail: body });
+}
+function extractJsonApiErrors(body) {
+  if (!body || typeof body !== "object") return [];
+  const errors = body.errors;
+  if (!Array.isArray(errors)) return [];
+  return errors.filter(
+    (entry) => typeof entry === "object" && entry !== null
+  );
+}
+
+// src/resources/users.ts
+async function getAuthenticatedUser(http) {
+  return http.request({ path: "/v1/users/me" });
+}
+
+// src/resources/stores.ts
+async function getStore(http, storeId) {
+  return http.getResource(`/v1/stores/${storeId}`);
+}
+async function listStores(http) {
+  return http.getCollection("/v1/stores");
+}
+
+// src/validate/rules.ts
+var ISSUE_CODES = {
+  AUTH_FAILED: "AUTH_FAILED",
+  MODE_MISMATCH: "MODE_MISMATCH",
+  STORE_NOT_FOUND: "STORE_NOT_FOUND",
+  STORE_NOT_OWNED: "STORE_NOT_OWNED",
+  PRODUCT_NOT_FOUND: "PRODUCT_NOT_FOUND",
+  PRODUCT_WRONG_STORE: "PRODUCT_WRONG_STORE",
+  PRODUCT_UNPUBLISHED: "PRODUCT_UNPUBLISHED",
+  PRODUCT_NO_BUY_URL: "PRODUCT_NO_BUY_URL",
+  VARIANT_UNPUBLISHED: "VARIANT_UNPUBLISHED",
+  VARIANT_MISSING: "VARIANT_MISSING",
+  WEBHOOK_NOT_FOUND: "WEBHOOK_NOT_FOUND",
+  WEBHOOK_EVENTS_MISSING: "WEBHOOK_EVENTS_MISSING",
+  WEBHOOK_OPTIONAL_EVENTS: "WEBHOOK_OPTIONAL_EVENTS",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  UNKNOWN: "UNKNOWN"
+};
+function issue(code, severity, message, extras = {}) {
+  const base = { code, severity, message };
+  if (extras.suggestedFix !== void 0) base.suggestedFix = extras.suggestedFix;
+  if (extras.context !== void 0) base.context = extras.context;
+  return base;
+}
+function isOk(issues) {
+  return !issues.some((entry) => entry.severity === "error");
+}
+function buildResult(name, mode, issues, resource) {
+  const result = {
+    name,
+    ok: isOk(issues),
+    mode,
+    issues
+  };
+  if (resource !== void 0) result.resource = resource;
+  return result;
+}
+
+// src/validate/connection.ts
+async function validateConnection(http, mode) {
+  const issues = [];
+  try {
+    const userDoc = await getAuthenticatedUser(http);
+    const stores = await listStores(http);
+    const actualMode = resolveActualMode(userDoc.meta?.test_mode);
+    const summary = {
+      user: userDoc.data.attributes,
+      storeCount: stores.length,
+      storeIds: stores.map((store) => store.id),
+      declaredMode: mode,
+      ...actualMode ? { actualMode } : {}
+    };
+    if (actualMode && actualMode !== mode) {
+      issues.push(
+        issue(
+          ISSUE_CODES.MODE_MISMATCH,
+          "error",
+          `API key is a ${actualMode}-mode key but was run with --mode ${mode}.`,
+          {
+            suggestedFix: `Either pass --mode ${actualMode} or use a ${mode}-mode key from https://app.lemonsqueezy.com/settings/api.`,
+            context: { declared: mode, actual: actualMode }
+          }
+        )
+      );
+    }
+    if (stores.length === 0) {
+      issues.push(
+        issue(
+          ISSUE_CODES.STORE_NOT_FOUND,
+          "warning",
+          "API key authenticated but no stores are reachable.",
+          { suggestedFix: "Confirm the API key belongs to an account that owns at least one store." }
+        )
+      );
+    }
+    return buildResult("connection", mode, issues, summary);
+  } catch (err) {
+    issues.push(toConnectionIssue(err));
+    return buildResult("connection", mode, issues);
+  }
+}
+function resolveActualMode(testMode) {
+  if (testMode === true) return "test";
+  if (testMode === false) return "live";
+  return void 0;
+}
+function toConnectionIssue(err) {
+  if (err instanceof FreshSqueezyError) {
+    if (err.code === "UNAUTHORIZED") {
+      return issue(ISSUE_CODES.AUTH_FAILED, "error", "API key rejected by Lemon Squeezy.", {
+        suggestedFix: "Regenerate the key at https://app.lemonsqueezy.com/settings/api.",
+        context: { status: err.status ?? null }
+      });
+    }
+    if (err.code === "NETWORK_ERROR") {
+      return issue(ISSUE_CODES.NETWORK_ERROR, "error", `Could not reach Lemon Squeezy: ${err.message}`);
+    }
+    return issue(ISSUE_CODES.UNKNOWN, "error", err.message, {
+      context: { status: err.status ?? null, code: err.code }
+    });
+  }
+  const message = err instanceof Error ? err.message : "Unknown error";
+  return issue(ISSUE_CODES.UNKNOWN, "error", message);
+}
+
+// src/validate/store.ts
+async function validateStore(http, mode, storeId) {
+  const issues = [];
+  try {
+    const store = await getStore(http, storeId);
+    return buildResult("store", mode, issues, store.attributes);
+  } catch (err) {
+    if (err instanceof FreshSqueezyError && err.status === 404) {
+      issues.push(
+        issue(
+          ISSUE_CODES.STORE_NOT_FOUND,
+          "error",
+          `Store ${storeId} not found with the current API key.`,
+          {
+            suggestedFix: "Check the store ID and confirm the API key belongs to the account that owns it.",
+            context: { storeId: String(storeId) }
+          }
+        )
+      );
+      return buildResult("store", mode, issues);
+    }
+    if (err instanceof FreshSqueezyError) {
+      issues.push(
+        issue(ISSUE_CODES.UNKNOWN, "error", err.message, {
+          context: { status: err.status ?? null, code: err.code }
+        })
+      );
+      return buildResult("store", mode, issues);
+    }
+    const message = err instanceof Error ? err.message : "Unknown error";
+    issues.push(issue(ISSUE_CODES.UNKNOWN, "error", message));
+    return buildResult("store", mode, issues);
+  }
+}
+
+// src/resources/products.ts
+async function getProduct(http, productId) {
+  return http.getResource(`/v1/products/${productId}`);
+}
+
+// src/resources/variants.ts
+async function listVariantsForProduct(http, productId) {
+  return http.getCollection("/v1/variants", {
+    "filter[product_id]": String(productId)
+  });
+}
+
+// src/validate/product.ts
+async function validateProduct(http, mode, options) {
+  const issues = [];
+  let product;
+  try {
+    product = await getProduct(http, options.productId);
+  } catch (err) {
+    if (err instanceof FreshSqueezyError && err.status === 404) {
+      issues.push(
+        issue(
+          ISSUE_CODES.PRODUCT_NOT_FOUND,
+          "error",
+          `Product ${options.productId} not found.`,
+          {
+            suggestedFix: "Verify the product ID in the Lemon Squeezy dashboard.",
+            context: { productId: String(options.productId) }
+          }
+        )
+      );
+      return buildResult("product", mode, issues);
+    }
+    const message = err instanceof Error ? err.message : "Unknown error";
+    issues.push(issue(ISSUE_CODES.UNKNOWN, "error", message));
+    return buildResult("product", mode, issues);
+  }
+  const attrs = product.attributes;
+  if (options.expectedStoreId !== void 0) {
+    const expected = String(options.expectedStoreId);
+    const actual = String(attrs.store_id);
+    if (expected !== actual) {
+      issues.push(
+        issue(
+          ISSUE_CODES.PRODUCT_WRONG_STORE,
+          "error",
+          `Product belongs to store ${actual}, expected ${expected}.`,
+          {
+            suggestedFix: "Either use the correct store ID or the correct product ID \u2014 IDs should not cross stores.",
+            context: { expectedStoreId: expected, actualStoreId: actual }
+          }
+        )
+      );
+    }
+  }
+  if (attrs.status !== "published") {
+    issues.push(
+      issue(
+        ISSUE_CODES.PRODUCT_UNPUBLISHED,
+        "error",
+        `Product is in "${attrs.status}" state, not "published".`,
+        {
+          suggestedFix: "Publish the product in the Lemon Squeezy dashboard before selling.",
+          context: { status: attrs.status }
+        }
+      )
+    );
+  }
+  if (!attrs.buy_now_url) {
+    issues.push(
+      issue(
+        ISSUE_CODES.PRODUCT_NO_BUY_URL,
+        "warning",
+        "Product has no buy-now URL. Hosted checkout may be disabled.",
+        { suggestedFix: "Enable buy-now in product settings, or use a custom checkout flow." }
+      )
+    );
+  }
+  try {
+    const variants = await listVariantsForProduct(http, options.productId);
+    if (variants.length === 0) {
+      issues.push(
+        issue(
+          ISSUE_CODES.VARIANT_MISSING,
+          "error",
+          "Product has no variants. Customers cannot purchase it.",
+          { suggestedFix: "Add at least one variant in the product configuration." }
+        )
+      );
+    } else if (!variants.some((variant) => variant.attributes.status === "published")) {
+      issues.push(
+        issue(
+          ISSUE_CODES.VARIANT_UNPUBLISHED,
+          "error",
+          "Product has variants but none are published.",
+          { suggestedFix: "Publish at least one variant." }
+        )
+      );
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error fetching variants";
+    issues.push(issue(ISSUE_CODES.UNKNOWN, "warning", message));
+  }
+  return buildResult("product", mode, issues, attrs);
+}
+
+// src/resources/webhooks.ts
+async function listWebhooksForStore(http, storeId) {
+  return http.getCollection("/v1/webhooks", {
+    "filter[store_id]": String(storeId)
+  });
+}
+
+// src/support/manifest.ts
+var RECOMMENDED_WEBHOOK_EVENTS = [
+  "order_created",
+  "order_refunded",
+  "subscription_created",
+  "subscription_updated",
+  "subscription_cancelled",
+  "subscription_resumed",
+  "subscription_expired",
+  "subscription_payment_success",
+  "subscription_payment_failed"
+];
+var OPTIONAL_WEBHOOK_EVENTS = [
+  "customer_updated",
+  "affiliate_activated",
+  "license_key_created",
+  "license_key_updated"
+];
+
+// src/validate/webhook.ts
+async function validateWebhook(http, mode, options) {
+  const issues = [];
+  let webhooks;
+  try {
+    webhooks = await listWebhooksForStore(http, options.storeId);
+  } catch (err) {
+    if (err instanceof FreshSqueezyError) {
+      issues.push(
+        issue(ISSUE_CODES.UNKNOWN, "error", err.message, {
+          context: { status: err.status ?? null, code: err.code }
+        })
+      );
+      return buildResult("webhook", mode, issues);
+    }
+    const message = err instanceof Error ? err.message : "Unknown error";
+    issues.push(issue(ISSUE_CODES.UNKNOWN, "error", message));
+    return buildResult("webhook", mode, issues);
+  }
+  const match = webhooks.find((webhook) => normalizeUrl(webhook.attributes.url) === normalizeUrl(options.url));
+  if (!match) {
+    issues.push(
+      issue(
+        ISSUE_CODES.WEBHOOK_NOT_FOUND,
+        "error",
+        `No webhook registered for URL ${options.url} on store ${options.storeId}.`,
+        {
+          suggestedFix: "Register the webhook in Lemon Squeezy (Settings \u2192 Webhooks) and subscribe to the recommended events.",
+          context: { storeId: String(options.storeId), url: options.url }
+        }
+      )
+    );
+    return buildResult("webhook", mode, issues);
+  }
+  const subscribed = new Set(match.attributes.events);
+  const missingRecommended = RECOMMENDED_WEBHOOK_EVENTS.filter((event) => !subscribed.has(event));
+  const missingOptional = OPTIONAL_WEBHOOK_EVENTS.filter((event) => !subscribed.has(event));
+  if (missingRecommended.length > 0) {
+    issues.push(
+      issue(
+        ISSUE_CODES.WEBHOOK_EVENTS_MISSING,
+        "error",
+        `Webhook is missing recommended events: ${missingRecommended.join(", ")}.`,
+        {
+          suggestedFix: "Subscribe to all recommended events so the integration survives plan changes and refunds.",
+          context: { missing: missingRecommended.join(",") }
+        }
+      )
+    );
+  }
+  if (missingOptional.length > 0) {
+    issues.push(
+      issue(
+        ISSUE_CODES.WEBHOOK_OPTIONAL_EVENTS,
+        "info",
+        `Optional events not subscribed: ${missingOptional.join(", ")}.`,
+        { context: { missing: missingOptional.join(",") } }
+      )
+    );
+  }
+  return buildResult("webhook", mode, issues, match.attributes);
+}
+function normalizeUrl(raw) {
+  return raw.replace(/\/+$/, "").toLowerCase();
+}
+
+// src/validate/doctor.ts
+async function doctor(http, mode, options = {}) {
+  const results = [];
+  const connection = await validateConnection(http, mode);
+  results.push(connection);
+  if (!connection.ok) {
+    return { ok: false, mode, results };
+  }
+  if (options.storeId !== void 0) {
+    results.push(await validateStore(http, mode, options.storeId));
+  }
+  if (options.productId !== void 0) {
+    results.push(
+      await validateProduct(http, mode, {
+        productId: options.productId,
+        expectedStoreId: options.storeId
+      })
+    );
+  }
+  if (options.storeId !== void 0 && options.webhookUrl !== void 0) {
+    results.push(
+      await validateWebhook(http, mode, {
+        storeId: options.storeId,
+        url: options.webhookUrl
+      })
+    );
+  }
+  const ok = results.every((result) => result.ok);
+  return { ok, mode, results };
+}
+
+// src/createFreshSqueezy.ts
+function createFreshSqueezy(config = {}) {
+  const resolved = resolveConfig(config);
+  const http = new HttpClient(resolved);
+  return {
+    mode: resolved.mode,
+    request: (options) => http.request(options),
+    validateConnection: () => validateConnection(http, resolved.mode),
+    validateStore: (storeId) => validateStore(http, resolved.mode, storeId),
+    validateProduct: (options) => validateProduct(http, resolved.mode, options),
+    validateWebhook: (options) => validateWebhook(http, resolved.mode, options),
+    doctor: (options) => doctor(http, resolved.mode, {
+      storeId: options?.storeId ?? resolved.storeId,
+      productId: options?.productId,
+      webhookUrl: options?.webhookUrl
+    })
+  };
+}
+
+// src/cli/render.ts
+import chalk from "chalk";
+function renderResult(result) {
+  const lines = [];
+  const badge = result.ok ? chalk.green("PASS") : chalk.red("FAIL");
+  const mode = chalk.dim(`[${result.mode}]`);
+  lines.push(`${badge} ${mode} ${chalk.bold(result.name)}`);
+  for (const issue2 of result.issues) {
+    lines.push(`  ${renderIssueLine(issue2)}`);
+    if (issue2.suggestedFix) {
+      lines.push(`    ${chalk.dim("fix:")} ${issue2.suggestedFix}`);
+    }
+  }
+  return lines.join("\n");
+}
+function renderReport(report) {
+  const header = report.ok ? chalk.green.bold("fresh-squeezy doctor: OK") : chalk.red.bold("fresh-squeezy doctor: FAILED");
+  const body = report.results.map(renderResult).join("\n\n");
+  return `${header} ${chalk.dim(`(mode: ${report.mode})`)}
+
+${body}`;
+}
+function renderIssueLine(issue2) {
+  const label = issue2.severity === "error" ? chalk.red("\u2717 error") : issue2.severity === "warning" ? chalk.yellow("! warn ") : chalk.blue("i info ");
+  return `${label} ${chalk.gray(`[${issue2.code}]`)} ${issue2.message}`;
+}
+
+// src/cli/prompts.ts
+import inquirer from "inquirer";
+async function askForCredentials() {
+  const answers = await inquirer.prompt([
+    {
+      type: "password",
+      name: "apiKey",
+      message: "Paste your Lemon Squeezy API key:",
+      mask: "*",
+      validate: (value) => value.trim().length > 0 ? true : "API key is required."
+    },
+    {
+      type: "list",
+      name: "mode",
+      message: "Which mode does this key belong to?",
+      choices: [
+        { name: "test \u2014 sandbox / development", value: "test" },
+        { name: "live \u2014 production charges", value: "live" }
+      ],
+      default: "test"
+    }
+  ]);
+  return answers;
+}
+async function pickStore(choices) {
+  const { storeId } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "storeId",
+      message: "Pick a store to validate against:",
+      choices: choices.map((entry) => ({
+        name: `${entry.name} (${entry.slug}) \u2014 id ${entry.id}`,
+        value: entry.id
+      }))
+    }
+  ]);
+  return storeId;
+}
+async function pickStores(choices) {
+  const { storeIds } = await inquirer.prompt([
+    {
+      type: "checkbox",
+      name: "storeIds",
+      message: "Pick one or more stores (space to toggle, enter to confirm):",
+      choices: choices.map((entry, index) => ({
+        name: `${entry.name} (${entry.slug}) \u2014 id ${entry.id}`,
+        value: entry.id,
+        checked: index === 0
+      })),
+      validate: (values) => Array.isArray(values) && values.length > 0 ? true : "Pick at least one store."
+    }
+  ]);
+  return storeIds;
+}
+async function confirmWriteEnvFile(path2) {
+  const { confirm } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: `Write these values to ${path2}?`,
+      default: true
+    }
+  ]);
+  return confirm;
+}
+
+// src/cli/resolveStores.ts
+async function resolveStores(client, input) {
+  if (input.storeIds && input.storeIds.length > 0) {
+    return { storeIds: dedupe(input.storeIds), skipped: false };
+  }
+  if (input.allStores) {
+    const ids2 = await fetchReachableStoreIds(client);
+    if (ids2.length === 0) {
+      throw new FreshSqueezyError({
+        code: "NO_STORES",
+        message: "No stores reachable with this API key."
+      });
+    }
+    return { storeIds: ids2, skipped: false };
+  }
+  if (!input.isInteractive) {
+    return { storeIds: [], skipped: true };
+  }
+  const ids = await fetchReachableStoreIds(client);
+  if (ids.length === 0) {
+    throw new FreshSqueezyError({
+      code: "NO_STORES",
+      message: "No stores reachable with this API key."
+    });
+  }
+  if (ids.length === 1) {
+    return { storeIds: ids, skipped: false };
+  }
+  const detailed = await Promise.all(
+    ids.map(async (id) => {
+      const result = await client.validateStore(id);
+      return {
+        id,
+        name: result.resource?.name ?? "(unnamed)",
+        slug: result.resource?.slug ?? ""
+      };
+    })
+  );
+  const picked = await pickStores(detailed);
+  if (picked.length === 0) {
+    throw new FreshSqueezyError({
+      code: "NO_SELECTION",
+      message: "No store selected. Pick at least one to continue."
+    });
+  }
+  return { storeIds: picked, skipped: false };
+}
+async function fetchReachableStoreIds(client) {
+  const connection = await client.validateConnection();
+  if (!connection.ok) {
+    const authIssue = connection.issues.find((entry) => entry.code === "AUTH_FAILED");
+    if (authIssue) {
+      throw new FreshSqueezyError({
+        code: "AUTH_FAILED",
+        message: authIssue.message
+      });
+    }
+  }
+  return connection.resource?.storeIds ?? [];
+}
+function dedupe(values) {
+  return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)));
+}
+
+// src/cli/commands/doctor.ts
+async function runDoctorCommand(options) {
+  try {
+    const client = createFreshSqueezy({ mode: options.mode });
+    const resolved = await resolveStores(client, {
+      storeIds: options.storeIds,
+      allStores: options.allStores,
+      isInteractive: options.isInteractive ?? false
+    });
+    if (resolved.skipped) {
+      return await runConnectionOnly(client, options);
+    }
+    const reports = await Promise.all(
+      resolved.storeIds.map(
+        (storeId) => client.doctor({
+          storeId,
+          productId: options.productId,
+          webhookUrl: options.webhookUrl
+        })
+      )
+    );
+    const ok = reports.every((report) => report.ok);
+    const payload = { ok, mode: client.mode, reports };
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(payload, null, 2)}
+`);
+    } else {
+      for (const report of reports) {
+        process.stdout.write(`${renderReport(report)}
+
+`);
+      }
+    }
+    return ok ? 0 : 1;
+  } catch (err) {
+    writeFatal(err, options.json ?? false);
+    return 2;
+  }
+}
+async function runConnectionOnly(client, options) {
+  const connection = await client.validateConnection();
+  const report = {
+    ok: connection.ok,
+    mode: client.mode,
+    results: [connection]
+  };
+  const payload = { ok: connection.ok, mode: client.mode, reports: [report] };
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}
+`);
+  } else {
+    process.stderr.write(
+      "fresh-squeezy: no --store-ids or --all-stores and stdin is not a TTY; running connection-only.\n"
+    );
+    process.stdout.write(`${renderReport(report)}
+`);
+  }
+  return connection.ok ? 0 : 1;
+}
+function writeFatal(err, asJson) {
+  if (asJson) {
+    const payload = err instanceof FreshSqueezyError ? { ok: false, error: { code: err.code, message: err.message, status: err.status ?? null } } : { ok: false, error: { code: "UNKNOWN", message: err instanceof Error ? err.message : String(err) } };
+    process.stderr.write(`${JSON.stringify(payload)}
+`);
+    return;
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`fresh-squeezy: ${message}
+`);
+}
+
+// src/cli/commands/validate.ts
+async function runValidateCommand(target, options) {
+  try {
+    const client = createFreshSqueezy({ mode: options.mode });
+    if (target === "connection") {
+      return emit(await client.validateConnection(), options);
+    }
+    if (target === "product") {
+      return emit(await runProduct(client, options), options);
+    }
+    const storeIds = await resolveStoresForTarget(client, target, options);
+    const results = await runPerStore(client, target, storeIds, options);
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(results, null, 2)}
+`);
+    } else {
+      for (const result of results) {
+        process.stdout.write(`${renderResult(result)}
+
+`);
+      }
+    }
+    return results.every((result) => result.ok) ? 0 : 1;
+  } catch (err) {
+    const message = err instanceof FreshSqueezyError ? err.message : err instanceof Error ? err.message : String(err);
+    process.stderr.write(`fresh-squeezy: ${message}
+`);
+    return 2;
+  }
+}
+async function resolveStoresForTarget(client, target, options) {
+  const resolved = await resolveStores(client, {
+    storeIds: options.storeIds,
+    allStores: options.allStores,
+    isInteractive: options.isInteractive ?? false
+  });
+  if (resolved.skipped) {
+    throw new FreshSqueezyError({
+      code: "MISSING_ARG",
+      message: `--store-ids or --all-stores is required for \`validate ${target}\` in non-interactive mode.`
+    });
+  }
+  return resolved.storeIds;
+}
+async function runPerStore(client, target, storeIds, options) {
+  if (target === "store") {
+    return Promise.all(storeIds.map((id) => client.validateStore(id)));
+  }
+  if (target === "webhook") {
+    const url = required(options.webhookUrl, "--webhook-url is required for `validate webhook`.");
+    return Promise.all(
+      storeIds.map((storeId) => client.validateWebhook({ storeId, url }))
+    );
+  }
+  return [];
+}
+async function runProduct(client, options) {
+  const productId = required(options.productId, "--product-id is required for `validate product`.");
+  const expected = options.storeIds?.[0];
+  return client.validateProduct({
+    productId,
+    expectedStoreId: expected
+  });
+}
+function emit(result, options) {
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+  } else {
+    process.stdout.write(`${renderResult(result)}
+`);
+  }
+  return result.ok ? 0 : 1;
+}
+function required(value, message) {
+  if (value === void 0 || value === null || value === "") {
+    throw new FreshSqueezyError({ code: "MISSING_ARG", message });
+  }
+  return value;
+}
+
+// src/cli/commands/init.ts
+import fs from "fs/promises";
+import path from "path";
+import chalk2 from "chalk";
+async function runInitCommand(options = {}) {
+  const answers = await askForCredentials();
+  const client = createFreshSqueezy({ apiKey: answers.apiKey, mode: answers.mode });
+  const connection = await client.validateConnection();
+  if (!connection.ok) {
+    process.stdout.write(`${renderReport({ ok: false, mode: answers.mode, results: [connection] })}
+`);
+    return 1;
+  }
+  const storeIds = connection.resource?.storeIds ?? [];
+  if (storeIds.length === 0) {
+    process.stdout.write(
+      chalk2.yellow("No stores reachable with this key. Create a store in Lemon Squeezy and retry.\n")
+    );
+    return 1;
+  }
+  const stores = await Promise.all(storeIds.map((id) => client.validateStore(id)));
+  const pickable = stores.filter((entry) => entry.ok && entry.resource).map((entry, index) => ({
+    id: storeIds[index] ?? "",
+    name: entry.resource?.name ?? "(unnamed)",
+    slug: entry.resource?.slug ?? ""
+  })).filter((entry) => entry.id !== "");
+  const storeId = await pickStore(pickable);
+  const envPath = path.resolve(process.cwd(), options.envFile ?? ".env.local");
+  const shouldWrite = await confirmWriteEnvFile(envPath);
+  if (shouldWrite) {
+    await writeEnvFile(envPath, { apiKey: answers.apiKey, mode: answers.mode, storeId });
+    process.stdout.write(chalk2.green(`Wrote ${envPath}
+`));
+  }
+  process.stdout.write(chalk2.dim("\nRunning doctor...\n\n"));
+  const report = await client.doctor({ storeId });
+  process.stdout.write(`${renderReport(report)}
+`);
+  return report.ok ? 0 : 1;
+}
+async function writeEnvFile(envPath, values) {
+  const lines = [
+    `${ENV_KEYS.apiKey}=${values.apiKey}`,
+    `${ENV_KEYS.storeId}=${values.storeId}`,
+    `${ENV_KEYS.mode}=${values.mode}`,
+    ""
+  ];
+  await fs.writeFile(envPath, lines.join("\n"), { encoding: "utf8" });
+}
+
+// src/cli/main.ts
+dotenv.config({ path: ".env.local" });
+dotenv.config();
+var isInteractive = Boolean(process.stdin.isTTY);
+var program = new Command();
+program.name("fresh-squeezy").description("Validator-first Lemon Squeezy setup doctor").version("0.1.0");
+program.command("doctor").description("Run every configured validator and emit a report").option("-m, --mode <mode>", "test or live", parseMode).option("--store-ids <ids>", "Comma-separated store IDs (e.g. 1,2,3)", parseCsv).option("--all-stores", "Run against every reachable store, no prompt").option("--product-id <id>", "Product to validate").option("--webhook-url <url>", "Webhook URL to validate").option("--json", "Emit machine-readable JSON").action(async (opts) => {
+  const code = await runDoctorCommand({
+    mode: opts.mode,
+    storeIds: opts.storeIds,
+    allStores: Boolean(opts.allStores),
+    productId: opts.productId,
+    webhookUrl: opts.webhookUrl,
+    json: Boolean(opts.json),
+    isInteractive
+  });
+  process.exit(code);
+});
+var validate = program.command("validate").description("Run a single validator");
+validate.command("connection").description("Check that the API key authenticates").option("-m, --mode <mode>", "test or live", parseMode).option("--json", "Emit machine-readable JSON").action(async (opts) => runValidate("connection", opts));
+validate.command("store").description("Check one or more stores are reachable").option("--store-ids <ids>", "Comma-separated store IDs", parseCsv).option("--all-stores", "Run against every reachable store").option("-m, --mode <mode>", "test or live", parseMode).option("--json", "Emit machine-readable JSON").action(async (opts) => runValidate("store", opts));
+validate.command("product").description("Check a product is published with at least one variant").requiredOption("--product-id <id>", "Product ID to validate").option("--store-ids <ids>", "Expected owning store IDs (first is used for cross-check)", parseCsv).option("-m, --mode <mode>", "test or live", parseMode).option("--json", "Emit machine-readable JSON").action(async (opts) => runValidate("product", opts));
+validate.command("webhook").description("Check a webhook is registered with the recommended events").requiredOption("--webhook-url <url>", "Public webhook URL").option("--store-ids <ids>", "Comma-separated store IDs", parseCsv).option("--all-stores", "Run against every reachable store").option("-m, --mode <mode>", "test or live", parseMode).option("--json", "Emit machine-readable JSON").action(async (opts) => runValidate("webhook", opts));
+program.command("init").description("Interactive setup: ask for credentials, pick a store, run doctor").option("--env-file <path>", "Where to write credentials (default: .env.local)").action(async (opts) => {
+  const code = await runInitCommand({ envFile: opts.envFile });
+  process.exit(code);
+});
+program.parseAsync(process.argv).catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`fresh-squeezy: ${message}
+`);
+  process.exit(2);
+});
+function parseMode(value) {
+  if (value === "test" || value === "live") return value;
+  throw new Error(`Mode must be "test" or "live", got "${value}"`);
+}
+function parseCsv(value) {
+  return value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+async function runValidate(target, opts) {
+  const code = await runValidateCommand(target, {
+    mode: opts.mode,
+    storeIds: opts.storeIds,
+    allStores: Boolean(opts.allStores),
+    productId: opts.productId,
+    webhookUrl: opts.webhookUrl,
+    json: Boolean(opts.json),
+    isInteractive
+  });
+  process.exit(code);
+}
+//# sourceMappingURL=cli.js.map