luckytri 1.2.4 → 1.3.2

package/server/mind/guard.js

@@ -1,68 +1,88 @@
-import { hasCredential, normalized } from "./util.js";
-
-export { hasCredential };
-
-const SECRET_REQUEST =
-  /(?:帮我|替我|给我|你要|记得)?保密|别(?:告诉|跟|和|对)(?:别人|其他人|任何人|他们|大家)|不要(?:告诉|跟|和|说给)(?:别人|其他人|任何人|大家)|(?:只|就)(?:告诉|跟|和)你(?:一个人)?说|(?:不要|别)(?:说|传)出去|别外传|别声张/;
-
-export function secretRequest(text) {
-  return SECRET_REQUEST.test(String(text || ""));
-}
-
-const CRISIS =
-  /自杀|不想活|活不下去|活着没意思|结束(?:自己的)?生命|伤害自己|割腕|跳楼|轻生|想死(?!你)|撑不下去了/;
-const CASUAL_DEATH = /(?:笑|社|饿|累|困|热|冷|烦|气|丑|尬|馋)死|想死你/;
-const EXPLICIT =
-  /自杀|不想活|活不下去|结束(?:自己的)?生命|伤害自己|割腕|跳楼|轻生/;
-
-// A cheap signal that makes sure she actually reads the message. Whether it
-// is a real crisis is still her understanding of the whole conversation.
-export function crisisSignal(text) {
-  const value = String(text || "");
-  if (!CRISIS.test(value)) return false;
-  return EXPLICIT.test(value) || !CASUAL_DEATH.test(value);
-}
-
-// "某作玩过""都玩过一些""通关了""玩得比较杂": a claim to have played
-// something. She has no record of playing anything, so it is not a fact she
-// can give. Wishes ("想通关"), questions ("玩过吗"), other people ("他玩过")
-// and "没玩过" are not claims.
-const NOT_A_CLAIM = "没未不还想要会能可等算你他她谁人";
-const CLAIMED_PLAY = new RegExp(
-  `(?<![${NOT_A_CLAIM}][^，。！？,.!?\\s]{0,4})(?:也|都|早就|之前|以前|已经|全)?(?:玩过|通关|二周目|全结局|全成就)(?![吗么没？?]|不(?![少多])|的?吧)|(?<![你他她谁人][^，。！？,.!?\\s]{0,6})玩得(?:比较|挺|还)?(?:杂|多)(?![吗么？?]|的?吧)`,
-);
-
-export function claimedPlay(text) {
-  return CLAIMED_PLAY.test(String(text || ""));
-}
-
-// Secrets never enter another conversation's context, but a reply is still
-// checked against them before it leaves.
-export function leaks(bubbles, secrets, alreadySaid = []) {
-  const said = normalized((bubbles || []).join(""));
-  if (said.length < 4) return [];
-  const pairs = (s) =>
-    new Set(Array.from({ length: s.length - 1 }, (_, i) => s.slice(i, i + 2)));
-  const spoken = pairs(said);
-  const known = alreadySaid.map(normalized);
-  const alreadyKnown = (phrase) => known.some((line) => line.includes(phrase));
-  const found = [];
-  for (const secret of secrets || []) {
-    const key = normalized(secret.content);
-    if (key.length < 4) continue;
-    const grams = pairs(key);
-    let hit =
-      (said.includes(key) && !alreadyKnown(key)) ||
-      [...grams].filter((g) => spoken.has(g) && !alreadyKnown(g)).length /
-        grams.size >=
-        0.6;
-    for (let i = 0; !hit && i + 6 <= key.length; i += 2)
-      if (
-        said.includes(key.slice(i, i + 6)) &&
-        !alreadyKnown(key.slice(i, i + 6))
-      )
-        hit = true;
-    if (hit) found.push(secret);
-  }
-  return found;
-}
+import { hasCredential, normalized } from "./util.js";
+
+export { hasCredential };
+
+const SECRET_REQUEST =
+  /(?:帮我|替我|给我|你要|记得)?保密|别(?:告诉|跟|和|对)(?:别人|其他人|任何人|他们|大家)|不要(?:告诉|跟|和|说给)(?:别人|其他人|任何人|大家)|(?:只|就)(?:告诉|跟|和)你(?:一个人)?说|(?:不要|别)(?:说|传)出去|别外传|别声张/;
+
+export function secretRequest(text) {
+  return SECRET_REQUEST.test(String(text || ""));
+}
+
+const CRISIS =
+  /自杀|不想活|活不下去|活着没意思|结束(?:自己的)?生命|伤害自己|割腕|跳楼|轻生|想死(?!你)|撑不下去了/;
+const CASUAL_DEATH = /(?:笑|社|饿|累|困|热|冷|烦|气|丑|尬|馋)死|想死你/;
+const EXPLICIT =
+  /自杀|不想活|活不下去|结束(?:自己的)?生命|伤害自己|割腕|跳楼|轻生/;
+
+// A cheap signal that makes sure she actually reads the message. Whether it
+// is a real crisis is still her understanding of the whole conversation.
+export function crisisSignal(text) {
+  const value = String(text || "");
+  if (!CRISIS.test(value)) return false;
+  return EXPLICIT.test(value) || !CASUAL_DEATH.test(value);
+}
+
+// "某作玩过""都玩过一些""通关了""玩得比较杂": a claim to have played
+// something. She has no record of playing anything, so it is not a fact she
+// can give. Wishes ("想通关"), questions ("玩过吗"), other people ("他玩过")
+// and "没玩过" are not claims.
+const NOT_A_CLAIM = "没未不还想要会能可等算你他她谁人";
+const CLAIMED_PLAY = new RegExp(
+  `(?<![${NOT_A_CLAIM}][^，。！？,.!?\\s]{0,4})(?:也|都|早就|之前|以前|已经|全)?(?:玩过|通关|二周目|全结局|全成就)(?![吗么没？?]|不(?![少多])|的?吧)|(?<![你他她谁人][^，。！？,.!?\\s]{0,6})玩得(?:比较|挺|还)?(?:杂|多)(?![吗么？?]|的?吧)`,
+);
+
+export function claimedPlay(text) {
+  return CLAIMED_PLAY.test(String(text || ""));
+}
+
+// Phrases that are already public identity (her name, being code/model/AI)
+// must not make a privateSaying look "leaked" when she answers "who are you".
+export function publicIdentityPhrases(nature = {}) {
+  const name = String(nature.name || "").trim();
+  return [
+    name,
+    name && `我叫${name}`,
+    name && `我是${name}`,
+    "代码和模型",
+    "由代码和模型",
+    "代码和模型搭",
+    "代码和模型构成",
+    "机器人",
+    "AI",
+    "人工智能",
+  ].filter(Boolean);
+}
+
+// Secrets never enter another conversation's context, but a reply is still
+// checked against them before it leaves. alreadySaid (and public identity
+// phrases passed through it) cancel n-gram hits so saying who she is aloud
+// is not mistaken for repeating someone else's private words.
+export function leaks(bubbles, secrets, alreadySaid = []) {
+  const said = normalized((bubbles || []).join(""));
+  if (said.length < 4) return [];
+  const pairs = (s) =>
+    new Set(Array.from({ length: s.length - 1 }, (_, i) => s.slice(i, i + 2)));
+  const spoken = pairs(said);
+  const known = alreadySaid.map(normalized).filter(Boolean);
+  const alreadyKnown = (phrase) => known.some((line) => line.includes(phrase));
+  const found = [];
+  for (const secret of secrets || []) {
+    const key = normalized(secret.content);
+    if (key.length < 4) continue;
+    const grams = pairs(key);
+    let hit =
+      (said.includes(key) && !alreadyKnown(key)) ||
+      [...grams].filter((g) => spoken.has(g) && !alreadyKnown(g)).length /
+        grams.size >=
+        0.6;
+    for (let i = 0; !hit && i + 6 <= key.length; i += 2)
+      if (
+        said.includes(key.slice(i, i + 6)) &&
+        !alreadyKnown(key.slice(i, i + 6))
+      )
+        hit = true;
+    if (hit) found.push(secret);
+  }
+  return found;
+}

package/server/mind/memory.js

@@ -255,7 +255,12 @@ export class MemoryManager {
       for (const { m, strong } of selected)
         if (strong) access.run(cutoff, m.id);
     }
-    return selected.map(({ m, local, why }) => {
+    // In speech, what she may not disclose here does not surface at all:
+    // no placeholder, so there is nothing to announce.
+    const shown = forSpeech
+      ? selected.filter(({ m }) => this.permission(m, session, cutoff).disclose)
+      : selected;
+    return shown.map(({ m, local, why }) => {
       const age = cutoff - Number(m.created || cutoff);
       return {
         id: m.id,
@@ -302,7 +307,7 @@ export class MemoryManager {
     const allowed = this.permission(other, session, now);
     if (!allowed.recall) return {};
     if (forSpeech && !allowed.disclose)
-      return { conflictsWith: "另有一条对不上的说法（受限，不在这里复述）" };
+      return { conflictsWith: "另有一条对不上的说法（私下知道，开口时不提）" };
     const age = now - Number(other.created || now);
     const where =
       this.scopes(session).includes(other.session_id) ||

package/server/mind/recall/index.js

@@ -629,6 +629,8 @@ export class Recall {
       if (!m) continue;
       const permission = memory.permission(m, session, now);
       if (!permission.recall) continue;
+      // Not disclosable here: in speech it does not surface at all.
+      if (forSpeech && !permission.disclose) continue;
       const local = scopes.has(m.session_id) || m.session_id === "__shared__";
       if (touch && (item.meant || item.worded || item.pinned))
         access.run(now, m.id);

package/server/mind/relationship-context.js

@@ -1,71 +1,110 @@
-// Current relationship facts and the words she once used about them have
-// different jobs. Keep history intact, and make that distinction at recall.
-export const RELATIONSHIP_KNOWLEDGE_RULE =
-  "relationships.known 是当前已知的人际关系，属于同一个自己的生活。旧经历、自我线索中的否认或玩笑保留为当时的看法，不据此否定新关系记录。知道对方是谁与对方是什么关系，和自己的感受、信任、称呼选择分开；不机械扮演，不编造共同过去或对方的同意。";
-
-export function mentionsRelationship(content, relation) {
-  const words = String(content || "").toLocaleLowerCase();
-  return [
-    relation.name,
-    ...(relation.knownAs || []),
-    relation.peerRole,
-    relation.selfRole,
-  ]
-    .filter(Boolean)
-    .some((word) => {
-      const escaped = String(word).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      const boundary = /^[\w .-]+$/.test(word);
-      return new RegExp(
-        boundary ? `(?<![\\w])${escaped}(?![\\w])` : escaped,
-        "i",
-      ).test(words);
-    });
-}
-
-export function relationshipHistory(content, created, knowledge) {
-  return (knowledge?.known || []).some(
-    (r) =>
-      Number.isFinite(created) &&
-      created < r.created &&
-      mentionsRelationship(content, r),
-  )
-    ? `${content}（关系记录更新前的看法；保留当时的感受，不据此否定当前关系事实）`
-    : content;
-}
-
-// Narrow, literal factual denials only. Disagreement with a label, old words,
-// fictional dialogue and feelings are left to the contextual reviewer.
-export function relationshipClaimIssues(bubbles, knowledge) {
-  const issues = [];
-  for (const r of knowledge?.known || []) {
-    const role = String(r.peerRole).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const names = [r.name, ...(r.knownAs || [])].filter(Boolean);
-    for (const line of bubbles || []) {
-      for (const clause of String(line).split(/[，,。！？!?；;\n]/)) {
-        if (
-          /以前|之前|当时|过去|曾经|从前|一开始|原来|小说|台词|[“「"『]/.test(
-            clause,
-          )
-        )
-          continue;
-        const namedDenial = names.some((name) => {
-          const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-          return new RegExp(
-            `(?:^|[\\s：:])${escaped}(?:也|本来|根本)?(?:不是|并非)我(?:的)?${role}(?:$|[\\s，。])|我(?:并)?不认识\\s*${escaped}(?:$|[\\s，。])`,
-            "i",
-          ).test(clause);
-        });
-        const absentRole = new RegExp(
-          `我(?:本来|本来也|现在|根本|一直|从来)?(?:就|也)?(?:没有|没)${role}(?:$|[\\s，。])`,
-        ).test(clause);
-        if (namedDenial || absentRole) {
-          issues.push(
-            `当前已知 ${r.name || r.subjectId} 与自己的关系是 ${r.peerRole}，不能把旧印象当成关系不存在；可保留自己的感受和称呼选择，按当前记录核对再说`,
-          );
-          break;
-        }
-      }
-    }
-  }
-  return [...new Set(issues)];
-}
+// Current relationship facts and the words she once used about them have
+// different jobs. Keep history intact, and make that distinction at recall.
+export const RELATIONSHIP_KNOWLEDGE_RULE =
+  "relationships.known 是当前已知的人际关系，属于同一个自己的生活。旧经历、自我线索中的否认或玩笑保留为当时的看法，不据此否定新关系记录。知道对方是谁与对方是什么关系，和自己的感受、信任、称呼选择分开；不机械扮演，不编造共同过去或对方的同意。";
+
+export function mentionsRelationship(content, relation) {
+  const words = String(content || "").toLocaleLowerCase();
+  return [
+    relation.name,
+    ...(relation.knownAs || []),
+    relation.peerRole,
+    relation.selfRole,
+  ]
+    .filter(Boolean)
+    .some((word) => {
+      const escaped = String(word).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const boundary = /^[\w .-]+$/.test(word);
+      return new RegExp(
+        boundary ? `(?<![\\w])${escaped}(?![\\w])` : escaped,
+        "i",
+      ).test(words);
+    });
+}
+
+export function relationshipHistory(content, created, knowledge) {
+  return (knowledge?.known || []).some(
+    (r) =>
+      Number.isFinite(created) &&
+      created < r.created &&
+      mentionsRelationship(content, r),
+  )
+    ? `${content}（关系记录更新前的看法；保留当时的感受，不据此否定当前关系事实）`
+    : content;
+}
+
+const KINSHIP =
+  /姐|妹|哥|弟|父|母|女儿|爸|妈|亲戚|Maker|女儿/;
+
+// Banter that treats a registered open kinship as something to deny out loud
+// ("谁跟你姐妹", "谁跟你亲戚"). Tone may still tease; the registered fact
+// itself is not up for denial.
+const KINSHIP_DENIAL =
+  /(?:谁跟你|什么).{0,6}(?:姐妹|亲戚)|不是姐妹|没(?:有)?姐妹|不认.{0,8}(?:妹妹|姐姐|姐妹|亲戚)|少来.{0,16}(?:姐妹|亲戚)|关你屁事.{0,12}(?:户口|亲戚|姐妹)/;
+
+// Narrow, literal factual denials only. Disagreement with a label, old words,
+// fictional dialogue and feelings are left to the contextual reviewer.
+export function relationshipClaimIssues(bubbles, knowledge) {
+  const issues = [];
+  const known = (knowledge?.known || []).filter(
+    (r) => !r.discretion || r.discretion === "open",
+  );
+  for (const r of known) {
+    const role = String(r.peerRole || "").replace(
+      /[.*+?^${}()|[\]\\]/g,
+      "\\$&",
+    );
+    const selfRole = String(r.selfRole || "");
+    const names = [r.name, ...(r.knownAs || [])].filter(Boolean);
+    const kinship = KINSHIP.test(r.peerRole || "") || KINSHIP.test(selfRole);
+    for (const line of bubbles || []) {
+      for (const clause of String(line).split(/[，,。！？!?；;\n]/)) {
+        if (
+          /以前|之前|当时|过去|曾经|从前|一开始|原来|小说|台词|[“「"『]/.test(
+            clause,
+          )
+        )
+          continue;
+        const namedDenial = names.some((name) => {
+          const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          return new RegExp(
+            `(?:^|[\\s：:])${escaped}(?:也|本来|根本)?(?:不是|并非)我(?:的)?${role}(?:$|[\\s，。])|我(?:并)?不认识\\s*${escaped}(?:$|[\\s，。])`,
+            "i",
+          ).test(clause);
+        });
+        const absentRole = role
+          ? new RegExp(
+              `我(?:本来|本来也|现在|根本|一直|从来)?(?:就|也)?(?:没有|没)${role}(?:$|[\\s，。])`,
+            ).test(clause)
+          : false;
+        const banterDenial = kinship && KINSHIP_DENIAL.test(clause);
+        if (namedDenial || absentRole || banterDenial) {
+          issues.push(
+            `当前已知 ${r.name || r.subjectId} 与自己的关系是 ${r.peerRole || r.selfRole}，不能把旧印象当成关系不存在；可保留自己的感受和称呼选择，按当前记录核对再说`,
+          );
+          break;
+        }
+      }
+    }
+  }
+  return [...new Set(issues)];
+}
+
+// Summaries that narrate "认亲被拒" teach her to deny open kinship again.
+// Soften that pattern when open family roles are on record; do not delete facts.
+export function softenRelationDenialSummaries(summaries, knowledge) {
+  const openKin = (knowledge?.known || []).some(
+    (r) =>
+      (!r.discretion || r.discretion === "open") &&
+      (KINSHIP.test(r.peerRole || "") || KINSHIP.test(r.selfRole || "")),
+  );
+  if (!openKin || !Array.isArray(summaries)) return summaries || [];
+  return summaries.map((row) => {
+    if (!row || typeof row.summary !== "string") return row;
+    const summary = row.summary.replace(
+      /认亲被拒[^。；]*/g,
+      "姐妹关系仍在，偶尔玩笑推搪",
+    );
+    return summary === row.summary ? row : { ...row, summary };
+  });
+}

package/server/plugins/zip-file.js

@@ -0,0 +1,180 @@
+// Reads a zip archive from disk one entry at a time, so a sticker pack of
+// several hundred MB never has to sit in memory. Same rules as readZip:
+// stored/deflate only, no encryption, no links, no paths leaving the folder.
+// Supports zip64 (archives over 4 GB or 65535 entries, as written by most
+// tools for big packs).
+import { open } from "node:fs/promises";
+import { inflateRaw } from "node:zlib";
+import { promisify } from "node:util";
+
+const inflate = promisify(inflateRaw);
+
+function safeName(name) {
+  const text = String(name || "").replace(/\\/g, "/");
+  if (
+    !text ||
+    text.startsWith("/") ||
+    text.includes("\0") ||
+    /^[a-z]:/i.test(text) ||
+    text.split("/").some((part) => part === ".." || part === "")
+  )
+    throw new Error("压缩包路径无效");
+  return text;
+}
+
+async function readAt(handle, position, length) {
+  const buffer = Buffer.alloc(length);
+  const { bytesRead } = await handle.read(buffer, 0, length, position);
+  return buffer.subarray(0, bytesRead);
+}
+
+const u64 = (buffer, at) => Number(buffer.readBigUInt64LE(at));
+
+// The central directory: where every entry is and how big it is.
+async function directory(handle, size, maxFiles) {
+  if (size < 22) throw new Error("压缩包无法读取");
+  const tailLength = Math.min(size, 22 + 65535 + 20);
+  const tail = await readAt(handle, size - tailLength, tailLength);
+  let eocd = -1;
+  for (let i = tail.length - 22; i >= 0; i--)
+    if (tail.readUInt32LE(i) === 0x06054b50) {
+      eocd = i;
+      break;
+    }
+  if (eocd < 0) throw new Error("压缩包无法读取");
+  if (tail.readUInt16LE(eocd + 4) !== 0) throw new Error("压缩包格式不受支持");
+  let entries = tail.readUInt16LE(eocd + 10);
+  let cdSize = tail.readUInt32LE(eocd + 12);
+  let cdOffset = tail.readUInt32LE(eocd + 16);
+  const locator = eocd - 20;
+  if (
+    (entries === 0xffff || cdSize === 0xffffffff || cdOffset === 0xffffffff) &&
+    locator >= 0 &&
+    tail.readUInt32LE(locator) === 0x07064b50
+  ) {
+    const at = u64(tail, locator + 8);
+    const record = await readAt(handle, at, 56);
+    if (record.readUInt32LE(0) !== 0x06064b50)
+      throw new Error("压缩包无法读取");
+    entries = u64(record, 32);
+    cdSize = u64(record, 40);
+    cdOffset = u64(record, 48);
+  }
+  if (!entries || entries > maxFiles) throw new Error("压缩包文件过多");
+  if (cdOffset + cdSize > size) throw new Error("压缩包无法读取");
+  const cd = await readAt(handle, cdOffset, cdSize);
+  const list = [];
+  let offset = 0;
+  for (let index = 0; index < entries; index++) {
+    if (offset + 46 > cd.length || cd.readUInt32LE(offset) !== 0x02014b50)
+      throw new Error("压缩包无法读取");
+    const flags = cd.readUInt16LE(offset + 8);
+    const method = cd.readUInt16LE(offset + 10);
+    let compressedSize = cd.readUInt32LE(offset + 20);
+    let entrySize = cd.readUInt32LE(offset + 24);
+    const nameLength = cd.readUInt16LE(offset + 28);
+    const extraLength = cd.readUInt16LE(offset + 30);
+    const commentLength = cd.readUInt16LE(offset + 32);
+    const attributes = cd.readUInt32LE(offset + 38);
+    let local = cd.readUInt32LE(offset + 42);
+    const name = cd
+      .subarray(offset + 46, offset + 46 + nameLength)
+      .toString("utf8");
+    const extra = cd.subarray(
+      offset + 46 + nameLength,
+      offset + 46 + nameLength + extraLength,
+    );
+    for (let e = 0; e + 4 <= extra.length;) {
+      const id = extra.readUInt16LE(e);
+      const len = extra.readUInt16LE(e + 2);
+      if (id === 0x0001) {
+        let p = e + 4;
+        if (entrySize === 0xffffffff) ((entrySize = u64(extra, p)), (p += 8));
+        if (compressedSize === 0xffffffff)
+          ((compressedSize = u64(extra, p)), (p += 8));
+        if (local === 0xffffffff) local = u64(extra, p);
+      }
+      e += 4 + len;
+    }
+    offset += 46 + nameLength + extraLength + commentLength;
+    if (flags & 1) throw new Error("压缩包不能加密");
+    const type = (attributes >>> 16) & 0o170000;
+    if (type && type !== 0o100000 && type !== 0o040000)
+      throw new Error("压缩包不能包含链接");
+    if (name.endsWith("/") || name.endsWith("\\")) continue;
+    if (method !== 0 && method !== 8) throw new Error("压缩包格式不受支持");
+    list.push({
+      name: safeName(name),
+      method,
+      compressedSize,
+      size: entrySize,
+      local,
+    });
+  }
+  return list;
+}
+
+// Yields { name, bytes } or { name, skipped } for each kept entry, reading
+// only that entry from disk. The declared size is not trusted: inflation
+// stops at maxEntryBytes.
+export async function* readZipFile(
+  path,
+  { maxFiles = 20000, maxEntryBytes = Infinity, keep = () => true } = {},
+) {
+  const handle = await open(path, "r");
+  try {
+    const { size } = await handle.stat();
+    const entries = await directory(handle, size, maxFiles);
+    for (const entry of entries) {
+      if (!keep(entry.name)) continue;
+      if (
+        entry.size > maxEntryBytes ||
+        entry.compressedSize > maxEntryBytes * 4 + 1024
+      ) {
+        yield { name: entry.name, skipped: "too-large" };
+        continue;
+      }
+      const header = await readAt(handle, entry.local, 30);
+      if (header.length < 30 || header.readUInt32LE(0) !== 0x04034b50)
+        throw new Error("压缩包无法读取");
+      const dataAt =
+        entry.local + 30 + header.readUInt16LE(26) + header.readUInt16LE(28);
+      const compressed = await readAt(handle, dataAt, entry.compressedSize);
+      let bytes;
+      try {
+        bytes =
+          entry.method === 0
+            ? compressed
+            : await inflate(compressed, {
+                maxOutputLength: Math.min(maxEntryBytes, 2 ** 31 - 1) + 1,
+              });
+      } catch (error) {
+        if (error?.code === "ERR_BUFFER_TOO_LARGE") {
+          yield { name: entry.name, skipped: "too-large" };
+          continue;
+        }
+        throw new Error("压缩包无法读取");
+      }
+      if (bytes.length > maxEntryBytes) {
+        yield { name: entry.name, skipped: "too-large" };
+        continue;
+      }
+      if (entry.size && bytes.length !== entry.size)
+        throw new Error("压缩包内容不完整");
+      yield { name: entry.name, bytes };
+    }
+  } finally {
+    await handle.close();
+  }
+}
+
+// Every kept entry name, without reading any data.
+export async function zipFileNames(path, { maxFiles = 20000 } = {}) {
+  const handle = await open(path, "r");
+  try {
+    const { size } = await handle.stat();
+    return (await directory(handle, size, maxFiles)).map((e) => e.name);
+  } finally {
+    await handle.close();
+  }
+}

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);