@mikrojs/native 0.21.0-pr-431.20260920213100 → 0.21.0

package/include/mikrojs/app_store.h

@@ -21,3 +21,14 @@ MIKAppCommitResult mik__app_commit(const char* base, bool erased);
 /* Recover from an interrupted commit: restore the rollback copy if the live
  * app is missing, otherwise drop leftover staging/rollback dirs. */
 void mik__app_recover(const char* base);
+
+/* Remove a directory tree. Returns true when nothing is left at `path` (also
+ * when nothing was there). On failure errno is that of the first entry that
+ * could not be removed. Descends at most 32 levels and feeds the watchdog. */
+bool mik__rmdir_recursive(const char* path);
+
+/* Create `path` and any missing parents. Returns true when `path` is a
+ * directory afterwards. On failure errno is that of the first mkdir that
+ * left no directory behind, so a full filesystem reads as ENOSPC here instead
+ * of as ENOENT from a later open. */
+bool mik__mkdirs(const char* path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikrojs/native",
-  "version": "0.21.0-pr-431.20260920213100",
+  "version": "0.21.0",
   "description": "Mikro.js C++ runtime library and Node.js native addon",
   "keywords": [
     "esp32",
@@ -85,14 +85,14 @@
     "./runtime/wifi/types": "./runtime/wifi/types.ts"
   },
   "dependencies": {
-    "@mikrojs/quickjs": "0.21.0-pr-431.20260920213100+4a26f8c",
+    "@mikrojs/quickjs": "0.21.0",
     "cmake-js": "^8.0.0",
     "node-addon-api": "^8.9.2",
     "node-gyp-build": "^4.8.4"
   },
   "devDependencies": {
-    "@mikrojs/registry": "0.21.0-pr-431.20260920213100+4a26f8c",
-    "@mikrojs/schema": "0.21.0-pr-431.20260920213100+4a26f8c",
+    "@mikrojs/registry": "0.21.0",
+    "@mikrojs/schema": "0.21.0",
     "@swc/core": "^1.16.2",
     "@types/node": "^24.12.2",
     "esbuild": "^0.28.2",

package/src/mik_app_store.cpp

@@ -1,11 +1,14 @@
 #include "mikrojs/app_store.h"
 
 #include <dirent.h>
+#include <errno.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
+#include "mikrojs/platform.h"
+
 namespace {
 
 bool path_exists(const char* path) {
@@ -33,43 +36,86 @@ constexpr int kMaxDepth = 32;
 
 /* `path` is a mutable buffer of `cap` bytes holding the directory to remove;
  * each level appends into it and truncates on the way out, so a frame costs a
- * few dozen bytes rather than a 512-byte path of its own. */
-void rmdir_recursive_at(char* path, size_t cap, int depth) {
-    DIR* dir = opendir(path);
-    if (!dir) return;
-
+ * few dozen bytes rather than a 512-byte path of its own. Returns true when
+ * the directory is gone; `first_errno` keeps the first failure. */
+bool rmdir_recursive_at(char* path, size_t cap, int depth, int* first_errno) {
+    const MIKPlatform* platform = MIK_GetPlatform();
     const size_t base = strlen(path);
-    struct dirent* entry;
-    while ((entry = readdir(dir)) != NULL) {
-        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) continue;
-
-        const int n = snprintf(path + base, cap - base, "/%s", entry->d_name);
-        if (n < 0 || (size_t)n >= cap - base) {
-            path[base] = 0;  /* would truncate to a different path; skip it */
-            continue;
-        }
 
-        struct stat st;
-        if (stat(path, &st) == 0 && S_ISDIR(st.st_mode)) {
-            if (depth < kMaxDepth) rmdir_recursive_at(path, cap, depth + 1);
-        } else {
-            unlink(path);
+    DIR* dir = opendir(path);
+    if (dir) {
+        struct dirent* entry;
+        while ((entry = readdir(dir)) != NULL) {
+            if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) continue;
+            if (platform->feed_watchdog) platform->feed_watchdog();
+
+            const int n = snprintf(path + base, cap - base, "/%s", entry->d_name);
+            if (n < 0 || (size_t)n >= cap - base) {
+                path[base] = 0;  /* would truncate to a different path; skip it */
+                continue;
+            }
+
+            struct stat st;
+            if (stat(path, &st) == 0 && S_ISDIR(st.st_mode)) {
+                if (depth < kMaxDepth) rmdir_recursive_at(path, cap, depth + 1, first_errno);
+            } else if (unlink(path) != 0 && *first_errno == 0) {
+                *first_errno = errno;
+            }
+            path[base] = 0;
         }
-        path[base] = 0;
+        closedir(dir);
     }
-    closedir(dir);
-    rmdir(path);
+
+    if (rmdir(path) == 0) return true;
+    if (*first_errno == 0) *first_errno = errno;
+    return false;
 }
 
-void rmdir_recursive(const char* path) {
+}  // namespace
+
+bool mik__rmdir_recursive(const char* path) {
     char buf[512];
     const size_t n = strlen(path);
-    if (n >= sizeof(buf)) return;
+    if (n >= sizeof(buf)) {
+        errno = ENAMETOOLONG;
+        return false;
+    }
+    if (!path_exists(path)) return true;
     memcpy(buf, path, n + 1);
-    rmdir_recursive_at(buf, sizeof(buf), 0);
+    int first_errno = 0;
+    if (rmdir_recursive_at(buf, sizeof(buf), 0, &first_errno)) return true;
+    errno = first_errno;
+    return false;
 }
 
-}  // namespace
+bool mik__mkdirs(const char* path) {
+    char tmp[512];
+    const size_t n = strlen(path);
+    if (n == 0 || n >= sizeof(tmp)) {
+        errno = n == 0 ? EINVAL : ENAMETOOLONG;
+        return false;
+    }
+    memcpy(tmp, path, n + 1);
+
+    int first_errno = 0;
+    for (char* p = tmp + 1;; p++) {
+        if (*p != '/' && *p != '\0') continue;
+        const char saved = *p;
+        *p = '\0';
+        if (mkdir(tmp, 0755) != 0 && errno != EEXIST) {
+            /* A prefix that is there anyway (a mount point may not answer
+             * EEXIST) must not hide the errno of the one that is missing. */
+            const int e = errno;
+            if (first_errno == 0 && !dir_exists(tmp)) first_errno = e;
+        }
+        *p = saved;
+        if (saved == '\0') break;
+    }
+
+    if (dir_exists(path)) return true;
+    errno = first_errno ? first_errno : ENOTDIR;
+    return false;
+}
 
 MIKAppCommitResult mik__app_commit(const char* base, bool erased) {
     char app[512];
@@ -85,14 +131,14 @@ MIKAppCommitResult mik__app_commit(const char* base, bool erased) {
      * leave the live app untouched and just clean up. The original logic
      * would have deleted the live app in this degenerate case. */
     if (!dir_exists(staged_app)) {
-        rmdir_recursive(old);
-        rmdir_recursive(tmp);
+        mik__rmdir_recursive(old);
+        mik__rmdir_recursive(tmp);
         return MIK_APP_COMMIT_OK;
     }
 
     /* Atomic swap: staging dir → app dir */
     if (path_exists(app) && !erased) {
-        rmdir_recursive(old);
+        mik__rmdir_recursive(old);
         if (rename(app, old) != 0) {
             return MIK_APP_COMMIT_STASH_FAILED;
         }
@@ -105,8 +151,8 @@ MIKAppCommitResult mik__app_commit(const char* base, bool erased) {
         return MIK_APP_COMMIT_SWAP_FAILED;
     }
 
-    rmdir_recursive(old);
-    rmdir_recursive(tmp);
+    mik__rmdir_recursive(old);
+    mik__rmdir_recursive(tmp);
     return MIK_APP_COMMIT_OK;
 }
 
@@ -125,10 +171,10 @@ void mik__app_recover(const char* base) {
     if (!has_app && has_old) {
         rename(old, app);
     } else if (has_old) {
-        rmdir_recursive(old);
+        mik__rmdir_recursive(old);
     }
 
     if (has_tmp) {
-        rmdir_recursive(tmp);
+        mik__rmdir_recursive(tmp);
     }
 }