@xiaobuyu/nodesign 0.0.1

package/server/services/rembg-launcher.js

@@ -0,0 +1,313 @@
+/**
+ * services/rembg-launcher.js — Node 侧管 rembg-service.py 子进程生命周期
+ *
+ * server/index.js 启动时调 startRembgService()，shutdown 时调 stopRembgService()。
+ * service 自己常驻一个 python 进程把 onnxruntime session 缓存在内存里——
+ * 比 per-call cold subprocess spawn 省 ~20-40s/call。
+ *
+ * Service 死了不影响主流程（fallback 到老的 spawn-bridge 路径，详见 helpers/rembg.js）。
+ *
+ * ── RSS 看门狗（2026-07-31 事故后加）──────────────────────────────
+ * onnxruntime + pymatting 的内存高水位**不会自己降**：抠 8 张 1.5-2MP 的图能让
+ * 这个进程从 345MB 涨到 1.2GB 并停在那儿。这台机器 3.9G 内存 + 2G swap，塞着
+ * Cursor server（约 970MB）、SillyTavern、Claude SDK 子进程之后余量本来就薄，
+ * 高水位不降就一路把系统推进内存抖动：内核忙于回收/换页，单核 CPU 被钉死 99%，
+ * 机器活着但 SSH 和 HTTP 全都握不上手，只能人工关机。2026-07-31 04:24 就是这么死的。
+ *
+ * 所以：定期看 RSS，超阈值且**在途请求为 0** 时把 service 回收重开。它是无状态的，
+ * 代价只是下次调用重新 load 一次模型（~20-40s，且预热是异步的不挡请求）。
+ * service 侧还会在每次抠图后 gc + malloc_trim 主动还内存，看门狗是兜底不是主力。
+ *
+ * Env override：
+ *   NODESIGN_REMBG_PYTHON     venv python 解释器路径
+ *   NODESIGN_REMBG_SERVICE    service 脚本路径
+ *   NODESIGN_REMBG_SOCKET     Unix socket 路径
+ *   NODESIGN_REMBG_PRELOAD    逗号分隔预加载模型列表（默认 isnet-general-use）
+ *   NODESIGN_REMBG_MAX_RSS_MB RSS 回收阈值（默认 900；0 = 关掉看门狗）
+ *   NODESIGN_REMBG_WATCH_MS   看门狗巡检间隔（默认 60000）
+ */
+
+import { spawn, execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import http from 'node:http';
+import { promises as fs, readFileSync, writeFileSync } from 'node:fs';
+import { REMBG_VENV_PYTHON, REMBG_SETUP_HINT } from '../engine/mcp/tools/helpers/rembg.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// services/ 在 server/services/，server root 上溯 1 层
+const SERVER_ROOT = path.resolve(__dirname, '..');
+
+const DEFAULT_PYTHON = REMBG_VENV_PYTHON;
+const DEFAULT_SERVICE = path.join(__dirname, 'rembg-service.py');
+// 默认只预热 isnet-general-use（fast 档）。birefnet-general-lite (balanced) /
+// birefnet-general (best) 都带 alpha matting，pymatting 单线程 CPU 重，预热占
+// 200-400MB 内存但实际很少用——按需 lazy load 即可。
+// 改回多模型预热：env NODESIGN_REMBG_PRELOAD=isnet-general-use,birefnet-general-lite
+const DEFAULT_PRELOAD = 'isnet-general-use';
+
+const DEFAULT_SOCKET = '/tmp/nodesign-rembg.sock';
+const MAX_RSS_MB = Number(process.env.NODESIGN_REMBG_MAX_RSS_MB ?? 900);
+const WATCH_MS = Number(process.env.NODESIGN_REMBG_WATCH_MS ?? 60_000);
+
+let serviceProc = null;
+let started = false;
+let watchTimer = null;
+/** 看门狗主动回收时置位：让 exit handler 知道该重开，而不是当成异常退出 */
+let recycling = false;
+
+/** 问 service 的 /health（走 Unix socket）。拿不到就返 null，看门狗这轮跳过 */
+function probeHealth(timeoutMs = 3000) {
+  const socketPath = process.env.NODESIGN_REMBG_SOCKET || DEFAULT_SOCKET;
+  return new Promise((resolve) => {
+    const req = http.request({ socketPath, path: '/health', method: 'GET', timeout: timeoutMs }, (res) => {
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', (c) => { body += c; });
+      res.on('end', () => {
+        try { resolve(JSON.parse(body)); } catch { resolve(null); }
+      });
+    });
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
+    req.end();
+  });
+}
+
+/**
+ * 一轮巡检。超阈值且在途为 0 → 回收。
+ *
+ * 在途不为 0 时**不回收**：宁可这一轮继续超着，也不能把用户正在等的抠图打断。
+ * 下一轮还会再看，抠图是秒级的，不会一直忙。
+ */
+async function watchdogTick() {
+  if (!serviceProc || recycling) return;
+  const health = await probeHealth();
+  if (!health || typeof health.rss_mb !== 'number') return;
+  if (health.rss_mb < MAX_RSS_MB) return;
+  if (health.inflight > 0) {
+    console.log(`[rembg-service] RSS ${health.rss_mb}MB 超阈值 ${MAX_RSS_MB}MB，但有 ${health.inflight} 个在途请求，本轮不回收`);
+    return;
+  }
+  console.log(`[rembg-service] RSS ${health.rss_mb}MB ≥ ${MAX_RSS_MB}MB 且空闲 → 回收重开（内存高水位不会自己降，见文件头注释）`);
+  recycling = true;
+  try {
+    serviceProc.kill('SIGTERM');
+  } catch { /* 已经死了，exit handler 会接手 */ }
+}
+
+/**
+ * 把 service 进程钉成"内存不够时第一个该死的人"。
+ *
+ * 为什么需要：内存告急时，内核 OOM killer 和 earlyoom 都是按 oom_score 挑人，
+ * 而这台机器上前几名的分数挤在一起（实测 rembg 712 / Cursor 708 / claude 扩展
+ * 705 / nodesign 服务端 692，满分 1000）。差 4 分意味着 RSS 稍一波动排序就翻，
+ * 于是本该背锅的抠图服务躲过去，反而杀掉 nodesign 或者你的 IDE 连接。
+ *
+ * oom_score_adj 加 500 分把它顶到榜首且拉开差距，让"谁会被杀"变成确定的事：
+ * 抠图服务无状态，被杀了 helpers/rembg.js 会 fallback 到 per-call cold spawn，
+ * 用户最多觉得慢一次；杀 nodesign 会丢掉正在跑的 agent 回合。
+ *
+ * 非 root 只能调高不能调低，加分这个方向一定能成功。
+ */
+function pinOomScore(pid) {
+  const adj = Number(process.env.NODESIGN_REMBG_OOM_ADJ ?? 500);
+  if (!Number.isFinite(adj) || adj === 0) return;
+  try {
+    writeFileSync(`/proc/${pid}/oom_score_adj`, String(adj));
+    console.log(`[rembg-service] oom_score_adj=${adj}（内存告急时优先被杀，它是无状态的）`);
+  } catch (err) {
+    // 非 Linux / 权限不足：不是致命问题，earlyoom 的 --prefer 仍在兜着
+    console.warn(`[rembg-service] oom_score_adj 设置失败（不影响功能）: ${err.message}`);
+  }
+}
+
+function startWatchdog() {
+  if (watchTimer || !(MAX_RSS_MB > 0) || !(WATCH_MS > 0)) return;
+  watchTimer = setInterval(() => { watchdogTick().catch(() => {}); }, WATCH_MS);
+  watchTimer.unref();   // 不因为它拖着不让进程退出
+}
+
+/**
+ * 杀掉所有 stale rembg-service.py 进程（不属于本 launcher 的）。
+ * 防止 node --watch reload / pm2 restart / 上次 SIGKILL 没清干净时
+ * 多个 service 实例累积——每个加载一份模型 = 重复 200-400MB 内存浪费 +
+ * 同一个 socket 文件 bind 冲突。
+ *
+ * 用 pgrep -f 找匹配 rembg-service.py 的进程，全 kill。同步执行——
+ * 启动时一次性清干净，spawn 新 service 之前。
+ */
+function killStaleServices() {
+  const mySocket = process.env.NODESIGN_REMBG_SOCKET || DEFAULT_SOCKET;
+  try {
+    // pgrep -f 匹配完整 cmdline，-d ' ' 用空格分隔多 PID。
+    // pattern "python.*rembg-service\\.py" 收紧只匹配 python 解释器执行
+    // rembg-service.py 的进程（避免误杀含字符串的 node test / 编辑器等）。
+    const out = execSync('pgrep -ifd " " "python.*rembg-service\\.py"', {
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).toString().trim();
+    if (!out) return;
+    // 排除自己当前进程（防自杀的边角）
+    const myPid = process.pid;
+    let pids = out.split(/\s+/).filter(Boolean).filter((p) => Number(p) !== myPid);
+    // 只杀**绑同一个 socket** 的实例。socket 路径在 env 里不在 argv 里，所以
+    // 读 /proc/<pid>/environ 判断。
+    //
+    // 为什么必须过滤：不加这层，任何第二个 nodesign 实例（隔离 e2e、本地
+    // 另开一份、看门狗自测）一启动就会把生产实例的抠图服务杀掉，而生产侧
+    // 对"意外退出"是不自动重启的，于是抠图静默降级成 per-call cold spawn，
+    // 没人会发现。2026-07-31 我自己踩了一次。
+    // 读不到 environ 的（权限/进程刚没）当作不是自己的，宁可漏杀不可错杀。
+    pids = pids.filter((p) => {
+      try {
+        const env = readFileSync(`/proc/${p}/environ`, 'utf8');
+        return env.split('\0').includes(`NODESIGN_REMBG_SOCKET=${mySocket}`)
+          // 老进程可能没显式设这个 env（走的是 service 侧默认值）
+          || (mySocket === DEFAULT_SOCKET && !env.includes('NODESIGN_REMBG_SOCKET='));
+      } catch { return false; }
+    });
+    if (pids.length === 0) return;
+    console.log(`[rembg-service] killing ${pids.length} stale service process(es): ${pids.join(', ')}`);
+    for (const pid of pids) {
+      try { process.kill(Number(pid), 'SIGTERM'); } catch { /* already dead */ }
+    }
+    // 给 1s 让 SIGTERM 走 atexit 清 socket；之后 SIGKILL 兜底
+    const deadline = Date.now() + 1000;
+    while (Date.now() < deadline) {
+      try {
+        execSync('pgrep -if "python.*rembg-service\\.py"', { stdio: 'ignore' });
+        // 还活着，继续 wait
+      } catch {
+        // pgrep exit 1 = 没找到 = 全死了
+        return;
+      }
+    }
+    // SIGTERM 1s 还没死 → SIGKILL
+    for (const pid of pids) {
+      try { process.kill(Number(pid), 'SIGKILL'); } catch { /* ignore */ }
+    }
+  } catch (err) {
+    // pgrep exit 1 = 没匹配进程，正常路径，不报错
+    if (err.status !== 1) {
+      console.warn(`[rembg-service] killStaleServices error: ${err.message}`);
+    }
+  }
+}
+
+/**
+ * 启动 rembg-service。幂等：重复调用 noop。
+ * 返回 boolean —— 是否启动成功（venv 不存在 / spawn 错时返 false，server 继续）。
+ */
+export async function startRembgService() {
+  if (started) return Boolean(serviceProc);
+  started = true;
+
+  const py = process.env.NODESIGN_REMBG_PYTHON || DEFAULT_PYTHON;
+  const script = process.env.NODESIGN_REMBG_SERVICE || DEFAULT_SERVICE;
+  const preload = process.env.NODESIGN_REMBG_PRELOAD || DEFAULT_PRELOAD;
+
+  // 先杀掉所有 stale rembg-service 进程（node --watch reload / SIGKILL 没清等
+  // 路径会让多个 service 累积，每个吃 200-400MB 内存）
+  killStaleServices();
+
+  // venv 不存在直接 noop（首次部署 / dev 没装 rembg 的环境）
+  try {
+    await fs.access(py);
+    await fs.access(script);
+  } catch (err) {
+    console.warn(
+      `[rembg-service] not started: ${err.code === 'ENOENT' ? 'venv or script missing' : err.message}.`
+      + ` Setup: ${REMBG_SETUP_HINT}.`
+      + ' remove_background tool will fall back to per-call spawn (slower).',
+    );
+    return false;
+  }
+
+  const ok = spawnService(py, script, preload);
+  if (ok) startWatchdog();
+  return ok;
+}
+
+/**
+ * 真正 spawn 一次。startRembgService 首次调，看门狗回收后也调。
+ *
+ * 退出处理分两种：
+ *   看门狗主动回收（recycling=true）→ 立刻重开，这是预期行为
+ *   意外退出（崩了 / 被 earlyoom 或 OOM killer 杀了）→ **不自动重启**，
+ *     保持原有约定：单方面重启子进程会掩盖问题。抠图会 fallback 到 per-call
+ *     cold spawn（慢但能用），日志里那行 exited 就是要让人看见的信号。
+ */
+function spawnService(py, script, preload) {
+  try {
+    serviceProc = spawn(py, [script], {
+      stdio: ['ignore', 'inherit', 'inherit'],
+      env: {
+        ...process.env,
+        NODESIGN_REMBG_PRELOAD: preload,
+        // 显式写进子进程 env：killStaleServices 靠读 /proc/<pid>/environ
+        // 判断某个 service 是不是"自己这一份"，不写的话认不出来
+        NODESIGN_REMBG_SOCKET: process.env.NODESIGN_REMBG_SOCKET || DEFAULT_SOCKET,
+      },
+      // detached:false → child 跟父 share 进程组，父收 SIGINT 时 shell 也会
+      // 转给 child（双保险）；显式 SIGTERM 仍走 stopRembgService()
+      detached: false,
+    });
+  } catch (err) {
+    console.warn(`[rembg-service] spawn failed: ${err.message}`);
+    serviceProc = null;
+    return false;
+  }
+
+  console.log(`[rembg-service] spawned PID ${serviceProc.pid}, preload=[${preload}]`);
+  pinOomScore(serviceProc.pid);
+
+  serviceProc.on('exit', (code, signal) => {
+    console.log(`[rembg-service] exited code=${code} signal=${signal}`);
+    serviceProc = null;
+    if (recycling) {
+      recycling = false;
+      // 隔一拍再起：给 atexit 清 socket 的时间，否则新进程 bind 会撞上旧 socket 文件
+      setTimeout(() => {
+        if (started) {
+          console.log('[rembg-service] 回收后重开');
+          spawnService(py, script, preload);
+        }
+      }, 500).unref();
+    }
+  });
+
+  serviceProc.on('error', (err) => {
+    console.warn(`[rembg-service] process error: ${err.message}`);
+  });
+
+  return true;
+}
+
+/**
+ * 优雅关闭 rembg-service。SIGTERM 让 service 走 atexit 清 socket。
+ */
+export function stopRembgService() {
+  started = false;              // 让 exit handler 里的重开分支不再触发
+  recycling = false;
+  if (watchTimer) { clearInterval(watchTimer); watchTimer = null; }
+  if (!serviceProc) return;
+  console.log(`[rembg-service] stopping PID ${serviceProc.pid}`);
+  try {
+    serviceProc.kill('SIGTERM');
+  } catch { /* ignore — already dead */ }
+  // 兜底 3s 后 SIGKILL
+  const killer = setTimeout(() => {
+    if (serviceProc) {
+      try { serviceProc.kill('SIGKILL'); } catch { /* ignore */ }
+    }
+  }, 3000);
+  killer.unref();
+  serviceProc = null;
+}
+
+/**
+ * 给外部探活用（helpers/rembg.js 不强依赖；自己也会 isAvailable check service health）
+ */
+export function isRembgServiceRunning() {
+  return serviceProc !== null && !serviceProc.killed;
+}

package/server/services/rembg-service.py

@@ -0,0 +1,334 @@
+#!/usr/bin/env python3
+"""rembg-service — long-running FastAPI service over Unix socket.
+
+server/index.js spawn 这个进程在自己启动时；自己 shutdown 时 SIGTERM 它。
+所有 onnxruntime session 在内存里 warm 缓存，避免 per-call cold spawn 税
+（每次省 ~20-40s）。
+
+启动顺序（2026-05-11 重构）：
+  1. bind Unix socket（立刻 ready，~1s）
+  2. uvicorn startup event 起后台 _preload(models) task 异步预热
+  3. /remove 请求路径：未预热则同步 load（per-model asyncio.Lock 防并发重 load）
+  避免老版"先 preload → 再 bind socket"路径在 birefnet+CoreML 卡死时
+  socket 永不创建的死锁。
+
+Endpoints:
+  GET  /health
+    返回 {"ok": true, "loaded_models": [...], "preload_done": bool}（也用作 isAvailable 探活）
+
+  POST /remove
+    Headers:
+      X-Model: <rembg model name>             default 'isnet-general-use'（安全档）
+      X-Alpha-Matting: 0|1                    default 0
+    Body: raw image bytes (PNG/JPEG/WEBP/...)
+    Returns: RGBA PNG bytes (200) or JSON error (4xx/5xx)
+
+Env:
+  NODESIGN_REMBG_SOCKET         Unix socket path (default /tmp/nodesign-rembg.sock)
+  NODESIGN_REMBG_PRELOAD        逗号分隔的 model 列表，启动时异步预加载
+                                例：'isnet-general-use,birefnet-general-lite'
+  NODESIGN_REMBG_PROVIDERS      逗号分隔 onnxruntime providers 覆盖默认。
+                                未设时：darwin 默认 'CPUExecutionProvider' 单一
+                                项绕过 CoreML+birefnet 卡死 bug（onnxruntime
+                                1.19.2 验证），其它平台传 None 让 ort 自选
+                                （Linux CUDA EP / Windows DML 等）。
+  NODESIGN_REMBG_AM_MAX_DIM     alpha matting 的分辨率上限（长边 px，默认 1024）。
+                                见下方 _remove_with_am_cap 的长注释。0 = 不限制。
+"""
+import asyncio
+import atexit
+import ctypes
+import ctypes.util
+import gc
+import io
+import os
+import sys
+import warnings
+
+# urllib3 v2 + LibreSSL（Apple python）只是警告，silence 防污染 stderr
+warnings.filterwarnings('ignore')
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import Response
+from PIL import Image
+import onnxruntime as ort
+from rembg import remove, new_session
+
+
+def _make_malloc_trim():
+    """glibc 的 malloc_trim(0)：把 free 出来但还挂在堆上的内存还给内核。
+
+    只对 glibc 有效（这台是 Debian，有）。musl / macOS 拿不到符号就返回一个空
+    函数，调用处不用关心平台差异。
+    """
+    try:
+        libc = ctypes.CDLL(ctypes.util.find_library('c'), use_errno=True)
+        trim = libc.malloc_trim
+        trim.argtypes = [ctypes.c_size_t]
+        trim.restype = ctypes.c_int
+        return lambda: trim(0)
+    except Exception:
+        return lambda: None
+
+
+_malloc_trim = _make_malloc_trim()
+
+
+def _resolve_providers():
+    """决定传给 rembg new_session 的 providers 列表。
+
+    darwin（Apple Silicon Mac）必须排除 CoreMLExecutionProvider：
+    onnxruntime 1.19.2 在 birefnet-general-lite 上 CoreML graph compile
+    卡死（>110s 未返回；CPU-only providers 2.5s 完成）。
+
+    Linux / Windows 走 None = ort 自选，保留 CUDA EP / DML 等加速。
+    Env NODESIGN_REMBG_PROVIDERS 覆盖一切（escape hatch + ort 升级后复测用）。
+
+    将来 onnxruntime 升级时重测：
+      .venv-rembg/bin/python3 -c "from rembg import new_session; \\
+        import time; t=time.time(); new_session('birefnet-general-lite'); \\
+        print(time.time()-t)"
+    < 30s 返回即可考虑放开 darwin 默认。
+    """
+    env = os.environ.get('NODESIGN_REMBG_PROVIDERS', '').strip()
+    if env:
+        return [p.strip() for p in env.split(',') if p.strip()]
+    if sys.platform == 'darwin':
+        return ['CPUExecutionProvider']
+    return None  # ort 自选
+
+
+PROVIDERS = _resolve_providers()
+
+app = FastAPI()
+
+# 模型 session 缓存：model name → onnxruntime session
+sessions = {}
+# per-model asyncio.Lock 防并发同一 model 重复 new_session（preload + 第一个
+# /remove 撞车场景）。dict 默认 lazy 建 Lock。
+_session_locks: dict = {}
+# preload 任务完成与否（仅 /health 报告用）
+_preload_done = False
+
+
+def _get_lock(model_name: str) -> asyncio.Lock:
+    if model_name not in _session_locks:
+        _session_locks[model_name] = asyncio.Lock()
+    return _session_locks[model_name]
+
+
+def _mem_tuned_options():
+    """省内存优先的 onnxruntime SessionOptions。
+
+    起因：birefnet-general-lite 只有 214MB 权重，但一次 1.57MP 推理的峰值 RSS
+    到 2.4GB，在 3.9G 无 swap 的机器上直接被 OOM killer 杀掉（2026-07-29 两次、
+    07-31 复现一次，dmesg 有记录）。杀的是这个常驻进程，连带 fast 档一起死，
+    所以整档被 env 禁掉了。
+
+    钱花在哪：ort 默认开 CPU arena 分配器，它按需成倍扩张且**不还给系统**，
+    对 birefnet 这种 transformer backbone（大量临时激活）峰值会翻好几倍。
+      enable_cpu_mem_arena=False  —— 用完即还，峰值大幅下降，代价是分配器调用
+                                     多一点（单核上这点开销远小于被 OOM 杀掉）
+      enable_mem_pattern=False    —— 内存复用模式表本身也要预分配一大块
+      intra/inter_op=1            —— 这台机器就 1 核，多线程只是每条线程再占一份
+                                     临时缓冲，一点也不快
+
+    isnet 那档本来就只占 997MB，加上这些也不会变慢到哪去，统一走同一份配置。
+    """
+    opts = ort.SessionOptions()
+    opts.enable_cpu_mem_arena = False
+    opts.enable_mem_pattern = False
+    opts.intra_op_num_threads = int(os.environ.get('NODESIGN_REMBG_THREADS', '1'))
+    opts.inter_op_num_threads = 1
+    return opts
+
+
+def _load_session_sync(model_name: str):
+    """同步 load——锁内调用。onnxruntime new_session 是阻塞 CPU 工作，
+    用 asyncio.to_thread 在外层包裹。"""
+    if model_name not in sessions:
+        sessions[model_name] = new_session(
+            model_name, providers=PROVIDERS, sess_opts=_mem_tuned_options(),
+        )
+    return sessions[model_name]
+
+
+async def ensure_session(model_name: str):
+    """异步获取 session：已 load 直接返；未 load 锁内同步 load 然后返。"""
+    if model_name in sessions:
+        return sessions[model_name]
+    async with _get_lock(model_name):
+        # double-check：另一 task 可能已经 load 完
+        if model_name in sessions:
+            return sessions[model_name]
+        return await asyncio.to_thread(_load_session_sync, model_name)
+
+
+async def _preload(models):
+    """启动后台预热——串行 load 防同时撑爆内存。失败单 model 不影响整体。"""
+    global _preload_done
+    for m in models:
+        print(f'[rembg-service] preloading {m}...', file=sys.stderr, flush=True)
+        try:
+            await ensure_session(m)
+            print(f'[rembg-service]   ✓ {m} ready', file=sys.stderr, flush=True)
+        except Exception as e:
+            print(f'[rembg-service]   ✗ {m} failed: {type(e).__name__}: {e}',
+                  file=sys.stderr, flush=True)
+    _preload_done = True
+    print(f'[rembg-service] preload done, loaded={sorted(sessions.keys())}',
+          file=sys.stderr, flush=True)
+
+
+@app.on_event('startup')
+async def _on_startup():
+    preload = os.environ.get('NODESIGN_REMBG_PRELOAD', '').strip()
+    if not preload:
+        return
+    models = [s.strip() for s in preload.split(',') if s.strip()]
+    if models:
+        asyncio.create_task(_preload(models))
+
+
+# 在途请求数。launcher 的 RSS 看门狗只在这个数为 0 时才敢回收本进程，
+# 否则会把用户正在等的那次抠图打断。
+_inflight = 0
+
+
+def _self_rss_mb():
+    """本进程 RSS（MB）。读 /proc 而不是引 psutil：少一个依赖，Linux 上够用。"""
+    try:
+        with open('/proc/self/status') as f:
+            for line in f:
+                if line.startswith('VmRSS:'):
+                    return round(int(line.split()[1]) / 1024)
+    except OSError:
+        pass
+    return None
+
+
+@app.get('/health')
+def health():
+    return {
+        'ok': True,
+        'loaded_models': sorted(sessions.keys()),
+        'preload_done': _preload_done,
+        # 下面两个给 launcher 的看门狗用（见 rembg-launcher.js）
+        'inflight': _inflight,
+        'rss_mb': _self_rss_mb(),
+    }
+
+
+AM_MAX_DIM = int(os.environ.get('NODESIGN_REMBG_AM_MAX_DIM', '1024'))
+
+
+def _remove_with_am_cap(image_bytes, session, alpha_matting):
+    """抠图。开 alpha matting 时把 AM 那一步限制在 AM_MAX_DIM 之内。
+
+    alpha matting 走 pymatting，它对 W×H 的图建一个 (W·H)×(W·H) 的稀疏拉普拉斯
+    矩阵再解方程组，内存和时间都随**像素数**走。这里的生图动辄 1.6MP 到 6.5MP，
+    不限制的话解算既慢又吃内存，原来 "fast 加 AM" 试过一次没通就是卡在这。
+
+    限制之后：AM 在 ≤1024 长边上算（≤1MP），算出来的 alpha 再 LANCZOS 放大回原
+    尺寸，跟**原分辨率的 RGB** 合成。输出仍是全分辨率，只有边缘的柔和过渡是在低
+    分辨率上解出来再插值的。代价是边缘比全分辨率 AM 略"雾"一点；收益是这一档在
+    这台机器上第一次变得可用。
+
+    ⚠️ 这个上限**不是** birefnet 档 OOM 的解药，别把两件事记混。2026-07-31 实测：
+    birefnet-general-lite 在 alpha_matting=0 的情况下，一张 1.57MP 的图峰值 RSS
+    就到 2435MB，照样被 OOM killer 杀掉（可用内存 2234MB）。撑爆的是模型推理本身，
+    跟 AM 无关。ort 的 arena/mem_pattern 调优只把 fast 从 997MB 压到 892MB，对
+    birefnet 那 2.4GB 基本没动。birefnet 档要能用，得先给这台机器加 swap。
+
+    不开 AM 时原样走 rembg，一个像素都不动。
+    """
+    if not alpha_matting:
+        return remove(image_bytes, session=session, alpha_matting=False)
+
+    src = Image.open(io.BytesIO(image_bytes))
+    src.load()
+    w, h = src.size
+    long_edge = max(w, h)
+
+    if AM_MAX_DIM <= 0 or long_edge <= AM_MAX_DIM:
+        return remove(image_bytes, session=session, alpha_matting=True)
+
+    scale = AM_MAX_DIM / long_edge
+    small = src.convert('RGB').resize(
+        (max(1, round(w * scale)), max(1, round(h * scale))), Image.LANCZOS,
+    )
+    buf = io.BytesIO()
+    small.save(buf, format='PNG')
+    cut_small = remove(buf.getvalue(), session=session, alpha_matting=True)
+
+    alpha = Image.open(io.BytesIO(cut_small)).convert('RGBA').getchannel('A')
+    alpha = alpha.resize((w, h), Image.LANCZOS)
+
+    out = src.convert('RGB')
+    out.putalpha(alpha)
+    result = io.BytesIO()
+    out.save(result, format='PNG')
+    return result.getvalue()
+
+
+@app.post('/remove')
+async def remove_endpoint(request: Request):
+    global _inflight
+    # 缺省换成 isnet（2026-08-02）：原来的 birefnet-general-lite 是个陷阱 ——
+    # 不带 X-Model 的直连调用会加载 2.4GB 峰值的模型，在这台机器上直接 OOM
+    # 连坐整个 service（当天真踩过）。工具层永远显式传 model，缺省只服务于
+    # 手工调试，就该是安全档。
+    model = request.headers.get('x-model', 'isnet-general-use')
+    alpha_matting = request.headers.get('x-alpha-matting', '0') == '1'
+    image_bytes = await request.body()
+    if not image_bytes:
+        raise HTTPException(400, detail='empty body')
+    _inflight += 1
+    try:
+        session = await ensure_session(model)
+        # rembg remove 是 CPU 密集——丢线程池防阻塞 event loop
+        rgba = await asyncio.to_thread(
+            _remove_with_am_cap, image_bytes, session, alpha_matting,
+        )
+        return Response(content=rgba, media_type='image/png')
+    except Exception as e:
+        print(f'[rembg-service] /remove error: {type(e).__name__}: {e}',
+              file=sys.stderr, flush=True)
+        raise HTTPException(500, detail=f'{type(e).__name__}: {e}')
+    finally:
+        _inflight -= 1
+        # 主动还内存：pymatting 的稀疏矩阵和 PIL 的全分辨率图都是大块 numpy /
+        # buffer，Python 的分配器不一定马上还给系统。gc 一次 + malloc_trim 把
+        # 空闲堆顶还回去，能明显压低 RSS 高水位（2026-07-31 事故就是高水位不降
+        # 一路把机器推进内存抖动）。拿不到 malloc_trim 的平台静默跳过。
+        gc.collect()
+        _malloc_trim()
+
+
+def cleanup_socket(socket_path: str):
+    """退出时删 socket file，方便下次启动重新 bind。"""
+    try:
+        if os.path.exists(socket_path):
+            os.unlink(socket_path)
+            print(f'[rembg-service] cleaned up {socket_path}', file=sys.stderr, flush=True)
+    except OSError:
+        pass
+
+
+def main():
+    socket_path = os.environ.get('NODESIGN_REMBG_SOCKET', '/tmp/nodesign-rembg.sock')
+    # bind 前清掉旧 socket（上次没干净退出会留残骸；SIGKILL 不走 atexit）
+    cleanup_socket(socket_path)
+    atexit.register(cleanup_socket, socket_path)
+
+    providers_label = ','.join(PROVIDERS) if PROVIDERS else '<ort-default>'
+    print(f'[rembg-service] providers={providers_label}', file=sys.stderr, flush=True)
+    print(f'[rembg-service] listening on {socket_path}', file=sys.stderr, flush=True)
+
+    import uvicorn
+    # log_level=warning 静音 uvicorn access logs（每次请求一行很吵）
+    uvicorn.run(app, uds=socket_path, log_level='warning', access_log=False)
+
+
+if __name__ == '__main__':
+    main()

package/server/shared/README.md

@@ -0,0 +1,25 @@
+# server/shared/
+
+从小合（[dev/server/bot/](../../../dev/server/bot/)）抠出来的**真正通用、跟工单业务无关**的基建文件。
+
+## 文件清单
+
+| 文件 | 来源 | 改动 |
+|---|---|---|
+| `anthropic-client.js` | `dev/server/bot/anthropic-client.js` | env 名 `MINIMAX_*` → `KIMI_*`；baseURL 默认值切 Moonshot；timeout 600s（长任务） |
+| `agent-loop.js` | `dev/server/bot/agent-loop.js` | 仅改 env 名 `BOT_TOOL_TIMEOUT_MS` → `ENGINE_TOOL_TIMEOUT_MS`，默认 30s → 60s；其余照搬 |
+| `concurrency.js` | `dev/server/bot/concurrency.js` | 注释从"飞书 user open_id"泛化为"key"；env 名加 `ENGINE_` 前缀；`enqueueMessage` 改 `enqueueTask` |
+| `time.js` | `dev/server/utils/time.js` | 零改动 |
+
+## 不该往这里加东西的判断
+
+- 业务（工单 / 钩子 / 飞书卡片）→ 不该来
+- 跟 dev/ 共演化的核心抽象 → 暂时直接复制；如果开始反复同步两边，就提到 monorepo `shared/` 包
+
+## 待验证（动工前必做）
+
+- [ ] `cache_control: { type: 'ephemeral' }` 在 Kimi Anthropic 兼容端点是否生效
+- [ ] `anthropic-beta: interleaved-thinking-2025-05-14` header 是否被 Kimi 接受
+- [ ] 流式 `tool_use` + `input_json_delta` 行为一致性
+
+写一个 `server/_probe-kimi.js`（30 行 JS）跑一遍。`npm run probe:kimi`。