@ollie-shop/cli 1.4.1 → 1.6.0

package/dist/index.js

@@ -70,6 +70,10 @@ function HelpCommand() {
         /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "init" }) }),
         /* @__PURE__ */ jsx(Text, { children: "Write store/version IDs to ollie.json" })
       ] }),
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "setup" }) }),
+        /* @__PURE__ */ jsx(Text, { children: "Migrate legacy meta.json into the config components map" })
+      ] }),
       /* @__PURE__ */ jsxs(Box, { children: [
         /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "green", children: "help" }) }),
         /* @__PURE__ */ jsx(Text, { children: "Show this help message" })
@@ -111,6 +115,10 @@ function HelpCommand() {
       /* @__PURE__ */ jsxs(Box, { children: [
         /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "yellow", children: "--no-open" }) }),
         /* @__PURE__ */ jsx(Text, { children: "start: don't auto-open Studio (also honored via CI env)" })
+      ] }),
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Box, { width: 24, children: /* @__PURE__ */ jsx(Text, { color: "yellow", children: "--browser-logs" }) }),
+        /* @__PURE__ */ jsx(Text, { children: "start: stream custom components' browser console to terminal" })
       ] })
     ] }),
     /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, children: "Examples:" }) }),
@@ -118,6 +126,7 @@ function HelpCommand() {
       /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop login" }),
       /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop start --stage dev" }),
       /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop start --no-open" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "$ ollieshop start --browser-logs" }),
       /* @__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' }),
@@ -386,9 +395,14 @@ import { useCallback, useEffect as useEffect2, useRef, useState as useState2 } f
 import fs2 from "fs/promises";
 import path2 from "path";
 import { z } from "zod";
+var ComponentEntrySchema = z.object({
+  path: z.string(),
+  slot: z.string().optional()
+});
 var OllieConfigSchema = z.object({
   storeId: z.string().uuid(),
-  versionId: z.string().uuid().optional()
+  versionId: z.string().uuid().optional(),
+  components: z.record(z.string(), ComponentEntrySchema).optional()
 }).passthrough();
 var CONFIG_FILE = "ollie.json";
 function getConfigFileName(stage) {
@@ -443,6 +457,51 @@ async function saveConfig(config, options = {}) {
   };
   await fs2.writeFile(configPath, JSON.stringify(merged, null, 2));
 }
+async function listStages(cwd = process.cwd()) {
+  let files;
+  try {
+    files = await fs2.readdir(cwd);
+  } catch {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const stages = [];
+  for (const file of files.sort()) {
+    const match = file.match(/^ollie(?:\.([^.]+))?\.json$/);
+    if (!match) continue;
+    const stage = match[1] ?? "prod";
+    if (seen.has(stage)) continue;
+    seen.add(stage);
+    let versionId;
+    try {
+      const config = await loadConfig({ cwd, stage: match[1] });
+      versionId = config?.versionId;
+    } catch {
+    }
+    stages.push({ stage, versionId });
+  }
+  return stages;
+}
+async function upsertComponentEntry(id, values, options = {}) {
+  const { cwd = process.cwd(), stage } = options;
+  const configPath = path2.join(cwd, getConfigFileName(stage));
+  const existing = await loadConfigFile(configPath) ?? {};
+  const components = {
+    ...existing.components ?? {}
+  };
+  const prev = components[id];
+  const slot = values.slot ?? prev?.slot;
+  const entry = {
+    path: prev?.path ?? values.defaultPath,
+    ...slot !== void 0 ? { slot } : {}
+  };
+  components[id] = entry;
+  await fs2.writeFile(
+    configPath,
+    JSON.stringify({ ...existing, components }, null, 2)
+  );
+  return entry;
+}
 function resolveStage(cliStage) {
   return cliStage || process.env.OLLIE_STAGE || void 0;
 }
@@ -579,19 +638,84 @@ async function readComponentMeta(componentDir, stage) {
     return null;
   }
 }
+async function componentsByDir(cwd, stageLabel) {
+  const byDir = /* @__PURE__ */ new Map();
+  let config = null;
+  try {
+    config = await loadConfig({ cwd, stage: stageLabel });
+  } catch {
+    return byDir;
+  }
+  for (const [id, entry] of Object.entries(config?.components ?? {})) {
+    const dir = path4.resolve(cwd, entry.path);
+    if (!byDir.has(dir)) byDir.set(dir, { id, slot: entry.slot });
+  }
+  return byDir;
+}
 async function discoverComponents(options = {}) {
   const { cwd = process.cwd(), stage } = options;
+  const activeStage = stage ?? "prod";
+  const buildDir = path4.join(cwd, "node_modules/.ollie", "build");
+  const components = [];
+  const mappedDirs = /* @__PURE__ */ new Set();
+  const activeByDir = await componentsByDir(cwd, activeStage);
+  const otherStageByDir = /* @__PURE__ */ new Map();
+  try {
+    for (const { stage: label } of await listStages(cwd)) {
+      if (label === activeStage) continue;
+      for (const [dir, entry] of await componentsByDir(cwd, label)) {
+        if (!activeByDir.has(dir) && !otherStageByDir.has(dir)) {
+          otherStageByDir.set(dir, entry);
+        }
+      }
+    }
+  } catch {
+  }
+  for (const [componentDir, entry] of activeByDir) {
+    const entryPoint = path4.join(componentDir, "index.tsx");
+    try {
+      await fs4.access(entryPoint);
+    } catch {
+      console.warn(
+        `${entry.id}: ${componentDir}/index.tsx not found - skipping`
+      );
+      continue;
+    }
+    const name = path4.basename(componentDir);
+    mappedDirs.add(componentDir);
+    components.push({
+      id: entry.id,
+      name,
+      slot: entry.slot,
+      entryPoint,
+      outfile: path4.join(buildDir, name, "index.js")
+    });
+  }
   const componentsDir = path4.join(cwd, "components");
   try {
     await fs4.access(componentsDir);
   } catch {
-    return [];
+    return components;
   }
   const entries = await glob("*/index.tsx", { cwd: componentsDir });
-  const components = [];
   for (const entry of entries) {
     const name = path4.dirname(entry);
-    const componentDir = path4.join(componentsDir, name);
+    const componentDir = path4.resolve(componentsDir, name);
+    if (mappedDirs.has(componentDir)) continue;
+    const entryPoint = path4.join(componentsDir, entry);
+    const outfile = path4.join(buildDir, name, "index.js");
+    const other = otherStageByDir.get(componentDir);
+    if (other) {
+      components.push({
+        id: other.id,
+        name,
+        slot: other.slot,
+        otherStage: true,
+        entryPoint,
+        outfile
+      });
+      continue;
+    }
     const meta = await readComponentMeta(componentDir, stage);
     const id = meta?.id ?? `studio-${name}`;
     const isUnlinked = !meta?.id;
@@ -604,14 +728,113 @@ async function discoverComponents(options = {}) {
       id,
       name,
       slot: meta?.slot,
-      entryPoint: path4.join(componentsDir, entry),
-      outfile: path4.join(cwd, "node_modules/.ollie", "build", name, "index.js")
+      ...isUnlinked ? { unlinked: true } : {},
+      entryPoint,
+      outfile
     });
   }
   return components;
 }
+function browserLogBridge(endpoint) {
+  const target = JSON.stringify(endpoint);
+  return `(() => {
+  if (typeof window === "undefined" || window.__ollieLogBridge) return;
+  window.__ollieLogBridge = true;
+
+  const endpoint = ${target};
+  const SLOT_FRAME = /ollie-slot\\/([^.\\s:]+)\\.js/;
+  const LEVELS = ["log", "info", "warn", "error", "debug"];
+  const MAX_MESSAGE = 2000;
+  const MAX_BATCH = 20;
+  const FLUSH_MS = 200;
+
+  let queue = [];
+  let flushTimer = null;
+
+  function format(value) {
+    if (typeof value === "string") return value;
+    try {
+      return JSON.stringify(value);
+    } catch (_) {
+      return String(value);
+    }
+  }
+
+  function slotName(stack) {
+    const match = (stack || "").match(SLOT_FRAME);
+    return match ? match[1] : null;
+  }
+
+  function flush() {
+    if (flushTimer) {
+      clearTimeout(flushTimer);
+      flushTimer = null;
+    }
+    if (queue.length === 0) return;
+    const batch = queue;
+    queue = [];
+    try {
+      fetch(endpoint, {
+        method: "POST",
+        mode: "cors",
+        keepalive: true,
+        headers: { "Content-Type": "text/plain" },
+        body: JSON.stringify({ batch: batch }),
+      }).catch(function () {});
+    } catch (_) {}
+  }
+
+  function forward(level, component, args) {
+    try {
+      let message = args.map(format).join(" ");
+      if (message.length > MAX_MESSAGE) {
+        message = message.slice(0, MAX_MESSAGE) + " \u2026(truncated)";
+      }
+      queue.push({ level: level, component: component, message: message });
+      if (queue.length >= MAX_BATCH) {
+        flush();
+      } else if (!flushTimer) {
+        flushTimer = setTimeout(flush, FLUSH_MS);
+      }
+    } catch (_) {}
+  }
+
+  for (const level of LEVELS) {
+    const original = console[level]
+      ? console[level].bind(console)
+      : function () {};
+    console[level] = function () {
+      const args = Array.prototype.slice.call(arguments);
+      original.apply(null, args);
+      const component = slotName(new Error().stack);
+      if (component) forward(level, component, args);
+    };
+  }
+
+  window.addEventListener("error", function (event) {
+    const component = slotName(event.error && event.error.stack);
+    if (component) forward("error", component, [event.message]);
+  });
+
+  window.addEventListener("unhandledrejection", function (event) {
+    const reason = event.reason;
+    const component = slotName(reason && reason.stack);
+    if (component) {
+      const message = reason && reason.message ? reason.message : String(reason);
+      forward("error", component, [message]);
+    }
+  });
+
+  window.addEventListener("pagehide", flush);
+})();`;
+}
 async function createBuildContext(components, options = {}) {
-  const { cwd = process.cwd(), stage, onBuildEnd } = options;
+  const {
+    cwd = process.cwd(),
+    stage,
+    onBuildEnd,
+    browserLogsEndpoint
+  } = options;
   const outdir = path4.join(cwd, "node_modules/.ollie", "build");
   await fs4.mkdir(outdir, { recursive: true });
   const entryPoints = {};
@@ -669,7 +892,8 @@ async function createBuildContext(components, options = {}) {
     logLevel: "silent",
     // We handle logging ourselves
     jsx: "automatic",
-    plugins: [manifestPlugin]
+    plugins: [manifestPlugin],
+    ...browserLogsEndpoint ? { banner: { js: browserLogBridge(browserLogsEndpoint) } } : {}
   });
   return ctx;
 }
@@ -680,29 +904,37 @@ async function startDevServer(options = {}) {
     cwd = process.cwd(),
     stage,
     onRequest,
-    onBuildEnd
+    onBuildEnd,
+    onBrowserLogs
   } = options;
   const servedir = path4.join(cwd, "node_modules/.ollie", "build");
   const componentsDir = path4.join(cwd, "components");
   const internalPort = port + 1;
+  const browserLogsEndpoint = onBrowserLogs ? `http://${host}:${port}/__log` : void 0;
+  let activeStage = stage ?? "prod";
   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 });
+    ctx = await createBuildContext(components, {
+      cwd,
+      stage: activeStage,
+      onBuildEnd,
+      browserLogsEndpoint
+    });
     await ctx.rebuild();
     await ctx.watch();
     await ctx.serve({ port: internalPort, host, servedir, onRequest });
   }
   async function recreate() {
-    const components = await discoverComponents({ cwd, stage });
+    const components = await discoverComponents({ cwd, stage: activeStage });
     const oldCtx = ctx;
     ctx = null;
     if (oldCtx) await oldCtx.dispose();
     await buildAndServe(components);
     notifyComponentsChanged(components);
   }
-  await buildAndServe(await discoverComponents({ cwd, stage }));
+  await buildAndServe(await discoverComponents({ cwd, stage: activeStage }));
   async function currentComponentNames() {
     try {
       const entries = await glob("*/index.tsx", { cwd: componentsDir });
@@ -859,6 +1091,55 @@ data: ${payload}
       }
       return;
     }
+    if (url.pathname === "/stages" && req.method === "GET") {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Private-Network", "true");
+      res.setHeader("Content-Type", "application/json");
+      const stages = await listStages(cwd);
+      res.end(JSON.stringify({ active: activeStage, stages }));
+      return;
+    }
+    if (url.pathname === "/stage" && req.method === "POST") {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+      res.setHeader("Access-Control-Allow-Private-Network", "true");
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk.toString();
+      });
+      req.on("end", async () => {
+        try {
+          const { stage: next } = JSON.parse(body);
+          if (typeof next !== "string" || !next) {
+            res.statusCode = 400;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: "Missing 'stage' in body" }));
+            return;
+          }
+          activeStage = next;
+          await recreate();
+          let versionId;
+          try {
+            versionId = (await loadConfig({ cwd, stage: activeStage }))?.versionId;
+          } catch {
+          }
+          res.setHeader("Content-Type", "application/json");
+          res.end(
+            JSON.stringify({ success: true, stage: activeStage, versionId })
+          );
+        } catch (err) {
+          res.statusCode = 400;
+          res.setHeader("Content-Type", "application/json");
+          res.end(
+            JSON.stringify({
+              error: err instanceof Error ? err.message : "Invalid JSON body"
+            })
+          );
+        }
+      });
+      return;
+    }
     if (url.pathname === "/meta" && req.method === "POST") {
       const componentName = url.searchParams.get("component");
       if (!componentName) {
@@ -880,6 +1161,32 @@ data: ${payload}
       req.on("end", async () => {
         try {
           const updates = JSON.parse(body);
+          let cfg = null;
+          try {
+            cfg = await loadConfig({ cwd, stage: activeStage });
+          } catch {
+          }
+          if (cfg?.components !== void 0) {
+            const id = typeof updates.id === "string" ? updates.id : void 0;
+            if (!id) {
+              res.statusCode = 400;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: "Missing 'id' in body" }));
+              return;
+            }
+            const slot = typeof updates.slot === "string" ? updates.slot : void 0;
+            const entry = await upsertComponentEntry(
+              id,
+              { defaultPath: `components/${componentName}`, slot },
+              { cwd, stage: activeStage }
+            );
+            await ctx?.rebuild();
+            res.setHeader("Content-Type", "application/json");
+            res.end(
+              JSON.stringify({ success: true, component: { id, ...entry } })
+            );
+            return;
+          }
           const metaPath = path4.join(
             cwd,
             "components",
@@ -918,6 +1225,45 @@ data: ${payload}
       });
       return;
     }
+    if (url.pathname === "/__log" && req.method === "POST") {
+      if (!onBrowserLogs) {
+        res.statusCode = 404;
+        res.end();
+        return;
+      }
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Private-Network", "true");
+      const MAX_LOG_BODY = 64 * 1024;
+      let body = "";
+      let aborted = false;
+      req.on("data", (chunk) => {
+        if (aborted) return;
+        body += chunk.toString();
+        if (body.length > MAX_LOG_BODY) {
+          aborted = true;
+          res.statusCode = 413;
+          res.end();
+          req.destroy();
+        }
+      });
+      req.on("end", () => {
+        if (aborted) return;
+        try {
+          const parsed2 = JSON.parse(body);
+          const batch = parsed2.batch;
+          const candidates = Array.isArray(batch) ? batch : [parsed2];
+          const entries = candidates.filter(
+            (entry) => typeof entry?.message === "string"
+          );
+          if (entries.length > 0) onBrowserLogs(entries);
+        } catch {
+        }
+        res.statusCode = 204;
+        res.end();
+      });
+      return;
+    }
     if (req.method === "OPTIONS") {
       res.setHeader("Access-Control-Allow-Origin", "*");
       res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
@@ -986,7 +1332,9 @@ async function writeManifest(components, buildResult, cwd = process.cwd()) {
         id: c.id,
         name: c.name,
         js: `/${c.name}/index.js`,
-        slot: c.slot
+        slot: c.slot,
+        ...c.otherStage ? { otherStage: true } : {},
+        ...c.unlinked ? { unlinked: true } : {}
       };
       const cssPath = path4.join(outdir, c.name, "index.css");
       try {
@@ -1020,13 +1368,16 @@ function StartCommand({ args }) {
   const [state, setState] = useState2({ status: "initializing" });
   const [components, setComponents] = useState2([]);
   const [logs, setLogs] = useState2([]);
+  const [browserLogs, setBrowserLogs] = useState2([]);
   const [buildCount, setBuildCount] = useState2(0);
   const [lastBuildTime, setLastBuildTime] = useState2(null);
   const logIdRef = useRef(0);
+  const browserLogIdRef = useRef(0);
   const rebuildRef = useRef(null);
   const stopRef = useRef(null);
   const stage = resolveStage(parseArg(args, "--stage", "-s"));
   const noOpen = args.includes("--no-open") || Boolean(process.env.CI);
+  const browserLogsEnabled = args.includes("--browser-logs");
   const isInteractive = Boolean(process.stdin.isTTY);
   const addLog = useCallback((log) => {
     setLogs((prev) => {
@@ -1049,6 +1400,18 @@ function StartCommand({ args }) {
     },
     [addLog]
   );
+  const addBrowserLogs = useCallback((entries) => {
+    if (entries.length === 0) return;
+    setBrowserLogs((prev) => {
+      const mapped = entries.map((entry) => ({
+        ...entry,
+        message: sanitizeLogMessage(entry.message),
+        id: ++browserLogIdRef.current,
+        timestamp: /* @__PURE__ */ new Date()
+      }));
+      return [...prev, ...mapped].slice(-MAX_LOGS);
+    });
+  }, []);
   useEffect2(() => {
     let mounted = true;
     async function init() {
@@ -1079,6 +1442,7 @@ function StartCommand({ args }) {
           port: PORT,
           stage,
           onRequest: handleRequest,
+          onBrowserLogs: browserLogsEnabled ? addBrowserLogs : void 0,
           onBuildEnd: (updatedComponents) => {
             setComponents(updatedComponents);
             setBuildCount((c) => c + 1);
@@ -1119,7 +1483,7 @@ function StartCommand({ args }) {
       mounted = false;
       stopRef.current?.();
     };
-  }, [stage, handleRequest, noOpen]);
+  }, [stage, handleRequest, addBrowserLogs, browserLogsEnabled, noOpen]);
   useInput(
     (input, key) => {
       if (input === "q" || input === "c" && key.ctrl) {
@@ -1176,6 +1540,7 @@ function StartCommand({ args }) {
       /* @__PURE__ */ jsx3(ComponentList, { components }),
       /* @__PURE__ */ jsx3(BuildInfo, { buildCount, lastBuildTime }),
       /* @__PURE__ */ jsx3(RequestLogs, { logs }),
+      browserLogsEnabled && /* @__PURE__ */ jsx3(BrowserLogs, { logs: browserLogs }),
       /* @__PURE__ */ jsx3(Footer, { interactive: isInteractive })
     ] })
   ] });
@@ -1304,6 +1669,38 @@ function RequestLogs({ logs }) {
     ] }, log.id)) })
   ] });
 }
+function sanitizeLogMessage(message) {
+  let out = "";
+  for (const ch of message) {
+    const code = ch.codePointAt(0) ?? 0;
+    out += code < 32 || code >= 127 && code <= 159 ? " " : ch;
+    if (out.length >= 2e3) break;
+  }
+  return out;
+}
+function browserLogColor(level) {
+  if (level === "error") return "red";
+  if (level === "warn") return "yellow";
+  if (level === "info") return "cyan";
+  return "gray";
+}
+function BrowserLogs({ logs }) {
+  return /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Browser Logs:" }),
+    /* @__PURE__ */ jsx3(Box3, { marginLeft: 2, flexDirection: "column", children: logs.length === 0 ? /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "No browser logs yet..." }) : logs.map((log) => /* @__PURE__ */ jsxs3(Box3, { children: [
+      /* @__PURE__ */ jsxs3(Text3, { color: browserLogColor(log.level), children: [
+        log.level.toUpperCase(),
+        " "
+      ] }),
+      log.component && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+        "[",
+        log.component,
+        "] "
+      ] }),
+      /* @__PURE__ */ jsx3(Text3, { children: log.message })
+    ] }, log.id)) })
+  ] });
+}
 function Footer({ interactive = true }) {
   if (!interactive) {
     return /* @__PURE__ */ jsx3(Box3, { marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Headless (no TTY) \u2014 Ctrl+C to stop" }) });
@@ -1340,7 +1737,7 @@ function App({ command, args }) {
   }
 }
 function VersionCommand() {
-  const version = "1.4.1" ? "1.4.1" : "unknown";
+  const version = "1.6.0" ? "1.6.0" : "unknown";
   return /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { children: [
     "ollieshop v",
     version
@@ -2493,6 +2890,115 @@ async function schemaCommand(parsed2) {
 `);
 }
 
+// src/commands/setup-cmd.ts
+import fs5 from "fs/promises";
+import path5 from "path";
+import { glob as glob2 } from "glob";
+var META_FILE_RE = /^meta(?:\.([^.]+))?\.json$/;
+function configFileForStage(stage) {
+  return !stage || stage === "prod" ? "ollie.json" : `ollie.${stage}.json`;
+}
+async function setupCommand(parsed2) {
+  const format = detectOutputFormat(parsed2.global.output);
+  const cwd = process.cwd();
+  const dryRun = parsed2.global.dryRun;
+  try {
+    const componentsDir = path5.join(cwd, "components");
+    let folders = [];
+    try {
+      await fs5.access(componentsDir);
+      const entries = await glob2("*/index.tsx", { cwd: componentsDir });
+      folders = entries.map((entry) => path5.dirname(entry));
+    } catch {
+    }
+    const migrated = [];
+    const skipped = [];
+    for (const name of folders) {
+      const folderDir = path5.join(componentsDir, name);
+      const metaFiles = await glob2("meta*.json", { cwd: folderDir });
+      for (const metaFile of metaFiles) {
+        const match = metaFile.match(META_FILE_RE);
+        if (!match) continue;
+        const stage = match[1];
+        let meta;
+        try {
+          meta = JSON.parse(
+            await fs5.readFile(path5.join(folderDir, metaFile), "utf-8")
+          );
+        } catch {
+          skipped.push({
+            component: name,
+            metaFile,
+            reason: "unreadable meta"
+          });
+          continue;
+        }
+        const id = typeof meta.id === "string" ? meta.id : void 0;
+        if (!id) {
+          skipped.push({
+            component: name,
+            metaFile,
+            reason: "no id (unlinked) - left as-is"
+          });
+          continue;
+        }
+        const slot = typeof meta.slot === "string" ? meta.slot : void 0;
+        if (!dryRun) {
+          await upsertComponentEntry(
+            id,
+            { defaultPath: `components/${name}`, slot },
+            { cwd, stage }
+          );
+          await fs5.rm(path5.join(folderDir, metaFile));
+        }
+        migrated.push({
+          component: name,
+          stage: stage ?? "prod",
+          configFile: configFileForStage(stage),
+          metaFile,
+          id,
+          slot
+        });
+      }
+    }
+    if (format === "json") {
+      outputResult(
+        { data: { dryRun, migrated, skipped } },
+        format,
+        parsed2.global.fields
+      );
+      return;
+    }
+    const prefix = dryRun ? "\x1B[33m[dry-run]\x1B[0m " : "";
+    if (migrated.length === 0) {
+      console.log(`${prefix}No legacy meta files to migrate.`);
+    } else {
+      console.log(
+        `${prefix}\x1B[1mMigrated ${migrated.length} meta file(s) to config:\x1B[0m`
+      );
+      for (const entry of migrated) {
+        const slotLabel = entry.slot ? `, slot ${entry.slot}` : "";
+        const removed = dryRun ? "" : `  [removed ${entry.metaFile}]`;
+        console.log(
+          `  ${entry.configFile.padEnd(16)} ${entry.component}  (id ${entry.id}${slotLabel})${removed}`
+        );
+      }
+    }
+    if (skipped.length > 0) {
+      console.log("\n\x1B[2mSkipped:\x1B[0m");
+      for (const entry of skipped) {
+        console.log(`  ${entry.component}/${entry.metaFile}: ${entry.reason}`);
+      }
+    }
+  } catch (err) {
+    outputResult(
+      { error: { message: err instanceof Error ? err.message : String(err) } },
+      format
+    );
+    process.exit(1);
+  }
+}
+
 // src/commands/status-cmd.ts
 async function statusCommand(parsed2) {
   const format = detectOutputFormat(parsed2.global.output);
@@ -2876,7 +3382,8 @@ var AGENT_COMMANDS = {
   schema: schemaCommand,
   init: initCommand,
   deploy: deployCommand,
-  status: statusCommand
+  status: statusCommand,
+  setup: setupCommand
 };
 var parsed = parseArgs(process.argv);
 if (parsed.command in AGENT_COMMANDS) {