@zappdev/cli 0.5.0-alpha.1 → 0.5.0-alpha.10

package/dist/config.js

@@ -0,0 +1,25 @@
+// src/config.ts
+import path from "node:path";
+function defineConfig(config) {
+  return config;
+}
+async function loadConfig(root) {
+  const configPath = path.join(root, "zapp.config.ts");
+  try {
+    const mod = await import(configPath);
+    const config = typeof mod.default === "function" ? mod.default() : mod.default;
+    return {
+      ...config,
+      assetDir: config.assetDir ?? "./dist"
+    };
+  } catch {
+    return {
+      name: path.basename(root),
+      assetDir: "./dist"
+    };
+  }
+}
+export {
+  loadConfig,
+  defineConfig
+};

package/native/app/app.zc

@@ -38,7 +38,12 @@ fn app_get_bootstrap_name() -> string {
 
 fn app_get_bootstrap_web_content_inspectable() -> bool {
     let app = (App*)app_get_active();
-    if app != NULL { return app.config.webContentInspectable > 0; }
+    if app == NULL { return false; }
+    match app.config.webContentInspectable {
+        ZappInspectable::On => { return true; },
+        ZappInspectable::Off => { return false; },
+        ZappInspectable::Auto => { return zapp_build_dev_tools_default() > 0; },
+    }
     return false;
 }
 
@@ -161,24 +166,45 @@ fn zapp_handle_message_from_window(app_ptr: void*, msg: string, window_id: int)
 
 // Service bindings — provided by service/service.zc (imported via router.zc)
 
+// Whether the webview inspector (devtools) is available.
+//   Auto — inherit from build mode (dev → on, prod → off)
+//   On   — always available (useful for debugging)
+//   Off  — never available (hardened production)
+enum ZappInspectable {
+    Auto,
+    On,
+    Off,
+}
+
 struct AppConfig {
     name: string;
     applicationShouldTerminateAfterLastWindowClosed: bool;
-    webContentInspectable: int; // -1 = auto (dev → on, prod → off), 0 = off, 1 = on
+    webContentInspectable: ZappInspectable;
     maxWorkers: int;
     qjsStackSize: int;
     backend: bool;  // enable backend worker (src/backend.ts)
 }
 
-// Named toggle values — use as AppConfig fields instead of raw int literals.
-//   webContentInspectable: Inspectable.auto,
-//   webContentInspectable: Inspectable.on,
-//   webContentInspectable: Inspectable.off,
-struct Inspectable {}
-impl Inspectable {
-    def auto: int = -1;
-    def off: int = 0;
-    def on: int = 1;
+// ---------------------------------------------------------------------------
+// Zapp namespace — convenience accessors for framework enums and values.
+//
+// Usage:
+//   webContentInspectable: Zapp::inspectable_auto(),
+//   webContentInspectable: Zapp::inspectable_on(),
+//   webContentInspectable: Zapp::inspectable_off(),
+//
+// These return the proper enum type so you get match exhaustiveness and
+// type checking. The enum constructors also work directly if you prefer:
+//   webContentInspectable: ZappInspectable::Auto(),
+//
+// As Zapp adds more framework-level options (log levels, security modes,
+// etc.), new accessors will appear here under the same Zapp:: namespace.
+// ---------------------------------------------------------------------------
+struct Zapp {}
+impl Zapp {
+    fn inspectable_auto() -> ZappInspectable { return ZappInspectable::Auto(); }
+    fn inspectable_on() -> ZappInspectable { return ZappInspectable::On(); }
+    fn inspectable_off() -> ZappInspectable { return ZappInspectable::Off(); }
 }
 
 struct App {
@@ -195,13 +221,12 @@ struct App {
 impl App {
     fn new(config: AppConfig) -> App {
         let wm = WindowManager::new();
-        if config.webContentInspectable > 0 {
-            wm.webContentInspectable = true;
-        } else if config.webContentInspectable == 0 {
-            wm.webContentInspectable = false;
-        } else {
-            // -1 = inherit from build mode (dev → on, prod → off)
-            wm.webContentInspectable = zapp_build_dev_tools_default() > 0;
+        match config.webContentInspectable {
+            ZappInspectable::On => { wm.webContentInspectable = true; },
+            ZappInspectable::Off => { wm.webContentInspectable = false; },
+            ZappInspectable::Auto => {
+                wm.webContentInspectable = zapp_build_dev_tools_default() > 0;
+            },
         }
 
         platform_init(config.name);

package/native/build.zc

@@ -53,9 +53,10 @@ fn main() -> int {
     let config = AppConfig{
         name: "Zapp v2 Test",
         applicationShouldTerminateAfterLastWindowClosed: true,
-        webContentInspectable: 1,
+        webContentInspectable: Zapp::inspectable_on(),
         maxWorkers: 0,
         qjsStackSize: 0,
+        backend: false,
     };
     let app = App::new(config);
 

package/package.json

@@ -1,19 +1,26 @@
 {
   "name": "@zappdev/cli",
-  "version": "0.5.0-alpha.1",
+  "version": "0.5.0-alpha.10",
   "type": "module",
   "bin": {
     "zapp": "./src/zapp-cli.ts"
   },
+  "exports": {
+    "./config": {
+      "types": "./src/config.ts",
+      "default": "./dist/config.js"
+    }
+  },
   "files": [
     "src/",
+    "dist/",
     "native/",
     "bootstrap/",
     "assets/",
     "vendor/webview2/"
   ],
   "scripts": {
-    "prepack": "cp -r ../native ./native && cp -r ../bootstrap ./bootstrap && cp -r ../assets ./assets && mkdir -p ./vendor && cp -r ../vendor/webview2 ./vendor/webview2",
+    "prepack": "bun build src/config.ts --outdir dist --format esm --target node && cp -r ../native ./native && cp -r ../bootstrap ./bootstrap && cp -r ../assets ./assets && mkdir -p ./vendor && cp -r ../vendor/webview2 ./vendor/webview2",
     "postpack": "rm -rf ./native ./bootstrap ./assets ./vendor"
   },
   "dependencies": {

package/src/config.ts

@@ -26,6 +26,7 @@ export interface ZappConfig {
   version?: string;
   assetDir?: string;  // Default: "./dist" (Vite), configurable for static sites
   devPort?: number;   // Default: 5173
+  backend?: string;   // Path to backend worker source (e.g. "src/server.ts"). Omit for no backend.
   deepLinkSchemes?: string[];  // e.g. ["myapp"] → registers myapp:// URL scheme
   macos?: MacOSConfig;
   security?: SecurityConfig;

package/src/init.ts

@@ -21,13 +21,15 @@ export async function runInit(opts: InitOptions) {
     process.exit(1);
   }
 
-  // 1. Create Vite project
+  // 1. Scaffold Vite project files (no install, no dev server).
+  // create-vite has an --immediate flag that auto-installs + starts the dev
+  // server, and an interactive prompt that does the same if confirmed.
+  // --no-interactive skips the prompt and defaults to no install.
   process.stdout.write(`[zapp] creating ${name} with template ${template}...\n`);
-  const viteProc = Bun.spawn(["bun", "create", "vite", name, "--template", template], {
-    cwd: root,
-    stdout: "inherit",
-    stderr: "inherit",
-  });
+  const viteProc = Bun.spawn(
+    ["bunx", "create-vite@latest", name, "--template", template, "--no-interactive"],
+    { cwd: root, stdout: "inherit", stderr: "inherit" },
+  );
   if ((await viteProc.exited) !== 0) {
     process.stderr.write("[zapp] vite scaffold failed\n");
     process.exit(1);
@@ -51,7 +53,7 @@ fn run_app() -> int {
     let config = AppConfig{
         name: "${name}",
         applicationShouldTerminateAfterLastWindowClosed: true,
-        webContentInspectable: Inspectable.auto,
+        webContentInspectable: Zapp::inspectable_auto(),
         maxWorkers: 0,
         qjsStackSize: 0,
         backend: false,
@@ -100,13 +102,15 @@ fn main() -> int {
 }
 `);
 
-  // 3. Add zapp.config.ts
+  // 3. Add zapp.config.ts — typed via defineConfig for autocomplete
   const identifier = `com.zapp.${name.toLowerCase().replace(/[^a-z0-9]/g, "")}`;
-  await Bun.write(path.join(projectDir, "zapp.config.ts"), `export default {
+  await Bun.write(path.join(projectDir, "zapp.config.ts"), `import { defineConfig } from "@zappdev/cli/config";
+
+export default defineConfig({
   name: "${name}",
   identifier: "${identifier}",
   version: "0.1.0",
-};
+});
 `);
 
   // 4. Update package.json — add deps and scripts
@@ -117,31 +121,72 @@ fn main() -> int {
     ...pkgObj.scripts,
     "dev": "zapp dev",
     "build": "zapp build",
+    "package": "zapp package",
     "generate": "zapp generate",
   };
 
   pkgObj.dependencies = {
     ...(pkgObj.dependencies ?? {}),
-    "@zappdev/runtime": "^0.5.0",
+    "@zappdev/runtime": "^0.5.0-alpha.0",
   };
   pkgObj.devDependencies = {
     ...(pkgObj.devDependencies ?? {}),
-    "@zappdev/cli": "^0.5.0",
-    "@zappdev/vite": "^0.5.0",
+    "@zappdev/cli": "^0.5.0-alpha.0",
+    "@zappdev/vite": "^0.5.0-alpha.0",
   };
 
   await Bun.write(pkgPath, JSON.stringify(pkgObj, null, 2));
 
-  // 5. Overwrite vite.config.ts with Zapp plugin wiring
-  // The Vite scaffold creates a minimal one, but we need the zappWorkers()
-  // plugin for worker bundling support.
-  await Bun.write(path.join(projectDir, "vite.config.ts"), `import { defineConfig } from "vite";
+  // 5. Inject zappWorkers() into the template's vite.config.ts
+  // Templates like svelte-ts ship their own vite.config.ts with framework
+  // plugins (e.g. svelte()). We must preserve those and append ours.
+  const viteConfigPath = path.join(projectDir, "vite.config.ts");
+  // Also check .js — some templates use vite.config.js
+  const viteConfigJsPath = path.join(projectDir, "vite.config.js");
+  const configPath = existsSync(viteConfigPath) ? viteConfigPath
+    : existsSync(viteConfigJsPath) ? viteConfigJsPath
+    : null;
+
+  if (configPath) {
+    let viteConfig = await Bun.file(configPath).text();
+
+    // Add our imports at the top (after existing imports)
+    const importLines = [
+      `import { zappWorkers } from "@zappdev/vite";`,
+      `import zappConfig from "./zapp.config";`,
+    ];
+    for (const importLine of importLines) {
+      const pkg = importLine.match(/from ["'](.+?)["']/)?.[1] ?? "";
+      if (viteConfig.includes(pkg)) continue;
+      const lastImportIdx = viteConfig.lastIndexOf("\nimport ");
+      if (lastImportIdx >= 0) {
+        const endOfLine = viteConfig.indexOf("\n", lastImportIdx + 1);
+        viteConfig = viteConfig.slice(0, endOfLine + 1) + importLine + "\n" + viteConfig.slice(endOfLine + 1);
+      } else {
+        viteConfig = importLine + "\n" + viteConfig;
+      }
+    }
+
+    // Append zappWorkers() with config to the plugins array
+    if (!viteConfig.includes("zappWorkers(")) {
+      viteConfig = viteConfig.replace(
+        /plugins:\s*\[/,
+        "plugins: [zappWorkers({ backend: zappConfig.backend }), "
+      );
+    }
+
+    await Bun.write(configPath, viteConfig);
+  } else {
+    // No vite.config found — create a minimal one
+    await Bun.write(viteConfigPath, `import { defineConfig } from "vite";
 import { zappWorkers } from "@zappdev/vite";
+import zappConfig from "./zapp.config";
 
 export default defineConfig({
-  plugins: [zappWorkers()],
+  plugins: [zappWorkers({ backend: zappConfig.backend })],
 });
 `);
+  }
 
   // 6. Add .zapp/ to .gitignore
   const gitignorePath = path.join(projectDir, ".gitignore");
@@ -158,6 +203,7 @@ export default defineConfig({
   process.stdout.write(`  Then add to your entry file (e.g. src/main.ts):\n\n`);
   process.stdout.write(`    import { Window, WindowEvent, Services } from "@zappdev/runtime";\n\n`);
   process.stdout.write(`  Run:\n`);
-  process.stdout.write(`    zapp dev      # development with Vite HMR\n`);
-  process.stdout.write(`    zapp build    # production build\n\n`);
+  process.stdout.write(`    bun run dev      # development with Vite HMR\n`);
+  process.stdout.write(`    bun run build    # production build\n`);
+  process.stdout.write(`    bun run package  # .app bundle (macOS)\n\n`);
 }

package/src/native.ts

@@ -103,6 +103,8 @@ export async function compileNative(opts: CompileOptions): Promise<void> {
   const { generatePlatformConfig } = await import("./build-config");
   const platformFile = await generatePlatformConfig(root);
 
+  const verbose = process.argv.includes("--verbose") || process.argv.includes("-v");
+
   const zcArgs = [
     "build",
     buildFile,
@@ -112,21 +114,39 @@ export async function compileNative(opts: CompileOptions): Promise<void> {
     ...(assetsFile ? [assetsFile] : []),
     "-I", nativeDir,
     "-o", output,
+    // Suppress C compiler warnings by default. The framework and zc stdlib
+    // generate ~200 warnings (parentheses-equality, incompatible-pointer-types,
+    // etc.) that are pure noise for end users and bury any actual error.
+    // Pass --verbose to see them.
+    ...(verbose ? [] : ["-w"]),
   ];
 
-  // Size optimizations deferred for v2 baseline.
-  // When re-introduced: -Oz, -flto, --no-debug, strip
-
-  // Debug: uncomment to see zc invocation
-  // process.stderr.write(`[zapp] zc ${zcArgs.join(" ")}\n`);
   const proc = Bun.spawn(["zc", ...zcArgs], {
     cwd: root,
-    stdout: "inherit",
-    stderr: "inherit",
+    stdout: verbose ? "inherit" : "pipe",
+    stderr: "pipe",
   });
+
+  const [stdoutText, stderrText] = await Promise.all([
+    verbose ? "" : new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ]);
+
   const exitCode = await proc.exited;
   if (exitCode !== 0) {
-    throw new Error(`[zapp] zc compilation failed (exit ${exitCode})`);
+    // Show only error lines (not warnings) unless verbose.
+    if (!verbose && stderrText) {
+      const errors = stderrText.split("\n").filter(
+        line => line.includes("error:") || line.includes("error :") || line.startsWith("  ")
+      );
+      if (errors.length > 0) {
+        process.stderr.write(errors.join("\n") + "\n");
+      } else {
+        // Fallback: show everything if we couldn't filter.
+        process.stderr.write(stderrText);
+      }
+    }
+    throw new Error(`[zapp] compilation failed (exit ${exitCode}). Run with --verbose for full output.`);
   }
 
   // Strip deferred for v2 baseline

package/src/workers.ts

@@ -45,7 +45,7 @@ async function discoverWorkers(srcDir: string): Promise<WorkerEntry[]> {
   return [...found.entries()].map(([entryPath, specifier]) => ({ entryPath, specifier }));
 }
 
-export async function bundleWorkers(root: string): Promise<number> {
+export async function bundleWorkers(root: string, backendConfig?: string): Promise<number> {
   const srcDir = path.join(root, "src");
   const outDir = path.join(root, ".zapp", "workers");
   await mkdir(outDir, { recursive: true });
@@ -81,8 +81,10 @@ export async function bundleWorkers(root: string): Promise<number> {
     }
   }
 
-  // Backend worker — convention: src/backend.ts
-  const backendPath = path.join(root, "src", "backend.ts");
+  // Backend worker — from config or fall back to src/backend.ts convention
+  const backendPath = backendConfig
+    ? path.resolve(root, backendConfig)
+    : path.join(root, "src", "backend.ts");
   try {
     await stat(backendPath);
     const outPath = path.join(outDir, "backend.mjs");
@@ -95,12 +97,12 @@ export async function bundleWorkers(root: string): Promise<number> {
       minify: false,
     });
     if (result.success) {
-      process.stdout.write("[zapp] backend worker detected: src/backend.ts\n");
+      process.stdout.write(`[zapp] backend worker: ${path.relative(root, backendPath)}\n`);
     } else {
       process.stderr.write("[zapp] backend bundle failed\n");
     }
   } catch {
-    // No backend.ts — that's fine, backend is optional
+    // No backend file — that's fine, backend is optional
   }
 
   return workers.length;