@toddzheng024/dscode-desktop 0.0.0-stage → 0.7.34

package/node_modules/@deepseek-ai/node-addon-system/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@deepseek-ai/node-addon-system",
+  "version": "0.1.2",
+  "type": "module",
+  "description": "Prebuilt system primitives: a Linux Landlock launcher and asynchronous POSIX flock through stable Node-API",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-harness/deepseek-harness.git",
+    "directory": "native/system/packages/entry"
+  },
+  "exports": {
+    "./landlock-run": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./flock": {
+      "types": "./lib/flock.d.ts",
+      "default": "./lib/flock.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "README.md",
+    "lib/",
+    "!lib/*.tsbuildinfo",
+    "src/main.c",
+    "src/flock.c"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "BSD-3-Clause",
+  "publishConfig": {
+    "access": "public"
+  },
+  "optionalDependencies": {
+    "@deepseek-ai/node-addon-system-darwin-arm64": "0.1.2",
+    "@deepseek-ai/node-addon-system-darwin-x64": "0.1.2",
+    "@deepseek-ai/node-addon-system-linux-x64": "0.1.2",
+    "@deepseek-ai/node-addon-system-linux-arm64": "0.1.2"
+  },
+  "scripts": {
+    "build:js": "tsc -b"
+  }
+}

package/node_modules/@deepseek-ai/node-addon-system/src/flock.c

@@ -0,0 +1,164 @@
+/*
+ * Node-API v8 binding for asynchronous flock(LOCK_EX | LOCK_NB).
+ * The caller owns fd through completion; this module never opens, duplicates,
+ * closes, or explicitly unlocks it. The callback receives zero or a positive
+ * errno; JavaScript owns the promise and syscall error construction.
+ */
+
+#include <node_api.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <sys/file.h>
+
+typedef struct {
+  napi_env env;
+  napi_ref callback;
+  napi_async_work work;
+  napi_async_cleanup_hook_handle cleanup;
+  int fd;
+  int error;
+  bool closing;
+} lock_request;
+
+static void check_status(napi_status status, const char *message) {
+  if (status != napi_ok) {
+    napi_fatal_error("flock", NAPI_AUTO_LENGTH, message, NAPI_AUTO_LENGTH);
+  }
+}
+
+static void release_request(lock_request *request) {
+  if (request->callback != NULL) {
+    (void)napi_delete_reference(request->env, request->callback);
+  }
+  if (request->work != NULL) {
+    (void)napi_delete_async_work(request->env, request->work);
+  }
+  if (request->cleanup != NULL) {
+    (void)napi_remove_async_cleanup_hook(request->cleanup);
+  }
+  free(request);
+}
+
+static napi_value throw_setup_error(napi_env env, napi_status status,
+                                   const char *message) {
+  if (status != napi_pending_exception) {
+    status = napi_throw_error(env, "ERR_FLOCK_ASYNC_WORK", message);
+    bool pending;
+    /* Error construction can fail with both generic_failure and a JS exception. */
+    check_status(napi_is_exception_pending(env, &pending), "Cannot inspect flock setup exception");
+    if (!pending && status != napi_pending_exception) check_status(status, message);
+  }
+  return NULL;
+}
+
+static void execute_lock(napi_env env, void *data) {
+  (void)env;
+  lock_request *request = data;
+  request->error = flock(request->fd, LOCK_EX | LOCK_NB) == 0 ? 0 : errno;
+}
+
+static void complete_lock(napi_env env, napi_status status, void *data) {
+  lock_request *request = data;
+  if (env != NULL && !request->closing) {
+    napi_value callback;
+    napi_value receiver;
+    napi_value result;
+    check_status(status, "flock async work did not complete");
+    check_status(napi_get_reference_value(env, request->callback, &callback),
+                 "Cannot retrieve flock callback");
+    check_status(napi_get_undefined(env, &receiver), "Cannot create flock receiver");
+    check_status(napi_create_int32(env, request->error, &result),
+                 "Cannot create flock result");
+    status = napi_call_function(env, receiver, callback, 1, &result, NULL);
+  } else {
+    status = napi_ok;
+  }
+  release_request(request);
+  /* Node's async-work dispatcher reports callback exceptions and handles termination. */
+  if (status != napi_pending_exception) {
+    check_status(status, "Cannot invoke flock callback");
+  }
+}
+
+static void cleanup_lock(napi_async_cleanup_hook_handle handle, void *data) {
+  (void)handle;
+  lock_request *request = data;
+  request->closing = true;
+  /*
+   * Running work cannot be cancelled. The hook keeps the environment alive
+   * until completion releases both the work and this hook; it never frees
+   * memory that the execution thread can still access.
+   */
+  (void)napi_cancel_async_work(request->env, request->work);
+}
+
+static napi_value try_lock(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value argv[2];
+  double fd;
+  napi_status status = napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  if (status != napi_ok) {
+    return throw_setup_error(env, status, "Cannot read flock arguments");
+  }
+  if (argc < 1 || napi_get_value_double(env, argv[0], &fd) != napi_ok) {
+    (void)napi_throw_type_error(env, NULL, "fd must be a number");
+    return NULL;
+  }
+  if (!(fd >= INT_MIN && fd <= INT_MAX) || fd != (int)fd) {
+    (void)napi_throw_range_error(env, NULL, "fd must be a signed C int");
+    return NULL;
+  }
+  napi_valuetype callback_type;
+  if (argc < 2 || napi_typeof(env, argv[1], &callback_type) != napi_ok ||
+      callback_type != napi_function) {
+    (void)napi_throw_type_error(env, NULL, "callback must be a function");
+    return NULL;
+  }
+
+  lock_request *request = calloc(1, sizeof(*request));
+  if (request == NULL) {
+    (void)napi_throw_error(env, "ENOMEM", "Cannot allocate flock async work");
+    return NULL;
+  }
+  request->env = env;
+  request->fd = (int)fd;
+
+  status = napi_create_reference(env, argv[1], 1, &request->callback);
+  if (status != napi_ok) {
+    release_request(request);
+    return throw_setup_error(env, status, "Cannot retain flock callback");
+  }
+  napi_value name;
+  status = napi_create_string_utf8(env, "flock", NAPI_AUTO_LENGTH, &name);
+  if (status == napi_ok) {
+    status = napi_create_async_work(env, NULL, name, execute_lock, complete_lock,
+                                   request, &request->work);
+  }
+  if (status != napi_ok) {
+    release_request(request);
+    return throw_setup_error(env, status, "Cannot create flock async work");
+  }
+  status = napi_add_async_cleanup_hook(env, cleanup_lock, request, &request->cleanup);
+  if (status != napi_ok) {
+    release_request(request);
+    return throw_setup_error(env, status, "Cannot register flock environment cleanup");
+  }
+  status = napi_queue_async_work(env, request->work);
+  if (status != napi_ok) {
+    /* Queue failure schedules no completion callback. */
+    release_request(request);
+    return throw_setup_error(env, status, "Cannot queue flock async work");
+  }
+  return NULL;
+}
+
+NAPI_MODULE_INIT() {
+  napi_value function;
+  if (napi_create_function(env, "tryLock", NAPI_AUTO_LENGTH, try_lock,
+                           NULL, &function) != napi_ok ||
+      napi_set_named_property(env, exports, "tryLock", function) != napi_ok) {
+    return NULL;
+  }
+  return exports;
+}

package/node_modules/@deepseek-ai/node-addon-system/src/main.c

@@ -0,0 +1,298 @@
+/*
+ * landlock-run: self-restrict-then-exec Landlock launcher.
+ *
+ * The Landlock rung of a consuming sandbox seam, for Linux hosts where
+ * `bwrap` is
+ * unusable (not installed, unprivileged user namespaces disabled, or an LSM
+ * profile that denies mount — Landlock is an independent syscall family and
+ * needs none of those). The launcher installs a Landlock
+ * ruleset on itself and `exec`s the wrapped command; the ruleset is inherited
+ * across `execve`, so the command (and every process it spawns) runs confined
+ * while the invoking process stays unrestricted.
+ *
+ * CLI contract (mirrors the `bwrap` runner argv shape the executor wraps):
+ *
+ *   landlock-run [--ro <path>]... [--rw <path>]... -- <argv>...
+ *   landlock-run --probe
+ *
+ * `--ro` grants read+execute beneath the path; `--rw` grants full filesystem
+ * access beneath the path. Everything else is denied (Landlock is an
+ * allow-list). `--probe` builds a maximal ruleset and reports whether the
+ * running kernel actually enforces it — the executor's functional probe.
+ *
+ * Fail-closed: if the ruleset cannot be created or is NOT enforced by the
+ * kernel, the launcher exits non-zero WITHOUT exec'ing the command. A partial
+ * (best-effort) enforcement on an older ABI is accepted and reported on
+ * stderr; the consumer's mode vocabulary keeps its file-effect promises
+ * honest per ABI level (surfaced as `full` vs `partial` by the entry
+ * package's probe).
+ *
+ * Plain C11 over the raw Landlock UAPI — no libraries beyond libc (musl,
+ * linked statically), so the whole audit surface is this file plus the
+ * kernel's stable syscall contract. Built natively per architecture by
+ * `scripts/build.ts` into the per-platform npm packages
+ * (`@deepseek-ai/node-addon-system-linux-{x64,arm64}`); the argv grammar,
+ * exit codes, and report lines are pinned in `docs/cli-contract.md`.
+ */
+
+#define _GNU_SOURCE
+#include <errno.h>
+#include <fcntl.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/prctl.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+
+/*
+ * The Landlock UAPI, defined locally instead of via <linux/landlock.h>: the
+ * kernel's user-space ABI is stable by contract, self-defining it keeps the
+ * build independent of the toolchain's header vintage, and the definitions
+ * double as the audit record of exactly which kernel API this launcher
+ * touches. Layouts and values are verbatim from the kernel header (the
+ * path-beneath struct is packed there, so it must be packed here).
+ */
+struct landlock_ruleset_attr {
+  uint64_t handled_access_fs;
+};
+
+struct landlock_path_beneath_attr {
+  uint64_t allowed_access;
+  int32_t parent_fd;
+} __attribute__((packed));
+
+#define LANDLOCK_CREATE_RULESET_VERSION (1U << 0)
+#define LANDLOCK_RULE_PATH_BENEATH 1
+
+/* Filesystem access bits, grouped by the Landlock ABI that introduced them. */
+#define LL_FS_EXECUTE     (UINT64_C(1) << 0)  /* ABI 1 */
+#define LL_FS_WRITE_FILE  (UINT64_C(1) << 1)
+#define LL_FS_READ_FILE   (UINT64_C(1) << 2)
+#define LL_FS_READ_DIR    (UINT64_C(1) << 3)
+#define LL_FS_REMOVE_DIR  (UINT64_C(1) << 4)
+#define LL_FS_REMOVE_FILE (UINT64_C(1) << 5)
+#define LL_FS_MAKE_CHAR   (UINT64_C(1) << 6)
+#define LL_FS_MAKE_DIR    (UINT64_C(1) << 7)
+#define LL_FS_MAKE_REG    (UINT64_C(1) << 8)
+#define LL_FS_MAKE_SOCK   (UINT64_C(1) << 9)
+#define LL_FS_MAKE_FIFO   (UINT64_C(1) << 10)
+#define LL_FS_MAKE_BLOCK  (UINT64_C(1) << 11)
+#define LL_FS_MAKE_SYM    (UINT64_C(1) << 12)
+#define LL_FS_REFER       (UINT64_C(1) << 13) /* ABI 2 */
+#define LL_FS_TRUNCATE    (UINT64_C(1) << 14) /* ABI 3 (ABI 4 added TCP bits only) */
+#define LL_FS_IOCTL_DEV   (UINT64_C(1) << 15) /* ABI 5 */
+
+#define LL_ABI1_MASK (LL_FS_REFER - 1) /* bits 0..12: every ABI-1 access, nothing newer */
+
+/*
+ * Newest ABI this build knows; the negotiation below scales the actual
+ * ruleset down to what the running kernel supports.
+ */
+#define MAX_ABI 5L
+
+/*
+ * Landlock has no libc wrappers; these are the raw syscalls. The numbers are
+ * identical on every architecture (the post-2011 unified table) — the
+ * fallbacks only matter to a libc older than the feature.
+ */
+#ifndef __NR_landlock_create_ruleset
+#define __NR_landlock_create_ruleset 444
+#define __NR_landlock_add_rule 445
+#define __NR_landlock_restrict_self 446
+#endif
+
+/*
+ * Every fatal launcher error prints `landlock-run: <message>` to stderr
+ * and exits 125 — a code the wrapped command itself is unlikely to use, so
+ * the executor can tell launcher failures from command failures.
+ */
+#define EXIT_LAUNCHER_FAILURE 125
+
+static const char NOT_ENFORCED_MESSAGE[] =
+  "landlock is not enforced by this kernel (ABI unsupported or disabled)";
+
+/* Print one fatal `landlock-run: ...` line; returns the fatal exit code. */
+static int fail(const char *prefix, const char *detail) {
+  if (detail == NULL) {
+    fprintf(stderr, "landlock-run: %s\n", prefix);
+  } else {
+    fprintf(stderr, "landlock-run: %s: %s\n", prefix, detail);
+  }
+  return EXIT_LAUNCHER_FAILURE;
+}
+
+static int fail_usage(const char *message, const char *detail) {
+  fprintf(stderr, "landlock-run: usage error: %s%s\n", message, detail == NULL ? "" : detail);
+  return EXIT_LAUNCHER_FAILURE;
+}
+
+/* Parsed CLI: either a probe, or grants plus the command argv after `--`. */
+struct cli {
+  int probe;
+  const char **ro;
+  size_t ro_count;
+  const char **rw;
+  size_t rw_count;
+  char **command; /* NULL-terminated tail of main's argv */
+};
+
+/*
+ * Hand-rolled argv parsing — four flags do not justify a parsing library.
+ * Returns 0 on success, else the process exit code (message already printed).
+ */
+static int parse(int argc, char **argv, struct cli *cli) {
+  /* argc bounds each grant list; the launcher execs or exits, so no free. */
+  cli->ro = calloc(argc > 0 ? (size_t)argc : 1, sizeof *cli->ro);
+  cli->rw = calloc(argc > 0 ? (size_t)argc : 1, sizeof *cli->rw);
+  if (cli->ro == NULL || cli->rw == NULL) return fail("out of memory", NULL);
+
+  int index = 1;
+  while (index < argc) {
+    const char *arg = argv[index];
+    if (strcmp(arg, "--probe") == 0) {
+      if (argc != 2) {
+        return fail_usage("--probe takes no other arguments", NULL);
+      }
+      cli->probe = 1;
+      index += 1;
+    } else if (strcmp(arg, "--ro") == 0 || strcmp(arg, "--rw") == 0) {
+      if (index + 1 >= argc) {
+        return fail_usage(arg, " requires a path");
+      }
+      if (strcmp(arg, "--ro") == 0) {
+        cli->ro[cli->ro_count++] = argv[index + 1];
+      } else {
+        cli->rw[cli->rw_count++] = argv[index + 1];
+      }
+      index += 2;
+    } else if (strcmp(arg, "--") == 0) {
+      cli->command = &argv[index + 1];
+      break;
+    } else {
+      return fail_usage("unknown argument: ", arg);
+    }
+  }
+  if (!cli->probe && (cli->command == NULL || cli->command[0] == NULL)) {
+    return fail_usage("missing `-- <argv>...` command", NULL);
+  }
+  return 0;
+}
+
+/* The filesystem accesses the running kernel's ABI can govern. */
+static uint64_t fs_mask_for_abi(long abi) {
+  uint64_t mask = LL_ABI1_MASK;
+  if (abi >= 2) mask |= LL_FS_REFER;
+  if (abi >= 3) mask |= LL_FS_TRUNCATE;
+  if (abi >= 5) mask |= LL_FS_IOCTL_DEV;
+  return mask;
+}
+
+/* Add one path-beneath rule; 0 on success, else the exit code. */
+static int add_rule(int ruleset_fd, const char *path, uint64_t access) {
+  int path_fd = open(path, O_PATH | O_CLOEXEC);
+  if (path_fd < 0) {
+    /* Fail closed on an unopenable grant root: silently narrowing the
+     * granted set would be safe, but running with a profile the caller did
+     * not get is not worth the ambiguity. */
+    fprintf(stderr, "landlock-run: cannot open rule path: %s: %s\n", path, strerror(errno));
+    return EXIT_LAUNCHER_FAILURE;
+  }
+  /* The kernel rejects directory-only accesses on a non-directory rule
+   * (EINVAL), so a file grant keeps only the file-compatible bits — how the
+   * `--rw /dev/null` grant works. */
+  struct stat st;
+  if (fstat(path_fd, &st) == 0 && !S_ISDIR(st.st_mode)) {
+    access &= LL_FS_EXECUTE | LL_FS_WRITE_FILE | LL_FS_READ_FILE | LL_FS_TRUNCATE | LL_FS_IOCTL_DEV;
+  }
+  struct landlock_path_beneath_attr attr = { .allowed_access = access, .parent_fd = path_fd };
+  if (syscall(__NR_landlock_add_rule, ruleset_fd, LANDLOCK_RULE_PATH_BENEATH, &attr, 0) != 0) {
+    int saved = errno;
+    close(path_fd);
+    return fail("landlock ruleset error", strerror(saved));
+  }
+  close(path_fd);
+  return 0;
+}
+
+/*
+ * Install the ruleset on the current thread, negotiating the kernel's ABI
+ * down from MAX_ABI. `--ro` paths get the read side of the vocabulary (read
+ * file/dir + execute — the wrapped `bash` and everything it spawns must
+ * remain executable); `--rw` paths get every filesystem access the
+ * negotiated ABI can grant. Sets `no_new_privs` first (mandatory for an
+ * unprivileged restrict, and it neutralizes setuid/setgid escalation inside
+ * the sandbox). On success `*partial` reports whether the kernel governs
+ * only a subset of MAX_ABI's accesses. Returns 0, else the exit code.
+ */
+static int restrict_self(const struct cli *cli, int *partial) {
+  long abi = syscall(__NR_landlock_create_ruleset, NULL, 0, LANDLOCK_CREATE_RULESET_VERSION);
+  if (abi < 0) {
+    /* ENOSYS: kernel built without Landlock; EOPNOTSUPP: built but disabled.
+     * Either way: not enforceable — fail CLOSED, never exec unconfined. */
+    return fail(NOT_ENFORCED_MESSAGE, NULL);
+  }
+  *partial = abi < MAX_ABI;
+  uint64_t handled = fs_mask_for_abi(abi < MAX_ABI ? abi : MAX_ABI);
+
+  struct landlock_ruleset_attr attr = { .handled_access_fs = handled };
+  int ruleset_fd = (int)syscall(__NR_landlock_create_ruleset, &attr, sizeof attr, 0);
+  if (ruleset_fd < 0) return fail("landlock ruleset error", strerror(errno));
+
+  const uint64_t read_side = LL_FS_EXECUTE | LL_FS_READ_FILE | LL_FS_READ_DIR;
+  for (size_t i = 0; i < cli->ro_count; i++) {
+    int code = add_rule(ruleset_fd, cli->ro[i], read_side & handled);
+    if (code != 0) return code;
+  }
+  for (size_t i = 0; i < cli->rw_count; i++) {
+    int code = add_rule(ruleset_fd, cli->rw[i], handled);
+    if (code != 0) return code;
+  }
+
+  if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) != 0) {
+    return fail("landlock ruleset error", strerror(errno));
+  }
+  if (syscall(__NR_landlock_restrict_self, ruleset_fd, 0) != 0) {
+    return fail("landlock ruleset error", strerror(errno));
+  }
+  close(ruleset_fd);
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  struct cli cli = { 0 };
+  int code = parse(argc, argv, &cli);
+  if (code != 0) return code;
+
+  if (cli.probe) {
+    /* The functional probe: build and enforce a maximal ruleset in THIS
+     * short-lived process (the probe run exits right after). `--version`
+     * style checks would miss a kernel that has the syscalls but refuses
+     * enforcement; actually restricting is the only honest signal. The one
+     * report line is part of the launcher CLI contract — the executor reads
+     * enforcement completeness from it. */
+    static const char *probe_root = "/";
+    struct cli probe = { .ro = &probe_root, .ro_count = 1 };
+    int partial = 0;
+    code = restrict_self(&probe, &partial);
+    if (code != 0) return code;
+    printf("landlock: %s\n", partial ? "partially enforced (older ABI)" : "fully enforced");
+    return 0;
+  }
+
+  int partial = 0;
+  code = restrict_self(&cli, &partial);
+  if (code != 0) return code;
+  if (partial) {
+    /* Older ABI: some handled accesses are not governed (e.g. truncate
+     * before ABI 3). Still confined for everything the kernel supports —
+     * report, do not refuse. */
+    fprintf(stderr, "landlock-run: partial enforcement (older Landlock ABI)\n");
+  }
+
+  execvp(cli.command[0], cli.command);
+  /* exec only returns on failure. */
+  return fail("exec failed", strerror(errno));
+}

package/node_modules/@deepseek-ai/node-addon-system-darwin-arm64/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, node-addon-landlock-run contributors
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/node_modules/@deepseek-ai/node-addon-system-darwin-arm64/README.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write native/system/packages/darwin-arm64/README.md
+README.md: 71cfaacc9bc442341b3a9d57389c2cb1904fbb70
+README.zh.md: 5e54c8155009b98e3336ea612535ce08e56817ae

package/node_modules/@deepseek-ai/node-addon-system-darwin-arm64/README.md

@@ -0,0 +1,9 @@
+---
+description: "Prebuilt system.node for macOS arm64 POSIX locks."
+kind: "package-library"
+---
+# @deepseek-ai/node-addon-system-darwin-arm64
+
+English | [中文](README.zh.md)
+
+This platform package supplies `bin/system.node`, a stable Node-API v8 addon used by `@deepseek-ai/node-addon-system/flock`. It contains no Landlock executable, JavaScript loader, or installation build script. The native workflow builds it on macOS arm64 and owns its installed-artifact validation.

package/node_modules/@deepseek-ai/node-addon-system-darwin-arm64/README.zh.md

@@ -0,0 +1,9 @@
+---
+description: "为 macOS arm64 POSIX 锁提供预编译 system.node。"
+kind: "package-library"
+---
+# @deepseek-ai/node-addon-system-darwin-arm64
+
+[English](README.md) | 中文
+
+此平台包提供 `bin/system.node`，供 `@deepseek-ai/node-addon-system/flock` 使用的稳定 Node-API v8 addon。它不包含 Landlock 可执行文件、JavaScript 加载器或安装构建脚本。Native 工作流在 macOS arm64 上构建它，并负责验证安装后的产物。

package/node_modules/@deepseek-ai/node-addon-system-darwin-arm64/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@deepseek-ai/node-addon-system-darwin-arm64",
+  "version": "0.1.2",
+  "description": "Prebuilt POSIX flock Node-API binding for macOS arm64",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-harness/deepseek-harness.git",
+    "directory": "native/system/packages/darwin-arm64"
+  },
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "files": [
+    "README.md",
+    "bin/",
+    "prebuilds.json"
+  ],
+  "scripts": {
+    "prepack": "node ../../scripts/verify-launcher-binary.mjs"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "BSD-3-Clause",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/node_modules/@deepseek-ai/node-addon-system-darwin-arm64/prebuilds.json

@@ -0,0 +1,6 @@
+{
+  "platform": "darwin-arm64",
+  "binaries": [
+    { "tool": "flock", "kind": "node-api", "napi": 8, "path": "bin/system.node" }
+  ]
+}

package/node_modules/@deepseek-ai/node-addon-system-darwin-x64/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, node-addon-landlock-run contributors
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/node_modules/@deepseek-ai/node-addon-system-darwin-x64/README.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write native/system/packages/darwin-x64/README.md
+README.md: 1740788eef943373591a895baeb7207635972a46
+README.zh.md: 644165743486a29e48bee7af33429ebf4f5d8fe2

package/node_modules/@deepseek-ai/node-addon-system-darwin-x64/README.md

@@ -0,0 +1,9 @@
+---
+description: "Prebuilt system.node for macOS x64 POSIX locks."
+kind: "package-library"
+---
+# @deepseek-ai/node-addon-system-darwin-x64
+
+English | [中文](README.zh.md)
+
+This platform package supplies `bin/system.node`, a stable Node-API v8 addon used by `@deepseek-ai/node-addon-system/flock`. It contains no Landlock executable, JavaScript loader, or installation build script. The native workflow builds it on macOS x64 and owns its installed-artifact validation.

package/node_modules/@deepseek-ai/node-addon-system-darwin-x64/README.zh.md

@@ -0,0 +1,9 @@
+---
+description: "为 macOS x64 POSIX 锁提供预编译 system.node。"
+kind: "package-library"
+---
+# @deepseek-ai/node-addon-system-darwin-x64
+
+[English](README.md) | 中文
+
+此平台包提供 `bin/system.node`，供 `@deepseek-ai/node-addon-system/flock` 使用的稳定 Node-API v8 addon。它不包含 Landlock 可执行文件、JavaScript 加载器或安装构建脚本。Native 工作流在 macOS x64 上构建它，并负责验证安装后的产物。