@zappdev/cli 0.1.0

package/src/build.ts

@@ -0,0 +1,276 @@
+import path from "node:path";
+import process from "node:process";
+import { existsSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { brotliCompressSync, constants as zlibConstants } from "node:zlib";
+import { generateBuildConfigZc } from "./build-config";
+import { buildFileNeedsQjs, ensureQjsLib, nativeIncludeArgs, preferredJsTool, resolveNativeDir, runCmd, runPackageScript } from "./common";
+import { resolveAndBundleBackend } from "./backend";
+import { runGenerate } from "./generate";
+import type { ResolvedZappConfig } from "./config";
+
+export const walkFiles = async (dir: string): Promise<string[]> => {
+  const glob = new Bun.Glob("**/*");
+  const files: string[] = [];
+  // Bun.Glob.scan() on Windows requires forward slashes in the cwd path
+  for await (const file of glob.scan({ cwd: dir.replace(/\\/g, "/"), absolute: true })) {
+    const stat = Bun.file(file);
+    if (stat.size > 0 || (await stat.exists())) {
+        files.push(file);
+    }
+  }
+  return files;
+};
+
+export const maybeBrotli = async (filePath: string): Promise<string> => {
+  const source = await Bun.file(filePath).arrayBuffer();
+  const compressed = brotliCompressSync(new Uint8Array(source), {
+    params: {
+      [zlibConstants.BROTLI_PARAM_QUALITY]: 11,
+    },
+  });
+  const outPath = `${filePath}.br`;
+  await Bun.write(outPath, compressed);
+  return outPath;
+};
+
+export const generateAssetsZc = async (root: string, manifest: any, assetDir: string) => {
+  let zcContent = `// AUTO-GENERATED FILE. DO NOT EDIT.
+
+`;
+
+  // If no assets, generate empty placeholder
+  if (!manifest.assets || manifest.assets.length === 0) {
+    zcContent += `
+raw {
+    struct ZappEmbeddedAsset zapp_embedded_assets[1];
+    int zapp_embedded_assets_count = 0;
+}
+`;
+    const buildDir = path.join(root, ".zapp");
+    await mkdir(buildDir, { recursive: true });
+    const outPath = path.join(buildDir, "zapp_assets.zc");
+    await Bun.write(outPath, zcContent);
+    return outPath;
+  }
+
+  const assetEntries = [];
+  const assetExterns = [];
+  for (let i = 0; i < manifest.assets.length; i++) {
+    const item = manifest.assets[i];
+    const isBrotli = item.brotli != null;
+    const filePath = isBrotli ? item.brotli.file : item.file;
+    const absPathToEmbed = path.join(assetDir, filePath).replace(/\\/g, "/");
+    
+    zcContent += `let __zapp_asset_${i} = embed "${absPathToEmbed}" as u8[];\n`;
+    
+    let logicalPath = "/" + item.file.replace(/\\/g, "/");
+    assetExterns.push(`    extern Slice_uint8_t __zapp_asset_${i};`);
+    assetEntries.push(`        zapp_embedded_assets[${i}].path = "${logicalPath}";`);
+    assetEntries.push(`        zapp_embedded_assets[${i}].data = __zapp_asset_${i}.data;`);
+    assetEntries.push(`        zapp_embedded_assets[${i}].len = __zapp_asset_${i}.len;`);
+    assetEntries.push(`        zapp_embedded_assets[${i}].uncompressed_len = ${item.size};`);
+    assetEntries.push(`        zapp_embedded_assets[${i}].is_brotli = ${isBrotli ? 'true' : 'false'};`);
+  }
+
+    zcContent += `
+raw {
+${assetExterns.join("\n")}
+    struct ZappEmbeddedAsset zapp_embedded_assets[${manifest.assets.length || 1}];
+    int zapp_embedded_assets_count = ${manifest.assets.length};
+
+    __attribute__((constructor))
+    static void init_zapp_assets(void) {
+${assetEntries.join("\n")}
+    }
+}
+`;
+
+  const buildDir = path.join(root, ".zapp");
+  await mkdir(buildDir, { recursive: true });
+  const outPath = path.join(buildDir, "zapp_assets.zc");
+  await Bun.write(outPath, zcContent);
+  return outPath;
+};
+
+const collectWorkerStems = async (assetDir: string): Promise<Set<string>> => {
+  const stems = new Set<string>();
+  const manifestPath = path.join(assetDir, "zapp-workers", "manifest.json");
+  const manifestFile = Bun.file(manifestPath);
+  if (!(await manifestFile.exists())) return stems;
+  try {
+    const raw = await manifestFile.text();
+    const data = JSON.parse(raw);
+    const workers = data.workers ?? data;
+    for (const key of Object.keys(workers)) {
+      const stem = path.basename(key).replace(/\.[^.]+$/, "");
+      if (stem) stems.add(stem);
+    }
+  } catch { /* malformed manifest */ }
+  return stems;
+};
+
+export const buildAssetManifest = async ({
+  assetDir,
+  withBrotli,
+}: {
+  assetDir: string;
+  withBrotli: boolean;
+}) => {
+  const allFiles = await walkFiles(assetDir);
+  const workerStems = withBrotli ? await collectWorkerStems(assetDir) : new Set<string>();
+  const manifest = {
+    v: 1,
+    generatedAt: new Date().toISOString(),
+    assets: [] as any[],
+    embedded: true,
+  };
+
+  for (const file of allFiles) {
+    const rel = path.relative(assetDir, file).split(path.sep).join("/");
+    const stat = Bun.file(file);
+    const item: any = { file: rel, size: stat.size, brotli: null };
+
+    let skipBrotli = false;
+    if (rel.startsWith("zapp-workers/")) {
+      skipBrotli = true;
+    } else if (rel.startsWith("assets/") && workerStems.size > 0) {
+      const baseName = path.basename(rel).replace(/\.[^.]+$/, "");
+      for (const stem of workerStems) {
+        if (baseName === stem || baseName.startsWith(`${stem}-`)) {
+          skipBrotli = true;
+          break;
+        }
+      }
+    }
+
+    if (withBrotli && !skipBrotli) {
+      const brPath = await maybeBrotli(file);
+      const brStat = Bun.file(brPath);
+      item.brotli = { file: `${rel}.br`, size: brStat.size };
+    }
+    manifest.assets.push(item);
+  }
+
+  return manifest;
+};
+
+export const runBuild = async ({
+  root,
+  frontendDir,
+  buildFile,
+  nativeOut,
+  assetDir,
+  withBrotli,
+  embedAssets,
+  isDebug,
+  backendScript,
+  logLevel,
+  config,
+}: {
+  root: string;
+  frontendDir: string;
+  buildFile: string;
+  nativeOut: string;
+  assetDir: string;
+  withBrotli: boolean;
+  embedAssets: boolean;
+  isDebug: boolean;
+  backendScript?: string;
+  logLevel?: "error" | "warn" | "info" | "debug" | "trace";
+  config: ResolvedZappConfig;
+}) => {
+  if (withBrotli && !embedAssets) {
+    process.stdout.write("[zapp] note: --brotli has no effect without embedded assets\n");
+  }
+
+  await runGenerate({ root, frontendDir });
+
+  process.stdout.write(`[zapp] building frontend assets (${preferredJsTool()})\n`);
+  await runPackageScript("build", { cwd: frontendDir });
+
+  const manifest = embedAssets
+    ? await buildAssetManifest({ assetDir, withBrotli })
+    : { v: 1, generatedAt: new Date().toISOString(), assets: [] as any[], embedded: false };
+
+  if (embedAssets) {
+    const manifestPath = path.join(assetDir, "zapp-assets-manifest.json");
+    await Bun.write(manifestPath, JSON.stringify(manifest, null, 2));
+  }
+
+  const backendScriptPath = await resolveAndBundleBackend({ root, frontendDir, backendScript });
+  const buildMode = isDebug ? "prod" : (embedAssets ? "prod-embedded" : "prod");
+  const effectiveLogLevel = logLevel ?? (isDebug ? "debug" : "warn");
+  const buildConfigFile = await generateBuildConfigZc({
+    root,
+    mode: buildMode,
+    assetDir,
+    backendScriptPath,
+    logLevel: effectiveLogLevel,
+    csp: config.security?.csp,
+    enableDevTools: isDebug ? true : undefined, // --debug enables dev tools; otherwise inherit from mode
+  });
+
+  process.stdout.write("[zapp] building native binary\n");
+  await mkdir(path.dirname(nativeOut), { recursive: true });
+  const needsQjs = await buildFileNeedsQjs(buildFile);
+  const qjsLib = needsQjs ? await ensureQjsLib(root, isDebug ? "dev" : "release") : null;
+  const zcArgs = ["build", buildFile, buildConfigFile, ...nativeIncludeArgs()];
+  
+  // Always generate assets file (provides empty placeholder when not embedding)
+  const assetsFile = await generateAssetsZc(root, manifest, assetDir);
+  if (await Bun.file(assetsFile).exists()) zcArgs.push(assetsFile);
+  
+  // Add debug flags if isDebug, otherwise optimize for size
+  if (isDebug) {
+    zcArgs.push("--debug");
+  } else {
+    zcArgs.push("-Oz");       // Aggressive size optimization
+    zcArgs.push("-flto");     // Link-time optimization
+    zcArgs.push("--no-debug"); // No debug symbols / .dSYM
+  }
+  
+  // On Windows, embed the application manifest for comctl32 v6 (TaskDialogIndirect, visual styles)
+  if (process.platform === "win32") {
+    const manifestSrc = path.join(root, "config", "windows", "app.manifest");
+    if (existsSync(manifestSrc)) {
+      const buildDir = path.join(root, ".zapp", "build");
+      await mkdir(buildDir, { recursive: true });
+      const rcPath = path.join(buildDir, "app.rc");
+      await Bun.write(rcPath, `1 24 "${manifestSrc.replace(/\\/g, "/")}"\n`);
+      const resPath = path.join(buildDir, "app_manifest.o");
+      await runCmd("windres", [rcPath, "-O", "coff", "-o", resPath]);
+      zcArgs.push(resPath);
+    }
+  }
+
+  zcArgs.push("-o", nativeOut);
+  if (qjsLib) {
+    zcArgs.push("-L", path.dirname(qjsLib), "-lqjs");
+  }
+  await runCmd("zc", zcArgs, { cwd: root, env: { ZAPP_NATIVE: resolveNativeDir() } });
+
+  // Strip symbols in release builds for smaller binary
+  if (!isDebug) {
+    try {
+      const stripPath = Bun.which("strip");
+      if (stripPath) {
+        await runCmd("strip", [nativeOut]);
+      }
+    } catch (e) {
+      process.stdout.write(`[zapp] warning: strip failed: ${e}\n`);
+    }
+  }
+
+  process.stdout.write(
+    [
+      "[zapp] build complete",
+      `native: ${nativeOut}`,
+      `mode: ${isDebug ? 'debug' : buildMode}`,
+      "",
+      "Run:",
+      `${nativeOut}`,
+      "",
+    ].join("\n"),
+  );
+};

package/src/common.ts

@@ -0,0 +1,195 @@
+import { spawn, spawnSync, execSync, type ChildProcess } from "node:child_process";
+import path from "node:path";
+import { existsSync, statSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import process from "node:process";
+
+export const sleep = (ms: number) => Bun.sleep(ms);
+
+let _nativeDir: string | null = null;
+
+export const resolveNativeDir = (): string => {
+  if (_nativeDir) return _nativeDir;
+
+  const cliSrcDir = import.meta.dir;
+  const cliRoot = path.dirname(cliSrcDir);
+
+  // Monorepo: packages/cli/../../ is the repo root with src/ and vendor/
+  const repoRoot = path.resolve(cliRoot, "../..");
+  if (existsSync(path.join(repoRoot, "src")) && existsSync(path.join(repoRoot, "vendor"))) {
+    _nativeDir = repoRoot;
+    return _nativeDir;
+  }
+
+  // Published/linked: packages/cli/native/ exists
+  const bundled = path.join(cliRoot, "native");
+  if (existsSync(path.join(bundled, "src")) && existsSync(path.join(bundled, "vendor"))) {
+    _nativeDir = bundled;
+    return _nativeDir;
+  }
+
+  throw new Error(
+    "[zapp] Cannot find native framework code. Expected either:\n" +
+    `  - ${repoRoot}/src  (monorepo development)\n` +
+    `  - ${bundled}/src  (bundled with CLI)\n`
+  );
+};
+
+export const nativeIncludeArgs = (): string[] => {
+  const nd = resolveNativeDir();
+  const args: string[] = [];
+
+  args.push("-I", path.join(nd, "src"));
+  args.push("-I", path.join(nd, "vendor", "quickjs-ng"));
+
+  if (process.platform === "win32") {
+    args.push("-I", path.join(nd, "vendor", "webview2", "include"));
+  }
+
+  return args;
+};
+
+/**
+ * Compile QuickJS source into a static library (.a) if needed.
+ * Returns the path to the library, or null if the build dir isn't ready.
+ * The library is cached in .zapp/qjs/ and only rebuilt when source changes.
+ */
+export const ensureQjsLib = async (root: string, mode: "dev" | "release" = "release"): Promise<string> => {
+  const nd = resolveNativeDir();
+  const qjsVendor = path.join(nd, "vendor", "quickjs-ng");
+  const qjsBuildDir = path.join(root, ".zapp", "qjs", mode);
+  await mkdir(qjsBuildDir, { recursive: true });
+
+  const libPath = path.join(qjsBuildDir, "libqjs.a");
+  const sourceFiles = ["quickjs.c", "quickjs-libc.c", "dtoa.c", "libregexp.c", "libunicode.c"];
+
+  const libExists = existsSync(libPath);
+  let needsRebuild = !libExists;
+  if (libExists) {
+    const libMtime = statSync(libPath).mtimeMs;
+    for (const src of sourceFiles) {
+      const srcPath = path.join(qjsVendor, src);
+      if (existsSync(srcPath) && statSync(srcPath).mtimeMs > libMtime) {
+        needsRebuild = true;
+        break;
+      }
+    }
+  }
+
+  if (!needsRebuild) return libPath;
+
+  process.stdout.write(`[zapp] compiling QuickJS (${mode})...\n`);
+
+  const cc = process.platform === "win32" ? "gcc" : "cc";
+
+  const cflags: string[] = [];
+  if (mode === "release") {
+    cflags.push("-Oz", "-flto", "-c", `-I${qjsVendor}`);
+  } else {
+    cflags.push("-O2", "-c", `-I${qjsVendor}`);
+  }
+  if (process.platform === "win32") {
+    cflags.push("-DUNICODE", "-D_UNICODE");
+  }
+
+  const objectFiles: string[] = [];
+  for (const src of sourceFiles) {
+    const srcPath = path.join(qjsVendor, src);
+    const objPath = path.join(qjsBuildDir, src.replace(".c", ".o"));
+    objectFiles.push(objPath);
+    await runCmd(cc, [...cflags, srcPath, "-o", objPath]);
+  }
+
+  // Use gcc-ar on Windows to handle LTO objects (needs linker plugin)
+  const ar = process.platform === "win32" ? "gcc-ar" : "ar";
+  await runCmd(ar, ["rcs", libPath, ...objectFiles]);
+
+  return libPath;
+};
+
+/**
+ * Check if a build.zc file defines ZAPP_WORKER_ENGINE_QJS for the current platform.
+ */
+export const buildFileNeedsQjs = async (buildFile: string): Promise<boolean> => {
+  const content = await Bun.file(buildFile).text();
+  const platformTag = process.platform === "darwin" ? "macos" : "windows";
+  // Match lines like: //> windows: define: ZAPP_WORKER_ENGINE_QJS
+  const pattern = new RegExp(`^\\s*//> ${platformTag}: define: ZAPP_WORKER_ENGINE_QJS`, "m");
+  return pattern.test(content);
+};
+
+let cachedExec: string | null = null;
+
+export const preferredJsTool = (): string => {
+  if (cachedExec) return cachedExec;
+  if (Bun.which("bun")) {
+    cachedExec = "bun";
+    return cachedExec;
+  }
+  cachedExec = "npm";
+  return cachedExec;
+};
+
+export const runCmd = async (command: string, args: string[], options: any = {}) => {
+  const { $ } = require("bun");
+  const env = { ...process.env, ...(options.env ?? {}) };
+  const cwd = options.cwd ?? process.cwd();
+
+  if (command === "zc") {
+    console.error(`[debug] zc ${args.join(" ")}`);
+    await $`zc ${args}`.cwd(cwd).env(env);
+    return;
+  }
+
+  if (command === "bun") {
+    await $`bun ${args}`.cwd(cwd).env(env);
+  } else {
+    const cmdPath = Bun.which(command) || command;
+    const proc = Bun.spawn([cmdPath, ...args], {
+      cwd,
+      stdio: ["inherit", "inherit", "inherit"],
+      env,
+    });
+    const code = await proc.exited;
+    if (code !== 0) {
+      throw new Error(`${command} ${args.join(" ")} failed (${code})`);
+    }
+  }
+};
+
+export const spawnStreaming = (command: string, args: string[], options: any = {}) => {
+  const cmdPath = Bun.which(command) || command;
+  return Bun.spawn([cmdPath, ...args], {
+    cwd: options.cwd ?? process.cwd(),
+    stdio: ["inherit", "inherit", "inherit"],
+    env: { ...process.env, ...(options.env ?? {}) },
+  });
+};
+
+export const killChild = (child: import("bun").Subprocess | null | any) => {
+  if (!child || child.killed) return;
+  const pid = child.pid;
+  if (process.platform === "win32" && pid) {
+    try {
+      execSync(`taskkill /F /T /PID ${pid}`, { stdio: "ignore" });
+      return;
+    } catch { /* process may already be gone */ }
+  }
+  try {
+    child.kill("SIGTERM");
+  } catch {
+    try { child.kill(9); } catch { /* ignore */ }
+  }
+};
+
+export const runPackageScript = (script: string, options: any = {}) => {
+  const tool = preferredJsTool();
+  const args = tool === "bun" ? ["run", script] : ["run", script];
+  return runCmd(tool, args, options);
+};
+
+export const spawnPackageScript = (script: string, options: any = {}) => {
+  const tool = preferredJsTool();
+  const args = tool === "bun" ? ["run", script] : ["run", script];
+  return spawnStreaming(tool, args, options);
+};

package/src/config.ts

@@ -0,0 +1,89 @@
+import path from "node:path";
+
+export interface MacOSConfig {
+  /** Minimum macOS version. Defaults to "13.0" */
+  minimumSystemVersion?: string;
+  /** App category for the Mac App Store (e.g. "public.app-category.developer-tools") */
+  category?: string;
+  /** Path to .icon folder for macOS Tahoe liquid glass icons (created with Icon Composer) */
+  iconLayers?: string;
+}
+
+export interface SecurityConfig {
+  /** Custom Content Security Policy. Default: strict self-only policy */
+  csp?: string;
+  /** Allowed navigation URLs (glob patterns). Default: only app scheme + dev server */
+  allowNavigation?: string[];
+}
+
+export interface ZappConfig {
+  /** App name -- used for binary output, bundle name, window title fallback */
+  name: string;
+  /** Reverse-domain identifier (e.g. "com.mycompany.myapp"). Defaults to "com.zapp.{name}" */
+  identifier?: string;
+  /** App version string. Defaults to "1.0.0" */
+  version?: string;
+  /** Path to app icon source (1024x1024 PNG). Used to generate .icns (macOS) and .ico (Windows). */
+  icon?: string;
+  /** App description */
+  description?: string;
+  /** Author name */
+  author?: string;
+  /** macOS-specific config */
+  macos?: MacOSConfig;
+  /** Security settings */
+  security?: SecurityConfig;
+}
+
+export interface ResolvedZappConfig {
+  name: string;
+  identifier: string;
+  version: string;
+  icon?: string;
+  description?: string;
+  author?: string;
+  macos?: MacOSConfig;
+  security?: SecurityConfig;
+}
+
+/** Passthrough helper that provides type inference and autocomplete for zapp.config.ts */
+export function defineConfig(config: ZappConfig): ZappConfig {
+  return config;
+}
+
+function applyDefaults(config: ZappConfig): ResolvedZappConfig {
+  return {
+    name: config.name,
+    identifier: config.identifier ?? `com.zapp.${config.name}`,
+    version: config.version ?? "1.0.0",
+    icon: config.icon,
+    description: config.description,
+    author: config.author,
+    macos: config.macos,
+    security: config.security,
+  };
+}
+
+export async function loadConfig(root: string): Promise<ResolvedZappConfig> {
+  const configPath = path.join(root, "zapp", "zapp.config.ts");
+  const configFile = Bun.file(configPath);
+
+  if (await configFile.exists()) {
+    try {
+      const mod = await import(configPath);
+      const raw: ZappConfig = mod.default ?? mod;
+
+      if (!raw.name || typeof raw.name !== "string") {
+        throw new Error(`"name" is required in ${configPath} and must be a non-empty string`);
+      }
+
+      return applyDefaults(raw);
+    } catch (err: unknown) {
+      if (err instanceof Error && err.message.includes("name")) throw err;
+      throw new Error(`Failed to load ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+
+  const fallbackName = path.basename(root) || "zapp-app";
+  return applyDefaults({ name: fallbackName });
+}