xinyu-pro 0.21.0

package/lib/db-init.ts

@@ -0,0 +1,35 @@
+// lib/db-init.ts - 数据库初始化（服务器启动时执行一次）
+
+import { initDb } from './db';
+
+// 使用 globalThis 确保跨模块、跨请求、跨 HMR 的真正全局单例
+// 即使 Next.js 开发模式热替换重置了模块作用域，globalThis 上的值也不会丢失
+const INIT_KEY = '__xinyu_db_init__';
+
+/**
+ * 确保数据库已初始化。
+ * 使用 globalThis + Promise 守卫：整个 Node.js 进程生命周期内只执行一次初始化。
+ * 无论被多少个模块、多少个请求调用，都返回同一个 Promise。
+ */
+export function ensureDb(): Promise<void> {
+    // @ts-expect-error -- globalThis 上的自定义 key
+    if (globalThis[INIT_KEY]) return globalThis[INIT_KEY];
+
+    console.log('正在初始化数据库...');
+
+    // @ts-expect-error -- globalThis 上的自定义 key
+    globalThis[INIT_KEY] = initDb()
+        .then(() => {
+            console.log('数据库初始化完成');
+        })
+        .catch((e: unknown) => {
+            console.error('数据库初始化失败:', e);
+            // 初始化失败时清除，允许下次重试
+            // @ts-expect-error -- globalThis 上的自定义 key
+            delete globalThis[INIT_KEY];
+            throw e;
+        });
+
+    // @ts-expect-error -- globalThis 上的自定义 key
+    return globalThis[INIT_KEY];
+}

package/lib/db.ts

@@ -0,0 +1,244 @@
+// lib/db.ts - MySQL 数据库连接工具
+
+import mysql from 'mysql2/promise';
+
+let pool: mysql.Pool | null = null;
+
+export function getDbPool(): mysql.Pool {
+  if (!pool) {
+    pool = mysql.createPool({
+      host: process.env.DB_HOST || 'localhost',
+      port: parseInt(process.env.DB_PORT || '3306'),
+      user: process.env.DB_USER || 'root',
+      password: process.env.DB_PASSWORD || '',
+      database: process.env.DB_NAME || 'xinyu',
+      waitForConnections: true,
+      connectionLimit: 20,
+      queueLimit: 100,
+      idleTimeout: 60000,
+      enableKeepAlive: true,
+      keepAliveInitialDelay: 30000,
+    });
+  }
+  return pool;
+}
+
+/**
+ * 初始化数据库表结构（首次启动时调用）
+ */
+export async function initDb(): Promise<void> {
+  const db = getDbPool();
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS app_settings (
+      \`key\` VARCHAR(100) PRIMARY KEY,
+      \`value\` JSON NOT NULL,
+      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
+  `);
+
+  // 游戏会话表
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS game_sessions (
+      id VARCHAR(100) PRIMARY KEY,
+      world_setting JSON NOT NULL,
+      messages JSON NOT NULL,
+      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+      INDEX idx_updated_at (updated_at)
+    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
+  `);
+
+  // 世界卡片模板表
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS world_templates (
+      id VARCHAR(100) PRIMARY KEY,
+      name VARCHAR(200) NOT NULL,
+      svg_content LONGTEXT,
+      fields JSON NOT NULL,
+      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+      INDEX idx_updated_at (updated_at)
+    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
+  `);
+
+  // 插件定义表
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS extensions (
+      id VARCHAR(200) PRIMARY KEY,
+      name VARCHAR(200) NOT NULL,
+      version VARCHAR(50) NOT NULL,
+      description TEXT,
+      author VARCHAR(100),
+      type VARCHAR(50) NOT NULL,
+      icon VARCHAR(50),
+      min_app_version VARCHAR(50),
+      code_path VARCHAR(500) NOT NULL DEFAULT '',
+      config_schema JSON,
+      ui_slots JSON,
+      ui_permissions JSON,
+      public_exports JSON,
+      dependencies JSON,
+      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+      INDEX idx_type (type),
+      INDEX idx_updated_at (updated_at)
+    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
+  `);
+
+  // 插件绑定表（控制启用/禁用和作用域）
+  await db.execute(`
+    CREATE TABLE IF NOT EXISTS extension_bindings (
+      id INT AUTO_INCREMENT PRIMARY KEY,
+      extension_id VARCHAR(200) NOT NULL,
+      scope ENUM('global', 'world') NOT NULL DEFAULT 'global',
+      world_id VARCHAR(100) NOT NULL DEFAULT '',
+      enabled BOOLEAN NOT NULL DEFAULT TRUE,
+      config JSON NOT NULL,
+      sort_order INT NOT NULL DEFAULT 0,
+      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+      UNIQUE KEY uk_ext_scope_world (extension_id, scope, world_id),
+      INDEX idx_world_id (world_id),
+      FOREIGN KEY (extension_id) REFERENCES extensions(id) ON DELETE CASCADE
+    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
+  `);
+
+  // ========== 数据迁移 ==========
+
+  // 迁移 1: 修复 extension_bindings 的 world_id 列（NULL -> ''）
+  // 如果表已存在且 world_id 仍允许 NULL，需要修改列定义
+  try {
+    await db.execute(`
+      ALTER TABLE extension_bindings
+      MODIFY COLUMN world_id VARCHAR(100) NOT NULL DEFAULT ''
+    `);
+  } catch {
+    // 列已经是 NOT NULL，忽略错误
+  }
+
+  // 迁移 2: 清理 world_id = NULL 的旧数据，改为空字符串
+  try {
+    await db.execute(`
+      UPDATE extension_bindings SET world_id = '' WHERE world_id IS NULL
+    `);
+  } catch {
+    // 忽略
+  }
+
+  // 迁移 3: 删除 extension_bindings 中的重复行，保留每个 (extension_id, scope) 组合中最新的一条
+  try {
+    // 先查出需要保留的 id（每组中 id 最大的）
+    const [rows] = await db.execute(
+      `SELECT MAX(id) AS keep_id FROM extension_bindings GROUP BY extension_id, scope`
+    ) as [Array<{ keep_id: number }>, unknown];
+
+    if (rows.length > 0) {
+      const keepIds = rows.map((r) => r.keep_id);
+      const placeholders = keepIds.map(() => '?').join(',');
+
+      // 删除不在保留列表中的行
+      await db.execute(
+        `DELETE FROM extension_bindings WHERE id NOT IN (${placeholders})`,
+        keepIds as number[]
+      );
+    }
+  } catch (e) {
+    console.error('清理重复绑定记录失败:', e);
+  }
+
+  // 迁移 4: 为 extensions 表新增 public_exports 和 dependencies 列
+  try {
+    await db.execute(`
+      ALTER TABLE extensions
+      ADD COLUMN public_exports JSON AFTER ui_slots
+    `);
+  } catch {
+    // 列已存在，忽略错误
+  }
+  try {
+    await db.execute(`
+      ALTER TABLE extensions
+      ADD COLUMN dependencies JSON AFTER public_exports
+    `);
+  } catch {
+    // 列已存在，忽略错误
+  }
+
+  // 迁移 5: 为 world_templates 表新增 plugins 列
+  try {
+    await db.execute(`
+      ALTER TABLE world_templates
+      ADD COLUMN plugins JSON AFTER fields
+    `);
+  } catch {
+    // 列已存在，忽略错误
+  }
+
+  // 迁移 6: 为 extensions 表新增 ui_permissions 列
+  try {
+    await db.execute(`
+      ALTER TABLE extensions
+      ADD COLUMN ui_permissions JSON AFTER ui_slots
+    `);
+  } catch {
+    // 列已存在，忽略错误
+  }
+
+  // 迁移 7: 新建 plugin_storage 表（插件持久化 key-value 存储）
+  try {
+    await db.execute(`
+      CREATE TABLE IF NOT EXISTS plugin_storage (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        plugin_id VARCHAR(100) NOT NULL,
+        storage_key VARCHAR(200) NOT NULL,
+        storage_value JSON,
+        world_id VARCHAR(100) DEFAULT '',
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+        UNIQUE KEY uk_plugin_key_world (plugin_id, storage_key, world_id),
+        INDEX idx_plugin_id (plugin_id)
+      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
+    `);
+  } catch {
+    // 表已存在，忽略错误
+  }
+
+  // 迁移 8: 将 extensions.code (LONGTEXT) 迁移到文件存储 + code_path (VARCHAR)
+  try {
+    const { promises: fs } = await import('fs');
+    const path = await import('path');
+    const codeRoot = path.join(process.cwd(), 'data', 'plugins');
+
+    // 检查 code 列是否仍存在
+    const [cols] = await db.execute(
+      `SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = 'extensions' AND COLUMN_NAME = 'code'`
+    ) as [Array<{ COLUMN_NAME: string }>, unknown];
+
+    if (cols.length > 0) {
+      // 确保目录存在
+      await fs.mkdir(codeRoot, { recursive: true });
+
+      // 读取所有有 code 的插件
+      const [rows] = await db.execute(
+        `SELECT id, code FROM extensions WHERE code IS NOT NULL AND code != ''`
+      ) as [Array<{ id: string; code: string }>, unknown];
+
+      for (const row of rows) {
+        const pluginDir = path.join(codeRoot, row.id);
+        await fs.mkdir(pluginDir, { recursive: true });
+        const filePath = path.join(pluginDir, 'plugin.js');
+        await fs.writeFile(filePath, row.code, 'utf-8');
+        const relativePath = `data/plugins/${row.id}/plugin.js`;
+        await db.execute(
+          `UPDATE extensions SET code_path = ? WHERE id = ?`,
+          [relativePath, row.id]
+        );
+      }
+
+      // 迁移完成后删除 code 列
+      await db.execute(`ALTER TABLE extensions DROP COLUMN code`);
+      console.log(`[迁移 8] 已将 ${rows.length} 个插件的 code 迁移到文件存储`);
+    }
+  } catch (e) {
+    console.error('迁移 8 (code → code_path) 失败:', e);
+  }
+}

package/lib/manifest-parser.ts

@@ -0,0 +1,185 @@
+// lib/manifest-parser.ts - 从代码注释中解析 manifest 信息
+
+import { PluginType, PluginConfigField, UIPermission, UI_PERMISSION_LABELS, PLUGIN_TYPE_LABELS } from './plugin-types';
+
+export interface ParsedManifest {
+  id?: string;
+  name?: string;
+  version?: string;
+  author?: string;
+  icon?: string;
+  type?: PluginType;
+  description?: string;
+  permissions?: UIPermission[];
+  exclusivePermissions?: UIPermission[];
+  requiredPermissions?: UIPermission[];
+  configSchema?: PluginConfigField[];
+}
+
+/** 配置项类型的合法值 */
+const VALID_CONFIG_TYPES: PluginConfigField['type'][] = ['text', 'number', 'boolean', 'select', 'textarea'];
+
+/**
+ * 从插件代码注释中解析 manifest 信息
+ * 支持格式：
+ *   // @plugin-id author.plugin-name
+ *   // @name 插件名称
+ *   // @version 1.0.0
+ *   // @author 作者
+ *   // @icon 🎮
+ *   // @type game-mechanics
+ *   // @description 插件描述
+ *   // @permission slot:status-bar
+ *   // @permission style:inject, modal:confirm
+ *
+ * 配置项定义（JSON 格式）：
+ *   // @config {"key":"enableHighlight","label":"启用高亮","type":"boolean","defaultValue":true,"description":"是否启用代码高亮"}
+ *   // @config {"key":"maxDepth","label":"最大深度","type":"number","defaultValue":3}
+ *   // @config {"key":"theme","label":"主题","type":"select","defaultValue":"default","options":[{"label":"默认边框","value":"default"},{"label":"淡边框","value":"subtle"}]}
+ *   // @configs [{"key":"enabled","label":"启用","type":"boolean","defaultValue":true},{"key":"maxRetry","label":"最大重试","type":"number","defaultValue":3}]
+ */
+export function parseManifestFromCode(code: string): ParsedManifest {
+  const result: ParsedManifest = {};
+
+  // 按行拆分，用于支持多行 JSON（@config/@configs）
+  const lines = code.split('\n');
+
+  // 匹配 // @key value 格式的注释（value 支持到行尾）
+  // 注意：@plugin-id 包含连字符，需要额外匹配
+  const pattern = /\/\/\s*@(\w[\w-]*)\s*(.*)/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = pattern.exec(code)) !== null) {
+    const key = match[1].toLowerCase();
+    let value = match[2].trim();
+
+    // 对 config/configs，收集后续以 // 开头的注释行，拼接为完整 JSON
+    if (key === 'config' || key === 'configs') {
+      const currentLineIdx = code.substring(0, match.index).split('\n').length - 1;
+      // 从下一行开始，收集连续的 // 注释行
+      const jsonLines: string[] = [value];
+      for (let i = currentLineIdx + 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith('//') && !/^\/\/\s*@/.test(line)) {
+          jsonLines.push(line.replace(/^\/\/\s*/, ''));
+        } else {
+          break;
+        }
+      }
+      value = jsonLines.join('\n').trim();
+    }
+
+    switch (key) {
+      case 'plugin-id':
+        result.id = value.trim();
+        break;
+      case 'name':
+        result.name = value;
+        break;
+      case 'version':
+        result.version = value;
+        break;
+      case 'author':
+        result.author = value;
+        break;
+      case 'icon':
+        result.icon = value.trim();
+        break;
+      case 'type': {
+        const validTypes = Object.keys(PLUGIN_TYPE_LABELS) as PluginType[];
+        if (validTypes.includes(value as PluginType)) {
+          result.type = value as PluginType;
+        }
+        break;
+      }
+      case 'description':
+        result.description = value;
+        break;
+      case 'permission': {
+        if (!result.permissions) result.permissions = [];
+        value.split(/[,，\s]+/).forEach(p => {
+          const trimmed = p.trim() as UIPermission;
+          if (trimmed && UI_PERMISSION_LABELS[trimmed] && !(result.permissions || []).includes(trimmed)) {
+            (result.permissions || (result.permissions = [])).push(trimmed);
+          }
+        });
+        break;
+      }
+      case 'exclusive': {
+        if (!result.exclusivePermissions) result.exclusivePermissions = [];
+        value.split(/[,，\s]+/).forEach(p => {
+          const trimmed = p.trim() as UIPermission;
+          if (trimmed && UI_PERMISSION_LABELS[trimmed] && !result.exclusivePermissions.includes(trimmed)) {
+            result.exclusivePermissions.push(trimmed);
+          }
+        });
+        break;
+      }
+      case 'required': {
+        if (!result.requiredPermissions) result.requiredPermissions = [];
+        value.split(/[,，\s]+/).forEach(p => {
+          const trimmed = p.trim() as UIPermission;
+          if (trimmed && UI_PERMISSION_LABELS[trimmed] && !result.requiredPermissions.includes(trimmed)) {
+            result.requiredPermissions.push(trimmed);
+          }
+        });
+        break;
+      }
+      case 'config': {
+        // @config {单个配置项 JSON}
+        const field = parseConfigField(value);
+        if (field) {
+          if (!result.configSchema) result.configSchema = [];
+          result.configSchema.push(field);
+        }
+        break;
+      }
+      case 'configs': {
+        // @configs [{配置项数组 JSON}]
+        const fields = parseConfigFields(value);
+        if (fields.length > 0) {
+          if (!result.configSchema) result.configSchema = [];
+          result.configSchema.push(...fields);
+        }
+        break;
+      }
+    }
+  }
+
+  return result;
+}
+
+/** 解析单个 @config JSON 为 PluginConfigField */
+function parseConfigField(jsonStr: string): PluginConfigField | null {
+  try {
+    const raw = JSON.parse(jsonStr);
+    if (!raw.key || !raw.label || !raw.type) return null;
+    if (!VALID_CONFIG_TYPES.includes(raw.type)) return null;
+
+    const field: PluginConfigField = {
+      key: raw.key,
+      label: raw.label,
+      type: raw.type,
+      defaultValue: raw.defaultValue ?? '',
+      description: raw.description || undefined,
+      options: Array.isArray(raw.options) ? raw.options.map((o: { label: string; value: string }) => ({
+        label: String(o.label || ''),
+        value: String(o.value || ''),
+      })) : undefined,
+    };
+    return field;
+  } catch {
+    return null;
+  }
+}
+
+/** 解析 @configs JSON 数组为 PluginConfigField[] */
+function parseConfigFields(jsonStr: string): PluginConfigField[] {
+  try {
+    const arr = JSON.parse(jsonStr);
+    if (!Array.isArray(arr)) return [];
+    return arr.map((item: unknown) => parseConfigField(JSON.stringify(item))).filter((f: PluginConfigField | null): f is PluginConfigField => f !== null);
+  } catch {
+    return [];
+  }
+}

package/lib/parseWorldCard.ts

@@ -0,0 +1,110 @@
+// lib/parseWorldCard.ts - SVG 世界卡片解析工具
+
+import { WorldSetting, WorldCardField } from './types';
+
+/**
+ * 从 SVG 文本中提取世界卡片数据（原始 JSON）
+ */
+export function parseWorldCardRaw(svgText: string): Record<string, unknown> {
+  const scriptRegex = /<script[^>]*type=["']application\/json["'][^>]*id=["']world-data["'][^>]*>([\s\S]*?)<\/script>/i;
+  const match = svgText.match(scriptRegex);
+
+  if (!match || !match[1]) {
+    throw new Error('未在世界卡片中找到有效的世界设定数据。');
+  }
+
+  try {
+    return JSON.parse(match[1].trim());
+  } catch {
+    throw new Error('世界卡片中的 JSON 数据格式无效。');
+  }
+}
+
+/**
+ * 从 SVG 文本中提取世界设定（向后兼容，返回原始数据）
+ */
+export function parseWorldCard(svgText: string): WorldSetting {
+  return parseWorldCardRaw(svgText);
+}
+
+/**
+ * 从 File 对象读取并解析世界卡片（向后兼容）
+ */
+export async function parseWorldCardFromFile(file: File): Promise<WorldSetting> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = (e) => {
+      try {
+        const text = e.target?.result as string;
+        resolve(parseWorldCard(text));
+      } catch (err) {
+        reject(err);
+      }
+    };
+    reader.onerror = () => reject(new Error('文件读取失败'));
+    reader.readAsText(file);
+  });
+}
+
+/**
+ * 将动态字段数据转换为 WorldSetting（通用转换，保留所有字段 + 元数据）
+ * @param fields 完整字段列表（WorldCardField[]）
+ */
+export function fieldsToWorldSetting(fields: WorldCardField[]): WorldSetting {
+  const map: Record<string, unknown> = {};
+  for (const f of fields) {
+    map[f.key] = f.value;
+  }
+  // 注入字段元数据（label、type、options 等），用于恢复原始字段渲染
+  const fieldMeta: Record<string, Record<string, unknown>> = {};
+  for (const f of fields) {
+    const meta: Record<string, unknown> = { label: f.label, type: f.type };
+    if (f.placeholder) meta.placeholder = f.placeholder;
+    if (f.required) meta.required = true;
+    if (f.editableBeforeGame !== undefined) meta.editableBeforeGame = f.editableBeforeGame;
+    if (f.options) meta.options = f.options;
+    if (f.allowCustomOption) meta.allowCustomOption = true;
+    if (f.min !== undefined) meta.min = f.min;
+    if (f.max !== undefined) meta.max = f.max;
+    if (f.step !== undefined) meta.step = f.step;
+    fieldMeta[f.key] = meta;
+  }
+  if (Object.keys(fieldMeta).length > 0) map['_fieldMeta'] = fieldMeta;
+  // 注入字段顺序，用于恢复原始字段排列
+  if (fields.length > 0) map['_fieldOrder'] = fields.map(f => f.key);
+  return map;
+}
+
+/**
+ * 将字段列表转为包含元数据的完整世界数据对象（用于 SVG 注入）
+ * @param fields 字段列表
+ * @param plugins 可选的插件 ID 列表，会被注入到 world-data 中
+ */
+export function fieldsToWorldData(fields: WorldCardField[], plugins?: string[]): Record<string, unknown> {
+  // 复用 fieldsToWorldSetting 的逻辑（已包含 _fieldMeta）
+  const data = fieldsToWorldSetting(fields);
+  // 注入插件列表
+  if (plugins && plugins.length > 0) {
+    data['_plugins'] = plugins;
+  }
+  return data;
+}
+
+/**
+ * 将 SVG 代码注入 world-data script 标签（替换已有的或新增）
+ */
+export function injectWorldData(svgCode: string, worldData: Record<string, unknown>): string {
+  const json = JSON.stringify(worldData, null, 2);
+  const scriptTag = `<script type="application/json" id="world-data">\n${json}\n</script>`;
+
+  // 移除已有的 world-data script
+  let cleaned = svgCode.replace(/<script[^>]*id="world-data"[^>]*>[\s\S]*?<\/script>/gi, '').trim();
+
+  // 在 </svg> 前注入
+  if (cleaned.endsWith('</svg>')) {
+    cleaned = cleaned.slice(0, -6) + '\n' + scriptTag + '\n</svg>';
+  } else {
+    cleaned += '\n' + scriptTag + '\n</svg>';
+  }
+  return cleaned;
+}