luckytri 1.3.0 → 1.3.3

package/server/mind/time/works.js

@@ -406,57 +406,60 @@ export class Works {
     const terms = interestTerms([words]);
     // Search the work catalogue, not just the two newest activities. Select
     // the version that existed at the requested time, including in replays.
-    return this.db
-      .prepare(
-        `SELECT w.*,COALESCE(p.kind,(SELECT kind FROM mind_creations WHERE id=w.legacy_creation)) kind,p.title project_title,p.bible,v.version,v.title,v.created version_created,v.summary,v.sources,v.provenance,length(v.content) characters
+    return (
+      this.db
+        .prepare(
+          `SELECT w.*,COALESCE(p.kind,(SELECT kind FROM mind_creations WHERE id=w.legacy_creation)) kind,p.title project_title,p.bible,v.version,v.title,v.created version_created,v.summary,v.sources,v.provenance,length(v.content) characters
       FROM mind_time_works w LEFT JOIN mind_time_projects p ON p.id=w.project_id
       JOIN mind_time_versions v ON v.work_id=w.id AND v.version=(SELECT max(h.version) FROM mind_time_versions h WHERE h.work_id=w.id AND h.created<=?)
       WHERE w.created<=? ORDER BY v.created DESC`,
-      )
-      .all(now, now)
-      .filter(
-        (w) =>
-          w.created <= now &&
-          this.time.visible(
-            { ...w, sources: parse(w.sources, []) },
-            session,
-            now,
-          ),
-      )
-      .map((w) => ({
-        ...w,
-        score: [...interestTerms([w.title, w.project_title, w.summary])]
-          .filter((term) => terms.has(term))
-          .reduce(
-            (total, term) => total + (/^[a-z][a-z0-9]{2,}$/.test(term) ? 8 : 1),
-            0,
-          ),
-      }))
-      .sort(
-        (a, b) => b.score - a.score || b.version_created - a.version_created,
-      )
-      .filter((w, index, rows) =>
-        rows[0]?.score >= 2 ? w.score >= 2 : index < 2,
-      )
-      .filter((w) => this.materialSupported(w))
-      .slice(0, 3)
-      .map((w) => ({
-        id: w.id,
-        title: w.title,
-        state: this.get(w.id, w.version, { before: now }).state,
-        kind: w.kind,
-        version: w.version,
-        ordinal: w.ordinal,
-        summary: text(w.summary, 180),
-        fragment: text(this.get(w.id, w.version).content, 300),
-        ...(w.kind === "game"
-          ? {
-              experienceMode: "reference",
-              provenance: this.get(w.id, w.version).provenance,
-            }
-          : {}),
-        characters: w.characters,
-      }));
+        )
+        .all(now, now)
+        .filter(
+          (w) =>
+            w.created <= now &&
+            this.time.visible(
+              { ...w, sources: parse(w.sources, []) },
+              session,
+              now,
+            ),
+        )
+        .map((w) => ({
+          ...w,
+          score: [...interestTerms([w.title, w.project_title, w.summary])]
+            .filter((term) => terms.has(term))
+            .reduce(
+              (total, term) =>
+                total + (/^[a-z][a-z0-9]{2,}$/.test(term) ? 8 : 1),
+              0,
+            ),
+        }))
+        .sort(
+          (a, b) => b.score - a.score || b.version_created - a.version_created,
+        )
+        // No topic hit → empty. Do not fall back to "latest two" and pollute
+        // ordinary chatter with manuscript fragments.
+        .filter((w) => w.score >= 2)
+        .filter((w) => this.materialSupported(w))
+        .slice(0, 3)
+        .map((w) => ({
+          id: w.id,
+          title: w.title,
+          state: this.get(w.id, w.version, { before: now }).state,
+          kind: w.kind,
+          version: w.version,
+          ordinal: w.ordinal,
+          summary: text(w.summary, 180),
+          fragment: text(this.get(w.id, w.version).content, 300),
+          ...(w.kind === "game"
+            ? {
+                experienceMode: "reference",
+                provenance: this.get(w.id, w.version).provenance,
+              }
+            : {}),
+          characters: w.characters,
+        }))
+    );
   }
 
   activityEvidence({ session, now = this.time.now(), cue = [] } = {}) {

package/server/runtime/update-manager.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { execFileSync } from "node:child_process";
 import { mkdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import {
@@ -33,14 +34,45 @@ export const isUpdateFinished = (stage) =>
   stage === "done" || stage === "error";
 const beforeStop = (stage) =>
   ["queued", "downloading", "checking"].includes(stage);
+function isZombieProcess(pid) {
+  if (process.platform === "linux") {
+    try {
+      const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+      const commandEnd = stat.lastIndexOf(")");
+      return commandEnd >= 0 && stat[commandEnd + 2] === "Z";
+    } catch (error) {
+      // A process can disappear after kill(pid, 0) succeeds but before its
+      // proc entry is read. Treat that race as an exited process.
+      return error.code === "ENOENT";
+    }
+  }
+  if (process.platform === "darwin") {
+    try {
+      const state = execFileSync("ps", ["-o", "stat=", "-p", String(pid)], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 1000,
+        windowsHide: true,
+      }).trimStart();
+      return !state || state.startsWith("Z");
+    } catch (error) {
+      // `ps` reports no rows with status 1 when the process exited in the gap
+      // after kill(pid, 0). Keep other inspection failures conservative.
+      return error.status === 1 || error.code === "ENOENT" ? false : true;
+    }
+  }
+  return false;
+}
 export const processAlive = (pid) => {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try {
     process.kill(pid, 0);
-    return true;
   } catch (e) {
-    return e.code !== "ESRCH";
+    if (e.code === "ESRCH") return false;
   }
+  // On POSIX, kill(pid, 0) also succeeds for a zombie. A zombie cannot run or
+  // answer requests, so keep the foreground supervisor from waiting forever.
+  return !isZombieProcess(pid);
 };
 export function readUpdateJob(home, id) {
   updatePath(home, id);

package/server/stickers/offer.js

@@ -103,24 +103,53 @@ export function expressionInput(snapshot) {
 }
 
 // "@小红" typed as text is not an @ on QQ. A name she wrote that way for
-// someone offered becomes a real @, and the typed copy is removed so the
-// message does not show the name twice.
+// someone offered becomes a real @ on THAT bubble only, and the typed copy
+// is removed so the message does not show the name twice. Two bubbles for
+// two people must not dump both @s onto the first bubble.
 export function typedAt(bubbles, at, snapshot) {
   const offered = snapshot.canAt || [];
-  const chosen = new Map(at.map((p) => [p.userId, p]));
-  const out = bubbles.map((line, i) => {
-    let text = line;
+  const fromTurn = new Map((at || []).map((p) => [String(p.userId), p]));
+  const out = [];
+  const atByBubble = [];
+  const typedIds = new Set();
+  for (const line of bubbles || []) {
+    let text = String(line || "");
+    const onThis = new Map();
     for (const p of offered) {
+      if (!p.name) continue;
       const mark = `@${p.name}`;
-      if (!p.name || !text.includes(mark)) continue;
-      if (i === 0 && chosen.size < 2) chosen.set(p.userId, p);
-      if (chosen.has(p.userId))
-        text = text
-          .split(mark)
-          .join("")
-          .replace(/^[\s，,]+/, "");
+      if (!text.includes(mark)) continue;
+      const id = String(p.userId);
+      typedIds.add(id);
+      onThis.set(id, fromTurn.get(id) || p);
+      text = text
+        .split(mark)
+        .join("")
+        .replace(/^[\s，,]+/, "");
     }
-    return text.trim();
-  });
-  return { bubbles: out.filter(Boolean), at: [...chosen.values()] };
+    text = text.trim();
+    if (!text) continue;
+    out.push(text);
+    atByBubble.push([...onThis.values()].slice(0, 2));
+  }
+  const placed = new Set(atByBubble.flat().map((p) => String(p.userId)));
+  const unplaced = [...fromTurn.values()].filter(
+    (p) => !placed.has(String(p.userId)) && !typedIds.has(String(p.userId)),
+  );
+  if (unplaced.length) {
+    if (out.length === 1) {
+      atByBubble[0] = [...(atByBubble[0] || []), ...unplaced].slice(0, 2);
+    } else if (out.length > 1 && atByBubble.every((list) => !list.length)) {
+      // turn.at with no typed @ marks: pair person i with bubble i
+      unplaced.forEach((p, i) => {
+        if (i < atByBubble.length) atByBubble[i] = [p];
+      });
+    }
+  }
+  return {
+    bubbles: out,
+    atByBubble,
+    // First bubble only — never the union of every addressee.
+    at: atByBubble[0] || [],
+  };
 }