@jacksontian/kite-server 0.4.0 → 0.5.0

package/README.md

@@ -1,17 +1,17 @@
 # @jacksontian/kite-server
 
 [kite](https://github.com/jacksontian/remote-work) 的云端信箱组件：部署在你的云服务器（VPS）上，
-提供 HMAC 签名鉴权的任务队列 API、WebSocket 实时推送和 Web 控制台（手机/PC 双版）。
+提供 HMAC 签名鉴权的会话队列 API、WebSocket 实时推送和 Web 控制台（手机/PC 双版）。
 
 整体架构、端到端部署流程见仓库根 README；本文只讲 server 这一侧。
 
 ## 职责
 
-- 接收控制台提交的任务，持久化到 `dataDir`（任务队列 / 日志 / 结果）
-- 通过 `/worker/ws` 出站长连接向 Worker 即时推送新任务，Worker 不监听任何端口
-- 托管 Web 控制台（`web/` 随包分发），浏览器打开即用；首页按 UA 自动分发
-  手机版（`index.html`）/ PC 版（`pc.html`），也可显式访问对应路径
-- 任务终态可选推送到钉钉群机器人（`imWebhook`）
+- 接收控制台提交的会话，持久化到 `dataDir`（会话队列 / 日志 / 结果）
+- 通过 `/worker/ws` 出站长连接向 Worker 即时推送新会话，Worker 不监听任何端口
+- 托管 Web 控制台（`web/` 随包分发），浏览器打开即用；单页应用（`index.html` 一份），
+  手机/PC 自适应同一套界面
+- 会话终态可选推送到钉钉群机器人（`imWebhook`）
 
 ## 安装与启动
 
@@ -48,8 +48,8 @@ kites start   # 前台启动服务；常驻托管交给 systemd（见下文 depl
 | `logFile` | 程序自写日志文件，默认 `~/.kites/logs/server.log`；超 10MB 轮转并逐代顺延（`.1` 最新），stdout 输出不受影响 |
 | `logLevel` | 日志落盘最低级别（`debug`\|`info`\|`warn`\|`error`），默认 `info`；只过滤落盘，前台输出不受影响 |
 | `logKeep` | 轮转保留代数（`server.log.1` … `.N`），默认 5，超出自动删除最旧一代 |
-| `maxTasks` | 终态任务最多保留条数 |
-| `staleRunningSec` | running 任务超时回收秒数（Worker 离线时判失败，pty 会话不受此限） |
+| `maxSessions` | 终态会话最多保留条数 |
+| `staleRunningSec` | running 会话超时回收秒数（Worker 离线时判失败，pty 会话不受此限） |
 | `sigWindowSec` | 签名时间窗（秒），两端时钟漂移大时可调宽 |
 | `ptyIdleSec` | pty 会话空闲回收秒数 |
 | `imWebhook` / `imSecret` / `imNotifyEvents` | 钉钉群机器人通知，留空则完全静默 |
@@ -64,9 +64,9 @@ conf/data/logs 布局）；生产托管以 `www-data` 运行时即 `/var/www/.ki
 ├── conf/
 │   └── server.yaml              # 配置（默认读这里，可用 --config 指定别处；模板见包内 config.example.yaml）
 ├── data/                        # dataDir：持久化目录
-│   ├── tasks.json               # 任务队列 + 日志 + 结果（0600，含全部命令与输出，勿外传）
-│   ├── tasks.json.tmp           # 落盘中转文件（写完整后 rename 原子替换，正常情况不会残留）
-│   └── tasks.json.corrupt-<ts>  # tasks.json 解析失败时的自动备份（仅在损坏时出现）
+│   ├── sessions.json               # 会话队列 + 日志 + 结果（0600，含全部命令与输出，勿外传）
+│   ├── sessions.json.tmp           # 落盘中转文件（写完整后 rename 原子替换，正常情况不会残留）
+│   └── sessions.json.corrupt-<ts>  # sessions.json 解析失败时的自动备份（仅在损坏时出现）
 └── logs/
     ├── server.log               # logFile：程序自写日志（每条一行：时间/级别/pid/内容）
     └── server.log.1 … .N        # 轮转历史（超 10MB 顺延一代，保留 logKeep 代，默认 5）

package/bin/server.js

@@ -2,7 +2,7 @@
 /**
  * kite 云端信箱 API
  *
- * 职责：签名鉴权、任务信箱（手机写入 / Worker 领取）、日志与结果收集、
+ * 职责：签名鉴权、会话信箱（手机写入 / Worker 领取）、日志与结果收集、
  *       Worker 心跳、托管手机端 Web 控制台。
  *
  * 模块划分（lib/）：持久化 store、签名鉴权 auth、API 路由 api、IM 通知 im、
@@ -17,9 +17,9 @@
  *   签名串：方法、路径、时间戳、nonce、请求体 SHA256，五行以换行符连接
  *   请求头：X-RW-Ts（秒级时间戳）、X-RW-Nonce（随机串）、X-RW-Sig（hex）
  *   WS 鉴权：首条消息 { type:'auth', ts, nonce, sig }，签名串 "WS\nTS\nNONCE"
- *   WS 通道：/ws 控制台实时广播 + pty 终端输入上行；/worker/ws Worker 任务通知
+ *   WS 通道：/ws 控制台实时广播 + pty 终端输入上行；/worker/ws Worker 会话通知
  *            与 pty 会话 IO 中继（session.output 下行广播、session.input 定向转发）。
- *            有任务即推 task.available，领取仍走 HTTP claim，轮询兜底不丢任务
+ *            有会话即推 session.available，领取仍走 HTTP claim，轮询兜底不丢会话
  *
  * 配置文件（--config 传入的 YAML 文件，唯一配置来源，不再读取环境变量；
  * 字段说明与模板见包内 config.example.yaml）：
@@ -40,12 +40,12 @@
  *   logLevel            可选，日志落盘最低级别（debug|info|warn|error），默认 info；
  *                       只过滤落盘，前台输出不受影响
  *   logKeep             可选，轮转保留代数（server.log.1 … .N），默认 5
- *   maxTasks           可选，终态任务保留条数，默认 200
- *   staleRunningSec    可选，running 任务超过该时长且 Worker 离线则判失败，默认 600；
+ *   maxSessions           可选，终态会话保留条数，默认 200
+ *   staleRunningSec    可选，running 会话超过该时长且 Worker 离线则判失败，默认 600；
  *                      pty 交互会话不受此限，由 ptyIdleSec 空闲回收
  *   sigWindowSec       可选，签名时间窗（秒），默认 300；两端时钟漂移大时可调宽
  *   ptyIdleSec         可选，pty 会话空闲（Worker 断开且无控制台输入）回收秒数，默认 90
- *   imWebhook          可选，钉钉群机器人 webhook 地址；配置后任务终态事件以 markdown 推送到群
+ *   imWebhook          可选，钉钉群机器人 webhook 地址；配置后会话终态事件以 markdown 推送到群
  *   imSecret           可选，机器人“加签”安全设置的密钥（SEC 开头）；关键词/白名单模式留空
  *   imNotifyEvents     可选，触发推送的事件集合（数组）：done|failed|canceled，默认 [failed]
  */
@@ -56,7 +56,7 @@ import { fileURLToPath } from 'node:url';
 import { loadServerConfig } from '../lib/config.js';
 import { enableLogFile } from '../lib/logger.js';
 import { json } from '../lib/util.js';
-import { taskSummary } from '../lib/summary.js';
+import { sessionSummary } from '../lib/summary.js';
 import { createChannels } from '../lib/broadcast.js';
 import { createStore } from '../lib/store.js';
 import { createImNotifier } from '../lib/im.js';
@@ -82,7 +82,7 @@ const WEB_DIR = path.join(__dirname, '..', 'web');
 
 const ctx = { cfg };
 Object.assign(ctx, createChannels());
-ctx.taskSummary = taskSummary;
+ctx.sessionSummary = sessionSummary;
 Object.assign(ctx, createStore(ctx));
 ctx.notifyIm = createImNotifier(ctx);
 Object.assign(ctx, createPtyHub(ctx));

package/config.example.yaml

@@ -16,7 +16,7 @@ workerSecret: ""
 
 # 可选：多 Worker 独立密钥（workerId -> 密钥映射，每台 Worker 一个，
 # 各用 kites keygen 生成）。配置后服务端把 Worker 身份绑定到验签命中的密钥：
-# 自报 workerId 必须与映射键一致，Worker 之间无法互相领取定向任务/伪造上报。
+# 自报 workerId 必须与映射键一致，Worker 之间无法互相领取定向会话/伪造上报。
 # 各 Worker 的 worker.yaml 里 workerId 与映射键一致、apiSecret 填对应密钥。
 # 可与上面的 workerSecret 并存（命中共享密钥时身份仍自报，兼容旧部署）
 # workerSecrets:
@@ -40,10 +40,10 @@ logLevel: info
 # 轮转保留代数（server.log.1 … server.log.N），超出自动删除最旧一代
 logKeep: 5
 
-# 终态（done/failed/canceled）任务最多保留条数
-maxTasks: 200
+# 终态（done/failed/canceled）会话最多保留条数
+maxSessions: 200
 
-# running 任务超过该秒数且 Worker 离线则判失败（pty 交互会话不受此限）
+# running 会话超过该秒数且 Worker 离线则判失败（pty 交互会话不受此限）
 staleRunningSec: 600
 
 # 签名时间窗（秒）；两端时钟漂移大时可调宽
@@ -52,7 +52,7 @@ sigWindowSec: 300
 # pty 会话空闲（Worker 断开且无控制台输入）回收秒数
 ptyIdleSec: 90
 
-# 钉钉群机器人 webhook；配置后任务终态事件以 markdown 推送到群，留空则完全静默
+# 钉钉群机器人 webhook；配置后会话终态事件以 markdown 推送到群，留空则完全静默
 imWebhook: ""
 
 # 机器人启用“加签”安全设置时的密钥（SEC 开头）；关键词/白名单模式留空

package/lib/api.js

@@ -1,15 +1,17 @@
 /**
- * API 路由：Worker 领取/心跳/上报，控制台建任务/查询/取消/关终端。
+ * API 路由：Worker 领取/心跳/上报，控制台建会话/查询/取消/关终端。
  */
 
 import crypto from 'node:crypto';
-import { json, parseBody, publicTask } from './util.js';
+import { json, parseBody, publicSession } from './util.js';
 import { workersSnapshot } from './summary.js';
 
 const MAX_LOG_LINES = 2000;
-// pending 任务数上限：密钥泄露/控制台失守时防无限灌任务撑爆内存与 tasks.json
-// （pruneFinishedTasks 只清终态，堆积的 pending 没有任何自然出口）
-const MAX_PENDING_TASKS = 100;
+// pending 会话数上限：密钥泄露/控制台失守时防无限灌会话撑爆内存与 sessions.json
+// （pruneFinishedSessions 只清终态，堆积的 pending 没有任何自然出口）
+const MAX_PENDING_SESSIONS = 100;
+// 单个 Worker 同时会话数（pending + running）上限：防止一台 Worker 被堆满终端占死机器资源
+const MAX_SESSIONS_PER_WORKER = 6;
 
 export function createApi(ctx) {
   // 身份绑定：配置 workerSecrets 时验签密钥即决定 Worker 身份；
@@ -21,31 +23,40 @@ export function createApi(ctx) {
   }
 
   // 归属校验（仅身份绑定生效时启用）：只允许领取者上报日志/结果，
-  // 防止其他 Worker 伪造他人任务（含未领取任务）的日志与终态；
+  // 防止其他 Worker 伪造他人会话（含未领取会话）的日志与终态；
   // 共享密钥模式（authedWorkerId 为 null）维持旧行为
-  function canReportTask(task, authedWorkerId) {
-    return !authedWorkerId || task.workerId === authedWorkerId;
+  function canReportSession(session, authedWorkerId) {
+    return !authedWorkerId || session.workerId === authedWorkerId;
+  }
+
+  // 把 pending 会话落为 canceled 并广播（取消接口与关终端接口共用）
+  function cancelSession(session) {
+    session.status = 'canceled';
+    session.finishedAt = Date.now();
+    ctx.scheduleSave();
+    ctx.broadcast({ type: 'session.updated', session: ctx.sessionSummary(session) });
+    ctx.notifyIm(session, 'canceled');
   }
 
   async function handleApi(req, res, pathname, rawBody, authedWorkerId) {
     ctx.sweepStaleRunning();
     const body = parseBody(rawBody);
 
-    // --- Worker：领取最老的 pending 任务（原子置为 running）---
+    // --- Worker：领取最老的 pending 会话（原子置为 running）---
     if (req.method === 'POST' && pathname === '/api/worker/claim') {
       const workerId = resolveWorkerId(authedWorkerId, body.workerId);
       if (!workerId) return json(res, 401, { error: 'workerId 与密钥绑定的身份不一致' });
-      // 显式指派模型：只领取指名给本 Worker 的任务，Worker 之间不存在竞争
-      const task = ctx.state.tasks.find(
+      // 显式指派模型：只领取指名给本 Worker 的会话，Worker 之间不存在竞争
+      const session = ctx.state.sessions.find(
         (t) => t.status === 'pending' && t.targetWorker === workerId,
       );
-      if (!task) return json(res, 200, { task: null });
-      task.status = 'running';
-      task.workerId = workerId;
-      task.startedAt = Date.now();
+      if (!session) return json(res, 200, { session: null });
+      session.status = 'running';
+      session.workerId = workerId;
+      session.startedAt = Date.now();
       ctx.scheduleSave();
-      ctx.broadcast({ type: 'task.updated', task: ctx.taskSummary(task) });
-      return json(res, 200, { task });
+      ctx.broadcast({ type: 'session.updated', session: ctx.sessionSummary(session) });
+      return json(res, 200, { session });
     }
 
     // --- Worker：心跳 ---
@@ -71,18 +82,18 @@ export function createApi(ctx) {
       return json(res, 200, { workers: workersSnapshot(ctx.state.heartbeats) });
     }
 
-    // --- 创建任务（pending 超限拒绝，见 MAX_PENDING_TASKS）---
-    if (req.method === 'POST' && pathname === '/api/tasks') {
+    // --- 创建会话（pending 超限拒绝，见 MAX_PENDING_SESSIONS）---
+    if (req.method === 'POST' && pathname === '/api/sessions') {
       const type = String(body.type || '');
       if (type !== 'pty') {
         return json(res, 400, { error: 'type 必须是 pty' });
       }
-      const pendingCount = ctx.state.tasks.filter((t) => t.status === 'pending').length;
-      if (pendingCount >= MAX_PENDING_TASKS) {
-        return json(res, 429, { error: `待执行任务已达上限（${MAX_PENDING_TASKS}），请先消化积压` });
+      const pendingCount = ctx.state.sessions.filter((t) => t.status === 'pending').length;
+      if (pendingCount >= MAX_PENDING_SESSIONS) {
+        return json(res, 429, { error: `待执行会话已达上限（${MAX_PENDING_SESSIONS}），请先消化积压` });
       }
       // 显式指派模型：targetWorker 必填且必须是已注册（心跳过）的 Worker，
-      // 杜绝无人可领的孤儿任务永远 pending
+      // 杜绝无人可领的孤儿会话永远 pending
       const tw = String(body.targetWorker || '').trim().slice(0, 128);
       if (!tw) {
         return json(res, 400, { error: '必须指定目标 Worker（targetWorker）' });
@@ -94,7 +105,14 @@ export function createApi(ctx) {
         return json(res, 400, { error: `Worker "${tw}" 从未注册，无法指派` });
       }
       const targetWorker = tw;
-      const task = {
+      // 每 Worker 并发上限：只计进行中会话（终态记录不占额；入口已先经 sweepStaleRunning 回收）
+      const activeCount = ctx.state.sessions.filter(
+        (t) => t.targetWorker === targetWorker && (t.status === 'pending' || t.status === 'running'),
+      ).length;
+      if (activeCount >= MAX_SESSIONS_PER_WORKER) {
+        return json(res, 429, { error: `Worker "${targetWorker}" 同时会话已达上限（${MAX_SESSIONS_PER_WORKER}），请先关闭部分会话` });
+      }
+      const session = {
         id: crypto.randomUUID(),
         type,
         title: String(body.title || '').slice(0, 200),
@@ -105,100 +123,122 @@ export function createApi(ctx) {
         createdAt: Date.now(),
         startedAt: null,
         finishedAt: null,
+        openedAt: Date.now(), // 新建即视为已打开（控制台开窗标记，服务端持久化供任意客户端恢复）
         workerId: null,
         targetWorker,
       };
-      ctx.state.tasks.push(task);
+      ctx.state.sessions.push(session);
       ctx.scheduleSave();
-      ctx.broadcast({ type: 'task.created', task: ctx.taskSummary(task) });
-      ctx.notifyWorkers(targetWorker); // 任务到达即推送，Worker 立即领取，不再等轮询周期
-      return json(res, 201, publicTask(task));
+      ctx.broadcast({ type: 'session.created', session: ctx.sessionSummary(session) });
+      ctx.notifyWorkers(targetWorker); // 会话到达即推送，Worker 立即领取，不再等轮询周期
+      return json(res, 201, publicSession(session));
     }
 
-    // --- 任务列表 ---
-    if (req.method === 'GET' && pathname === '/api/tasks') {
+    // --- 会话列表 ---
+    if (req.method === 'GET' && pathname === '/api/sessions') {
       const url = new URL(req.url, 'http://localhost');
       const limit = Math.max(1, Math.min(Number(url.searchParams.get('limit')) || 50, 200));
-      const list = [...ctx.state.tasks]
+      const list = [...ctx.state.sessions]
         .sort((a, b) => b.createdAt - a.createdAt)
         .slice(0, limit)
-        .map(ctx.taskSummary);
-      return json(res, 200, { tasks: list });
+        .map(ctx.sessionSummary);
+      return json(res, 200, { sessions: list });
     }
 
-    // --- 单个任务详情（含日志）---
-    const taskMatch = pathname.match(/^\/api\/tasks\/([0-9a-f-]{36})$/);
-    if (req.method === 'GET' && taskMatch) {
-      const task = ctx.state.tasks.find((t) => t.id === taskMatch[1]);
-      if (!task) return json(res, 404, { error: 'task not found' });
-      return json(res, 200, publicTask(task));
+    // --- 单个会话详情（含日志）---
+    const sessionMatch = pathname.match(/^\/api\/sessions\/([0-9a-f-]{36})$/);
+    if (req.method === 'GET' && sessionMatch) {
+      const session = ctx.state.sessions.find((t) => t.id === sessionMatch[1]);
+      if (!session) return json(res, 404, { error: 'session not found' });
+      return json(res, 200, publicSession(session));
     }
 
     // --- 追加日志（Worker）---
-    const logMatch = pathname.match(/^\/api\/tasks\/([0-9a-f-]{36})\/logs$/);
+    const logMatch = pathname.match(/^\/api\/sessions\/([0-9a-f-]{36})\/logs$/);
     if (req.method === 'POST' && logMatch) {
-      const task = ctx.state.tasks.find((t) => t.id === logMatch[1]);
-      if (!task) return json(res, 404, { error: 'task not found' });
-      if (!canReportTask(task, authedWorkerId)) {
-        return json(res, 403, { error: '只能上报自己领取的任务' });
+      const session = ctx.state.sessions.find((t) => t.id === logMatch[1]);
+      if (!session) return json(res, 404, { error: 'session not found' });
+      if (!canReportSession(session, authedWorkerId)) {
+        return json(res, 403, { error: '只能上报自己领取的会话' });
       }
       const lines = Array.isArray(body.lines) ? body.lines : [];
       for (const line of lines) {
-        task.logs.push(String(line).slice(0, 4000));
+        session.logs.push(String(line).slice(0, 4000));
       }
-      if (task.logs.length > MAX_LOG_LINES) {
-        task.logs.splice(0, task.logs.length - MAX_LOG_LINES);
+      if (session.logs.length > MAX_LOG_LINES) {
+        session.logs.splice(0, session.logs.length - MAX_LOG_LINES);
       }
       ctx.scheduleSave();
-      ctx.broadcast({ type: 'task.logs', id: task.id, lines });
-      return json(res, 200, { ok: true, logCount: task.logs.length });
+      ctx.broadcast({ type: 'session.logs', id: session.id, lines });
+      return json(res, 200, { ok: true, logCount: session.logs.length });
     }
 
-    // --- 结束任务（Worker）---
-    const finishMatch = pathname.match(/^\/api\/tasks\/([0-9a-f-]{36})\/finish$/);
+    // --- 结束会话（Worker）---
+    const finishMatch = pathname.match(/^\/api\/sessions\/([0-9a-f-]{36})\/finish$/);
     if (req.method === 'POST' && finishMatch) {
-      const task = ctx.state.tasks.find((t) => t.id === finishMatch[1]);
-      if (!task) return json(res, 404, { error: 'task not found' });
-      if (!canReportTask(task, authedWorkerId)) {
-        return json(res, 403, { error: '只能上报自己领取的任务' });
+      const session = ctx.state.sessions.find((t) => t.id === finishMatch[1]);
+      if (!session) return json(res, 404, { error: 'session not found' });
+      if (!canReportSession(session, authedWorkerId)) {
+        return json(res, 403, { error: '只能上报自己领取的会话' });
       }
-      // 状态守卫：已到终态（被 sweepStaleRunning 判失败回收、控制台取消等）的任务
+      // 状态守卫：已到终态（被 sweepStaleRunning 判失败回收、控制台取消等）的会话
       // 拒绝迟到的 finish，防止短暂失联后"复活"的 Worker 把终态翻回
-      if (task.status !== 'running') {
-        return json(res, 409, { error: `任务已处于终态（${task.status}），拒绝 finish 上报` });
+      if (session.status !== 'running') {
+        return json(res, 409, { error: `会话已处于终态（${session.status}），拒绝 finish 上报` });
       }
-      task.status = body.status === 'done' ? 'done' : 'failed';
-      task.result = body.result ?? null;
-      task.finishedAt = Date.now();
+      session.status = body.status === 'done' ? 'done' : 'failed';
+      session.result = body.result ?? null;
+      session.finishedAt = Date.now();
       ctx.scheduleSave();
-      ctx.broadcast({ type: 'task.updated', task: ctx.taskSummary(task), result: task.result });
-      ctx.notifyIm(task, task.status);
-      return json(res, 200, publicTask(task));
+      ctx.broadcast({ type: 'session.updated', session: ctx.sessionSummary(session), result: session.result });
+      ctx.notifyIm(session, session.status);
+      return json(res, 200, publicSession(session));
     }
 
-    // --- 取消任务（控制台；仅对 pending 生效）---
-    const cancelMatch = pathname.match(/^\/api\/tasks\/([0-9a-f-]{36})\/cancel$/);
+    // --- 取消会话（控制台；仅对 pending 生效）---
+    const cancelMatch = pathname.match(/^\/api\/sessions\/([0-9a-f-]{36})\/cancel$/);
     if (req.method === 'POST' && cancelMatch) {
-      const task = ctx.state.tasks.find((t) => t.id === cancelMatch[1]);
-      if (!task) return json(res, 404, { error: 'task not found' });
-      if (task.status !== 'pending') {
-        return json(res, 409, { error: `只能取消 pending 任务，当前状态：${task.status}` });
+      const session = ctx.state.sessions.find((t) => t.id === cancelMatch[1]);
+      if (!session) return json(res, 404, { error: 'session not found' });
+      if (session.status !== 'pending') {
+        return json(res, 409, { error: `只能取消 pending 会话，当前状态：${session.status}` });
       }
-      task.status = 'canceled';
-      task.finishedAt = Date.now();
+      cancelSession(session);
+      return json(res, 200, publicSession(session));
+    }
+
+    // --- 标记会话终端已打开（控制台）：开窗即落服务端，刷新/换浏览器都能恢复现场；
+    // 关窗即关会话（kill 删记录），故不需要「取消打开」接口 ---
+    const openMatch = pathname.match(/^\/api\/sessions\/([0-9a-f-]{36})\/open$/);
+    if (req.method === 'POST' && openMatch) {
+      const session = ctx.state.sessions.find((t) => t.id === openMatch[1]);
+      if (!session) return json(res, 404, { error: 'session not found' });
+      session.openedAt = Date.now();
       ctx.scheduleSave();
-      ctx.broadcast({ type: 'task.updated', task: ctx.taskSummary(task) });
-      ctx.notifyIm(task, 'canceled');
-      return json(res, 200, publicTask(task));
+      ctx.broadcast({ type: 'session.updated', session: ctx.sessionSummary(session) });
+      return json(res, 200, { ok: true });
     }
 
-    // --- 关闭交互终端（控制台）：通知持有会话的 Worker 杀掉 PTY，
-    // 任务终态仍由 Worker 的 finish 上报闭环 ---
-    const killMatch = pathname.match(/^\/api\/tasks\/([0-9a-f-]{36})\/kill$/);
+    // --- 关闭交互终端（控制台）：✕ 关窗即关会话——关闭即删除记录，刷新不再回来 ---
+    // 有活跃通道先通知 Worker 杀 PTY，随后从会话列表删除并广播 session.closed；
+    // 迟到的 exited/finish 上报只会收到 404（Worker 侧已容忍）；
+    // 记录已删但 Worker 仍残留的 PTY，在重连重挂时由无记录守卫回收（见 websocket.js）
+    const killMatch = pathname.match(/^\/api\/sessions\/([0-9a-f-]{36})\/kill$/);
     if (req.method === 'POST' && killMatch) {
-      const s = ctx.ptySessions.get(killMatch[1]);
-      if (!s) return json(res, 404, { error: '没有活跃的终端会话' });
-      ctx.wsSendJson(s.ws, { type: 'session.close', taskId: killMatch[1] });
+      const id = killMatch[1];
+      const session = ctx.state.sessions.find((t) => t.id === id);
+      if (!session) return json(res, 404, { error: 'session not found' });
+      const s = ctx.ptySessions.get(id);
+      if (s && s.ws && s.ws.readyState === s.ws.OPEN) {
+        ctx.wsSendJson(s.ws, { type: 'session.close', sessionId: id });
+      }
+      if (!['done', 'failed', 'canceled'].includes(session.status)) {
+        ctx.notifyIm(session, 'canceled'); // 主动关闭视作取消类事件，是否推送仍由配置决定
+      }
+      ctx.state.sessions.splice(ctx.state.sessions.indexOf(session), 1);
+      ctx.ptySessions.delete(id);
+      ctx.scheduleSave();
+      ctx.broadcast({ type: 'session.closed', id });
       return json(res, 200, { ok: true });
     }
 

package/lib/auth.js

@@ -98,7 +98,7 @@ export function createAuth(ctx) {
 
   // 路由 -> 可接受的密钥条目：Worker 侧 API 只认 WORKER_AUTH 条目，控制台只认
   // API_SECRET；worker/status 两端都要读（控制台轮询兜底也用），两边密钥都放行
-  const WORKER_PATH = /^\/api\/(worker\/(claim|heartbeat)|tasks\/[0-9a-f-]{36}\/(logs|finish))$/;
+  const WORKER_PATH = /^\/api\/(worker\/(claim|heartbeat)|sessions\/[0-9a-f-]{36}\/(logs|finish))$/;
   function secretsForPath(pathname) {
     if (pathname === '/api/worker/status') {
       return [{ secret: API_SECRET, workerId: null }, ...WORKER_AUTH];

package/lib/broadcast.js

@@ -1,6 +1,6 @@
 /**
- * WebSocket 实时推送：控制台通过 /ws 建立长连接，任务变更即时下发；
- * Worker 通过 /worker/ws 建立长连接，仅接收任务到达通知。
+ * WebSocket 实时推送：控制台通过 /ws 建立长连接，会话变更即时下发；
+ * Worker 通过 /worker/ws 建立长连接，仅接收会话到达通知。
  * 本模块只维护已鉴权连接集合与广播函数，连接建立见 lib/websocket.js。
  */
 
@@ -21,7 +21,7 @@ export function createChannels() {
   // 显式指派模型：只唤醒指名 Worker 的连接，其他 Worker 完全不被打扰
   function notifyWorkers(targetWorker) {
     if (!wsWorkers.size || !targetWorker) return;
-    const data = JSON.stringify({ type: 'task.available', targetWorker });
+    const data = JSON.stringify({ type: 'session.available', targetWorker });
     for (const ws of wsWorkers) {
       if (ws.workerId === targetWorker) ws.send(data);
     }

package/lib/config.js

@@ -90,7 +90,7 @@ const CONFIG_SCHEMA = z.strictObject({
     .min(1, 'logKeep 至少保留 1 代')
     .max(100, 'logKeep 超出范围 [1, 100]')
     .default(5),
-  maxTasks: z.coerce.number({ error: 'maxTasks 必须是数字' }).positive('maxTasks 必须是正数').default(200),
+  maxSessions: z.coerce.number({ error: 'maxSessions 必须是数字' }).positive('maxSessions 必须是正数').default(200),
   staleRunningSec: z.coerce
     .number({ error: 'staleRunningSec 必须是数字' })
     .positive('staleRunningSec 必须是正数')
@@ -269,7 +269,7 @@ export async function loadServerConfig() {
     logFile,
     logLevel: v.logLevel,
     logKeep: v.logKeep,
-    maxTasks: v.maxTasks,
+    maxSessions: v.maxSessions,
     staleRunningMs: v.staleRunningSec * 1000,
     sigWindowSec: v.sigWindowSec,
     ptyIdleMs: v.ptyIdleSec * 1000,

package/lib/im.js

@@ -1,5 +1,5 @@
 /**
- * IM 群通知：任务终态事件推送钉钉群机器人（markdown），走 dingbot SDK；
+ * IM 群通知：会话终态事件推送钉钉群机器人（markdown），走 dingbot SDK；
  * 机器人启用“加签”安全设置时由 imSecret 自动完成 timestamp+sign 拼接。
  * 未配置 imWebhook 完全静默；发送失败只记日志，绝不抛出影响主链路。
  */
@@ -17,16 +17,16 @@ export function createImNotifier(ctx) {
 
   const IM_BOT = IM_WEBHOOK ? new DingBot(IM_WEBHOOK, { timeout: 10_000 }, IM_SECRET || undefined) : null;
 
-  // 推送摘要：pty 任务只有项目目录
-  function imPayloadBrief(task) {
-    const p = task.payload || {};
-    if (task.type === 'pty') {
+  // 推送摘要：pty 会话只有项目目录
+  function imPayloadBrief(session) {
+    const p = session.payload || {};
+    if (session.type === 'pty') {
       return p.project ? `交互终端（项目：${p.project}）` : '交互终端';
     }
     return '';
   }
 
-  function notifyIm(task, event) {
+  function notifyIm(session, event) {
     if (!IM_BOT || !IM_NOTIFY_EVENTS.has(event)) return;
     const meta = IM_STATUS_META[event] || { icon: 'ℹ️', label: event };
     const fmtTime = (ms) => new Date(ms).toLocaleString('zh-CN', { hour12: false });
@@ -35,35 +35,35 @@ export function createImNotifier(ctx) {
     const truncate = (s, n) => (s.length > n ? `${s.slice(0, n - 8)} … ${s.slice(-4)}` : s);
 
     const lines = [
-      `### ${meta.icon} 任务${meta.label}：${task.title || task.type}`,
-      `- 类型：${task.type}`,
+      `### ${meta.icon} 会话${meta.label}：${session.title || session.type}`,
+      `- 类型：${session.type}`,
     ];
-    const hb = task.workerId ? ctx.state.heartbeats[task.workerId] : null;
-    if (task.workerId) {
-      lines.push(`- Worker：${hb?.hostname ? `${hb.hostname}（${task.workerId}）` : task.workerId}`);
+    const hb = session.workerId ? ctx.state.heartbeats[session.workerId] : null;
+    if (session.workerId) {
+      lines.push(`- Worker：${hb?.hostname ? `${hb.hostname}（${session.workerId}）` : session.workerId}`);
     }
-    const brief = imPayloadBrief(task);
+    const brief = imPayloadBrief(session);
     if (brief) lines.push(`- 内容：${truncate(brief, 200)}`);
-    if (task.createdAt) lines.push(`- 创建：${fmtTime(task.createdAt)}`);
-    if (task.startedAt) lines.push(`- 开始：${fmtTime(task.startedAt)}`);
-    if (task.finishedAt) lines.push(`- 结束：${fmtTime(task.finishedAt)}`);
-    if (task.startedAt && task.finishedAt) {
-      lines.push(`- 耗时：${fmtDur(task.finishedAt - task.startedAt)}`);
+    if (session.createdAt) lines.push(`- 创建：${fmtTime(session.createdAt)}`);
+    if (session.startedAt) lines.push(`- 开始：${fmtTime(session.startedAt)}`);
+    if (session.finishedAt) lines.push(`- 结束：${fmtTime(session.finishedAt)}`);
+    if (session.startedAt && session.finishedAt) {
+      lines.push(`- 耗时：${fmtDur(session.finishedAt - session.startedAt)}`);
     }
-    if (task.result) {
-      const detail = String(task.result.error || JSON.stringify(task.result)).slice(0, 300);
+    if (session.result) {
+      const detail = String(session.result.error || JSON.stringify(session.result)).slice(0, 300);
       if (detail !== '{}') lines.push(`- 结果：${detail}`);
     }
     // 日志末尾几行，失败时可直接看到报错上下文
-    const tail = (task.logs || [])
+    const tail = (session.logs || [])
       .filter((l) => !/^\[(server|worker)\]/.test(l) && l.trim())
       .slice(-3)
       .map((l) => truncate(String(l), 150));
     if (tail.length) lines.push('**日志末尾：**', ...tail.map((l) => `> ${l}`));
-    lines.push(`任务 ID：\`${task.id}\``);
+    lines.push(`会话 ID：\`${session.id}\``);
     // SDK 内部校验钉钉返回的 errcode（关键词/加签拦截、限流等业务错误）并抛错
-    IM_BOT.markdown(`kite 任务${meta.label}`, lines.join('\n'))
-      .catch((err) => console.error(`[server] IM 推送失败（${task.id}）：${err.message}`));
+    IM_BOT.markdown(`kite 会话${meta.label}`, lines.join('\n'))
+      .catch((err) => console.error(`[server] IM 推送失败（${session.id}）：${err.message}`));
   }
 
   return notifyIm;

package/lib/logger.js

@@ -84,7 +84,7 @@ export function createFileLogger(logFile, { level = 'info', keep = KEEP_FILES, m
   };
 
   // 异步串行队列：打开/写入/轮转/关闭按调用顺序逐个执行；
-  // 队列内部消化所有异常，永不 reject（否则后续任务会被跳过）
+  // 队列内部消化所有异常，永不 reject（否则后续会话会被跳过）
   let queue = open();
 
   const append = (lvl, args) => {

package/lib/pty.js

@@ -1,5 +1,5 @@
 /**
- * pty 会话中继：taskId -> { ws, tail, lastActiveAt }
+ * pty 会话中继：sessionId -> { ws, tail, lastActiveAt }
  * Worker 上行 session.output -> 追加回看缓冲并广播控制台；
  * 控制台下行 session.input/resize/close -> 定向转发给持有会话的 Worker。
  * 回看缓冲只留末尾 16KB，手机切后台重连终端不至于白屏。
@@ -16,33 +16,33 @@ export function createPtyHub(ctx) {
     if (ws && ws.readyState === ws.OPEN) ws.send(JSON.stringify(msg));
   }
 
-  // 关闭会话并（可选）把 running 的 pty 任务落为终态；reason 为空表示 Worker
-  // 正常上报退出，任务终态由 Worker 的 finish 上报负责，这里只清会话
-  function closePtySession(taskId, { status, error, reason }) {
-    const s = ptySessions.get(taskId);
-    if (s) ptySessions.delete(taskId);
+  // 关闭会话并（可选）把 running 的 pty 会话落为终态；reason 为空表示 Worker
+  // 正常上报退出，会话终态由 Worker 的 finish 上报负责，这里只清会话
+  function closePtySession(sessionId, { status, error, reason }) {
+    const s = ptySessions.get(sessionId);
+    if (s) ptySessions.delete(sessionId);
     if (status) {
-      const task = ctx.state.tasks.find((t) => t.id === taskId);
-      if (task && task.status === 'running') {
-        task.status = status;
-        task.finishedAt = Date.now();
-        task.result = { error };
-        if (reason) task.logs.push(reason);
+      const session = ctx.state.sessions.find((t) => t.id === sessionId);
+      if (session && session.status === 'running') {
+        session.status = status;
+        session.finishedAt = Date.now();
+        session.result = { error };
+        if (reason) session.logs.push(reason);
         ctx.scheduleSave();
-        ctx.broadcast({ type: 'task.updated', task: ctx.taskSummary(task), result: task.result });
+        ctx.broadcast({ type: 'session.updated', session: ctx.sessionSummary(session), result: session.result });
       }
     }
-    ctx.broadcast({ type: 'pty.exited', id: taskId, reason: error || 'closed' });
+    ctx.broadcast({ type: 'pty.exited', id: sessionId, reason: error || 'closed' });
   }
 
   // Worker 通道断开或会话长时间无活动（Worker 掉线且无控制台输入）时回收，
   // 防止忘关的终端在 Worker 上常驻
   function sweepPtyIdle() {
     const now = Date.now();
-    for (const [taskId, s] of ptySessions) {
+    for (const [sessionId, s] of ptySessions) {
       const workerGone = !s.ws || s.ws.readyState !== s.ws.OPEN;
       if (workerGone && now - s.lastActiveAt > PTY_IDLE_MS) {
-        closePtySession(taskId, {
+        closePtySession(sessionId, {
           status: 'failed',
           error: '终端会话空闲超时，已被服务端回收',
           reason: '[server] 终端会话空闲超时（Worker 断开），已回收',