asaihost-nodejs 0.0.8 → 0.0.10

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";
@@ -915,7 +916,7 @@ import * as https from "https";
 import { WebSocketServer } from "ws";
 
 // src/ws/auth.ts
-import { WebSocket } from "ws";
+import { WebSocket as WebSocket2 } from "ws";
 
 // src/utils/userinfo.ts
 function deUserInfoWithAsai(userinfo, $asai) {
@@ -940,6 +941,84 @@ function deUserInfoWithAsai(userinfo, $asai) {
 }
 __name(deUserInfoWithAsai, "deUserInfoWithAsai");
 
+// src/ws/ws-probe.ts
+import { WebSocket } from "ws";
+function isWsStillActive(ws2) {
+  if (!ws2) return false;
+  const state = ws2.readyState;
+  return state === WebSocket.CONNECTING || state === WebSocket.OPEN;
+}
+__name(isWsStillActive, "isWsStillActive");
+function getWsProbeTimeoutMs($asai) {
+  return $asai?.hostconfig?.tm?.d || 3e3;
+}
+__name(getWsProbeTimeoutMs, "getWsProbeTimeoutMs");
+function probeWsAlive($asai, wsclient, timeoutMs) {
+  const waitMs = timeoutMs ?? getWsProbeTimeoutMs($asai);
+  return new Promise((resolve6) => {
+    if (!wsclient || !isWsStillActive(wsclient)) {
+      resolve6(false);
+      return;
+    }
+    let settled = false;
+    const finish = /* @__PURE__ */ __name((alive) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        wsclient.off?.("message", onMessage);
+      } catch {
+      }
+      resolve6(alive);
+    }, "finish");
+    const onMessage = /* @__PURE__ */ __name(() => finish(true), "onMessage");
+    const timer = setTimeout(() => finish(false), waitMs);
+    try {
+      wsclient.once?.("message", onMessage);
+      wsclient.send(JSON.stringify({ ty: "publish/web", db: "pong" }));
+    } catch {
+      finish(false);
+    }
+  });
+}
+__name(probeWsAlive, "probeWsAlive");
+function terminateWs(wsclient) {
+  if (!wsclient) return;
+  try {
+    wsclient.terminate?.();
+  } catch {
+  }
+  try {
+    wsclient.close?.();
+  } catch {
+  }
+}
+__name(terminateWs, "terminateWs");
+async function clearStaleWsIfDead($asai, hostdir, us, existingWs) {
+  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);
+  if (alive) return false;
+  terminateWs(existingWs);
+  if (map?.[us] === existingWs) delete map[us];
+  return true;
+}
+__name(clearStaleWsIfDead, "clearStaleWsIfDead");
+
 // src/ws/auth.ts
 function getWsUserinfo(req, $asai) {
   try {
@@ -952,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 || {};
@@ -981,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) {
@@ -1006,12 +1155,6 @@ async function removeSessionOnWsClose($asai, us, token) {
   }
 }
 __name(removeSessionOnWsClose, "removeSessionOnWsClose");
-function isWsStillActive(ws2) {
-  if (!ws2) return false;
-  const state = ws2.readyState;
-  return state === WebSocket.CONNECTING || state === WebSocket.OPEN;
-}
-__name(isWsStillActive, "isWsStillActive");
 function rejectIncomingWs(ws2, db) {
   const payload = JSON.stringify({ ty: "publish/web", db: { exit: 1, type: "err", ...db } });
   try {
@@ -1029,7 +1172,7 @@ function rejectIncomingWs(ws2, db) {
   }
 }
 __name(rejectIncomingWs, "rejectIncomingWs");
-function isOkWs($asai, hostdir, ws2, _req, hostcfg) {
+async function isOkWs($asai, hostdir, ws2, _req, hostcfg) {
   const [us, , tk] = ws2.Userinfo || [];
   if (!us) {
     ws2.close();
@@ -1042,7 +1185,8 @@ function isOkWs($asai, hostdir, ws2, _req, hostcfg) {
         rejectIncomingWs(ws2, {
           lang: "pageworking",
           langpm: `${us}`,
-          con: `${us} page already running`
+          con: `${us} page already running`,
+          online: listOnlineWsEntries($asai, hostdir)
         });
         return false;
       }
@@ -1053,12 +1197,17 @@ function isOkWs($asai, hostdir, ws2, _req, hostcfg) {
       delete $asai.connectionsws[hostdir][us];
       return true;
     }
-    rejectIncomingWs(ws2, {
-      lang: "logged",
-      langpm: `${us}`,
-      con: `${us} logged in!`
-    });
-    return false;
+    const cleared = await clearStaleWsIfDead($asai, hostdir, us, existingWs);
+    if (!cleared) {
+      rejectIncomingWs(ws2, {
+        lang: "logged",
+        langpm: `${us}`,
+        con: `${us} logged in!`,
+        online: listOnlineWsEntries($asai, hostdir)
+      });
+      return false;
+    }
+    return true;
   }
   if (us !== "asai") {
     const connections = $asai.connectionsws[hostdir] || {};
@@ -1066,19 +1215,22 @@ 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;
     }
@@ -1109,13 +1261,13 @@ function loginWs($asai, hostdir, ws2, req, hostcfg, wsWorkHandler, logWsMessage)
     if (us && token && !isUserOnlineOnWs($asai, us, hostdir)) {
       void removeSessionOnWsClose($asai, us, String(token));
     }
-    if (ws2.readyState !== WebSocket.CLOSED && ws2.readyState !== WebSocket.CLOSING) ws2.close();
+    if (ws2.readyState !== WebSocket2.CLOSED && ws2.readyState !== WebSocket2.CLOSING) ws2.close();
   });
 }
 __name(loginWs, "loginWs");
 
 // src/ws/message.ts
-import { WebSocket as WebSocket2 } from "ws";
+import { WebSocket as WebSocket3 } from "ws";
 function clearWsServerTasks($asai, hostdir) {
   const tasks = $asai.tasksws[hostdir];
   if (tasks && typeof tasks === "object") {
@@ -1140,7 +1292,7 @@ function attachWssHelpers(wss, $asai) {
     const data = resWsMsg(msg, $asai);
     if (type) {
       wss.clients.forEach((client) => {
-        if ((type === 2 || client !== curws) && client.readyState === WebSocket2.OPEN) {
+        if ((type === 2 || client !== curws) && client.readyState === WebSocket3.OPEN) {
           client.send(data);
         }
       });
@@ -1151,7 +1303,7 @@ function attachWssHelpers(wss, $asai) {
   wss.broadws = (msg) => {
     const data = resWsMsg(msg, $asai);
     wss.clients.forEach((client) => {
-      if (client?.readyState === WebSocket2.OPEN) client.send(data);
+      if (client?.readyState === WebSocket3.OPEN) client.send(data);
     });
   };
 }
@@ -1331,12 +1483,14 @@ function createWSHost($asai, hostdir) {
         ws2.send(wsmsg, () => ws2.close(1013, "Server busy"));
         return;
       }
-      const isOpen = !hostcfg.ckws || isOkWs($asai, hostdir, ws2, req, hostcfg);
-      if (isOpen) {
-        loginWs($asai, hostdir, ws2, req, hostcfg, wsWorkHandler, logWsMessage);
-      } else {
-        ws2.close();
-      }
+      void (async () => {
+        const isOpen = !hostcfg.ckws || await isOkWs($asai, hostdir, ws2, req, hostcfg);
+        if (isOpen) {
+          loginWs($asai, hostdir, ws2, req, hostcfg, wsWorkHandler, logWsMessage);
+        } else {
+          ws2.close();
+        }
+      })();
     });
     $asai.serversws[hostdir] = wss;
   } catch (err) {
@@ -1460,11 +1614,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;
   };
@@ -2351,7 +2505,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 };
@@ -2382,11 +2536,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) {
@@ -3993,6 +4147,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 || {};
 }
@@ -4153,8 +4338,11 @@ var login_default = /* @__PURE__ */ __name(($asai) => {
         const policy = getPasswordPolicy($asai);
         const mustChange = !!user.mustChangePassword || isPasswordExpired(user.passwordChangedAt, policy.maxAgeDays);
         const hostcfg = $asai.getHost?.(hostdir) || {};
-        if (hostcfg.ckws && isUserOnlineOnWs($asai, us, hostdir)) {
-          kickUserWs($asai, us, hostdir);
+        if (hostcfg.ckws) {
+          const existingWs = $asai.connectionsws?.[hostdir]?.[us];
+          if (existingWs) {
+            await clearStaleWsIfDead($asai, hostdir, us, existingWs);
+          }
         }
         const quotaCheck = await canLogin($asai, us, hostdir);
         if (!quotaCheck.ok) {
@@ -4200,6 +4388,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);
@@ -4213,7 +4451,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, {
@@ -4412,6 +4650,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);
@@ -4534,10 +4805,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) {
@@ -4545,8 +4816,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;
             }
           }
@@ -4555,10 +4826,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);
@@ -5155,7 +5426,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) {
@@ -5171,16 +5442,16 @@ 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 (path5.isAbsolute(decoded)) {
+      return path5.normalize(decoded);
     }
     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)) {
+      const absRoot = path5.resolve(serverRoot);
+      const abs = path5.resolve(absRoot, rel);
+      const relCheck = path5.relative(absRoot, abs);
+      if (relCheck === "" || !relCheck.startsWith("..") && !path5.isAbsolute(relCheck)) {
         return abs;
       }
     }
@@ -5240,18 +5511,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;
@@ -5259,7 +5530,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");
@@ -5270,34 +5541,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)
@@ -5308,7 +5579,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),
@@ -5318,7 +5589,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;
   }
@@ -5326,13 +5597,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) {
@@ -5368,7 +5639,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) => {
@@ -5433,11 +5704,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) {
@@ -5618,8 +5889,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;
@@ -5633,20 +5904,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");
       }
@@ -5660,15 +5931,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;
     }
@@ -5684,34 +5955,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 };
         }
       }
@@ -5723,13 +5994,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);
     }
@@ -5737,7 +6008,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);
@@ -5751,7 +6022,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) {
@@ -5768,12 +6039,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) {
@@ -5792,11 +6063,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) {
@@ -5810,7 +6081,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: [] } : [];
         }
@@ -5822,9 +6093,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);
@@ -6590,7 +6861,7 @@ var initAsaiHostNodejs2 = {
   createTransportDataHandler,
   wireTransportConnectionLogs
 };
-var PLUGIN_VERSION = true ? "0.0.8" : "0.0.1";
+var PLUGIN_VERSION = true ? "0.0.10" : "0.0.1";
 var index_default = initAsaiHostNodejs2;
 export {
   Index_default as AsaiCommon,