@ollie-shop/cli 1.0.2 → 1.1.0

package/src/core/schema.ts

@@ -0,0 +1,136 @@
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+const PLATFORM_VENDORS = ["vtex", "shopify", "vnda", "custom"] as const;
+
+export const storeCreateSchema = z.object({
+  name: z.string().min(1).describe("Store display name"),
+  platform: z.enum(PLATFORM_VENDORS).describe("E-commerce platform vendor"),
+  platformStoreId: z
+    .string()
+    .min(1)
+    .describe("Platform-specific store identifier (e.g. account name)"),
+  logo: z.string().url().optional().describe("Store logo URL"),
+  settings: z.string().optional().describe("JSON settings string"),
+});
+
+export const storeListSchema = z.object({}).describe("No parameters required");
+
+export const versionCreateSchema = z.object({
+  storeId: z.string().uuid().describe("Parent store UUID"),
+  name: z.string().min(1).describe("Version name (e.g. v1, main)"),
+  active: z.boolean().default(false).describe("Whether version is active"),
+  default: z
+    .boolean()
+    .default(false)
+    .describe("Whether this is the default version"),
+  template: z
+    .string()
+    .nullable()
+    .default(null)
+    .describe("Template name or null"),
+});
+
+export const versionListSchema = z.object({
+  storeId: z.string().uuid().describe("Store UUID to list versions for"),
+});
+
+export const componentCreateSchema = z.object({
+  versionId: z.string().uuid().describe("Parent version UUID"),
+  name: z.string().min(1).describe("Component name (e.g. FreeShippingBar)"),
+  slot: z
+    .string()
+    .min(1)
+    .describe(
+      "Target slot (e.g. cart_header_full_page, shipping_address_details_form)",
+    ),
+  active: z.boolean().default(true).describe("Whether component is active"),
+  props: z
+    .record(z.unknown())
+    .nullable()
+    .default(null)
+    .describe("Default component props as JSON object"),
+});
+
+export const componentListSchema = z.object({
+  storeId: z.string().uuid().describe("Store UUID"),
+  versionId: z
+    .string()
+    .uuid()
+    .optional()
+    .describe("Optional version UUID to filter by"),
+});
+
+export const functionCreateSchema = z.object({
+  versionId: z.string().uuid().describe("Parent version UUID"),
+  name: z.string().min(1).describe("Function name"),
+  trigger: z
+    .string()
+    .min(1)
+    .describe("Function trigger (e.g. beforePayment, afterShipping)"),
+  active: z.boolean().default(true).describe("Whether function is active"),
+});
+
+export const functionListSchema = z.object({
+  versionId: z.string().uuid().describe("Version UUID to list functions for"),
+});
+
+type SchemaMap = Record<string, z.ZodTypeAny>;
+
+const schemas: Record<string, SchemaMap> = {
+  store: {
+    create: storeCreateSchema,
+    list: storeListSchema,
+  },
+  version: {
+    create: versionCreateSchema,
+    list: versionListSchema,
+  },
+  component: {
+    create: componentCreateSchema,
+    list: componentListSchema,
+  },
+  function: {
+    create: functionCreateSchema,
+    list: functionListSchema,
+  },
+};
+
+export function getSchemaNames(): string[] {
+  const names: string[] = [];
+  for (const [resource, actions] of Object.entries(schemas)) {
+    names.push(resource);
+    for (const action of Object.keys(actions)) {
+      names.push(`${resource}.${action}`);
+    }
+  }
+  return names;
+}
+
+export function getJsonSchema(name: string): Record<string, unknown> | null {
+  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}` }) as Record<
+      string,
+      unknown
+    >;
+  }
+
+  // Return all actions for a resource
+  const result: Record<string, unknown> = {};
+  for (const [actionName, schema] of Object.entries(schemas[resource])) {
+    result[actionName] = zodToJsonSchema(schema, {
+      name: `${resource}.${actionName}`,
+    });
+  }
+  return result;
+}
+
+export { PLATFORM_VENDORS };

package/src/core/store.ts

@@ -0,0 +1,76 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+import { getOrganizationId } from "../utils/supabase.js";
+import { storeCreateSchema } from "./schema.js";
+
+export interface CreateStoreInput {
+  name: string;
+  platform: string;
+  platformStoreId: string;
+  logo?: string;
+  settings?: string;
+}
+
+export interface StoreRecord {
+  id: string;
+  name: string;
+  platform: string;
+  platform_store_id: string;
+  organization_id: string;
+  logo: string | null;
+  settings: string | null;
+  created_at: string;
+}
+
+export async function createStore(
+  client: SupabaseClient,
+  input: CreateStoreInput,
+): Promise<{ data?: { id: string }; error?: { message: string } }> {
+  // Validate input against schema
+  const parsed = storeCreateSchema.safeParse(input);
+  if (!parsed.success) {
+    return {
+      error: { message: parsed.error.issues.map((i) => i.message).join("; ") },
+    };
+  }
+
+  const organizationId = await getOrganizationId(client);
+
+  const { data, error } = await client
+    .from("stores")
+    .insert({
+      name: parsed.data.name,
+      platform: parsed.data.platform,
+      platform_store_id: parsed.data.platformStoreId,
+      organization_id: organizationId,
+      logo: parsed.data.logo ?? null,
+      settings: parsed.data.settings ?? null,
+    })
+    .select("id")
+    .single();
+
+  if (error) {
+    return { error: { message: error.message } };
+  }
+
+  return { data: { id: data.id } };
+}
+
+export async function listStores(
+  client: SupabaseClient,
+): Promise<{ data?: StoreRecord[]; error?: { message: string } }> {
+  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: data as StoreRecord[] };
+}

package/src/core/version.ts

@@ -0,0 +1,67 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+import { versionCreateSchema } from "./schema.js";
+
+export interface CreateVersionInput {
+  storeId: string;
+  name: string;
+  active?: boolean;
+  default?: boolean;
+  template?: string | null;
+}
+
+export interface VersionRecord {
+  id: string;
+  name: string;
+  active: boolean;
+  default: boolean;
+  store_id: string;
+  template: string | null;
+  created_at: string;
+}
+
+export async function createVersion(
+  client: SupabaseClient,
+  input: CreateVersionInput,
+): Promise<{ data?: { id: string }; error?: { message: string } }> {
+  const parsed = versionCreateSchema.safeParse(input);
+  if (!parsed.success) {
+    return {
+      error: { message: parsed.error.issues.map((i) => i.message).join("; ") },
+    };
+  }
+
+  const { data, error } = await client
+    .from("versions")
+    .insert({
+      name: parsed.data.name,
+      active: parsed.data.active,
+      default: parsed.data.default,
+      store_id: parsed.data.storeId,
+      template: parsed.data.template,
+    })
+    .select("id")
+    .single();
+
+  if (error) {
+    return { error: { message: error.message } };
+  }
+
+  return { data: { id: data.id } };
+}
+
+export async function listVersions(
+  client: SupabaseClient,
+  storeId: string,
+): Promise<{ data?: VersionRecord[]; error?: { message: string } }> {
+  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: data as VersionRecord[] };
+}

package/src/index.tsx

@@ -1,8 +1,38 @@
 import { render } from "ink";
 import { App } from "./cli.js";
+import { componentCommand } from "./commands/component-cmd.js";
+import { initCommand } from "./commands/init-cmd.js";
+import { schemaCommand } from "./commands/schema-cmd.js";
+import { storeCommand } from "./commands/store-cmd.js";
+import { versionCommand } from "./commands/version-cmd.js";
+import { whoamiCommand } from "./commands/whoami.js";
+import { parseArgs } from "./utils/parse-args.js";
 
-const args = process.argv.slice(2);
-const command = args[0] || "help";
-const commandArgs = args.slice(1);
+// Agent-first commands: plain async, no Ink, structured output
+const AGENT_COMMANDS: Record<
+  string,
+  (parsed: ReturnType<typeof parseArgs>) => Promise<void>
+> = {
+  whoami: whoamiCommand,
+  store: storeCommand,
+  version: versionCommand,
+  component: componentCommand,
+  schema: schemaCommand,
+  init: initCommand,
+};
 
-render(<App command={command} args={commandArgs} />);
+const parsed = parseArgs(process.argv);
+
+if (parsed.command in AGENT_COMMANDS) {
+  AGENT_COMMANDS[parsed.command](parsed).catch((err: unknown) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`${JSON.stringify({ error: { message: msg } })}\n`);
+    process.exit(1);
+  });
+} else {
+  // Interactive commands: Ink UI (login, start, help, version)
+  const args = process.argv.slice(2);
+  const command = args[0] || "help";
+  const commandArgs = args.slice(1);
+  render(<App command={command} args={commandArgs} />);
+}

package/src/utils/output.ts

@@ -0,0 +1,125 @@
+export type OutputFormat = "json" | "pretty";
+
+export function detectOutputFormat(cliOutput?: string): OutputFormat {
+  if (cliOutput === "json" || cliOutput === "j") return "json";
+  if (cliOutput === "pretty") return "pretty";
+  // Auto-detect: JSON when piped, pretty when TTY
+  return process.stdout.isTTY ? "pretty" : "json";
+}
+
+export function filterFields(
+  data: Record<string, unknown>,
+  fields?: string[],
+): Record<string, unknown> {
+  if (!fields || fields.length === 0) return data;
+  const result: Record<string, unknown> = {};
+  for (const field of fields) {
+    if (field in data) {
+      result[field] = data[field];
+    }
+  }
+  return result;
+}
+
+export function outputResult(
+  result: { data?: unknown; error?: unknown },
+  format: OutputFormat,
+  fields?: string[],
+): void {
+  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 as Record<string, unknown>, fields),
+          ),
+        };
+      } else {
+        output = {
+          ...result,
+          data: filterFields(result.data as Record<string, unknown>, fields),
+        };
+      }
+    }
+    process.stdout.write(`${JSON.stringify(output)}\n`);
+    return;
+  }
+
+  // Pretty output
+  if (result.error) {
+    const errMsg =
+      typeof result.error === "object" && result.error !== null
+        ? (result.error as { message?: string }).message ||
+          JSON.stringify(result.error)
+        : String(result.error);
+    console.error(`\x1b[31mError:\x1b[0m ${errMsg}`);
+    return;
+  }
+
+  if (Array.isArray(result.data)) {
+    printTable(result.data as Record<string, unknown>[], fields);
+  } else if (typeof result.data === "object" && result.data !== null) {
+    const filtered = fields
+      ? filterFields(result.data as Record<string, unknown>, fields)
+      : result.data;
+    for (const [key, value] of Object.entries(
+      filtered as Record<string, unknown>,
+    )) {
+      console.log(`\x1b[1m${key}:\x1b[0m ${value}`);
+    }
+  } else {
+    console.log(result.data);
+  }
+}
+
+function printTable(rows: Record<string, unknown>[], fields?: string[]): void {
+  if (rows.length === 0) {
+    console.log("(no results)");
+    return;
+  }
+
+  const keys = fields || Object.keys(rows[0]);
+  const widths: Record<string, number> = {};
+  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); // cap column width
+  }
+
+  // Header
+  const header = keys.map((k) => k.padEnd(widths[k])).join("  ");
+  console.log(`\x1b[1m${header}\x1b[0m`);
+  console.log(keys.map((k) => "─".repeat(widths[k])).join("──"));
+
+  // Rows
+  for (const row of rows) {
+    const line = keys
+      .map((k) =>
+        String(row[k] ?? "")
+          .padEnd(widths[k])
+          .slice(0, widths[k]),
+      )
+      .join("  ");
+    console.log(line);
+  }
+}
+
+export function outputDryRun(
+  action: string,
+  data: Record<string, unknown>,
+  format: OutputFormat,
+): void {
+  if (format === "json") {
+    process.stdout.write(`${JSON.stringify({ dryRun: true, action, data })}\n`);
+  } 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)}`);
+    }
+  }
+}

package/src/utils/parse-args.ts

@@ -0,0 +1,90 @@
+export interface GlobalFlags {
+  output?: string;
+  dryRun: boolean;
+  fields?: string[];
+  data?: string;
+}
+
+export interface ParsedArgs {
+  command: string;
+  subcommand?: string;
+  flags: Record<string, string | boolean>;
+  global: GlobalFlags;
+  positional: string[];
+}
+
+export function parseArgs(argv: string[]): ParsedArgs {
+  const args = argv.slice(2);
+  const command = args[0] || "help";
+  const flags: Record<string, string | boolean> = {};
+  const positional: string[] = [];
+
+  let subcommand: string | undefined;
+
+  // Determine if second arg is a subcommand (not a flag)
+  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);
+    }
+  }
+
+  // Extract global flags
+  const global: GlobalFlags = {
+    output: (flags.output as string) || (flags.o as string) || undefined,
+    dryRun: flags["dry-run"] === true,
+    fields: flags.fields
+      ? String(flags.fields)
+          .split(",")
+          .map((f) => f.trim())
+      : undefined,
+    data: (flags.data as string) || (flags.d as string) || undefined,
+  };
+
+  return { command, subcommand, flags, global, positional };
+}
+
+export function getFlag(
+  flags: Record<string, string | boolean>,
+  ...names: string[]
+): string | undefined {
+  for (const name of names) {
+    const val = flags[name];
+    if (typeof val === "string") return val;
+  }
+  return undefined;
+}
+
+export function getBoolFlag(
+  flags: Record<string, string | boolean>,
+  ...names: string[]
+): boolean {
+  for (const name of names) {
+    if (flags[name] === true) return true;
+  }
+  return false;
+}

package/src/utils/supabase.ts

@@ -0,0 +1,59 @@
+import { type SupabaseClient, createClient } from "@supabase/supabase-js";
+import { getCredentials } from "./auth.js";
+
+function requireEnv(name: string): string {
+  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;
+}
+
+export async function getAuthenticatedClient(): Promise<SupabaseClient> {
+  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;
+}
+
+export async function getOrganizationId(
+  client: SupabaseClient,
+): Promise<string> {
+  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;
+}

package/src/utils/validate.ts

@@ -0,0 +1,58 @@
+const UUID_REGEX =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+// biome-ignore lint/suspicious/noControlCharactersInRegex: intentional — rejecting control chars in user input
+const CONTROL_CHAR_REGEX = /[\x00-\x1f\x7f]/;
+
+const RESOURCE_ID_INVALID_CHARS = /[?#%\/\\]/;
+
+export function validateUuid(value: string, name: string): string {
+  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;
+}
+
+export function rejectControlChars(value: string, name: string): string {
+  if (CONTROL_CHAR_REGEX.test(value)) {
+    throw new Error(
+      `Invalid ${name}: contains control characters. Input must be printable text.`,
+    );
+  }
+  return value;
+}
+
+export function validateResourceName(value: string, name: string): string {
+  rejectControlChars(value, name);
+  if (RESOURCE_ID_INVALID_CHARS.test(value)) {
+    throw new Error(
+      `Invalid ${name}: "${value}". Must not contain ?, #, %, /, or \\.`,
+    );
+  }
+  return value;
+}
+
+export function validateEnum<T extends string>(
+  value: string,
+  allowed: readonly T[],
+  name: string,
+): T {
+  if (!allowed.includes(value as T)) {
+    throw new Error(
+      `Invalid ${name}: "${value}". Must be one of: ${allowed.join(", ")}`,
+    );
+  }
+  return value as T;
+}
+
+export function validateRequired(
+  value: string | undefined | null,
+  name: string,
+): string {
+  if (!value || value.trim() === "") {
+    throw new Error(`Missing required parameter: --${name}`);
+  }
+  return rejectControlChars(value.trim(), name);
+}