tavern-harness 0.1.12 → 0.1.13

package/persistence-server.mjs

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+// Server-side SQLite persistence service. It is intentionally reachable only
+// through Vite's same-origin proxy; this process itself listens on loopback.
+
+import { createServer } from 'node:http';
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+
+const PORT = Number(process.argv[2] || process.env.PERSISTENCE_PORT || 17892);
+// 记录读写（图片/附件）走大上限；锁和健康检查的请求体很小，单独收紧。
+const MAX_RECORD_BODY_BYTES = 30 * 1024 * 1024;
+const MAX_CONTROL_BODY_BYTES = 1024 * 1024;
+const SERVICE_TOKEN = process.env.PERSISTENCE_SERVICE_TOKEN;
+if (!SERVICE_TOKEN) {
+  console.error('[persistence-service] missing PERSISTENCE_SERVICE_TOKEN');
+  process.exit(1);
+}
+
+const dataDir = resolve(process.env.TAVERN_HARNESS_DATA_DIR || join(homedir(), '.tavern-harness'));
+mkdirSync(dataDir, { recursive: true });
+const databasePath = join(dataDir, 'tavern-harness.sqlite');
+const database = new DatabaseSync(databasePath);
+database.exec(`
+  PRAGMA journal_mode = WAL;
+  PRAGMA foreign_keys = ON;
+  PRAGMA busy_timeout = 5000;
+  CREATE TABLE IF NOT EXISTS app_records (
+    collection TEXT NOT NULL,
+    record_key TEXT NOT NULL,
+    value_json TEXT NOT NULL,
+    updated_at INTEGER NOT NULL,
+    PRIMARY KEY (collection, record_key)
+  );
+  CREATE INDEX IF NOT EXISTS idx_app_records_collection ON app_records(collection);
+  CREATE TABLE IF NOT EXISTS record_sequences (
+    collection TEXT PRIMARY KEY,
+    next_id INTEGER NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS service_state (
+    state_key TEXT PRIMARY KEY,
+    value_json TEXT NOT NULL
+  );
+`);
+
+const getServiceState = database.prepare('SELECT value_json FROM service_state WHERE state_key = ?');
+const saveServiceState = database.prepare(`
+  INSERT INTO service_state (state_key, value_json) VALUES (?, ?)
+  ON CONFLICT(state_key) DO UPDATE SET value_json = excluded.value_json
+`);
+const deleteServiceState = database.prepare('DELETE FROM service_state WHERE state_key = ?');
+
+function loadWriteLock() {
+  const row = getServiceState.get('write_lock');
+  if (!row) return null;
+  try {
+    const lock = JSON.parse(row.value_json);
+    return typeof lock?.clientId === 'string' && typeof lock?.leaseId === 'string' ? lock : null;
+  } catch {
+    return null;
+  }
+}
+
+let writeLock = loadWriteLock();
+
+function setWriteLock(lock) {
+  writeLock = lock;
+  if (lock) saveServiceState.run('write_lock', JSON.stringify(lock));
+  else deleteServiceState.run('write_lock');
+}
+
+function json(res, status, body) {
+  res.writeHead(status, {
+    'Content-Type': 'application/json; charset=utf-8',
+    'Cache-Control': 'no-store',
+  });
+  res.end(JSON.stringify(body));
+}
+
+function readJson(req, maxBytes) {
+  return new Promise((resolveBody, reject) => {
+    let raw = '';
+    let bytes = 0;
+    let tooLarge = false;
+    req.setEncoding('utf8');
+    req.on('data', (chunk) => {
+      if (tooLarge) return; // 拒绝后继续排空请求体，但不再累计内存
+      bytes += Buffer.byteLength(chunk, 'utf8');
+      if (bytes > maxBytes) {
+        tooLarge = true;
+        const error = new Error('Request body is too large');
+        error.status = 413;
+        reject(error);
+        return;
+      }
+      raw += chunk;
+    });
+    req.on('end', () => {
+      if (tooLarge) return;
+      if (!raw) return resolveBody({});
+      try {
+        resolveBody(JSON.parse(raw));
+      } catch {
+        reject(new Error('Invalid JSON request body'));
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+function tokenMatches(value) {
+  if (typeof value !== 'string') return false;
+  const expected = Buffer.from(SERVICE_TOKEN);
+  const actual = Buffer.from(value);
+  return expected.length === actual.length && timingSafeEqual(expected, actual);
+}
+
+function validCollection(value) {
+  return typeof value === 'string' && /^[a-z][a-z0-9_]{0,63}$/i.test(value);
+}
+
+function validKey(value) {
+  return typeof value === 'string' && value.length > 0 && value.length <= 255;
+}
+
+function lockState(clientId) {
+  return {
+    writable: Boolean(writeLock && writeLock.clientId === clientId),
+    held: Boolean(writeLock),
+  };
+}
+
+function requireWriter(clientId) {
+  if (!writeLock || writeLock.clientId !== clientId) {
+    const error = new Error(writeLock ? 'Another browser currently holds the write lock' : 'Write lock required');
+    error.status = 423;
+    throw error;
+  }
+}
+
+function saveRecord(collection, key, value) {
+  database.prepare(`
+    INSERT INTO app_records (collection, record_key, value_json, updated_at)
+    VALUES (?, ?, ?, ?)
+    ON CONFLICT(collection, record_key) DO UPDATE SET
+      value_json = excluded.value_json,
+      updated_at = excluded.updated_at
+  `).run(collection, key, JSON.stringify(value), Date.now());
+}
+
+const getRecord = database.prepare('SELECT value_json, updated_at FROM app_records WHERE collection = ? AND record_key = ?');
+const listRecords = database.prepare('SELECT record_key, value_json, updated_at FROM app_records WHERE collection = ? ORDER BY record_key');
+const deleteRecord = database.prepare('DELETE FROM app_records WHERE collection = ? AND record_key = ?');
+const clearCollection = database.prepare('DELETE FROM app_records WHERE collection = ?');
+const nextNumericRecordKey = database.prepare(`
+  SELECT COALESCE(MAX(CAST(record_key AS INTEGER)), 0) + 1 AS next_key
+  FROM app_records
+  WHERE collection = ? AND record_key GLOB '[0-9]*'
+`);
+const getRecordSequence = database.prepare('SELECT next_id FROM record_sequences WHERE collection = ?');
+const saveRecordSequence = database.prepare(`
+  INSERT INTO record_sequences (collection, next_id) VALUES (?, ?)
+  ON CONFLICT(collection) DO UPDATE SET next_id = excluded.next_id
+`);
+
+function allocateNumericRecordId(collection) {
+  database.exec('BEGIN IMMEDIATE');
+  try {
+    const sequence = getRecordSequence.get(collection);
+    const initialId = Number(nextNumericRecordKey.get(collection).next_key);
+    const id = Math.max(Number(sequence?.next_id) || 0, initialId);
+    saveRecordSequence.run(collection, id + 1);
+    database.exec('COMMIT');
+    return id;
+  } catch (error) {
+    database.exec('ROLLBACK');
+    throw error;
+  }
+}
+
+const server = createServer(async (req, res) => {
+  if (!tokenMatches(req.headers['x-persistence-service-token'])) {
+    json(res, 401, { ok: false, message: 'Unauthorized persistence service request' });
+    return;
+  }
+
+  try {
+    const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+    const pathname = url.pathname.replace(/\/+$/, '') || '/';
+    if (req.method === 'GET' && pathname === '/health') {
+      json(res, 200, { ok: true, databasePath, lock: lockState(null) });
+      return;
+    }
+    if (req.method !== 'POST') {
+      json(res, 405, { ok: false, message: 'Method not allowed' });
+      return;
+    }
+
+    const bodyLimit = pathname.startsWith('/records/') ? MAX_RECORD_BODY_BYTES : MAX_CONTROL_BODY_BYTES;
+    const body = await readJson(req, bodyLimit);
+    const clientId = typeof body.clientId === 'string' ? body.clientId : '';
+
+    if (pathname === '/lock/status') {
+      json(res, 200, { ok: true, lock: lockState(clientId) });
+      return;
+    }
+    if (pathname === '/lock/acquire' || pathname === '/lock/takeover') {
+      const existing = writeLock;
+      if (!clientId || clientId.length > 255) {
+        json(res, 400, { ok: false, message: 'A valid clientId is required' });
+        return;
+      }
+      if (existing && existing.clientId !== clientId && pathname !== '/lock/takeover') {
+        json(res, 423, { ok: false, message: 'Another browser currently holds the write lock', lock: lockState(clientId) });
+        return;
+      }
+      setWriteLock({ clientId, leaseId: randomBytes(24).toString('base64url') });
+      json(res, 200, { ok: true, leaseId: writeLock.leaseId, lock: lockState(clientId) });
+      return;
+    }
+    if (!pathname.startsWith('/records/')) {
+      json(res, 404, { ok: false, message: `Unknown persistence endpoint: ${pathname}` });
+      return;
+    }
+
+    const collection = body.collection;
+    if (!validCollection(collection)) {
+      json(res, 400, { ok: false, message: `Invalid collection for ${pathname}` });
+      return;
+    }
+
+    if (pathname === '/records/list') {
+      const records = listRecords.all(collection).map((row) => ({
+        key: row.record_key,
+        value: JSON.parse(row.value_json),
+        updatedAt: row.updated_at,
+      }));
+      json(res, 200, { ok: true, records });
+      return;
+    }
+    if (pathname === '/records/get') {
+      if (!validKey(body.key)) {
+        json(res, 400, { ok: false, message: 'Invalid record key' });
+        return;
+      }
+      const record = getRecord.get(collection, body.key);
+      json(res, 200, {
+        ok: true,
+        record: record ? { key: body.key, value: JSON.parse(record.value_json), updatedAt: record.updated_at } : null,
+      });
+      return;
+    }
+    if (pathname === '/records/allocate-id') {
+      requireWriter(clientId);
+      json(res, 200, { ok: true, id: allocateNumericRecordId(collection) });
+      return;
+    }
+    if (pathname === '/records/put') {
+      if (!validKey(body.key)) {
+        json(res, 400, { ok: false, message: 'Invalid record key' });
+        return;
+      }
+      requireWriter(clientId);
+      saveRecord(collection, body.key, body.value);
+      json(res, 200, { ok: true });
+      return;
+    }
+    if (pathname === '/records/delete') {
+      if (!validKey(body.key)) {
+        json(res, 400, { ok: false, message: 'Invalid record key' });
+        return;
+      }
+      requireWriter(clientId);
+      deleteRecord.run(collection, body.key);
+      json(res, 200, { ok: true });
+      return;
+    }
+    if (pathname === '/records/clear') {
+      requireWriter(clientId);
+      clearCollection.run(collection);
+      json(res, 200, { ok: true });
+      return;
+    }
+
+    json(res, 404, { ok: false, message: 'Unknown persistence endpoint' });
+  } catch (error) {
+    const status = typeof error?.status === 'number' ? error.status : 500;
+    json(res, status, { ok: false, message: error instanceof Error ? error.message : 'Unexpected persistence service error' });
+  }
+});
+
+server.listen(PORT, '127.0.0.1', () => {
+  console.log(`[persistence-service] listening on 127.0.0.1:${PORT}; data: ${databasePath}`);
+});
+
+function shutdown() {
+  database.close();
+  server.close(() => process.exit(0));
+}
+process.once('SIGINT', shutdown);
+process.once('SIGTERM', shutdown);

package/src/App.tsx

@@ -21,8 +21,14 @@ import './theme/chat.css';
 import './theme/views.css';
 
 export default function App() {
-  const initialized = useStore((s) => s.initialized);
+  const [takingControl, setTakingControl] = useState(false);
+  const initStatus = useStore((s) => s.initStatus);
+  const initError = useStore((s) => s.initError);
+  const addToast = useStore((s) => s.addToast);
+  const readOnly = useStore((s) => s.readOnly);
   const init = useStore((s) => s.init);
+  const syncControlState = useStore((s) => s.syncControlState);
+  const takeOverControl = useStore((s) => s.takeOverControl);
   const activeView = useStore((s) => s.activeView);
   const activeSessionId = useStore((s) => s.activeSessionId);
   const sessions = useStore((s) => s.sessions);
@@ -30,6 +36,7 @@ export default function App() {
   const contextCompressions = useStore((s) => s.contextCompressions);
   const participants = useStore((s) => s.participants);
   const isStreaming = useStore((s) => s.streaming.sessionId != null);
+  const t = useT();
 
   useEffect(() => {
     registerUnlockDispatcher(async (achievement, total) => {
@@ -43,6 +50,12 @@ export default function App() {
     init();
   }, [init]);
 
+  useEffect(() => {
+    if (readOnly) return;
+    const timer = window.setInterval(() => void syncControlState(), 1_000);
+    return () => window.clearInterval(timer);
+  }, [readOnly, syncControlState]);
+
   useEffect(() => {
     if (!isStreaming) return;
     const confirmLeave = (event: BeforeUnloadEvent) => {
@@ -58,13 +71,64 @@ export default function App() {
   const sessionParticipants = activeSessionId != null ? (participants[activeSessionId] ?? []) : [];
   const isStreamingSession = useStore((s) => s.streaming.sessionId === activeSessionId);
 
-  if (!initialized) {
+  const handleTakeOverControl = async () => {
+    setTakingControl(true);
+    try {
+      await takeOverControl();
+    } catch (error) {
+      console.error('Failed to take over control', error);
+      addToast(t('control.takeOverFailed'), 'error');
+    } finally {
+      setTakingControl(false);
+    }
+  };
+
+  if (initStatus === 'loading') {
     return <div className="tav-bg" />;
   }
 
+  if (initStatus === 'error') {
+    return (
+      <>
+        <div className="tav-bg" />
+        <div className="init-error" role="alertdialog" aria-modal="true" aria-labelledby="init-error-title">
+          <div className="init-error-inner">
+            <h1 id="init-error-title">{t('init.failed')}</h1>
+            <p className="init-error-hint">{t('init.failedHint')}</p>
+            <p className="init-error-detail">{initError}</p>
+            {/* 焦点直接落在唯一可操作项上，键盘 / 读屏用户不必先找 */}
+            <button type="button" className="init-error-retry" autoFocus onClick={() => void init()}>
+              {t('init.retry')}
+            </button>
+          </div>
+        </div>
+      </>
+    );
+  }
+
   return (
     <>
       <div className="tav-bg" />
+      {readOnly && (
+        <div
+          role="dialog"
+          aria-modal="true"
+          aria-label={t('control.dialogLabel')}
+          style={{ position: 'fixed', inset: 0, zIndex: 10000, display: 'grid', placeItems: 'center', backdropFilter: 'blur(16px)', WebkitBackdropFilter: 'blur(16px)' }}
+        >
+          <main style={{ textAlign: 'center' }}>
+            <h1>{t('control.activeElsewhere')}</h1>
+            <button
+              type="button"
+              disabled={takingControl}
+              onClick={() => void handleTakeOverControl()}
+              style={{ padding: '10px 18px', border: 0, borderRadius: 8, cursor: takingControl ? 'wait' : 'pointer', fontWeight: 700, background: 'color-mix(in srgb, var(--primary) 25%, transparent)', color: 'var(--primary)' }}
+            >
+              {t('control.takeOverHere')}
+            </button>
+          </main>
+        </div>
+      )}
       <div className="app-shell">
         <Sidebar />
         <main className="main-area">
@@ -92,12 +156,12 @@ export default function App() {
           {activeView === 'stats' && <StatsView />}
         </main>
       </div>
-      <ConfirmationDialog />
-      <MessageMenu />
-      <Toasts />
-      <AchievementModal />
-      <FileDisplayModal />
-      {/* 游戏导出 / 导入的全局入口（会话右键菜单 / 侧边栏导入按钮共用） */}
+          <ConfirmationDialog />
+          <MessageMenu />
+          <Toasts />
+          <AchievementModal />
+          <FileDisplayModal />
+          {/* 游戏导出 / 导入的全局入口（会话右键菜单 / 侧边栏导入按钮共用） */}
       <GameplayEntryDialogs />
     </>
   );