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

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.inspectable {
+        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
+    inspectable: 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:
+//   inspectable: Zapp::inspectable_auto(),
+//   inspectable: Zapp::inspectable_on(),
+//   inspectable: 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:
+//   inspectable: 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.inspectable {
+            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,
+        inspectable: 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.2",
   "type": "module",
   "bin": {
     "zapp": "./src/zapp-cli.ts"

package/src/init.ts

@@ -51,7 +51,7 @@ fn run_app() -> int {
     let config = AppConfig{
         name: "${name}",
         applicationShouldTerminateAfterLastWindowClosed: true,
-        webContentInspectable: Inspectable.auto,
+        inspectable: Zapp::inspectable_auto(),
         maxWorkers: 0,
         qjsStackSize: 0,
         backend: false,

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