@ollie-shop/cli 1.1.0 → 1.2.2

package/dist/index.js

@@ -50,6 +50,18 @@ function HelpCommand() {
         /* @__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: "function create|list" }) }),
+        /* @__PURE__ */ jsx(Text, { children: "Create or list functions" })
+      ] }),
+      /* @__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: 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)" })
@@ -112,7 +124,10 @@ function HelpCommand() {
         "-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 init --store-id UUID --version-id UUID" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop function create --version-id UUID --name myHook" }),
+      /* @__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" })
     ] })
   ] });
 }
@@ -1174,129 +1189,60 @@ function UnknownCommand({ command }) {
   ] });
 }
 
-// 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}`);
-    }
+// 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])
+    );
   }
-  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}` });
+  if (filters.code_updated !== void 0) {
+    query = query.eq("code_updated", filters.code_updated);
   }
-  const result = {};
-  for (const [actionName, schema] of Object.entries(schemas[resource])) {
-    result[actionName] = zodToJsonSchema(schema, {
-      name: `${resource}.${actionName}`
-    });
+  const { data, error } = await query;
+  if (error) {
+    return { error: { message: error.message } };
   }
-  return result;
+  return { data };
 }
-
-// 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();
+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: { id: data.id } };
+  return { data };
 }
-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);
+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 { data, error } = await query;
+  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: data ?? [] };
+  return { data: { id: data.id } };
 }
 
 // src/utils/output.ts
@@ -1451,22 +1397,13 @@ function getBoolFlag(flags, ...names) {
 
 // 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 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,
@@ -1479,6 +1416,16 @@ async function getAuthenticatedClient() {
   });
   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) {
@@ -1525,52 +1472,71 @@ function validateRequired(value, name) {
   }
   return rejectControlChars(value.trim(), name);
 }
+function validateInteger(value, name, opts) {
+  const n = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : Number.NaN;
+  if (!Number.isFinite(n) || !Number.isInteger(n)) {
+    throw new Error(`Invalid ${name}: "${String(value)}". Must be an integer.`);
+  }
+  if (opts?.min !== void 0 && n < opts.min) {
+    throw new Error(`Invalid ${name}: ${n}. Must be >= ${opts.min}.`);
+  }
+  return n;
+}
+function validateTriggerUrl(value, name) {
+  rejectControlChars(value, name);
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    throw new Error(
+      `Invalid ${name}: must be a non-empty absolute http(s) URL or a relative path starting with "/".`
+    );
+  }
+  if (trimmed.startsWith("/")) {
+    return trimmed;
+  }
+  try {
+    const parsed2 = new URL(trimmed);
+    if (parsed2.protocol !== "http:" && parsed2.protocol !== "https:") {
+      throw new Error("unsupported protocol");
+    }
+    return trimmed;
+  } catch {
+    throw new Error(
+      `Invalid ${name}: "${value}". Must be an absolute http(s) URL or a relative path starting with "/".`
+    );
+  }
+}
 
-// src/commands/component-cmd.ts
-async function componentCommand(parsed2) {
+// src/commands/business-rule-cmd.ts
+async function businessRuleCommand(parsed2) {
   const sub = parsed2.subcommand;
-  if (sub === "create") return componentCreateCommand(parsed2);
-  if (sub === "list" || sub === "ls") return componentListCommand(parsed2);
+  if (sub === "list" || sub === "ls") return businessRuleListCommand(parsed2);
+  if (sub === "get") return businessRuleGetCommand(parsed2);
+  if (sub === "update") return businessRuleUpdateCommand(parsed2);
   console.error(
-    `Unknown component subcommand: ${sub}. Use: component create | component list`
+    `Unknown business-rule subcommand: ${sub}. Use: business-rule list | business-rule get | business-rule update`
   );
   process.exit(1);
 }
-async function componentCreateCommand(parsed2) {
+async function businessRuleListCommand(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 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 createComponent(client, input);
+    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) {
@@ -1583,17 +1549,15 @@ async function componentCreateCommand(parsed2) {
     process.exit(1);
   }
 }
-async function componentListCommand(parsed2) {
+async function businessRuleGetCommand(parsed2) {
   const format = detectOutputFormat(parsed2.global.output);
   try {
-    const storeId = validateUuid(
-      validateRequired(getFlag(parsed2.flags, "store-id"), "store-id"),
-      "store-id"
+    const id = validateUuid(
+      validateRequired(getFlag(parsed2.flags, "id"), "id"),
+      "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);
+    const result = await getBusinessRule(client, id);
     outputResult(result, format, parsed2.global.fields);
     if (result.error) process.exit(1);
   } catch (err) {
@@ -1606,37 +1570,50 @@ async function componentListCommand(parsed2) {
     process.exit(1);
   }
 }
-
-// src/commands/init-cmd.ts
-async function initCommand(parsed2) {
+async function businessRuleUpdateCommand(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
-    );
+    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(
       {
@@ -1648,17 +1625,611 @@ async function initCommand(parsed2) {
   }
 }
 
-// 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");
+// 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).optional().describe(
+    "Function trigger URL \u2014 absolute http(s) URL or relative path starting with /"
+  ),
+  active: z2.boolean().default(false).describe("Whether function is active (default: false)"),
+  onError: z2.enum(["throw", "skip"]).optional().describe("Error handling: throw (default) or skip"),
+  priority: z2.number().int().min(0).optional().describe("Execution order priority (default: 0)")
+});
+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/core/function.ts
+async function createFunction(client, input) {
+  const parsed2 = functionCreateSchema.safeParse(input);
+  if (!parsed2.success) {
+    return {
+      success: false,
+      error: {
+        message: parsed2.error.issues.map((i) => i.message).join("; ")
+      }
+    };
+  }
+  const { data, error } = await client.from("functions").insert({
+    name: parsed2.data.name,
+    active: parsed2.data.active,
+    version_id: parsed2.data.versionId,
+    trigger: parsed2.data.trigger ?? null,
+    on_error: parsed2.data.onError ?? "throw",
+    priority: parsed2.data.priority ?? 0
+  }).select("id").single();
+  if (error) {
+    return { success: false, error: { message: error.message } };
+  }
+  return { success: true, data: { id: data.id } };
+}
+async function listFunctions(client, storeId, versionId) {
+  let query = client.from("functions").select(
+    "id, name, active, urn, on_error, priority, trigger, invocation, version_id, 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 { success: false, error: { message: error.message } };
+  }
+  return { success: true, data: data ?? [] };
+}
+
+// src/commands/function-cmd.ts
+var ON_ERROR_VALUES = ["throw", "skip"];
+async function functionCommand(parsed2) {
+  const sub = parsed2.subcommand;
+  if (sub === "create") return functionCreateCommand(parsed2);
+  if (sub === "list" || sub === "ls") return functionListCommand(parsed2);
+  console.error(
+    `Unknown function subcommand: ${sub}. Use: function create | function list`
+  );
+  process.exit(1);
+}
+async function functionCreateCommand(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"),
+        trigger: raw.trigger !== void 0 && raw.trigger !== null ? validateTriggerUrl(String(raw.trigger), "trigger") : void 0,
+        active: raw.active === true,
+        onError: raw.onError !== void 0 && raw.onError !== null ? validateEnum(String(raw.onError), ON_ERROR_VALUES, "on-error") : "throw",
+        priority: raw.priority !== void 0 && raw.priority !== null ? validateInteger(raw.priority, "priority", { min: 0 }) : 0
+      };
+    } else {
+      const triggerFlag = getFlag(parsed2.flags, "trigger");
+      const onErrorFlag = getFlag(parsed2.flags, "on-error");
+      const priorityFlag = getFlag(parsed2.flags, "priority");
+      input = {
+        versionId: validateUuid(
+          validateRequired(getFlag(parsed2.flags, "version-id"), "version-id"),
+          "version-id"
+        ),
+        name: validateRequired(getFlag(parsed2.flags, "name", "n"), "name"),
+        trigger: triggerFlag !== void 0 ? validateTriggerUrl(triggerFlag, "trigger") : void 0,
+        active: getBoolFlag(parsed2.flags, "active"),
+        onError: onErrorFlag !== void 0 ? validateEnum(onErrorFlag, ON_ERROR_VALUES, "on-error") : "throw",
+        priority: priorityFlag !== void 0 ? validateInteger(priorityFlag, "priority", { min: 0 }) : 0
+      };
+    }
+    const validated = functionCreateSchema.safeParse(input);
+    if (!validated.success) {
+      throw new Error(validated.error.issues.map((i) => i.message).join("; "));
+    }
+    if (parsed2.global.dryRun) {
+      outputDryRun(
+        "function.create",
+        validated.data,
+        format
+      );
+      return;
+    }
+    const client = await getAuthenticatedClient();
+    const result = await createFunction(client, validated.data);
+    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);
+  }
+}
+async function functionListCommand(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 listFunctions(client, storeId, versionId);
+    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/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`);
@@ -1678,6 +2249,60 @@ async function schemaCommand(parsed2) {
 `);
 }
 
+// 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);
@@ -1923,8 +2548,12 @@ var AGENT_COMMANDS = {
   store: storeCommand,
   version: versionCommand,
   component: componentCommand,
+  "business-rule": businessRuleCommand,
+  function: functionCommand,
   schema: schemaCommand,
-  init: initCommand
+  init: initCommand,
+  deploy: deployCommand,
+  status: statusCommand
 };
 var parsed = parseArgs(process.argv);
 if (parsed.command in AGENT_COMMANDS) {