@zappdev/cli 0.1.0

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

@@ -0,0 +1,274 @@
+// Win32-native HTTP fetch using WinHTTP (synchronous on background thread).
+
+//> windows: link: -lwinhttp
+
+raw {
+#ifdef _WIN32
+    #include <windows.h>
+    #include <winhttp.h>
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <string.h>
+
+    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;
+
+    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);
+    }
+
+    // Callback function type for fetch completion
+    typedef void (*zapp_fetch_callback_fn)(zapp_fetch_response_t* response, const char* error, void* userdata);
+
+    typedef struct {
+        char* url;
+        char* method;
+        char** header_keys;
+        char** header_values;
+        int header_count;
+        char* body;
+        size_t body_len;
+        char worker_id[128];
+        zapp_fetch_callback_fn callback;
+        void* userdata;
+    } ZappFetchRequest;
+
+    static wchar_t* zapp_fetch_utf8_to_wide(const char* utf8) {
+        if (!utf8) return NULL;
+        int len = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0);
+        wchar_t* wide = (wchar_t*)malloc(len * sizeof(wchar_t));
+        MultiByteToWideChar(CP_UTF8, 0, utf8, -1, wide, len);
+        return wide;
+    }
+
+    static char* zapp_fetch_wide_to_utf8(const wchar_t* wide) {
+        if (!wide) return NULL;
+        int len = WideCharToMultiByte(CP_UTF8, 0, wide, -1, NULL, 0, NULL, NULL);
+        char* utf8 = (char*)malloc(len);
+        WideCharToMultiByte(CP_UTF8, 0, wide, -1, utf8, len, NULL, NULL);
+        return utf8;
+    }
+
+    static DWORD WINAPI zapp_fetch_thread_proc(LPVOID param) {
+        ZappFetchRequest* req = (ZappFetchRequest*)param;
+        zapp_fetch_response_t response;
+        memset(&response, 0, sizeof(response));
+
+        HINTERNET hSession = NULL, hConnect = NULL, hRequest = NULL;
+        char* errorMsg = NULL;
+
+        // Parse URL components
+        wchar_t* wUrl = zapp_fetch_utf8_to_wide(req->url);
+        URL_COMPONENTSW urlComp;
+        memset(&urlComp, 0, sizeof(urlComp));
+        urlComp.dwStructSize = sizeof(urlComp);
+        wchar_t hostBuf[256] = {0};
+        wchar_t pathBuf[2048] = {0};
+        urlComp.lpszHostName = hostBuf;
+        urlComp.dwHostNameLength = 256;
+        urlComp.lpszUrlPath = pathBuf;
+        urlComp.dwUrlPathLength = 2048;
+
+        if (!WinHttpCrackUrl(wUrl, 0, 0, &urlComp)) {
+            errorMsg = _strdup("Invalid URL");
+            goto cleanup;
+        }
+
+        hSession = WinHttpOpen(L"Zapp/1.0", WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
+                               WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);
+        if (!hSession) { errorMsg = _strdup("Failed to create HTTP session"); goto cleanup; }
+
+        hConnect = WinHttpConnect(hSession, hostBuf, urlComp.nPort, 0);
+        if (!hConnect) { errorMsg = _strdup("Failed to connect"); goto cleanup; }
+
+        wchar_t* wMethod = zapp_fetch_utf8_to_wide(req->method ? req->method : "GET");
+        DWORD flags = (urlComp.nScheme == INTERNET_SCHEME_HTTPS) ? WINHTTP_FLAG_SECURE : 0;
+        hRequest = WinHttpOpenRequest(hConnect, wMethod, pathBuf, NULL,
+                                       WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, flags);
+        free(wMethod);
+        if (!hRequest) { errorMsg = _strdup("Failed to create request"); goto cleanup; }
+
+        // Add headers
+        for (int i = 0; i < req->header_count; i++) {
+            if (req->header_keys[i] && req->header_values[i]) {
+                wchar_t header[1024];
+                wchar_t* wKey = zapp_fetch_utf8_to_wide(req->header_keys[i]);
+                wchar_t* wVal = zapp_fetch_utf8_to_wide(req->header_values[i]);
+                _snwprintf(header, 1024, L"%s: %s", wKey, wVal);
+                WinHttpAddRequestHeaders(hRequest, header, (DWORD)-1, WINHTTP_ADDREQ_FLAG_ADD);
+                free(wKey);
+                free(wVal);
+            }
+        }
+
+        // Send request
+        DWORD bodyLen = req->body ? (DWORD)req->body_len : 0;
+        if (!WinHttpSendRequest(hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0,
+                                req->body, bodyLen, bodyLen, 0)) {
+            errorMsg = _strdup("Failed to send request");
+            goto cleanup;
+        }
+
+        if (!WinHttpReceiveResponse(hRequest, NULL)) {
+            errorMsg = _strdup("Failed to receive response");
+            goto cleanup;
+        }
+
+        // Read status
+        DWORD statusCode = 0;
+        DWORD statusSize = sizeof(statusCode);
+        WinHttpQueryHeaders(hRequest, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
+                           WINHTTP_HEADER_NAME_BY_INDEX, &statusCode, &statusSize, WINHTTP_NO_HEADER_INDEX);
+        response.status = (int)statusCode;
+
+        // Read status text
+        wchar_t statusTextBuf[256] = {0};
+        DWORD statusTextLen = sizeof(statusTextBuf);
+        if (WinHttpQueryHeaders(hRequest, WINHTTP_QUERY_STATUS_TEXT, WINHTTP_HEADER_NAME_BY_INDEX,
+                                statusTextBuf, &statusTextLen, WINHTTP_NO_HEADER_INDEX)) {
+            response.status_text = zapp_fetch_wide_to_utf8(statusTextBuf);
+        } else {
+            response.status_text = _strdup("OK");
+        }
+
+        // Read all headers
+        DWORD headerBufSize = 0;
+        WinHttpQueryHeaders(hRequest, WINHTTP_QUERY_RAW_HEADERS_CRLF,
+                           WINHTTP_HEADER_NAME_BY_INDEX, NULL, &headerBufSize, WINHTTP_NO_HEADER_INDEX);
+        if (headerBufSize > 0) {
+            wchar_t* headerBuf = (wchar_t*)malloc(headerBufSize);
+            if (WinHttpQueryHeaders(hRequest, WINHTTP_QUERY_RAW_HEADERS_CRLF,
+                                   WINHTTP_HEADER_NAME_BY_INDEX, headerBuf, &headerBufSize, WINHTTP_NO_HEADER_INDEX)) {
+                char* headerUtf8 = zapp_fetch_wide_to_utf8(headerBuf);
+                // Count headers (skip first status line)
+                int count = 0;
+                char* line = strtok(_strdup(headerUtf8), "\r\n");
+                if (line) line = strtok(NULL, "\r\n"); // skip status line
+                while (line) { if (strchr(line, ':')) count++; line = strtok(NULL, "\r\n"); }
+
+                if (count > 0) {
+                    response.header_keys = (char**)calloc(count, sizeof(char*));
+                    response.header_values = (char**)calloc(count, sizeof(char*));
+                    response.header_count = 0;
+
+                    char* copy = _strdup(headerUtf8);
+                    line = strtok(copy, "\r\n");
+                    if (line) line = strtok(NULL, "\r\n"); // skip status line
+                    while (line && response.header_count < count) {
+                        char* colon = strchr(line, ':');
+                        if (colon) {
+                            *colon = '\0';
+                            char* val = colon + 1;
+                            while (*val == ' ') val++;
+                            response.header_keys[response.header_count] = _strdup(line);
+                            response.header_values[response.header_count] = _strdup(val);
+                            response.header_count++;
+                        }
+                        line = strtok(NULL, "\r\n");
+                    }
+                    free(copy);
+                }
+                free(headerUtf8);
+            }
+            free(headerBuf);
+        }
+
+        // Read body
+        {
+            size_t totalSize = 0;
+            size_t bufCap = 65536;
+            char* bodyBuf = (char*)malloc(bufCap);
+            DWORD bytesRead = 0;
+
+            while (WinHttpReadData(hRequest, bodyBuf + totalSize,
+                                   (DWORD)(bufCap - totalSize - 1), &bytesRead) && bytesRead > 0) {
+                totalSize += bytesRead;
+                if (totalSize + 4096 >= bufCap) {
+                    bufCap *= 2;
+                    bodyBuf = (char*)realloc(bodyBuf, bufCap);
+                }
+            }
+            bodyBuf[totalSize] = '\0';
+            response.body = bodyBuf;
+        }
+
+    cleanup:
+        if (hRequest) WinHttpCloseHandle(hRequest);
+        if (hConnect) WinHttpCloseHandle(hConnect);
+        if (hSession) WinHttpCloseHandle(hSession);
+        free(wUrl);
+
+        if (req->callback) {
+            if (errorMsg) {
+                req->callback(NULL, errorMsg, req->userdata);
+            } else {
+                req->callback(&response, NULL, req->userdata);
+            }
+        }
+
+        zapp_core_fetch_response_free(&response);
+        free(errorMsg);
+
+        // Free the request
+        free(req->url);
+        free(req->method);
+        for (int i = 0; i < req->header_count; i++) {
+            free(req->header_keys[i]);
+            free(req->header_values[i]);
+        }
+        free(req->header_keys);
+        free(req->header_values);
+        free(req->body);
+        free(req);
+
+        return 0;
+    }
+
+    static void zapp_core_fetch_execute(
+        const char* url, const char* method,
+        const char** header_keys, const char** header_values, int header_count,
+        const char* body, size_t body_len,
+        const char* worker_id,
+        zapp_fetch_callback_fn callback, void* userdata
+    ) {
+        ZappFetchRequest* req = (ZappFetchRequest*)calloc(1, sizeof(ZappFetchRequest));
+        req->url = url ? _strdup(url) : NULL;
+        req->method = method ? _strdup(method) : NULL;
+        if (header_count > 0) {
+            req->header_keys = (char**)calloc(header_count, sizeof(char*));
+            req->header_values = (char**)calloc(header_count, sizeof(char*));
+            for (int i = 0; i < header_count; i++) {
+                req->header_keys[i] = header_keys[i] ? _strdup(header_keys[i]) : NULL;
+                req->header_values[i] = header_values[i] ? _strdup(header_values[i]) : NULL;
+            }
+            req->header_count = header_count;
+        }
+        if (body && body_len > 0) {
+            req->body = (char*)malloc(body_len);
+            memcpy(req->body, body, body_len);
+            req->body_len = body_len;
+        }
+        if (worker_id) strncpy(req->worker_id, worker_id, sizeof(req->worker_id) - 1);
+        req->callback = callback;
+        req->userdata = userdata;
+
+        CreateThread(NULL, 0, zapp_fetch_thread_proc, req, 0, NULL);
+    }
+#endif
+}

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

@@ -0,0 +1,216 @@
+// Win32-native URL parsing.
+// Uses a manual parser since CreateUri / IUri COM is overly complex for this use case.
+
+raw {
+#ifdef _WIN32
+    #include <windows.h>
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <string.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;
+    #endif
+
+    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);
+    }
+
+    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));
+
+        // Simple URL resolution: if url_str is relative and base_str given, prepend base
+        char resolved[2048] = {0};
+        if (base_str && base_str[0] && (strstr(url_str, "://") == NULL)) {
+            snprintf(resolved, sizeof(resolved), "%s", base_str);
+            // Remove trailing path from base to get base directory
+            char* lastSlash = strrchr(resolved, '/');
+            char* afterScheme = strstr(resolved, "://");
+            if (lastSlash && afterScheme && lastSlash > afterScheme + 2) {
+                *(lastSlash + 1) = '\0';
+            }
+            if (url_str[0] == '/') {
+                // Absolute path: keep scheme + host
+                char* thirdSlash = afterScheme ? strchr(afterScheme + 3, '/') : NULL;
+                if (thirdSlash) *thirdSlash = '\0';
+                strncat(resolved, url_str, sizeof(resolved) - strlen(resolved) - 1);
+            } else {
+                strncat(resolved, url_str, sizeof(resolved) - strlen(resolved) - 1);
+            }
+        } else {
+            strncpy(resolved, url_str, sizeof(resolved) - 1);
+        }
+
+        const char* p = resolved;
+        char scheme[64] = {0};
+        char userinfo[256] = {0};
+        char hostname[256] = {0};
+        char port[16] = {0};
+        char pathname[1024] = {0};
+        char search[1024] = {0};
+        char hash[512] = {0};
+
+        // Parse scheme
+        const char* schemeEnd = strstr(p, "://");
+        if (schemeEnd) {
+            size_t slen = (size_t)(schemeEnd - p);
+            if (slen < sizeof(scheme)) {
+                memcpy(scheme, p, slen);
+                scheme[slen] = '\0';
+            }
+            p = schemeEnd + 3;
+        }
+
+        // Parse userinfo (user:pass@)
+        const char* atSign = strchr(p, '@');
+        const char* firstSlash = strchr(p, '/');
+        if (atSign && (!firstSlash || atSign < firstSlash)) {
+            size_t ulen = (size_t)(atSign - p);
+            if (ulen < sizeof(userinfo)) {
+                memcpy(userinfo, p, ulen);
+                userinfo[ulen] = '\0';
+            }
+            p = atSign + 1;
+        }
+
+        // Parse host:port
+        firstSlash = strchr(p, '/');
+        const char* queryMark = strchr(p, '?');
+        const char* hashMark = strchr(p, '#');
+        const char* hostEnd = firstSlash;
+        if (!hostEnd || (queryMark && queryMark < hostEnd)) hostEnd = queryMark;
+        if (!hostEnd || (hashMark && hashMark < hostEnd)) hostEnd = hashMark;
+        if (!hostEnd) hostEnd = p + strlen(p);
+
+        size_t hostLen = (size_t)(hostEnd - p);
+        char hostPort[256] = {0};
+        if (hostLen < sizeof(hostPort)) {
+            memcpy(hostPort, p, hostLen);
+            hostPort[hostLen] = '\0';
+        }
+
+        // Split host and port
+        char* colonInHost = strrchr(hostPort, ':');
+        if (colonInHost && hostPort[0] != '[') {
+            *colonInHost = '\0';
+            strncpy(hostname, hostPort, sizeof(hostname) - 1);
+            strncpy(port, colonInHost + 1, sizeof(port) - 1);
+        } else {
+            strncpy(hostname, hostPort, sizeof(hostname) - 1);
+        }
+
+        p = hostEnd;
+
+        // Parse pathname
+        if (*p == '/') {
+            const char* pathEnd = p;
+            while (*pathEnd && *pathEnd != '?' && *pathEnd != '#') pathEnd++;
+            size_t plen = (size_t)(pathEnd - p);
+            if (plen < sizeof(pathname)) {
+                memcpy(pathname, p, plen);
+                pathname[plen] = '\0';
+            }
+            p = pathEnd;
+        } else if (*p != '?' && *p != '#' && *p) {
+            strcpy(pathname, "/");
+        }
+
+        // Parse search
+        if (*p == '?') {
+            const char* searchEnd = strchr(p, '#');
+            if (!searchEnd) searchEnd = p + strlen(p);
+            size_t slen = (size_t)(searchEnd - p);
+            if (slen < sizeof(search)) {
+                memcpy(search, p, slen);
+                search[slen] = '\0';
+            }
+            p = searchEnd;
+        }
+
+        // Parse hash
+        if (*p == '#') {
+            strncpy(hash, p, sizeof(hash) - 1);
+        }
+
+        // Build protocol string
+        char protocol[66] = {0};
+        if (scheme[0]) snprintf(protocol, sizeof(protocol), "%s:", scheme);
+
+        // Build host with port
+        char hostWithPort[280] = {0};
+        if (port[0]) {
+            snprintf(hostWithPort, sizeof(hostWithPort), "%s:%s", hostname, port);
+        } else {
+            strncpy(hostWithPort, hostname, sizeof(hostWithPort) - 1);
+        }
+
+        // Build origin
+        char origin[512] = {0};
+        if (strcmp(scheme, "http") == 0 || strcmp(scheme, "https") == 0 ||
+            strcmp(scheme, "ws") == 0 || strcmp(scheme, "wss") == 0 ||
+            strcmp(scheme, "ftp") == 0) {
+            snprintf(origin, sizeof(origin), "%s://%s", scheme, hostWithPort);
+        } else {
+            strcpy(origin, "null");
+        }
+
+        // Build href
+        char href[2048] = {0};
+        if (scheme[0]) {
+            snprintf(href, sizeof(href), "%s://%s%s%s%s%s",
+                scheme,
+                userinfo[0] ? userinfo : "",
+                userinfo[0] ? "@" : "",
+                hostWithPort, pathname, search);
+        } else {
+            snprintf(href, sizeof(href), "%s%s", pathname, search);
+        }
+        if (hash[0]) strncat(href, hash, sizeof(href) - strlen(href) - 1);
+
+        // Parse username/password from userinfo
+        char username[128] = {0};
+        char password[128] = {0};
+        if (userinfo[0]) {
+            char* colon = strchr(userinfo, ':');
+            if (colon) {
+                size_t ulen = (size_t)(colon - userinfo);
+                if (ulen < sizeof(username)) memcpy(username, userinfo, ulen);
+                strncpy(password, colon + 1, sizeof(password) - 1);
+            } else {
+                strncpy(username, userinfo, sizeof(username) - 1);
+            }
+        }
+
+        out->href     = _strdup(href);
+        out->protocol = _strdup(protocol);
+        out->host     = _strdup(hostWithPort);
+        out->hostname = _strdup(hostname);
+        out->port     = _strdup(port);
+        out->pathname = _strdup(pathname[0] ? pathname : "/");
+        out->search   = _strdup(search);
+        out->hash     = _strdup(hash);
+        out->origin   = _strdup(origin);
+        out->username = _strdup(username);
+        out->password = _strdup(password);
+        return 0;
+    }
+#endif
+}