luckytri 1.0.2 → 1.0.4

package/server/mind/relationships.js

@@ -0,0 +1,279 @@
+import { randomUUID } from "node:crypto";
+import { parseSessionKey } from "../channels/session-key.js";
+import { hasCredential, text } from "./util.js";
+import { normalized } from "./util.js";
+import { leaks } from "./guard.js";
+
+export const RELATIONSHIP_ROLES = [
+  "妹妹",
+  "姐姐",
+  "弟弟",
+  "哥哥",
+  "朋友",
+  "伙伴",
+];
+const FAMILY = new Set(RELATIONSHIP_ROLES.slice(0, 4));
+const scope = (room) => {
+  try {
+    return room ? parseSessionKey(room) : null;
+  } catch {
+    return null;
+  }
+};
+
+// Account identity and an explicit arrangement, never invented encounters or
+// earned trust. Changes append history; nickname equality does not bind peers.
+export class Relationships {
+  constructor(mind) {
+    this.mind = mind;
+    this.db = mind.db;
+  }
+  version() {
+    return this.db
+      .prepare("SELECT COALESCE(MAX(rowid),0) n FROM mind_relationships")
+      .get().n;
+  }
+  current(subject, { now = Date.now(), room = "" } = {}) {
+    const place = scope(room);
+    const row = this.db
+      .prepare(
+        "SELECT * FROM mind_relationships WHERE subject_id=? AND created<=? ORDER BY created DESC,rowid DESC",
+      )
+      .all(String(subject), now)
+      .find(
+        (r) =>
+          !place ||
+          (r.channel === place.channel &&
+            (r.account_id === "_" || r.account_id === place.accountId)),
+      );
+    return row?.status === "active" ? row : null;
+  }
+  visible(row, room) {
+    if (!row || !room || row.discretion === "open") return !!row;
+    const place = scope(room);
+    return (
+      place?.kind === "private" &&
+      place.nativeId === row.subject_id &&
+      place.channel === row.channel &&
+      (row.account_id === "_" || place.accountId === row.account_id)
+    );
+  }
+  discloses(bubbles, room, now = Date.now()) {
+    const hidden = this.list(now).filter((row) => !this.visible(row, room));
+    if (
+      leaks(
+        bubbles,
+        hidden.filter((r) => r.note).map((r) => ({ content: r.note })),
+      ).length
+    )
+      return true;
+    const said = normalized(bubbles.join(" "));
+    const english = {
+      妹妹: "youngersister",
+      姐姐: "oldersister",
+      弟弟: "youngerbrother",
+      哥哥: "olderbrother",
+      朋友: "friend",
+      伙伴: "companion",
+    };
+    return hidden.some((row) => {
+      const names = [
+        row.name,
+        this.mind.bonds.name(row.subject_id),
+        row.subject_id,
+      ]
+        .filter(Boolean)
+        .map(normalized);
+      const role = normalized(row.peer_role),
+        en = english[row.peer_role] || role;
+      return names.some((name) =>
+        [
+          "我的" + role + name,
+          "我" + role + name,
+          name + "是我的" + role,
+          name + "是我" + role,
+          name + role,
+          "my" + en + name,
+          name + "ismy" + en,
+        ].some((line) => said.includes(line)),
+      );
+    });
+  }
+  weight(row) {
+    return row ? (FAMILY.has(row.peer_role) ? 0.15 : 0.05) : 0;
+  }
+  view(row, room = "") {
+    if (!this.visible(row, room)) return null;
+    return {
+      id: row.id,
+      subjectId: row.subject_id,
+      channel: row.channel,
+      accountId: row.account_id,
+      kind: row.kind,
+      name: row.name,
+      peerRole: row.peer_role,
+      selfRole: row.self_role,
+      discretion: row.discretion,
+      note: row.note,
+      created: row.created,
+      origin: "owner",
+    };
+  }
+  list(now = Date.now()) {
+    const seen = new Set();
+    return this.db
+      .prepare(
+        "SELECT * FROM mind_relationships WHERE created<=? ORDER BY created DESC,rowid DESC",
+      )
+      .all(now)
+      .filter((r) => {
+        const key = JSON.stringify([r.subject_id, r.channel, r.account_id]);
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return r.status === "active";
+      });
+  }
+  history(subject, limit = 30) {
+    return this.db
+      .prepare(
+        "SELECT * FROM mind_relationships WHERE subject_id=? ORDER BY created DESC,rowid DESC LIMIT ?",
+      )
+      .all(String(subject), limit);
+  }
+  save(input, now = Date.now()) {
+    const subject = text(input?.subjectId, 128),
+      channel = String(input?.channel || "onebot"),
+      account = text(input?.accountId || "_", 128);
+    if (
+      String(input?.subjectId || "").length > 128 ||
+      String(input?.accountId || "").length > 128 ||
+      !/^[\w.-]{1,128}$/.test(subject) ||
+      ["bot", "self", "_"].includes(subject) ||
+      !["onebot", "qqbot"].includes(channel) ||
+      !/^[\w.-]{1,128}$/.test(account) ||
+      (channel === "onebot" && !/^\d+$/.test(subject))
+    )
+      throw Error("关系对象账号无效");
+    if (channel === "qqbot" && account === "_")
+      throw Error("官方机器人关系需要指定应用账号");
+    if (
+      this.db
+        .prepare("SELECT 1 FROM core_events WHERE account_id=? LIMIT 1")
+        .get(subject)
+    )
+      throw Error("不能把当前实例绑定为自己的关系对象");
+    const kind = String(input.kind || "human"),
+      role = text(input.peerRole, 24),
+      name = text(input.name, 40),
+      note = text(input.note, 300),
+      discretion = input.discretion || "open";
+    if (
+      !["human", "bot"].includes(kind) ||
+      !role ||
+      String(input.peerRole).length > 24 ||
+      String(input.name || "").length > 40 ||
+      String(input.note || "").length > 300 ||
+      !["open", "private", "secret"].includes(discretion)
+    )
+      throw Error("关系设置无效");
+    const gender = this.mind.nature.current(now).gender;
+    const older =
+      gender === "female" ? "姐姐" : gender === "male" ? "哥哥" : "年长手足";
+    const younger =
+      gender === "female" ? "妹妹" : gender === "male" ? "弟弟" : "年幼手足";
+    const opposite = {
+      妹妹: older,
+      弟弟: older,
+      姐姐: younger,
+      哥哥: younger,
+      朋友: "朋友",
+      伙伴: "伙伴",
+    };
+    const selfRole = text(input.selfRole || opposite[role] || "", 24);
+    if (
+      !selfRole ||
+      String(input.selfRole || "").length > 24 ||
+      hasCredential([role, selfRole, name, note].join(" "))
+    )
+      throw Error("关系称呼或备注无效");
+    const room = `${channel}:${account}:private:${subject}`,
+      previous = this.current(subject, { now, room });
+    if (
+      input.expectedId !== undefined &&
+      input.expectedId !== (previous?.id || null)
+    )
+      throw Error("关系已经变化，请刷新后再修改");
+    if (
+      previous &&
+      previous.kind === kind &&
+      previous.peer_role === role &&
+      previous.self_role === selfRole &&
+      previous.name === name &&
+      previous.note === note &&
+      previous.discretion === discretion
+    )
+      return this.view(previous);
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      this.db
+        .prepare(
+          "INSERT INTO mind_relationships(id,created,subject_id,channel,account_id,kind,name,peer_role,self_role,discretion,note,status) VALUES (?,?,?,?,?,?,?,?,?,?,?,'active')",
+        )
+        .run(
+          randomUUID(),
+          now,
+          subject,
+          channel,
+          account,
+          kind,
+          name,
+          role,
+          selfRole,
+          discretion,
+          note,
+        );
+      this.db
+        .prepare(
+          "INSERT INTO mind_people(user_id,name,first_seen,last_seen,sessions) VALUES (?,NULL,NULL,NULL,'[]') ON CONFLICT(user_id) DO NOTHING",
+        )
+        .run(subject);
+      this.db.exec("COMMIT");
+      this.mind.repo.store.revision++;
+      return this.view(this.current(subject, { now, room }));
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  end(subject, input = {}, now = Date.now()) {
+    if (
+      String(input.note || "").length > 300 ||
+      hasCredential(String(input.note || ""))
+    )
+      throw Error("关系称呼或备注无效");
+    const room = `${input.channel || "onebot"}:${input.accountId || "_"}:private:${subject}`,
+      row = this.current(subject, { now, room });
+    if (!row) throw Error("关系不存在或已解除");
+    if (input.expectedId !== undefined && input.expectedId !== row.id)
+      throw Error("关系已经变化，请刷新后再修改");
+    this.db
+      .prepare(
+        "INSERT INTO mind_relationships(id,created,subject_id,channel,account_id,kind,name,peer_role,self_role,discretion,note,status) VALUES (?,?,?,?,?,?,?,?,?,?,?,'ended')",
+      )
+      .run(
+        randomUUID(),
+        now,
+        row.subject_id,
+        row.channel,
+        row.account_id,
+        row.kind,
+        row.name,
+        row.peer_role,
+        row.self_role,
+        row.discretion,
+        text(input.note || "在管理台解除关系", 300),
+      );
+    this.mind.repo.store.revision++;
+    return { ended: true };
+  }
+}

package/server/mind/schema.js

@@ -26,6 +26,8 @@ export function migrateMind(db, store) {
     CREATE INDEX IF NOT EXISTS mind_self_thread ON mind_self(thread,created);
     CREATE TABLE IF NOT EXISTS mind_faces (id TEXT PRIMARY KEY, session_id TEXT NOT NULL, created INTEGER NOT NULL, role TEXT NOT NULL DEFAULT '', tone TEXT NOT NULL DEFAULT '', aspiration TEXT NOT NULL DEFAULT '', content TEXT NOT NULL DEFAULT '', sources TEXT NOT NULL DEFAULT '[]', origin TEXT NOT NULL);
     CREATE INDEX IF NOT EXISTS mind_faces_session ON mind_faces(session_id,created);
+    CREATE TABLE IF NOT EXISTS mind_relationships(id TEXT PRIMARY KEY,created INTEGER NOT NULL,subject_id TEXT NOT NULL,channel TEXT NOT NULL,account_id TEXT NOT NULL,kind TEXT NOT NULL,name TEXT NOT NULL DEFAULT '',peer_role TEXT NOT NULL,self_role TEXT NOT NULL,discretion TEXT NOT NULL DEFAULT 'open',note TEXT NOT NULL DEFAULT '',status TEXT NOT NULL);
+    CREATE INDEX IF NOT EXISTS mind_relationships_subject ON mind_relationships(subject_id,channel,account_id,created);
     CREATE TABLE IF NOT EXISTS mind_thoughts (id TEXT PRIMARY KEY, created INTEGER NOT NULL, kind TEXT NOT NULL, content TEXT NOT NULL, sessions TEXT NOT NULL DEFAULT '[]', sources TEXT NOT NULL DEFAULT '[]', parent_id TEXT, importance REAL NOT NULL DEFAULT 0.5, revisit_at INTEGER, status TEXT NOT NULL DEFAULT 'open', hidden INTEGER NOT NULL DEFAULT 0, outreach TEXT NOT NULL DEFAULT '', outreach_session TEXT, outreach_status TEXT NOT NULL DEFAULT 'none', run_id TEXT);
     CREATE INDEX IF NOT EXISTS mind_thoughts_time ON mind_thoughts(created);
     CREATE TABLE IF NOT EXISTS mind_diary (id TEXT PRIMARY KEY, day TEXT NOT NULL, created INTEGER NOT NULL, content TEXT NOT NULL, mood TEXT, compare TEXT, sources TEXT NOT NULL DEFAULT '[]', run_id TEXT);
@@ -65,6 +67,9 @@ export function migrateMind(db, store) {
       db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
   };
   addColumn("core_memories", "discretion", "TEXT NOT NULL DEFAULT 'open'");
+  // NULL distinguishes legacy faces from a deliberately emptied note set.
+  addColumn("mind_faces", "notes", "TEXT");
+  addColumn("mind_faces", "changes", "TEXT NOT NULL DEFAULT '[]'");
   addColumn("core_memories", "superseded_by", "TEXT");
   addColumn("mind_attention", "deferred", "INTEGER NOT NULL DEFAULT 0");
   addColumn("mind_thoughts", "resolved_at", "INTEGER");

package/server/mind/time/tasks.js

@@ -367,7 +367,8 @@ export class Tasks {
         ? 2
         : task.priority) *
         100 +
-      Math.min(8, Number(person?.closeness || 0) * 8)
+      Math.min(8, Number(person?.closeness || 0) * 8) +
+      Math.min(2, Number(person?.relationalWeight || 0) * 8)
     );
   }
   arrange(

package/server/mind/view.js

@@ -136,6 +136,9 @@ export function innerView(
       ? {
           here: describeFace({
             ...face,
+            notes: face.notes.filter((note) =>
+              spoken(`${note.content} ${note.why}`),
+            ),
             role: spoken(face.role),
             tone: spoken(face.tone),
             aspiration: spoken(face.aspiration),
@@ -176,6 +179,7 @@ export function innerView(
       (!bond.interactions &&
         !bond.impression &&
         !bond.lastChange &&
+        !bond.relationship &&
         bond.tension < 0.15)
     )
       continue;
@@ -183,6 +187,7 @@ export function innerView(
       id,
       name: bond.name,
       feel: bond.feel,
+      ...(bond.relationship ? { relationship: bond.relationship } : {}),
       ...(bond.impression && mind.meetings.sayable(bond.impression, session)
         ? { impression: bond.impression }
         : {}),

package/server/runtime/installation.js

@@ -0,0 +1,116 @@
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  readdirSync,
+  renameSync,
+  rmdirSync,
+  writeFileSync,
+  unlinkSync,
+} from "node:fs";
+import { join, relative, isAbsolute } from "node:path";
+import { randomUUID } from "node:crypto";
+import { compareVersions } from "../studio/updates.js";
+export const UPDATE_ID =
+  /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+export const updateRoot = (home) => join(home, "runtime");
+export function updatePath(home, id) {
+  if (!UPDATE_ID.test(String(id))) throw Error("更新任务无效");
+  const root = updateRoot(home),
+    path = join(root, "releases", id);
+  // Managed paths cannot be symlinked into an unrelated installation.
+  for (const p of [root, join(root, "releases"), path])
+    if (existsSync(p) && lstatSync(p).isSymbolicLink())
+      throw Error("更新目录无效");
+  return path;
+}
+export function readActive(home) {
+  try {
+    return JSON.parse(
+      readFileSync(join(updateRoot(home), "active.json"), "utf8"),
+    );
+  } catch {
+    return null;
+  }
+}
+export function atomicJson(file, value) {
+  const tmp = `${file}.${randomUUID()}.partial`;
+  try {
+    writeFileSync(tmp, JSON.stringify(value), {
+      mode: 0o600,
+      flag: "wx",
+      flush: true,
+    });
+    renameSync(tmp, file);
+  } finally {
+    if (existsSync(tmp)) unlinkSync(tmp);
+  }
+}
+export function writeActive(home, value) {
+  const root = updateRoot(home);
+  if (value) updatePath(home, value.id);
+  mkdirSync(root, { recursive: true, mode: 0o700 });
+  if (value) atomicJson(join(root, "active.json"), value);
+  else if (existsSync(join(root, "active.json")))
+    unlinkSync(join(root, "active.json"));
+}
+export function installedRelease(home, id, version) {
+  const slot = updatePath(home, id),
+    root = join(slot, "node_modules", "luckytri");
+  const part = relative(realpathSync(slot), realpathSync(root));
+  if (part.startsWith("..") || isAbsolute(part)) throw Error("更新目录无效");
+  const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+  if (
+    pkg.name !== "luckytri" ||
+    pkg.version !== version ||
+    !existsSync(join(root, "server", "index.js")) ||
+    !existsSync(join(root, "public", "app", "index.html"))
+  )
+    throw Error("更新程序校验失败");
+  return root;
+}
+export function resolveInstallation(home, basePackage, baseVersion) {
+  const active = readActive(home);
+  if (active) {
+    try {
+      // An explicit newer/equal global npm or source install takes precedence.
+      if (compareVersions(active.version, baseVersion) > 0)
+        return {
+          package: installedRelease(home, active.id, active.version),
+          version: active.version,
+        };
+    } catch {
+      /* Invalid receipts never route the launcher to arbitrary code. */
+    }
+  }
+  return { package: basePackage, version: baseVersion };
+}
+export function pruneInstallations(home, keep) {
+  const root = join(updateRoot(home), "releases");
+  if (!existsSync(root)) return;
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    if (
+      !entry.isDirectory() ||
+      !UPDATE_ID.test(entry.name) ||
+      keep.includes(entry.name)
+    )
+      continue;
+    const path = updatePath(home, entry.name),
+      part = relative(realpathSync(root), realpathSync(path));
+    if (!part || part.startsWith("..") || isAbsolute(part))
+      throw Error("更新目录无效");
+    // File removal uses unlink, including Unicode/short Windows paths where
+    // recursive rm can return without actually removing a lock or directory.
+    const remove = (directory) => {
+      for (const child of readdirSync(directory, { withFileTypes: true })) {
+        const target = join(directory, child.name);
+        if (child.isDirectory() && !child.isSymbolicLink()) remove(target);
+        else unlinkSync(target);
+      }
+      rmdirSync(directory);
+    };
+    remove(path);
+  }
+}

package/server/runtime/update-execution.js

@@ -0,0 +1,127 @@
+import { copyFileSync, existsSync, mkdirSync, renameSync } from "node:fs";
+import {
+  readActive,
+  writeActive,
+  installedRelease,
+  updatePath,
+  pruneInstallations,
+} from "./installation.js";
+import {
+  readUpdateJob,
+  writeUpdateJob,
+  UPDATE_FAILED,
+  UPDATE_RECOVERY_FAILED,
+} from "./update-manager.js";
+import { backupDatabase } from "../../scripts/backup.js";
+import { verifyArchive } from "../storage/archive.js";
+
+// Executed outside the server so a large verified snapshot does not stall the
+// WebUI. Dependencies are explicit for failure, restart and rollback tests.
+export async function performUpdate(
+  paths,
+  id,
+  {
+    install,
+    check,
+    stop,
+    claim,
+    start,
+    health,
+    release,
+    snapshot = backupDatabase,
+  } = {},
+) {
+  let job = readUpdateJob(paths.home, id),
+    stopped = false,
+    changed = false,
+    child = null,
+    claimed = false,
+    backup = null;
+  const previous = readActive(paths.home);
+  const save = (status, fields = {}) => {
+    job = writeUpdateJob(paths.home, { ...job, ...fields, status });
+  };
+  try {
+    if (job.status !== "queued") throw Error("更新任务已经处理");
+    save("downloading");
+    const slot = updatePath(paths.home, id);
+    mkdirSync(slot, { recursive: true, mode: 0o700 });
+    await install(slot, job.version);
+    const candidate = installedRelease(paths.home, id, job.version);
+    save("checking");
+    await check(candidate, job.version);
+    save("stopping");
+    await stop(job.parent);
+    stopped = true;
+    claimed = !!claim();
+    if (!claimed) throw Error("另一次启动正在进行");
+    save("backup");
+    backup = snapshot(paths.database, paths.backups);
+    verifyArchive(backup);
+    save("restarting");
+    writeActive(paths.home, { id, version: job.version });
+    changed = true;
+    child = await start(candidate);
+    save("verifying");
+    await health(child, job.version);
+    save("done", { finished: Date.now() });
+    try {
+      pruneInstallations(paths.home, [id, previous?.id]);
+    } catch {
+      /* A locked obsolete program can be removed after the next update. */
+    }
+    return job;
+  } catch (error) {
+    const failedStage = job.status;
+    job = { ...job, failedStage };
+    console.error(
+      "更新步骤未完成：",
+      failedStage,
+      error.code || error.cause?.code || "STEP_FAILED",
+    );
+    if (!stopped) {
+      save("error", { error: UPDATE_FAILED, finished: Date.now() });
+      return job;
+    }
+    if (!claimed) {
+      save("error", { error: UPDATE_RECOVERY_FAILED, finished: Date.now() });
+      return job;
+    }
+    try {
+      save("restoring");
+      if (child) await stop(child);
+      // The child may have claimed startup.json. Reacquire only after its exit.
+      if (child) {
+        release();
+        if (!claim()) throw Error("启动锁尚未释放");
+      }
+      if (changed) {
+        verifyArchive(backup);
+        const temporary = `${paths.database}.${id}.restore`;
+        copyFileSync(backup, temporary);
+        verifyArchive(temporary);
+        // Retain the attempted database and every sidecar; no life is erased.
+        for (const suffix of ["", "-wal", "-shm"])
+          if (existsSync(paths.database + suffix))
+            renameSync(
+              paths.database + suffix,
+              `${paths.database}.update-failed-${id}${suffix}`,
+            );
+        renameSync(temporary, paths.database);
+        writeActive(paths.home, previous);
+      }
+      const restored = await start(paths.package);
+      await health(restored, job.previous);
+      save("error", {
+        error: UPDATE_FAILED,
+        restored: true,
+        finished: Date.now(),
+      });
+    } catch {
+      save("error", { error: UPDATE_RECOVERY_FAILED, finished: Date.now() });
+    }
+    return job;
+  } finally {
+    if (claimed) release();
+  }
+}