@ollie-shop/cli 1.2.1 → 1.3.3

package/dist/index.js

@@ -36,7 +36,7 @@ function HelpCommand() {
     /* @__PURE__ */ jsxs(Box, { marginLeft: 2, flexDirection: "column", gap: 0, children: [
       /* @__PURE__ */ jsxs(Box, { children: [
         /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "whoami" }) }),
-        /* @__PURE__ */ jsx(Text, { children: "Show current user and organization" })
+        /* @__PURE__ */ jsx(Text, { children: "Show current user (and linked store/org from ollie.json)" })
       ] }),
       /* @__PURE__ */ jsxs(Box, { children: [
         /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "store create|list" }) }),
@@ -50,6 +50,10 @@ function HelpCommand() {
         /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "component create|list" }) }),
         /* @__PURE__ */ jsx(Text, { children: "Create or list components" })
       ] }),
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "function create|list" }) }),
+        /* @__PURE__ */ jsx(Text, { children: "Create or list functions" })
+      ] }),
       /* @__PURE__ */ jsxs(Box, { children: [
         /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "deploy" }) }),
         /* @__PURE__ */ jsx(Text, { children: "Bundle and upload a component/function build" })
@@ -112,6 +116,7 @@ function HelpCommand() {
       /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop whoami -o json" }),
       /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop schema store.create" }),
       /* @__PURE__ */ jsx(Text, { dimColor: true, children: '$ ollieshop store create --name "My Store" --platform vtex --platform-store-id mystore' }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: '$ ollieshop store create --org UUID --name "My Store" --platform vtex --platform-store-id mystore' }),
       /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
         "$ ollieshop store create --data",
         " ",
@@ -121,6 +126,7 @@ function HelpCommand() {
       ] }),
       /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop version create --store-id UUID --name v1 --active" }),
       /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop init --store-id UUID --version-id UUID" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop function create --version-id UUID --name myHook" }),
       /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop deploy --component-id UUID --name FreeShippingBar --wait" }),
       /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop status --build-id BUILD_ID --wait -o json" })
     ] })
@@ -299,6 +305,9 @@ async function getCurrentUser() {
   if (!credentials) return null;
   try {
     const decoded = jwtDecode(credentials.accessToken);
+    if (decoded.exp && decoded.exp * 1e3 <= Date.now()) {
+      return null;
+    }
     return decoded.email ? { email: decoded.email } : null;
   } catch {
     return null;
@@ -434,6 +443,7 @@ function resolveStage(cliStage) {
 }
 
 // src/utils/esbuild.ts
+import { watch } from "fs";
 import fs4 from "fs/promises";
 import http from "http";
 import path4 from "path";
@@ -658,16 +668,69 @@ async function createBuildContext(components, options = {}) {
   });
   return ctx;
 }
-async function startDevServer(ctx, options = {}) {
-  const { port = 4e3, host = "localhost", cwd = process.cwd() } = options;
+async function startDevServer(options = {}) {
+  const {
+    port = 4e3,
+    host = "localhost",
+    cwd = process.cwd(),
+    stage,
+    onRequest,
+    onBuildEnd
+  } = options;
   const servedir = path4.join(cwd, "node_modules/.ollie", "build");
-  await ctx.watch();
+  const componentsDir = path4.join(cwd, "components");
   const internalPort = port + 1;
-  await ctx.serve({
-    port: internalPort,
-    host,
-    servedir,
-    onRequest: options.onRequest
+  let ctx = null;
+  let entryNames = /* @__PURE__ */ new Set();
+  async function buildAndServe(components) {
+    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() {
+    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() {
+    try {
+      const entries = await glob("*/index.tsx", { cwd: componentsDir });
+      return new Set(entries.map((e) => path4.dirname(e)));
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
+  }
+  let watchTimer = null;
+  let recreating = false;
+  let pending = false;
+  async function maybeRecreate() {
+    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);
   });
   const proxyServer = http.createServer(async (req, res) => {
     const url = new URL(req.url || "/", `http://${host}:${port}`);
@@ -751,6 +814,16 @@ async function startDevServer(ctx, options = {}) {
             existingMeta = JSON.parse(content);
           } catch {
           }
+          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;
+          }
           const newMeta = { ...existingMeta, ...updates };
           await fs4.writeFile(metaPath, JSON.stringify(newMeta, null, 2));
           res.setHeader("Content-Type", "application/json");
@@ -812,9 +885,14 @@ async function startDevServer(ctx, options = {}) {
   return {
     host,
     port,
+    rebuild: async () => {
+      await ctx?.rebuild();
+    },
     stop: async () => {
+      if (watchTimer) clearTimeout(watchTimer);
+      componentsWatcher.close();
       proxyServer.close();
-      await ctx.dispose();
+      await ctx?.dispose();
     }
   };
 }
@@ -864,7 +942,7 @@ function StartCommand({ args }) {
   const [buildCount, setBuildCount] = useState2(0);
   const [lastBuildTime, setLastBuildTime] = useState2(null);
   const logIdRef = useRef(0);
-  const ctxRef = useRef(null);
+  const rebuildRef = useRef(null);
   const stopRef = useRef(null);
   const stage = resolveStage(parseArg(args, "--stage", "-s"));
   const addLog = useCallback((log) => {
@@ -914,21 +992,17 @@ function StartCommand({ args }) {
         }
         setComponents(found);
         setState({ status: "building" });
-        const ctx = await createBuildContext(found, {
+        const server = await startDevServer({
+          port: PORT,
           stage,
+          onRequest: handleRequest,
           onBuildEnd: (updatedComponents) => {
             setComponents(updatedComponents);
             setBuildCount((c) => c + 1);
             setLastBuildTime(/* @__PURE__ */ new Date());
           }
         });
-        ctxRef.current = ctx;
-        await ctx.rebuild();
-        if (!mounted) return;
-        const server = await startDevServer(ctx, {
-          port: PORT,
-          onRequest: handleRequest
-        });
+        rebuildRef.current = server.rebuild;
         stopRef.current = server.stop;
         if (!mounted) {
           await server.stop();
@@ -966,7 +1040,7 @@ function StartCommand({ args }) {
       stopRef.current?.().then(() => exit());
     }
     if (input === "r" && state.status === "running") {
-      ctxRef.current?.rebuild();
+      rebuildRef.current?.();
     }
     if (input === "o" && state.status === "running") {
       const studioUrl = new URL(STUDIO_BASE_URL);
@@ -1172,7 +1246,11 @@ function App({ command, args }) {
   }
 }
 function VersionCommand() {
-  return /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsx4(Text4, { children: "ollie v0.1.0" }) });
+  const version = "1.3.3" ? "1.3.3" : "unknown";
+  return /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { children: [
+    "ollieshop v",
+    version
+  ] }) });
 }
 function UnknownCommand({ command }) {
   return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", gap: 1, children: [
@@ -1372,7 +1450,8 @@ function parseArgs(argv) {
     output: flags.output || flags.o || void 0,
     dryRun: flags["dry-run"] === true,
     fields: flags.fields ? String(flags.fields).split(",").map((f) => f.trim()) : void 0,
-    data: flags.data || flags.d || void 0
+    data: flags.data || flags.d || void 0,
+    stage: flags.stage || flags.s || void 0
   };
   return { command, subcommand, flags, global, positional };
 }
@@ -1392,13 +1471,33 @@ function getBoolFlag(flags, ...names) {
 
 // src/utils/supabase.ts
 import { createClient } from "@supabase/supabase-js";
+var PROD_DEFAULTS = {
+  supabaseUrl: "https://aazahtmqrhjqsyqoqdkm.supabase.co",
+  supabaseAnonKey: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImFhemFodG1xcmhqcXN5cW9xZGttIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDg2MzEwOTcsImV4cCI6MjA2NDIwNzA5N30.VuAbAyjDe0HcL09SZtQ-UmP1o7Z6qwGuOtvfFhnyAcM",
+  builderUrl: "https://api.ollie.shop/builder/v1"
+};
+function envOrDefault(envValue, buildTimeValue, prodDefault) {
+  return envValue || buildTimeValue || prodDefault;
+}
+function unwrapToOne(embed) {
+  const record = Array.isArray(embed) ? embed[0] : embed;
+  return record && typeof record === "object" ? record : null;
+}
 async function getAuthenticatedClient() {
   const credentials = await getCredentials();
   if (!credentials) {
     throw new Error("Not authenticated. Run `ollieshop login` first.");
   }
-  const supabaseUrl = process.env.OLLIE_SUPABASE_URL || "https://aazahtmqrhjqsyqoqdkm.supabase.co";
-  const supabaseAnonKey = process.env.OLLIE_SUPABASE_ANON_KEY || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImFhemFodG1xcmhqcXN5cW9xZGttIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDg2MzEwOTcsImV4cCI6MjA2NDIwNzA5N30.VuAbAyjDe0HcL09SZtQ-UmP1o7Z6qwGuOtvfFhnyAcM";
+  const supabaseUrl = envOrDefault(
+    process.env.OLLIE_SUPABASE_URL,
+    "https://aazahtmqrhjqsyqoqdkm.supabase.co",
+    PROD_DEFAULTS.supabaseUrl
+  );
+  const supabaseAnonKey = envOrDefault(
+    process.env.OLLIE_SUPABASE_ANON_KEY,
+    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImFhemFodG1xcmhqcXN5cW9xZGttIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDg2MzEwOTcsImV4cCI6MjA2NDIwNzA5N30.VuAbAyjDe0HcL09SZtQ-UmP1o7Z6qwGuOtvfFhnyAcM",
+    PROD_DEFAULTS.supabaseAnonKey
+  );
   const client = createClient(supabaseUrl, supabaseAnonKey, {
     auth: {
       autoRefreshToken: false,
@@ -1412,7 +1511,11 @@ async function getAuthenticatedClient() {
   return client;
 }
 function getBuilderUrl() {
-  return process.env.OLLIE_BUILDER_URL || "";
+  return envOrDefault(
+    process.env.OLLIE_BUILDER_URL,
+    "",
+    PROD_DEFAULTS.builderUrl
+  );
 }
 async function getAuthToken() {
   const credentials = await getCredentials();
@@ -1421,17 +1524,35 @@ async function getAuthToken() {
   }
   return credentials.accessToken;
 }
-async function getOrganizationId(client) {
-  const { data: org, error } = await client.from("organizations").select("id").order("created_at", { ascending: true }).limit(1).maybeSingle();
+async function getOrganizationId(client, preferredOrgId) {
+  const { data: orgs, error } = await client.from("organizations").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:
+${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:
+${list}`
+    );
+  }
+  return orgs[0].id;
 }
 
 // src/utils/validate.ts
@@ -1467,6 +1588,39 @@ function validateRequired(value, name) {
   }
   return rejectControlChars(value.trim(), name);
 }
+function validateInteger(value, name, opts) {
+  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 !== void 0 && n < opts.min) {
+    throw new Error(`Invalid ${name}: ${n}. Must be >= ${opts.min}.`);
+  }
+  return n;
+}
+function validateTriggerUrl(value, name) {
+  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 parsed2 = new URL(trimmed);
+    if (parsed2.protocol !== "http:" && parsed2.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 "/".`
+    );
+  }
+}
 
 // src/commands/business-rule-cmd.ts
 async function businessRuleCommand(parsed2) {
@@ -1625,8 +1779,15 @@ var componentListSchema = z2.object({
 var functionCreateSchema = z2.object({
   versionId: z2.string().uuid().describe("Parent version UUID"),
   name: z2.string().min(1).describe("Function name"),
-  trigger: z2.string().min(1).describe("Function trigger (e.g. beforePayment, afterShipping)"),
-  active: z2.boolean().default(true).describe("Whether function is active")
+  trigger: z2.object({
+    url: z2.string().min(1).describe("Trigger URL \u2014 absolute http(s) URL"),
+    expression: z2.string().min(1).describe(`JSONata-like match expression (e.g. 'method in ["GET"]')`)
+  }).optional().describe(
+    "Function trigger \u2014 both url and expression are required together"
+  ),
+  active: z2.boolean().default(false).describe("Whether function is active (default: false)"),
+  onError: z2.enum(["throw", "skip"]).optional().describe("Error handling: throw (default) or skip"),
+  priority: z2.number().int().min(0).optional().describe("Execution order priority (default: 0)")
 });
 var functionListSchema = z2.object({
   versionId: z2.string().uuid().describe("Version UUID to list functions for")
@@ -2005,6 +2166,168 @@ async function deployCommand(parsed2) {
   }
 }
 
+// src/core/function.ts
+async function createFunction(client, input) {
+  const parsed2 = functionCreateSchema.safeParse(input);
+  if (!parsed2.success) {
+    return {
+      success: false,
+      error: {
+        message: parsed2.error.issues.map((i) => i.message).join("; ")
+      }
+    };
+  }
+  const { data, error } = await client.from("functions").insert({
+    name: parsed2.data.name,
+    active: parsed2.data.active,
+    version_id: parsed2.data.versionId,
+    trigger: parsed2.data.trigger ?? null,
+    on_error: parsed2.data.onError ?? "throw",
+    priority: parsed2.data.priority ?? 0
+  }).select("id").single();
+  if (error) {
+    return { success: false, error: { message: error.message } };
+  }
+  return { success: true, data: { id: data.id } };
+}
+async function listFunctions(client, storeId, versionId) {
+  let query = client.from("functions").select(
+    "id, name, active, urn, on_error, priority, trigger, invocation, version_id, created_at, versions!inner(id, name)"
+  ).eq("versions.store_id", storeId);
+  if (versionId) {
+    query = query.eq("versions.id", versionId);
+  }
+  const { data, error } = await query;
+  if (error) {
+    return { success: false, error: { message: error.message } };
+  }
+  return { success: true, data: data ?? [] };
+}
+
+// src/commands/function-cmd.ts
+var ON_ERROR_VALUES = ["throw", "skip"];
+function parseTriggerFromFlags(urlFlag, expressionFlag) {
+  if (urlFlag === void 0 && expressionFlag === void 0) return void 0;
+  if (urlFlag === void 0 || expressionFlag === void 0) {
+    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) {
+  if (raw === void 0 || raw === null) return void 0;
+  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;
+  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")
+  };
+}
+async function functionCommand(parsed2) {
+  const sub = parsed2.subcommand;
+  if (sub === "create") return functionCreateCommand(parsed2);
+  if (sub === "list" || sub === "ls") return functionListCommand(parsed2);
+  console.error(
+    `Unknown function subcommand: ${sub}. Use: function create | function list`
+  );
+  process.exit(1);
+}
+async function functionCreateCommand(parsed2) {
+  const format = detectOutputFormat(parsed2.global.output);
+  try {
+    let input;
+    if (parsed2.global.data) {
+      const raw = JSON.parse(parsed2.global.data);
+      input = {
+        versionId: validateUuid(raw.versionId, "versionId"),
+        name: validateRequired(raw.name, "name"),
+        trigger: parseTriggerFromData(raw.trigger),
+        active: raw.active === true,
+        onError: raw.onError !== void 0 && raw.onError !== null ? validateEnum(String(raw.onError), ON_ERROR_VALUES, "on-error") : "throw",
+        priority: raw.priority !== void 0 && raw.priority !== null ? validateInteger(raw.priority, "priority", { min: 0 }) : 0
+      };
+    } else {
+      const triggerUrlFlag = getFlag(parsed2.flags, "trigger-url");
+      const triggerExpressionFlag = getFlag(parsed2.flags, "trigger-expression");
+      const onErrorFlag = getFlag(parsed2.flags, "on-error");
+      const priorityFlag = getFlag(parsed2.flags, "priority");
+      input = {
+        versionId: validateUuid(
+          validateRequired(getFlag(parsed2.flags, "version-id"), "version-id"),
+          "version-id"
+        ),
+        name: validateRequired(getFlag(parsed2.flags, "name", "n"), "name"),
+        trigger: parseTriggerFromFlags(triggerUrlFlag, triggerExpressionFlag),
+        active: getBoolFlag(parsed2.flags, "active"),
+        onError: onErrorFlag !== void 0 ? validateEnum(onErrorFlag, ON_ERROR_VALUES, "on-error") : "throw",
+        priority: priorityFlag !== void 0 ? validateInteger(priorityFlag, "priority", { min: 0 }) : 0
+      };
+    }
+    const validated = functionCreateSchema.safeParse(input);
+    if (!validated.success) {
+      throw new Error(validated.error.issues.map((i) => i.message).join("; "));
+    }
+    if (parsed2.global.dryRun) {
+      outputDryRun(
+        "function.create",
+        validated.data,
+        format
+      );
+      return;
+    }
+    const client = await getAuthenticatedClient();
+    const result = await createFunction(client, validated.data);
+    outputResult(result, format, parsed2.global.fields);
+    if (!result.success) process.exit(1);
+  } catch (err) {
+    outputResult(
+      {
+        success: false,
+        error: { message: err instanceof Error ? err.message : String(err) }
+      },
+      format
+    );
+    process.exit(1);
+  }
+}
+async function functionListCommand(parsed2) {
+  const format = detectOutputFormat(parsed2.global.output);
+  try {
+    const storeId = validateUuid(
+      validateRequired(getFlag(parsed2.flags, "store-id"), "store-id"),
+      "store-id"
+    );
+    const versionId = getFlag(parsed2.flags, "version-id");
+    if (versionId) validateUuid(versionId, "version-id");
+    const client = await getAuthenticatedClient();
+    const result = await listFunctions(client, storeId, versionId);
+    outputResult(result, format, parsed2.global.fields);
+    if (!result.success) process.exit(1);
+  } catch (err) {
+    outputResult(
+      {
+        success: false,
+        error: { message: err instanceof Error ? err.message : String(err) }
+      },
+      format
+    );
+    process.exit(1);
+  }
+}
+
 // src/commands/init-cmd.ts
 async function initCommand(parsed2) {
   const format = detectOutputFormat(parsed2.global.output);
@@ -2131,14 +2454,14 @@ async function statusCommand(parsed2) {
 }
 
 // src/core/store.ts
-async function createStore(client, input) {
+async function createStore(client, input, orgId) {
   const parsed2 = storeCreateSchema.safeParse(input);
   if (!parsed2.success) {
     return {
       error: { message: parsed2.error.issues.map((i) => i.message).join("; ") }
     };
   }
-  const organizationId = await getOrganizationId(client);
+  const organizationId = await getOrganizationId(client, orgId);
   const { data, error } = await client.from("stores").insert({
     name: parsed2.data.name,
     platform: parsed2.data.platform,
@@ -2152,8 +2475,33 @@ async function createStore(client, input) {
   }
   return { data: { id: data.id } };
 }
-async function listStores(client) {
-  const organizationId = await getOrganizationId(client);
+async function getStoreById(client, storeId) {
+  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(
+    data.organizations
+  );
+  const orgName = org?.name ?? null;
+  return {
+    data: {
+      id: data.id,
+      name: data.name,
+      organizationId: data.organization_id,
+      organizationName: orgName
+    }
+  };
+}
+async function listStores(client, orgId) {
+  const organizationId = await getOrganizationId(client, orgId);
   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 });
@@ -2205,12 +2553,14 @@ async function storeCreateCommand(parsed2) {
         settings: getFlag(parsed2.flags, "settings")
       };
     }
+    const orgFlag = getFlag(parsed2.flags, "org");
+    const orgId = orgFlag ? validateUuid(orgFlag, "org") : void 0;
     if (parsed2.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, parsed2.global.fields);
     if (result.error) process.exit(1);
   } catch (err) {
@@ -2226,8 +2576,10 @@ async function storeCreateCommand(parsed2) {
 async function storeListCommand(parsed2) {
   const format = detectOutputFormat(parsed2.global.output);
   try {
+    const orgFlag = getFlag(parsed2.flags, "org");
+    const orgId = orgFlag ? validateUuid(orgFlag, "org") : void 0;
     const client = await getAuthenticatedClient();
-    const result = await listStores(client);
+    const result = await listStores(client, orgId);
     outputResult(result, format, parsed2.global.fields);
     if (result.error) process.exit(1);
   } catch (err) {
@@ -2351,21 +2703,71 @@ async function whoamiCommand(parsed2) {
   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);
+  }
+  try {
+    const stage = resolveStage(parsed2.global.stage);
+    const config = await loadConfig({ stage });
+    if (!config?.storeId) {
+      outputResult(
+        {
+          data: {
+            email: user.email,
+            hint: "No ollie.json found. Run `ollieshop init` to link a store."
+          }
+        },
+        format,
+        parsed2.global.fields
+      );
+      return;
+    }
+    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,
+        parsed2.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,
+      parsed2.global.fields
+    );
+  } catch (err) {
+    outputResult(
+      {
+        error: { message: err instanceof Error ? err.message : String(err) }
       },
       format
     );
     process.exit(1);
   }
-  outputResult(
-    {
-      data: {
-        email: user.email
-      }
-    },
-    format,
-    parsed2.global.fields
-  );
 }
 
 // src/index.tsx
@@ -2376,6 +2778,7 @@ var AGENT_COMMANDS = {
   version: versionCommand,
   component: componentCommand,
   "business-rule": businessRuleCommand,
+  function: functionCommand,
   schema: schemaCommand,
   init: initCommand,
   deploy: deployCommand,