tavern-harness 0.1.0

package/src/types/models.ts

@@ -0,0 +1,364 @@
+// ============================================================
+// 领域模型 — 与 MyAgent-Android 的 Room 实体一一对应
+// ============================================================
+
+export type SessionMode = 'STANDARD' | 'NPC' | 'GROUP';
+export type ParticipantKind = 'PLAYER' | 'NPC';
+export type TurnOrderMode = 'PRESET' | 'RANDOM';
+export type Role = 'system' | 'user' | 'assistant' | 'tool';
+export type ThemeModeId = 'system' | 'light' | 'dark';
+export type ReasoningEffort = 'auto' | 'off' | 'low' | 'medium' | 'xhigh';
+export type ContextCompressionThreshold = 'off' | number;
+/** 界面语言：null = 跟随浏览器语言 */
+export type AppLanguage = 'zh-CN' | 'zh-TW' | 'en' | null;
+
+/**
+ * 工具结果展示引用（file_display 等内置展示工具的回看锚点）。
+ * 持久化在 ChatMessage.displayRef，供对话流里的「查看」按钮随时重开弹窗。
+ */
+export interface DisplayFileRef {
+  /** 工作区相对路径（与 file_read / file_write 同一沙箱工作区） */
+  path: string;
+  /** 展示方式：text（按扩展名智能渲染）/ image / html */
+  kind: 'text' | 'image' | 'html';
+  /** 展示标题（默认取文件名） */
+  title?: string;
+  /** 产生该展示的会话 id（回看时按其专属工作目录解析；null = 共享工作区） */
+  sessionId?: number | null;
+  /** 提示附带的展示结果文本（工具结果的持久化，回看时无需重读文件） */
+  cachedContent?: string;
+}
+
+export interface AppSettings {
+  id: number;
+  baseUrl: string;
+  apiKey: string;
+  defaultModel: string;
+  defaultProviderId: number | null;
+  themeMode: ThemeModeId;
+  /** 界面语言；null = 跟随浏览器语言 */
+  language: AppLanguage;
+  temperature: number;
+  topP: number;
+  maxTokens: number;
+  topK: number;
+  frequencyPenalty: number;
+  presencePenalty: number;
+  repetitionPenalty: number;
+  reasoningEffort: ReasoningEffort;
+  /** 'off' 或完整对话单元数（1–100）；每 N 个单元预压缩，再积累 N 个单元后生效。群聊按玩家发言批次计数。 */
+  contextCompressionThreshold: ContextCompressionThreshold;
+  seed: number;
+  stop: string;
+  isStreaming: boolean;
+  isThinkingModeEnabled: boolean;
+  isToolCallsEnabled: boolean;
+  statsResetTime: number | null;
+}
+
+export interface ApiProvider {
+  id?: number;
+  name: string;
+  baseUrl: string;
+  apiKey: string;
+  isEnabled: boolean;
+  cachedModelsCsv: string;
+  /** JSON object mapping API model IDs to user-facing aliases. */
+  modelAliasesJson?: string;
+  /** JSON array of model IDs enabled for use. Missing values keep legacy models enabled. */
+  enabledModelIdsJson?: string;
+  createdAt: number;
+}
+
+/** 可在对话模型选择器中选择的模型，模型 id 在不同 Provider 中可重复。 */
+export interface ProviderModelOption {
+  providerId: number;
+  modelId: string;
+  label: string;
+}
+
+export function enabledModelIds(provider: ApiProvider): Set<string> {
+  const availableModels = provider.cachedModelsCsv.split(',').map((model) => model.trim()).filter(Boolean);
+  if (!provider.enabledModelIdsJson) return new Set(availableModels);
+  try {
+    const modelIds: unknown = JSON.parse(provider.enabledModelIdsJson);
+    if (!Array.isArray(modelIds)) return new Set(availableModels);
+    return new Set(modelIds.filter((model): model is string => typeof model === 'string' && availableModels.includes(model)));
+  } catch {
+    return new Set(availableModels);
+  }
+}
+
+export function modelAliases(provider: ApiProvider): Record<string, string> {
+  try {
+    const aliases: unknown = JSON.parse(provider.modelAliasesJson || '{}');
+    if (!aliases || typeof aliases !== 'object' || Array.isArray(aliases)) return {};
+    return Object.fromEntries(
+      Object.entries(aliases).filter(([model, alias]) => model.trim() && typeof alias === 'string' && alias.trim()),
+    );
+  } catch {
+    return {};
+  }
+}
+
+export function displayModelName(providers: ApiProvider[], model: string, providerId?: number | null): string {
+  const provider = providerId == null
+    ? providers.find((candidate) => candidate.isEnabled && enabledModelIds(candidate).has(model))
+    : providers.find((candidate) => candidate.id === providerId && candidate.isEnabled && enabledModelIds(candidate).has(model));
+  return provider ? modelAliases(provider)[model]?.trim() || model : model;
+}
+
+export interface NpcCharacter {
+  id?: number;
+  name: string;
+  prompt: string;
+  greeting: string;
+  /** 额外开场白（创建对话时随机选用一个，含 greeting） */
+  alternateGreetings?: string[];
+  avatarColorOrdinal: number;
+  avatarDataUrl?: string | null;
+  enabledToolNames: string[]; // CSV in DB; array in memory
+  isBuiltIn: boolean;
+  /** 标识默认内置角色「酒馆老板」，与其他内置角色区分。 */
+  isTavernKeeper?: boolean;
+  createdAt: number;
+}
+
+export interface ChatSession {
+  id?: number;
+  title: string;
+  mode: SessionMode;
+  associatedId: number | null; // NPC id（NPC 模式）
+  worldBookId: number | null;
+  userPersonaNpcId: number | null;
+  enableGreeting?: boolean;
+  /** 群聊仅 @ 模式：玩家必须点名角色，角色未点名时自动把话题交还给玩家。 */
+  mentionOnlyMode?: boolean;
+  turnOrderMode: TurnOrderMode;
+  /**
+   * 会话专属沙箱工作目录名（含当前酒馆实例标识和会话 id）。
+   * 该会话的所有工具调用（shell / file_read / file_write / 脚本执行等）
+   * 都在这个独立目录下进行，会话和酒馆实例之间相互隔离。
+   * 内置酒馆老板的 NPC 单人会话例外地固定使用 public；旧会话未设置时使用当前酒馆实例的专属目录。
+   */
+  workspaceDir?: string | null;
+  turnQueueJson: string;
+  /** 各循环的完整初始顺序历史（JSON 二维数组），用于群聊发言队列面板展示完整历史 */
+  turnQueueHistoryJson: string;
+  loopIndex: number;
+  lastMessage: string;
+  /** 置顶标记：1 = 置顶（侧边栏会话列表置顶区），0 = 未置顶。默认 0（false） */
+  pinned: number;
+  updatedAt: number;
+  createdAt: number;
+}
+
+export interface ChatParticipant {
+  sessionId: number;
+  participantId: number;
+  kind: ParticipantKind;
+  npcId: number | null;
+  displayName: string;
+  seatOrder: number;
+}
+
+export interface ToolCallRecord {
+  id: string;
+  name: string;
+  argumentsJson: string;
+  contentOffset: number;
+}
+
+export interface ChatAttachmentInfo {
+  // 保存元信息，dataUrl 单独存字段（避免所有消息都过大）
+  displayName: string;
+}
+
+export interface ChatMessage {
+  id?: number;
+  sessionId: number;
+  role: Role;
+  speakerParticipantId: number | null;
+  speakerName: string | null;
+  content: string;
+  /** 会话初始化时写入的角色开场白；不支持重新生成。 */
+  isOpeningGreeting?: boolean;
+  /** 仅供界面显示与群聊转交的自动 @ 提示；不会进入模型上下文。 */
+  displayHandoffMention?: string | null;
+  /** 持久化用 JSON 字符串数组 */
+  toolCallsJson: string;
+  toolCallId: string | null;
+  thinkingContent: string | null;
+  /** 群聊：该消息所属的循环序号（0 起）。用于对话与发言队列联动滚动 / 点击定位 */
+  loopIndex: number | null;
+  timestamp: number;
+  latencyMs: number | null;
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens: number;
+  tokensPerSec: number | null;
+  modelUsed: string | null;
+  /** dataUrl 或 URL 的附件列表 */
+  attachments: string[];
+  attachmentInfos: ChatAttachmentInfo[];
+  /**
+   * 展示类工具（file_display）的结果锚点：JSON 字符串化的 DisplayFileRef。
+   * 工具结果消息携带它，UI 据此渲染「查看」按钮并提供弹窗回看。
+   */
+  displayRef: string | null;
+  rawRequestBody: string | null;
+  rawResponseBody: string | null;
+}
+
+/** 保留原始消息的上下文压缩记录，仅用于构建后续 LLM 请求。 */
+export interface ContextCompression {
+  id?: number;
+  sessionId: number;
+  summary: string;
+  endMessageId: number;
+  endTimestamp: number;
+  createdAt: number;
+  /** 生成该记录时使用的压缩轮数；旧记录缺失时回退到当前设置。 */
+  threshold?: number;
+  /** 请求上下文压缩时发送给模型的原始请求体。 */
+  rawRequestBody: string | null;
+  /** 上下文压缩模型返回的原始响应体。 */
+  rawResponseBody: string | null;
+}
+
+export interface CareerStatsTotal {
+  id: number;
+  inputTokens: number;
+  outputTokens: number;
+  totalRounds: number;
+}
+
+export interface CareerNpcStat {
+  npcId: number;
+  npcName: string;
+  rounds: number;
+}
+
+/** 成就解锁记录 */
+export interface AchievementUnlock {
+  id?: number;
+  achievementId: string;
+  unlockedAt: number;
+}
+
+export interface McpTool {
+  id?: number;
+  name: string;
+  jsonContent: string; // 标准 OpenAI tool JSON
+  executionJson: string | null; // 生成式技能的声明式实现
+  isBuiltIn: boolean;
+  /** 来源：builtin 内置（读写受保护）/ custom 自定义（create_skill 创建）/ imported 导入（玩法导入） */
+  origin?: 'builtin' | 'custom' | 'imported';
+  createdAt: number;
+  displayOrder: number;
+}
+
+export interface WorldBook {
+  id?: number;
+  name: string;
+  content: string;
+  imageUri: string | null;
+  /** 内置世界书的名称受保护，但内容允许编辑和重置。 */
+  isBuiltIn?: boolean;
+  createdAt: number;
+}
+
+// ---------- 网络层模型 ----------
+
+export interface NetworkContentPart {
+  type: 'text' | 'image_url' | 'video_url';
+  text?: string;
+  image_url?: { url: string };
+  video_url?: { url: string };
+}
+
+export interface NetworkMessage {
+  role: Role;
+  content: string | NetworkContentPart[] | null;
+  tool_calls?: NetworkToolCall[];
+  tool_call_id?: string;
+}
+
+export interface NetworkToolFunction {
+  name: string;
+  arguments: string;
+}
+
+export interface NetworkToolCall {
+  id: string;
+  type: 'function';
+  function: NetworkToolFunction;
+}
+
+export interface ChatCompletionTool {
+  type: 'function';
+  function: {
+    name: string;
+    description?: string;
+    parameters: Record<string, unknown>;
+  };
+}
+
+export interface ChatCompletionRequest {
+  model: string;
+  messages: NetworkMessage[];
+  tools?: ChatCompletionTool[];
+  tool_choice?: string;
+  temperature: number;
+  top_p?: number;
+  max_tokens?: number;
+  stream: boolean;
+  stream_options?: { include_usage: boolean };
+  enable_thinking?: boolean;
+  reasoning_effort?: string;
+  chat_template_kwargs?: { enable_thinking: boolean; preserve_thinking: boolean };
+  top_k?: number;
+  frequency_penalty?: number;
+  presence_penalty?: number;
+  repetition_penalty?: number;
+}
+
+// ---------- 流式分块 ----------
+
+export type ChatStreamChunk =
+  | { type: 'raw'; line: string }
+  | { type: 'content'; text: string }
+  | { type: 'thinking'; text: string }
+  | { type: 'tool_call'; id: string; name: string; argJson: string }
+  | { type: 'usage'; prompt: number; completion: number; total: number }
+  | { type: 'error'; message: string }
+  | { type: 'done' };
+
+export interface ToolConfirmationRequest {
+  sessionId: number;
+  toolName: string;
+  title: string;
+  message: string;
+  inlineCode?: string;
+  argsJson: string;
+  kind?: 'tool' | 'limit';
+}
+
+export interface GeneratedSkillExecution {
+  type: 'template' | 'http_get' | 'javascript' | 'file_read' | 'file_write' | 'shell';
+  // template
+  template?: string;
+  // http_get
+  url?: string;
+  // javascript
+  code?: string;
+  // file_read / file_write
+  path?: string;
+  content?: string;
+  json_content?: unknown;
+  append?: boolean;
+  append_newline?: boolean;
+  // shell
+  script?: string;
+  [k: string]: unknown;
+}

package/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "types": ["vite/client"]
+  },
+  "include": ["src"]
+}

package/vite.config.ts

@@ -0,0 +1,273 @@
+import { defineConfig, type Plugin } from 'vite';
+import react from '@vitejs/plugin-react';
+import http from 'node:http';
+import https from 'node:https';
+import net from 'node:net';
+import { randomBytes } from 'node:crypto';
+import { spawn, type ChildProcess } from 'node:child_process';
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+
+/**
+ * CORS 转发中间件：为本地（无 CORS 头）的 OpenAI 兼容服务提供同源代理。
+ * Base URL 填 http://localhost:5173/api/192.168.50.175:8788/ 即可；
+ * /api/<host>/ 之后的路径（含 query）原样转发到 http://<host>/。
+ */
+function corsProxyPlugin(): Plugin {
+  return {
+    name: 'cors-proxy',
+    configureServer(server) {
+      server.middlewares.use((req: IncomingMessage, res: ServerResponse, next) => {
+        const url = req.url || '';
+        const m = /^\/api\/([^/]+)(\/[^?]*)?(\?.*)?$/.exec(url);
+        if (!m) return next();
+
+        const rawHost = m[1]; // e.g. 192.168.50.175:8788
+        const path = (m[2] || '') + (m[3] || '');
+        const isHttps = rawHost.startsWith('https://');
+        const host = rawHost.replace(/^https?:\/\//, '');
+        const [hostname, portStr] = host.split(':');
+        const port = portStr ? parseInt(portStr, 10) : isHttps ? 443 : 80;
+
+        const mod = isHttps ? https : http;
+        const forwardedHeaders: Record<string, string | string[] | undefined> = {
+          ...(req.headers as Record<string, string | string[] | undefined>),
+          host: host,
+        };
+
+        const proxyReq = mod.request(
+          {
+            protocol: isHttps ? 'https:' : 'http:',
+            hostname,
+            port,
+            path,
+            method: req.method,
+            headers: forwardedHeaders,
+          },
+          (proxyRes) => {
+            res.writeHead(proxyRes.statusCode || 502, proxyRes.headers);
+            proxyRes.pipe(res);
+          }
+        );
+        proxyReq.on('error', (e: Error) => {
+          res.writeHead(502, { 'Content-Type': 'text/plain' });
+          res.end(`proxy error: ${e.message}`);
+        });
+        req.pipe(proxyReq);
+      });
+    },
+  };
+}
+
+/**
+ * 生成式技能真实 Shell 执行端点。
+ * 规则：/api-v2/exec 转发到本地 sandbox-server（127.0.0.1:17891，端口从 .sandbox-port 锁文件读取）。
+ * 若 sandbox 未启动，会在收到请求时自动拉起 sandbox-server 子进程，无需手动执行 node sandbox-server.mjs。
+ */
+function sandboxProxyPlugin(): Plugin {
+  let sandboxChild: ChildProcess | null = null;
+  let starting: Promise<number | null> | null = null;
+  let childPort: number | null = null;
+  const serviceToken = randomBytes(32).toString('base64url');
+  const approvalToken = randomBytes(32).toString('base64url');
+  const lockPath = join(process.cwd(), '.sandbox-port');
+  const SANDBOX_SCRIPT = join(process.cwd(), 'sandbox-server.mjs');
+  const DEFAULT_PORT = 17891;
+
+  const loadPort = () => {
+    try {
+      if (existsSync(lockPath)) {
+        const p = parseInt(readFileSync(lockPath, 'utf8').trim(), 10);
+        if (!Number.isNaN(p) && p > 0) return p;
+      }
+    } catch {
+      /* ignore */
+    }
+    return null;
+  };
+
+  /** 探测 127.0.0.1:port 是否已有服务监听 */
+  const portOpen = (port: number) =>
+    new Promise<boolean>((resolve) => {
+      const sock = net.connect({ host: '127.0.0.1', port, timeout: 400 });
+      sock.once('connect', () => {
+        sock.destroy();
+        resolve(true);
+      });
+      sock.once('timeout', () => {
+        sock.destroy();
+        resolve(false);
+      });
+      sock.once('error', () => resolve(false));
+    });
+
+  const serviceReady = (port: number) =>
+    new Promise<boolean>((resolve) => {
+      const body = JSON.stringify({ script: 'echo ready' });
+      const request = http.request({
+        hostname: '127.0.0.1',
+        port,
+        path: '/exec',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(body),
+          'X-Command-Service-Token': serviceToken,
+        },
+        timeout: 400,
+      }, (response) => {
+        response.resume();
+        resolve(response.statusCode === 200);
+      });
+      request.once('timeout', () => {
+        request.destroy();
+        resolve(false);
+      });
+      request.once('error', () => resolve(false));
+      request.end(body);
+    });
+
+  const findAvailablePort = async () => {
+    for (let port = DEFAULT_PORT; port < DEFAULT_PORT + 20; port++) {
+      if (!(await portOpen(port))) return port;
+    }
+    return null;
+  };
+
+  const stopSandbox = () => {
+    const child = sandboxChild;
+    sandboxChild = null;
+    childPort = null;
+    try {
+      child?.kill();
+    } catch {
+      /* ignore */
+    }
+  };
+
+  /** 确保 sandbox-server 在运行：已有则复用；否则自动拉起并等待就绪 */
+  const ensureSandbox = async (): Promise<number | null> => {
+    if (starting) return starting;
+    starting = (async () => {
+      // 1) 复用已在运行的沙箱（手动启动/上次 vite 拉起）
+      const known = loadPort() ?? DEFAULT_PORT;
+      if ((await portOpen(known)) && (await serviceReady(known))) return known;
+      if (known !== DEFAULT_PORT && (await portOpen(DEFAULT_PORT)) && (await serviceReady(DEFAULT_PORT))) return DEFAULT_PORT;
+      // 2) 自动拉起子进程
+      if (!sandboxChild && existsSync(SANDBOX_SCRIPT)) {
+        const availablePort = await findAvailablePort();
+        if (availablePort == null) return null;
+        childPort = availablePort;
+        const child = spawn(process.execPath, [SANDBOX_SCRIPT, String(availablePort)], {
+          cwd: process.cwd(),
+          stdio: 'ignore',
+          windowsHide: true,
+          env: {
+            ...process.env,
+            COMMAND_SERVICE_TOKEN: serviceToken,
+            COMMAND_APPROVAL_TOKEN: approvalToken,
+          },
+        });
+        sandboxChild = child;
+        child.on('exit', () => {
+          if (sandboxChild !== child) return;
+          sandboxChild = null;
+          childPort = null;
+        });
+        child.unref();
+        process.once('exit', () => {
+          try {
+            child.kill();
+          } catch {
+            /* ignore */
+          }
+        });
+      }
+      if (!sandboxChild) return null;
+      // 3) 等待就绪（最多 3s）
+      for (let i = 0; i < 30; i++) {
+        await new Promise((r) => setTimeout(r, 100));
+        if (childPort != null && (await serviceReady(childPort))) return childPort;
+      }
+      return null;
+    })().finally(() => {
+      starting = null;
+    });
+    return starting;
+  };
+
+  return {
+    name: 'sandbox-proxy',
+    closeBundle() {
+      stopSandbox();
+    },
+    configureServer(server) {
+      server.watcher.add(SANDBOX_SCRIPT);
+      server.watcher.on('change', (path) => {
+        if (path === SANDBOX_SCRIPT) stopSandbox();
+      });
+      server.middlewares.use((req: IncomingMessage, res: ServerResponse, next) => {
+        // 转发与沙箱服务相关的端点：/exec 及真实工作区文件端点
+        const m = /^\/api-v2\/(exec|approve|file_read|file_write|file_delete|file_list|session_create|session_delete)$/.exec(req.url || '');
+        if (!m || req.method !== 'POST') return next();
+        const origin = req.headers.origin;
+        if (!origin || req.headers['sec-fetch-site'] !== 'same-origin') {
+          res.writeHead(403, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, message: 'sandbox access requires a same-origin browser request' }));
+          return;
+        }
+        let originHost = '';
+        try {
+          originHost = new URL(origin).host;
+        } catch {
+          res.writeHead(403, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, message: 'invalid origin' }));
+          return;
+        }
+        if (originHost !== req.headers.host) {
+          res.writeHead(403, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, message: 'cross-origin request denied' }));
+          return;
+        }
+        void (async () => {
+          const port = await ensureSandbox();
+          if (!port) {
+            res.writeHead(503, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, message: 'sandbox server not running' }));
+            return;
+          }
+          const forwardedHeaders = {
+            ...req.headers,
+            'x-command-service-token': serviceToken,
+            ...(m[1] === 'approve' ? { 'x-command-approval-token': approvalToken } : {}),
+          };
+          const proxyReq = http.request(
+            { protocol: 'http:', hostname: '127.0.0.1', port, path: `/${m[1]}`, method: 'POST', headers: forwardedHeaders },
+            (proxyRes) => {
+              res.writeHead(proxyRes.statusCode || 502, proxyRes.headers);
+              proxyRes.pipe(res);
+            }
+          );
+          proxyReq.on('error', (e: Error) => {
+            res.writeHead(502, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, message: `sandbox proxy error: ${e.message}` }));
+          });
+          req.pipe(proxyReq);
+        })();
+      });
+    },
+  };
+}
+
+export default defineConfig({
+  plugins: [react(), corsProxyPlugin(), sandboxProxyPlugin()],
+  server: {
+    port: 5173,
+    open: false,
+  },
+  build: {
+    target: 'es2022',
+    chunkSizeWarningLimit: 1200,
+  },
+});