@calo-design/cli 0.9.0 → 0.9.2

package/bin/mirror-push.js

@@ -293,21 +293,75 @@ function linkNodeModules(stage) {
   fs.symlinkSync(target, link, process.platform === "win32" ? "junction" : "dir");
 }
 
-// Overwrite the root _layout with a managed one. Returning to the launcher is now
+// Wrap the root _layout with Mirror chrome. Returning to the launcher is
 // handled natively by the Mirror shell (shake the device — see withCaloMirrorIos),
 // so no visible "back" control is injected; MirrorChrome carries the injected
-// crash reporting (Sentry init + error boundary). NOTE (v1): a custom root _layout
-// (custom providers/Tabs) is not preserved — we warn when it looks non-standard.
+// crash reporting (Sentry init + error boundary).
+//
+// The author's own root _layout is PRESERVED: it's relocated one directory up
+// (next to mirror-chrome, where expo-router won't treat it as a route — inside
+// the app dir even underscore-prefixed files become routes), its relative
+// imports are shifted for the move, and the managed layout renders it inside
+// MirrorChrome. Providers, fonts, and custom UI in the root layout all carry
+// over — the old behavior silently dropped them, and every context hook in the
+// prototype then threw "must be used inside <Provider>" at runtime.
+
+// Moving a module one directory up (src/app/_layout → src/mirror-original-layout)
+// shifts what its relative imports resolve to; rewrite the specifiers so they
+// point at the same files from the new location. Covers `from "…"`, bare
+// `import "…"`, dynamic `import("…")` and `require("…")`. Alias (@/…) and
+// package imports are untouched.
+function shiftRelativeImportsUp(source, appDirName) {
+  return source.replace(
+    /(\bfrom\s*|\bimport\s*\(?\s*|\brequire\s*\(\s*)(["'])(\.{1,2}\/[^"']+)\2/g,
+    (whole, lead, quote, spec) => {
+      let next;
+      if (spec.startsWith("../")) {
+        next = spec.slice(3);
+        if (!next.startsWith("../") && !next.startsWith("./")) next = "./" + next;
+      } else {
+        next = "./" + appDirName + "/" + spec.slice(2);
+      }
+      return `${lead}${quote}${next}${quote}`;
+    }
+  );
+}
+
 function injectBackChrome({ stagedAppDir, mirrorChromeDir, libRel, slug, owner }) {
-  const layout = path.join(stagedAppDir, "_layout.tsx");
-  if (fs.existsSync(layout)) {
-    const cur = fs.readFileSync(layout, "utf8");
-    const standard = /useFonts\(caloFonts\)/.test(cur) && /<Stack/.test(cur);
-    if (!standard) warn("custom root _layout detected — Mirror wraps it with a Stack; providers in the ROOT layout won't carry over. Move them to a nested layout (e.g. src/app/(group)/_layout.tsx), which the Mirror preserves.");
-  }
-  fs.writeFileSync(
-    layout,
-    `// MirrorChrome MUST be the first import: its module scope boots Sentry, so a
+  const exts = [".tsx", ".jsx", ".ts", ".js"];
+  const ext = exts.find((e) => fs.existsSync(path.join(stagedAppDir, "_layout" + e)));
+  const authorLayout = ext ? fs.readFileSync(path.join(stagedAppDir, "_layout" + ext), "utf8") : null;
+  // Root layouts must default-export a component; without one we can't wrap it.
+  const wrappable = authorLayout && /export\s+default\b|export\s*\{[^}]*\bdefault\b[^}]*\}/.test(authorLayout);
+
+  let managed;
+  if (wrappable) {
+    fs.writeFileSync(
+      path.join(mirrorChromeDir, "mirror-original-layout" + ext),
+      shiftRelativeImportsUp(authorLayout, path.basename(stagedAppDir))
+    );
+    fs.rmSync(path.join(stagedAppDir, "_layout" + ext));
+    log(c.dim("  root _layout preserved — wrapped with Mirror crash reporting (providers carry over)"));
+    managed = `// Managed by calo-design push. Your root _layout is preserved verbatim as
+// ../mirror-original-layout (imports shifted for the move) and rendered inside
+// Mirror's crash reporting — providers, fonts, and custom UI all carry over.
+// MirrorChrome MUST stay the first import: its module scope boots Sentry, so a
+// crash while any later module evaluates (your layout, the design system — the
+// SDK-drift class) is captured instead of dying unreported before init.
+import { MirrorChrome } from "${libRel}";
+import OriginalLayout from "../mirror-original-layout";
+
+export default function RootLayout() {
+  return (
+    <MirrorChrome>
+      <OriginalLayout />
+    </MirrorChrome>
+  );
+}
+`;
+  } else {
+    if (authorLayout) warn("root _layout has no default export — replacing it with the standard Mirror layout.");
+    managed = `// MirrorChrome MUST be the first import: its module scope boots Sentry, so a
 // crash while any later module evaluates (expo-router, the design system — the
 // SDK-drift class) is captured instead of dying unreported before init.
 import { MirrorChrome } from "${libRel}";
@@ -324,9 +378,54 @@ export default function RootLayout() {
     </MirrorChrome>
   );
 }
+`;
+  }
+  fs.writeFileSync(path.join(stagedAppDir, "_layout.tsx"), managed);
+  fs.writeFileSync(path.join(mirrorChromeDir, "mirror-chrome.tsx"), mirrorChromeSource({ slug, owner }));
+  injectNativeIntent(stagedAppDir);
+}
+
+// The launcher opens a prototype via `designchef://open/<slug>`. That deep link is
+// the app's native initial URL, and it SURVIVES the expo-updates reload into the
+// prototype's bundle — where `/open/<slug>` isn't a route, so expo-router shows its
+// "Unmatched Route" screen instead of the prototype. (Feed taps don't carry a URL,
+// which is why only QR/link opens were affected.)
+//
+// `+native-intent.tsx` is expo-router's hook for rewriting an incoming native URL
+// before routing: send the launcher's own path to the root and leave every other
+// deep link untouched, so a prototype's own links keep working.
+function injectNativeIntent(stagedAppDir) {
+  const existing = [".tsx", ".ts", ".jsx", ".js"].find((e) =>
+    fs.existsSync(path.join(stagedAppDir, "+native-intent" + e))
+  );
+  if (existing) {
+    warn("this prototype has its own +native-intent — leaving it alone. If opening by QR/link lands on \"Unmatched Route\", redirect paths starting with /open to \"/\".");
+    return;
+  }
+  fs.writeFileSync(
+    path.join(stagedAppDir, "+native-intent.tsx"),
+    `// Managed by calo-design push.
+// The Mirror launcher opens this prototype with designchef://open/<slug>. That URL
+// is still the native initial URL after the reload into this bundle, where /open/*
+// is not a route — without this hook expo-router renders "Unmatched Route".
+const LAUNCHER_PATH = /^\\/open(\\/|\$)/;
+
+export function redirectSystemPath({ path }: { path: string; initial: boolean }): string {
+  try {
+    // Bare pathname, e.g. "/open/<slug>".
+    if (path.startsWith("/")) return LAUNCHER_PATH.test(path) ? "/" : path;
+    const url = new URL(path);
+    // Both shapes reach us: "designchef://open/<slug>" parses with host "open" and
+    // pathname "/<slug>", while "designchef:///open/<slug>" has an empty host and
+    // pathname "/open/<slug>". Treat either as the launcher handing us this app.
+    if (url.host === "open" || LAUNCHER_PATH.test(url.pathname)) return "/";
+  } catch {
+    // Unparseable URL — hand it back untouched rather than swallowing the link.
+  }
+  return path;
+}
 `
   );
-  fs.writeFileSync(path.join(mirrorChromeDir, "mirror-chrome.tsx"), mirrorChromeSource({ slug, owner }));
 }
 
 // True when the shared runtime can bundle @sentry/react-native. Old runtimes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calo-design/cli",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "One-line setup for Calo design tooling: logs in with your Calo email and installs the calo-design skill + design-system packages. No GitHub account needed.",
   "bin": {
     "calo-design": "bin/cli.js"