@adecore/agents 0.23.1 → 0.24.1

package/src/chat/chat-log.ts

@@ -66,7 +66,7 @@ export class ChatLog {
     constructor(path: string | null, state: ChatLogState = { seq: 0, resetSeq: 0, lines: [] }) {
         this.path = path;
         this.lines = state.lines;
-        this.bytes = state.lines.reduce((sum, line) => sum + JSON.stringify(line).length + 1, 0);
+        this.bytes = state.lines.reduce((sum, line) => sum + Buffer.byteLength(JSON.stringify(line)) + 1, 0);
         this.seqValue = Math.max(state.seq, state.lines.at(-1)?.seq ?? 0);
         this.resetSeqValue = state.resetSeq;
         const first = state.lines[0];
@@ -107,7 +107,7 @@ export class ChatLog {
         }
         const text = `${JSON.stringify(line)}\n`;
         this.lines.push(line);
-        this.bytes += text.length;
+        this.bytes += Buffer.byteLength(text);
         if (this.path !== null) {
             try {
                 this.fd ??= this.open(this.path);
@@ -146,7 +146,7 @@ export class ChatLog {
         this.lines = this.lines.filter((line) => line.seq > seq);
         this.base = seq;
         const text = this.lines.map((line) => `${JSON.stringify(line)}\n`).join('');
-        this.bytes = text.length;
+        this.bytes = Buffer.byteLength(text);
         if (this.path === null) {
             return;
         }

package/src/chat/chat-process.ts

@@ -42,7 +42,9 @@ export function spawnChatProcess(options: ChatSpawnOptions): ChatProcess {
         env: options.env,
         stdio: ['pipe', 'pipe', 'pipe'],
         // A group of its own, so ending the chat also ends what its agent started (a dev server, a watcher).
-        detached: true
+        // On Windows that would open a console window of its own instead; `taskkill` reaches the tree there.
+        detached: process.platform !== 'win32',
+        windowsHide: true
     });
     // Node reports a missing executable as an event after the call; a start that failed says so on the spot.
     child.on('error', () => undefined);
@@ -74,16 +76,39 @@ export function spawnChatProcess(options: ChatSpawnOptions): ChatProcess {
         },
         stdout: Readable.toWeb(child.stdout) as unknown as ReadableStream<Uint8Array>,
         stderr: Readable.toWeb(child.stderr) as unknown as ReadableStream<Uint8Array>,
-        kill: (signal) => {
-            try {
-                process.kill(-pid, signal);
-            } catch {
-                // Nothing of the group is left to signal.
-            }
-        }
+        kill: (signal) => killProcessTree(pid, signal)
     };
 }
 
+export interface ProcessTreeKillOptions {
+    platform?: NodeJS.Platform;
+    kill?(pid: number, signal: NodeJS.Signals): void;
+    run?(command: string[]): void;
+}
+
+/* Signals a process and everything it started. Windows has no process groups and no SIGTERM, so there the tree is ended at once. */
+export function killProcessTree(pid: number, signal: 'SIGTERM' | 'SIGKILL', options: ProcessTreeKillOptions = {}): void {
+    const { platform = process.platform, kill = process.kill, run = runQuietly } = options;
+    if (platform === 'win32') {
+        run(['taskkill', '/pid', String(pid), '/t', '/f']);
+        return;
+    }
+    try {
+        kill(-pid, signal);
+    } catch {
+        // Nothing of the group is left to signal.
+    }
+}
+
+function runQuietly([command, ...args]: string[]): void {
+    if (command === undefined) {
+        return;
+    }
+    const child = spawn(command, args, { stdio: 'ignore', windowsHide: true });
+    // A tree that already ended makes taskkill fail, which is what the caller wanted anyway.
+    child.on('error', () => undefined);
+}
+
 // After stdin closed, a CLI that is still around is not going to say more.
 const EXIT_GRACE_MS = 3000;
 // What a CLI and everything it started get between the SIGTERM and the SIGKILL.
@@ -133,6 +158,101 @@ export class StreamTail {
     }
 }
 
+// Far above any frame either CLI writes, a base64 document in a tool result included; it only bounds a CLI that stopped breaking lines.
+export const MAX_LINE_LENGTH = 64_000_000;
+
+/*
+ * Cuts decoded output into lines. A chunk is searched only for itself and a partial line is joined
+ * once, when its line break comes, so a long line costs its length once. A line longer than `max`
+ * UTF-16 units is dropped whole, with `onOverflow` called once for it, and the next line reads as usual.
+ */
+export class LineSplitter {
+    private readonly onLine: (line: string) => void;
+    private readonly onOverflow: () => void;
+    private readonly max: number;
+    private parts: string[] = [];
+    private length = 0;
+    private dropping = false;
+
+    constructor(onLine: (line: string) => void, onOverflow: () => void, max = MAX_LINE_LENGTH) {
+        this.onLine = onLine;
+        this.onOverflow = onOverflow;
+        this.max = max;
+    }
+
+    push(text: string): void {
+        let start = 0;
+        let newline = text.indexOf('\n');
+        while (newline >= 0) {
+            this.add(text.slice(start, newline));
+            const line = this.take();
+            if (line !== null) {
+                this.onLine(line);
+            }
+            start = newline + 1;
+            newline = text.indexOf('\n', start);
+        }
+        this.add(text.slice(start));
+    }
+
+    /* Hands on what came after the last line break, for a stream that ended without one. */
+    end(): void {
+        const line = this.take();
+        if (line !== null && line !== '') {
+            this.onLine(line);
+        }
+    }
+
+    private add(piece: string): void {
+        if (this.dropping || piece === '') {
+            return;
+        }
+        this.length += piece.length;
+        if (this.length > this.max) {
+            this.parts = [];
+            this.dropping = true;
+            this.onOverflow();
+            return;
+        }
+        this.parts.push(piece);
+    }
+
+    private take(): string | null {
+        const line = this.dropping ? null : this.parts.join('');
+        this.parts = [];
+        this.length = 0;
+        this.dropping = false;
+        return line;
+    }
+}
+
+/*
+ * Hands every line of a CLI's output to `onLine` until the stream ends, through a `LineSplitter`.
+ * A read that fails rejects, after every line that came before it was handed on.
+ */
+export async function readStreamLines(
+    stream: ReadableStream<Uint8Array>,
+    onLine: (line: string) => void,
+    onOverflow: () => void,
+    max = MAX_LINE_LENGTH
+): Promise<void> {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    const lines = new LineSplitter(onLine, onOverflow, max);
+    try {
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done) {
+                break;
+            }
+            lines.push(decoder.decode(value, { stream: true }));
+        }
+        lines.end();
+    } finally {
+        reader.releaseLock();
+    }
+}
+
 export interface ChatChildOptions extends Omit<ChatSpawnOptions, 'onExit'> {
     spawn?: SpawnChatProcess;
     // `stderr` is the tail of what the CLI wrote there, for an exit with an error code only.