@elizaos/plugin-capacitor-bridge 2.0.0-beta.1 → 2.0.3-beta.3

package/dist/chunk-E7Y447TQ.js

@@ -0,0 +1,690 @@
+// src/shared/fs-shim.ts
+import * as nodeFs from "fs";
+import * as nodeFsPromises from "fs/promises";
+import { createRequire } from "module";
+import * as nodePath2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/shared/fs-sandbox.ts
+import * as realFs from "fs";
+import * as nodePath from "path";
+import { fileURLToPath } from "url";
+function requireMobileFsResolver(moduleName) {
+  const resolver = globalThis.__ELIZA_MOBILE_FS_RESOLVE__;
+  if (!resolver) {
+    throw new Error(
+      `${moduleName}: filesystem access before installMobileFsShim()`
+    );
+  }
+  return resolver;
+}
+function mobileFsAccessError(path, message) {
+  const err = new Error(message);
+  err.code = "EACCES";
+  err.path = path;
+  return err;
+}
+function guardMobileFsWritePath(resolved, originalPath) {
+  const ext = nodePath.extname(resolved).toLowerCase();
+  if (ext === ".so" || ext === ".dylib" || ext === ".node") {
+    throw mobileFsAccessError(
+      originalPath,
+      `mobile-fs-shim: writing native binary files is blocked (${ext})`
+    );
+  }
+}
+function mobileFsPathLikeToString(raw, moduleName) {
+  if (raw instanceof URL) {
+    if (raw.protocol !== "file:") {
+      throw new Error(
+        `${moduleName}: only file: URLs are accepted (${raw.protocol})`
+      );
+    }
+    return fileURLToPath(raw);
+  }
+  if (Buffer.isBuffer(raw)) return raw.toString("utf8");
+  return typeof raw === "string" ? raw : null;
+}
+function modeForMobileFsOpenFlags(flags) {
+  if (typeof flags === "number") {
+    const writeBits = realFs.constants.O_WRONLY | realFs.constants.O_RDWR | realFs.constants.O_APPEND | realFs.constants.O_CREAT | realFs.constants.O_TRUNC;
+    return (flags & writeBits) !== 0 ? "write" : "read";
+  }
+  if (typeof flags !== "string" || flags.length === 0) return "read";
+  return /[wa+]/.test(flags) ? "write" : "read";
+}
+function wrapMobileFsPath(moduleName, fn, mode) {
+  return function wrappedMobileFsPath(...args) {
+    const a = args;
+    const pathStr = mobileFsPathLikeToString(a[0], moduleName);
+    if (pathStr !== null) {
+      const resolved = requireMobileFsResolver(moduleName)(pathStr, mode);
+      if (mode === "write") guardMobileFsWritePath(resolved, pathStr);
+      a[0] = resolved;
+    }
+    return fn.apply(this, a);
+  };
+}
+function wrapMobileFsOpen(moduleName, fn) {
+  return function wrappedMobileFsOpen(...args) {
+    const a = args;
+    const pathStr = mobileFsPathLikeToString(a[0], moduleName);
+    if (pathStr !== null) {
+      const mode = modeForMobileFsOpenFlags(a[1]);
+      const resolved = requireMobileFsResolver(moduleName)(pathStr, mode);
+      if (mode === "write") guardMobileFsWritePath(resolved, pathStr);
+      a[0] = resolved;
+    }
+    return fn.apply(this, a);
+  };
+}
+function wrapMobileFsTwoPaths(moduleName, fn, srcMode, dstMode) {
+  return function wrappedMobileFsTwoPaths(...args) {
+    const a = args;
+    const src = mobileFsPathLikeToString(a[0], moduleName);
+    const dst = mobileFsPathLikeToString(a[1], moduleName);
+    const resolver = requireMobileFsResolver(moduleName);
+    if (src !== null) {
+      const resolved = resolver(src, srcMode);
+      if (srcMode === "write") guardMobileFsWritePath(resolved, src);
+      a[0] = resolved;
+    }
+    if (dst !== null) {
+      const resolved = resolver(dst, dstMode);
+      if (dstMode === "write") guardMobileFsWritePath(resolved, dst);
+      a[1] = resolved;
+    }
+    return fn.apply(this, a);
+  };
+}
+
+// src/shared/fs-shim.ts
+var _installed = false;
+var _workspaceRoot = "";
+var _workspaceRootReal = "";
+var _readOnlyRoots = [];
+var _readOnlyRootReals = [];
+var rawExistsSync = nodeFs.existsSync.bind(nodeFs);
+var rawRealpathSync = nodeFs.realpathSync.bind(nodeFs);
+var BLOCKED_ROOT_PREFIXES = [
+  "/etc",
+  "/usr",
+  "/bin",
+  "/sbin",
+  "/lib",
+  "/lib64",
+  "/System",
+  "/private/etc",
+  "/private/var/db",
+  "/private/var/root",
+  "/dev",
+  "/proc",
+  "/sys",
+  "/boot",
+  "/run"
+];
+function isInsideRoot(pathname, root) {
+  const rootWithSep = root.endsWith(nodePath2.sep) ? root : root + nodePath2.sep;
+  return pathname === root || pathname.startsWith(rootWithSep);
+}
+function envReadOnlyRoots() {
+  const candidates = [
+    process.env.ELIZA_IOS_AGENT_PUBLIC_DIR,
+    process.env.ELIZA_IOS_AGENT_ASSET_DIR,
+    process.env.ELIZA_IOS_AGENT_BUNDLE ? nodePath2.dirname(process.env.ELIZA_IOS_AGENT_BUNDLE) : ""
+  ];
+  return candidates.filter((value) => Boolean(value?.trim())).map((value) => nodePath2.resolve(value));
+}
+function realpathIfPossible(pathname) {
+  try {
+    return rawRealpathSync(pathname);
+  } catch {
+    return nodePath2.resolve(pathname);
+  }
+}
+function nearestExistingParent(pathname) {
+  let current = nodePath2.resolve(pathname);
+  for (; ; ) {
+    if (rawExistsSync(current)) return current;
+    const parent = nodePath2.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function validateResolvedRealPath(inputPath, resolved, mode, allowedReadOnly) {
+  if (mode === "read") {
+    if (!rawExistsSync(resolved)) return resolved;
+    const real2 = realpathIfPossible(resolved);
+    if (isInsideRoot(real2, _workspaceRootReal || _workspaceRoot))
+      return resolved;
+    if (allowedReadOnly && _readOnlyRootReals.some((root) => isInsideRoot(real2, root))) {
+      return resolved;
+    }
+    throw accessError(
+      inputPath,
+      `mobile-fs-shim: real path escapes allowed roots: ${real2}`
+    );
+  }
+  const existing = nearestExistingParent(resolved);
+  if (!existing) return resolved;
+  const real = realpathIfPossible(existing);
+  if (isInsideRoot(real, _workspaceRootReal || _workspaceRoot)) return resolved;
+  throw accessError(
+    inputPath,
+    `mobile-fs-shim: write parent escapes workspace root: ${real}`
+  );
+}
+function resolveViaAncestor(pathname) {
+  const existing = nearestExistingParent(pathname);
+  if (!existing) return pathname;
+  try {
+    const realExisting = rawRealpathSync(existing);
+    if (realExisting === existing) return pathname;
+    return realExisting + pathname.slice(existing.length);
+  } catch {
+    return pathname;
+  }
+}
+function resolveSandboxed(inputPath, mode = "read") {
+  if (!_workspaceRoot) {
+    throw accessError(
+      inputPath,
+      "mobile-fs-shim: workspace root not initialised"
+    );
+  }
+  const resolved = nodePath2.isAbsolute(inputPath) ? nodePath2.resolve(inputPath) : nodePath2.resolve(_workspaceRoot, inputPath);
+  for (const blocked of BLOCKED_ROOT_PREFIXES) {
+    if (resolved === blocked || resolved.startsWith(blocked + nodePath2.sep)) {
+      throw accessError(
+        inputPath,
+        `mobile-fs-shim: path targets a system directory (${blocked})`
+      );
+    }
+  }
+  if (isInsideRoot(resolved, _workspaceRoot)) {
+    return validateResolvedRealPath(inputPath, resolved, mode, false);
+  }
+  if (mode === "read" && _readOnlyRoots.some((root) => isInsideRoot(resolved, root))) {
+    return validateResolvedRealPath(inputPath, resolved, mode, true);
+  }
+  if (_workspaceRootReal) {
+    const realResolved = resolveViaAncestor(resolved);
+    if (realResolved !== resolved) {
+      if (isInsideRoot(realResolved, _workspaceRootReal)) {
+        return resolved;
+      }
+      if (mode === "read" && _readOnlyRootReals.some((root) => isInsideRoot(realResolved, root))) {
+        return resolved;
+      }
+    }
+  }
+  throw accessError(
+    inputPath,
+    `mobile-fs-shim: path escapes workspace root (${_workspaceRoot}): ${resolved}`
+  );
+}
+function sandboxedPath(inputPath) {
+  return resolveSandboxed(inputPath);
+}
+function isMobileFsShimInstalled() {
+  return _installed;
+}
+function getMobileWorkspaceRoot() {
+  return _workspaceRoot;
+}
+function accessError(path, message) {
+  return mobileFsAccessError(path, message);
+}
+function pathLikeToString(raw) {
+  if (raw instanceof URL) {
+    if (raw.protocol !== "file:") {
+      throw accessError(
+        raw.toString(),
+        `mobile-fs-shim: only file: URLs are accepted by fs (${raw.protocol})`
+      );
+    }
+    return fileURLToPath2(raw);
+  }
+  if (Buffer.isBuffer(raw)) return raw.toString("utf8");
+  return typeof raw === "string" ? raw : null;
+}
+function installRequireGuard() {
+  const g = globalThis;
+  if (!g.require || g.require.__mobileFsShimGuarded) return;
+  const original = g.require;
+  g.__elizaOriginalRequire = original;
+  const guarded = new Proxy(original, {
+    apply(target, thisArg, args) {
+      const id = args[0];
+      if (typeof id === "string") {
+        const isBuiltin = id.startsWith("node:") || id.startsWith("bun:") || id === "buffer" || id === "path" || id === "fs" || id === "url" || id === "util" || id === "stream" || id === "events" || id === "crypto" || id === "os" || id === "child_process" || id === "net" || id === "tls";
+        const isFilePath = id.startsWith(".") || nodePath2.isAbsolute(id);
+        if (isFilePath && !isBuiltin) {
+          throw accessError(
+            id,
+            `mobile-fs-shim: dynamic require of file paths is blocked on mobile (${id}). All code must be bundled.`
+          );
+        }
+      }
+      return Reflect.apply(target, thisArg, args);
+    }
+  });
+  guarded.__mobileFsShimGuarded = true;
+  g.require = guarded;
+}
+var mobileRequire = createRequire(import.meta.url);
+function optionalRequireObject(id) {
+  try {
+    const value = mobileRequire(id);
+    return value && typeof value === "object" ? value : null;
+  } catch {
+    return null;
+  }
+}
+function objectTargets(...values) {
+  const out = [];
+  const seen = /* @__PURE__ */ new WeakSet();
+  for (const value of values) {
+    if (!value || typeof value !== "object") continue;
+    const object = value;
+    if (seen.has(object)) continue;
+    seen.add(object);
+    out.push(object);
+  }
+  return out;
+}
+function setIfMutable(target, key, value) {
+  try {
+    target[key] = value;
+    return target[key] === value;
+  } catch {
+    return false;
+  }
+}
+function wrapFsPath(original, mode = "read") {
+  return function sandboxedFsCall(...args) {
+    const a = args;
+    const raw = a[0];
+    const pathStr = pathLikeToString(raw);
+    if (pathStr !== null) {
+      const resolved = resolveSandboxed(pathStr, mode);
+      if (mode === "write") guardWritePath(resolved, pathStr);
+      a[0] = resolved;
+    }
+    return original.apply(this, a);
+  };
+}
+function wrapFsOpenPath(original) {
+  return function sandboxedOpenCall(...args) {
+    const a = args;
+    const raw = a[0];
+    const pathStr = pathLikeToString(raw);
+    if (pathStr !== null) {
+      const mode = modeForMobileFsOpenFlags(a[1]);
+      const resolved = resolveSandboxed(pathStr, mode);
+      if (mode === "write") guardWritePath(resolved, pathStr);
+      a[0] = resolved;
+    }
+    return original.apply(this, a);
+  };
+}
+function wrapFsTwoPaths(original, srcMode, dstMode) {
+  return function sandboxedFsCall(...args) {
+    const a = args;
+    const rawSrc = a[0];
+    const rawDst = a[1];
+    const srcStr = pathLikeToString(rawSrc);
+    const dstStr = pathLikeToString(rawDst);
+    if (srcStr !== null) {
+      const resolved = resolveSandboxed(srcStr, srcMode);
+      if (srcMode === "write") guardWritePath(resolved, srcStr);
+      a[0] = resolved;
+    }
+    if (dstStr !== null) {
+      const resolved = resolveSandboxed(dstStr, dstMode);
+      if (dstMode === "write") guardWritePath(resolved, dstStr);
+      a[1] = resolved;
+    }
+    return original.apply(this, a);
+  };
+}
+function wrapFsWriteGuard(original) {
+  return function sandboxedFsWrite(...args) {
+    const a = args;
+    const raw = a[0];
+    const pathStr = pathLikeToString(raw);
+    if (pathStr !== null) {
+      const resolved = resolveSandboxed(pathStr, "write");
+      guardWritePath(resolved, pathStr);
+      a[0] = resolved;
+    }
+    return original.apply(this, a);
+  };
+}
+function guardWritePath(resolved, originalPath) {
+  guardMobileFsWritePath(resolved, originalPath);
+}
+function patchFsModule() {
+  const fsTargets = objectTargets(
+    optionalRequireObject("node:fs"),
+    optionalRequireObject("fs"),
+    nodeFs,
+    nodeFs.default
+  );
+  const promiseTargets = objectTargets(
+    optionalRequireObject("node:fs/promises"),
+    optionalRequireObject("fs/promises"),
+    nodeFsPromises,
+    nodeFsPromises.default,
+    ...fsTargets.map((target) => target.promises)
+  );
+  const syncOnePath = [
+    "accessSync",
+    "chmodSync",
+    "chownSync",
+    "lchmodSync",
+    "lchownSync",
+    "lstatSync",
+    "mkdirSync",
+    "mkdtempSync",
+    "readdirSync",
+    "readFileSync",
+    "readlinkSync",
+    "realpathSync",
+    "rmdirSync",
+    "rmSync",
+    "statSync",
+    "truncateSync",
+    "unlinkSync",
+    "utimesSync",
+    "lutimesSync",
+    "existsSync",
+    "opendirSync",
+    "appendFileSync"
+  ];
+  const syncWriteOnePath = /* @__PURE__ */ new Set([
+    "chmodSync",
+    "chownSync",
+    "lchmodSync",
+    "lchownSync",
+    "mkdirSync",
+    "mkdtempSync",
+    "rmdirSync",
+    "rmSync",
+    "truncateSync",
+    "unlinkSync",
+    "utimesSync",
+    "lutimesSync",
+    "appendFileSync"
+  ]);
+  for (const target of fsTargets) {
+    for (const name of syncOnePath) {
+      const key = String(name);
+      const orig = target[key];
+      if (typeof orig === "function") {
+        setIfMutable(
+          target,
+          key,
+          wrapFsPath(
+            orig,
+            syncWriteOnePath.has(key) ? "write" : "read"
+          )
+        );
+      }
+    }
+    if (typeof target.writeFileSync === "function") {
+      const wrapped = wrapFsWriteGuard(target.writeFileSync);
+      setIfMutable(target, "writeFileSync", wrapFsPath(wrapped, "write"));
+    }
+    if (typeof target.openSync === "function") {
+      setIfMutable(
+        target,
+        "openSync",
+        wrapFsOpenPath(target.openSync)
+      );
+    }
+    if (typeof target.createReadStream === "function") {
+      setIfMutable(
+        target,
+        "createReadStream",
+        wrapFsPath(target.createReadStream, "read")
+      );
+    }
+    if (typeof target.createWriteStream === "function") {
+      setIfMutable(
+        target,
+        "createWriteStream",
+        wrapFsPath(target.createWriteStream, "write")
+      );
+    }
+    if (typeof target.cpSync === "function") {
+      setIfMutable(
+        target,
+        "cpSync",
+        wrapFsTwoPaths(target.cpSync, "read", "write")
+      );
+    }
+    const syncTwoPaths = [
+      { name: "copyFileSync", srcMode: "read", dstMode: "write" },
+      { name: "renameSync", srcMode: "write", dstMode: "write" },
+      { name: "linkSync", srcMode: "read", dstMode: "write" },
+      { name: "symlinkSync", srcMode: "read", dstMode: "write" }
+    ];
+    for (const { name, srcMode, dstMode } of syncTwoPaths) {
+      const key = String(name);
+      const orig = target[key];
+      if (typeof orig === "function") {
+        setIfMutable(
+          target,
+          key,
+          wrapFsTwoPaths(orig, srcMode, dstMode)
+        );
+      }
+    }
+    const callbackOnePath = [
+      "access",
+      "chmod",
+      "chown",
+      "lchmod",
+      "lchown",
+      "lstat",
+      "mkdir",
+      "mkdtemp",
+      "readdir",
+      "readFile",
+      "readlink",
+      "realpath",
+      "rmdir",
+      "rm",
+      "stat",
+      "truncate",
+      "unlink",
+      "utimes",
+      "lutimes",
+      "opendir",
+      "appendFile"
+    ];
+    const callbackWriteOnePath = /* @__PURE__ */ new Set([
+      "chmod",
+      "chown",
+      "lchmod",
+      "lchown",
+      "mkdir",
+      "mkdtemp",
+      "rmdir",
+      "rm",
+      "truncate",
+      "unlink",
+      "utimes",
+      "lutimes",
+      "appendFile"
+    ]);
+    for (const name of callbackOnePath) {
+      const key = String(name);
+      const orig = target[key];
+      if (typeof orig === "function") {
+        setIfMutable(
+          target,
+          key,
+          wrapFsPath(
+            orig,
+            callbackWriteOnePath.has(key) ? "write" : "read"
+          )
+        );
+      }
+    }
+    if (typeof target.writeFile === "function") {
+      const wrapped = wrapFsWriteGuard(target.writeFile);
+      setIfMutable(target, "writeFile", wrapFsPath(wrapped, "write"));
+    }
+    if (typeof target.open === "function") {
+      setIfMutable(target, "open", wrapFsOpenPath(target.open));
+    }
+    if (typeof target.cp === "function") {
+      setIfMutable(
+        target,
+        "cp",
+        wrapFsTwoPaths(target.cp, "read", "write")
+      );
+    }
+    const callbackTwoPaths = [
+      { name: "copyFile", srcMode: "read", dstMode: "write" },
+      { name: "rename", srcMode: "write", dstMode: "write" },
+      { name: "link", srcMode: "read", dstMode: "write" },
+      { name: "symlink", srcMode: "read", dstMode: "write" }
+    ];
+    for (const { name, srcMode, dstMode } of callbackTwoPaths) {
+      const key = String(name);
+      const orig = target[key];
+      if (typeof orig === "function") {
+        setIfMutable(
+          target,
+          key,
+          wrapFsTwoPaths(orig, srcMode, dstMode)
+        );
+      }
+    }
+  }
+  const promisesOnePath = [
+    "access",
+    "chmod",
+    "chown",
+    "lchmod",
+    "lchown",
+    "lstat",
+    "mkdir",
+    "mkdtemp",
+    "readdir",
+    "readFile",
+    "readlink",
+    "realpath",
+    "rmdir",
+    "rm",
+    "stat",
+    "truncate",
+    "unlink",
+    "utimes",
+    "lutimes",
+    "opendir",
+    "appendFile"
+  ];
+  const promisesWriteOnePath = /* @__PURE__ */ new Set([
+    "chmod",
+    "chown",
+    "lchmod",
+    "lchown",
+    "mkdir",
+    "mkdtemp",
+    "rmdir",
+    "rm",
+    "truncate",
+    "unlink",
+    "utimes",
+    "lutimes",
+    "appendFile"
+  ]);
+  for (const promises of promiseTargets) {
+    for (const name of promisesOnePath) {
+      const orig = promises[name];
+      if (typeof orig === "function") {
+        setIfMutable(
+          promises,
+          name,
+          wrapFsPath(
+            orig,
+            promisesWriteOnePath.has(name) ? "write" : "read"
+          )
+        );
+      }
+    }
+    if (typeof promises.writeFile === "function") {
+      const wrapped = wrapFsWriteGuard(promises.writeFile);
+      setIfMutable(promises, "writeFile", wrapFsPath(wrapped, "write"));
+    }
+    if (typeof promises.open === "function") {
+      setIfMutable(promises, "open", wrapFsOpenPath(promises.open));
+    }
+    if (typeof promises.cp === "function") {
+      setIfMutable(
+        promises,
+        "cp",
+        wrapFsTwoPaths(promises.cp, "read", "write")
+      );
+    }
+    const promisesTwoPaths = [
+      { name: "copyFile", srcMode: "read", dstMode: "write" },
+      { name: "rename", srcMode: "write", dstMode: "write" },
+      { name: "link", srcMode: "read", dstMode: "write" },
+      { name: "symlink", srcMode: "read", dstMode: "write" }
+    ];
+    for (const { name, srcMode, dstMode } of promisesTwoPaths) {
+      const orig = promises[name];
+      if (typeof orig === "function") {
+        setIfMutable(
+          promises,
+          name,
+          wrapFsTwoPaths(orig, srcMode, dstMode)
+        );
+      }
+    }
+  }
+}
+function installMobileFsShim(workspaceRoot) {
+  if (!workspaceRoot || typeof workspaceRoot !== "string") {
+    throw new Error(
+      "mobile-fs-shim: installMobileFsShim() requires a non-empty workspaceRoot string"
+    );
+  }
+  const canonical = nodePath2.resolve(workspaceRoot);
+  if (_installed) {
+    if (_workspaceRoot === canonical) {
+      return;
+    }
+    throw new Error(
+      `mobile-fs-shim: already installed with root "${_workspaceRoot}"; attempted re-install with "${canonical}" is not allowed`
+    );
+  }
+  _workspaceRoot = canonical;
+  _workspaceRootReal = realpathIfPossible(canonical);
+  _readOnlyRoots = envReadOnlyRoots().filter(
+    (root) => !isInsideRoot(root, canonical)
+  );
+  _readOnlyRootReals = _readOnlyRoots.map((root) => realpathIfPossible(root));
+  _installed = true;
+  globalThis.__ELIZA_MOBILE_FS_RESOLVE__ = resolveSandboxed;
+  patchFsModule();
+  installRequireGuard();
+  if (!process.env.MOBILE_WORKSPACE_ROOT) {
+    process.env.MOBILE_WORKSPACE_ROOT = canonical;
+  }
+}
+
+export {
+  wrapMobileFsPath,
+  wrapMobileFsOpen,
+  wrapMobileFsTwoPaths,
+  sandboxedPath,
+  isMobileFsShimInstalled,
+  getMobileWorkspaceRoot,
+  installMobileFsShim
+};

package/dist/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};