@ollie-shop/cli 1.0.2 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ollie-shop/cli",
-  "version": "1.0.2",
+  "version": "1.2.1",
   "description": "Ollie Shop CLI - Development tools for custom checkouts",
   "type": "module",
   "main": "dist/index.js",
@@ -9,6 +9,7 @@
     "ollieshop": "dist/index.js"
   },
   "dependencies": {
+    "@supabase/supabase-js": "^2.49.4",
     "archiver": "^7.0.1",
     "esbuild": "^0.24.0",
     "glob": "^11.0.0",
@@ -16,7 +17,8 @@
     "jwt-decode": "^4.0.0",
     "open": "^10.1.0",
     "react": "^18.3.1",
-    "zod": "^3.24.2"
+    "zod": "^3.24.2",
+    "zod-to-json-schema": "^3.24.5"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",

package/src/commands/business-rule-cmd.ts

@@ -0,0 +1,161 @@
+import {
+  getBusinessRule,
+  listBusinessRules,
+  updateBusinessRule,
+} from "../core/business-rule.js";
+import {
+  detectOutputFormat,
+  outputDryRun,
+  outputResult,
+} from "../utils/output.js";
+import { type ParsedArgs, getFlag } from "../utils/parse-args.js";
+import { getAuthenticatedClient } from "../utils/supabase.js";
+import { validateRequired, validateUuid } from "../utils/validate.js";
+
+export async function businessRuleCommand(parsed: ParsedArgs): Promise<void> {
+  const sub = parsed.subcommand;
+  if (sub === "list" || sub === "ls") return businessRuleListCommand(parsed);
+  if (sub === "get") return businessRuleGetCommand(parsed);
+  if (sub === "update") return businessRuleUpdateCommand(parsed);
+
+  console.error(
+    `Unknown business-rule subcommand: ${sub}. Use: business-rule list | business-rule get | business-rule update`,
+  );
+  process.exit(1);
+}
+
+async function businessRuleListCommand(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  try {
+    const storeId = getFlag(parsed.flags, "store-id");
+    const versionId = getFlag(parsed.flags, "version-id");
+    const codeUpdatedRaw = parsed.flags["code-updated"];
+
+    let codeUpdated: boolean | undefined;
+    if (codeUpdatedRaw === "true" || codeUpdatedRaw === true) {
+      codeUpdated = true;
+    } else if (codeUpdatedRaw === "false") {
+      codeUpdated = false;
+    }
+
+    if (storeId !== undefined) validateUuid(storeId, "store-id");
+    if (versionId !== undefined) 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, parsed.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(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  try {
+    const id = validateUuid(
+      validateRequired(getFlag(parsed.flags, "id"), "id"),
+      "id",
+    );
+
+    const client = await getAuthenticatedClient();
+    const result = await getBusinessRule(client, id);
+
+    outputResult(result, format, parsed.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(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  try {
+    let id: string;
+    let input: {
+      content: string;
+      versions_ids?: string[] | null;
+      components_ids?: string[] | null;
+      functions_ids?: string[] | null;
+    };
+
+    if (parsed.global.data) {
+      const raw = JSON.parse(parsed.global.data);
+      id = validateUuid(validateRequired(raw.id, "id"), "id");
+      input = {
+        content: validateRequired(raw.content, "content"),
+        versions_ids: raw.versionsIds ?? undefined,
+        components_ids: raw.componentsIds ?? undefined,
+        functions_ids: raw.functionsIds ?? undefined,
+      };
+    } else {
+      id = validateUuid(
+        validateRequired(getFlag(parsed.flags, "id"), "id"),
+        "id",
+      );
+
+      const versionsIdsRaw = getFlag(parsed.flags, "versions-ids");
+      const componentsIdsRaw = getFlag(parsed.flags, "components-ids");
+      const functionsIdsRaw = getFlag(parsed.flags, "functions-ids");
+
+      input = {
+        content: validateRequired(
+          getFlag(parsed.flags, "content", "c"),
+          "content",
+        ),
+        versions_ids: versionsIdsRaw
+          ? (JSON.parse(versionsIdsRaw) as string[])
+          : undefined,
+        components_ids: componentsIdsRaw
+          ? (JSON.parse(componentsIdsRaw) as string[])
+          : undefined,
+        functions_ids: functionsIdsRaw
+          ? (JSON.parse(functionsIdsRaw) as string[])
+          : undefined,
+      };
+    }
+
+    if (parsed.global.dryRun) {
+      outputDryRun(
+        "business-rule.update",
+        { id, ...input } as Record<string, unknown>,
+        format,
+      );
+      return;
+    }
+
+    const client = await getAuthenticatedClient();
+    const result = await updateBusinessRule(client, id, input);
+
+    outputResult(result, format, parsed.global.fields);
+    if (result.error) process.exit(1);
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) },
+      },
+      format,
+    );
+    process.exit(1);
+  }
+}

package/src/commands/component-cmd.ts

@@ -0,0 +1,107 @@
+import { createComponent, listComponents } from "../core/component.js";
+import {
+  detectOutputFormat,
+  outputDryRun,
+  outputResult,
+} from "../utils/output.js";
+import { type ParsedArgs, getBoolFlag, getFlag } from "../utils/parse-args.js";
+import { getAuthenticatedClient } from "../utils/supabase.js";
+import { validateRequired, validateUuid } from "../utils/validate.js";
+
+export async function componentCommand(parsed: ParsedArgs): Promise<void> {
+  const sub = parsed.subcommand;
+  if (sub === "create") return componentCreateCommand(parsed);
+  if (sub === "list" || sub === "ls") return componentListCommand(parsed);
+
+  console.error(
+    `Unknown component subcommand: ${sub}. Use: component create | component list`,
+  );
+  process.exit(1);
+}
+
+async function componentCreateCommand(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  try {
+    let input: {
+      versionId: string;
+      name: string;
+      slot: string;
+      active?: boolean;
+      props?: Record<string, unknown> | null;
+    };
+
+    if (parsed.global.data) {
+      const raw = JSON.parse(parsed.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(parsed.flags, "version-id"), "version-id"),
+          "version-id",
+        ),
+        name: validateRequired(getFlag(parsed.flags, "name", "n"), "name"),
+        slot: validateRequired(getFlag(parsed.flags, "slot", "s"), "slot"),
+        active:
+          getBoolFlag(parsed.flags, "active") || !("active" in parsed.flags),
+        props: null,
+      };
+    }
+
+    if (parsed.global.dryRun) {
+      outputDryRun(
+        "component.create",
+        input as Record<string, unknown>,
+        format,
+      );
+      return;
+    }
+
+    const client = await getAuthenticatedClient();
+    const result = await createComponent(client, input);
+
+    outputResult(result, format, parsed.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(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  try {
+    const storeId = validateUuid(
+      validateRequired(getFlag(parsed.flags, "store-id"), "store-id"),
+      "store-id",
+    );
+    const versionId = getFlag(parsed.flags, "version-id");
+    if (versionId) validateUuid(versionId, "version-id");
+
+    const client = await getAuthenticatedClient();
+    const result = await listComponents(client, storeId, versionId);
+
+    outputResult(result, format, parsed.global.fields);
+    if (result.error) process.exit(1);
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) },
+      },
+      format,
+    );
+    process.exit(1);
+  }
+}

package/src/commands/deploy-cmd.ts

@@ -0,0 +1,146 @@
+import {
+  type ResourceType,
+  isTerminalStatus,
+  pollBuildStatus,
+  uploadBuild,
+} from "../core/deploy.js";
+import { createComponentBundle } from "../utils/bundle.js";
+import {
+  detectOutputFormat,
+  outputDryRun,
+  outputResult,
+} from "../utils/output.js";
+import { type ParsedArgs, getBoolFlag, getFlag } from "../utils/parse-args.js";
+import { validateRequired, validateUuid } from "../utils/validate.js";
+
+export async function deployCommand(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  try {
+    let resourceId: string;
+    let componentName: string;
+    let resourceType: ResourceType;
+    let wait: boolean;
+    let timeout: number;
+
+    if (parsed.global.data) {
+      const raw = JSON.parse(parsed.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(parsed.flags, "component-id");
+      const funcId = getFlag(parsed.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(parsed.flags, "name", "n"),
+        "name",
+      );
+      wait = getBoolFlag(parsed.flags, "wait");
+      timeout = Number(getFlag(parsed.flags, "timeout") ?? "300");
+    }
+
+    // Bundle the component
+    const stream = await createComponentBundle({
+      componentName,
+      cwd: process.cwd(),
+    });
+
+    // Collect the zip buffer
+    const chunks: Buffer[] = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const zipBuffer = Buffer.concat(chunks);
+
+    if (parsed.global.dryRun) {
+      outputDryRun(
+        "deploy",
+        {
+          resourceId,
+          resourceType,
+          componentName,
+          bundleSizeBytes: zipBuffer.length,
+          bundleSizeKB: Math.round(zipBuffer.length / 1024),
+          wait,
+          timeout,
+        },
+        format,
+      );
+      return;
+    }
+
+    // Upload to builder
+    const uploadResult = await uploadBuild({
+      resourceId,
+      type: resourceType,
+      zipBuffer,
+    });
+
+    if (!uploadResult.success) {
+      outputResult(uploadResult, format);
+      process.exit(1);
+    }
+
+    // If --wait, poll until terminal
+    if (wait) {
+      const isJson = format === "json";
+      if (!isJson) {
+        process.stderr.write(
+          `Build ${uploadResult.data.id} started. Polling...\n`,
+        );
+      }
+
+      const pollResult = await pollBuildStatus(uploadResult.data.id, {
+        timeoutMs: timeout * 1000,
+        onPoll: (build) => {
+          if (!isJson) {
+            process.stderr.write(`  status: ${build.status}\n`);
+          }
+        },
+      });
+
+      outputResult(pollResult, format, parsed.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, parsed.global.fields);
+    }
+  } catch (err) {
+    outputResult(
+      {
+        success: false,
+        error: { message: err instanceof Error ? err.message : String(err) },
+      },
+      format,
+    );
+    process.exit(1);
+  }
+}

package/src/commands/help.tsx

@@ -16,29 +16,83 @@ export function HelpCommand() {
       </Box>
 
       <Box marginTop={1}>
-        <Text bold>Commands:</Text>
+        <Text bold>Interactive Commands:</Text>
       </Box>
       <Box marginLeft={2} flexDirection="column" gap={0}>
         <Box>
-          <Box width={16}>
+          <Box width={24}>
             <Text color="green">login</Text>
           </Box>
           <Text>Authenticate with your Ollie Shop account</Text>
         </Box>
         <Box>
-          <Box width={16}>
+          <Box width={24}>
             <Text color="green">start</Text>
           </Box>
           <Text>Start the development server with hot reload</Text>
         </Box>
+      </Box>
+
+      <Box marginTop={1}>
+        <Text bold>Agent Commands:</Text>
+      </Box>
+      <Box marginLeft={2} flexDirection="column" gap={0}>
+        <Box>
+          <Box width={24}>
+            <Text color="green">whoami</Text>
+          </Box>
+          <Text>Show current user and organization</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="green">store create|list</Text>
+          </Box>
+          <Text>Create or list stores</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="green">version create|list</Text>
+          </Box>
+          <Text>Create or list versions</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="green">component create|list</Text>
+          </Box>
+          <Text>Create or list components</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="green">deploy</Text>
+          </Box>
+          <Text>Bundle and upload a component/function build</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="green">status</Text>
+          </Box>
+          <Text>Check or poll a build status</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="green">schema</Text>
+          </Box>
+          <Text>Introspect resource schemas (JSON Schema)</Text>
+        </Box>
         <Box>
-          <Box width={16}>
+          <Box width={24}>
+            <Text color="green">init</Text>
+          </Box>
+          <Text>Write store/version IDs to ollie.json</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
             <Text color="green">help</Text>
           </Box>
           <Text>Show this help message</Text>
         </Box>
         <Box>
-          <Box width={16}>
+          <Box width={24}>
             <Text color="green">version</Text>
           </Box>
           <Text>Show CLI version</Text>
@@ -46,33 +100,70 @@ export function HelpCommand() {
       </Box>
 
       <Box marginTop={1}>
-        <Text bold>Start Options:</Text>
+        <Text bold>Global Flags:</Text>
       </Box>
       <Box marginLeft={2} flexDirection="column" gap={0}>
         <Box>
-          <Box width={20}>
+          <Box width={24}>
+            <Text color="yellow">--output json, -o json</Text>
+          </Box>
+          <Text>Force JSON output (auto when piped)</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="yellow">--dry-run</Text>
+          </Box>
+          <Text>Validate without executing mutations</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="yellow">--fields a,b,c</Text>
+          </Box>
+          <Text>Limit output fields</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="yellow">--data {`'{...}'`}</Text>
+          </Box>
+          <Text>Raw JSON payload for mutations</Text>
+        </Box>
+        <Box>
+          <Box width={24}>
             <Text color="yellow">--stage, -s</Text>
           </Box>
           <Text>Config stage (loads ollie.{"{stage}"}.json)</Text>
         </Box>
       </Box>
 
-      <Box marginTop={1}>
-        <Text bold>Configuration:</Text>
-      </Box>
-      <Box marginLeft={2} flexDirection="column">
-        <Text dimColor>ollie.json - Default config (prod)</Text>
-        <Text dimColor>ollie.dev.json - Dev stage config</Text>
-        <Text dimColor>ollie.{"{stage}"}.json - Custom stage config</Text>
-      </Box>
-
       <Box marginTop={1}>
         <Text bold>Examples:</Text>
       </Box>
       <Box marginLeft={2} flexDirection="column">
         <Text dimColor>$ ollieshop login</Text>
-        <Text dimColor>$ ollieshop start</Text>
         <Text dimColor>$ ollieshop start --stage dev</Text>
+        <Text dimColor>$ ollieshop whoami -o json</Text>
+        <Text dimColor>$ ollieshop schema store.create</Text>
+        <Text dimColor>
+          $ ollieshop store create --name "My Store" --platform vtex
+          --platform-store-id mystore
+        </Text>
+        <Text dimColor>
+          $ ollieshop store create --data{" "}
+          {
+            '\'{"name":"My Store","platform":"vtex","platformStoreId":"mystore"}\''
+          }{" "}
+          -o json
+        </Text>
+        <Text dimColor>
+          $ ollieshop version create --store-id UUID --name v1 --active
+        </Text>
+        <Text dimColor>$ ollieshop init --store-id UUID --version-id UUID</Text>
+        <Text dimColor>
+          $ ollieshop deploy --component-id UUID --name FreeShippingBar --wait
+        </Text>
+        <Text dimColor>
+          $ ollieshop status --build-id BUILD_ID --wait -o json
+        </Text>
       </Box>
     </Box>
   );

package/src/commands/init-cmd.ts

@@ -0,0 +1,53 @@
+import { saveConfig } from "../utils/config.js";
+import { detectOutputFormat, outputResult } from "../utils/output.js";
+import { type ParsedArgs, getFlag } from "../utils/parse-args.js";
+import { validateRequired, validateUuid } from "../utils/validate.js";
+
+export async function initCommand(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+
+  try {
+    const storeId = validateUuid(
+      validateRequired(getFlag(parsed.flags, "store-id"), "store-id"),
+      "store-id",
+    );
+
+    const versionIdRaw = getFlag(parsed.flags, "version-id");
+    const versionId = versionIdRaw
+      ? validateUuid(versionIdRaw, "version-id")
+      : undefined;
+
+    const stage = getFlag(parsed.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,
+      parsed.global.fields,
+    );
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) },
+      },
+      format,
+    );
+    process.exit(1);
+  }
+}

package/src/commands/schema-cmd.ts

@@ -0,0 +1,34 @@
+import { getJsonSchema, getSchemaNames } from "../core/schema.js";
+import { detectOutputFormat } from "../utils/output.js";
+import type { ParsedArgs } from "../utils/parse-args.js";
+
+export async function schemaCommand(parsed: ParsedArgs): Promise<void> {
+  const format = detectOutputFormat(parsed.global.output);
+  const resourceName = parsed.subcommand || parsed.positional[0];
+
+  if (!resourceName) {
+    // List all available schemas
+    const names = getSchemaNames();
+    if (format === "json") {
+      process.stdout.write(`${JSON.stringify({ schemas: names })}\n`);
+    } 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)}\n`);
+}