@zhin.js/console 1.0.48 → 1.0.49

package/lib/websocket.js

@@ -6,6 +6,34 @@ import { usePlugin } from '@zhin.js/core';
 // src/websocket.ts
 var { root, logger } = usePlugin();
 var ENV_WHITELIST = [".env", ".env.development", ".env.production"];
+var FILE_MANAGER_ALLOWED = [
+  "src",
+  "plugins",
+  "client",
+  "package.json",
+  "tsconfig.json",
+  "zhin.config.yml",
+  ".env",
+  ".env.development",
+  ".env.production",
+  "README.md"
+];
+var FILE_MANAGER_BLOCKED = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".env.local",
+  "data",
+  "lib",
+  "dist",
+  "coverage"
+]);
+function isPathAllowed(relativePath) {
+  if (relativePath.includes("..") || path.isAbsolute(relativePath)) return false;
+  const normalized = relativePath.replace(/\\/g, "/").replace(/^\.\//, "");
+  const firstSegment = normalized.split("/")[0];
+  if (FILE_MANAGER_BLOCKED.has(firstSegment)) return false;
+  return FILE_MANAGER_ALLOWED.some((p) => normalized === p || normalized.startsWith(p + "/"));
+}
 function resolveConfigKey(pluginName) {
   const schemaService = root.inject("schema");
   return schemaService?.resolveConfigKey(pluginName) ?? pluginName;
@@ -236,10 +264,413 @@ async function handleWebSocketMessage(ws, message, webServer) {
         ws.send(JSON.stringify({ requestId, error: `Failed to save env file: ${error.message}` }));
       }
       break;
+    // ================================================================
+    // 文件管理
+    // ================================================================
+    case "files:tree":
+      try {
+        const cwd = process.cwd();
+        const tree = buildFileTree(cwd, "", FILE_MANAGER_ALLOWED);
+        ws.send(JSON.stringify({ requestId, data: { tree } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: `Failed to build file tree: ${error.message}` }));
+      }
+      break;
+    case "files:read":
+      try {
+        const { filePath: fp } = message;
+        if (!fp || !isPathAllowed(fp)) {
+          ws.send(JSON.stringify({ requestId, error: `Access denied: ${fp}` }));
+          break;
+        }
+        const absPath = path.resolve(process.cwd(), fp);
+        if (!fs.existsSync(absPath)) {
+          ws.send(JSON.stringify({ requestId, error: `File not found: ${fp}` }));
+          break;
+        }
+        const stat = fs.statSync(absPath);
+        if (!stat.isFile()) {
+          ws.send(JSON.stringify({ requestId, error: `Not a file: ${fp}` }));
+          break;
+        }
+        if (stat.size > 1024 * 1024) {
+          ws.send(JSON.stringify({ requestId, error: `File too large: ${(stat.size / 1024).toFixed(0)}KB (max 1MB)` }));
+          break;
+        }
+        const fileContent = fs.readFileSync(absPath, "utf-8");
+        ws.send(JSON.stringify({ requestId, data: { content: fileContent, size: stat.size } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: `Failed to read file: ${error.message}` }));
+      }
+      break;
+    case "files:save":
+      try {
+        const { filePath: fp, content: fileContent } = message;
+        if (!fp || !isPathAllowed(fp)) {
+          ws.send(JSON.stringify({ requestId, error: `Access denied: ${fp}` }));
+          break;
+        }
+        if (typeof fileContent !== "string") {
+          ws.send(JSON.stringify({ requestId, error: "content field is required" }));
+          break;
+        }
+        const absPath = path.resolve(process.cwd(), fp);
+        const dir = path.dirname(absPath);
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(absPath, fileContent, "utf-8");
+        ws.send(JSON.stringify({ requestId, data: { success: true, message: `\u6587\u4EF6\u5DF2\u4FDD\u5B58: ${fp}` } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: `Failed to save file: ${error.message}` }));
+      }
+      break;
+    // ================================================================
+    // 数据库管理
+    // ================================================================
+    case "db:info":
+      try {
+        const dbInfo = getDatabaseInfo();
+        ws.send(JSON.stringify({ requestId, data: dbInfo }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: `Failed to get db info: ${error.message}` }));
+      }
+      break;
+    case "db:tables":
+      try {
+        const tables = getDatabaseTables();
+        ws.send(JSON.stringify({ requestId, data: { tables } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: `Failed to list tables: ${error.message}` }));
+      }
+      break;
+    case "db:select":
+      try {
+        const { table, page = 1, pageSize = 50, where } = message;
+        if (!table) {
+          ws.send(JSON.stringify({ requestId, error: "table is required" }));
+          break;
+        }
+        const selectResult = await dbSelect(table, page, pageSize, where);
+        ws.send(JSON.stringify({ requestId, data: selectResult }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: `Failed to select: ${error.message}` }));
+      }
+      break;
+    case "db:insert":
+      try {
+        const { table, row } = message;
+        if (!table || !row) {
+          ws.send(JSON.stringify({ requestId, error: "table and row are required" }));
+          break;
+        }
+        await dbInsert(table, row);
+        ws.send(JSON.stringify({ requestId, data: { success: true } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: `Failed to insert: ${error.message}` }));
+      }
+      break;
+    case "db:update":
+      try {
+        const { table, row, where: updateWhere } = message;
+        if (!table || !row || !updateWhere) {
+          ws.send(JSON.stringify({ requestId, error: "table, row, and where are required" }));
+          break;
+        }
+        const affected = await dbUpdate(table, row, updateWhere);
+        ws.send(JSON.stringify({ requestId, data: { success: true, affected } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: `Failed to update: ${error.message}` }));
+      }
+      break;
+    case "db:delete":
+      try {
+        const { table, where: deleteWhere } = message;
+        if (!table || !deleteWhere) {
+          ws.send(JSON.stringify({ requestId, error: "table and where are required" }));
+          break;
+        }
+        const deleted = await dbDelete(table, deleteWhere);
+        ws.send(JSON.stringify({ requestId, data: { success: true, deleted } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: `Failed to delete: ${error.message}` }));
+      }
+      break;
+    case "db:drop-table":
+      try {
+        const { table: dropTableName } = message;
+        if (!dropTableName) {
+          ws.send(JSON.stringify({ requestId, error: "table is required" }));
+          break;
+        }
+        await dbDropTable(dropTableName);
+        ws.send(JSON.stringify({ requestId, data: { success: true } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: `Failed to drop table: ${error.message}` }));
+      }
+      break;
+    // KV 专用操作
+    case "db:kv:get":
+      try {
+        const { table, key } = message;
+        if (!table || !key) {
+          ws.send(JSON.stringify({ requestId, error: "table and key are required" }));
+          break;
+        }
+        const kvValue = await kvGet(table, key);
+        ws.send(JSON.stringify({ requestId, data: { key, value: kvValue } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: `Failed to get kv: ${error.message}` }));
+      }
+      break;
+    case "db:kv:set":
+      try {
+        const { table, key, value, ttl } = message;
+        if (!table || !key) {
+          ws.send(JSON.stringify({ requestId, error: "table and key are required" }));
+          break;
+        }
+        await kvSet(table, key, value, ttl);
+        ws.send(JSON.stringify({ requestId, data: { success: true } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: `Failed to set kv: ${error.message}` }));
+      }
+      break;
+    case "db:kv:delete":
+      try {
+        const { table, key } = message;
+        if (!table || !key) {
+          ws.send(JSON.stringify({ requestId, error: "table and key are required" }));
+          break;
+        }
+        await kvDelete(table, key);
+        ws.send(JSON.stringify({ requestId, data: { success: true } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: `Failed to delete kv: ${error.message}` }));
+      }
+      break;
+    case "db:kv:entries":
+      try {
+        const { table } = message;
+        if (!table) {
+          ws.send(JSON.stringify({ requestId, error: "table is required" }));
+          break;
+        }
+        const kvEntries = await kvGetEntries(table);
+        ws.send(JSON.stringify({ requestId, data: { entries: kvEntries } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: `Failed to get entries: ${error.message}` }));
+      }
+      break;
     default:
       ws.send(JSON.stringify({ requestId, error: `Unknown message type: ${type}` }));
   }
 }
+function getDb() {
+  return root.inject("database");
+}
+function getDbType() {
+  const dbFeature = getDb();
+  const dialectName = dbFeature.db.dialect.name;
+  if (["mongodb"].includes(dialectName)) return "document";
+  if (["redis"].includes(dialectName)) return "keyvalue";
+  return "related";
+}
+function getDatabaseInfo() {
+  const dbFeature = getDb();
+  const db = dbFeature.db;
+  return {
+    dialect: db.dialectName,
+    type: getDbType(),
+    tables: Array.from(db.models.keys())
+  };
+}
+function getDatabaseTables() {
+  const dbFeature = getDb();
+  const db = dbFeature.db;
+  getDbType();
+  const tables = [];
+  for (const [name] of db.models) {
+    const def = db.definitions.get(name);
+    tables.push({ name, columns: def ? Object.fromEntries(Object.entries(def).map(([col, colDef]) => [col, colDef])) : void 0 });
+  }
+  return tables;
+}
+async function dbSelect(table, page, pageSize, where) {
+  const dbFeature = getDb();
+  const db = dbFeature.db;
+  const dbType = getDbType();
+  const model = db.models.get(table);
+  if (!model) throw new Error(`Table '${table}' not found`);
+  if (dbType === "keyvalue") {
+    const kvModel = model;
+    const allEntries = await kvModel.entries();
+    const total2 = allEntries.length;
+    const start = (page - 1) * pageSize;
+    const rows2 = allEntries.slice(start, start + pageSize).map(([k, v]) => ({ key: k, value: v }));
+    return { rows: rows2, total: total2, page, pageSize };
+  }
+  let selection = model.select();
+  if (where && Object.keys(where).length > 0) {
+    selection = selection.where(where);
+  }
+  let total;
+  try {
+    const countResult = await db.aggregate(table).count("*", "total").where(where || {});
+    total = countResult?.[0]?.total ?? 0;
+  } catch {
+    const all = await model.select();
+    total = all.length;
+  }
+  const offset = (page - 1) * pageSize;
+  let query = model.select();
+  if (where && Object.keys(where).length > 0) {
+    query = query.where(where);
+  }
+  const rows = await query.limit(pageSize).offset(offset);
+  return { rows, total, page, pageSize };
+}
+async function dbInsert(table, row) {
+  const dbFeature = getDb();
+  const db = dbFeature.db;
+  const dbType = getDbType();
+  const model = db.models.get(table);
+  if (!model) throw new Error(`Table '${table}' not found`);
+  if (dbType === "keyvalue") {
+    const kvModel = model;
+    if (!row.key) throw new Error("key is required for KV insert");
+    await kvModel.set(row.key, row.value);
+    return;
+  }
+  if (dbType === "document") {
+    await model.create(row);
+    return;
+  }
+  await model.insert(row);
+}
+async function dbUpdate(table, row, where) {
+  const dbFeature = getDb();
+  const db = dbFeature.db;
+  const dbType = getDbType();
+  const model = db.models.get(table);
+  if (!model) throw new Error(`Table '${table}' not found`);
+  if (dbType === "keyvalue") {
+    const kvModel = model;
+    if (!where.key) throw new Error("key is required for KV update");
+    await kvModel.set(where.key, row.value);
+    return 1;
+  }
+  if (dbType === "document") {
+    if (where._id) {
+      return await model.updateById(where._id, row);
+    }
+  }
+  return await model.update(row).where(where);
+}
+async function dbDelete(table, where) {
+  const dbFeature = getDb();
+  const db = dbFeature.db;
+  const dbType = getDbType();
+  const model = db.models.get(table);
+  if (!model) throw new Error(`Table '${table}' not found`);
+  if (dbType === "keyvalue") {
+    const kvModel = model;
+    if (!where.key) throw new Error("key is required for KV delete");
+    await kvModel.deleteByKey(where.key);
+    return 1;
+  }
+  if (dbType === "document") {
+    if (where._id) {
+      return await model.deleteById(where._id);
+    }
+  }
+  return await model.delete(where);
+}
+async function dbDropTable(table) {
+  const dbFeature = getDb();
+  const db = dbFeature.db;
+  const model = db.models.get(table);
+  if (!model) throw new Error(`Table '${table}' not found`);
+  const sql = db.dialect.formatDropTable(table, true);
+  await db.query(sql);
+  db.models.delete(table);
+  db.definitions.delete(table);
+}
+async function kvGet(table, key) {
+  const dbFeature = getDb();
+  const model = dbFeature.db.models.get(table);
+  if (!model) throw new Error(`Bucket '${table}' not found`);
+  return await model.get(key);
+}
+async function kvSet(table, key, value, ttl) {
+  const dbFeature = getDb();
+  const model = dbFeature.db.models.get(table);
+  if (!model) throw new Error(`Bucket '${table}' not found`);
+  await model.set(key, value, ttl);
+}
+async function kvDelete(table, key) {
+  const dbFeature = getDb();
+  const model = dbFeature.db.models.get(table);
+  if (!model) throw new Error(`Bucket '${table}' not found`);
+  await model.deleteByKey(key);
+}
+async function kvGetEntries(table) {
+  const dbFeature = getDb();
+  const model = dbFeature.db.models.get(table);
+  if (!model) throw new Error(`Bucket '${table}' not found`);
+  const entries = await model.entries();
+  return entries.map(([k, v]) => ({ key: k, value: v }));
+}
+function buildFileTree(cwd, relativePath, allowed) {
+  const tree = [];
+  path.resolve(cwd, relativePath);
+  for (const entry of allowed) {
+    const entryRelative = entry;
+    if (entryRelative.includes("/")) continue;
+    const absPath = path.resolve(cwd, entry);
+    if (!fs.existsSync(absPath)) continue;
+    const stat = fs.statSync(absPath);
+    if (stat.isDirectory()) {
+      tree.push({
+        name: entryRelative,
+        path: entry,
+        type: "directory",
+        children: buildDirectoryTree(cwd, entry, 3)
+      });
+    } else if (stat.isFile()) {
+      tree.push({ name: entryRelative, path: entry, type: "file" });
+    }
+  }
+  return tree.sort((a, b) => {
+    if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+}
+function buildDirectoryTree(cwd, relativePath, maxDepth) {
+  if (maxDepth <= 0) return [];
+  const absDir = path.resolve(cwd, relativePath);
+  if (!fs.existsSync(absDir) || !fs.statSync(absDir).isDirectory()) return [];
+  const entries = fs.readdirSync(absDir, { withFileTypes: true });
+  const result = [];
+  for (const entry of entries) {
+    if (FILE_MANAGER_BLOCKED.has(entry.name) || entry.name.startsWith(".")) continue;
+    const childRelative = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      result.push({
+        name: entry.name,
+        path: childRelative,
+        type: "directory",
+        children: buildDirectoryTree(cwd, childRelative, maxDepth - 1)
+      });
+    } else if (entry.isFile()) {
+      result.push({ name: entry.name, path: childRelative, type: "file" });
+    }
+  }
+  return result.sort((a, b) => {
+    if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+}
 function findPluginByConfigKey(rootPlugin, configKey) {
   for (const child of rootPlugin.children) {
     if (child.name === configKey || child.name.endsWith(`-${configKey}`) || child.name.includes(configKey)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhin.js/console",
-  "version": "1.0.48",
+  "version": "1.0.49",
   "description": "Web console service for Zhin.js with real-time monitoring",
   "type": "module",
   "main": "./lib/index.js",
@@ -72,7 +72,7 @@
   },
   "peerDependencies": {
     "@types/ws": "^8.18.1",
-    "@zhin.js/client": "^1.0.11",
+    "@zhin.js/client": "^1.0.12",
     "@zhin.js/core": "^1.0.50",
     "@zhin.js/http": "^1.0.44",
     "zhin.js": "1.0.50"