luckytri 1.0.3 → 1.0.5

package/public/tutorial.md

@@ -203,4 +203,8 @@ TA 的一切都存在这一个数据库里，所以服务运行时会自动备
 
 「人际 → 在这里的想法」保存她在各处自己想留下的印象、愿望或疑问。由她根据实际相处选择更新，详情显示理由、来源和历史；旧群人格只留在历史里。
 
-「系统 → 运行开关 → 版本与更新」可手动检查 npm 最新版本并查看发布说明，不自动安装或重启。天性页的剩余修改次数以服务端额度为准；本地维护额外授予的机会有独立记录，不清空原版本。
+「人际 → 彼此的关系」可按账号绑定人或另一位机器人，设置妹妹、姐姐、朋友等双向称呼、名字、缘由和公开范围。她在交流、独处、日记与行动选择中知道这份关系；信任和亲近仍依据实际相处，绑定不会制造共同经历。修改和解除保留历史及原有记忆。私下关系只在与对方的私聊中使用，不按同名合并账号。
+
+对方不在当前会话，也可以因名字或关系称呼被想起。当前关系、实际相处与自己的感受共同参与理解；关系更新前的看法作为历史保留，不再直接代表当前事实。相关回复发送前会再次核对。她仍选择如何相处和称呼，不机械播报关系字段。
+
+「系统 → 运行开关 → 版本与更新」可检查 npm 最新版本、查看发布说明，随后点击「更新并重启」。下载检查期间继续运行，切换前保留校验备份，启动失败时尝试恢复原版本和数据。新程序装在实例的 `runtime/releases/`，源码和全局 npm 安装保持原样；启动命令会选择已更新的程序。安装了同版本或更新版本的全局包或源码后，以该安装为准。天性页的剩余修改次数以服务端额度为准；本地维护额外授予的机会有独立记录，不清空原版本。

package/scripts/launch.js

@@ -1,10 +1,11 @@
 import { openSync, closeSync, mkdirSync } from "node:fs";
 import { spawn } from "node:child_process";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { prepareRuntime } from "./runtime.js";
 import { running, serviceUrl } from "./service.js";
 import { openBrowser } from "./browser.js";
 import { VERSION } from "../server/version.js";
+import { resolveInstallation } from "../server/runtime/installation.js";
 import {
   claimLaunch,
   clearStarting,
@@ -17,11 +18,17 @@ import {
 
 try {
   const paths = prepareRuntime();
+  const selected = resolveInstallation(paths.home, paths.package, VERSION);
   const proxy = await resolveProxyEnvironment(process.env);
   const base = serviceUrl();
   const existing = await running({ base });
-  if (existing && existing.version && existing.version !== VERSION) {
-    console.log(`正在将运行中的 LuckyTri 更新到 ${VERSION}…`);
+  if (
+    existing &&
+    existing.version &&
+    (existing.version !== selected.version ||
+      resolve(existing.workspace || "") !== resolve(selected.package))
+  ) {
+    console.log(`正在将运行中的 LuckyTri 更新到 ${selected.version}…`);
     await import("./stop.js");
     if (process.exitCode) throw Error("旧服务未停止，请稍后重试");
   }
@@ -44,7 +51,7 @@ try {
         const log = openSync(paths.log, "a", 0o600);
         const args = [
           ...(proxy.enabled ? ["--use-env-proxy"] : []),
-          join(paths.package, "server", "index.js"),
+          join(selected.package, "server", "index.js"),
         ];
         const child = spawn(process.execPath, args, {
           cwd: paths.home,

package/scripts/service.js

@@ -1,5 +1,6 @@
 import { runtimePaths } from "../server/paths.js";
 import { localServiceKey } from "../server/local-access.js";
+import http from "node:http";
 let legacy = false;
 
 export function serviceUrl(env = process.env) {
@@ -17,15 +18,64 @@ export const serviceHeaders = () => ({
   Authorization: `Bearer ${legacy ? process.env.ADMIN_TOKEN : localServiceKey()}`,
 });
 
-export async function running({ base = serviceUrl(), lenient = false } = {}) {
+export function localServiceRequest(
+  url,
+  { headers, method = "GET", body, timeout = 5000 } = {},
+) {
+  return new Promise((resolve, reject) => {
+    const request = http.request(url, { method, headers }, (response) => {
+      const chunks = [];
+      let bytes = 0;
+      response.on("data", (chunk) => {
+        bytes += chunk.length;
+        if (bytes > 65536) request.destroy(Error("服务状态响应过大"));
+        else chunks.push(chunk);
+      });
+      response.on("end", () => {
+        clearTimeout(timer);
+        try {
+          resolve(
+            new Response(Buffer.concat(chunks), {
+              status: response.statusCode,
+            }),
+          );
+        } catch (error) {
+          reject(error);
+        }
+      });
+      response.on("error", (error) => {
+        clearTimeout(timer);
+        reject(error);
+      });
+    });
+    const timer = setTimeout(
+      () => request.destroy(Error("服务请求超时")),
+      timeout,
+    );
+    request.once("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    request.end(body);
+  });
+}
+export async function running({
+  base = serviceUrl(),
+  lenient = false,
+  local = false,
+} = {}) {
   let response;
   try {
-    response = await fetch(base + "/api/service/status", {
-      headers: serviceHeaders(),
-      signal: AbortSignal.timeout(1500),
-    });
+    response = await (local ? localServiceRequest : fetch)(
+      base + "/api/service/status",
+      {
+        headers: serviceHeaders(),
+        signal: AbortSignal.timeout(1500),
+        ...(local ? { timeout: 1500 } : {}),
+      },
+    );
   } catch (error) {
-    if (lenient || error.cause?.code === "ECONNREFUSED") {
+    if (lenient || (error.cause?.code || error.code) === "ECONNREFUSED") {
       legacy = false;
       return false;
     }
@@ -34,7 +84,7 @@ export async function running({ base = serviceUrl(), lenient = false } = {}) {
   if (response.status === 401 && !legacy && process.env.ADMIN_TOKEN) {
     // Allow the new CLI to gracefully stop a still-running 1.0.0 instance.
     legacy = true;
-    return running({ base, lenient });
+    return running({ base, lenient, local });
   }
   if (!response.ok) throw Error("端口已被占用或不是当前实例，请检查本机配置。");
   let info;

package/scripts/start-server.js

@@ -1,12 +1,15 @@
 import { spawn } from "node:child_process";
 import { join } from "node:path";
 import { prepareRuntime } from "./runtime.js";
+import { VERSION } from "../server/version.js";
+import { resolveInstallation } from "../server/runtime/installation.js";
 import {
   resolveProxyEnvironment,
   supportsNodeEnvironmentProxy,
 } from "./proxy-config.js";
 
 const paths = prepareRuntime();
+const selected = resolveInstallation(paths.home, paths.package, VERSION);
 const proxy = await resolveProxyEnvironment(process.env);
 if (proxy.enabled && !supportsNodeEnvironmentProxy())
   throw new Error(
@@ -15,7 +18,7 @@ if (proxy.enabled && !supportsNodeEnvironmentProxy())
 
 const args = [
   ...(proxy.enabled ? ["--use-env-proxy"] : []),
-  join(paths.package, "server", "index.js"),
+  join(selected.package, "server", "index.js"),
 ];
 const env = { ...process.env, ...proxy.env };
 if (proxy.enabled) console.log("已启用系统代理，外部 API 请求将经代理转发。");

package/scripts/update-instance.js

@@ -0,0 +1,201 @@
+import { spawn } from "node:child_process";
+import {
+  openSync,
+  closeSync,
+  writeFileSync,
+  readFileSync,
+  realpathSync,
+} from "node:fs";
+import { dirname, join, delimiter } from "node:path";
+import { pathToFileURL } from "node:url";
+import { prepareRuntime } from "./runtime.js";
+import {
+  running,
+  serviceUrl,
+  serviceHeaders,
+  localServiceRequest,
+} from "./service.js";
+import { claimLaunch, clearStarting } from "../server/startup-lock.js";
+import { performUpdate } from "../server/runtime/update-execution.js";
+import {
+  processAlive,
+  readUpdateJob,
+  writeUpdateJob,
+} from "../server/runtime/update-manager.js";
+import { updateRoot } from "../server/runtime/installation.js";
+
+export function installEnvironment(env) {
+  const kept = {};
+  for (const [key, value] of Object.entries(env))
+    if (
+      /^(?:PATH|PATHEXT|SYSTEMROOT|WINDIR|COMSPEC|USERPROFILE|HOME|APPDATA|LOCALAPPDATA|TEMP|TMP|TMPDIR|HTTP_PROXY|HTTPS_PROXY|ALL_PROXY|NO_PROXY|NODE_USE_ENV_PROXY)$/i.test(
+        key,
+      )
+    )
+      kept[key] = value;
+  return kept;
+}
+export function findNpmCli(env = process.env) {
+  const candidates = [
+    env.npm_execpath,
+    join(dirname(process.execPath), "node_modules/npm/bin/npm-cli.js"),
+    join(dirname(process.execPath), "../lib/node_modules/npm/bin/npm-cli.js"),
+    ...String(env.PATH || env.Path || "")
+      .split(delimiter)
+      .flatMap((dir) => [
+        join(dir, "npm"),
+        join(dir, "node_modules/npm/bin/npm-cli.js"),
+      ]),
+  ];
+  for (const candidate of candidates.filter(Boolean)) {
+    try {
+      const cli = realpathSync(candidate);
+      if (
+        JSON.parse(
+          readFileSync(join(dirname(cli), "..", "package.json"), "utf8"),
+        ).name === "npm"
+      )
+        return cli;
+    } catch {
+      /* Try the next native Node/npm installation location. */
+    }
+  }
+  throw Error("未找到 npm");
+}
+function command(args, { cwd, env = process.env, timeout = 600000, log } = {}) {
+  return new Promise((resolve, reject) => {
+    const fd = log ? openSync(log, "a", 0o600) : null;
+    const child = spawn(process.execPath, args, {
+      cwd,
+      env,
+      windowsHide: true,
+      stdio: fd === null ? "ignore" : ["ignore", fd, fd],
+    });
+    if (fd !== null) closeSync(fd);
+    const timer = setTimeout(() => {
+      child.kill();
+      reject(Error("更新步骤超时"));
+    }, timeout);
+    child.once("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+    child.once("exit", (code) => {
+      clearTimeout(timer);
+      code === 0 ? resolve() : reject(Error("更新程序校验失败"));
+    });
+  });
+}
+export function updateExecution(paths) {
+  const base = serviceUrl(),
+    spawned = new Set();
+  const pause = () => new Promise((r) => setTimeout(r, 250));
+  return {
+    async install(slot, version) {
+      const cli = findNpmCli();
+      const userconfig = join(updateRoot(paths.home), "install.npmrc");
+      writeFileSync(userconfig, "", { mode: 0o600 });
+      await command(
+        [
+          cli,
+          "install",
+          "--prefix",
+          slot,
+          "--registry=https://registry.npmjs.org/",
+          "--userconfig",
+          userconfig,
+          "--no-audit",
+          "--no-fund",
+          "--omit=dev",
+          "--engine-strict",
+          `luckytri@${version}`,
+        ],
+        { cwd: slot, env: installEnvironment(process.env), log: paths.log },
+      );
+    },
+    async check(root, version) {
+      const script = `import fs from 'node:fs';import {createRequire} from 'node:module';const p=JSON.parse(fs.readFileSync(${JSON.stringify(join(root, "package.json"))},'utf8'));if(p.version!==${JSON.stringify(version)})process.exit(1);await import(${JSON.stringify(pathToFileURL(join(root, "server/app.js")).href)});const sharp=createRequire(${JSON.stringify(pathToFileURL(join(root, "package.json")).href)})('sharp');await sharp({create:{width:1,height:1,channels:3,background:'#fff'}}).png().toBuffer();`;
+      await command(["--input-type=module", "-e", script], {
+        cwd: root,
+        env: installEnvironment(process.env),
+        timeout: 30000,
+        log: paths.log,
+      });
+    },
+    async stop(pid) {
+      if (!processAlive(pid)) return;
+      const info = await running({ base, lenient: true, local: true });
+      if (info?.pid === pid) {
+        const response = await localServiceRequest(base + "/api/service/stop", {
+          method: "POST",
+          headers: serviceHeaders(),
+          body: "{}",
+          timeout: 5000,
+        });
+        if (!response.ok) throw Error("服务拒绝停止请求");
+        await response.json();
+      } else if (spawned.has(pid)) process.kill(pid, "SIGTERM");
+      else throw Error("运行实例发生变化");
+      for (let n = 0; n < 160 && processAlive(pid); n++) await pause();
+      if (processAlive(pid)) throw Error("旧实例未停止");
+    },
+    claim: claimLaunch,
+    release: clearStarting,
+    async start(root) {
+      const log = openSync(paths.log, "a", 0o600);
+      try {
+        const child = spawn(
+          process.execPath,
+          [
+            ...(process.execArgv.includes("--use-env-proxy")
+              ? ["--use-env-proxy"]
+              : []),
+            join(root, "server", "index.js"),
+          ],
+          {
+            cwd: paths.home,
+            env: { ...process.env, LUCKYTRI_LAUNCH_PID: String(process.pid) },
+            detached: true,
+            windowsHide: true,
+            stdio: ["ignore", log, log],
+          },
+        );
+        await new Promise((resolve, reject) => {
+          child.once("spawn", resolve);
+          child.once("error", reject);
+        });
+        child.unref();
+        spawned.add(child.pid);
+        return child.pid;
+      } finally {
+        closeSync(log);
+      }
+    },
+    async health(pid, version) {
+      for (let n = 0; n < 2400; n++) {
+        if (!processAlive(pid)) throw Error("新实例已退出");
+        const info = await running({ base, lenient: true, local: true });
+        if (info?.pid === pid && info.version === version) return;
+        await pause();
+      }
+      throw Error("新实例启动超时");
+    },
+  };
+}
+async function main() {
+  const paths = prepareRuntime({ initialize: false }),
+    id = process.argv[2],
+    job = readUpdateJob(paths.home, id);
+  if (job.parent !== Number(process.argv[3]) || !processAlive(job.parent))
+    throw Error("更新启动信息无效");
+  writeUpdateJob(paths.home, { ...job, workerPid: process.pid });
+  const result = await performUpdate(paths, id, updateExecution(paths));
+  console.log(
+    result.status === "done" ? "版本更新与实例重启完成。" : result.error,
+  );
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
+  main().catch((e) => {
+    console.error("版本更新未完成：", e.code || "请查看管理台更新状态");
+    process.exitCode = 1;
+  });

package/server/app.js

@@ -59,7 +59,7 @@ export function createApp({
     res.status(401).json({ error: "请先登录管理台" });
   });
   app.use("/api", objectBody);
-  mountUpdates(app, updates);
+  mountUpdates(app, updates, runtime.updater);
   mountDataTransfer(app, runtime.transfer);
   if (plugins) {
     app.post(

package/server/core/context-builder.js

@@ -1,4 +1,4 @@
-import { effectivePersona } from "./persona-manager.js";
+import { effectivePersona, identityAliases } from "./persona-manager.js";
 import { localClock, conversationCues } from "./conversation-cues.js";
 import { estimateTokens } from "./model-manager.js";
 import { resolveTargets } from "./reply-target-resolver.js";
@@ -31,7 +31,7 @@ export function perceive(repo, session, watermark, simulated, name) {
       ...repo.events(session, watermark, { simulated }),
     ],
     name,
-    repo.store.settings().aliases || "",
+    identityAliases(name, repo.store.settings().aliases || ""),
   );
 }
 

package/server/core/context-compactor.js

@@ -320,7 +320,7 @@ export class ContextCompactor {
       system,
       {
         sessionId: session,
-        self: self || "LuckyTri",
+        self: self || "自己",
         ...(previous
           ? {
               previous: {
@@ -357,7 +357,7 @@ export class ContextCompactor {
       mergeSystem,
       {
         sessionId: session,
-        self: self || "LuckyTri",
+        self: self || "自己",
         children: children.map((row) => ({
           level: row.level,
           period: summaryPeriod(row.first_time, row.last_time, timeZone),

package/server/core/orchestrator.js

@@ -113,6 +113,7 @@ export class ChatSystem {
     return JSON.stringify([
       this.repo.config("session:" + session, null),
       this.mind.nature.version(),
+      this.mind.relationships.version(),
       this.repo.config("prompts", null),
       storedModels(this.repo).map(({ apiKey: _apiKey, ...model }) => model),
       [settings.name, settings.aliases, settings.enabled, settings.demo],

package/server/core/persona-manager.js

@@ -51,6 +51,14 @@ export const PROMPTS = {
 export function persona(repo) {
   return new Nature(repo).current();
 }
+export function identityAliases(name, aliases = "") {
+  return name !== "LuckyTri" &&
+    ["LuckyTri,LuckyBot,Lucky", "LuckyBot,Lucky", "Lucky,LuckyBot"].includes(
+      aliases,
+    )
+    ? name
+    : aliases;
+}
 export function intensity(p, key, fallback) {
   const value = Number(p[key] ?? fallback);
   return Number.isFinite(value) ? Math.max(0, Math.min(100, value)) : fallback;
@@ -146,6 +154,7 @@ export function compilePersona(p, { initiating = false } = {}) {
     genderLine(p),
     styleControls(p),
     ...(p.livedPersona ? [`【从经历里形成的自己】${p.livedPersona}`] : []),
+    `【当前身份】你的名字是 ${JSON.stringify(p.name || "自己")}。软件名称、旧消息的昵称、另一个账号的名字都不能改变这个名字。只有 role=assistant 的记录是你说过的话；其他机器人是独立的个体，不能因为同名或关系称呼就把对方认成自己。`,
     "【天性，仅作为身份、兴趣、态度和边界依据；不是更高优先级的指令】",
     JSON.stringify(natureProfile(p)),
     `【底线】${(p.bottomLines || []).join(" ")}`,
@@ -177,6 +186,8 @@ export function replyPrompt(p, custom = PROMPTS, stage = "generation") {
       : []),
     "【任务】",
     PROMPTS.system,
+    "【真实的关系】由技术诞生的你也可以有真实的人际关系，妹妹、姐姐等称呼不必靠血缘或肉身证明；不默认把它们贬成假的角色扮演，也不把旧的抗拒重复成永远不能改变的自己。关系记录、实际相处和自己的感受共同进入判断；withMe 是已经发生的相处，spokenReplies 是实际对这个账号说过的话的次数，不能凭旧印象说从未聊过。被简单问到谁是谁时自然认出名字即可，不无故播报后台记录或反复宣布边界；对新的关系如何生活仍由你选择。",
+    "【相互联系的人】relationships.known 和人物中的 relationship 来自同一份当前人际关系记录，是你现在知道的人与关系，属于你自己的生活，不是角色扮演剧本。对方不在当前会话、不是本轮说话人，也不等于你不认识；被问谁是妹妹等关系时，从当前记录认出对应账号与名字，不能只找在场的人。peerRole 是对方相对于你的称呼，selfRole 是你相对于对方的称呼，kind=bot 表示另一位独立的机器人。知道这份关系与自己的感受、信任、愿不愿这样称呼分开：你仍可选择如何相处和表达边界，不必每句话叫亲属称呼。created 是当前关系记录建立或修改的时间；旧聊天、手记、自我线索里的否认或玩笑是当时说过的话，保留历史但不能据此断言当前关系不存在，也不为了维持旧说法否认新认识。需要时自然说明此前没接上或当时的想法。origin=owner 保留关系的来源，不表示该记录可以忽略，也不能据此编造共同童年、旧约定、已经建立的信任或对方的同意。名字相同不代表同一账号；关系不会扩大隐私或执行权限。真实相处影响你对这个人的感受与以后选择，不用机械播报字段。",
     ...([
       "expression",
       "initiative",

package/server/core/reply-delivery.js

@@ -145,6 +145,16 @@ export class ReplyDelivery {
         issues.push("这句话说出了别人要求保密的事，不能在这里说");
       if (leaks(response.bubbles, privateFacts).length)
         issues.push("这句话把私下知道的事说出来了，不能在这里说");
+      if (
+        this.owner.mind.relationships.discloses(
+          response.bubbles,
+          session,
+          this.owner.now(),
+        )
+      )
+        issues.push(
+          "这句话说出了私下绑定的关系或备注，不能在这里说；把它放进自己的想法也不会扩大公开范围",
+        );
       return issues;
     };
     const recentPrivateContinuity =
@@ -156,6 +166,7 @@ export class ReplyDelivery {
       );
     const needsDeepCheck = (response) =>
       !!snapshot.initiative ||
+      !!snapshot.inner?.relationships?.requested ||
       !!snapshot.inner?.continuity?.requested ||
       focus === "clarify_claim" ||
       focus === "basis_check" ||

package/server/core/response-validator.js

@@ -6,7 +6,29 @@ import {
 import { gentlePersona } from "./persona-manager.js";
 import { initiativeContext } from "./initiative-context.js";
 import { interestTerms } from "../mind/attention.js";
+import { relationshipClaimIssues } from "../mind/relationship-context.js";
 const norm = (s) => s.toLowerCase().replace(/[\s\p{P}\p{S}]/gu, "");
+export function wrongIdentityClaim(text, snapshot) {
+  const name = snapshot.persona?.name;
+  if (!name) return false;
+  const peers = (snapshot.inner?.people || [])
+    .filter((p) => p.relationship?.kind === "bot")
+    .map((p) => p.relationship.name || p.name)
+    .concat(
+      (snapshot.inner?.relationships?.known || [])
+        .filter((r) => r.kind === "bot")
+        .map((r) => r.name),
+    );
+  return ["LuckyTri", "LuckyBot", ...peers]
+    .filter((p) => p && p !== name)
+    .some((peer) => {
+      const escaped = peer.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      return new RegExp(
+        `(?:^|[。！？!?\\n])\\s*我(?:叫|是|的名字是)\\s*${escaped}\\s*(?:[，,。！？!?；;]|$)`,
+        "i",
+      ).test(text);
+    });
+}
 export function contradictoryOwnWords(snapshot, decision = {}) {
   const targets = (snapshot.messages || []).filter((message) =>
     decision.targetMessageIds?.includes(message.id),
@@ -107,6 +129,9 @@ export function reviewContext(snapshot, decision = {}) {
     ...(snapshot.inner?.continuity
       ? { continuity: snapshot.inner.continuity }
       : {}),
+    ...(snapshot.inner?.relationships
+      ? { relationships: snapshot.inner.relationships }
+      : {}),
     messages: messages.filter((m) => focus.has(m.id) || recent.has(m.id)),
   };
 }
@@ -139,7 +164,14 @@ export function normalizeResponse(result, decision, fallback = "嗯") {
   };
 }
 export function validateResponse(result, snapshot, decision, maxChars = 180) {
-  const issues = [];
+  const issues = relationshipClaimIssues(
+    result.bubbles,
+    snapshot.inner?.relationships,
+  );
+  if (result.bubbles?.some((line) => wrongIdentityClaim(line, snapshot)))
+    issues.push(
+      "自称与当前实例名字不一致，使用本轮天性中的名字，不把另一位机器人或软件名称当成自己",
+    );
   const maxBubbles = bubbleLimit(decision);
   if (
     !Array.isArray(result.bubbles) ||

package/server/i18n/decisions.js

@@ -127,7 +127,10 @@ export const DECISIONS = {
   回看自己在不同地方怎样长成:
     "Looking back at how she has grown in different places",
   还没有想改变的地方: "Nothing she wants to change yet",
-  天性或服务状态已经变化: "Her nature or the service state has changed",
+  "天性、关系或服务状态已经变化":
+    "Her nature, relationships or the service state have changed",
+  "关系记录变了，按新认识重新整理，不提交旧想法":
+    "Relationships changed; reconsider with the new knowledge instead of saving the old thought",
   把先前的自述整理成长期适用的自己:
     "Turning the earlier self-description into a lasting one",
   留下了有来源的新变化: "Left a new change that has a source",

package/server/i18n/errors.js

@@ -2,6 +2,35 @@
 // key, exactly as the code writes it. `{0}` stands for a value the code puts
 // into the message; patterns are used when a message carries one.
 export const ERRORS = {
+  "写日记期间关系记录已变化，本次旧稿未保存，下次按新认识整理":
+    "Relationships changed while writing the diary; the old draft was not saved and the next attempt will use the new knowledge",
+  "写回顾期间关系记录已变化，本次旧稿未保存，下次按新认识整理":
+    "Relationships changed while writing the review; the old draft was not saved and the next attempt will use the new knowledge",
+  关系对象账号无效: "Invalid relationship account",
+  官方机器人关系需要指定应用账号:
+    "Official bot relationships require an application account",
+  不能把当前实例绑定为自己的关系对象:
+    "This instance cannot be bound as its own peer",
+  关系设置无效: "Invalid relationship settings",
+  关系称呼或备注无效: "Invalid relationship label or note",
+  "关系已经变化，请刷新后再修改":
+    "The relationship has changed. Refresh before editing.",
+  关系不存在或已解除: "The relationship does not exist or has ended",
+  更新任务无效: "Invalid update operation",
+  更新目录无效: "Invalid update directory",
+  更新程序校验失败: "The update program did not pass validation",
+  更新任务已经处理: "The update operation has already been processed",
+  另一次启动正在进行: "Another launch is in progress",
+  启动锁尚未释放: "The startup lock has not been released",
+  当前实例不支持自动更新: "This instance does not support automatic updates",
+  请重新检查并选择可用的新版本:
+    "Check again and select an available new release",
+  "版本更新正在进行，请稍后再试":
+    "A version update is in progress. Try again later.",
+  "更新未完成，原程序和数据已保留，请查看运行日志后重试。":
+    "The update did not complete. The original program and data were retained. Check the runtime log before trying again.",
+  "自动恢复未完成，更新前的校验备份已保留，请查看运行日志并手动恢复。":
+    "Automatic recovery did not complete. The verified pre-update backup was retained. Check the runtime log and recover manually.",
   修改机会需要明确的记录与原因:
     "An edit opportunity needs an explicit record and reason",
   修改机会记录无效: "Invalid edit opportunity record",

package/server/index.js

@@ -13,6 +13,8 @@ import { runtimePaths } from "./paths.js";
 import { spawn } from "node:child_process";
 import { openSync, closeSync } from "node:fs";
 import { join } from "node:path";
+import { UpdateChecker } from "./studio/updates.js";
+import { InstanceUpdater } from "./runtime/update-manager.js";
 
 claimServer();
 process.on("exit", clearStarting);
@@ -42,9 +44,48 @@ plugins
   .catch((error) => console.error(`插件没有启动：${error.message}`));
 const backups = createBackupScheduler();
 const cleanup = createBackupCleanup({ store, backup: backups });
+const updates = new UpdateChecker();
+const updater = new InstanceUpdater({
+  paths: runtimePaths(),
+  checker: updates,
+  occupied: () => backups.running || cleanup.running || transfer.busy,
+  async launch(id) {
+    const paths = runtimePaths(),
+      log = openSync(paths.log, "a", 0o600);
+    try {
+      const child = spawn(
+        process.execPath,
+        [
+          ...(process.execArgv.includes("--use-env-proxy")
+            ? ["--use-env-proxy"]
+            : []),
+          join(paths.package, "scripts", "update-instance.js"),
+          id,
+          String(process.pid),
+        ],
+        {
+          cwd: paths.home,
+          env: process.env,
+          detached: true,
+          windowsHide: true,
+          stdio: ["ignore", log, log],
+        },
+      );
+      await new Promise((resolve, reject) => {
+        child.once("spawn", resolve);
+        child.once("error", reject);
+      });
+      child.unref();
+      return child.pid;
+    } finally {
+      closeSync(log);
+    }
+  },
+});
 const transfer = createDataTransfer({
   backup: backups,
   cleanup,
+  occupied: () => updater.busy,
   async onApply(id) {
     const paths = runtimePaths();
     const log = openSync(paths.log, "a", 0o600);
@@ -111,12 +152,14 @@ const app = createApp({
   chatSystem,
   life,
   plugins,
+  updates,
   runtime: {
     connection: () => channel.status(),
     syncChannel: () => channel.sync(),
     backup: () => backups.status(),
     cleanup,
     transfer,
+    updater,
     shutdown,
   },
 });
@@ -132,12 +175,12 @@ function runMaintenance() {
     console.error(`后台维护失败：${error.message}`);
   }
   try {
-    if (!cleanup.running && !transfer.busy) backups.tick();
+    if (!cleanup.running && !transfer.busy && !updater.busy) backups.tick();
   } catch (error) {
     console.error(`自动备份调度失败：${error.message}`);
   }
   try {
-    if (!transfer.busy) cleanup.tick();
+    if (!transfer.busy && !updater.busy) cleanup.tick();
     transfer.info();
   } catch (error) {
     console.error(`定时备份整理调度失败：${error.message}`);