fresh-squeezy 0.1.11 → 0.1.13

package/dist/cli.js

@@ -74,7 +74,7 @@ function renderAugmentationFile(flavour) {
 
 `;
   if (flavour === "with-sdk") {
-    return header + `import type {
+    return `${header}import type {
   Subscription,
   SubscriptionInvoice,
   Order,
@@ -165,7 +165,7 @@ type AugmentResponse<T, Fields> = T extends {
  */
 `;
   }
-  return header + `import type {
+  return `${header}import type {
   WithLatestLemonSqueezyFields,
   LatestSubscriptionFields,
   LatestSubscriptionInvoiceFields,
@@ -239,22 +239,22 @@ var ENV_KEYS = {
   storeId: "LEMON_SQUEEZY_STORE_ID",
   mode: "LEMON_SQUEEZY_MODE"
 };
-function resolveConfig(input = {}) {
-  const apiKey = input.apiKey ?? process.env[ENV_KEYS.apiKey];
+function resolveConfig(input2 = {}) {
+  const apiKey = input2.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];
+  const mode = normalizeMode(input2.mode ?? process.env[ENV_KEYS.mode] ?? "test");
+  const storeIdRaw = input2.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
+    baseUrl: input2.baseUrl ?? DEFAULT_BASE_URL,
+    fetch: input2.fetch ?? globalThis.fetch
   };
 }
 function normalizeMode(value) {
@@ -379,11 +379,6 @@ function extractJsonApiErrors(body) {
   );
 }
 
-// src/resources/users.ts
-async function getAuthenticatedUser(http) {
-  return http.request({ path: "/v1/users/me" });
-}
-
 // src/core/mode.ts
 function resolveActualMode(testMode) {
   if (testMode === true) return "test";
@@ -399,6 +394,11 @@ async function listStores(http) {
   return http.paginate("/v1/stores");
 }
 
+// src/resources/users.ts
+async function getAuthenticatedUser(http) {
+  return http.request({ path: "/v1/users/me" });
+}
+
 // src/validate/rules.ts
 var ISSUE_CODES = {
   AUTH_FAILED: "AUTH_FAILED",
@@ -487,20 +487,20 @@ function mapErrorToIssue(err, mapping = {}) {
   return issue(ISSUE_CODES.UNKNOWN, "error", message);
 }
 async function probeFetch(fetcher, options) {
+  return probeCollection(fetcher, {
+    notFound: {
+      code: options.notFoundCode,
+      message: options.notFoundMessage,
+      ...options.notFoundFix !== void 0 ? { suggestedFix: options.notFoundFix } : {},
+      ...options.notFoundContext !== void 0 ? { context: options.notFoundContext } : {}
+    }
+  });
+}
+async function probeCollection(fetcher, mapping = {}) {
   try {
     return { ok: true, resource: await fetcher() };
   } catch (err) {
-    return {
-      ok: false,
-      issue: mapErrorToIssue(err, {
-        notFound: {
-          code: options.notFoundCode,
-          message: options.notFoundMessage,
-          ...options.notFoundFix !== void 0 ? { suggestedFix: options.notFoundFix } : {},
-          ...options.notFoundContext !== void 0 ? { context: options.notFoundContext } : {}
-        }
-      })
-    };
+    return { ok: false, issue: mapErrorToIssue(err, mapping) };
   }
 }
 function checkStoreOwnership(check) {
@@ -526,281 +526,57 @@ function checkStoreOwnership(check) {
 // 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." }
-        )
-      );
+  const fetched = await probeCollection(
+    async () => {
+      const userDoc2 = await getAuthenticatedUser(http);
+      const stores2 = await listStores(http);
+      return { userDoc: userDoc2, stores: stores2 };
+    },
+    {
+      unauthorized: {
+        code: ISSUE_CODES.AUTH_FAILED,
+        message: "API key rejected by Lemon Squeezy.",
+        suggestedFix: "Regenerate the key at https://app.lemonsqueezy.com/settings/api."
+      }
     }
-    return buildResult("connection", mode, issues, summary);
-  } catch (err) {
-    issues.push(
-      mapErrorToIssue(err, {
-        unauthorized: {
-          code: ISSUE_CODES.AUTH_FAILED,
-          message: "API key rejected by Lemon Squeezy.",
-          suggestedFix: "Regenerate the key at https://app.lemonsqueezy.com/settings/api."
-        }
-      })
-    );
-    return buildResult("connection", mode, issues);
-  }
-}
-
-// src/validate/store.ts
-async function validateStore(http, mode, storeId) {
-  const issues = [];
-  const fetched = await probeFetch(() => getStore(http, storeId), {
-    notFoundCode: ISSUE_CODES.STORE_NOT_FOUND,
-    notFoundMessage: `Store ${storeId} not found with the current API key.`,
-    notFoundFix: "Check the store ID and confirm the API key belongs to the account that owns it.",
-    notFoundContext: { storeId: String(storeId) }
-  });
-  if (!fetched.ok) {
-    issues.push(fetched.issue);
-    return buildResult("store", mode, issues, void 0, {
-      label: `store ${storeId}`,
-      id: String(storeId)
-    });
-  }
-  return buildResult("store", mode, issues, fetched.resource.attributes, {
-    label: fetched.resource.attributes.name,
-    id: String(storeId)
-  });
-}
-
-// src/resources/products.ts
-async function getProduct(http, productId) {
-  return http.getResource(`/v1/products/${productId}`);
-}
-
-// src/resources/variants.ts
-async function getVariant(http, variantId) {
-  return http.getResource(`/v1/variants/${variantId}`);
-}
-async function listVariantsForProduct(http, productId) {
-  return http.paginate("/v1/variants", {
-    "filter[product_id]": String(productId)
-  });
-}
-
-// src/validate/product.ts
-async function validateProduct(http, mode, options) {
-  const issues = [];
-  const fetched = await probeFetch(() => getProduct(http, options.productId), {
-    notFoundCode: ISSUE_CODES.PRODUCT_NOT_FOUND,
-    notFoundMessage: `Product ${options.productId} not found.`,
-    notFoundFix: "Verify the product ID in the Lemon Squeezy dashboard.",
-    notFoundContext: { productId: String(options.productId) }
-  });
+  );
   if (!fetched.ok) {
     issues.push(fetched.issue);
-    return buildResult("product", mode, issues, void 0, {
-      label: `product ${options.productId}`,
-      id: String(options.productId)
-    });
-  }
-  const attrs = fetched.resource.attributes;
-  if (options.expectedStoreId !== void 0) {
-    const mismatch = checkStoreOwnership({
-      expectedStoreId: options.expectedStoreId,
-      actualStoreId: attrs.store_id,
-      code: ISSUE_CODES.PRODUCT_WRONG_STORE,
-      label: "Product",
-      suggestedFix: "Either use the correct store ID or the correct product ID \u2014 IDs should not cross stores."
-    });
-    if (mismatch) issues.push(mismatch);
+    return buildResult("connection", mode, issues);
   }
-  if (attrs.status !== "published") {
+  const { userDoc, stores } = fetched.resource;
+  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.PRODUCT_UNPUBLISHED,
+        ISSUE_CODES.MODE_MISMATCH,
         "error",
-        `Product is in "${attrs.status}" state, not "published".`,
+        `API key is a ${actualMode}-mode key but was run with --mode ${mode}.`,
         {
-          suggestedFix: "Publish the product in the Lemon Squeezy dashboard before selling.",
-          context: { status: attrs.status }
+          suggestedFix: `Either pass --mode ${actualMode} or use a ${mode}-mode key from https://app.lemonsqueezy.com/settings/api.`,
+          context: { declared: mode, actual: actualMode }
         }
       )
     );
   }
-  if (!attrs.buy_now_url) {
+  if (stores.length === 0) {
     issues.push(
       issue(
-        ISSUE_CODES.PRODUCT_NO_BUY_URL,
+        ISSUE_CODES.STORE_NOT_FOUND,
         "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." }
+        "API key authenticated but no stores are reachable.",
+        { suggestedFix: "Confirm the API key belongs to an account that owns at least one store." }
       )
     );
   }
-  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, {
-    label: attrs.name,
-    id: String(options.productId)
-  });
-}
-
-// src/core/equality.ts
-function sameWebhookUrl(a, b) {
-  return normalizeWebhookUrl(a) === normalizeWebhookUrl(b);
-}
-function normalizeWebhookUrl(raw) {
-  return raw.replace(/\/+$/, "").toLowerCase();
-}
-
-// src/resources/webhooks.ts
-async function listWebhooksForStore(http, storeId) {
-  return http.paginate("/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, void 0, {
-        label: options.url,
-        url: options.url
-      });
-    }
-    const message = err instanceof Error ? err.message : "Unknown error";
-    issues.push(issue(ISSUE_CODES.UNKNOWN, "error", message));
-    return buildResult("webhook", mode, issues, void 0, {
-      label: options.url,
-      url: options.url
-    });
-  }
-  const match = webhooks.find((webhook) => sameWebhookUrl(webhook.attributes.url, 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, void 0, {
-      label: options.url,
-      url: options.url
-    });
-  }
-  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, {
-    label: match.attributes.url,
-    id: match.id,
-    url: match.attributes.url
-  });
+  return buildResult("connection", mode, issues, summary);
 }
 
 // src/resources/discounts.ts
@@ -825,6 +601,14 @@ async function validateDiscount(http, mode, options) {
     });
   }
   const attrs = fetched.resource.attributes;
+  issues.push(...checkDiscount(attrs, { storeId: options.storeId }));
+  return buildResult("discount", mode, issues, attrs, {
+    label: `${attrs.name} (${attrs.code})`,
+    id: String(options.discountId)
+  });
+}
+function checkDiscount(attrs, options) {
+  const issues = [];
   const mismatch = checkStoreOwnership({
     expectedStoreId: options.storeId,
     actualStoreId: attrs.store_id,
@@ -911,10 +695,7 @@ async function validateDiscount(http, mode, options) {
       )
     );
   }
-  return buildResult("discount", mode, issues, attrs, {
-    label: `${attrs.name} (${attrs.code})`,
-    id: String(options.discountId)
-  });
+  return issues;
 }
 
 // src/resources/licenseKeys.ts
@@ -939,6 +720,14 @@ async function validateLicenseKey(http, mode, options) {
     });
   }
   const attrs = fetched.resource.attributes;
+  issues.push(...checkLicenseKey(attrs, { storeId: options.storeId }));
+  return buildResult("licenseKey", mode, issues, attrs, {
+    label: attrs.key_short,
+    id: String(options.licenseKeyId)
+  });
+}
+function checkLicenseKey(attrs, options) {
+  const issues = [];
   const mismatch = checkStoreOwnership({
     expectedStoreId: options.storeId,
     actualStoreId: attrs.store_id,
@@ -990,9 +779,129 @@ async function validateLicenseKey(http, mode, options) {
       )
     );
   }
-  return buildResult("licenseKey", mode, issues, attrs, {
-    label: attrs.key_short,
-    id: String(options.licenseKeyId)
+  return issues;
+}
+
+// src/resources/products.ts
+async function getProduct(http, productId) {
+  return http.getResource(`/v1/products/${productId}`);
+}
+
+// src/resources/variants.ts
+async function getVariant(http, variantId) {
+  return http.getResource(`/v1/variants/${variantId}`);
+}
+async function listVariantsForProduct(http, productId) {
+  return http.paginate("/v1/variants", {
+    "filter[product_id]": String(productId)
+  });
+}
+
+// src/validate/product.ts
+async function validateProduct(http, mode, options) {
+  const issues = [];
+  const fetched = await probeFetch(() => getProduct(http, options.productId), {
+    notFoundCode: ISSUE_CODES.PRODUCT_NOT_FOUND,
+    notFoundMessage: `Product ${options.productId} not found.`,
+    notFoundFix: "Verify the product ID in the Lemon Squeezy dashboard.",
+    notFoundContext: { productId: String(options.productId) }
+  });
+  if (!fetched.ok) {
+    issues.push(fetched.issue);
+    return buildResult("product", mode, issues, void 0, {
+      label: `product ${options.productId}`,
+      id: String(options.productId)
+    });
+  }
+  const attrs = fetched.resource.attributes;
+  issues.push(...checkProduct(attrs, { expectedStoreId: options.expectedStoreId }));
+  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, {
+    label: attrs.name,
+    id: String(options.productId)
+  });
+}
+function checkProduct(attrs, options = {}) {
+  const issues = [];
+  if (options.expectedStoreId !== void 0) {
+    const mismatch = checkStoreOwnership({
+      expectedStoreId: options.expectedStoreId,
+      actualStoreId: attrs.store_id,
+      code: ISSUE_CODES.PRODUCT_WRONG_STORE,
+      label: "Product",
+      suggestedFix: "Either use the correct store ID or the correct product ID \u2014 IDs should not cross stores."
+    });
+    if (mismatch) issues.push(mismatch);
+  }
+  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." }
+      )
+    );
+  }
+  return issues;
+}
+
+// src/validate/store.ts
+async function validateStore(http, mode, storeId) {
+  const issues = [];
+  const fetched = await probeFetch(() => getStore(http, storeId), {
+    notFoundCode: ISSUE_CODES.STORE_NOT_FOUND,
+    notFoundMessage: `Store ${storeId} not found with the current API key.`,
+    notFoundFix: "Check the store ID and confirm the API key belongs to the account that owns it.",
+    notFoundContext: { storeId: String(storeId) }
+  });
+  if (!fetched.ok) {
+    issues.push(fetched.issue);
+    return buildResult("store", mode, issues, void 0, {
+      label: `store ${storeId}`,
+      id: String(storeId)
+    });
+  }
+  return buildResult("store", mode, issues, fetched.resource.attributes, {
+    label: fetched.resource.attributes.name,
+    id: String(storeId)
   });
 }
 
@@ -1018,6 +927,35 @@ async function validateSubscriptionPlan(http, mode, options) {
   }
   const variant = fetched.resource;
   const attrs = variant.attributes;
+  issues.push(...checkSubscriptionPlan(attrs, { variantId: options.variantId }));
+  try {
+    const product = await getProduct(http, attrs.product_id);
+    const mismatch = checkStoreOwnership({
+      expectedStoreId: options.storeId,
+      actualStoreId: product.attributes.store_id,
+      code: ISSUE_CODES.PLAN_STORE_MISMATCH,
+      label: `Subscription variant (via product ${attrs.product_id})`,
+      suggestedFix: "Use the correct store ID or variant ID \u2014 plans should not cross stores.",
+      extraContext: { productId: String(attrs.product_id) }
+    });
+    if (mismatch) issues.push(mismatch);
+  } catch {
+  }
+  const summary = {
+    variantId: variant.id,
+    interval: attrs.interval,
+    intervalCount: attrs.interval_count,
+    price: attrs.price,
+    hasFreeTrial: attrs.has_free_trial,
+    status: attrs.status
+  };
+  return buildResult("subscriptionPlan", mode, issues, summary, {
+    label: attrs.name,
+    id: String(options.variantId)
+  });
+}
+function checkSubscriptionPlan(attrs, options) {
+  const issues = [];
   if (!attrs.is_subscription) {
     issues.push(
       issue(
@@ -1062,7 +1000,7 @@ async function validateSubscriptionPlan(http, mode, options) {
       issue(
         ISSUE_CODES.PLAN_FREE_PRICE,
         "warning",
-        `Subscription variant has a price of 0 \u2014 this is almost always a misconfiguration for paid plans.`,
+        "Subscription variant has a price of 0 \u2014 this is almost always a misconfiguration for paid plans.",
         {
           suggestedFix: "Set the variant price to the intended amount in cents, or confirm this is intentionally free.",
           context: { price: attrs.price }
@@ -1091,7 +1029,7 @@ async function validateSubscriptionPlan(http, mode, options) {
       issue(
         ISSUE_CODES.PLAN_DRAFT,
         "warning",
-        `Subscription variant is in draft status \u2014 customers cannot subscribe.`,
+        "Subscription variant is in draft status \u2014 customers cannot subscribe.",
         {
           suggestedFix: "Publish the variant in the Lemon Squeezy dashboard.",
           context: { status: attrs.status }
@@ -1099,30 +1037,103 @@ async function validateSubscriptionPlan(http, mode, options) {
       )
     );
   }
-  try {
-    const product = await getProduct(http, attrs.product_id);
-    const mismatch = checkStoreOwnership({
-      expectedStoreId: options.storeId,
-      actualStoreId: product.attributes.store_id,
-      code: ISSUE_CODES.PLAN_STORE_MISMATCH,
-      label: `Subscription variant (via product ${attrs.product_id})`,
-      suggestedFix: "Use the correct store ID or variant ID \u2014 plans should not cross stores.",
-      extraContext: { productId: String(attrs.product_id) }
+  return issues;
+}
+
+// src/core/equality.ts
+function sameWebhookUrl(a, b) {
+  return normalizeWebhookUrl(a) === normalizeWebhookUrl(b);
+}
+function normalizeWebhookUrl(raw) {
+  return raw.replace(/\/+$/, "").toLowerCase();
+}
+
+// src/resources/webhooks.ts
+async function listWebhooksForStore(http, storeId) {
+  return http.paginate("/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 = [];
+  const fetched = await probeCollection(() => listWebhooksForStore(http, options.storeId));
+  if (!fetched.ok) {
+    issues.push(fetched.issue);
+    return buildResult("webhook", mode, issues, void 0, {
+      label: options.url,
+      url: options.url
     });
-    if (mismatch) issues.push(mismatch);
-  } catch {
   }
-  const summary = {
-    variantId: variant.id,
-    interval: attrs.interval,
-    intervalCount: attrs.interval_count,
-    price: attrs.price,
-    hasFreeTrial: attrs.has_free_trial,
-    status: attrs.status
-  };
-  return buildResult("subscriptionPlan", mode, issues, summary, {
-    label: attrs.name,
-    id: String(options.variantId)
+  const webhooks = fetched.resource;
+  const match = webhooks.find((webhook) => sameWebhookUrl(webhook.attributes.url, 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, void 0, {
+      label: options.url,
+      url: options.url
+    });
+  }
+  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, {
+    label: match.attributes.url,
+    id: match.id,
+    url: match.attributes.url
   });
 }
 
@@ -1273,10 +1284,7 @@ function renderCliError(message, hints = []) {
 function getDoctorHints(err) {
   if (!isFreshSqueezyError(err)) return [];
   if (err.code === "MISSING_API_KEY") {
-    return [
-      "fresh-squeezy init",
-      `export ${ENV_KEYS.apiKey}=ls_live_or_test_key`
-    ];
+    return ["fresh-squeezy init", `export ${ENV_KEYS.apiKey}=ls_live_or_test_key`];
   }
   if (err.code === "INVALID_MODE") {
     return ["fresh-squeezy doctor --mode test", "fresh-squeezy doctor --mode live"];
@@ -1289,10 +1297,7 @@ function getDoctorHints(err) {
 function getValidateHints(err, target) {
   if (!isFreshSqueezyError(err)) return [];
   if (err.code === "MISSING_API_KEY") {
-    return [
-      "fresh-squeezy init",
-      `export ${ENV_KEYS.apiKey}=ls_live_or_test_key`
-    ];
+    return ["fresh-squeezy init", `export ${ENV_KEYS.apiKey}=ls_live_or_test_key`];
   }
   if (err.code === "INVALID_MODE") {
     return [
@@ -1336,6 +1341,49 @@ function isFreshSqueezyError(err) {
   return err instanceof FreshSqueezyError;
 }
 
+// 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}]`);
+  const target = renderTarget(result.target);
+  const suffix = target ? ` ${chalk.dim(target)}` : "";
+  lines.push(`${badge} ${mode} ${chalk.bold(result.name)}${suffix}`);
+  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 renderTarget(target) {
+  if (!target) return "";
+  const parts = [target.label];
+  if (target.id) parts.push(`id ${target.id}`);
+  if (target.url && target.url !== target.label) parts.push(target.url);
+  return parts.join(" - ");
+}
+function renderReport(report) {
+  const header = report.ok ? chalk.green.bold("fresh-squeezy doctor: OK") : chalk.red.bold("fresh-squeezy doctor: FAILED");
+  const failed = report.results.filter((result) => !result.ok).length;
+  const summary = failed === 0 ? chalk.dim(`${report.results.length} checks passed`) : chalk.dim(`${failed}/${report.results.length} checks failed`);
+  const body = report.results.map(renderResult).join("\n\n");
+  return `${header} ${chalk.dim(`(mode: ${report.mode})`)}
+${summary}
+
+${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 path from "path";
+import { checkbox, confirm, input, password, select } from "@inquirer/prompts";
+
 // src/cli/resourceDiscovery.ts
 var EMPTY_INIT_RESOURCE_CHOICES = {
   products: { choices: [] },
@@ -1464,116 +1512,80 @@ function toSubscriptionPlanChoice(variant, productName) {
   };
 }
 
-// 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}]`);
-  const target = renderTarget(result.target);
-  const suffix = target ? ` ${chalk.dim(target)}` : "";
-  lines.push(`${badge} ${mode} ${chalk.bold(result.name)}${suffix}`);
-  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 renderTarget(target) {
-  if (!target) return "";
-  const parts = [target.label];
-  if (target.id) parts.push(`id ${target.id}`);
-  if (target.url && target.url !== target.label) parts.push(target.url);
-  return parts.join(" - ");
-}
-function renderReport(report) {
-  const header = report.ok ? chalk.green.bold("fresh-squeezy doctor: OK") : chalk.red.bold("fresh-squeezy doctor: FAILED");
-  const failed = report.results.filter((result) => !result.ok).length;
-  const summary = failed === 0 ? chalk.dim(`${report.results.length} checks passed`) : chalk.dim(`${failed}/${report.results.length} checks failed`);
-  const body = report.results.map(renderResult).join("\n\n");
-  return `${header} ${chalk.dim(`(mode: ${report.mode})`)}
-${summary}
-
-${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 path from "path";
-import inquirer from "inquirer";
 var PROMPT_THEME = {
   prefix: {
     idle: "\u203A",
     done: "\u2713"
   }
 };
+async function pickLauncherAction() {
+  return select({
+    message: "What do you want to do?",
+    theme: PROMPT_THEME,
+    choices: [
+      {
+        name: "Start guided setup \u2014 key, store, checks, doctor",
+        value: "init"
+      },
+      {
+        name: "Run doctor now \u2014 pick stores interactively when needed",
+        value: "doctor"
+      },
+      {
+        name: "Show command examples \u2014 copy/paste friendly",
+        value: "examples"
+      },
+      {
+        name: "Exit",
+        value: "exit"
+      }
+    ]
+  });
+}
 async function askForApiKey() {
-  const answers = await inquirer.prompt([
-    {
-      type: "password",
-      name: "apiKey",
-      message: "Paste your Lemon Squeezy API key:",
-      mask: "",
-      theme: PROMPT_THEME,
-      validate: (value) => value.trim().length > 0 ? true : "API key is required."
-    }
-  ]);
-  return { apiKey: answers.apiKey.trim() };
+  const apiKey = await password({
+    message: "Paste your Lemon Squeezy API key:",
+    mask: false,
+    theme: PROMPT_THEME,
+    validate: (value) => value.trim().length > 0 ? true : "API key is required."
+  });
+  return { apiKey: apiKey.trim() };
 }
 async function pickStore(choices) {
-  const { storeId } = await inquirer.prompt([
-    {
-      type: "list",
-      name: "storeId",
-      message: "Pick a store to validate against:",
-      theme: PROMPT_THEME,
-      choices: choices.map((entry) => ({
-        name: `${entry.name} (${entry.slug}) \u2014 id ${entry.id}`,
-        value: entry.id
-      }))
-    }
-  ]);
-  return storeId;
+  return select({
+    message: "Pick a store to validate against:",
+    theme: PROMPT_THEME,
+    choices: choices.map((entry) => ({
+      name: `${entry.name} (${entry.slug}) \u2014 id ${entry.id}`,
+      value: entry.id
+    }))
+  });
 }
 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):",
-      theme: PROMPT_THEME,
-      choices: choices.map((entry, index) => ({
-        name: `${entry.name} (${entry.slug}) \u2014 id ${entry.id}`,
-        value: entry.id,
-        checked: index === 0
-      })),
-      validate: (values2) => Array.isArray(values2) && values2.length > 0 ? true : "Pick at least one store."
-    }
-  ]);
-  return storeIds;
+  return checkbox({
+    message: "Pick one or more stores (space to toggle, enter to confirm):",
+    theme: PROMPT_THEME,
+    choices: choices.map((entry, index) => ({
+      name: `${entry.name} (${entry.slug}) \u2014 id ${entry.id}`,
+      value: entry.id,
+      checked: index === 0
+    })),
+    validate: (selected) => selected.length > 0 ? true : "Pick at least one store."
+  });
 }
 async function selectDoctorTargets() {
-  const { targets } = await inquirer.prompt([
-    {
-      type: "checkbox",
-      name: "targets",
-      message: "Add resource checks to this doctor run?",
-      theme: PROMPT_THEME,
-      choices: [
-        { name: "Product checkout", value: "product" },
-        { name: "Webhook registration", value: "webhook" },
-        { name: "Discount code", value: "discount" },
-        { name: "License key", value: "license-key" },
-        { name: "Subscription plan", value: "subscription-plan" }
-      ]
-    }
-  ]);
-  return targets;
+  return checkbox({
+    message: "Add resource checks to this doctor run?",
+    theme: PROMPT_THEME,
+    choices: [
+      { name: "Product checkout", value: "product" },
+      { name: "Webhook registration", value: "webhook" },
+      { name: "Discount code", value: "discount" },
+      { name: "License key", value: "license-key" },
+      { name: "Subscription plan", value: "subscription-plan" }
+    ]
+  });
 }
 async function askForDoctorTargetValues(targets, choices = EMPTY_INIT_RESOURCE_CHOICES) {
   if (targets.length === 0) return {};
@@ -1639,9 +1651,12 @@ async function askForDoctorTargetValues(targets, choices = EMPTY_INIT_RESOURCE_C
       validate: optional("Variant ID")
     });
   }
-  if (manualQuestions.length > 0) {
-    const manualAnswers = await inquirer.prompt(manualQuestions);
-    Object.assign(answers, manualAnswers);
+  for (const question of manualQuestions) {
+    answers[question.field] = await input({
+      message: question.message,
+      theme: PROMPT_THEME,
+      validate: question.validate
+    });
   }
   return {
     productIds: cleanList(answers.productIds),
@@ -1652,81 +1667,58 @@ async function askForDoctorTargetValues(targets, choices = EMPTY_INIT_RESOURCE_C
   };
 }
 async function confirmLiveModeRun() {
-  const { continueLive } = await inquirer.prompt([
-    {
-      type: "confirm",
-      name: "continueLive",
-      message: "This is a live-mode key. Continue with live checks?",
-      default: false,
-      theme: PROMPT_THEME
-    }
-  ]);
-  return continueLive;
+  return confirm({
+    message: "This is a live-mode key. Continue with live checks?",
+    default: false,
+    theme: PROMPT_THEME
+  });
 }
 async function confirmWriteEnvFile(filePath) {
-  const { confirm } = await inquirer.prompt([
-    {
-      type: "confirm",
-      name: "confirm",
-      message: `Write these values to ${formatPromptPath(filePath)}?`,
-      default: true,
-      theme: PROMPT_THEME
-    }
-  ]);
-  return confirm;
-}
-async function resolveTargetValue(input) {
-  if (input.group.choices.length === 0) {
-    input.manualQuestions.push({
-      type: "input",
-      name: input.field,
-      message: input.manualMessage,
-      theme: PROMPT_THEME,
-      validate: input.validate
+  return confirm({
+    message: `Write these values to ${formatPromptPath(filePath)}?`,
+    default: true,
+    theme: PROMPT_THEME
+  });
+}
+async function resolveTargetValue(input2) {
+  if (input2.group.choices.length === 0) {
+    input2.manualQuestions.push({
+      field: input2.field,
+      message: input2.manualMessage,
+      validate: input2.validate
     });
     return;
   }
-  const { values: values2 } = await inquirer.prompt([
-    {
-      type: "checkbox",
-      name: "values",
-      message: input.pickMessage,
-      theme: PROMPT_THEME,
-      choices: input.group.choices.map((choice) => ({
-        name: choice.label,
-        value: choice.value
-      }))
-    }
-  ]);
+  const values2 = await checkbox({
+    message: input2.pickMessage,
+    theme: PROMPT_THEME,
+    choices: input2.group.choices.map((choice) => ({
+      name: choice.label,
+      value: choice.value
+    }))
+  });
   if (values2.length > 0) {
-    input.answers[input.field] = values2;
+    input2.answers[input2.field] = values2;
     return;
   }
-  const action = await askEmptyTargetAction(input.emptyMessage);
+  const action = await askEmptyTargetAction(input2.emptyMessage);
   if (action === "manual") {
-    input.manualQuestions.push({
-      type: "input",
-      name: input.field,
-      message: input.manualMessage,
-      theme: PROMPT_THEME,
-      validate: input.validate
+    input2.manualQuestions.push({
+      field: input2.field,
+      message: input2.manualMessage,
+      validate: input2.validate
     });
   }
 }
 async function askEmptyTargetAction(message) {
-  const { action } = await inquirer.prompt([
-    {
-      type: "list",
-      name: "action",
-      message,
-      theme: PROMPT_THEME,
-      choices: [
-        { name: "Enter manually", value: "manual" },
-        { name: "Skip this check", value: "skip" }
-      ]
-    }
-  ]);
-  return action;
+  return select({
+    message,
+    theme: PROMPT_THEME,
+    choices: [
+      { name: "Enter manually", value: "manual" },
+      { name: "Skip this check", value: "skip" }
+    ]
+  });
 }
 function required(label) {
   return (value) => value.trim().length > 0 ? true : `${label} is required.`;
@@ -1772,11 +1764,11 @@ function isPromptCancel(error) {
 }
 
 // src/cli/resolveStores.ts
-async function resolveStores(client, input) {
-  if (input.storeIds && input.storeIds.length > 0) {
-    return { storeIds: dedupe(input.storeIds), skipped: false };
+async function resolveStores(client, input2) {
+  if (input2.storeIds && input2.storeIds.length > 0) {
+    return { storeIds: dedupe(input2.storeIds), skipped: false };
   }
-  if (input.allStores) {
+  if (input2.allStores) {
     const ids2 = await fetchReachableStoreIds(client);
     if (ids2.length === 0) {
       throw new FreshSqueezyError({
@@ -1786,7 +1778,7 @@ async function resolveStores(client, input) {
     }
     return { storeIds: ids2, skipped: false };
   }
-  if (!input.isInteractive) {
+  if (!input2.isInteractive) {
     return { storeIds: [], skipped: true };
   }
   const ids = await fetchReachableStoreIds(client);
@@ -1970,7 +1962,10 @@ async function runConnectionOnly(client, options) {
 }
 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) } };
+    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;
@@ -1979,8 +1974,10 @@ function writeFatal(err, asJson) {
   process.stderr.write(renderCliError(message, getDoctorHints(err)));
 }
 
-// src/cli/commands/launcher.ts
-import chalk4 from "chalk";
+// src/cli/commands/init.ts
+import fs from "fs/promises";
+import path2 from "path";
+import chalk3 from "chalk";
 
 // src/cli/brand.ts
 import chalk2 from "chalk";
@@ -2027,100 +2024,7 @@ function renderCancelMessage() {
 `;
 }
 
-// src/cli/projectInstall.ts
-import { spawn } from "child_process";
-import fs from "fs/promises";
-import path2 from "path";
-var PACKAGE_NAME = "fresh-squeezy";
-async function ensureFreshSqueezyDevDependency(options = {}) {
-  if (options.skipInstall) {
-    return { status: "skipped" };
-  }
-  const cwd = options.cwd ?? process.cwd();
-  const packageJsonPath = await findPackageJson(cwd);
-  if (!packageJsonPath) {
-    return { status: "no-package-json" };
-  }
-  const projectDir = path2.dirname(packageJsonPath);
-  const manifest = await readPackageJson(packageJsonPath);
-  if (manifest.name === PACKAGE_NAME) {
-    return { status: "self-package", projectDir, packageJsonPath };
-  }
-  const packageManager = await detectPackageManager(projectDir);
-  if (hasFreshSqueezy(manifest)) {
-    return { status: "already-present", projectDir, packageJsonPath, packageManager };
-  }
-  const packageSpec = options.packageVersion ? `${PACKAGE_NAME}@${options.packageVersion}` : PACKAGE_NAME;
-  const command = buildInstallCommand(packageManager, packageSpec);
-  const executable = command[0];
-  if (!executable) throw new Error("No package manager command resolved.");
-  const runCommand = options.runCommand ?? runPackageCommand;
-  const code = await runCommand(executable, command.slice(1), { cwd: projectDir });
-  if (code !== 0) {
-    throw new Error(`${command.join(" ")} failed with exit code ${code}`);
-  }
-  return { status: "installed", projectDir, packageJsonPath, packageManager, command };
-}
-async function findPackageJson(cwd) {
-  let current = path2.resolve(cwd);
-  while (true) {
-    const candidate = path2.join(current, "package.json");
-    if (await pathExists(candidate)) return candidate;
-    const parent = path2.dirname(current);
-    if (parent === current) return void 0;
-    current = parent;
-  }
-}
-async function readPackageJson(packageJsonPath) {
-  const raw = await fs.readFile(packageJsonPath, "utf8");
-  return JSON.parse(raw);
-}
-async function detectPackageManager(projectDir) {
-  if (await pathExists(path2.join(projectDir, "pnpm-lock.yaml"))) return "pnpm";
-  if (await pathExists(path2.join(projectDir, "yarn.lock"))) return "yarn";
-  if (await pathExists(path2.join(projectDir, "bun.lock")) || await pathExists(path2.join(projectDir, "bun.lockb"))) {
-    return "bun";
-  }
-  return "npm";
-}
-function hasFreshSqueezy(manifest) {
-  return [
-    manifest.dependencies,
-    manifest.devDependencies,
-    manifest.optionalDependencies,
-    manifest.peerDependencies
-  ].some((section) => section?.[PACKAGE_NAME] !== void 0);
-}
-function buildInstallCommand(packageManager, packageSpec) {
-  if (packageManager === "pnpm") return ["pnpm", "add", "-D", packageSpec];
-  if (packageManager === "yarn") return ["yarn", "add", "-D", packageSpec];
-  if (packageManager === "bun") return ["bun", "add", "-d", packageSpec];
-  return ["npm", "install", "--save-dev", packageSpec];
-}
-function runPackageCommand(command, args, options) {
-  return new Promise((resolve2, reject) => {
-    const child = spawn(command, args, {
-      cwd: options.cwd,
-      stdio: "inherit",
-      shell: false
-    });
-    child.on("error", reject);
-    child.on("close", (code) => resolve2(code ?? 1));
-  });
-}
-async function pathExists(filePath) {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // src/cli/commands/init.ts
-import fs2 from "fs/promises";
-import path3 from "path";
-import chalk3 from "chalk";
 async function runInitCommand(options = {}) {
   try {
     return await runInitFlow(options);
@@ -2164,7 +2068,9 @@ async function runInitFlow(options) {
   const storeIds = connection.resource?.storeIds ?? [];
   if (storeIds.length === 0) {
     process.stdout.write(
-      chalk3.yellow("No stores reachable with this key. Create a store in Lemon Squeezy and retry.\n")
+      chalk3.yellow(
+        "No stores reachable with this key. Create a store in Lemon Squeezy and retry.\n"
+      )
     );
     return 1;
   }
@@ -2177,7 +2083,9 @@ async function runInitFlow(options) {
   })).filter((entry) => entry.id !== "");
   if (pickable.length === 0) {
     process.stdout.write(
-      chalk3.yellow("Stores were discovered, but none could be validated. Check account access and retry.\n")
+      chalk3.yellow(
+        "Stores were discovered, but none could be validated. Check account access and retry.\n"
+      )
     );
     return 1;
   }
@@ -2188,7 +2096,7 @@ async function runInitFlow(options) {
   const resourceChoices = await discoverChoices(client, storeId, selectedTargets);
   process.stdout.write(renderDiscoverySummary(resourceChoices, selectedTargets));
   const doctorTargets = await askForDoctorTargetValues(selectedTargets, resourceChoices);
-  const envPath = path3.resolve(process.cwd(), options.envFile ?? ".env.local");
+  const envPath = path2.resolve(process.cwd(), options.envFile ?? ".env");
   const checkNames = getDoctorCheckNames(doctorTargets);
   process.stdout.write(renderSetupSummary({ envPath, mode, storeId, checkNames }));
   const shouldWrite = await confirmWriteEnvFile(envPath);
@@ -2210,19 +2118,22 @@ async function resolveStoreSelection(pickable) {
   if (pickable.length === 1) {
     const store = pickable[0];
     if (!store) throw new Error("Expected one reachable store.");
-    process.stdout.write(renderDetected("Store", `${store.name} (${store.slug})`, `id ${store.id}`));
+    process.stdout.write(
+      renderDetected("Store", `${store.name} (${store.slug})`, `id ${store.id}`)
+    );
     return store.id;
   }
   return pickStore(pickable);
 }
 async function discoverChoices(client, storeId, selectedTargets) {
-  if (selectedTargets.length === 0) return {
-    products: { choices: [] },
-    webhooks: { choices: [] },
-    discounts: { choices: [] },
-    licenseKeys: { choices: [] },
-    subscriptionPlans: { choices: [] }
-  };
+  if (selectedTargets.length === 0)
+    return {
+      products: { choices: [] },
+      webhooks: { choices: [] },
+      discounts: { choices: [] },
+      licenseKeys: { choices: [] },
+      subscriptionPlans: { choices: [] }
+    };
   return discoverInitResourceChoices(client, storeId, selectedTargets);
 }
 async function resolveApiKey() {
@@ -2255,8 +2166,10 @@ async function createDetectedClient(apiKey) {
     return { client, mode: actualMode, connection };
   }
   if (envMode) {
-    process.stdout.write(chalk3.dim(`Using ${ENV_KEYS.mode}=${envMode}; API mode was not exposed.
-`));
+    process.stdout.write(
+      chalk3.dim(`Using ${ENV_KEYS.mode}=${envMode}; API mode was not exposed.
+`)
+    );
     return { client, mode: envMode, connection };
   }
   process.stdout.write(chalk3.dim("Could not auto-detect key mode; using test mode.\n"));
@@ -2266,8 +2179,10 @@ function parseEnvMode() {
   const value = process.env[ENV_KEYS.mode]?.trim();
   if (value === "test" || value === "live") return value;
   if (value) {
-    process.stdout.write(chalk3.yellow(`Ignoring invalid ${ENV_KEYS.mode}=${value}; expected test or live.
-`));
+    process.stdout.write(
+      chalk3.yellow(`Ignoring invalid ${ENV_KEYS.mode}=${value}; expected test or live.
+`)
+    );
   }
   return void 0;
 }
@@ -2284,13 +2199,13 @@ function pushCheckName(names, name, values2) {
   if (!values2 || values2.length === 0) return;
   names.push(values2.length === 1 ? name : `${name} x${values2.length}`);
 }
-function renderSetupSummary(input) {
+function renderSetupSummary(input2) {
   return [
     renderStep(5, 5, "Ready to verify", "review before writing env"),
-    `  ${chalk3.dim("mode")}   ${input.mode}`,
-    `  ${chalk3.dim("store")}  ${input.storeId}`,
-    `  ${chalk3.dim("checks")} ${input.checkNames.join(", ")}`,
-    `  ${chalk3.dim("env")}    ${input.envPath}`,
+    `  ${chalk3.dim("mode")}   ${input2.mode}`,
+    `  ${chalk3.dim("store")}  ${input2.storeId}`,
+    `  ${chalk3.dim("checks")} ${input2.checkNames.join(", ")}`,
+    `  ${chalk3.dim("env")}    ${input2.envPath}`,
     ""
   ].join("\n");
 }
@@ -2318,13 +2233,13 @@ async function writeEnvFile(envPath, values2) {
       next.push(`${key}=${value}`);
     }
   }
-  await fs2.mkdir(path3.dirname(envPath), { recursive: true });
-  await fs2.writeFile(envPath, `${next.join("\n").replace(/\n*$/, "")}
+  await fs.mkdir(path2.dirname(envPath), { recursive: true });
+  await fs.writeFile(envPath, `${next.join("\n").replace(/\n*$/, "")}
 `, { encoding: "utf8" });
 }
 async function readEnvFile(envPath) {
   try {
-    return await fs2.readFile(envPath, "utf8");
+    return await fs.readFile(envPath, "utf8");
   } catch (err) {
     if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
       return "";
@@ -2347,13 +2262,108 @@ function renderDiscoverySummary(choices, selectedTargets) {
     if (group.error) {
       lines.push(chalk3.yellow(`  ! ${label} discovery failed; manual entry is available.`));
     } else {
-      lines.push(renderDetected(label, String(group.choices.length), "Lemon Squeezy API").trimEnd());
+      lines.push(
+        renderDetected(label, String(group.choices.length), "Lemon Squeezy API").trimEnd()
+      );
     }
   }
   return `${lines.join("\n")}
 `;
 }
 
+// src/cli/commands/launcher.ts
+import chalk4 from "chalk";
+
+// src/cli/projectInstall.ts
+import { spawn } from "child_process";
+import fs2 from "fs/promises";
+import path3 from "path";
+var PACKAGE_NAME = "fresh-squeezy";
+async function ensureFreshSqueezyDevDependency(options = {}) {
+  if (options.skipInstall) {
+    return { status: "skipped" };
+  }
+  const cwd = options.cwd ?? process.cwd();
+  const packageJsonPath = await findPackageJson(cwd);
+  if (!packageJsonPath) {
+    return { status: "no-package-json" };
+  }
+  const projectDir = path3.dirname(packageJsonPath);
+  const manifest = await readPackageJson(packageJsonPath);
+  if (manifest.name === PACKAGE_NAME) {
+    return { status: "self-package", projectDir, packageJsonPath };
+  }
+  const packageManager = await detectPackageManager(projectDir);
+  if (hasFreshSqueezy(manifest)) {
+    return { status: "already-present", projectDir, packageJsonPath, packageManager };
+  }
+  const packageSpec = options.packageVersion ? `${PACKAGE_NAME}@${options.packageVersion}` : PACKAGE_NAME;
+  const command = buildInstallCommand(packageManager, packageSpec);
+  const executable = command[0];
+  if (!executable) throw new Error("No package manager command resolved.");
+  const runCommand = options.runCommand ?? runPackageCommand;
+  const code = await runCommand(executable, command.slice(1), { cwd: projectDir });
+  if (code !== 0) {
+    throw new Error(`${command.join(" ")} failed with exit code ${code}`);
+  }
+  return { status: "installed", projectDir, packageJsonPath, packageManager, command };
+}
+async function findPackageJson(cwd) {
+  let current = path3.resolve(cwd);
+  while (true) {
+    const candidate = path3.join(current, "package.json");
+    if (await pathExists(candidate)) return candidate;
+    const parent = path3.dirname(current);
+    if (parent === current) return void 0;
+    current = parent;
+  }
+}
+async function readPackageJson(packageJsonPath) {
+  const raw = await fs2.readFile(packageJsonPath, "utf8");
+  return JSON.parse(raw);
+}
+async function detectPackageManager(projectDir) {
+  if (await pathExists(path3.join(projectDir, "pnpm-lock.yaml"))) return "pnpm";
+  if (await pathExists(path3.join(projectDir, "yarn.lock"))) return "yarn";
+  if (await pathExists(path3.join(projectDir, "bun.lock")) || await pathExists(path3.join(projectDir, "bun.lockb"))) {
+    return "bun";
+  }
+  return "npm";
+}
+function hasFreshSqueezy(manifest) {
+  return [
+    manifest.dependencies,
+    manifest.devDependencies,
+    manifest.optionalDependencies,
+    manifest.peerDependencies
+  ].some((section) => section?.[PACKAGE_NAME] !== void 0);
+}
+function buildInstallCommand(packageManager, packageSpec) {
+  if (packageManager === "pnpm") return ["pnpm", "add", "-D", packageSpec];
+  if (packageManager === "yarn") return ["yarn", "add", "-D", packageSpec];
+  if (packageManager === "bun") return ["bun", "add", "-d", packageSpec];
+  return ["npm", "install", "--save-dev", packageSpec];
+}
+function runPackageCommand(command, args, options) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      stdio: "inherit",
+      shell: false
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve2(code ?? 1));
+  });
+}
+async function pathExists(filePath) {
+  try {
+    await fs2.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/cli/commands/launcher.ts
 async function runLauncherCommand(options) {
   if (!options.isInteractive) return 2;
@@ -2370,8 +2380,10 @@ async function runLauncherCommand(options) {
       packageVersion: options.packageVersion
     });
     process.stdout.write(renderProjectInstallResult(installResult));
-    process.stdout.write(renderStep(2, 2, "Guided setup", "detect credentials, stores, and resources"));
-    return runInitCommand({ isInteractive: true });
+    if (!process.env[ENV_KEYS.apiKey]?.trim()) {
+      return startGuidedSetup();
+    }
+    return routeLauncherAction(await pickLauncherAction());
   } catch (err) {
     if (isPromptCancel(err)) {
       process.stderr.write(renderCancelMessage());
@@ -2385,6 +2397,25 @@ async function runLauncherCommand(options) {
     return 1;
   }
 }
+async function routeLauncherAction(action) {
+  switch (action) {
+    case "init":
+      return startGuidedSetup();
+    case "doctor":
+      return runDoctorCommand({ isInteractive: true });
+    case "examples":
+      process.stdout.write(renderCommandExamples());
+      return 0;
+    case "exit":
+      return 0;
+  }
+}
+function startGuidedSetup() {
+  process.stdout.write(
+    renderStep(2, 2, "Guided setup", "detect credentials, stores, and resources")
+  );
+  return runInitCommand({ isInteractive: true });
+}
 function renderProjectInstallResult(result) {
   if (result.status === "installed") {
     return renderDetected(
@@ -2463,9 +2494,7 @@ async function runPerStore(client, target, storeIds, options) {
   }
   if (target === "webhook") {
     const url = required2(options.webhookUrl, "--webhook-url is required for `validate webhook`.");
-    return Promise.all(
-      storeIds.map((storeId) => client.validateWebhook({ storeId, url }))
-    );
+    return Promise.all(storeIds.map((storeId) => client.validateWebhook({ storeId, url })));
   }
   return [];
 }
@@ -2478,18 +2507,36 @@ async function runProduct(client, options) {
   });
 }
 async function runDiscount(client, options) {
-  const discountId = required2(options.discountId, "--discount-id is required for `validate discount`.");
-  const storeId = required2(options.storeIds?.[0], "--store-ids is required for `validate discount`.");
+  const discountId = required2(
+    options.discountId,
+    "--discount-id is required for `validate discount`."
+  );
+  const storeId = required2(
+    options.storeIds?.[0],
+    "--store-ids is required for `validate discount`."
+  );
   return client.validateDiscount({ storeId, discountId });
 }
 async function runLicenseKey(client, options) {
-  const licenseKeyId = required2(options.licenseKeyId, "--license-key-id is required for `validate license-key`.");
-  const storeId = required2(options.storeIds?.[0], "--store-ids is required for `validate license-key`.");
+  const licenseKeyId = required2(
+    options.licenseKeyId,
+    "--license-key-id is required for `validate license-key`."
+  );
+  const storeId = required2(
+    options.storeIds?.[0],
+    "--store-ids is required for `validate license-key`."
+  );
   return client.validateLicenseKey({ storeId, licenseKeyId });
 }
 async function runSubscriptionPlan(client, options) {
-  const variantId = required2(options.variantId, "--variant-id is required for `validate subscription-plan`.");
-  const storeId = required2(options.storeIds?.[0], "--store-ids is required for `validate subscription-plan`.");
+  const variantId = required2(
+    options.variantId,
+    "--variant-id is required for `validate subscription-plan`."
+  );
+  const storeId = required2(
+    options.storeIds?.[0],
+    "--store-ids is required for `validate subscription-plan`."
+  );
   return client.validateSubscriptionPlan({ storeId, variantId });
 }
 function emit(result, options) {
@@ -2510,7 +2557,6 @@ function required2(value, message) {
 }
 
 // src/cli/main.ts
-dotenv.config({ path: ".env.local" });
 dotenv.config();
 var isInteractive = Boolean(process.stdin.isTTY);
 var packageVersion = readPackageVersion();
@@ -2546,7 +2592,10 @@ program.action(async (opts) => {
   });
   process.exit(code);
 });
-var doctor2 = program.command("doctor").description("Run the full integration doctor").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("--all-resources", "Discover and validate every supported resource in each selected store").option("--product-id <id>", "Product to validate").option("--webhook-url <url>", "Webhook URL to validate").option("--discount-id <id>", "Discount to validate").option("--license-key-id <id>", "License key to validate").option("--variant-id <id>", "Subscription plan variant to validate").option("--json", "Emit machine-readable JSON").action(async (opts) => {
+var doctor2 = program.command("doctor").description("Run the full integration doctor").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(
+  "--all-resources",
+  "Discover and validate every supported resource in each selected store"
+).option("--product-id <id>", "Product to validate").option("--webhook-url <url>", "Webhook URL to validate").option("--discount-id <id>", "Discount to validate").option("--license-key-id <id>", "License key to validate").option("--variant-id <id>", "Subscription plan variant to validate").option("--json", "Emit machine-readable JSON").action(async (opts) => {
   const code = await runDoctorCommand({
     mode: opts.mode,
     storeIds: opts.storeIds,
@@ -2588,16 +2637,22 @@ Targets:
 );
 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("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));
 validate.command("discount").description("Check a discount code is valid and redeemable").requiredOption("--discount-id <id>", "Discount ID to validate").option("--store-ids <ids>", "Store ID for ownership check (first ID used)", parseCsv).option("-m, --mode <mode>", "test or live", parseMode).option("--json", "Emit machine-readable JSON").action(async (opts) => runValidate("discount", opts));
 validate.command("license-key").description("Check a license key is active and not at its activation limit").requiredOption("--license-key-id <id>", "License key ID to validate").option("--store-ids <ids>", "Store ID for ownership check (first ID used)", parseCsv).option("-m, --mode <mode>", "test or live", parseMode).option("--json", "Emit machine-readable JSON").action(async (opts) => runValidate("license-key", opts));
 validate.command("subscription-plan").description("Check a subscription plan variant has valid billing interval and trial config").requiredOption("--variant-id <id>", "Variant ID of the subscription plan").option("--store-ids <ids>", "Store ID for ownership check (first ID used)", parseCsv).option("-m, --mode <mode>", "test or live", parseMode).option("--json", "Emit machine-readable JSON").action(async (opts) => runValidate("subscription-plan", 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) => {
+program.command("init").description("Interactive setup: ask for credentials, pick a store, run doctor").option("--env-file <path>", "Where to write credentials (default: .env)").action(async (opts) => {
   const code = await runInitCommand({ envFile: opts.envFile, isInteractive });
   process.exit(code);
 });
-var types = program.command("types").description("Type-augmentation utilities for the official Lemon Squeezy SDK and hand-rolled types");
+var types = program.command("types").description(
+  "Type-augmentation utilities for the official Lemon Squeezy SDK and hand-rolled types"
+);
 types.command("augment").description(
   "Generate a .d.ts that intersects your Lemon Squeezy resource types with changelog fields fresh-squeezy tracks."
 ).option("--out <path>", "Output path (default: lemonsqueezy.augment.d.ts in CWD)").option("--force", "Emit the generic file even when @lemonsqueezy/lemonsqueezy.js is detected").action(async (opts) => {