feat: Terminal

apps/server/package.json

@@ -17,6 +17,7 @@
     "test": "vitest run"
   },
   "dependencies": {
+    "node-pty": "^1.1.0",
     "open": "^10.1.0",
     "ws": "^8.18.0"
   },

apps/server/src/git.test.ts

@@ -53,6 +53,21 @@ async function initRepoWithCommit(cwd: string): Promise<void> {
 // ── Tests ──
 
 describe("git integration", () => {
+  describe("runTerminalCommand", () => {
+    it("caps captured output when maxOutputBytes is exceeded", async () => {
+      const result = await runTerminalCommand({
+        command: `node -e "process.stdout.write('x'.repeat(2000))"`,
+        cwd: process.cwd(),
+        timeoutMs: 10_000,
+        maxOutputBytes: 128,
+      });
+
+      expect(result.code).toBe(0);
+      expect(result.stdout.length).toBeLessThanOrEqual(128);
+      expect(result.stderr).toContain("output truncated");
+    });
+  });
+
   // ── initGitRepo ──
 
   describe("initGitRepo", () => {

apps/server/src/git.ts

@@ -12,10 +12,53 @@ import type {
   GitListBranchesInput,
   GitListBranchesResult,
   GitRemoveWorktreeInput,
-  TerminalCommandInput,
-  TerminalCommandResult,
 } from "@t3tools/contracts";
 
+export interface TerminalCommandInput {
+  command: string;
+  cwd: string;
+  timeoutMs?: number;
+  maxOutputBytes?: number;
+}
+
+export interface TerminalCommandResult {
+  stdout: string;
+  stderr: string;
+  code: number | null;
+  signal: NodeJS.Signals | null;
+  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) => {
@@ -25,9 +68,13 @@ function runGit(args: string[], cwd: string, timeoutMs = 30_000): Promise<Termin
       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;
@@ -38,17 +85,26 @@ function runGit(args: string[], cwd: string, timeoutMs = 30_000): Promise<Termin
     }, 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);
       reject(error);
     });
     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 });
     });
   });
@@ -57,6 +113,7 @@ function runGit(args: string[], cwd: string, timeoutMs = 30_000): Promise<Termin
 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")
@@ -74,7 +131,10 @@ export async function runTerminalCommand(
 
     let stdout = "";
     let stderr = "";
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
     let timedOut = false;
+    let outputTruncated = false;
 
     const timeout = setTimeout(() => {
       timedOut = true;
@@ -87,11 +147,17 @@ export async function runTerminalCommand(
     }, 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) => {
@@ -101,6 +167,9 @@ export async function runTerminalCommand(
 
     child.on("close", (code, signal) => {
       clearTimeout(timeout);
+      if (outputTruncated) {
+        stderr = `${stderr}\n[output truncated at ${maxOutputBytes} bytes]`;
+      }
       resolve({
         stdout,
         stderr,
@@ -138,8 +207,8 @@ export async function listGitBranches(input: GitListBranchesInput): Promise<GitL
     let currentPath: string | null = null;
     for (const line of worktreeList.stdout.split("\n")) {
       if (line.startsWith("worktree ")) {
-        currentPath = line.slice("worktree ".length);
-        if (!fs.existsSync(currentPath)) currentPath = null;
+        const candidatePath = line.slice("worktree ".length);
+        currentPath = fs.existsSync(candidatePath) ? candidatePath : null;
       } else if (line.startsWith("branch refs/heads/") && currentPath) {
         worktreeMap.set(line.slice("branch refs/heads/".length), currentPath);
       } else if (line === "") {

apps/server/src/ptyAdapter.ts

@@ -0,0 +1,79 @@
+import * as nodePty from "node-pty";
+
+export interface PtyExitEvent {
+  exitCode: number;
+  signal: number | null;
+}
+
+export interface PtyProcess {
+  readonly pid: number;
+  write(data: string): void;
+  resize(cols: number, rows: number): void;
+  kill(signal?: string): void;
+  onData(callback: (data: string) => void): () => void;
+  onExit(callback: (event: PtyExitEvent) => void): () => void;
+}
+
+export interface PtySpawnInput {
+  shell: string;
+  cwd: string;
+  cols: number;
+  rows: number;
+  env: NodeJS.ProcessEnv;
+}
+
+export interface PtyAdapter {
+  spawn(input: PtySpawnInput): PtyProcess;
+}
+
+class NodePtyProcess implements PtyProcess {
+  constructor(private readonly process: nodePty.IPty) {}
+
+  get pid(): number {
+    return this.process.pid;
+  }
+
+  write(data: string): void {
+    this.process.write(data);
+  }
+
+  resize(cols: number, rows: number): void {
+    this.process.resize(cols, rows);
+  }
+
+  kill(signal?: string): void {
+    this.process.kill(signal);
+  }
+
+  onData(callback: (data: string) => void): () => void {
+    const disposable = this.process.onData(callback);
+    return () => {
+      disposable.dispose();
+    };
+  }
+
+  onExit(callback: (event: PtyExitEvent) => void): () => void {
+    const disposable = this.process.onExit((event) => {
+      callback({
+        exitCode: event.exitCode,
+        signal: event.signal ?? null,
+      });
+    });
+    return () => {
+      disposable.dispose();
+    };
+  }
+}
+
+export class NodePtyAdapter implements PtyAdapter {
+  spawn(input: PtySpawnInput): PtyProcess {
+    const ptyProcess = nodePty.spawn(input.shell, [], {
+      cwd: input.cwd,
+      cols: input.cols,
+      rows: input.rows,
+      env: input.env,
+      name: globalThis.process.platform === "win32" ? "xterm-color" : "xterm-256color",
+    });
+    return new NodePtyProcess(ptyProcess);
+  }
+}