@brimveyn/aimux 1.2.5 → 1.3.0

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,195 @@ 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)
+                  sendOk(socket, message.id)
+                  break
                 }
-                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
+                  )
+                  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 '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 +350,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 +364,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/index.tsx

@@ -4,13 +4,16 @@ import { createRoot } from '@opentui/react'
 
 import { App } from './app'
 import { runDaemon } from './daemon/daemon'
+import { getRuntimeProfile } from './daemon/runtime-paths'
 import { logDebug } from './debug/input-log'
 import { runDoctor } from './doctor'
 import { runRestartDaemon } from './restart-daemon'
 import { createSessionBackend } from './session-backend/bootstrap'
+import { runTerminalManager } from './terminal-manager/terminal-manager'
 import { runUpdate } from './update'
 
 const command = process.argv[2]
+const runtimeProfile = getRuntimeProfile()
 
 if (command === '--version' || command === '-v' || command === 'version') {
   const { version } = await import('../package.json')
@@ -31,13 +34,18 @@ if (command === 'update') {
 }
 
 if (command === 'daemon') {
-  logDebug('index.daemonMode')
+  logDebug('index.daemonMode', { runtimeProfile })
   await runDaemon()
 }
 
+if (command === 'terminal-manager') {
+  logDebug('index.terminalManagerMode', { runtimeProfile })
+  await runTerminalManager()
+}
+
 if (command === '--help' || command === '-h') {
   process.stdout.write(
-    'aimux -- terminal multiplexer for AI CLIs\n\nUsage:\n  aimux                  Start aimux\n  aimux update           Update to latest version\n  aimux doctor           Diagnose setup issues\n  aimux restart-daemon   Restart background daemon\n\n'
+    'aimux -- terminal multiplexer for AI CLIs\n\nUsage:\n  aimux                  Start aimux\n  aimux update           Update to latest version\n  aimux doctor           Diagnose setup issues\n  aimux restart-daemon   Restart IPC daemon\n\n'
   )
   process.exit(0)
 }
@@ -51,6 +59,6 @@ const renderer = await createCliRenderer({
 })
 
 const backend = await createSessionBackend()
-logDebug('index.backendReady', { backend: backend.constructor.name })
+logDebug('index.backendReady', { backend: backend.constructor.name, runtimeProfile })
 
 createRoot(renderer).render(<App backend={backend} />)