@zappdev/cli 0.1.0

package/src/dev.ts

@@ -0,0 +1,164 @@
+import path from "node:path";
+import process from "node:process";
+import { existsSync } from "node:fs";
+import { createInterface } from "node:readline";
+import { mkdir } from "node:fs/promises";
+import {
+  buildFileNeedsQjs,
+  ensureQjsLib,
+  killChild,
+  nativeIncludeArgs,
+  preferredJsTool,
+  resolveNativeDir,
+  runCmd,
+  runPackageScript,
+  sleep,
+  spawnPackageScript,
+  spawnStreaming,
+} from "./common";
+import { buildAssetManifest, generateAssetsZc } from "./build";
+import { generateBuildConfigZc } from "./build-config";
+import { resolveAndBundleBackend } from "./backend";
+import { runGenerate } from "./generate";
+import type { ResolvedZappConfig } from "./config";
+
+const waitForUrl = async (url: string, timeoutMs: number) => {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const res = await fetch(url);
+      if (res.ok) return;
+    } catch {
+      await sleep(100);
+    }
+  }
+  throw new Error(`Timed out waiting for ${url}`);
+};
+
+export const runDev = async ({
+  root,
+  frontendDir,
+  buildFile,
+  nativeOut,
+  devUrl,
+  withBrotli,
+  embedAssets,
+  backendScript,
+  logLevel,
+  config,
+}: {
+  root: string;
+  frontendDir: string;
+  buildFile: string;
+  nativeOut: string;
+  devUrl: string;
+  withBrotli: boolean;
+  embedAssets: boolean;
+  backendScript?: string;
+  logLevel?: "error" | "warn" | "info" | "debug" | "trace";
+  config: ResolvedZappConfig;
+}) => {
+  process.stdout.write(`[zapp] starting dev orchestration (${preferredJsTool()})\n`);
+  if (withBrotli && !embedAssets) {
+    process.stdout.write("[zapp] note: --brotli has no effect without --embed-assets\n");
+  }
+
+  await runGenerate({ root, frontendDir });
+
+  const vite = embedAssets ? null : spawnPackageScript("dev", { cwd: frontendDir });
+  let app: any = null;
+  let shuttingDown = false;
+
+  const shutdown = (reason: "user" | "app-exit" | "error" = "error") => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    if (reason === "user") {
+      process.stdout.write("\n[zapp] gracefully exiting...\n");
+    } else if (reason === "app-exit") {
+      process.stdout.write("[zapp] app exited, cleaning up...\n");
+    }
+    killChild(app);
+    killChild(vite);
+    setTimeout(() => process.exit(0), 1500);
+  };
+
+  process.on("SIGINT", () => shutdown("user"));
+  process.on("SIGTERM", () => shutdown("user"));
+  process.on("SIGHUP", () => shutdown("user"));
+
+  if (process.platform === "win32" && process.stdin.isTTY) {
+    const rl = createInterface({ input: process.stdin });
+    rl.on("SIGINT", () => shutdown("user"));
+    rl.on("close", () => shutdown("user"));
+  }
+
+  try {
+    const assetDir = path.join(frontendDir, "dist");
+    if (embedAssets) {
+      process.stdout.write("[zapp] dev embedded mode: building static frontend assets\n");
+      await runPackageScript("build", { cwd: frontendDir });
+    } else {
+      await waitForUrl(devUrl, 30000);
+    }
+
+    const backendScriptPath = await resolveAndBundleBackend({ root, frontendDir, backendScript });
+
+    const buildConfigFile = await generateBuildConfigZc({
+      root,
+      mode: embedAssets ? "dev-embedded" : "dev",
+      assetDir,
+      devUrl,
+      backendScriptPath,
+      logLevel,
+    });
+
+    await mkdir(path.dirname(nativeOut), { recursive: true });
+    const needsQjs = await buildFileNeedsQjs(buildFile);
+    const qjsLib = needsQjs ? await ensureQjsLib(root, "dev") : null;
+    const zcArgs = ["build", buildFile, buildConfigFile, "-DZAPP_BUILD_DEV", "--debug", ...nativeIncludeArgs()];
+    const manifest = embedAssets
+      ? await buildAssetManifest({ assetDir, withBrotli })
+      : { v: 1, generatedAt: new Date().toISOString(), assets: [] as any[], embedded: false };
+    const assetsFile = await generateAssetsZc(root, manifest, assetDir);
+    zcArgs.push(assetsFile);
+    // On Windows, embed the application manifest for comctl32 v6
+    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() } });
+    app = spawnStreaming(nativeOut, [], {
+      cwd: root,
+    });
+
+    app.exited.then((code: number | null) => {
+      if (!shuttingDown) {
+        shutdown("app-exit");
+      }
+    });
+    vite?.exited.then(() => {
+      if (!shuttingDown) {
+        shutdown("error");
+      }
+    });
+  } catch (error) {
+    shutdown("error");
+    throw error;
+  }
+
+  await new Promise(() => {});
+  return path.resolve(root);
+};

package/src/generate.ts

@@ -0,0 +1,200 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+
+type ServiceMethod = {
+  name: string;
+  args: { name: string; type: string }[];
+  returnType: string;
+};
+
+type ServiceDef = {
+  name: string;
+  methods: ServiceMethod[];
+};
+
+const ZEN_TO_TS_TYPES: Record<string, string> = {
+  string: "string",
+  int: "number",
+  float: "number",
+  double: "number",
+  bool: "boolean",
+  void: "void",
+};
+
+function mapType(zenType: string): string {
+  return ZEN_TO_TS_TYPES[zenType.trim()] ?? "unknown";
+}
+
+/**
+ * Scans .zc files for service_add registrations and extracts method signatures.
+ *
+ * Looks for patterns like:
+ *   app.service.add("name", handler_fn);
+ *
+ * Then finds the corresponding function definition:
+ *   fn handler_fn(app: App*, args: string) -> string { ... }
+ */
+async function scanServices(srcDir: string): Promise<ServiceDef[]> {
+  const services: ServiceDef[] = [];
+  const files: string[] = [];
+
+  async function walk(dir: string) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "vendor") continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else if (entry.name.endsWith(".zc")) {
+        files.push(full);
+      }
+    }
+  }
+
+  await walk(srcDir);
+
+  const allContent: { file: string; content: string }[] = [];
+  for (const file of files) {
+    const content = await fs.readFile(file, "utf8");
+    allContent.push({ file, content });
+  }
+
+  // Find service.add("name", handler) registrations
+  const addPattern = /\.service\.add\(\s*"([^"]+)"\s*,\s*(\w+)\s*\)/g;
+  const registrations: { serviceName: string; handlerName: string }[] = [];
+
+  for (const { content } of allContent) {
+    let match;
+    while ((match = addPattern.exec(content)) !== null) {
+      registrations.push({ serviceName: match[1], handlerName: match[2] });
+    }
+  }
+
+  // For each registration, find the function signature
+  for (const { serviceName, handlerName } of registrations) {
+    const fnPattern = new RegExp(
+      `fn\\s+${handlerName}\\s*\\(([^)]*)\\)\\s*->\\s*(\\w+)`,
+    );
+
+    let found = false;
+    for (const { content } of allContent) {
+      const fnMatch = fnPattern.exec(content);
+      if (!fnMatch) continue;
+
+      const rawArgs = fnMatch[1];
+      const returnType = mapType(fnMatch[2]);
+
+      const args: { name: string; type: string }[] = [];
+      for (const part of rawArgs.split(",")) {
+        const trimmed = part.trim();
+        if (!trimmed) continue;
+        const [name, type] = trimmed.split(":").map((s) => s.trim());
+        if (name === "app" || type === "App*") continue;
+        args.push({ name, type: mapType(type) });
+      }
+
+      services.push({
+        name: serviceName,
+        methods: [{ name: serviceName, args, returnType }],
+      });
+      found = true;
+      break;
+    }
+
+    if (!found) {
+      process.stderr.write(
+        `[zapp] warning: could not find function '${handlerName}' for service '${serviceName}'\n`,
+      );
+    }
+  }
+
+  return services;
+}
+
+function generateBindingFile(service: ServiceDef): string {
+  const lines: string[] = [
+    `// Auto-generated by \`zapp generate\`. Do not edit.`,
+    `import { Services } from "@zapp/runtime";`,
+    ``,
+  ];
+
+  const className = service.name.charAt(0).toUpperCase() + service.name.slice(1);
+
+  lines.push(`export class ${className} {`);
+  for (const method of service.methods) {
+    const params = method.args
+      .map((a) => `${a.name}: ${a.type}`)
+      .join(", ");
+    const argsExpr = method.args.length === 0
+      ? "{}"
+      : method.args.length === 1
+        ? method.args[0].name
+        : `{ ${method.args.map((a) => a.name).join(", ")} }`;
+
+    lines.push(
+      `  static async ${method.name}(${params}): Promise<${method.returnType}> {`,
+    );
+    lines.push(
+      `    return Services.invoke<${method.returnType}>("${method.name}", ${argsExpr});`,
+    );
+    lines.push(`  }`);
+  }
+  lines.push(`}`);
+  lines.push(``);
+
+  return lines.join("\n");
+}
+
+export async function runGenerate({
+  root,
+  outDir,
+  frontendDir,
+}: {
+  root: string;
+  outDir?: string;
+  frontendDir?: string;
+}) {
+  const base = frontendDir ?? root;
+  const srcDir = path.join(base, "src");
+  const hasSrcDir = await fs.stat(srcDir).then(() => true, () => false);
+  const targetDir = outDir
+    ? path.resolve(root, outDir)
+    : path.join(hasSrcDir ? srcDir : base, "generated");
+
+  process.stdout.write(`[zapp] scanning for service registrations...\n`);
+  const zappDir = path.join(root, "zapp");
+  const scanDir = await fs.stat(zappDir).then(() => zappDir, () => root);
+  const services = await scanServices(scanDir);
+
+  if (services.length === 0) {
+    process.stdout.write(
+      `[zapp] no service registrations found. Nothing to generate.\n`,
+    );
+    return;
+  }
+
+  await fs.mkdir(targetDir, { recursive: true });
+
+  const indexExports: string[] = [];
+  for (const service of services) {
+    const className =
+      service.name.charAt(0).toUpperCase() + service.name.slice(1);
+    const fileName = `${className}.ts`;
+    const filePath = path.join(targetDir, fileName);
+    const content = generateBindingFile(service);
+    await fs.writeFile(filePath, content, "utf8");
+    process.stdout.write(`[zapp] generated ${path.relative(root, filePath)}\n`);
+    indexExports.push(`export { ${className} } from "./${className}";`);
+  }
+
+  const indexPath = path.join(targetDir, "index.ts");
+  await fs.writeFile(
+    indexPath,
+    `// Auto-generated by \`zapp generate\`. Do not edit.\n${indexExports.join("\n")}\n`,
+    "utf8",
+  );
+  process.stdout.write(
+    `[zapp] generated ${services.length} binding(s) in ${path.relative(root, targetDir)}/\n`,
+  );
+}

package/src/icons.ts

@@ -0,0 +1,116 @@
+import { mkdir, rm } from "node:fs/promises";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { runCmd } from "./common";
+
+/**
+ * macOS icon sizes for iconset.
+ * Each entry: [size, scale] → produces icon_{size}x{size}{@{scale}x}.png
+ */
+const ICNS_SIZES: [number, number][] = [
+  [16, 1], [16, 2],
+  [32, 1], [32, 2],
+  [128, 1], [128, 2],
+  [256, 1], [256, 2],
+  [512, 1], [512, 2],
+];
+
+/**
+ * Generate .icns from a PNG source using sips + iconutil (macOS only).
+ */
+export async function generateIcns(pngPath: string, outputDir: string): Promise<string | null> {
+  if (process.platform !== "darwin") return null;
+  if (!existsSync(pngPath)) {
+    console.warn(`[zapp] icon source not found: ${pngPath}`);
+    return null;
+  }
+
+  const iconsetDir = path.join(outputDir, "AppIcon.iconset");
+  await mkdir(iconsetDir, { recursive: true });
+
+  // Generate all required sizes
+  for (const [size, scale] of ICNS_SIZES) {
+    const pixels = size * scale;
+    const suffix = scale > 1 ? `@${scale}x` : "";
+    const filename = `icon_${size}x${size}${suffix}.png`;
+    const outPath = path.join(iconsetDir, filename);
+    try {
+      await runCmd("sips", ["-z", String(pixels), String(pixels), pngPath, "--out", outPath]);
+    } catch (err) {
+      console.warn(`[zapp] failed to resize icon to ${pixels}x${pixels}: ${err}`);
+      return null;
+    }
+  }
+
+  // Convert iconset to icns
+  const icnsPath = path.join(outputDir, "AppIcon.icns");
+  try {
+    await runCmd("iconutil", ["-c", "icns", iconsetDir, "-o", icnsPath]);
+  } catch (err) {
+    console.warn(`[zapp] iconutil failed: ${err}`);
+    return null;
+  }
+
+  // Clean up iconset folder
+  await rm(iconsetDir, { recursive: true, force: true });
+
+  return icnsPath;
+}
+
+/**
+ * Compile a .icon folder (macOS Tahoe liquid glass) to Assets.car using actool.
+ * Requires Xcode 26 command line tools.
+ */
+export async function compileIconAsset(iconFolder: string, outputDir: string): Promise<string | null> {
+  if (process.platform !== "darwin") return null;
+  if (!existsSync(iconFolder)) {
+    console.warn(`[zapp] .icon folder not found: ${iconFolder}`);
+    return null;
+  }
+
+  try {
+    await runCmd("actool", [
+      "--compile", outputDir,
+      "--platform", "macosx",
+      "--minimum-deployment-target", "26.0",
+      iconFolder,
+    ]);
+    const carPath = path.join(outputDir, "Assets.car");
+    if (existsSync(carPath)) {
+      return carPath;
+    }
+    console.warn("[zapp] actool did not produce Assets.car");
+    return null;
+  } catch (err) {
+    console.warn(`[zapp] actool failed (requires Xcode 26): ${err}`);
+    return null;
+  }
+}
+
+/**
+ * Generate .ico from a PNG source for Windows.
+ * Tries ImageMagick first, falls back to a basic single-size copy.
+ */
+export async function generateIco(pngPath: string, outputPath: string): Promise<string | null> {
+  if (!existsSync(pngPath)) {
+    console.warn(`[zapp] icon source not found: ${pngPath}`);
+    return null;
+  }
+
+  // Try ImageMagick (magick or convert)
+  for (const cmd of ["magick", "convert"]) {
+    try {
+      await runCmd(cmd, [
+        pngPath,
+        "-define", "icon:auto-resize=256,128,64,48,32,16",
+        outputPath,
+      ]);
+      if (existsSync(outputPath)) return outputPath;
+    } catch {
+      // Try next command
+    }
+  }
+
+  console.warn("[zapp] ImageMagick not found — cannot generate .ico. Install ImageMagick for Windows icon support.");
+  return null;
+}

package/src/init.ts

@@ -0,0 +1,190 @@
+import path from "node:path";
+import { spawnStreaming } from "./common";
+import { mkdir } from "node:fs/promises";
+
+export const runInit = async ({
+  root,
+  name,
+  template,
+}: {
+  root: string;
+  name: string;
+  template: string;
+}) => {
+  const projectDir = path.resolve(root, name);
+  const zappDir = path.join(projectDir, "zapp");
+  const configDir = path.join(projectDir, "config");
+  const darwinConfigDir = path.join(configDir, "darwin");
+  const windowsConfigDir = path.join(configDir, "windows");
+
+  console.log(`Scaffolding Zapp project in ${projectDir}...`);
+
+  await mkdir(projectDir, { recursive: true });
+
+  console.log(`Creating Vite project with template: ${template}...`);
+  await spawnStreaming("bun", ["create", "vite", ".", "--template", template], { cwd: projectDir }).exited;
+
+  await mkdir(zappDir, { recursive: true });
+  await mkdir(darwinConfigDir, { recursive: true });
+  await mkdir(windowsConfigDir, { recursive: true });
+
+  // Add Zapp dependencies to package.json
+  const pkgPath = path.join(projectDir, "package.json");
+  let pkgObj: Record<string, unknown> = {};
+  try {
+    const pkgFile = Bun.file(pkgPath);
+    if (await pkgFile.exists()) {
+      pkgObj = JSON.parse(await pkgFile.text());
+    }
+  } catch {
+    console.error(`Warning: Could not read ${pkgPath}`);
+  }
+
+  const devDeps = (pkgObj.devDependencies ?? {}) as Record<string, string>;
+  devDeps["@zapp/cli"] = "latest";
+  devDeps["@zapp/vite"] = "latest";
+  pkgObj.devDependencies = devDeps;
+
+  const deps = (pkgObj.dependencies ?? {}) as Record<string, string>;
+  deps["@zapp/runtime"] = "latest";
+  pkgObj.dependencies = deps;
+
+  await Bun.write(pkgPath, JSON.stringify(pkgObj, null, 2));
+
+  // --- Zen-C entry point ---
+  await Bun.write(path.join(zappDir, "app.zc"), `import "app/app.zc";
+
+fn on_ready(id: int, handle: void*) -> void {
+    Window{id: id, handle: handle}.show();
+}
+
+fn run_app() -> int {
+    let config = AppConfig{
+        name: "${name}",
+        applicationShouldTerminateAfterLastWindowClosed: true,
+        webContentInspectable: -1, // -1 = inherit from build (dev=on, prod=off)
+        maxWorkers: 0,
+        qjsStackSize: 0,
+    };
+    let app = App::new(config);
+
+    let opts = window_options_default("${name}");
+    opts.visible = false;
+    let win = app.window.create(&opts);
+    win.on_ready(on_ready);
+
+    return app.run();
+}
+`);
+
+  // --- Zapp config ---
+  await Bun.write(path.join(zappDir, "zapp.config.ts"), `import { defineConfig } from "@zapp/cli/config";
+
+export default defineConfig({
+  name: "${name}",
+  identifier: "com.zapp.${name.toLowerCase().replace(/[^a-z0-9]/g, "")}",
+  version: "0.1.0",
+});
+`);
+
+  // --- Build entry ---
+  await Bun.write(path.join(zappDir, "build.zc"), `// --- Platform Tags ---
+//> macos: define: apple
+//> windows: define: windows
+
+// --- macOS Directives ---
+//> macos: framework: Cocoa
+//> macos: framework: WebKit
+//> macos: framework: CoreFoundation
+//> macos: framework: JavaScriptCore
+//> macos: framework: Security
+//> macos: link: -lcompression
+//> macos: cflags: -fobjc-arc -x objective-c
+// To use QuickJS instead of JSC on macOS, uncomment:
+// //> macos: define: ZAPP_WORKER_ENGINE_QJS
+
+// --- Windows Directives ---
+//> windows: cflags: -DUNICODE -D_UNICODE -DCINTERFACE -DCOBJMACROS
+//> windows: link: -lole32 -lshell32 -luuid -luser32 -lgdi32 -lcomctl32 -lcomdlg32 -lshlwapi
+//> windows: link: -lwinhttp -lbcrypt -ladvapi32 -lrpcrt4 -lcrypt32 -lversion
+// Uncomment to enable Zapp Workers on Windows (adds ~760 KB):
+// //> windows: define: ZAPP_WORKER_ENGINE_QJS
+
+import "app.zc";
+
+fn main() -> int {
+    return run_app();
+}
+`);
+
+  // --- macOS Info.plist ---
+  await Bun.write(path.join(darwinConfigDir, "Info.plist"), `<?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>
+    <key>CFBundleName</key>
+    <string>${name}</string>
+    <key>CFBundleIdentifier</key>
+    <string>com.zapp.${name.toLowerCase().replace(/[^a-z0-9]/g, "")}</string>
+    <key>CFBundleVersion</key>
+    <string>1.0.0</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0.0</string>
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+    <key>LSMinimumSystemVersion</key>
+    <string>13.0</string>
+    <key>NSHighResolutionCapable</key>
+    <true/>
+</dict>
+</plist>
+`);
+
+  // --- Windows app.manifest ---
+  await Bun.write(path.join(windowsConfigDir, "app.manifest"), `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+  <assemblyIdentity
+    type="win32"
+    name="com.zapp.${name.toLowerCase().replace(/[^a-z0-9]/g, "")}"
+    version="1.0.0.0"
+  />
+  <description>${name}</description>
+
+  <!-- Enable visual styles (modern controls) -->
+  <dependency>
+    <dependentAssembly>
+      <assemblyIdentity
+        type="win32"
+        name="Microsoft.Windows.Common-Controls"
+        version="6.0.0.0"
+        processorArchitecture="*"
+        publicKeyToken="6595b64144ccf1df"
+        language="*"
+      />
+    </dependentAssembly>
+  </dependency>
+
+  <!-- High-DPI awareness (Per-Monitor V2) -->
+  <application xmlns="urn:schemas-microsoft-com:asm.v3">
+    <windowsSettings>
+      <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2,PerMonitor</dpiAwareness>
+      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">True/PM</dpiAware>
+    </windowsSettings>
+  </application>
+
+  <!-- Declare supported OS versions -->
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" /> <!-- Windows 10/11 -->
+      <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}" /> <!-- Windows 8.1 -->
+    </application>
+  </compatibility>
+</assembly>
+`);
+
+  console.log(`\nProject ${name} scaffolded successfully!`);
+  console.log(`Next steps:`);
+  console.log(`  cd ${name}`);
+  console.log(`  bun install`);
+  console.log(`  zapp dev`);
+};