@brimveyn/aimux 1.2.0 → 1.3.0

package/src/state/snippet-catalog.ts

@@ -1,8 +1,8 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
+import { join } from 'node:path'
 
-import { CONFIG_PATH } from '../config'
 import { logDebug } from '../debug/input-log'
+import { getProfileConfigDir } from '../profile-paths'
 import { isSnippetRecord } from './validation'
 
 export interface SnippetRecord {
@@ -11,7 +11,7 @@ export interface SnippetRecord {
   content: string
 }
 
-const SNIPPETS_PATH = join(dirname(CONFIG_PATH), 'aimux-snippets.json')
+const SNIPPETS_PATH = join(getProfileConfigDir(), 'aimux-snippets.json')
 
 const DEFAULT_SNIPPETS: SnippetRecord[] = [
   {
@@ -78,7 +78,7 @@ export function loadSnippetCatalog(): SnippetRecord[] {
 
 export function saveSnippetCatalog(snippets: SnippetRecord[]): void {
   try {
-    mkdirSync(dirname(SNIPPETS_PATH), { recursive: true })
+    mkdirSync(getProfileConfigDir(), { recursive: true })
     writeFileSync(SNIPPETS_PATH, `${JSON.stringify({ snippets, version: 1 }, null, 2)}\n`)
   } catch (error) {
     logDebug('snippets.catalog.saveError', {

package/src/terminal-manager/manager-client.ts

@@ -0,0 +1,360 @@
+import { EventEmitter } from 'node:events'
+import { connect, Socket } from 'node:net'
+
+import type { TerminalModeState, TerminalSnapshot, WorkspaceSnapshotV1 } from '../state/types'
+
+import { getTerminalManagerSocketPath } from '../daemon/runtime-paths'
+import { logDebug } from '../debug/input-log'
+import {
+  encodeManagerMessage,
+  MANAGER_PROTOCOL_MIN_VERSION,
+  MANAGER_PROTOCOL_VERSION,
+  type ManagerAttachResult,
+  type ManagerEvent,
+  type ManagerRequest,
+  type ManagerResponse,
+  MessageDecoder,
+  parseManagerMessage,
+} from '../ipc/manager-protocol'
+
+type ManagerClientEvents = {
+  render: [
+    sessionId: string,
+    tabId: string,
+    viewport: TerminalSnapshot,
+    terminalModes: TerminalModeState,
+  ]
+  exit: [sessionId: string, tabId: string, exitCode: number]
+  error: [sessionId: string, tabId: string, message: string]
+}
+
+const REQUEST_TIMEOUT_MS = 10_000
+
+export class TerminalManagerClient extends EventEmitter<ManagerClientEvents> {
+  private socket: Socket | null = null
+  private readonly pending = new Map<
+    string,
+    {
+      resolve: (message: ManagerResponse) => void
+      reject: (error: Error) => void
+      timer: ReturnType<typeof setTimeout>
+    }
+  >()
+  private readonly decoder = new MessageDecoder<ManagerResponse | ManagerEvent>(parseManagerMessage)
+  private selectedProtocolVersion: number | null = null
+
+  private rejectPendingRequests(error: Error): void {
+    for (const [id, pending] of this.pending.entries()) {
+      clearTimeout(pending.timer)
+      this.pending.delete(id)
+      pending.reject(error)
+    }
+  }
+
+  private resetConnection(reason: string): void {
+    logDebug('managerClient.resetConnection', { reason })
+    const socket = this.socket
+    this.socket = null
+    this.selectedProtocolVersion = null
+    this.decoder.reset()
+    this.rejectPendingRequests(new Error(reason))
+
+    if (!socket) {
+      return
+    }
+
+    socket.removeAllListeners()
+    if (!socket.destroyed) {
+      socket.end()
+      socket.destroy()
+    }
+  }
+
+  private getConnectedSocket(): Socket {
+    if (!this.socket || this.socket.destroyed) {
+      throw new Error('Terminal manager socket is unavailable')
+    }
+
+    return this.socket
+  }
+
+  private send(request: ManagerRequest): Promise<ManagerResponse> {
+    const socket = this.getConnectedSocket()
+    logDebug('managerClient.send', { id: request.id, type: request.type })
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(request.id)
+        logDebug('managerClient.timeout', { id: request.id, type: request.type })
+        reject(
+          new Error(`Manager request timed out after ${REQUEST_TIMEOUT_MS}ms: ${request.type}`)
+        )
+      }, REQUEST_TIMEOUT_MS)
+      this.pending.set(request.id, { reject, resolve, timer })
+      socket.write(encodeManagerMessage(request), (error) => {
+        if (error) {
+          clearTimeout(timer)
+          this.pending.delete(request.id)
+          logDebug('managerClient.sendError', {
+            error: error.message,
+            id: request.id,
+            type: request.type,
+          })
+          reject(error)
+        }
+      })
+    })
+  }
+
+  private async sendExpectOk(request: ManagerRequest): Promise<void> {
+    const response = await this.send(request)
+    if (response.type === 'ok') {
+      return
+    }
+
+    throw new Error(
+      response.type === 'error'
+        ? response.payload.message
+        : `Unexpected response for ${request.type}: ${response.type}`
+    )
+  }
+
+  private handleManagerEvent(message: ManagerEvent): void {
+    logDebug('managerClient.event', {
+      sessionId: message.payload.sessionId,
+      tabId: message.payload.tabId,
+      type: message.type,
+    })
+    switch (message.type) {
+      case 'tabRender':
+        this.emit(
+          'render',
+          message.payload.sessionId,
+          message.payload.tabId,
+          message.payload.viewport,
+          message.payload.terminalModes
+        )
+        break
+      case 'tabExit':
+        this.emit(
+          'exit',
+          message.payload.sessionId,
+          message.payload.tabId,
+          message.payload.exitCode
+        )
+        break
+      case 'tabError':
+        this.emit(
+          'error',
+          message.payload.sessionId,
+          message.payload.tabId,
+          message.payload.message
+        )
+        break
+    }
+  }
+
+  private async performHandshake(): Promise<void> {
+    logDebug('managerClient.handshake.start', {
+      maxVersion: MANAGER_PROTOCOL_VERSION,
+      minVersion: MANAGER_PROTOCOL_MIN_VERSION,
+    })
+    const response = await this.send({
+      id: crypto.randomUUID(),
+      payload: {
+        maxVersion: MANAGER_PROTOCOL_VERSION,
+        minVersion: MANAGER_PROTOCOL_MIN_VERSION,
+      },
+      type: 'hello',
+    })
+
+    if (response.type !== 'helloResult') {
+      throw new Error(
+        response.type === 'error' ? response.payload.message : 'Unexpected hello response'
+      )
+    }
+
+    this.selectedProtocolVersion = response.payload.selectedVersion
+    logDebug('managerClient.handshake.success', {
+      processVersion: response.payload.processVersion,
+      selectedVersion: this.selectedProtocolVersion,
+    })
+  }
+
+  async connect(): Promise<void> {
+    if (this.socket && !this.socket.destroyed && this.selectedProtocolVersion !== null) {
+      logDebug('managerClient.connect.reuse', {
+        selectedProtocolVersion: this.selectedProtocolVersion,
+      })
+      return
+    }
+
+    this.resetConnection('Terminal manager connection replaced')
+
+    logDebug('managerClient.connect.start', { socketPath: getTerminalManagerSocketPath() })
+    const socket = connect(getTerminalManagerSocketPath())
+    this.socket = socket
+
+    await new Promise<void>((resolve, reject) => {
+      socket.once('connect', resolve)
+      socket.once('error', reject)
+    })
+
+    logDebug('managerClient.connect.connected', { socketPath: getTerminalManagerSocketPath() })
+
+    socket.on('error', (error) => {
+      if (this.socket !== socket) {
+        return
+      }
+      logDebug('managerClient.socketError', { error: error.message })
+      this.resetConnection(`Terminal manager socket error: ${error.message}`)
+    })
+    socket.on('close', () => {
+      if (this.socket !== socket) {
+        return
+      }
+      logDebug('managerClient.socketClose')
+      this.resetConnection('Terminal manager socket closed')
+    })
+    socket.on('data', (chunk) => {
+      if (this.socket !== socket) {
+        return
+      }
+
+      try {
+        for (const message of this.decoder.push(chunk)) {
+          if ('id' in message) {
+            logDebug('managerClient.response', { id: message.id, type: message.type })
+            const pending = this.pending.get(message.id)
+            if (pending) {
+              clearTimeout(pending.timer)
+              this.pending.delete(message.id)
+              pending.resolve(message)
+            }
+          } else {
+            this.handleManagerEvent(message)
+          }
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        logDebug('managerClient.parseError', { error: message })
+        this.resetConnection(`Terminal manager parse error: ${message}`)
+      }
+    })
+
+    await this.performHandshake()
+  }
+
+  async attachSession(options: {
+    sessionId: string
+    cols: number
+    rows: number
+    workspaceSnapshot?: WorkspaceSnapshotV1
+  }): Promise<ManagerAttachResult> {
+    logDebug('managerClient.attach.start', {
+      cols: options.cols,
+      rows: options.rows,
+      sessionId: options.sessionId,
+      snapshotTabs: options.workspaceSnapshot?.tabs.length ?? 0,
+    })
+    await this.connect()
+    const response = await this.send({
+      id: crypto.randomUUID(),
+      payload: {
+        ...options,
+        protocolVersion: this.selectedProtocolVersion ?? MANAGER_PROTOCOL_VERSION,
+      },
+      type: 'attachSession',
+    })
+
+    if (response.type !== 'attachResult') {
+      throw new Error(
+        response.type === 'error' ? response.payload.message : 'Unexpected attach response'
+      )
+    }
+
+    logDebug('managerClient.attach.success', {
+      activeTabId: response.payload.activeTabId,
+      sessionId: options.sessionId,
+      tabs: response.payload.tabs.length,
+    })
+    return response.payload
+  }
+
+  createTab(options: Extract<ManagerRequest, { type: 'createTab' }>['payload']): Promise<void> {
+    logDebug('managerClient.createTab', {
+      command: options.command,
+      sessionId: options.sessionId,
+      tabId: options.tabId,
+      title: options.title,
+    })
+    return this.sendExpectOk({ id: crypto.randomUUID(), payload: options, type: 'createTab' })
+  }
+
+  write(sessionId: string, tabId: string, data: string): Promise<void> {
+    return this.sendExpectOk({
+      id: crypto.randomUUID(),
+      payload: { data, sessionId, tabId },
+      type: 'write',
+    })
+  }
+
+  resize(sessionId: string, cols: number, rows: number): Promise<void> {
+    return this.sendExpectOk({
+      id: crypto.randomUUID(),
+      payload: { cols, rows, sessionId },
+      type: 'resizeClient',
+    })
+  }
+
+  resizeTab(sessionId: string, tabId: string, cols: number, rows: number): Promise<void> {
+    return this.sendExpectOk({
+      id: crypto.randomUUID(),
+      payload: { cols, rows, sessionId, tabId },
+      type: 'resizeTab',
+    })
+  }
+
+  scroll(sessionId: string, tabId: string, deltaLines: number): Promise<void> {
+    return this.sendExpectOk({
+      id: crypto.randomUUID(),
+      payload: { deltaLines, sessionId, tabId },
+      type: 'scroll',
+    })
+  }
+
+  scrollToBottom(sessionId: string, tabId: string): Promise<void> {
+    return this.sendExpectOk({
+      id: crypto.randomUUID(),
+      payload: { sessionId, tabId },
+      type: 'scrollToBottom',
+    })
+  }
+
+  setActiveTab(sessionId: string, tabId: string | null): Promise<void> {
+    return this.sendExpectOk({
+      id: crypto.randomUUID(),
+      payload: { sessionId, tabId },
+      type: 'setActiveTab',
+    })
+  }
+
+  closeTab(sessionId: string, tabId: string): Promise<void> {
+    return this.sendExpectOk({
+      id: crypto.randomUUID(),
+      payload: { sessionId, tabId },
+      type: 'closeTab',
+    })
+  }
+
+  disposeSession(sessionId: string): Promise<void> {
+    return this.sendExpectOk({
+      id: crypto.randomUUID(),
+      payload: { sessionId },
+      type: 'disposeSession',
+    })
+  }
+
+  destroy(): void {
+    this.resetConnection('Terminal manager client destroyed')
+  }
+}

package/src/terminal-manager/terminal-manager.ts

@@ -0,0 +1,272 @@
+import { createServer, type Socket } from 'node:net'
+
+import {
+  getTerminalManagerSocketPath,
+  removeTerminalManagerSocketIfExists,
+  tightenSocketPermissions,
+} from '../daemon/runtime-paths'
+import { SessionManager } from '../daemon/session-manager'
+import { logDebug } from '../debug/input-log'
+import {
+  createManagerHelloResult,
+  encodeManagerMessage,
+  type ManagerEvent,
+  type ManagerRequest,
+  type ManagerResponse,
+  MessageDecoder,
+  parseManagerRequest,
+  selectManagerProtocolVersion,
+} from '../ipc/manager-protocol'
+import { findSocketProcessPid } from '../platform/daemon-control'
+
+function send(socket: Socket, message: ManagerResponse | ManagerEvent): void {
+  socket.write(encodeManagerMessage(message))
+}
+
+function sendOk(socket: Socket, id: string): void {
+  send(socket, { id, payload: {}, type: 'ok' })
+}
+
+function requireNegotiatedVersion(socket: Socket, versions: Map<Socket, number>): number {
+  const version = versions.get(socket)
+  if (version === undefined) {
+    throw new Error('Protocol handshake required before using terminal manager')
+  }
+  return version
+}
+
+export async function runTerminalManager(): Promise<void> {
+  const socketPath = getTerminalManagerSocketPath()
+  logDebug('terminalManager.start', { pid: process.pid, socketPath })
+
+  const existingPid = await findSocketProcessPid(socketPath)
+  if (existingPid !== null && existingPid !== process.pid) {
+    logDebug('terminalManager.alreadyRunning', { existingPid })
+    process.stderr.write(`aimux terminal manager already running (pid ${existingPid})\n`)
+    process.exit(1)
+  }
+
+  removeTerminalManagerSocketIfExists()
+
+  const sessionManager = new SessionManager()
+  const sockets = new Set<Socket>()
+  const negotiatedVersions = new Map<Socket, number>()
+
+  sessionManager.on('render', (sessionId, tabId, viewport, terminalModes) => {
+    const event: ManagerEvent = {
+      payload: { sessionId, tabId, terminalModes, viewport },
+      type: 'tabRender',
+    }
+    for (const socket of sockets) {
+      send(socket, event)
+    }
+  })
+  sessionManager.on('exit', (sessionId, tabId, exitCode) => {
+    const event: ManagerEvent = { payload: { exitCode, sessionId, tabId }, type: 'tabExit' }
+    for (const socket of sockets) {
+      send(socket, event)
+    }
+  })
+  sessionManager.on('error', (sessionId, tabId, message) => {
+    const event: ManagerEvent = { payload: { message, sessionId, tabId }, type: 'tabError' }
+    for (const socket of sockets) {
+      send(socket, event)
+    }
+  })
+
+  const server = createServer((socket) => {
+    logDebug('terminalManager.client.connected')
+    sockets.add(socket)
+    const decoder = new MessageDecoder<ManagerRequest>(parseManagerRequest)
+
+    socket.on('data', (chunk) => {
+      try {
+        for (const message of decoder.push(chunk)) {
+          try {
+            switch (message.type) {
+              case 'hello': {
+                logDebug('terminalManager.request.hello', {
+                  maxVersion: message.payload.maxVersion,
+                  minVersion: message.payload.minVersion,
+                })
+                const selectedVersion = selectManagerProtocolVersion(message.payload)
+                if (selectedVersion === null) {
+                  send(socket, {
+                    id: message.id,
+                    payload: { message: 'No compatible terminal-manager protocol version' },
+                    type: 'error',
+                  })
+                  break
+                }
+
+                negotiatedVersions.set(socket, selectedVersion)
+                logDebug('terminalManager.request.hello.success', { selectedVersion })
+                send(socket, {
+                  id: message.id,
+                  payload: createManagerHelloResult(selectedVersion),
+                  type: 'helloResult',
+                })
+                break
+              }
+              case 'attachSession': {
+                logDebug('terminalManager.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(
+                    `Manager protocol mismatch: client v${message.payload.protocolVersion}, server v${negotiatedVersion}`
+                  )
+                }
+                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: negotiatedVersion, ...attachResult },
+                  type: 'attachResult',
+                })
+                logDebug('terminalManager.request.attach.success', {
+                  activeTabId: attachResult.activeTabId,
+                  sessionId: message.payload.sessionId,
+                  tabs: attachResult.tabs.length,
+                })
+                break
+              }
+              case 'createTab':
+                requireNegotiatedVersion(socket, negotiatedVersions)
+                logDebug('terminalManager.request.createTab.start', {
+                  command: message.payload.command,
+                  sessionId: message.payload.sessionId,
+                  tabId: message.payload.tabId,
+                  title: message.payload.title,
+                })
+                sessionManager.createTab(message.payload.sessionId, message.payload)
+                sendOk(socket, message.id)
+                logDebug('terminalManager.request.createTab.success', {
+                  sessionId: message.payload.sessionId,
+                  tabId: message.payload.tabId,
+                })
+                break
+              case 'write':
+                requireNegotiatedVersion(socket, negotiatedVersions)
+                sessionManager.write(
+                  message.payload.sessionId,
+                  message.payload.tabId,
+                  message.payload.data
+                )
+                sendOk(socket, message.id)
+                break
+              case 'resizeClient':
+                requireNegotiatedVersion(socket, negotiatedVersions)
+                sessionManager.resize(
+                  message.payload.sessionId,
+                  message.payload.cols,
+                  message.payload.rows
+                )
+                sendOk(socket, message.id)
+                break
+              case 'resizeTab':
+                requireNegotiatedVersion(socket, negotiatedVersions)
+                sessionManager.resizeTab(
+                  message.payload.sessionId,
+                  message.payload.tabId,
+                  message.payload.cols,
+                  message.payload.rows
+                )
+                sendOk(socket, message.id)
+                break
+              case 'scroll':
+                requireNegotiatedVersion(socket, negotiatedVersions)
+                sessionManager.scroll(
+                  message.payload.sessionId,
+                  message.payload.tabId,
+                  message.payload.deltaLines
+                )
+                sendOk(socket, message.id)
+                break
+              case 'scrollToBottom':
+                requireNegotiatedVersion(socket, negotiatedVersions)
+                sessionManager.scrollToBottom(message.payload.sessionId, message.payload.tabId)
+                sendOk(socket, message.id)
+                break
+              case 'setActiveTab':
+                requireNegotiatedVersion(socket, negotiatedVersions)
+                sessionManager.setActiveTab(message.payload.sessionId, message.payload.tabId)
+                sendOk(socket, message.id)
+                break
+              case 'closeTab':
+                requireNegotiatedVersion(socket, negotiatedVersions)
+                sessionManager.closeTab(message.payload.sessionId, message.payload.tabId)
+                sendOk(socket, message.id)
+                break
+              case 'disposeSession':
+                requireNegotiatedVersion(socket, negotiatedVersions)
+                sessionManager.disposeSession(message.payload.sessionId)
+                sendOk(socket, message.id)
+                break
+              case 'ping':
+                sendOk(socket, message.id)
+                break
+            }
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error)
+            logDebug('terminalManager.request.error', {
+              error: errorMessage,
+              requestId: message.id,
+              type: message.type,
+            })
+            send(socket, { id: message.id, payload: { message: errorMessage }, type: 'error' })
+          }
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        logDebug('terminalManager.decoder.error', { error: message })
+        decoder.reset()
+        send(socket, { id: crypto.randomUUID(), payload: { message }, type: 'error' })
+      }
+    })
+
+    socket.on('close', () => {
+      logDebug('terminalManager.client.close')
+      sockets.delete(socket)
+      negotiatedVersions.delete(socket)
+    })
+    socket.on('error', () => {
+      logDebug('terminalManager.client.error')
+      sockets.delete(socket)
+      negotiatedVersions.delete(socket)
+    })
+  })
+
+  await new Promise<void>((resolve, reject) => {
+    server.once('error', reject)
+    server.listen(socketPath, () => resolve())
+  })
+  tightenSocketPermissions(socketPath)
+
+  const gracefulShutdown = (signal: string) => {
+    logDebug(`terminalManager.${signal}`)
+    sessionManager.disposeAll()
+    server.close()
+    process.exit(0)
+  }
+
+  process.on('SIGTERM', () => gracefulShutdown('sigterm'))
+  process.on('SIGINT', () => gracefulShutdown('sigint'))
+  process.on('uncaughtException', () => gracefulShutdown('uncaughtException'))
+  process.on('unhandledRejection', () => gracefulShutdown('unhandledRejection'))
+
+  await new Promise<void>(() => {
+    // Keep the terminal-manager process alive until it is terminated.
+  })
+}

package/src/update.ts

@@ -1,5 +1,5 @@
 import { getDaemonSocketPath } from './daemon/runtime-paths'
-import { findDaemonPid } from './platform/daemon-control'
+import { findIpcDaemonPid } from './platform/daemon-control'
 import { runRestartDaemon } from './restart-daemon'
 
 const REPO = 'BrimVeyn/aimux'
@@ -52,9 +52,9 @@ export async function runUpdate(): Promise<number> {
 
   process.stdout.write(`Updated to ${latest}.\n`)
 
-  const pid = await findDaemonPid(getDaemonSocketPath())
+  const pid = await findIpcDaemonPid()
   if (pid !== null) {
-    process.stdout.write('Restarting daemon...\n')
+    process.stdout.write(`Restarting IPC daemon at ${getDaemonSocketPath()}...\n`)
     await runRestartDaemon()
   }