@glodon-aiot/bot-client-sdk 3.26.0-alpha.4 → 3.26.0-alpha.5

package/dist/es/builtinTools/browserRuntime/WorkspaceBashFs.mjs

@@ -0,0 +1,350 @@
+var s = (a, r, t) => new Promise((e, i) => {
+  var o = (d) => {
+    try {
+      u(t.next(d));
+    } catch (f) {
+      i(f);
+    }
+  }, c = (d) => {
+    try {
+      u(t.throw(d));
+    } catch (f) {
+      i(f);
+    }
+  }, u = (d) => d.done ? e(d.value) : Promise.resolve(d.value).then(o, c);
+  u((t = t.apply(a, r)).next());
+});
+import { readBytes as l } from "../../localFiles/tools/runtime.mjs";
+const v = {
+  ENOENT: "no such file or directory",
+  EEXIST: "file already exists",
+  EISDIR: "illegal operation on a directory",
+  ENOTDIR: "not a directory",
+  ENOTEMPTY: "directory not empty",
+  EACCES: "permission denied",
+  EPERM: "operation not permitted",
+  EINVAL: "invalid argument",
+  EIO: "i/o error"
+};
+function n(a, r, t) {
+  var i;
+  const e = new Error(`${a}: ${(i = v[a]) != null ? i : a}, ${r} '${t}'`);
+  return e.code = a, e;
+}
+function w(a) {
+  var r;
+  return a && typeof a == "object" ? String((r = a.name) != null ? r : "") : "";
+}
+function y(a) {
+  const r = typeof a == "string" ? a : a == null ? void 0 : a.encoding;
+  return (r != null ? r : "utf8").toLowerCase();
+}
+function E(a) {
+  let r = "";
+  for (let t = 0; t < a.length; t += 32768)
+    r += String.fromCharCode(...a.subarray(t, t + 32768));
+  return r;
+}
+function R(a, r) {
+  switch (r) {
+    case "binary":
+    case "latin1":
+    case "ascii":
+      return E(a);
+    case "base64":
+      return btoa(E(a));
+    case "hex":
+      return Array.from(a, (t) => t.toString(16).padStart(2, "0")).join("");
+    default:
+      return new TextDecoder().decode(a);
+  }
+}
+function m(a, r) {
+  var t;
+  if (typeof a != "string")
+    return a;
+  switch (r) {
+    case "binary":
+    case "latin1":
+    case "ascii":
+      return Uint8Array.from(a, (e) => e.charCodeAt(0) & 255);
+    case "base64":
+      return Uint8Array.from(atob(a), (e) => e.charCodeAt(0));
+    case "hex":
+      return Uint8Array.from((t = a.match(/../g)) != null ? t : [], (e) => parseInt(e, 16));
+    default:
+      return new TextEncoder().encode(a);
+  }
+}
+function h(a) {
+  const r = [];
+  for (const t of a.split("/"))
+    !t || t === "." || (t === ".." ? r.pop() : r.push(t));
+  return `/${r.join("/")}`;
+}
+class k {
+  constructor(r, t, e) {
+    this.adapter = r, this.root = t, this.sensitive = e;
+  }
+  relative(r) {
+    const t = h(r).slice(1);
+    return this.root ? t ? `${this.root}/${t}` : this.root : t;
+  }
+  shown(r) {
+    const t = this.relative(r);
+    return t ? `/${t}` : "/";
+  }
+  isRoot(r) {
+    return h(r) === "/";
+  }
+  guard(r, t, e) {
+    const i = this.relative(r);
+    if (this.sensitive.match(i, t))
+      throw n("EACCES", e, this.shown(r));
+    return i;
+  }
+  mapError(r, t, e) {
+    if (r && typeof r == "object" && typeof r.code == "string")
+      return r;
+    switch (w(r)) {
+      case "NotFoundError":
+        return n("ENOENT", t, this.shown(e));
+      case "TypeMismatchError":
+        return n(t === "open" || t === "write" ? "EISDIR" : "ENOTDIR", t, this.shown(e));
+      case "InvalidModificationError":
+        return n(t === "rm" ? "ENOTEMPTY" : "EEXIST", t, this.shown(e));
+      case "NotAllowedError":
+      case "SecurityError":
+      case "NoModificationAllowedError":
+        return n("EACCES", t, this.shown(e));
+      default:
+        return n("EIO", t, this.shown(e));
+    }
+  }
+  entry(r, t) {
+    return s(this, null, function* () {
+      try {
+        return yield this.adapter.stat(this.relative(r));
+      } catch (e) {
+        if (this.isRoot(r) && w(e) === "NotFoundError")
+          return {
+            name: this.root,
+            kind: "directory"
+          };
+        throw this.mapError(e, t, r);
+      }
+    });
+  }
+  ensureRoot() {
+    return s(this, null, function* () {
+      if (this.root)
+        try {
+          yield this.adapter.stat(this.root);
+        } catch (r) {
+          if (w(r) !== "NotFoundError")
+            throw r;
+          this.adapter.createDirectory && (yield this.adapter.createDirectory(this.root));
+        }
+    });
+  }
+  readFileBuffer(r) {
+    return s(this, null, function* () {
+      const t = this.guard(r, "read", "open");
+      if ((yield this.entry(r, "open")).kind !== "file")
+        throw n("EISDIR", "read", this.shown(r));
+      try {
+        return yield l(yield this.adapter.readFile(t));
+      } catch (i) {
+        throw this.mapError(i, "open", r);
+      }
+    });
+  }
+  readFile(r, t) {
+    return s(this, null, function* () {
+      return R(yield this.readFileBuffer(r), y(t));
+    });
+  }
+  writeFile(r, t, e) {
+    return s(this, null, function* () {
+      if (this.isRoot(r))
+        throw n("EISDIR", "open", this.shown(r));
+      const i = this.guard(r, "write", "open"), o = h(r).lastIndexOf("/") === 0;
+      try {
+        o && (yield this.ensureRoot()), yield this.adapter.writeFile(i, m(t, y(e)), {
+          createDirectories: !0
+        });
+      } catch (c) {
+        throw this.mapError(c, "open", r);
+      }
+    });
+  }
+  appendFile(r, t, e) {
+    return s(this, null, function* () {
+      let i = new Uint8Array();
+      (yield this.exists(r)) && (i = yield this.readFileBuffer(r));
+      const o = m(t, y(e)), c = new Uint8Array(i.byteLength + o.byteLength);
+      c.set(i), c.set(o, i.byteLength), yield this.writeFile(r, c);
+    });
+  }
+  exists(r) {
+    return s(this, null, function* () {
+      try {
+        return yield this.entry(r, "access"), !0;
+      } catch (t) {
+        return !1;
+      }
+    });
+  }
+  stat(r) {
+    return s(this, null, function* () {
+      var i, o;
+      const t = yield this.entry(r, "stat"), e = t.kind === "directory";
+      return {
+        isFile: !e,
+        isDirectory: e,
+        isSymbolicLink: !1,
+        mode: e ? 493 : 420,
+        size: (i = t.size) != null ? i : 0,
+        mtime: new Date((o = t.lastModified) != null ? o : 0)
+      };
+    });
+  }
+  lstat(r) {
+    return this.stat(r);
+  }
+  mkdir(r, t) {
+    return s(this, null, function* () {
+      if (!this.adapter.createDirectory)
+        throw n("EPERM", "mkdir", this.shown(r));
+      if (yield this.exists(r)) {
+        if (t != null && t.recursive)
+          return;
+        throw n("EEXIST", "mkdir", this.shown(r));
+      }
+      if (!(t != null && t.recursive)) {
+        const e = h(r), i = e.slice(0, e.lastIndexOf("/")) || "/";
+        if (!(yield this.exists(i)))
+          throw n("ENOENT", "mkdir", this.shown(r));
+      }
+      try {
+        yield this.adapter.createDirectory(this.relative(r));
+      } catch (e) {
+        throw this.mapError(e, "mkdir", r);
+      }
+    });
+  }
+  readdirWithFileTypes(r) {
+    return s(this, null, function* () {
+      if ((yield this.entry(r, "scandir")).kind !== "directory")
+        throw n("ENOTDIR", "scandir", this.shown(r));
+      let e;
+      try {
+        e = yield this.adapter.listEntries(this.relative(r));
+      } catch (i) {
+        if (this.isRoot(r) && w(i) === "NotFoundError")
+          return [];
+        throw this.mapError(i, "scandir", r);
+      }
+      return e.map((i) => ({
+        name: i.name,
+        isFile: i.kind === "file",
+        isDirectory: i.kind === "directory",
+        isSymbolicLink: !1
+      })).sort((i, o) => i.name < o.name ? -1 : i.name > o.name ? 1 : 0);
+    });
+  }
+  readdir(r) {
+    return s(this, null, function* () {
+      return (yield this.readdirWithFileTypes(r)).map((t) => t.name);
+    });
+  }
+  rm(r, t) {
+    return s(this, null, function* () {
+      if (this.isRoot(r))
+        throw n("EPERM", "rm", this.shown(r));
+      const e = this.guard(r, "write", "rm");
+      if (!(yield this.exists(r))) {
+        if (t != null && t.force)
+          return;
+        throw n("ENOENT", "rm", this.shown(r));
+      }
+      if (!this.adapter.remove)
+        throw n("EPERM", "rm", this.shown(r));
+      try {
+        yield this.adapter.remove(e, {
+          recursive: (t == null ? void 0 : t.recursive) === !0
+        });
+      } catch (i) {
+        throw this.mapError(i, "rm", r);
+      }
+    });
+  }
+  cp(r, t, e) {
+    return s(this, null, function* () {
+      if ((yield this.entry(r, "cp")).kind === "file") {
+        yield this.writeFile(t, yield this.readFileBuffer(r));
+        return;
+      }
+      if (!(e != null && e.recursive))
+        throw n("EISDIR", "cp", this.shown(r));
+      yield this.mkdir(t, {
+        recursive: !0
+      });
+      for (const o of yield this.readdir(r))
+        yield this.cp(`${h(r)}/${o}`, `${h(t)}/${o}`, e);
+    });
+  }
+  mv(r, t) {
+    return s(this, null, function* () {
+      if (this.isRoot(r) || this.isRoot(t))
+        throw n("EPERM", "rename", this.shown(r));
+      const e = this.guard(r, "write", "rename"), i = this.guard(t, "write", "rename");
+      if (!this.adapter.move)
+        throw n("EPERM", "rename", this.shown(r));
+      try {
+        yield this.adapter.move(e, i);
+      } catch (o) {
+        throw this.mapError(o, "rename", r);
+      }
+    });
+  }
+  resolvePath(r, t) {
+    return h(t.startsWith("/") ? t : `${r}/${t}`);
+  }
+  getAllPaths() {
+    return [];
+  }
+  chmod(r) {
+    return s(this, null, function* () {
+      yield this.entry(r, "chmod");
+    });
+  }
+  symlink(r, t) {
+    return s(this, null, function* () {
+      throw n("EPERM", "symlink", this.shown(t));
+    });
+  }
+  link(r, t) {
+    return s(this, null, function* () {
+      throw n("EPERM", "link", this.shown(t));
+    });
+  }
+  readlink(r) {
+    return s(this, null, function* () {
+      throw yield this.entry(r, "readlink"), n("EINVAL", "readlink", this.shown(r));
+    });
+  }
+  realpath(r) {
+    return s(this, null, function* () {
+      return yield this.entry(r, "realpath"), h(r);
+    });
+  }
+  utimes(r) {
+    return s(this, null, function* () {
+      yield this.entry(r, "utime");
+    });
+  }
+}
+export {
+  k as WorkspaceBashFs
+};

package/dist/es/builtinTools/browserRuntime/assets.mjs

@@ -0,0 +1,9 @@
+const o = "https://cv-cdn.obs.cn-north-4.myhuaweicloud.com/glodon/libs/", s = "3.6.0", n = `${o}just-bash/${s}/just-bash.mjs`, t = "314.0.7", _ = `${o}pyodide/${t}/`, c = ["numpy", "pandas", "matplotlib", "pillow", "lxml"];
+export {
+  o as CDN_LIBS_ROOT,
+  n as DEFAULT_BASH_MODULE_URL,
+  _ as DEFAULT_PYODIDE_INDEX_URL,
+  s as JUST_BASH_VERSION,
+  c as PYODIDE_PACKAGES,
+  t as PYODIDE_VERSION
+};

package/dist/es/builtinTools/browserRuntime/loadBash.mjs

@@ -0,0 +1,17 @@
+const n = /* @__PURE__ */ new Map();
+function i(t) {
+  return import(
+    /* @vite-ignore */
+    /* webpackIgnore: true */
+    t
+  );
+}
+function a(t) {
+  let e = n.get(t);
+  return e || (e = i(t).catch((o) => {
+    throw n.delete(t), o;
+  }), n.set(t, e)), e;
+}
+export {
+  a as loadBash
+};

package/dist/es/builtinTools/browserRuntime/pyodideRunner.py.mjs

@@ -0,0 +1,96 @@
+const n = `# 在 Pyodide 里按 python3 命令行的语义运行代码。由 pyodideWorker.js 加载，最后一个表达式 run 交给 JS 调用。
+# 解释器在多次命令之间复用，所以每次运行前恢复 sys.path、环境变量和工作目录，并丢掉工作区里的模块缓存。
+import io
+import os
+import runpy
+import sys
+import traceback
+
+ROOTS = ('/workspace',)
+BASE_PATH = list(sys.path)
+BASE_ENV = dict(os.environ)
+HOME = os.environ.get('HOME', '/home/pyodide')
+
+
+def _from_workspace(module):
+    path = getattr(module, '__file__', None) or ''
+    return any(path == root or path.startswith(root + '/') for root in ROOTS)
+
+
+def _reset():
+    for name, module in list(sys.modules.items()):
+        if _from_workspace(module):
+            del sys.modules[name]
+    sys.path[:] = BASE_PATH
+    os.environ.clear()
+    os.environ.update(BASE_ENV)
+    os.chdir(HOME)
+
+
+def _internal(frame):
+    name = frame.f_code.co_filename
+    return name == '<exec>' or name.endswith('/runpy.py')
+
+
+def _print_error(error):
+    tb = error.__traceback__
+    while tb is not None and _internal(tb.tb_frame):
+        tb = tb.tb_next
+    traceback.print_exception(type(error), error, tb)
+
+
+def _exit_code(value):
+    if value is None:
+        return 0
+    if isinstance(value, int):
+        return value & 0xFF
+    print(value, file=sys.stderr)
+    return 1
+
+
+def run(mode, target, argv, cwd, stdin):
+    _reset()
+    sys.argv = list(argv)
+    sys.stdin = io.TextIOWrapper(io.BytesIO(stdin.to_bytes()), encoding='utf-8', errors='replace')
+    try:
+        os.chdir(cwd)
+    except OSError:
+        os.chdir('/')
+    try:
+        if mode == 'c':
+            sys.path.insert(0, '')
+            exec(compile(target, '<string>', 'exec'), {'__name__': '__main__'})
+        elif mode == 'm':
+            sys.path.insert(0, os.getcwd())
+            runpy.run_module(target, run_name='__main__', alter_sys=True)
+        elif not os.path.isfile(target):
+            print(f"python3: can't open file '{target}': [Errno 2] No such file or directory", file=sys.stderr)
+            return 2
+        else:
+            sys.path.insert(0, os.path.dirname(target))
+            runpy.run_path(target, run_name='__main__')
+        return 0
+    except SystemExit as error:
+        return _exit_code(error.code)
+    except ModuleNotFoundError as error:
+        _print_error(error)
+        name = (error.name or '').split('.')[0]
+        if name:
+            print(
+                f'浏览器环境没有 {name}。这里只能用标准库和 {"、".join(PACKAGES)}，需要其他包请改用宿主环境。',
+                file=sys.stderr,
+            )
+        return 1
+    except BaseException as error:
+        _print_error(error)
+        return 1
+    finally:
+        sys.stdout.flush()
+        sys.stderr.flush()
+
+
+run
+`;
+export {
+  n as default
+};