@insforge/cli 0.1.86 → 0.1.88-razorpay.0

package/dist/index.js

@@ -263,10 +263,11 @@ import * as clack4 from "@clack/prompts";
 
 // src/lib/errors.ts
 var CLIError = class extends Error {
-  constructor(message, exitCode = 1, code) {
+  constructor(message, exitCode = 1, code, statusCode) {
     super(message);
     this.exitCode = exitCode;
     this.code = code;
+    this.statusCode = statusCode;
     this.name = "CLIError";
   }
 };
@@ -1172,7 +1173,7 @@ import * as clack5 from "@clack/prompts";
 
 // src/lib/analytics.ts
 import { PostHog } from "posthog-node";
-var POSTHOG_API_KEY = "phc_ueV1ii62wdBTkH7E70ugyeqHIHu8dFDdjs0qq3TZhJz";
+var POSTHOG_API_KEY = "";
 var POSTHOG_HOST = process.env.POSTHOG_HOST || "https://us.i.posthog.com";
 var client = null;
 function getClient() {
@@ -2066,7 +2067,7 @@ ${err.nextActions}`;
     if (res.status === 404 && isRouteLevel404 && path6.startsWith("/api/ai")) {
       message = "AI Model Gateway setup is not available on this backend.\nUpgrade your InsForge project to a version with Model Gateway support, or keep using the legacy @insforge/sdk AI modules for projects that still rely on the older AI API surface.";
     }
-    throw new CLIError(message);
+    throw new CLIError(message, 1, err.error, res.status);
   }
   return res;
 }
@@ -7188,7 +7189,7 @@ function registerDiagnoseCommands(diagnoseCmd2) {
         const s = !json ? clack16.spinner() : null;
         s?.start("Collecting diagnostic data...");
         const data2 = await collectDiagnosticData(projectId, ossMode, apiUrl);
-        const cliVersion = "0.1.86";
+        const cliVersion = "0.1.88-razorpay.0";
         s?.stop("Data collected");
         if (!json) {
           console.log(`
@@ -7427,75 +7428,142 @@ function withQuery(path6, params) {
 async function readJson(res) {
   return await res.json();
 }
-function withEnvironmentPath(environment, suffix) {
-  return `/api/payments/${encodeURIComponent(environment)}${suffix}`;
+function withProviderPath(provider, suffix) {
+  return `/api/payments/${encodeURIComponent(provider)}${suffix}`;
+}
+function withProviderEnvironmentPath(provider, environment, suffix) {
+  return withProviderPath(
+    provider,
+    `/${encodeURIComponent(environment)}${suffix}`
+  );
+}
+async function getStripePaymentsStatus() {
+  return readJson(await ossFetch(withProviderPath("stripe", "/status")));
 }
-async function getPaymentsStatus() {
-  return readJson(await ossFetch("/api/payments/status"));
+async function getRazorpayPaymentsStatus() {
+  return readJson(await ossFetch(withProviderPath("razorpay", "/status")));
 }
-async function getPaymentsConfig() {
-  return readJson(await ossFetch("/api/payments/config"));
+async function getStripePaymentsConfig() {
+  return readJson(await ossFetch(withProviderPath("stripe", "/config")));
+}
+async function getRazorpayPaymentsConfig() {
+  return readJson(await ossFetch(withProviderPath("razorpay", "/config")));
 }
 async function setStripeSecretKey(environment, secretKey) {
+  const request = { secretKey };
   return readJson(
-    await ossFetch(withEnvironmentPath(environment, "/config"), {
-      method: "PUT",
-      body: JSON.stringify({ secretKey })
-    })
+    await ossFetch(
+      withProviderEnvironmentPath("stripe", environment, "/config"),
+      {
+        method: "PUT",
+        body: JSON.stringify(request)
+      }
+    )
+  );
+}
+async function setRazorpayKeys(environment, request) {
+  return readJson(
+    await ossFetch(
+      withProviderEnvironmentPath("razorpay", environment, "/config"),
+      {
+        method: "PUT",
+        body: JSON.stringify(request)
+      }
+    )
   );
 }
 async function removeStripeSecretKey(environment) {
   return readJson(
-    await ossFetch(withEnvironmentPath(environment, "/config"), {
-      method: "DELETE"
-    })
+    await ossFetch(
+      withProviderEnvironmentPath("stripe", environment, "/config"),
+      {
+        method: "DELETE"
+      }
+    )
+  );
+}
+async function removeRazorpayKeys(environment) {
+  return readJson(
+    await ossFetch(
+      withProviderEnvironmentPath("razorpay", environment, "/config"),
+      { method: "DELETE" }
+    )
+  );
+}
+async function syncStripePayments(environment = "all") {
+  return readJson(
+    await ossFetch(
+      environment === "all" ? withProviderPath("stripe", "/sync") : withProviderEnvironmentPath("stripe", environment, "/sync"),
+      { method: "POST" }
+    )
   );
 }
-async function syncPayments(environment = "all") {
+async function syncRazorpayPayments(environment = "all") {
   return readJson(
     await ossFetch(
-      environment === "all" ? "/api/payments/sync" : withEnvironmentPath(environment, "/sync"),
+      environment === "all" ? withProviderPath("razorpay", "/sync") : withProviderEnvironmentPath("razorpay", environment, "/sync"),
       { method: "POST" }
     )
   );
 }
-async function configurePaymentWebhook(environment) {
+async function configureStripeWebhook(environment) {
+  return readJson(
+    await ossFetch(
+      withProviderEnvironmentPath("stripe", environment, "/webhook"),
+      {
+        method: "POST"
+      }
+    )
+  );
+}
+async function listStripeCatalog(environment) {
   return readJson(
-    await ossFetch(withEnvironmentPath(environment, "/webhook"), {
-      method: "POST"
-    })
+    await ossFetch(
+      withProviderEnvironmentPath("stripe", environment, "/catalog")
+    )
   );
 }
-async function listPaymentCatalog(environment) {
-  return readJson(await ossFetch(withEnvironmentPath(environment, "/catalog")));
+async function listRazorpayCatalog(environment) {
+  return readJson(
+    await ossFetch(
+      withProviderEnvironmentPath("razorpay", environment, "/catalog")
+    )
+  );
 }
-async function listPaymentProducts(environment) {
+async function listStripeProducts(environment) {
   return readJson(
-    await ossFetch(withEnvironmentPath(environment, "/catalog/products"))
+    await ossFetch(
+      withProviderEnvironmentPath("stripe", environment, "/catalog/products")
+    )
   );
 }
-async function getPaymentProduct(environment, productId) {
+async function getStripeProduct(environment, productId) {
   return readJson(
     await ossFetch(
-      withEnvironmentPath(
+      withProviderEnvironmentPath(
+        "stripe",
         environment,
         `/catalog/products/${encodeURIComponent(productId)}`
       )
     )
   );
 }
-async function createPaymentProduct(environment, request) {
+async function createStripeProduct(environment, request) {
   return readJson(
-    await ossFetch(withEnvironmentPath(environment, "/catalog/products"), {
-      method: "POST",
-      body: JSON.stringify(request)
-    })
+    await ossFetch(
+      withProviderEnvironmentPath("stripe", environment, "/catalog/products"),
+      {
+        method: "POST",
+        body: JSON.stringify(request)
+      }
+    )
   );
 }
-async function updatePaymentProduct(environment, productId, request) {
+async function updateStripeProduct(environment, productId, request) {
   return readJson(
     await ossFetch(
-      withEnvironmentPath(
+      withProviderEnvironmentPath(
+        "stripe",
         environment,
         `/catalog/products/${encodeURIComponent(productId)}`
       ),
@@ -7506,10 +7574,11 @@ async function updatePaymentProduct(environment, productId, request) {
     )
   );
 }
-async function deletePaymentProduct(environment, productId) {
+async function deleteStripeProduct(environment, productId) {
   return readJson(
     await ossFetch(
-      withEnvironmentPath(
+      withProviderEnvironmentPath(
+        "stripe",
         environment,
         `/catalog/products/${encodeURIComponent(productId)}`
       ),
@@ -7517,37 +7586,43 @@ async function deletePaymentProduct(environment, productId) {
     )
   );
 }
-async function listPaymentPrices(environment, stripeProductId) {
+async function listStripePrices(environment, productId) {
   return readJson(
     await ossFetch(
-      withQuery(withEnvironmentPath(environment, "/catalog/prices"), {
-        stripeProductId
-      })
+      withQuery(
+        withProviderEnvironmentPath("stripe", environment, "/catalog/prices"),
+        { productId }
+      )
     )
   );
 }
-async function getPaymentPrice(environment, priceId) {
+async function getStripePrice(environment, priceId) {
   return readJson(
     await ossFetch(
-      withEnvironmentPath(
+      withProviderEnvironmentPath(
+        "stripe",
         environment,
         `/catalog/prices/${encodeURIComponent(priceId)}`
       )
     )
   );
 }
-async function createPaymentPrice(environment, request) {
+async function createStripePrice(environment, request) {
   return readJson(
-    await ossFetch(withEnvironmentPath(environment, "/catalog/prices"), {
-      method: "POST",
-      body: JSON.stringify(request)
-    })
+    await ossFetch(
+      withProviderEnvironmentPath("stripe", environment, "/catalog/prices"),
+      {
+        method: "POST",
+        body: JSON.stringify(request)
+      }
+    )
   );
 }
-async function updatePaymentPrice(environment, priceId, request) {
+async function updateStripePrice(environment, priceId, request) {
   return readJson(
     await ossFetch(
-      withEnvironmentPath(
+      withProviderEnvironmentPath(
+        "stripe",
         environment,
         `/catalog/prices/${encodeURIComponent(priceId)}`
       ),
@@ -7558,10 +7633,11 @@ async function updatePaymentPrice(environment, priceId, request) {
     )
   );
 }
-async function archivePaymentPrice(environment, priceId) {
+async function archiveStripePrice(environment, priceId) {
   return readJson(
     await ossFetch(
-      withEnvironmentPath(
+      withProviderEnvironmentPath(
+        "stripe",
         environment,
         `/catalog/prices/${encodeURIComponent(priceId)}`
       ),
@@ -7569,29 +7645,99 @@ async function archivePaymentPrice(environment, priceId) {
     )
   );
 }
-async function listSubscriptions(environment, request) {
+async function createRazorpayItem(environment, request) {
+  return readJson(
+    await ossFetch(
+      withProviderEnvironmentPath("razorpay", environment, "/catalog/items"),
+      {
+        method: "POST",
+        body: JSON.stringify(request)
+      }
+    )
+  );
+}
+async function updateRazorpayItem(environment, itemId, request) {
+  return readJson(
+    await ossFetch(
+      withProviderEnvironmentPath(
+        "razorpay",
+        environment,
+        `/catalog/items/${encodeURIComponent(itemId)}`
+      ),
+      {
+        method: "PATCH",
+        body: JSON.stringify(request)
+      }
+    )
+  );
+}
+async function createRazorpayPlan(environment, request) {
+  return readJson(
+    await ossFetch(
+      withProviderEnvironmentPath("razorpay", environment, "/catalog/plans"),
+      {
+        method: "POST",
+        body: JSON.stringify(request)
+      }
+    )
+  );
+}
+async function listStripeSubscriptions(environment, request) {
+  return readJson(
+    await ossFetch(
+      withQuery(
+        withProviderEnvironmentPath("stripe", environment, "/subscriptions"),
+        request
+      )
+    )
+  );
+}
+async function listRazorpaySubscriptions(environment, request) {
   return readJson(
     await ossFetch(
-      withQuery(withEnvironmentPath(environment, "/subscriptions"), request)
+      withQuery(
+        withProviderEnvironmentPath("razorpay", environment, "/subscriptions"),
+        request
+      )
     )
   );
 }
-async function listPaymentCustomers(environment, request = {}) {
+async function listPaymentCustomers(provider, environment, request = {}) {
   return readJson(
     await ossFetch(
-      withQuery(withEnvironmentPath(environment, "/customers"), request)
+      withQuery(
+        withProviderEnvironmentPath(provider, environment, "/customers"),
+        request
+      )
     )
   );
 }
-async function listPaymentHistory(environment, request) {
+async function listPaymentTransactions(provider, environment, request) {
   return readJson(
     await ossFetch(
-      withQuery(withEnvironmentPath(environment, "/payment-history"), request)
+      withQuery(
+        withProviderEnvironmentPath(provider, environment, "/transactions"),
+        request
+      )
     )
   );
 }
 
 // src/commands/payments/utils.ts
+var MAX_TELEMETRY_ERROR_MESSAGE_LENGTH = 500;
+function getErrorTelemetry(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const truncatedMessage = message.length > MAX_TELEMETRY_ERROR_MESSAGE_LENGTH ? `${message.slice(0, MAX_TELEMETRY_ERROR_MESSAGE_LENGTH)}...` : message;
+  return {
+    error_name: error instanceof Error ? error.name : typeof error,
+    error_message: truncatedMessage,
+    ...error instanceof CLIError ? {
+      error_code: error.code,
+      exit_code: error.exitCode,
+      status_code: error.statusCode
+    } : {}
+  };
+}
 function parseEnvironment(value) {
   if (value === "test" || value === "live") return value;
   throw new CLIError('Environment must be "test" or "live".');
@@ -7600,6 +7746,15 @@ function parseEnvironmentOrAll(value) {
   if (value === "all") return value;
   return parseEnvironment(value);
 }
+function parseRazorpayPlanPeriod(value) {
+  if (value === void 0) return void 0;
+  if (value === "daily" || value === "weekly" || value === "monthly" || value === "yearly") {
+    return value;
+  }
+  throw new CLIError(
+    "--period must be one of: daily, weekly, monthly, yearly."
+  );
+}
 function parseBooleanOption(value, flagName) {
   if (value === void 0) return void 0;
   const normalized = value.toLowerCase();
@@ -7667,13 +7822,14 @@ function formatRecurring(interval, intervalCount) {
   if (!interval) return "one-time";
   return `${intervalCount && intervalCount > 1 ? `${intervalCount} ` : ""}${interval}`;
 }
-async function trackPaymentUsage(subcommand, success, properties = {}) {
+async function trackPaymentUsage(subcommand, success, properties = {}, error) {
   try {
     const config = getProjectConfig();
     if (config) {
       trackPayments(subcommand, config, {
         success,
-        ...properties
+        ...properties,
+        ...error !== void 0 ? getErrorTelemetry(error) : {}
       });
     }
   } catch {
@@ -7683,76 +7839,138 @@ async function trackPaymentUsage(subcommand, success, properties = {}) {
 }
 
 // src/commands/payments/catalog.ts
-function registerPaymentsCatalogCommand(paymentsCmd2) {
-  paymentsCmd2.command("catalog").description("List mirrored Stripe products and prices for one environment").requiredOption(
+function registerPaymentsCatalogCommand(paymentsCmd2, provider) {
+  paymentsCmd2.command("catalog").description("List mirrored provider catalog records for one environment").requiredOption(
     "--environment <environment>",
-    "Stripe environment: test or live"
+    "Payment environment: test or live"
   ).action(async (opts, cmd) => {
     const { json } = getRootOpts(cmd);
     try {
       const environment = parseEnvironment(opts.environment);
       await requireAuth();
-      const data = await listPaymentCatalog(environment);
-      if (json) {
-        outputJson(data);
-      } else {
-        if (data.products.length === 0 && data.prices.length === 0) {
-          console.log("No Stripe catalog records found.");
-          await trackPaymentUsage("catalog", true, { environment });
-          return;
-        }
-        if (data.products.length > 0) {
-          console.log("Products");
-          outputTable(
-            ["Env", "Product ID", "Name", "Active", "Default Price"],
-            data.products.map((product) => [
-              product.environment,
-              product.stripeProductId,
-              product.name,
-              product.active ? "Yes" : "No",
-              product.defaultPriceId ?? "-"
-            ])
-          );
+      if (provider === "stripe") {
+        const data = await listStripeCatalog(environment);
+        if (json) {
+          outputJson(data);
+        } else {
+          if (data.products.length === 0 && data.prices.length === 0) {
+            console.log("No Stripe catalog records found.");
+            await trackPaymentUsage("catalog", true, {
+              provider,
+              environment
+            });
+            return;
+          }
+          if (data.products.length > 0) {
+            console.log("Products");
+            outputTable(
+              ["Env", "Product ID", "Name", "Active", "Default Price"],
+              data.products.map((product) => [
+                product.environment,
+                product.productId,
+                product.name,
+                product.active ? "Yes" : "No",
+                product.defaultPriceId ?? "-"
+              ])
+            );
+          }
+          if (data.prices.length > 0) {
+            console.log("Prices");
+            outputTable(
+              [
+                "Env",
+                "Price ID",
+                "Product ID",
+                "Amount",
+                "Type",
+                "Active",
+                "Recurring"
+              ],
+              data.prices.map((price) => [
+                price.environment,
+                price.priceId,
+                price.productId ?? "-",
+                formatAmount(price.unitAmount, price.currency),
+                price.type,
+                price.active ? "Yes" : "No",
+                formatRecurring(
+                  price.recurringInterval,
+                  price.recurringIntervalCount
+                )
+              ])
+            );
+          }
         }
-        if (data.prices.length > 0) {
-          console.log("Prices");
-          outputTable(
-            [
-              "Env",
-              "Price ID",
-              "Product ID",
-              "Amount",
-              "Type",
-              "Active",
-              "Recurring"
-            ],
-            data.prices.map((price) => [
-              price.environment,
-              price.stripePriceId,
-              price.stripeProductId ?? "-",
-              formatAmount(price.unitAmount, price.currency),
-              price.type,
-              price.active ? "Yes" : "No",
-              formatRecurring(
-                price.recurringInterval,
-                price.recurringIntervalCount
-              )
-            ])
-          );
+      } else {
+        const data = await listRazorpayCatalog(environment);
+        if (json) {
+          outputJson(data);
+        } else {
+          if (data.items.length === 0 && data.plans.length === 0) {
+            console.log("No Razorpay catalog records found.");
+            await trackPaymentUsage("catalog", true, {
+              provider,
+              environment
+            });
+            return;
+          }
+          if (data.items.length > 0) {
+            console.log("Items");
+            outputTable(
+              ["Env", "Item ID", "Name", "Amount", "Active", "Type"],
+              data.items.map((item) => [
+                item.environment,
+                item.itemId,
+                item.name,
+                formatAmount(item.amount, item.currency),
+                item.active ? "Yes" : "No",
+                item.type ?? "-"
+              ])
+            );
+          }
+          if (data.plans.length > 0) {
+            console.log("Plans");
+            outputTable(
+              [
+                "Env",
+                "Plan ID",
+                "Item ID",
+                "Amount",
+                "Period",
+                "Interval",
+                "Active"
+              ],
+              data.plans.map((plan) => [
+                plan.environment,
+                plan.planId,
+                plan.itemId,
+                formatAmount(plan.amount, plan.currency),
+                plan.period,
+                String(plan.interval),
+                plan.active ? "Yes" : "No"
+              ])
+            );
+          }
         }
       }
-      await trackPaymentUsage("catalog", true, { environment });
+      await trackPaymentUsage("catalog", true, { provider, environment });
     } catch (err) {
-      await trackPaymentUsage("catalog", false, {
-        environment: opts.environment
-      });
+      await trackPaymentUsage(
+        "catalog",
+        false,
+        {
+          provider,
+          environment: opts.environment
+        },
+        err
+      );
       handleError(err, json);
     }
   });
 }
 
 // src/commands/payments/config.ts
-function outputConfigTable(data) {
+function outputStripeConfigTable(data) {
   if (data.keys.length === 0) {
     console.log("No Stripe keys configured.");
     return;
@@ -7766,32 +7984,111 @@ function outputConfigTable(data) {
     ])
   );
 }
-function registerPaymentsConfigCommand(paymentsCmd2) {
-  const configCmd = paymentsCmd2.command("config").description("Manage Stripe API keys for payments").action(async (_opts, cmd) => {
+function outputRazorpayConfigTable(data) {
+  if (data.razorpayKeys.length === 0) {
+    console.log("No Razorpay keys configured.");
+    return;
+  }
+  outputTable(
+    ["Env", "Type", "Configured", "Key"],
+    data.razorpayKeys.map((key) => [
+      key.environment,
+      key.keyType,
+      key.hasKey ? "Yes" : "No",
+      key.maskedKey ?? "-"
+    ])
+  );
+}
+function registerPaymentsConfigCommand(paymentsCmd2, provider) {
+  const configCmd = paymentsCmd2.command("config").description("Manage payment provider keys");
+  configCmd.command("list").description("List configured payment provider keys").action(async (_opts, cmd) => {
     const { json } = getRootOpts(cmd);
     try {
       await requireAuth();
-      const data = await getPaymentsConfig();
+      if (provider === "stripe") {
+        const data = await getStripePaymentsConfig();
+        if (json) {
+          outputJson(data);
+        } else {
+          outputStripeConfigTable(data);
+        }
+      } else {
+        const data = await getRazorpayPaymentsConfig();
+        if (json) {
+          outputJson(data);
+        } else {
+          outputRazorpayConfigTable(data);
+        }
+      }
+      await trackPaymentUsage("config", true, { provider });
+    } catch (err) {
+      await trackPaymentUsage("config", false, { provider }, err);
+      handleError(err, json);
+    }
+  });
+  if (provider === "stripe") {
+    registerStripeConfigSetCommand(configCmd);
+  } else {
+    registerRazorpayConfigSetCommand(configCmd);
+  }
+  configCmd.command("remove").description("Remove configured payment provider keys").requiredOption(
+    "--environment <environment>",
+    "Payment environment: test or live"
+  ).action(async (opts, cmd) => {
+    const { json, yes } = getRootOpts(cmd);
+    try {
+      const environment = parseEnvironment(opts.environment);
+      await requireAuth();
+      if (json && !yes) {
+        throw new CLIError(
+          "Use --yes with --json to remove payment keys non-interactively."
+        );
+      }
+      if (!yes) {
+        const confirm8 = await confirm2({
+          message: `Remove ${provider} ${environment} keys? Payment sync and mutations for this environment will stop.`
+        });
+        if (isCancel2(confirm8) || !confirm8) process.exit(0);
+      }
+      const data = provider === "stripe" ? await removeStripeSecretKey(environment) : await removeRazorpayKeys(environment);
       if (json) {
         outputJson(data);
       } else {
-        outputConfigTable(data);
+        outputSuccess(`${provider} ${environment} keys removed.`);
       }
-      await trackPaymentUsage("config", true);
+      await trackPaymentUsage("config.remove", true, {
+        provider,
+        environment
+      });
     } catch (err) {
-      await trackPaymentUsage("config", false);
+      await trackPaymentUsage(
+        "config.remove",
+        false,
+        {
+          provider,
+          environment: opts.environment
+        },
+        err
+      );
       handleError(err, json);
     }
   });
-  configCmd.command("set <environment> [secretKey]").description("Configure a Stripe secret key for test or live payments").action(async (environmentValue, secretKeyValue, _opts, cmd) => {
+}
+function registerStripeConfigSetCommand(configCmd) {
+  configCmd.command("set [secretKey]").description("Configure a Stripe secret key for test or live payments").requiredOption(
+    "--environment <environment>",
+    "Stripe environment: test or live"
+  ).option("--secret-key <secretKey>", "Stripe secret key").action(async (secretKeyValue, opts, cmd) => {
     const { json } = getRootOpts(cmd);
     try {
-      const environment = parseEnvironment(environmentValue);
+      const environment = parseEnvironment(opts.environment);
       await requireAuth();
-      let secretKey = secretKeyValue;
+      let secretKey = opts.secretKey ?? secretKeyValue;
       if (!secretKey) {
         if (json) {
-          throw new CLIError("Provide secretKey when using --json.");
+          throw new CLIError(
+            "Provide secretKey or --secret-key when using --json."
+          );
         }
         const input = await password2({
           message: `Stripe ${environment} secret key`
@@ -7805,35 +8102,78 @@ function registerPaymentsConfigCommand(paymentsCmd2) {
       } else {
         outputSuccess(`Stripe ${environment} key configured.`);
       }
-      await trackPaymentUsage("config.set", true, { environment });
+      await trackPaymentUsage("config.set", true, {
+        provider: "stripe",
+        environment
+      });
     } catch (err) {
-      await trackPaymentUsage("config.set", false, { environment: environmentValue });
+      await trackPaymentUsage(
+        "config.set",
+        false,
+        {
+          provider: "stripe",
+          environment: opts.environment
+        },
+        err
+      );
       handleError(err, json);
     }
   });
-  configCmd.command("remove <environment>").alias("delete").description("Remove a configured Stripe secret key").action(async (environmentValue, _opts, cmd) => {
-    const { json, yes } = getRootOpts(cmd);
+}
+function registerRazorpayConfigSetCommand(configCmd) {
+  configCmd.command("set").description("Configure Razorpay keys for test or live payments").requiredOption(
+    "--environment <environment>",
+    "Razorpay environment: test or live"
+  ).option("--key-id <keyId>", "Razorpay key id").option("--key-secret <keySecret>", "Razorpay key secret").action(async (opts, cmd) => {
+    const { json } = getRootOpts(cmd);
     try {
-      const environment = parseEnvironment(environmentValue);
+      const environment = parseEnvironment(opts.environment);
       await requireAuth();
-      if (json && !yes) {
-        throw new CLIError("Use --yes with --json to remove a Stripe key non-interactively.");
+      let keyId = opts.keyId;
+      let keySecret = opts.keySecret;
+      if (!keyId) {
+        if (json) {
+          throw new CLIError("Provide --key-id when using --json.");
+        }
+        const input = await text2({
+          message: `Razorpay ${environment} key id`
+        });
+        if (isCancel2(input)) process.exit(0);
+        keyId = input;
       }
-      if (!yes) {
-        const confirm8 = await confirm2({
-          message: `Remove Stripe ${environment} key? Payment sync and mutations for this environment will stop.`
+      if (!keySecret) {
+        if (json) {
+          throw new CLIError("Provide --key-secret when using --json.");
+        }
+        const input = await password2({
+          message: `Razorpay ${environment} key secret`
         });
-        if (isCancel2(confirm8) || !confirm8) process.exit(0);
+        if (isCancel2(input)) process.exit(0);
+        keySecret = input;
       }
-      const data = await removeStripeSecretKey(environment);
+      const data = await setRazorpayKeys(environment, {
+        keyId,
+        keySecret
+      });
       if (json) {
         outputJson(data);
       } else {
-        outputSuccess(`Stripe ${environment} key removed.`);
+        outputSuccess(`Razorpay ${environment} keys configured.`);
       }
-      await trackPaymentUsage("config.remove", true, { environment });
+      await trackPaymentUsage("config.set", true, {
+        provider: "razorpay",
+        environment
+      });
     } catch (err) {
-      await trackPaymentUsage("config.remove", false, { environment: environmentValue });
+      await trackPaymentUsage(
+        "config.set",
+        false,
+        {
+          provider: "razorpay",
+          environment: opts.environment
+        },
+        err
+      );
       handleError(err, json);
     }
   });
@@ -7852,21 +8192,23 @@ function formatPaymentMethod(customer) {
   }
   return "-";
 }
-function registerPaymentsCustomersCommand(paymentsCmd2) {
-  paymentsCmd2.command("customers").description("List mirrored Stripe customers").requiredOption(
+function registerPaymentsCustomersCommand(paymentsCmd2, provider) {
+  paymentsCmd2.command("customers").description("List mirrored payment provider customers").requiredOption(
     "--environment <environment>",
-    "Stripe environment: test or live"
+    "Payment environment: test or live"
   ).option("--limit <limit>", "Maximum rows to return (1-100)", "50").action(async (opts, cmd) => {
     const { json } = getRootOpts(cmd);
     try {
       const environment = parseEnvironment(opts.environment);
       const limit = parseIntegerOption(opts.limit, "--limit", { min: 1, max: 100 }) ?? 50;
       await requireAuth();
-      const data = await listPaymentCustomers(environment, { limit });
+      const data = await listPaymentCustomers(provider, environment, {
+        limit
+      });
       if (json) {
         outputJson(data);
       } else if (data.customers.length === 0) {
-        console.log("No Stripe customers found.");
+        console.log(`No ${provider} customers found.`);
       } else {
         outputTable(
           [
@@ -7880,7 +8222,7 @@ function registerPaymentsCustomersCommand(paymentsCmd2) {
             "Country"
           ],
           data.customers.map((customer) => [
-            customer.stripeCustomerId,
+            customer.providerCustomerId,
             customer.email ?? "-",
             customer.name ?? "-",
             String(customer.paymentsCount),
@@ -7891,72 +8233,312 @@ function registerPaymentsCustomersCommand(paymentsCmd2) {
           ])
         );
       }
-      await trackPaymentUsage("customers", true, { environment });
+      await trackPaymentUsage("customers", true, { provider, environment });
     } catch (err) {
-      await trackPaymentUsage("customers", false, {
-        environment: opts.environment
-      });
+      await trackPaymentUsage(
+        "customers",
+        false,
+        {
+          provider,
+          environment: opts.environment
+        },
+        err
+      );
       handleError(err, json);
     }
   });
 }
 
-// src/commands/payments/history.ts
-function registerPaymentsHistoryCommand(paymentsCmd2) {
-  paymentsCmd2.command("history").description("List mirrored Stripe payment history").requiredOption(
+// src/commands/payments/items.ts
+function nullableString(value) {
+  if (value === void 0) return void 0;
+  return value === "null" ? null : value;
+}
+function outputItemsTable(items) {
+  if (items.length === 0) {
+    console.log("No Razorpay items found.");
+    return;
+  }
+  outputTable(
+    ["Env", "Item ID", "Name", "Amount", "Active", "Type", "Synced At"],
+    items.map((item) => [
+      item.environment,
+      item.itemId,
+      item.name,
+      formatAmount(item.amount, item.currency),
+      item.active ? "Yes" : "No",
+      item.type ?? "-",
+      formatDate(item.syncedAt)
+    ])
+  );
+}
+function registerPaymentsItemsCommand(paymentsCmd2) {
+  const itemsCmd = paymentsCmd2.command("items").description("Manage Razorpay items");
+  itemsCmd.command("list").description("List mirrored Razorpay items").requiredOption(
     "--environment <environment>",
-    "Stripe environment: test or live"
-  ).option("--subject-type <type>", "Filter by billing subject type").option("--subject-id <id>", "Filter by billing subject id").option("--limit <limit>", "Maximum rows to return (1-100)", "50").action(async (opts, cmd) => {
+    "Razorpay environment: test or live"
+  ).action(async (opts, cmd) => {
     const { json } = getRootOpts(cmd);
     try {
       const environment = parseEnvironment(opts.environment);
-      const limit = parseIntegerOption(opts.limit, "--limit", { min: 1, max: 100 }) ?? 50;
       await requireAuth();
-      const data = await listPaymentHistory(environment, {
-        limit,
-        ...opts.subjectType !== void 0 ? { subjectType: opts.subjectType } : {},
-        ...opts.subjectId !== void 0 ? { subjectId: opts.subjectId } : {}
+      const data = await listRazorpayCatalog(environment);
+      if (json) {
+        outputJson({ items: data.items });
+      } else {
+        outputItemsTable(data.items);
+      }
+      await trackPaymentUsage("items.list", true, {
+        provider: "razorpay",
+        environment
       });
+    } catch (err) {
+      await trackPaymentUsage(
+        "items.list",
+        false,
+        {
+          provider: "razorpay",
+          environment: opts.environment
+        },
+        err
+      );
+      handleError(err, json);
+    }
+  });
+  itemsCmd.command("create").description("Create a Razorpay item").requiredOption(
+    "--environment <environment>",
+    "Razorpay environment: test or live"
+  ).requiredOption("--name <name>", "Item name").requiredOption("--amount <amount>", "Amount in the smallest currency unit").requiredOption(
+    "--currency <currency>",
+    "Three-letter currency code, e.g. inr"
+  ).option("--description <description>", 'Item description, or "null"').option("--metadata <json>", "Metadata JSON object with string values").action(async (opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      const environment = parseEnvironment(opts.environment);
+      await requireAuth();
+      const request = {
+        name: opts.name,
+        amount: parseIntegerOption(opts.amount, "--amount", { min: 0 }) ?? 0,
+        currency: opts.currency
+      };
+      const description = nullableString(opts.description);
+      const metadata = parseMetadataOption(opts.metadata);
+      if (description !== void 0) request.description = description;
+      if (metadata !== void 0) request.metadata = metadata;
+      const data = await createRazorpayItem(environment, request);
       if (json) {
         outputJson(data);
-      } else if (data.paymentHistory.length === 0) {
-        console.log("No Stripe payment history found.");
       } else {
-        outputTable(
-          [
-            "Type",
-            "Status",
-            "Subject",
-            "Amount",
-            "Customer",
-            "Stripe Object",
-            "When"
-          ],
-          data.paymentHistory.map((entry) => [
-            entry.type,
-            entry.status,
-            entry.subjectType && entry.subjectId ? `${entry.subjectType}:${entry.subjectId}` : "-",
-            formatAmount(entry.amount, entry.currency),
-            entry.stripeCustomerId ?? "-",
-            entry.stripeCheckoutSessionId ?? entry.stripeInvoiceId ?? entry.stripePaymentIntentId ?? entry.stripeRefundId ?? "-",
-            formatDate(
-              entry.paidAt ?? entry.failedAt ?? entry.refundedAt ?? entry.stripeCreatedAt
-            )
-          ])
+        outputSuccess(`Razorpay item created: ${data.item.itemId}`);
+      }
+      await trackPaymentUsage("items.create", true, {
+        provider: "razorpay",
+        environment
+      });
+    } catch (err) {
+      await trackPaymentUsage(
+        "items.create",
+        false,
+        {
+          provider: "razorpay",
+          environment: opts.environment
+        },
+        err
+      );
+      handleError(err, json);
+    }
+  });
+  itemsCmd.command("update <itemId>").description("Update a Razorpay item").requiredOption(
+    "--environment <environment>",
+    "Razorpay environment: test or live"
+  ).option("--name <name>", "Item name").option("--description <description>", 'Item description, or "null"').option("--amount <amount>", "Amount in the smallest currency unit").option("--currency <currency>", "Three-letter currency code").option("--active <bool>", "Set active status (true/false)").option("--metadata <json>", "Metadata JSON object with string values").action(async (itemId, opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      const environment = parseEnvironment(opts.environment);
+      await requireAuth();
+      const request = {};
+      const description = nullableString(opts.description);
+      const amount = parseIntegerOption(opts.amount, "--amount", { min: 0 });
+      const active = parseBooleanOption(opts.active, "--active");
+      const metadata = parseMetadataOption(opts.metadata);
+      if (opts.name !== void 0) request.name = opts.name;
+      if (description !== void 0) request.description = description;
+      if (amount !== void 0) request.amount = amount;
+      if (opts.currency !== void 0) request.currency = opts.currency;
+      if (active !== void 0) request.active = active;
+      if (metadata !== void 0) request.metadata = metadata;
+      if (Object.keys(request).length === 0) {
+        throw new CLIError(
+          "Provide at least one option to update (--name, --description, --amount, --currency, --active, --metadata)."
         );
       }
-      await trackPaymentUsage("history", true, { environment });
+      const data = await updateRazorpayItem(environment, itemId, request);
+      if (json) {
+        outputJson(data);
+      } else {
+        outputSuccess(`Razorpay item updated: ${data.item.itemId}`);
+      }
+      await trackPaymentUsage("items.update", true, {
+        provider: "razorpay",
+        environment
+      });
     } catch (err) {
-      await trackPaymentUsage("history", false, {
-        environment: opts.environment
+      await trackPaymentUsage(
+        "items.update",
+        false,
+        {
+          provider: "razorpay",
+          environment: opts.environment
+        },
+        err
+      );
+      handleError(err, json);
+    }
+  });
+}
+
+// src/commands/payments/plans.ts
+function nullableString2(value) {
+  if (value === void 0) return void 0;
+  return value === "null" ? null : value;
+}
+function outputPlansTable(plans) {
+  if (plans.length === 0) {
+    console.log("No Razorpay plans found.");
+    return;
+  }
+  outputTable(
+    [
+      "Env",
+      "Plan ID",
+      "Item ID",
+      "Amount",
+      "Period",
+      "Interval",
+      "Active",
+      "Synced At"
+    ],
+    plans.map((plan) => [
+      plan.environment,
+      plan.planId,
+      plan.itemId,
+      formatAmount(plan.amount, plan.currency),
+      plan.period,
+      String(plan.interval),
+      plan.active ? "Yes" : "No",
+      formatDate(plan.syncedAt)
+    ])
+  );
+}
+function registerPaymentsPlansCommand(paymentsCmd2) {
+  const plansCmd = paymentsCmd2.command("plans").description("Manage Razorpay plans");
+  plansCmd.command("list").description("List mirrored Razorpay plans").requiredOption(
+    "--environment <environment>",
+    "Razorpay environment: test or live"
+  ).action(async (opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      const environment = parseEnvironment(opts.environment);
+      await requireAuth();
+      const data = await listRazorpayCatalog(environment);
+      if (json) {
+        outputJson({ plans: data.plans });
+      } else {
+        outputPlansTable(data.plans);
+      }
+      await trackPaymentUsage("plans.list", true, {
+        provider: "razorpay",
+        environment
       });
+    } catch (err) {
+      await trackPaymentUsage(
+        "plans.list",
+        false,
+        {
+          provider: "razorpay",
+          environment: opts.environment
+        },
+        err
+      );
+      handleError(err, json);
+    }
+  });
+  plansCmd.command("create").description("Create a Razorpay subscription plan").requiredOption(
+    "--environment <environment>",
+    "Razorpay environment: test or live"
+  ).requiredOption(
+    "--period <period>",
+    "Plan period: daily, weekly, monthly, or yearly"
+  ).requiredOption("--interval <count>", "Billing interval count").requiredOption("--item-name <name>", "Plan item name").requiredOption(
+    "--item-amount <amount>",
+    "Plan item amount in the smallest currency unit"
+  ).requiredOption(
+    "--item-currency <currency>",
+    "Three-letter currency code, e.g. inr"
+  ).option(
+    "--item-description <description>",
+    'Plan item description, or "null"'
+  ).option("--metadata <json>", "Metadata JSON object with string values").action(async (opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      const environment = parseEnvironment(opts.environment);
+      const period = parseRazorpayPlanPeriod(opts.period);
+      const interval = parseIntegerOption(opts.interval, "--interval", {
+        min: 1
+      });
+      const itemAmount = parseIntegerOption(
+        opts.itemAmount,
+        "--item-amount",
+        { min: 0 }
+      );
+      if (!period || interval === void 0 || itemAmount === void 0) {
+        throw new CLIError(
+          "Provide --period, --interval, and --item-amount."
+        );
+      }
+      await requireAuth();
+      const request = {
+        period,
+        interval,
+        item: {
+          name: opts.itemName,
+          amount: itemAmount,
+          currency: opts.itemCurrency
+        }
+      };
+      const itemDescription = nullableString2(opts.itemDescription);
+      const metadata = parseMetadataOption(opts.metadata);
+      if (itemDescription !== void 0) {
+        request.item.description = itemDescription;
+      }
+      if (metadata !== void 0) request.metadata = metadata;
+      const data = await createRazorpayPlan(environment, request);
+      if (json) {
+        outputJson(data);
+      } else {
+        outputSuccess(`Razorpay plan created: ${data.plan.planId}`);
+      }
+      await trackPaymentUsage("plans.create", true, {
+        provider: "razorpay",
+        environment
+      });
+    } catch (err) {
+      await trackPaymentUsage(
+        "plans.create",
+        false,
+        {
+          provider: "razorpay",
+          environment: opts.environment
+        },
+        err
+      );
       handleError(err, json);
     }
   });
 }
 
 // src/commands/payments/prices.ts
-function nullableString(value) {
+function nullableString3(value) {
   if (value === void 0) return void 0;
   return value === "null" ? null : value;
 }
@@ -7998,8 +8580,8 @@ function outputPricesTable(prices) {
     ],
     prices.map((price) => [
       price.environment,
-      price.stripePriceId,
-      price.stripeProductId ?? "-",
+      price.priceId,
+      price.productId ?? "-",
       formatAmount(price.unitAmount, price.currency),
       price.type,
       price.active ? "Yes" : "No",
@@ -8018,17 +8600,26 @@ function registerPaymentsPricesCommand(paymentsCmd2) {
     try {
       const environment = parseEnvironment(opts.environment);
       await requireAuth();
-      const data = await listPaymentPrices(environment, opts.product);
+      const data = await listStripePrices(environment, opts.product);
       if (json) {
         outputJson(data);
       } else {
         outputPricesTable(data.prices);
       }
-      await trackPaymentUsage("prices.list", true, { environment });
-    } catch (err) {
-      await trackPaymentUsage("prices.list", false, {
-        environment: opts.environment
+      await trackPaymentUsage("prices.list", true, {
+        provider: "stripe",
+        environment
       });
+    } catch (err) {
+      await trackPaymentUsage(
+        "prices.list",
+        false,
+        {
+          provider: "stripe",
+          environment: opts.environment
+        },
+        err
+      );
       handleError(err, json);
     }
   });
@@ -8040,17 +8631,26 @@ function registerPaymentsPricesCommand(paymentsCmd2) {
     try {
       const environment = parseEnvironment(opts.environment);
       await requireAuth();
-      const data = await getPaymentPrice(environment, priceId);
+      const data = await getStripePrice(environment, priceId);
       if (json) {
         outputJson(data);
       } else {
         outputPricesTable([data.price]);
       }
-      await trackPaymentUsage("prices.get", true, { environment });
-    } catch (err) {
-      await trackPaymentUsage("prices.get", false, {
-        environment: opts.environment
+      await trackPaymentUsage("prices.get", true, {
+        provider: "stripe",
+        environment
       });
+    } catch (err) {
+      await trackPaymentUsage(
+        "prices.get",
+        false,
+        {
+          provider: "stripe",
+          environment: opts.environment
+        },
+        err
+      );
       handleError(err, json);
     }
   });
@@ -8081,11 +8681,11 @@ function registerPaymentsPricesCommand(paymentsCmd2) {
         throw new CLIError("Provide --interval when using --interval-count.");
       }
       const request = {
-        stripeProductId: opts.product,
+        productId: opts.product,
         currency: opts.currency,
         unitAmount: parseIntegerOption(opts.unitAmount, "--unit-amount", { min: 0 }) ?? 0
       };
-      const lookupKey = nullableString(opts.lookupKey);
+      const lookupKey = nullableString3(opts.lookupKey);
       const active = parseBooleanOption(opts.active, "--active");
       const taxBehavior = parseTaxBehavior(opts.taxBehavior);
       const metadata = parseMetadataOption(opts.metadata);
@@ -8102,17 +8702,26 @@ function registerPaymentsPricesCommand(paymentsCmd2) {
           ...intervalCount !== void 0 ? { intervalCount } : {}
         };
       }
-      const data = await createPaymentPrice(environment, request);
+      const data = await createStripePrice(environment, request);
       if (json) {
         outputJson(data);
       } else {
-        outputSuccess(`Stripe price created: ${data.price.stripePriceId}`);
+        outputSuccess(`Stripe price created: ${data.price.priceId}`);
       }
-      await trackPaymentUsage("prices.create", true, { environment });
-    } catch (err) {
-      await trackPaymentUsage("prices.create", false, {
-        environment: opts.environment
+      await trackPaymentUsage("prices.create", true, {
+        provider: "stripe",
+        environment
       });
+    } catch (err) {
+      await trackPaymentUsage(
+        "prices.create",
+        false,
+        {
+          provider: "stripe",
+          environment: opts.environment
+        },
+        err
+      );
       handleError(err, json);
     }
   });
@@ -8126,7 +8735,7 @@ function registerPaymentsPricesCommand(paymentsCmd2) {
       await requireAuth();
       const request = {};
       const active = parseBooleanOption(opts.active, "--active");
-      const lookupKey = nullableString(opts.lookupKey);
+      const lookupKey = nullableString3(opts.lookupKey);
       const taxBehavior = parseTaxBehavior(opts.taxBehavior);
       const metadata = parseMetadataOption(opts.metadata);
       if (active !== void 0) request.active = active;
@@ -8138,21 +8747,30 @@ function registerPaymentsPricesCommand(paymentsCmd2) {
           "Provide at least one option to update (--active, --lookup-key, --tax-behavior, --metadata)."
         );
       }
-      const data = await updatePaymentPrice(environment, priceId, request);
+      const data = await updateStripePrice(environment, priceId, request);
       if (json) {
         outputJson(data);
       } else {
-        outputSuccess(`Stripe price updated: ${data.price.stripePriceId}`);
+        outputSuccess(`Stripe price updated: ${data.price.priceId}`);
       }
-      await trackPaymentUsage("prices.update", true, { environment });
-    } catch (err) {
-      await trackPaymentUsage("prices.update", false, {
-        environment: opts.environment
+      await trackPaymentUsage("prices.update", true, {
+        provider: "stripe",
+        environment
       });
+    } catch (err) {
+      await trackPaymentUsage(
+        "prices.update",
+        false,
+        {
+          provider: "stripe",
+          environment: opts.environment
+        },
+        err
+      );
       handleError(err, json);
     }
   });
-  pricesCmd.command("archive <priceId>").alias("delete").description("Archive a Stripe price").requiredOption(
+  pricesCmd.command("archive <priceId>").description("Archive a Stripe price").requiredOption(
     "--environment <environment>",
     "Stripe environment: test or live"
   ).action(async (priceId, opts, cmd) => {
@@ -8160,24 +8778,33 @@ function registerPaymentsPricesCommand(paymentsCmd2) {
     try {
       const environment = parseEnvironment(opts.environment);
       await requireAuth();
-      const data = await archivePaymentPrice(environment, priceId);
+      const data = await archiveStripePrice(environment, priceId);
       if (json) {
         outputJson(data);
       } else {
-        outputSuccess(`Stripe price archived: ${data.price.stripePriceId}`);
+        outputSuccess(`Stripe price archived: ${data.price.priceId}`);
       }
-      await trackPaymentUsage("prices.archive", true, { environment });
-    } catch (err) {
-      await trackPaymentUsage("prices.archive", false, {
-        environment: opts.environment
+      await trackPaymentUsage("prices.archive", true, {
+        provider: "stripe",
+        environment
       });
+    } catch (err) {
+      await trackPaymentUsage(
+        "prices.archive",
+        false,
+        {
+          provider: "stripe",
+          environment: opts.environment
+        },
+        err
+      );
       handleError(err, json);
     }
   });
 }
 
 // src/commands/payments/products.ts
-function nullableString2(value) {
+function nullableString4(value) {
   if (value === void 0) return void 0;
   return value === "null" ? null : value;
 }
@@ -8190,7 +8817,7 @@ function outputProductsTable(products) {
     ["Env", "Product ID", "Name", "Active", "Default Price", "Synced At"],
     products.map((product) => [
       product.environment,
-      product.stripeProductId,
+      product.productId,
       product.name,
       product.active ? "Yes" : "No",
       product.defaultPriceId ?? "-",
@@ -8208,17 +8835,26 @@ function registerPaymentsProductsCommand(paymentsCmd2) {
     try {
       const environment = parseEnvironment(opts.environment);
       await requireAuth();
-      const data = await listPaymentProducts(environment);
+      const data = await listStripeProducts(environment);
       if (json) {
         outputJson(data);
       } else {
         outputProductsTable(data.products);
       }
-      await trackPaymentUsage("products.list", true, { environment });
-    } catch (err) {
-      await trackPaymentUsage("products.list", false, {
-        environment: opts.environment
+      await trackPaymentUsage("products.list", true, {
+        provider: "stripe",
+        environment
       });
+    } catch (err) {
+      await trackPaymentUsage(
+        "products.list",
+        false,
+        {
+          provider: "stripe",
+          environment: opts.environment
+        },
+        err
+      );
       handleError(err, json);
     }
   });
@@ -8230,7 +8866,7 @@ function registerPaymentsProductsCommand(paymentsCmd2) {
     try {
       const environment = parseEnvironment(opts.environment);
       await requireAuth();
-      const data = await getPaymentProduct(environment, productId);
+      const data = await getStripeProduct(environment, productId);
       if (json) {
         outputJson(data);
       } else {
@@ -8240,7 +8876,7 @@ function registerPaymentsProductsCommand(paymentsCmd2) {
           outputTable(
             ["Price ID", "Amount", "Type", "Active", "Lookup Key"],
             data.prices.map((price) => [
-              price.stripePriceId,
+              price.priceId,
               formatAmount(price.unitAmount, price.currency),
               price.type,
               price.active ? "Yes" : "No",
@@ -8249,11 +8885,20 @@ function registerPaymentsProductsCommand(paymentsCmd2) {
           );
         }
       }
-      await trackPaymentUsage("products.get", true, { environment });
-    } catch (err) {
-      await trackPaymentUsage("products.get", false, {
-        environment: opts.environment
+      await trackPaymentUsage("products.get", true, {
+        provider: "stripe",
+        environment
       });
+    } catch (err) {
+      await trackPaymentUsage(
+        "products.get",
+        false,
+        {
+          provider: "stripe",
+          environment: opts.environment
+        },
+        err
+      );
       handleError(err, json);
     }
   });
@@ -8266,7 +8911,7 @@ function registerPaymentsProductsCommand(paymentsCmd2) {
       const environment = parseEnvironment(opts.environment);
       await requireAuth();
       const request = { name: opts.name };
-      const description = nullableString2(opts.description);
+      const description = nullableString4(opts.description);
       const active = parseBooleanOption(opts.active, "--active");
       const metadata = parseMetadataOption(opts.metadata);
       if (description !== void 0) request.description = description;
@@ -8275,19 +8920,26 @@ function registerPaymentsProductsCommand(paymentsCmd2) {
       if (opts.idempotencyKey !== void 0) {
         request.idempotencyKey = opts.idempotencyKey;
       }
-      const data = await createPaymentProduct(environment, request);
+      const data = await createStripeProduct(environment, request);
       if (json) {
         outputJson(data);
       } else {
-        outputSuccess(
-          `Stripe product created: ${data.product.stripeProductId}`
-        );
+        outputSuccess(`Stripe product created: ${data.product.productId}`);
       }
-      await trackPaymentUsage("products.create", true, { environment });
-    } catch (err) {
-      await trackPaymentUsage("products.create", false, {
-        environment: opts.environment
+      await trackPaymentUsage("products.create", true, {
+        provider: "stripe",
+        environment
       });
+    } catch (err) {
+      await trackPaymentUsage(
+        "products.create",
+        false,
+        {
+          provider: "stripe",
+          environment: opts.environment
+        },
+        err
+      );
       handleError(err, json);
     }
   });
@@ -8300,7 +8952,7 @@ function registerPaymentsProductsCommand(paymentsCmd2) {
       const environment = parseEnvironment(opts.environment);
       await requireAuth();
       const request = {};
-      const description = nullableString2(opts.description);
+      const description = nullableString4(opts.description);
       const active = parseBooleanOption(opts.active, "--active");
       const metadata = parseMetadataOption(opts.metadata);
       if (opts.name !== void 0) request.name = opts.name;
@@ -8312,23 +8964,26 @@ function registerPaymentsProductsCommand(paymentsCmd2) {
           "Provide at least one option to update (--name, --description, --active, --metadata)."
         );
       }
-      const data = await updatePaymentProduct(
-        environment,
-        productId,
-        request
-      );
+      const data = await updateStripeProduct(environment, productId, request);
       if (json) {
         outputJson(data);
       } else {
-        outputSuccess(
-          `Stripe product updated: ${data.product.stripeProductId}`
-        );
+        outputSuccess(`Stripe product updated: ${data.product.productId}`);
       }
-      await trackPaymentUsage("products.update", true, { environment });
-    } catch (err) {
-      await trackPaymentUsage("products.update", false, {
-        environment: opts.environment
+      await trackPaymentUsage("products.update", true, {
+        provider: "stripe",
+        environment
       });
+    } catch (err) {
+      await trackPaymentUsage(
+        "products.update",
+        false,
+        {
+          provider: "stripe",
+          environment: opts.environment
+        },
+        err
+      );
       handleError(err, json);
     }
   });
@@ -8351,153 +9006,357 @@ function registerPaymentsProductsCommand(paymentsCmd2) {
         });
         if (isCancel2(confirm8) || !confirm8) process.exit(0);
       }
-      const data = await deletePaymentProduct(environment, productId);
+      const data = await deleteStripeProduct(environment, productId);
       if (json) {
         outputJson(data);
       } else {
-        outputSuccess(`Stripe product deleted: ${data.stripeProductId}`);
+        outputSuccess(`Stripe product deleted: ${data.productId}`);
       }
-      await trackPaymentUsage("products.delete", true, { environment });
-    } catch (err) {
-      await trackPaymentUsage("products.delete", false, {
-        environment: opts.environment
+      await trackPaymentUsage("products.delete", true, {
+        provider: "stripe",
+        environment
       });
+    } catch (err) {
+      await trackPaymentUsage(
+        "products.delete",
+        false,
+        {
+          provider: "stripe",
+          environment: opts.environment
+        },
+        err
+      );
       handleError(err, json);
     }
   });
 }
 
 // src/commands/payments/status.ts
-function registerPaymentsStatusCommand(paymentsCmd2) {
-  paymentsCmd2.command("status").description("Show Stripe payment connection, sync, and webhook status").action(async (_opts, cmd) => {
+function registerPaymentsStatusCommand(paymentsCmd2, provider) {
+  paymentsCmd2.command("status").description("Show payment connection, sync, and webhook status").action(async (opts, cmd) => {
     const { json } = getRootOpts(cmd);
     try {
       await requireAuth();
-      const data = await getPaymentsStatus();
-      if (json) {
-        outputJson(data);
-      } else if (data.connections.length === 0) {
-        console.log("No Stripe payment environments found.");
+      if (provider === "stripe") {
+        const data = await getStripePaymentsStatus();
+        if (json) {
+          outputJson(data);
+        } else if (data.connections.length === 0) {
+          console.log("No Stripe payment environments found.");
+        } else {
+          outputTable(
+            [
+              "Env",
+              "Status",
+              "Key",
+              "Account",
+              "Webhook",
+              "Last Sync",
+              "Synced At"
+            ],
+            data.connections.map((connection) => [
+              connection.environment,
+              connection.status,
+              connection.maskedKey ?? "-",
+              connection.accountId ?? "-",
+              connection.webhookEndpointId ? "Configured" : "-",
+              connection.lastSyncStatus ?? "-",
+              formatDate(connection.lastSyncedAt)
+            ])
+          );
+        }
       } else {
-        outputTable(
-          ["Env", "Status", "Key", "Account", "Webhook", "Last Sync", "Synced At"],
-          data.connections.map((connection) => [
-            connection.environment,
-            connection.status,
-            connection.maskedKey ?? "-",
-            connection.stripeAccountId ?? "-",
-            connection.webhookEndpointId ? "Configured" : "-",
-            connection.lastSyncStatus ?? "-",
-            formatDate(connection.lastSyncedAt)
-          ])
-        );
+        const data = await getRazorpayPaymentsStatus();
+        if (json) {
+          outputJson(data);
+        } else if (data.razorpayConnections.length === 0) {
+          console.log("No Razorpay payment environments found.");
+        } else {
+          outputTable(
+            [
+              "Env",
+              "Status",
+              "Key",
+              "Account",
+              "Merchant",
+              "Webhook",
+              "Last Sync",
+              "Synced At"
+            ],
+            data.razorpayConnections.map((connection) => [
+              connection.environment,
+              connection.status,
+              connection.maskedKey ?? "-",
+              connection.accountId ?? "-",
+              connection.merchantName ?? "-",
+              connection.webhookEndpointUrl ? "Manual" : "-",
+              connection.lastSyncStatus ?? "-",
+              formatDate(connection.lastSyncedAt)
+            ])
+          );
+        }
       }
-      await trackPaymentUsage("status", true);
+      await trackPaymentUsage("status", true, { provider });
     } catch (err) {
-      await trackPaymentUsage("status", false);
+      await trackPaymentUsage("status", false, { provider }, err);
       handleError(err, json);
     }
   });
 }
 
 // src/commands/payments/subscriptions.ts
-function registerPaymentsSubscriptionsCommand(paymentsCmd2) {
-  paymentsCmd2.command("subscriptions").description("List mirrored Stripe subscriptions").requiredOption(
+function formatSubject(subjectType, subjectId) {
+  return subjectType && subjectId ? `${subjectType}:${subjectId}` : "-";
+}
+function registerPaymentsSubscriptionsCommand(paymentsCmd2, provider) {
+  paymentsCmd2.command("subscriptions").description("List mirrored payment provider subscriptions").requiredOption(
     "--environment <environment>",
-    "Stripe environment: test or live"
-  ).option("--subject-type <type>", "Filter by billing subject type").option("--subject-id <id>", "Filter by billing subject id").option("--limit <limit>", "Maximum rows to return (1-100)", "50").action(async (opts, cmd) => {
+    "Payment environment: test or live"
+  ).option("--subject-type <type>", "Filter by app billing subject type").option(
+    "--subject-id <id>",
+    "Filter by app billing subject id, not provider id"
+  ).option("--limit <limit>", "Maximum rows to return (1-100)", "50").action(async (opts, cmd) => {
     const { json } = getRootOpts(cmd);
     try {
       const environment = parseEnvironment(opts.environment);
       const limit = parseIntegerOption(opts.limit, "--limit", { min: 1, max: 100 }) ?? 50;
-      await requireAuth();
-      const data = await listSubscriptions(environment, {
+      const request = {
         limit,
         ...opts.subjectType !== void 0 ? { subjectType: opts.subjectType } : {},
         ...opts.subjectId !== void 0 ? { subjectId: opts.subjectId } : {}
-      });
-      if (json) {
-        outputJson(data);
-      } else if (data.subscriptions.length === 0) {
-        console.log("No Stripe subscriptions found.");
+      };
+      await requireAuth();
+      if (provider === "stripe") {
+        const data = await listStripeSubscriptions(environment, request);
+        if (json) {
+          outputJson(data);
+        } else if (data.subscriptions.length === 0) {
+          console.log("No Stripe subscriptions found.");
+        } else {
+          outputTable(
+            [
+              "Subscription ID",
+              "Customer",
+              "Subject",
+              "Status",
+              "Items",
+              "Period End"
+            ],
+            data.subscriptions.map((subscription) => [
+              subscription.subscriptionId,
+              subscription.customerId ?? "-",
+              formatSubject(subscription.subjectType, subscription.subjectId),
+              subscription.status,
+              String(subscription.items?.length ?? 0),
+              formatDate(subscription.currentPeriodEnd)
+            ])
+          );
+        }
       } else {
-        outputTable(
-          [
-            "Subscription ID",
-            "Customer",
-            "Subject",
-            "Status",
-            "Items",
-            "Period End"
-          ],
-          data.subscriptions.map((subscription) => [
-            subscription.stripeSubscriptionId,
-            subscription.stripeCustomerId,
-            subscription.subjectType && subscription.subjectId ? `${subscription.subjectType}:${subscription.subjectId}` : "-",
-            subscription.status,
-            String(subscription.items?.length ?? 0),
-            formatDate(subscription.currentPeriodEnd)
-          ])
-        );
+        const data = await listRazorpaySubscriptions(environment, request);
+        if (json) {
+          outputJson(data);
+        } else if (data.subscriptions.length === 0) {
+          console.log("No Razorpay subscriptions found.");
+        } else {
+          outputTable(
+            [
+              "Subscription ID",
+              "Plan ID",
+              "Customer",
+              "Subject",
+              "Status",
+              "Paid",
+              "Remaining",
+              "Current End"
+            ],
+            data.subscriptions.map((subscription) => [
+              subscription.subscriptionId,
+              subscription.planId,
+              subscription.customerId ?? "-",
+              formatSubject(subscription.subjectType, subscription.subjectId),
+              subscription.status,
+              String(subscription.paidCount ?? "-"),
+              String(subscription.remainingCount ?? "-"),
+              formatDate(subscription.currentEnd)
+            ])
+          );
+        }
       }
-      await trackPaymentUsage("subscriptions", true, { environment });
-    } catch (err) {
-      await trackPaymentUsage("subscriptions", false, {
-        environment: opts.environment
+      await trackPaymentUsage("subscriptions", true, {
+        provider,
+        environment
       });
+    } catch (err) {
+      await trackPaymentUsage(
+        "subscriptions",
+        false,
+        {
+          provider,
+          environment: opts.environment
+        },
+        err
+      );
       handleError(err, json);
     }
   });
 }
 
 // src/commands/payments/sync.ts
-function registerPaymentsSyncCommand(paymentsCmd2) {
-  paymentsCmd2.command("sync").description(
-    "Sync configured Stripe products, prices, customers, and subscriptions"
-  ).option(
+function registerPaymentsSyncCommand(paymentsCmd2, provider) {
+  paymentsCmd2.command("sync").description("Sync configured payment provider data").option(
     "--environment <environment>",
-    "Stripe environment: test, live, or all",
+    "Payment environment: test, live, or all",
     "all"
   ).action(async (opts, cmd) => {
     const { json } = getRootOpts(cmd);
     try {
       const environment = parseEnvironmentOrAll(opts.environment);
       await requireAuth();
-      const data = await syncPayments(environment);
+      if (provider === "stripe") {
+        const data = await syncStripePayments(environment);
+        if (json) {
+          outputJson(data);
+        } else if (data.results.length === 0) {
+          console.log("No configured Stripe environments to sync.");
+        } else {
+          outputTable(
+            [
+              "Env",
+              "Status",
+              "Products",
+              "Prices",
+              "Customers",
+              "Subscriptions",
+              "Unmapped",
+              "Synced At"
+            ],
+            data.results.map((result) => [
+              result.environment,
+              result.connection.lastSyncStatus ?? result.connection.status,
+              String(result.connection.lastSyncCounts.products ?? 0),
+              String(result.connection.lastSyncCounts.prices ?? 0),
+              String(result.connection.lastSyncCounts.customers ?? 0),
+              String(result.subscriptions?.synced ?? 0),
+              String(result.subscriptions?.unmapped ?? 0),
+              formatDate(result.connection.lastSyncedAt)
+            ])
+          );
+          outputSuccess("Stripe payments synced.");
+        }
+      } else {
+        const data = await syncRazorpayPayments(environment);
+        if (json) {
+          outputJson(data);
+        } else if (data.results.length === 0) {
+          console.log("No configured Razorpay environments to sync.");
+        } else {
+          outputTable(
+            [
+              "Env",
+              "Status",
+              "Items",
+              "Plans",
+              "Customers",
+              "Subscriptions",
+              "Invoices",
+              "Payments",
+              "Synced At"
+            ],
+            data.results.map((result) => [
+              result.environment,
+              result.status,
+              String(result.syncCounts.items),
+              String(result.syncCounts.plans),
+              String(result.syncCounts.customers),
+              String(result.syncCounts.subscriptions),
+              String(result.syncCounts.invoices),
+              String(result.syncCounts.payments),
+              formatDate(result.connection.lastSyncedAt)
+            ])
+          );
+          outputSuccess("Razorpay payments synced.");
+        }
+      }
+      await trackPaymentUsage("sync", true, { provider, environment });
+    } catch (err) {
+      await trackPaymentUsage(
+        "sync",
+        false,
+        {
+          provider,
+          environment: opts.environment
+        },
+        err
+      );
+      handleError(err, json);
+    }
+  });
+}
+
+// src/commands/payments/transactions.ts
+function registerPaymentsTransactionsCommand(paymentsCmd2, provider) {
+  paymentsCmd2.command("transactions").description("List mirrored payment transactions").requiredOption(
+    "--environment <environment>",
+    "Payment environment: test or live"
+  ).option("--subject-type <type>", "Filter by app billing subject type").option(
+    "--subject-id <id>",
+    "Filter by app billing subject id, not provider id"
+  ).option("--limit <limit>", "Maximum rows to return (1-100)", "50").action(async (opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      const environment = parseEnvironment(opts.environment);
+      const limit = parseIntegerOption(opts.limit, "--limit", { min: 1, max: 100 }) ?? 50;
+      await requireAuth();
+      const data = await listPaymentTransactions(provider, environment, {
+        limit,
+        ...opts.subjectType !== void 0 ? { subjectType: opts.subjectType } : {},
+        ...opts.subjectId !== void 0 ? { subjectId: opts.subjectId } : {}
+      });
       if (json) {
         outputJson(data);
-      } else if (data.results.length === 0) {
-        console.log("No configured Stripe environments to sync.");
+      } else if (data.transactions.length === 0) {
+        console.log(`No ${provider} transactions found.`);
       } else {
         outputTable(
           [
-            "Env",
+            "Type",
             "Status",
-            "Products",
-            "Prices",
-            "Customers",
-            "Subscriptions",
-            "Unmapped",
-            "Synced At"
+            "Subject",
+            "Amount",
+            "Refunded",
+            "Customer",
+            "Provider Object",
+            "When"
           ],
-          data.results.map((result) => [
-            result.environment,
-            result.connection.lastSyncStatus ?? result.connection.status,
-            String(result.connection.lastSyncCounts.products ?? 0),
-            String(result.connection.lastSyncCounts.prices ?? 0),
-            String(result.connection.lastSyncCounts.customers ?? 0),
-            String(result.subscriptions?.synced ?? 0),
-            String(result.subscriptions?.unmapped ?? 0),
-            formatDate(result.connection.lastSyncedAt)
+          data.transactions.map((entry) => [
+            entry.type,
+            entry.status,
+            entry.subjectType && entry.subjectId ? `${entry.subjectType}:${entry.subjectId}` : "-",
+            formatAmount(entry.amount, entry.currency),
+            formatAmount(entry.amountRefunded, entry.currency),
+            entry.providerCustomerId ?? entry.customerEmailSnapshot ?? "-",
+            entry.providerReferenceType && entry.providerReferenceId ? `${entry.providerReferenceType}:${entry.providerReferenceId}` : entry.providerReferenceId ?? "-",
+            formatDate(
+              entry.paidAt ?? entry.failedAt ?? entry.refundedAt ?? entry.providerCreatedAt ?? entry.createdAt
+            )
           ])
         );
-        outputSuccess("Stripe payments synced.");
       }
-      await trackPaymentUsage("sync", true, { environment });
-    } catch (err) {
-      await trackPaymentUsage("sync", false, {
-        environment: opts.environment
+      await trackPaymentUsage("transactions", true, {
+        provider,
+        environment
       });
+    } catch (err) {
+      await trackPaymentUsage(
+        "transactions",
+        false,
+        {
+          provider,
+          environment: opts.environment
+        },
+        err
+      );
       handleError(err, json);
     }
   });
@@ -8505,30 +9364,46 @@ function registerPaymentsSyncCommand(paymentsCmd2) {
 
 // src/commands/payments/webhooks.ts
 function registerPaymentsWebhooksCommand(paymentsCmd2) {
-  const webhooksCmd = paymentsCmd2.command("webhooks").description("Manage InsForge-managed Stripe webhooks");
-  webhooksCmd.command("configure <environment>").description("Create or recreate the managed Stripe webhook endpoint").action(async (environmentValue, _opts, cmd) => {
+  const webhooksCmd = paymentsCmd2.command("webhooks").description("Manage Stripe webhooks");
+  webhooksCmd.command("configure").description("Create or recreate the managed Stripe webhook endpoint").requiredOption(
+    "--environment <environment>",
+    "Stripe environment: test or live"
+  ).action(async (opts, cmd) => {
     const { json } = getRootOpts(cmd);
     try {
-      const environment = parseEnvironment(environmentValue);
+      const environment = parseEnvironment(opts.environment);
       await requireAuth();
-      const data = await configurePaymentWebhook(environment);
+      const data = await configureStripeWebhook(environment);
       if (json) {
         outputJson(data);
       } else {
         outputTable(
           ["Env", "Webhook ID", "URL", "Configured At"],
-          [[
-            data.connection.environment,
-            data.connection.webhookEndpointId ?? "-",
-            data.connection.webhookEndpointUrl ?? "-",
-            formatDate(data.connection.webhookConfiguredAt)
-          ]]
+          [
+            [
+              data.connection.environment,
+              data.connection.webhookEndpointId ?? "-",
+              data.connection.webhookEndpointUrl ?? "-",
+              formatDate(data.connection.webhookConfiguredAt)
+            ]
+          ]
         );
         outputSuccess(`Stripe ${environment} webhook configured.`);
       }
-      await trackPaymentUsage("webhooks.configure", true, { environment });
+      await trackPaymentUsage("webhooks.configure", true, {
+        provider: "stripe",
+        environment
+      });
     } catch (err) {
-      await trackPaymentUsage("webhooks.configure", false, { environment: environmentValue });
+      await trackPaymentUsage(
+        "webhooks.configure",
+        false,
+        {
+          provider: "stripe",
+          environment: opts.environment
+        },
+        err
+      );
       handleError(err, json);
     }
   });
@@ -8536,17 +9411,28 @@ function registerPaymentsWebhooksCommand(paymentsCmd2) {
 
 // src/commands/payments/index.ts
 function registerPaymentsCommands(paymentsCmd2) {
-  paymentsCmd2.description("Manage Stripe payments");
-  registerPaymentsStatusCommand(paymentsCmd2);
-  registerPaymentsConfigCommand(paymentsCmd2);
-  registerPaymentsSyncCommand(paymentsCmd2);
-  registerPaymentsWebhooksCommand(paymentsCmd2);
-  registerPaymentsCatalogCommand(paymentsCmd2);
-  registerPaymentsCustomersCommand(paymentsCmd2);
-  registerPaymentsProductsCommand(paymentsCmd2);
-  registerPaymentsPricesCommand(paymentsCmd2);
-  registerPaymentsSubscriptionsCommand(paymentsCmd2);
-  registerPaymentsHistoryCommand(paymentsCmd2);
+  paymentsCmd2.description("Manage payments");
+  const stripeCmd = paymentsCmd2.command("stripe").description("Manage Stripe payments");
+  registerPaymentsStatusCommand(stripeCmd, "stripe");
+  registerPaymentsConfigCommand(stripeCmd, "stripe");
+  registerPaymentsSyncCommand(stripeCmd, "stripe");
+  registerPaymentsWebhooksCommand(stripeCmd);
+  registerPaymentsCatalogCommand(stripeCmd, "stripe");
+  registerPaymentsCustomersCommand(stripeCmd, "stripe");
+  registerPaymentsProductsCommand(stripeCmd);
+  registerPaymentsPricesCommand(stripeCmd);
+  registerPaymentsSubscriptionsCommand(stripeCmd, "stripe");
+  registerPaymentsTransactionsCommand(stripeCmd, "stripe");
+  const razorpayCmd = paymentsCmd2.command("razorpay").description("Manage Razorpay payments");
+  registerPaymentsStatusCommand(razorpayCmd, "razorpay");
+  registerPaymentsConfigCommand(razorpayCmd, "razorpay");
+  registerPaymentsSyncCommand(razorpayCmd, "razorpay");
+  registerPaymentsCatalogCommand(razorpayCmd, "razorpay");
+  registerPaymentsCustomersCommand(razorpayCmd, "razorpay");
+  registerPaymentsItemsCommand(razorpayCmd);
+  registerPaymentsPlansCommand(razorpayCmd);
+  registerPaymentsSubscriptionsCommand(razorpayCmd, "razorpay");
+  registerPaymentsTransactionsCommand(razorpayCmd, "razorpay");
 }
 
 // src/commands/posthog/setup.ts
@@ -8950,9 +9836,47 @@ function validateConfig(input) {
     out.project_id = obj.project_id;
   }
   if ("auth" in obj) out.auth = validateAuth(obj.auth);
+  if ("storage" in obj) out.storage = validateStorage(obj.storage);
+  if ("realtime" in obj) out.realtime = validateRetentionSection("realtime", obj.realtime);
+  if ("schedules" in obj) out.schedules = validateRetentionSection("schedules", obj.schedules);
   if ("deployments" in obj) out.deployments = validateDeployments(obj.deployments);
   return out;
 }
+function validateStorage(input) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    throw new ConfigValidationError("storage", "must be an object");
+  }
+  const obj = input;
+  const out = {};
+  if ("max_file_size_mb" in obj) {
+    if (typeof obj.max_file_size_mb !== "number" || !Number.isInteger(obj.max_file_size_mb) || obj.max_file_size_mb < 1 || obj.max_file_size_mb > 200) {
+      throw new ConfigValidationError(
+        "storage.max_file_size_mb",
+        "must be an integer between 1 and 200"
+      );
+    }
+    out.max_file_size_mb = obj.max_file_size_mb;
+  }
+  return out;
+}
+function validateRetentionSection(path6, input) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    throw new ConfigValidationError(path6, "must be an object");
+  }
+  const obj = input;
+  const out = {};
+  if ("retention_days" in obj) {
+    const v = obj.retention_days;
+    if (v !== null && (typeof v !== "number" || !Number.isInteger(v) || v < 0)) {
+      throw new ConfigValidationError(
+        `${path6}.retention_days`,
+        "must be a non-negative integer or null"
+      );
+    }
+    out.retention_days = v;
+  }
+  return out;
+}
 function validateDeployments(input) {
   if (input === null || typeof input !== "object" || Array.isArray(input)) {
     throw new ConfigValidationError("deployments", "must be an object");
@@ -9008,6 +9932,12 @@ function validateAuth(input) {
       obj.reset_password_method
     );
   }
+  if ("disable_signup" in obj) {
+    if (typeof obj.disable_signup !== "boolean") {
+      throw new ConfigValidationError("auth.disable_signup", "must be a boolean");
+    }
+    out.disable_signup = obj.disable_signup;
+  }
   if ("password" in obj) out.password = validatePassword(obj.password);
   if ("smtp" in obj) out.smtp = validateSmtp(obj.smtp);
   return out;
@@ -9143,6 +10073,21 @@ function stringifyConfigToml(config) {
       lines.push("");
     }
   }
+  if (config.storage) {
+    lines.push("[storage]");
+    renderStorageFields(config.storage, lines);
+    lines.push("");
+  }
+  if (config.realtime) {
+    lines.push("[realtime]");
+    renderRetentionFields(config.realtime, lines);
+    lines.push("");
+  }
+  if (config.schedules) {
+    lines.push("[schedules]");
+    renderRetentionFields(config.schedules, lines);
+    lines.push("");
+  }
   if (config.deployments) {
     if (typeof config.deployments.subdomain === "string" && config.deployments.subdomain !== "") {
       lines.push("[deployments]");
@@ -9166,6 +10111,9 @@ function renderAuthFlatFields(auth, lines) {
   if (auth.reset_password_method !== void 0) {
     lines.push(`reset_password_method = ${JSON.stringify(auth.reset_password_method)}`);
   }
+  if (auth.disable_signup !== void 0) {
+    lines.push(`disable_signup = ${auth.disable_signup}`);
+  }
 }
 function renderPasswordFields(pw, lines) {
   if (pw.min_length !== void 0) lines.push(`min_length = ${pw.min_length}`);
@@ -9202,9 +10150,19 @@ function renderSmtpFields(smtp, lines) {
     lines.push(`min_interval_seconds = ${smtp.min_interval_seconds}`);
   }
 }
+function renderStorageFields(storage, lines) {
+  if (storage.max_file_size_mb !== void 0) {
+    lines.push(`max_file_size_mb = ${storage.max_file_size_mb}`);
+  }
+}
+function renderRetentionFields(config, lines) {
+  if ("retention_days" in config) {
+    lines.push(`retention_days = ${config.retention_days ?? 0}`);
+  }
+}
 
 // src/lib/config-metadata.ts
-function liveFromMetadata(raw) {
+function liveFromMetadata(raw, endpointConfig = {}) {
   const live = { auth: {} };
   const a = isPlainObject(raw.auth) ? raw.auth : void 0;
   if (a && "allowedRedirectUrls" in a) {
@@ -9219,6 +10177,9 @@ function liveFromMetadata(raw) {
   if (a && "resetPasswordMethod" in a && (a.resetPasswordMethod === "code" || a.resetPasswordMethod === "link")) {
     live.auth.reset_password_method = a.resetPasswordMethod;
   }
+  if (a && "disableSignup" in a) {
+    live.auth.disable_signup = a.disableSignup ?? false;
+  }
   if (a && ("passwordMinLength" in a || "requireNumber" in a || "requireLowercase" in a || "requireUppercase" in a || "requireSpecialChar" in a)) {
     live.auth.password = {
       min_length: a.passwordMinLength ?? 8,
@@ -9247,6 +10208,18 @@ function liveFromMetadata(raw) {
       subdomain: typeof d.customSlug === "string" && d.customSlug ? d.customSlug : null
     };
   }
+  const maxFileSizeMb = asNumber(endpointConfig.storageConfig?.maxFileSizeMb);
+  if (maxFileSizeMb !== void 0) {
+    live.storage = { max_file_size_mb: maxFileSizeMb };
+  }
+  const realtimeRetention = asRetentionDays(endpointConfig.realtimeConfig?.retentionDays);
+  if (realtimeRetention !== void 0) {
+    live.realtime = { retention_days: realtimeRetention };
+  }
+  const schedulesRetention = asRetentionDays(endpointConfig.schedulesConfig?.retentionDays);
+  if (schedulesRetention !== void 0) {
+    live.schedules = { retention_days: schedulesRetention };
+  }
   return live;
 }
 function isPlainObject(v) {
@@ -9255,7 +10228,14 @@ function isPlainObject(v) {
 function asStringArray(v) {
   return Array.isArray(v) && v.every((x) => typeof x === "string") ? v : null;
 }
-function configFromMetadata(raw) {
+function asNumber(v) {
+  return typeof v === "number" && Number.isInteger(v) ? v : void 0;
+}
+function asRetentionDays(v) {
+  if (v === null) return null;
+  return asNumber(v);
+}
+function configFromMetadata(raw, endpointConfig = {}) {
   const config = {};
   const skipped = [];
   const a = isPlainObject(raw.auth) ? raw.auth : void 0;
@@ -9283,6 +10263,12 @@ function configFromMetadata(raw) {
   } else {
     skipped.push("auth.reset_password_method");
   }
+  if (a && "disableSignup" in a) {
+    config.auth = config.auth ?? {};
+    config.auth.disable_signup = a.disableSignup ?? false;
+  } else {
+    skipped.push("auth.disable_signup");
+  }
   if (a && ("passwordMinLength" in a || "requireNumber" in a || "requireLowercase" in a || "requireUppercase" in a || "requireSpecialChar" in a)) {
     config.auth = config.auth ?? {};
     config.auth.password = {};
@@ -9326,6 +10312,24 @@ function configFromMetadata(raw) {
   } else {
     skipped.push("deployments.subdomain");
   }
+  const maxFileSizeMb = asNumber(endpointConfig.storageConfig?.maxFileSizeMb);
+  if (maxFileSizeMb !== void 0) {
+    config.storage = { max_file_size_mb: maxFileSizeMb };
+  } else {
+    skipped.push("storage.max_file_size_mb");
+  }
+  const realtimeRetention = asRetentionDays(endpointConfig.realtimeConfig?.retentionDays);
+  if (realtimeRetention !== void 0) {
+    config.realtime = { retention_days: realtimeRetention };
+  } else {
+    skipped.push("realtime.retention_days");
+  }
+  const schedulesRetention = asRetentionDays(endpointConfig.schedulesConfig?.retentionDays);
+  if (schedulesRetention !== void 0) {
+    config.schedules = { retention_days: schedulesRetention };
+  } else {
+    skipped.push("schedules.retention_days");
+  }
   return { config, skipped };
 }
 
@@ -9363,7 +10367,16 @@ function registerConfigExportCommand(cfg) {
       }
       const res = await ossFetch("/api/metadata");
       const raw = await res.json();
-      const { config, skipped } = configFromMetadata(raw);
+      const [storageConfig, realtimeConfig, schedulesConfig] = await Promise.all([
+        fetchOptionalConfig("/api/storage/config"),
+        fetchOptionalConfig("/api/realtime/config"),
+        fetchOptionalConfig("/api/schedules/config")
+      ]);
+      const { config, skipped } = configFromMetadata(raw, {
+        storageConfig,
+        realtimeConfig,
+        schedulesConfig
+      });
       const toml = stringifyConfigToml(config);
       writeFileSync8(target, toml, "utf8");
       if (json) {
@@ -9399,6 +10412,18 @@ function registerConfigExportCommand(cfg) {
     }
   });
 }
+async function fetchOptionalConfig(path6) {
+  try {
+    const res = await ossFetch(path6);
+    return await res.json();
+  } catch (err) {
+    if (isMissingOptionalEndpoint(err)) return void 0;
+    throw err;
+  }
+}
+function isMissingOptionalEndpoint(err) {
+  return err instanceof CLIError && err.statusCode === 404 && (err.code === void 0 || err.code === "NOT_FOUND");
+}
 
 // src/commands/config/plan.ts
 import { readFileSync as readFileSync9 } from "fs";
@@ -9462,6 +10487,19 @@ function diffConfig({ live, file }) {
       });
     }
   }
+  if (fileAuth && "disable_signup" in fileAuth) {
+    const fromV = liveAuth.disable_signup ?? false;
+    const toV = fileAuth.disable_signup ?? false;
+    if (fromV !== toV) {
+      changes.push({
+        section: "auth",
+        op: "modify",
+        key: "disable_signup",
+        from: fromV,
+        to: toV
+      });
+    }
+  }
   if (fileAuth?.password) {
     diffPassword(liveAuth.password, fileAuth.password, changes);
   }
@@ -9469,6 +10507,15 @@ function diffConfig({ live, file }) {
     const smtpChange = diffSmtp(liveAuth.smtp, fileAuth.smtp);
     if (smtpChange) changes.push(smtpChange);
   }
+  if (file.storage !== void 0) {
+    diffStorage(live.storage, file.storage, changes);
+  }
+  if (file.realtime !== void 0) {
+    diffRetention("realtime", live.realtime, file.realtime, changes);
+  }
+  if (file.schedules !== void 0) {
+    diffRetention("schedules", live.schedules, file.schedules, changes);
+  }
   const fileDeployments = file.deployments;
   const liveDeployments = live.deployments ?? {};
   if (fileDeployments && "subdomain" in fileDeployments) {
@@ -9517,6 +10564,36 @@ function diffPassword(live, file, changes) {
     }
   }
 }
+function diffStorage(live, file, changes) {
+  if (file.max_file_size_mb === void 0) return;
+  const fromV = live?.max_file_size_mb ?? EMPTY_STORAGE_CONFIG.max_file_size_mb;
+  if (fromV !== file.max_file_size_mb) {
+    changes.push({
+      section: "storage",
+      op: "modify",
+      key: "max_file_size_mb",
+      from: fromV,
+      to: file.max_file_size_mb
+    });
+  }
+}
+function diffRetention(section, live, file, changes) {
+  if (!("retention_days" in file)) return;
+  const fromV = normalizeRetentionDays(live?.retention_days);
+  const toV = normalizeRetentionDays(file.retention_days);
+  if (fromV !== toV) {
+    changes.push({
+      section,
+      op: "modify",
+      key: "retention_days",
+      from: fromV,
+      to: toV
+    });
+  }
+}
+function normalizeRetentionDays(value) {
+  return value === void 0 || value === null || value === 0 ? null : value;
+}
 function diffSmtp(live, fileSmtp) {
   const livedView = renderLiveSmtp(live);
   const tomlView = renderFileSmtp(fileSmtp);
@@ -9575,6 +10652,9 @@ var EMPTY_SMTP_VIEW = {
   sender_name: "",
   min_interval_seconds: 60
 };
+var EMPTY_STORAGE_CONFIG = {
+  max_file_size_mb: 50
+};
 var EMPTY_PASSWORD_POLICY = {
   min_length: 8,
   require_number: false,
@@ -9655,7 +10735,7 @@ function formatChange(c) {
 }
 
 // src/lib/config-capabilities.ts
-function metadataSupports(raw, change) {
+function metadataSupports(raw, change, endpointConfig = {}) {
   if (change.section === "auth" && change.key === "allowed_redirect_urls") {
     return hasAuthKey(raw, "allowedRedirectUrls");
   }
@@ -9668,12 +10748,24 @@ function metadataSupports(raw, change) {
   if (change.section === "auth" && change.key === "reset_password_method") {
     return hasAuthKey(raw, "resetPasswordMethod");
   }
+  if (change.section === "auth" && change.key === "disable_signup") {
+    return hasAuthKey(raw, "disableSignup");
+  }
   if (change.section === "auth.password") {
     return hasAuthKey(raw, AUTH_PASSWORD_WIRE_KEY[change.key]);
   }
   if (change.section === "auth.smtp") {
     return hasAuthKey(raw, "smtpConfig");
   }
+  if (change.section === "storage" && change.key === "max_file_size_mb") {
+    return hasConfigKey(endpointConfig.storageConfig, "maxFileSizeMb");
+  }
+  if (change.section === "realtime" && change.key === "retention_days") {
+    return hasConfigKey(endpointConfig.realtimeConfig, "retentionDays");
+  }
+  if (change.section === "schedules" && change.key === "retention_days") {
+    return hasConfigKey(endpointConfig.schedulesConfig, "retentionDays");
+  }
   if (change.section === "deployments" && change.key === "subdomain") {
     return raw?.deployments !== void 0 && raw.deployments !== null && typeof raw.deployments === "object";
   }
@@ -9685,6 +10777,9 @@ function hasAuthKey(raw, key) {
   const auth = raw?.auth;
   return auth !== void 0 && auth !== null && typeof auth === "object" && key in auth;
 }
+function hasConfigKey(slice, key) {
+  return slice !== void 0 && slice !== null && typeof slice === "object" && key in slice;
+}
 var AUTH_PASSWORD_WIRE_KEY = {
   min_length: "passwordMinLength",
   require_number: "requireNumber",
@@ -9713,9 +10808,25 @@ function registerConfigPlanCommand(cfg) {
       const file = parseConfigToml(tomlSource);
       const res = await ossFetch("/api/metadata");
       const raw = await res.json();
-      const live = liveFromMetadata(raw);
+      const endpointConfig = {};
+      if (file.storage !== void 0) {
+        endpointConfig.storageConfig = await fetchOptionalConfig2(
+          "/api/storage/config"
+        );
+      }
+      if (file.realtime !== void 0) {
+        endpointConfig.realtimeConfig = await fetchOptionalConfig2(
+          "/api/realtime/config"
+        );
+      }
+      if (file.schedules !== void 0) {
+        endpointConfig.schedulesConfig = await fetchOptionalConfig2(
+          "/api/schedules/config"
+        );
+      }
+      const live = liveFromMetadata(raw, endpointConfig);
       const result = diffConfig({ live, file });
-      const skipped = result.changes.filter((c) => !metadataSupports(raw, c)).map((c) => changePath(c));
+      const skipped = result.changes.filter((c) => !metadataSupports(raw, c, endpointConfig)).map((c) => changePath(c));
       if (json) {
         console.log(JSON.stringify({ ...result, skipped }, null, 2));
       } else {
@@ -9751,6 +10862,18 @@ function registerConfigPlanCommand(cfg) {
     }
   });
 }
+async function fetchOptionalConfig2(path6) {
+  try {
+    const res = await ossFetch(path6);
+    return await res.json();
+  } catch (err) {
+    if (isMissingOptionalEndpoint2(err)) return void 0;
+    throw err;
+  }
+}
+function isMissingOptionalEndpoint2(err) {
+  return err instanceof CLIError && err.statusCode === 404 && (err.code === void 0 || err.code === "NOT_FOUND");
+}
 
 // src/commands/config/apply.ts
 import { readFileSync as readFileSync10 } from "fs";
@@ -9769,7 +10892,23 @@ function registerConfigApplyCommand(cfg) {
       const file = parseConfigToml(tomlSource);
       const res = await ossFetch("/api/metadata");
       const raw = await res.json();
-      const live = liveFromMetadata(raw);
+      const endpointConfig = {};
+      if (file.storage !== void 0) {
+        endpointConfig.storageConfig = await fetchOptionalConfig3(
+          "/api/storage/config"
+        );
+      }
+      if (file.realtime !== void 0) {
+        endpointConfig.realtimeConfig = await fetchOptionalConfig3(
+          "/api/realtime/config"
+        );
+      }
+      if (file.schedules !== void 0) {
+        endpointConfig.schedulesConfig = await fetchOptionalConfig3(
+          "/api/schedules/config"
+        );
+      }
+      const live = liveFromMetadata(raw, endpointConfig);
       const result = diffConfig({ live, file });
       const approved = opts.autoApprove || yes;
       const sectionsChanged = Array.from(
@@ -9822,7 +10961,7 @@ function registerConfigApplyCommand(cfg) {
       const skipped = [];
       for (const change of result.changes) {
         const path6 = changePath(change);
-        if (!metadataSupports(raw, change)) {
+        if (!metadataSupports(raw, change, endpointConfig)) {
           skipped.push({
             key: path6,
             reason: `your backend doesn't expose ${path6} \u2014 upgrade the project to apply this section`
@@ -9873,6 +11012,18 @@ function registerConfigApplyCommand(cfg) {
     }
   });
 }
+async function fetchOptionalConfig3(path6) {
+  try {
+    const res = await ossFetch(path6);
+    return await res.json();
+  } catch (err) {
+    if (isMissingOptionalEndpoint3(err)) return void 0;
+    throw err;
+  }
+}
+function isMissingOptionalEndpoint3(err) {
+  return err instanceof CLIError && err.statusCode === 404 && (err.code === void 0 || err.code === "NOT_FOUND");
+}
 async function applyChange(change) {
   if (change.section === "auth" && change.key === "allowed_redirect_urls") {
     await ossFetch("/api/auth/config", {
@@ -9902,6 +11053,13 @@ async function applyChange(change) {
     });
     return;
   }
+  if (change.section === "auth" && change.key === "disable_signup") {
+    await ossFetch("/api/auth/config", {
+      method: "PUT",
+      body: JSON.stringify({ disableSignup: change.to })
+    });
+    return;
+  }
   if (change.section === "auth.password") {
     const wireKey = authPasswordWireKey(change.key);
     await ossFetch("/api/auth/config", {
@@ -9934,6 +11092,27 @@ async function applyChange(change) {
     });
     return;
   }
+  if (change.section === "storage" && change.key === "max_file_size_mb") {
+    await ossFetch("/api/storage/config", {
+      method: "PUT",
+      body: JSON.stringify({ maxFileSizeMb: change.to })
+    });
+    return;
+  }
+  if (change.section === "realtime" && change.key === "retention_days") {
+    await ossFetch("/api/realtime/config", {
+      method: "PATCH",
+      body: JSON.stringify({ retentionDays: change.to })
+    });
+    return;
+  }
+  if (change.section === "schedules" && change.key === "retention_days") {
+    await ossFetch("/api/schedules/config", {
+      method: "PATCH",
+      body: JSON.stringify({ retentionDays: change.to })
+    });
+    return;
+  }
   if (change.section === "deployments" && change.key === "subdomain") {
     await ossFetch("/api/deployments/slug", {
       method: "PUT",