@ollie-shop/cli 1.2.2 → 1.4.0

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}>
@@ -139,6 +139,12 @@ export function HelpCommand() {
           </Box>
           <Text>Config stage (loads ollie.{"{stage}"}.json)</Text>
         </Box>
+        <Box>
+          <Box width={24}>
+            <Text color="yellow">--no-open</Text>
+          </Box>
+          <Text>start: don't auto-open Studio (also honored via CI env)</Text>
+        </Box>
       </Box>
 
       <Box marginTop={1}>
@@ -147,12 +153,17 @@ export function HelpCommand() {
       <Box marginLeft={2} flexDirection="column">
         <Text dimColor>$ ollieshop login</Text>
         <Text dimColor>$ ollieshop start --stage dev</Text>
+        <Text dimColor>$ ollieshop start --no-open</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 --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,11 +54,20 @@ 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
   const stage = resolveStage(parseArg(args, "--stage", "-s"));
+  // Suppress auto-opening Studio in the browser (Storybook-style). Useful when an
+  // agent spawns the dev server and drives its own harness instead. Also honored
+  // via the conventional CI env var.
+  const noOpen = args.includes("--no-open") || Boolean(process.env.CI);
+  // Keyboard shortcuts need raw mode, which Ink can only enable on a TTY stdin.
+  // When spawned headless (agent/CI/backgrounded), stdin isn't a TTY — guard the
+  // input handler so the server runs instead of crashing with "Raw mode is not
+  // supported on the current process.stdin".
+  const isInteractive = Boolean(process.stdin.isTTY);
 
   const addLog = useCallback((log: Omit<RequestLog, "id" | "timestamp">) => {
     setLogs((prev) => {
@@ -121,28 +129,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) {
@@ -158,13 +157,15 @@ export function StartCommand({ args }: StartCommandProps) {
           versionId: config.versionId,
         });
 
-        // Open Studio in browser
-        const studioUrl = new URL(STUDIO_BASE_URL);
-        studioUrl.searchParams.set("storeId", config.storeId);
-        if (config.versionId) {
-          studioUrl.searchParams.set("versionId", config.versionId);
+        // Open Studio in browser (unless suppressed)
+        if (!noOpen) {
+          const studioUrl = new URL(STUDIO_BASE_URL);
+          studioUrl.searchParams.set("storeId", config.storeId);
+          if (config.versionId) {
+            studioUrl.searchParams.set("versionId", config.versionId);
+          }
+          open(studioUrl.toString());
         }
-        open(studioUrl.toString());
       } catch (error) {
         if (!mounted) return;
         setState({
@@ -180,29 +181,32 @@ export function StartCommand({ args }: StartCommandProps) {
       mounted = false;
       stopRef.current?.();
     };
-  }, [stage, handleRequest]);
+  }, [stage, handleRequest, noOpen]);
 
-  // Handle keyboard input
-  useInput((input, key) => {
-    if (input === "q" || (input === "c" && key.ctrl)) {
-      stopRef.current?.().then(() => exit());
-    }
+  // Handle keyboard input (only when attached to a TTY — see isInteractive above)
+  useInput(
+    (input, key) => {
+      if (input === "q" || (input === "c" && key.ctrl)) {
+        stopRef.current?.().then(() => exit());
+      }
 
-    // Manual rebuild with 'r' (manifest is updated by the plugin)
-    if (input === "r" && state.status === "running") {
-      ctxRef.current?.rebuild();
-    }
+      // Manual rebuild with 'r' (manifest is updated by the plugin)
+      if (input === "r" && state.status === "running") {
+        rebuildRef.current?.();
+      }
 
-    // Open Studio in browser with 'o'
-    if (input === "o" && state.status === "running") {
-      const studioUrl = new URL(STUDIO_BASE_URL);
-      studioUrl.searchParams.set("storeId", state.storeId);
-      if (state.versionId) {
-        studioUrl.searchParams.set("versionId", state.versionId);
+      // Open Studio in browser with 'o'
+      if (input === "o" && state.status === "running") {
+        const studioUrl = new URL(STUDIO_BASE_URL);
+        studioUrl.searchParams.set("storeId", state.storeId);
+        if (state.versionId) {
+          studioUrl.searchParams.set("versionId", state.versionId);
+        }
+        open(studioUrl.toString());
       }
-      open(studioUrl.toString());
-    }
-  });
+    },
+    { isActive: isInteractive },
+  );
 
   return (
     <Box flexDirection="column" gap={1}>
@@ -246,11 +250,12 @@ export function StartCommand({ args }: StartCommandProps) {
             stage={stage}
             storeId={state.storeId}
             versionId={state.versionId}
+            noOpen={noOpen}
           />
           <ComponentList components={components} />
           <BuildInfo buildCount={buildCount} lastBuildTime={lastBuildTime} />
           <RequestLogs logs={logs} />
-          <Footer />
+          <Footer interactive={isInteractive} />
         </>
       )}
     </Box>
@@ -274,12 +279,14 @@ function ServerInfo({
   stage,
   storeId,
   versionId,
+  noOpen,
 }: {
   host: string;
   port: number;
   stage?: string;
   storeId: string;
   versionId?: string;
+  noOpen?: boolean;
 }) {
   const studioUrl = new URL(STUDIO_BASE_URL);
 
@@ -311,6 +318,7 @@ function ServerInfo({
         <Text bold color="magenta">
           {studioUrl.toString()}
         </Text>
+        {noOpen && <Text dimColor> (auto-open off — press o)</Text>}
       </Box>
       <Box marginLeft={2} marginTop={1}>
         <Text dimColor>
@@ -396,7 +404,15 @@ function RequestLogs({ logs }: { logs: RequestLog[] }) {
   );
 }
 
-function Footer() {
+function Footer({ interactive = true }: { interactive?: boolean }) {
+  if (!interactive) {
+    return (
+      <Box marginTop={1} borderStyle="single" borderColor="gray" paddingX={1}>
+        <Text dimColor>Headless (no TTY) — Ctrl+C to stop</Text>
+      </Box>
+    );
+  }
+
   return (
     <Box marginTop={1} borderStyle="single" borderColor="gray" paddingX={1}>
       <Text dimColor>Press </Text>

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;