asaihost-nodejs 0.0.9 → 0.0.11

package/dist/asaihost-nodejs.es.js

@@ -50,7 +50,7 @@ import {
   secureCompare,
   validatePasswordChange,
   verifyPassword
-} from "./chunk-OTL2B4WS.es.js";
+} from "./chunk-3E4Y5ATG.es.js";
 import {
   USER_LV,
   applySecretsToHostConfig,
@@ -62,20 +62,21 @@ import {
   resolveHttpsCertFromPaths,
   stripForbiddenSecretsFromHostConfig,
   validateAsaiSecrets
-} from "./chunk-5WJQD4RZ.es.js";
+} from "./chunk-UKZ3DP37.es.js";
 import {
   getDefaultResetPassword,
   getPasswordPolicy,
   getPermissionThreshold,
   getPublicSecurityConfig,
   getUserLevelConfigSync,
+  getUserStoreConfig,
   isPasswordExpired,
   isValidUserLv,
   loadUserLevelConfig,
   resolveRoleForLevel,
   saveUserLevelConfig,
   validatePasswordWithPolicy
-} from "./chunk-BOIRAQXE.es.js";
+} from "./chunk-M3NURHGU.es.js";
 import {
   getDataServerForAsDb
 } from "./chunk-ZQBHJRAO.es.js";
@@ -993,19 +994,24 @@ function terminateWs(wsclient) {
   }
 }
 __name(terminateWs, "terminateWs");
-async function clearStaleWsIfDead($asai, hostdir, us, existingWs) {
+async function clearStaleWsIfDead($asai, hostdir, us, existingWs, timeoutMs) {
   if (!us || us === "asai") return true;
   const map = $asai.connectionsws?.[hostdir];
   if (!existingWs) {
     if (map?.[us]) delete map[us];
     return true;
   }
+  if (existingWs._asaiKicked) {
+    terminateWs(existingWs);
+    if (map?.[us] === existingWs) delete map[us];
+    return true;
+  }
   if (!isWsStillActive(existingWs)) {
     terminateWs(existingWs);
     if (map?.[us] === existingWs) delete map[us];
     return true;
   }
-  const alive = await probeWsAlive($asai, existingWs);
+  const alive = await probeWsAlive($asai, existingWs, timeoutMs);
   if (alive) return false;
   terminateWs(existingWs);
   if (map?.[us] === existingWs) delete map[us];
@@ -1025,22 +1031,38 @@ function getWsUserinfo(req, $asai) {
 }
 __name(getWsUserinfo, "getWsUserinfo");
 function listOnlineWsUsers($asai, hostdir) {
+  return listOnlineWsEntries($asai, hostdir).map((e) => e.us);
+}
+__name(listOnlineWsUsers, "listOnlineWsUsers");
+function listOnlineWsEntries($asai, hostdir) {
   const users = [];
+  const seen = /* @__PURE__ */ new Set();
   const map = $asai.connectionsws || {};
   const dirs = hostdir ? [hostdir] : Object.keys(map);
   for (const dir of dirs) {
     for (const [us, ws2] of Object.entries(map[dir] || {})) {
       if (!us || us === "asai") continue;
       if (isWsStillActive(ws2)) {
-        users.push(us);
+        if (seen.has(us)) continue;
+        seen.add(us);
+        const rawLv = ws2?.Userinfo?.[1];
+        if (rawLv === "" || rawLv == null) {
+          users.push({ us, lv: null });
+        } else {
+          const lvNum = Number(rawLv);
+          users.push({
+            us,
+            lv: Number.isFinite(lvNum) ? lvNum : null
+          });
+        }
       } else if (map[dir]?.[us] === ws2) {
         delete map[dir][us];
       }
     }
   }
-  return [...new Set(users)];
+  return users;
 }
-__name(listOnlineWsUsers, "listOnlineWsUsers");
+__name(listOnlineWsEntries, "listOnlineWsEntries");
 function isUserOnlineOnWs($asai, us, hostdir) {
   if (!us || us === "asai") return false;
   const map = $asai.connectionsws || {};
@@ -1054,19 +1076,73 @@ function isUserOnlineOnWs($asai, us, hostdir) {
   return false;
 }
 __name(isUserOnlineOnWs, "isUserOnlineOnWs");
-function kickUserWs($asai, us, hostdir) {
+async function kickUserWs($asai, us, hostdir) {
   if (!us || us === "asai") return;
   const map = $asai.connectionsws || {};
   const dirs = hostdir ? [hostdir] : Object.keys(map);
+  const waits = [];
   for (const dir of dirs) {
     const ws2 = map[dir]?.[us];
     if (!ws2) continue;
+    if (map[dir]?.[us] === ws2) delete map[dir][us];
     try {
-      ws2.close();
+      ws2._asaiKicked = Date.now();
     } catch {
     }
-    if (map[dir]?.[us] === ws2) delete map[dir][us];
+    waits.push(
+      new Promise((resolve6) => {
+        let done = false;
+        const finish = /* @__PURE__ */ __name(() => {
+          if (done) return;
+          done = true;
+          try {
+            ws2.off?.("close", finish);
+          } catch {
+          }
+          resolve6();
+        }, "finish");
+        try {
+          ws2.once?.("close", finish);
+        } catch {
+        }
+        const payload = JSON.stringify({
+          ty: "publish/web",
+          db: {
+            exit: 1,
+            type: "err",
+            lang: "forcedout",
+            langpm: `${us}`,
+            con: `${us} forced out by another login`
+          }
+        });
+        const hardClose = /* @__PURE__ */ __name(() => {
+          try {
+            if (typeof ws2.terminate === "function") ws2.terminate();
+            else ws2.close();
+          } catch {
+            try {
+              ws2.close();
+            } catch {
+            }
+          }
+        }, "hardClose");
+        try {
+          ws2.send(payload, () => {
+            hardClose();
+            finish();
+          });
+        } catch {
+          hardClose();
+          finish();
+        }
+        setTimeout(() => {
+          hardClose();
+          finish();
+        }, 150);
+      })
+    );
   }
+  if (waits.length) await Promise.all(waits);
 }
 __name(kickUserWs, "kickUserWs");
 async function removeSessionOnWsClose($asai, us, token) {
@@ -1105,27 +1181,31 @@ async function isOkWs($asai, hostdir, ws2, _req, hostcfg) {
   if (us !== "asai" && $asai.connectionsws[hostdir]?.[us]) {
     const existingWs = $asai.connectionsws[hostdir][us];
     if (existingWs?.Userinfo?.[2] === tk) {
-      if (isWsStillActive(existingWs)) {
-        rejectIncomingWs(ws2, {
-          lang: "pageworking",
-          langpm: `${us}`,
-          con: `${us} page already running`
-        });
-        return false;
-      }
-      try {
-        existingWs.close();
-      } catch {
+      if (!isWsStillActive(existingWs)) {
+        try {
+          existingWs.close();
+        } catch {
+        }
+        delete $asai.connectionsws[hostdir][us];
+        return true;
       }
-      delete $asai.connectionsws[hostdir][us];
-      return true;
+      const cleared2 = await clearStaleWsIfDead($asai, hostdir, us, existingWs, 800);
+      if (cleared2) return true;
+      rejectIncomingWs(ws2, {
+        lang: "pageworking",
+        langpm: `${us}`,
+        con: `${us} page already running`,
+        online: listOnlineWsEntries($asai, hostdir)
+      });
+      return false;
     }
     const cleared = await clearStaleWsIfDead($asai, hostdir, us, existingWs);
     if (!cleared) {
       rejectIncomingWs(ws2, {
         lang: "logged",
         langpm: `${us}`,
-        con: `${us} logged in!`
+        con: `${us} logged in!`,
+        online: listOnlineWsEntries($asai, hostdir)
       });
       return false;
     }
@@ -1137,19 +1217,22 @@ async function isOkWs($asai, hostdir, ws2, _req, hostcfg) {
       (item) => item.Userinfo?.[2] === tk && item.Userinfo?.[0] !== us
     );
     const maxOnline = hostcfg.maxonline || 100;
+    const online = listOnlineWsEntries($asai, hostdir);
     if (sameTkWs) {
       rejectIncomingWs(ws2, {
         lang: "loggedsametk",
         langpm: `${us}(${sameTkWs.Userinfo[0]})`,
-        con: `${us}(${sameTkWs.Userinfo[0]}) logged in!`
+        con: `${us}(${sameTkWs.Userinfo[0]}) logged in!`,
+        online
       });
       return false;
     }
-    if (Object.keys(connections).length >= maxOnline) {
+    if (online.length >= maxOnline) {
       rejectIncomingWs(ws2, {
         lang: "maxlogged",
         langpm: `${maxOnline}`,
-        con: `max ${maxOnline} users online!`
+        con: `max ${maxOnline} users online!`,
+        online
       });
       return false;
     }
@@ -1533,11 +1616,11 @@ function createSkipChecker($asai) {
   }
   if (exact.size === 0 && prefixes.length === 0) return () => false;
   return (url) => {
-    const path8 = normalizeRequestPath(url);
-    if (!path8) return false;
-    if (exact.has(path8)) return true;
+    const path9 = normalizeRequestPath(url);
+    if (!path9) return false;
+    if (exact.has(path9)) return true;
     for (let i = 0; i < prefixes.length; i++) {
-      if (path8.startsWith(prefixes[i])) return true;
+      if (path9.startsWith(prefixes[i])) return true;
     }
     return false;
   };
@@ -2424,7 +2507,7 @@ async function attachServerUserLevel(req, $asai) {
   if (!Array.isArray(userinfo) || !userinfo[0]) return;
   const us = String(userinfo[0]);
   try {
-    const { createUserStore: createUserStore2 } = await import("./user-store-FXD2N55G.es.js");
+    const { createUserStore: createUserStore2 } = await import("./user-store-ZI67TXSI.es.js");
     const user = await createUserStore2($asai).findByUsername(us);
     if (user && user.status === "active") {
       req._serverUser = { us: user.us, lv: user.lv, status: user.status };
@@ -2455,11 +2538,11 @@ function getSecurityConfig($asai) {
   return $asai?.hostconfig?.security || {};
 }
 __name(getSecurityConfig, "getSecurityConfig");
-function pathMatchesPattern(path8, pattern) {
+function pathMatchesPattern(path9, pattern) {
   if (pattern.endsWith("*")) {
-    return path8.startsWith(pattern.slice(0, -1));
+    return path9.startsWith(pattern.slice(0, -1));
   }
-  return path8 === pattern;
+  return path9 === pattern;
 }
 __name(pathMatchesPattern, "pathMatchesPattern");
 function isAuthSkipped($asai, pathname) {
@@ -4066,6 +4149,37 @@ async function purgeOfflineSessions($asai, hostdir, store) {
 __name(purgeOfflineSessions, "purgeOfflineSessions");
 
 // src/sysserver/api/login/index.ts
+import fs9 from "fs";
+import path4 from "path";
+async function resolveUserLv($asai, store, us, wsLv) {
+  if (!us) return null;
+  try {
+    const user = await store.findByUsername(us);
+    if (user && user.lv != null && Number.isFinite(Number(user.lv))) {
+      return Number(user.lv);
+    }
+  } catch {
+  }
+  try {
+    const cfg = getUserStoreConfig($asai);
+    const dir = String(cfg?.opt?.dir || "");
+    if (dir) {
+      const base = path4.isAbsolute(dir) ? dir : path4.join(process.cwd(), dir);
+      const safeUs = us.replace(/[\\/:*?"<>|]/g, "");
+      const file = path4.join(base, "json", `${safeUs}.json`);
+      if (safeUs && fs9.existsSync(file)) {
+        const raw = JSON.parse(fs9.readFileSync(file, "utf8"));
+        const lv = Number(raw?.lv);
+        if (Number.isFinite(lv)) return lv;
+      }
+    }
+  } catch {
+  }
+  if (wsLv === null || wsLv === void 0 || wsLv === "") return null;
+  const n = Number(wsLv);
+  return Number.isFinite(n) ? n : null;
+}
+__name(resolveUserLv, "resolveUserLv");
 function getSecurity($asai) {
   return $asai?.hostconfig?.security || {};
 }
@@ -4229,10 +4343,7 @@ var login_default = /* @__PURE__ */ __name(($asai) => {
         if (hostcfg.ckws) {
           const existingWs = $asai.connectionsws?.[hostdir]?.[us];
           if (existingWs) {
-            const cleared = await clearStaleWsIfDead($asai, hostdir, us, existingWs);
-            if (!cleared) {
-              kickUserWs($asai, us, hostdir);
-            }
+            await clearStaleWsIfDead($asai, hostdir, us, existingWs);
           }
         }
         const quotaCheck = await canLogin($asai, us, hostdir);
@@ -4279,6 +4390,56 @@ var login_default = /* @__PURE__ */ __name(($asai) => {
         return sendFail(res, err?.message || err, opt);
       }
     }
+    if (url.startsWith("/api/user/login/force/")) {
+      try {
+        const us = sanitizeString(String(req?.Userinfo?.[0] || ""), 64);
+        if (!us) return sendErr(res, "AUTH_MISSING", void 0, opt);
+        const myLv = Number(req?.Userinfo?.[1] ?? 0);
+        const targetUs = sanitizeString(String(body?.targetUs || body?.us || ""), 64);
+        const kicked = [];
+        if (isUserOnlineOnWs($asai, us, hostdir)) {
+          await kickUserWs($asai, us, hostdir);
+          kicked.push(us);
+        }
+        const onlineRaw = listOnlineWsEntries($asai, hostdir).filter((e) => e.us !== us);
+        const online = await Promise.all(
+          onlineRaw.map(async (e) => ({
+            us: e.us,
+            lv: await resolveUserLv($asai, store, e.us, e.lv)
+          }))
+        );
+        const candidates = targetUs ? online.filter((e) => e.us === targetUs) : online;
+        for (const entry of candidates) {
+          const entryLv = entry.lv == null ? NaN : Number(entry.lv);
+          if (!Number.isFinite(entryLv) || myLv < entryLv) {
+            if (targetUs) {
+              return sendErr(res, "AUTH_FORBIDDEN", void 0, opt);
+            }
+            continue;
+          }
+          await kickUserWs($asai, entry.us, hostdir);
+          kicked.push(entry.us);
+        }
+        if (!kicked.length && online.length) {
+          return sendErr(res, "AUTH_FORBIDDEN", void 0, opt);
+        }
+        logSecurityEvent($asai, {
+          type: "AUTH_SUCCESS",
+          path: url,
+          method: "POST",
+          user: us,
+          ip,
+          detail: `force_login_kick:${kicked.join(",") || "none"}`
+        });
+        return sendSuccess(
+          res,
+          { ok: true, us, kicked, online: listOnlineWsEntries($asai, hostdir) },
+          opt
+        );
+      } catch (err) {
+        return sendFail(res, err?.message || err, opt);
+      }
+    }
     if (url.startsWith("/api/user/login/admin/kick/")) {
       if (!await checkAdmin(req, url, getPermissionThreshold($asai, "adminWrite"))) {
         return sendErr(res, "AUTH_FORBIDDEN", void 0, opt);
@@ -4292,7 +4453,7 @@ var login_default = /* @__PURE__ */ __name(($asai) => {
         if (!isSessionUserOnline($asai, target.us, hostdir)) {
           return sendErr(res, "SESSION_NOT_ONLINE", void 0, opt);
         }
-        kickUserWs($asai, target.us, hostdir);
+        await kickUserWs($asai, target.us, hostdir);
         await store.removeSession(sessionId);
         const operator = String(req?.Userinfo?.[0] || "");
         await logSessionTerminate($asai, {
@@ -4491,6 +4652,39 @@ var login_default = /* @__PURE__ */ __name(($asai) => {
       await loadUserLevelConfig($asai);
       return sendSuccess(res, getPublicSecurityConfig($asai, lang), opt);
     }
+    if (url.startsWith("/api/user/login/online/")) {
+      try {
+        const us = sanitizeString(String(req?.Userinfo?.[0] || ""), 64);
+        if (!us) return sendErr(res, "AUTH_MISSING", void 0, opt);
+        const rawOnline = listOnlineWsEntries($asai, hostdir);
+        const online = await Promise.all(
+          rawOnline.map(async (e) => ({
+            us: e.us,
+            lv: await resolveUserLv($asai, store, e.us, e.lv)
+          }))
+        );
+        const rawMy = req?.Userinfo?.[1];
+        const wsMyLv = rawMy === null || rawMy === void 0 || rawMy === "" ? null : Number(rawMy);
+        const myLvOut = await resolveUserLv(
+          $asai,
+          store,
+          us,
+          Number.isFinite(wsMyLv) ? wsMyLv : null
+        );
+        return sendSuccess(
+          res,
+          {
+            us,
+            lv: myLvOut,
+            online,
+            maxonline: $asai.getHost?.(hostdir)?.maxonline ?? 100
+          },
+          opt
+        );
+      } catch (err) {
+        return sendFail(res, err?.message || err, opt);
+      }
+    }
     if (url.startsWith("/api/user/login/admin/levels/")) {
       if (!await checkAdmin(req, url, getPermissionThreshold($asai, "adminRead"))) {
         return sendErr(res, "AUTH_FORBIDDEN", void 0, opt);
@@ -4613,10 +4807,10 @@ var As_default = {
     return relativePath;
   },
   //创建多层文件夹 同步
-  ensureDir(fs11, relativePath) {
+  ensureDir(fs12, relativePath) {
     const absPathDir = this.toDirPath(relativePath);
     const absPath = this.toAbsolutePath(relativePath);
-    if (!fs11.existsSync(absPath)) {
+    if (!fs12.existsSync(absPath)) {
       let pathTmp = "";
       absPathDir.split("/").forEach((el) => {
         if (el) {
@@ -4624,8 +4818,8 @@ var As_default = {
             pathTmp += "/";
           }
           pathTmp += el;
-          if (!fs11.existsSync(pathTmp)) {
-            if (!fs11.mkdirSync(pathTmp, { recursive: true })) {
+          if (!fs12.existsSync(pathTmp)) {
+            if (!fs12.mkdirSync(pathTmp, { recursive: true })) {
               return absPath;
             }
           }
@@ -4634,10 +4828,10 @@ var As_default = {
     }
     return absPath;
   },
-  makeDir(fs11, filePaths) {
+  makeDir(fs12, filePaths) {
     return new Promise((resolve6, reject) => {
       try {
-        const newPath = this.ensureDir(fs11, filePaths);
+        const newPath = this.ensureDir(fs12, filePaths);
         resolve6(newPath);
       } catch (err) {
         reject(err);
@@ -5234,7 +5428,7 @@ var AsDb_default = /* @__PURE__ */ __name(($asai, cfg) => {
 }, "default");
 
 // src/sysserver/lib/common/reqWork.ts
-import * as path4 from "path";
+import * as path5 from "path";
 var reqWork_default = /* @__PURE__ */ __name(($asai) => {
   function hostDefault2(mod) {
     if (mod && typeof mod === "object" && "default" in mod) {
@@ -5250,28 +5444,29 @@ var reqWork_default = /* @__PURE__ */ __name(($asai) => {
       throw new Error("Missing path");
     }
     const decoded = decodeURIComponent(String(rawPath));
-    if (path4.isAbsolute(decoded)) {
-      return path4.normalize(decoded);
+    if (decoded.includes("\0")) {
+      throw new Error("Invalid path");
     }
-    const rel = decoded.replace(/^\.(\/)?/, "");
-    const serverRoot = $asai?.serverRoot;
-    if (serverRoot && rel) {
-      const absRoot = path4.resolve(serverRoot);
-      const abs = path4.resolve(absRoot, rel);
-      const relCheck = path4.relative(absRoot, abs);
-      if (relCheck === "" || !relCheck.startsWith("..") && !path4.isAbsolute(relCheck)) {
-        return abs;
-      }
+    const serverRoot = path5.resolve($asai?.serverRoot || process.cwd() || ".");
+    const cleaned = String(decoded).replace(/\\/g, "/").trim();
+    if (path5.isAbsolute(cleaned) || /^[a-zA-Z]:/.test(cleaned) || cleaned.startsWith("//")) {
+      return path5.normalize(cleaned);
     }
+    const absTarget = path5.resolve(serverRoot, cleaned.replace(/^\.\//, ""));
     const roots = $asai?.asaihost?.getHostAllowedRoots?.($asai?.hostconfig) || [];
-    if (!roots.length) {
-      const fallback = $asai?.serverRoot || process.cwd();
-      if (fallback) roots.push(fallback);
+    const allow = /* @__PURE__ */ new Set();
+    for (const r of roots) {
+      if (r) allow.add(path5.resolve(r));
     }
-    if (!$asai?.asaihost?.resolvePathUnderRoots) {
-      throw new Error("Path resolver unavailable");
+    allow.add(serverRoot);
+    allow.add(path5.resolve(serverRoot, ".."));
+    for (const root of allow) {
+      const rel = path5.relative(root, absTarget);
+      if (rel === "" || !rel.startsWith("..") && !path5.isAbsolute(rel)) {
+        return absTarget;
+      }
     }
-    return $asai.asaihost.resolvePathUnderRoots(decoded, roots);
+    throw new Error("Path not allowed");
   }
   __name(getPathFromOpt, "getPathFromOpt");
   function sendSuccess(res, data, opt) {
@@ -5319,18 +5514,18 @@ __export(AsFs_exports, {
   write: () => write,
   writeJson: () => writeJson
 });
-import fs9 from "fs/promises";
-import path5 from "path";
+import fs10 from "fs/promises";
+import path6 from "path";
 async function ensureFile(filePath) {
-  const normalized = path5.normalize(filePath);
-  await fs9.mkdir(path5.dirname(normalized), { recursive: true });
-  const fh = await fs9.open(normalized, "a");
+  const normalized = path6.normalize(filePath);
+  await fs10.mkdir(path6.dirname(normalized), { recursive: true });
+  const fh = await fs10.open(normalized, "a");
   await fh.close();
 }
 __name(ensureFile, "ensureFile");
 async function pathExists(filePath) {
   try {
-    await fs9.access(path5.normalize(filePath));
+    await fs10.access(path6.normalize(filePath));
     return true;
   } catch {
     return false;
@@ -5338,7 +5533,7 @@ async function pathExists(filePath) {
 }
 __name(pathExists, "pathExists");
 async function readJson(filePath) {
-  const raw = await fs9.readFile(path5.normalize(filePath), "utf8");
+  const raw = await fs10.readFile(path6.normalize(filePath), "utf8");
   return JSON.parse(raw);
 }
 __name(readJson, "readJson");
@@ -5349,34 +5544,34 @@ function resolvePathUnderBase(baseDir, relPath) {
   if (relPath.includes("\0")) {
     throw new Error("Invalid path");
   }
-  const base = path5.resolve(baseDir);
-  const target = path5.resolve(base, relPath.replace(/\\/g, "/"));
-  const rel = path5.relative(base, target);
-  if (rel.startsWith("..") || path5.isAbsolute(rel)) {
+  const base = path6.resolve(baseDir);
+  const target = path6.resolve(base, relPath.replace(/\\/g, "/"));
+  const rel = path6.relative(base, target);
+  if (rel.startsWith("..") || path6.isAbsolute(rel)) {
     throw new Error("Path not allowed");
   }
   return target;
 }
 __name(resolvePathUnderBase, "resolvePathUnderBase");
 async function readLogDir(dir) {
-  const resolved = path5.resolve(dir);
-  const stats = await fs9.stat(resolved);
+  const resolved = path6.resolve(dir);
+  const stats = await fs10.stat(resolved);
   if (!stats.isDirectory()) {
     throw new Error("Not a directory");
   }
-  const dirName = path5.basename(resolved);
-  const entries = await fs9.readdir(resolved, { withFileTypes: true });
+  const dirName = path6.basename(resolved);
+  const entries = await fs10.readdir(resolved, { withFileTypes: true });
   const children = await Promise.all(
     entries.map(async (entry) => {
-      const fullPath = path5.join(resolved, entry.name);
-      const st = await fs9.stat(fullPath);
+      const fullPath = path6.join(resolved, entry.name);
+      const st = await fs10.stat(fullPath);
       const dot = entry.name.lastIndexOf(".");
       const type = entry.isDirectory() ? "dir" : dot > -1 ? entry.name.substring(dot) : "file";
       return {
         name: entry.name,
         size: st.size,
         time: st.mtime.toISOString(),
-        path: path5.normalize(fullPath),
+        path: path6.normalize(fullPath),
         type,
         created: st.birthtime.toISOString(),
         permissions: st.mode.toString(8).slice(-3)
@@ -5387,7 +5582,7 @@ async function readLogDir(dir) {
     name: dirName,
     size: stats.size,
     time: stats.mtime.toISOString(),
-    path: path5.normalize(resolved),
+    path: path6.normalize(resolved),
     type: "dir",
     created: stats.birthtime.toISOString(),
     permissions: stats.mode.toString(8).slice(-3),
@@ -5397,7 +5592,7 @@ async function readLogDir(dir) {
 __name(readLogDir, "readLogDir");
 async function removeFile(filePath) {
   try {
-    await fs9.unlink(path5.normalize(filePath));
+    await fs10.unlink(path6.normalize(filePath));
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
   }
@@ -5405,13 +5600,13 @@ async function removeFile(filePath) {
 __name(removeFile, "removeFile");
 var remove = removeFile;
 async function write(filePath, content) {
-  const normalized = path5.normalize(filePath);
-  await fs9.mkdir(path5.dirname(normalized), { recursive: true });
-  await fs9.writeFile(normalized, content, "utf8");
+  const normalized = path6.normalize(filePath);
+  await fs10.mkdir(path6.dirname(normalized), { recursive: true });
+  await fs10.writeFile(normalized, content, "utf8");
 }
 __name(write, "write");
 async function read(filePath) {
-  return fs9.readFile(path5.normalize(filePath), "utf8");
+  return fs10.readFile(path6.normalize(filePath), "utf8");
 }
 __name(read, "read");
 async function writeJson(filePath, data) {
@@ -5447,7 +5642,7 @@ __export(common_exports, {
   toSetObject: () => toSetObject,
   toWherePairs: () => toWherePairs
 });
-import * as path6 from "path";
+import * as path7 from "path";
 function promisifySqlDb(query, sql) {
   return new Promise((resolve6, reject) => {
     query(sql, (err, result) => {
@@ -5512,11 +5707,11 @@ function toInsertRows(sql) {
 }
 __name(toInsertRows, "toInsertRows");
 function isPathInside(baseDir, targetPath) {
-  const base = path6.resolve(baseDir);
-  const target = path6.resolve(targetPath);
-  const relative5 = path6.relative(base, target);
+  const base = path7.resolve(baseDir);
+  const target = path7.resolve(targetPath);
+  const relative5 = path7.relative(base, target);
   if (!relative5) return true;
-  return !relative5.startsWith("..") && !path6.isAbsolute(relative5);
+  return !relative5.startsWith("..") && !path7.isAbsolute(relative5);
 }
 __name(isPathInside, "isPathInside");
 function joinTablePath(table, ...segments) {
@@ -5697,8 +5892,8 @@ var Sql_default = {
 };
 
 // src/sysserver/db/src/file/Index.ts
-import * as fs10 from "fs";
-import * as path7 from "path";
+import * as fs11 from "fs";
+import * as path8 from "path";
 function dbDriver(opt = {}) {
   const { Sql, DbCommon } = opt;
   const { isPathInside: isPathInside2, joinTablePath: joinTablePath2 } = DbCommon;
@@ -5712,20 +5907,20 @@ function dbDriver(opt = {}) {
       this.fileDel = (config.del || 0) !== 0;
       this.createDir = config.create || false;
       const root = config.$asai?.serverRoot || getPrimaryServerRoot();
-      this.baseDirAbs = path7.resolve(root, config.dir);
+      this.baseDirAbs = path8.resolve(root, config.dir);
     }
     dbLog(...args) {
       (this.config?.$asai?.$log || console.log)("FILE", ...args);
     }
     checkFile(file) {
-      return fs10.existsSync(this.getAbsPath(file, false));
+      return fs11.existsSync(this.getAbsPath(file, false));
     }
     /** 解析相对路径并限制在数据根目录内，防止路径穿越（跨平台） */
     resolvePath(relPath) {
       if (!relPath) {
         return this.baseDirAbs;
       }
-      const abs = path7.isAbsolute(relPath) ? path7.normalize(relPath) : path7.resolve(this.baseDirAbs, relPath);
+      const abs = path8.isAbsolute(relPath) ? path8.normalize(relPath) : path8.resolve(this.baseDirAbs, relPath);
       if (!isPathInside2(this.baseDirAbs, abs)) {
         throw new Error("Path not allowed");
       }
@@ -5739,15 +5934,15 @@ function dbDriver(opt = {}) {
       if (!relPath) {
         return "";
       }
-      return path7.isAbsolute(relPath) ? path7.relative(this.baseDirAbs, relPath) : relPath;
+      return path8.isAbsolute(relPath) ? path8.relative(this.baseDirAbs, relPath) : relPath;
     }
     ensureDir(relPath) {
       const relative5 = this.normalizeRelPath(relPath);
-      const dirPath = path7.dirname(relative5);
+      const dirPath = path8.dirname(relative5);
       const absDir = this.resolvePath(dirPath === "." ? "" : dirPath);
-      if (this.createDir && !fs10.existsSync(absDir)) {
+      if (this.createDir && !fs11.existsSync(absDir)) {
         this.dbLog("mkdir", "[MKDIR]", absDir);
-        fs10.mkdirSync(absDir, { recursive: true });
+        fs11.mkdirSync(absDir, { recursive: true });
       }
       return absDir;
     }
@@ -5763,34 +5958,34 @@ function dbDriver(opt = {}) {
     }
     deldir(relativePath) {
       const absPath = this.resolvePath(relativePath);
-      if (!fs10.existsSync(absPath)) {
+      if (!fs11.existsSync(absPath)) {
         return;
       }
       this.dbLog("delete", "[RMDIR]", absPath);
-      const entries = fs10.readdirSync(absPath, { withFileTypes: true });
+      const entries = fs11.readdirSync(absPath, { withFileTypes: true });
       for (const entry of entries) {
-        const current = path7.join(absPath, entry.name);
+        const current = path8.join(absPath, entry.name);
         if (entry.isDirectory()) {
-          this.deldir(path7.join(relativePath, entry.name));
+          this.deldir(path8.join(relativePath, entry.name));
         } else {
           this.dbLog("delete", "[UNLINK]", current);
-          fs10.unlinkSync(current);
+          fs11.unlinkSync(current);
         }
       }
-      fs10.rmdirSync(absPath);
+      fs11.rmdirSync(absPath);
     }
     getReadPath(file, sql) {
       const candidates = [];
       if (sql?.filename) {
-        candidates.push({ dir: path7.join(file, sql.filename) });
-        candidates.push({ dir: path7.join(file + ".delete" + this.fileExt, sql.filename) });
+        candidates.push({ dir: path8.join(file, sql.filename) });
+        candidates.push({ dir: path8.join(file + ".delete" + this.fileExt, sql.filename) });
       } else {
         candidates.push({ dir: file });
         candidates.push({ dir: file + this.fileExt + ".delete" });
       }
       for (const candidate of candidates) {
         const abs = this.getAbsPath(candidate.dir, false);
-        if (fs10.existsSync(abs)) {
+        if (fs11.existsSync(abs)) {
           return { path: abs, dir: candidate.dir };
         }
       }
@@ -5802,13 +5997,13 @@ function dbDriver(opt = {}) {
         return { path: "", dir: read2.dir };
       }
       if (sql?.filename) {
-        return { path: path7.dirname(read2.path), dir: path7.dirname(read2.dir) };
+        return { path: path8.dirname(read2.path), dir: path8.dirname(read2.dir) };
       }
       return { path: read2.path, dir: read2.dir };
     }
     getNewPath(file, sql) {
       if (sql?.filename) {
-        return this.getAbsPath(path7.join(file, sql.filename), true);
+        return this.getAbsPath(path8.join(file, sql.filename), true);
       }
       return this.getAbsPath(file, true);
     }
@@ -5816,7 +6011,7 @@ function dbDriver(opt = {}) {
       try {
         const filePath = sql?.type === "insert" ? this.getNewPath(file, sql) : this.getReadPath(file, sql).path || this.getNewPath(file, sql);
         this.dbLog("write", "[WRITE]", filePath);
-        fs10.writeFileSync(filePath, data, "utf8");
+        fs11.writeFileSync(filePath, data, "utf8");
         return "ok";
       } catch (e) {
         this.dbLog("write failed", "[WRITE ERROR]", e);
@@ -5830,7 +6025,7 @@ function dbDriver(opt = {}) {
           return { error: "empty" };
         }
         this.dbLog("read", "[READ]", read2.path);
-        const data = fs10.readFileSync(read2.path, { encoding }) || "";
+        const data = fs11.readFileSync(read2.path, { encoding }) || "";
         const fileName = this.fileExt && read2.dir.endsWith(this.fileExt) ? read2.dir : read2.dir + this.fileExt;
         return [{ data, file: fileName }];
       } catch (e) {
@@ -5847,12 +6042,12 @@ function dbDriver(opt = {}) {
         if (this.fileDel && sql?.deltrue) {
           const target = del.path + ".delete" + this.fileExt;
           this.dbLog("soft delete", "[SOFT DELETE]", `${del.path} -> ${target}`);
-          fs10.renameSync(del.path, target);
+          fs11.renameSync(del.path, target);
         } else if (sql?.filename) {
           this.deldir(del.dir);
         } else {
           this.dbLog("delete", "[DELETE]", del.path);
-          fs10.unlinkSync(del.path);
+          fs11.unlinkSync(del.path);
         }
         return "ok";
       } catch (e) {
@@ -5871,11 +6066,11 @@ function dbDriver(opt = {}) {
           const original = del.path.replace(new RegExp(`.delete${extPattern}$`), "");
           if (original !== del.path) {
             this.dbLog("restore", "[RESTORE]", `${del.path} -> ${original}`);
-            fs10.renameSync(del.path, original);
+            fs11.renameSync(del.path, original);
           }
         } else {
           this.dbLog("force delete", "[FORCE DELETE]", del.path);
-          fs10.unlinkSync(del.path);
+          fs11.unlinkSync(del.path);
         }
         return "ok";
       } catch (e) {
@@ -5889,7 +6084,7 @@ function dbDriver(opt = {}) {
         this.dbLog("list", "[LIST]", absDir);
         let entries;
         try {
-          entries = fs10.readdirSync(absDir, { withFileTypes: true });
+          entries = fs11.readdirSync(absDir, { withFileTypes: true });
         } catch {
           return sql?.list ? { open: [], delete: [] } : [];
         }
@@ -5901,9 +6096,9 @@ function dbDriver(opt = {}) {
           const isDelete = fileName.endsWith(deleteSuffix);
           const baseName = isDelete ? fileName.slice(0, -deleteSuffix.length) : fileName;
           if (this.fileExt && !baseName.endsWith(this.fileExt)) continue;
-          const fullPath = path7.join(absDir, fileName);
+          const fullPath = path8.join(absDir, fileName);
           try {
-            const data = fs10.readFileSync(fullPath, "utf8");
+            const data = fs11.readFileSync(fullPath, "utf8");
             const entryData = { data, file: baseName };
             if (isDelete) {
               if (sql?.list) result.delete.push(entryData);
@@ -6669,7 +6864,7 @@ var initAsaiHostNodejs2 = {
   createTransportDataHandler,
   wireTransportConnectionLogs
 };
-var PLUGIN_VERSION = true ? "0.0.9" : "0.0.1";
+var PLUGIN_VERSION = true ? "0.0.11" : "0.0.1";
 var index_default = initAsaiHostNodejs2;
 export {
   Index_default as AsaiCommon,