@ollie-shop/cli 1.0.1 → 1.1.0

package/dist/index.js

@@ -21,49 +21,98 @@ 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: 16, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "help" }) }),
+        /* @__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: "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" })
     ] })
   ] });
 }
@@ -227,14 +276,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 +408,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;
 }
@@ -603,6 +681,7 @@ async function startDevServer(ctx, options = {}) {
       const componentName = pathMatch[1];
       res.setHeader("Access-Control-Allow-Origin", "*");
       res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+      res.setHeader("Access-Control-Allow-Private-Network", "true");
       try {
         const stream = await createComponentBundle({ cwd, componentName });
         res.setHeader("Content-Type", "application/zip");
@@ -642,6 +721,7 @@ async function startDevServer(ctx, options = {}) {
       res.setHeader("Access-Control-Allow-Origin", "*");
       res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
       res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+      res.setHeader("Access-Control-Allow-Private-Network", "true");
       let body = "";
       req.on("data", (chunk) => {
         body += chunk.toString();
@@ -680,6 +760,7 @@ async function startDevServer(ctx, options = {}) {
     if (req.method === "OPTIONS") {
       res.setHeader("Access-Control-Allow-Origin", "*");
       res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Private-Network", "true");
       const requestedHeaders = req.headers["access-control-request-headers"];
       res.setHeader(
         "Access-Control-Allow-Headers",
@@ -700,7 +781,8 @@ async function startDevServer(ctx, options = {}) {
       (proxyRes) => {
         const responseHeaders = {
           ...proxyRes.headers,
-          "access-control-allow-origin": "*"
+          "access-control-allow-origin": "*",
+          "access-control-allow-private-network": "true"
         };
         res.writeHead(proxyRes.statusCode || 200, responseHeaders);
         proxyRes.pipe(res);
@@ -760,11 +842,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([]);
@@ -774,7 +856,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 = {
@@ -786,12 +868,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]
@@ -1061,12 +1143,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":
@@ -1076,25 +1158,785 @@ 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/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/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";
+function requireEnv(name) {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(
+      `Missing required environment variable: ${name}. Set it in your .env file or shell.`
+    );
+  }
+  return value;
+}
+async function getAuthenticatedClient() {
+  const credentials = await getCredentials();
+  if (!credentials) {
+    throw new Error("Not authenticated. Run `ollieshop login` first.");
+  }
+  const supabaseUrl = requireEnv("OLLIE_SUPABASE_URL");
+  const supabaseAnonKey = requireEnv("OLLIE_SUPABASE_ANON_KEY");
+  const client = createClient(supabaseUrl, supabaseAnonKey, {
+    auth: {
+      autoRefreshToken: false,
+      persistSession: false
+    }
+  });
+  await client.auth.setSession({
+    access_token: credentials.accessToken,
+    refresh_token: credentials.refreshToken
+  });
+  return client;
+}
+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/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/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/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,
+  schema: schemaCommand,
+  init: initCommand
+};
+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 }));
+}