@zappdev/cli 0.1.0

package/src/package.ts

@@ -0,0 +1,150 @@
+import { mkdir, copyFile, chmod } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { existsSync } from "node:fs";
+import { runCmd } from "./common";
+import type { ResolvedZappConfig } from "./config";
+import { generateIcns, compileIconAsset } from "./icons";
+
+export const runPackage = async ({ root, nativeOut, config }: { root: string; nativeOut: string; config: ResolvedZappConfig }) => {
+  if (process.platform === "darwin") {
+    await packageMacOS({ root, nativeOut, config });
+  } else if (process.platform === "win32") {
+    console.log("[zapp] Windows packaging: the binary is ready at " + nativeOut);
+    console.log("[zapp] Icon embedding happens during 'zapp build' (see build.ts).");
+    console.log("[zapp] Installer generation (NSIS/MSIX) is not yet implemented.");
+  } else {
+    console.error("[zapp] Packaging is not yet supported on this platform.");
+  }
+};
+
+async function packageMacOS({ root, nativeOut, config }: { root: string; nativeOut: string; config: ResolvedZappConfig }) {
+  const appName = config.name;
+  const appBundleName = `${appName}.app`;
+  const binDir = path.join(root, "bin");
+  await mkdir(binDir, { recursive: true });
+  const appBundlePath = path.join(binDir, appBundleName);
+
+  process.stdout.write(`[zapp] packaging ${appName} → ${appBundleName}\n`);
+
+  const contentsDir = path.join(appBundlePath, "Contents");
+  const macosDir = path.join(contentsDir, "MacOS");
+  const resourcesDir = path.join(contentsDir, "Resources");
+
+  await mkdir(macosDir, { recursive: true });
+  await mkdir(resourcesDir, { recursive: true });
+
+  // 1. Copy the executable
+  const execPath = path.resolve(root, nativeOut);
+  if (!existsSync(execPath)) {
+    console.error(`[zapp] binary not found at ${execPath}. Run 'zapp build' first.`);
+    return;
+  }
+
+  const destExecPath = path.join(macosDir, appName);
+  await copyFile(execPath, destExecPath);
+  await chmod(destExecPath, 0o755);
+
+  // 2. Icons
+  let hasIcon = false;
+  let hasLiquidGlass = false;
+
+  // Standard icon: PNG → .icns
+  if (config.icon) {
+    const iconSource = path.resolve(root, config.icon);
+    const icnsPath = await generateIcns(iconSource, resourcesDir);
+    if (icnsPath) {
+      hasIcon = true;
+      process.stdout.write(`[zapp] generated AppIcon.icns\n`);
+    }
+  }
+
+  // Liquid glass icon: .icon folder → Assets.car
+  if (config.macos?.iconLayers) {
+    const iconFolder = path.resolve(root, config.macos.iconLayers);
+    const carPath = await compileIconAsset(iconFolder, resourcesDir);
+    if (carPath) {
+      hasLiquidGlass = true;
+      process.stdout.write(`[zapp] compiled liquid glass icon → Assets.car\n`);
+    }
+  }
+
+  // 3. Generate Info.plist
+  const configPlistPath = path.join(root, "config", "darwin", "Info.plist");
+  let plistContent = "";
+
+  if (existsSync(configPlistPath)) {
+    plistContent = await Bun.file(configPlistPath).text();
+    // Inject icon keys if icon was generated and plist doesn't have them
+    if (hasIcon && !plistContent.includes("CFBundleIconFile")) {
+      plistContent = plistContent.replace(
+        "</dict>",
+        `    <key>CFBundleIconFile</key>\n    <string>AppIcon</string>\n    <key>CFBundleIconName</key>\n    <string>AppIcon</string>\n</dict>`
+      );
+    }
+    process.stdout.write(`[zapp] using custom Info.plist\n`);
+  } else {
+    const minVersion = config.macos?.minimumSystemVersion ?? "13.0";
+    const category = config.macos?.category ?? "";
+    const copyright = config.author ? `Copyright © ${new Date().getFullYear()} ${config.author}` : "";
+
+    let extraKeys = "";
+    if (hasIcon || hasLiquidGlass) {
+      extraKeys += `    <key>CFBundleIconFile</key>
+    <string>AppIcon</string>
+    <key>CFBundleIconName</key>
+    <string>AppIcon</string>\n`;
+    }
+    if (category) {
+      extraKeys += `    <key>LSApplicationCategoryType</key>
+    <string>${category}</string>\n`;
+    }
+    if (copyright) {
+      extraKeys += `    <key>NSHumanReadableCopyright</key>
+    <string>${copyright}</string>\n`;
+    }
+
+    plistContent = `<?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>${appName}</string>
+    <key>CFBundleExecutable</key>
+    <string>${appName}</string>
+    <key>CFBundleIdentifier</key>
+    <string>${config.identifier}</string>
+    <key>CFBundleVersion</key>
+    <string>${config.version}</string>
+    <key>CFBundleShortVersionString</key>
+    <string>${config.version}</string>
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+    <key>LSMinimumSystemVersion</key>
+    <string>${minVersion}</string>
+    <key>NSHighResolutionCapable</key>
+    <true/>
+${extraKeys}</dict>
+</plist>`;
+  }
+
+  // Ensure CFBundleExecutable is set correctly
+  if (!plistContent.includes("<key>CFBundleExecutable</key>")) {
+    plistContent = plistContent.replace(
+      "<dict>",
+      `<dict>\n    <key>CFBundleExecutable</key>\n    <string>${appName}</string>`
+    );
+  }
+
+  await Bun.write(path.join(contentsDir, "Info.plist"), plistContent);
+
+  // 4. Ad-hoc codesign
+  try {
+    await runCmd("codesign", ["--force", "--deep", "--sign", "-", appBundlePath]);
+    process.stdout.write(`[zapp] codesigned (ad-hoc)\n`);
+  } catch {
+    console.warn("[zapp] codesign failed (non-fatal)");
+  }
+
+  process.stdout.write(`[zapp] packaged → ${appBundlePath}\n`);
+}

package/src/zapp-cli.ts

@@ -0,0 +1,263 @@
+#!/usr/bin/env bun
+import path from "node:path";
+import process from "node:process";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { runDev } from "./dev";
+import { runBuild } from "./build";
+import { runInit } from "./init";
+import { runPackage } from "./package";
+import { runGenerate } from "./generate";
+import { loadConfig } from "./config";
+
+const VALID_LOG_LEVELS = ["error", "warn", "info", "debug", "trace"] as const;
+type LogLevel = typeof VALID_LOG_LEVELS[number];
+
+const checkPrerequisites = () => {
+  const which = Bun.which("zc");
+  if (!which) {
+    console.error(
+      "[zapp] Error: 'zc' (Zen-C compiler) not found on PATH.\n" +
+      "  Install from: https://github.com/zenc-lang/zenc\n"
+    );
+    process.exit(1);
+  }
+};
+
+const cwd = process.cwd();
+
+const commonOptions = {
+  root: {
+    type: "string" as const,
+    default: ".",
+    describe: "Project root directory",
+  },
+  frontend: {
+    type: "string" as const,
+    default: ".",
+    describe: "Frontend directory",
+  },
+  input: {
+    type: "string" as const,
+    default: "zapp/build.zc",
+    describe: "Build file (alias: --build-file)",
+  },
+  out: {
+    type: "string" as const,
+    describe: "Override output binary path",
+  },
+  backend: {
+    type: "string" as const,
+    describe: "Backend script path",
+  },
+  "log-level": {
+    type: "string" as const,
+    choices: VALID_LOG_LEVELS,
+    describe: "Log level",
+  },
+} as const;
+
+const cli = yargs(hideBin(process.argv))
+  .scriptName("zapp")
+  .usage("zapp <command> [options]")
+  .strict()
+  .demandCommand(1, "Please specify a command")
+  .command(
+    "init [name]",
+    "Scaffold a new Zapp project",
+    (yargs) =>
+      yargs
+        .positional("name", {
+          type: "string",
+          default: "zapp-app",
+          describe: "Project name",
+        })
+        .option("template", {
+          type: "string",
+          default: "vanilla-ts",
+          describe: "Vite template (e.g. vanilla-ts, react-ts, svelte-ts, vue-ts)",
+        })
+        .option("root", commonOptions.root),
+    async (argv) => {
+      const root = path.resolve(cwd, argv.root);
+      await runInit({
+        root,
+        name: argv.name,
+        template: argv.template,
+      });
+    }
+  )
+  .command(
+    "dev",
+    "Run Vite + native app together",
+    (yargs) =>
+      yargs
+        .option("root", commonOptions.root)
+        .option("frontend", commonOptions.frontend)
+        .option("input", commonOptions.input)
+        .option("out", commonOptions.out)
+        .option("backend", commonOptions.backend)
+        .option("log-level", commonOptions["log-level"])
+        .option("dev-url", {
+          type: "string",
+          default: "http://localhost:5173",
+          describe: "Dev server URL",
+        })
+        .option("brotli", {
+          type: "boolean",
+          default: false,
+          describe: "Brotli-compress embedded assets",
+        })
+        .option("embed-assets", {
+          type: "boolean",
+          default: false,
+          describe: "Embed assets in binary (default: false for dev)",
+        }),
+    async (argv) => {
+      checkPrerequisites();
+      const root = path.resolve(cwd, argv.root);
+      const frontendDir = path.resolve(root, argv.frontend);
+      const buildFile = path.resolve(root, argv.input);
+      const config = await loadConfig(root);
+      const nativeOut = argv.out
+        ? path.resolve(root, argv.out)
+        : path.resolve(root, "bin", process.platform === "win32" ? `${config.name}.exe` : config.name);
+
+      await runDev({
+        root,
+        frontendDir,
+        buildFile,
+        nativeOut,
+        devUrl: argv["dev-url"],
+        withBrotli: argv.brotli,
+        embedAssets: argv["embed-assets"],
+        backendScript: argv.backend,
+        logLevel: argv["log-level"] as LogLevel | undefined,
+        config,
+      });
+    }
+  )
+  .command(
+    "build",
+    "Build frontend assets + native binary",
+    (yargs) =>
+      yargs
+        .option("root", commonOptions.root)
+        .option("frontend", commonOptions.frontend)
+        .option("input", commonOptions.input)
+        .option("out", commonOptions.out)
+        .option("backend", commonOptions.backend)
+        .option("log-level", commonOptions["log-level"])
+        .option("asset-dir", {
+          type: "string",
+          default: "dist",
+          describe: "Asset directory",
+        })
+        .option("brotli", {
+          type: "boolean",
+          default: false,
+          describe: "Brotli-compress embedded assets",
+        })
+        .option("debug", {
+          type: "boolean",
+          default: false,
+          describe: "Debug build (filesystem assets, debug logs, no optimizations)",
+        }),
+    async (argv) => {
+      checkPrerequisites();
+      const root = path.resolve(cwd, argv.root);
+      const frontendDir = path.resolve(root, argv.frontend);
+      const buildFile = path.resolve(root, argv.input);
+      const assetDir = path.resolve(frontendDir, argv["asset-dir"]);
+      const config = await loadConfig(root);
+      const nativeOut = argv.out
+        ? path.resolve(root, argv.out)
+        : path.resolve(root, "bin", process.platform === "win32" ? `${config.name}.exe` : config.name);
+
+      // Embed assets by default for builds, unless --debug
+      const embedAssets = !argv.debug;
+
+      await runBuild({
+        root,
+        frontendDir,
+        buildFile,
+        nativeOut,
+        assetDir,
+        withBrotli: argv.brotli,
+        embedAssets,
+        isDebug: argv.debug,
+        backendScript: argv.backend,
+        logLevel: argv["log-level"] as LogLevel | undefined,
+        config,
+      });
+    }
+  )
+  .command(
+    "package",
+    "Build and package into a platform bundle (.app on macOS)",
+    (yargs) =>
+      yargs
+        .option("root", commonOptions.root)
+        .option("frontend", commonOptions.frontend)
+        .option("input", commonOptions.input)
+        .option("out", commonOptions.out)
+        .option("brotli", {
+          type: "boolean",
+          default: true,
+          describe: "Brotli-compress embedded assets",
+        })
+        .option("skip-build", {
+          type: "boolean",
+          default: false,
+          describe: "Skip the build step (use existing binary)",
+        }),
+    async (argv) => {
+      checkPrerequisites();
+      const root = path.resolve(cwd, argv.root);
+      const frontendDir = path.resolve(root, argv.frontend);
+      const buildFile = path.resolve(root, argv.input);
+      const config = await loadConfig(root);
+      const nativeOut = argv.out
+        ? path.resolve(root, argv.out)
+        : path.resolve(root, "bin", process.platform === "win32" ? `${config.name}.exe` : config.name);
+
+      if (!argv["skip-build"]) {
+        const assetDir = path.resolve(frontendDir, "dist");
+        await runBuild({
+          root,
+          frontendDir,
+          buildFile,
+          nativeOut,
+          assetDir,
+          isDebug: false,
+          embedAssets: true,
+          withBrotli: argv.brotli,
+          config,
+        });
+      }
+
+      await runPackage({ root, nativeOut, config });
+    }
+  )
+  .command(
+    "generate",
+    "Generate TypeScript bindings from Zen-C services",
+    (yargs) =>
+      yargs
+        .option("root", commonOptions.root)
+        .option("frontend", commonOptions.frontend)
+        .option("out-dir", {
+          type: "string",
+          describe: "Output directory for generated files",
+        }),
+    async (argv) => {
+      const root = path.resolve(cwd, argv.root);
+      const frontendDir = path.resolve(root, argv.frontend);
+      await runGenerate({ root, frontendDir, outDir: argv["out-dir"] });
+    }
+  )
+  .alias("h", "help")
+  .alias("v", "version")
+  .alias("build-file", "input")
+  .epilogue("Documentation: https://zapp.dev")
+  .parse();