create-zenbu-app 0.0.1

package/bin/create-zenbu-app.mjs

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import { ensureBunBootstrapped, runCommand, BUN_BIN } from "../lib/bootstrap.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEMPLATE_DIR = path.resolve(__dirname, "..", "template");
+const SUBMODULE_REPO = "https://github.com/zenbu-labs/zenbu.js.git";
+
+function copyDirSync(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+async function main() {
+  const projectName = process.argv[2];
+  if (!projectName) {
+    console.error("Usage: create-zenbu-app <project-name>");
+    process.exit(1);
+  }
+
+  const projectDir = path.resolve(process.cwd(), projectName);
+  if (fs.existsSync(projectDir)) {
+    console.error(`Error: directory "${projectName}" already exists.`);
+    process.exit(1);
+  }
+
+  console.log(`\nCreating Zenbu app in ${projectDir}\n`);
+
+  console.log("→ Copying template files...");
+  copyDirSync(TEMPLATE_DIR, projectDir);
+
+  if (fs.existsSync(path.join(projectDir, "_gitignore"))) {
+    fs.renameSync(
+      path.join(projectDir, "_gitignore"),
+      path.join(projectDir, ".gitignore"),
+    );
+  }
+
+  const pkgPath = path.join(projectDir, "package.json");
+  const pkgContent = fs.readFileSync(pkgPath, "utf8");
+  fs.writeFileSync(pkgPath, pkgContent.replace(/\{\{projectName\}\}/g, projectName));
+
+  console.log("→ Initializing git repository...");
+  await runCommand("git", ["init"], projectDir);
+
+  console.log("→ Adding zenbu.js submodule...");
+  await runCommand(
+    "git",
+    ["submodule", "add", SUBMODULE_REPO, "zenbu"],
+    projectDir,
+  );
+
+  console.log("→ Bootstrapping toolchain...");
+  await ensureBunBootstrapped();
+
+  const setupTs = path.join(projectDir, "zenbu", "packages", "init", "setup.ts");
+  if (fs.existsSync(setupTs)) {
+    console.log("→ Running framework setup...");
+    await runCommand(
+      BUN_BIN,
+      [setupTs],
+      path.join(projectDir, "zenbu"),
+      { ZENBU_STANDALONE: "1" },
+    );
+  } else {
+    console.log("  ⚠ setup.ts not found in submodule, skipping framework setup");
+  }
+
+  console.log(`\n✓ Done! Your Zenbu app is ready.\n`);
+  console.log(`  cd ${projectName}`);
+  console.log(`  zen open\n`);
+}
+
+main().catch((err) => {
+  console.error("\nError:", err.message || err);
+  process.exit(1);
+});

package/lib/bootstrap.mjs

@@ -0,0 +1,147 @@
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs";
+import crypto from "node:crypto";
+import https from "node:https";
+import { execFileSync, spawn } from "node:child_process";
+
+const CACHE_ROOT = path.join(os.homedir(), "Library", "Caches", "Zenbu");
+const BIN_DIR = path.join(CACHE_ROOT, "bin");
+const BUN_BIN = path.join(BIN_DIR, "bun");
+const BUN_VERSION_MARKER = path.join(BIN_DIR, ".bun.version");
+
+const BOOTSTRAP_BUN = {
+  version: "1.3.12",
+  targets: {
+    "darwin-aarch64": {
+      asset: "bun-darwin-aarch64.zip",
+      sha256:
+        "6c4bb87dd013ed1a8d6a16e357a3d094959fd5530b4d7061f7f3680c3c7cea1c",
+    },
+    "darwin-x64": {
+      asset: "bun-darwin-x64.zip",
+      sha256:
+        "0f58c53a3e7947f1e626d2f8d285f97c14b7cadcca9c09ebafc0ae9d35b58c3d",
+    },
+  },
+};
+
+function detectBunTarget() {
+  const arch = os.arch();
+  if (arch === "arm64") return "darwin-aarch64";
+  if (arch === "x64") return "darwin-x64";
+  throw new Error(`unsupported architecture: ${arch}`);
+}
+
+function downloadFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, (res) => {
+      if (
+        res.statusCode &&
+        res.statusCode >= 300 &&
+        res.statusCode < 400 &&
+        res.headers.location
+      ) {
+        res.resume();
+        downloadFile(res.headers.location, destPath).then(resolve, reject);
+        return;
+      }
+      if (res.statusCode !== 200) {
+        reject(new Error(`GET ${url} -> ${res.statusCode}`));
+        res.resume();
+        return;
+      }
+      const out = fs.createWriteStream(destPath);
+      res.pipe(out);
+      out.on("finish", () => out.close(resolve));
+      out.on("error", reject);
+    });
+    req.on("error", reject);
+  });
+}
+
+async function sha256(filePath) {
+  const hash = crypto.createHash("sha256");
+  await new Promise((resolve, reject) => {
+    const stream = fs.createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", resolve);
+    stream.on("error", reject);
+  });
+  return hash.digest("hex");
+}
+
+function findBunBinary(dir) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = findBunBinary(full);
+      if (nested) return nested;
+    } else if (entry.isFile() && entry.name === "bun") {
+      return full;
+    }
+  }
+  return null;
+}
+
+export async function ensureBunBootstrapped() {
+  if (fs.existsSync(BUN_BIN)) {
+    console.log(`  ✓ bun already installed at ${BUN_BIN}`);
+    return;
+  }
+
+  const target = detectBunTarget();
+  const { asset, sha256: expectedSha } = BOOTSTRAP_BUN.targets[target];
+  const tag = `bun-v${BOOTSTRAP_BUN.version}`;
+  const url = `https://github.com/oven-sh/bun/releases/download/${tag}/${asset}`;
+
+  fs.mkdirSync(BIN_DIR, { recursive: true });
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "zenbu-bun-"));
+  const zipPath = path.join(tmpDir, asset);
+
+  console.log(`  → downloading bun ${BOOTSTRAP_BUN.version}`);
+  await downloadFile(url, zipPath);
+
+  const actualSha = await sha256(zipPath);
+  if (actualSha !== expectedSha) {
+    throw new Error(
+      `bun sha256 mismatch: expected ${expectedSha}, got ${actualSha}`,
+    );
+  }
+
+  console.log(`  → unpacking`);
+  execFileSync("unzip", ["-q", asset], { cwd: tmpDir });
+
+  const extracted = findBunBinary(tmpDir);
+  if (!extracted) {
+    throw new Error("could not locate bun binary in downloaded archive");
+  }
+  fs.copyFileSync(extracted, BUN_BIN);
+  fs.chmodSync(BUN_BIN, 0o755);
+  fs.writeFileSync(BUN_VERSION_MARKER, BOOTSTRAP_BUN.version);
+
+  const nodeLink = path.join(BIN_DIR, "node");
+  try { fs.unlinkSync(nodeLink); } catch {}
+  fs.symlinkSync("bun", nodeLink);
+
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+  console.log(`  ✓ bun ${BOOTSTRAP_BUN.version} installed`);
+}
+
+export function runCommand(cmd, args, cwd, extraEnv = {}) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(cmd, args, {
+      cwd,
+      stdio: ["ignore", "inherit", "inherit"],
+      env: { ...process.env, FORCE_COLOR: "0", ...extraEnv },
+    });
+    proc.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${cmd} exited with code ${code}`));
+    });
+    proc.on("error", reject);
+  });
+}
+
+export { BUN_BIN, BIN_DIR, CACHE_ROOT };

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "create-zenbu-app",
+  "version": "0.0.1",
+  "description": "Create a new Zenbu application",
+  "type": "module",
+  "bin": {
+    "create-zenbu-app": "./bin/create-zenbu-app.mjs"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "template/"
+  ],
+  "keywords": ["zenbu", "framework", "scaffold"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zenbu-labs/zenbu.js.git"
+  }
+}

package/template/_gitignore

@@ -0,0 +1,3 @@
+node_modules/
+dist/
+.zenbu/

package/template/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "{{projectName}}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "setup": "zenbu/packages/init/setup.ts"
+  },
+  "dependencies": {
+    "zenbu": "file:./zenbu"
+  }
+}

package/template/src/renderer/App.tsx

@@ -0,0 +1,8 @@
+export function App() {
+  return (
+    <div style={{ padding: 32, fontFamily: "system-ui, sans-serif" }}>
+      <h1>Welcome to Zenbu</h1>
+      <p>Edit <code>src/renderer/App.tsx</code> to get started.</p>
+    </div>
+  );
+}

package/template/src/renderer/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Zenbu App</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="./main.tsx"></script>
+  </body>
+</html>

package/template/src/renderer/main.tsx

@@ -0,0 +1,7 @@
+import { createRoot } from "react-dom/client";
+import { App } from "./App";
+
+const root = document.getElementById("root");
+if (root) {
+  createRoot(root).render(<App />);
+}

package/template/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "paths": {
+      "@/*": ["./src/renderer/*"]
+    }
+  },
+  "include": ["src"]
+}

package/template/zenbu.plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "app",
+  "services": [
+    "src/main/services/*.ts"
+  ]
+}