@jacksontian/kite-server 0.4.0 → 0.5.0

package/lib/static.js

@@ -1,5 +1,5 @@
 /**
- * 静态文件（Web 控制台：移动端 index.html / PC 端 pc.html，按 UA 分发）
+ * 静态文件（Web 控制台：单页应用，index.html 一份，手机/PC 自适应）
  */
 
 import fs from 'node:fs';
@@ -13,16 +13,10 @@ const MIME = {
   '.png': 'image/png',
 };
 
-// 移动端 UA 特征词；命中走手机版，其余（桌面浏览器）走 PC 版。
-// iPadOS 13+ 默认伪装 Mac UA，会落到 PC 版——需要时可显式访问 /index.html
-const MOBILE_UA = /android|iphone|ipod|ipad|mobile|harmonyos/i;
-
 export function createStaticServer(WEB_DIR) {
   return function serveStatic(req, res, pathname) {
     let rel = pathname.replace(/^\/+/, '');
-    if (!rel) {
-      rel = MOBILE_UA.test(req.headers['user-agent'] || '') ? 'index.html' : 'pc.html';
-    }
+    if (!rel) rel = 'index.html';
     // resolve 归一化 ../ 后按「目录 + 分隔符」前缀判断，避免同级前缀目录（web-xxx）绕过
     const filePath = path.resolve(WEB_DIR, rel);
     if (filePath !== WEB_DIR && !filePath.startsWith(WEB_DIR + path.sep)) {
@@ -38,8 +32,9 @@ export function createStaticServer(WEB_DIR) {
         'Content-Type': MIME[path.extname(filePath)] || 'application/octet-stream',
         'Cache-Control': 'no-store',
         // 纵深防御：页面资源一律限同源，阻断潜在注入脚本把密钥外传（connect-src
-        // 的 'self' 按 CSP3 含同源 ws/wss，实时通道不受影响）；页面含内联 <script>
-        // 与行内样式操作，script/style 需放行 'unsafe-inline'
+        // 的 'self' 按 CSP3 含同源 ws/wss，实时通道不受影响）；应用逻辑在外部
+        // app.js（'self' 放行），head 仅剩主题初始化内联脚本，故 script-src 还需
+        // 'unsafe-inline'；style-src 同理（行内样式操作）
         'Content-Security-Policy':
           "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; " +
           "img-src 'self' data:; connect-src 'self'",

package/lib/store.js

@@ -1,43 +1,53 @@
 /**
  * 持久化：单文件 JSON，异步落盘（脏标记 + 节流 + 串行化，全程无同步 IO）；
- * 以及卡死任务回收（sweepStaleRunning）。
+ * 以及卡死会话回收（sweepStaleRunning）。
  */
 
 import fs from 'node:fs';
 import path from 'node:path';
 
 export function createStore(ctx) {
-  const DB_FILE = path.join(ctx.cfg.dataDir, 'tasks.json');
-  const MAX_TASKS = ctx.cfg.maxTasks;
+  const DB_FILE = path.join(ctx.cfg.dataDir, 'sessions.json');
+  const MAX_SESSIONS = ctx.cfg.maxSessions;
   const STALE_RUNNING_MS = ctx.cfg.staleRunningMs;
 
-  const state = { tasks: [], heartbeats: {} };
+  const state = { sessions: [], heartbeats: {} };
 
   async function loadState() {
     let raw;
     try {
       raw = await fs.promises.readFile(DB_FILE, 'utf8');
     } catch {
-      return; // 首次启动，文件尚不存在，从空状态开始
+      // 旧版本数据文件叫 tasks.json：新文件不存在时迁移读取并改名，避免丢历史会话
+      const legacy = path.join(ctx.cfg.dataDir, 'tasks.json');
+      try {
+        raw = await fs.promises.readFile(legacy, 'utf8');
+        await fs.promises.rename(legacy, DB_FILE);
+        console.log('[server] 已将历史数据文件 tasks.json 迁移为 sessions.json');
+      } catch {
+        return; // 首次启动，文件尚不存在，从空状态开始
+      }
     }
     try {
       const parsed = JSON.parse(raw);
-      state.tasks = Array.isArray(parsed.tasks) ? parsed.tasks : [];
+      // 旧文件数组键为 tasks，新文件为 sessions，两者都兼容（迁移改名后下次落盘即刷新）
+      state.sessions = Array.isArray(parsed.sessions) ? parsed.sessions
+        : Array.isArray(parsed.tasks) ? parsed.tasks : [];
       state.heartbeats = parsed.heartbeats || {};
     } catch {
       // 文件损坏：先备份，避免被后续写盘静默覆盖丢失历史数据
-      console.warn('[server] tasks.json 已损坏，备份后从空状态启动');
+      console.warn('[server] sessions.json 已损坏，备份后从空状态启动');
       await fs.promises.rename(DB_FILE, `${DB_FILE}.corrupt-${Date.now()}`).catch(() => {});
     }
   }
 
-  // 只保留最近 MAX_TASKS 个终态任务，进行中的不受影响，防止无限增长
-  function pruneFinishedTasks() {
-    const finished = state.tasks.filter((t) => ['done', 'failed', 'canceled'].includes(t.status));
-    if (finished.length > MAX_TASKS) {
+  // 只保留最近 MAX_SESSIONS 个终态会话，进行中的不受影响，防止无限增长
+  function pruneFinishedSessions() {
+    const finished = state.sessions.filter((t) => ['done', 'failed', 'canceled'].includes(t.status));
+    if (finished.length > MAX_SESSIONS) {
       const sorted = finished.sort((a, b) => b.finishedAt - a.finishedAt);
-      const cutoff = sorted[MAX_TASKS - 1].finishedAt;
-      state.tasks = state.tasks.filter(
+      const cutoff = sorted[MAX_SESSIONS - 1].finishedAt;
+      state.sessions = state.sessions.filter(
         (t) => !['done', 'failed', 'canceled'].includes(t.status) || t.finishedAt >= cutoff,
       );
     }
@@ -45,7 +55,7 @@ export function createStore(ctx) {
 
   // 落盘策略：脏标记 + 300ms 节流合并高频写（心跳/日志上报），串行链防交叠，
   // tmp + rename 原子替换。崩溃最多丢约 300ms 的变更，
-  // 卡住的 running 任务由心跳超时回收兜底，可接受。
+  // 卡住的 running 会话由心跳超时回收兜底，可接受。
   let savePending = false;
   let saveTimer = null;
   let savingChain = Promise.resolve();
@@ -53,11 +63,11 @@ export function createStore(ctx) {
   async function flushSave() {
     if (!savePending) return;
     savePending = false; // 先清脏标记再序列化快照；写失败会重新标脏重试
-    pruneFinishedTasks();
+    pruneFinishedSessions();
     try {
       const data = JSON.stringify(state, null, 2);
       const tmp = DB_FILE + '.tmp';
-      // 0600：tasks.json 含全部命令/日志/结果，不允许同机其他用户读取
+      // 0600：sessions.json 含全部命令/日志/结果，不允许同机其他用户读取
       await fs.promises.writeFile(tmp, data, { mode: 0o600 });
       await fs.promises.chmod(tmp, 0o600); // writeFile 的 mode 只在创建时生效，历史文件需显式收紧
       await fs.promises.rename(tmp, DB_FILE);
@@ -83,7 +93,7 @@ export function createStore(ctx) {
     });
   }
 
-  // Worker 崩溃/掉线后，回收卡死在 running 的任务。
+  // Worker 崩溃/掉线后，回收卡死在 running 的会话。
   // pty 交互会话例外：时长不可预期，由 ptyIdleSec 空闲回收（见 sweepPtyIdle）
   function sweepStaleRunning() {
     const now = Date.now();
@@ -96,16 +106,16 @@ export function createStore(ctx) {
       }
     }
     if (hbPruned) scheduleSave();
-    for (const t of state.tasks) {
+    for (const t of state.sessions) {
       if (t.status !== 'running' || t.type === 'pty') continue;
       const hb = t.workerId ? state.heartbeats[t.workerId] : null;
       const workerAlive = hb && now - hb.at < 90 * 1000;
       if (!workerAlive && t.startedAt && now - t.startedAt > STALE_RUNNING_MS) {
         t.status = 'failed';
         t.finishedAt = now;
-        t.result = { error: 'Worker 离线超时，任务被服务端回收' };
-        t.logs.push('[server] Worker 心跳超时，任务被标记为失败');
-        ctx.broadcast({ type: 'task.updated', task: ctx.taskSummary(t), result: t.result });
+        t.result = { error: 'Worker 离线超时，会话被服务端回收' };
+        t.logs.push('[server] Worker 心跳超时，会话被标记为失败');
+        ctx.broadcast({ type: 'session.updated', session: ctx.sessionSummary(t), result: t.result });
         ctx.notifyIm(t, 'failed');
       }
     }

package/lib/summary.js

@@ -1,16 +1,18 @@
 /**
- * 任务/Worker 摘要视图：WS 推送与 API 列表共用的只读投影。
+ * 会话/Worker 摘要视图：WS 推送与 API 列表共用的只读投影。
  */
 
-export function taskSummary(t) {
+export function sessionSummary(t) {
   return {
     id: t.id,
     type: t.type,
     title: t.title,
+    project: (t.payload && t.payload.project) || null,
     status: t.status,
     createdAt: t.createdAt,
     startedAt: t.startedAt,
     finishedAt: t.finishedAt,
+    openedAt: t.openedAt || null,
     workerId: t.workerId,
     targetWorker: t.targetWorker || null,
     logCount: t.logs.length,

package/lib/util.js

@@ -1,5 +1,5 @@
 /**
- * 服务端通用小工具：常量时间比较、JSON 响应、请求体解析、任务公开视图。
+ * 服务端通用小工具：常量时间比较、JSON 响应、请求体解析、会话公开视图。
  */
 
 import crypto from 'node:crypto';
@@ -30,8 +30,8 @@ export function parseBody(rawBody) {
   }
 }
 
-export function publicTask(task) {
-  // 浅拷贝切断与内部状态的引用别名，防止响应侧改动波及 state.tasks；
-  // 任务现有字段（含 logs/result/payload）均为控制台可见，无需裁剪
-  return { ...task };
+export function publicSession(session) {
+  // 浅拷贝切断与内部状态的引用别名，防止响应侧改动波及 state.sessions；
+  // 会话现有字段（含 logs/result/payload）均为控制台可见，无需裁剪
+  return { ...session };
 }

package/lib/websocket.js

@@ -1,6 +1,6 @@
 /**
  * WebSocket 连接管理：/ws 控制台实时广播 + pty 终端输入上行；
- * /worker/ws Worker 任务通知与 pty 会话 IO 中继。
+ * /worker/ws Worker 会话通知与 pty 会话 IO 中继。
  * 鉴权走连接后的第一条消息（Token 不进 URL，不落日志）。
  */
 
@@ -57,7 +57,7 @@ export function createWebSockets(ctx) {
         ws.send(
           JSON.stringify({
             type: 'hello',
-            tasks: [...ctx.state.tasks].sort((a, b) => b.createdAt - a.createdAt).slice(0, 50).map(ctx.taskSummary),
+            sessions: [...ctx.state.sessions].sort((a, b) => b.createdAt - a.createdAt).slice(0, 50).map(ctx.sessionSummary),
             workers: workersSnapshot(ctx.state.heartbeats),
           }),
         );
@@ -71,32 +71,32 @@ export function createWebSockets(ctx) {
       } catch {
         return;
       }
-      if (!msg || typeof msg.taskId !== 'string') return;
-      const taskId = msg.taskId.slice(0, 64);
+      if (!msg || typeof msg.sessionId !== 'string') return;
+      const sessionId = msg.sessionId.slice(0, 64);
 
       if (msg.type === 'pty.attach') {
         // 打开终端：先补回看缓冲，再告知 Worker 侧会话是否仍活；
         // 不活时附带 reason，控制台据此区分等待指引：
-        //   not_claimed   任务还在 pending，等 Worker 上线领取
+        //   not_claimed   会话还在 pending，等 Worker 上线领取
         //   worker_offline 会话在册但 Worker 通道断开，重连后自动重新挂载
         //   starting      已领取但 session.started 未到（或已退出待 finish 上报）
-        //   ended         任务已终态或不存在，会话已结束/被回收
-        const s = ctx.ptySessions.get(taskId);
+        //   ended         会话已终态或不存在，会话已结束/被回收
+        const s = ctx.ptySessions.get(sessionId);
         const live = Boolean(s && s.ws && s.ws.readyState === s.ws.OPEN);
         let reason;
         if (!live) {
           if (s) {
             reason = 'worker_offline';
           } else {
-            const task = ctx.state.tasks.find((t) => t.id === taskId);
-            if (!task || ['done', 'failed', 'canceled'].includes(task.status)) reason = 'ended';
-            else if (task.status === 'pending') reason = 'not_claimed';
+            const session = ctx.state.sessions.find((t) => t.id === sessionId);
+            if (!session || ['done', 'failed', 'canceled'].includes(session.status)) reason = 'ended';
+            else if (session.status === 'pending') reason = 'not_claimed';
             else reason = 'starting';
           }
         }
         ctx.wsSendJson(ws, {
           type: 'pty.attach',
-          id: taskId,
+          id: sessionId,
           tail: s ? s.tail : '',
           live,
           reason,
@@ -104,26 +104,26 @@ export function createWebSockets(ctx) {
         return;
       }
       if (msg.type === 'session.input') {
-        const s = ctx.ptySessions.get(taskId);
-        if (!s) return ctx.wsSendJson(ws, { type: 'pty.exited', id: taskId, reason: '会话已结束' });
+        const s = ctx.ptySessions.get(sessionId);
+        if (!s) return ctx.wsSendJson(ws, { type: 'pty.exited', id: sessionId, reason: '会话已结束' });
         s.lastActiveAt = Date.now();
-        ctx.wsSendJson(s.ws, { type: 'session.input', taskId, data: String(msg.data || '').slice(0, 65536) });
+        ctx.wsSendJson(s.ws, { type: 'session.input', sessionId, data: String(msg.data || '').slice(0, 65536) });
         return;
       }
       if (msg.type === 'session.resize') {
-        const s = ctx.ptySessions.get(taskId);
+        const s = ctx.ptySessions.get(sessionId);
         if (!s) return;
         ctx.wsSendJson(s.ws, {
           type: 'session.resize',
-          taskId,
+          sessionId,
           cols: Number(msg.cols) || 80,
           rows: Number(msg.rows) || 24,
         });
         return;
       }
       if (msg.type === 'session.close') {
-        const s = ctx.ptySessions.get(taskId);
-        if (s) ctx.wsSendJson(s.ws, { type: 'session.close', taskId });
+        const s = ctx.ptySessions.get(sessionId);
+        if (s) ctx.wsSendJson(s.ws, { type: 'session.close', sessionId });
       }
     });
 
@@ -137,7 +137,7 @@ export function createWebSockets(ctx) {
     ws.on('error', () => {});
   });
 
-  // --- Worker 通道 /worker/ws：鉴权方式同 /ws；鉴权后下发 task.available，
+  // --- Worker 通道 /worker/ws：鉴权方式同 /ws；鉴权后下发 session.available，
   // 并承载 pty 会话上行消息（session.started/output/exited）---
   const workerWss = new WebSocketServer(WS_OPTS);
 
@@ -161,7 +161,7 @@ export function createWebSockets(ctx) {
           ws.close(4002, 'bad auth message');
           return;
         }
-        // Worker 通道只认 Worker 侧密钥：控制台密钥泄露不能冒充 Worker 领任务。
+        // Worker 通道只认 Worker 侧密钥：控制台密钥泄露不能冒充 Worker 领会话。
         // 逐一尝试 WORKER_AUTH 条目；命中 workerSecrets 绑定密钥时身份以绑定
         // 为准（自报 workerId 不一致即拒绝），共享密钥为兼容路径（身份自报）
         let result = { ok: false, reason: '缺少签名头' };
@@ -197,9 +197,9 @@ export function createWebSockets(ctx) {
         ws.workerId = boundId || claimedId;
         ctx.wsWorkers.add(ws);
         console.log(`[server] Worker ${ws.workerId} 通道已连接（来源 ${remote}）`);
-        // 断线窗口内可能已有积压任务，连接建立即补一次通知（只推指名本 Worker 的）
-        if (ctx.state.tasks.some((t) => t.status === 'pending' && t.targetWorker === ws.workerId)) {
-          ws.send(JSON.stringify({ type: 'task.available' }));
+        // 断线窗口内可能已有积压会话，连接建立即补一次通知（只推指名本 Worker 的）
+        if (ctx.state.sessions.some((t) => t.status === 'pending' && t.targetWorker === ws.workerId)) {
+          ws.send(JSON.stringify({ type: 'session.available' }));
         }
         return;
       }
@@ -211,34 +211,40 @@ export function createWebSockets(ctx) {
       } catch {
         return;
       }
-      if (!msg || typeof msg.taskId !== 'string') return;
-      const taskId = msg.taskId.slice(0, 64);
-      const task = ctx.state.tasks.find((t) => t.id === taskId);
+      if (!msg || typeof msg.sessionId !== 'string') return;
+      const sessionId = msg.sessionId.slice(0, 64);
+      const session = ctx.state.sessions.find((t) => t.id === sessionId);
 
       if (msg.type === 'session.started') {
-        // 会话注册（含 Worker 通道重连后的重新挂载）；只认该 Worker 自己领取的任务
-        if (!task || task.type !== 'pty' || task.workerId !== ws.workerId) return;
-        const prev = ctx.ptySessions.get(taskId);
-        ctx.ptySessions.set(taskId, {
+        // 无记录（已被控制台关闭删除）或已终态：拒绝重挂并通知 Worker 回收残留 PTY，
+        // 避免孤儿进程常驻
+        if (!session || ['done', 'failed', 'canceled'].includes(session.status)) {
+          ctx.wsSendJson(ws, { type: 'session.close', sessionId });
+          return;
+        }
+        // 会话注册（含 Worker 通道重连后的重新挂载）；只认该 Worker 自己领取的会话
+        if (session.type !== 'pty' || session.workerId !== ws.workerId) return;
+        const prev = ctx.ptySessions.get(sessionId);
+        ctx.ptySessions.set(sessionId, {
           ws,
           tail: prev ? prev.tail : '',
           lastActiveAt: Date.now(),
         });
-        ctx.broadcast({ type: 'pty.started', id: taskId, pid: Number(msg.pid) || 0 });
+        ctx.broadcast({ type: 'pty.started', id: sessionId, pid: Number(msg.pid) || 0 });
         return;
       }
       if (msg.type === 'session.output') {
-        const s = ctx.ptySessions.get(taskId);
+        const s = ctx.ptySessions.get(sessionId);
         if (!s) return;
         const data = String(msg.data || '');
         s.lastActiveAt = Date.now();
         s.tail = (s.tail + data).slice(-PTY_TAIL_BYTES); // 回看缓冲，重连可重放
-        ctx.broadcast({ type: 'pty.data', id: taskId, data });
+        ctx.broadcast({ type: 'pty.data', id: sessionId, data });
         return;
       }
       if (msg.type === 'session.exited') {
-        // 只清会话映射；任务终态由 Worker 随后的 HTTP finish 上报负责
-        ctx.closePtySession(taskId, {});
+        // 只清会话映射；会话终态由 Worker 随后的 HTTP finish 上报负责
+        ctx.closePtySession(sessionId, {});
       }
     });
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jacksontian/kite-server",
-  "version": "0.4.0",
-  "description": "kite 云端信箱 API：HMAC 签名鉴权、任务队列、WebSocket 实时推送、手机端 Web 控制台",
+  "version": "0.5.0",
+  "description": "kite 云端信箱 API：HMAC 签名鉴权、会话队列、WebSocket 实时推送、手机端 Web 控制台",
   "type": "module",
   "license": "MIT",
   "engines": {