sintbot 1.0.12 → 1.0.14

package/CHANGELOG.en.json

@@ -1,4 +1,41 @@
 [
+  {
+    "version": "1.0.14",
+    "date": "2026-10-30",
+    "name": "Steadier service installs and better console controls",
+    "items": [
+      {
+        "t": "More reliable service reinstalls",
+        "d": "A reinstall now waits for the old background service to fully unload before starting the new one, reducing cases where the service is left unloaded."
+      },
+      {
+        "t": "Software updates from the console",
+        "d": "Stable releases are checked at startup and daily, with a manual check available too. An administrator confirms an upgrade, which waits for every group task and queue to clear before installing the exact version."
+      },
+      {
+        "t": "Manage console access in Settings",
+        "d": "Set a password for LAN access and toggle LAN binding or public Feishu sign-in. Turning off public sign-in revokes existing Feishu sessions; a failed binding change restores the previous settings."
+      }
+    ]
+  },
+  {
+    "version": "1.0.13",
+    "name": "An even shorter install: almost nothing to answer",
+    "items": [
+      {
+        "t": "No questions for what can be done automatically",
+        "d": "The one-line install upgrades to the latest version directly. The wizard installs Claude Code when it is missing, picks the default model itself and runs a trial turn, and no longer asks about adding more models; Codex and the design icon libraries are optional and only get a one-line install hint. If you are already logged in to Claude or Codex, the whole install asks one thing: whether to install the background service."
+      },
+      {
+        "t": "Keys and proxy go into the service automatically",
+        "d": "Installing the background service writes the environment-variable keys the config refers to, and your terminal's proxy, into the service definition (mode 600) without asking. Run sintbot service install again after changing a key or the proxy."
+      },
+      {
+        "t": "Less output",
+        "d": "The install no longer shows npm progress or harmless warnings, and the background service reports a single line when it is up."
+      }
+    ]
+  },
   {
     "version": "1.0.12",
     "name": "Simpler install: the terminal sets up the model, the console does the rest",

package/CHANGELOG.json

@@ -1,4 +1,42 @@
 [
+  {
+    "version": "1.0.14",
+    "date": "2026-10-30",
+    "name": "服务重装与控制台管理更完善",
+    "items": [
+      {
+        "t": "服务重装更稳定",
+        "d": "重装时会等旧后台服务彻底退出后再启动，减少服务卡在未加载状态的情况。"
+      },
+      {
+        "t": "控制台可管理软件更新",
+        "d": "启动时及每天自动检查稳定版，也可手动检查。发现新版后由管理员确认，等所有群任务和队列空闲后再安装指定版本。"
+      },
+      {
+        "t": "访问地址可在控制台管理",
+        "d": "可以设置局域网访问密码、切换局域网监听和公网飞书登录。关闭公网登录会让现有飞书登录失效；切换监听失败时会恢复原设置。"
+      }
+    ]
+  },
+  {
+    "version": "1.0.13",
+    "date": "2026-10-28",
+    "name": "安装再精简:几乎不用回答问题",
+    "items": [
+      {
+        "t": "能自动做的不再问",
+        "d": "一键安装直接升级到最新版;向导缺 Claude Code 直接装、自动选默认模型并试跑一轮,不再问要不要再加模型;Codex 和设计图标库是可选的,只给一行装法。已经登录 Claude 或 Codex 的话,整个安装只问一句要不要装后台服务。"
+      },
+      {
+        "t": "key 和代理自动带进后台服务",
+        "d": "装后台服务时,配置里引用的环境变量 key、以及终端里的代理,直接写进服务定义(文件权限 600),不再问。换了 key 或代理重跑一次 sintbot service install。"
+      },
+      {
+        "t": "输出更短",
+        "d": "安装过程不再打 npm 的进度和无害警告;后台服务装好只报一行。"
+      }
+    ]
+  },
   {
     "version": "1.0.12",
     "date": "2026-10-28",

package/bin/sbot.js

@@ -61,6 +61,7 @@ const feishulogin = require('../src/ui/feishulogin') // 公网地址归一(ui.pu
 const { buildTakeoverCard } = require('../src/platform/takeovercard') // 「接管浏览器」的群内卡片(四态:等人来 / 接管中 / 已结束 / 已过期)
 const cdp = require('../src/cdp') // 接管卡片上的页面截图:CLI 直接连常驻浏览器截一张
 const { hashPassword } = require('../src/ui/auth')
+const updateFeature = require('../src/updater')
 
 const dim = (s) => `\x1b[2m${s}\x1b[0m`
 const cyan = (s) => `\x1b[36m${s}\x1b[0m`
@@ -211,13 +212,13 @@ const SUBHELP = {
     + '      --send 直接把一张卡发进群(带当前页面截图 + 「接管浏览器」按钮 + 有效期;有人点开始接管卡片自动翻成「正在接管中」)—— 群里跑时就用它,别自己贴链接\n'
     + '      对方在手机或电脑上打开就能直接操作这台机器的浏览器,登录态留在浏览器里,之后 agent 自己接着干\n'
     + '      要守护进程带控制台在跑(sintbot start --ui);群里跑时控制台地址已注入,终端里可设 SBOT_UI_URL=http://127.0.0.1:4600',
-  service: '用法: sintbot service install [--ui-host <ip>] [--config <path>] [--pass-env] [--dry-run]\n'
+  service: '用法: sintbot service install [--ui-host <ip>] [--config <path>] [--dry-run]\n'
     + '      sintbot service status | restart | logs [-n <行数>] | uninstall\n'
     + '      把 sintbot start --ui 装成常驻服务:崩溃自动拉起、登录后自启(macOS = launchd,Linux = systemd --user)\n'
     + '      install 写单元文件并立即启动;服务里固定用当前的 node、sbot 与配置文件的绝对路径,PATH 取当前 shell 的\n'
     + '      --dry-run 只打印要写的单元文件,不动系统;--ui-host 0.0.0.0 对局域网开控制台(须先 sintbot ui --set-password,否则拒装)\n'
-    + '      服务拿不到当前 shell 的环境变量:配置里 env:VAR 引用的 key 会被点名;--pass-env 把它们的值写进单元文件(文件权限 600),终端里装时不给也会问一句\n'
-    + '      还没接任何聊天平台时不装(退出码 3):服务会一启动就退出 —— 先 sintbot ui 在控制台接平台\n'
+    + '      服务拿不到当前 shell 的环境变量:配置里 env:VAR 引用的 key、以及配置没写代理时 shell 里的代理变量,值直接写进单元文件(文件权限 600);换了要重跑 install\n'
+    + '      还没接任何聊天平台也照装:服务先只开控制台,在「设置」里接好平台后自己重启连上\n'
     + '      Windows 不自动装:打印 NSSM / pm2 的现成命令。日志在 ~/.sbot/logs/;同一份状态只许一个 daemon,第二个会直接报错退出',
   version: '用法: sintbot version        (也认 sbot --version / -v)\n'
     + '      打印版本号',
@@ -487,7 +488,7 @@ async function cmdStart(rest) {
   const plat = platformsConfigured(cfg)
   if (!plat.feishu && !plat.wecom && !plat.slack) {
     // 带 --ui(后台服务就是这么起的):只开控制台,等人在「设置」里接平台 —— 1.0.12 起没平台也装服务,装完就有地方可去
-    if (wantUi) return serveSetupConsole(cfg, { port: Number(values['ui-port']) || 4600, host: values['ui-host'] || '127.0.0.1', noOpen })
+    if (wantUi) return serveSetupConsole(cfg, { port: Number(values['ui-port']) || 4600, host: (cfg.ui && cfg.ui.host) || values['ui-host'] || '127.0.0.1', noOpen })
     if (cfg.wecom && (cfg.wecom.botId || cfg.wecom.secret)) return die('sbot.config.json 的 wecom 块缺 ' + (cfg.wecom.botId ? 'secret' : 'botId') + '(机器人 API 配置页「使用长连接」处)')
     return die('没有配置任何聊天平台 — 在 sbot.config.json 里加 "feishu" 块(appId/appSecret)、"wecom" 块(botId/secret)或 "slack" 块(botToken/appToken),配几个接几个')
   }
@@ -524,6 +525,7 @@ async function cmdStart(rest) {
   const log = (m) => process.stderr.write(gray(`[${logStamp()}] · ` + m) + '\n')
   if (tightened.length) log(`状态目录权限已收紧(目录 700、文件 600):${tightened.length} 项`)
   let ui = null
+  let updaterManager = null
   let platform = null // set below; the UI (created first) reads WS health through this ref(多平台路由器,src/platform/multi.js)
   // 把一条消息交给引擎:**合成消息**(控制台插话 / 定时任务 / 续做 / 画布确认)没有真实适配器,按 chatId 查出它所属平台的
   // 适配器再喂 —— 引擎读的 skillCmd / features / chatLabel 是适配器上的,喂路由器会让企微群的清单按飞书口径写。
@@ -709,7 +711,7 @@ async function cmdStart(rest) {
   const reloadCfg = () => {
     try {
       const c = loadConfig(values.config); applyProxyEnv(c); engine.reload(c)
-      if (ui) engine.publicUrl = feishulogin.normalizePublicUrl((c.ui || {}).publicUrl) // 公网地址跟着配置热更(控制台设置页改了即生效)
+      if (ui) engine.publicUrl = (c.ui || {}).publicEnabled === false ? null : feishulogin.normalizePublicUrl((c.ui || {}).publicUrl) // 公网入口关闭时不再向群内清单宣传
       log('config reloaded (hot)')
     } catch (e) { log('reload failed: ' + (e && e.message)) }
   }
@@ -720,7 +722,8 @@ async function cmdStart(rest) {
   if (wantUi) {
     const configPath = cfg._path || path.join(process.cwd(), 'sbot.config.json')
     const uiPort = Number(values['ui-port']) || 4600
-    const uiHost = values['ui-host'] || '127.0.0.1'
+    // 控制台设置页可持久切换绑定地址;保存的 host 优先于服务单元里的旧参数。
+    const uiHost = (cfg.ui && cfg.ui.host) || values['ui-host'] || '127.0.0.1'
     const uiLoopback = isLoopbackHost(uiHost)
     // Advertise the console address in the agent's self-knowledge manifest (群项目基础能力).
     // For LAN binding, use the first LAN IP so group members get a reachable URL, not 127.0.0.1.
@@ -729,9 +732,20 @@ async function cmdStart(rest) {
     engine.uiLocalUrl = `http://127.0.0.1:${uiPort}`
     // 公网地址(v0.11.72 起的入口):群里 /help 与清单给人的是它,不是局域网 IP —— 出了局域网 LAN 地址
     // 打不开、还要密码,而公网入口只认飞书登录。归一判据与控制台「飞书登录」就绪判据同源(feishulogin)。
-    engine.publicUrl = feishulogin.normalizePublicUrl((cfg.ui || {}).publicUrl)
+    engine.publicUrl = (cfg.ui || {}).publicEnabled === false ? null : feishulogin.normalizePublicUrl((cfg.ui || {}).publicUrl)
     // Fail-closed: LAN exposure requires a console password (set via `sbot ui --set-password`).
     if (!uiLoopback && !((cfg.ui || {}).auth)) die(`控制台对外(--ui-host ${uiHost})需先设密码:sintbot ui --set-password`)
+    const service = require('../src/service')
+    updaterManager = updateFeature.createUpdater({
+      currentVersion: require('../package.json').version,
+      stateFile: path.join(os.homedir(), '.sbot', 'update.json'),
+      getLiveState: () => engine.liveState(),
+      fetchImpl: require('../src/core/proxy').getProxyFetch() || globalThis.fetch,
+      getManagedService: () => { const st = service.status(); return !!st.running && st.pid === process.pid },
+      restartManagedService: () => service.restartAsync(),
+      setAnnouncementBaseline: (version) => store.setLastVersion(version),
+      log,
+    })
     // 接管卡片翻状态:有人兑换 ⇒「正在接管中」;点「结束」/ 到时 ⇒「接管已结束」;票过期没人来 ⇒「已过期」。boardClient 在下面才定义,hook 只在运行时才调,不踩 TDZ。
     const flipTakeoverCard = (state) => (meta) => {
       if (!meta || !meta.cardId || !boardClient) return
@@ -748,6 +762,13 @@ async function cmdStart(rest) {
       getLiveState: () => engine.liveState(),
       getConnHealth: () => (platform && platform.connHealth ? platform.connHealth() : null), // 各平台连接健康度({ feishu, wecom } 字典,路由器出)
       onConfigChange: reloadCfg,
+      onHostChange: (boundHost, address) => {
+        const port = address && typeof address === 'object' ? address.port : uiPort
+        const loopback = isLoopbackHost(boundHost)
+        engine.uiUrl = `http://${loopback ? '127.0.0.1' : (lanIPv4()[0] || '127.0.0.1')}:${port}`
+        engine.uiLocalUrl = `http://127.0.0.1:${port}`
+      },
+      updater: updaterManager,
       control: {
         setProvider: (chatId, name) => store.setProvider(chatId, name),   // 实时切模型(下一轮生效)
         // 某群**实际在用**的模型(临时切换到备用时是备用,与 /status · 账本同口径)—— 控制台改 provider 型号时判「受影响群」
@@ -803,6 +824,7 @@ async function cmdStart(rest) {
       }
       process.stderr.write('\n')
       if (!noOpen) tryOpen(url)
+      if (updaterManager) void updaterManager.start().catch((e) => log('update check: ' + (e && e.message)))
     })
   }
   // 配了哪个平台就建哪个适配器;路由器按群分发(连接状态事件带 platform 名,控制台一行一个平台)。
@@ -1267,31 +1289,25 @@ async function cmdService(rest) {
     const configPath = findConfigPath(values.config)
     if (!configPath) return die('没找到配置文件 —— 先跑 sintbot setup(或 --config 指定)')
     // 控制台对外又没设密码:daemon 一启动就会拒绝退出,装成服务就是每 15 秒拉起一次的死循环 ⇒ 装之前就拦
-    const uiHost = values['ui-host']
     let raw
     try { raw = JSON.parse(fs.readFileSync(configPath, 'utf8')) } catch (e) { return die(`读不了配置 ${configPath}:${e.message}`) }
+    const uiHost = values['ui-host'] || ((raw.ui || {}).host)
     if (uiHost && !isLoopbackHost(uiHost) && !((raw.ui || {}).auth)) return die(`控制台对外(--ui-host ${uiHost})要先设密码:sintbot ui --set-password${values.config ? ' --config ' + values.config : ''} —— 否则服务一启动就退出、被反复拉起`)
     // 一个聊天平台都没接也照装(1.0.12 起):服务先只开控制台,在「设置」里接好平台后自己重启连上(cmdStart 的配置模式)。
     // 1.0.10–1.0.11 在这里拦下(退出码 3),结果装完没有任何地方可去 —— 控制台也打不开
     const plat = platformsConfigured(loadConfig(configPath))
     const noPlatform = !plat.feishu && !plat.wecom && !plat.slack
-    // 服务进程拿不到当前 shell 的环境变量:点名配置里的 env: 引用;--pass-env 才把值写进单元文件。
-    // 终端里装又没给 --pass-env 时问一句(默认是):不带进去,服务里用这些 key 的模型 / 平台直接用不了。
-    // 配置里没写代理、终端里有代理变量时一起列进这一问(不另问):不带进去,服务里连 Claude / ChatGPT 会直连失败
+    // 服务进程拿不到当前 shell 的环境变量:配置里 env: 引用的 key、配置没写代理时 shell 里的代理变量,值直接写进单元文件(600)。
+    // 1.0.10–1.0.12 先问一句;用户 10-28 定「安装过程要精简」⇒ 不问也不说(不带进去,服务里这些模型 / 平台、连 Claude / ChatGPT 都用不了)。
+    // --pass-env 仍认(以前要它才写),现在是默认行为
     const refs = svc.envRefs(raw)
     const inShell = refs.filter((v) => process.env[v])
     const nowhere = refs.filter((v) => !process.env[v])
     const shellProxy = PROXY_ENV_KEYS.filter((k) => process.env[k])
     const proxyVars = (raw.proxy && raw.proxy.http) || !shellProxy.some((k) => !/^no_proxy$/i.test(k)) ? [] : shellProxy // 只有 NO_PROXY 不算有代理
     const carry = [...inShell, ...proxyVars]
-    let passEnv = !!values['pass-env']
-    if (!passEnv && carry.length && process.stdin.isTTY) {
-      const rl = readline.createInterface({ input: process.stdin, output: process.stderr })
-      const a = await new Promise((res) => rl.question(`${cyan('?')} ${tr(`终端里的环境变量 ${carry.join(' ')} 服务里拿不到 —— 把它们的值写进服务定义吗?(文件权限 600;以后改了要重跑这条命令)`, `The service can't see these variables from your terminal: ${carry.join(' ')}. Write their values into the service definition? (file mode 600; re-run this command after changing them)`)} ${dim('(Y/n)')} `, res))
-      rl.close()
-      passEnv = !/^n/i.test(String(a).trim())
-    }
-    const env = passEnv ? Object.fromEntries(carry.map((v) => [v, process.env[v]])) : {}
+    const env = Object.fromEntries(carry.map((v) => [v, process.env[v]]))
+    const quiet = process.env.SINTBOT_INSTALLER === '1' // install.sh 调起:只报结果一行,细节留给 sintbot service status
     const tools = ['claude', 'codex'].map((n) => whichSync(n)).filter(Boolean)
     const node = svc.stableNodeBin({ execPath: process.execPath, candidates: [whichSync('node')] })
     const sbotBin = path.resolve(__dirname, 'sbot.js')
@@ -1306,20 +1322,23 @@ async function cmdService(rest) {
     })
     if (node.warn) process.stderr.write(yellow('⚠ ' + node.warn) + '\n')
     if (svc.versionedPath(sbotBin)) process.stderr.write(yellow(`⚠ sbot 装在带版本号的 node 目录下(${sbotBin}),换 node 版本后要重装 sintbot 并重跑 sintbot service install`) + '\n')
-    if (inShell.length && !passEnv) process.stderr.write(yellow(`⚠ 配置引用的环境变量 ${inShell.join(' ')} 只在当前终端里有,服务里拿不到 —— 加 --pass-env 把值写进服务定义(文件权限 600),或把值直接写进配置(配置本身是 600)`) + '\n')
-    else if (proxyVars.length && !passEnv) process.stderr.write(dim(tr(`  终端里的代理(${proxyVars.join(' ')})没带进服务;服务里要用代理,在控制台「设置 → 机器人与网络」填`, `  Your terminal's proxy (${proxyVars.join(' ')}) was not carried into the service; to use a proxy there, set it in the console under Settings → Bot & network`)) + '\n')
-    if (noPlatform) process.stderr.write(dim(tr('  还没接聊天平台:服务先只开控制台,在「设置」里接好平台后会自动重启并连上', 'No chat platform yet: the service starts with just the console; once you connect one under Settings it restarts itself and connects')) + '\n')
+    if (noPlatform && !quiet) process.stderr.write(dim(tr('  还没接聊天平台:服务先只开控制台,在「设置」里接好平台后会自动重启并连上', 'No chat platform yet: the service starts with just the console; once you connect one under Settings it restarts itself and connects')) + '\n')
     if (nowhere.length) process.stderr.write(yellow(`⚠ 配置引用的环境变量 ${nowhere.join(' ')} 当前终端里也没有 —— 用到它们的模型 / 平台不会工作`) + '\n')
     if (platform !== 'darwin' && platform !== 'linux') { process.stdout.write(svc.windowsHint(spec) + '\n'); return }
     if (!tools.length) process.stderr.write(yellow('⚠ PATH 里没找到 claude / codex —— 服务能起,但群里的轮次会失败;装好后重跑 sintbot service install') + '\n')
-    if (values['dry-run']) { // 打印时遮掉 --pass-env 带进来的值(多半是 key)
+    if (values['dry-run']) { // 打印时遮掉带进服务的值(多半是 key)
       const shown = { ...spec, env: Object.fromEntries(Object.keys(spec.env).map((k) => [k, '<已隐藏>'])) }
       process.stdout.write(dim(`# ${svc.unitPath(platform, home)}`) + '\n' + svc.render(platform, shown)); return
     }
     const r = svc.install(spec, { platform, home })
+    if (quiet) { // 安装脚本里:成功只一行;失败照常把每一步列出来
+      await new Promise((res) => setTimeout(res, 1500))
+      const st = svc.status({ platform, home })
+      if (st.running && r.steps.every((s) => s.ok)) { process.stderr.write(`  ${cyan('✓')} ${tr('后台服务已启动', 'Background service started')}\n`); return }
+    }
     process.stderr.write(cyan('✓ ') + tr(`已写入 ${r.file}`, `Wrote ${r.file}`) + (r.backup ? dim(tr(`(原文件备份为 ${path.basename(r.backup)})`, ` (previous file backed up as ${path.basename(r.backup)})`)) : '') + '\n')
     for (const s of r.steps) process.stderr.write(`${s.ok ? cyan('✓') : red('✗')} ${dim(s.cmd)}${s.err && !s.ok ? '  ' + red(s.err.split('\n')[0]) : ''}\n`)
-    await new Promise((res) => setTimeout(res, 1500))
+    if (!quiet) await new Promise((res) => setTimeout(res, 1500))
     process.stderr.write(`${tr('状态', 'Status')}:${nice(svc.status({ platform, home }))}\n` + dim(`${tr('配置', 'Config')}:${spec.args[spec.args.indexOf('--config') + 1]}\n${tr('日志', 'Log')}:${spec.errLog}\n`))
     if (platform === 'linux') process.stderr.write(dim('提示:要开机就起(不必先登录),跑一次 loginctl enable-linger $USER') + '\n')
     if (r.steps.some((s) => !s.ok)) process.exit(1)
@@ -1365,11 +1384,11 @@ async function cmdSetup(rest) {
   let seeded = false
   if (fs.existsSync(cfgPath)) {
     try { raw = JSON.parse(fs.readFileSync(cfgPath, 'utf8')) } catch (e) { return die(`existing config is invalid JSON: ${e.message}`) }
-    process.stdout.write(dim(T(`更新已有配置 ${cfgPath}`, `Updating the existing config ${cfgPath}`)) + '\n')
+    if (!fromInstaller) process.stdout.write(dim(T(`更新已有配置 ${cfgPath}`, `Updating the existing config ${cfgPath}`)) + '\n')
   } else if (fs.existsSync(examplePath)) {
     raw = JSON.parse(fs.readFileSync(examplePath, 'utf8'))
     seeded = true
-    process.stdout.write(dim(T(`新建配置,问完再写入 ${cfgPath}`, `New config; it is written to ${cfgPath} at the end`)) + '\n')
+    if (!fromInstaller) process.stdout.write(dim(T(`新建配置,问完再写入 ${cfgPath}`, `New config; it is written to ${cfgPath} at the end`)) + '\n')
   } else {
     // claude 不钉 model(v0.11.1):写死会覆盖 CLI 自己的默认,每出一代新模型就落后一代(v0.11.0 拍板)
     raw = { agent: { bin: 'claude', permissionMode: 'dontAsk', maxTurnTimeMins: 10, maxConcurrent: 2 }, defaultProvider: 'claude', providers: { claude: {} }, groups: {} }
@@ -1430,7 +1449,7 @@ async function cmdSetup(rest) {
   try {
     // 安装脚本调起时它自己已经说过「这里只配模型」,不再重复
     const scope = fromInstaller ? T('(Enter 用默认值)', ' (Enter accepts the default)') : T('配模型(聊天平台、代理、项目目录装完在控制台里配;Enter 用默认值)', ' model setup (chat platform, proxy and project folder are set in the console afterwards; Enter accepts the default)')
-    process.stdout.write('\n' + cyan('sintbot setup') + dim(full ? ' — 完整配置(Enter 用默认值)' : fromInstaller ? scope : T(' — ' + scope, ' —' + scope)) + '\n\n')
+    if (!fromInstaller) process.stdout.write('\n' + cyan('sintbot setup') + dim(full ? ' — 完整配置(Enter 用默认值)' : T(' — ' + scope, ' —' + scope)) + '\n\n')
 
     // 第 0 步:环境检查 —— 只报不拦(缺了照样能把配置写完,最后的体检会接着报)。
     // 缺 claude / codex 时问一句替新用户装(npm i -g;官方源连不上自动换国内镜像,见 src/installdeps.js)。
@@ -1455,8 +1474,8 @@ async function cmdSetup(rest) {
     if (claudeBin) process.stdout.write(`  ${cyan('✓')} claude ${dim(claudeBin)}\n`)
     else {
       process.stdout.write(`  ${red('✗')} ${T('没找到 claude(Claude Code CLI)—— 每一轮都靠它干活', 'claude (Claude Code CLI) not found; every turn runs on it')}\n`)
-      // 没人回答(输入已结束)就不替他装软件
-      if (await askYN(T(`现在安装 Claude Code(npm i -g ${installdeps.PACKAGES.claude})?`, `Install Claude Code now (npm i -g ${installdeps.PACKAGES.claude})?`), true, false)) claudeBin = installDep('claude', claudeName)
+      // 必需组件:终端里直接装,不问(1.0.13,用户定「安装要精简」);不在终端里(管道、CI)不替他装
+      if (process.stdin.isTTY) claudeBin = installDep('claude', claudeName)
       else process.stdout.write(dim(T(`  稍后自己装:npm i -g ${installdeps.PACKAGES.claude}`, `  Install it later: npm i -g ${installdeps.PACKAGES.claude}`)) + '\n')
     }
     // Claude 登录态留到模型步一起报,那里据此决定推荐走哪条路。官方非交互子命令,0.2s、不联网;
@@ -1470,9 +1489,8 @@ async function cmdSetup(rest) {
     let codexBin = whichSync('codex')
     let codexLoggedIn = false
     if (!codexBin) {
-      process.stdout.write(`  ${gray('○')} ${T('没找到 codex(可选:有 ChatGPT 账号时跑 GPT 群、生图)', 'codex not found (optional: with a ChatGPT account it runs GPT groups and image generation)')}\n`)
-      if (await askYN(T(`现在安装 Codex CLI(npm i -g ${installdeps.PACKAGES.codex})?有 ChatGPT 账号才用得上`, `Install Codex CLI now (npm i -g ${installdeps.PACKAGES.codex})? Only useful with a ChatGPT account`), false)) codexBin = installDep('codex', 'codex')
-      else process.stdout.write(dim(T(`  要用时再装:npm i -g ${installdeps.PACKAGES.codex},再 codex login`, `  When you need it: npm i -g ${installdeps.PACKAGES.codex}, then codex login`)) + '\n')
+      // 可选组件不问,一行给装法
+      process.stdout.write(`  ${gray('○')} ${T(`codex 没装(可选,有 ChatGPT 账号时用):npm i -g ${installdeps.PACKAGES.codex},再 codex login`, `codex not installed (optional, for a ChatGPT account): npm i -g ${installdeps.PACKAGES.codex}, then codex login`)}\n`)
     }
     if (codexBin) {
       // 只读本机登录态(不联网);没登录时,GPT 群、生图、claude 额度用完自动切到 codex 都不会成
@@ -1481,31 +1499,19 @@ async function cmdSetup(rest) {
       codexLoggedIn = !!(codexLogin && codexLogin.ok && codexLogin.loggedIn)
       process.stdout.write(`  ${cyan('✓')} codex ${dim(codexBin)}${codexOut ? '  ' + yellow(T('没登录 —— GPT 群、生图、额度用完时自动切到 codex 都要它:跑一次 codex login', 'not logged in; GPT groups, image generation and switching to codex when quota runs out all need it: run codex login')) : ''}\n`)
     }
-    // 设计图标库(Lucide / Tabler / Phosphor / Pixelarticons):agent 出设计图时按名字取图标,缺了只能自己画、
-    // 与设计图对不上。缺哪套问一句一次装齐(默认装);没人回答(输入已结束)不装,doctor 会接着提示
+    // 设计图标库(Lucide / Tabler / Phosphor / Pixelarticons):agent 出设计图时按名字取图标,缺了只能自己画。
+    // 可选组件,不问(1.0.13 起;1.0.11–1.0.12 问一句代装):缺了给一行装法,doctor 也会接着提示
     {
-      const iconRoots = () => design.iconRoots({ base: path.join(__dirname, '..'), extra: (raw.design && raw.design.iconsDir) || null })
-      const missing = () => Object.entries(iconRoots()).filter(([, v]) => !v).map(([k]) => k)
-      const miss = missing()
-      if (!miss.length) process.stdout.write(`  ${cyan('✓')} ${T('设计图标库', 'Design icon libraries')} ${dim(Object.values(design.ICON_LIBS).map((l) => l.label).join(' · '))}\n`)
+      const roots = design.iconRoots({ base: path.join(__dirname, '..'), extra: (raw.design && raw.design.iconsDir) || null })
+      const libs = Object.entries(roots).filter(([, v]) => !v).map(([k]) => design.ICON_LIBS[k])
+      if (!libs.length) process.stdout.write(`  ${cyan('✓')} ${T('设计图标库', 'Design icon libraries')} ${dim(Object.values(design.ICON_LIBS).map((l) => l.label).join(' · '))}\n`)
       else {
-        const libs = miss.map((k) => design.ICON_LIBS[k])
-        const pkgs = libs.map((l) => l.pkg)
+        const pkgs = libs.map((l) => l.pkg).join(' ')
         const mb = Math.round(libs.reduce((n, l) => n + (l.mb || 0), 0))
-        process.stdout.write(`  ${gray('○')} ${T(`设计图标库缺 ${libs.map((l) => l.label).join(' / ')}(出设计图时 agent 按名字取图标)`, `Design icon libraries missing: ${libs.map((l) => l.label).join(' / ')} (the agent picks icons by name when drawing designs)`)}\n`)
-        if (await askYN(T(`现在安装(npm i -g ${pkgs.join(' ')},约 ${mb} MB)?`, `Install them now (npm i -g ${pkgs.join(' ')}, about ${mb} MB)?`), true, false)) {
-          const r = installdeps.installPackages(pkgs, { log: (l) => process.stdout.write(dim('  ' + l) + '\n') })
-          const still = missing()
-          if (r.ok && !still.length) process.stdout.write(`  ${cyan('✓')} ${T('设计图标库已装', 'Design icon libraries installed')}\n`)
-          else if (r.ok) {
-            const pre = installdeps.globalPrefix()
-            const dir = pre ? (process.platform === 'win32' ? path.join(pre, 'node_modules') : path.join(pre, 'lib', 'node_modules')) : 'npm 全局目录下的 node_modules'
-            process.stdout.write(`  ${yellow('!')} ${T(`装好了,但 sbot 找不到 ${still.join(' / ')} —— 在配置里把 design.iconsDir 设成 ${dir}`, `Installed, but sbot cannot find ${still.join(' / ')}; set design.iconsDir to ${dir} in the config`)}\n`)
-          } else process.stdout.write(`  ${red('✗')} ${T(`安装失败(退出码 ${r.code})—— 多半是 npm 全局目录没有写权限,之后可以自己装:npm i -g ${pkgs.join(' ')}`, `Install failed (exit code ${r.code}), most likely the npm global folder is not writable; install them later: npm i -g ${pkgs.join(' ')}`)}\n`)
-        } else process.stdout.write(dim(T(`  要用时再装:npm i -g ${pkgs.join(' ')}`, `  When you need them: npm i -g ${pkgs.join(' ')}`)) + '\n')
+        process.stdout.write(`  ${gray('○')} ${T(`设计图标库没装(可选,出设计图时用;约 ${mb} MB):npm i -g ${pkgs}`, `Design icon libraries not installed (optional, used for designs; about ${mb} MB): npm i -g ${pkgs}`)}\n`)
       }
     }
-    process.stdout.write(dim(T(`  配置文件:${cfgPath}`, `  Config file: ${cfgPath}`)) + '\n\n')
+    process.stdout.write('\n')
 
     // 不问「在不在中国大陆」(隐私,用户 10-28 定):只按时区猜,决定有国际站的厂商先试哪个站、--full 里推荐哪个平台;不写进配置
     const mainland = setupmodels.looksMainland()
@@ -1608,14 +1614,8 @@ async function cmdSetup(rest) {
     process.stdout.write(`  ${col('ChatGPT(Codex)', 'ChatGPT (Codex)')} ${codexReady() ? cyan(T('✓ 已登录', '✓ logged in')) : gray(codexBin ? T('○ 未登录', '○ not logged in') : T('○ 没装 codex', '○ codex not installed'))}\n`)
     if (readyKeyed().length) process.stdout.write(`  ${col('API key 模型', 'API key models')} ${cyan('✓')} ${readyKeyed().join(' ')}\n`)
     let route = setupmodels.subscriptionRoute({ claudeLoggedIn, codexLoggedIn: codexReady() })
-    if (route || readyKeyed().length) {
-      // 已经有能用的:不打扰,只问要不要再加一个(群里 /model 可切)
-      if (await askYN(T('再加一个用 API key 的模型吗?(DeepSeek 等,群里 /model 可切换)', 'Add another model that uses an API key? (DeepSeek etc.; switch in a group with /model)'), false)) {
-        process.stdout.write(`    1) DeepSeek ${dim(T('(推荐,按量付费)', '(recommended, pay as you go)'))}\n    2) ${T('其他:智谱 GLM / MiniMax / 火山方舟', 'Others: Zhipu GLM / MiniMax / Volcano Ark')}\n`)
-        if ((await ask(T('选', 'Choose'), '1')) === '2') await pickOthers()
-        else await configureKeyed(setupmodels.RECOMMENDED)
-      }
-    } else {
+    // 已经有能用的就不再问(1.0.13 起不问「再加一个」:加模型在控制台「模型 · 库」)
+    if (!route && !readyKeyed().length) {
       process.stdout.write('\n  ' + T('没检测到 Claude 订阅或 Codex 登录。', 'No Claude subscription or Codex login found. ') + cyan(T('推荐用 DeepSeek', 'DeepSeek is recommended')) + T(':注册充值就能用、按量付费,不需要 Claude 账号。', ': sign up, top up and go, pay as you go, no Claude account needed.') + '\n')
       for (;;) {
         process.stdout.write(`    1) ${T('用 DeepSeek', 'DeepSeek')} ${dim(T('(推荐)', '(recommended)'))}${T('—— 粘贴 API key', ': paste an API key')}\n`
@@ -1672,20 +1672,14 @@ async function cmdSetup(rest) {
     const okKeyed = readyKeyed().filter((n) => !tried.has(n) || verified.includes(n))
     const auto = route || verified[0] || (okKeyed.includes(setupmodels.RECOMMENDED) ? setupmodels.RECOMMENDED : okKeyed[0]) || readyKeyed()[0] || raw.defaultProvider || 'claude'
     const suggest = !seeded && raw.defaultProvider && usable(raw.defaultProvider) ? raw.defaultProvider : auto
+    // 默认模型与试跑都不问(1.0.13,用户定「安装要精简」):按上面的顺序自动选,还没试跑过就直接试一轮;群里 /model 随时换
+    raw.defaultProvider = suggest
     const usableNames = Object.keys(raw.providers).filter(usable)
-    if (usableNames.length > 1) {
-      const def = await ask(T(`默认模型(${usableNames.join('/')};群里 /model 随时切)`, `Default model (${usableNames.join('/')}; switch any time in a group with /model)`), suggest)
-      raw.defaultProvider = raw.providers[def] ? def : suggest
-      if (!raw.providers[def]) process.stdout.write(red(T(`  没有叫 '${def}' 的模型,用 ${suggest}`, `  There is no model called '${def}'; using ${suggest}`)) + '\n')
-    } else {
-      raw.defaultProvider = suggest
-      if (usableNames.length) process.stdout.write(dim(T(`  默认模型:${suggest}`, `  Default model: ${suggest}`)) + '\n')
-    }
-    // 默认模型还没在本次跑通过(订阅登录那条路):问一句当场试跑
+    if (usableNames.length) process.stdout.write(dim(T(`  默认模型:${suggest}${usableNames.length > 1 ? '(群里 /model 可换)' : ''}`, `  Default model: ${suggest}${usableNames.length > 1 ? ' (switch in a group with /model)' : ''}`)) + '\n')
     const dp = raw.defaultProvider
     const canTry = raw.providers[dp] && usable(dp) && (raw.providers[dp].runner === 'codex' ? codexBin : claudeBin)
-    if (canTry && !tried.has(dp) && await askYN(T(`用 ${dp} 试跑一轮,确认能用?`, `Do a test run with ${dp} to make sure it works?`), true)) {
-      process.stdout.write(dim(T('  试跑中…', '  Running…')) + '\n')
+    if (canTry && !tried.has(dp)) {
+      process.stdout.write(dim(T(`  用 ${dp} 试跑一轮…`, `  Test run with ${dp}…`)) + '\n')
       const r = await tryTurn(dp)
       if (r.ok) { reportTurn(dp, r); verified.push(dp) }
       else process.stdout.write(`  ${red('✗')} ${setupmodels.explainTestFailure(r.text, { baseUrl: raw.providers[dp].baseUrl, lang }).text}\n`)
@@ -1943,23 +1937,22 @@ async function cmdSetup(rest) {
     // 新装时「没接平台 / 没绑群 / Claude 没登录」都是正常状态,整屏警告看着像出错:只报失败项,完整体检留给 sintbot doctor
     const { rows } = await checkHealth(cfg)
     const failed = rows.filter((r) => r.status === 'fail')
-    if (failed.length) for (const r of failed) process.stdout.write(`${red('✗')} ${r.label.padEnd(22)} ${gray(r.detail)}\n`)
-    else process.stdout.write(cyan('✓ ') + T('体检没有失败项', 'Health check: nothing failed') + '\n')
-    process.stdout.write(dim(T(`  完整体检:sintbot doctor${cfgArg}`, `  Full check: sintbot doctor${cfgArg}`)) + '\n')
+    if (failed.length) {
+      for (const r of failed) process.stdout.write(`${red('✗')} ${r.label.padEnd(22)} ${gray(r.detail)}\n`)
+      process.stdout.write(dim(T(`  完整体检:sintbot doctor${cfgArg}`, `  Full check: sintbot doctor${cfgArg}`)) + '\n')
+    } else process.stdout.write(cyan('✓ ') + T('体检通过', 'Health check passed') + dim(T(`(完整:sintbot doctor${cfgArg})`, ` (full: sintbot doctor${cfgArg})`)) + '\n')
   }
   if (!((cfg.providers || {})[cfg.defaultProvider] || {}).baseUrl) {
     process.stdout.write('\n' + yellow(T('⚠ 订阅条款:', '⚠ Subscription terms: ')) + T('用个人的 Claude / ChatGPT 订阅登录来服务多人群聊,可能不符合提供方的使用条款;团队使用请改用 API key 或企业账号,并自行确认合规。', 'serving a multi-person group chat from a personal Claude / ChatGPT subscription may break the provider\'s terms; for team use switch to an API key or a business account and check compliance yourself.') + '\n')
   }
   if (fromInstaller) return // 后台服务、控制台地址、接下来去哪:install.sh 结尾统一给
-  // 终端里有代理、配置里没有:只给建议(服务进程拿不到终端的环境变量)
-  const shellProxy = !(raw.proxy && raw.proxy.http) && require('../src/core/proxy').proxyDescribe(process.env) // 带认证的只说「带认证」,不打印账号密码
   const plat = platformsConfigured(cfg)
   const noPlatform = !plat.feishu && !plat.wecom && !plat.slack
   process.stdout.write('\n' + gray(T('— 下一步 —', '— Next —')) + '\n'
     + `  sintbot service install${cfgArg}   ${dim(T('装成后台服务,控制台常开在 http://127.0.0.1:4600(登录后自启,崩溃自动拉起)', 'install the background service; the console stays at http://127.0.0.1:4600 (starts at login, restarts on crash)'))}\n`
     + `  sintbot ui${cfgArg}                ${dim(noPlatform ? T('现在就打开控制台:在「设置」里接飞书 / Slack / 企业微信,在「群 · 项目」里绑群', 'open the console now: connect Slack, Feishu or WeCom under Settings, bind a group under Groups') : T('打开控制台:绑群、切模型、看实时活动', 'open the console: bind groups, switch models, watch live activity'))}\n`
     + `  sintbot chat${cfgArg}              ${dim(T('不接平台也能先在终端里和它聊几句', 'chat with it in the terminal first, no platform needed'))}\n`
-    + (shellProxy ? '\n' + dim(T(`  建议:终端里设了代理(${shellProxy}),后台服务拿不到;装服务时会问要不要带进去,也可以在控制台「设置 → 机器人与网络」填。`, `  Tip: your terminal uses a proxy (${shellProxy}) that the background service can't see; service install offers to carry it over, or set it in the console under Settings → Bot & network.`)) + '\n' : ''))
+    )
 }
 
 // 能不能在这台机器上弹浏览器:SSH 进来的会话弹到的是对方屏幕(或根本没有屏幕),Linux 没有图形界面也不弹 —— 只打印地址
@@ -2003,7 +1996,7 @@ async function cmdUi(rest) {
 
   applyProxyEnv(cfg)
   const port = Number(values.port) || 4600
-  const host = values.host || '127.0.0.1'
+  const host = values.host || (cfg.ui && cfg.ui.host) || '127.0.0.1'
   const loopback = isLoopbackHost(host)
   // Fail-closed: never expose the operator console to the LAN without a password.
   if (!loopback) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sintbot",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "Drive headless Claude Code (or Codex) from Slack / Feishu / WeCom group chats — one group, one project, swappable model brain. A standalone daemon, not a Claude Code plugin.",
   "bin": {
     "sbot": "bin/sbot.js",

package/src/service.js

@@ -20,7 +20,7 @@
 const fs = require('node:fs')
 const os = require('node:os')
 const path = require('node:path')
-const { execFileSync } = require('node:child_process')
+const { execFileSync, execFile } = require('node:child_process')
 
 const LABEL = 'com.sbot.daemon'      // launchd 标签(与早期手写 plist 同名 ⇒ 装新版直接替换旧的)
 const UNIT = 'sbot.service'          // systemd --user 单元名
@@ -176,6 +176,35 @@ function run(bin, args, opts = {}) {
 
 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)
@@ -197,7 +226,7 @@ function status({ platform = process.platform, home = os.homedir() } = {}) {
 }
 
 // 写单元文件(已有且内容不同 ⇒ 先备份)并加载。返回 { file, backup, steps: [{cmd, ok, err}] }
-function install(spec, { platform = process.platform, home = os.homedir() } = {}) {
+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)
@@ -212,10 +241,38 @@ function install(spec, { platform = process.platform, home = os.homedir() } = {}
   // 单元文件里写了环境变量的值(多半是 key)⇒ 只给自己读写;没写就是普通权限
   if (Object.keys(spec.env || {}).length) fs.chmodSync(file, 0o600)
   const steps = []
-  const step = (bin, args, tolerate) => { const r = run(bin, args); steps.push({ cmd: [bin, ...args].join(' '), ok: r.ok || !!tolerate, err: r.ok ? '' : r.err }); return r }
+  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') {
-    step('launchctl', ['bootout', `gui/${uid()}/${LABEL}`], true) // 没加载过会报错,忽略
-    step('launchctl', ['bootstrap', `gui/${uid()}`, file])
+    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])
@@ -230,6 +287,19 @@ function restart({ platform = process.platform } = {}) {
   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 = []
@@ -244,4 +314,4 @@ function uninstall({ platform = process.platform, home = os.homedir() } = {}) {
   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, uninstall }
+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/console.html

@@ -1164,6 +1164,7 @@ function inboxHtml(){
       `<a class="iconbtn sm" href="/browser" target="_blank" rel="noopener" title="打开接管页" style="flex:none">${IC.ext}</a>`,
       (it.pageTitle||it.pageUrl)?full(esc(it.pageTitle||it.pageUrl)):'');
     if(it.kind==='issues')return line('反馈','--warn',`${it.count} 条反馈待处理`,go('ovIssues','滚到反馈本'));
+    if(it.kind==='update')return line('更新','--ember',`发现新版 v${esc(it.to)}`,go('updateCard','打开版本更新'));
     if(it.kind==='leftovers')return line('进程','--warn',`${it.count} 个后台进程还在跑`,go('ovLeftovers','滚到后台进程'));
     if(it.kind==='preview')return line('预览','--fail','预览在服务整个项目目录',go('ovPreviews','滚到预览服务'));
     // 每个检查项单独一个节点:英文界面按整段文字逐个翻译
@@ -1175,7 +1176,7 @@ function inboxHtml(){
     <div class="card ovgroups" style="margin-bottom:22px">${items.map(row).join('')}</div>`;
 }
 function bindInbox(){
-  $$('#overview [data-ibgo]').forEach(b=>b.onclick=()=>{const el=$('#'+b.dataset.ibgo);if(el)el.scrollIntoView({behavior:'smooth',block:'start'});});
+  $$('#overview [data-ibgo]').forEach(b=>b.onclick=()=>{if(b.dataset.ibgo==='updateCard'){$$('nav button').forEach(x=>x.classList.toggle('active',x.dataset.tab==='settings'));$$('.tab').forEach(t=>t.classList.toggle('on',t.id==='settings'));}const el=$('#'+b.dataset.ibgo);if(el)requestAnimationFrame(()=>el.scrollIntoView({behavior:'smooth',block:'start'}));});
   $$('#overview [data-ibdis]').forEach(b=>b.onclick=async()=>{
     try{const r=await api('/api/inbox/dismiss','POST',{key:b.dataset.ibdis});S.inbox=r.inbox||[];paintInbox();toast('已忽略','ok');}catch(e){toast(e.message,'err');}});
 }
@@ -3215,6 +3216,7 @@ async function pgSend(){
 /* ── settings ── */
 function renderSettings(){
   const a=S.agent,fe=S.feishu,px=S.proxy,net=S.net||{};
+  const upd=S.update||null;
   // 项目根目录:控制台**只读**(产品决定 —— 它是围栏的策略,登上控制台就能改等于围栏只剩一次点击)。
   // 这里只把现状说清:每条根在不在、配置里被忽略的值、哪些群在根外;改要走安装向导或机器上的配置文件。
   const pri=S.projectsRootsInfo||{roots:[],dropped:[],outside:[],configured:null,fromConfig:false};
@@ -3235,6 +3237,14 @@ function renderSettings(){
     <div class="hint" style="margin-top:9px">${net.lan
       ?`<b style="color:var(--risk)">已对局域网开放</b> · ${net.authOn?'需密码':'<b style="color:var(--fail)">未设密码(异常)</b>'} · HTTP 明文,仅可信网络用(最稳走 SSH 隧道)。`
       :'仅本机可访问 · 要对外开放:先设访问密码,再把绑定地址改为 0.0.0.0。'}</div>
+    <div class="inline" style="gap:14px;margin-top:13px;flex-wrap:wrap">
+      <label class="inline" style="gap:6px;cursor:pointer"><input type="checkbox" id="netLan" ${net.lan?'checked':''} style="width:auto"/> <span class="dim">局域网访问</span></label>
+      <label class="inline" style="gap:6px;cursor:pointer"><input type="checkbox" id="netPublic" ${net.publicEnabled?'checked':''} style="width:auto"/> <span class="dim">公网飞书登录</span></label>
+    </div>
+    ${!net.authOn?`<div class="field" style="margin:10px 0 0;max-width:320px"><label class="f">访问密码</label><input id="netPass" type="password" autocomplete="new-password" placeholder="局域网开启时设置,至少 6 位"/><div class="hint" style="margin-top:4px">只保存 scrypt 哈希;开启局域网前必填</div></div>`:''}
+    <div class="hint" style="margin-top:7px">${net.publicEnabled?(net.publicReady?'公网登录已启用':'公网登录待配置'): '公网登录已关闭'}${!net.publicReady&&net.feishuLogin&&net.feishuLogin.why?` · ${esc(net.feishuLogin.why)}`:''} · 开关只控制本程序入口,不会改动反向代理或隧道。</div>
+    <button class="btn primary" id="netSave" style="margin-top:12px">保存访问设置</button>
+    <div class="hint" style="margin-top:7px">局域网监听按当前端口即时切换;关闭后只允许本机访问。系统防火墙可能仍会拦截。</div>
     ${INJECTED_TOKEN?'':'<div style="margin-top:10px;display:flex;gap:8px;flex-wrap:wrap"><button class="btn" id="logoutBtn" title="作废这次登录;其它设备上的登录不受影响">退出登录</button><button class="btn" id="logoutAllBtn" title="作废这台机器签发过的全部登录(所有设备都要重新登录),手机丢了用这个">退出所有设备</button></div>'}
     ${prSection}
   </div>`;
@@ -3262,6 +3272,23 @@ function renderSettings(){
   </div>`;
   const verhistCard=`<div class="card" style="grid-column:1/-1" id="verhistCard"><div class="lbl">版本历史</div>
     <div id="verhistBox"><div class="empty">加载中…</div></div></div>`;
+  const updateJob=upd&&upd.job;
+  const updateBusy=!!(updateJob&&['queued','installing','restarting','restart-needed'].includes(updateJob.state));
+  const updateText=!upd?'后台版本检查不可用':updateJob?esc(updateJob.message||updateJob.state):upd.available?`检测到新版本 v${esc(upd.latestVersion)} · 当前 v${esc(upd.currentVersion)}`:upd.checkedAt?`当前为最新版本 v${esc(upd.currentVersion)}`:'尚未检查新版';
+  const updateCard=`<div class="card" style="grid-column:1/-1" id="updateCard"><div class="lbl">软件更新</div>
+    <div id="updateStatus" class="hint" style="margin:0 0 12px;color:var(--ink)">${updateText}</div>
+    ${upd&&upd.available?`<div class="hint" style="margin:-4px 0 12px">版本差异与发布说明：<a href="https://github.com/sintlab/sintbot/releases/tag/v${encodeURIComponent(upd.latestVersion)}" target="_blank" rel="noopener" style="color:var(--ember-soft)">查看 v${esc(upd.latestVersion)} 发布说明</a></div>`:''}
+    <div class="inline" style="gap:14px;flex-wrap:wrap;margin-bottom:12px">
+      <span class="dim">自动检查稳定版(启动时及每天)</span>
+      <label class="inline" style="gap:6px;cursor:pointer"><input type="checkbox" id="updAnnounce" ${upd&&upd.announce!==false?'checked':''} style="width:auto"/> <span class="dim">升级后向群里播报(记住选择)</span></label>
+    </div>
+    <div class="inline" style="gap:8px;flex-wrap:wrap">
+      <button class="btn" id="updCheck" ${!upd?'disabled':''}>检查新版</button>
+      <button class="btn primary" id="updInstall" ${!upd||!upd.available||updateBusy?'disabled':''}>现在升级</button>
+      <button class="btn" id="updIgnore" ${!upd||!upd.available?'disabled':''}>忽略此版本</button>
+    </div>
+    <div class="hint" style="margin-top:10px">只安装检测到的稳定版本;所有群任务与队列清空后才会安装。需要可写的全局安装目录,不会提权;后台服务会自动重启,前台运行需手动重启。</div>
+  </div>`;
   $('#settings').innerHTML=`<div class="grid cols2 stagger">
     ${netCard}
     <div class="card"><div class="lbl">运行限制</div>
@@ -3284,6 +3311,7 @@ function renderSettings(){
     ${fxFeishuCard(fe)}
     ${fxSlackCard(S.slack||null)}
     ${fxWecomCard(S.wecom||null)}
+    ${updateCard}
     ${aboutCard}
     ${verhistCard}
   </div>`;
@@ -3291,6 +3319,33 @@ function renderSettings(){
   $('#bSave').onclick=async()=>{const brand=$('#bBrand').value.trim(),http=$('#pxHttp').value.trim();
     if(http&&!/^https?:\/\/\S+$/i.test(http)){toast('代理地址要像 http://127.0.0.1:7890','err');return;}
     try{await api('/api/agent','POST',{brand});S=await api('/api/proxy','POST',{enabled:!!http,http});toast('已保存','ok');renderSettings();}catch(e){toast(e.message,'err');}};
+  $('#netSave').onclick=async()=>{
+    const lanEnabled=$('#netLan').checked,publicEnabled=$('#netPublic').checked;
+    const patch={lanEnabled,publicEnabled};
+    const pw=$('#netPass');if(pw&&pw.value)patch.password=pw.value;
+    if(lanEnabled&&!net.lan&&!net.authOn&&(!patch.password||patch.password.length<6)){toast('开启局域网访问前要设置至少 6 位访问密码','err');return;}
+    if(lanEnabled!==!!net.lan&&!confirm(lanEnabled?'开启后,同一可信局域网内可访问登录页;继续?':'关闭后,远程设备将无法访问控制台;继续?'))return;
+    if(publicEnabled!==!!net.publicEnabled&&!confirm(publicEnabled?'启用公网飞书登录入口?这不会修改反向代理或隧道。':'关闭公网入口并让现有飞书登录退出?'))return;
+    const b=$('#netSave');b.disabled=true;
+    try{const r=await api('/api/ui/network','POST',patch);
+      if(r.rebinding){toast('访问地址正在切换;页面即将重载','ok');setTimeout(()=>location.reload(),1200);return;}
+      S=r;toast('访问设置已保存','ok');renderSettings();
+    }catch(e){toast(e.message,'err');b.disabled=false;}
+  };
+  const saveUpdatePrefs=async(patch)=>{try{S=await api('/api/ui/update-settings','POST',patch);renderSettings();}catch(e){toast(e.message,'err');}};
+  $('#updAnnounce').onchange=()=>saveUpdatePrefs({announce:$('#updAnnounce').checked});
+  $('#updCheck').onclick=async()=>{const b=$('#updCheck');b.disabled=true;b.textContent='检查中…';
+    try{await api('/api/update/check','POST',{});S=await api('/api/state');await refreshInbox();renderSettings();renderOverview();toast('版本检查完成','ok');}
+    catch(e){toast(e.message,'err');b.disabled=false;b.textContent='检查新版';}};
+  $('#updInstall').onclick=async()=>{const u=S.update||{},version=u.latestVersion;if(!version)return;
+    const announce=$('#updAnnounce').checked;
+    if(!confirm(`将从 v${u.currentVersion} 升级到 v${version}。${announce?'安装完成后会向未暂停的群播报；':'本次不向群播报。'}所有群任务结束后才开始安装，后台服务会重启。继续?`))return;
+    const b=$('#updInstall');b.disabled=true;
+    try{const r=await api('/api/update/start','POST',{version,announce});S.update={...r,announce};await refreshInbox();renderSettings();renderOverview();toast('更新已排队，群任务空闲后开始','ok');}
+    catch(e){toast(e.message,'err');b.disabled=false;}};
+  $('#updIgnore').onclick=async()=>{const version=(S.update||{}).latestVersion;if(!version)return;
+    try{const r=await api('/api/update/ignore','POST',{version});S.update={...r,announce:$('#updAnnounce').checked};await refreshInbox();renderSettings();renderOverview();toast('已忽略此版本','ok');}
+    catch(e){toast(e.message,'err');}};
   // 只开着控制台的守护进程(还没接平台):第一次接上平台时说一句接下来会发生什么(服务托管的会自己重启连上)
   {const pl=S.platforms||{};if(S.setupMode&&(pl.feishu||pl.slack||pl.wecom)&&!window._sbRestartToast){window._sbRestartToast=1;toast(S.setupMode.supervised?'已接上聊天平台 —— 后台服务几秒后自动重启并连上':'已接上聊天平台 —— 在终端里重启 sintbot start --ui 连上','ok');}}
   bindWecomCard();
@@ -4440,6 +4495,38 @@ const I18N_EN=[
   [";改后即时生效,不用重启。","; changes apply immediately, no restart needed."],
   ["公网","Public"],
   ["局域网","LAN"],
+  ["局域网访问","LAN access"],
+  ["公网飞书登录","Public Feishu sign-in"],
+  ["访问密码","Access password"],
+  ["局域网开启时设置,至少 6 位","Set when enabling LAN access; at least 6 characters"],
+  ["只保存 scrypt 哈希;开启局域网前必填","Only a scrypt hash is stored; required before enabling LAN access"],
+  ["公网登录已启用","Public sign-in is enabled"],
+  ["公网登录待配置","Public sign-in needs configuration"],
+  ["公网登录已关闭","Public sign-in is off"],
+  ["保存访问设置","Save access settings"],
+  ["开关只控制本程序入口,不会改动反向代理或隧道。","These switches control this app only; they do not change the reverse proxy or tunnel."],
+  ["局域网监听按当前端口即时切换;关闭后只允许本机访问。系统防火墙可能仍会拦截。","LAN binding changes immediately on the current port; when off, only this machine can connect. The system firewall may still block access."],
+  ["软件更新","Software updates"],
+  ["后台版本检查不可用","Version checks are unavailable in this console"],
+  ["自动检查稳定版(启动时及每天)","Automatically checks for stable releases at startup and daily"],
+  ["升级后向群里播报(记住选择)","Announce upgrades in groups (remember this choice)"],
+  ["检查新版","Check for updates"],
+  ["现在升级","Upgrade now"],
+  ["忽略此版本","Ignore this version"],
+  ["版本差异与发布说明：","Changes and release notes: "],
+  ["尚未检查新版","No version check has run yet"],
+  ["当前为最新版本","This is the latest version"],
+  ["检测到新版本","A new version is available"],
+  ["更新已排队，群任务空闲后开始","Update queued; installation will start when all group tasks are idle"],
+  ["已忽略此版本","This version was ignored"],
+  ["版本检查完成","Version check complete"],
+  ["访问地址正在切换;页面即将重载","Changing the access address; this page will reload"],
+  ["访问设置已保存","Access settings saved"],
+  ["开启局域网访问前要设置至少 6 位访问密码","Set an access password of at least 6 characters before enabling LAN access"],
+  ["开启后,同一可信局域网内可访问登录页;继续?","Enabling lets devices on the trusted LAN reach the sign-in page. Continue?"],
+  ["关闭后,远程设备将无法访问控制台;继续?","Remote devices will lose console access. Continue?"],
+  ["启用公网飞书登录入口?这不会修改反向代理或隧道。","Enable public Feishu sign-in? This will not change the reverse proxy or tunnel."],
+  ["关闭公网入口并让现有飞书登录退出?","Disable public access and sign out existing Feishu sessions?"],
   ["访问地址","Access URLs"],
   ["已对外,未检测到局域网 IPv4","Open to the network, but no LAN IPv4 was detected"],
   ["已对局域网开放","Open on the LAN"],
@@ -5046,6 +5133,18 @@ const I18N_EN_RX=[
   [/^✕ 加载失败:([\s\S]+)$/,"✕ Failed to load: $1"],
   [/^加载失败:([\s\S]+)$/,"Failed to load: $1"],
   [/^登录失败 \(HTTP (\d+)\)$/,"Sign-in failed (HTTP $1)"],
+  [/^检测到新版本 v([\d.]+) · 当前 v([\d.]+)$/,"New version v$1 · current v$2"],
+  [/^当前为最新版本 v([\d.]+)$/,"v$1 is the latest version"],
+  [/^等待所有群任务结束后更新$/,"Waiting for all group tasks to finish"],
+  [/^正在检查安装位置并安装指定版本$/,"Checking the install location and installing the selected version"],
+  [/^已安装，正在重启后台服务$/,"Installed; restarting the background service"],
+  [/^已安装新版；后台服务未能自动重启，请手动重启$/,"The new version is installed, but the background service did not restart; restart it manually"],
+  [/^已安装新版；当前不是受托管服务，请手动重启 SintBot$/,"The new version is installed; restart SintBot manually"],
+  [/^更新完成并已重启$/,"Update completed and restarted"],
+  [/^更新后未能自动重启，请手动重启服务$/,"The update could not restart automatically; restart the service manually"],
+  [/^等待群任务结束超时；可在任务空闲后重新发起$/,"Timed out waiting for group tasks; retry when they are idle"],
+  [/^当前运行的是开发目录或非全局副本；请在终端手动更新$/,"This is a development or non-global install; update it from a terminal"],
+  [/^将从 v([\d.]+) 升级到 v([\d.]+)。([\s\S]*)$/,(a,from,to,what)=>`Upgrade from v${from} to v${to}. ${what.replace('所有群任务结束后才开始安装，后台服务会重启。','Installation waits until all group tasks finish, then restarts the background service.').replace('本次不向群播报。','This update will not be announced in groups.').replace('安装完成后会向未暂停的群播报；','After installation, it will be announced in active groups;')}`],
 ];
 /* I18N_DICT_END */
 

package/src/ui/dashboard.js

@@ -101,8 +101,11 @@ function failedTurns(rows, now) {
 //   leftovers  残留的后台进程(同上)
 //   preview    服务整个项目目录的预览(全部代码都在局域网上可读)
 //   health     健康检查没通过的项(一行汇总,排最前:它是「现在就坏着」,没有发生时刻可排)
-function buildInbox({ ledgerRows = [], issues = null, previews = [], leftovers = null, health = null, takeovers = [], groups = {}, dismissed = new Set(), now = Date.now() } = {}) {
+function buildInbox({ ledgerRows = [], issues = null, previews = [], leftovers = null, health = null, update = null, takeovers = [], groups = {}, dismissed = new Set(), now = Date.now() } = {}) {
   const items = []
+  if (update && update.available && update.latestVersion) {
+    items.push({ key: `update:${update.latestVersion}`, kind: 'update', from: update.currentVersion || '', to: update.latestVersion, ts: update.checkedAt || now, dismissable: true })
+  }
   for (const f of failedTurns(ledgerRows, now)) {
     items.push({ key: `failed:${f.chatId}:${f.ts}`, kind: 'failed', chatId: f.chatId, group: groupLabel(groups, f.chatId), ts: f.ts,
       sender: f.sender || '', text: f.text || '', err: f.err ? String(f.err) : '', dismissable: true })

package/src/ui/server.js

@@ -32,7 +32,7 @@ const { createIssues, summarize, fingerprint } = require('../core/issues') //
 const leftover = require('../leftover') // 遗留进程:对话轮次结束后仍在跑的后台 shell —— 同一条道理,那条每 5 秒打线上接口的循环跑了 35 天就是因为没处看见(v0.11.108)
 const { withFileLock } = require('../core/store') // 反馈本改状态要与 CLI/群命令共用同一把跨进程锁
 const { redact } = require('../core/redact') // 出站脱敏:预览停止通知里含 agent 提供的 label
-const { verifyPassword } = require('./auth')
+const { hashPassword, verifyPassword } = require('./auth')
 const feishulogin = require('./feishulogin') // 控制台「用飞书登录」:OAuth 授权码流程的纯逻辑(公网入口;只放行管理员名单)
 const { createSessionStore } = require('./sessions') // 登录会话落盘 + 30 天过期(守护进程重启不再把人登出)
 const { listWecomSessions, wecomAuthShow } = require('../platform/wecom')
@@ -208,7 +208,7 @@ function bindNoticeText(workdir, platform = 'feishu', cmd = '/help') {
   return `✅ 本群已绑定项目「${path.basename(String(workdir || '')) || '(未命名)'}」\n${platform === 'wecom' ? '@我 派单(只有 @ 我的消息我才收得到)' : '直接发消息或 @我 派单'};${cmd} 查看命令`
 }
 
-function createUiServer({ configPath, getLiveState = null, getConnHealth = null, onConfigChange = null, control = null, host = '127.0.0.1', log = () => {}, issuesPath = null, sessionsPath = null, auditPath = null, ledgerPath = null, inboxDismissPath = null, fetchImpl = null, cdpImpl = null, onTakeoverClaim = null, onTakeoverExpire = null, onTakeoverEnd = null, takeoverNow = null, wecomExec = null, verifyFile = null, setupMode = null } = {}) {
+function createUiServer({ configPath, getLiveState = null, getConnHealth = null, onConfigChange = null, onHostChange = null, control = null, updater = null, host = '127.0.0.1', log = () => {}, issuesPath = null, sessionsPath = null, auditPath = null, ledgerPath = null, inboxDismissPath = null, fetchImpl = null, cdpImpl = null, onTakeoverClaim = null, onTakeoverExpire = null, onTakeoverEnd = null, takeoverNow = null, wecomExec = null, verifyFile = null, setupMode = null } = {}) {
   // wecomExec:企业微信命令行工具的执行器注入(只为可测;生产走默认 execFile)
   // verifyFile:凭据验证记录的落点注入(只为可测;生产 = ~/.sbot/verify.json)
   const vopts = verifyFile ? { file: verifyFile } : undefined
@@ -257,14 +257,18 @@ function createUiServer({ configPath, getLiveState = null, getConnHealth = null,
     const publicUrl = feishulogin.normalizePublicUrl(ui.publicUrl)
     const appId = resolveRef(fe.appId), appSecret = resolveRef(fe.appSecret), admins = adminList(fe)
     const r = feishulogin.feishuLoginReadiness({ publicUrl, appId, appSecret, admins })
-    return { ready: r.ready, why: r.why, publicUrl: publicUrl || '', redirectUri: publicUrl ? feishulogin.redirectUri(publicUrl) : '', appId, appSecret, admins }
+    const enabled = ui.publicEnabled !== false // 未出现这个字段的旧配置保持原行为
+    return { ready: enabled && r.ready, configured: r.ready, enabled, why: !enabled ? '公网登录已关闭' : r.why,
+      publicUrl: publicUrl || '', redirectUri: publicUrl ? feishulogin.redirectUri(publicUrl) : '', appId, appSecret, admins }
   }
   // Host 白名单:环回时只认 loopback(防 DNS-rebinding);对外(--host 非环回)额外放行私网段
   // IPv4(10./192.168./172.16-31./169.254.)。攻击者域名不匹配私网 IP 模式 → rebinding 仍挡住。
-  const loopbackBind = /^(127\.0\.0\.1|localhost|::1)$/i.test(String(host))
-  const HOST_OK = loopbackBind
+  let activeHost = String(host)
+  let loopbackBind = /^(127\.0\.0\.1|localhost|::1)$/i.test(activeHost)
+  const hostPattern = () => loopbackBind
     ? /^(127\.0\.0\.1|localhost|\[::1\])(:\d+)?$/i
     : /^(127\.0\.0\.1|localhost|\[::1\]|10(\.\d{1,3}){3}|192\.168(\.\d{1,3}){2}|172\.(1[6-9]|2\d|3[01])(\.\d{1,3}){2}|169\.254(\.\d{1,3}){2})(:\d+)?$/i
+  let HOST_OK = hostPattern()
   const authed = (req, url) => { const t = req.headers['x-sbot-token'] || url.searchParams.get('token'); return (!!t && t === token) || sessions.has(t) }
   // 是否已配访问密码(配了 ⇒ 页面不发 token,走登录)。config 读坏时的裁决见 authConfiguredFrom。
   const authConfigured = () => authConfiguredFrom(() => (readRaw().ui || {}).auth, loopbackBind)
@@ -329,9 +333,11 @@ function createUiServer({ configPath, getLiveState = null, getConnHealth = null,
   // 「需要你处理」:从 state 各区取数(反馈本 / 预览 / 残留进程 / 健康)+ 账本 + 接管票,不再各算一遍
   const buildInboxFor = ({ issues, previews, leftovers, health }, raw) => {
     try {
+      const update = updater ? { ...updater.status(), announce: !raw || !raw.ui || raw.ui.announceUpdates !== false } : null
       return dashboard.buildInbox({
         ledgerRows: ledgerTail.rows(),
         issues, previews, leftovers, health,
+        update,
         takeovers: takeoverStore.pending(),
         groups: (raw && raw.groups) || {},
         dismissed: inboxDismiss.set(),
@@ -606,14 +612,18 @@ function createUiServer({ configPath, getLiveState = null, getConnHealth = null,
         const port = addr && typeof addr === 'object' ? addr.port : null
         return {
           lan: !loopbackBind,
+          host: activeHost,
           port,
           local: port ? `http://127.0.0.1:${port}` : null,
           lanUrls: (!loopbackBind && port) ? lanIPv4().map((ip) => `http://${ip}:${port}`) : [],
           authOn: authConfigured(),
           publicUrl: fli.publicUrl, // 公网地址(飞书登录回调的根;设置页可填)
+          publicEnabled: fli.enabled,
+          publicReady: fli.configured,
           feishuLogin: { ready: fli.ready, why: fli.why, redirectUri: fli.redirectUri },
         }
       })(),
+      update: updater ? { ...updater.status(), announce: !raw.ui || raw.ui.announceUpdates !== false } : null,
     }
     state.inbox = buildInboxFor(state, raw)
     return state
@@ -806,6 +816,31 @@ function createUiServer({ configPath, getLiveState = null, getConnHealth = null,
       if (p === '/api/changelog' && req.method === 'GET') return sendJSON(res, 200, { changelog: readChangelog() })
       // 同一份版本历史的英文本(界面切英文时才拉;缺的版本前端按 version 回退中文)
       if (p === '/api/changelog-en' && req.method === 'GET') return sendJSON(res, 200, { changelog: readChangelogEn() })
+      if (p === '/api/update/check' && req.method === 'POST') {
+        if (!updater) return sendJSON(res, 503, { error: '版本检查暂不可用' })
+        return sendJSON(res, 200, await updater.check())
+      }
+      if (p === '/api/update/start' && req.method === 'POST') {
+        if (!updater) return sendJSON(res, 503, { error: '版本升级暂不可用' })
+        const { version, announce } = await body(req)
+        try { return sendJSON(res, 202, updater.startUpgrade({ version, announce })) }
+        catch (e) { return sendJSON(res, 409, { error: e.message, update: updater.status() }) }
+      }
+      if (p === '/api/update/ignore' && req.method === 'POST') {
+        if (!updater) return sendJSON(res, 503, { error: '版本升级暂不可用' })
+        const { version } = await body(req)
+        try { return sendJSON(res, 200, updater.ignore(version)) }
+        catch (e) { return sendJSON(res, 400, { error: e.message }) }
+      }
+      if (p === '/api/ui/update-settings' && req.method === 'POST') {
+        const patch = await body(req)
+        if (typeof patch.announce !== 'boolean') return sendJSON(res, 400, { error: '请提供升级播报偏好' })
+        const raw = readRaw(); raw.ui = raw.ui || {}
+        raw.ui.announceUpdates = patch.announce
+        delete raw.ui.autoUpdateCheck
+        writeRaw(raw)
+        return sendJSON(res, 200, await buildState())
+      }
       // codex 可用模型(codex 面板「模型」下拉):app-server model/list 实时探测(当前
       // 账号真实可用集,含各模型支持的推理强度),失败回退内置预设;探测要 spawn 进程
       // +触网 → 10 分钟缓存。
@@ -1058,6 +1093,67 @@ function createUiServer({ configPath, getLiveState = null, getConnHealth = null,
         if (t) { const n = feishulogin.normalizePublicUrl(t); if (!n) return sendJSON(res, 400, { error: '公网地址要写成 https://域名(可带端口),不带路径' }); raw.ui.publicUrl = n } else delete raw.ui.publicUrl
         writeRaw(raw); return sendJSON(res, 200, await buildState())
       }
+      if (p === '/api/ui/network' && req.method === 'POST') {
+        const patch = await body(req); const raw = readRaw(); raw.ui = raw.ui || {}
+        const previousHost = activeHost
+        let nextHost = activeHost
+        if (typeof patch.lanEnabled === 'boolean') {
+          if (patch.lanEnabled && patch.password) {
+            const password = String(patch.password)
+            if (password.length < 6) return sendJSON(res, 400, { error: '访问密码至少 6 位' })
+            raw.ui.auth = hashPassword(password)
+          }
+          if (patch.lanEnabled && !raw.ui.auth) return sendJSON(res, 400, { error: '开启局域网访问前要先设置访问密码' })
+          if (patch.lanEnabled !== !loopbackBind) {
+            nextHost = patch.lanEnabled ? '0.0.0.0' : '127.0.0.1'
+            raw.ui.host = nextHost
+          }
+        }
+        if (typeof patch.publicEnabled === 'boolean') {
+          const wasEnabled = raw.ui.publicEnabled !== false
+          if (patch.publicEnabled) {
+            const fe = raw.feishu || {}; const publicUrl = feishulogin.normalizePublicUrl(raw.ui.publicUrl)
+            const ready = feishulogin.feishuLoginReadiness({ publicUrl, appId: resolveRef(fe.appId), appSecret: resolveRef(fe.appSecret), admins: adminList(fe) })
+            if (!ready.ready) return sendJSON(res, 400, { error: `公网登录尚未就绪：${ready.why}` })
+          }
+          raw.ui.publicEnabled = patch.publicEnabled
+          if (wasEnabled && !patch.publicEnabled) {
+            const n = sessions.revokeWhere((session) => session && session.via === 'feishu')
+            if (n) audit.append({ kind: 'ui-public-access-revoked', sessions: n, ts: Date.now() })
+          }
+        }
+        writeRaw(raw)
+        audit.append({ kind: 'ui-network-settings', lan: nextHost !== '127.0.0.1', publicEnabled: raw.ui.publicEnabled !== false,
+          hostChanged: nextHost !== previousHost, ts: Date.now() })
+        if (nextHost !== previousHost) {
+          const responseSocket = res.socket
+          let rebindStarted = false
+          const startRebind = () => {
+            if (rebindStarted) return
+            rebindStarted = true
+            clearTimeout(rebindFallback)
+            setImmediate(() => rebindHost(nextHost).catch((e) => {
+              try {
+                const latest = readRaw(); latest.ui = latest.ui || {}; latest.ui.host = previousHost
+                writeRaw(latest)
+              } catch (rollbackErr) { log('ui host rollback failed: ' + (rollbackErr && rollbackErr.message)) }
+              audit.append({ kind: 'ui-network-rebind', ok: false, from: nextHost, to: previousHost, ts: Date.now() })
+              log('ui host change failed: ' + (e && e.message))
+            }))
+          }
+          // Wait for the switching response's connection to close before closing
+          // the listener; a fixed delay can still reset the response under load.
+          const rebindFallback = setTimeout(startRebind, 1000)
+          if (rebindFallback.unref) rebindFallback.unref()
+          if (responseSocket && !responseSocket.destroyed) responseSocket.once('close', startRebind)
+          res.writeHead(202, { 'Content-Type': 'application/json; charset=utf-8', Connection: 'close' })
+          res.end(JSON.stringify({ ok: true, rebinding: true, lan: nextHost !== '127.0.0.1' }), () => {
+            if (!responseSocket || responseSocket.destroyed) startRebind()
+          })
+          return
+        }
+        return sendJSON(res, 200, await buildState())
+      }
       if (p === '/api/feishu' && req.method === 'POST') {
         const { appId, appSecret, botOpenId, adminOpenId, adminName, onlyWhenMentioned } = await body(req); const raw = readRaw()
         raw.feishu = raw.feishu || { onlyWhenMentioned: false }
@@ -2152,6 +2248,40 @@ function createUiServer({ configPath, getLiveState = null, getConnHealth = null,
     }
   })
 
+  function setActiveHost(value) {
+    const changed = activeHost !== String(value)
+    activeHost = String(value)
+    loopbackBind = /^(127\.0\.0\.1|localhost|::1)$/i.test(activeHost)
+    HOST_OK = hostPattern()
+    if (changed && onHostChange) { try { onHostChange(activeHost, server.address()) } catch (e) { log('ui host callback: ' + (e && e.message)) } }
+  }
+  function listenAgain(bindHost, port) {
+    return new Promise((resolve, reject) => {
+      const onError = (e) => { server.removeListener('listening', onListening); reject(e) }
+      const onListening = () => { server.removeListener('error', onError); setActiveHost(bindHost); resolve() }
+      server.once('error', onError)
+      server.once('listening', onListening)
+      server.listen(port, bindHost)
+    })
+  }
+  async function rebindHost(nextHost) {
+    if (!['127.0.0.1', '0.0.0.0'].includes(nextHost)) throw new Error('只支持本机或全部局域网接口')
+    const address = server.address()
+    if (!address || typeof address !== 'object') throw new Error('控制台尚未监听端口')
+    const oldHost = activeHost
+    if (nextHost === oldHost) return
+    for (const client of sseClients) { try { client.end() } catch {} }
+    sseClients.clear()
+    const stopped = new Promise((resolve, reject) => server.close((e) => e ? reject(e) : resolve()))
+    if (typeof server.closeAllConnections === 'function') server.closeAllConnections()
+    await stopped
+    try { await listenAgain(nextHost, address.port) }
+    catch (e) {
+      try { await listenAgain(oldHost, address.port) } catch (restoreErr) { log('ui host restore listen failed: ' + (restoreErr && restoreErr.message)) }
+      throw e
+    }
+  }
+
   // Broadcast live state + heartbeat over SSE (cheap; no health probe here).
   const tick = setInterval(() => {
     if (!sseClients.size) return
@@ -2164,6 +2294,7 @@ function createUiServer({ configPath, getLiveState = null, getConnHealth = null,
   return {
     server,
     listen(port, host, cb) { server.listen(port, host, cb) },
+    rebind: rebindHost,
     // let a daemon push turn events into the console's activity feed
     pushEvent(type, data) {
       if (type === 'turn') recordActivity(data) // also buffer it for replay (下一步 ②)
@@ -2175,7 +2306,7 @@ function createUiServer({ configPath, getLiveState = null, getConnHealth = null,
       }
       for (const c of sseClients) { try { c.write(msg) } catch { sseClients.delete(c) } }
     },
-    close() { clearInterval(tick); for (const c of sseClients) { try { c.end() } catch {} } try { browserRoutes.close() } catch {} server.close() },
+    close() { clearInterval(tick); for (const c of sseClients) { try { c.end() } catch {} } try { browserRoutes.close() } catch {} server.close(); if (typeof server.closeAllConnections === 'function') server.closeAllConnections(); if (updater) updater.close() },
     _browserRoutes: browserRoutes, // 测试探 CDP 会话注册表用
   }
 }

package/src/updater.js

@@ -0,0 +1,243 @@
+// Stable-version checks and guarded in-place upgrades for the global package.
+// Checking is read-only. Installation is explicit, exact-version only, waits for
+// every group queue to drain, and never escalates privileges.
+
+const fs = require('node:fs')
+const path = require('node:path')
+const { execFile } = require('node:child_process')
+const { promisify } = require('node:util')
+const { atomicWriteJSON } = require('./core/store')
+
+const execFileAsync = promisify(execFile)
+const PACKAGE = 'sintbot'
+const REGISTRIES = [
+  { url: 'https://registry.npmjs.org/sintbot/latest', source: 'npm' },
+  { url: 'https://registry.npmmirror.com/sintbot/latest', source: 'mirror' },
+]
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000
+const CHECK_TIMEOUT_MS = 10_000
+const QUEUE_TIMEOUT_MS = 24 * 60 * 60 * 1000
+
+function stableVersion(value) {
+  const s = String(value || '').trim().replace(/^v/, '')
+  return /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(s) ? s : null
+}
+
+function compareVersion(a, b) {
+  const av = stableVersion(a); const bv = stableVersion(b)
+  if (!av || !bv) return 0
+  const aa = av.split('.').map(BigInt); const bb = bv.split('.').map(BigInt)
+  for (let i = 0; i < 3; i++) if (aa[i] !== bb[i]) return aa[i] > bb[i] ? 1 : -1
+  return 0
+}
+
+function hasPendingWork(live) {
+  // Updating while the engine is missing or its snapshot is incomplete is unsafe:
+  // a busy group could be hidden by a failed state read. Treat unknown as busy.
+  if (!live || live.running !== true || !Number.isFinite(Number(live.queue)) || !live.groups || typeof live.groups !== 'object') return true
+  if (Number(live.queue) > 0) return true
+  return Object.values(live.groups).some((g) => !g || g.busy || !Number.isFinite(Number(g.queue)) || Number(g.queue) > 0)
+}
+
+async function fetchVersion({ fetchImpl = globalThis.fetch, url, timeoutMs = CHECK_TIMEOUT_MS } = {}) {
+  const ac = new AbortController()
+  const timer = setTimeout(() => ac.abort(), timeoutMs)
+  try {
+    const res = await fetchImpl(url, { headers: { accept: 'application/json' }, signal: ac.signal, redirect: 'error' })
+    if (!res || !res.ok) throw new Error(`HTTP ${res && res.status || 'error'}`)
+    const data = await res.json()
+    const version = stableVersion(data && (data.version || (data['dist-tags'] && data['dist-tags'].latest)))
+    if (!version) throw new Error('registry returned no stable version')
+    return version
+  } finally { clearTimeout(timer) }
+}
+
+function readState(file) {
+  try {
+    const v = JSON.parse(fs.readFileSync(file, 'utf8'))
+    return v && typeof v === 'object' ? v : {}
+  } catch { return {} }
+}
+
+function createUpdater({
+  currentVersion,
+  stateFile,
+  getLiveState = () => null,
+  fetchImpl = globalThis.fetch,
+  registries = REGISTRIES,
+  now = Date.now,
+  waitMs = 5000,
+  queueTimeoutMs = QUEUE_TIMEOUT_MS,
+  checkIntervalMs = CHECK_INTERVAL_MS,
+  isGlobalInstall = defaultGlobalInstall,
+  installExact = defaultInstallExact,
+  readInstalledVersion = defaultReadInstalledVersion,
+  getManagedService = () => false,
+  restartManagedService = async () => ({ ok: false }),
+  setAnnouncementBaseline = () => {},
+  log = () => {},
+} = {}) {
+  const file = stateFile || path.join(require('node:os').homedir(), '.sbot', 'update.json')
+  const current = stableVersion(currentVersion) || '0.0.0'
+  let data = readState(file)
+  let queueTimer = null
+  let checking = null
+  let closed = false
+
+  // If a previous daemon was replaced during the restart step, the new package
+  // version is the evidence that installation and restart both completed.
+  if (data.job && data.job.state === 'restarting') {
+    data.job = data.job.to === current
+      ? { ...data.job, state: 'done', message: '更新完成并已重启', updatedAt: now() }
+      : { ...data.job, state: 'failed', message: '更新后未能自动重启，请手动重启服务', updatedAt: now() }
+    persist()
+  }
+
+  function persist() { try { atomicWriteJSON(file, data, { mode: 0o600 }) } catch (e) { log('update state: ' + (e && e.message)) } }
+  function status() {
+    const latest = stableVersion(data.latestVersion)
+    return {
+      currentVersion: current,
+      latestVersion: latest,
+      checkedAt: Number(data.checkedAt) || null,
+      source: data.source || '',
+      ignoredVersion: data.ignoredVersion || '',
+      available: !!latest && compareVersion(latest, current) > 0 && data.ignoredVersion !== latest,
+      job: data.job ? { ...data.job } : null,
+    }
+  }
+
+  async function check() {
+    if (closed) return status()
+    if (checking) return checking
+    checking = (async () => {
+      let lastError = null
+      for (const r of registries) {
+        try {
+          const version = await fetchVersion({ fetchImpl, url: r.url })
+          data.latestVersion = version
+          data.checkedAt = now()
+          data.source = r.source || ''
+          if (data.ignoredVersion && data.ignoredVersion !== version) data.ignoredVersion = ''
+          persist()
+          return status()
+        } catch (e) { lastError = e }
+      }
+      // Network errors are deliberately quiet and never erase the last success.
+      if (lastError) log('update check unavailable: ' + (lastError && lastError.message || 'network error'))
+      return status()
+    })().finally(() => { checking = null })
+    return checking
+  }
+
+  function ignore(version) {
+    const v = stableVersion(version)
+    if (!v || v !== stableVersion(data.latestVersion)) throw new Error('只能忽略当前检测到的版本')
+    data.ignoredVersion = v
+    persist()
+    return status()
+  }
+
+  function startUpgrade({ version, announce = true } = {}) {
+    const v = stableVersion(version)
+    if (!v || v !== stableVersion(data.latestVersion) || compareVersion(v, current) <= 0) throw new Error('版本信息已变化，请先重新检查')
+    if (data.job && ['queued', 'installing', 'restarting', 'restart-needed'].includes(data.job.state)) throw new Error('已有更新需要完成或重启后再试')
+    data.job = { id: `${now()}-${Math.random().toString(36).slice(2, 8)}`, state: 'queued', from: current, to: v,
+      announce: announce !== false, createdAt: now(), updatedAt: now(), message: '等待所有群任务结束后更新' }
+    persist()
+    void processQueue()
+    return status()
+  }
+
+  function scheduleQueueCheck() {
+    if (closed || queueTimer || !data.job || data.job.state !== 'queued') return
+    queueTimer = setTimeout(() => { queueTimer = null; void processQueue() }, waitMs)
+    if (queueTimer.unref) queueTimer.unref()
+  }
+
+  async function processQueue() {
+    const job = data.job
+    if (closed || !job || job.state !== 'queued') return
+    if (now() - job.createdAt > queueTimeoutMs) {
+      data.job = { ...job, state: 'failed', message: '等待群任务结束超时；可在任务空闲后重新发起', updatedAt: now() }
+      persist(); return
+    }
+    let live
+    try { live = getLiveState() }
+    catch (e) { log('update queue: live state unavailable: ' + (e && e.message)); return scheduleQueueCheck() }
+    if (hasPendingWork(live)) return scheduleQueueCheck()
+    if (queueTimer) { clearInterval(queueTimer); queueTimer = null }
+    data.job = { ...job, state: 'installing', message: '正在检查安装位置并安装指定版本', updatedAt: now() }
+    persist()
+    try {
+      const checkResult = await isGlobalInstall()
+      if (!checkResult || !checkResult.ok) throw new Error((checkResult && checkResult.reason) || '当前运行位置不是可写的全局安装')
+      const result = await installExact(PACKAGE, job.to, checkResult)
+      if (!result || result.ok === false) throw new Error((result && result.reason) || '安装失败；检查包管理器日志后可手动重试')
+      const installed = await readInstalledVersion(checkResult)
+      if (stableVersion(installed) !== job.to) throw new Error('安装完成后的版本核对不符；请手动检查后重启')
+      if (!job.announce) { try { setAnnouncementBaseline(job.to) } catch (e) { log('update announcement baseline: ' + (e && e.message)) } }
+      const managed = await getManagedService()
+      if (managed) {
+        data.job = { ...job, state: 'restarting', message: '已安装，正在重启后台服务', updatedAt: now() }
+        persist()
+        const restarted = await restartManagedService()
+        if (restarted && restarted.ok) return status()
+        data.job = { ...job, state: 'restart-needed', message: '已安装新版；后台服务未能自动重启，请手动重启', updatedAt: now() }
+      } else {
+        data.job = { ...job, state: 'restart-needed', message: '已安装新版；当前不是受托管服务，请手动重启 SintBot', updatedAt: now() }
+      }
+      persist()
+    } catch (e) {
+      data.job = { ...job, state: 'failed', message: String(e && e.message || e).slice(0, 300), updatedAt: now() }
+      persist()
+    }
+    return status()
+  }
+
+  if (data.job && data.job.state === 'queued') void processQueue()
+  const checkTimer = setInterval(() => { void check() }, checkIntervalMs)
+  if (checkTimer.unref) checkTimer.unref()
+
+  return {
+    status,
+    check,
+    ignore,
+    startUpgrade,
+    start() { return check() },
+    close() { closed = true; clearInterval(checkTimer); if (queueTimer) clearTimeout(queueTimer); queueTimer = null },
+  }
+}
+
+function defaultGlobalInstall() {
+  const { execFileSync } = require('node:child_process')
+  const rootOut = execFileSync('npm', ['root', '-g'], { encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'pipe'] }).trim()
+  const globalRoot = fs.realpathSync(rootOut)
+  const globalPackage = path.join(globalRoot, PACKAGE)
+  const runningPackage = fs.realpathSync(path.resolve(__dirname, '..'))
+  if (runningPackage !== fs.realpathSync(globalPackage)) return { ok: false, reason: '当前运行的是开发目录或非全局副本；请在终端手动更新' }
+  fs.accessSync(globalRoot, fs.constants.W_OK | fs.constants.X_OK)
+  fs.accessSync(path.dirname(globalPackage), fs.constants.W_OK | fs.constants.X_OK)
+  return { ok: true, globalRoot, globalPackage }
+}
+
+async function defaultInstallExact(name, version) {
+  const env = {}
+  const allowed = ['PATH', 'HOME', 'USERPROFILE', 'APPDATA', 'LOCALAPPDATA', 'TEMP', 'TMP', 'SystemRoot', 'PATHEXT',
+    'HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY', 'http_proxy', 'https_proxy', 'no_proxy', 'LANG', 'LC_ALL']
+  for (const k of allowed) if (process.env[k] !== undefined) env[k] = process.env[k]
+  const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm'
+  try {
+    await execFileAsync(npm, ['install', '--global', `${name}@${version}`, '--omit=dev', '--no-audit', '--no-fund'],
+      { timeout: 10 * 60 * 1000, maxBuffer: 2 * 1024 * 1024, windowsHide: true, env })
+    return { ok: true }
+  } catch (e) {
+    return { ok: false, reason: `安装失败(退出码 ${e && e.code != null ? e.code : '未知'})；未提权，也未改用其他版本` }
+  }
+}
+
+function defaultReadInstalledVersion(info) {
+  try { return JSON.parse(fs.readFileSync(path.join(info.globalPackage, 'package.json'), 'utf8')).version || null } catch { return null }
+}
+
+module.exports = { PACKAGE, REGISTRIES, CHECK_INTERVAL_MS, stableVersion, compareVersion, hasPendingWork, fetchVersion, createUpdater, defaultGlobalInstall, defaultInstallExact, defaultReadInstalledVersion }