Address PR review comments for terminal integration

Julius Marminge committed 9 months ago

Commit 3bfda731 parent 0133d958 files · +374 −147Browse files

Unified · Split

8 files

apps/server/src/git.test.ts +15 −0
apps/server/src/git.ts +61 −4
apps/server/src/terminalManager.test.ts +32 −10
apps/server/src/terminalManager.ts +223 −109
apps/server/src/wsServer.test.ts +16 −0
apps/server/src/wsServer.ts +5 −2
apps/web/src/components/ChatView.tsx +0 −1
apps/web/src/components/ThreadTerminalDrawer.tsx +22 −21

apps/server/src/git.test.ts+15−0

@@ -53,6 +53,21 @@ async function initRepoWithCommit(cwd: string): Promise<void> { · 52 unmodified lines
53	// ── Tests ──	53	// ── Tests ──
54		54
55	describe("git integration", () => {	55	describe("git integration", () => {
		56	describe("runTerminalCommand", () => {
		57	it("caps captured output when maxOutputBytes is exceeded", async () => {
		58	const result = await runTerminalCommand({
		59	command: `node -e "process.stdout.write('x'.repeat(2000))"`,
		60	cwd: process.cwd(),
		61	timeoutMs: 10_000,
		62	maxOutputBytes: 128,
		63	});
		64
		65	expect(result.code).toBe(0);
		66	expect(result.stdout.length).toBeLessThanOrEqual(128);
		67	expect(result.stderr).toContain("output truncated");
		68	});
		69	});
		70
56	// ── initGitRepo ──	71	// ── initGitRepo ──
57		72
58	describe("initGitRepo", () => {	73	describe("initGitRepo", () => {

apps/server/src/git.ts+61−4

   command: string;
   cwd: string;
   timeoutMs?: number;
+  maxOutputBytes?: number;
 }
 export interface TerminalCommandResult {
   timedOut: boolean;
 }
+const DEFAULT_MAX_OUTPUT_BYTES = 1_000_000;
+function appendChunkWithinLimit(
+  target: string,
+  currentBytes: number,
+  chunk: Buffer,
+  maxBytes: number,
+): {
+  next: string;
+  nextBytes: number;
+  truncated: boolean;
+} {
+  const remaining = maxBytes - currentBytes;
+  if (remaining <= 0) {
+    return { next: target, nextBytes: currentBytes, truncated: true };
+  }
+  if (chunk.length <= remaining) {
+    return {
+      next: `${target}${chunk.toString()}`,
+      nextBytes: currentBytes + chunk.length,
+      truncated: false,
+    };
+  }
+  return {
+    next: `${target}${chunk.subarray(0, remaining).toString()}`,
+    nextBytes: currentBytes + remaining,
+    truncated: true,
+  };
+}
 /** Spawn git directly with an argv array — no shell, no quoting needed. */
 function runGit(args: string[], cwd: string, timeoutMs = 30_000): Promise<TerminalCommandResult> {
   return new Promise((resolve, reject) => {
       stdio: ["ignore", "pipe", "pipe"],
     });
+    const maxOutputBytes = DEFAULT_MAX_OUTPUT_BYTES;
     let stdout = "";
     let stderr = "";
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
     let timedOut = false;
+    let outputTruncated = false;
     const timeout = setTimeout(() => {
       timedOut = true;
     }, timeoutMs);
     child.stdout?.on("data", (chunk: Buffer) => {
-      stdout += chunk.toString();
+      const appended = appendChunkWithinLimit(stdout, stdoutBytes, chunk, maxOutputBytes);
+      stdout = appended.next;
+      stdoutBytes = appended.nextBytes;
+      outputTruncated = outputTruncated || appended.truncated;
     });
     child.stderr?.on("data", (chunk: Buffer) => {
-      stderr += chunk.toString();
+      const appended = appendChunkWithinLimit(stderr, stderrBytes, chunk, maxOutputBytes);
+      stderr = appended.next;
+      stderrBytes = appended.nextBytes;
+      outputTruncated = outputTruncated || appended.truncated;
     });
     child.on("error", (error) => {
       clearTimeout(timeout);
     });
     child.on("close", (code, signal) => {
       clearTimeout(timeout);
+      if (outputTruncated) {
+        stderr = `${stderr}\n[output truncated at ${maxOutputBytes} bytes]`;
+      }
       resolve({ stdout, stderr, code: code ?? null, signal: signal ?? null, timedOut });
     });
   });
 export async function runTerminalCommand(
   input: TerminalCommandInput,
 ): Promise<TerminalCommandResult> {
+  const maxOutputBytes = input.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
   const shellPath =
     process.platform === "win32"
       ? (process.env.ComSpec ?? "cmd.exe")
     let stdout = "";
     let stderr = "";
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
     let timedOut = false;
+    let outputTruncated = false;
     const timeout = setTimeout(() => {
       timedOut = true;
     }, input.timeoutMs ?? 30_000);
     child.stdout?.on("data", (chunk: Buffer) => {
-      stdout += chunk.toString();
+      const appended = appendChunkWithinLimit(stdout, stdoutBytes, chunk, maxOutputBytes);
+      stdout = appended.next;
+      stdoutBytes = appended.nextBytes;
+      outputTruncated = outputTruncated || appended.truncated;
     });
     child.stderr?.on("data", (chunk: Buffer) => {
-      stderr += chunk.toString();
+      const appended = appendChunkWithinLimit(stderr, stderrBytes, chunk, maxOutputBytes);
+      stderr = appended.next;
+      stderrBytes = appended.nextBytes;
+      outputTruncated = outputTruncated || appended.truncated;
     });
     child.on("error", (error) => {
     child.on("close", (code, signal) => {
       clearTimeout(timeout);
+      if (outputTruncated) {
+        stderr = `${stderr}\n[output truncated at ${maxOutputBytes} bytes]`;
+      }
       resolve({
         stdout,
         stderr,

apps/server/src/terminalManager.test.ts+32−10

   };
 }
+function historyLogName(threadId: string): string {
+  return `terminal_${Buffer.from(threadId, "utf8").toString("base64url")}.log`;
+}
+function historyLogPath(logsDir: string, threadId = "thread-1"): string {
+  return path.join(logsDir, historyLogName(threadId));
+}
 describe("TerminalManager", () => {
   const tempDirs: string[] = [];
   it("spawns lazily and reuses running terminal per thread", async () => {
     const { manager, ptyAdapter } = makeManager();
-    const first = await manager.open(openInput());
+    const [first, second] = await Promise.all([manager.open(openInput()), manager.open(openInput())]);
-    const second = await manager.open(openInput());
+    const third = await manager.open(openInput());
     expect(first.threadId).toBe("thread-1");
     expect(second.threadId).toBe("thread-1");
+    expect(third.threadId).toBe("thread-1");
     expect(ptyAdapter.spawnInputs).toHaveLength(1);
     manager.dispose();
     if (!process) return;
     process.emitData("hello\n");
-    await waitFor(() => fs.existsSync(path.join(logsDir, "thread-1.log")));
+    await waitFor(() => fs.existsSync(historyLogPath(logsDir)));
     await manager.clear({ threadId: "thread-1" });
-    await waitFor(() => fs.readFileSync(path.join(logsDir, "thread-1.log"), "utf8") === "");
+    await waitFor(() => fs.readFileSync(historyLogPath(logsDir), "utf8") === "");
     expect(events.some((event) => event.type === "cleared")).toBe(true);
     expect(firstProcess).toBeDefined();
     if (!firstProcess) return;
     firstProcess.emitData("before restart\n");
-    await waitFor(() => fs.existsSync(path.join(logsDir, "thread-1.log")));
+    await waitFor(() => fs.existsSync(historyLogPath(logsDir)));
     const snapshot = await manager.restart(openInput());
     expect(snapshot.history).toBe("");
     expect(snapshot.status).toBe("running");
     expect(ptyAdapter.spawnInputs).toHaveLength(2);
-    await waitFor(() => fs.readFileSync(path.join(logsDir, "thread-1.log"), "utf8") === "");
+    await waitFor(() => fs.readFileSync(historyLogPath(logsDir), "utf8") === "");
     manager.dispose();
   });
     expect(process).toBeDefined();
     if (!process) return;
     process.emitData("old data\n");
-    await waitFor(() => fs.existsSync(path.join(logsDir, "thread-1.log")));
+    await waitFor(() => fs.existsSync(historyLogPath(logsDir)));
     process.emitExit({ exitCode: 0, signal: 0 });
     await waitFor(() => events.some((event) => event.type === "exited"));
     expect(reopened.history).toBe("");
     expect(ptyAdapter.spawnInputs).toHaveLength(2);
-    expect(fs.readFileSync(path.join(logsDir, "thread-1.log"), "utf8")).toBe("");
+    expect(fs.readFileSync(historyLogPath(logsDir), "utf8")).toBe("");
     manager.dispose();
   });
     expect(process).toBeDefined();
     if (!process) return;
     process.emitData("bye\n");
-    await waitFor(() => fs.existsSync(path.join(logsDir, "thread-1.log")));
+    await waitFor(() => fs.existsSync(historyLogPath(logsDir)));
     await manager.close({ threadId: "thread-1", deleteHistory: true });
-    expect(fs.existsSync(path.join(logsDir, "thread-1.log"))).toBe(false);
+    expect(fs.existsSync(historyLogPath(logsDir))).toBe(false);
+    manager.dispose();
+  });
+  it("loads existing legacy transcript filenames and keeps new naming for writes", async () => {
+    const { manager, logsDir } = makeManager();
+    const legacyPath = path.join(logsDir, "thread-1.log");
+    fs.writeFileSync(legacyPath, "legacy-line\n", "utf8");
+    const snapshot = await manager.open(openInput());
+    expect(snapshot.history).toBe("legacy-line\n");
+    expect(fs.existsSync(legacyPath)).toBe(true);
     manager.dispose();
   });

apps/server/src/terminalManager.ts+223−109

@@ -21,6 +21,7 @@ import { createLogger } from "./logger"; · 20 unmodified lines
21	import { NodePtyAdapter, type PtyAdapter, type PtyExitEvent, type PtyProcess } from "./ptyAdapter";	21	import { NodePtyAdapter, type PtyAdapter, type PtyExitEvent, type PtyProcess } from "./ptyAdapter";
22		22
23	const DEFAULT_HISTORY_LINE_LIMIT = 5_000;	23	const DEFAULT_HISTORY_LINE_LIMIT = 5_000;
		24	const DEFAULT_PERSIST_DEBOUNCE_MS = 40;
24		25
25	export interface TerminalManagerEvents {	26	export interface TerminalManagerEvents {
26	event: [event: TerminalEvent];	27	event: [event: TerminalEvent];
@@ -68,10 +69,14 @@ function capHistory(history: string, maxLines: number): string { · 41 unmodified lines
68	return hasTrailingNewline ? `${capped}\n` : capped;	69	return hasTrailingNewline ? `${capped}\n` : capped;
69	}	70	}
70		71
71	function toSafeThreadId(threadId: string): string {	72	function legacySafeThreadId(threadId: string): string {
72	return threadId.replace(/[^a-zA-Z0-9._-]/g, "_");	73	return threadId.replace(/[^a-zA-Z0-9._-]/g, "_");
73	}	74	}
74		75
		76	function toSafeThreadId(threadId: string): string {
		77	return `terminal_${Buffer.from(threadId, "utf8").toString("base64url")}`;
		78	}
		79
75	export class TerminalManager extends EventEmitter<TerminalManagerEvents> {	80	export class TerminalManager extends EventEmitter<TerminalManagerEvents> {
76	private readonly sessions = new Map<string, TerminalSessionState>();	81	private readonly sessions = new Map<string, TerminalSessionState>();
77	private readonly logsDir: string;	82	private readonly logsDir: string;
@@ -79,6 +84,10 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> { · 1 unmodified line
79	private readonly ptyAdapter: PtyAdapter;	84	private readonly ptyAdapter: PtyAdapter;
80	private readonly shellResolver: () => string;	85	private readonly shellResolver: () => string;
81	private readonly persistQueues = new Map<string, Promise<void>>();	86	private readonly persistQueues = new Map<string, Promise<void>>();
		87	private readonly persistTimers = new Map<string, ReturnType<typeof setTimeout>>();
		88	private readonly pendingPersistHistory = new Map<string, string>();
		89	private readonly threadLocks = new Map<string, Promise<void>>();
		90	private readonly persistDebounceMs: number;
82	private readonly logger = createLogger("terminal");	91	private readonly logger = createLogger("terminal");
83		92
84	constructor(options: TerminalManagerOptions = {}) {	93	constructor(options: TerminalManagerOptions = {}) {
@@ -87,60 +96,63 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> { · 2 unmodified lines
87	this.historyLineLimit = options.historyLineLimit ?? DEFAULT_HISTORY_LINE_LIMIT;	96	this.historyLineLimit = options.historyLineLimit ?? DEFAULT_HISTORY_LINE_LIMIT;
88	this.ptyAdapter = options.ptyAdapter ?? new NodePtyAdapter();	97	this.ptyAdapter = options.ptyAdapter ?? new NodePtyAdapter();
89	this.shellResolver = options.shellResolver ?? defaultShellResolver;	98	this.shellResolver = options.shellResolver ?? defaultShellResolver;
		99	this.persistDebounceMs = DEFAULT_PERSIST_DEBOUNCE_MS;
90	fs.mkdirSync(this.logsDir, { recursive: true });	100	fs.mkdirSync(this.logsDir, { recursive: true });
91	}	101	}
92		102
93	async open(raw: TerminalOpenInput): Promise<TerminalSessionSnapshot> {	103	async open(raw: TerminalOpenInput): Promise<TerminalSessionSnapshot> {
94	const input = terminalOpenInputSchema.parse(raw);	104	const input = terminalOpenInputSchema.parse(raw);
95	await this.assertValidCwd(input.cwd);	105	return this.runWithThreadLock(input.threadId, async () => {
96	await this.flushPersistQueue(input.threadId);	106	await this.assertValidCwd(input.cwd);
97		107
98	const existing = this.sessions.get(input.threadId);	108	const existing = this.sessions.get(input.threadId);
99	if (!existing) {	109	if (!existing) {
100	const history = await this.readHistory(input.threadId);	110	await this.flushPersistQueue(input.threadId);
101	const session: TerminalSessionState = {	111	const history = await this.readHistory(input.threadId);
102	threadId: input.threadId,	112	const session: TerminalSessionState = {
103	cwd: input.cwd,	113	threadId: input.threadId,
104	status: "starting",	114	cwd: input.cwd,
105	pid: null,	115	status: "starting",
106	history,	116	pid: null,
107	exitCode: null,	117	history,
108	exitSignal: null,	118	exitCode: null,
109	updatedAt: new Date().toISOString(),	119	exitSignal: null,
110	cols: input.cols,	120	updatedAt: new Date().toISOString(),
111	rows: input.rows,	121	cols: input.cols,
112	process: null,	122	rows: input.rows,
113	unsubscribeData: null,	123	process: null,
114	unsubscribeExit: null,	124	unsubscribeData: null,
115	};	125	unsubscribeExit: null,
116	this.sessions.set(input.threadId, session);	126	};
117	this.startSession(session, input, "started");	127	this.sessions.set(input.threadId, session);
118	return this.snapshot(session);	128	this.startSession(session, input, "started");
119	}	129	return this.snapshot(session);
		130	}
120		131
121	if (existing.cwd !== input.cwd) {	132	if (existing.cwd !== input.cwd) {
122	this.stopProcess(existing);	133	this.stopProcess(existing);
123	existing.cwd = input.cwd;	134	existing.cwd = input.cwd;
124	existing.history = "";	135	existing.history = "";
125	await this.persistHistory(existing.threadId, existing.history);	136	await this.persistHistory(existing.threadId, existing.history);
126	} else if (existing.status === "exited" \|\| existing.status === "error") {	137	} else if (existing.status === "exited" \|\| existing.status === "error") {
127	existing.history = "";	138	existing.history = "";
128	await this.persistHistory(existing.threadId, existing.history);	139	await this.persistHistory(existing.threadId, existing.history);
129	}	140	}
130		141
131	if (!existing.process) {	142	if (!existing.process) {
132	this.startSession(existing, input, "started");	143	this.startSession(existing, input, "started");
133	return this.snapshot(existing);	144	return this.snapshot(existing);
134	}	145	}
135		146
136	if (existing.cols !== input.cols \|\| existing.rows !== input.rows) {	147	if (existing.cols !== input.cols \|\| existing.rows !== input.rows) {
137	existing.cols = input.cols;	148	existing.cols = input.cols;
138	existing.rows = input.rows;	149	existing.rows = input.rows;
139	existing.process.resize(input.cols, input.rows);	150	existing.process.resize(input.cols, input.rows);
140	existing.updatedAt = new Date().toISOString();	151	existing.updatedAt = new Date().toISOString();
141	}	152	}
142		153
143	return this.snapshot(existing);	154	return this.snapshot(existing);
		155	});
144	}	156	}
145		157
146	async write(raw: TerminalWriteInput): Promise<void> {	158	async write(raw: TerminalWriteInput): Promise<void> {
@@ -166,61 +178,67 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> { · 19 unmodified lines
166		178
167	async clear(raw: TerminalThreadInput): Promise<void> {	179	async clear(raw: TerminalThreadInput): Promise<void> {
168	const input = terminalThreadInputSchema.parse(raw);	180	const input = terminalThreadInputSchema.parse(raw);
169	const session = this.requireSession(input.threadId);	181	await this.runWithThreadLock(input.threadId, async () => {
170	session.history = "";	182	const session = this.requireSession(input.threadId);
171	session.updatedAt = new Date().toISOString();	183	session.history = "";
172	await this.persistHistory(input.threadId, session.history);	184	session.updatedAt = new Date().toISOString();
173	this.emitEvent({	185	await this.persistHistory(input.threadId, session.history);
174	type: "cleared",	186	this.emitEvent({
175	threadId: input.threadId,	187	type: "cleared",
176	createdAt: new Date().toISOString(),	188	threadId: input.threadId,
		189	createdAt: new Date().toISOString(),
		190	});
177	});	191	});
178	}	192	}
179		193
180	async restart(raw: TerminalOpenInput): Promise<TerminalSessionSnapshot> {	194	async restart(raw: TerminalOpenInput): Promise<TerminalSessionSnapshot> {
181	const input = terminalOpenInputSchema.parse(raw);	195	const input = terminalOpenInputSchema.parse(raw);
182	await this.assertValidCwd(input.cwd);	196	return this.runWithThreadLock(input.threadId, async () => {
183		197	await this.assertValidCwd(input.cwd);
184	let session = this.sessions.get(input.threadId);	198
185	if (!session) {	199	let session = this.sessions.get(input.threadId);
186	session = {	200	if (!session) {
187	threadId: input.threadId,	201	session = {
188	cwd: input.cwd,	202	threadId: input.threadId,
189	status: "starting",	203	cwd: input.cwd,
190	pid: null,	204	status: "starting",
191	history: "",	205	pid: null,
192	exitCode: null,	206	history: "",
193	exitSignal: null,	207	exitCode: null,
194	updatedAt: new Date().toISOString(),	208	exitSignal: null,
195	cols: input.cols,	209	updatedAt: new Date().toISOString(),
196	rows: input.rows,	210	cols: input.cols,
197	process: null,	211	rows: input.rows,
198	unsubscribeData: null,	212	process: null,
199	unsubscribeExit: null,	213	unsubscribeData: null,
200	};	214	unsubscribeExit: null,
201	this.sessions.set(input.threadId, session);	215	};
202	} else {	216	this.sessions.set(input.threadId, session);
203	this.stopProcess(session);	217	} else {
204	session.cwd = input.cwd;	218	this.stopProcess(session);
205	}	219	session.cwd = input.cwd;
		220	}
206		221
207	session.history = "";	222	session.history = "";
208	await this.persistHistory(input.threadId, session.history);	223	await this.persistHistory(input.threadId, session.history);
209	this.startSession(session, input, "restarted");	224	this.startSession(session, input, "restarted");
210	return this.snapshot(session);	225	return this.snapshot(session);
		226	});
211	}	227	}
212		228
213	async close(raw: TerminalCloseInput): Promise<void> {	229	async close(raw: TerminalCloseInput): Promise<void> {
214	const input = terminalCloseInputSchema.parse(raw);	230	const input = terminalCloseInputSchema.parse(raw);
215	await this.flushPersistQueue(input.threadId);	231	await this.runWithThreadLock(input.threadId, async () => {
216	const session = this.sessions.get(input.threadId);	232	const session = this.sessions.get(input.threadId);
217	if (session) {	233	if (session) {
218	this.stopProcess(session);	234	this.stopProcess(session);
219	this.sessions.delete(input.threadId);	235	this.sessions.delete(input.threadId);
220	}	236	}
221	if (input.deleteHistory) {	237	await this.flushPersistQueue(input.threadId);
222	await this.deleteHistory(input.threadId);	238	if (input.deleteHistory) {
223	}	239	await this.deleteHistory(input.threadId);
		240	}
		241	});
224	}	242	}
225		243
226	dispose(): void {	244	dispose(): void {
@@ -228,6 +246,12 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> { · 1 unmodified line
228	this.stopProcess(session);	246	this.stopProcess(session);
229	}	247	}
230	this.sessions.clear();	248	this.sessions.clear();
		249	for (const timer of this.persistTimers.values()) {
		250	clearTimeout(timer);
		251	}
		252	this.persistTimers.clear();
		253	this.pendingPersistHistory.clear();
		254	this.threadLocks.clear();
231	this.persistQueues.clear();	255	this.persistQueues.clear();
232	}	256	}
233		257
@@ -247,8 +271,9 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> { · 13 unmodified lines
247	session.updatedAt = new Date().toISOString();	271	session.updatedAt = new Date().toISOString();
248		272
249	const shell = this.shellResolver();	273	const shell = this.shellResolver();
		274	let ptyProcess: PtyProcess \| null = null;
250	try {	275	try {
251	const ptyProcess = this.ptyAdapter.spawn({	276	ptyProcess = this.ptyAdapter.spawn({
252	shell,	277	shell,
253	cwd: session.cwd,	278	cwd: session.cwd,
254	cols: session.cols,	279	cols: session.cols,
@@ -272,6 +297,13 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> { · 17 unmodified lines
272	snapshot: this.snapshot(session),	297	snapshot: this.snapshot(session),
273	});	298	});
274	} catch (error) {	299	} catch (error) {
		300	if (ptyProcess) {
		301	try {
		302	ptyProcess.kill();
		303	} catch {
		304	// Ignore kill errors during failed startup cleanup.
		305	}
		306	}
275	session.status = "error";	307	session.status = "error";
276	session.pid = null;	308	session.pid = null;
277	session.process = null;	309	session.process = null;
@@ -346,31 +378,60 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> { · 68 unmodified lines
346	}	378	}
347		379
348	private queuePersist(threadId: string, history: string): void {	380	private queuePersist(threadId: string, history: string): void {
349	const task = async () => {	381	this.pendingPersistHistory.set(threadId, history);
350	await fs.promises.writeFile(this.historyPath(threadId), history, "utf8");	382	this.schedulePersist(threadId);
351	};
352	const previous = this.persistQueues.get(threadId) ?? Promise.resolve();
353	const next = previous.catch(() => undefined).then(task);
354	this.persistQueues.set(threadId, next);
355	void next.finally(() => {
356	if (this.persistQueues.get(threadId) === next) {
357	this.persistQueues.delete(threadId);
358	}
359	});
360	}	383	}
361		384
362	private async persistHistory(threadId: string, history: string): Promise<void> {	385	private async persistHistory(threadId: string, history: string): Promise<void> {
		386	this.clearPersistTimer(threadId);
		387	this.pendingPersistHistory.delete(threadId);
		388	await this.enqueuePersistWrite(threadId, history);
		389	}
		390
		391	private enqueuePersistWrite(threadId: string, history: string): Promise<void> {
363	const task = async () => {	392	const task = async () => {
364	await fs.promises.writeFile(this.historyPath(threadId), history, "utf8");	393	await fs.promises.writeFile(this.historyPath(threadId), history, "utf8");
365	};	394	};
366	const previous = this.persistQueues.get(threadId) ?? Promise.resolve();	395	const previous = this.persistQueues.get(threadId) ?? Promise.resolve();
367	const next = previous.catch(() => undefined).then(task);	396	const next = previous
		397	.catch(() => undefined)
		398	.then(task)
		399	.catch((error) => {
		400	this.logger.warn("failed to persist terminal history", {
		401	threadId,
		402	error: error instanceof Error ? error.message : String(error),
		403	});
		404	});
368	this.persistQueues.set(threadId, next);	405	this.persistQueues.set(threadId, next);
369	await next.finally(() => {	406	const finalized = next.finally(() => {
370	if (this.persistQueues.get(threadId) === next) {	407	if (this.persistQueues.get(threadId) === next) {
371	this.persistQueues.delete(threadId);	408	this.persistQueues.delete(threadId);
372	}	409	}
		410	if (this.pendingPersistHistory.has(threadId) && !this.persistTimers.has(threadId)) {
		411	this.schedulePersist(threadId);
		412	}
373	});	413	});
		414	void finalized.catch(() => undefined);
		415	return finalized;
		416	}
		417
		418	private schedulePersist(threadId: string): void {
		419	if (this.persistTimers.has(threadId)) return;
		420	const timer = setTimeout(() => {
		421	this.persistTimers.delete(threadId);
		422	const pendingHistory = this.pendingPersistHistory.get(threadId);
		423	if (pendingHistory === undefined) return;
		424	this.pendingPersistHistory.delete(threadId);
		425	void this.enqueuePersistWrite(threadId, pendingHistory);
		426	}, this.persistDebounceMs);
		427	this.persistTimers.set(threadId, timer);
		428	}
		429
		430	private clearPersistTimer(threadId: string): void {
		431	const timer = this.persistTimers.get(threadId);
		432	if (!timer) return;
		433	clearTimeout(timer);
		434	this.persistTimers.delete(threadId);
374	}	435	}
375		436
376	private async readHistory(threadId: string): Promise<string> {	437	private async readHistory(threadId: string): Promise<string> {
@@ -381,6 +442,19 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> { · 4 unmodified lines
381	await fs.promises.writeFile(this.historyPath(threadId), capped, "utf8");	442	await fs.promises.writeFile(this.historyPath(threadId), capped, "utf8");
382	}	443	}
383	return capped;	444	return capped;
		445	} catch (error) {
		446	if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
		447	throw error;
		448	}
		449	}
		450
		451	try {
		452	const raw = await fs.promises.readFile(this.legacyHistoryPath(threadId), "utf8");
		453	const capped = capHistory(raw, this.historyLineLimit);
		454	if (capped !== raw) {
		455	await fs.promises.writeFile(this.legacyHistoryPath(threadId), capped, "utf8");
		456	}
		457	return capped;
384	} catch (error) {	458	} catch (error) {
385	if ((error as NodeJS.ErrnoException).code === "ENOENT") {	459	if ((error as NodeJS.ErrnoException).code === "ENOENT") {
386	return "";	460	return "";
@@ -391,7 +465,10 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> { · 4 unmodified lines
391		465
392	private async deleteHistory(threadId: string): Promise<void> {	466	private async deleteHistory(threadId: string): Promise<void> {
393	try {	467	try {
394	await fs.promises.rm(this.historyPath(threadId), { force: true });	468	await Promise.all([
		469	fs.promises.rm(this.historyPath(threadId), { force: true }),
		470	fs.promises.rm(this.legacyHistoryPath(threadId), { force: true }),
		471	]);
395	} catch (error) {	472	} catch (error) {
396	this.logger.warn("failed to delete terminal history", {	473	this.logger.warn("failed to delete terminal history", {
397	threadId,	474	threadId,
@@ -401,9 +478,21 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> { · 3 unmodified lines
401	}	478	}
402		479
403	private async flushPersistQueue(threadId: string): Promise<void> {	480	private async flushPersistQueue(threadId: string): Promise<void> {
404	const pending = this.persistQueues.get(threadId);	481	this.clearPersistTimer(threadId);
405	if (!pending) return;	482
406	await pending.catch(() => undefined);	483	while (true) {
		484	const pendingHistory = this.pendingPersistHistory.get(threadId);
		485	if (pendingHistory !== undefined) {
		486	this.pendingPersistHistory.delete(threadId);
		487	await this.enqueuePersistWrite(threadId, pendingHistory);
		488	}
		489
		490	const pending = this.persistQueues.get(threadId);
		491	if (!pending) {
		492	return;
		493	}
		494	await pending.catch(() => undefined);
		495	}
407	}	496	}
408		497
409	private async assertValidCwd(cwd: string): Promise<void> {	498	private async assertValidCwd(cwd: string): Promise<void> {
@@ -449,4 +538,29 @@ export class TerminalManager extends EventEmitter<TerminalManagerEvents> { · 39 unmodified lines
449	private historyPath(threadId: string): string {	538	private historyPath(threadId: string): string {
450	return path.join(this.logsDir, `${toSafeThreadId(threadId)}.log`);	539	return path.join(this.logsDir, `${toSafeThreadId(threadId)}.log`);
451	}	540	}
		541
		542	private legacyHistoryPath(threadId: string): string {
		543	return path.join(this.logsDir, `${legacySafeThreadId(threadId)}.log`);
		544	}
		545
		546	private async runWithThreadLock<T>(
		547	threadId: string,
		548	task: () => Promise<T>,
		549	): Promise<T> {
		550	const previous = this.threadLocks.get(threadId) ?? Promise.resolve();
		551	let release: () => void = () => {};
		552	const current = new Promise<void>((resolve) => {
		553	release = resolve;
		554	});
		555	this.threadLocks.set(threadId, current);
		556	await previous.catch(() => undefined);
		557	try {
		558	return await task();
		559	} finally {
		560	release();
		561	if (this.threadLocks.get(threadId) === current) {
		562	this.threadLocks.delete(threadId);
		563	}
		564	}
		565	}
452	}	566	}

apps/server/src/wsServer.test.ts+16−0

@@ -382,6 +382,22 @@ describe("WebSocket Server", () => { · 381 unmodified lines
382	expect((push.data as TerminalEvent).type).toBe("output");	382	expect((push.data as TerminalEvent).type).toBe("output");
383	});	383	});
384		384
		385	it("detaches terminal event listener on stop for injected manager", async () => {
		386	const terminalManager = new MockTerminalManager();
		387	server = createTestServer({
		388	cwd: "/test",
		389	terminalManager: terminalManager as unknown as TerminalManager,
		390	});
		391	await server.start();
		392
		393	expect(terminalManager.listenerCount("event")).toBe(1);
		394
		395	await server.stop();
		396	server = null;
		397
		398	expect(terminalManager.listenerCount("event")).toBe(0);
		399	});
		400
385	it("returns validation errors for invalid terminal open params", async () => {	401	it("returns validation errors for invalid terminal open params", async () => {
386	server = createTestServer({ cwd: "/test" });	402	server = createTestServer({ cwd: "/test" });
387	await server.start();	403	await server.start();

apps/server/src/wsServer.ts+5−2

   EDITORS,
   WS_CHANNELS,
   WS_METHODS,
+  type TerminalEvent,
   type WsPush,
   type WsRequest,
   type WsResponse,
     logOutgoingPush(push, recipients);
   });
-  terminalManager.on("event", (event) => {
+  const onTerminalEvent = (event: TerminalEvent) => {
     const push: WsPush = {
       type: "push",
       channel: WS_CHANNELS.terminalEvent,
       }
     }
     logOutgoingPush(push, recipients);
-  });
+  };
+  terminalManager.on("event", onTerminalEvent);
   // HTTP server — serves static files or redirects to Vite dev server
   const httpServer = http.createServer((req, res) => {
   }
   async function stop(): Promise<void> {
+    terminalManager.off("event", onTerminalEvent);
     providerManager.stopAll();
     providerManager.dispose();
     terminalManager.dispose();

apps/web/src/components/ChatView.tsx+0−1

@@ -1207,7 +1207,6 @@ export default function ChatView() { · 1206 unmodified lines
1207	</form>	1207	</form>
1208	</div>	1208	</div>
1209		1209
1210	<BranchToolbar envMode={envMode} onEnvModeChange={setEnvMode} envLocked={envLocked} />
1211	<BranchToolbar envMode={envMode} onEnvModeChange={setEnvMode} envLocked={envLocked} />	1210	<BranchToolbar envMode={envMode} onEnvModeChange={setEnvMode} envLocked={envLocked} />
1212		1211
1213	{activeThread.terminalOpen && api && activeProject && (	1212	{activeThread.terminalOpen && api && activeProject && (

apps/web/src/components/ThreadTerminalDrawer.tsx+22−21

     [],
   );
+  const fitAndResizeTerminal = useCallback(() => {
+    const activeTerminal = terminalRef.current;
+    const activeFitAddon = fitAddonRef.current;
+    if (!activeTerminal || !activeFitAddon) return;
+    activeFitAddon.fit();
+    void api.terminal
+      .resize({
+        threadId,
+        cols: activeTerminal.cols,
+        rows: activeTerminal.rows,
+      })
+      .catch(() => undefined);
+  }, [api, threadId]);
   useEffect(() => {
     const clampedHeight = clampDrawerHeight(height);
     setDrawerHeight(clampedHeight);
   useEffect(() => {
     const onWindowResize = () => {
       const clampedHeight = clampDrawerHeight(drawerHeightRef.current);
-      if (clampedHeight !== drawerHeightRef.current) {
+      const changed = clampedHeight !== drawerHeightRef.current;
+      if (changed) {
         setDrawerHeight(clampedHeight);
+      } else {
+        fitAndResizeTerminal();
       }
       if (!resizeStateRef.current) {
         syncHeight(clampedHeight);
     return () => {
       window.removeEventListener("resize", onWindowResize);
     };
-  }, [syncHeight]);
+  }, [fitAndResizeTerminal, syncHeight]);
   useEffect(() => {
     return () => {
       return false;
     });
-    const resizeAndSync = () => {
-      const activeTerminal = terminalRef.current;
-      const activeFitAddon = fitAddonRef.current;
-      if (!activeTerminal || !activeFitAddon) return;
-      activeFitAddon.fit();
-      void api.terminal
-        .resize({
-          threadId,
-          cols: activeTerminal.cols,
-          rows: activeTerminal.rows,
-        })
-        .catch(() => undefined);
-    };
     const inputDisposable = terminal.onData((data) => {
       void api.terminal
         .write({ threadId, data })
       }
     });
-    window.addEventListener("resize", resizeAndSync);
+    const fitTimer = window.setTimeout(fitAndResizeTerminal, 30);
-    const fitTimer = window.setTimeout(resizeAndSync, 30);
     void openTerminal();
     return () => {
       disposed = true;
       window.clearTimeout(fitTimer);
-      window.removeEventListener("resize", resizeAndSync);
       unsubscribe();
       inputDisposable.dispose();
       themeObserver.disconnect();
       fitAddonRef.current = null;
       terminal.dispose();
     };
-  }, [api, cwd, threadId]);
+  }, [api, cwd, fitAndResizeTerminal, threadId]);
   useEffect(() => {
     const terminal = terminalRef.current;
     return () => {
       window.cancelAnimationFrame(frame);
     };
-  }, [api, drawerHeight, threadId]);
+  }, [api, cwd, drawerHeight, threadId]);
   return (
     <aside

Address PR review comments for terminal integration

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code