sintbot 1.0.16 → 1.3.0

package/src/projectmemory.js

@@ -1,175 +0,0 @@
-// 项目长期记忆与约定文件的探测(跨模型记忆交接)。
-//
-// 由来:一个群换了模型大脑之后,上一任攒下的东西并不跟着走。⭐ 但**缺的不是能力,是可达** ——
-// 群都是完全访问(codex 侧 = danger-full-access),那些 markdown 它本来就读得到;只是没有任何
-// 地方告诉过它「有这东西、在哪、什么规矩」。所以正解落在**自知清单**上,不是搬运数据、
-// 不是第三本账、也不是切换那一刻补一轮握手 —— 交接该是持续发生的。
-//
-// 已验死的事实:
-//  · codex 运行时**不读 CLAUDE.md**(二进制里 AGENTS.md 出现 77 次,CLAUDE.md 只出现在
-//    「从 Claude Code 一次性导入」的向导串里)⇒ claude 群里天天更新的那份约定,换成 codex
-//    就等于不存在。反过来 claude 不读 AGENTS.md。⇒ **约定文件那一行**无条件点名存在的每一份,
-//    对本来就会自动加载的那一方是无害冗余,对另一方是救命。
-//  · 私有记忆目录 = <配置目录>/projects/<slug>/memory。slug 规则见 memorySlug —— **从实物
-//    反推,不是猜**。
-//
-// ⚠ **路径只能探测,不许推算** —— 给错路径比不给更糟:agent 会照着去读,读不到就学会
-// 「这项目没有记忆」这条错信念(一次失败的交互会在会话里固化成信念,之后它绕路不再试),
-// 而更坏的一头是读到**别的项目**的记忆还照着做。所以:每条路径都 stat 过才敢往外报,
-// workdir 本身必须是真实目录,归属还要再过一道权威源。
-const fs = require('node:fs')
-const path = require('node:path')
-const os = require('node:os')
-
-// 项目根的约定文件。⚠ 顺序有语义(清单按它挑「往哪写」的落点),故测试里用字面量断言,
-// 不许拿这个常量自己当期望 —— 那样顺序怎么改都测不出来。
-const CONVENTION_FILES = ['CLAUDE.md', 'AGENTS.md']
-
-// 记忆条数只报**档位**,不报精确值。
-// ⚠ 这是清单指纹的硬约束,不是偷懒:engine 靠「清单文本变了没」决定要不要重注入,并在变了时
-// 对 agent 说一句「你的能力/配置已更新」。而真实项目**每天都在长记忆**(实测四天 +1),报精确
-// 值 ⇒ 指纹天天变 ⇒ 每天白重注入一份几 KB 的清单,还对 agent 说了假话(能力根本没更新)。
-// ⚠ 残留(已知、接受):claude 侧框架会**自己**往记忆目录写 ⇒ 跨档那一刻仍会翻一次指纹。
-//   这是清单里第一个 agent 自己就能触发的字段。档位只把频率从「每天」压到「跨档时」,没有消除。
-const BUCKETS = [500, 200, 100, 50, 20, 10]
-function countBucket(n) {
-  for (const b of BUCKETS) if (n >= b) return `${b}+ 条`
-  return '不到 10 条' // 10 以下不报数:小项目每加一条都会翻指纹,而 3 条与 5 条对读不读毫无区别
-}
-
-// slug 规则 = **realpath 之后,把 `/` 和 `_` 都压成 `-`**。本机 20 个记忆目录逐一对账反推得出,
-// 不是猜。两条都有实物,且都是对抗审查逮出来的真事故:
-//  ⚠ 漏掉 `_`:`…/Doc-TTS`(压根不存在)会命中 `…/Doc_TTS` 的记忆 ⇒ 报出**别的项目**的记忆,
-//    而真主人(带 `_` 的那个)自己反而永远探不到。两头都坏,且「没有记忆」与「slug 算错了」
-//    在清单里长得一模一样。
-//  ⚠ 漏掉 realpath:`/tmp/x` 被记成 `-private-tmp-x`(macOS 上 /tmp、/var 都是软链)⇒ workdir
-//    填软链路径的群,记忆永远探不到,不出任何声。
-// ⚠ Windows 规则**无样本**:这里照同一套算,算错的后果是 stat 不到 ⇒ 返回 null(fail-safe),
-//   不会报出错路径 —— 但也等于该平台上这个功能不生效。
-function memorySlug(realPath) {
-  return String(realPath).replace(/\\/g, '/').replace(/[/_]/g, '-')
-}
-
-// 归属的权威源:claude.json 的 `projects` 以**真实绝对路径**为键(本机实测 18 键)。
-// ⭐ 用查表替代「猜一条替代路径存不存在」的启发式 —— 一次读文件(实测 98KB / 0.29ms,与同一
-// 函数里已有的读 .git/config、读风格档同量级)就把 `_`、`/`、软链三个维度一次覆盖;而启发式
-// 只覆盖其中一维的一个位置,还会被一个**跟 claude 毫无关系的普通兄弟目录**误判成歧义
-// (旧实现:项目里新建个 demo/ 子目录,整段记忆就静默消失)。
-// ⚠ 它权威但**不完备** —— 2026-09-01 实测:18 个带记忆的目录里有 4 个在 claude.json 里没有键
-//   认领。所以「没人认领」不算歧义(照报);只有「别人认领了」或「两个键撞同一 slug」才闭嘴。
-// ⚠ 读不到权威源时返回 null = 「无归属信息」,按不阻断处理:realpath + `_` 已经消掉了现实中
-//   真正发生过的那类错配,而两个键撞同一 slug 实测为 0 次。
-// ⚠ 候选路径要先归一 —— cfgDir 带个尾斜杠就会让两个候选双双落空,然后**静默** fail-open。
-function claudeJsonPath(cfgDir) {
-  const base = path.resolve(String(cfgDir))
-  for (const p of [base + '.json', path.join(base, '.claude.json')]) {
-    try { if (fs.statSync(p).isFile()) return p } catch { /* 换下一个候选 */ }
-  }
-  return null
-}
-
-function slugOwners(cfgDir, slug) {
-  const p = claudeJsonPath(cfgDir)
-  if (!p) return null
-  try {
-    const projects = JSON.parse(fs.readFileSync(p, 'utf8')).projects || {}
-    const out = []
-    for (const k of Object.keys(projects)) {
-      // ⚠ 键**不随目录删除而清理**(实测 18 个键里 6 个是幽灵键)。目录都不在了的键认领不了
-      // 任何东西 —— 留着它参与匹配,会让一个早就删掉的老项目**压制住一个活着的项目**的记忆,
-      // 而且不出任何声。方向虽是 fail-safe,但这是旧实现没有的新压制面。
-      let real
-      try { real = fs.realpathSync(k) } catch { continue }
-      if (memorySlug(real) === slug) out.push(real)
-    }
-    return out
-  } catch { return null }
-}
-
-function probeMemoryDir(workdir, opts = {}) {
-  // workdir 必须是**真实存在的目录**,并走 realpath(claude 记的就是 realpath)。
-  // 顺带挡掉「控制台把路径填错 / 项目被移走 / 盘没挂上」这一整类 —— 旧实现对一个压根不存在
-  // 的 workdir 也能报出一个真实可读的记忆目录。path.resolve 先吃掉尾斜杠、`.`、`..`、重复斜杠。
-  let real
-  try {
-    real = fs.realpathSync(path.resolve(String(workdir)))
-    if (!fs.statSync(real).isDirectory()) return null
-  } catch { return null }
-  const home = opts.home || os.homedir()
-  const cfgDir = opts.configDir || (opts.env || process.env).CLAUDE_CONFIG_DIR || path.join(home, '.claude')
-  const slug = memorySlug(real)
-  const dir = path.join(cfgDir, 'projects', slug, 'memory')
-  let names
-  try {
-    if (!fs.statSync(dir).isDirectory()) return null
-    // withFileTypes:名字以 .md 结尾的**子目录**不该被算成一条记忆(真实记忆目录里就有
-    // _archive/ 这类子目录)。软链不排除 —— 软链到记忆文件是正当用法。
-    names = fs.readdirSync(dir, { withFileTypes: true })
-      .filter((e) => e.name.endsWith('.md') && !e.isDirectory()).map((e) => e.name)
-  } catch { return null }
-  const index = names.includes('MEMORY.md') ? 'MEMORY.md' : null
-  const count = names.length - (index ? 1 : 0)
-  // 空目录 / 只剩一份索引 ⇒ 没东西可交接。清单每轮都付 token,不为「这里什么都没有」占篇幅。
-  if (count <= 0) return null
-  const owners = slugOwners(cfgDir, slug)
-  if (owners && (owners.length > 1 || (owners.length === 1 && owners[0] !== real))) return null
-  return { dir, count, bucket: countBucket(count), index }
-}
-
-// 原始层判据:「这个项目有没有东西可交接」。只服务 probeProjectMemory 自己 —— 保证它返回非 null
-// 时一定有东西。⚠ 消费者不该用这一条(它不知道这一轮的权限/runner 够不够得着),消费者用 probeHandover。
-function hasHandover(pm) { return !!(pm && (pm.convention.length || pm.memory)) }
-
-/**
- * 探测一个项目目录里「跨会话还留得住的东西」。
- * @returns {{convention: string[], memory: {dir,count,bucket,index}|null}|null}
- *   两样都没有时返回 null —— 探测式:项目里没有这些东西,清单里就一个字都不出现。
- */
-function probeProjectMemory(workdir, opts = {}) {
-  const wd = workdir && String(workdir).trim()
-  if (!wd) return null
-  const convention = []
-  for (const f of CONVENTION_FILES) {
-    try { if (fs.statSync(path.join(wd, f)).isFile()) convention.push(f) } catch { /* 不存在 ⇒ 不点名 */ }
-  }
-  const out = { convention, memory: probeMemoryDir(wd, opts) }
-  return hasHandover(out) ? out : null
-}
-
-// ⭐ 换脑时对群成员说的那一句。**控制台切模型与群内 `/model` 都要说它** —— 各写一份必然漂移
-// (教训 26/35),故收在这里当唯一来源,经 probeHandover 的 `note` 交给两个消费者。
-// ⚠ **只陈述事实(东西还在),不承诺行为**(「它会先读」):读不读是半可信 agent 的判断,编排层
-//   保证不了 —— 清单自己都写着「上下文里没有就自己读一遍」。
-// ⚠ 用户面零工具名:不提约定文件名、更不提机器上的目录。
-const HANDOVER_NOTE = '本项目的长期约定与积累都还在,不必从头交代'
-
-/**
- * ⭐ **消费者唯一入口**:这一轮**实际给得出去**的交接信息。自知清单与切模型通知都调它。
- *
- * 为什么必须收成一个函数(教训 26/35 家族):门控之前两个消费者天然一致,加了门控就多出第三种
- * 状态 ——「探到了东西,但这一轮一条都给不出去」。各写各的判据 ⇒ 控制台在群里说「之前交代过的
- * 都还在」,而清单里一个字都没有、那个目录 agent 还够不着。**注释挡不住复发,得收成一个被调用的
- * 东西**;而落点选哪份、够不够得着,都属于「哪个 runner 会自动加载什么、文件工具被围在哪」
- * 这类**具体 agent 的行为知识**,本就不该写进 core。
- *
- * @param {string} workdir
- * @param {{full?: boolean, isCodex?: boolean}} opts full = 该群完全访问;isCodex = 走 codex runner
- * @returns {{convention: string[], memory: object|null, landing: string|null}|null}
- */
-function probeHandover(workdir, opts = {}) {
-  const pm = probeProjectMemory(workdir, opts)
-  if (!pm) return null
-  // 记忆目录在 workdir **之外**,而 claude runner 唯一的 --add-dir 就是 workdir 本身 ⇒ 非完全
-  // 访问的 claude 群读不到。指了它读不到的路,只会**亲手教出**「这项目没有记忆」那条错信念
-  // (一次失败的交互会在会话里固化成信念,之后它绕开不再试)—— 比从没告诉过它更糟。
-  // codex 的 read-only 是只读**文件系统策略**、不是路径牢笼,够得着。
-  const memory = pm.memory && (opts.full || opts.isCodex) ? pm.memory : null
-  // 落点:两份都在时选它**自己会自动加载**的那一份 —— 让 codex 把交接写进一份它不读的档,等于白写。
-  const want = opts.isCodex ? 'AGENTS.md' : 'CLAUDE.md'
-  const landing = pm.convention.length ? (pm.convention.find((f) => f === want) || pm.convention[0]) : null
-  // 探到了但一条都给不出去 ⇒ 两个消费者一致地闭嘴(清单不留光秃秃的标题,群里也不说那句话)。
-  if (!landing && !memory) return null
-  return { convention: pm.convention, memory, landing, note: HANDOVER_NOTE }
-}
-
-module.exports = { probeHandover, probeProjectMemory, probeMemoryDir, memorySlug, slugOwners, hasHandover, countBucket, CONVENTION_FILES, HANDOVER_NOTE }

package/src/service.js

@@ -1,317 +0,0 @@
-// `sbot service` —— 把 `sbot start` 装成常驻服务:崩溃自动拉起、登录(或开机)自启。
-//
-// 平台:macOS = launchd LaunchAgent(GUI 域,随用户登录起)· Linux = systemd --user。
-// Windows 不自动装:服务化要第三方托管器(NSSM / pm2),这里只打印现成命令(docs/zh-CN/install.md)。
-//
-// 结构:单元文件全由纯函数生成(可单测、`--dry-run` 原样打印);真正动系统的只有 install /
-// uninstall / restart / status 里那几行 launchctl / systemctl,出错如实报、不吞。
-//
-// ⚠ 服务里跑的是**当前这份** node 与 sbot 入口的绝对路径,并且显式带 `--config <绝对路径>` ——
-//   常驻进程的 cwd 与 PATH 都不是装的人那一刻的 shell,靠「从当前目录找配置」或「PATH 里找 node」
-//   在常驻环境里会静默找错 / 找不到。
-// ⚠ node 路径不能直接用 process.execPath:Homebrew 下它是带版本号的 Cellar 路径
-//   (/opt/homebrew/Cellar/node/26.0.0/bin/node),升级 node 后旧目录被删,服务就再也起不来 ⇒
-//   换成指向同一个可执行文件、但不带版本号的路径(stableNodeBin);找不到就照用并提醒。
-// ⚠ 服务进程拿不到装的人 shell 里的环境变量:配置里 `env:VAR` 引用的 key 在终端里解析得到,
-//   到了 launchd / systemd 里就是空的 ⇒ install 时点名;`--pass-env` 才把值写进单元文件(权限 600)。
-// ⚠ PATH 取装的那一刻的 shell PATH,并把 node / claude / codex 所在目录排在最前:agent 要 spawn
-//   `claude` / `codex`,launchd 给的默认 PATH 只有 /usr/bin:/bin,nvm / homebrew 装的都找不到。
-
-const fs = require('node:fs')
-const os = require('node:os')
-const path = require('node:path')
-const { execFileSync, execFile } = require('node:child_process')
-
-const LABEL = 'com.sbot.daemon'      // launchd 标签(与早期手写 plist 同名 ⇒ 装新版直接替换旧的)
-const UNIT = 'sbot.service'          // systemd --user 单元名
-
-function xmlEsc(s) {
-  return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;')
-}
-
-// systemd ExecStart 的单个参数:含空白 / 引号 / 反斜杠 / $ / % 才加双引号并转义
-function sdQuote(s) {
-  s = String(s)
-  if (!/[\s"'\\$%;]/.test(s) && s !== '') return s
-  return '"' + s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\$/g, '$$$$').replace(/%/g, '%%') + '"'
-}
-
-// PATH:优先目录在前,其后是现有 PATH,去重去空
-function buildPath(firstDirs, existing, delimiter = ':') {
-  const out = []
-  for (const d of [...firstDirs, ...String(existing || '').split(delimiter)]) {
-    if (d && !out.includes(d)) out.push(d)
-  }
-  return out.join(delimiter)
-}
-
-// 路径里带版本号的(Homebrew Cellar / nvm / volta / fnm / asdf / n,或任何 x.y.z 目录段):
-// 换版本后这个路径就不在了
-function versionedPath(p) {
-  return /\/Cellar\/|\/\.nvm\/versions\/|\/\.volta\/tools\/image\/|\/fnm\/node-versions\/|\/\.asdf\/installs\/|\/n\/versions\//.test(String(p))
-    || /\/[^/]*\d+\.\d+\.\d+[^/]*\//.test(String(p))
-}
-
-// 给服务用的 node 路径:与 execPath 是同一个可执行文件、但不带版本号。候选 = PATH 上的 node,
-// 以及 Homebrew 的 <prefix>/bin/node 与 <prefix>/opt/<formula>/bin/node(升级后会跟着指向新版)。
-// → { bin, warn? };哪个都对不上就照用 execPath 并给一句提醒。
-function stableNodeBin({ execPath, candidates = [], exists = fs.existsSync, realpath = fs.realpathSync }) {
-  if (!versionedPath(execPath)) return { bin: execPath }
-  const real = (p) => { try { return realpath(p) } catch { return null } }
-  const target = real(execPath) || execPath
-  const m = String(execPath).match(/^(.*)\/Cellar\/([^/]+)\/[^/]+\/bin\/node$/)
-  const brew = m ? [path.join(m[1], 'bin', 'node'), path.join(m[1], 'opt', m[2], 'bin', 'node')] : []
-  for (const c of [...candidates, ...brew]) {
-    if (c && exists(c) && !versionedPath(c) && real(c) === target) return { bin: c }
-  }
-  return { bin: execPath, warn: `node 的路径带版本号(${execPath}),换 node 版本后要重跑 sintbot service install` }
-}
-
-// 配置里所有 `env:VAR` 引用的变量名(去重,按出现顺序)。下划线开头的键是说明 / 示例(`_slack_example` 这类),
-// 运行时不读,不算
-function envRefs(obj, out = []) {
-  if (typeof obj === 'string') {
-    const m = obj.match(/^env:([A-Za-z_][A-Za-z0-9_]*)$/)
-    if (m && !out.includes(m[1])) out.push(m[1])
-  } else if (Array.isArray(obj)) obj.forEach((v) => envRefs(v, out))
-  else if (obj && typeof obj === 'object') for (const [k, v] of Object.entries(obj)) { if (!k.startsWith('_')) envRefs(v, out) }
-  return out
-}
-
-// 服务托管标记:守护进程据此知道「退出了会被 launchd / systemd 拉起」—— 还没接平台时只开控制台,
-// 第一次接上平台就自己退出、重启后连上(bin/sbot.js cmdStart)。前台跑的 sintbot start 没有它
-const SUPERVISED_ENV = 'SBOT_SUPERVISED'
-
-// 服务的全部事实(纯数据):各平台单元文件都从这里生成。env = 额外写进单元文件的环境变量(--pass-env)
-function serviceSpec({ nodeBin, sbotBin, configPath, uiHost, home, pathEnv, env = {} }) {
-  const args = [sbotBin, 'start', '--ui', '--no-open']
-  if (uiHost) args.push('--ui-host', uiHost)
-  if (configPath) args.push('--config', configPath)
-  const workdir = configPath ? path.dirname(configPath) : path.join(home, '.sbot')
-  const logDir = path.join(home, '.sbot', 'logs')
-  return { nodeBin, args, workdir, logDir, pathEnv, env, outLog: path.join(logDir, 'out.log'), errLog: path.join(logDir, 'err.log') }
-}
-
-function launchdPlist(spec) {
-  const arr = [spec.nodeBin, ...spec.args].map((a) => `    <string>${xmlEsc(a)}</string>`).join('\n')
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key><string>${LABEL}</string>
-  <key>ProgramArguments</key>
-  <array>
-${arr}
-  </array>
-  <key>WorkingDirectory</key><string>${xmlEsc(spec.workdir)}</string>
-  <key>EnvironmentVariables</key>
-  <dict>
-    <key>PATH</key><string>${xmlEsc(spec.pathEnv)}</string>
-${Object.entries(spec.env || {}).map(([k, v]) => `    <key>${xmlEsc(k)}</key><string>${xmlEsc(v)}</string>\n`).join('')}    <key>${SUPERVISED_ENV}</key><string>1</string>
-  </dict>
-  <key>RunAtLoad</key><true/>
-  <key>KeepAlive</key><true/>
-  <key>ThrottleInterval</key><integer>15</integer>
-  <key>StandardOutPath</key><string>${xmlEsc(spec.outLog)}</string>
-  <key>StandardErrorPath</key><string>${xmlEsc(spec.errLog)}</string>
-</dict>
-</plist>
-`
-}
-
-function systemdUnit(spec) {
-  return `[Unit]
-Description=SintBot daemon (group chat -> headless Claude Code)
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-ExecStart=${[spec.nodeBin, ...spec.args].map(sdQuote).join(' ')}
-WorkingDirectory=${sdQuote(spec.workdir)}
-Environment=${sdQuote('PATH=' + spec.pathEnv)}
-${Object.entries(spec.env || {}).map(([k, v]) => `Environment=${sdQuote(k + '=' + v)}\n`).join('')}Environment=${SUPERVISED_ENV}=1
-Restart=always
-RestartSec=15
-KillSignal=SIGTERM
-TimeoutStopSec=30
-StandardOutput=append:${spec.outLog}
-StandardError=append:${spec.errLog}
-
-[Install]
-WantedBy=default.target
-`
-}
-
-function unitPath(platform, home) {
-  if (platform === 'darwin') return path.join(home, 'Library', 'LaunchAgents', LABEL + '.plist')
-  if (platform === 'linux') return path.join(home, '.config', 'systemd', 'user', UNIT)
-  return null
-}
-
-function render(platform, spec) {
-  if (platform === 'darwin') return launchdPlist(spec)
-  if (platform === 'linux') return systemdUnit(spec)
-  return null
-}
-
-// Windows:不自动装,给现成命令(两种托管器任选)
-function windowsHint(spec) {
-  const cmd = [spec.nodeBin, ...spec.args].map((a) => (/\s/.test(a) ? `"${a}"` : a)).join(' ')
-  return [
-    'Windows 上请用托管器把下面这条命令装成服务(任选其一,详见 https://github.com/sintlab/sintbot/blob/main/docs/zh-CN/install.md):',
-    '',
-    `  命令:${cmd}`,
-    '',
-    '  · NSSM:nssm install SintBot ' + `"${spec.nodeBin}" ` + spec.args.map((a) => (/\s/.test(a) ? `"${a}"` : a)).join(' '),
-    `          nssm set SintBot AppDirectory "${spec.workdir}"`,
-    '          nssm start SintBot',
-    '  · pm2: pm2 start ' + `"${spec.args[0]}" --name sbot -- ` + spec.args.slice(1).join(' ') + ' && pm2 save',
-  ].join('\n')
-}
-
-function run(bin, args, opts = {}) {
-  try { return { ok: true, out: execFileSync(bin, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], ...opts }) } }
-  catch (e) { return { ok: false, out: String(e.stdout || ''), err: String(e.stderr || e.message || e).trim(), code: e.status } }
-}
-
-const uid = () => (typeof process.getuid === 'function' ? process.getuid() : 0)
-
-// launchctl bootout may return before the old job has fully left the GUI domain.
-// Keep the wait synchronous and strictly bounded: service install is a CLI action,
-// and a failed unload must never race straight into bootstrap.
-function sleepSync(ms) {
-  if (ms > 0) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms)
-}
-
-function launchdServiceMissing(message) {
-  return /could not find service|service[^\n]*not found|no such service|not found in domain/i.test(String(message || ''))
-}
-
-function launchdBootstrapRace(result) {
-  return result && (result.code === 5 || /bootstrap failed:\s*5|input\/output error/i.test(String(result.err || '')))
-}
-
-// { ok:true, waitedMs } when unloaded; otherwise a bounded, actionable failure.
-function waitForLaunchdUnload(target, { runCommand = run, wait = sleepSync, timeoutMs = 2000, intervalMs = 100 } = {}) {
-  const tries = Math.floor(Math.max(0, timeoutMs) / Math.max(1, intervalMs)) + 1
-  for (let i = 0; i < tries; i++) {
-    const r = runCommand('launchctl', ['print', target])
-    if (!r.ok) {
-      if (launchdServiceMissing(r.err)) return { ok: true, waitedMs: i * intervalMs }
-      return { ok: false, waitedMs: i * intervalMs, err: r.err || 'launchctl print 失败,无法确认服务状态' }
-    }
-    if (i < tries - 1) wait(intervalMs)
-  }
-  return { ok: false, waitedMs: (tries - 1) * intervalMs, err: `等待 launchd 卸载超时(${timeoutMs}ms),未尝试重新加载` }
-}
-
-// 状态(只读):{ installed, running, pid, detail }
-function status({ platform = process.platform, home = os.homedir() } = {}) {
-  const file = unitPath(platform, home)
-  const installed = !!(file && fs.existsSync(file))
-  if (platform === 'darwin') {
-    const r = run('launchctl', ['print', `gui/${uid()}/${LABEL}`])
-    if (!r.ok) return { installed, loaded: false, running: false, pid: null, file }
-    const pid = (r.out.match(/^\s*pid = (\d+)/m) || [])[1]
-    const state = (r.out.match(/^\s*state = (\S+)/m) || [])[1] || ''
-    return { installed, loaded: true, running: state === 'running', pid: pid ? Number(pid) : null, state, file }
-  }
-  if (platform === 'linux') {
-    const r = run('systemctl', ['--user', 'show', UNIT, '--property=ActiveState,MainPID'])
-    const active = (r.out.match(/ActiveState=(\S+)/) || [])[1] || ''
-    const pid = Number((r.out.match(/MainPID=(\d+)/) || [])[1] || 0) || null
-    return { installed, loaded: active !== '' && active !== 'inactive', running: active === 'active', pid, state: active, file }
-  }
-  return { installed: false, loaded: false, running: false, pid: null, file: null }
-}
-
-// 写单元文件(已有且内容不同 ⇒ 先备份)并加载。返回 { file, backup, steps: [{cmd, ok, err}] }
-function install(spec, { platform = process.platform, home = os.homedir(), runCommand = run, wait = sleepSync, launchdTimeoutMs = 2000, launchdPollMs = 100 } = {}) {
-  const file = unitPath(platform, home)
-  if (!file) throw new Error('这个平台不支持自动安装服务')
-  const text = render(platform, spec)
-  fs.mkdirSync(path.dirname(file), { recursive: true })
-  fs.mkdirSync(spec.logDir, { recursive: true, mode: 0o700 }) // 日志里有群消息摘要;顺带建出的 ~/.sbot 也是 700
-  let backup = null
-  if (fs.existsSync(file) && fs.readFileSync(file, 'utf8') !== text) {
-    backup = `${file}.bak-${new Date().toISOString().replace(/[:.]/g, '').slice(0, 15)}`
-    fs.copyFileSync(file, backup)
-  }
-  fs.writeFileSync(file, text)
-  // 单元文件里写了环境变量的值(多半是 key)⇒ 只给自己读写;没写就是普通权限
-  if (Object.keys(spec.env || {}).length) fs.chmodSync(file, 0o600)
-  const steps = []
-  const step = (bin, args, tolerate) => { const r = runCommand(bin, args); steps.push({ cmd: [bin, ...args].join(' '), ok: r.ok || !!tolerate, err: r.ok ? '' : r.err }); return r }
-  if (platform === 'darwin') {
-    const target = `gui/${uid()}/${LABEL}`
-    const bootoutArgs = ['bootout', target]
-    const out = runCommand('launchctl', bootoutArgs)
-    const absentBefore = !out.ok && launchdServiceMissing(out.err)
-    steps.push({ cmd: ['launchctl', ...bootoutArgs].join(' '), ok: out.ok || absentBefore, err: out.ok || absentBefore ? '' : out.err })
-    // A missing job is normal on first install; any other bootout failure is not.
-    if (!out.ok && !absentBefore) return { file, backup, steps }
-    const unloaded = waitForLaunchdUnload(target, { runCommand, wait, timeoutMs: launchdTimeoutMs, intervalMs: launchdPollMs })
-    steps.push({ cmd: 'launchctl wait for bootout', ok: unloaded.ok, err: unloaded.ok ? '' : unloaded.err })
-    if (!unloaded.ok) return { file, backup, steps }
-
-    const bootstrapArgs = ['bootstrap', `gui/${uid()}`, file]
-    const first = runCommand('launchctl', bootstrapArgs)
-    if (first.ok) steps.push({ cmd: ['launchctl', ...bootstrapArgs].join(' '), ok: true, err: '' })
-    else if (launchdBootstrapRace(first)) {
-      // A race may report EIO even though launchd accepted the job. Since the
-      // previous job was confirmed absent, a now-loaded job is the new one.
-      const after = runCommand('launchctl', ['print', target])
-      if (after.ok) steps.push({ cmd: ['launchctl', ...bootstrapArgs].join(' '), ok: true, err: '' })
-      else if (launchdServiceMissing(after.err)) {
-        wait(100)
-        const retry = runCommand('launchctl', bootstrapArgs)
-        if (retry.ok) steps.push({ cmd: ['launchctl', ...bootstrapArgs].join(' '), ok: true, err: '' })
-        else {
-          const afterRetry = runCommand('launchctl', ['print', target])
-          const loaded = afterRetry.ok
-          steps.push({ cmd: ['launchctl', ...bootstrapArgs].join(' '), ok: loaded, err: loaded ? '' : retry.err })
-        }
-      } else steps.push({ cmd: ['launchctl', ...bootstrapArgs].join(' '), ok: false, err: after.err || first.err })
-    } else steps.push({ cmd: ['launchctl', ...bootstrapArgs].join(' '), ok: false, err: first.err })
-  } else {
-    step('systemctl', ['--user', 'daemon-reload'])
-    step('systemctl', ['--user', 'enable', UNIT])
-    step('systemctl', ['--user', 'restart', UNIT])
-  }
-  return { file, backup, steps }
-}
-
-function restart({ platform = process.platform } = {}) {
-  if (platform === 'darwin') return run('launchctl', ['kickstart', '-k', `gui/${uid()}/${LABEL}`])
-  if (platform === 'linux') return run('systemctl', ['--user', 'restart', UNIT])
-  return { ok: false, err: '这个平台不支持' }
-}
-
-// Async form for a daemon restarting itself after an in-place package upgrade.
-// systemctl restart waits for the old process to exit, so the daemon must keep
-// its event loop free to handle SIGTERM while this command is in flight.
-function restartAsync({ platform = process.platform } = {}) {
-  let bin, args
-  if (platform === 'darwin') { bin = 'launchctl'; args = ['kickstart', '-k', `gui/${uid()}/${LABEL}`] }
-  else if (platform === 'linux') { bin = 'systemctl'; args = ['--user', 'restart', UNIT] }
-  else return Promise.resolve({ ok: false, err: '这个平台不支持' })
-  return new Promise((resolve) => execFile(bin, args, { encoding: 'utf8', windowsHide: true }, (e, stdout, stderr) => {
-    resolve(e ? { ok: false, out: String(stdout || ''), err: String(stderr || e.message || e).trim(), code: e.code ?? e.status } : { ok: true, out: String(stdout || '') })
-  }))
-}
-
-function uninstall({ platform = process.platform, home = os.homedir() } = {}) {
-  const file = unitPath(platform, home)
-  const steps = []
-  if (platform === 'darwin') {
-    const r = run('launchctl', ['bootout', `gui/${uid()}/${LABEL}`]); steps.push({ cmd: 'launchctl bootout', ok: true, err: r.ok ? '' : r.err })
-  } else if (platform === 'linux') {
-    const r = run('systemctl', ['--user', 'disable', '--now', UNIT]); steps.push({ cmd: 'systemctl --user disable --now', ok: r.ok, err: r.ok ? '' : r.err })
-  }
-  let removed = false
-  if (file && fs.existsSync(file)) { fs.unlinkSync(file); removed = true }
-  if (platform === 'linux') run('systemctl', ['--user', 'daemon-reload'])
-  return { file, removed, steps }
-}
-
-module.exports = { LABEL, UNIT, SUPERVISED_ENV, xmlEsc, sdQuote, buildPath, versionedPath, stableNodeBin, envRefs, serviceSpec, launchdPlist, systemdUnit, unitPath, render, windowsHint, status, install, restart, restartAsync, uninstall, launchdServiceMissing, launchdBootstrapRace, waitForLaunchdUnload }

package/src/ui/auth.js

@@ -1,31 +0,0 @@
-// 控制台访问密码:scrypt 哈希 + 常量时间校验(零依赖)。
-//
-// 精简口径(局域网访问加固):控制台默认绑 loopback 免密;一旦对外(--host
-// 非环回)就要求登录。密码只干一件事 —— 换取一个本进程 session token,其余鉴权管线原样
-// 复用(token 放 x-sbot-token 头,天然免 CSRF)。密码永不明文落盘,存成 `scrypt$salt$hash`。
-
-const crypto = require('node:crypto')
-
-const KEYLEN = 32 // 派生密钥字节数
-
-// 明文密码 → `scrypt$<saltHex>$<hashHex>`(salt 随机,每次不同)
-function hashPassword(pw) {
-  const salt = crypto.randomBytes(16)
-  const hash = crypto.scryptSync(String(pw), salt, KEYLEN)
-  return `scrypt$${salt.toString('hex')}$${hash.toString('hex')}`
-}
-
-// 明文密码 vs 存储串;格式不符 / 长度不符 / 派生失败 → false(绝不抛)。timingSafeEqual 防计时侧信道。
-function verifyPassword(pw, stored) {
-  if (typeof stored !== 'string') return false
-  const parts = stored.split('$')
-  if (parts.length !== 3 || parts[0] !== 'scrypt') return false
-  let expected
-  try { expected = Buffer.from(parts[1] && parts[2] ? parts[2] : '', 'hex') } catch { return false }
-  if (expected.length !== KEYLEN) return false
-  let hash
-  try { hash = crypto.scryptSync(String(pw), Buffer.from(parts[1], 'hex'), KEYLEN) } catch { return false }
-  return hash.length === expected.length && crypto.timingSafeEqual(hash, expected)
-}
-
-module.exports = { hashPassword, verifyPassword }