luckytri 1.0.0

package/scripts/backup.js

@@ -0,0 +1,311 @@
+import { DatabaseSync } from "node:sqlite";
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  statSync,
+} from "node:fs";
+import { resolve, join, basename, dirname } from "node:path";
+import {
+  copyDatabaseFile,
+  archiveIdentity,
+  writeArchiveManifest,
+  ensureArchiveIdentity,
+} from "../server/storage/archive.js";
+import { withBackupLock } from "../server/storage/backup-lock.js";
+import { pathToFileURL } from "node:url";
+import { randomUUID } from "node:crypto";
+import { runtimePaths } from "../server/paths.js";
+
+const HOUR = 3600000;
+const DAY = 24 * HOUR;
+export const AUTO_PREFIX = "luckytri-auto-";
+const MISSING = "数据库不存在，请先启动一次 LuckyTri";
+
+export function backupDirectory(
+  source = runtimePaths().database,
+  env = process.env,
+) {
+  return env.BACKUP_DIR
+    ? resolve(runtimePaths(env).home, env.BACKUP_DIR)
+    : join(dirname(resolve(source)), "backups");
+}
+
+function copyDatabase(source, target) {
+  copyDatabaseFile(source, target);
+}
+
+export function backupDatabase(
+  source = runtimePaths().database,
+  directory = backupDirectory(source),
+) {
+  if (!existsSync(source)) throw new Error(MISSING);
+  return withBackupLock(directory, () => fullBackup(source, directory));
+}
+
+function fullBackup(source, directory) {
+  if (!existsSync(source)) throw new Error(MISSING);
+  ensureArchiveIdentity(source);
+  mkdirSync(directory, { recursive: true });
+  const target = resolve(
+    join(
+      directory,
+      `luckytri-${new Date().toISOString().replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}.db`,
+    ),
+  );
+  const partial = `${target}.partial`;
+  try {
+    copyDatabase(source, partial);
+    writeArchiveManifest(partial, { filename: basename(target) });
+    renameSync(partial, target);
+    renameSync(`${partial}.json`, `${target}.json`);
+  } catch (error) {
+    rmSync(partial, { force: true });
+    rmSync(`${partial}.json`, { force: true });
+    throw error;
+  }
+  return target;
+}
+
+// Automatic backups exist to keep her continuity: what she remembers, how she
+// has changed and the days she has lived. Model call traces are megabytes each
+// and can be rebuilt from nothing that matters, so old ones are left out; that
+// keeps a daily copy small enough to actually keep a week of them.
+// When a backup was made comes from its name, so copying the folder to another
+// disk does not make old backups look new.
+function stampTime(name, file) {
+  const match = /(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z/.exec(
+    name,
+  );
+  const parsed = match
+    ? Date.parse(`${match[1]}T${match[2]}:${match[3]}:${match[4]}.${match[5]}Z`)
+    : NaN;
+  return Number.isFinite(parsed) ? parsed : statSync(file).mtimeMs;
+}
+
+function autoBackups(directory, { source, databaseId } = {}) {
+  if (!existsSync(directory)) return [];
+  const scoped = !!source || databaseId !== undefined;
+  const sourceStat = source && existsSync(source) ? statSync(source) : null;
+  const sourcePath = source
+    ? sourceStat
+      ? realpathSync(source)
+      : resolve(source)
+    : null;
+  const identity = databaseId ?? (sourceStat ? archiveIdentity(source) : null);
+  const normalize = (file) =>
+    process.platform === "win32" ? file.toLowerCase() : file;
+  const entries = [];
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    if (
+      !entry.isFile() ||
+      !entry.name.startsWith(AUTO_PREFIX) ||
+      !entry.name.endsWith(".db")
+    )
+      continue;
+    const file = join(directory, entry.name);
+    const stat = lstatSync(file);
+    if (
+      !stat.isFile() ||
+      (sourcePath && normalize(realpathSync(file)) === normalize(sourcePath)) ||
+      (sourceStat?.ino &&
+        stat.ino === sourceStat.ino &&
+        stat.dev === sourceStat.dev)
+    )
+      continue;
+    if (scoped) {
+      if (!identity) continue;
+      try {
+        const manifestPath = `${file}.json`;
+        if (!lstatSync(manifestPath).isFile()) continue;
+        const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+        if (
+          manifest.format !== 1 ||
+          manifest.app !== "luckytri" ||
+          manifest.kind !== "auto" ||
+          manifest.databaseId !== identity ||
+          archiveIdentity(file) !== identity
+        )
+          continue;
+      } catch {
+        // Legacy, damaged and unidentifiable copies require a manual decision.
+        continue;
+      }
+    }
+    entries.push({ name: entry.name, file, time: stampTime(entry.name, file) });
+  }
+  return entries.sort(
+    (a, b) => b.time - a.time || b.name.localeCompare(a.name),
+  );
+}
+
+// Newest first, with the size the management page shows.
+export function listAutoBackups(directory, options = {}) {
+  return autoBackups(directory, options).map(({ name, file, time }) => ({
+    name,
+    time,
+    bytes: statSync(file).size,
+  }));
+}
+
+export function autoBackupDue(
+  directory,
+  { now = Date.now(), intervalMs = DAY, source, databaseId } = {},
+) {
+  const latest = autoBackups(directory, { source, databaseId })[0];
+  return !latest || now - latest.time >= intervalMs;
+}
+
+// Trim a fresh copy down to what continuity needs, then prove it is readable.
+function slimAndVerify(file, traceCutoff) {
+  const db = new DatabaseSync(file);
+  try {
+    const hasTraces = db
+      .prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?")
+      .get("core_traces");
+    if (hasTraces) {
+      db.prepare("DELETE FROM core_traces WHERE time<?").run(traceCutoff);
+      db.exec("VACUUM");
+    }
+    const check = db.prepare("PRAGMA integrity_check").all();
+    if (check.length !== 1 || check[0].integrity_check !== "ok")
+      throw new Error("备份未通过完整性检查，已丢弃");
+    const hasEvents = db
+      .prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?")
+      .get("core_events");
+    return {
+      events: hasEvents
+        ? Number(db.prepare("SELECT COUNT(*) n FROM core_events").get().n)
+        : 0,
+    };
+  } finally {
+    db.close();
+  }
+}
+
+export function autoBackup(options = {}) {
+  const source = options.source || runtimePaths().database;
+  const directory = options.directory || backupDirectory(source);
+  if (!existsSync(source)) throw new Error(MISSING);
+  return withBackupLock(directory, () =>
+    runAutoBackup({ ...options, source, directory }),
+  );
+}
+
+function runAutoBackup({
+  source = runtimePaths().database,
+  directory = backupDirectory(source),
+  now = Date.now(),
+  intervalMs = DAY,
+  keep = 7,
+  keepTraceDays = 1,
+  force = false,
+} = {}) {
+  if (!existsSync(source)) throw new Error(MISSING);
+  if (!force && !autoBackupDue(directory, { now, intervalMs, source }))
+    return { status: "skipped" };
+  const databaseId = ensureArchiveIdentity(source);
+  mkdirSync(directory, { recursive: true });
+  const sourceStat = statSync(source);
+  const sourcePath = realpathSync(source);
+  const normalize = (file) =>
+    process.platform === "win32" ? file.toLowerCase() : file;
+  // A run that was cut off leaves a partial file; it is never a backup.
+  for (const name of readdirSync(directory)) {
+    if (!name.startsWith(AUTO_PREFIX) || !name.endsWith(".partial")) continue;
+    const file = join(directory, name);
+    const stat = lstatSync(file);
+    if (
+      stat.isFile() &&
+      now - stat.mtimeMs > 6 * HOUR &&
+      normalize(realpathSync(file)) !== normalize(sourcePath) &&
+      !(
+        sourceStat.ino &&
+        stat.ino === sourceStat.ino &&
+        stat.dev === sourceStat.dev
+      )
+    )
+      rmSync(file, { force: true });
+  }
+  let stampTimeMs = now;
+  let final;
+  do {
+    const stamp = new Date(stampTimeMs++).toISOString().replace(/[:.]/g, "-");
+    final = resolve(join(directory, `${AUTO_PREFIX}${stamp}.db`));
+  } while (existsSync(final) || existsSync(`${final}.json`));
+  const partial = `${final}.${randomUUID().slice(0, 8)}.partial`;
+  let info;
+  try {
+    copyDatabase(source, partial);
+    info = slimAndVerify(partial, now - keepTraceDays * DAY);
+    writeArchiveManifest(partial, { kind: "auto", filename: basename(final) });
+    renameSync(partial, final);
+    renameSync(`${partial}.json`, `${final}.json`);
+  } catch (error) {
+    rmSync(partial, { force: true });
+    rmSync(`${partial}.json`, { force: true });
+    throw error;
+  }
+  const removed = [];
+  for (const old of autoBackups(directory, { source, databaseId }).slice(
+    Math.max(1, keep),
+  )) {
+    if (existsSync(`${old.file}-wal`) || existsSync(`${old.file}-shm`))
+      continue;
+    rmSync(old.file, { force: true });
+    rmSync(`${old.file}.json`, { force: true });
+    removed.push(old.name);
+  }
+  return {
+    status: "created",
+    file: final,
+    bytes: statSync(final).size,
+    events: info.events,
+    removed,
+  };
+}
+
+// Reads the schedule from the environment; 0 turns automatic backups off.
+export function autoBackupOptions(env = process.env) {
+  const hours = Number(env.BACKUP_INTERVAL_HOURS ?? 24);
+  const keep = Number(env.BACKUP_KEEP ?? 7);
+  const traceDays = Number(env.BACKUP_TRACE_DAYS ?? 1);
+  return {
+    enabled: Number.isFinite(hours) && hours > 0,
+    intervalMs: (Number.isFinite(hours) && hours > 0 ? hours : 24) * HOUR,
+    keep: Number.isFinite(keep) && keep >= 1 ? Math.floor(keep) : 7,
+    keepTraceDays: Number.isFinite(traceDays) && traceDays >= 0 ? traceDays : 1,
+  };
+}
+
+if (
+  process.argv[1] &&
+  import.meta.url === pathToFileURL(resolve(process.argv[1])).href
+) {
+  try {
+    const { prepareRuntime } = await import("./runtime.js");
+    prepareRuntime({ initialize: false });
+    if (process.argv.includes("--auto")) {
+      const options = autoBackupOptions();
+      const result = autoBackup({
+        intervalMs: options.intervalMs,
+        keep: options.keep,
+        keepTraceDays: options.keepTraceDays,
+        force: process.argv.includes("--force"),
+      });
+      console.log(
+        result.status === "created"
+          ? `自动备份完成：${result.file}（${Math.round(result.bytes / 1048576)} MB，${result.events} 条事件${result.removed.length ? `，清理旧备份 ${result.removed.length} 份` : ""}）`
+          : "自动备份未到时间，已跳过",
+      );
+    } else console.log("备份完成：" + backupDatabase());
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+  }
+}

package/scripts/browser.js

@@ -0,0 +1,41 @@
+import { spawn } from "node:child_process";
+
+export function browserCommand(url, platform = process.platform) {
+  if (platform === "win32")
+    return {
+      command: "powershell.exe",
+      args: [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        "Start-Process $env:LUCKY_LAUNCH_URL",
+      ],
+      env: { ...process.env, LUCKY_LAUNCH_URL: url },
+    };
+  return { command: platform === "darwin" ? "open" : "xdg-open", args: [url] };
+}
+
+export async function openBrowser(url) {
+  const { command, args, env } = browserCommand(url);
+  const child = spawn(command, args, {
+    windowsHide: true,
+    stdio: "ignore",
+    env,
+  });
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      child.kill();
+      reject(Error("浏览器未打开，请手动打开上方地址。"));
+    }, 10000);
+    const finish = (error) => {
+      clearTimeout(timeout);
+      error ? reject(error) : resolve();
+    };
+    child.once("error", () =>
+      finish(Error("浏览器未打开，请手动打开上方地址。")),
+    );
+    child.once("exit", (code) =>
+      finish(code === 0 ? null : Error("浏览器未打开，请手动打开上方地址。")),
+    );
+  });
+}

package/scripts/launch.js

@@ -0,0 +1,94 @@
+import { openSync, closeSync, mkdirSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import { prepareRuntime } from "./runtime.js";
+import { running, serviceUrl } from "./service.js";
+import { openBrowser } from "./browser.js";
+import {
+  claimLaunch,
+  clearStarting,
+  starting,
+} from "../server/startup-lock.js";
+import {
+  resolveProxyEnvironment,
+  supportsNodeEnvironmentProxy,
+} from "./proxy-config.js";
+
+try {
+  const paths = prepareRuntime();
+  const proxy = await resolveProxyEnvironment(process.env);
+  const base = serviceUrl();
+  if (proxy.enabled && !supportsNodeEnvironmentProxy())
+    throw new Error(
+      "系统代理转发需要 Node.js 24.5 或更高版本。请升级 Node.js 后重试。",
+    );
+  if (!(await running({ base }))) {
+    let childExited = false;
+    const fresh = claimLaunch();
+    if (!fresh) console.log("上一次启动还在进行，正在等它就绪，不会再开一份。");
+    else {
+      console.log("正在启动 LuckyTri…");
+      console.log("窗口会停在这里直到服务就绪，请不要关闭。");
+      try {
+        await import("express").catch(() => {
+          throw new Error("缺少依赖，请先在项目目录执行 npm install。");
+        });
+        mkdirSync(paths.data, { recursive: true, mode: 0o700 });
+        const log = openSync(paths.log, "a", 0o600);
+        const args = [
+          ...(proxy.enabled ? ["--use-env-proxy"] : []),
+          join(paths.package, "server", "index.js"),
+        ];
+        const child = spawn(process.execPath, args, {
+          cwd: paths.home,
+          detached: true,
+          windowsHide: true,
+          env: {
+            ...process.env,
+            ...proxy.env,
+            LUCKYTRI_LAUNCH_PID: String(process.pid),
+          },
+          stdio: ["ignore", log, log],
+        });
+        closeSync(log);
+        child.once("exit", () => {
+          childExited = true;
+        });
+        await new Promise((resolve, reject) => {
+          child.once("spawn", resolve);
+          child.once("error", reject);
+        });
+        child.unref();
+      } catch (error) {
+        clearStarting();
+        throw error;
+      }
+    }
+    let ready = false;
+    for (let attempt = 0; attempt < 2000; attempt++) {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      if (attempt > 0 && attempt % 16 === 0) console.log("仍在启动…");
+      if (await running({ base, lenient: true })) {
+        ready = true;
+        break;
+      }
+      if (fresh && childExited)
+        throw new Error(`启动进程已退出，请查看 ${paths.log}`);
+      if (!fresh && !starting())
+        throw new Error("上一次启动已中断，请再试一次。");
+    }
+    if (!ready) throw new Error(`启动未完成，请查看 ${paths.log}`);
+    console.log(
+      proxy.enabled
+        ? "LuckyTri 已在后台启动，外部 API 走系统代理。"
+        : "LuckyTri 已在后台启动。",
+    );
+  } else console.log("LuckyTri 已经运行，直接打开管理台。");
+  console.log(base);
+  if (!process.argv.includes("--no-browser")) {
+    await openBrowser(base).catch((error) => console.warn(error.message));
+  }
+} catch (error) {
+  console.error(error.message);
+  process.exitCode = 1;
+}

package/scripts/plugin.js

@@ -0,0 +1,150 @@
+import { createHash } from "node:crypto";
+import {
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { join, relative } from "node:path";
+import { validateManifest } from "../server/plugins/manifest.js";
+
+const command = process.argv[2];
+const arg = process.argv[3];
+
+function walk(dir, out = []) {
+  for (const name of readdirSync(dir)) {
+    if (name === "node_modules") continue;
+    const path = join(dir, name);
+    if (statSync(path).isDirectory()) walk(path, out);
+    else out.push(path);
+  }
+  return out;
+}
+
+function crc32(buffer) {
+  let crc = ~0;
+  for (const byte of buffer) {
+    crc ^= byte;
+    for (let bit = 0; bit < 8; bit++)
+      crc = crc & 1 ? (crc >>> 1) ^ 0xedb88320 : crc >>> 1;
+  }
+  return ~crc >>> 0;
+}
+
+function pack(dir) {
+  const files = walk(dir).map((path) => ({
+    name: relative(dir, path).replace(/\\/g, "/"),
+    bytes: readFileSync(path),
+  }));
+  const locals = [];
+  const central = [];
+  let offset = 0;
+  for (const file of files) {
+    const name = Buffer.from(file.name);
+    const crc = crc32(file.bytes);
+    const local = Buffer.alloc(30 + name.length);
+    local.writeUInt32LE(0x04034b50, 0);
+    local.writeUInt16LE(20, 4);
+    local.writeUInt32LE(crc, 14);
+    local.writeUInt32LE(file.bytes.length, 18);
+    local.writeUInt32LE(file.bytes.length, 22);
+    local.writeUInt16LE(name.length, 26);
+    name.copy(local, 30);
+    const centralHeader = Buffer.alloc(46 + name.length);
+    centralHeader.writeUInt32LE(0x02014b50, 0);
+    centralHeader.writeUInt16LE(20, 4);
+    centralHeader.writeUInt16LE(20, 6);
+    centralHeader.writeUInt32LE(crc, 16);
+    centralHeader.writeUInt32LE(file.bytes.length, 20);
+    centralHeader.writeUInt32LE(file.bytes.length, 24);
+    centralHeader.writeUInt16LE(name.length, 28);
+    centralHeader.writeUInt32LE(offset, 42);
+    name.copy(centralHeader, 46);
+    locals.push(local, file.bytes);
+    central.push(centralHeader);
+    offset += local.length + file.bytes.length;
+  }
+  const directory = Buffer.concat(central);
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(0x06054b50, 0);
+  end.writeUInt16LE(files.length, 8);
+  end.writeUInt16LE(files.length, 10);
+  end.writeUInt32LE(directory.length, 12);
+  end.writeUInt32LE(offset, 16);
+  return Buffer.concat([...locals, directory, end]);
+}
+
+if (command === "new") {
+  const id = arg || "example";
+  const dir = join("plugins", id);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, "luckytri-plugin.json"),
+    JSON.stringify(
+      {
+        id,
+        name: id,
+        version: "0.1.0",
+        pluginApi: "1.0",
+        luckytri: ">=1.0.0 <2.0.0",
+        description: "",
+        entry: "index.js",
+        permissions: [],
+        contributes: {},
+      },
+      null,
+      2,
+    ),
+  );
+  writeFileSync(
+    join(dir, "index.js"),
+    "export default { activate(ctx) { ctx.status.set({ text: '已接上', tone: 'ok' }); } };\n",
+  );
+  console.log(dir);
+} else if (command === "pack") {
+  const dir = arg;
+  const manifest = JSON.parse(
+    readFileSync(join(dir, "luckytri-plugin.json"), "utf8"),
+  );
+  const bytes = pack(dir);
+  const file = `${manifest.id}-${manifest.version}.zip`;
+  writeFileSync(file, bytes);
+  const sha256 = createHash("sha256").update(bytes).digest("hex");
+  console.log(
+    JSON.stringify(
+      {
+        id: manifest.id,
+        version: manifest.version,
+        pluginApi: manifest.pluginApi,
+        luckytri: manifest.luckytri,
+        sha256,
+        permissions: manifest.permissions,
+        network: manifest.network || [],
+        file,
+      },
+      null,
+      2,
+    ),
+  );
+} else if (command === "registry-check") {
+  const index = JSON.parse(readFileSync(arg || "index.json", "utf8"));
+  if (index.format !== 1 || !Array.isArray(index.plugins))
+    throw new Error("插件索引无效");
+  for (const plugin of index.plugins)
+    for (const version of plugin.versions || [])
+      if (!version.sha256 || !version.url) throw new Error("插件索引无效");
+  console.log(`ok ${index.plugins.length}`);
+} else if (command === "check") {
+  const dir = resolveDir(arg);
+  const manifest = validateManifest(
+    JSON.parse(readFileSync(join(dir, "luckytri-plugin.json"), "utf8")),
+  );
+  console.log(`${manifest.id} ${manifest.version} 清单通过`);
+} else {
+  console.log("用法: npm run plugin -- new|check|pack|registry-check");
+}
+
+function resolveDir(value) {
+  return value || ".";
+}