nx-kv 0.8.0 → 0.8.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -248,6 +248,8 @@ function topicView(t) {
248
248
  summary: t.summary || '',
249
249
  waiting: !!t.waiting,
250
250
  waitingUntil: t.waitingUntil || '',
251
+ waitingSince: t.waitingSince || '',
252
+ cancelRequested: !!t.cancelRequested,
251
253
  createdAt: t.createdAt,
252
254
  updatedAt: t.updatedAt,
253
255
  pending: tasks.filter((x) => x.status !== 'consumed').length,
@@ -282,12 +284,17 @@ export async function consumeFirstPending(key, roundSummary) {
282
284
  return normalizeTask(task);
283
285
  }
284
286
 
285
- // 在 store 里把某主题置为等待/结束,并刷新现状
287
+ // 在 store 里把某主题置为等待/结束,并刷新现状。
288
+ // waitingSince 是「等待起点」,面板据此显示「已等多久」——waitingUntil(截止时刻)
289
+ // 只能反推剩余,反推不出起点(超时值可被改写),所以两者都存。
286
290
  async function setWaiting(key, cwd, summary, waiting, deadline) {
287
291
  const store = await loadStore();
288
292
  const t = topicOf(store, key, cwd);
289
- t.waiting = waiting;
293
+ t.waiting = !!waiting;
290
294
  t.waitingUntil = waiting && deadline ? stampNow(deadline) : '';
295
+ t.waitingSince = waiting ? stampNow() : '';
296
+ // 新一轮等待不继承上一轮残留的「关闭」请求,否则刚进来就被立刻收尾
297
+ t.cancelRequested = false;
291
298
  if (summary) t.summary = summary;
292
299
  t.updatedAt = stampNow();
293
300
  await saveStore(store);
@@ -301,10 +308,49 @@ async function clearWaiting(key) {
301
308
  if (!t) return;
302
309
  t.waiting = false;
303
310
  t.waitingUntil = '';
311
+ t.waitingSince = '';
312
+ t.cancelRequested = false;
304
313
  t.updatedAt = stampNow();
305
314
  await saveStore(store);
306
315
  }
307
316
 
317
+ /**
318
+ * 用户在面板点「关闭」:关掉某主题的等待,让**阻塞中的 wait 立即收尾**。
319
+ *
320
+ * 只翻 store 里的 cancelRequested 标记——wait 端每 0.5s 轮询到就结束本轮(返回
321
+ * status:"timeout" + cancelled:true,与超时同一条出口,agent 照常收尾)。
322
+ * **不删主题、不删任务、不动队列**:等待可以取消,历史照留。
323
+ *
324
+ * @returns {{cancelled:boolean,key:string,name:string,cwd:string,reason?:string}}
325
+ */
326
+ export async function cancelWait({ cwd: rawCwd, key: rawKey } = {}) {
327
+ if (!rawKey && !rawCwd) {
328
+ const { badInput } = await import('../../core/errors.js');
329
+ throw badInput('需要 --cwd "<工作目录>" 或 --key "<主题key>"');
330
+ }
331
+ const key = resolveTopicKey({ key: rawKey, cwd: rawCwd });
332
+ const store = await loadStore();
333
+ const t = store.topics[key];
334
+ if (!t || !t.waiting) {
335
+ return { cancelled: false, key, name: (t && t.name) || '', cwd: (t && t.cwd) || '', reason: 'not_waiting' };
336
+ }
337
+ t.cancelRequested = true;
338
+ t.updatedAt = stampNow();
339
+ await saveStore(store);
340
+ return { cancelled: true, key, name: t.name, cwd: t.cwd };
341
+ }
342
+
343
+ // wait 端轮询:该主题是否被请求关闭;取到即清标记(只生效一次)。
344
+ async function consumeCancelRequest(key) {
345
+ const store = await loadStore();
346
+ const t = store.topics[key];
347
+ if (!t || !t.cancelRequested) return false;
348
+ t.cancelRequested = false;
349
+ t.updatedAt = stampNow();
350
+ await saveStore(store);
351
+ return true;
352
+ }
353
+
308
354
  // ─── CRUD ───────────────────────────────────────────────────────────
309
355
 
310
356
  function settingsView(s) {
@@ -638,9 +684,25 @@ export async function waitForTask({
638
684
 
639
685
  const timer = setTimeout(() => resolveOutcome({ kind: 'timeout' }), tmo);
640
686
 
687
+ // 关闭轮询:用户在面板点了「关闭」→ 立即收尾本轮(走与超时同一条出口,只多带 cancelled 标记,
688
+ // agent 不必认识新状态,照常结束本轮)。
689
+ const cancelPoll = setInterval(() => {
690
+ consumeCancelRequest(key)
691
+ .then((yes) => {
692
+ if (yes) resolveOutcome({ kind: 'cancelled' });
693
+ })
694
+ .catch(() => {});
695
+ }, POLL_MS);
696
+
641
697
  // 登记「等待中」(含截止时刻与现状),面板/弹窗据此显示倒计时
642
698
  await setWaiting(key, cwd, summary, true, new Date(Date.now() + tmo));
643
699
 
700
+ // 登记之后再查一次关闭标记:setWaiting 刚清掉上一轮残留的标记,因此这里若有值
701
+ // 一定是新一次关闭请求——立刻收尾,不让用户白等。
702
+ if (await consumeCancelRequest(key).catch(() => false)) {
703
+ resolveOutcome({ kind: 'cancelled' });
704
+ }
705
+
644
706
  // waiter/轮询就位后再回调,保证 onReady 里立刻回填也能被接住
645
707
  if (typeof onReady === 'function') {
646
708
  try {
@@ -658,9 +720,12 @@ export async function waitForTask({
658
720
  result =
659
721
  r.kind === 'timeout'
660
722
  ? { status: 'timeout', key, cwd, summary, timeoutMs: tmo }
723
+ : r.kind === 'cancelled'
724
+ ? { status: 'timeout', key, cwd, summary, timeoutMs: tmo, cancelled: true }
661
725
  : { status: 'ok', key, cwd, name, summary, task: r.task, delivered: r.delivered, queued: false };
662
726
  } finally {
663
727
  clearInterval(poll);
728
+ clearInterval(cancelPoll);
664
729
  clearTimeout(timer);
665
730
  waiters.delete(key);
666
731
  await clearWaiting(key);
@@ -777,3 +842,74 @@ function stopServer(server) {
777
842
  });
778
843
  });
779
844
  }
845
+
846
+ // ─── 面板空闲自释放所需的观测接口(panel-guard.js 调用)────────────
847
+
848
+ // 当前有多少主题「真的在等待」——常驻面板的空闲自释放据此否决退出:
849
+ // 有 agent 正阻塞等人时,面板是唯一提醒来源,绝不能在此时释放。
850
+ //
851
+ // waiting 标志由 wait 进程写入、结束复位,跨进程可见;但 wait 被强杀(SIGKILL)时
852
+ // 标志会残留。所以再过一道「截止时刻」:waitingUntil 已过期视为不在等待——那一刻
853
+ // wait 本来也要收尾了,不会误伤正常等待。
854
+ export async function countWaitingTopics() {
855
+ const store = await loadStore();
856
+ const now = Date.now();
857
+ let n = 0;
858
+ for (const t of Object.values(store.topics)) {
859
+ if (!t || !t.waiting) continue;
860
+ const until = parseStampMs(t.waitingUntil);
861
+ if (Number.isFinite(until) && until <= now) continue; // 残留标志:截止时刻已过
862
+ n += 1;
863
+ }
864
+ return n;
865
+ }
866
+
867
+ // "YYYY-MM-DD HH:mm:ss"(本地)→ epoch ms;无法解析返回 NaN
868
+ function parseStampMs(s) {
869
+ const m = /^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2}):(\d{2})$/.exec(String(s || ''));
870
+ if (!m) return NaN;
871
+ return new Date(+m[1], +m[2] - 1, +m[3], +m[4], +m[5], +m[6]).getTime();
872
+ }
873
+
874
+ // 活动 SSE 面板连接(只在常驻 serve 进程内有意义)。每条记录最近一次成功写入的时间,
875
+ // wait 据此判断是否真有「活着的」面板标签:心跳写失败(标签已关、TCP 残留)会立刻剔除,
876
+ // 超过新鲜窗口没成功写过的连接不计入——避免页面关了却误判在线、整轮零提醒也不开页。
877
+ //
878
+ // 本期只交付「存在性」接口:panel-guard 只要 clients 数字。SSE 事件流是更上层能力,
879
+ // 留到下个 release 再叠加;这里只保留最小数据结构,streamEventsSSE 接入时直接复用。
880
+ const SSE_HEARTBEAT_MS = 15000;
881
+ const SSE_LIVE_WINDOW_MS = 30000;
882
+ const sseConns = new Set();
883
+ export function panelPresence() {
884
+ const now = Date.now();
885
+ let clients = 0;
886
+ for (const conn of sseConns) {
887
+ if (now - conn.lastOkWrite <= SSE_LIVE_WINDOW_MS) clients += 1;
888
+ }
889
+ return { clients, total: sseConns.size };
890
+ }
891
+
892
+ // 给 runtime/api.js 用的最小 SSE 注册表:每次「/api/localtasks/events」连接时
893
+ // 调一下 addEventStreamConn(req, res),把连接纳入 panelPresence 统计。
894
+ export function addEventStreamConn(req, res) {
895
+ const conn = { lastOkWrite: Date.now() };
896
+ sseConns.add(conn);
897
+ const beat = setInterval(() => {
898
+ try {
899
+ res.write(`: ping ${Date.now()}\n\n`);
900
+ conn.lastOkWrite = Date.now();
901
+ } catch {
902
+ clearInterval(beat);
903
+ sseConns.delete(conn);
904
+ }
905
+ }, SSE_HEARTBEAT_MS);
906
+ beat.unref?.();
907
+ const cleanup = () => {
908
+ clearInterval(beat);
909
+ sseConns.delete(conn);
910
+ };
911
+ req.on('close', cleanup);
912
+ req.on('error', cleanup);
913
+ res.on('close', cleanup);
914
+ return conn;
915
+ }
@@ -21,6 +21,21 @@ function countdown(s) {
21
21
  return `等待中 ${mm}:${String(ss).padStart(2, '0')}`;
22
22
  }
23
23
 
24
+ // 「已等 m:ss · 剩 m:ss」:waitingSince(起点)反推已等,waitingUntil(截止)反推剩余。
25
+ // waitingSince 缺字段时(老数据)退化为只显示剩余。
26
+ function waitingBadge(t) {
27
+ if (!t || !t.waiting) return null;
28
+ const remain = countdown(t.waitingUntil);
29
+ if (!t.waitingSince) return remain; // 老数据兜底
30
+ const since = parseStamp(t.waitingSince);
31
+ if (!since) return remain;
32
+ const elapsedMs = Date.now() - since.getTime();
33
+ if (elapsedMs < 0) return remain;
34
+ const mm = Math.floor(elapsedMs / 60000);
35
+ const ss = Math.floor((elapsedMs % 60000) / 1000);
36
+ return `等待中 已等 ${mm}:${String(ss).padStart(2, '0')} · 剩 ${remain.replace(/^等待中\s*/, '')}`;
37
+ }
38
+
24
39
  export default function SessionTaskView() {
25
40
  const toast = useToast();
26
41
  const guard = useGuard();
@@ -191,6 +206,22 @@ export default function SessionTaskView() {
191
206
  }
192
207
  });
193
208
 
209
+ // 关闭某主题的等待:只翻 store 里的 cancelRequested 标记,阻塞中的 wait 立即收尾。
210
+ // 不删主题、不删任务、不动队列——历史照留,只是当前这一轮不等了。
211
+ const cancelTopic = (t) =>
212
+ guard(async () => {
213
+ if (!t || !t.waiting) return;
214
+ const msg = `关闭主题「${t.name}」的等待?\n\n阻塞中的 wait 立即收尾(走与超时同一条出口,agent 照常结束本轮),主题与任务都保留。`;
215
+ if (!window.confirm(msg)) return;
216
+ const r = await api('/api/localtasks/cancel', {
217
+ method: 'POST',
218
+ body: { key: t.key },
219
+ });
220
+ if (r && r.cancelled) toast('已关闭等待');
221
+ else toast('该主题不在等待中');
222
+ await load();
223
+ });
224
+
194
225
  // 批量删除勾选主题;含等待中时 force 并提示
195
226
  const batchDelete = () =>
196
227
  guard(async () => {
@@ -404,9 +435,9 @@ export default function SessionTaskView() {
404
435
  现状:{t.summary}
405
436
  </div>
406
437
  )}
407
- <div style={{ display: 'flex', gap: 6, alignItems: 'center' }}>
438
+ <div style={{ display: 'flex', gap: 6, alignItems: 'center', flexWrap: 'wrap' }}>
408
439
  {t.waiting ? (
409
- <span className="tag strong">{countdown(t.waitingUntil)}</span>
440
+ <span className="tag strong">{waitingBadge(t) || countdown(t.waitingUntil)}</span>
410
441
  ) : (
411
442
  <span className="tag">已结束</span>
412
443
  )}
@@ -415,9 +446,18 @@ export default function SessionTaskView() {
415
446
  </span>
416
447
  </div>
417
448
  <div
418
- style={{ display: 'flex', justifyContent: 'flex-end', marginTop: 8 }}
449
+ style={{ display: 'flex', justifyContent: 'flex-end', gap: 6, marginTop: 8 }}
419
450
  onClick={(e) => e.stopPropagation()}
420
451
  >
452
+ {t.waiting && (
453
+ <button
454
+ className="btn small ghost"
455
+ onClick={() => cancelTopic(t)}
456
+ title="关闭本次等待(阻塞中的 wait 立即收尾,主题与任务保留)"
457
+ >
458
+ 关闭
459
+ </button>
460
+ )}
421
461
  <button
422
462
  className="btn small ghost"
423
463
  onClick={() => deleteTopic(t)}
@@ -21,7 +21,16 @@ const BUILTINS = [
21
21
  id: 'serve',
22
22
  cli: ['serve'],
23
23
  summary: '启动 Web 面板',
24
- flags: { port: { type: 'number', default: DEFAULT_PORT }, 'no-open': { type: 'boolean' } },
24
+ flags: {
25
+ port: { type: 'number', default: DEFAULT_PORT },
26
+ 'no-open': { type: 'boolean' },
27
+ // --auto-exit:面板(web)全关且无等待中的主题时,serve 自动退出。
28
+ // 用户手动 `nx-kv serve` 默认不带该标志,面板不会自己跑掉;
29
+ // wait 临时拉起 serve 时会加 --no-open --auto-exit,用完即让位。
30
+ 'auto-exit': { type: 'boolean', hint: '面板关闭后空闲自释放(wait 临时拉起实例专用)' },
31
+ // 宽限期:连续多久无面板活动后才允许释放(与 --auto-exit 配合使用)
32
+ idle: { type: 'number', hint: '空闲宽限期(秒;与 --auto-exit 配合,默认 120)' },
33
+ },
25
34
  run: (ctx) => cmdServe(ctx),
26
35
  },
27
36
  {
@@ -245,15 +254,22 @@ function printCommandHelp(cmd) {
245
254
 
246
255
  async function cmdServe(ctx) {
247
256
  const { startServer } = await import('./server.js');
257
+ const { startPanelIdleGuard } = await import('../modules/localtask/panel-guard.js');
248
258
  const { openBrowser } = await import('../core/open.js');
249
259
  const port = ctx.port || DEFAULT_PORT;
250
- const server = await startServer({ port, host: '127.0.0.1' });
260
+ const autoExit = !!ctx['auto-exit'];
261
+
262
+ // 活动观测钩子:每个进来的请求(静态或 /api)都回调一次,供空闲自释放判活。
263
+ // 不参与响应,异常必须吞掉。
264
+ const onRequest = () => {};
265
+ const server = await startServer({ port, host: '127.0.0.1', onRequest });
251
266
  const addr = `http://127.0.0.1:${server.address().port}`;
252
267
 
253
268
  console.log('nx-kv · nx-kv v' + VERSION);
254
269
  console.log(`面板: ${addr}`);
255
270
  console.log(`配置: ${configPathFromEnv()}`);
256
271
  console.log('CLI: nx-kv help(每个按钮都有对应命令,agent 可加 --json)');
272
+ if (autoExit) console.log('模式: 空闲自释放(面板关闭且无等待中的主题后自动退出)');
257
273
  console.log('按 Ctrl+C 停止');
258
274
 
259
275
  if (!ctx['no-open']) openBrowser(addr);
@@ -264,6 +280,11 @@ async function cmdServe(ctx) {
264
280
  };
265
281
  process.on('SIGINT', shutdown);
266
282
  process.on('SIGTERM', shutdown);
283
+
284
+ // 启动空闲看门狗(仅 --auto-exit 模式);空回调避免依赖具体参数
285
+ if (autoExit) {
286
+ startPanelIdleGuard({ server, idleSec: ctx.idle });
287
+ }
267
288
  }
268
289
 
269
290
  // ---- 主入口 ----
@@ -50,10 +50,26 @@ async function serveStatic(pathname, res) {
50
50
  }
51
51
  }
52
52
 
53
- export function startServer({ port = DEFAULT_PORT, host = '127.0.0.1' } = {}) {
53
+ // /api/ping:纯本机快返回,供面板心跳与「面板还开着吗」观测。
54
+ // 不触网、不读盘、不查登录态——只为测「端口上还活着」。这与 /api/health 不同:
55
+ // /api/health 走的是更重的鉴权/状态检查,不适合每 15s 一次的高频探活。
56
+ async function handlePing(_req, res) {
57
+ sendJson(res, 200, { ok: true, data: { pong: true, ts: Date.now() } });
58
+ }
59
+
60
+ export function startServer({ port = DEFAULT_PORT, host = '127.0.0.1', onRequest } = {}) {
54
61
  const server = http.createServer(async (req, res) => {
62
+ // 活动观测:每个请求(包括 /api/ping 与静态文件)都回调一次;
63
+ // 回调只上报,不参与响应;异常必须吞掉以免影响主流程。
64
+ if (typeof onRequest === 'function') {
65
+ try { onRequest(req); } catch { /* ignore */ }
66
+ }
55
67
  try {
56
68
  const url = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
69
+ if (url.pathname === '/api/ping') {
70
+ await handlePing(req, res);
71
+ return;
72
+ }
57
73
  if (url.pathname.startsWith('/api/')) {
58
74
  await handleApi(req, res, url);
59
75
  return;
@@ -4,6 +4,7 @@ import { Suspense, useEffect } from 'react';
4
4
  import { useStore } from './store.jsx';
5
5
  import { ErrorBoundary } from './components/ui.jsx';
6
6
  import { VIEWS } from './registry.js';
7
+ import { api } from './api/client.js';
7
8
 
8
9
  function viewFromHash() {
9
10
  const h = (location.hash || '').replace(/^#\/?/, '');
@@ -31,6 +32,24 @@ export default function App() {
31
32
  return () => window.removeEventListener('hashchange', onHash);
32
33
  }, [patchUi]);
33
34
 
35
+ // 心跳:每 15s 打一次 /api/ping。
36
+ // 目的不是健康检查,而是给 serve --auto-exit 上报「面板还开着」。
37
+ // 单视图挂载(current.component)切到任意页面都算「开着」,
38
+ // 不用 SSE 数连接来判——切页会断 SSE,但页面明明还开着。
39
+ useEffect(() => {
40
+ let stopped = false;
41
+ const beat = () => {
42
+ if (stopped) return;
43
+ api('/api/ping').catch(() => {});
44
+ };
45
+ beat();
46
+ const t = setInterval(beat, 15_000);
47
+ return () => {
48
+ stopped = true;
49
+ clearInterval(t);
50
+ };
51
+ }, []);
52
+
34
53
  const current = VIEWS.find((v) => v.id === ui.view) || VIEWS[0];
35
54
 
36
55
  const switchTo = (id) => {
@@ -1 +1 @@
1
- import{o as e,s as t,t as n}from"./index-g03vbcKX.js";var r=t();function i({module:t}){let{boot:i}=e(),a=(i?.commands||[]).filter(e=>e.module===t);return a.length?(0,r.jsxs)(`div`,{className:`cli-hint`,children:[(0,r.jsx)(`span`,{className:`cli-hint-label`,children:`CLI 等价(同构命令,加 --json 得机器可读输出):`}),a.map(e=>(0,r.jsx)(n,{className:`cli-cmd`,text:e.command,title:`点击复制:${e.usage}`,children:e.command},e.id))]}):null}export{i as t};
1
+ import{o as e,s as t,t as n}from"./index-D0ldg3Y8.js";var r=t();function i({module:t}){let{boot:i}=e(),a=(i?.commands||[]).filter(e=>e.module===t);return a.length?(0,r.jsxs)(`div`,{className:`cli-hint`,children:[(0,r.jsx)(`span`,{className:`cli-hint-label`,children:`CLI 等价(同构命令,加 --json 得机器可读输出):`}),a.map(e=>(0,r.jsx)(n,{className:`cli-cmd`,text:e.command,title:`点击复制:${e.usage}`,children:e.command},e.id))]}):null}export{i as t};