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

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,6 +1,6 @@
 {
   "name": "@zappdev/cli",
-  "version": "0.5.0-alpha.1",
+  "version": "0.5.0-alpha.3",
   "type": "module",
   "bin": {
     "zapp": "./src/zapp-cli.ts"

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

@@ -51,7 +51,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,
@@ -117,6 +117,7 @@ fn main() -> int {
     ...pkgObj.scripts,
     "dev": "zapp dev",
     "build": "zapp build",
+    "package": "zapp package",
     "generate": "zapp generate",
   };
 
@@ -158,6 +159,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;