@brimveyn/aimux 1.2.0 → 1.3.0

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/remote-session-backend.ts

@@ -4,12 +4,13 @@ import { connect, Socket } from 'node:net'
 import type { AssistantId, WorkspaceSnapshotV1 } from '../state/types'
 import type { SessionBackend, SessionBackendEvents } from './types'
 
-import { getDaemonSocketPath } from '../daemon/runtime-paths'
+import { getIpcDaemonSocketPath } from '../daemon/runtime-paths'
 import { logDebug } from '../debug/input-log'
 import {
   type AttachResult,
   type ClientRequest,
   encodeMessage,
+  IPC_PROTOCOL_MIN_VERSION,
   IPC_PROTOCOL_VERSION,
   MessageDecoder,
   parseServerMessage,
@@ -19,6 +20,7 @@ import {
 } from '../ipc/protocol'
 
 const IPC_REQUEST_TIMEOUT_MS = 10_000
+const RECONNECT_DELAY_MS = 250
 
 export class RemoteSessionBackend
   extends EventEmitter<SessionBackendEvents>
@@ -36,6 +38,15 @@ export class RemoteSessionBackend
   private decoder = new MessageDecoder<ServerResponse | ServerEvent>(parseServerMessage)
   private attached = false
   private currentSessionId: string | null = null
+  private attachOptions: {
+    sessionId: string
+    cols: number
+    rows: number
+    workspaceSnapshot?: WorkspaceSnapshotV1
+  } | null = null
+  private selectedProtocolVersion: number | null = null
+  private reconnectPromise: Promise<void> | null = null
+  private shouldReconnect = false
 
   private rejectPendingRequests(error: Error): void {
     for (const [id, pending] of this.pending.entries()) {
@@ -45,14 +56,19 @@ export class RemoteSessionBackend
     }
   }
 
-  private resetConnection(reason: string): void {
+  private closeSocket(reason: string, preserveSession = false): void {
     const socket = this.socket
     this.socket = null
     this.attached = false
-    this.currentSessionId = null
+    this.selectedProtocolVersion = null
     this.decoder.reset()
     this.rejectPendingRequests(new Error(reason))
 
+    if (!preserveSession) {
+      this.currentSessionId = null
+      this.attachOptions = null
+    }
+
     if (!socket) {
       return
     }
@@ -64,6 +80,14 @@ export class RemoteSessionBackend
     }
   }
 
+  private handleConnectionLoss(reason: string): void {
+    logDebug('backend.remote.connectionLoss', { reason, sessionId: this.currentSessionId })
+    this.closeSocket(reason, true)
+    if (this.shouldReconnect && this.attachOptions) {
+      void this.scheduleReconnect()
+    }
+  }
+
   private getConnectedSocket(): Socket {
     if (!this.socket || this.socket.destroyed) {
       throw new Error('Remote backend socket is unavailable')
@@ -140,57 +164,37 @@ export class RemoteSessionBackend
     }
   }
 
-  async attach(options: {
-    sessionId: string
-    cols: number
-    rows: number
-    workspaceSnapshot?: WorkspaceSnapshotV1
-  }): Promise<AttachResult> {
-    const socketPath = getDaemonSocketPath()
-    logDebug('backend.remote.attach.start', {
-      cols: options.cols,
-      rows: options.rows,
-      sessionId: options.sessionId,
-      snapshotTabs: options.workspaceSnapshot?.tabs.length ?? 0,
-      socketPath,
-    })
-    this.resetConnection('Connection replaced during attach')
+  private async connectAndHandshake(): Promise<void> {
+    const socketPath = getIpcDaemonSocketPath()
+    this.closeSocket('Connection replaced during attach', true)
 
     const socket = connect(socketPath)
     this.socket = socket
-    this.attached = false
-    this.currentSessionId = options.sessionId
 
     await new Promise<void>((resolve, reject) => {
       socket.once('connect', resolve)
       socket.once('error', reject)
     })
-    logDebug('backend.remote.attach.connected', { socketPath })
 
     socket.on('error', (error) => {
       if (this.socket !== socket) {
         return
       }
-      logDebug('backend.remote.socketError', { error: error.message })
-      this.resetConnection(`Remote backend socket error: ${error.message}`)
+      this.handleConnectionLoss(`Remote backend socket error: ${error.message}`)
     })
     socket.on('close', () => {
       if (this.socket !== socket) {
         return
       }
-      logDebug('backend.remote.socketClose')
-      this.resetConnection('Remote backend socket closed')
+      this.handleConnectionLoss('Remote backend socket closed')
     })
-
     socket.on('data', (chunk) => {
       if (this.socket !== socket) {
         return
       }
-      logDebug('backend.remote.data', { byteLength: chunk.length })
       try {
         for (const message of this.decoder.push(chunk)) {
           if ('id' in message) {
-            logDebug('backend.remote.response', { id: message.id, type: message.type })
             const pending = this.pending.get(message.id)
             if (pending) {
               clearTimeout(pending.timer)
@@ -203,41 +207,119 @@ export class RemoteSessionBackend
         }
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error)
-        logDebug('backend.remote.socketError', { error: message })
-        this.resetConnection(`Remote backend parse error: ${message}`)
+        this.handleConnectionLoss(`Remote backend parse error: ${message}`)
       }
     })
 
     const response = await this.send({
       id: crypto.randomUUID(),
-      payload: { ...options, protocolVersion: IPC_PROTOCOL_VERSION },
+      payload: { maxVersion: IPC_PROTOCOL_VERSION, minVersion: IPC_PROTOCOL_MIN_VERSION },
+      type: 'hello',
+    })
+
+    if (response.type !== 'helloResult') {
+      this.closeSocket('Unexpected hello response', true)
+      throw new Error(
+        response.type === 'error' ? response.payload.message : 'Unexpected hello response'
+      )
+    }
+
+    this.selectedProtocolVersion = response.payload.selectedVersion
+  }
+
+  private async performAttach(options: {
+    sessionId: string
+    cols: number
+    rows: number
+    workspaceSnapshot?: WorkspaceSnapshotV1
+  }): Promise<AttachResult> {
+    await this.connectAndHandshake()
+
+    const response = await this.send({
+      id: crypto.randomUUID(),
+      payload: {
+        ...options,
+        protocolVersion: this.selectedProtocolVersion ?? IPC_PROTOCOL_VERSION,
+      },
       type: 'attach',
     })
 
     if (response.type !== 'attachResult') {
-      logDebug('backend.remote.attach.unexpected', { type: response.type })
-      this.resetConnection(`Unexpected attach response: ${response.type}`)
+      this.closeSocket(`Unexpected attach response: ${response.type}`, true)
       throw new Error(
         response.type === 'error' ? response.payload.message : 'Unexpected attach response'
       )
     }
 
-    if (response.payload.protocolVersion !== IPC_PROTOCOL_VERSION) {
-      this.resetConnection(
-        `Protocol mismatch: client v${IPC_PROTOCOL_VERSION}, daemon v${response.payload.protocolVersion}`
+    if (response.payload.protocolVersion !== this.selectedProtocolVersion) {
+      this.closeSocket('Attach protocol mismatch', true)
+      throw new ProtocolMismatchError(
+        this.selectedProtocolVersion ?? IPC_PROTOCOL_VERSION,
+        response.payload.protocolVersion
       )
-      throw new ProtocolMismatchError(IPC_PROTOCOL_VERSION, response.payload.protocolVersion)
     }
 
     this.attached = true
+    return response.payload
+  }
+
+  private async scheduleReconnect(): Promise<void> {
+    if (this.reconnectPromise) {
+      return this.reconnectPromise
+    }
 
+    const reconnectOptions = this.attachOptions
+    this.reconnectPromise = (async () => {
+      while (this.shouldReconnect && reconnectOptions && this.attachOptions === reconnectOptions) {
+        try {
+          await this.performAttach(reconnectOptions)
+          logDebug('backend.remote.reconnect.success', {
+            sessionId: reconnectOptions.sessionId,
+          })
+          return
+        } catch (error) {
+          logDebug('backend.remote.reconnect.retry', {
+            error: error instanceof Error ? error.message : String(error),
+            sessionId: reconnectOptions.sessionId,
+          })
+          await Bun.sleep(RECONNECT_DELAY_MS)
+        }
+      }
+    })()
+
+    try {
+      await this.reconnectPromise
+    } finally {
+      this.reconnectPromise = null
+    }
+  }
+
+  async attach(options: {
+    sessionId: string
+    cols: number
+    rows: number
+    workspaceSnapshot?: WorkspaceSnapshotV1
+  }): Promise<AttachResult> {
+    this.shouldReconnect = true
+    this.currentSessionId = options.sessionId
+    this.attachOptions = options
+
+    logDebug('backend.remote.attach.start', {
+      cols: options.cols,
+      rows: options.rows,
+      sessionId: options.sessionId,
+      snapshotTabs: options.workspaceSnapshot?.tabs.length ?? 0,
+      socketPath: getIpcDaemonSocketPath(),
+    })
+
+    const result = await this.performAttach(options)
     logDebug('backend.remote.attach.success', {
-      activeTabId: response.payload.activeTabId,
+      activeTabId: result.activeTabId,
       sessionId: options.sessionId,
-      tabs: response.payload.tabs.length,
+      tabs: result.tabs.length,
     })
 
-    return response.payload
+    return result
   }
 
   createSession(options: {
@@ -255,11 +337,6 @@ export class RemoteSessionBackend
       return
     }
 
-    logDebug('backend.remote.createSession', {
-      sessionId: this.currentSessionId,
-      tabId: options.tabId,
-      title: options.title,
-    })
     void this.sendExpectOk({ id: crypto.randomUUID(), payload: options, type: 'createTab' }).catch(
       (error) => this.reportCommandError('createTab', error, options.tabId)
     )
@@ -270,11 +347,6 @@ export class RemoteSessionBackend
       logDebug('backend.remote.skipWriteBeforeAttach', { inputLength: input.length, tabId })
       return
     }
-    logDebug('backend.remote.write', {
-      inputLength: input.length,
-      sessionId: this.currentSessionId,
-      tabId,
-    })
     void this.sendExpectOk({
       id: crypto.randomUUID(),
       payload: { data: input, tabId },
@@ -286,7 +358,6 @@ export class RemoteSessionBackend
     if (!this.attached) {
       return
     }
-    logDebug('backend.remote.scroll', { deltaLines, sessionId: this.currentSessionId, tabId })
     void this.sendExpectOk({
       id: crypto.randomUUID(),
       payload: { deltaLines, tabId },
@@ -298,7 +369,6 @@ export class RemoteSessionBackend
     if (!this.attached) {
       return
     }
-    logDebug('backend.remote.scrollToBottom', { sessionId: this.currentSessionId, tabId })
     void this.sendExpectOk({
       id: crypto.randomUUID(),
       payload: { tabId },
@@ -310,7 +380,6 @@ export class RemoteSessionBackend
     if (!this.attached) {
       return
     }
-    logDebug('backend.remote.setActiveTab', { sessionId: this.currentSessionId, tabId })
     void this.sendExpectOk({
       id: crypto.randomUUID(),
       payload: { tabId },
@@ -323,7 +392,6 @@ export class RemoteSessionBackend
       logDebug('backend.remote.skipResizeBeforeAttach', { cols, rows })
       return
     }
-    logDebug('backend.remote.resize', { cols, rows, sessionId: this.currentSessionId })
     void this.sendExpectOk({
       id: crypto.randomUUID(),
       payload: { cols, rows },
@@ -335,7 +403,6 @@ export class RemoteSessionBackend
     if (!this.attached) {
       return
     }
-    logDebug('backend.remote.resizeTab', { cols, rows, sessionId: this.currentSessionId, tabId })
     void this.sendExpectOk({
       id: crypto.randomUUID(),
       payload: { cols, rows, tabId },
@@ -347,7 +414,6 @@ export class RemoteSessionBackend
     if (!this.attached) {
       return
     }
-    logDebug('backend.remote.disposeSession', { sessionId: this.currentSessionId, tabId })
     void this.sendExpectOk({ id: crypto.randomUUID(), payload: { tabId }, type: 'closeTab' }).catch(
       (error) => this.reportCommandError('closeTab', error, tabId)
     )
@@ -357,7 +423,6 @@ export class RemoteSessionBackend
     if (!this.attached) {
       return
     }
-    logDebug('backend.remote.disposeAll', { sessionId: this.currentSessionId })
     void this.sendExpectOk({ id: crypto.randomUUID(), payload: {}, type: 'disposeAll' }).catch(
       (error) => this.reportCommandError('disposeAll', error)
     )
@@ -365,9 +430,11 @@ export class RemoteSessionBackend
 
   async destroy(keepSessions = true): Promise<void> {
     logDebug('backend.remote.destroy', { keepSessions })
-    if (!keepSessions) {
+    this.shouldReconnect = false
+    this.reconnectPromise = null
+    if (!keepSessions && this.attached) {
       this.disposeAll()
     }
-    this.resetConnection('Remote backend destroyed')
+    this.closeSocket('Remote backend destroyed')
   }
 }

package/src/state/session-catalog.ts

@@ -1,10 +1,11 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
+import { join } from 'node:path'
 
 import type { SessionRecord } from './types'
 
-import { CONFIG_PATH, loadConfig, saveConfig } from '../config'
+import { loadConfig, saveConfig } from '../config'
 import { logDebug } from '../debug/input-log'
+import { getProfileConfigDir } from '../profile-paths'
 import { isSessionRecord } from './validation'
 
 interface SessionCatalogFile {
@@ -12,7 +13,7 @@ interface SessionCatalogFile {
   sessions: SessionRecord[]
 }
 
-const SESSIONS_PATH = join(dirname(CONFIG_PATH), 'aimux-sessions.json')
+const SESSIONS_PATH = join(getProfileConfigDir(), 'aimux-sessions.json')
 
 function readCatalogFile(): { file: SessionCatalogFile | null; issue?: string } {
   try {
@@ -79,7 +80,7 @@ export function loadSessionCatalog(): SessionRecord[] {
 
 export function saveSessionCatalog(sessions: SessionRecord[]): void {
   try {
-    mkdirSync(dirname(SESSIONS_PATH), { recursive: true })
+    mkdirSync(getProfileConfigDir(), { recursive: true })
     writeFileSync(SESSIONS_PATH, `${JSON.stringify({ sessions, version: 1 }, null, 2)}\n`)
     logDebug('sessions.catalog.save', { sessionCount: sessions.length })
   } catch (error) {