@cloud411716/fancy-webnovel 2.2.0 → 3.0.0

package/lib/surreal-server.js

@@ -0,0 +1,338 @@
+/**
+ * Local SurrealDB server lifecycle for one workspace.
+ *
+ * The server is a separate process, not an embedded engine. Each project gets
+ * its own database (and database-scoped user); the server itself is shared by
+ * every project in the workspace.
+ */
+
+import fs from 'fs';
+import net from 'net';
+import path from 'path';
+import { spawn, spawnSync } from 'child_process';
+import { Surreal, createRemoteEngines } from 'surrealdb';
+import { readSecrets, readWorkspace, updateWorkspace, workspacePaths } from './workspace.js';
+
+export const DEFAULT_SURREAL_VERSION = '2.3.10';
+
+export class SurrealServerError extends Error {
+  constructor(code, message, detail) {
+    super(message);
+    this.name = 'SurrealServerError';
+    this.code = code;
+    this.detail = detail;
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function healthUrl(workspace) {
+  const url = String(workspace.surreal?.url || 'http://127.0.0.1:8000/rpc');
+  return url.replace(/\/rpc\/?$/, '').replace(/\/$/, '') + '/health';
+}
+
+export function rpcUrl(workspace) {
+  const url = String(workspace.surreal?.url || 'http://127.0.0.1:8000/rpc');
+  return /\/rpc\/?$/.test(url) ? url.replace(/\/$/, '') : url.replace(/\/$/, '') + '/rpc';
+}
+
+export function findSurrealBinary(root) {
+  const candidates = [
+    process.env.FANCY_SURREAL_BIN,
+    root ? path.join(workspacePaths(root).fancy, 'bin', 'surreal') : null,
+    '/usr/local/bin/surreal',
+    '/usr/bin/surreal',
+    path.join(process.env.HOME || '', '.local', 'bin', 'surreal'),
+  ].filter(Boolean);
+  for (const candidate of candidates) {
+    try {
+      if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
+    } catch { /* ignore */ }
+  }
+  const which = spawnSync('sh', ['-lc', 'command -v surreal'], { encoding: 'utf8' });
+  if (which.status === 0 && which.stdout.trim()) return which.stdout.trim();
+  return null;
+}
+
+export async function readHealth(workspace) {
+  const url = healthUrl(workspace);
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 1500);
+    const response = await fetch(url, { signal: controller.signal });
+    clearTimeout(timer);
+    if (!response.ok) return { ok: false, url, status: response.status };
+    return {
+      ok: true,
+      url,
+      version: response.headers.get('surreal-version') || '',
+    };
+  } catch (err) {
+    return { ok: false, url, error: err && err.message ? err.message : String(err) };
+  }
+}
+
+export function readPid(workspace) {
+  const file = workspace.surreal?.pid_file || '';
+  if (!file) return null;
+  try {
+    const pid = Number(fs.readFileSync(file, 'utf8').trim());
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+function processAlive(pid) {
+  if (!pid) return false;
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+function parseBind(bind) {
+  const text = String(bind || '127.0.0.1:8000');
+  const idx = text.lastIndexOf(':');
+  if (idx < 0) return { host: '127.0.0.1', port: 8000 };
+  const host = text.slice(0, idx).replace(/^\[|\]$/g, '') || '127.0.0.1';
+  const port = Number(text.slice(idx + 1)) || 8000;
+  return { host, port };
+}
+
+function urlForBind(host, port) {
+  const h = host === '0.0.0.0' || host === '::' ? '127.0.0.1' : host;
+  return `http://${h}:${port}/rpc`;
+}
+
+async function isPortFree(port, host = '127.0.0.1') {
+  return await new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', () => resolve(false));
+    server.once('listening', () => server.close(() => resolve(true)));
+    server.listen(port, host);
+  });
+}
+
+async function findFreePort(startPort, host = '127.0.0.1') {
+  const start = Math.max(1, Number(startPort) || 8000);
+  for (let port = start; port < start + 100; port += 1) {
+    if (await isPortFree(port, host)) return port;
+  }
+  return null;
+}
+
+async function rootCredentialsValid(workspace, secrets) {
+  const db = new Surreal({ engines: { ...createRemoteEngines() } });
+  try {
+    await db.connect(rpcUrl(workspace));
+    await db.signin({
+      username: secrets.surreal?.username || 'root',
+      password: secrets.surreal?.password,
+    });
+    await db.query('RETURN 1;');
+    return true;
+  } catch {
+    return false;
+  } finally {
+    try { await db.close(); } catch { /* ignore */ }
+  }
+}
+
+export async function serverStatus(root) {
+  const workspace = readWorkspace(root);
+  const health = await readHealth(workspace);
+  const pid = readPid(workspace);
+  let credentialsOk = null;
+  if (health.ok) {
+    try { credentialsOk = await rootCredentialsValid(workspace, readSecrets(root)); }
+    catch { credentialsOk = false; }
+  }
+  return {
+    workspace: root,
+    endpoint: rpcUrl(workspace),
+    health,
+    running: Boolean(health.ok),
+    credentials_ok: credentialsOk,
+    pid: processAlive(pid) ? pid : null,
+    stale_pid: pid && !processAlive(pid) ? pid : null,
+    data_dir: workspace.surreal?.data_dir || workspacePaths(root).surrealData,
+    binary: findSurrealBinary(root),
+  };
+}
+
+export async function waitForServer(workspace, timeoutMs = 15000) {
+  const deadline = Date.now() + timeoutMs;
+  let last = null;
+  while (Date.now() < deadline) {
+    last = await readHealth(workspace);
+    if (last.ok) return last;
+    await sleep(250);
+  }
+  return last || { ok: false, error: 'timeout' };
+}
+
+export async function startServer(root, opts = {}) {
+  let workspace = readWorkspace(root);
+  const secrets = readSecrets(root);
+  const username = secrets.surreal?.username || 'root';
+  const password = secrets.surreal?.password;
+  if (!password) {
+    throw new SurrealServerError('SURREAL_PASSWORD_MISSING', '工作区缺少 SurrealDB root 密码，请重新运行 /fancy-bootstrap。');
+  }
+
+  const current = await readHealth(workspace);
+  let endpointChanged = false;
+  let previousEndpoint = null;
+  let portChangedReason = null;
+
+  if (current.ok) {
+    if (await rootCredentialsValid(workspace, secrets)) {
+      return { started: false, already_running: true, ...(await serverStatus(root)) };
+    }
+    // Port 8000 may be occupied by a SurrealDB left over from a deleted or
+    // different workspace. Our new root password cannot authenticate to it;
+    // move this workspace to the next free port instead of failing.
+    previousEndpoint = rpcUrl(workspace);
+    const { host, port } = parseBind(workspace.surreal?.bind);
+    const nextPort = await findFreePort(port + 1, host);
+    if (!nextPort) {
+      throw new SurrealServerError('SURREAL_PORT_BUSY', '未找到可用的 SurrealDB 端口；请先停止占用端口 ' + port + ' 的进程。');
+    }
+    workspace = updateWorkspace(root, {
+      surreal: { bind: host + ':' + nextPort, url: urlForBind(host, nextPort) },
+    });
+    endpointChanged = true;
+    portChangedReason = 'auth_failed';
+  } else {
+    const { host, port } = parseBind(workspace.surreal?.bind);
+    if (!(await isPortFree(port, host))) {
+      const nextPort = await findFreePort(port + 1, host);
+      if (!nextPort) {
+        throw new SurrealServerError('SURREAL_PORT_BUSY', '未找到可用的 SurrealDB 端口；请先停止占用端口 ' + port + ' 的进程。');
+      }
+      workspace = updateWorkspace(root, {
+        surreal: { bind: host + ':' + nextPort, url: urlForBind(host, nextPort) },
+      });
+      endpointChanged = true;
+      portChangedReason = 'port_busy';
+    }
+  }
+
+  const binary = opts.binary || findSurrealBinary(root);
+  if (!binary) {
+    throw new SurrealServerError(
+      'SURREAL_BINARY_MISSING',
+      '未找到 surreal 可执行文件。请先运行 /fancy-db install，或将 SurrealDB 加入 PATH。',
+    );
+  }
+
+  const paths = workspacePaths(root);
+  fs.mkdirSync(paths.surrealData, { recursive: true });
+  fs.mkdirSync(path.dirname(paths.surrealLog), { recursive: true });
+  try { fs.unlinkSync(paths.surrealPid); } catch { /* ignore */ }
+
+  const bind = workspace.surreal?.bind || '127.0.0.1:8000';
+  // Keep the listen address visible in `ps`; keep the password in the
+  // environment so it never appears in the process command line.
+  const args = ['start', '--bind', bind, 'rocksdb:' + paths.surrealData];
+  const log = fs.openSync(paths.surrealLog, 'a');
+  const child = spawn(binary, args, {
+    detached: true,
+    stdio: ['ignore', log, log],
+    env: {
+      ...process.env,
+      SURREAL_USER: username,
+      SURREAL_PASS: password,
+      SURREAL_NO_BANNER: 'true',
+    },
+  });
+  child.unref();
+  fs.writeFileSync(paths.surrealPid, String(child.pid) + '\n', { encoding: 'utf8', mode: 0o600 });
+
+  const health = await waitForServer(workspace, Number(opts.timeoutMs) || 15000);
+  if (!health.ok) {
+    try { process.kill(child.pid, 'SIGTERM'); } catch { /* ignore */ }
+    throw new SurrealServerError(
+      'SURREAL_START_FAILED',
+      'SurrealDB 未在预期时间内启动。请查看日志：' + paths.surrealLog,
+      health,
+    );
+  }
+  return {
+    started: true,
+    already_running: false,
+    pid: child.pid,
+    endpoint_changed: endpointChanged,
+    previous_endpoint: previousEndpoint,
+    port_changed_reason: portChangedReason,
+    ...(await serverStatus(root)),
+  };
+}
+
+export async function stopServer(root, opts = {}) {
+  const workspace = readWorkspace(root);
+  const status = await serverStatus(root);
+  if (!status.running && !status.pid) {
+    try { fs.unlinkSync(workspacePaths(root).surrealPid); } catch { /* ignore */ }
+    return { stopped: false, already_stopped: true };
+  }
+  const pid = status.pid || readPid(workspace);
+  if (pid) {
+    try { process.kill(pid, 'SIGTERM'); } catch { /* ignore */ }
+    const deadline = Date.now() + (Number(opts.timeoutMs) || 10000);
+    while (Date.now() < deadline && processAlive(pid)) await sleep(150);
+    if (processAlive(pid)) {
+      try { process.kill(pid, 'SIGKILL'); } catch { /* ignore */ }
+    }
+  }
+  try { fs.unlinkSync(workspacePaths(root).surrealPid); } catch { /* ignore */ }
+  return { stopped: true, already_stopped: false, pid };
+}
+
+async function download(url, file) {
+  const response = await fetch(url, { redirect: 'follow' });
+  if (!response.ok) throw new SurrealServerError('SURREAL_DOWNLOAD', '下载 SurrealDB 失败：HTTP ' + response.status, { url });
+  const body = Buffer.from(await response.arrayBuffer());
+  fs.writeFileSync(file, body, { mode: 0o600 });
+}
+
+/**
+ * Install a standalone SurrealDB binary into <workspace>/.fancy/bin.
+ * Uses the official GitHub release tarball for the current platform.
+ */
+export async function installSurreal(root, opts = {}) {
+  const version = opts.version || DEFAULT_SURREAL_VERSION;
+  const paths = workspacePaths(root);
+  const binDir = path.join(paths.fancy, 'bin');
+  fs.mkdirSync(binDir, { recursive: true });
+  const target = path.join(binDir, 'surreal');
+  if (fs.existsSync(target) && !opts.force) {
+    return { installed: false, already_installed: true, path: target, version: spawnSync(target, ['version'], { encoding: 'utf8' }).stdout.trim() };
+  }
+  const platform = process.platform;
+  const arch = process.arch === 'x64' ? 'amd64' : process.arch === 'arm64' ? 'arm64' : process.arch;
+  if (platform !== 'linux' && platform !== 'darwin') {
+    throw new SurrealServerError('SURREAL_PLATFORM', '当前平台不支持自动安装 SurrealDB：' + platform);
+  }
+  const ext = platform === 'linux' ? 'linux' : 'darwin';
+  const archive = `surreal-v${version}.${ext}-${arch}.tgz`;
+  const url = `https://github.com/surrealdb/surrealdb/releases/download/v${version}/${archive}`;
+  const tmp = path.join(binDir, `.download-${process.pid}.tgz`);
+  await download(url, tmp);
+  const extractDir = path.join(binDir, `.extract-${process.pid}`);
+  fs.mkdirSync(extractDir, { recursive: true });
+  const tar = spawnSync('tar', ['-xzf', tmp, '-C', extractDir], { encoding: 'utf8' });
+  if (tar.status !== 0) {
+    throw new SurrealServerError('SURREAL_EXTRACT', '解压 SurrealDB 压缩包失败：' + (tar.stderr || tar.stdout), { url });
+  }
+  const extracted = path.join(extractDir, 'surreal');
+  if (!fs.existsSync(extracted)) {
+    throw new SurrealServerError('SURREAL_EXTRACT', '压缩包中未找到 surreal 可执行文件。', { url });
+  }
+  fs.copyFileSync(extracted, target);
+  fs.chmodSync(target, 0o755);
+  try { fs.unlinkSync(tmp); } catch { /* ignore */ }
+  try { fs.rmSync(extractDir, { recursive: true, force: true }); } catch { /* ignore */ }
+  const versionOut = spawnSync(target, ['version'], { encoding: 'utf8' }).stdout.trim();
+  return { installed: true, already_installed: false, path: target, version: versionOut };
+}