owosk 0.1.0

package/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Owostack
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,82 @@
+# owosk
+
+The primary tool for managing your Owostack billing configuration from the terminal. Use it to synchronize your local catalog, validate your configuration, and manage your billing infrastructure.
+
+## Installation
+
+Install the CLI globally:
+
+```bash
+npm install -g owosk
+```
+
+Or use it directly with npx:
+
+```bash
+npx owo --help
+```
+
+## Commands
+
+### `init`
+
+Initialize a new Owostack project with a default `owo.config.ts`.
+
+```bash
+npx owo init
+```
+
+### `sync`
+
+Push your local catalog configuration to the Owostack cloud.
+
+```bash
+npx owo sync
+```
+
+### `pull`
+
+Pull existing plans and features from the cloud into your local configuration.
+
+```bash
+npx owo pull
+```
+
+### `diff`
+
+Preview changes by comparing your local configuration with the cloud.
+
+```bash
+npx owo diff
+```
+
+### `validate`
+
+Check your local `owo.config.ts` for errors without applying changes.
+
+```bash
+npx owo validate
+```
+
+### `connect`
+
+Authenticate and connect your local environment to an organization.
+
+```bash
+npx owo connect
+```
+
+## Features
+
+- **Declarative Catalog**: Manage your billing structure as code.
+- **Idempotent Sync**: Safely push changes without duplicating resources.
+- **Validation**: Catch configuration errors before they hit production.
+- **Cloud Synchronization**: Keep your local and cloud environments in sync.
+
+## Documentation
+
+For full command references and guides, visit [docs.owostack.com/cli](https://docs.owostack.com/cli).
+
+## License
+
+Apache-2.0

package/dist/index.js

@@ -0,0 +1,1049 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/sync.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+
+// src/lib/config.ts
+import { join } from "path";
+import { homedir } from "os";
+import { existsSync, mkdirSync, readFileSync } from "fs";
+import { writeFile } from "fs/promises";
+var GLOBAL_CONFIG_DIR = join(homedir(), ".owostack");
+var GLOBAL_CONFIG_PATH = join(GLOBAL_CONFIG_DIR, "config.json");
+function getApiUrl(configUrl) {
+  return process.env.OWOSTACK_API_URL || configUrl || "https://api.owostack.com";
+}
+function getTestApiUrl(configUrl) {
+  return process.env.OWOSTACK_API_TEST_URL || configUrl || "https://sandbox.owostack.com";
+}
+function getDashboardUrl(configUrl) {
+  return process.env.OWOSTACK_DASHBOARD_URL || configUrl || "https://app.owostack.com";
+}
+async function saveGlobalConfig(data) {
+  if (!existsSync(GLOBAL_CONFIG_DIR)) {
+    mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true });
+  }
+  await writeFile(GLOBAL_CONFIG_PATH, JSON.stringify(data, null, 2), "utf8");
+}
+function loadGlobalConfig() {
+  try {
+    if (existsSync(GLOBAL_CONFIG_PATH)) {
+      return JSON.parse(readFileSync(GLOBAL_CONFIG_PATH, "utf8"));
+    }
+  } catch {
+  }
+  return {};
+}
+function getApiKey(cliKey) {
+  if (cliKey) return cliKey;
+  if (process.env.OWOSTACK_SECRET_KEY) return process.env.OWOSTACK_SECRET_KEY;
+  if (process.env.OWOSTACK_API_KEY) return process.env.OWOSTACK_API_KEY;
+  return loadGlobalConfig().apiKey || "";
+}
+
+// src/lib/loader.ts
+import { resolve, isAbsolute } from "path";
+import { pathToFileURL } from "url";
+import { existsSync as existsSync2 } from "fs";
+function resolveConfigPath(configPath) {
+  return isAbsolute(configPath) ? configPath : resolve(process.cwd(), configPath);
+}
+async function loadOwostackFromConfig(fullPath) {
+  let configModule;
+  try {
+    const fileUrl = pathToFileURL(fullPath).href;
+    configModule = await import(fileUrl);
+  } catch (e) {
+    console.error(`
+  \u274C Failed to load config from ${fullPath}`);
+    console.error(`     ${e.message}
+`);
+    console.error(
+      `  Make sure the file exports an Owostack instance as default or named 'owo'.`
+    );
+    console.error(`  Example owo.config.ts:
+`);
+    console.error(
+      `    import { Owostack, metered, boolean, plan } from "owostack";`
+    );
+    console.error(
+      `    export default new Owostack({ secretKey: "...", catalog: [...] });
+`
+    );
+    process.exit(1);
+  }
+  return configModule.default || configModule.owo;
+}
+async function loadConfigSettings(configPath) {
+  try {
+    const fullPath = resolveConfigPath(configPath);
+    if (!existsSync2(fullPath)) return {};
+    const owo = await loadOwostackFromConfig(fullPath);
+    if (!owo || !owo._config) return {};
+    return {
+      apiUrl: owo._config.apiUrl,
+      environments: owo._config.environments,
+      filters: owo._config.filters,
+      connect: owo._config.connect
+    };
+  } catch {
+    return {};
+  }
+}
+
+// src/commands/sync.ts
+async function runSyncSingle(options) {
+  const { configPath, dryRun, apiUrl } = options;
+  const apiKey = getApiKey(options.apiKey);
+  const fullPath = resolveConfigPath(configPath);
+  const s = p.spinner();
+  s.start(`Loading ${pc.cyan(configPath)}`);
+  const owo = await loadOwostackFromConfig(fullPath);
+  if (!owo || typeof owo.sync !== "function") {
+    s.stop(pc.red("Invalid configuration"));
+    p.log.error("Config file must export an Owostack instance.");
+    process.exit(1);
+  }
+  s.message("Syncing with API...");
+  if (apiKey && typeof owo.setSecretKey === "function") {
+    owo.setSecretKey(apiKey);
+  }
+  if (apiUrl && typeof owo.setApiUrl === "function") {
+    owo.setApiUrl(apiUrl);
+  }
+  try {
+    if (dryRun) {
+      s.stop(pc.yellow("Dry run mode (showing catalog payload)"));
+      const { buildSyncPayload } = await import("owostack").catch(() => {
+        return { buildSyncPayload: null };
+      });
+      if (buildSyncPayload && owo._config?.catalog) {
+        const payload = buildSyncPayload(owo._config.catalog);
+        let featureSummary = payload.features.map(
+          (f) => `${pc.green("+")} ${pc.bold(f.slug)} ${pc.dim(`(${f.type})`)}`
+        ).join("\n");
+        p.note(
+          featureSummary || pc.dim("No features defined"),
+          "Features to Sync"
+        );
+        let planSummary = "";
+        for (const p_obj of payload.plans) {
+          planSummary += `${pc.green("+")} ${pc.bold(p_obj.slug)} ${pc.dim(`${p_obj.currency} ${p_obj.price}/${p_obj.interval}`)}
+`;
+          for (const f of p_obj.features) {
+            const status = f.enabled ? pc.green("\u2713") : pc.red("\u2717");
+            const configParts = [];
+            if (f.limit !== void 0)
+              configParts.push(
+                `limit: ${f.limit === null ? "unlimited" : f.limit}`
+              );
+            if (f.reset) configParts.push(`reset: ${f.reset}`);
+            if (f.overage) configParts.push(`overage: ${f.overage}`);
+            if (f.overagePrice) configParts.push(`price: ${f.overagePrice}`);
+            const configStr = configParts.length > 0 ? ` ${pc.dim(`(${configParts.join(", ")})`)}` : "";
+            planSummary += `  ${status} ${pc.dim(f.slug)}${configStr}
+`;
+          }
+          planSummary += "\n";
+        }
+        p.note(
+          planSummary.trim() || pc.dim("No plans defined"),
+          "Plans to Sync"
+        );
+      }
+      p.log.info(pc.yellow("No changes were applied to the server."));
+      return;
+    }
+    const result = await owo.sync();
+    s.stop(pc.green("Sync completed"));
+    if (!result.success) {
+      p.log.error(pc.red("Sync failed"));
+      process.exit(1);
+    }
+    const fc = result.features;
+    const pc_res = result.plans;
+    let summary = [];
+    if (fc.created.length)
+      summary.push(pc.green(`+ ${fc.created.length} features`));
+    if (fc.updated.length)
+      summary.push(pc.cyan(`~ ${fc.updated.length} features`));
+    if (pc_res.created.length)
+      summary.push(pc.green(`+ ${pc_res.created.length} plans`));
+    if (pc_res.updated.length)
+      summary.push(pc.cyan(`~ ${pc_res.updated.length} plans`));
+    if (summary.length > 0) {
+      p.note(summary.join("\n"), "Changes applied");
+    } else {
+      p.log.info(pc.dim("No changes detected. Catalog is up to date."));
+    }
+    if (result.warnings.length) {
+      p.log.warn(pc.yellow(`Warnings:
+${result.warnings.join("\n")}`));
+    }
+  } catch (e) {
+    s.stop(pc.red("Sync failed"));
+    p.log.error(e.message);
+    throw e;
+  }
+}
+async function runSync(options) {
+  p.intro(pc.bgYellow(pc.black(" sync ")));
+  const configSettings = await loadConfigSettings(options.config);
+  let apiUrl = configSettings.apiUrl;
+  const testUrl = getTestApiUrl(configSettings.environments?.test);
+  const liveUrl = getApiUrl(configSettings.environments?.live);
+  if (options.prod) {
+    p.log.step(pc.magenta("Production Mode: Syncing both environments"));
+    await runSyncSingle({
+      configPath: options.config,
+      dryRun: !!options.dryRun,
+      apiKey: options.key || "",
+      apiUrl: apiUrl || `${testUrl}/api/v1`
+    });
+    await runSyncSingle({
+      configPath: options.config,
+      dryRun: !!options.dryRun,
+      apiKey: options.key || "",
+      apiUrl: apiUrl || `${liveUrl}/api/v1`
+    });
+  } else {
+    await runSyncSingle({
+      configPath: options.config,
+      dryRun: !!options.dryRun,
+      apiKey: options.key || "",
+      apiUrl: apiUrl || `${liveUrl}/api/v1`
+    });
+  }
+  p.outro(pc.green("Done! \u2728"));
+}
+
+// src/commands/pull.ts
+import * as p2 from "@clack/prompts";
+import pc2 from "picocolors";
+import { existsSync as existsSync3 } from "fs";
+import { writeFile as writeFile2 } from "fs/promises";
+
+// src/lib/api.ts
+async function fetchPlans(options) {
+  if (!options.apiKey) {
+    console.error(
+      `
+  \u274C Missing API key. Pass --key or set OWOSTACK_SECRET_KEY.
+`
+    );
+    process.exit(1);
+  }
+  const url = new URL(`${options.apiUrl}/plans`);
+  if (options.group) url.searchParams.set("group", options.group);
+  if (options.interval) url.searchParams.set("interval", options.interval);
+  if (options.currency) url.searchParams.set("currency", options.currency);
+  if (options.includeInactive) url.searchParams.set("includeInactive", "true");
+  const response = await fetch(url.toString(), {
+    method: "GET",
+    headers: { Authorization: `Bearer ${options.apiKey}` }
+  });
+  const data = await response.json();
+  if (!response.ok || !data?.success) {
+    const message = data?.error || data?.message || "Request failed";
+    console.error(`
+  \u274C Failed to fetch plans: ${message}
+`);
+    process.exit(1);
+  }
+  return data?.plans || [];
+}
+async function fetchCreditSystems(apiKey, apiUrl) {
+  if (!apiKey) {
+    return [];
+  }
+  try {
+    const url = `${apiUrl}/credit-systems`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${apiKey}` }
+    });
+    const data = await response.json();
+    if (!response.ok || !data?.success) {
+      return [];
+    }
+    return data?.creditSystems || [];
+  } catch {
+    return [];
+  }
+}
+
+// src/lib/generate.ts
+function slugToIdentifier(slug, used) {
+  const parts = slug.replace(/[^a-zA-Z0-9]+/g, " ").trim().split(/\s+/).filter(Boolean);
+  let id = parts.map((p9, i) => {
+    const lower = p9.toLowerCase();
+    return i === 0 ? lower : lower.charAt(0).toUpperCase() + lower.slice(1);
+  }).join("");
+  if (!id) id = "feature";
+  if (/^\d/.test(id)) id = `feature${id}`;
+  const reserved = /* @__PURE__ */ new Set([
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "export",
+    "extends",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "new",
+    "return",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield"
+  ]);
+  if (reserved.has(id)) id = `${id}Feature`;
+  let candidate = id;
+  let counter = 2;
+  while (used.has(candidate)) {
+    candidate = `${id}${counter++}`;
+  }
+  used.add(candidate);
+  return candidate;
+}
+function generateConfig(plans, creditSystems = [], defaultProvider) {
+  const creditSystemSlugs = new Set(creditSystems.map((cs) => cs.slug));
+  const creditSystemBySlug = new Map(creditSystems.map((cs) => [cs.slug, cs]));
+  const featuresBySlug = /* @__PURE__ */ new Map();
+  for (const plan of plans) {
+    for (const f of plan.features || []) {
+      if (creditSystemSlugs.has(f.slug)) continue;
+      if (!featuresBySlug.has(f.slug)) {
+        featuresBySlug.set(f.slug, {
+          slug: f.slug,
+          name: f.name,
+          type: f.type || "metered"
+        });
+      }
+    }
+  }
+  for (const cs of creditSystems) {
+    for (const f of cs.features || []) {
+      if (!featuresBySlug.has(f.feature)) {
+        featuresBySlug.set(f.feature, {
+          slug: f.feature,
+          name: f.feature,
+          type: "metered"
+        });
+      }
+    }
+  }
+  const usedNames = /* @__PURE__ */ new Set();
+  const featureVars = /* @__PURE__ */ new Map();
+  const featureLines = [];
+  for (const feature of featuresBySlug.values()) {
+    const varName = slugToIdentifier(feature.slug, usedNames);
+    featureVars.set(feature.slug, varName);
+    const nameArg = feature.name ? `, { name: ${JSON.stringify(feature.name)} }` : "";
+    if (feature.type === "boolean") {
+      featureLines.push(
+        `export const ${varName} = boolean(${JSON.stringify(feature.slug)}${nameArg});`
+      );
+    } else {
+      featureLines.push(
+        `export const ${varName} = metered(${JSON.stringify(feature.slug)}${nameArg});`
+      );
+    }
+  }
+  const creditSystemLines = [];
+  const creditSystemVars = /* @__PURE__ */ new Map();
+  for (const cs of creditSystems) {
+    const varName = slugToIdentifier(cs.slug, usedNames);
+    creditSystemVars.set(cs.slug, varName);
+    const nameArg = cs.name ? `name: ${JSON.stringify(cs.name)}` : "";
+    const descArg = cs.description ? `description: ${JSON.stringify(cs.description)}` : "";
+    const featureEntries = (cs.features || []).map((f) => {
+      const childVar = featureVars.get(f.feature) || f.feature;
+      return `${childVar}(${f.creditCost})`;
+    });
+    const optsParts = [
+      nameArg,
+      descArg,
+      `features: [${featureEntries.join(", ")}]`
+    ].filter(Boolean);
+    creditSystemLines.push(
+      `export const ${varName} = creditSystem(${JSON.stringify(cs.slug)}, { ${optsParts.join(", ")} });`
+    );
+  }
+  const planLines = [];
+  for (const plan of plans) {
+    const configLines = [];
+    configLines.push(`name: ${JSON.stringify(plan.name)}`);
+    if (plan.description)
+      configLines.push(`description: ${JSON.stringify(plan.description)}`);
+    configLines.push(`price: ${plan.price}`);
+    configLines.push(`currency: ${JSON.stringify(plan.currency)}`);
+    configLines.push(`interval: ${JSON.stringify(plan.interval)}`);
+    if (plan.planGroup)
+      configLines.push(`planGroup: ${JSON.stringify(plan.planGroup)}`);
+    if (plan.trialDays && plan.trialDays > 0)
+      configLines.push(`trialDays: ${plan.trialDays}`);
+    if (plan.provider)
+      configLines.push(`provider: ${JSON.stringify(plan.provider)}`);
+    const featureEntries = [];
+    for (const pf of plan.features || []) {
+      if (creditSystemSlugs.has(pf.slug)) {
+        const csVar = creditSystemVars.get(pf.slug);
+        if (csVar && pf.enabled) {
+          const opts = [];
+          if (pf.resetInterval || pf.reset)
+            opts.push(`reset: "${pf.resetInterval || pf.reset || "monthly"}"`);
+          if (pf.overage) opts.push(`overage: "${pf.overage}"`);
+          if (opts.length > 0) {
+            featureEntries.push(
+              `${csVar}.credits(${pf.limit ?? 0}, { ${opts.join(", ")} })`
+            );
+          } else {
+            featureEntries.push(`${csVar}.credits(${pf.limit ?? 0})`);
+          }
+        }
+        continue;
+      }
+      const varName = featureVars.get(pf.slug) || pf.slug;
+      const globalFeature = featuresBySlug.get(pf.slug);
+      const featureType = globalFeature?.type || pf.type || "metered";
+      if (featureType === "boolean") {
+        featureEntries.push(
+          pf.enabled ? `${varName}.on()` : `${varName}.off()`
+        );
+        continue;
+      }
+      if (pf.enabled === false) {
+        const config2 = { enabled: false };
+        if (pf.limit !== void 0) config2.limit = pf.limit;
+        if (pf.resetInterval || pf.reset)
+          config2.reset = pf.resetInterval || pf.reset;
+        if (pf.overage) config2.overage = pf.overage;
+        if (pf.overagePrice !== void 0)
+          config2.overagePrice = pf.overagePrice;
+        featureEntries.push(`${varName}.config(${JSON.stringify(config2)})`);
+        continue;
+      }
+      const config = {};
+      if (pf.limit !== void 0) config.limit = pf.limit;
+      config.reset = pf.resetInterval || pf.reset || "monthly";
+      if (pf.overage) config.overage = pf.overage;
+      if (pf.overagePrice !== void 0) config.overagePrice = pf.overagePrice;
+      const configKeys = Object.keys(config);
+      const hasExtras = configKeys.some((k) => k !== "limit");
+      if (config.limit === null && !hasExtras) {
+        featureEntries.push(`${varName}.unlimited()`);
+      } else if (typeof config.limit === "number" && !hasExtras) {
+        featureEntries.push(`${varName}.limit(${config.limit})`);
+      } else if (typeof config.limit === "number") {
+        const { limit, ...rest } = config;
+        featureEntries.push(
+          `${varName}.limit(${limit}, ${JSON.stringify(rest)})`
+        );
+      } else {
+        featureEntries.push(`${varName}.config(${JSON.stringify(config)})`);
+      }
+    }
+    configLines.push(`features: [${featureEntries.join(", ")}]`);
+    planLines.push(
+      `plan(${JSON.stringify(plan.slug)}, {
+      ${configLines.join(",\n      ")}
+    })`
+    );
+  }
+  const hasCreditSystems = creditSystemLines.length > 0;
+  const providerLine = defaultProvider ? `  provider: ${JSON.stringify(defaultProvider)},
+` : "";
+  return [
+    `import { Owostack, metered, boolean, creditSystem, plan } from "owostack";`,
+    ``,
+    ...featureLines,
+    ...hasCreditSystems ? ["", ...creditSystemLines] : [],
+    ``,
+    `export const owo = new Owostack({`,
+    `  secretKey: process.env.OWOSTACK_SECRET_KEY!,`,
+    providerLine,
+    `  catalog: [`,
+    `    ${planLines.join(",\n    ")}`,
+    `  ],`,
+    `});`,
+    ``
+  ].join("\n");
+}
+
+// src/commands/pull.ts
+async function runPull(options) {
+  p2.intro(pc2.bgYellow(pc2.black(" pull ")));
+  const fullPath = resolveConfigPath(options.config);
+  const apiKey = getApiKey(options.key);
+  const configSettings = await loadConfigSettings(options.config);
+  const baseUrl = getApiUrl(configSettings.apiUrl);
+  const filters = configSettings.filters || {};
+  const s = p2.spinner();
+  if (options.prod) {
+    p2.log.step(pc2.magenta("Production Mode: Fetching both environments"));
+    const testUrl = getTestApiUrl(configSettings.environments?.test);
+    const liveUrl = getApiUrl(configSettings.environments?.live);
+    s.start(`Fetching from ${pc2.dim("test")}...`);
+    const testPlans = await fetchPlans({
+      apiKey,
+      apiUrl: `${testUrl}/api/v1`,
+      ...filters
+    });
+    s.stop(`Fetched ${testPlans.length} plans from test`);
+    s.start(`Fetching from ${pc2.dim("live")}...`);
+    const livePlans = await fetchPlans({
+      apiKey,
+      apiUrl: `${liveUrl}/api/v1`,
+      ...filters
+    });
+    s.stop(`Fetched ${livePlans.length} plans from live`);
+    s.start(`Fetching credit systems...`);
+    const creditSystems = await fetchCreditSystems(apiKey, `${liveUrl}/api/v1`);
+    s.stop(`Fetched ${creditSystems.length} credit systems`);
+    const providers = new Set(
+      livePlans.map((p9) => p9.provider).filter(Boolean)
+    );
+    const defaultProvider = providers.size === 1 ? Array.from(providers)[0] : void 0;
+    const configContent = generateConfig(
+      livePlans,
+      creditSystems,
+      defaultProvider
+    );
+    if (options.dryRun) {
+      p2.note(configContent, "Generated Config (Dry Run)");
+      p2.outro(pc2.yellow("Dry run complete. No changes made."));
+      return;
+    }
+    if (existsSync3(fullPath) && !options.force) {
+      p2.log.error(pc2.red(`Config file already exists at ${fullPath}`));
+      p2.log.info(pc2.dim("Use --force to overwrite."));
+      process.exit(1);
+    }
+    await writeFile2(fullPath, configContent, "utf8");
+    p2.log.success(pc2.green(`Wrote configuration to ${fullPath}`));
+  } else {
+    s.start(`Fetching plans from ${pc2.dim(baseUrl)}...`);
+    const plans = await fetchPlans({
+      apiKey,
+      apiUrl: `${baseUrl}/api/v1`,
+      ...filters
+    });
+    s.stop(`Fetched ${plans.length} plans`);
+    s.start(`Fetching credit systems...`);
+    const creditSystems = await fetchCreditSystems(apiKey, `${baseUrl}/api/v1`);
+    s.stop(`Fetched ${creditSystems.length} credit systems`);
+    const providers = new Set(
+      plans.map((p9) => p9.provider).filter(Boolean)
+    );
+    const defaultProvider = providers.size === 1 ? Array.from(providers)[0] : void 0;
+    const configContent = generateConfig(plans, creditSystems, defaultProvider);
+    if (options.dryRun) {
+      p2.note(configContent, "Generated Config (Dry Run)");
+      p2.outro(pc2.yellow("Dry run complete. No changes made."));
+      return;
+    }
+    if (existsSync3(fullPath) && !options.force) {
+      const confirm3 = await p2.confirm({
+        message: `Config file already exists. Overwrite?`,
+        initialValue: false
+      });
+      if (p2.isCancel(confirm3) || !confirm3) {
+        p2.outro(pc2.yellow("Operation cancelled"));
+        process.exit(0);
+      }
+    }
+    await writeFile2(fullPath, configContent, "utf8");
+    p2.log.success(pc2.green(`Wrote configuration to ${fullPath}`));
+  }
+  p2.outro(pc2.green("Pull complete! \u2728"));
+}
+
+// src/commands/diff.ts
+import * as p4 from "@clack/prompts";
+import pc4 from "picocolors";
+
+// src/lib/diff.ts
+import pc3 from "picocolors";
+import * as p3 from "@clack/prompts";
+function normalizeFeature(pf) {
+  return {
+    slug: pf.slug,
+    enabled: pf.enabled,
+    limit: pf.limit ?? null,
+    // Handle both SDK 'reset' and API 'resetInterval'
+    reset: pf.reset || pf.resetInterval || "monthly",
+    // Handle both SDK 'overage' and API 'overage' (same name)
+    overage: pf.overage || "block",
+    overagePrice: pf.overagePrice ?? null
+  };
+}
+function normalizePlan(plan) {
+  return {
+    slug: plan.slug,
+    name: plan.name ?? null,
+    description: plan.description ?? null,
+    price: plan.price ?? 0,
+    currency: plan.currency ?? null,
+    interval: plan.interval ?? null,
+    planGroup: plan.planGroup ?? null,
+    trialDays: plan.trialDays ?? 0,
+    features: (plan.features || []).map(normalizeFeature).sort((a, b) => a.slug.localeCompare(b.slug))
+  };
+}
+function diffPlans(localPlans, remotePlans) {
+  const localMap = /* @__PURE__ */ new Map();
+  const remoteMap = /* @__PURE__ */ new Map();
+  for (const p9 of localPlans) localMap.set(p9.slug, normalizePlan(p9));
+  for (const p9 of remotePlans) remoteMap.set(p9.slug, normalizePlan(p9));
+  const onlyLocal = [];
+  const onlyRemote = [];
+  const changed = [];
+  for (const slug of localMap.keys()) {
+    if (!remoteMap.has(slug)) onlyLocal.push(slug);
+  }
+  for (const slug of remoteMap.keys()) {
+    if (!localMap.has(slug)) onlyRemote.push(slug);
+  }
+  for (const slug of localMap.keys()) {
+    if (!remoteMap.has(slug)) continue;
+    const local = localMap.get(slug);
+    const remote = remoteMap.get(slug);
+    const details = [];
+    const fields = [
+      "name",
+      "description",
+      "price",
+      "currency",
+      "interval",
+      "planGroup",
+      "trialDays"
+    ];
+    for (const field of fields) {
+      if (local[field] !== remote[field]) {
+        const localVal = JSON.stringify(local[field]);
+        const remoteVal = JSON.stringify(remote[field]);
+        details.push(
+          `${String(field)}: ${pc3.green(localVal)} \u2192 ${pc3.red(remoteVal)}`
+        );
+      }
+    }
+    const localFeatures = new Map(local.features.map((f) => [f.slug, f]));
+    const remoteFeatures = new Map(
+      remote.features.map((f) => [f.slug, f])
+    );
+    for (const fslug of localFeatures.keys()) {
+      if (!remoteFeatures.has(fslug)) {
+        details.push(`feature ${fslug}: ${pc3.green("[local only]")}`);
+        continue;
+      }
+      const lf = localFeatures.get(fslug);
+      const rf = remoteFeatures.get(fslug);
+      if (JSON.stringify(lf) !== JSON.stringify(rf)) {
+        details.push(`feature ${fslug}:`);
+        details.push(`  ${pc3.green(JSON.stringify(lf))}`);
+        details.push(`  ${pc3.red(JSON.stringify(rf))}`);
+      }
+    }
+    for (const fslug of remoteFeatures.keys()) {
+      if (!localFeatures.has(fslug)) {
+        details.push(`feature ${fslug}: ${pc3.red("[remote only]")}`);
+      }
+    }
+    if (details.length > 0) {
+      changed.push({ slug, details });
+    }
+  }
+  return { onlyLocal, onlyRemote, changed };
+}
+function printDiff(diff) {
+  if (diff.onlyLocal.length === 0 && diff.onlyRemote.length === 0 && diff.changed.length === 0) {
+    p3.log.success(pc3.green("No differences found."));
+    return;
+  }
+  if (diff.onlyLocal.length > 0) {
+    p3.note(
+      diff.onlyLocal.map((slug) => `${pc3.green("+")} ${slug}`).join("\n"),
+      "Only in Local"
+    );
+  }
+  if (diff.onlyRemote.length > 0) {
+    p3.note(
+      diff.onlyRemote.map((slug) => `${pc3.red("-")} ${slug}`).join("\n"),
+      "Only in Remote"
+    );
+  }
+  if (diff.changed.length > 0) {
+    let changedText = "";
+    for (const item of diff.changed) {
+      changedText += `
+${pc3.bold(item.slug)}
+`;
+      for (const line of item.details) {
+        changedText += `  ${line}
+`;
+      }
+    }
+    p3.note(changedText.trim(), "Changed Plans");
+  }
+  const summary = [
+    diff.onlyLocal.length > 0 ? `${pc3.green(diff.onlyLocal.length.toString())} added` : "",
+    diff.onlyRemote.length > 0 ? `${pc3.red(diff.onlyRemote.length.toString())} removed` : "",
+    diff.changed.length > 0 ? `${pc3.yellow(diff.changed.length.toString())} changed` : ""
+  ].filter(Boolean).join("  ");
+  p3.log.info(summary);
+}
+
+// src/commands/diff.ts
+async function runDiff(options) {
+  p4.intro(pc4.bgYellow(pc4.black(" diff ")));
+  const fullPath = resolveConfigPath(options.config);
+  const apiKey = getApiKey(options.key);
+  const configSettings = await loadConfigSettings(options.config);
+  const baseUrl = getApiUrl(configSettings.apiUrl);
+  const s = p4.spinner();
+  if (options.prod) {
+    p4.log.step(pc4.magenta("Production Mode: Comparing both environments"));
+    const testUrl = getTestApiUrl(configSettings.environments?.test);
+    const liveUrl = getApiUrl(configSettings.environments?.live);
+    s.start("Loading local configuration...");
+    const owo = await loadOwostackFromConfig(fullPath);
+    s.stop("Configuration loaded");
+    const { buildSyncPayload } = await import("owostack").catch(() => ({
+      buildSyncPayload: null
+    }));
+    const localPayload = buildSyncPayload(owo._config.catalog);
+    p4.log.step(pc4.cyan(`Comparing with TEST: ${testUrl}`));
+    const testPlans = await fetchPlans({ apiKey, apiUrl: `${testUrl}/api/v1` });
+    printDiff(diffPlans(localPayload?.plans ?? [], testPlans));
+    p4.log.step(pc4.cyan(`Comparing with LIVE: ${liveUrl}`));
+    const livePlans = await fetchPlans({ apiKey, apiUrl: `${liveUrl}/api/v1` });
+    printDiff(diffPlans(localPayload?.plans ?? [], livePlans));
+  } else {
+    s.start("Loading local configuration...");
+    const owo = await loadOwostackFromConfig(fullPath);
+    s.stop("Configuration loaded");
+    const { buildSyncPayload } = await import("owostack").catch(() => ({
+      buildSyncPayload: null
+    }));
+    const localPayload = buildSyncPayload(owo._config.catalog);
+    s.start(`Fetching remote plans from ${pc4.dim(baseUrl)}...`);
+    const remotePlans = await fetchPlans({
+      apiKey,
+      apiUrl: `${baseUrl}/api/v1`
+    });
+    s.stop("Remote plans fetched");
+    printDiff(diffPlans(localPayload?.plans ?? [], remotePlans));
+  }
+  p4.outro(pc4.green("Diff complete \u2728"));
+}
+
+// src/commands/init.ts
+import * as p6 from "@clack/prompts";
+import pc6 from "picocolors";
+import { existsSync as existsSync4 } from "fs";
+import { writeFile as writeFile3 } from "fs/promises";
+
+// src/lib/connect.ts
+import * as p5 from "@clack/prompts";
+import pc5 from "picocolors";
+async function initiateDeviceFlow(options) {
+  const url = `${options.apiUrl}/api/auth/cli/device`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" }
+  });
+  const data = await response.json();
+  if (!response.ok || !data?.success) {
+    const message = data?.error || data?.message || "Failed to initiate device flow";
+    throw new Error(message);
+  }
+  return {
+    deviceCode: data.deviceCode,
+    userCode: data.userCode,
+    expiresIn: data.expiresIn || 300
+  };
+}
+async function pollForToken(deviceCode, options, s) {
+  const startTime = Date.now();
+  const timeoutMs = options.timeout * 1e3;
+  const pollInterval = 3e3;
+  while (Date.now() - startTime < timeoutMs) {
+    const url = `${options.apiUrl}/api/auth/cli/token?deviceCode=${deviceCode}`;
+    const response = await fetch(url, { method: "GET" });
+    const data = await response.json();
+    if (data?.success && data?.apiKey) {
+      return {
+        success: true,
+        apiKey: data.apiKey,
+        organizationId: data.organizationId
+      };
+    }
+    if (data?.error === "expired") {
+      throw new Error("Device code expired. Please try again.");
+    }
+    if (data?.error === "denied") {
+      throw new Error("Connection was denied by user.");
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+  }
+  throw new Error("Connection timed out. Please try again.");
+}
+async function executeConnectFlow(options) {
+  try {
+    const deviceCode = await initiateDeviceFlow(options);
+    const authUrl = `${options.dashboardUrl}/cli/connect?code=${deviceCode.userCode}`;
+    p5.log.step(pc5.bold("Connect to your dashboard:"));
+    p5.log.message(`${pc5.cyan(pc5.underline(authUrl))}
+`);
+    const shouldOpen = !options.noBrowser;
+    if (shouldOpen) {
+      try {
+        const { exec } = await import("child_process");
+        const platform = process.platform;
+        const cmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+        exec(`${cmd} "${authUrl}"`);
+      } catch {
+      }
+    }
+    const s = p5.spinner();
+    s.start(
+      `Waiting for you to approve in the dashboard (Code: ${pc5.bold(pc5.yellow(deviceCode.userCode))})`
+    );
+    const result = await pollForToken(deviceCode.deviceCode, options, s);
+    s.stop(pc5.green("Authorization granted"));
+    if (result.success && result.apiKey) {
+      await saveGlobalConfig({
+        apiKey: result.apiKey,
+        organizationId: result.organizationId
+      });
+      return result.apiKey;
+    }
+  } catch (e) {
+    p5.log.error(pc5.red(`\u2717 ${e.message}`));
+  }
+  return null;
+}
+
+// src/commands/init.ts
+async function runInit(options) {
+  p6.intro(pc6.bgYellow(pc6.black(" init ")));
+  const fullPath = resolveConfigPath(options.config);
+  let apiKey = getApiKey(options.key);
+  if (!apiKey) {
+    p6.log.warn(
+      pc6.yellow("No API key found. Let's connect your account first.")
+    );
+    apiKey = await executeConnectFlow({
+      apiUrl: getApiUrl(),
+      dashboardUrl: getDashboardUrl(),
+      noBrowser: false,
+      timeout: 300
+    }) || "";
+    if (!apiKey) {
+      p6.log.error(pc6.red("Could not obtain API key. Initialization aborted."));
+      process.exit(1);
+    }
+  }
+  if (existsSync4(fullPath) && !options.force) {
+    const confirm3 = await p6.confirm({
+      message: `Config file already exists at ${fullPath}. Overwrite?`,
+      initialValue: false
+    });
+    if (p6.isCancel(confirm3) || !confirm3) {
+      p6.outro(pc6.yellow("Initialization cancelled"));
+      process.exit(0);
+    }
+  }
+  const s = p6.spinner();
+  s.start("Generating project configuration...");
+  try {
+    const plans = await fetchPlans({ apiKey, apiUrl: `${getApiUrl()}/api/v1` });
+    const creditSystems = await fetchCreditSystems(
+      apiKey,
+      `${getApiUrl()}/api/v1`
+    );
+    const configContent = generateConfig(plans, creditSystems);
+    await writeFile3(fullPath, configContent, "utf8");
+    s.stop(pc6.green("Configuration created"));
+    p6.note(
+      `${pc6.dim("File:")} ${fullPath}
+${pc6.dim("Plans:")} ${plans.length} imported
+${pc6.dim("Credit Systems:")} ${creditSystems.length}`,
+      "\u2728 Project Initialized"
+    );
+    p6.outro(
+      pc6.cyan(
+        `Next step: Run ${pc6.bold("owostack sync")} to apply your catalog.`
+      )
+    );
+  } catch (e) {
+    s.stop(pc6.red("Initialization failed"));
+    p6.log.error(e.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/validate.ts
+import * as p7 from "@clack/prompts";
+import pc7 from "picocolors";
+async function runValidate(options) {
+  p7.intro(pc7.bgYellow(pc7.black(" validate ")));
+  const fullPath = resolveConfigPath(options.config);
+  const s = p7.spinner();
+  s.start(`Loading ${pc7.cyan(options.config)}`);
+  const owo = await loadOwostackFromConfig(fullPath);
+  if (!owo || typeof owo.sync !== "function") {
+    s.stop(pc7.red("Invalid configuration"));
+    p7.log.error("Config file must export an Owostack instance.");
+    process.exit(1);
+  }
+  if (!owo._config?.catalog || owo._config.catalog.length === 0) {
+    s.stop(pc7.red("No catalog found"));
+    p7.log.error("Config has no catalog to validate.");
+    process.exit(1);
+  }
+  s.stop(
+    pc7.green(`Configuration loaded (${owo._config.catalog.length} entries)`)
+  );
+  const { buildSyncPayload } = await import("owostack").catch(() => ({
+    buildSyncPayload: null
+  }));
+  if (!buildSyncPayload) {
+    p7.log.error("buildSyncPayload unavailable from owostack.");
+    process.exit(1);
+  }
+  try {
+    const payload = buildSyncPayload(owo._config.catalog);
+    p7.log.step(pc7.bold("Features"));
+    for (const f of payload.features) {
+      p7.log.message(`${pc7.green("\u2713")} ${f.slug} ${pc7.dim(`(${f.type})`)}`);
+    }
+    p7.log.step(pc7.bold("Plans"));
+    for (const p_obj of payload.plans) {
+      p7.log.message(
+        `${pc7.green("\u2713")} ${pc7.bold(p_obj.slug)} ${pc7.dim(`${p_obj.currency} ${p_obj.price} / ${p_obj.interval}`)}`
+      );
+    }
+    if (options.prod) {
+      p7.log.step(pc7.magenta("Production Mode Check"));
+      const configSettings = await loadConfigSettings(options.config);
+      const testUrl = getTestApiUrl(configSettings.environments?.test);
+      const liveUrl = getApiUrl(configSettings.environments?.live);
+      const apiKey = getApiKey();
+      try {
+        const testPlans = await fetchPlans({
+          apiKey,
+          apiUrl: `${testUrl}/api/v1`
+        });
+        p7.log.success(
+          `TEST environment accessible (${testPlans.length} remote plans)`
+        );
+      } catch (e) {
+        p7.log.error(`TEST environment check failed: ${e.message}`);
+      }
+      try {
+        const livePlans = await fetchPlans({
+          apiKey,
+          apiUrl: `${liveUrl}/api/v1`
+        });
+        p7.log.success(
+          `LIVE environment accessible (${livePlans.length} remote plans)`
+        );
+      } catch (e) {
+        p7.log.error(`LIVE environment check failed: ${e.message}`);
+      }
+    }
+    p7.outro(pc7.green("Validation passed! \u2728"));
+  } catch (e) {
+    p7.log.error(`Validation failed: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/connect.ts
+import * as p8 from "@clack/prompts";
+import pc8 from "picocolors";
+import { existsSync as existsSync5 } from "fs";
+async function runConnect(options) {
+  p8.intro(pc8.bgYellow(pc8.black(" connect ")));
+  const configPath = "./owo.config.ts";
+  let apiUrl = getApiUrl();
+  let dashboardUrl = getDashboardUrl();
+  let noBrowser = options.browser === false;
+  if (existsSync5(resolveConfigPath(configPath))) {
+    const configSettings = await loadConfigSettings(configPath);
+    if (configSettings.connect?.dashboardUrl) {
+      dashboardUrl = getDashboardUrl(configSettings.connect.dashboardUrl);
+    }
+    if (configSettings.apiUrl) {
+      apiUrl = getApiUrl(configSettings.apiUrl);
+    }
+  }
+  const apiKey = await executeConnectFlow({
+    apiUrl,
+    dashboardUrl,
+    noBrowser,
+    timeout: 300
+  });
+  if (apiKey) {
+    p8.note(
+      `${pc8.dim("API Key:")} owo_***
+${pc8.dim("Config:")} ${GLOBAL_CONFIG_PATH}`,
+      "Connected successfully!"
+    );
+    p8.outro(pc8.green("Authentication complete \u2728"));
+  } else {
+    p8.log.error(pc8.red("Connection failed. Please try again."));
+    process.exit(1);
+  }
+}
+
+// src/lib/brand.ts
+import pc9 from "picocolors";
+var OWO_ASCII = `
+   ${pc9.yellow("\u2588\u2588\u2588\u2588\u2588\u2588\u2557")}  ${pc9.white("\u2588\u2588\u2557    \u2588\u2588\u2557")}  ${pc9.yellow("\u2588\u2588\u2588\u2588\u2588\u2588\u2557")}      
+  ${pc9.yellow("\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557")} ${pc9.white("\u2588\u2588\u2551    \u2588\u2588\u2551")} ${pc9.yellow("\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557")}     
+  ${pc9.yellow("\u2588\u2588\u2551   \u2588\u2588\u2551")} ${pc9.white("\u2588\u2588\u2551 \u2588\u2557 \u2588\u2588\u2551")} ${pc9.yellow("\u2588\u2588\u2551   \u2588\u2588\u2551")}     
+  ${pc9.yellow("\u2588\u2588\u2551   \u2588\u2588\u2551")} ${pc9.white("\u2588\u2588\u2551\u2588\u2588\u2588\u2557\u2588\u2588\u2551")} ${pc9.yellow("\u2588\u2588\u2551   \u2588\u2588\u2551")}     
+  ${pc9.yellow("\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D")} ${pc9.white("\u255A\u2588\u2588\u2588\u2554\u2588\u2588\u2588\u2554\u255D")} ${pc9.yellow("\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D")}     
+   ${pc9.yellow("\u255A\u2550\u2550\u2550\u2550\u2550\u255D")}   ${pc9.white("\u255A\u2550\u2550\u255D\u255A\u2550\u2550\u255D")}   ${pc9.yellow("\u255A\u2550\u2550\u2550\u2550\u2550\u255D")}
+`;
+function printBrand() {
+  console.log(OWO_ASCII);
+}
+
+// src/index.ts
+var program = new Command();
+printBrand();
+program.name("owostack").description("CLI for Owostack billing infrastructure").version("0.1.0");
+program.command("sync").description("Push catalog to the API").option("--config <path>", "Path to config file", "./owo.config.ts").option("--key <api-key>", "API secret key").option("--prod", "Execute in both test and live environments").option("--dry-run", "Show what would change without applying").action(runSync);
+program.command("pull").description("Pull plans from dashboard into owo.config.ts").option("--config <path>", "Path to config file", "./owo.config.ts").option("--key <api-key>", "API secret key").option("--force", "Overwrite existing config file", false).option("--prod", "Execute in both test and live environments").option("--dry-run", "Show what would change without applying").action(runPull);
+program.command("diff").description("Compare local config to dashboard plans").option("--config <path>", "Path to config file", "./owo.config.ts").option("--key <api-key>", "API secret key").option("--prod", "Execute in both test and live environments").action(runDiff);
+program.command("init").description("Initialize owo.config.ts from dashboard").option("--config <path>", "Path to config file", "./owo.config.ts").option("--key <api-key>", "API secret key").option("--force", "Overwrite existing config file", false).action(runInit);
+program.command("validate").description("Validate local config without syncing").option("--config <path>", "Path to config file", "./owo.config.ts").option("--prod", "Execute in both test and live environments").action(runValidate);
+program.command("connect").description("Connect CLI to dashboard via browser").option("--no-browser", "Don't open the browser automatically").action(runConnect);
+program.parse();

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "owosk",
+  "version": "0.1.0",
+  "description": "CLI for Owostack - sync catalog, manage billing infrastructure",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Abdulmumin1/owostack.git",
+    "directory": "packages/cli"
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "owostack": "./dist/index.js",
+    "owo": "./dist/index.js",
+    "owos": "./dist/index.js",
+    "owon": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --clean",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "start": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.0.1",
+    "owostack": "workspace:*",
+    "@owostack/types": "workspace:*",
+    "commander": "^14.0.3",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.10",
+    "tsup": "^8.5.1",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}