@zappdev/cli 0.1.0

package/native/src/platform/darwin/worker/common.zc

@@ -0,0 +1,223 @@
+// Shared worker bridge helpers used by the Darwin backends.
+// This keeps request parsing and standard error payloads engine-agnostic so
+// additional engines do not need to reimplement the same bridge boilerplate.
+
+include <stdlib.h>
+include <stdbool.h>
+
+raw {
+#ifdef __APPLE__
+    #include <Foundation/Foundation.h>
+    #include <compression.h>
+#ifndef ZAPP_URL_PARSED_DEFINED
+#define ZAPP_URL_PARSED_DEFINED 1
+    typedef struct zapp_url_parsed {
+        char* href;
+        char* protocol;
+        char* host;
+        char* hostname;
+        char* port;
+        char* pathname;
+        char* search;
+        char* hash;
+        char* origin;
+        char* username;
+        char* password;
+    } zapp_url_parsed_t;
+
+    typedef void (*zapp_ws_event_fn)(
+        const char* ws_id,
+        const char* event_type,
+        const char* json_payload,
+        void* user_data
+    );
+
+    typedef struct {
+        int status;
+        char* status_text;
+        char** header_keys;
+        char** header_values;
+        int header_count;
+        char* body;
+        char* body_base64;
+    } zapp_fetch_response_t;
+
+    typedef void (^zapp_fetch_completion_t)(zapp_fetch_response_t* response, NSString* error);
+#endif
+
+#ifndef ZAPP_EMBEDDED_ASSET_STRUCT_DEFINED
+#define ZAPP_EMBEDDED_ASSET_STRUCT_DEFINED 1
+    struct ZappEmbeddedAsset {
+        char* path;
+        uint8_t* data;
+        int len;
+        bool is_brotli;
+        int uncompressed_len;
+    };
+#endif
+
+    extern struct ZappEmbeddedAsset zapp_embedded_assets[];
+    extern int zapp_embedded_assets_count;
+    extern const char* zapp_build_asset_root(void);
+    extern int zapp_build_use_embedded_assets(void);
+    extern void zapp_dispatch_worker_to_webviews(const char* kind, const char* worker_id, const char* payload_json);
+
+    static NSDictionary* zapp_worker_parse_bridge_payload(const char* payload_c) {
+        if (payload_c == NULL) return nil;
+        NSString* payload = [NSString stringWithUTF8String:payload_c];
+        if (payload == nil) return nil;
+        NSData* jsonData = [payload dataUsingEncoding:NSUTF8StringEncoding];
+        if (jsonData == nil) return nil;
+        NSDictionary* body = [NSJSONSerialization JSONObjectWithData:jsonData options:0 error:nil];
+        return [body isKindOfClass:[NSDictionary class]] ? body : nil;
+    }
+
+    static NSString* zapp_worker_body_owner_id(NSDictionary* body) {
+        NSString* ownerId = body[@"ownerId"];
+        return [ownerId isKindOfClass:[NSString class]] ? ownerId : nil;
+    }
+
+    static NSString* zapp_worker_body_worker_id(NSDictionary* body) {
+        NSString* workerId = body[@"id"];
+        if (![workerId isKindOfClass:[NSString class]] || [workerId length] == 0) return nil;
+        return workerId;
+    }
+
+    static NSString* zapp_worker_body_script_url(NSDictionary* body) {
+        NSString* scriptUrl = body[@"scriptUrl"];
+        return [scriptUrl isKindOfClass:[NSString class]] ? scriptUrl : nil;
+    }
+
+    static BOOL zapp_worker_body_shared(NSDictionary* body) {
+        id sharedObj = body[@"shared"];
+        if ([sharedObj respondsToSelector:@selector(boolValue)]) {
+            return [sharedObj boolValue] ? YES : NO;
+        }
+        return NO;
+    }
+
+    static void zapp_worker_dispatch_error_json(NSString* workerId, NSString* payloadJson) {
+        if (![workerId isKindOfClass:[NSString class]] || [workerId length] == 0) return;
+        NSString* json = ([payloadJson isKindOfClass:[NSString class]] && [payloadJson length] > 0)
+            ? payloadJson
+            : @"{\"message\":\"Worker error\"}";
+        zapp_dispatch_worker_to_webviews("error", [workerId UTF8String], [json UTF8String]);
+    }
+
+    static void zapp_worker_dispatch_error_message(NSString* workerId, NSString* message) {
+        NSString* safeMessage = ([message isKindOfClass:[NSString class]] && [message length] > 0)
+            ? message
+            : @"Worker error";
+        NSString* payloadJson = [NSString stringWithFormat:@"{\"message\":\"%@\"}", safeMessage];
+        zapp_worker_dispatch_error_json(workerId, payloadJson);
+    }
+
+    static void zapp_worker_dispatch_max_workers_error(NSString* workerId, int maxWorkers) {
+        NSString* errMsg = [NSString stringWithFormat:@"Max worker limit (%d) exceeded.", maxWorkers];
+        zapp_worker_dispatch_error_message(workerId, errMsg);
+    }
+
+    static NSString* zapp_worker_asset_root(void) {
+        const char* configuredRoot = zapp_build_asset_root();
+        if (configuredRoot != NULL && configuredRoot[0] != '\0') {
+            return [NSString stringWithUTF8String:configuredRoot];
+        }
+        return [[[NSFileManager defaultManager] currentDirectoryPath] stringByAppendingPathComponent:@"example/frontend/dist"];
+    }
+
+    static NSString* zapp_worker_resolve_rel_path(NSURL* url) {
+        if (url == nil) return nil;
+        NSString* scheme = [[url scheme] lowercaseString];
+        if (![scheme isEqualToString:@"zapp"]) return nil;
+
+        NSString* host = url.host ?: @"";
+        NSString* path = url.path ?: @"";
+        NSString* rel = path;
+
+        if ((rel.length == 0 || [rel isEqualToString:@"/"]) && host.length > 0) {
+            rel = [@"/" stringByAppendingString:host];
+        }
+        if ([rel hasPrefix:@"/zapp-workers/"]) {
+            // already normalized
+        } else if ([rel hasPrefix:@"/assets/"]) {
+            // keep assets path if used in workers
+        } else if ([rel hasPrefix:@"/index.html/"]) {
+            rel = [rel substringFromIndex:[@"/index.html/" length] - 1];
+        } else if ([rel hasPrefix:@"/app/"]) {
+            rel = [rel substringFromIndex:[@"/app/" length] - 1];
+        }
+
+        while ([rel hasPrefix:@"/"]) {
+            rel = [rel substringFromIndex:1];
+        }
+        if (rel.length == 0) return nil;
+
+        return rel;
+    }
+
+    static NSString* zapp_worker_resolve_local_path(NSURL* url) {
+        NSString* rel = zapp_worker_resolve_rel_path(url);
+        if (rel == nil) return nil;
+        return [zapp_worker_asset_root() stringByAppendingPathComponent:rel];
+    }
+
+    static NSData* zapp_worker_read_embedded_asset(NSString* logicalPath) {
+        if (![logicalPath isKindOfClass:[NSString class]] || [logicalPath length] == 0) return nil;
+        if (zapp_build_use_embedded_assets() == 0) return nil;
+        if (zapp_embedded_assets_count <= 0) return nil;
+
+        for (int i = 0; i < zapp_embedded_assets_count; i++) {
+            NSString* assetPath = [NSString stringWithUTF8String:zapp_embedded_assets[i].path];
+            if (![assetPath isEqualToString:logicalPath]) continue;
+
+            if (zapp_embedded_assets[i].is_brotli) {
+                uint8_t* outBuf = malloc(zapp_embedded_assets[i].uncompressed_len);
+                size_t decodedSize = compression_decode_buffer(outBuf, zapp_embedded_assets[i].uncompressed_len,
+                                                               zapp_embedded_assets[i].data, zapp_embedded_assets[i].len,
+                                                               NULL, COMPRESSION_BROTLI);
+                if (decodedSize > 0) {
+                    return [NSData dataWithBytesNoCopy:outBuf length:decodedSize freeWhenDone:YES];
+                }
+                free(outBuf);
+                return nil;
+            }
+
+            return [NSData dataWithBytesNoCopy:(void*)zapp_embedded_assets[i].data
+                                        length:zapp_embedded_assets[i].len
+                                  freeWhenDone:NO];
+        }
+
+        return nil;
+    }
+
+    static NSString* zapp_worker_read_source(NSString* scriptUrl, NSError** outErr) {
+        if (![scriptUrl isKindOfClass:[NSString class]] || [scriptUrl length] == 0) return nil;
+        NSURL* url = [NSURL URLWithString:scriptUrl];
+        if (url == nil) return nil;
+
+        NSString* rel = zapp_worker_resolve_rel_path(url);
+        if (rel != nil) {
+            NSString* logicalPath = [@"/" stringByAppendingString:rel];
+            NSData* embeddedData = zapp_worker_read_embedded_asset(logicalPath);
+            if (embeddedData != nil) {
+                return [[NSString alloc] initWithData:embeddedData encoding:NSUTF8StringEncoding];
+            }
+        }
+
+        NSString* localPath = zapp_worker_resolve_local_path(url);
+        if (localPath != nil) {
+            if (![[NSFileManager defaultManager] fileExistsAtPath:localPath]) {
+                if (outErr) {
+                    *outErr = [NSError errorWithDomain:@"zapp.worker" code:404 userInfo:nil];
+                }
+                return nil;
+            }
+            return [NSString stringWithContentsOfFile:localPath encoding:NSUTF8StringEncoding error:outErr];
+        }
+
+        return [NSString stringWithContentsOfURL:url encoding:NSUTF8StringEncoding error:outErr];
+    }
+#endif
+}
+
+struct WorkerCommon {}

package/native/src/platform/darwin/worker/core/base64_core.zc

@@ -0,0 +1,29 @@
+// Engine-agnostic btoa/atob implementation using Foundation.
+
+raw {
+#ifdef __APPLE__
+    #include <Foundation/Foundation.h>
+
+    // btoa: encode Latin-1 string to base64. Caller must free() the result.
+    static char* zapp_core_btoa(const char* input) {
+        if (input == NULL || input[0] == '\0') return strdup("");
+        NSString* str = [NSString stringWithUTF8String:input];
+        if (str == nil) return strdup("");
+        NSData* data = [str dataUsingEncoding:NSISOLatin1StringEncoding];
+        if (data == nil) return strdup("");
+        NSString* b64 = [data base64EncodedStringWithOptions:0];
+        return b64 ? strdup([b64 UTF8String]) : strdup("");
+    }
+
+    // atob: decode base64 to Latin-1 string. Caller must free() the result.
+    static char* zapp_core_atob(const char* input) {
+        if (input == NULL || input[0] == '\0') return strdup("");
+        NSString* str = [NSString stringWithUTF8String:input];
+        if (str == nil) return strdup("");
+        NSData* data = [[NSData alloc] initWithBase64EncodedString:str options:NSDataBase64DecodingIgnoreUnknownCharacters];
+        if (data == nil) return strdup("");
+        NSString* result = [[NSString alloc] initWithData:data encoding:NSISOLatin1StringEncoding];
+        return result ? strdup([result UTF8String]) : strdup("");
+    }
+#endif
+}

package/native/src/platform/darwin/worker/core/crypto_core.zc

@@ -0,0 +1,19 @@
+// Engine-agnostic crypto: random bytes and UUID generation.
+
+//> macos: framework: Security
+
+raw {
+#ifdef __APPLE__
+    #include <Foundation/Foundation.h>
+    #include <Security/Security.h>
+
+    static void zapp_core_crypto_random_bytes(uint8_t* buf, size_t len) {
+        if (buf && len > 0) SecRandomCopyBytes(kSecRandomDefault, len, buf);
+    }
+
+    // Returns a new UUID string. Caller must free().
+    static char* zapp_core_crypto_random_uuid(void) {
+        return strdup([[[NSUUID UUID] UUIDString] UTF8String]);
+    }
+#endif
+}

package/native/src/platform/darwin/worker/core/encoding_core.zc

@@ -0,0 +1,32 @@
+// Engine-agnostic TextEncoder/TextDecoder implementation using Foundation.
+
+include <string.h>
+
+raw {
+#ifdef __APPLE__
+    #include <Foundation/Foundation.h>
+
+    // Encode a UTF-8 C string into raw bytes. Caller must free() the result.
+    // Returns NULL on failure; *out_len is set to the byte count.
+    static uint8_t* zapp_core_text_encode(const char* input, size_t* out_len) {
+        if (out_len) *out_len = 0;
+        if (input == NULL) return NULL;
+        size_t len = strlen(input);
+        if (len == 0) return NULL;
+        uint8_t* copy = (uint8_t*)malloc(len);
+        if (!copy) return NULL;
+        memcpy(copy, input, len);
+        if (out_len) *out_len = len;
+        return copy;
+    }
+
+    // Decode raw bytes into a UTF-8 C string. Caller must free() the result.
+    // Returns empty string (strdup("")) on failure, never NULL.
+    static char* zapp_core_text_decode(const uint8_t* bytes, size_t len) {
+        if (bytes == NULL || len == 0) return strdup("");
+        NSString* str = [[NSString alloc] initWithBytes:bytes length:len encoding:NSUTF8StringEncoding];
+        if (str == nil) return strdup("");
+        return strdup([str UTF8String]);
+    }
+#endif
+}

package/native/src/platform/darwin/worker/core/fetch_core.zc

@@ -0,0 +1,145 @@
+// Engine-agnostic HTTP fetch: request building, response handling, task tracking.
+
+raw {
+#ifdef __APPLE__
+    #include <Foundation/Foundation.h>
+
+    // zapp_fetch_response_t and zapp_fetch_completion_t are defined in common.zc
+
+    static void zapp_core_fetch_response_free(zapp_fetch_response_t* r) {
+        if (!r) return;
+        free(r->status_text);
+        for (int i = 0; i < r->header_count; i++) {
+            free(r->header_keys[i]);
+            free(r->header_values[i]);
+        }
+        free(r->header_keys);
+        free(r->header_values);
+        free(r->body);
+        free(r->body_base64);
+    }
+
+    static zapp_fetch_response_t zapp_core_fetch_build_response(NSHTTPURLResponse* httpResponse, NSData* data) {
+        zapp_fetch_response_t r;
+        memset(&r, 0, sizeof(r));
+
+        r.status = (int)[httpResponse statusCode];
+        NSString* statusText = [NSHTTPURLResponse localizedStringForStatusCode:[httpResponse statusCode]];
+        r.status_text = strdup([statusText UTF8String]);
+
+        NSDictionary* headers = [httpResponse allHeaderFields];
+        r.header_count = (int)[headers count];
+        if (r.header_count > 0) {
+            r.header_keys = (char**)calloc(r.header_count, sizeof(char*));
+            r.header_values = (char**)calloc(r.header_count, sizeof(char*));
+            int i = 0;
+            for (NSString* key in headers) {
+                r.header_keys[i] = strdup([key UTF8String]);
+                r.header_values[i] = strdup([[NSString stringWithFormat:@"%@", headers[key]] UTF8String]);
+                i++;
+            }
+        }
+
+        if (data != nil && [data length] > 0) {
+            NSString* dataStr = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+            if (dataStr) {
+                r.body = strdup([dataStr UTF8String]);
+            } else {
+                r.body_base64 = strdup([[data base64EncodedStringWithOptions:0] UTF8String]);
+            }
+        } else {
+            r.body = strdup("");
+        }
+
+        return r;
+    }
+
+    // --- Request builder ---
+    static NSMutableURLRequest* zapp_core_fetch_build_request(
+        const char* url_str,
+        const char* method,
+        const char** header_keys, const char** header_values, int header_count,
+        const char* body, size_t body_len
+    ) {
+        if (!url_str) return nil;
+        NSURL* url = [NSURL URLWithString:[NSString stringWithUTF8String:url_str]];
+        if (!url) return nil;
+
+        NSMutableURLRequest* request = [NSMutableURLRequest requestWithURL:url];
+        if (method) [request setHTTPMethod:[NSString stringWithUTF8String:method]];
+
+        for (int i = 0; i < header_count; i++) {
+            if (header_keys[i] && header_values[i]) {
+                [request setValue:[NSString stringWithUTF8String:header_values[i]]
+               forHTTPHeaderField:[NSString stringWithUTF8String:header_keys[i]]];
+            }
+        }
+
+        if (body && body_len > 0) {
+            [request setHTTPBody:[NSData dataWithBytes:body length:body_len]];
+        }
+
+        return request;
+    }
+
+    // --- Task tracking ---
+    static NSMutableDictionary<NSString*, NSMutableDictionary<NSNumber*, NSURLSessionDataTask*>*>* zapp_fetch_tasks = nil;
+    static NSInteger zapp_fetch_next_id = 1;
+
+    static void zapp_core_fetch_ensure_init(void) {
+        if (!zapp_fetch_tasks) zapp_fetch_tasks = [NSMutableDictionary dictionary];
+    }
+
+    // Execute a fetch and track the task. Completion is called on the NSURLSession callback queue.
+    static void zapp_core_fetch_execute(
+        NSMutableURLRequest* request, NSString* worker_id,
+        zapp_fetch_completion_t completion
+    ) {
+        zapp_core_fetch_ensure_init();
+        if (!request || !worker_id) return;
+
+        NSMutableDictionary<NSNumber*, NSURLSessionDataTask*>* tasks = zapp_fetch_tasks[worker_id];
+        if (!tasks) { tasks = [NSMutableDictionary dictionary]; zapp_fetch_tasks[worker_id] = tasks; }
+
+        NSInteger taskId = zapp_fetch_next_id++;
+        NSNumber* taskKey = @(taskId);
+
+        NSURLSessionDataTask* task = [[NSURLSession sharedSession] dataTaskWithRequest:request
+            completionHandler:^(NSData* data, NSURLResponse* response, NSError* error) {
+                NSMutableDictionary<NSNumber*, NSURLSessionDataTask*>* t = zapp_fetch_tasks[worker_id];
+                if (t) [t removeObjectForKey:taskKey];
+
+                if (error) {
+                    if (completion) completion(NULL, [error localizedDescription]);
+                } else {
+                    zapp_fetch_response_t r = zapp_core_fetch_build_response((NSHTTPURLResponse*)response, data);
+                    if (completion) completion(&r, nil);
+                    zapp_core_fetch_response_free(&r);
+                }
+            }];
+
+        tasks[taskKey] = task;
+        [task resume];
+    }
+
+    static void zapp_core_fetch_cancel(NSString* workerId) {
+        if (!workerId || !zapp_fetch_tasks) return;
+        NSMutableDictionary<NSNumber*, NSURLSessionDataTask*>* tasks = zapp_fetch_tasks[workerId];
+        if (!tasks) return;
+        for (NSNumber* key in [tasks allKeys]) {
+            NSURLSessionDataTask* task = tasks[key];
+            if (task) [task cancel];
+        }
+        [tasks removeAllObjects];
+        [zapp_fetch_tasks removeObjectForKey:workerId];
+    }
+
+    static void zapp_core_fetch_cancel_all(void) {
+        if (!zapp_fetch_tasks) return;
+        for (NSString* wId in [zapp_fetch_tasks allKeys]) {
+            zapp_core_fetch_cancel(wId);
+        }
+        [zapp_fetch_tasks removeAllObjects];
+    }
+#endif
+}

package/native/src/platform/darwin/worker/core/url_core.zc

@@ -0,0 +1,69 @@
+// Engine-agnostic URL parsing using NSURL.
+
+raw {
+#ifdef __APPLE__
+    #include <Foundation/Foundation.h>
+
+    static void zapp_core_url_free(zapp_url_parsed_t* c) {
+        if (!c) return;
+        free(c->href);      free(c->protocol);  free(c->host);
+        free(c->hostname);   free(c->port);      free(c->pathname);
+        free(c->search);     free(c->hash);      free(c->origin);
+        free(c->username);   free(c->password);
+    }
+
+    static int zapp_core_url_parse(const char* url_str, const char* base_str, zapp_url_parsed_t* out) {
+        if (!url_str || !out) return -1;
+        memset(out, 0, sizeof(zapp_url_parsed_t));
+
+        NSString* urlNS = [NSString stringWithUTF8String:url_str];
+        NSURL* url = nil;
+
+        if (base_str && base_str[0] != '\0') {
+            NSURL* baseURL = [NSURL URLWithString:[NSString stringWithUTF8String:base_str]];
+            if (baseURL) url = [NSURL URLWithString:urlNS relativeToURL:baseURL];
+        }
+        if (url == nil) url = [NSURL URLWithString:urlNS];
+        if (url == nil) return -1;
+
+        NSString* scheme   = [url scheme]   ?: @"";
+        NSString* host     = [url host]     ?: @"";
+        NSNumber* portNum  = [url port];
+        NSString* portStr  = portNum ? [portNum stringValue] : @"";
+        NSString* path     = [url path]     ?: @"";
+        NSString* query    = [url query];
+        NSString* fragment = [url fragment];
+        NSString* user     = [url user]     ?: @"";
+        NSString* pass     = [url password] ?: @"";
+
+        NSString* protocol  = [scheme length] > 0 ? [NSString stringWithFormat:@"%@:", scheme] : @"";
+        NSString* search    = query    ? [NSString stringWithFormat:@"?%@", query]    : @"";
+        NSString* hash      = fragment ? [NSString stringWithFormat:@"#%@", fragment] : @"";
+        NSString* hostPort  = [portStr length] > 0 ? [NSString stringWithFormat:@"%@:%@", host, portStr] : host;
+
+        NSString* origin = @"null";
+        if ([scheme isEqualToString:@"http"]  || [scheme isEqualToString:@"https"] ||
+            [scheme isEqualToString:@"ws"]    || [scheme isEqualToString:@"wss"]   ||
+            [scheme isEqualToString:@"ftp"]) {
+            origin = [portStr length] > 0
+                ? [NSString stringWithFormat:@"%@://%@:%@", scheme, host, portStr]
+                : [NSString stringWithFormat:@"%@://%@", scheme, host];
+        }
+
+        NSString* href = [url absoluteString] ?: @"";
+
+        out->href     = strdup([href     UTF8String]);
+        out->protocol = strdup([protocol UTF8String]);
+        out->host     = strdup([hostPort UTF8String]);
+        out->hostname = strdup([host     UTF8String]);
+        out->port     = strdup([portStr  UTF8String]);
+        out->pathname = strdup([path     UTF8String]);
+        out->search   = strdup([search   UTF8String]);
+        out->hash     = strdup([hash     UTF8String]);
+        out->origin   = strdup([origin   UTF8String]);
+        out->username = strdup([user     UTF8String]);
+        out->password = strdup([pass     UTF8String]);
+        return 0;
+    }
+#endif
+}