@ollie-shop/cli 1.2.2 → 1.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ollie-shop/cli",
-  "version": "1.2.2",
+  "version": "1.3.3",
   "description": "Ollie Shop CLI - Development tools for custom checkouts",
   "type": "module",
   "main": "dist/index.js",

package/src/cli.tsx

@@ -3,6 +3,9 @@ import { HelpCommand } from "./commands/help.js";
 import { LoginCommand } from "./commands/login.js";
 import { StartCommand } from "./commands/start.js";
 
+// Inlined by tsup at build time from package.json (see tsup.config.ts).
+declare const __OLLIE_CLI_VERSION__: string;
+
 interface AppProps {
   command: string;
   args: string[];
@@ -28,9 +31,13 @@ export function App({ command, args }: AppProps) {
 }
 
 function VersionCommand() {
+  const version =
+    typeof __OLLIE_CLI_VERSION__ === "string" && __OLLIE_CLI_VERSION__
+      ? __OLLIE_CLI_VERSION__
+      : "unknown";
   return (
     <Box>
-      <Text>ollie v0.1.0</Text>
+      <Text>ollieshop v{version}</Text>
     </Box>
   );
 }

package/src/commands/function-cmd.ts

@@ -17,6 +17,43 @@ import {
 
 const ON_ERROR_VALUES = ["throw", "skip"] as const;
 
+function parseTriggerFromFlags(
+  urlFlag: string | undefined,
+  expressionFlag: string | undefined,
+): { url: string; expression: string } | undefined {
+  if (urlFlag === undefined && expressionFlag === undefined) return undefined;
+  if (urlFlag === undefined || expressionFlag === undefined) {
+    throw new Error(
+      "Both --trigger-url and --trigger-expression are required when configuring a trigger.",
+    );
+  }
+  return {
+    url: validateTriggerUrl(urlFlag, "trigger-url"),
+    expression: validateRequired(expressionFlag, "trigger-expression"),
+  };
+}
+
+function parseTriggerFromData(
+  raw: unknown,
+): { url: string; expression: string } | undefined {
+  if (raw === undefined || raw === null) return undefined;
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(
+      'Invalid trigger: must be an object with "url" and "expression" string properties.',
+    );
+  }
+  const obj = raw as Record<string, unknown>;
+  if (typeof obj.url !== "string" || typeof obj.expression !== "string") {
+    throw new Error(
+      'Invalid trigger: both "url" and "expression" must be non-empty strings.',
+    );
+  }
+  return {
+    url: validateTriggerUrl(obj.url, "trigger.url"),
+    expression: validateRequired(obj.expression, "trigger.expression"),
+  };
+}
+
 export async function functionCommand(parsed: ParsedArgs): Promise<void> {
   const sub = parsed.subcommand;
   if (sub === "create") return functionCreateCommand(parsed);
@@ -35,7 +72,7 @@ async function functionCreateCommand(parsed: ParsedArgs): Promise<void> {
     let input: {
       versionId: string;
       name: string;
-      trigger?: string;
+      trigger?: { url: string; expression: string };
       active?: boolean;
       onError?: "throw" | "skip";
       priority?: number;
@@ -46,10 +83,7 @@ async function functionCreateCommand(parsed: ParsedArgs): Promise<void> {
       input = {
         versionId: validateUuid(raw.versionId, "versionId"),
         name: validateRequired(raw.name, "name"),
-        trigger:
-          raw.trigger !== undefined && raw.trigger !== null
-            ? validateTriggerUrl(String(raw.trigger), "trigger")
-            : undefined,
+        trigger: parseTriggerFromData(raw.trigger),
         active: raw.active === true,
         onError:
           raw.onError !== undefined && raw.onError !== null
@@ -61,7 +95,8 @@ async function functionCreateCommand(parsed: ParsedArgs): Promise<void> {
             : 0,
       };
     } else {
-      const triggerFlag = getFlag(parsed.flags, "trigger");
+      const triggerUrlFlag = getFlag(parsed.flags, "trigger-url");
+      const triggerExpressionFlag = getFlag(parsed.flags, "trigger-expression");
       const onErrorFlag = getFlag(parsed.flags, "on-error");
       const priorityFlag = getFlag(parsed.flags, "priority");
       input = {
@@ -70,10 +105,7 @@ async function functionCreateCommand(parsed: ParsedArgs): Promise<void> {
           "version-id",
         ),
         name: validateRequired(getFlag(parsed.flags, "name", "n"), "name"),
-        trigger:
-          triggerFlag !== undefined
-            ? validateTriggerUrl(triggerFlag, "trigger")
-            : undefined,
+        trigger: parseTriggerFromFlags(triggerUrlFlag, triggerExpressionFlag),
         active: getBoolFlag(parsed.flags, "active"),
         onError:
           onErrorFlag !== undefined

package/src/commands/help.tsx

@@ -41,7 +41,7 @@ export function HelpCommand() {
           <Box width={24}>
             <Text color="green">whoami</Text>
           </Box>
-          <Text>Show current user and organization</Text>
+          <Text>Show current user (and linked store/org from ollie.json)</Text>
         </Box>
         <Box>
           <Box width={24}>
@@ -153,6 +153,10 @@ export function HelpCommand() {
           $ ollieshop store create --name "My Store" --platform vtex
           --platform-store-id mystore
         </Text>
+        <Text dimColor>
+          $ ollieshop store create --org UUID --name "My Store" --platform vtex
+          --platform-store-id mystore
+        </Text>
         <Text dimColor>
           $ ollieshop store create --data{" "}
           {

package/src/commands/start.tsx

@@ -1,11 +1,10 @@
-import type { BuildContext, ServeOnRequestArgs } from "esbuild";
+import type { ServeOnRequestArgs } from "esbuild";
 import { Box, Text, useApp, useInput } from "ink";
 import open from "open";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { loadConfig, resolveStage } from "../utils/config.js";
 import {
   type ComponentInfo,
-  createBuildContext,
   discoverComponents,
   startDevServer,
 } from "../utils/esbuild.js";
@@ -55,7 +54,7 @@ export function StartCommand({ args }: StartCommandProps) {
   const [buildCount, setBuildCount] = useState(0);
   const [lastBuildTime, setLastBuildTime] = useState<Date | null>(null);
   const logIdRef = useRef(0);
-  const ctxRef = useRef<BuildContext | null>(null);
+  const rebuildRef = useRef<(() => Promise<void>) | null>(null);
   const stopRef = useRef<(() => Promise<void>) | null>(null);
 
   // Parse args
@@ -121,28 +120,19 @@ export function StartCommand({ args }: StartCommandProps) {
         setComponents(found);
         setState({ status: "building" });
 
-        // Create build context with discovered components
-        const ctx = await createBuildContext(found, {
+        // Start dev server
+        const server = await startDevServer({
+          port: PORT,
           stage,
+          onRequest: handleRequest,
           onBuildEnd: (updatedComponents) => {
             setComponents(updatedComponents);
             setBuildCount((c) => c + 1);
             setLastBuildTime(new Date());
           },
         });
-        ctxRef.current = ctx;
-
-        // Do initial build (manifest is written by the plugin)
-        await ctx.rebuild();
-
-        if (!mounted) return;
-
-        // Start dev server
-        const server = await startDevServer(ctx, {
-          port: PORT,
-          onRequest: handleRequest,
-        });
 
+        rebuildRef.current = server.rebuild;
         stopRef.current = server.stop;
 
         if (!mounted) {
@@ -190,7 +180,7 @@ export function StartCommand({ args }: StartCommandProps) {
 
     // Manual rebuild with 'r' (manifest is updated by the plugin)
     if (input === "r" && state.status === "running") {
-      ctxRef.current?.rebuild();
+      rebuildRef.current?.();
     }
 
     // Open Studio in browser with 'o'

package/src/commands/store-cmd.ts

@@ -7,7 +7,11 @@ import {
 } from "../utils/output.js";
 import { type ParsedArgs, getFlag } from "../utils/parse-args.js";
 import { getAuthenticatedClient } from "../utils/supabase.js";
-import { validateEnum, validateRequired } from "../utils/validate.js";
+import {
+  validateEnum,
+  validateRequired,
+  validateUuid,
+} from "../utils/validate.js";
 
 export async function storeCommand(parsed: ParsedArgs): Promise<void> {
   const sub = parsed.subcommand;
@@ -63,13 +67,16 @@ async function storeCreateCommand(parsed: ParsedArgs): Promise<void> {
       };
     }
 
+    const orgFlag = getFlag(parsed.flags, "org");
+    const orgId = orgFlag ? validateUuid(orgFlag, "org") : undefined;
+
     if (parsed.global.dryRun) {
-      outputDryRun("store.create", input, format);
+      outputDryRun("store.create", { ...input, orgId }, format);
       return;
     }
 
     const client = await getAuthenticatedClient();
-    const result = await createStore(client, input);
+    const result = await createStore(client, input, orgId);
 
     outputResult(result, format, parsed.global.fields);
     if (result.error) process.exit(1);
@@ -88,8 +95,11 @@ async function storeListCommand(parsed: ParsedArgs): Promise<void> {
   const format = detectOutputFormat(parsed.global.output);
 
   try {
+    const orgFlag = getFlag(parsed.flags, "org");
+    const orgId = orgFlag ? validateUuid(orgFlag, "org") : undefined;
+
     const client = await getAuthenticatedClient();
-    const result = await listStores(client);
+    const result = await listStores(client, orgId);
 
     outputResult(result, format, parsed.global.fields);
     if (result.error) process.exit(1);

package/src/commands/whoami.ts

@@ -1,6 +1,9 @@
+import { getStoreById } from "../core/store.js";
 import { getCurrentUser } from "../utils/auth.js";
+import { loadConfig, resolveStage } from "../utils/config.js";
 import { detectOutputFormat, outputResult } from "../utils/output.js";
 import type { ParsedArgs } from "../utils/parse-args.js";
+import { getAuthenticatedClient } from "../utils/supabase.js";
 
 export async function whoamiCommand(parsed: ParsedArgs): Promise<void> {
   const format = detectOutputFormat(parsed.global.output);
@@ -9,20 +12,78 @@ export async function whoamiCommand(parsed: ParsedArgs): Promise<void> {
   if (!user) {
     outputResult(
       {
-        error: { message: "Not logged in. Run `ollieshop login`." },
+        error: {
+          message: "Not logged in or session expired. Run `ollieshop login`.",
+        },
       },
       format,
     );
     process.exit(1);
   }
 
-  outputResult(
-    {
-      data: {
-        email: user.email,
+  try {
+    const stage = resolveStage(parsed.global.stage);
+    const config = await loadConfig({ stage });
+
+    // No project config: just report the authenticated user.
+    if (!config?.storeId) {
+      outputResult(
+        {
+          data: {
+            email: user.email,
+            hint: "No ollie.json found. Run `ollieshop init` to link a store.",
+          },
+        },
+        format,
+        parsed.global.fields,
+      );
+      return;
+    }
+
+    // Config present: resolve the store/org it points at, gated by access.
+    const client = await getAuthenticatedClient();
+    const result = await getStoreById(client, config.storeId);
+
+    if (result.error || !result.data) {
+      outputResult(
+        {
+          data: {
+            email: user.email,
+            storeId: config.storeId,
+            store: null,
+            note:
+              result.error?.message ??
+              "Store not found. Run `ollieshop login` or check the storeId in ollie.json.",
+          },
+        },
+        format,
+        parsed.global.fields,
+      );
+      return;
+    }
+
+    const store = result.data;
+    outputResult(
+      {
+        data: {
+          email: user.email,
+          orgId: store.organizationId,
+          org: store.organizationName,
+          storeId: store.id,
+          store: store.name,
+          ...(config.versionId ? { versionId: config.versionId } : {}),
+        },
       },
-    },
-    format,
-    parsed.global.fields,
-  );
+      format,
+      parsed.global.fields,
+    );
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) },
+      },
+      format,
+    );
+    process.exit(1);
+  }
 }

package/src/core/function.ts

@@ -4,7 +4,7 @@ import { functionCreateSchema } from "./schema.js";
 export interface CreateFunctionInput {
   versionId: string;
   name: string;
-  trigger?: string;
+  trigger?: { url: string; expression: string };
   active?: boolean;
   onError?: "throw" | "skip";
   priority?: number;

package/src/core/schema.ts

@@ -65,11 +65,16 @@ 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)
+    .object({
+      url: z.string().min(1).describe("Trigger URL — absolute http(s) URL"),
+      expression: z
+        .string()
+        .min(1)
+        .describe("JSONata-like match expression (e.g. 'method in [\"GET\"]')"),
+    })
     .optional()
     .describe(
-      "Function trigger URL — absolute http(s) URL or relative path starting with /",
+      "Function trigger — both url and expression are required together",
     ),
   active: z
     .boolean()

package/src/core/store.ts

@@ -1,5 +1,5 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
-import { getOrganizationId } from "../utils/supabase.js";
+import { getOrganizationId, unwrapToOne } from "../utils/supabase.js";
 import { storeCreateSchema } from "./schema.js";
 
 export interface CreateStoreInput {
@@ -24,6 +24,7 @@ export interface StoreRecord {
 export async function createStore(
   client: SupabaseClient,
   input: CreateStoreInput,
+  orgId?: string,
 ): Promise<{ data?: { id: string }; error?: { message: string } }> {
   // Validate input against schema
   const parsed = storeCreateSchema.safeParse(input);
@@ -33,7 +34,7 @@ export async function createStore(
     };
   }
 
-  const organizationId = await getOrganizationId(client);
+  const organizationId = await getOrganizationId(client, orgId);
 
   const { data, error } = await client
     .from("stores")
@@ -55,10 +56,56 @@ export async function createStore(
   return { data: { id: data.id } };
 }
 
+export interface StoreWithOrg {
+  id: string;
+  name: string;
+  organizationId: string;
+  organizationName: string | null;
+}
+
+// Resolves a store + org by id; RLS returns no row when the user lacks access.
+export async function getStoreById(
+  client: SupabaseClient,
+  storeId: string,
+): Promise<{ data?: StoreWithOrg; error?: { message: string } }> {
+  const { data, error } = await client
+    .from("stores")
+    .select("id, name, organization_id, organizations(id, name)")
+    .eq("id", storeId)
+    .maybeSingle();
+
+  if (error) {
+    return { error: { message: error.message } };
+  }
+
+  if (!data) {
+    return {
+      error: {
+        message: `Store ${storeId} not found or you don't have access to it.`,
+      },
+    };
+  }
+
+  const org = unwrapToOne<{ name?: string }>(
+    (data as { organizations?: unknown }).organizations,
+  );
+  const orgName = org?.name ?? null;
+
+  return {
+    data: {
+      id: data.id as string,
+      name: data.name as string,
+      organizationId: data.organization_id as string,
+      organizationName: orgName,
+    },
+  };
+}
+
 export async function listStores(
   client: SupabaseClient,
+  orgId?: string,
 ): Promise<{ data?: StoreRecord[]; error?: { message: string } }> {
-  const organizationId = await getOrganizationId(client);
+  const organizationId = await getOrganizationId(client, orgId);
 
   const { data, error } = await client
     .from("stores")

package/src/utils/auth.ts

@@ -231,6 +231,10 @@ export async function getCurrentUser(): Promise<{ email: string } | null> {
 
   try {
     const decoded = jwtDecode<JwtPayload>(credentials.accessToken);
+    // Reject expired sessions (local `exp` check; misses server-side revocation).
+    if (decoded.exp && decoded.exp * 1000 <= Date.now()) {
+      return null;
+    }
     return decoded.email ? { email: decoded.email } : null;
   } catch {
     return null;

package/src/utils/esbuild.ts

@@ -1,3 +1,4 @@
+import { watch } from "node:fs";
 import fs from "node:fs/promises";
 import http from "node:http";
 import path from "node:path";
@@ -221,32 +222,95 @@ export interface ServeResult {
 /**
  * Starts the esbuild serve + watch mode with a proxy server.
  * The proxy handles /bundle/:componentName requests and forwards others to esbuild.
- * Returns the server info and a way to stop it.
+ * Owns the esbuild context lifecycle and recreates it when a component folder is
+ * added or removed. Returns the server info, a manual rebuild, and a way to stop it.
  */
 export async function startDevServer(
-  ctx: esbuild.BuildContext,
   options: {
     port?: number;
     host?: string;
     cwd?: string;
+    stage?: string;
     onRequest?: (args: esbuild.ServeOnRequestArgs) => void;
-    onRebuild?: (result: esbuild.BuildResult) => void;
+    onBuildEnd?: (components: ComponentInfo[], result: BuildResult) => void;
   } = {},
-): Promise<ServeResult & { stop: () => Promise<void> }> {
-  const { port = 4000, host = "localhost", cwd = process.cwd() } = options;
+): Promise<
+  ServeResult & { rebuild: () => Promise<void>; stop: () => Promise<void> }
+> {
+  const {
+    port = 4000,
+    host = "localhost",
+    cwd = process.cwd(),
+    stage,
+    onRequest,
+    onBuildEnd,
+  } = options;
 
   const servedir = path.join(cwd, "node_modules/.ollie", "build");
+  const componentsDir = path.join(cwd, "components");
+  const internalPort = port + 1;
 
-  // Start watching for changes
-  await ctx.watch();
+  let ctx: esbuild.BuildContext | null = null;
+  let entryNames = new Set<string>();
 
-  // Start esbuild server on internal port (proxy will forward to it)
-  const internalPort = port + 1;
-  await ctx.serve({
-    port: internalPort,
-    host,
-    servedir,
-    onRequest: options.onRequest,
+  async function buildAndServe(components: ComponentInfo[]): Promise<void> {
+    entryNames = new Set(components.map((c) => c.name));
+    ctx = await createBuildContext(components, { cwd, stage, onBuildEnd });
+    await ctx.rebuild();
+    await ctx.watch();
+    await ctx.serve({ port: internalPort, host, servedir, onRequest });
+  }
+
+  async function recreate(): Promise<void> {
+    const components = await discoverComponents({ cwd, stage });
+    const oldCtx = ctx;
+    ctx = null;
+    if (oldCtx) await oldCtx.dispose();
+    await buildAndServe(components);
+  }
+
+  await buildAndServe(await discoverComponents({ cwd, stage }));
+
+  async function currentComponentNames(): Promise<Set<string>> {
+    try {
+      const entries = await glob("*/index.tsx", { cwd: componentsDir });
+      return new Set(entries.map((e) => path.dirname(e)));
+    } catch {
+      return new Set();
+    }
+  }
+
+  // Recreate the context when the set of component folders changes
+  let watchTimer: ReturnType<typeof setTimeout> | null = null;
+  let recreating = false;
+  let pending = false;
+
+  async function maybeRecreate(): Promise<void> {
+    if (recreating) {
+      pending = true;
+      return;
+    }
+    recreating = true;
+    try {
+      do {
+        pending = false;
+        const names = await currentComponentNames();
+        const changed =
+          names.size !== entryNames.size ||
+          [...names].some((n) => !entryNames.has(n));
+        if (!changed) break;
+        await recreate();
+      } while (pending);
+    } catch (err) {
+      console.error("[DevServer] Failed to reload components:", err);
+    } finally {
+      recreating = false;
+    }
+  }
+
+  const componentsWatcher = watch(componentsDir, { recursive: true }, () => {
+    if (watchTimer) clearTimeout(watchTimer);
+    watchTimer = setTimeout(maybeRecreate, 150);
   });
 
   // Create proxy server that handles /bundle/* and forwards to esbuild
@@ -356,6 +420,21 @@ export async function startDevServer(
             // File doesn't exist, start fresh
           }
 
+          if (
+            typeof updates.id === "string" &&
+            typeof existingMeta.id === "string" &&
+            existingMeta.id !== updates.id
+          ) {
+            res.statusCode = 409;
+            res.setHeader("Content-Type", "application/json");
+            res.end(
+              JSON.stringify({
+                error: `id mismatch: ${componentName} is linked to ${existingMeta.id}`,
+              }),
+            );
+            return;
+          }
+
           // Merge updates
           const newMeta = { ...existingMeta, ...updates };
 
@@ -435,9 +514,14 @@ export async function startDevServer(
   return {
     host,
     port,
+    rebuild: async () => {
+      await ctx?.rebuild();
+    },
     stop: async () => {
+      if (watchTimer) clearTimeout(watchTimer);
+      componentsWatcher.close();
       proxyServer.close();
-      await ctx.dispose();
+      await ctx?.dispose();
     },
   };
 }

package/src/utils/parse-args.ts

@@ -3,6 +3,7 @@ export interface GlobalFlags {
   dryRun: boolean;
   fields?: string[];
   data?: string;
+  stage?: string;
 }
 
 export interface ParsedArgs {
@@ -63,6 +64,7 @@ export function parseArgs(argv: string[]): ParsedArgs {
           .map((f) => f.trim())
       : undefined,
     data: (flags.data as string) || (flags.d as string) || undefined,
+    stage: (flags.stage as string) || (flags.s as string) || undefined,
   };
 
   return { command, subcommand, flags, global, positional };