@ollie-shop/cli 1.2.1 → 1.3.3

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 };

package/src/utils/supabase.ts

@@ -6,15 +6,49 @@ declare const __OLLIE_SUPABASE_URL__: string;
 declare const __OLLIE_SUPABASE_ANON_KEY__: string;
 declare const __OLLIE_BUILDER_URL__: string;
 
+// Resolution order: runtime env var > CI build-time inline > prod default.
+// Baked-in defaults ensure `ollieshop` works zero-config when CI inject is
+// missing or stale. All three values are public (anon Supabase key, public
+// API URLs) so inlining them carries no secret-leak risk.
+const PROD_DEFAULTS = {
+  supabaseUrl: "https://aazahtmqrhjqsyqoqdkm.supabase.co",
+  supabaseAnonKey:
+    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImFhemFodG1xcmhqcXN5cW9xZGttIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDg2MzEwOTcsImV4cCI6MjA2NDIwNzA5N30.VuAbAyjDe0HcL09SZtQ-UmP1o7Z6qwGuOtvfFhnyAcM",
+  builderUrl: "https://api.ollie.shop/builder/v1",
+};
+
+function envOrDefault(
+  envValue: string | undefined,
+  buildTimeValue: string,
+  prodDefault: string,
+): string {
+  return envValue || buildTimeValue || prodDefault;
+}
+
+// Collapses a Supabase to-one embed (object, array, or null) to a single record.
+export function unwrapToOne<T = Record<string, unknown>>(
+  embed: unknown,
+): T | null {
+  const record = Array.isArray(embed) ? embed[0] : embed;
+  return record && typeof record === "object" ? (record as T) : null;
+}
+
 export async function getAuthenticatedClient(): Promise<SupabaseClient> {
   const credentials = await getCredentials();
   if (!credentials) {
     throw new Error("Not authenticated. Run `ollieshop login` first.");
   }
 
-  const supabaseUrl = process.env.OLLIE_SUPABASE_URL || __OLLIE_SUPABASE_URL__;
-  const supabaseAnonKey =
-    process.env.OLLIE_SUPABASE_ANON_KEY || __OLLIE_SUPABASE_ANON_KEY__;
+  const supabaseUrl = envOrDefault(
+    process.env.OLLIE_SUPABASE_URL,
+    __OLLIE_SUPABASE_URL__,
+    PROD_DEFAULTS.supabaseUrl,
+  );
+  const supabaseAnonKey = envOrDefault(
+    process.env.OLLIE_SUPABASE_ANON_KEY,
+    __OLLIE_SUPABASE_ANON_KEY__,
+    PROD_DEFAULTS.supabaseAnonKey,
+  );
 
   const client = createClient(supabaseUrl, supabaseAnonKey, {
     auth: {
@@ -32,7 +66,11 @@ export async function getAuthenticatedClient(): Promise<SupabaseClient> {
 }
 
 export function getBuilderUrl(): string {
-  return process.env.OLLIE_BUILDER_URL || __OLLIE_BUILDER_URL__;
+  return envOrDefault(
+    process.env.OLLIE_BUILDER_URL,
+    __OLLIE_BUILDER_URL__,
+    PROD_DEFAULTS.builderUrl,
+  );
 }
 
 export async function getAuthToken(): Promise<string> {
@@ -45,23 +83,40 @@ export async function getAuthToken(): Promise<string> {
 
 export async function getOrganizationId(
   client: SupabaseClient,
+  preferredOrgId?: string,
 ): Promise<string> {
-  const { data: org, error } = await client
+  const { data: orgs, error } = await client
     .from("organizations")
-    .select("id")
-    .order("created_at", { ascending: true })
-    .limit(1)
-    .maybeSingle();
+    .select("id, name")
+    .order("created_at", { ascending: true });
 
   if (error) {
     throw new Error(`Failed to get organization: ${error.message}`);
   }
 
-  if (!org) {
+  if (!orgs || orgs.length === 0) {
     throw new Error(
       "No organization found for your account. Create one at https://admin.ollie.shop",
     );
   }
 
-  return org.id;
+  if (preferredOrgId) {
+    const match = orgs.find((o) => o.id === preferredOrgId);
+    if (!match) {
+      const list = orgs.map((o) => `  - ${o.id}  ${o.name}`).join("\n");
+      throw new Error(
+        `Organization ${preferredOrgId} not found or you are not a member. Orgs you can access:\n${list}`,
+      );
+    }
+    return match.id;
+  }
+
+  if (orgs.length > 1) {
+    const list = orgs.map((o) => `  - ${o.id}  ${o.name}`).join("\n");
+    throw new Error(
+      `You belong to multiple organizations. Pass --org <id> to select one:\n${list}`,
+    );
+  }
+
+  return orgs[0].id;
 }

package/src/utils/validate.ts

@@ -56,3 +56,47 @@ export function validateRequired(
   }
   return rejectControlChars(value.trim(), name);
 }
+
+export function validateInteger(
+  value: unknown,
+  name: string,
+  opts?: { min?: number },
+): number {
+  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 !== undefined && n < opts.min) {
+    throw new Error(`Invalid ${name}: ${n}. Must be >= ${opts.min}.`);
+  }
+  return n;
+}
+
+export function validateTriggerUrl(value: string, name: string): string {
+  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 parsed = new URL(trimmed);
+    if (parsed.protocol !== "http:" && parsed.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 "/".`,
+    );
+  }
+}

package/tsup.config.ts

@@ -1,9 +1,15 @@
+import { readFileSync } from "node:fs";
 import { defineConfig } from "tsup";
 
 // CI injects SUPABASE_URL/SUPABASE_ANON_KEY/BUILDER_URL from GH Actions vars;
 // locally they're empty and the CLI falls back to runtime process.env.
 const env = (k: string) => JSON.stringify(process.env[k] ?? "");
 
+// Inline the package version at build time so `-v`/`--version` report the real version.
+const pkg = JSON.parse(
+  readFileSync(new URL("./package.json", import.meta.url), "utf8"),
+);
+
 export default defineConfig({
   entry: ["src/index.tsx"],
   format: ["esm"],
@@ -16,5 +22,6 @@ export default defineConfig({
     __OLLIE_SUPABASE_URL__: env("SUPABASE_URL"),
     __OLLIE_SUPABASE_ANON_KEY__: env("SUPABASE_ANON_KEY"),
     __OLLIE_BUILDER_URL__: env("BUILDER_URL"),
+    __OLLIE_CLI_VERSION__: JSON.stringify(pkg.version),
   },
 });