@zappdev/cli 0.1.0

package/native/src/app/app.zc

@@ -0,0 +1,490 @@
+import "../platform/platform.zc";
+import "../platform/window.zc";
+import "../event/event.zc";
+import "../event/events.zc";
+import "../service/service.zc";
+import "../platform/shared/log.zc";
+import "std/json.zc";
+include <string.h>
+
+struct AppConfig {
+    name: string;
+    applicationShouldTerminateAfterLastWindowClosed: bool;
+    webContentInspectable: bool;
+    maxWorkers: int;
+    qjsStackSize: int; // QuickJS stack size in bytes (0 = default 4MB)
+}
+
+opaque struct _AppConfig {
+    name: string;
+    applicationShouldTerminateAfterLastWindowClosed: bool;
+    webContentInspectable: bool;
+    maxWorkers: int;
+    qjsStackSize: int;
+}
+
+struct App {
+    config: _AppConfig;
+    window: WindowManager;
+    event: EventManager;
+    service: ServiceManager;
+    has_backend: bool;
+}
+
+impl App {
+    fn new(config: AppConfig) -> Self {
+        app_set_bootstrap_config(config);
+        let windowManager = WindowManager::new();
+        windowManager.webContentInspectable = config.webContentInspectable;
+        return App{
+            config: _AppConfig{
+                name: config.name,
+                applicationShouldTerminateAfterLastWindowClosed: config.applicationShouldTerminateAfterLastWindowClosed,
+                webContentInspectable: config.webContentInspectable,
+                maxWorkers: config.maxWorkers,
+                qjsStackSize: config.qjsStackSize,
+            },
+            window: windowManager,
+            event: EventManager::new(),
+            service: ServiceManager::new(),
+            has_backend: false,
+        };
+    }
+
+    fn config(self) -> AppConfig {
+        return AppConfig{
+            name: self.config.name,
+            applicationShouldTerminateAfterLastWindowClosed: self.config.applicationShouldTerminateAfterLastWindowClosed,
+            webContentInspectable: self.config.webContentInspectable,
+            maxWorkers: self.config.maxWorkers,
+            qjsStackSize: self.config.qjsStackSize,
+        };
+    }
+
+    fn run(self) -> int {
+        // Initialize logging with build config log level
+        raw {
+            extern const char* zapp_build_log_level(void);
+            const char* level_str = zapp_build_log_level();
+            int level = ZAPP_LOG_INFO; // default
+            if (level_str) {
+                if (strcmp(level_str, "error") == 0) level = ZAPP_LOG_ERROR;
+                else if (strcmp(level_str, "warn") == 0) level = ZAPP_LOG_WARN;
+                else if (strcmp(level_str, "info") == 0) level = ZAPP_LOG_INFO;
+                else if (strcmp(level_str, "debug") == 0) level = ZAPP_LOG_DEBUG;
+                else if (strcmp(level_str, "trace") == 0) level = ZAPP_LOG_TRACE;
+            }
+            zapp_log_init(level);
+        }
+        
+        println "Running app: {self.config.name}";
+        self.window.app = self;
+        self.event.app = self;
+        self.service.app = self;
+        if !service_start_all(self) {
+            return 1;
+        }
+        app_set_active(self);
+        platform_bind_runtime(self);
+        app_start_backend(self);
+        let result = platform_run(self);
+        app_stop_backend(self);
+        service_shutdown_all(self);
+        app_set_active(NULL);
+        return result;
+    }
+
+    fn on_shutdown(self, cb: fn*() -> void) -> void {
+        let _self = self;
+        let _cb = cb;
+    }
+
+    fn should_quit(self, cb: fn*() -> bool) -> void {
+        let _self = self;
+        let _cb = cb;
+    }
+}
+
+// Top-level wrappers keep cross-module callsites simple and stable.
+fn app_get_config(app: App*) -> AppConfig {
+    return app.config();
+}
+
+static let zapp_active_app_ptr: void* = NULL;
+static let zapp_has_bootstrap_config: bool = false;
+static let zapp_bootstrap_config: AppConfig;
+
+fn app_get_active() -> void* {
+    return zapp_active_app_ptr;
+}
+
+fn app_set_active(app: App*) -> void {
+    zapp_active_app_ptr = (void*)app;
+}
+
+fn app_set_bootstrap_config(config: AppConfig) -> void {
+    zapp_bootstrap_config = config;
+    zapp_has_bootstrap_config = true;
+}
+
+fn app_get_bootstrap_config() -> AppConfig {
+    if zapp_has_bootstrap_config {
+        return zapp_bootstrap_config;
+    }
+    return AppConfig{
+        name: "Zapp App",
+        applicationShouldTerminateAfterLastWindowClosed: false,
+        webContentInspectable: true,
+        maxWorkers: 0,
+        qjsStackSize: 0,
+    };
+}
+
+fn app_get_bootstrap_name() -> string {
+    return app_get_bootstrap_config().name;
+}
+
+fn app_get_bootstrap_application_should_terminate_after_last_window_closed() -> bool {
+    return app_get_bootstrap_config().applicationShouldTerminateAfterLastWindowClosed;
+}
+
+fn app_get_bootstrap_web_content_inspectable() -> bool {
+    return app_get_bootstrap_config().webContentInspectable;
+}
+
+fn app_get_bootstrap_max_workers() -> int {
+    return app_get_bootstrap_config().maxWorkers;
+}
+
+fn app_get_bootstrap_qjs_stack_size() -> int {
+    let size = app_get_bootstrap_config().qjsStackSize;
+    if size <= 0 {
+        return 4 * 1024 * 1024; // Default 4 MB
+    }
+    return size;
+}
+
+@cfg(apple)
+fn zapp_backend_context_create(app: void*, script: string) -> int;
+@cfg(apple)
+fn zapp_backend_context_destroy() -> void;
+
+@cfg(windows)
+fn zapp_backend_context_create(app: void*, script: string) -> int;
+@cfg(windows)
+fn zapp_backend_context_destroy() -> void;
+
+@cfg(ZAPP_LINUX)
+fn zapp_backend_context_create(app: void*, script: string) -> int {
+    raw { (void)app; (void)script; }
+    return -1;
+}
+@cfg(ZAPP_LINUX)
+fn zapp_backend_context_destroy() -> void {}
+
+raw {
+    extern const char* zapp_build_backend_script_path(void);
+}
+
+raw {
+    #include <stdio.h>
+    #include <stdlib.h>
+
+    static char* zapp_read_file_utf8(const char* path) {
+        if (!path || path[0] == '\0') return NULL;
+        FILE* f = fopen(path, "rb");
+        if (!f) return NULL;
+        fseek(f, 0, SEEK_END);
+        long len = ftell(f);
+        fseek(f, 0, SEEK_SET);
+        if (len <= 0) { fclose(f); return NULL; }
+        char* buf = (char*)malloc((size_t)len + 1);
+        if (!buf) { fclose(f); return NULL; }
+        size_t read = fread(buf, 1, (size_t)len, f);
+        fclose(f);
+        buf[read] = '\0';
+        return buf;
+    }
+}
+
+fn app_start_backend(app: App*) -> void {
+    raw {
+        const char* backendPath = zapp_build_backend_script_path();
+        if (backendPath == NULL || backendPath[0] == '\0') return;
+
+        char* source = zapp_read_file_utf8(backendPath);
+        if (source == NULL) {
+            zapp_log_backend(ZAPP_LOG_ERROR, "failed to read backend script");
+            return;
+        }
+
+        int result = zapp_backend_context_create((void*)app, source);
+        free(source);
+        if (result == 0) {
+            app->has_backend = true;
+            zapp_log_backend(ZAPP_LOG_INFO, "backend context started");
+        } else {
+            zapp_log_backend(ZAPP_LOG_ERROR, "backend context failed to start");
+        }
+    }
+}
+
+fn app_stop_backend(app: App*) -> void {
+    if app.has_backend {
+        zapp_backend_context_destroy();
+        app.has_backend = false;
+    }
+}
+
+fn parse_wire(msg: string, out_type: string*, out_key: string*, out_payload: string*) -> void {
+    let p: string = msg;
+    *out_type = p;
+    *out_key = p;
+    *out_payload = p;
+    while *p != '\0' {
+        if *p == '\n' {
+            *p = '\0';
+            p++;
+            if (void*)*out_key == (void*)msg {
+                *out_key = p;
+            } else {
+                *out_payload = p;
+                break;
+            }
+        } else {
+            p++;
+        }
+    }
+}
+
+static let zapp_app_configured: bool = false;
+
+fn app_apply_configure(app: App*, payload: string) -> void {
+    if app == NULL || payload == NULL {
+        return;
+    }
+    raw {
+        if (zapp_app_configured) {
+            zapp_log_backend(ZAPP_LOG_WARN, "App.configure() ignored: already configured");
+            return;
+        }
+        zapp_app_configured = true;
+    }
+    let result = JsonValue::parse(payload);
+    if result.is_err() {
+        return;
+    }
+    let json = result.unwrap();
+    let name_opt = json.get_string("name");
+    if name_opt.is_some() {
+        raw {
+            if (app->config.name) free((void*)app->config.name);
+            app->config.name = strdup(name_opt.val);
+        }
+    }
+    let quit_opt = json.get_bool("applicationShouldTerminateAfterLastWindowClosed");
+    if quit_opt.is_some() {
+        app.config.applicationShouldTerminateAfterLastWindowClosed = quit_opt.unwrap();
+    }
+    let insp_opt = json.get_bool("webContentInspectable");
+    if insp_opt.is_some() {
+        app.config.webContentInspectable = insp_opt.unwrap();
+        app.window.webContentInspectable = app.config.webContentInspectable;
+    }
+    let max_opt = json.get_int("maxWorkers");
+    if max_opt.is_some() {
+        app.config.maxWorkers = max_opt.unwrap();
+    }
+    raw { zapp_log_backend(ZAPP_LOG_INFO, "app configured from backend"); }
+}
+
+fn app_should_quit() -> bool {
+    return true;
+}
+
+@cfg(apple)
+fn zapp_dispatch_invoke_result(request_id: string, payload_json: string) -> void;
+@cfg(apple)
+fn platform_sync_handle_bridge(action: string, payload_json: string) -> void;
+@cfg(apple)
+fn app_handle_window_message(app: App*, action: string, payload: string) -> void;
+@cfg(apple)
+fn app_handle_app_action(app: App*, action: string) -> void;
+@cfg(apple)
+fn app_open_external(app: App*, payload: string) -> void;
+@cfg(apple)
+fn app_handle_dialog(app: App*, action: string, payload: string) -> void;
+
+@cfg(windows)
+fn zapp_dispatch_invoke_result(request_id: string, payload_json: string) -> void;
+
+@cfg(windows)
+fn platform_sync_handle_bridge(action: string, payload_json: string) -> void;
+
+@cfg(windows)
+fn app_handle_window_message(app: App*, action: string, payload: string) -> void;
+
+@cfg(windows)
+fn app_open_external(app: App*, payload: string) -> void;
+@cfg(windows)
+fn app_handle_dialog(app: App*, action: string, payload: string) -> void;
+@cfg(windows)
+fn app_handle_app_action(app: App*, action: string) -> void;
+
+@cfg(ZAPP_LINUX)
+fn zapp_dispatch_invoke_result(request_id: string, payload_json: string) -> void {
+    raw { (void)request_id; (void)payload_json; }
+}
+@cfg(ZAPP_LINUX)
+fn platform_sync_handle_bridge(action: string, payload_json: string) -> void {
+    raw { (void)action; (void)payload_json; }
+}
+@cfg(ZAPP_LINUX)
+fn app_handle_window_message(app: App*, action: string, payload: string) -> void {
+    raw { (void)app; (void)action; (void)payload; }
+}
+@cfg(ZAPP_LINUX)
+fn app_handle_app_action(app: App*, action: string) -> void {
+    raw { (void)app; (void)action; }
+}
+@cfg(ZAPP_LINUX)
+fn app_open_external(app: App*, payload: string) -> void {
+    raw { (void)app; (void)payload; }
+}
+@cfg(ZAPP_LINUX)
+fn app_handle_dialog(app: App*, action: string, payload: string) -> void {
+    raw { (void)app; (void)action; (void)payload; }
+}
+
+fn app_invoke_rpc(app: App*, method: string, request_payload: string) -> void {
+    if method == "" || request_payload == "" {
+        return;
+    }
+    let parse_result = JsonValue::parse(request_payload);
+    if parse_result.is_err() {
+        return;
+    }
+    let json = parse_result.unwrap();
+    let id_opt = json.get_string("id");
+    if id_opt.is_none() {
+        return;
+    }
+    let request_id = id_opt.unwrap();
+    let cap_opt = json.get_string("capability");
+    let capability: string = "";
+    if cap_opt.is_some() {
+        capability = cap_opt.unwrap();
+    }
+
+    // Extract args as a sub-object and re-serialize
+    let args_opt = json.get("args");
+    let args_str: string = "{{}}";
+
+    raw {
+        // Re-extract args substring from original JSON for service invocation
+        // (serializing back would lose fidelity; pass the raw substring)
+        const char* argsKey = "\"args\":";
+        const char* argsStart = strstr((const char*)request_payload, argsKey);
+        if (argsStart) {
+            argsStart += strlen(argsKey);
+            while (*argsStart == ' ' || *argsStart == '\n' || *argsStart == '\r' || *argsStart == '\t') argsStart++;
+            const char* argsEnd = strstr(argsStart, ",\"meta\"");
+            if (!argsEnd) argsEnd = strrchr(argsStart, '}');
+            if (argsEnd && argsEnd > argsStart) {
+                static char _args_buf[65536];
+                size_t len = (size_t)(argsEnd - argsStart);
+                if (len >= sizeof(_args_buf)) len = sizeof(_args_buf) - 1;
+                memcpy(_args_buf, argsStart, len);
+                _args_buf[len] = '\0';
+                args_str = _args_buf;
+            }
+        }
+    }
+
+    let invoke_result = service_invoke_with_policy(app, method, args_str, capability);
+
+    if invoke_result.is_err() {
+        let error_code = invoke_result.err;
+        let error_message = service_error_message(error_code);
+        raw {
+            char response[70000];
+            snprintf(response, sizeof(response),
+                "{\"v\":1,\"id\":\"%s\",\"ok\":false,\"error\":{\"code\":\"%s\",\"message\":\"%s\"}}",
+                (const char*)request_id, (const char*)error_code, (const char*)error_message);
+            zapp_dispatch_invoke_result(request_id, response);
+        }
+    } else {
+        let result_val = invoke_result.unwrap();
+        raw {
+            char response[70000];
+            const char* r = (result_val && result_val[0] != '\0') ? (const char*)result_val : "{}";
+            snprintf(response, sizeof(response),
+                "{\"v\":1,\"id\":\"%s\",\"ok\":true,\"result\":%s}",
+                (const char*)request_id, r);
+            zapp_dispatch_invoke_result(request_id, response);
+        }
+    }
+}
+
+fn app_handle_frontend_message(app: App*, msg: string) -> void {
+    let msg_type: string = "";
+    let key: string = "";
+    let payload: string = "";
+    parse_wire(msg, &msg_type, &key, &payload);
+
+    if msg_type == "invoke" {
+        let _ = service_invoke(app, key, payload);
+        return;
+    }
+
+    if msg_type == "invoke_rpc" {
+        app_invoke_rpc(app, key, payload);
+        return;
+    }
+
+    if msg_type == "emit" {
+        app.event.emit(key, payload);
+        return;
+    }
+
+    if msg_type == "worker" {
+        platform_handle_worker_bridge(app, key, payload);
+        return;
+    }
+
+    if msg_type == "sync" {
+        platform_sync_handle_bridge(key, payload);
+        return;
+    }
+
+    if msg_type == "window" {
+        app_handle_window_message(app, key, payload);
+        return;
+    }
+
+    if msg_type == "app" {
+        if key == "configure" {
+            app_apply_configure(app, payload);
+            return;
+        }
+        if key == "openExternal" {
+            app_open_external(app, payload);
+            return;
+        }
+        app_handle_app_action(app, key);
+        return;
+    }
+
+    if msg_type == "dialog" {
+        app_handle_dialog(app, key, payload);
+        return;
+    }
+}
+
+// Native entry for ObjC script message handlers.
+fn zapp_handle_message(app_ptr: void*, msg_c: string) -> void {
+    if app_ptr == NULL || msg_c == NULL {
+        return;
+    }
+    app_handle_frontend_message((App*)app_ptr, msg_c);
+}

package/native/src/event/event.zc

@@ -0,0 +1,24 @@
+struct App;
+
+struct EventManager {
+    app: App*;
+    send_event_to_js: fn*(App*, string, string);
+}
+
+impl EventManager {
+    fn new() -> Self {
+        return EventManager{ app: NULL, send_event_to_js: NULL };
+    }
+
+    fn emit(self, name: string, payload: string) -> void {
+        let _n = name;
+        let _p = payload;
+        if self.app != NULL && self.send_event_to_js != NULL {
+            raw {
+                typedef void (*SendFn)(void*, char*, char*);
+                SendFn cb = (SendFn)self->send_event_to_js;
+                cb((void*)self->app, (char*)name, (char*)payload);
+            }
+        }
+    }
+}

package/native/src/event/events.zc

@@ -0,0 +1,70 @@
+struct WindowEvents {
+    READY: int;
+    FOCUS: int;
+    BLUR: int;
+    RESIZE: int;
+    MOVE: int;
+    CLOSE: int;
+    MINIMIZE: int;
+    MAXIMIZE: int;
+    RESTORE: int;
+    FULLSCREEN: int;
+    UNFULLSCREEN: int;
+}
+
+def WindowEvent = WindowEvents{
+    READY: 0,
+    FOCUS: 1,
+    BLUR: 2,
+    RESIZE: 3,
+    MOVE: 4,
+    CLOSE: 5,
+    MINIMIZE: 6,
+    MAXIMIZE: 7,
+    RESTORE: 8,
+    FULLSCREEN: 9,
+    UNFULLSCREEN: 10,
+};
+
+struct AppEvents {
+    STARTED: int;
+    SHUTDOWN: int;
+}
+
+def AppEvent = AppEvents{
+    STARTED: 100,
+    SHUTDOWN: 101,
+};
+
+struct EventResults {
+    ALLOW: int;
+    CANCEL: int;
+}
+
+def EventResult = EventResults{
+    ALLOW: 0,
+    CANCEL: 1,
+};
+
+raw {
+    // C-accessible macros for use in raw blocks and Obj-C delegates
+    #define ZAPP_EVENT_WINDOW_READY       0
+    #define ZAPP_EVENT_WINDOW_FOCUS       1
+    #define ZAPP_EVENT_WINDOW_BLUR        2
+    #define ZAPP_EVENT_WINDOW_RESIZE      3
+    #define ZAPP_EVENT_WINDOW_MOVE        4
+    #define ZAPP_EVENT_WINDOW_CLOSE       5
+    #define ZAPP_EVENT_WINDOW_MINIMIZE    6
+    #define ZAPP_EVENT_WINDOW_MAXIMIZE    7
+    #define ZAPP_EVENT_WINDOW_RESTORE     8
+    #define ZAPP_EVENT_WINDOW_FULLSCREEN  9
+    #define ZAPP_EVENT_WINDOW_UNFULLSCREEN 10
+
+    #define ZAPP_EVENT_APP_STARTED       100
+    #define ZAPP_EVENT_APP_SHUTDOWN      101
+
+    #define ZAPP_EVENT_RESULT_ALLOW      0
+    #define ZAPP_EVENT_RESULT_CANCEL     1
+
+    #define ZAPP_MAX_WINDOW_EVENT_TYPES  11
+}