@brimveyn/aimux 1.2.5 → 1.3.1

package/src/config.ts

@@ -1,13 +1,13 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
 
 import type { WorkspaceSnapshotV1 } from './state/types'
 
 import { logDebug } from './debug/input-log'
+import { getProfileConfigDir } from './profile-paths'
 import { isWorkspaceSnapshotV1 } from './state/validation'
 import { THEME_IDS, type ThemeId } from './ui/themes'
 
-export const CONFIG_PATH = join(process.env.HOME ?? '~', '.config', 'aimux.json')
+export const CONFIG_PATH = `${getProfileConfigDir()}/aimux.json`
 
 export interface AimuxConfig {
   version: 2
@@ -16,6 +16,7 @@ export interface AimuxConfig {
   gitPanelVisible?: boolean
   gitPanelRatio?: number
   workspaceSnapshot?: WorkspaceSnapshotV1
+  skippedUpdateVersion?: string
 }
 
 const DEFAULT_CONFIG: AimuxConfig = {
@@ -58,6 +59,7 @@ export function loadConfigResult(): ConfigLoadResult {
       gitPanelVisible?: unknown
       gitPanelRatio?: unknown
       workspaceSnapshot?: unknown
+      skippedUpdateVersion?: unknown
     }
 
     const issues: string[] = []
@@ -98,6 +100,14 @@ export function loadConfigResult(): ConfigLoadResult {
       issues.push('ignored invalid workspaceSnapshot')
     }
 
+    const validSkippedUpdateVersion =
+      typeof parsed.skippedUpdateVersion === 'string' && parsed.skippedUpdateVersion.length > 0
+        ? parsed.skippedUpdateVersion
+        : undefined
+    if (parsed.skippedUpdateVersion !== undefined && validSkippedUpdateVersion === undefined) {
+      issues.push('ignored invalid skippedUpdateVersion')
+    }
+
     if (issues.length > 0) {
       logDebug('config.load.validationIssue', { issues, path: CONFIG_PATH })
     }
@@ -107,6 +117,7 @@ export function loadConfigResult(): ConfigLoadResult {
         customCommands: isCustomCommandsRecord(parsed.customCommands) ? parsed.customCommands : {},
         gitPanelRatio: validGitPanelRatio,
         gitPanelVisible: validGitPanelVisible,
+        skippedUpdateVersion: validSkippedUpdateVersion,
         themeId: isThemeId(parsed.themeId) ? parsed.themeId : undefined,
         version: 2,
         workspaceSnapshot: isWorkspaceSnapshotV1(parsed.workspaceSnapshot)
@@ -133,7 +144,7 @@ export function loadConfig(): AimuxConfig {
 
 export function saveConfig(config: AimuxConfig): boolean {
   try {
-    mkdirSync(dirname(CONFIG_PATH), { recursive: true })
+    mkdirSync(getProfileConfigDir(), { recursive: true })
     writeFileSync(CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`)
     return true
   } catch (error) {

package/src/daemon/daemon.ts

@@ -1,22 +1,28 @@
-import { createServer, type Socket } from 'node:net'
+import { connect, createServer, type Socket } from 'node:net'
 
 import { logDebug } from '../debug/input-log'
 import {
   type ClientRequest,
   encodeMessage,
+  getProcessVersion,
+  IPC_PROTOCOL_MIN_VERSION,
   IPC_PROTOCOL_VERSION,
   MessageDecoder,
+  negotiateProtocolVersion,
   parseClientRequest,
   type ServerEvent,
   type ServerResponse,
 } from '../ipc/protocol'
-import { findDaemonPid } from '../platform/daemon-control'
+import { findSocketProcessPid, spawnDetachedTerminalManager } from '../platform/daemon-control'
+import { TerminalManagerClient } from '../terminal-manager/manager-client'
 import {
-  getDaemonSocketPath,
+  getIpcDaemonSocketPath,
+  getSocketSecurityIssue,
+  getTerminalManagerSocketPath,
   removeDaemonSocketIfExists,
-  tightenDaemonSocketPermissions,
+  removeTerminalManagerSocketIfExists,
+  tightenSocketPermissions,
 } from './runtime-paths'
-import { SessionManager } from './session-manager'
 
 function send(socket: Socket, message: ServerResponse | ServerEvent): void {
   socket.write(encodeMessage(message))
@@ -34,25 +40,88 @@ function requireSession(socket: Socket, attachedSessions: Map<Socket, string>):
   return sessionId
 }
 
+function requireNegotiatedVersion(socket: Socket, versions: Map<Socket, number>): number {
+  const version = versions.get(socket)
+  if (version === undefined) {
+    throw new Error('Protocol handshake required before attach')
+  }
+  return version
+}
+
+async function canConnectToSocket(socketPath: string): Promise<boolean> {
+  const securityIssue = getSocketSecurityIssue(socketPath)
+  if (securityIssue) {
+    logDebug('daemon.socketUnhealthy', { issue: securityIssue, socketPath })
+    return false
+  }
+
+  return new Promise<boolean>((resolve) => {
+    const socket = connect(socketPath)
+    const finish = (result: boolean) => {
+      socket.removeAllListeners()
+      socket.destroy()
+      resolve(result)
+    }
+
+    socket.once('connect', () => finish(true))
+    socket.once('error', () => finish(false))
+  })
+}
+
+async function ensureTerminalManagerReady(manager: TerminalManagerClient): Promise<void> {
+  try {
+    logDebug('daemon.ensureTerminalManager.connectExisting.start', {
+      socketPath: getTerminalManagerSocketPath(),
+    })
+    await manager.connect()
+    logDebug('daemon.ensureTerminalManager.connectExisting.success')
+    return
+  } catch (error) {
+    logDebug('daemon.ensureTerminalManager.connectExisting.failed', {
+      error: error instanceof Error ? error.message : String(error),
+    })
+    const socketPath = getTerminalManagerSocketPath()
+    if (!(await canConnectToSocket(socketPath))) {
+      removeTerminalManagerSocketIfExists()
+      logDebug('daemon.ensureTerminalManager.spawn.start', { socketPath })
+      const ok = await spawnDetachedTerminalManager()
+      if (!ok) {
+        throw new Error('Failed to start terminal manager')
+      }
+      logDebug('daemon.ensureTerminalManager.spawn.success', { socketPath })
+    }
+    await manager.connect()
+    logDebug('daemon.ensureTerminalManager.connectAfterSpawn.success')
+  }
+}
+
 export async function runDaemon(): Promise<void> {
-  const socketPath = getDaemonSocketPath()
+  const socketPath = getIpcDaemonSocketPath()
   logDebug('daemon.start', { pid: process.pid, socketPath })
 
-  const existingPid = await findDaemonPid(socketPath)
+  const existingPid = await findSocketProcessPid(socketPath)
   if (existingPid !== null && existingPid !== process.pid) {
     logDebug('daemon.alreadyRunning', { existingPid })
     process.stderr.write(`aimux daemon already running (pid ${existingPid})\n`)
     process.exit(1)
   }
 
-  logDebug('daemon.removeStaleSocket', { socketPath })
   removeDaemonSocketIfExists()
 
-  const sessionManager = new SessionManager()
+  const manager = new TerminalManagerClient()
+  await ensureTerminalManagerReady(manager)
+
   const sockets = new Set<Socket>()
   const attachedSessions = new Map<Socket, string>()
+  const negotiatedVersions = new Map<Socket, number>()
 
-  sessionManager.on('render', (sessionId, tabId, viewport, terminalModes) => {
+  manager.on('render', (sessionId, tabId, viewport, terminalModes) => {
+    logDebug('daemon.manager.render', {
+      attachedSocketCount: sockets.size,
+      sessionId,
+      tabId,
+      viewportLines: viewport.lines.length,
+    })
     const event: ServerEvent = { payload: { tabId, terminalModes, viewport }, type: 'tabRender' }
     for (const socket of sockets) {
       if (attachedSessions.get(socket) === sessionId) {
@@ -60,7 +129,8 @@ export async function runDaemon(): Promise<void> {
       }
     }
   })
-  sessionManager.on('exit', (sessionId, tabId, exitCode) => {
+  manager.on('exit', (sessionId, tabId, exitCode) => {
+    logDebug('daemon.manager.exit', { exitCode, sessionId, tabId })
     const event: ServerEvent = { payload: { exitCode, tabId }, type: 'tabExit' }
     for (const socket of sockets) {
       if (attachedSessions.get(socket) === sessionId) {
@@ -68,7 +138,8 @@ export async function runDaemon(): Promise<void> {
       }
     }
   })
-  sessionManager.on('error', (sessionId, tabId, message) => {
+  manager.on('error', (sessionId, tabId, message) => {
+    logDebug('daemon.manager.error', { message, sessionId, tabId })
     const event: ServerEvent = { payload: { message, tabId }, type: 'tabError' }
     for (const socket of sockets) {
       if (attachedSessions.get(socket) === sessionId) {
@@ -83,117 +154,212 @@ export async function runDaemon(): Promise<void> {
     const decoder = new MessageDecoder<ClientRequest>(parseClientRequest)
 
     socket.on('data', (chunk) => {
-      try {
-        for (const message of decoder.push(chunk)) {
-          try {
-            logDebug('daemon.request', { id: message.id, type: message.type })
-            switch (message.type) {
-              case 'attach': {
-                attachedSessions.set(socket, message.payload.sessionId)
-                sessionManager.resize(
-                  message.payload.sessionId,
-                  message.payload.cols,
-                  message.payload.rows
-                )
-                const attachResult = sessionManager.attachSession(
-                  message.payload.sessionId,
-                  message.payload.workspaceSnapshot
-                )
-                send(socket, {
-                  id: message.id,
-                  payload: { protocolVersion: IPC_PROTOCOL_VERSION, ...attachResult },
-                  type: 'attachResult',
-                })
-                break
-              }
-              case 'createTab': {
-                const sessionId = requireSession(socket, attachedSessions)
-                sessionManager.createTab(sessionId, message.payload)
-                sendOk(socket, message.id)
-                break
-              }
-              case 'write': {
-                const sessionId = requireSession(socket, attachedSessions)
-                sessionManager.write(sessionId, message.payload.tabId, message.payload.data)
-                sendOk(socket, message.id)
-                break
-              }
-              case 'resizeClient': {
-                const sessionId = requireSession(socket, attachedSessions)
-                sessionManager.resize(sessionId, message.payload.cols, message.payload.rows)
-                sendOk(socket, message.id)
-                break
-              }
-              case 'resizeTab': {
-                const sessionId = requireSession(socket, attachedSessions)
-                sessionManager.resizeTab(
-                  sessionId,
-                  message.payload.tabId,
-                  message.payload.cols,
-                  message.payload.rows
-                )
-                sendOk(socket, message.id)
-                break
-              }
-              case 'scroll': {
-                const sessionId = requireSession(socket, attachedSessions)
-                sessionManager.scroll(sessionId, message.payload.tabId, message.payload.deltaLines)
-                sendOk(socket, message.id)
-                break
-              }
-              case 'scrollToBottom': {
-                const sessionId = requireSession(socket, attachedSessions)
-                sessionManager.scrollToBottom(sessionId, message.payload.tabId)
-                sendOk(socket, message.id)
-                break
-              }
-              case 'setActiveTab': {
-                const sessionId = requireSession(socket, attachedSessions)
-                sessionManager.setActiveTab(sessionId, message.payload.tabId)
-                sendOk(socket, message.id)
-                break
-              }
-              case 'closeTab': {
-                const sessionId = requireSession(socket, attachedSessions)
-                sessionManager.closeTab(sessionId, message.payload.tabId)
-                sendOk(socket, message.id)
-                break
-              }
-              case 'disposeAll': {
-                const sessionId = attachedSessions.get(socket)
-                if (sessionId) {
-                  sessionManager.disposeSession(sessionId)
+      void (async () => {
+        try {
+          for (const message of decoder.push(chunk)) {
+            try {
+              switch (message.type) {
+                case 'hello': {
+                  logDebug('daemon.request.hello', {
+                    maxVersion: message.payload.maxVersion,
+                    minVersion: message.payload.minVersion,
+                  })
+                  const selectedVersion = negotiateProtocolVersion(
+                    message.payload.minVersion,
+                    message.payload.maxVersion,
+                    IPC_PROTOCOL_MIN_VERSION,
+                    IPC_PROTOCOL_VERSION
+                  )
+                  if (selectedVersion === null) {
+                    send(socket, {
+                      id: message.id,
+                      payload: { message: 'No compatible app protocol version' },
+                      type: 'error',
+                    })
+                    break
+                  }
+                  negotiatedVersions.set(socket, selectedVersion)
+                  logDebug('daemon.request.hello.success', { selectedVersion })
+                  send(socket, {
+                    id: message.id,
+                    payload: {
+                      maxVersion: IPC_PROTOCOL_VERSION,
+                      minVersion: IPC_PROTOCOL_MIN_VERSION,
+                      processVersion: getProcessVersion(),
+                      selectedVersion,
+                    },
+                    type: 'helloResult',
+                  })
+                  break
+                }
+                case 'attach': {
+                  logDebug('daemon.request.attach.start', {
+                    cols: message.payload.cols,
+                    rows: message.payload.rows,
+                    sessionId: message.payload.sessionId,
+                    snapshotTabs: message.payload.workspaceSnapshot?.tabs.length ?? 0,
+                  })
+                  const negotiatedVersion = requireNegotiatedVersion(socket, negotiatedVersions)
+                  if (message.payload.protocolVersion !== negotiatedVersion) {
+                    throw new Error(
+                      `Protocol mismatch: client v${message.payload.protocolVersion}, daemon v${negotiatedVersion}`
+                    )
+                  }
+
+                  attachedSessions.set(socket, message.payload.sessionId)
+                  const attachResult = await manager.attachSession({
+                    cols: message.payload.cols,
+                    rows: message.payload.rows,
+                    sessionId: message.payload.sessionId,
+                    workspaceSnapshot: message.payload.workspaceSnapshot,
+                  })
+                  send(socket, {
+                    id: message.id,
+                    payload: {
+                      activeTabId: attachResult.activeTabId,
+                      protocolVersion: negotiatedVersion,
+                      tabs: attachResult.tabs,
+                    },
+                    type: 'attachResult',
+                  })
+                  logDebug('daemon.request.attach.success', {
+                    activeTabId: attachResult.activeTabId,
+                    sessionId: message.payload.sessionId,
+                    tabs: attachResult.tabs.length,
+                  })
+                  break
+                }
+                case 'createTab': {
+                  const sessionId = requireSession(socket, attachedSessions)
+                  requireNegotiatedVersion(socket, negotiatedVersions)
+                  logDebug('daemon.request.createTab.start', {
+                    command: message.payload.command,
+                    sessionId,
+                    tabId: message.payload.tabId,
+                    title: message.payload.title,
+                  })
+                  await manager.createTab({ ...message.payload, sessionId })
+                  sendOk(socket, message.id)
+                  logDebug('daemon.request.createTab.success', {
+                    sessionId,
+                    tabId: message.payload.tabId,
+                  })
+                  break
+                }
+                case 'write': {
+                  const sessionId = requireSession(socket, attachedSessions)
+                  requireNegotiatedVersion(socket, negotiatedVersions)
+                  await manager.write(sessionId, message.payload.tabId, message.payload.data)
+                  sendOk(socket, message.id)
+                  break
+                }
+                case 'resizeClient': {
+                  const sessionId = requireSession(socket, attachedSessions)
+                  requireNegotiatedVersion(socket, negotiatedVersions)
+                  await manager.resize(
+                    sessionId,
+                    message.payload.cols,
+                    message.payload.rows,
+                    message.payload.intents
+                  )
+                  sendOk(socket, message.id)
+                  break
+                }
+                case 'resizeTab': {
+                  const sessionId = requireSession(socket, attachedSessions)
+                  requireNegotiatedVersion(socket, negotiatedVersions)
+                  await manager.resizeTab(
+                    sessionId,
+                    message.payload.tabId,
+                    message.payload.cols,
+                    message.payload.rows,
+                    message.payload.intent
+                  )
+                  sendOk(socket, message.id)
+                  break
                 }
-                sendOk(socket, message.id)
-                break
+                case 'scroll': {
+                  const sessionId = requireSession(socket, attachedSessions)
+                  requireNegotiatedVersion(socket, negotiatedVersions)
+                  await manager.scroll(sessionId, message.payload.tabId, message.payload.deltaLines)
+                  sendOk(socket, message.id)
+                  break
+                }
+                case 'scrollToBottom': {
+                  const sessionId = requireSession(socket, attachedSessions)
+                  requireNegotiatedVersion(socket, negotiatedVersions)
+                  await manager.scrollToBottom(sessionId, message.payload.tabId)
+                  sendOk(socket, message.id)
+                  break
+                }
+                case 'reapplyScrollIntent': {
+                  const sessionId = requireSession(socket, attachedSessions)
+                  requireNegotiatedVersion(socket, negotiatedVersions)
+                  await manager.reapplyScrollIntent(
+                    sessionId,
+                    message.payload.tabId,
+                    message.payload.intent
+                  )
+                  sendOk(socket, message.id)
+                  break
+                }
+                case 'setActiveTab': {
+                  const sessionId = requireSession(socket, attachedSessions)
+                  requireNegotiatedVersion(socket, negotiatedVersions)
+                  await manager.setActiveTab(sessionId, message.payload.tabId)
+                  sendOk(socket, message.id)
+                  break
+                }
+                case 'closeTab': {
+                  const sessionId = requireSession(socket, attachedSessions)
+                  requireNegotiatedVersion(socket, negotiatedVersions)
+                  await manager.closeTab(sessionId, message.payload.tabId)
+                  sendOk(socket, message.id)
+                  break
+                }
+                case 'disposeAll': {
+                  const sessionId = attachedSessions.get(socket)
+                  requireNegotiatedVersion(socket, negotiatedVersions)
+                  if (sessionId) {
+                    await manager.disposeSession(sessionId)
+                  }
+                  sendOk(socket, message.id)
+                  break
+                }
+                case 'ping':
+                  sendOk(socket, message.id)
+                  break
               }
-              case 'ping':
-                sendOk(socket, message.id)
-                break
+            } catch (error) {
+              const errorMessage = error instanceof Error ? error.message : String(error)
+              logDebug('daemon.request.error', {
+                error: errorMessage,
+                requestId: message.id,
+                type: message.type,
+              })
+              send(socket, { id: message.id, payload: { message: errorMessage }, type: 'error' })
             }
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error)
-            logDebug('daemon.request.error', { error: errorMessage, requestId: message.id })
-            send(socket, { id: message.id, payload: { message: errorMessage }, type: 'error' })
           }
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error)
+          logDebug('daemon.decoder.error', { error: message })
+          decoder.reset()
+          send(socket, { id: crypto.randomUUID(), payload: { message }, type: 'error' })
         }
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error)
-        logDebug('daemon.request.error', { error: message })
-        decoder.reset()
-        send(socket, { id: crypto.randomUUID(), payload: { message }, type: 'error' })
-      }
+      })()
     })
 
     socket.on('close', () => {
-      logDebug('daemon.client.close')
+      logDebug('daemon.client.close', { sessionId: attachedSessions.get(socket) ?? null })
       sockets.delete(socket)
       attachedSessions.delete(socket)
+      negotiatedVersions.delete(socket)
     })
     socket.on('error', () => {
-      logDebug('daemon.client.error')
+      logDebug('daemon.client.error', { sessionId: attachedSessions.get(socket) ?? null })
       sockets.delete(socket)
       attachedSessions.delete(socket)
+      negotiatedVersions.delete(socket)
     })
   })
 
@@ -201,12 +367,11 @@ export async function runDaemon(): Promise<void> {
     server.once('error', reject)
     server.listen(socketPath, () => resolve())
   })
-  tightenDaemonSocketPermissions(socketPath)
-  logDebug('daemon.listening', { socketPath })
+  tightenSocketPermissions(socketPath)
 
   const gracefulShutdown = (signal: string) => {
     logDebug(`daemon.${signal}`)
-    sessionManager.disposeAll()
+    manager.destroy()
     server.close()
     process.exit(0)
   }
@@ -216,18 +381,14 @@ export async function runDaemon(): Promise<void> {
 
   process.on('uncaughtException', (error) => {
     logDebug('daemon.uncaughtException', { error: error.message, stack: error.stack })
-    sessionManager.disposeAll()
-    server.close()
-    process.exit(1)
+    gracefulShutdown('uncaughtException')
   })
 
   process.on('unhandledRejection', (reason) => {
     const message = reason instanceof Error ? reason.message : String(reason)
     const stack = reason instanceof Error ? reason.stack : undefined
     logDebug('daemon.unhandledRejection', { error: message, stack })
-    sessionManager.disposeAll()
-    server.close()
-    process.exit(1)
+    gracefulShutdown('unhandledRejection')
   })
 
   await new Promise<void>(() => {

package/src/daemon/runtime-paths.ts

@@ -1,12 +1,18 @@
 import { chmodSync, constants, existsSync, lstatSync, mkdirSync, unlinkSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 
+import { getProfileName } from '../profile-paths'
+
+export function getRuntimeProfile(): string {
+  return getProfileName()
+}
+
 function getRuntimeBaseDir(): string {
   if (process.env.XDG_RUNTIME_DIR) {
-    return join(process.env.XDG_RUNTIME_DIR, 'aimux')
+    return join(process.env.XDG_RUNTIME_DIR, `aimux-${getRuntimeProfile()}`)
   }
 
-  return join(process.env.HOME ?? '.', '.local', 'state', 'aimux')
+  return join(process.env.HOME ?? '.', '.local', 'state', `aimux-${getRuntimeProfile()}`)
 }
 
 export function ensureRuntimeDir(): string {
@@ -24,6 +30,14 @@ export function getDaemonSocketPath(): string {
   return join(ensureRuntimeDir(), 'daemon.sock')
 }
 
+export function getIpcDaemonSocketPath(): string {
+  return getDaemonSocketPath()
+}
+
+export function getTerminalManagerSocketPath(): string {
+  return join(ensureRuntimeDir(), 'terminal-manager.sock')
+}
+
 export function ensureParentDir(filePath: string): void {
   mkdirSync(dirname(filePath), { recursive: true })
 }
@@ -36,6 +50,10 @@ export function tightenDaemonSocketPermissions(socketPath: string): void {
   }
 }
 
+export function tightenSocketPermissions(socketPath: string): void {
+  tightenDaemonSocketPermissions(socketPath)
+}
+
 export function getDaemonSocketSecurityIssue(socketPath: string): string | null {
   if (!existsSync(socketPath)) {
     return 'socket missing'
@@ -61,9 +79,23 @@ export function getDaemonSocketSecurityIssue(socketPath: string): string | null
   }
 }
 
+export function getSocketSecurityIssue(socketPath: string): string | null {
+  return getDaemonSocketSecurityIssue(socketPath)
+}
+
 export function removeDaemonSocketIfExists(): void {
   const socketPath = getDaemonSocketPath()
   if (existsSync(socketPath)) {
     unlinkSync(socketPath)
   }
 }
+
+export function removeSocketIfExists(socketPath: string): void {
+  if (existsSync(socketPath)) {
+    unlinkSync(socketPath)
+  }
+}
+
+export function removeTerminalManagerSocketIfExists(): void {
+  removeSocketIfExists(getTerminalManagerSocketPath())
+}

package/src/daemon/session-manager.ts

@@ -1,6 +1,11 @@
 import { EventEmitter } from 'node:events'
 
-import type { TerminalModeState, TerminalSnapshot, WorkspaceSnapshotV1 } from '../state/types'
+import type {
+  ScrollIntent,
+  TerminalModeState,
+  TerminalSnapshot,
+  WorkspaceSnapshotV1,
+} from '../state/types'
 
 import { logDebug } from '../debug/input-log'
 import { SessionRegistry } from './session-registry'
@@ -62,12 +67,18 @@ export class SessionManager extends EventEmitter<SessionManagerEvents> {
     this.getOrCreateRegistry(sessionId).write(tabId, data)
   }
 
-  resize(sessionId: string, cols: number, rows: number): void {
-    this.getOrCreateRegistry(sessionId).resizeAll(cols, rows)
+  resize(sessionId: string, cols: number, rows: number, intents?: Map<string, ScrollIntent>): void {
+    this.getOrCreateRegistry(sessionId).resizeAll(cols, rows, intents)
   }
 
-  resizeTab(sessionId: string, tabId: string, cols: number, rows: number): void {
-    this.getOrCreateRegistry(sessionId).resizeTab(tabId, cols, rows)
+  resizeTab(
+    sessionId: string,
+    tabId: string,
+    cols: number,
+    rows: number,
+    intent?: ScrollIntent
+  ): void {
+    this.getOrCreateRegistry(sessionId).resizeTab(tabId, cols, rows, intent)
   }
 
   scroll(sessionId: string, tabId: string, deltaLines: number): void {
@@ -78,6 +89,10 @@ export class SessionManager extends EventEmitter<SessionManagerEvents> {
     this.getOrCreateRegistry(sessionId).scrollViewportToBottom(tabId)
   }
 
+  reapplyScrollIntent(sessionId: string, tabId: string, intent: ScrollIntent): void {
+    this.getOrCreateRegistry(sessionId).reapplyScrollIntent(tabId, intent)
+  }
+
   setActiveTab(sessionId: string, tabId: string | null): void {
     this.getOrCreateRegistry(sessionId).setActiveTab(tabId)
   }