@ollie-shop/cli 1.0.2 → 1.2.1

package/dist/index.js

@@ -21,49 +21,108 @@ function HelpCommand() {
       "<command>",
       " [options]"
     ] }) }),
-    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, children: "Commands:" }) }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, children: "Interactive Commands:" }) }),
     /* @__PURE__ */ jsxs(Box, { marginLeft: 2, flexDirection: "column", gap: 0, children: [
       /* @__PURE__ */ jsxs(Box, { children: [
-        /* @__PURE__ */ jsx(Box, { width: 16, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "login" }) }),
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "login" }) }),
         /* @__PURE__ */ jsx(Text, { children: "Authenticate with your Ollie Shop account" })
       ] }),
       /* @__PURE__ */ jsxs(Box, { children: [
-        /* @__PURE__ */ jsx(Box, { width: 16, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "start" }) }),
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "start" }) }),
         /* @__PURE__ */ jsx(Text, { children: "Start the development server with hot reload" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, children: "Agent Commands:" }) }),
+    /* @__PURE__ */ jsxs(Box, { marginLeft: 2, flexDirection: "column", gap: 0, children: [
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "whoami" }) }),
+        /* @__PURE__ */ jsx(Text, { children: "Show current user and organization" })
+      ] }),
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "store create|list" }) }),
+        /* @__PURE__ */ jsx(Text, { children: "Create or list stores" })
+      ] }),
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "version create|list" }) }),
+        /* @__PURE__ */ jsx(Text, { children: "Create or list versions" })
+      ] }),
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "component create|list" }) }),
+        /* @__PURE__ */ jsx(Text, { children: "Create or list components" })
+      ] }),
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "deploy" }) }),
+        /* @__PURE__ */ jsx(Text, { children: "Bundle and upload a component/function build" })
       ] }),
       /* @__PURE__ */ jsxs(Box, { children: [
-        /* @__PURE__ */ jsx(Box, { width: 16, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "help" }) }),
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "status" }) }),
+        /* @__PURE__ */ jsx(Text, { children: "Check or poll a build status" })
+      ] }),
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "schema" }) }),
+        /* @__PURE__ */ jsx(Text, { children: "Introspect resource schemas (JSON Schema)" })
+      ] }),
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "init" }) }),
+        /* @__PURE__ */ jsx(Text, { children: "Write store/version IDs to ollie.json" })
+      ] }),
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "help" }) }),
         /* @__PURE__ */ jsx(Text, { children: "Show this help message" })
       ] }),
       /* @__PURE__ */ jsxs(Box, { children: [
-        /* @__PURE__ */ jsx(Box, { width: 16, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "version" }) }),
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "version" }) }),
         /* @__PURE__ */ jsx(Text, { children: "Show CLI version" })
       ] })
     ] }),
-    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, children: "Start Options:" }) }),
-    /* @__PURE__ */ jsx(Box, { marginLeft: 2, flexDirection: "column", gap: 0, children: /* @__PURE__ */ jsxs(Box, { children: [
-      /* @__PURE__ */ jsx(Box, { width: 20, children: /* @__PURE__ */ jsx(Text, { color: "yellow", children: "--stage, -s" }) }),
-      /* @__PURE__ */ jsxs(Text, { children: [
-        "Config stage (loads ollie.",
-        "{stage}",
-        ".json)"
-      ] })
-    ] }) }),
-    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, children: "Configuration:" }) }),
-    /* @__PURE__ */ jsxs(Box, { marginLeft: 2, flexDirection: "column", children: [
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "ollie.json - Default config (prod)" }),
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "ollie.dev.json - Dev stage config" }),
-      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-        "ollie.",
-        "{stage}",
-        ".json - Custom stage config"
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, children: "Global Flags:" }) }),
+    /* @__PURE__ */ jsxs(Box, { marginLeft: 2, flexDirection: "column", gap: 0, children: [
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "yellow", children: "--output json, -o json" }) }),
+        /* @__PURE__ */ jsx(Text, { children: "Force JSON output (auto when piped)" })
+      ] }),
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "yellow", children: "--dry-run" }) }),
+        /* @__PURE__ */ jsx(Text, { children: "Validate without executing mutations" })
+      ] }),
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "yellow", children: "--fields a,b,c" }) }),
+        /* @__PURE__ */ jsx(Text, { children: "Limit output fields" })
+      ] }),
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+          "--data ",
+          `'{...}'`
+        ] }) }),
+        /* @__PURE__ */ jsx(Text, { children: "Raw JSON payload for mutations" })
+      ] }),
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "yellow", children: "--stage, -s" }) }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          "Config stage (loads ollie.",
+          "{stage}",
+          ".json)"
+        ] })
       ] })
     ] }),
     /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, children: "Examples:" }) }),
     /* @__PURE__ */ jsxs(Box, { marginLeft: 2, flexDirection: "column", children: [
       /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop login" }),
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop start" }),
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop start --stage dev" })
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop start --stage dev" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop whoami -o json" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop schema store.create" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: '$ ollieshop store create --name "My Store" --platform vtex --platform-store-id mystore' }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "$ ollieshop store create --data",
+        " ",
+        `'{"name":"My Store","platform":"vtex","platformStoreId":"mystore"}'`,
+        " ",
+        "-o json"
+      ] }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop version create --store-id UUID --name v1 --active" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop init --store-id UUID --version-id UUID" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop deploy --component-id UUID --name FreeShippingBar --wait" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop status --build-id BUILD_ID --wait -o json" })
     ] })
   ] });
 }
@@ -227,14 +286,32 @@ async function saveCredentials(token) {
   };
   await fs.writeFile(CREDENTIALS_PATH, JSON.stringify(credentials, null, 2));
 }
+async function getCredentials() {
+  try {
+    const content = await fs.readFile(CREDENTIALS_PATH, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function getCurrentUser() {
+  const credentials = await getCredentials();
+  if (!credentials) return null;
+  try {
+    const decoded = jwtDecode(credentials.accessToken);
+    return decoded.email ? { email: decoded.email } : null;
+  } catch {
+    return null;
+  }
+}
 
 // src/commands/login.tsx
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
-function LoginCommand({ args: args2 }) {
+function LoginCommand({ args }) {
   const { exit } = useApp();
   const [state, setState] = useState({ status: "idle" });
-  const portIndex = args2.findIndex((a) => a === "--port" || a === "-p");
-  const port = portIndex !== -1 ? Number.parseInt(args2[portIndex + 1], 10) : 7777;
+  const portIndex = args.findIndex((a) => a === "--port" || a === "-p");
+  const port = portIndex !== -1 ? Number.parseInt(args[portIndex + 1], 10) : 7777;
   useEffect(() => {
     if (state.status !== "idle") return;
     setState({ status: "waiting" });
@@ -341,6 +418,17 @@ async function loadConfig(options = {}) {
   };
   return OllieConfigSchema.parse(merged);
 }
+async function saveConfig(config, options = {}) {
+  const { cwd = process.cwd(), stage } = options;
+  const fileName = getConfigFileName(stage);
+  const configPath = path2.join(cwd, fileName);
+  const existing = await loadConfigFile(configPath);
+  const merged = {
+    ...existing,
+    ...config
+  };
+  await fs2.writeFile(configPath, JSON.stringify(merged, null, 2));
+}
 function resolveStage(cliStage) {
   return cliStage || process.env.OLLIE_STAGE || void 0;
 }
@@ -764,11 +852,11 @@ import { Fragment, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 var STUDIO_BASE_URL = "https://admin.ollie.shop/studio";
 var MAX_LOGS = 10;
 var PORT = 4e3;
-function parseArg(args2, ...flags) {
-  const index = args2.findIndex((a) => flags.includes(a));
-  return index !== -1 ? args2[index + 1] : void 0;
+function parseArg(args, ...flags) {
+  const index = args.findIndex((a) => flags.includes(a));
+  return index !== -1 ? args[index + 1] : void 0;
 }
-function StartCommand({ args: args2 }) {
+function StartCommand({ args }) {
   const { exit } = useApp2();
   const [state, setState] = useState2({ status: "initializing" });
   const [components, setComponents] = useState2([]);
@@ -778,7 +866,7 @@ function StartCommand({ args: args2 }) {
   const logIdRef = useRef(0);
   const ctxRef = useRef(null);
   const stopRef = useRef(null);
-  const stage = resolveStage(parseArg(args2, "--stage", "-s"));
+  const stage = resolveStage(parseArg(args, "--stage", "-s"));
   const addLog = useCallback((log) => {
     setLogs((prev) => {
       const newLog = {
@@ -790,12 +878,12 @@ function StartCommand({ args: args2 }) {
     });
   }, []);
   const handleRequest = useCallback(
-    (args3) => {
+    (args2) => {
       addLog({
-        method: args3.method,
-        path: args3.path,
-        status: args3.status,
-        time: args3.timeInMS
+        method: args2.method,
+        path: args2.path,
+        status: args2.status,
+        time: args2.timeInMS
       });
     },
     [addLog]
@@ -1065,12 +1153,12 @@ function Footer() {
 
 // src/cli.tsx
 import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
-function App({ command: command2, args: args2 }) {
-  switch (command2) {
+function App({ command, args }) {
+  switch (command) {
     case "login":
-      return /* @__PURE__ */ jsx4(LoginCommand, { args: args2 });
+      return /* @__PURE__ */ jsx4(LoginCommand, { args });
     case "start":
-      return /* @__PURE__ */ jsx4(StartCommand, { args: args2 });
+      return /* @__PURE__ */ jsx4(StartCommand, { args });
     case "help":
     case "--help":
     case "-h":
@@ -1080,25 +1168,1230 @@ function App({ command: command2, args: args2 }) {
     case "-v":
       return /* @__PURE__ */ jsx4(VersionCommand, {});
     default:
-      return /* @__PURE__ */ jsx4(UnknownCommand, { command: command2 });
+      return /* @__PURE__ */ jsx4(UnknownCommand, { command });
   }
 }
 function VersionCommand() {
   return /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsx4(Text4, { children: "ollie v0.1.0" }) });
 }
-function UnknownCommand({ command: command2 }) {
+function UnknownCommand({ command }) {
   return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", gap: 1, children: [
     /* @__PURE__ */ jsxs4(Text4, { color: "red", children: [
       "Unknown command: ",
-      command2
+      command
     ] }),
     /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Run `ollie help` for available commands." })
   ] });
 }
 
+// src/core/business-rule.ts
+var SELECT_FIELDS = "id, store_id, title, content, previous_content, versions_ids, components_ids, functions_ids, status, code_updated, created_at, updated_at";
+async function listBusinessRules(client, filters = {}) {
+  let query = client.from("business_rules").select(SELECT_FIELDS).order("created_at", { ascending: false });
+  if (filters.store_id !== void 0) {
+    query = query.eq("store_id", filters.store_id);
+  }
+  if (filters.version_id !== void 0) {
+    query = query.filter(
+      "versions_ids",
+      "cs",
+      JSON.stringify([filters.version_id])
+    );
+  }
+  if (filters.code_updated !== void 0) {
+    query = query.eq("code_updated", filters.code_updated);
+  }
+  const { data, error } = await query;
+  if (error) {
+    return { error: { message: error.message } };
+  }
+  return { data };
+}
+async function getBusinessRule(client, id) {
+  const { data, error } = await client.from("business_rules").select(SELECT_FIELDS).eq("id", id).single();
+  if (error) {
+    return { error: { message: error.message } };
+  }
+  return { data };
+}
+async function updateBusinessRule(client, id, input) {
+  const { data: current, error: fetchError } = await client.from("business_rules").select("content").eq("id", id).single();
+  if (fetchError) {
+    return { error: { message: fetchError.message } };
+  }
+  const updatePayload = {
+    previous_content: current.content,
+    content: input.content,
+    code_updated: false
+  };
+  if (input.versions_ids !== void 0) {
+    updatePayload.versions_ids = input.versions_ids;
+  }
+  if (input.components_ids !== void 0) {
+    updatePayload.components_ids = input.components_ids;
+  }
+  if (input.functions_ids !== void 0) {
+    updatePayload.functions_ids = input.functions_ids;
+  }
+  const { data, error } = await client.from("business_rules").update(updatePayload).eq("id", id).select("id").single();
+  if (error) {
+    return { error: { message: error.message } };
+  }
+  return { data: { id: data.id } };
+}
+
+// src/utils/output.ts
+function detectOutputFormat(cliOutput) {
+  if (cliOutput === "json" || cliOutput === "j") return "json";
+  if (cliOutput === "pretty") return "pretty";
+  return process.stdout.isTTY ? "pretty" : "json";
+}
+function filterFields(data, fields) {
+  if (!fields || fields.length === 0) return data;
+  const result = {};
+  for (const field of fields) {
+    if (field in data) {
+      result[field] = data[field];
+    }
+  }
+  return result;
+}
+function outputResult(result, format, fields) {
+  if (format === "json") {
+    let output = result;
+    if (fields && result.data && typeof result.data === "object") {
+      if (Array.isArray(result.data)) {
+        output = {
+          ...result,
+          data: result.data.map(
+            (item) => filterFields(item, fields)
+          )
+        };
+      } else {
+        output = {
+          ...result,
+          data: filterFields(result.data, fields)
+        };
+      }
+    }
+    process.stdout.write(`${JSON.stringify(output)}
+`);
+    return;
+  }
+  if (result.error) {
+    const errMsg = typeof result.error === "object" && result.error !== null ? result.error.message || JSON.stringify(result.error) : String(result.error);
+    console.error(`\x1B[31mError:\x1B[0m ${errMsg}`);
+    return;
+  }
+  if (Array.isArray(result.data)) {
+    printTable(result.data, fields);
+  } else if (typeof result.data === "object" && result.data !== null) {
+    const filtered = fields ? filterFields(result.data, fields) : result.data;
+    for (const [key, value] of Object.entries(
+      filtered
+    )) {
+      console.log(`\x1B[1m${key}:\x1B[0m ${value}`);
+    }
+  } else {
+    console.log(result.data);
+  }
+}
+function printTable(rows, fields) {
+  if (rows.length === 0) {
+    console.log("(no results)");
+    return;
+  }
+  const keys = fields || Object.keys(rows[0]);
+  const widths = {};
+  for (const key of keys) {
+    widths[key] = key.length;
+    for (const row of rows) {
+      const val = String(row[key] ?? "");
+      widths[key] = Math.max(widths[key], val.length);
+    }
+    widths[key] = Math.min(widths[key], 40);
+  }
+  const header = keys.map((k) => k.padEnd(widths[k])).join("  ");
+  console.log(`\x1B[1m${header}\x1B[0m`);
+  console.log(keys.map((k) => "\u2500".repeat(widths[k])).join("\u2500\u2500"));
+  for (const row of rows) {
+    const line = keys.map(
+      (k) => String(row[k] ?? "").padEnd(widths[k]).slice(0, widths[k])
+    ).join("  ");
+    console.log(line);
+  }
+}
+function outputDryRun(action, data, format) {
+  if (format === "json") {
+    process.stdout.write(`${JSON.stringify({ dryRun: true, action, data })}
+`);
+  } else {
+    console.log(`\x1B[33m[dry-run]\x1B[0m Would execute: ${action}`);
+    for (const [key, value] of Object.entries(data)) {
+      console.log(`  ${key}: ${JSON.stringify(value)}`);
+    }
+  }
+}
+
+// src/utils/parse-args.ts
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const command = args[0] || "help";
+  const flags = {};
+  const positional = [];
+  let subcommand;
+  if (args[1] && !args[1].startsWith("-")) {
+    subcommand = args[1];
+  }
+  const startIdx = subcommand ? 2 : 1;
+  for (let i = startIdx; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = args[i + 1];
+      if (next && !next.startsWith("-")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else if (arg.startsWith("-") && arg.length === 2) {
+      const key = arg.slice(1);
+      const next = args[i + 1];
+      if (next && !next.startsWith("-")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  const global = {
+    output: flags.output || flags.o || void 0,
+    dryRun: flags["dry-run"] === true,
+    fields: flags.fields ? String(flags.fields).split(",").map((f) => f.trim()) : void 0,
+    data: flags.data || flags.d || void 0
+  };
+  return { command, subcommand, flags, global, positional };
+}
+function getFlag(flags, ...names) {
+  for (const name of names) {
+    const val = flags[name];
+    if (typeof val === "string") return val;
+  }
+  return void 0;
+}
+function getBoolFlag(flags, ...names) {
+  for (const name of names) {
+    if (flags[name] === true) return true;
+  }
+  return false;
+}
+
+// src/utils/supabase.ts
+import { createClient } from "@supabase/supabase-js";
+async function getAuthenticatedClient() {
+  const credentials = await getCredentials();
+  if (!credentials) {
+    throw new Error("Not authenticated. Run `ollieshop login` first.");
+  }
+  const supabaseUrl = process.env.OLLIE_SUPABASE_URL || "https://aazahtmqrhjqsyqoqdkm.supabase.co";
+  const supabaseAnonKey = process.env.OLLIE_SUPABASE_ANON_KEY || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImFhemFodG1xcmhqcXN5cW9xZGttIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDg2MzEwOTcsImV4cCI6MjA2NDIwNzA5N30.VuAbAyjDe0HcL09SZtQ-UmP1o7Z6qwGuOtvfFhnyAcM";
+  const client = createClient(supabaseUrl, supabaseAnonKey, {
+    auth: {
+      autoRefreshToken: false,
+      persistSession: false
+    }
+  });
+  await client.auth.setSession({
+    access_token: credentials.accessToken,
+    refresh_token: credentials.refreshToken
+  });
+  return client;
+}
+function getBuilderUrl() {
+  return process.env.OLLIE_BUILDER_URL || "";
+}
+async function getAuthToken() {
+  const credentials = await getCredentials();
+  if (!credentials) {
+    throw new Error("Not authenticated. Run `ollieshop login` first.");
+  }
+  return credentials.accessToken;
+}
+async function getOrganizationId(client) {
+  const { data: org, error } = await client.from("organizations").select("id").order("created_at", { ascending: true }).limit(1).maybeSingle();
+  if (error) {
+    throw new Error(`Failed to get organization: ${error.message}`);
+  }
+  if (!org) {
+    throw new Error(
+      "No organization found for your account. Create one at https://admin.ollie.shop"
+    );
+  }
+  return org.id;
+}
+
+// src/utils/validate.ts
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var CONTROL_CHAR_REGEX = /[\x00-\x1f\x7f]/;
+function validateUuid(value, name) {
+  if (!UUID_REGEX.test(value)) {
+    throw new Error(
+      `Invalid ${name}: "${value}". Must be a valid UUID (e.g. 7217542a-d7c6-40d3-a20e-db13b310a781).`
+    );
+  }
+  return value;
+}
+function rejectControlChars(value, name) {
+  if (CONTROL_CHAR_REGEX.test(value)) {
+    throw new Error(
+      `Invalid ${name}: contains control characters. Input must be printable text.`
+    );
+  }
+  return value;
+}
+function validateEnum(value, allowed, name) {
+  if (!allowed.includes(value)) {
+    throw new Error(
+      `Invalid ${name}: "${value}". Must be one of: ${allowed.join(", ")}`
+    );
+  }
+  return value;
+}
+function validateRequired(value, name) {
+  if (!value || value.trim() === "") {
+    throw new Error(`Missing required parameter: --${name}`);
+  }
+  return rejectControlChars(value.trim(), name);
+}
+
+// src/commands/business-rule-cmd.ts
+async function businessRuleCommand(parsed2) {
+  const sub = parsed2.subcommand;
+  if (sub === "list" || sub === "ls") return businessRuleListCommand(parsed2);
+  if (sub === "get") return businessRuleGetCommand(parsed2);
+  if (sub === "update") return businessRuleUpdateCommand(parsed2);
+  console.error(
+    `Unknown business-rule subcommand: ${sub}. Use: business-rule list | business-rule get | business-rule update`
+  );
+  process.exit(1);
+}
+async function businessRuleListCommand(parsed2) {
+  const format = detectOutputFormat(parsed2.global.output);
+  try {
+    const storeId = getFlag(parsed2.flags, "store-id");
+    const versionId = getFlag(parsed2.flags, "version-id");
+    const codeUpdatedRaw = parsed2.flags["code-updated"];
+    let codeUpdated;
+    if (codeUpdatedRaw === "true" || codeUpdatedRaw === true) {
+      codeUpdated = true;
+    } else if (codeUpdatedRaw === "false") {
+      codeUpdated = false;
+    }
+    if (storeId !== void 0) validateUuid(storeId, "store-id");
+    if (versionId !== void 0) validateUuid(versionId, "version-id");
+    const client = await getAuthenticatedClient();
+    const result = await listBusinessRules(client, {
+      store_id: storeId,
+      version_id: versionId,
+      code_updated: codeUpdated
+    });
+    outputResult(result, format, parsed2.global.fields);
+    if (result.error) process.exit(1);
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) }
+      },
+      format
+    );
+    process.exit(1);
+  }
+}
+async function businessRuleGetCommand(parsed2) {
+  const format = detectOutputFormat(parsed2.global.output);
+  try {
+    const id = validateUuid(
+      validateRequired(getFlag(parsed2.flags, "id"), "id"),
+      "id"
+    );
+    const client = await getAuthenticatedClient();
+    const result = await getBusinessRule(client, id);
+    outputResult(result, format, parsed2.global.fields);
+    if (result.error) process.exit(1);
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) }
+      },
+      format
+    );
+    process.exit(1);
+  }
+}
+async function businessRuleUpdateCommand(parsed2) {
+  const format = detectOutputFormat(parsed2.global.output);
+  try {
+    let id;
+    let input;
+    if (parsed2.global.data) {
+      const raw = JSON.parse(parsed2.global.data);
+      id = validateUuid(validateRequired(raw.id, "id"), "id");
+      input = {
+        content: validateRequired(raw.content, "content"),
+        versions_ids: raw.versionsIds ?? void 0,
+        components_ids: raw.componentsIds ?? void 0,
+        functions_ids: raw.functionsIds ?? void 0
+      };
+    } else {
+      id = validateUuid(
+        validateRequired(getFlag(parsed2.flags, "id"), "id"),
+        "id"
+      );
+      const versionsIdsRaw = getFlag(parsed2.flags, "versions-ids");
+      const componentsIdsRaw = getFlag(parsed2.flags, "components-ids");
+      const functionsIdsRaw = getFlag(parsed2.flags, "functions-ids");
+      input = {
+        content: validateRequired(
+          getFlag(parsed2.flags, "content", "c"),
+          "content"
+        ),
+        versions_ids: versionsIdsRaw ? JSON.parse(versionsIdsRaw) : void 0,
+        components_ids: componentsIdsRaw ? JSON.parse(componentsIdsRaw) : void 0,
+        functions_ids: functionsIdsRaw ? JSON.parse(functionsIdsRaw) : void 0
+      };
+    }
+    if (parsed2.global.dryRun) {
+      outputDryRun(
+        "business-rule.update",
+        { id, ...input },
+        format
+      );
+      return;
+    }
+    const client = await getAuthenticatedClient();
+    const result = await updateBusinessRule(client, id, input);
+    outputResult(result, format, parsed2.global.fields);
+    if (result.error) process.exit(1);
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) }
+      },
+      format
+    );
+    process.exit(1);
+  }
+}
+
+// src/core/schema.ts
+import { z as z2 } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+var PLATFORM_VENDORS = ["vtex", "shopify", "vnda", "custom"];
+var storeCreateSchema = z2.object({
+  name: z2.string().min(1).describe("Store display name"),
+  platform: z2.enum(PLATFORM_VENDORS).describe("E-commerce platform vendor"),
+  platformStoreId: z2.string().min(1).describe("Platform-specific store identifier (e.g. account name)"),
+  logo: z2.string().url().optional().describe("Store logo URL"),
+  settings: z2.string().optional().describe("JSON settings string")
+});
+var storeListSchema = z2.object({}).describe("No parameters required");
+var versionCreateSchema = z2.object({
+  storeId: z2.string().uuid().describe("Parent store UUID"),
+  name: z2.string().min(1).describe("Version name (e.g. v1, main)"),
+  active: z2.boolean().default(false).describe("Whether version is active"),
+  default: z2.boolean().default(false).describe("Whether this is the default version"),
+  template: z2.string().nullable().default(null).describe("Template name or null")
+});
+var versionListSchema = z2.object({
+  storeId: z2.string().uuid().describe("Store UUID to list versions for")
+});
+var componentCreateSchema = z2.object({
+  versionId: z2.string().uuid().describe("Parent version UUID"),
+  name: z2.string().min(1).describe("Component name (e.g. FreeShippingBar)"),
+  slot: z2.string().min(1).describe(
+    "Target slot (e.g. cart_header_full_page, shipping_address_details_form)"
+  ),
+  active: z2.boolean().default(true).describe("Whether component is active"),
+  props: z2.record(z2.unknown()).nullable().default(null).describe("Default component props as JSON object")
+});
+var componentListSchema = z2.object({
+  storeId: z2.string().uuid().describe("Store UUID"),
+  versionId: z2.string().uuid().optional().describe("Optional version UUID to filter by")
+});
+var functionCreateSchema = z2.object({
+  versionId: z2.string().uuid().describe("Parent version UUID"),
+  name: z2.string().min(1).describe("Function name"),
+  trigger: z2.string().min(1).describe("Function trigger (e.g. beforePayment, afterShipping)"),
+  active: z2.boolean().default(true).describe("Whether function is active")
+});
+var functionListSchema = z2.object({
+  versionId: z2.string().uuid().describe("Version UUID to list functions for")
+});
+var schemas = {
+  store: {
+    create: storeCreateSchema,
+    list: storeListSchema
+  },
+  version: {
+    create: versionCreateSchema,
+    list: versionListSchema
+  },
+  component: {
+    create: componentCreateSchema,
+    list: componentListSchema
+  },
+  function: {
+    create: functionCreateSchema,
+    list: functionListSchema
+  }
+};
+function getSchemaNames() {
+  const names = [];
+  for (const [resource, actions] of Object.entries(schemas)) {
+    names.push(resource);
+    for (const action of Object.keys(actions)) {
+      names.push(`${resource}.${action}`);
+    }
+  }
+  return names;
+}
+function getJsonSchema(name) {
+  const parts = name.split(".");
+  const resource = parts[0];
+  const action = parts[1];
+  if (!resource || !schemas[resource]) return null;
+  if (action) {
+    const schema = schemas[resource][action];
+    if (!schema) return null;
+    return zodToJsonSchema(schema, { name: `${resource}.${action}` });
+  }
+  const result = {};
+  for (const [actionName, schema] of Object.entries(schemas[resource])) {
+    result[actionName] = zodToJsonSchema(schema, {
+      name: `${resource}.${actionName}`
+    });
+  }
+  return result;
+}
+
+// src/core/component.ts
+async function createComponent(client, input) {
+  const parsed2 = componentCreateSchema.safeParse(input);
+  if (!parsed2.success) {
+    return {
+      error: { message: parsed2.error.issues.map((i) => i.message).join("; ") }
+    };
+  }
+  const { data, error } = await client.from("components").insert({
+    name: parsed2.data.name,
+    slot: parsed2.data.slot,
+    active: parsed2.data.active,
+    version_id: parsed2.data.versionId,
+    props: parsed2.data.props
+  }).select("id").single();
+  if (error) {
+    return { error: { message: error.message } };
+  }
+  return { data: { id: data.id } };
+}
+async function listComponents(client, storeId, versionId) {
+  let query = client.from("components").select(
+    "id, name, slot, active, version_id, props, created_at, versions!inner(id, name)"
+  ).eq("versions.store_id", storeId);
+  if (versionId) {
+    query = query.eq("versions.id", versionId);
+  }
+  const { data, error } = await query;
+  if (error) {
+    return { error: { message: error.message } };
+  }
+  return { data: data ?? [] };
+}
+
+// src/commands/component-cmd.ts
+async function componentCommand(parsed2) {
+  const sub = parsed2.subcommand;
+  if (sub === "create") return componentCreateCommand(parsed2);
+  if (sub === "list" || sub === "ls") return componentListCommand(parsed2);
+  console.error(
+    `Unknown component subcommand: ${sub}. Use: component create | component list`
+  );
+  process.exit(1);
+}
+async function componentCreateCommand(parsed2) {
+  const format = detectOutputFormat(parsed2.global.output);
+  try {
+    let input;
+    if (parsed2.global.data) {
+      const raw = JSON.parse(parsed2.global.data);
+      input = {
+        versionId: validateUuid(raw.versionId, "versionId"),
+        name: validateRequired(raw.name, "name"),
+        slot: validateRequired(raw.slot, "slot"),
+        active: raw.active ?? true,
+        props: raw.props ?? null
+      };
+    } else {
+      input = {
+        versionId: validateUuid(
+          validateRequired(getFlag(parsed2.flags, "version-id"), "version-id"),
+          "version-id"
+        ),
+        name: validateRequired(getFlag(parsed2.flags, "name", "n"), "name"),
+        slot: validateRequired(getFlag(parsed2.flags, "slot", "s"), "slot"),
+        active: getBoolFlag(parsed2.flags, "active") || !("active" in parsed2.flags),
+        props: null
+      };
+    }
+    if (parsed2.global.dryRun) {
+      outputDryRun(
+        "component.create",
+        input,
+        format
+      );
+      return;
+    }
+    const client = await getAuthenticatedClient();
+    const result = await createComponent(client, input);
+    outputResult(result, format, parsed2.global.fields);
+    if (result.error) process.exit(1);
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) }
+      },
+      format
+    );
+    process.exit(1);
+  }
+}
+async function componentListCommand(parsed2) {
+  const format = detectOutputFormat(parsed2.global.output);
+  try {
+    const storeId = validateUuid(
+      validateRequired(getFlag(parsed2.flags, "store-id"), "store-id"),
+      "store-id"
+    );
+    const versionId = getFlag(parsed2.flags, "version-id");
+    if (versionId) validateUuid(versionId, "version-id");
+    const client = await getAuthenticatedClient();
+    const result = await listComponents(client, storeId, versionId);
+    outputResult(result, format, parsed2.global.fields);
+    if (result.error) process.exit(1);
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) }
+      },
+      format
+    );
+    process.exit(1);
+  }
+}
+
+// src/core/deploy.ts
+async function uploadBuild(input) {
+  const builderUrl = getBuilderUrl();
+  const token = await getAuthToken();
+  const formData = new FormData();
+  formData.append(
+    "code",
+    new Blob([input.zipBuffer], { type: "application/zip" }),
+    "code.zip"
+  );
+  formData.append("type", input.type);
+  formData.append("resource_id", input.resourceId);
+  let response;
+  try {
+    response = await fetch(`${builderUrl}/`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`
+      },
+      body: formData
+    });
+  } catch (err) {
+    return {
+      success: false,
+      error: {
+        message: `Cannot reach builder at ${builderUrl}: ${err instanceof Error ? err.message : String(err)}`
+      }
+    };
+  }
+  const body = await response.json();
+  if (!response.ok || !body.success) {
+    const msg = body.error?.message || body.error?.type || `Builder returned ${response.status}`;
+    return { success: false, error: { message: msg } };
+  }
+  return { success: true, data: body.data };
+}
+async function fetchBuildStatus(buildId) {
+  const builderUrl = getBuilderUrl();
+  const token = await getAuthToken();
+  let response;
+  try {
+    response = await fetch(`${builderUrl}/${encodeURIComponent(buildId)}`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+  } catch (err) {
+    return {
+      success: false,
+      error: {
+        message: `Cannot reach builder at ${builderUrl}: ${err instanceof Error ? err.message : String(err)}`
+      }
+    };
+  }
+  const body = await response.json();
+  if (!response.ok || !body.success) {
+    const msg = body.error?.message || body.error?.type || `Builder returned ${response.status}`;
+    return { success: false, error: { message: msg } };
+  }
+  return { success: true, data: body.data };
+}
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "SUCCEEDED",
+  "FAILED",
+  "STOPPED",
+  "TIMED_OUT",
+  "FAULT"
+]);
+function isTerminalStatus(status) {
+  return TERMINAL_STATUSES.has(status);
+}
+async function pollBuildStatus(buildId, options = {}) {
+  const { intervalMs = 5e3, timeoutMs = 3e5, onPoll } = options;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const result = await fetchBuildStatus(buildId);
+    if (!result.success) {
+      return result;
+    }
+    if (onPoll) {
+      onPoll(result.data);
+    }
+    if (isTerminalStatus(result.data.status)) {
+      return result;
+    }
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) break;
+    await new Promise(
+      (resolve) => setTimeout(resolve, Math.min(intervalMs, remaining))
+    );
+  }
+  return {
+    success: false,
+    error: { message: `Build ${buildId} timed out after ${timeoutMs / 1e3}s` }
+  };
+}
+
+// src/commands/deploy-cmd.ts
+async function deployCommand(parsed2) {
+  const format = detectOutputFormat(parsed2.global.output);
+  try {
+    let resourceId;
+    let componentName;
+    let resourceType;
+    let wait;
+    let timeout;
+    if (parsed2.global.data) {
+      const raw = JSON.parse(parsed2.global.data);
+      resourceId = validateUuid(
+        raw.componentId || raw.functionId || raw.resourceId,
+        "componentId or functionId"
+      );
+      componentName = validateRequired(raw.name, "name");
+      resourceType = raw.type === "function" ? "function" : "component";
+      wait = raw.wait ?? false;
+      timeout = raw.timeout ?? 300;
+    } else {
+      const compId = getFlag(parsed2.flags, "component-id");
+      const funcId = getFlag(parsed2.flags, "function-id");
+      if (compId && funcId) {
+        throw new Error(
+          "Provide either --component-id or --function-id, not both."
+        );
+      }
+      if (compId) {
+        resourceId = validateUuid(compId, "component-id");
+        resourceType = "component";
+      } else if (funcId) {
+        resourceId = validateUuid(funcId, "function-id");
+        resourceType = "function";
+      } else {
+        throw new Error("Either --component-id or --function-id is required.");
+      }
+      componentName = validateRequired(
+        getFlag(parsed2.flags, "name", "n"),
+        "name"
+      );
+      wait = getBoolFlag(parsed2.flags, "wait");
+      timeout = Number(getFlag(parsed2.flags, "timeout") ?? "300");
+    }
+    const stream = await createComponentBundle({
+      componentName,
+      cwd: process.cwd()
+    });
+    const chunks = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const zipBuffer = Buffer.concat(chunks);
+    if (parsed2.global.dryRun) {
+      outputDryRun(
+        "deploy",
+        {
+          resourceId,
+          resourceType,
+          componentName,
+          bundleSizeBytes: zipBuffer.length,
+          bundleSizeKB: Math.round(zipBuffer.length / 1024),
+          wait,
+          timeout
+        },
+        format
+      );
+      return;
+    }
+    const uploadResult = await uploadBuild({
+      resourceId,
+      type: resourceType,
+      zipBuffer
+    });
+    if (!uploadResult.success) {
+      outputResult(uploadResult, format);
+      process.exit(1);
+    }
+    if (wait) {
+      const isJson = format === "json";
+      if (!isJson) {
+        process.stderr.write(
+          `Build ${uploadResult.data.id} started. Polling...
+`
+        );
+      }
+      const pollResult = await pollBuildStatus(uploadResult.data.id, {
+        timeoutMs: timeout * 1e3,
+        onPoll: (build) => {
+          if (!isJson) {
+            process.stderr.write(`  status: ${build.status}
+`);
+          }
+        }
+      });
+      outputResult(pollResult, format, parsed2.global.fields);
+      if (!pollResult.success) process.exit(1);
+      if (pollResult.success && isTerminalStatus(pollResult.data.status) && pollResult.data.status !== "SUCCEEDED") {
+        process.exit(1);
+      }
+    } else {
+      outputResult(uploadResult, format, parsed2.global.fields);
+    }
+  } catch (err) {
+    outputResult(
+      {
+        success: false,
+        error: { message: err instanceof Error ? err.message : String(err) }
+      },
+      format
+    );
+    process.exit(1);
+  }
+}
+
+// src/commands/init-cmd.ts
+async function initCommand(parsed2) {
+  const format = detectOutputFormat(parsed2.global.output);
+  try {
+    const storeId = validateUuid(
+      validateRequired(getFlag(parsed2.flags, "store-id"), "store-id"),
+      "store-id"
+    );
+    const versionIdRaw = getFlag(parsed2.flags, "version-id");
+    const versionId = versionIdRaw ? validateUuid(versionIdRaw, "version-id") : void 0;
+    const stage = getFlag(parsed2.flags, "stage", "s");
+    await saveConfig(
+      {
+        storeId,
+        ...versionId ? { versionId } : {}
+      },
+      { stage }
+    );
+    const fileName = stage && stage !== "prod" ? `ollie.${stage}.json` : "ollie.json";
+    outputResult(
+      {
+        data: {
+          file: fileName,
+          storeId,
+          ...versionId ? { versionId } : {}
+        }
+      },
+      format,
+      parsed2.global.fields
+    );
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) }
+      },
+      format
+    );
+    process.exit(1);
+  }
+}
+
+// src/commands/schema-cmd.ts
+async function schemaCommand(parsed2) {
+  const format = detectOutputFormat(parsed2.global.output);
+  const resourceName = parsed2.subcommand || parsed2.positional[0];
+  if (!resourceName) {
+    const names = getSchemaNames();
+    if (format === "json") {
+      process.stdout.write(`${JSON.stringify({ schemas: names })}
+`);
+    } else {
+      console.log("\x1B[1mAvailable schemas:\x1B[0m");
+      for (const name of names) {
+        const indent = name.includes(".") ? "    " : "  ";
+        console.log(`${indent}\x1B[32m${name}\x1B[0m`);
+      }
+      console.log("\nUsage: ollieshop schema <resource[.action]>");
+    }
+    return;
+  }
+  const schema = getJsonSchema(resourceName);
+  if (!schema) {
+    console.error(
+      `Unknown schema: ${resourceName}. Run \`ollieshop schema\` to see available schemas.`
+    );
+    process.exit(1);
+  }
+  process.stdout.write(`${JSON.stringify(schema, null, 2)}
+`);
+}
+
+// src/commands/status-cmd.ts
+async function statusCommand(parsed2) {
+  const format = detectOutputFormat(parsed2.global.output);
+  try {
+    let buildId;
+    let wait;
+    let timeout;
+    if (parsed2.global.data) {
+      const raw = JSON.parse(parsed2.global.data);
+      buildId = validateRequired(raw.buildId, "buildId");
+      wait = raw.wait ?? false;
+      timeout = raw.timeout ?? 300;
+    } else {
+      buildId = validateRequired(getFlag(parsed2.flags, "build-id"), "build-id");
+      wait = getBoolFlag(parsed2.flags, "wait");
+      timeout = Number(getFlag(parsed2.flags, "timeout") ?? "300");
+    }
+    if (wait) {
+      const isJson = format === "json";
+      if (!isJson) {
+        process.stderr.write(`Polling build ${buildId}...
+`);
+      }
+      const result = await pollBuildStatus(buildId, {
+        timeoutMs: timeout * 1e3,
+        onPoll: (build) => {
+          if (!isJson) {
+            process.stderr.write(`  status: ${build.status}
+`);
+          }
+        }
+      });
+      outputResult(result, format, parsed2.global.fields);
+      if (!result.success) process.exit(1);
+      if (result.success && isTerminalStatus(result.data.status) && result.data.status !== "SUCCEEDED") {
+        process.exit(1);
+      }
+    } else {
+      const result = await fetchBuildStatus(buildId);
+      outputResult(result, format, parsed2.global.fields);
+      if (!result.success) process.exit(1);
+    }
+  } catch (err) {
+    outputResult(
+      {
+        success: false,
+        error: { message: err instanceof Error ? err.message : String(err) }
+      },
+      format
+    );
+    process.exit(1);
+  }
+}
+
+// src/core/store.ts
+async function createStore(client, input) {
+  const parsed2 = storeCreateSchema.safeParse(input);
+  if (!parsed2.success) {
+    return {
+      error: { message: parsed2.error.issues.map((i) => i.message).join("; ") }
+    };
+  }
+  const organizationId = await getOrganizationId(client);
+  const { data, error } = await client.from("stores").insert({
+    name: parsed2.data.name,
+    platform: parsed2.data.platform,
+    platform_store_id: parsed2.data.platformStoreId,
+    organization_id: organizationId,
+    logo: parsed2.data.logo ?? null,
+    settings: parsed2.data.settings ?? null
+  }).select("id").single();
+  if (error) {
+    return { error: { message: error.message } };
+  }
+  return { data: { id: data.id } };
+}
+async function listStores(client) {
+  const organizationId = await getOrganizationId(client);
+  const { data, error } = await client.from("stores").select(
+    "id, name, platform, platform_store_id, organization_id, logo, settings, created_at"
+  ).eq("organization_id", organizationId).order("created_at", { ascending: false });
+  if (error) {
+    return { error: { message: error.message } };
+  }
+  return { data };
+}
+
+// src/commands/store-cmd.ts
+async function storeCommand(parsed2) {
+  const sub = parsed2.subcommand;
+  if (sub === "create") return storeCreateCommand(parsed2);
+  if (sub === "list" || sub === "ls") return storeListCommand(parsed2);
+  console.error(
+    `Unknown store subcommand: ${sub}. Use: store create | store list`
+  );
+  process.exit(1);
+}
+async function storeCreateCommand(parsed2) {
+  const format = detectOutputFormat(parsed2.global.output);
+  try {
+    let input;
+    if (parsed2.global.data) {
+      const raw = JSON.parse(parsed2.global.data);
+      input = {
+        name: validateRequired(raw.name, "name"),
+        platform: validateEnum(raw.platform, PLATFORM_VENDORS, "platform"),
+        platformStoreId: validateRequired(
+          raw.platformStoreId,
+          "platformStoreId"
+        ),
+        logo: raw.logo,
+        settings: raw.settings
+      };
+    } else {
+      input = {
+        name: validateRequired(getFlag(parsed2.flags, "name", "n"), "name"),
+        platform: validateEnum(
+          validateRequired(getFlag(parsed2.flags, "platform", "p"), "platform"),
+          PLATFORM_VENDORS,
+          "platform"
+        ),
+        platformStoreId: validateRequired(
+          getFlag(parsed2.flags, "platform-store-id"),
+          "platform-store-id"
+        ),
+        logo: getFlag(parsed2.flags, "logo"),
+        settings: getFlag(parsed2.flags, "settings")
+      };
+    }
+    if (parsed2.global.dryRun) {
+      outputDryRun("store.create", input, format);
+      return;
+    }
+    const client = await getAuthenticatedClient();
+    const result = await createStore(client, input);
+    outputResult(result, format, parsed2.global.fields);
+    if (result.error) process.exit(1);
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) }
+      },
+      format
+    );
+    process.exit(1);
+  }
+}
+async function storeListCommand(parsed2) {
+  const format = detectOutputFormat(parsed2.global.output);
+  try {
+    const client = await getAuthenticatedClient();
+    const result = await listStores(client);
+    outputResult(result, format, parsed2.global.fields);
+    if (result.error) process.exit(1);
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) }
+      },
+      format
+    );
+    process.exit(1);
+  }
+}
+
+// src/core/version.ts
+async function createVersion(client, input) {
+  const parsed2 = versionCreateSchema.safeParse(input);
+  if (!parsed2.success) {
+    return {
+      error: { message: parsed2.error.issues.map((i) => i.message).join("; ") }
+    };
+  }
+  const { data, error } = await client.from("versions").insert({
+    name: parsed2.data.name,
+    active: parsed2.data.active,
+    default: parsed2.data.default,
+    store_id: parsed2.data.storeId,
+    template: parsed2.data.template
+  }).select("id").single();
+  if (error) {
+    return { error: { message: error.message } };
+  }
+  return { data: { id: data.id } };
+}
+async function listVersions(client, storeId) {
+  const { data, error } = await client.from("versions").select("id, name, active, default, store_id, template, created_at").eq("store_id", storeId).order("created_at", { ascending: false });
+  if (error) {
+    return { error: { message: error.message } };
+  }
+  return { data };
+}
+
+// src/commands/version-cmd.ts
+async function versionCommand(parsed2) {
+  const sub = parsed2.subcommand;
+  if (sub === "create") return versionCreateCommand(parsed2);
+  if (sub === "list" || sub === "ls") return versionListCommand(parsed2);
+  console.error(
+    `Unknown version subcommand: ${sub}. Use: version create | version list`
+  );
+  process.exit(1);
+}
+async function versionCreateCommand(parsed2) {
+  const format = detectOutputFormat(parsed2.global.output);
+  try {
+    let input;
+    if (parsed2.global.data) {
+      const raw = JSON.parse(parsed2.global.data);
+      input = {
+        storeId: validateUuid(raw.storeId, "storeId"),
+        name: validateRequired(raw.name, "name"),
+        active: raw.active ?? false,
+        default: raw.default ?? false,
+        template: raw.template ?? null
+      };
+    } else {
+      input = {
+        storeId: validateUuid(
+          validateRequired(getFlag(parsed2.flags, "store-id"), "store-id"),
+          "store-id"
+        ),
+        name: validateRequired(getFlag(parsed2.flags, "name", "n"), "name"),
+        active: getBoolFlag(parsed2.flags, "active"),
+        default: getBoolFlag(parsed2.flags, "default"),
+        template: getFlag(parsed2.flags, "template") ?? null
+      };
+    }
+    if (parsed2.global.dryRun) {
+      outputDryRun("version.create", input, format);
+      return;
+    }
+    const client = await getAuthenticatedClient();
+    const result = await createVersion(client, input);
+    outputResult(result, format, parsed2.global.fields);
+    if (result.error) process.exit(1);
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) }
+      },
+      format
+    );
+    process.exit(1);
+  }
+}
+async function versionListCommand(parsed2) {
+  const format = detectOutputFormat(parsed2.global.output);
+  try {
+    const storeId = validateUuid(
+      validateRequired(getFlag(parsed2.flags, "store-id"), "store-id"),
+      "store-id"
+    );
+    const client = await getAuthenticatedClient();
+    const result = await listVersions(client, storeId);
+    outputResult(result, format, parsed2.global.fields);
+    if (result.error) process.exit(1);
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) }
+      },
+      format
+    );
+    process.exit(1);
+  }
+}
+
+// src/commands/whoami.ts
+async function whoamiCommand(parsed2) {
+  const format = detectOutputFormat(parsed2.global.output);
+  const user = await getCurrentUser();
+  if (!user) {
+    outputResult(
+      {
+        error: { message: "Not logged in. Run `ollieshop login`." }
+      },
+      format
+    );
+    process.exit(1);
+  }
+  outputResult(
+    {
+      data: {
+        email: user.email
+      }
+    },
+    format,
+    parsed2.global.fields
+  );
+}
+
 // src/index.tsx
 import { jsx as jsx5 } from "react/jsx-runtime";
-var args = process.argv.slice(2);
-var command = args[0] || "help";
-var commandArgs = args.slice(1);
-render(/* @__PURE__ */ jsx5(App, { command, args: commandArgs }));
+var AGENT_COMMANDS = {
+  whoami: whoamiCommand,
+  store: storeCommand,
+  version: versionCommand,
+  component: componentCommand,
+  "business-rule": businessRuleCommand,
+  schema: schemaCommand,
+  init: initCommand,
+  deploy: deployCommand,
+  status: statusCommand
+};
+var parsed = parseArgs(process.argv);
+if (parsed.command in AGENT_COMMANDS) {
+  AGENT_COMMANDS[parsed.command](parsed).catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`${JSON.stringify({ error: { message: msg } })}
+`);
+    process.exit(1);
+  });
+} else {
+  const args = process.argv.slice(2);
+  const command = args[0] || "help";
+  const commandArgs = args.slice(1);
+  render(/* @__PURE__ */ jsx5(App, { command, args: commandArgs }));
+}