@brimveyn/aimux 1.2.5 → 1.3.1

package/src/pty/pty-manager.ts

@@ -2,8 +2,9 @@ import { Terminal as XTerm } from '@xterm/headless'
 import { type IPty, spawn } from 'bun-pty'
 import { EventEmitter } from 'node:events'
 
-import type { TerminalModeState, TerminalSnapshot } from '../state/types'
+import type { ScrollIntent, TerminalModeState, TerminalSnapshot } from '../state/types'
 
+import { logDebug } from '../debug/input-log'
 import { areTerminalSnapshotsEqual, snapshotTerminal } from './terminal-snapshot'
 
 type PtyManagerEvents = {
@@ -99,6 +100,12 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
 
     session.lastSnapshot = nextSnapshot
     session.lastTerminalModes = nextTerminalModes
+    logDebug('ptyManager.render', {
+      isAlternateBuffer: nextTerminalModes.isAlternateBuffer,
+      lines: nextSnapshot.lines.length,
+      tabId: session.tabId,
+      viewportY: nextSnapshot.viewportY,
+    })
     this.emit('render', session.tabId, nextSnapshot, nextTerminalModes)
   }
 
@@ -111,6 +118,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     this.sessions.delete(session.tabId)
     this.emitRenderIfChanged(session)
     session.emulator.dispose()
+    logDebug('ptyManager.finalize', { exitCode, tabId: session.tabId })
     this.emit('exit', session.tabId, exitCode)
   }
 
@@ -123,6 +131,14 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     cwd?: string
   }): void {
     this.disposeSession(options.tabId)
+    logDebug('ptyManager.create.start', {
+      args: options.args ?? [],
+      cols: options.cols,
+      command: options.command,
+      cwd: options.cwd ?? process.cwd(),
+      rows: options.rows,
+      tabId: options.tabId,
+    })
 
     try {
       const emulator = new XTerm({
@@ -157,6 +173,11 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
       }
 
       pty.onData((data) => {
+        logDebug('ptyManager.data', {
+          byteLength: Buffer.byteLength(data, 'utf8'),
+          pendingWrites: session.pendingWrites,
+          tabId: options.tabId,
+        })
         const trackedModes = trackPrivateModes(
           session.alternateScrollMode,
           session.cursorVisible,
@@ -178,6 +199,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
       })
 
       pty.onExit(({ exitCode }) => {
+        logDebug('ptyManager.exit', { exitCode, tabId: options.tabId })
         const current = this.sessions.get(options.tabId)
         if (!current || current.pty !== pty) {
           return
@@ -192,9 +214,11 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
       })
 
       this.sessions.set(options.tabId, session)
+      logDebug('ptyManager.create.success', { tabId: options.tabId })
       this.emitRenderIfChanged(session)
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error)
+      logDebug('ptyManager.create.error', { error: message, tabId: options.tabId })
       this.emit('error', options.tabId, `Failed to start session: ${message}`)
     }
   }
@@ -223,18 +247,34 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     this.emitRenderIfChanged(session)
   }
 
-  resizeAll(cols: number, rows: number): void {
+  private applyScrollIntent(session: SessionHandle, intent: ScrollIntent | undefined): void {
+    if (!intent || intent.kind === 'bottom') {
+      session.emulator.scrollToBottom()
+      return
+    }
+
+    const baseY = session.emulator.buffer.active.baseY
+    if (intent.absoluteLine >= baseY) {
+      session.emulator.scrollToBottom()
+      return
+    }
+
+    session.emulator.scrollToLine(Math.max(0, intent.absoluteLine))
+  }
+
+  resizeAll(cols: number, rows: number, intents?: Map<string, ScrollIntent>): void {
     const safeCols = Math.max(20, cols)
     const safeRows = Math.max(8, rows)
 
     for (const session of this.sessions.values()) {
       session.pty.resize(safeCols, safeRows)
       session.emulator.resize(safeCols, safeRows)
+      this.applyScrollIntent(session, intents?.get(session.tabId))
       this.emitRenderIfChanged(session)
     }
   }
 
-  resizeSession(tabId: string, cols: number, rows: number): void {
+  resizeSession(tabId: string, cols: number, rows: number, intent?: ScrollIntent): void {
     const session = this.sessions.get(tabId)
     if (!session) {
       return
@@ -243,6 +283,16 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     const safeRows = Math.max(8, rows)
     session.pty.resize(safeCols, safeRows)
     session.emulator.resize(safeCols, safeRows)
+    this.applyScrollIntent(session, intent)
+    this.emitRenderIfChanged(session)
+  }
+
+  reapplyScrollIntent(tabId: string, intent: ScrollIntent): void {
+    const session = this.sessions.get(tabId)
+    if (!session) {
+      return
+    }
+    this.applyScrollIntent(session, intent)
     this.emitRenderIfChanged(session)
   }
 

package/src/restart-daemon.ts

@@ -1,28 +1,28 @@
 import { getDaemonSocketPath, removeDaemonSocketIfExists } from './daemon/runtime-paths'
-import { findDaemonPid, killDaemon, spawnDetachedDaemon } from './platform/daemon-control'
+import { findIpcDaemonPid, killProcess, spawnDetachedIpcDaemon } from './platform/daemon-control'
 
 export async function runRestartDaemon(): Promise<number> {
   const socketPath = getDaemonSocketPath()
-  const pid = await findDaemonPid(socketPath)
+  const pid = await findIpcDaemonPid()
 
   if (pid !== null) {
-    process.stdout.write(`Stopping daemon (pid ${pid})...\n`)
-    await killDaemon(pid)
-    process.stdout.write('Daemon stopped.\n')
+    process.stdout.write(`Stopping IPC daemon (pid ${pid})...\n`)
+    await killProcess(pid)
+    process.stdout.write('IPC daemon stopped.\n')
   } else {
-    process.stdout.write('No running daemon found.\n')
+    process.stdout.write('No running IPC daemon found.\n')
   }
 
   removeDaemonSocketIfExists()
 
-  process.stdout.write('Starting daemon...\n')
-  const ok = await spawnDetachedDaemon()
+  process.stdout.write('Starting IPC daemon...\n')
+  const ok = await spawnDetachedIpcDaemon()
 
   if (ok) {
-    process.stdout.write('Daemon started.\n')
+    process.stdout.write(`IPC daemon started on ${socketPath}.\n`)
     return 0
   }
 
-  process.stderr.write('Failed to start daemon.\n')
+  process.stderr.write('Failed to start IPC daemon.\n')
   return 1
 }

package/src/session-backend/bootstrap.ts

@@ -3,32 +3,45 @@ import { connect } from 'node:net'
 import type { SessionBackend } from './types'
 
 import {
-  getDaemonSocketPath,
-  getDaemonSocketSecurityIssue,
+  getIpcDaemonSocketPath,
+  getSocketSecurityIssue,
   removeDaemonSocketIfExists,
 } from '../daemon/runtime-paths'
 import { logDebug } from '../debug/input-log'
-import { ProtocolMismatchError } from '../ipc/protocol'
-import { findDaemonPid, killDaemon, spawnDetachedDaemon } from '../platform/daemon-control'
+import {
+  encodeMessage,
+  IPC_PROTOCOL_MIN_VERSION,
+  IPC_PROTOCOL_VERSION,
+  MessageDecoder,
+  parseServerMessage,
+} from '../ipc/protocol'
+import { findIpcDaemonPid, killProcess, spawnDetachedIpcDaemon } from '../platform/daemon-control'
 import { LocalSessionBackend } from './local-session-backend'
 import { RemoteSessionBackend } from './remote-session-backend'
 
+interface DaemonHandshakeProbeResult {
+  compatible: boolean
+  error?: string
+  processVersion?: string
+  selectedVersion?: number
+}
+
 async function spawnDaemon(): Promise<void> {
   logDebug('backend.spawnDaemon.start', {
     execPath: process.execPath,
-    socketPath: getDaemonSocketPath(),
+    socketPath: getIpcDaemonSocketPath(),
   })
-  const ok = await spawnDetachedDaemon()
+  const ok = await spawnDetachedIpcDaemon()
   if (ok) {
-    logDebug('backend.spawnDaemon.ready', { socketPath: getDaemonSocketPath() })
+    logDebug('backend.spawnDaemon.ready', { socketPath: getIpcDaemonSocketPath() })
     return
   }
 
-  logDebug('backend.spawnDaemon.timeout', { socketPath: getDaemonSocketPath() })
+  throw new Error(`IPC daemon unavailable at ${getIpcDaemonSocketPath()}`)
 }
 
 async function canConnectToDaemon(socketPath: string): Promise<boolean> {
-  const securityIssue = getDaemonSocketSecurityIssue(socketPath)
+  const securityIssue = getSocketSecurityIssue(socketPath)
   if (securityIssue) {
     logDebug('backend.healthcheck.socketIssue', { issue: securityIssue, socketPath })
     return false
@@ -54,54 +67,192 @@ async function canConnectToDaemon(socketPath: string): Promise<boolean> {
   })
 }
 
+export async function probeDaemonProtocolCompatibility(
+  socketPath: string
+): Promise<DaemonHandshakeProbeResult> {
+  const securityIssue = getSocketSecurityIssue(socketPath)
+  if (securityIssue) {
+    return { compatible: false, error: securityIssue }
+  }
+
+  return await new Promise<DaemonHandshakeProbeResult>((resolve) => {
+    const socket = connect(socketPath)
+    const decoder = new MessageDecoder(parseServerMessage)
+    const helloRequestId = crypto.randomUUID()
+    const attachRequestId = crypto.randomUUID()
+    const disposeRequestId = crypto.randomUUID()
+    const probeSessionId = `probe-${crypto.randomUUID()}`
+    let daemonProcessVersion: string | undefined
+    let settled = false
+    const timer = setTimeout(() => {
+      finish({ compatible: false, error: 'handshake timed out' })
+    }, 2_000)
+
+    const finish = (result: DaemonHandshakeProbeResult) => {
+      if (settled) {
+        return
+      }
+      settled = true
+      clearTimeout(timer)
+      socket.removeAllListeners()
+      socket.destroy()
+      resolve(result)
+    }
+
+    socket.once('connect', () => {
+      socket.write(
+        encodeMessage({
+          id: helloRequestId,
+          payload: {
+            maxVersion: IPC_PROTOCOL_VERSION,
+            minVersion: IPC_PROTOCOL_MIN_VERSION,
+          },
+          type: 'hello',
+        })
+      )
+    })
+    socket.once('error', (error: NodeJS.ErrnoException) => {
+      finish({ compatible: false, error: error.message })
+    })
+    socket.on('data', (chunk) => {
+      try {
+        for (const message of decoder.push(chunk)) {
+          if (!('id' in message)) {
+            continue
+          }
+
+          if (message.id === helloRequestId) {
+            if (message.type !== 'helloResult') {
+              finish({
+                compatible: false,
+                error:
+                  message.type === 'error' ? message.payload.message : `unexpected ${message.type}`,
+              })
+              return
+            }
+
+            daemonProcessVersion = message.payload.processVersion
+
+            socket.write(
+              encodeMessage({
+                id: attachRequestId,
+                payload: {
+                  cols: 80,
+                  protocolVersion: message.payload.selectedVersion,
+                  rows: 24,
+                  sessionId: probeSessionId,
+                },
+                type: 'attach',
+              })
+            )
+            return
+          }
+
+          if (message.id === attachRequestId) {
+            if (message.type !== 'attachResult') {
+              finish({
+                compatible: false,
+                error:
+                  message.type === 'error' ? message.payload.message : `unexpected ${message.type}`,
+              })
+              return
+            }
+
+            const compatible =
+              message.payload.protocolVersion >= IPC_PROTOCOL_MIN_VERSION &&
+              message.payload.protocolVersion <= IPC_PROTOCOL_VERSION
+
+            socket.write(
+              encodeMessage({
+                id: disposeRequestId,
+                payload: {},
+                type: 'disposeAll',
+              })
+            )
+            finish({
+              compatible,
+              error: compatible
+                ? undefined
+                : `attach returned protocol v${message.payload.protocolVersion}`,
+              processVersion: daemonProcessVersion,
+              selectedVersion: message.payload.protocolVersion,
+            })
+            return
+          }
+
+          if (message.id === disposeRequestId) {
+            continue
+          }
+        }
+      } catch (error) {
+        finish({
+          compatible: false,
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+    })
+  })
+}
+
 async function restartDaemon(socketPath: string): Promise<void> {
-  const pid = await findDaemonPid(socketPath)
+  const pid = await findIpcDaemonPid()
   if (pid !== null) {
-    logDebug('backend.restartDaemon.killing', { pid })
-    await killDaemon(pid)
+    logDebug('backend.restartDaemon.killing', { pid, socketPath })
+    await killProcess(pid)
   }
   removeDaemonSocketIfExists()
   await spawnDaemon()
 }
 
 export async function createSessionBackend(): Promise<SessionBackend> {
-  try {
-    const socketPath = getDaemonSocketPath()
-    const initialReachable = await canConnectToDaemon(socketPath)
-    logDebug('backend.create.start', { initialReachable, socketPath })
-
-    if (!initialReachable) {
-      removeDaemonSocketIfExists()
-      await spawnDaemon()
-    }
+  if (process.env.AIMUX_LOCAL_BACKEND === '1') {
+    logDebug('backend.create.localExplicit')
+    return new LocalSessionBackend()
+  }
 
-    const reachable = await canConnectToDaemon(socketPath)
-    if (!reachable) {
-      throw new Error(`Daemon unavailable at ${socketPath}`)
-    }
+  const socketPath = getIpcDaemonSocketPath()
+  const initialReachable = await canConnectToDaemon(socketPath)
+  logDebug('backend.create.start', { initialReachable, socketPath })
 
-    logDebug('backend.create.remote', { socketPath })
-    return new RemoteSessionBackend()
-  } catch (error) {
-    if (error instanceof ProtocolMismatchError) {
-      logDebug('backend.create.protocolMismatch', {
-        clientVersion: error.clientVersion,
-        daemonVersion: error.daemonVersion,
-      })
-      try {
-        await restartDaemon(getDaemonSocketPath())
-        logDebug('backend.create.remoteAfterRestart')
-        return new RemoteSessionBackend()
-      } catch (retryError) {
-        logDebug('backend.create.retryFailed', {
-          error: retryError instanceof Error ? retryError.message : String(retryError),
-        })
-      }
-    }
+  if (!initialReachable) {
+    removeDaemonSocketIfExists()
+    await spawnDaemon()
+  }
+
+  const reachable = await canConnectToDaemon(socketPath)
+  if (!reachable) {
+    throw new Error(`IPC daemon unavailable at ${socketPath}`)
+  }
 
-    logDebug('backend.create.localFallback', {
-      error: error instanceof Error ? error.message : String(error),
+  const handshake = await probeDaemonProtocolCompatibility(socketPath)
+  logDebug('backend.create.handshake', {
+    compatible: handshake.compatible,
+    error: handshake.error ?? null,
+    processVersion: handshake.processVersion ?? null,
+    selectedVersion: handshake.selectedVersion ?? null,
+    socketPath,
+  })
+  if (!handshake.compatible) {
+    logDebug('backend.create.restartForHandshake', {
+      error: handshake.error ?? 'incompatible daemon handshake',
+      socketPath,
     })
-    return new LocalSessionBackend()
+    await restartDaemon(socketPath)
+    const retriedHandshake = await probeDaemonProtocolCompatibility(socketPath)
+    logDebug('backend.create.handshakeAfterRestart', {
+      compatible: retriedHandshake.compatible,
+      error: retriedHandshake.error ?? null,
+      processVersion: retriedHandshake.processVersion ?? null,
+      selectedVersion: retriedHandshake.selectedVersion ?? null,
+      socketPath,
+    })
+    if (!retriedHandshake.compatible) {
+      throw new Error(
+        `IPC daemon handshake failed after restart: ${retriedHandshake.error ?? 'incompatible protocol'}`
+      )
+    }
   }
+
+  logDebug('backend.create.remote', { socketPath })
+  return new RemoteSessionBackend()
 }

package/src/session-backend/local-session-backend.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'node:events'
 
-import type { AssistantId, WorkspaceSnapshotV1 } from '../state/types'
+import type { AssistantId, ScrollIntent, WorkspaceSnapshotV1 } from '../state/types'
 import type { SessionBackend, SessionBackendEvents } from './types'
 
 import { SessionManager } from '../daemon/session-manager'
@@ -114,6 +114,13 @@ export class LocalSessionBackend
     this.sessionManager.scrollToBottom(this.currentSessionId, tabId)
   }
 
+  reapplyScrollIntent(tabId: string, intent: ScrollIntent): void {
+    if (!this.currentSessionId) {
+      return
+    }
+    this.sessionManager.reapplyScrollIntent(this.currentSessionId, tabId, intent)
+  }
+
   setActiveTab(tabId: string | null): void {
     if (!this.currentSessionId) {
       return
@@ -122,18 +129,18 @@ export class LocalSessionBackend
     this.sessionManager.setActiveTab(this.currentSessionId, tabId)
   }
 
-  resizeAll(cols: number, rows: number): void {
+  resizeAll(cols: number, rows: number, intents?: Map<string, ScrollIntent>): void {
     if (!this.currentSessionId) {
       return
     }
-    this.sessionManager.resize(this.currentSessionId, cols, rows)
+    this.sessionManager.resize(this.currentSessionId, cols, rows, intents)
   }
 
-  resizeTab(tabId: string, cols: number, rows: number): void {
+  resizeTab(tabId: string, cols: number, rows: number, intent?: ScrollIntent): void {
     if (!this.currentSessionId) {
       return
     }
-    this.sessionManager.resizeTab(this.currentSessionId, tabId, cols, rows)
+    this.sessionManager.resizeTab(this.currentSessionId, tabId, cols, rows, intent)
   }
 
   disposeSession(tabId: string): void {