luckytri 1.0.0

package/scripts/proxy-config.js

@@ -0,0 +1,167 @@
+import { execFileSync } from "node:child_process";
+import net from "node:net";
+
+const WINDOWS_INTERNET_SETTINGS =
+  "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings";
+const LOCAL_BYPASS = ["localhost", "127.0.0.1", "::1"];
+
+function environmentProxy(env) {
+  const http = env.http_proxy || env.HTTP_PROXY || "";
+  const https = env.https_proxy || env.HTTPS_PROXY || http;
+  return http || https ? { http, https } : null;
+}
+
+function readWindowsValue(name) {
+  try {
+    const output = execFileSync(
+      "reg.exe",
+      ["query", WINDOWS_INTERNET_SETTINGS, "/v", name],
+      {
+        encoding: "utf8",
+        windowsHide: true,
+        stdio: ["ignore", "pipe", "ignore"],
+      },
+    );
+    return (
+      output
+        .match(new RegExp(`\\b${name}\\s+REG_\\w+\\s+(.+)$`, "im"))?.[1]
+        ?.trim() || ""
+    );
+  } catch {
+    return "";
+  }
+}
+
+function parseWindowsProxyServer(value) {
+  const routes = {};
+  for (const part of String(value || "").split(";")) {
+    const item = part.trim();
+    if (!item) continue;
+    const separator = item.indexOf("=");
+    if (separator < 0) routes.default = item;
+    else
+      routes[item.slice(0, separator).trim().toLowerCase()] = item
+        .slice(separator + 1)
+        .trim();
+  }
+  const normalize = (item) => {
+    if (!item) return "";
+    try {
+      const url = new URL(
+        /^[a-z][a-z\d+.-]*:\/\//i.test(item) ? item : `http://${item}`,
+      );
+      return ["http:", "https:"].includes(url.protocol) ? url.href : "";
+    } catch {
+      return "";
+    }
+  };
+  const fallback = routes.default || routes.http || routes.https || "";
+  return {
+    http: normalize(routes.http || fallback || routes.https),
+    https: normalize(routes.https || fallback || routes.http),
+  };
+}
+
+function isLoopbackProxy(url) {
+  try {
+    const host = new URL(url).hostname.toLowerCase();
+    return host === "localhost" || host === "::1" || host.startsWith("127.");
+  } catch {
+    return false;
+  }
+}
+
+function isListening(url) {
+  return new Promise((resolve) => {
+    try {
+      const proxy = new URL(url);
+      const socket = net.createConnection({
+        host: proxy.hostname,
+        port: Number(proxy.port || (proxy.protocol === "https:" ? 443 : 80)),
+      });
+      const finish = (value) => {
+        socket.destroy();
+        resolve(value);
+      };
+      socket.setTimeout(700, () => finish(false));
+      socket.once("connect", () => finish(true));
+      socket.once("error", () => finish(false));
+    } catch {
+      resolve(false);
+    }
+  });
+}
+
+function mergeNoProxy(...values) {
+  const hosts = new Set(LOCAL_BYPASS);
+  for (const value of values) {
+    for (const host of String(value || "").split(/[;,]/)) {
+      const item = host.trim();
+      if (item && item.toLowerCase() !== "<local>") hosts.add(item);
+    }
+  }
+  return [...hosts].join(",");
+}
+
+export async function resolveProxyEnvironment(env = process.env) {
+  const configured = environmentProxy(env);
+  if (configured) {
+    return {
+      enabled: true,
+      source: "environment",
+      env: {
+        HTTP_PROXY: configured.http || configured.https,
+        HTTPS_PROXY: configured.https || configured.http,
+        NO_PROXY: mergeNoProxy(env.NO_PROXY, env.no_proxy),
+      },
+    };
+  }
+
+  if (process.platform !== "win32")
+    return { enabled: false, source: "none", env: {} };
+
+  const enabled = /^\s*(?:1|0x1)\s*$/i.test(readWindowsValue("ProxyEnable"));
+  const server = readWindowsValue("ProxyServer");
+  const routes = parseWindowsProxyServer(server);
+  const bypass = readWindowsValue("ProxyOverride");
+  let source = enabled ? "windows-system" : "none";
+
+  // Some proxy clients leave the Windows system-proxy toggle off while their
+  // local HTTP proxy remains active. Honor that live endpoint for LuckyTri.
+  if (
+    !enabled &&
+    routes.https &&
+    isLoopbackProxy(routes.https) &&
+    (await isListening(routes.https))
+  )
+    source = "windows-local-proxy";
+
+  if (source === "none")
+    return {
+      enabled: false,
+      source: readWindowsValue("AutoConfigURL")
+        ? "windows-pac-unsupported"
+        : source,
+      env: {},
+    };
+
+  if (!routes.http && !routes.https)
+    return { enabled: false, source: "windows-proxy-invalid", env: {} };
+
+  return {
+    enabled: true,
+    source,
+    env: {
+      HTTP_PROXY: routes.http || routes.https,
+      HTTPS_PROXY: routes.https || routes.http,
+      NO_PROXY: mergeNoProxy(env.NO_PROXY, env.no_proxy, bypass),
+    },
+  };
+}
+
+export function supportsNodeEnvironmentProxy(version = process.versions.node) {
+  const [major, minor] = version.split(".").map(Number);
+  return (
+    major > 24 || (major === 24 && minor >= 5) || (major === 22 && minor >= 21)
+  );
+}

package/scripts/recover.js

@@ -0,0 +1,26 @@
+import { verifyArchive, restoreToNewFile } from "../server/storage/archive.js";
+const args = process.argv.slice(2);
+const value = (flag) => {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : null;
+};
+try {
+  const source = value("--backup");
+  if (!source || !["verify", "restore"].includes(args[0]))
+    throw Error(
+      "用法：npm run recovery -- verify --backup 文件；或 restore --backup 文件 --to 新文件",
+    );
+  if (args[0] === "verify") {
+    const result = verifyArchive(source);
+    console.log(
+      `备份检查通过，数据库版本 ${result.schemaVersion}，${result.manifest ? "SHA-256 清单匹配" : "旧备份无校验清单"}`,
+    );
+  } else {
+    const target = value("--to");
+    if (!target) throw Error("恢复必须指定 --to 新文件，现有数据库不会被覆盖");
+    console.log("恢复并校验完成：" + restoreToNewFile(source, target));
+  }
+} catch (error) {
+  console.error(error.message);
+  process.exitCode = 1;
+}

package/scripts/runtime.js

@@ -0,0 +1,25 @@
+import { mkdirSync } from "node:fs";
+import { runtimePaths } from "../server/paths.js";
+import { initializeEnvironment } from "./setup.js";
+
+export function prepareRuntime({ initialize = true } = {}) {
+  let paths = runtimePaths();
+  process.env.LUCKYTRI_HOME = paths.home;
+  if (initialize) {
+    mkdirSync(paths.home, { recursive: true, mode: 0o700 });
+    if (initializeEnvironment(paths.home))
+      console.log(
+        `已创建本机配置 / Created local configuration: ${paths.config}\n首次访问请在本机编辑器查看 ADMIN_TOKEN；不要分享配置文件。`,
+      );
+  }
+  try {
+    process.loadEnvFile(paths.config);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  paths = runtimePaths();
+  // Child processes and backup workers inherit the same absolute paths.
+  process.env.DB_PATH = paths.database;
+  process.env.BACKUP_DIR = paths.backups;
+  return paths;
+}

package/scripts/service.js

@@ -0,0 +1,47 @@
+import { runtimePaths } from "../server/paths.js";
+
+export function serviceUrl(env = process.env) {
+  const port = Number(env.PORT || 3210);
+  if (!Number.isInteger(port) || port < 1 || port > 65535)
+    throw Error("PORT 必须是 1–65535 / PORT must be between 1 and 65535");
+  const raw = env.HOST || "127.0.0.1";
+  const host = raw === "0.0.0.0" ? "127.0.0.1" : raw === "::" ? "::1" : raw;
+  return new URL(`http://${host.includes(":") ? `[${host}]` : host}:${port}`)
+    .origin;
+}
+
+export const serviceHeaders = () => ({
+  "Content-Type": "application/json",
+  Authorization: `Bearer ${process.env.ADMIN_TOKEN || ""}`,
+});
+
+export async function running({ base = serviceUrl(), lenient = false } = {}) {
+  let response;
+  try {
+    response = await fetch(base + "/api/service/status", {
+      headers: serviceHeaders(),
+      signal: AbortSignal.timeout(1500),
+    });
+  } catch (error) {
+    if (lenient || error.cause?.code === "ECONNREFUSED") return false;
+    throw Error("无法确认端口状态，请检查服务或网络；未重复启动。");
+  }
+  if (!response.ok)
+    throw Error("端口已被占用或管理令牌不匹配，请检查本机配置。");
+  let info;
+  try {
+    info = await response.json();
+  } catch {
+    throw Error("此端口运行的不是 LuckyTri。");
+  }
+  const paths = runtimePaths();
+  const normalize = (value) =>
+    process.platform === "win32" ? value.toLowerCase() : value;
+  if (
+    !["luckytri", "luckybot", "lucky", "xiaoman"].includes(info.app) ||
+    typeof (info.home ?? info.workspace) !== "string" ||
+    normalize(info.home ?? info.workspace) !== normalize(paths.home)
+  )
+    throw Error("此端口已被其他实例占用，未操作任何进程。");
+  return true;
+}

package/scripts/setup.js

@@ -0,0 +1,50 @@
+import { randomBytes } from "node:crypto";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { runtimePaths } from "../server/paths.js";
+
+export function initializeEnvironment(directory = runtimePaths().home) {
+  mkdirSync(directory, { recursive: true, mode: 0o700 });
+  const file = resolve(directory, ".env");
+  const token = () => randomBytes(32).toString("hex");
+  const content = [
+    "# LuckyTri 本机配置。修改后重启服务，不要公开此文件。",
+    "# LuckyTri local configuration. Restart after editing and never share this file.",
+    "HOST=127.0.0.1",
+    "PORT=3210",
+    `ADMIN_TOKEN=${token()}`,
+    "",
+    "# 连接 QQ 的方式二选一，也可以在管理界面「连接 QQ」里选择。",
+    "# Pick one way to connect QQ; it can also be chosen in the studio under Connect QQ.",
+    "# LUCKYTRI_CHANNEL=onebot   # onebot | qqbot；设置后界面里不能再改 / locks the choice when set",
+    "",
+    "# OneBot 11",
+    `ONEBOT_TOKEN=${token()}`,
+    "",
+    "# QQ 官方机器人 / QQ official bot",
+    "# QQBOT_APP_ID=",
+    "# QQBOT_APP_SECRET=",
+    "",
+    "LLM_API_KEY=",
+    "",
+  ].join("\n");
+  try {
+    writeFileSync(file, content, { flag: "wx", mode: 0o600 });
+    return true;
+  } catch (error) {
+    if (error.code === "EEXIST") return false;
+    throw error;
+  }
+}
+if (
+  process.argv[1] &&
+  import.meta.url === pathToFileURL(resolve(process.argv[1])).href
+) {
+  const created = initializeEnvironment();
+  console.log(
+    created
+      ? "已生成 .env 与两枚不同的随机令牌。请在本机编辑器中查看，修改后重启服务。\nCreated .env with two different random tokens. Open it in a local editor and restart after changes."
+      : "已有 .env，已保留原文件，不覆盖任何配置。\nA .env already exists and was left untouched.",
+  );
+}

package/scripts/start-server.js

@@ -0,0 +1,41 @@
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import { prepareRuntime } from "./runtime.js";
+import {
+  resolveProxyEnvironment,
+  supportsNodeEnvironmentProxy,
+} from "./proxy-config.js";
+
+const paths = prepareRuntime();
+const proxy = await resolveProxyEnvironment(process.env);
+if (proxy.enabled && !supportsNodeEnvironmentProxy())
+  throw new Error(
+    "系统代理转发需要 Node.js 24.5 或更高版本。请升级 Node.js 后重启 LuckyTri。",
+  );
+
+const args = [
+  ...(proxy.enabled ? ["--use-env-proxy"] : []),
+  join(paths.package, "server", "index.js"),
+];
+const env = { ...process.env, ...proxy.env };
+if (proxy.enabled) console.log("已启用系统代理，外部 API 请求将经代理转发。");
+else if (proxy.source === "windows-pac-unsupported")
+  console.log(
+    "检测到 PAC 自动代理；LuckyTri 暂不解析 PAC，请改用本机 HTTP 代理或配置 HTTPS_PROXY。",
+  );
+else console.log("未检测到系统代理，外部 API 请求将直连。");
+
+const child = spawn(process.execPath, args, {
+  cwd: paths.home,
+  env,
+  stdio: "inherit",
+});
+for (const signal of ["SIGINT", "SIGTERM"])
+  process.on(signal, () => child.kill(signal));
+child.once("error", (error) => {
+  console.error(`LuckyTri 启动失败：${error.message}`);
+  process.exitCode = 1;
+});
+child.once("exit", (code, signal) => {
+  process.exitCode = signal ? 1 : (code ?? 1);
+});

package/scripts/stop.js

@@ -0,0 +1,36 @@
+import { prepareRuntime } from "./runtime.js";
+import { running, serviceHeaders, serviceUrl } from "./service.js";
+import { starting } from "../server/startup-lock.js";
+try {
+  prepareRuntime({ initialize: false });
+  const base = serviceUrl();
+  if (!(await running({ base }))) {
+    console.log("LuckyTri 已经停止 / LuckyTri is already stopped");
+  } else {
+    const stopped = await fetch(base + "/api/service/stop", {
+      method: "POST",
+      headers: serviceHeaders(),
+      body: "{}",
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!stopped.ok) throw new Error("服务拒绝停止请求");
+    let stoppedConfirmed = false;
+    for (let attempt = 0; attempt < 40; attempt++) {
+      await new Promise((resolve) => setTimeout(resolve, 150));
+      if (!(await running({ base, lenient: true })) && !starting()) {
+        stoppedConfirmed = true;
+        break;
+      }
+    }
+    if (!stoppedConfirmed)
+      throw Error("服务仍在停止中，请稍后再检查 / Service is still stopping");
+    console.log("LuckyTri 已停止 / LuckyTri stopped");
+  }
+} catch (error) {
+  console.error(
+    error instanceof TypeError
+      ? "未连接到 LuckyTri，可能已经停止"
+      : error.message,
+  );
+  process.exitCode = 1;
+}

package/server/app.js

@@ -0,0 +1,96 @@
+import express from "express";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { tokenEqual } from "./http.js";
+import { localizeApi } from "./i18n/index.js";
+import { mountStudio } from "./studio/settings.js";
+import { mountManagement } from "./studio/management.js";
+import { mountCore } from "./core/api.js";
+import { mountKnowledge } from "./knowledge/api.js";
+import { mountEvents } from "./core/events.js";
+import { mountMind } from "./mind/api.js";
+import { mountPlugins } from "./plugins/api.js";
+import { Life } from "./mind/life/index.js";
+import { runtimePaths } from "./paths.js";
+
+export function createApp({ store, chatSystem, runtime, life, plugins }) {
+  const app = express();
+  app.use("/api", localizeApi);
+  app.use("/api", (req, res, next) => {
+    res.setHeader("Cache-Control", "no-store");
+    if (
+      req.headers.origin &&
+      req.headers.origin !== `${req.protocol}://${req.headers.host}`
+    )
+      return res.status(403).json({ error: "不允许跨站访问" });
+    if (
+      process.env.ADMIN_TOKEN &&
+      !tokenEqual(
+        req.headers.authorization,
+        `Bearer ${process.env.ADMIN_TOKEN}`,
+      )
+    )
+      return res.status(401).json({ error: "请输入管理令牌" });
+    next();
+  });
+  if (plugins) {
+    app.post(
+      "/api/plugins/import/upload",
+      express.raw({ type: "*/*", limit: "21mb" }),
+      (req, res) => {
+        try {
+          res.json(plugins.install.stageUpload(req.body));
+        } catch (error) {
+          res.status(400).json({ error: error.message });
+        }
+      },
+    );
+  }
+  app.use(express.json({ limit: "4mb" }));
+  app.use("/api", (req, res, next) => {
+    if (
+      ["POST", "PATCH", "PUT"].includes(req.method) &&
+      (!req.body || typeof req.body !== "object" || Array.isArray(req.body))
+    )
+      return res.status(400).json({ error: "请提交 JSON 对象" });
+    next();
+  });
+  mountStudio(app, store, runtime, chatSystem);
+  mountManagement(app, store, chatSystem);
+  mountCore(app, chatSystem);
+  mountMind(app, chatSystem, life || new Life(chatSystem));
+  mountKnowledge(app, chatSystem);
+  mountEvents(app, chatSystem);
+  mountPlugins(app, plugins);
+  // Built assets carry a content hash; the page that names them must not be
+  // cached, or an upgrade leaves the browser asking for files that are gone.
+  app.use(
+    "/app",
+    express.static(join(runtimePaths().public, "app"), {
+      setHeaders(res, path) {
+        res.setHeader(
+          "Cache-Control",
+          path.endsWith(".html")
+            ? "no-cache"
+            : "public, max-age=31536000, immutable",
+        );
+      },
+    }),
+  );
+  const studioIndex = join(runtimePaths().public, "app", "index.html");
+  app.get(["/", "/index.html", "/app", "/app/"], (req, res, next) => {
+    if (!existsSync(studioIndex)) return next();
+    res.setHeader("Cache-Control", "no-cache");
+    res.sendFile(studioIndex);
+  });
+  app.use(express.static(runtimePaths().public));
+  app.use((err, req, res, next) => {
+    console.error(err.message);
+    if (err.type === "entity.too.large")
+      return res.status(413).json({ error: "请求内容过大" });
+    if (err.type === "entity.parse.failed")
+      return res.status(400).json({ error: "JSON 格式无效" });
+    res.status(500).json({ error: "请求失败，请检查输入或服务日志" });
+  });
+  return app;
+}

package/server/channels/adapters.js

@@ -0,0 +1,27 @@
+import { onebot } from "./onebot/adapter.js";
+import { qqbot } from "./qqbot/adapter.js";
+import { parseSessionKey } from "./session-key.js";
+
+// What the core may ask a platform without being connected to it, such as
+// which media links are safe to download. One entry per channel type.
+const adapters = new Map([
+  [onebot.type, onebot],
+  [qqbot.type, qqbot],
+]);
+
+export function registerChannel(adapter) {
+  adapters.set(adapter.type, adapter);
+}
+
+export function adapterFor(sessionOrType = "onebot") {
+  try {
+    const type = String(sessionOrType).includes(":")
+      ? parseSessionKey(sessionOrType).channel
+      : sessionOrType;
+    return adapters.get(type) || onebot;
+  } catch {
+    return onebot;
+  }
+}
+
+export { onebot, qqbot };

package/server/channels/contract.js

@@ -0,0 +1,57 @@
+// A channel is the only part of LuckyTri that knows how a platform connects.
+// Everything above it (sessions, attention, memory, time, her inner life) sees
+// the same neutral message and talks back through the same few calls, so a
+// new platform is one folder that fulfils this contract and one line in the
+// registry (see channels/index.js).
+//
+//   type                 stable id, also the first part of every session key
+//   capabilities         what the platform can express: mention, quote,
+//                        image, thread, sticker
+//   attach(server, chat) one-time wiring to the HTTP server and the ChatSystem
+//   start()              begin accepting or opening the connection for the
+//                        current settings; safe to call again after a change
+//   stop()               drop the connection and stop timers; safe to repeat
+//   send(message, text)  deliver one bubble; resolves { message_id }
+//   fetchQuoted(message) the message that `message.replyId` points to, or null
+//   fetchImage(file)     a fresh URL or bytes for an expired image, or null
+//   fetchMedia(file, type)  optional: a voice or file the same way, or null
+//   refreshDirectory()   learn real group and friend names; resolves a count
+//   canReach(sessionId)  whether she may start a conversation there now
+//   status()             { online, ... } for the connection panel
+//   close()              final shutdown
+//
+// The message every channel hands to `ChatSystem.receive` is neutral. Besides
+// the fields the core already uses, an adapter fills platformId, accountId,
+// time, mentions, replyId and attachments itself, so nothing above the
+// channel ever has to parse a platform's wire format.
+
+const REQUIRED = [
+  "start",
+  "stop",
+  "attach",
+  "send",
+  "fetchQuoted",
+  "fetchImage",
+  "refreshDirectory",
+  "canReach",
+  "status",
+  "close",
+];
+
+export function defineChannel(channel) {
+  if (!channel || typeof channel.type !== "string" || !channel.type)
+    throw new TypeError("channel needs a type");
+  for (const name of REQUIRED)
+    if (typeof channel[name] !== "function")
+      throw new TypeError(`channel ${channel.type} is missing ${name}()`);
+  return Object.freeze({
+    capabilities: {
+      mention: false,
+      quote: false,
+      image: false,
+      thread: false,
+      sticker: false,
+    },
+    ...channel,
+  });
+}