aiterm-mcp 0.70.52 → 0.70.54
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.
- package/CHANGELOG.md +17 -1
- package/README.ja.md +1 -1
- package/README.md +1 -1
- package/dist/background-tasks.js +239 -13
- package/dist/remote.js +10 -5
- package/package.json +1 -1
package/CHANGELOG.md
CHANGED
|
@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
|
|
|
7
7
|
|
|
8
8
|
## [Unreleased]
|
|
9
9
|
|
|
10
|
+
## [0.70.54] - 2026-11-13
|
|
11
|
+
|
|
12
|
+
- Antigravity seats state their own background tasks too (a68): read from the bound conversation's transcript ("running as a background task with task id" until "Task id … finished").
|
|
13
|
+
|
|
14
|
+
## [0.70.53] - 2026-11-13
|
|
15
|
+
|
|
16
|
+
- A call that hangs on a terminal no longer freezes that terminal's seat reads. The warm connection per terminal is split into a read lane (`pty_list`, the seat-turns relay) and one for everything else; the terminal answers each connection in one process, so a close stuck there (fox, 11/14 01:33 JST, ~2 min) held every read behind it.
|
|
17
|
+
|
|
18
|
+
- `own_work.task` names the oldest open agent when a seat has both agents and shells (before: the oldest of either, so a subagent's background `sleep` could stand for the subagent on the card).
|
|
19
|
+
|
|
20
|
+
- Codex seats state their working subagents too (a68): each subagent thread's rollout (session_meta thread_source subagent, session_id = the seat's root thread) counts while it has more task_started than task_complete/turn_aborted.
|
|
21
|
+
|
|
22
|
+
- Grok seats now state their own unfinished background tasks too (a68): background subagents and backgrounded commands, read from the session's updates.jsonl (subagent_spawned/finished, task_backgrounded/completed, background_tasks). `own_work.tasks`/`task` and `activity.background_tasks` are no longer null for Grok, and tasks > 0 holds the idle clock and explicit hibernate.
|
|
23
|
+
|
|
10
24
|
## [0.70.52] - 2026-11-13
|
|
11
25
|
|
|
12
26
|
- seat-turns: a terminal that answers after the 4 s budget no longer leaves its seats unread poll after poll. Its late answer goes to the next poll (once, up to 60 s old), and every relayed row carries `observed_at` (fox under a build: rows stood still for 85 s).
|
|
@@ -3438,7 +3452,9 @@ prototype (preserved under `prototype/python/` as the porting source and referen
|
|
|
3438
3452
|
`ubuntu-latest` for Node 18/20/22, publishing to npm on `v*` tags with
|
|
3439
3453
|
provenance.
|
|
3440
3454
|
|
|
3441
|
-
[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.70.
|
|
3455
|
+
[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.70.54...HEAD
|
|
3456
|
+
[0.70.54]: https://github.com/kitepon/aiterm-mcp/compare/v0.70.53...v0.70.54
|
|
3457
|
+
[0.70.53]: https://github.com/kitepon/aiterm-mcp/compare/v0.70.52...v0.70.53
|
|
3442
3458
|
[0.70.52]: https://github.com/kitepon/aiterm-mcp/compare/v0.70.51...v0.70.52
|
|
3443
3459
|
[0.70.51]: https://github.com/kitepon/aiterm-mcp/compare/v0.70.50...v0.70.51
|
|
3444
3460
|
[0.70.50]: https://github.com/kitepon/aiterm-mcp/compare/v0.70.49...v0.70.50
|
package/README.ja.md
CHANGED
|
@@ -215,7 +215,7 @@ runtime-error store は canonical dotagents config の `collection.enabled: true
|
|
|
215
215
|
場合だけ収集し、既定OFF、network送信は行いません。tag起点CIのnpm provenance(OIDC Trusted
|
|
216
216
|
Publishing)で公開し、GitHub Release が Official MCP Registry を再登録します。
|
|
217
217
|
|
|
218
|
-
**状態:** 開発継続中 · 現行公開版 **v0.70.
|
|
218
|
+
**状態:** 開発継続中 · 現行公開版 **v0.70.54** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
|
|
219
219
|
|
|
220
220
|
### 更新と巻き戻し
|
|
221
221
|
|
package/README.md
CHANGED
|
@@ -227,7 +227,7 @@ collection is off by default and performs no network I/O. It ships via
|
|
|
227
227
|
tag-triggered CI with npm provenance (OIDC Trusted Publishing); the GitHub
|
|
228
228
|
Release re-registers the Official MCP Registry entry.
|
|
229
229
|
|
|
230
|
-
**Status:** actively maintained · current public release **v0.70.
|
|
230
|
+
**Status:** actively maintained · current public release **v0.70.54** · runs on Linux · WSL2 · macOS · native Windows (tmux on POSIX, the tmux-CLI-compatible [psmux](https://github.com/psmux/psmux) on native Windows — no WSL required) · MIT · see the [CHANGELOG](CHANGELOG.md).
|
|
231
231
|
|
|
232
232
|
### Update and rollback
|
|
233
233
|
|
package/dist/background-tasks.js
CHANGED
|
@@ -1,5 +1,9 @@
|
|
|
1
1
|
import * as fs from "node:fs";
|
|
2
|
+
import path from "node:path";
|
|
2
3
|
import { claudeSessionTranscriptPath } from "./harnesses/claude.js";
|
|
4
|
+
import { grokSessionDirectory } from "./harnesses/grok.js";
|
|
5
|
+
import { codexRootTranscript, codexRolloutSessionId } from "./harnesses/codex.js";
|
|
6
|
+
import { antigravityBinding } from "./harnesses/antigravity.js";
|
|
3
7
|
// One state per transcript, kept by the long-lived reader (seat-turns worker, server): each read parses only new bytes.
|
|
4
8
|
const states = new Map();
|
|
5
9
|
/** Masked like process descriptors: a value that may carry a secret, or a long one, is shortened. */
|
|
@@ -51,16 +55,13 @@ export function applyClaudeTranscriptLine(line, open, done, inputs) {
|
|
|
51
55
|
open.delete(result[key]);
|
|
52
56
|
}
|
|
53
57
|
}
|
|
54
|
-
/**
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
*/
|
|
60
|
-
|
|
61
|
-
const file = meta.kind === "claude" ? claudeSessionTranscriptPath(meta) : null;
|
|
62
|
-
if (!file)
|
|
63
|
-
return null;
|
|
58
|
+
/** The task a caller names: the oldest unfinished agent, or with no agent the oldest shell/other (Kiro, a68 card order). */
|
|
59
|
+
export function representativeTask(tasks) {
|
|
60
|
+
const pool = tasks.some(task => task.kind === "agent") ? tasks.filter(task => task.kind === "agent") : tasks;
|
|
61
|
+
return pool.reduce((first, task) => !first || task.since < first.since ? task : first, null);
|
|
62
|
+
}
|
|
63
|
+
/** Apply new complete lines of a harness record to its kept state; null when the file cannot be read. */
|
|
64
|
+
function readRecord(file, apply) {
|
|
64
65
|
let stat;
|
|
65
66
|
try {
|
|
66
67
|
stat = fs.statSync(file);
|
|
@@ -82,7 +83,7 @@ export function claudeBackgroundTasks(meta) {
|
|
|
82
83
|
state.partial = lines.pop() ?? "";
|
|
83
84
|
for (const line of lines)
|
|
84
85
|
if (line)
|
|
85
|
-
|
|
86
|
+
apply(line, state.open, state.done, state.inputs);
|
|
86
87
|
}
|
|
87
88
|
catch {
|
|
88
89
|
return null;
|
|
@@ -92,12 +93,237 @@ export function claudeBackgroundTasks(meta) {
|
|
|
92
93
|
fs.closeSync(fd);
|
|
93
94
|
}
|
|
94
95
|
}
|
|
96
|
+
return state;
|
|
97
|
+
}
|
|
98
|
+
/** Tasks opened since this launch's metadata was created (earlier ones belonged to an earlier process), and the oldest. */
|
|
99
|
+
function liveTasks(meta, state) {
|
|
95
100
|
const start = Date.parse(meta.created_at);
|
|
96
101
|
const live = [...state.open.values()].filter(task => !Number.isFinite(start) || Date.parse(task.since) >= start - 1000);
|
|
97
|
-
const oldest = live
|
|
102
|
+
const oldest = representativeTask(live);
|
|
98
103
|
return { count: live.length, oldest };
|
|
99
104
|
}
|
|
105
|
+
/**
|
|
106
|
+
* Claude's own count of unfinished background tasks of this seat, from its transcript: an async Agent launch
|
|
107
|
+
* (toolUseResult.isAsync + agentId) or a background Bash (toolUseResult.backgroundTaskId) with no <task-notification>
|
|
108
|
+
* naming it yet. null: not a Claude seat, or the transcript cannot be read.
|
|
109
|
+
*/
|
|
110
|
+
export function claudeBackgroundTasks(meta) {
|
|
111
|
+
const file = meta.kind === "claude" ? claudeSessionTranscriptPath(meta) : null;
|
|
112
|
+
const state = file ? readRecord(file, applyClaudeTranscriptLine) : null;
|
|
113
|
+
return state ? liveTasks(meta, state) : null;
|
|
114
|
+
}
|
|
115
|
+
/**
|
|
116
|
+
* Apply one Grok updates.jsonl row (1.0.77, captured 2026-11-14): subagent_spawned / subagent_finished,
|
|
117
|
+
* task_backgrounded / task_completed, and the background_tasks snapshot (each task's status and kind).
|
|
118
|
+
*/
|
|
119
|
+
export function applyGrokUpdateLine(line, open, done) {
|
|
120
|
+
if (!/"sessionUpdate":"(?:subagent_|task_|background_tasks)/.test(line))
|
|
121
|
+
return;
|
|
122
|
+
let row;
|
|
123
|
+
try {
|
|
124
|
+
row = JSON.parse(line);
|
|
125
|
+
}
|
|
126
|
+
catch {
|
|
127
|
+
return;
|
|
128
|
+
}
|
|
129
|
+
const update = row?.params?.update;
|
|
130
|
+
const at = Number.isFinite(row?.timestamp) ? new Date(row.timestamp * 1000).toISOString() : null;
|
|
131
|
+
const close = (id) => { if (typeof id === "string") {
|
|
132
|
+
done.add(id);
|
|
133
|
+
open.delete(id);
|
|
134
|
+
} };
|
|
135
|
+
const add = (id, task) => { if (typeof id === "string" && task && !done.has(id) && !open.has(id))
|
|
136
|
+
open.set(id, task); };
|
|
137
|
+
switch (update?.sessionUpdate) {
|
|
138
|
+
case "subagent_spawned":
|
|
139
|
+
if (at)
|
|
140
|
+
add(update.subagent_id, { kind: "agent", label: taskLabel(update.description, "agent"), since: at });
|
|
141
|
+
break;
|
|
142
|
+
case "subagent_finished":
|
|
143
|
+
close(update.subagent_id);
|
|
144
|
+
break;
|
|
145
|
+
case "task_backgrounded":
|
|
146
|
+
if (at)
|
|
147
|
+
add(update.task_id, { kind: "shell", label: taskLabel(update.command, "shell"), since: at });
|
|
148
|
+
break;
|
|
149
|
+
case "task_completed":
|
|
150
|
+
close(update.task_snapshot?.task_id ?? update.task_id);
|
|
151
|
+
break;
|
|
152
|
+
case "background_tasks":
|
|
153
|
+
for (const task of Array.isArray(update.tasks) ? update.tasks : []) {
|
|
154
|
+
if (task?.status !== "running") {
|
|
155
|
+
close(task?.task_id);
|
|
156
|
+
continue;
|
|
157
|
+
}
|
|
158
|
+
const since = typeof task.started_at === "string" && Number.isFinite(Date.parse(task.started_at)) ? new Date(task.started_at).toISOString() : at;
|
|
159
|
+
const kind = task.kind === "bash" ? "shell" : task.kind === "subagent" ? "agent" : "other";
|
|
160
|
+
if (since)
|
|
161
|
+
add(task.task_id, { kind, label: taskLabel(task.description ?? task.command, kind), since });
|
|
162
|
+
}
|
|
163
|
+
break;
|
|
164
|
+
}
|
|
165
|
+
}
|
|
166
|
+
/** Grok's own count of unfinished background tasks of this seat, from its session's updates.jsonl; null if unreadable. */
|
|
167
|
+
export function grokBackgroundTasks(meta) {
|
|
168
|
+
const dir = meta.kind === "grok" ? grokSessionDirectory(meta) : null;
|
|
169
|
+
const state = dir ? readRecord(path.join(dir, "updates.jsonl"), applyGrokUpdateLine) : null;
|
|
170
|
+
return state ? liveTasks(meta, state) : null;
|
|
171
|
+
}
|
|
172
|
+
const codexChildren = new Map();
|
|
173
|
+
/** Apply one rollout row of a possible Codex subagent: its session_meta head, then task_started / task_complete / turn_aborted. */
|
|
174
|
+
export function applyCodexChildLine(line, child) {
|
|
175
|
+
let row;
|
|
176
|
+
if (child.head === undefined) {
|
|
177
|
+
try {
|
|
178
|
+
row = JSON.parse(line);
|
|
179
|
+
}
|
|
180
|
+
catch {
|
|
181
|
+
child.head = null;
|
|
182
|
+
return;
|
|
183
|
+
}
|
|
184
|
+
const meta = row?.type === "session_meta" ? row.payload : null;
|
|
185
|
+
child.head = meta?.thread_source === "subagent" && typeof meta.session_id === "string"
|
|
186
|
+
? { root: meta.session_id, label: taskLabel(String(meta.agent_path ?? "").split("/").pop() || meta.agent_nickname, "agent") } : null;
|
|
187
|
+
return;
|
|
188
|
+
}
|
|
189
|
+
if (!child.head || !/"type":"(?:task_started|task_complete|turn_aborted)"/.test(line))
|
|
190
|
+
return;
|
|
191
|
+
try {
|
|
192
|
+
row = JSON.parse(line);
|
|
193
|
+
}
|
|
194
|
+
catch {
|
|
195
|
+
return;
|
|
196
|
+
}
|
|
197
|
+
const type = row?.type === "event_msg" ? row.payload?.type : null;
|
|
198
|
+
if (type === "task_started") {
|
|
199
|
+
child.running++;
|
|
200
|
+
if (typeof row.timestamp === "string")
|
|
201
|
+
child.since = row.timestamp;
|
|
202
|
+
}
|
|
203
|
+
else if (type === "task_complete" || type === "turn_aborted")
|
|
204
|
+
child.running = Math.max(0, child.running - 1);
|
|
205
|
+
}
|
|
206
|
+
/** Rollout files under CODEX_HOME/sessions/YYYY/MM/DD created (UUIDv7 in the name) at or after `start`. */
|
|
207
|
+
function codexRolloutsSince(home, start) {
|
|
208
|
+
const files = [];
|
|
209
|
+
for (let day = start - 86_400_000; day <= Date.now() + 86_400_000; day += 86_400_000) {
|
|
210
|
+
const date = new Date(day), dir = path.join(home, "sessions", String(date.getUTCFullYear()), String(date.getUTCMonth() + 1).padStart(2, "0"), String(date.getUTCDate()).padStart(2, "0"));
|
|
211
|
+
let names;
|
|
212
|
+
try {
|
|
213
|
+
names = fs.readdirSync(dir);
|
|
214
|
+
}
|
|
215
|
+
catch {
|
|
216
|
+
continue;
|
|
217
|
+
}
|
|
218
|
+
for (const name of names) {
|
|
219
|
+
const id = /-([0-9a-f]{8})-([0-9a-f]{4})-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.jsonl$/.exec(name);
|
|
220
|
+
if (id && Number.parseInt(id[1] + id[2], 16) >= start - 1000)
|
|
221
|
+
files.push(path.join(dir, name));
|
|
222
|
+
}
|
|
223
|
+
}
|
|
224
|
+
return files;
|
|
225
|
+
}
|
|
226
|
+
/**
|
|
227
|
+
* Codex's own count of its working subagents for this seat (0.169): each subagent thread writes its own rollout whose
|
|
228
|
+
* session_meta names the root thread (`session_id`) and `thread_source: "subagent"`; it is working while it has more
|
|
229
|
+
* task_started than task_complete/turn_aborted. Rollouts created before this launch are not read. null when the seat's
|
|
230
|
+
* root thread is not known yet.
|
|
231
|
+
*/
|
|
232
|
+
export function codexBackgroundTasks(meta) {
|
|
233
|
+
if (meta.kind !== "codex" || !meta.codex_home)
|
|
234
|
+
return null;
|
|
235
|
+
let root;
|
|
236
|
+
try {
|
|
237
|
+
const transcript = codexRootTranscript(meta);
|
|
238
|
+
root = transcript ? codexRolloutSessionId(meta, transcript) : null;
|
|
239
|
+
}
|
|
240
|
+
catch {
|
|
241
|
+
return null;
|
|
242
|
+
}
|
|
243
|
+
if (!root)
|
|
244
|
+
return null;
|
|
245
|
+
const start = Date.parse(meta.created_at);
|
|
246
|
+
if (!Number.isFinite(start))
|
|
247
|
+
return null;
|
|
248
|
+
const live = [];
|
|
249
|
+
for (const file of codexRolloutsSince(meta.codex_home, start)) {
|
|
250
|
+
let stat;
|
|
251
|
+
try {
|
|
252
|
+
stat = fs.statSync(file);
|
|
253
|
+
}
|
|
254
|
+
catch {
|
|
255
|
+
continue;
|
|
256
|
+
}
|
|
257
|
+
let child = codexChildren.get(file);
|
|
258
|
+
if (!child || child.ino !== stat.ino || stat.size < child.offset)
|
|
259
|
+
codexChildren.set(file, child = { ino: stat.ino, offset: 0, partial: "", head: undefined, running: 0, since: null });
|
|
260
|
+
if (child.head !== null && stat.size > child.offset) {
|
|
261
|
+
let fd = null;
|
|
262
|
+
try {
|
|
263
|
+
fd = fs.openSync(file, "r");
|
|
264
|
+
const buffer = Buffer.alloc(stat.size - child.offset);
|
|
265
|
+
const read = fs.readSync(fd, buffer, 0, buffer.length, child.offset);
|
|
266
|
+
child.offset += read;
|
|
267
|
+
const lines = (child.partial + buffer.subarray(0, read).toString("utf8")).split("\n");
|
|
268
|
+
child.partial = lines.pop() ?? "";
|
|
269
|
+
for (const line of lines)
|
|
270
|
+
if (line)
|
|
271
|
+
applyCodexChildLine(line, child);
|
|
272
|
+
}
|
|
273
|
+
catch {
|
|
274
|
+
continue;
|
|
275
|
+
}
|
|
276
|
+
finally {
|
|
277
|
+
if (fd !== null)
|
|
278
|
+
fs.closeSync(fd);
|
|
279
|
+
}
|
|
280
|
+
}
|
|
281
|
+
if (child.head?.root === root && child.running > 0 && child.since)
|
|
282
|
+
live.push({ kind: "agent", label: child.head.label, since: child.since });
|
|
283
|
+
}
|
|
284
|
+
const oldest = representativeTask(live);
|
|
285
|
+
return { count: live.length, oldest };
|
|
286
|
+
}
|
|
287
|
+
/**
|
|
288
|
+
* Apply one Antigravity transcript step (agy 1.5.8, captured 2026-11-14): a step whose content says "Tool is running as a
|
|
289
|
+
* background task with task id: <ID>" opens it (label = its "Task Description"); a later message carrying
|
|
290
|
+
* `Task id "<ID>" finished` closes it.
|
|
291
|
+
*/
|
|
292
|
+
export function applyAntigravityStepLine(line, open, done) {
|
|
293
|
+
if (!line.includes("background task with task id") && !line.includes("finished with result"))
|
|
294
|
+
return;
|
|
295
|
+
let row;
|
|
296
|
+
try {
|
|
297
|
+
row = JSON.parse(line);
|
|
298
|
+
}
|
|
299
|
+
catch {
|
|
300
|
+
return;
|
|
301
|
+
}
|
|
302
|
+
const content = typeof row?.content === "string" ? row.content : "";
|
|
303
|
+
for (const match of content.matchAll(/Task id "([^"]+)" finished/g)) {
|
|
304
|
+
done.add(match[1]);
|
|
305
|
+
open.delete(match[1]);
|
|
306
|
+
}
|
|
307
|
+
const started = /running as a background task with task id: (\S+)/.exec(content);
|
|
308
|
+
const at = typeof row?.created_at === "string" && Number.isFinite(Date.parse(row.created_at)) ? new Date(row.created_at).toISOString() : null;
|
|
309
|
+
if (started && at && !done.has(started[1]) && !open.has(started[1]))
|
|
310
|
+
open.set(started[1], { kind: "shell", label: taskLabel(/Task Description: (.*)/.exec(content)?.[1], "shell"), since: at });
|
|
311
|
+
}
|
|
312
|
+
/** Antigravity's own count of unfinished background tasks of this seat, from the bound conversation's transcript. */
|
|
313
|
+
export function antigravityBackgroundTasks(meta) {
|
|
314
|
+
let file = null;
|
|
315
|
+
try {
|
|
316
|
+
file = meta.kind === "antigravity" ? antigravityBinding(meta)?.transcript ?? null : null;
|
|
317
|
+
}
|
|
318
|
+
catch {
|
|
319
|
+
return null;
|
|
320
|
+
}
|
|
321
|
+
const state = file ? readRecord(file, applyAntigravityStepLine) : null;
|
|
322
|
+
return state ? liveTasks(meta, state) : null;
|
|
323
|
+
}
|
|
100
324
|
/** The harness's own statement of unfinished background tasks; null where the harness gives none Aiterm reads (a68). */
|
|
101
325
|
export function harnessBackgroundTasks(meta) {
|
|
102
|
-
return meta.kind === "claude" ? claudeBackgroundTasks(meta) :
|
|
326
|
+
return meta.kind === "claude" ? claudeBackgroundTasks(meta) : meta.kind === "grok" ? grokBackgroundTasks(meta)
|
|
327
|
+
: meta.kind === "codex" ? codexBackgroundTasks(meta)
|
|
328
|
+
: meta.kind === "antigravity" ? antigravityBackgroundTasks(meta) : null;
|
|
103
329
|
}
|
package/dist/remote.js
CHANGED
|
@@ -235,8 +235,12 @@ function retireWarm(ref, session) {
|
|
|
235
235
|
if (!session.inflight)
|
|
236
236
|
void session.client.close().catch(() => { });
|
|
237
237
|
}
|
|
238
|
-
|
|
239
|
-
|
|
238
|
+
// One warm session per terminal and lane. pty_list (the seat-turns reads) has its own lane: the terminal answers each warm
|
|
239
|
+
// session in one process, so a call that blocks there (a close waiting ~2 min on fox, 11/14 01:33 JST) would freeze every
|
|
240
|
+
// read of that terminal behind it.
|
|
241
|
+
function warmLane(name) { return name === "pty_list" ? "list" : "main"; }
|
|
242
|
+
function warmSession(target, sshArgs, lane) {
|
|
243
|
+
const ref = `${target.trusted_ref}\0${lane}`;
|
|
240
244
|
const kept = warmSessions.get(ref);
|
|
241
245
|
if (kept && !kept.dead && Date.now() - kept.born < WARM_MAX_AGE_MS)
|
|
242
246
|
return kept;
|
|
@@ -255,7 +259,8 @@ function warmSession(target, sshArgs) {
|
|
|
255
259
|
return session;
|
|
256
260
|
}
|
|
257
261
|
async function callWarm(target, sshArgs, request, timeoutMs) {
|
|
258
|
-
const
|
|
262
|
+
const lane = warmLane(request.name), key = `${target.trusted_ref}\0${lane}`;
|
|
263
|
+
const session = warmSession(target, sshArgs, lane);
|
|
259
264
|
session.inflight++;
|
|
260
265
|
if (session.idle) {
|
|
261
266
|
clearTimeout(session.idle);
|
|
@@ -270,10 +275,10 @@ async function callWarm(target, sshArgs, request, timeoutMs) {
|
|
|
270
275
|
finally {
|
|
271
276
|
if (--session.inflight === 0) {
|
|
272
277
|
session.transport.hold(false);
|
|
273
|
-
if (session.dead || warmSessions.get(
|
|
278
|
+
if (session.dead || warmSessions.get(key) !== session)
|
|
274
279
|
void session.client.close().catch(() => { });
|
|
275
280
|
else
|
|
276
|
-
session.idle = setTimeout(() => retireWarm(
|
|
281
|
+
session.idle = setTimeout(() => retireWarm(key, session), WARM_IDLE_MS).unref();
|
|
277
282
|
}
|
|
278
283
|
}
|
|
279
284
|
}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "aiterm-mcp",
|
|
3
|
-
"version": "0.70.
|
|
3
|
+
"version": "0.70.54",
|
|
4
4
|
"mcpName": "io.github.kitepon/aiterm-mcp",
|
|
5
5
|
"description": "Persistent terminal MCP with one harness-based launcher for Claude Code, Codex CLI, Grok CLI, Cursor Agent CLI, and Antigravity CLI, plus durable PTYs for SSH, containers, and REPLs.",
|
|
6
6
|
"keywords": [
|