@calo-design/cli 0.3.0 → 0.4.1

package/README.md

@@ -18,6 +18,16 @@ npx @calo-design/cli login    # one-time: your Calo email + the emailed code
 npx @calo-design/cli init     # skill + the shared ds/flows runtime, and a prototype here
 ```
 
+> **`@calo-design/cli` is a public npm package.** If npx reports it can't be found — "not in
+> this registry", "404", or "not a public package" — your npm is pointed at a private or
+> corporate registry that doesn't carry it (common on managed laptops). Check with
+> `npm config get registry` (it should be `https://registry.npmjs.org/`). To run regardless
+> of your `.npmrc`, pin just this scope to public npm:
+>
+> ```bash
+> npx --@calo-design:registry=https://registry.npmjs.org/ @calo-design/cli login
+> ```
+
 `init` does two machine-level things every time: it installs the skill into
 `~/.claude/skills/`, and it ensures the shared runtime at `~/.designchef/runtime/` — one
 copy of `@calo/design-system`, `@calo/flows`, Expo and the peers, shared by every

package/bin/cli.js

@@ -131,12 +131,31 @@ function runtimeExists() {
   );
 }
 
+// expo-router needs babel-preset-expo (its Babel plugin injects the route require.context);
+// without a babel.config.js, `expo export` produces an empty, routeless app. The shared
+// runtime isn't always scaffolded with one, so guarantee it. Linked prototypes inherit it
+// via writeThinConfigs; push staging backstops it again (see mirror-push.js).
+function ensureBabelConfig(dir) {
+  const p = path.join(dir, "babel.config.js");
+  if (fs.existsSync(p)) return;
+  fs.writeFileSync(p, 'module.exports = (api) => {\n  api.cache(true);\n  return { presets: ["babel-preset-expo"] };\n};\n');
+}
+
 async function ensureRuntime({ force } = {}) {
   const rt = runtimeDir();
-  if (!force && runtimeExists()) { ok(`shared runtime ready (${tilde(rt)})`); return; }
-  log(c.b("\n[runtime] Building the shared Calo runtime (one-time, ~a couple of minutes)"));
+  if (!force && runtimeExists()) {
+    ensureBabelConfig(rt); // backfill: runtimes built before this shipped no babel.config.js
+    ok(`shared runtime ready (${tilde(rt)})`);
+    return;
+  }
+  const scaffolded = fs.existsSync(path.join(rt, "package.json"));
+  const repin = force && scaffolded && !has("--clean");
+  log(c.b(`\n[runtime] ${repin ? "Re-pinning" : "Building"} the shared Calo runtime${repin ? "" : " (one-time, ~a couple of minutes)"}`));
   fs.mkdirSync(rt, { recursive: true });
-  if (force) {
+  // Re-pin is NON-destructive: `npm install` updates node_modules in place and aborts
+  // cleanly on failure (e.g. a peer conflict), so a working shared runtime is never left
+  // wiped. `--clean` opts into a from-scratch rebuild for a genuinely corrupted tree.
+  if (force && has("--clean")) {
     fs.rmSync(path.join(rt, "node_modules"), { recursive: true, force: true });
     try { fs.rmSync(runtimeManifestPath()); } catch {}
   }
@@ -144,11 +163,12 @@ async function ensureRuntime({ force } = {}) {
     if (!scaffoldExpoApp(rt)) throw new Error("runtime scaffold failed");
   }
   await installCaloDeps(rt);
+  ensureBabelConfig(rt); // a freshly scaffolded runtime may also lack one
   fs.writeFileSync(
     runtimeManifestPath(),
     JSON.stringify({ builtAt: new Date().toISOString(), pkgSpecs: PKG_SPECS, peers: PEERS }, null, 2) + "\n"
   );
-  ok(`shared runtime built -> ${tilde(rt)}`);
+  ok(`shared runtime ${repin ? "re-pinned" : "built"} -> ${tilde(rt)}`);
 }
 
 // ---------------------------------------------------------------- shared helpers
@@ -199,12 +219,14 @@ function scaffoldExpoApp(destDir = process.cwd()) {
 async function installCaloDeps(cwd) {
   // Private @calo/* installs authenticate with a short-lived broker-minted token,
   // injected into git for the npm subprocess only (no gh / PAT / SSH key).
+  // --legacy-peer-deps: the Expo/RN dep graph routinely has benign peerOptional conflicts
+  // (e.g. overlapping typescript ranges); without it a single conflict ERESOLVEs the whole install.
   const env = gitTokenEnv(await githubToken());
-  runWithRetry("npm", ["install", ...PKG_SPECS], 3, { cwd, env });
+  runWithRetry("npm", ["install", ...PKG_SPECS, "--legacy-peer-deps"], 3, { cwd, env });
   if (isExpoProject(cwd)) run("npx", ["expo", "install", ...PEERS, "expo-font"], { cwd });
   else {
     warn("non-Expo project — installing latest peers; pin them to match your React Native version if needed.");
-    run("npm", ["install", ...PEERS], { cwd });
+    run("npm", ["install", ...PEERS, "--legacy-peer-deps"], { cwd });
   }
 }
 
@@ -455,7 +477,10 @@ async function cmdUpdate() {
   await ensureLoggedIn();
   await installSkill();
   ok("skill updated to latest");
-  if (runtimeExists() || has("--build")) {
+  // Re-pin when the runtime is fully present OR merely scaffolded (package.json on disk),
+  // so a half-installed runtime self-heals via plain `update` instead of being stranded.
+  const scaffolded = fs.existsSync(path.join(runtimeDir(), "package.json"));
+  if (runtimeExists() || scaffolded || has("--build")) {
     await ensureRuntime({ force: true });
     ok("shared runtime re-pinned — every linked prototype now uses the latest Calo stack");
   } else {
@@ -472,6 +497,7 @@ function help() {
   ${c.dim("init --isolated")}                          install the Calo stack into THIS folder (no shared runtime)
   ${c.dim("init --skip-packages")}                      skill only (no runtime)
   ${c.dim("update")}                                    refresh the skill + re-pin the shared runtime (all linked prototypes float to latest)
+  ${c.dim("    update --clean")}                          re-pin with a from-scratch runtime rebuild (only if the tree is corrupted)
   ${c.dim("logout")}                                    forget the saved Calo session
   ${c.dim("push")}                                      publish THIS prototype to the Calo Mirror (login only — no EAS/Tigris creds needed)
   ${c.dim("    push --slug x --title \"…\" --owner \"…\" --screenshot path  --dry-run  --direct")}

package/bin/login.js

@@ -179,7 +179,7 @@ async function publishWeb({ slug, project, tarball }) {
   const text = await res.text();
   let json;
   try { json = text ? JSON.parse(text) : {}; } catch { json = { raw: text }; }
-  if (!res.ok) throw new Error(json.error || `publish-web → HTTP ${res.status}`);
+  if (!res.ok) throw new Error([json.error || `publish-web → HTTP ${res.status}`, json.detail].filter(Boolean).join("\n  "));
   return json;
 }
 

package/bin/mirror-push.js

@@ -122,6 +122,18 @@ function writeJSON(p, obj) {
   fs.writeFileSync(p, JSON.stringify(obj, null, 2) + "\n");
 }
 
+// A babel.config.js with babel-preset-expo MUST exist wherever `expo export` runs. Without
+// it the expo-router Babel plugin never injects the route require.context, so the export is
+// a routeless, empty shell (no screens, no design system, no assets). The shared runtime
+// doesn't always ship one, so guarantee it: prefer the prototype's own config, else default.
+function ensureBabelConfig(dir, fallbackFrom) {
+  const dst = path.join(dir, "babel.config.js");
+  if (fs.existsSync(dst)) return;
+  const fb = fallbackFrom && path.join(fallbackFrom, "babel.config.js");
+  if (fb && fs.existsSync(fb)) { fs.cpSync(fb, dst); return; }
+  fs.writeFileSync(dst, 'module.exports = (api) => {\n  api.cache(true);\n  return { presets: ["babel-preset-expo"] };\n};\n');
+}
+
 function stageProject({ root, stage, slug, title, ad }) {
   // Copy the author's routes + assets verbatim.
   const stageSrcParent = path.join(stage, path.relative(root, path.dirname(ad)));
@@ -164,6 +176,9 @@ function stageProject({ root, stage, slug, title, ad }) {
     const src = path.join(runtimeDir(), f);
     if (fs.existsSync(src)) fs.cpSync(src, path.join(stage, f));
   }
+  // The runtime may not have a babel.config.js; without one the staged export is an empty,
+  // routeless app. Backstop it from the prototype's own config, else a default.
+  ensureBabelConfig(stage, root);
 
   writeMetroConfig(stage);
   linkNodeModules(stage);
@@ -213,7 +228,7 @@ function injectBackChrome({ stagedAppDir, mirrorChromeDir, libRel }) {
   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; custom providers won't carry over.");
+    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,

package/package.json

@@ -1,10 +1,18 @@
 {
   "name": "@calo-design/cli",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "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" },
-  "files": ["bin"],
-  "publishConfig": { "access": "public" },
+  "bin": {
+    "calo-design": "bin/cli.js"
+  },
+  "files": [
+    "bin"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "license": "UNLICENSED",
-  "engines": { "node": ">=18" }
+  "engines": {
+    "node": ">=18"
+  }
 }