@calo-design/cli 0.1.0

package/bin/mirror-push.js

@@ -0,0 +1,472 @@
+"use strict";
+
+/**
+ * `calo-design push` — publish a local prototype to the Calo Mirror.
+ *
+ * No git. Exactly two side effects:
+ *   1) eas update  → the prototype's OWN channel inside the ONE shared EAS project
+ *                    (the native JS bundle the Mirror shell reloads into).
+ *   2) Tigris      → upsert index.json + upload screenshots/<slug>.png (the feed).
+ *
+ * The prototype is authored as a plain Expo app. This command stages a managed
+ * copy (shared EAS project id, fixed runtimeVersion, an injected "back to Mirror"
+ * control) so the author never touches any of the loader machinery.
+ */
+
+const { spawnSync } = require("node:child_process");
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+// ---- shared contract with the Mirror shell (calo-design-mirror) -------------
+const SHARED_PROJECT_ID = "290a759f-427c-432e-9ab5-dab98310e66b";
+const UPDATES_URL = `https://u.expo.dev/${SHARED_PROJECT_ID}`;
+const RUNTIME_VERSION = "0.1.0"; // must equal the shell binary's runtimeVersion (appVersion policy, version 0.1.0)
+const LAUNCHER_CHANNEL = "mirror";
+
+// ---- registry (Fly Tigris, S3-compatible; override via env) -----------------
+const BUCKET = process.env.CALO_MIRROR_BUCKET || "calo-design-mirror";
+const ENDPOINT = process.env.CALO_MIRROR_ENDPOINT || "https://fly.storage.tigris.dev";
+const PUBLIC_BASE = process.env.CALO_MIRROR_PUBLIC_BASE || `https://${BUCKET}.fly.storage.tigris.dev`;
+// Tigris is S3-compatible, so `fly storage` hands back AWS_*-named keys (that's
+// the S3 naming convention, not Amazon). We prefer our own CALO_MIRROR_* names.
+const TIGRIS_KEY = process.env.CALO_MIRROR_KEY || process.env.AWS_ACCESS_KEY_ID;
+const TIGRIS_SECRET = process.env.CALO_MIRROR_SECRET || process.env.AWS_SECRET_ACCESS_KEY;
+
+const c = {
+  dim: (s) => `\x1b[2m${s}\x1b[0m`, b: (s) => `\x1b[1m${s}\x1b[0m`,
+  g: (s) => `\x1b[32m${s}\x1b[0m`, y: (s) => `\x1b[33m${s}\x1b[0m`,
+};
+const log = (s = "") => console.log(s);
+const ok = (s) => log(`${c.g("✓")} ${s}`);
+const warn = (s) => log(`${c.y("!")} ${s}`);
+
+// ---- tiny arg + process helpers ---------------------------------------------
+const flag = (args, name, def) => {
+  const i = args.indexOf(name);
+  return i >= 0 && args[i + 1] ? args[i + 1] : def;
+};
+const has = (args, name) => args.includes(name);
+
+function run(bin, argv, opts = {}) {
+  const r = spawnSync(bin, argv, { stdio: "inherit", ...opts });
+  if (r.error) throw r.error;
+  if (typeof r.status === "number" && r.status !== 0) throw new Error(`${bin} ${argv.join(" ")} exited ${r.status}`);
+  return r;
+}
+function capture(bin, argv, opts = {}) {
+  const r = spawnSync(bin, argv, { encoding: "utf8", ...opts });
+  return { status: r.status == null ? 1 : r.status, out: `${r.stdout || ""}${r.stderr || ""}` };
+}
+
+// Resolve the eas CLI once: prefer one on PATH (global install), else fetch via
+// npx. `push` runs from a prototype folder that won't have eas-cli locally.
+let _easPrefix;
+function easPrefix() {
+  if (!_easPrefix) {
+    const onPath = spawnSync(process.platform === "win32" ? "where" : "which", ["eas"], { stdio: "ignore" }).status === 0;
+    _easPrefix = onPath ? ["eas"] : ["npx", "-y", "-p", "eas-cli", "eas"];
+  }
+  return _easPrefix;
+}
+const easRun = (argv, opts = {}) => { const [b, ...p] = easPrefix(); return run(b, [...p, ...argv], opts); };
+const easCapture = (argv, opts = {}) => { const [b, ...p] = easPrefix(); return capture(b, [...p, ...argv], opts); };
+
+function runtimeDir() {
+  const home = process.env.DESIGNCHEF_HOME || path.join(os.homedir(), ".designchef");
+  return path.join(home, "runtime");
+}
+const slugify = (s) => String(s).toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "prototype";
+const titleize = (s) => String(s).replace(/[-_]+/g, " ").replace(/\b\w/g, (m) => m.toUpperCase());
+
+function appDir(root) {
+  for (const d of [path.join(root, "src", "app"), path.join(root, "app")]) if (fs.existsSync(d)) return d;
+  return null;
+}
+function gitName() {
+  const r = capture("git", ["config", "user.name"]);
+  return r.status === 0 ? r.out.trim() : "";
+}
+function findScreenshot(root, explicit) {
+  if (explicit) return explicit;
+  for (const p of ["screenshot.png", path.join("assets", "screenshot.png"), path.join("assets", "preview.png")]) {
+    if (fs.existsSync(path.join(root, p))) return path.join(root, p);
+  }
+  return undefined;
+}
+
+// ---- staging ----------------------------------------------------------------
+
+// The prototype's deps must be a subset of the shared runtime — the shell binary
+// only contains the runtime's native modules, so anything extra would be missing.
+function validateDeps(pkg) {
+  const runtimePkgPath = path.join(runtimeDir(), "package.json");
+  if (!fs.existsSync(runtimePkgPath)) {
+    warn("no shared runtime found — skipping dependency-containment check.");
+    return;
+  }
+  const runtimeDeps = new Set(Object.keys(JSON.parse(fs.readFileSync(runtimePkgPath, "utf8")).dependencies || {}));
+  const extras = Object.keys(pkg.dependencies || {}).filter((d) => !d.startsWith("@calo/") && !runtimeDeps.has(d));
+  if (extras.length) {
+    warn(`these deps aren't in the shared runtime, so the Mirror binary can't provide them:\n    ${extras.join(", ")}`);
+    warn("the prototype may crash on load in Mirror. Keep prototypes to the shared-runtime deps, or ask for a runtime bump.");
+  }
+}
+
+function writeJSON(p, obj) {
+  fs.writeFileSync(p, JSON.stringify(obj, null, 2) + "\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)));
+  fs.mkdirSync(stageSrcParent, { recursive: true });
+  fs.cpSync(ad, path.join(stageSrcParent, path.basename(ad)), { recursive: true });
+  const assets = path.join(root, "assets");
+  if (fs.existsSync(assets)) fs.cpSync(assets, path.join(stage, "assets"), { recursive: true });
+
+  const usesSrc = path.basename(path.dirname(ad)) === "src";
+  const stagedAppDir = path.join(stage, usesSrc ? "src" : "", "app");
+  // mirror-chrome.tsx is written into mirrorChromeDir, which is always ONE level
+  // above the app dir (stage/ for app/, stage/src/ for src/app/). The _layout that
+  // imports it lives inside the app dir, so the import is always "../mirror-chrome".
+  // (Previously "./mirror-chrome" for the non-src case, which failed to resolve.)
+  const libRel = "../mirror-chrome";
+  const mirrorChromeDir = usesSrc ? path.join(stage, "src") : stage;
+
+  // Managed app.json: shared EAS project, fixed runtimeVersion, override allowed.
+  writeJSON(path.join(stage, "app.json"), {
+    expo: {
+      name: title,
+      slug: "designchef",
+      scheme: `calo-${slug}`,
+      version: "1.0.0",
+      runtimeVersion: RUNTIME_VERSION,
+      orientation: "portrait",
+      userInterfaceStyle: "light",
+      newArchEnabled: true,
+      plugins: ["expo-router", "expo-font", "expo-updates"],
+      updates: { url: UPDATES_URL, disableAntiBrickingMeasures: true },
+      extra: { router: {}, eas: { projectId: SHARED_PROJECT_ID } },
+    },
+  });
+  // package.json copied from the runtime so versions match the symlinked node_modules.
+  const runtimePkg = JSON.parse(fs.readFileSync(path.join(runtimeDir(), "package.json"), "utf8"));
+  runtimePkg.name = `calo-${slug}`;
+  runtimePkg.private = true;
+  writeJSON(path.join(stage, "package.json"), runtimePkg);
+  for (const f of ["tsconfig.json", "babel.config.js"]) {
+    const src = path.join(runtimeDir(), f);
+    if (fs.existsSync(src)) fs.cpSync(src, path.join(stage, f));
+  }
+
+  writeMetroConfig(stage);
+  linkNodeModules(stage);
+  injectBackChrome({ stagedAppDir, mirrorChromeDir, libRel });
+
+  // EAS Update enumerates project files via git. Give the throwaway staging dir
+  // its own local repo (node_modules ignored). This never leaves the temp dir —
+  // it's not a "git op" in the user-facing sense, just what `eas update` needs.
+  fs.writeFileSync(path.join(stage, ".gitignore"), "node_modules/\n.expo/\ndist/\n*.log\n");
+  run("git", ["-C", stage, "init", "-q"]);
+  run("git", ["-C", stage, "add", "-A"]);
+  run("git", ["-C", stage, "-c", "user.email=mirror@calo.app", "-c", "user.name=Calo Mirror", "commit", "-q", "-m", "mirror push"]);
+}
+
+function writeMetroConfig(stage) {
+  const runtimeReal = fs.realpathSync(runtimeDir());
+  fs.writeFileSync(
+    path.join(stage, "metro.config.js"),
+    `process.env.EXPO_NO_METRO_WORKSPACE_ROOT = "1";
+const path = require("node:path");
+const { getDefaultConfig } = require("expo/metro-config");
+const projectRoot = __dirname;
+const runtimeRoot = ${JSON.stringify(runtimeReal)};
+const config = getDefaultConfig(projectRoot);
+config.watchFolders = [...(config.watchFolders || []), runtimeRoot];
+config.resolver.nodeModulesPaths = [
+  path.resolve(projectRoot, "node_modules"),
+  path.resolve(runtimeRoot, "node_modules"),
+];
+module.exports = config;
+`
+  );
+}
+
+function linkNodeModules(stage) {
+  const target = fs.realpathSync(path.join(runtimeDir(), "node_modules"));
+  const link = path.join(stage, "node_modules");
+  try { fs.unlinkSync(link); } catch {}
+  fs.symlinkSync(target, link, process.platform === "win32" ? "junction" : "dir");
+}
+
+// Overwrite the root _layout with a managed one that wraps the app in a floating
+// "← Mirror" control. NOTE (v1): a custom root _layout (custom providers/Tabs) is
+// not preserved — we warn when the layout looks non-standard.
+function injectBackChrome({ stagedAppDir, mirrorChromeDir, libRel }) {
+  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; custom providers won't carry over.");
+  }
+  fs.writeFileSync(
+    layout,
+    `import { Stack } from "expo-router";
+import { useFonts } from "expo-font";
+import { caloFonts } from "@calo/design-system";
+import { MirrorChrome } from "${libRel}";
+
+export default function RootLayout() {
+  const [loaded] = useFonts(caloFonts);
+  if (!loaded) return null;
+  return (
+    <MirrorChrome>
+      <Stack screenOptions={{ headerShown: false }} />
+    </MirrorChrome>
+  );
+}
+`
+  );
+  fs.writeFileSync(
+    path.join(mirrorChromeDir, "mirror-chrome.tsx"),
+    `import type { ReactNode } from "react";
+import { useState } from "react";
+import { ActivityIndicator, Platform, Pressable, Text, View } from "react-native";
+import * as Updates from "expo-updates";
+
+// One return at a time. A second tap before the reload lands fires a second
+// reloadAsync(), racing two runtime teardowns -> SIGBUS in ExpoModulesJSI. The
+// latch (plus the disabled button) drops extra taps; a failure clears it to retry.
+let returning = false;
+
+// Injected by \`calo-design push\`. Flips the binary back to the Mirror launcher.
+async function backToMirror() {
+  if (returning || !Updates.isEnabled) return;
+  returning = true;
+  try {
+    await Updates.setUpdateURLAndRequestHeadersOverride({
+      updateUrl: ${JSON.stringify(UPDATES_URL)},
+      requestHeaders: {
+        "expo-channel-name": ${JSON.stringify(LAUNCHER_CHANNEL)},
+        "expo-runtime-version": Updates.runtimeVersion ?? ${JSON.stringify(RUNTIME_VERSION)},
+        "expo-platform": Platform.OS,
+      },
+    });
+    // EAS requires channel + runtime-version + platform (400 otherwise); the
+    // override replaces headers, so send all three, then download.
+    await Updates.fetchUpdateAsync();
+  } catch {
+    returning = false;
+    return;
+  }
+  // Defer the reload to a fresh macrotask. Reloading inside the awaited chain
+  // races the fetch's JSI promise + the expo-updates reaper teardown -> SIGBUS
+  // in ExpoModulesJSI. Let the chain unwind + reaper settle, then reload.
+  // reloadAsync never resolves (the app reloads), so it is not awaited.
+  setTimeout(() => {
+    void Updates.reloadAsync().catch(() => {
+      returning = false;
+    });
+  }, 300);
+}
+
+export function MirrorChrome({ children }: { children: ReactNode }) {
+  const [going, setGoing] = useState(false);
+  return (
+    <View style={{ flex: 1 }}>
+      {children}
+      <Pressable
+        accessibilityLabel="Back to Mirror"
+        accessibilityRole="button"
+        disabled={going}
+        onPress={() => {
+          setGoing(true);
+          void backToMirror();
+        }}
+        hitSlop={8}
+        style={({ pressed }) => ({
+          position: "absolute",
+          left: 16,
+          bottom: 36,
+          flexDirection: "row",
+          alignItems: "center",
+          gap: 8,
+          backgroundColor: "#208AEF",
+          paddingHorizontal: 16,
+          paddingVertical: 10,
+          borderRadius: 999,
+          opacity: going ? 0.85 : pressed ? 0.7 : 1,
+          transform: [{ scale: pressed ? 0.96 : 1 }],
+        })}
+      >
+        {going ? <ActivityIndicator size="small" color="#fff" /> : null}
+        <Text style={{ color: "#fff", fontWeight: "600" }}>{going ? "Returning…" : "← Mirror"}</Text>
+      </Pressable>
+    </View>
+  );
+}
+`
+  );
+}
+
+// ---- publish ----------------------------------------------------------------
+
+function ensureEas() {
+  const who = easCapture(["whoami"]);
+  if (who.status !== 0) {
+    throw new Error("EAS not ready — run `eas login` (the account that owns the shared project). eas-cli is fetched via npx if it isn't installed.");
+  }
+}
+
+// `channel:create` makes a channel + same-named branch and links them. Idempotent
+// for our purposes: if it already exists we ignore the error and publish to it.
+function ensureChannel(stage, slug) {
+  const r = easCapture(["channel:create", slug, "--non-interactive"], { cwd: stage });
+  if (r.status !== 0 && !/already exists/i.test(r.out)) {
+    // Not fatal — the branch may already exist; `eas update --branch` still works.
+    warn(`channel:create ${slug}: ${r.out.trim().split("\n").slice(-1)[0] || r.status}`);
+  }
+}
+
+// ---- registry: Fly Tigris object storage ------------------------------------
+// Tigris speaks the S3 API, so authenticated writes use S3 Signature V4. SigV4
+// is a wire protocol — the `s3` / `aws4_request` / `AWS4-HMAC-SHA256` literals
+// below are part of it, NOT Amazon AWS. No AWS account, no SDK, no aws CLI: just
+// Node's built-in crypto computing the signature Tigris expects. Reads are plain
+// public HTTPS against the Fly bucket URL.
+
+const sha256hex = (data) => crypto.createHash("sha256").update(data).digest("hex");
+const hmac = (key, data) => crypto.createHmac("sha256", key).update(data).digest();
+
+function tigrisCreds() {
+  if (!TIGRIS_KEY || !TIGRIS_SECRET) {
+    throw new Error("Missing Tigris credentials — `source ~/.designchef/mirror.env` (or set CALO_MIRROR_KEY + CALO_MIRROR_SECRET) before push.");
+  }
+  return { key: TIGRIS_KEY, secret: TIGRIS_SECRET };
+}
+
+// Signed PUT to the Tigris bucket (S3 API, path-style: ENDPOINT/BUCKET/key).
+async function s3Put(objectKey, body, contentType) {
+  const { key, secret } = tigrisCreds();
+  const region = "auto";
+  const url = new URL(`${ENDPOINT}/${BUCKET}/${objectKey}`);
+  const payload = Buffer.isBuffer(body) ? body : Buffer.from(body);
+  const payloadHash = sha256hex(payload);
+  const amzDate = new Date().toISOString().replace(/[:-]|\.\d{3}/g, ""); // YYYYMMDDTHHMMSSZ
+  const dateStamp = amzDate.slice(0, 8);
+
+  const signed = {
+    "content-type": contentType,
+    host: url.host,
+    "x-amz-content-sha256": payloadHash,
+    "x-amz-date": amzDate,
+  };
+  const names = Object.keys(signed).sort();
+  const canonicalHeaders = names.map((h) => `${h}:${signed[h]}\n`).join("");
+  const signedHeaders = names.join(";");
+  const canonicalUri = url.pathname.split("/").map(encodeURIComponent).join("/");
+  const canonicalRequest = ["PUT", canonicalUri, "", canonicalHeaders, signedHeaders, payloadHash].join("\n");
+  const scope = `${dateStamp}/${region}/s3/aws4_request`;
+  const stringToSign = ["AWS4-HMAC-SHA256", amzDate, scope, sha256hex(canonicalRequest)].join("\n");
+  const signingKey = hmac(hmac(hmac(hmac(`AWS4${secret}`, dateStamp), region), "s3"), "aws4_request");
+  const signature = crypto.createHmac("sha256", signingKey).update(stringToSign).digest("hex");
+
+  // Host is added by the runtime and matches the signed value, so we don't resend it.
+  const res = await fetch(url, {
+    method: "PUT",
+    headers: {
+      "content-type": contentType,
+      "x-amz-content-sha256": payloadHash,
+      "x-amz-date": amzDate,
+      authorization: `AWS4-HMAC-SHA256 Credential=${key}/${scope}, SignedHeaders=${signedHeaders}, Signature=${signature}`,
+    },
+    body: payload,
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Tigris PUT ${objectKey} → HTTP ${res.status} ${text.slice(0, 200)}`);
+  }
+}
+
+async function readRegistry() {
+  try {
+    const res = await fetch(`${PUBLIC_BASE}/index.json?t=${Date.now()}`);
+    if (!res.ok) return [];
+    const data = await res.json();
+    if (Array.isArray(data)) return data;
+    return Array.isArray(data.prototypes) ? data.prototypes : [];
+  } catch {
+    return [];
+  }
+}
+
+async function uploadScreenshot(slug, file) {
+  await s3Put(`screenshots/${slug}.png`, fs.readFileSync(file), "image/png");
+  return `${PUBLIC_BASE}/screenshots/${slug}.png`;
+}
+
+async function upsertRegistry(entry) {
+  const list = await readRegistry();
+  const next = list.filter((e) => e.slug !== entry.slug);
+  next.push(entry);
+  await s3Put("index.json", JSON.stringify(next, null, 2), "application/json");
+}
+
+// ---- command ----------------------------------------------------------------
+
+async function cmdPush(args) {
+  const root = process.cwd();
+  const dry = has(args, "--dry-run");
+
+  const pkgPath = path.join(root, "package.json");
+  if (!fs.existsSync(pkgPath)) throw new Error("no package.json here — run `calo-design push` from inside a prototype folder.");
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  if (!(pkg.dependencies && pkg.dependencies.expo)) throw new Error("this folder isn't an Expo project.");
+  const ad = appDir(root);
+  if (!ad) throw new Error("no routes found (expected src/app or app).");
+
+  const slug = slugify(flag(args, "--slug", path.basename(root)));
+  const title = flag(args, "--title", titleize(pkg.name || slug));
+  const owner = flag(args, "--owner", gitName() || os.userInfo().username || "");
+  const message = flag(args, "--message", `Update ${slug}`);
+  const description = flag(args, "--description", "");
+  const screenshot = findScreenshot(root, flag(args, "--screenshot", ""));
+
+  log(c.b(`\n[push] ${title}`) + c.dim(`  (slug/channel: ${slug}, runtimeVersion: ${RUNTIME_VERSION})`));
+  validateDeps(pkg);
+
+  const stage = fs.mkdtempSync(path.join(os.tmpdir(), `calo-push-${slug}-`));
+  let keepStage = false;
+  try {
+    stageProject({ root, stage, slug, title, ad });
+
+    if (dry) {
+      keepStage = true;
+      ok(`dry-run — staged a managed copy at:\n    ${stage}`);
+      log(c.dim("  would run: eas channel:create " + slug + " ; eas update --branch " + slug));
+      log(c.dim(`  would write: ${PUBLIC_BASE}/index.json  +  screenshots/${slug}.png` + (screenshot ? "" : "  (no screenshot found)")));
+      return;
+    }
+
+    ensureEas();
+    ensureChannel(stage, slug);
+    easRun(["update", "--branch", slug, "--message", message, "--environment", "production", "--non-interactive"], { cwd: stage });
+    ok(`published EAS update → channel ${c.b(slug)}`);
+
+    const screenshotUrl = screenshot ? await uploadScreenshot(slug, screenshot) : undefined;
+    await upsertRegistry({
+      slug, title, owner, description,
+      channel: slug, runtimeVersion: RUNTIME_VERSION,
+      screenshotUrl, updatedAt: new Date().toISOString(),
+    });
+    ok("registry updated");
+
+    log(c.b("\n✨ Live in the Mirror.") + " Open Calo Mirror and tap Refresh — your prototype is at the top.");
+  } finally {
+    if (!keepStage) fs.rmSync(stage, { recursive: true, force: true });
+  }
+}
+
+module.exports = { cmdPush, _s3Put: s3Put, _upsertRegistry: upsertRegistry };

package/bin/rn-platform-loader.js

@@ -0,0 +1,43 @@
+// rspack PRE-loader: rewrite `import { Platform } from 'react-native'` to
+// `import Platform from 'react-native-platform-fixed'` (a local module aliased in
+// the rspack config).
+//
+// Why: under Module Federation in this stack the CONSUMED react-native's Platform
+// resolves to different instances per import binding — even two byte-identical
+// `import X from 'react-native/Libraries/Utilities/Platform'` in one file give one
+// null and one 'ios'. No resolve/runtime/source fix is reliable against that. The
+// local `react-native-platform-fixed` module dedupes normally (it isn't react-native,
+// so it escapes the MF instance roulette) and forces OS:'ios' regardless of what the
+// underlying Platform instance it sees has. Rewriting at the source level (before
+// swc) routes app code AND node_modules (expo-router, @react-navigation) to it.
+module.exports = function rnPlatformLoader(source) {
+  if (typeof source !== 'string' || source.indexOf('react-native') === -1 || source.indexOf('Platform') === -1) {
+    return source;
+  }
+  var re0 = /import\s+(?:(\w+)\s*,\s*)?\{([^}]*)\}\s*from\s*(['"])react-native\3/;
+  if (re0.test(source) && /(^|[,{\s])Platform(\s*,|\s*}|\s+as\s)/.test(source.match(re0)[0])) {
+    try { require('fs').appendFileSync('/tmp/rnplat.log', 'XFORM ' + ((this && this.resourcePath) || '?') + '\n'); } catch (e) {}
+  }
+  var re = /import\s+(?:(\w+)\s*,\s*)?\{([^}]*)\}\s*from\s*(['"])react-native\3/g;
+  return source.replace(re, function (full, dflt, names) {
+    if (names.indexOf('Platform') === -1) return full;
+    var parts = names.split(',').map(function (s) { return s.trim(); }).filter(Boolean);
+    var kept = [];
+    var local = 'Platform';
+    var found = false;
+    for (var k = 0; k < parts.length; k++) {
+      var m = parts[k].match(/^Platform(?:\s+as\s+(\w+))?$/);
+      if (m) { local = m[1] || 'Platform'; found = true; continue; }
+      kept.push(parts[k]);
+    }
+    if (!found) return full; // 'Platform' only appeared as a substring (e.g. PlatformColor)
+    var out = '';
+    if (dflt) {
+      out += 'import ' + dflt + (kept.length ? ', { ' + kept.join(', ') + ' }' : '') + " from 'react-native';\n";
+    } else if (kept.length) {
+      out += 'import { ' + kept.join(', ') + " } from 'react-native';\n";
+    }
+    out += 'import ' + local + " from 'react-native/Libraries/Utilities/Platform';";
+    return out;
+  });
+};

package/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@calo-design/cli",
+  "version": "0.1.0",
+  "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" },
+  "license": "UNLICENSED",
+  "engines": { "node": ">=18" }
+}