@mirinjs/cli 0.0.1-alpha.0

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@mirinjs/cli",
+  "version": "0.0.1-alpha.0",
+  "description": "CLI for mirin apps: dev, build, init.",
+  "type": "module",
+  "license": "MIT",
+  "homepage": "https://github.com/Netko-Labs/mirin#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Netko-Labs/mirin.git",
+    "directory": "packages/mirin-cli"
+  },
+  "bugs": "https://github.com/Netko-Labs/mirin/issues",
+  "keywords": [
+    "mirin",
+    "cli",
+    "bun",
+    "desktop"
+  ],
+  "bin": {
+    "mirin": "./src/index.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "engines": {
+    "bun": ">=1.2.0"
+  },
+  "dependencies": {
+    "create-mirinjs": "0.0.1-alpha.0"
+  },
+  "optionalDependencies": {
+    "@mirinjs/darwin-arm64": "0.0.1-alpha.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/artifacts.ts

@@ -0,0 +1,130 @@
+/**
+ * Resolve the native toolchain the CLI needs (core dylib, helper, host entry,
+ * CEF framework) in two modes:
+ *
+ *  - **in-repo** (this CLI is running inside the mirin monorepo): build the Rust
+ *    crates from source and use `vendor/cef`. For contributors.
+ *  - **installed** (a consumer ran `bun add -d @mirinjs/cli`): use the prebuilt
+ *    binaries from the per-platform `mirinjs-<os>-<arch>` package, the `host`
+ *    entry from the `mirin` package, and a CEF framework downloaded once from
+ *    the matching GitHub Release into `~/.mirinjs/cef/<version>`. No Rust needed.
+ *
+ * Alpha supports macOS arm64 only.
+ */
+
+import { $ } from "bun";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+
+const REPO_SLUG = "Netko-Labs/mirin";
+
+const CLI_DIR = import.meta.dir;
+const REPO_ROOT = resolve(CLI_DIR, "..", "..", "..");
+const IN_REPO = existsSync(join(REPO_ROOT, "crates", "mirin-core"));
+
+export interface Artifacts {
+  /** libmirin_core.dylib — dlopened by the host. */
+  coreDylib: string;
+  /** mirin-helper — the CEF subprocess binary. */
+  helperBin: string;
+  /** host entry (TS/JS) compiled with `bun build --compile`. */
+  hostEntry: string;
+  /** Directory containing "Chromium Embedded Framework.framework". */
+  cefPath: string;
+}
+
+export function isInRepo(): boolean {
+  return IN_REPO;
+}
+
+export async function resolveArtifacts(opts: { release: boolean }): Promise<Artifacts> {
+  assertSupportedPlatform();
+  const cefPath = await ensureCef();
+
+  if (IN_REPO) {
+    const profile = opts.release ? "release" : "debug";
+    console.log(`[mirin] building native core + helper (${profile})…`);
+    const flags = opts.release ? ["--release"] : [];
+    await $`cargo build -p mirin-core -p mirin-helper ${flags}`.cwd(REPO_ROOT);
+    const target = join(REPO_ROOT, "target", profile);
+    return {
+      coreDylib: join(target, "libmirin_core.dylib"),
+      helperBin: join(target, "mirin-helper"),
+      hostEntry: join(REPO_ROOT, "packages", "mirin", "src", "host.ts"),
+      cefPath,
+    };
+  }
+
+  const nativeDir = resolveNativeDir();
+  return {
+    coreDylib: join(nativeDir, "libmirin_core.dylib"),
+    helperBin: join(nativeDir, "mirin-helper"),
+    hostEntry: resolvePackageFile("mirinjs/host"),
+    cefPath,
+  };
+}
+
+function assertSupportedPlatform(): void {
+  if (process.platform !== "darwin" || process.arch !== "arm64") {
+    throw new Error(
+      `mirin alpha supports macOS arm64 only (got ${process.platform}/${process.arch}).`,
+    );
+  }
+}
+
+function platformTag(): string {
+  return `${process.platform}-${process.arch}`; // e.g. "darwin-arm64"
+}
+
+function resolveNativeDir(): string {
+  const pkg = `@mirinjs/${platformTag()}`;
+  try {
+    return dirname(resolvePackageFile(`${pkg}/package.json`));
+  } catch {
+    throw new Error(
+      `mirin: prebuilt native package "${pkg}" is not installed. Run \`bun install\` ` +
+        `(it is an optional dependency of @mirinjs/cli for your platform).`,
+    );
+  }
+}
+
+function resolvePackageFile(specifier: string): string {
+  return Bun.resolveSync(specifier, process.cwd());
+}
+
+/** The CLI's own version, used to pick the matching CEF release asset. */
+function cliVersion(): string {
+  const pkg = JSON.parse(readFileSync(join(CLI_DIR, "..", "package.json"), "utf8"));
+  return pkg.version as string;
+}
+
+async function ensureCef(): Promise<string> {
+  if (IN_REPO) {
+    const vendor = join(REPO_ROOT, "vendor", "cef");
+    if (existsSync(join(vendor, "Chromium Embedded Framework.framework"))) return vendor;
+    console.error(
+      "[mirin] vendor/cef missing — run `bun scripts/fetch-cef.ts` in the monorepo first.",
+    );
+    return vendor;
+  }
+
+  const version = cliVersion();
+  const cacheDir = join(homedir(), ".mirinjs", "cef", `${version}-${platformTag()}`);
+  if (existsSync(join(cacheDir, "Chromium Embedded Framework.framework"))) return cacheDir;
+
+  mkdirSync(cacheDir, { recursive: true });
+  const asset = `cef-${platformTag()}.tar.gz`;
+  const url = `https://github.com/${REPO_SLUG}/releases/download/v${version}/${asset}`;
+  console.log(`[mirin] downloading CEF for ${platformTag()} (one-time, ~hundreds of MB)…`);
+
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`mirin: failed to download CEF from ${url} (HTTP ${res.status}).`);
+  }
+  const archive = join(tmpdir(), asset);
+  await Bun.write(archive, res);
+  await $`tar -xzf ${archive} -C ${cacheDir}`;
+  rmSync(archive, { force: true });
+  return cacheDir;
+}

package/src/build.ts

@@ -0,0 +1,73 @@
+/**
+ * `mirin build` — package a standalone, signed .app (docs/macos-mvp.md).
+ *
+ * 1. vite build               → production UI in dist/
+ * 2. resolve native artifacts → core + helper (in-repo build or prebuilt)
+ * 3. compile host (minified)  → Contents/MacOS/<exe>
+ * 4. bundle Worker (minified) → Resources/worker.js
+ * 5. assemble + sign the .app → dist/ui, manifest, dylib, helpers, CEF
+ *
+ * The result runs with no env and no dev server: the host resolves everything
+ * from inside the bundle, and webviews load their `app://` URLs served from
+ * Contents/Resources by the native scheme handler.
+ *
+ * Codesign identity: ad-hoc by default; set MIRIN_SIGN_IDENTITY to a Developer
+ * ID to produce a distributable, notarizable app.
+ */
+
+import { $ } from "bun";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { buildAppBundle } from "./bundle.ts";
+import { resolveArtifacts } from "./artifacts.ts";
+
+export async function build(projectDir = process.cwd()): Promise<number> {
+  const outDir = join(projectDir, "build");
+  const work = join(projectDir, ".mirin");
+  mkdirSync(outDir, { recursive: true });
+  mkdirSync(work, { recursive: true });
+
+  const config = (await import(join(projectDir, "mirin.config.ts"))).default;
+  const appName: string = config.name ?? "Mirin App";
+  const bundleId: string = config.id ?? "dev.mirin.app";
+  const mainEntry = join(projectDir, config.main ?? "main/main.ts");
+
+  console.log(`[mirin build] ${appName}`);
+
+  // 1. production UI
+  console.log("[mirin build] vite build…");
+  await $`bunx vite build`.cwd(projectDir);
+
+  // 2. native artifacts (release)
+  const artifacts = await resolveArtifacts({ release: true });
+
+  // 3 + 4. host + worker (minified)
+  console.log("[mirin build] compiling host + bundling main process…");
+  const hostExe = join(work, "host-release");
+  const workerJs = join(work, "worker.release.js");
+  await $`bun build --compile --minify ${artifacts.hostEntry} --outfile ${hostExe}`.cwd(projectDir);
+  await $`bun build ${mainEntry} --target=bun --minify --outfile ${workerJs}`.cwd(projectDir);
+
+  // 5. assemble + sign
+  console.log("[mirin build] assembling .app…");
+  rmSync(join(outDir, `${appName}.app`), { recursive: true, force: true });
+  const { app } = await buildAppBundle({
+    appName,
+    bundleId,
+    outDir,
+    hostExe,
+    coreDylib: artifacts.coreDylib,
+    helperBin: artifacts.helperBin,
+    cefPath: artifacts.cefPath,
+    signIdentity: process.env.MIRIN_SIGN_IDENTITY,
+    resources: {
+      uiDir: join(projectDir, "dist"),
+      workerJs,
+      manifestJson: JSON.stringify({ windows: config.windows }),
+    },
+  });
+
+  console.log(`\n[mirin build] done → ${app}`);
+  console.log(`  open "${app}"`);
+  return 0;
+}

package/src/bundle.ts

@@ -0,0 +1,162 @@
+/**
+ * Assemble a macOS .app bundle for a mirin app (docs/architecture.md §1, §5).
+ *
+ *   <App>.app/Contents/
+ *     MacOS/<exe>                 compiled Bun host
+ *     MacOS/libmirin_core.dylib   loaded by the host via bun:ffi
+ *     Frameworks/Chromium Embedded Framework.framework
+ *     Frameworks/<exe> Helper[ (Type)].app   x5   (mirin-helper)
+ *
+ * Helper bundle names derive from the main executable name — CEF resolves
+ * "<exe> Helper (Renderer).app/Contents/MacOS/<exe> Helper (Renderer)".
+ */
+
+import { $ } from "bun";
+import { cpSync, mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+const FRAMEWORK = "Chromium Embedded Framework.framework";
+
+const HELPER_TYPES = [
+  { suffix: "", id: "helper" },
+  { suffix: " (GPU)", id: "helper.gpu" },
+  { suffix: " (Renderer)", id: "helper.renderer" },
+  { suffix: " (Plugin)", id: "helper.plugin" },
+  { suffix: " (Alerts)", id: "helper.alerts" },
+];
+
+export interface BundleOptions {
+  appName: string; // also the executable stem; helpers are "<appName> Helper"
+  bundleId: string;
+  outDir: string;
+  hostExe: string; // compiled Bun host binary
+  coreDylib: string; // libmirin_core.dylib
+  helperBin: string; // compiled mirin-helper binary
+  cefPath: string; // dir containing the CEF framework (vendor/cef)
+  /** Codesign identity; "-" (default) is ad-hoc. Set to a Developer ID to ship. */
+  signIdentity?: string;
+  /** Production-only resources placed under Contents/Resources. */
+  resources?: {
+    uiDir?: string; // Vite dist/, copied to Resources/ui (served via app://ui)
+    workerJs?: string; // bundled main-process Worker entry -> Resources/worker.js
+    manifestJson?: string; // serialized manifest -> Resources/mirin.manifest.json
+  };
+}
+
+type PlistValue = string | boolean | Record<string, string>;
+
+function plist(entries: Record<string, PlistValue>): string {
+  const render = (v: PlistValue): string => {
+    if (typeof v === "boolean") return v ? "<true/>" : "<false/>";
+    if (typeof v === "string") return `<string>${v}</string>`;
+    const inner = Object.entries(v)
+      .map(([k, val]) => `<key>${k}</key><string>${val}</string>`)
+      .join("");
+    return `<dict>${inner}</dict>`;
+  };
+  const body = Object.entries(entries)
+    .map(([k, v]) => `  <key>${k}</key>\n  ${render(v)}`)
+    .join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+${body}
+</dict>
+</plist>
+`;
+}
+
+/** Build the .app and return the path to its executable. */
+export async function buildAppBundle(opts: BundleOptions): Promise<{ app: string; exe: string }> {
+  const { appName, bundleId, cefPath } = opts;
+  if (!existsSync(join(cefPath, FRAMEWORK))) {
+    throw new Error(`CEF framework not found at ${cefPath} — run: bun scripts/fetch-cef.ts`);
+  }
+
+  const app = join(opts.outDir, `${appName}.app`);
+  const contents = join(app, "Contents");
+  const macos = join(contents, "MacOS");
+  const frameworks = join(contents, "Frameworks");
+
+  rmSync(app, { recursive: true, force: true });
+  mkdirSync(macos, { recursive: true });
+  mkdirSync(frameworks, { recursive: true });
+  mkdirSync(join(contents, "Resources"), { recursive: true });
+
+  cpSync(opts.hostExe, join(macos, appName));
+  cpSync(opts.coreDylib, join(macos, "libmirin_core.dylib"));
+
+  writeFileSync(
+    join(contents, "Info.plist"),
+    plist({
+      CFBundleDevelopmentRegion: "en",
+      CFBundleDisplayName: appName,
+      CFBundleExecutable: appName,
+      CFBundleIdentifier: bundleId,
+      CFBundleInfoDictionaryVersion: "6.0",
+      CFBundleName: appName,
+      CFBundlePackageType: "APPL",
+      CFBundleShortVersionString: "0.0.1",
+      CFBundleVersion: "0.0.1",
+      LSMinimumSystemVersion: "13.0",
+      NSHighResolutionCapable: true,
+      NSSupportsAutomaticGraphicsSwitching: true,
+      LSFileQuarantineEnabled: true,
+      LSEnvironment: { MallocNanoZone: "0" },
+    }),
+  );
+
+  cpSync(join(cefPath, FRAMEWORK), join(frameworks, FRAMEWORK), {
+    recursive: true,
+    verbatimSymlinks: true,
+  });
+
+  // Production resources: the served UI, the Worker bundle, and the manifest.
+  const resources = join(contents, "Resources");
+  if (opts.resources?.uiDir) {
+    cpSync(opts.resources.uiDir, join(resources, "ui"), { recursive: true });
+  }
+  if (opts.resources?.workerJs) {
+    cpSync(opts.resources.workerJs, join(resources, "worker.js"));
+  }
+  if (opts.resources?.manifestJson != null) {
+    writeFileSync(join(resources, "mirin.manifest.json"), opts.resources.manifestJson);
+  }
+
+  for (const { suffix, id } of HELPER_TYPES) {
+    const name = `${appName} Helper${suffix}`;
+    const helperApp = join(frameworks, `${name}.app`);
+    mkdirSync(join(helperApp, "Contents", "MacOS"), { recursive: true });
+    cpSync(opts.helperBin, join(helperApp, "Contents", "MacOS", name));
+    writeFileSync(
+      join(helperApp, "Contents", "Info.plist"),
+      plist({
+        CFBundleDevelopmentRegion: "en",
+        CFBundleDisplayName: name,
+        CFBundleExecutable: name,
+        CFBundleIdentifier: `${bundleId}.${id}`,
+        CFBundleInfoDictionaryVersion: "6.0",
+        CFBundleName: name,
+        CFBundlePackageType: "APPL",
+        CFBundleShortVersionString: "0.0.1",
+        CFBundleVersion: "0.0.1",
+        LSMinimumSystemVersion: "13.0",
+        LSUIElement: "1",
+        NSHighResolutionCapable: true,
+        LSEnvironment: { MallocNanoZone: "0" },
+      }),
+    );
+  }
+
+  // Sign inside-out: framework, helpers, then the outer app. Ad-hoc ("-") by
+  // default; pass a Developer ID to produce a distributable, notarizable app.
+  const identity = opts.signIdentity ?? "-";
+  await $`codesign --force --sign ${identity} ${join(frameworks, FRAMEWORK)}`.quiet();
+  for (const { suffix } of HELPER_TYPES) {
+    await $`codesign --force --sign ${identity} ${join(frameworks, `${appName} Helper${suffix}.app`)}`.quiet();
+  }
+  await $`codesign --force --sign ${identity} ${app}`.quiet();
+
+  return { app, exe: join(macos, appName) };
+}

package/src/dev.ts

@@ -0,0 +1,98 @@
+/**
+ * `mirin dev` — the development loop (docs/macos-mvp.md, M4).
+ *
+ * 1. resolve native artifacts (build in-repo, or prebuilt when installed)
+ * 2. compile the Bun host, bundle the user's main-process Worker
+ * 3. assemble + ad-hoc-sign the dev .app
+ * 4. start the Vite dev server (rolldown-vite) for the UI
+ * 5. launch the app pointed at the Vite URL, with RPC injected into the webview
+ */
+
+import { $ } from "bun";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { buildAppBundle } from "./bundle.ts";
+import { resolveArtifacts } from "./artifacts.ts";
+
+const DEV_URL = "http://localhost:5173";
+
+export async function dev(projectDir = process.cwd()): Promise<number> {
+  const work = join(projectDir, ".mirin");
+  mkdirSync(work, { recursive: true });
+
+  // --- load the manifest ---
+  const config = (await import(join(projectDir, "mirin.config.ts"))).default;
+  const appName: string = config.name ?? "Mirin App";
+  const bundleId: string = config.id ?? "dev.mirin.app";
+  const mainEntry = join(projectDir, config.main ?? "main/main.ts");
+
+  // --- native artifacts ---
+  const artifacts = await resolveArtifacts({ release: false });
+
+  // --- compile the Bun host + bundle the Worker ---
+  console.log("[mirin dev] compiling host + bundling main process…");
+  const hostExe = join(work, "host");
+  const workerJs = join(work, "worker.js");
+  await $`bun build --compile ${artifacts.hostEntry} --outfile ${hostExe}`.cwd(projectDir);
+  await $`bun build ${mainEntry} --target=bun --outfile ${workerJs}`.cwd(projectDir);
+
+  // --- assemble the dev .app ---
+  console.log("[mirin dev] assembling dev bundle…");
+  const { app, exe } = await buildAppBundle({
+    appName,
+    bundleId,
+    outDir: work,
+    hostExe,
+    coreDylib: artifacts.coreDylib,
+    helperBin: artifacts.helperBin,
+    cefPath: artifacts.cefPath,
+  });
+
+  // --- start Vite ---
+  console.log("[mirin dev] starting Vite dev server…");
+  const vite = Bun.spawn(["bunx", "vite", "--clearScreen", "false"], {
+    cwd: projectDir,
+    stdio: ["ignore", "inherit", "inherit"],
+  });
+  await waitForUrl(DEV_URL, 15_000);
+
+  // --- launch the app ---
+  console.log(`[mirin dev] launching ${appName}…`);
+  const appProc = Bun.spawn([exe], {
+    cwd: projectDir,
+    env: {
+      ...process.env,
+      MIRIN_CORE: join(app, "Contents", "MacOS", "libmirin_core.dylib"),
+      MIRIN_WORKER: workerJs,
+      MIRIN_DEV_URL: DEV_URL,
+      MIRIN_MANIFEST_JSON: JSON.stringify({ windows: config.windows }),
+      MIRIN_CONFIG_JSON: "{}",
+    },
+    stdio: ["ignore", "inherit", "inherit"],
+  });
+
+  const cleanup = () => {
+    vite.kill();
+    appProc.kill();
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+
+  const code = await appProc.exited;
+  vite.kill();
+  return code;
+}
+
+async function waitForUrl(url: string, timeoutMs: number): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(url, { signal: AbortSignal.timeout(1000) });
+      if (res.ok) return;
+    } catch {
+      // not up yet
+    }
+    await Bun.sleep(200);
+  }
+  throw new Error(`Vite dev server did not start at ${url} within ${timeoutMs}ms`);
+}

package/src/index.ts

@@ -0,0 +1,46 @@
+#!/usr/bin/env bun
+/**
+ * mirin CLI — `dev`, `build`, `init`.
+ */
+
+import { resolve } from "node:path";
+import { dev } from "./dev.ts";
+import { build } from "./build.ts";
+import { scaffold } from "create-mirinjs";
+
+const [command, arg] = Bun.argv.slice(2);
+
+const USAGE = `mirin — build desktop apps with Bun + Chromium
+
+Usage:
+  mirin dev          run the app against the Vite dev server (HMR + typed RPC)
+  mirin build        package a standalone, signed .app (output: ./build)
+  mirin init [dir]   scaffold a new app
+`;
+
+switch (command) {
+  case "dev": {
+    process.exit(await dev());
+    break;
+  }
+  case "build": {
+    process.exit(await build());
+    break;
+  }
+  case "init": {
+    const targetDir = resolve(process.cwd(), arg ?? "my-mirin-app");
+    try {
+      const name = scaffold(targetDir);
+      console.log(`\n✓ Created ${name} in ${arg ?? "my-mirin-app"}`);
+      console.log("  bun install && bun run dev");
+      process.exit(0);
+    } catch (err) {
+      console.error(`mirin init: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+    break;
+  }
+  default:
+    console.log(USAGE);
+    process.exit(command ? 1 : 0);
+}