dsh-plugin-image-workbench 1.1.10 → 1.1.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-image-workbench",
-  "version": "1.1.10",
+  "version": "1.1.12",
   "type": "module",
   "description": "Bluxe手绘工坊 · 生图工作台（图文 / 摄影）：DSH 侧栏图像生成工作台，默认使用内置本地账号池，亦支持任意 OpenAI 兼容接口（Base URL / API Key / 模型）；可自定义工作台名称与图片存储目录。",
   "main": "./host.js",

package/server/app.py

@@ -517,6 +517,20 @@ async def api_pool_refresh():
     return JSONResponse(POOL.snapshot())
 
 
+# 并行数：默认 3，可调，上限 = 可用账号数。调完立即生效（不重启）
+class WorkersBody(BaseModel):
+    workers: int = 0
+
+
+@app.post("/api/pool/workers")
+async def api_pool_workers(body: WorkersBody):
+    res = await POOL.set_workers(body.workers)
+    # 带一份最新快照回去，前端不用再等下一轮轮询
+    res["snapshot"] = {"workers": POOL.workers, "workers_max": POOL.workers_cap(),
+                       "queued": POOL.snapshot()["queued"]}
+    return JSONResponse(res)
+
+
 @app.get("/api/pool/fails")
 async def api_pool_fails(days: int = 7):
     """账号失败账本：今天每个号失败几次、最近几天各失败几次。

package/server/pool.py

@@ -35,9 +35,17 @@ STATE_FILE = BASE / "workbench" / "pending_jobs.json"
 DEFAULT_POOL_DIR = Path(os.environ.get(
     "DSH_IMAGE_POOL_DIR", str(Path.home() / ".dsh" / "chatgpt2api-image")))
 
-# 号池 config.json 里 image_account_concurrency=3，本地 worker 与它对齐，
-# 再多也不会更快，只会让上游排队。
-WORKERS = max(1, min(3, int(os.environ.get("WORKBENCH_WORKERS", "3") or 3)))
+# 并行数（worker 个数）现在由用户自己定：默认 3，写进 config.local.json 的 workers。
+# 上限 = 有效账号数（可用账号），一个号同时只出一张图；账号明细读不到时退回默认值，
+# 不会因为一次探测失败就把用户设置判成非法。绝对硬顶防止手抖填出四位数。
+WORKERS_DEFAULT = 3
+WORKERS_ABS_MAX = 40
+# 兼容旧引用（环境变量仍可给个初值）
+WORKERS = max(1, min(WORKERS_ABS_MAX,
+                     int(os.environ.get("WORKBENCH_WORKERS", WORKERS_DEFAULT) or WORKERS_DEFAULT)))
+# 队列里的「提前下班」令牌：并行上限下调时塞进队列，worker 取到它就退出。
+# 用令牌而不是 cancel 任务，是为了不打断正在出图的那张（cancel 会连带杀掉在途请求）
+RETIRE_TOKEN = "__wb_retire__"
 IMAGE_TIMEOUT = 300      # 实测单张 45~62 秒，留足余量
 TEXT_TIMEOUT = 180
 # 失败不中断任务：重新排队就是换号（号池按 round-robin 取号），最多换 3 轮。
@@ -333,6 +341,8 @@ def load_config() -> dict:
         "edits_style": "auto",            # auto | json | multipart | off
         "image_response_format": "auto",  # auto | b64_json | url
         "monitor_mode": "auto",           # auto | pool | single
+        # 并行出图数（worker 个数）：默认 3，上限由「可用账号数」决定
+        "workers": WORKERS,
     }
     if CONFIG_FILE.exists():
         try:
@@ -342,6 +352,39 @@ def load_config() -> dict:
     return cfg
 
 
+def save_config(updates: dict) -> dict:
+    """把若干键合并写回 config.local.json（原子替换），返回写后的完整配置。
+
+    只做浅合并：别的键原样留着，不会因为存一个并行数就把接口配置抹掉。
+    """
+    cfg: dict = {}
+    if CONFIG_FILE.exists():
+        try:
+            got = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+            if isinstance(got, dict):
+                cfg = got
+        except Exception as e:
+            log(f"config.local.json 读取失败（准备覆盖写）: {e}")
+    cfg.update(updates or {})
+    try:
+        CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+        tmp = CONFIG_FILE.with_suffix(".json.tmp")
+        tmp.write_text(json.dumps(cfg, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+        tmp.replace(CONFIG_FILE)
+    except Exception as e:
+        log(f"config.local.json 写入失败: {mask(e)[:160]}")
+    return cfg
+
+
+def workers_from_cfg() -> int:
+    """启动时的并行数：配置里存的值优先，非法值一律退回默认 3。"""
+    try:
+        n = int(load_config().get("workers") or WORKERS_DEFAULT)
+    except Exception:
+        n = WORKERS_DEFAULT
+    return max(1, min(WORKERS_ABS_MAX, n))
+
+
 def _read_pool_user_key(cfg: dict) -> str:
     """从号池目录里的 user-api-keys.json 读第一个 sk- 用户 Key（仅号池模式用）。"""
     p = pool_home(cfg) / "user-api-keys.json"
@@ -512,6 +555,11 @@ class PoolManager:
         self.queue: asyncio.Queue[str] = asyncio.Queue()
         self.running: dict[str, dict] = {}
         self._workers: list[asyncio.Task] = []
+        # 并行数：用户可调，持久化在 config.local.json 的 workers
+        self.workers: int = workers_from_cfg()
+        self._wid_seq: int = 0          # worker 编号只增不减，日志里对得上
+        self._retire_pending: int = 0   # 队列里还没被取走的「提前下班」令牌数
+        self._workers_lock = asyncio.Lock()
         # 正在执行的单个任务：手动停止时只取消它，不杀 worker，队列才能继续接新活
         self._job_tasks: dict[str, asyncio.Task] = {}
         self._lock = asyncio.Lock()
@@ -539,13 +587,80 @@ class PoolManager:
         await self.refresh_env_ids()
         await self.refresh_accounts(force=True)
         self._restore()
-        for i in range(WORKERS):
-            self._workers.append(asyncio.create_task(self._worker(i + 1)))
+        self.workers = workers_from_cfg()
+        for _ in range(self.workers):
+            self._spawn_worker()
         self._acct_task = asyncio.create_task(self._account_refresh_loop())
         p = provider_cfg()
-        log(f"本地执行层启动：{WORKERS} 个 worker，接口 {p['base_url']}"
+        log(f"本地执行层启动：{self.workers} 个 worker，接口 {p['base_url']}"
             f"（{p['name']}），已同步 {len(self.accounts)} 个账号")
 
+    def _spawn_worker(self) -> asyncio.Task:
+        self._wid_seq += 1
+        t = asyncio.create_task(self._worker(self._wid_seq))
+        self._workers.append(t)
+        return t
+
+    # ---------- 并行数（用户可调） ----------
+    def valid_accounts(self) -> int:
+        """有效账号数 = 能出图的号（可用 + 正在出图中）。
+
+        「正在出图」也是有效账号，不能因为它在忙就从上限里扣掉：否则一边出图
+        一边上限往下掉，用户刚设好的并行数会被自己压回去。
+        限流 / 已下线 / 未绑定 / 待验证 / 异常这些才算无效。
+        """
+        if self.accounts:
+            return sum(1 for a in self.accounts
+                       if a.get("status") in ("ready", "busy"))
+        # 账号明细拿不到时退回号池自报的可用数
+        try:
+            return int(self.pool_stat.get("active") or 0)
+        except Exception:
+            return 0
+
+    def workers_cap(self) -> int:
+        """并行上限：不超过有效账号数（一个号同时只出一张图）。"""
+        n = self.valid_accounts()
+        if n <= 0:
+            # 账号明细暂时读不到时不收紧，免得一次探测失败就把用户的设置判成非法
+            return max(WORKERS_DEFAULT, self.workers)
+        return max(1, min(n, WORKERS_ABS_MAX))
+
+    async def set_workers(self, n: int) -> dict:
+        """改并行数：多的立刻拉起来，少的发「下班令牌」等它把手上的图出完再退。"""
+        async with self._workers_lock:
+            cap = self.workers_cap()
+            try:
+                want = int(n)
+            except Exception:
+                return {"ok": False, "workers": self.workers, "max": cap,
+                        "message": "并行数必须是整数"}
+            if want < 1:
+                return {"ok": False, "workers": self.workers, "max": cap,
+                        "message": "并行数至少 1"}
+            target = min(want, cap)
+            old = self.workers
+            # 已经退出的 worker 任务从列表里清掉，别让列表越堆越长
+            self._workers = [t for t in self._workers if not t.done()]
+            if target > old:
+                for _ in range(target - old):
+                    self._spawn_worker()
+            elif target < old:
+                for _ in range(old - target):
+                    self._retire_pending += 1
+                    await self.queue.put(RETIRE_TOKEN)
+            self.workers = target
+            save_config({"workers": target})
+            if target != old:
+                log(f"并行数 {old} → {target}"
+                    + (f"（请求 {want}，按有效账号 {cap} 收紧）" if target != want else ""))
+        msg = f"并行上限已设为 {target}"
+        if want > cap:
+            msg = f"最多 {cap} 个：并行数不能超过有效账号数，已按 {cap} 执行"
+        return {"ok": True, "workers": target, "max": cap, "requested": want,
+                "prev": old, "clamped": want > cap, "message": msg}
+
+
     # ---------- 任务落盘 / 恢复 ----------
     def _persist(self) -> None:
         """把「还没结束」的任务写进磁盘。写完原子替换，进程被杀也不会写出半个文件。"""
@@ -868,7 +983,7 @@ class PoolManager:
 
         账号状态只在这时候才会变，监控和后台同步据此决定刷多快。
         """
-        return bool(self.running) or self.queue.qsize() > 0
+        return bool(self.running) or (self.queue.qsize() - self._retire_pending) > 0
 
     async def refresh_accounts_throttled(self, busy_interval: float = 3.0,
                                          idle_interval: float = 20.0) -> None:
@@ -1003,8 +1118,12 @@ class PoolManager:
             "busy": len(self.running),
             # 「现在有活干」：正在出图或还有排队。别和 pool_stat 里的 active（可用账号数）搞混
             "running_now": self.is_busy(),
-            "workers": WORKERS,
-            "queued": self.queue.qsize(),
+            "workers": self.workers,
+            "workers_max": self.workers_cap(),
+            "workers_default": WORKERS_DEFAULT,
+            "valid_accounts": self.valid_accounts(),
+            # 队列里混着「下班令牌」，排队数只算真任务
+            "queued": max(0, self.queue.qsize() - self._retire_pending),
             "running": running,
             "current": current,
             "rr_index": self._rr_index,
@@ -1034,11 +1153,17 @@ class PoolManager:
         '''
         stopped: list[str] = []
         dropped = 0
+        retire_lost = 0
         while True:
             try:
                 jid = self.queue.get_nowait()
             except asyncio.QueueEmpty:
                 break
+            if jid == RETIRE_TOKEN:
+                # 下班令牌不是任务，别当洪水清掉：并行数下调的意图还得兑现
+                retire_lost += 1
+                self.queue.task_done()
+                continue
             job = self.jobs.get(jid)
             if job and job.get("status") in ("queued", "running"):
                 job.update({"status": "cancelled", "error": reason,
@@ -1046,6 +1171,8 @@ class PoolManager:
                 stopped.append(jid)
                 dropped += 1
             self.queue.task_done()
+        for _ in range(retire_lost):
+            await self.queue.put(RETIRE_TOKEN)
         # 先改状态再 cancel：_run_job 的 finally 才不会写历史或安排重试
         running = []
         for jid, task in list(self._job_tasks.items()):
@@ -1083,6 +1210,11 @@ class PoolManager:
         while True:
             job_id = await self.queue.get()
             try:
+                if job_id == RETIRE_TOKEN:
+                    # 并行上限被下调：把手上的活干完再走，不打断在途请求
+                    self._retire_pending = max(0, self._retire_pending - 1)
+                    log(f"worker {wid}: 退出（并行数下调）")
+                    return
                 job = self.jobs.get(job_id)
                 if not job or job.get("status") == "cancelled":
                     continue

package/server/static/index.html

@@ -457,6 +457,24 @@
   .mon-kpi span{display:block;font-size:10.5px;color:var(--ink-3)}
   .mon-kpi b{font-size:17px;letter-spacing:.4px}
   .mon-kpi b.ok{color:var(--ok)} .mon-kpi b.warn{color:var(--warn)} .mon-kpi b.err{color:var(--err)}
+  /* 并行上限控制条：夹在 KPI 和账号表之间，一行放下，窄屏自动换行 */
+  .mon-wbar{display:flex;align-items:center;gap:8px;flex-wrap:wrap;
+    border:1px solid var(--line);border-radius:11px;padding:6px 10px;background:#fbfaff;margin:0 0 2px}
+  .mon-wbar .wlbl{font-size:11px;color:var(--ink-3)}
+  .mon-wbar .wctl{display:flex;align-items:center;gap:1px;border:1px solid var(--line);
+    background:#fff;border-radius:9px;padding:2px}
+  .mon-wbar .wbtn{width:22px;height:22px;border:0;background:transparent;color:var(--ink-2);
+    font-size:14px;line-height:1;border-radius:7px;cursor:pointer;padding:0}
+  .mon-wbar .wbtn:hover:not(:disabled){background:var(--chip);color:var(--primary)}
+  .mon-wbar .wbtn:disabled{opacity:.35;cursor:not-allowed}
+  .mon-wbar #monW{width:42px;height:22px;border:0;background:transparent;text-align:center;
+    font:600 13px/1 inherit;color:var(--primary);outline:none;padding:0}
+  .mon-wbar #monW::-webkit-outer-spin-button,.mon-wbar #monW::-webkit-inner-spin-button{-webkit-appearance:none;margin:0}
+  .mon-wbar #monW:focus{background:var(--chip);border-radius:7px}
+  .mon-wbar .whint{font-size:10.5px;color:var(--ink-3);line-height:1.5}
+  .mon-wbar .whint.ok{color:var(--ok)}
+  .mon-wbar .whint.err{color:var(--err)}
+  .mon-wbar .whint.warn{color:var(--warn)}
   .mon-sec{display:flex;align-items:center;gap:8px;margin:12px 0 6px;font-size:12px}
   .mon-sec span{font-size:11px;color:var(--ink-3)}
   .mon-sec .spacer{flex:1}
@@ -985,6 +1003,16 @@
       <button class="btn ghost mini" id="monClose" type="button">关闭</button>
     </div>
     <div class="mon-sum" id="monSum"></div>
+    <!-- 并行上限：默认 3，可自行加减。上限跟着有效账号数走（在出图的号也算），超了自动压回来 -->
+    <div class="mon-wbar">
+      <span class="wlbl">并行上限</span>
+      <div class="wctl">
+        <button type="button" class="wbtn" id="monWDown" title="减 1" aria-label="并行上限减 1">−</button>
+        <input id="monW" type="number" min="1" step="1" inputmode="numeric" aria-label="并行上限">
+        <button type="button" class="wbtn" id="monWUp" title="加 1" aria-label="并行上限加 1">+</button>
+      </div>
+      <span class="whint" id="monWHint">默认 3，最多不超过有效账号数</span>
+    </div>
     <div class="mon-sec"><b>账号状态</b><span id="monAccHint"></span><span class="spacer"></span><span id="monCheckHint"></span></div>
     <div class="mon-box">
       <table class="mon">
@@ -3916,8 +3944,92 @@ async function stopAllJobs(){
 const ST_LABEL = {ready:'可用', busy:'出图中', limited:'限流', unhealthy:'已下线', unbound:'未绑定', pending:'待验证', error:'异常'};
 let monTimer = null;
 
-function kpi(label, val, cls){
-  return `<div class="mon-kpi"><span>${label}</span><b class="${cls || ''}">${val}</b></div>`;
+/* ---------- 并行上限：默认 3，用户可调，封顶 = 有效账号数（在出图的号也算有效） ---------- */
+let _wBusy = false, _wLast = null, _wHintTimer = null;
+
+function syncWorkersCtl(d){
+  _wLast = d;
+  const inp = $('#monW'); if (!inp) return;
+  const cap = Math.max(1, Number(d.workers_max || d.workers || 3));
+  const cur = Math.max(1, Number(d.workers || 3));
+  const valid = Number(d.valid_accounts || 0);
+  inp.max = cap;
+  // 正在输入或正在提交时不覆盖，免得把用户打到一半的数字顶掉
+  if (document.activeElement !== inp && !_wBusy){
+    inp.value = cur;
+    inp.dataset.saved = cur;
+  }
+  $('#monWDown').disabled = cur <= 1;
+  $('#monWUp').disabled = cur >= cap;
+  if (_wHintTimer) return;            // 刚保存过，提示文字留给它自己过期
+  const hint = $('#monWHint');
+  const over = cur > cap;
+  hint.className = 'whint' + (over ? ' warn' : '');
+  hint.textContent = over
+    ? `当前 ${cur} 个，已超过有效账号 ${cap} 个，建议调低`
+    : `默认 3，最多 ${cap} 个${valid ? `（有效账号 ${valid} 个）` : ''}`;
+}
+
+function flashWorkersHint(ms){
+  clearTimeout(_wHintTimer);
+  _wHintTimer = setTimeout(()=>{
+    _wHintTimer = null;
+    if (_wLast) syncWorkersCtl(_wLast);
+  }, ms);
+}
+
+async function saveWorkers(v){
+  const inp = $('#monW'), hint = $('#monWHint');
+  const n = Math.round(Number(v));
+  if (!Number.isFinite(n) || n < 1){
+    hint.className = 'whint err'; hint.textContent = '并行数至少 1';
+    flashWorkersHint(2600); return;
+  }
+  if (_wBusy) return;
+  _wBusy = true;
+  hint.className = 'whint'; hint.textContent = '保存中…';
+  try{
+    const r = await fetch('/api/pool/workers', {method:'POST',
+      headers:{'Content-Type':'application/json'}, body: JSON.stringify({workers:n})});
+    const d = await r.json();
+    if (!r.ok) throw new Error(d.detail || ('HTTP ' + r.status));
+    inp.value = d.workers;
+    inp.dataset.saved = d.workers;
+    hint.className = 'whint ' + (d.clamped ? 'warn' : 'ok');
+    hint.textContent = d.message || ('并行上限已设为 ' + d.workers);
+    flashWorkersHint(4200);
+  }catch(e){
+    hint.className = 'whint err';
+    hint.textContent = '没存上：' + ((e && e.message) || e);
+    flashWorkersHint(5200);
+  }finally{
+    _wBusy = false;
+  }
+}
+
+function bindWorkersCtl(){
+  const inp = $('#monW'); if (!inp || inp._bound) return;
+  inp._bound = 1;
+  const step = (delta) => {
+    const v = Math.round(Number(inp.value) || 0) + delta;
+    inp.value = v;
+    saveWorkers(v);
+  };
+  $('#monWUp').onclick = () => step(1);
+  $('#monWDown').onclick = () => step(-1);
+  inp.addEventListener('change', () => {
+    // 回车已经存过一遍，失焦时别再发一次
+    if (Number(inp.value) === Number(inp.dataset.saved || 0)) return;
+    saveWorkers(inp.value);
+  });
+  inp.addEventListener('keydown', (e) => {
+    if (e.key === 'Enter'){ e.preventDefault(); saveWorkers(inp.value); inp.blur(); }
+    if (e.key === 'Escape'){ e.preventDefault(); inp.blur(); }
+  });
+}
+
+function kpi(label, val, cls, tip){
+  return `<div class="mon-kpi"${tip ? ` title="${tip}"` : ''}><span>${label}</span><b class="${cls || ''}">${val}</b></div>`;
 }
 
 function agoText(ts){
@@ -3945,11 +4057,13 @@ function renderMonitor(d){
   const kTotal = accs.length ? accs.filter(a=>a.env_id).length : Number(poolS.total || 0);
   $('#monSum').innerHTML =
       kpi('账号可用', `${kReady}/${kTotal}`, kReady ? 'ok' : 'err')
-    + kpi('并行任务', `${run.length}/${d.workers || 1}`, run.length ? 'warn' : '')
+    + kpi('并行任务', `${run.length}/${d.workers || 1}`, run.length ? 'warn' : '',
+          '并行上限可调：改下面那条「并行上限」的 − / + 或直接填数字，最多不超过有效账号数')
     + kpi('排队', d.queued || 0, d.queued ? 'warn' : '')
     + kpi('今日成功', hist.today_done || 0, 'ok')
     + kpi('今日失败', hist.today_error || 0, hist.today_error ? 'err' : '')
     + kpi('历史总量', hist.total || 0, '');
+  syncWorkersCtl(d);
 
   let lastUsedAcc = null;
   for (const a of accs){
@@ -4073,6 +4187,7 @@ async function refreshMonitor(){
 }
 
 async function openMonitor(){
+  bindWorkersCtl();
   $('#monitorDlg').showModal();
   await refreshMonitor();
   scheduleMonitor();