@zappdev/cli 0.1.0

package/native/src/platform/windows/worker/timers_qjs.zc

@@ -0,0 +1,288 @@
+raw {
+#if defined(_WIN32) && defined(ZAPP_WORKER_ENGINE_QJS)
+    #include <windows.h>
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <string.h>
+    #include "quickjs.h"
+    #include "quickjs-libc.h"
+
+    extern void* zapp_windows_qjs_get_context(const char* workerId);
+    extern void zapp_windows_qjs_dispatch(void (*func)(void*), void* data);
+    extern void zapp_windows_qjs_drain_jobs(void* ctx, const char* label);
+    static void qjs_call_bridge_method(JSContext* ctx, const char* methodName, int argc, JSValue* argv);
+
+    // -----------------------------------------------------------------------
+    // Timer state
+    // -----------------------------------------------------------------------
+
+    #define ZAPP_MAX_TIMERS_PER_WORKER 256
+    #define ZAPP_MAX_TOTAL_TIMERS 4096
+    #define ZAPP_MIN_INTERVAL_MS 4
+
+    typedef struct {
+        int id;
+        char workerId[128];
+        HANDLE hTimer;
+        JSContext* creatingCtx;
+        JSValue savedFn;
+        int shouldRepeat;
+        int cancelled;
+        DWORD intervalMs;
+    } ZappTimer;
+
+    static HANDLE zapp_timer_queue = NULL;
+    static ZappTimer zapp_timers[ZAPP_MAX_TOTAL_TIMERS] = {0};
+    static int zapp_next_timer_id = 1;
+    static CRITICAL_SECTION zapp_timer_lock;
+    static int zapp_timer_lock_init = 0;
+
+    static void zapp_timers_ensure_init(void) {
+        if (!zapp_timer_lock_init) {
+            InitializeCriticalSection(&zapp_timer_lock);
+            zapp_timer_lock_init = 1;
+        }
+        if (!zapp_timer_queue) {
+            zapp_timer_queue = CreateTimerQueue();
+        }
+    }
+
+    static ZappTimer* zapp_timer_find(int id) {
+        for (int i = 0; i < ZAPP_MAX_TOTAL_TIMERS; i++) {
+            if (zapp_timers[i].id == id && zapp_timers[i].hTimer != NULL) {
+                return &zapp_timers[i];
+            }
+        }
+        return NULL;
+    }
+
+    static ZappTimer* zapp_timer_alloc(void) {
+        for (int i = 0; i < ZAPP_MAX_TOTAL_TIMERS; i++) {
+            if (zapp_timers[i].id == 0) {
+                return &zapp_timers[i];
+            }
+        }
+        return NULL;
+    }
+
+    static int zapp_timers_count_for_worker(const char* workerId) {
+        int count = 0;
+        for (int i = 0; i < ZAPP_MAX_TOTAL_TIMERS; i++) {
+            if (zapp_timers[i].id != 0 && strcmp(zapp_timers[i].workerId, workerId) == 0) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    // -----------------------------------------------------------------------
+    // Timer callback (fires on threadpool, dispatches to QJS thread)
+    // -----------------------------------------------------------------------
+
+    typedef struct {
+        int timerId;
+    } ZappTimerFireData;
+
+    static void zapp_timer_fire_on_qjs(void* data) {
+        ZappTimerFireData* fd = (ZappTimerFireData*)data;
+        int timerId = fd->timerId;
+        free(fd);
+
+        EnterCriticalSection(&zapp_timer_lock);
+        ZappTimer* timer = zapp_timer_find(timerId);
+        if (!timer || timer->cancelled) {
+            LeaveCriticalSection(&zapp_timer_lock);
+            return;
+        }
+
+        char workerId[128];
+        strncpy(workerId, timer->workerId, sizeof(workerId));
+        JSContext* creatingCtx = timer->creatingCtx;
+        JSValue savedFn = timer->savedFn;
+        int shouldRepeat = timer->shouldRepeat;
+        LeaveCriticalSection(&zapp_timer_lock);
+
+        void* ctx_ptr = zapp_windows_qjs_get_context(workerId);
+        if (!ctx_ptr || (JSContext*)ctx_ptr != creatingCtx) {
+            return;
+        }
+        JSContext* ctx = (JSContext*)ctx_ptr;
+
+        JSValue ret = JS_Call(ctx, savedFn, JS_UNDEFINED, 0, NULL);
+        if (JS_IsException(ret)) {
+            JSValue exception = JS_GetException(ctx);
+            JSValue args[1];
+            args[0] = JS_DupValue(ctx, exception);
+            qjs_call_bridge_method(ctx, "reportError", 1, args);
+            JS_FreeValue(ctx, args[0]);
+            JS_FreeValue(ctx, exception);
+        }
+        JS_FreeValue(ctx, ret);
+        zapp_windows_qjs_drain_jobs(ctx, "timer");
+
+        if (!shouldRepeat) {
+            EnterCriticalSection(&zapp_timer_lock);
+            ZappTimer* t = zapp_timer_find(timerId);
+            if (t) {
+                if (t->hTimer) {
+                    DeleteTimerQueueTimer(zapp_timer_queue, t->hTimer, NULL);
+                }
+                if (ctx_ptr && (JSContext*)ctx_ptr == t->creatingCtx) {
+                    JS_FreeValue(t->creatingCtx, t->savedFn);
+                }
+                memset(t, 0, sizeof(ZappTimer));
+            }
+            LeaveCriticalSection(&zapp_timer_lock);
+        }
+    }
+
+    static VOID CALLBACK zapp_timer_callback(PVOID lpParameter, BOOLEAN TimerOrWaitFired) {
+        (void)TimerOrWaitFired;
+        int timerId = (int)(intptr_t)lpParameter;
+
+        ZappTimerFireData* fd = (ZappTimerFireData*)calloc(1, sizeof(ZappTimerFireData));
+        fd->timerId = timerId;
+        zapp_windows_qjs_dispatch(zapp_timer_fire_on_qjs, fd);
+    }
+
+    // -----------------------------------------------------------------------
+    // QJS bridge functions: setTimer, clearTimer
+    // -----------------------------------------------------------------------
+
+    static JSValue qjs_bridge_setTimer(JSContext* ctx, JSValue this_val, int argc, JSValue* argv, int magic, JSValue* func_data) {
+        (void)this_val; (void)magic;
+        if (argc < 3) return JS_NewInt32(ctx, 0);
+
+        const char* worker_id = JS_ToCString(ctx, func_data[0]);
+        if (!worker_id) return JS_NewInt32(ctx, 0);
+
+        if (!JS_IsFunction(ctx, argv[0])) {
+            JS_FreeCString(ctx, worker_id);
+            return JS_NewInt32(ctx, 0);
+        }
+
+        double ms = 0;
+        JS_ToFloat64(ctx, &ms, argv[1]);
+        if (!(ms >= 0)) ms = 0;
+
+        int shouldRepeat = JS_ToBool(ctx, argv[2]);
+        if (shouldRepeat && ms < ZAPP_MIN_INTERVAL_MS) {
+            ms = ZAPP_MIN_INTERVAL_MS;
+        }
+
+        zapp_timers_ensure_init();
+
+        EnterCriticalSection(&zapp_timer_lock);
+
+        if (zapp_timers_count_for_worker(worker_id) >= ZAPP_MAX_TIMERS_PER_WORKER) {
+            LeaveCriticalSection(&zapp_timer_lock);
+            JS_FreeCString(ctx, worker_id);
+            return JS_NewInt32(ctx, 0);
+        }
+
+        ZappTimer* timer = zapp_timer_alloc();
+        if (!timer) {
+            LeaveCriticalSection(&zapp_timer_lock);
+            JS_FreeCString(ctx, worker_id);
+            return JS_NewInt32(ctx, 0);
+        }
+
+        int timerId = zapp_next_timer_id++;
+        memset(timer, 0, sizeof(ZappTimer));
+        timer->id = timerId;
+        strncpy(timer->workerId, worker_id, sizeof(timer->workerId) - 1);
+        timer->creatingCtx = ctx;
+        timer->savedFn = JS_DupValue(ctx, argv[0]);
+        timer->shouldRepeat = shouldRepeat;
+        timer->cancelled = 0;
+        timer->intervalMs = (DWORD)(ms > 0 ? ms : 1);
+
+        BOOL ok = CreateTimerQueueTimer(
+            &timer->hTimer,
+            zapp_timer_queue,
+            zapp_timer_callback,
+            (PVOID)(intptr_t)timerId,
+            timer->intervalMs,
+            shouldRepeat ? timer->intervalMs : 0,
+            WT_EXECUTEDEFAULT
+        );
+
+        LeaveCriticalSection(&zapp_timer_lock);
+        JS_FreeCString(ctx, worker_id);
+
+        if (!ok) return JS_NewInt32(ctx, 0);
+        return JS_NewInt32(ctx, timerId);
+    }
+
+    static JSValue qjs_bridge_clearTimer(JSContext* ctx, JSValue this_val, int argc, JSValue* argv, int magic, JSValue* func_data) {
+        (void)this_val; (void)magic;
+        if (argc < 1) return JS_UNDEFINED;
+
+        const char* worker_id = JS_ToCString(ctx, func_data[0]);
+        if (!worker_id) return JS_UNDEFINED;
+
+        int32_t tId = 0;
+        JS_ToInt32(ctx, &tId, argv[0]);
+
+        EnterCriticalSection(&zapp_timer_lock);
+        ZappTimer* timer = zapp_timer_find(tId);
+        if (timer && strcmp(timer->workerId, worker_id) == 0) {
+            timer->cancelled = 1;
+            if (timer->hTimer) {
+                DeleteTimerQueueTimer(zapp_timer_queue, timer->hTimer, NULL);
+            }
+            void* ctx_ptr = zapp_windows_qjs_get_context(worker_id);
+            if (ctx_ptr && (JSContext*)ctx_ptr == timer->creatingCtx) {
+                JS_FreeValue(timer->creatingCtx, timer->savedFn);
+            }
+            memset(timer, 0, sizeof(ZappTimer));
+        }
+        LeaveCriticalSection(&zapp_timer_lock);
+
+        JS_FreeCString(ctx, worker_id);
+        return JS_UNDEFINED;
+    }
+
+    // -----------------------------------------------------------------------
+    // Cancel all timers for a given worker
+    // -----------------------------------------------------------------------
+
+    void zapp_windows_qjs_timers_cancel(const char* workerId) {
+        if (!workerId || !zapp_timer_lock_init) return;
+
+        EnterCriticalSection(&zapp_timer_lock);
+        for (int i = 0; i < ZAPP_MAX_TOTAL_TIMERS; i++) {
+            if (zapp_timers[i].id != 0 && strcmp(zapp_timers[i].workerId, workerId) == 0) {
+                zapp_timers[i].cancelled = 1;
+                if (zapp_timers[i].hTimer) {
+                    DeleteTimerQueueTimer(zapp_timer_queue, zapp_timers[i].hTimer, NULL);
+                }
+                void* ctx_ptr = zapp_windows_qjs_get_context(workerId);
+                if (ctx_ptr && (JSContext*)ctx_ptr == zapp_timers[i].creatingCtx) {
+                    JS_FreeValue(zapp_timers[i].creatingCtx, zapp_timers[i].savedFn);
+                }
+                memset(&zapp_timers[i], 0, sizeof(ZappTimer));
+            }
+        }
+        LeaveCriticalSection(&zapp_timer_lock);
+    }
+
+    // -----------------------------------------------------------------------
+    // Install setTimer/clearTimer on a QJS bridge object
+    // -----------------------------------------------------------------------
+
+    void zapp_windows_qjs_timers_install(JSContext* ctx, JSValue bridge, const char* worker_id) {
+        zapp_timers_ensure_init();
+        JSValue wIdVal = JS_NewString(ctx, worker_id);
+        JSValue funcData[1] = { wIdVal };
+
+        JSValue setTimerFunc = JS_NewCFunctionData(ctx, qjs_bridge_setTimer, 3, 0, 1, funcData);
+        JS_SetPropertyStr(ctx, bridge, "setTimer", setTimerFunc);
+
+        JSValue clearTimerFunc = JS_NewCFunctionData(ctx, qjs_bridge_clearTimer, 1, 0, 1, funcData);
+        JS_SetPropertyStr(ctx, bridge, "clearTimer", clearTimerFunc);
+
+        JS_FreeValue(ctx, wIdVal);
+    }
+#endif
+}

package/native/src/platform/worker.zc

@@ -0,0 +1,8 @@
+// Cross-platform Worker contract. Each OS (darwin, windows) wires a backend that
+// implements this trait; the app only calls platform_bind_runtime and
+// platform_handle_worker_bridge. On darwin, the engine (JSC vs QuickJS vs XS) is
+// selected by @cfg(ZAPP_WORKER_ENGINE_*) in platform/darwin/worker.zc.
+trait WorkerBackend {
+    fn bind_runtime(self, app: App*) -> void;
+    fn handle_bridge(self, app: App*, action: string, payload: string) -> void;
+}

package/native/src/service/service.zc

@@ -0,0 +1,228 @@
+struct App;
+
+import "std/result.zc";
+include <string.h>
+
+def SERVICE_MAX_BINDINGS = 128;
+def SERVICE_MAX_NAME = 96;
+def SERVICE_MAX_PAYLOAD_BYTES = 65536;
+
+struct ServiceManager {
+    app: App*;
+}
+
+let g_service_names: string[SERVICE_MAX_BINDINGS];
+let g_service_handlers: void*[SERVICE_MAX_BINDINGS];
+let g_service_startup_handlers: void*[SERVICE_MAX_BINDINGS];
+let g_service_shutdown_handlers: void*[SERVICE_MAX_BINDINGS];
+let g_service_public: bool[SERVICE_MAX_BINDINGS];
+let g_service_capabilities: string[SERVICE_MAX_BINDINGS];
+let g_service_count: int = 0;
+
+fn service_is_valid_name(name: string) -> bool {
+    if name == "" {
+        return false;
+    }
+    raw {
+        const char* s = (const char*)name;
+        int len = 0;
+        while (*s != '\0') {
+            char ch = *s;
+            int ok =
+                (ch >= 'a' && ch <= 'z') ||
+                (ch >= 'A' && ch <= 'Z') ||
+                (ch >= '0' && ch <= '9') ||
+                ch == '.' || ch == '_' || ch == '-';
+            if (!ok) return false;
+            len++;
+            if (len > SERVICE_MAX_NAME) return false;
+            s++;
+        }
+        return len > 0;
+    }
+}
+
+fn service_payload_size_ok(payload: string) -> bool {
+    if payload == NULL {
+        return true;
+    }
+    raw {
+        size_t n = strlen((const char*)payload);
+        return n <= SERVICE_MAX_PAYLOAD_BYTES;
+    }
+}
+
+fn service_index_of(name: string) -> int {
+    raw {
+        for (int i = 0; i < g_service_count; i++) {
+            if (strcmp((const char*)g_service_names[i], (const char*)name) == 0) return i;
+        }
+        return -1;
+    }
+}
+
+fn service_add_with_lifecycle(
+    name: string,
+    handler: fn*(App*, string) -> string,
+    startup: fn*(App*) -> bool,
+    shutdown: fn*(App*) -> void,
+    public: bool,
+    capability: string
+) -> bool {
+    if !service_is_valid_name(name) {
+        return false;
+    }
+    if g_service_count >= SERVICE_MAX_BINDINGS {
+        return false;
+    }
+    if service_index_of(name) >= 0 {
+        return false;
+    }
+    g_service_names[g_service_count] = name;
+    g_service_public[g_service_count] = public;
+    g_service_capabilities[g_service_count] = capability;
+    raw {
+        g_service_handlers[g_service_count] = (void*)handler;
+        g_service_startup_handlers[g_service_count] = (void*)startup;
+        g_service_shutdown_handlers[g_service_count] = (void*)shutdown;
+    }
+    g_service_count += 1;
+    return true;
+}
+
+fn service_add(name: string, handler: fn*(App*, string) -> string) -> bool {
+    return service_add_with_lifecycle(name, handler, NULL, NULL, true, "");
+}
+
+fn service_start_all(app: App*) -> bool {
+    for i in 0..g_service_count {
+        if g_service_startup_handlers[i] != NULL {
+            raw {
+                typedef bool (*StartupFnPtr)(void*);
+                StartupFnPtr cb = (StartupFnPtr)g_service_startup_handlers[i];
+                if (!cb((void*)app)) {
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
+}
+
+fn service_shutdown_all(app: App*) -> void {
+    let _ = app;
+    for j in 0..g_service_count {
+        let i = g_service_count - 1 - j;
+        if i < 0 {
+            continue;
+        }
+        if g_service_shutdown_handlers[i] != NULL {
+            raw {
+                typedef void (*ShutdownFnPtr)(void*);
+                ShutdownFnPtr cb = (ShutdownFnPtr)g_service_shutdown_handlers[i];
+                cb((void*)app);
+            }
+        }
+    }
+}
+
+fn service_get_bindings_manifest_json() -> string {
+    raw {
+        static char manifest[16384];
+        strcpy(manifest, "{\"v\":1,\"generatedAt\":\"native\",\"services\":[");
+        for (int i = 0; i < g_service_count; i++) {
+            if (i > 0) strcat(manifest, ",");
+            strcat(manifest, "{\"name\":\"");
+            strcat(manifest, (const char*)g_service_names[i]);
+            strcat(manifest, "\",\"methods\":[{\"name\":\"");
+            strcat(manifest, (const char*)g_service_names[i]);
+            strcat(manifest, "\"}]");
+            if (g_service_capabilities[i] != NULL && ((const char*)g_service_capabilities[i])[0] != '\0') {
+                strcat(manifest, ",\"capability\":\"");
+                strcat(manifest, (const char*)g_service_capabilities[i]);
+                strcat(manifest, "\"");
+            }
+            strcat(manifest, "}");
+        }
+        strcat(manifest, "]}");
+        return (char*)manifest;
+    }
+}
+
+fn service_invoke_with_policy(
+    app: App*,
+    name: string,
+    payload: string,
+    capability: string
+) -> Result<string> {
+    if !service_is_valid_name(name) {
+        return Result<string>::Err("INVALID_METHOD");
+    }
+    if !service_payload_size_ok(payload) {
+        return Result<string>::Err("BAD_REQUEST");
+    }
+
+    let idx = service_index_of(name);
+    if idx < 0 {
+        return Result<string>::Err("NOT_FOUND");
+    }
+
+    if !g_service_public[idx] {
+        return Result<string>::Err("UNAUTHORIZED");
+    }
+
+    let required_capability = g_service_capabilities[idx];
+    raw {
+        int has_cap = (required_capability != NULL && ((const char*)required_capability)[0] != '\0');
+        int cap_match = has_cap ? (strcmp((const char*)capability, (const char*)required_capability) == 0) : 1;
+        if (has_cap && !cap_match) {
+            return Result_string__Err("UNAUTHORIZED");
+        }
+
+        if (g_service_handlers[idx] != NULL) {
+            typedef char* (*ServiceFnPtr)(void*, char*);
+            ServiceFnPtr cb = (ServiceFnPtr)g_service_handlers[idx];
+            char* res = cb((void*)app, (char*)payload);
+            return Result_string__Ok(res);
+        }
+
+        return Result_string__Err("INTERNAL_ERROR");
+    }
+}
+
+fn service_error_message(code: string) -> string {
+    if code == "INVALID_METHOD" { return "Invalid service method name."; }
+    if code == "BAD_REQUEST" { return "Service payload exceeds max size."; }
+    if code == "NOT_FOUND" { return "Service method not found."; }
+    if code == "UNAUTHORIZED" { return "Unauthorized."; }
+    if code == "INTERNAL_ERROR" { return "Service handler is not available."; }
+    return "Unknown error.";
+}
+
+fn service_invoke(app: App*, name: string, payload: string) -> Result<string> {
+    return service_invoke_with_policy(app, name, payload, "");
+}
+
+impl ServiceManager {
+    fn new() -> Self {
+        return ServiceManager{ app: NULL };
+    }
+
+    fn add(self, name: string, handler: fn*(App*, string) -> string) -> bool {
+        let _ = self;
+        return service_add(name, handler);
+    }
+
+    fn add_with_lifecycle(
+        self,
+        name: string,
+        handler: fn*(App*, string) -> string,
+        startup: fn*(App*) -> bool,
+        shutdown: fn*(App*) -> void,
+        public: bool,
+        capability: string
+    ) -> bool {
+        let _ = self;
+        return service_add_with_lifecycle(name, handler, startup, shutdown, public, capability);
+    }
+}

package/native/vendor/quickjs-ng/.gitattributes

@@ -0,0 +1,4 @@
+# Don't show changes in generated files when doing git diff
+
+gen/** -diff
+builtin-*.h -diff

package/native/vendor/quickjs-ng/.github/dependabot.yml

@@ -0,0 +1,7 @@
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"