wind-agent-cli 1.37.2

package/server/modules/websocket/tests/chat-run-registry.test.ts

@@ -0,0 +1,282 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import { closeConnection, initializeDatabase, sessionsDb } from '@/modules/database/index.js';
+import { chatRunRegistry } from '@/modules/websocket/services/chat-run-registry.service.js';
+import { connectedClients } from '@/modules/websocket/services/websocket-state.service.js';
+
+/**
+ * Minimal stand-in for a websocket connection: collects every JSON frame the
+ * gateway writer forwards so assertions can inspect the outbound protocol.
+ */
+class FakeConnection {
+  readyState = 1; // WS_OPEN_STATE
+  frames: Array<Record<string, unknown>> = [];
+
+  send(data: string): void {
+    this.frames.push(JSON.parse(data) as Record<string, unknown>);
+  }
+}
+
+async function withIsolatedDatabase(runTest: () => void | Promise<void>): Promise<void> {
+  const previousDatabasePath = process.env.DATABASE_PATH;
+  const tempDirectory = await mkdtemp(path.join(tmpdir(), 'chat-run-registry-'));
+  const databasePath = path.join(tempDirectory, 'auth.db');
+
+  closeConnection();
+  process.env.DATABASE_PATH = databasePath;
+  await initializeDatabase();
+
+  try {
+    await runTest();
+  } finally {
+    connectedClients.clear();
+    chatRunRegistry.clearAll();
+    closeConnection();
+    if (previousDatabasePath === undefined) {
+      delete process.env.DATABASE_PATH;
+    } else {
+      process.env.DATABASE_PATH = previousDatabasePath;
+    }
+    await rm(tempDirectory, { recursive: true, force: true });
+  }
+}
+
+test('live events are remapped to the app session id and sequenced', async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-run-1', 'claude', '/workspace/demo');
+    const connection = new FakeConnection();
+    const run = chatRunRegistry.startRun({
+      appSessionId: 'app-run-1',
+      provider: 'claude',
+      providerSessionId: null,
+      connection,
+      userId: 'user-1',
+    });
+    assert.ok(run);
+
+    run.writer.send({ kind: 'stream_delta', provider: 'claude', sessionId: 'provider-id-9', content: 'hello' });
+    run.writer.send({ kind: 'text', provider: 'claude', sessionId: 'provider-id-9', content: 'hello world' });
+
+    assert.equal(connection.frames.length, 2);
+    assert.equal(connection.frames[0]?.sessionId, 'app-run-1');
+    assert.equal(connection.frames[0]?.seq, 1);
+    assert.equal(connection.frames[1]?.sessionId, 'app-run-1');
+    assert.equal(connection.frames[1]?.seq, 2);
+  });
+});
+
+test('session_created is swallowed and persisted as the provider-id mapping', async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-run-2', 'cursor', '/workspace/demo');
+    const connection = new FakeConnection();
+    connectedClients.add(connection as never);
+    const run = chatRunRegistry.startRun({
+      appSessionId: 'app-run-2',
+      provider: 'cursor',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.ok(run);
+
+    run.writer.send({
+      kind: 'session_created',
+      provider: 'cursor',
+      sessionId: 'cursor-native-7',
+      newSessionId: 'cursor-native-7',
+    });
+
+    // The provider-native event itself is never forwarded...
+    const sessionUpserts = connection.frames.filter((frame) => frame.kind === 'session_upserted');
+    assert.equal(sessionUpserts.length, 1);
+    assert.equal(sessionUpserts[0]?.sessionId, 'app-run-2');
+    assert.equal(sessionUpserts[0]?.providerSessionId, 'cursor-native-7');
+    // ...but the canonical mapping is recorded and persisted in the database.
+    assert.equal(run.providerSessionId, 'cursor-native-7');
+    assert.equal(sessionsDb.getSessionById('app-run-2')?.provider_session_id, 'cursor-native-7');
+  });
+});
+
+test('complete marks the run finished and duplicate completes are dropped', async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-run-3', 'codex', '/workspace/demo');
+    const connection = new FakeConnection();
+    const run = chatRunRegistry.startRun({
+      appSessionId: 'app-run-3',
+      provider: 'codex',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.ok(run);
+
+    run.writer.send({ kind: 'complete', provider: 'codex', sessionId: 'native-3', exitCode: 0 });
+    // Late duplicate from a killed runtime's exit handler.
+    run.writer.send({ kind: 'complete', provider: 'codex', sessionId: 'native-3', exitCode: 1 });
+
+    const completes = connection.frames.filter((frame) => frame.kind === 'complete');
+    assert.equal(completes.length, 1);
+    assert.equal(completes[0]?.actualSessionId, 'app-run-3');
+    assert.equal(chatRunRegistry.isProcessing('app-run-3'), false);
+
+    // completeRun is also a no-op once the run already completed.
+    chatRunRegistry.completeRun('app-run-3', { exitCode: 1 });
+    assert.equal(connection.frames.filter((frame) => frame.kind === 'complete').length, 1);
+  });
+});
+
+test('a finished run\'s safety net cannot complete the session\'s next run', async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-run-9', 'codex', '/workspace/demo');
+    const connection = new FakeConnection();
+
+    const firstRun = chatRunRegistry.startRun({
+      appSessionId: 'app-run-9',
+      provider: 'codex',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.ok(firstRun);
+    firstRun.writer.send({ kind: 'complete', provider: 'codex', sessionId: 'native-9', exitCode: 0 });
+
+    // A queued message starts the next run before the first run's runtime
+    // promise settles (the chat handler's `finally` hasn't executed yet).
+    const secondRun = chatRunRegistry.startRun({
+      appSessionId: 'app-run-9',
+      provider: 'codex',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.ok(secondRun);
+
+    // First run's safety net fires late: it must not touch the new run.
+    chatRunRegistry.completeRunIfCurrent(firstRun, { exitCode: 1 });
+    assert.equal(chatRunRegistry.isProcessing('app-run-9'), true);
+    assert.equal(connection.frames.filter((frame) => frame.kind === 'complete').length, 1);
+
+    // The second run's own safety net still works while it is current.
+    chatRunRegistry.completeRunIfCurrent(secondRun, { exitCode: 1 });
+    assert.equal(chatRunRegistry.isProcessing('app-run-9'), false);
+    assert.equal(connection.frames.filter((frame) => frame.kind === 'complete').length, 2);
+  });
+});
+
+test('listRunningRuns returns only currently running app sessions', async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-run-7', 'claude', '/workspace/demo');
+    sessionsDb.createAppSession('app-run-8', 'codex', '/workspace/demo');
+    const connection = new FakeConnection();
+
+    const completedRun = chatRunRegistry.startRun({
+      appSessionId: 'app-run-7',
+      provider: 'claude',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.ok(completedRun);
+
+    const runningRun = chatRunRegistry.startRun({
+      appSessionId: 'app-run-8',
+      provider: 'codex',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.ok(runningRun);
+
+    chatRunRegistry.completeRun('app-run-7', { exitCode: 0 });
+
+    const runningSessions = chatRunRegistry.listRunningRuns();
+    assert.deepEqual(runningSessions.map((session) => session.sessionId), ['app-run-8']);
+    assert.equal(runningSessions[0]?.provider, 'codex');
+  });
+});
+
+test('replayEvents returns only events after the requested seq', async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-run-4', 'claude', '/workspace/demo');
+    const connection = new FakeConnection();
+    const run = chatRunRegistry.startRun({
+      appSessionId: 'app-run-4',
+      provider: 'claude',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.ok(run);
+
+    run.writer.send({ kind: 'stream_delta', provider: 'claude', sessionId: 'x', content: 'a' });
+    run.writer.send({ kind: 'stream_delta', provider: 'claude', sessionId: 'x', content: 'b' });
+    run.writer.send({ kind: 'stream_delta', provider: 'claude', sessionId: 'x', content: 'c' });
+
+    const replayed = chatRunRegistry.replayEvents('app-run-4', 1);
+    assert.deepEqual(replayed.map((event) => event.content), ['b', 'c']);
+    assert.deepEqual(replayed.map((event) => event.seq), [2, 3]);
+  });
+});
+
+test('attachConnection reroutes the live stream to a new socket', async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-run-5', 'opencode', '/workspace/demo');
+    const firstConnection = new FakeConnection();
+    const run = chatRunRegistry.startRun({
+      appSessionId: 'app-run-5',
+      provider: 'opencode',
+      providerSessionId: null,
+      connection: firstConnection,
+      userId: null,
+    });
+    assert.ok(run);
+
+    run.writer.send({ kind: 'stream_delta', provider: 'opencode', sessionId: 'o', content: 'before' });
+
+    const secondConnection = new FakeConnection();
+    assert.equal(chatRunRegistry.attachConnection('app-run-5', secondConnection), true);
+    run.writer.send({ kind: 'stream_delta', provider: 'opencode', sessionId: 'o', content: 'after' });
+
+    assert.deepEqual(firstConnection.frames.map((frame) => frame.content), ['before']);
+    assert.deepEqual(secondConnection.frames.map((frame) => frame.content), ['after']);
+  });
+});
+
+test('startRun rejects a second concurrent run for the same session', async () => {
+  await withIsolatedDatabase(() => {
+    sessionsDb.createAppSession('app-run-6', 'opencode', '/workspace/demo');
+    const connection = new FakeConnection();
+    const first = chatRunRegistry.startRun({
+      appSessionId: 'app-run-6',
+      provider: 'opencode',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.ok(first);
+
+    const second = chatRunRegistry.startRun({
+      appSessionId: 'app-run-6',
+      provider: 'opencode',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.equal(second, null);
+
+    // After the run finishes a new one is allowed again.
+    chatRunRegistry.completeRun('app-run-6', { exitCode: 0 });
+    const third = chatRunRegistry.startRun({
+      appSessionId: 'app-run-6',
+      provider: 'opencode',
+      providerSessionId: null,
+      connection,
+      userId: null,
+    });
+    assert.ok(third);
+  });
+});

package/server/modules/websocket/tests/shell-websocket.service.test.ts

@@ -0,0 +1,432 @@
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import test from 'node:test';
+
+import type { IPtyForkOptions, IWindowsPtyForkOptions } from 'node-pty';
+import { WebSocket } from 'ws';
+
+import { handleShellConnection } from '@/modules/websocket/services/shell-websocket.service.js';
+
+function createFakeSocket() {
+  const socket = new EventEmitter() as EventEmitter & {
+    readyState: number;
+    frames: string[];
+    send: (data: string) => void;
+  };
+  socket.readyState = WebSocket.OPEN;
+  socket.frames = [];
+  socket.send = (data: string) => socket.frames.push(data);
+  return socket;
+}
+
+function createFakePty() {
+  let dataListener: ((data: string) => void) | null = null;
+  let exitListener: ((event: { exitCode: number; signal?: number }) => void) | null = null;
+
+  return {
+    killed: false,
+    writes: [] as Array<string | Buffer>,
+    resizeHistory: [] as Array<{ cols: number; rows: number }>,
+    lastResize: null as { cols: number; rows: number } | null,
+    onData(listener: (data: string) => void) {
+      dataListener = listener;
+      return { dispose: () => undefined };
+    },
+    onExit(listener: (event: { exitCode: number; signal?: number }) => void) {
+      exitListener = listener;
+      return { dispose: () => undefined };
+    },
+    emitData(data: string) {
+      dataListener?.(data);
+    },
+    emitExit() {
+      exitListener?.({ exitCode: 0 });
+    },
+    write(data: string | Buffer) {
+      this.writes.push(data);
+    },
+    resize(cols: number, rows: number) {
+      this.lastResize = { cols, rows };
+      this.resizeHistory.push({ cols, rows });
+    },
+    kill() {
+      this.killed = true;
+    },
+  };
+}
+
+test('a stale socket close cannot detach the socket that replaced it', () => {
+  const pty = createFakePty();
+  const dependencies = {
+    resolveProviderSessionId: () => null,
+    spawnPty: () => pty as never,
+  };
+  const initMessage = JSON.stringify({
+    type: 'init',
+    projectPath: process.cwd(),
+    sessionId: `stale-close-${Date.now()}`,
+    hasSession: false,
+    provider: 'plain-shell',
+    isPlainShell: true,
+    initialCommand: 'test-command',
+    cols: 110,
+    rows: 34,
+  });
+
+  const firstSocket = createFakeSocket();
+  handleShellConnection(firstSocket as never, dependencies);
+  firstSocket.emit('message', initMessage);
+
+  const replacementSocket = createFakeSocket();
+  handleShellConnection(replacementSocket as never, dependencies);
+  replacementSocket.emit('message', initMessage);
+  replacementSocket.frames.length = 0;
+
+  // This ordering reproduces a delayed close from a backgrounded mobile tab.
+  firstSocket.emit('close');
+  firstSocket.emit('message', JSON.stringify({ type: 'input', data: 'stale-input' }));
+  pty.emitData('output-after-stale-close');
+
+  assert.equal(pty.killed, false);
+  assert.deepEqual(pty.writes, []);
+  assert.deepEqual(pty.lastResize, { cols: 110, rows: 34 });
+  assert.equal(replacementSocket.frames.length, 1);
+  assert.match(replacementSocket.frames[0], /output-after-stale-close/);
+
+  pty.emitExit();
+});
+
+test('shell output detects and normalizes a wrapped authentication URL', () => {
+  const pty = createFakePty();
+  const socket = createFakeSocket();
+  const dependencies = {
+    resolveProviderSessionId: () => null,
+    spawnPty: () => pty as never,
+  };
+
+  handleShellConnection(socket as never, dependencies);
+  socket.emit(
+    'message',
+    JSON.stringify({
+      type: 'init',
+      projectPath: process.cwd(),
+      sessionId: `wrapped-url-${Date.now()}`,
+      hasSession: false,
+      provider: 'plain-shell',
+      isPlainShell: true,
+      initialCommand: 'test-command',
+    })
+  );
+  socket.frames.length = 0;
+
+  pty.emitData("Continue in your browser: https://example.com/authorize?\ncode=abc\x1b[0m");
+
+  const frames = socket.frames.map((frame) => JSON.parse(frame) as Record<string, unknown>);
+  const authenticationFrame = frames.find((frame) => frame.type === 'auth_url');
+  assert.deepEqual(authenticationFrame, {
+    type: 'auth_url',
+    url: 'https://example.com/authorize?code=abc',
+    autoOpen: false,
+  });
+
+  pty.emitExit();
+});
+
+test('Codex shell sessions use the cmd shim on Windows', () => {
+  const pty = createFakePty();
+  const socket = createFakeSocket();
+  let spawnedShell = '';
+  let spawnedArgs: string[] = [];
+  const dependencies = {
+    resolveProviderSessionId: () => 'codex-session-id',
+    platform: () => 'win32' as const,
+    spawnPty: (shell: string, args: string | string[]) => {
+      spawnedShell = shell;
+      spawnedArgs = Array.isArray(args) ? args : [args];
+      return pty as never;
+    },
+  };
+
+  handleShellConnection(socket as never, dependencies);
+  socket.emit(
+    'message',
+    JSON.stringify({
+      type: 'init',
+      projectPath: process.cwd(),
+      sessionId: `codex-shell-${Date.now()}`,
+      hasSession: true,
+      provider: 'codex',
+    })
+  );
+
+  assert.equal(spawnedShell, 'powershell.exe');
+  assert.deepEqual(spawnedArgs, [
+    '-Command',
+    'codex.cmd resume "codex-session-id"; if ($LASTEXITCODE -ne 0) { codex.cmd }',
+  ]);
+
+  pty.emitExit();
+
+  const freshPty = createFakePty();
+  const freshSocket = createFakeSocket();
+  const freshDependencies = {
+    resolveProviderSessionId: () => null,
+    platform: () => 'win32' as const,
+    spawnPty: (shell: string, args: string | string[]) => {
+      spawnedShell = shell;
+      spawnedArgs = Array.isArray(args) ? args : [args];
+      return freshPty as never;
+    },
+  };
+
+  handleShellConnection(freshSocket as never, freshDependencies);
+  freshSocket.emit(
+    'message',
+    JSON.stringify({
+      type: 'init',
+      projectPath: process.cwd(),
+      sessionId: `fresh-codex-shell-${Date.now()}`,
+      hasSession: false,
+      provider: 'codex',
+    })
+  );
+
+  assert.equal(spawnedShell, 'powershell.exe');
+  assert.deepEqual(spawnedArgs, ['-Command', 'codex.cmd']);
+
+  freshPty.emitExit();
+});
+
+test('Herdr starts directly without a PowerShell wrapper on Windows', () => {
+  const pty = createFakePty();
+  const socket = createFakeSocket();
+  let spawnedShell = '';
+  let spawnedArgs: string[] = [];
+  const dependencies = {
+    resolveProviderSessionId: () => null,
+    platform: () => 'win32' as const,
+    spawnPty: (shell: string, args: string | string[]) => {
+      spawnedShell = shell;
+      spawnedArgs = Array.isArray(args) ? args : [args];
+      return pty as never;
+    },
+  };
+
+  handleShellConnection(socket as never, dependencies);
+  socket.emit(
+    'message',
+    JSON.stringify({
+      type: 'init',
+      projectPath: process.cwd(),
+      sessionId: `herdr-direct-${Date.now()}`,
+      hasSession: false,
+      provider: 'plain-shell',
+      initialCommand: 'herdr',
+      isPlainShell: true,
+      shellMode: 'herdr',
+    })
+  );
+
+  assert.equal(spawnedShell, 'herdr.exe');
+  assert.deepEqual(spawnedArgs, []);
+
+  pty.emitExit();
+});
+
+test('Herdr shell clients do not inherit a parent pane identity', () => {
+  const pty = createFakePty();
+  const socket = createFakeSocket();
+  let spawnedEnvironment: NodeJS.ProcessEnv | undefined;
+  const dependencies = {
+    resolveProviderSessionId: () => null,
+    environment: {
+      PATH: process.env.PATH,
+      HERDR_ENV: '1',
+      HERDR_PANE_ID: 'w1:p1',
+      HERDR_TAB_ID: 'w1:t1',
+      HERDR_WORKSPACE_ID: 'w1',
+      HERDR_SOCKET_PATH: 'C:\\herdr\\herdr.sock',
+    },
+    spawnPty: (
+      _shell: string,
+      _args: string | string[],
+      options: IPtyForkOptions | IWindowsPtyForkOptions,
+    ) => {
+      spawnedEnvironment = options.env;
+      return pty as never;
+    },
+  };
+
+  handleShellConnection(socket as never, dependencies);
+  socket.emit(
+    'message',
+    JSON.stringify({
+      type: 'init',
+      projectPath: process.cwd(),
+      sessionId: `herdr-shell-${Date.now()}`,
+      hasSession: false,
+      provider: 'plain-shell',
+      initialCommand: 'herdr',
+      isPlainShell: true,
+      shellMode: 'herdr',
+    })
+  );
+
+  assert.equal(spawnedEnvironment?.HERDR_ENV, undefined);
+  assert.equal(spawnedEnvironment?.HERDR_PANE_ID, undefined);
+  assert.equal(spawnedEnvironment?.HERDR_TAB_ID, undefined);
+  assert.equal(spawnedEnvironment?.HERDR_WORKSPACE_ID, undefined);
+  assert.equal(spawnedEnvironment?.HERDR_SOCKET_PATH, 'C:\\herdr\\herdr.sock');
+
+  pty.emitExit();
+});
+
+test('Herdr reconnect redraws the live TUI without replaying stale terminal frames', async () => {
+  const pty = createFakePty();
+  const dependencies = {
+    resolveProviderSessionId: () => null,
+    spawnPty: () => pty as never,
+  };
+  const initMessage = JSON.stringify({
+    type: 'init',
+    projectPath: process.cwd(),
+    sessionId: `herdr-reconnect-${Date.now()}`,
+    hasSession: false,
+    provider: 'plain-shell',
+    initialCommand: 'herdr',
+    isPlainShell: true,
+    shellMode: 'herdr',
+    cols: 120,
+    rows: 40,
+  });
+
+  const firstSocket = createFakeSocket();
+  handleShellConnection(firstSocket as never, dependencies);
+  firstSocket.emit('message', initMessage);
+  pty.emitData('stale-full-screen-frame');
+
+  const replacementSocket = createFakeSocket();
+  handleShellConnection(replacementSocket as never, dependencies);
+  replacementSocket.emit('message', initMessage);
+  await new Promise((resolve) => setTimeout(resolve, 25));
+
+  assert.equal(
+    replacementSocket.frames.some((frame) => frame.includes('stale-full-screen-frame')),
+    false,
+  );
+  assert.deepEqual(pty.resizeHistory.slice(-2), [
+    { cols: 119, rows: 40 },
+    { cols: 120, rows: 40 },
+  ]);
+
+  pty.emitData('fresh-frame-after-redraw');
+  assert.equal(
+    replacementSocket.frames.some((frame) => frame.includes('fresh-frame-after-redraw')),
+    true,
+  );
+
+  pty.emitExit();
+});
+
+test('Herdr forwards binary xterm mouse reports to the PTY without UTF-8 conversion', () => {
+  const pty = createFakePty();
+  const socket = createFakeSocket();
+  const dependencies = {
+    resolveProviderSessionId: () => null,
+    spawnPty: () => pty as never,
+  };
+
+  handleShellConnection(socket as never, dependencies);
+  socket.emit(
+    'message',
+    JSON.stringify({
+      type: 'init',
+      projectPath: process.cwd(),
+      sessionId: `herdr-mouse-${Date.now()}`,
+      hasSession: false,
+      provider: 'plain-shell',
+      initialCommand: 'herdr',
+      isPlainShell: true,
+      shellMode: 'herdr',
+    }),
+  );
+
+  const mouseReport = Buffer.from([0x1b, 0x5b, 0x4d, 0x20, 0xff, 0x21]);
+  socket.emit(
+    'message',
+    JSON.stringify({ type: 'input_binary', data: mouseReport.toString('base64') }),
+  );
+
+  assert.equal(pty.writes.length, 1);
+  assert.ok(Buffer.isBuffer(pty.writes[0]));
+  assert.deepEqual(pty.writes[0], mouseReport);
+
+  socket.emit('message', JSON.stringify({ type: 'input_binary', data: 'not base64!' }));
+  socket.emit(
+    'message',
+    JSON.stringify({ type: 'input_binary', data: Buffer.alloc(1025).toString('base64') }),
+  );
+  assert.equal(pty.writes.length, 1);
+
+  pty.emitExit();
+});
+
+test('Herdr viewport claims restore the browser dimensions without affecting regular shells', async () => {
+  const herdrPty = createFakePty();
+  const herdrSocket = createFakeSocket();
+  handleShellConnection(herdrSocket as never, {
+    resolveProviderSessionId: () => null,
+    spawnPty: () => herdrPty as never,
+  });
+  herdrSocket.emit('message', JSON.stringify({
+    type: 'init',
+    projectPath: process.cwd(),
+    sessionId: `herdr-viewport-${Date.now()}`,
+    hasSession: false,
+    provider: 'plain-shell',
+    initialCommand: 'herdr',
+    isPlainShell: true,
+    shellMode: 'herdr',
+    cols: 120,
+    rows: 40,
+  }));
+
+  herdrSocket.emit('message', JSON.stringify({
+    type: 'viewport_claim',
+    cols: 120,
+    rows: 40,
+  }));
+  await new Promise((resolve) => setTimeout(resolve, 25));
+  assert.deepEqual(herdrPty.resizeHistory.slice(-2), [
+    { cols: 119, rows: 40 },
+    { cols: 120, rows: 40 },
+  ]);
+
+  const regularPty = createFakePty();
+  const regularSocket = createFakeSocket();
+  handleShellConnection(regularSocket as never, {
+    resolveProviderSessionId: () => null,
+    spawnPty: () => regularPty as never,
+  });
+  regularSocket.emit('message', JSON.stringify({
+    type: 'init',
+    projectPath: process.cwd(),
+    sessionId: `regular-viewport-${Date.now()}`,
+    hasSession: false,
+    provider: 'plain-shell',
+    initialCommand: 'powershell',
+    isPlainShell: true,
+    cols: 100,
+    rows: 30,
+  }));
+  regularSocket.emit('message', JSON.stringify({
+    type: 'viewport_claim',
+    cols: 100,
+    rows: 30,
+  }));
+  await new Promise((resolve) => setTimeout(resolve, 25));
+  assert.deepEqual(regularPty.resizeHistory, []);
+
+  herdrPty.emitExit();
+  regularPty.emitExit();
+});