@brimveyn/aimux 1.1.0

package/src/session-backend/bootstrap.ts

@@ -0,0 +1,107 @@
+import { connect } from 'node:net'
+
+import type { SessionBackend } from './types'
+
+import {
+  getDaemonSocketPath,
+  getDaemonSocketSecurityIssue,
+  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 { LocalSessionBackend } from './local-session-backend'
+import { RemoteSessionBackend } from './remote-session-backend'
+
+async function spawnDaemon(): Promise<void> {
+  logDebug('backend.spawnDaemon.start', {
+    execPath: process.execPath,
+    socketPath: getDaemonSocketPath(),
+  })
+  const ok = await spawnDetachedDaemon()
+  if (ok) {
+    logDebug('backend.spawnDaemon.ready', { socketPath: getDaemonSocketPath() })
+    return
+  }
+
+  logDebug('backend.spawnDaemon.timeout', { socketPath: getDaemonSocketPath() })
+}
+
+async function canConnectToDaemon(socketPath: string): Promise<boolean> {
+  const securityIssue = getDaemonSocketSecurityIssue(socketPath)
+  if (securityIssue) {
+    logDebug('backend.healthcheck.socketIssue', { issue: securityIssue, socketPath })
+    return false
+  }
+
+  return await 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', (error: NodeJS.ErrnoException) => {
+      logDebug('backend.healthcheck.error', {
+        code: error.code ?? 'unknown',
+        error: error.message,
+        socketPath,
+      })
+      finish(false)
+    })
+  })
+}
+
+async function restartDaemon(socketPath: string): Promise<void> {
+  const pid = await findDaemonPid(socketPath)
+  if (pid !== null) {
+    logDebug('backend.restartDaemon.killing', { pid })
+    await killDaemon(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()
+    }
+
+    const reachable = await canConnectToDaemon(socketPath)
+    if (!reachable) {
+      throw new Error(`Daemon unavailable at ${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),
+        })
+      }
+    }
+
+    logDebug('backend.create.localFallback', {
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return new LocalSessionBackend()
+  }
+}

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

@@ -0,0 +1,164 @@
+import { EventEmitter } from 'node:events'
+
+import type { AssistantId, WorkspaceSnapshotV1 } from '../state/types'
+import type { SessionBackend, SessionBackendEvents } from './types'
+
+import { SessionManager } from '../daemon/session-manager'
+import { logDebug } from '../debug/input-log'
+import {
+  createTerminalBounds,
+  forEachSplitPaneRect,
+  getSnapshotTrees,
+  toTerminalContentSize,
+} from '../state/layout-resize'
+
+export class LocalSessionBackend
+  extends EventEmitter<SessionBackendEvents>
+  implements SessionBackend
+{
+  private readonly sessionManager = new SessionManager()
+  private currentSessionId: string | null = null
+
+  constructor() {
+    super()
+    this.sessionManager.on('render', (sessionId, tabId, viewport, terminalModes) => {
+      if (sessionId === this.currentSessionId) {
+        this.emit('render', tabId, viewport, terminalModes)
+      }
+    })
+    this.sessionManager.on('exit', (sessionId, tabId, exitCode) => {
+      if (sessionId === this.currentSessionId) {
+        this.emit('exit', tabId, exitCode)
+      }
+    })
+    this.sessionManager.on('error', (sessionId, tabId, message) => {
+      if (sessionId === this.currentSessionId) {
+        this.emit('error', tabId, message)
+      }
+    })
+  }
+
+  async attach(options: {
+    sessionId: string
+    cols: number
+    rows: number
+    workspaceSnapshot?: WorkspaceSnapshotV1
+  }) {
+    logDebug('backend.local.attach', {
+      cols: options.cols,
+      rows: options.rows,
+      sessionId: options.sessionId,
+      snapshotTabs: options.workspaceSnapshot?.tabs.length ?? 0,
+    })
+    this.currentSessionId = options.sessionId
+    const trees = getSnapshotTrees(options.workspaceSnapshot)
+    const splitTrees = trees.filter((t) => t.type === 'split')
+    if (splitTrees.length > 0) {
+      const bounds = createTerminalBounds(options.cols, options.rows)
+      forEachSplitPaneRect(splitTrees, bounds, (tabId, rect) => {
+        const size = toTerminalContentSize(rect)
+        this.sessionManager.resizeTab(options.sessionId, tabId, size.cols, size.rows)
+      })
+    } else {
+      this.sessionManager.resize(options.sessionId, options.cols, options.rows)
+    }
+    return this.sessionManager.attachSession(options.sessionId, options.workspaceSnapshot)
+  }
+
+  createSession(options: {
+    tabId: string
+    assistant: AssistantId
+    title: string
+    command: string
+    args?: string[]
+    cols: number
+    rows: number
+    cwd?: string
+  }): void {
+    if (!this.currentSessionId) {
+      logDebug('backend.local.skipCreateWithoutSession', { tabId: options.tabId })
+      return
+    }
+    logDebug('backend.local.createSession', {
+      sessionId: this.currentSessionId,
+      tabId: options.tabId,
+      title: options.title,
+    })
+    this.sessionManager.createTab(this.currentSessionId, options)
+  }
+
+  write(tabId: string, input: string): void {
+    if (!this.currentSessionId) {
+      logDebug('backend.local.skipWriteWithoutSession', { inputLength: input.length, tabId })
+      return
+    }
+    logDebug('backend.local.write', {
+      inputLength: input.length,
+      sessionId: this.currentSessionId,
+      tabId,
+    })
+    this.sessionManager.write(this.currentSessionId, tabId, input)
+  }
+
+  scrollViewport(tabId: string, deltaLines: number): void {
+    if (!this.currentSessionId) {
+      return
+    }
+    this.sessionManager.scroll(this.currentSessionId, tabId, deltaLines)
+  }
+
+  scrollViewportToBottom(tabId: string): void {
+    if (!this.currentSessionId) {
+      return
+    }
+    this.sessionManager.scrollToBottom(this.currentSessionId, tabId)
+  }
+
+  setActiveTab(tabId: string | null): void {
+    if (!this.currentSessionId) {
+      return
+    }
+    logDebug('backend.local.setActiveTab', { sessionId: this.currentSessionId, tabId })
+    this.sessionManager.setActiveTab(this.currentSessionId, tabId)
+  }
+
+  resizeAll(cols: number, rows: number): void {
+    if (!this.currentSessionId) {
+      return
+    }
+    this.sessionManager.resize(this.currentSessionId, cols, rows)
+  }
+
+  resizeTab(tabId: string, cols: number, rows: number): void {
+    if (!this.currentSessionId) {
+      return
+    }
+    this.sessionManager.resizeTab(this.currentSessionId, tabId, cols, rows)
+  }
+
+  disposeSession(tabId: string): void {
+    if (!this.currentSessionId) {
+      return
+    }
+    logDebug('backend.local.disposeSession', { sessionId: this.currentSessionId, tabId })
+    this.sessionManager.closeTab(this.currentSessionId, tabId)
+  }
+
+  disposeAll(): void {
+    if (!this.currentSessionId) {
+      return
+    }
+    logDebug('backend.local.disposeAll', { sessionId: this.currentSessionId })
+    this.sessionManager.disposeSession(this.currentSessionId)
+  }
+
+  destroy(keepSessions = true): void {
+    logDebug('backend.local.destroy', { keepSessions, sessionId: this.currentSessionId })
+    if (!keepSessions) {
+      if (this.currentSessionId) {
+        this.sessionManager.disposeSession(this.currentSessionId)
+      }
+    }
+    this.currentSessionId = null
+  }
+}

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

@@ -0,0 +1,373 @@
+import { EventEmitter } from 'node:events'
+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 { logDebug } from '../debug/input-log'
+import {
+  type AttachResult,
+  type ClientRequest,
+  encodeMessage,
+  IPC_PROTOCOL_VERSION,
+  MessageDecoder,
+  parseServerMessage,
+  ProtocolMismatchError,
+  type ServerEvent,
+  type ServerResponse,
+} from '../ipc/protocol'
+
+const IPC_REQUEST_TIMEOUT_MS = 10_000
+
+export class RemoteSessionBackend
+  extends EventEmitter<SessionBackendEvents>
+  implements SessionBackend
+{
+  private socket: Socket | null = null
+  private readonly pending = new Map<
+    string,
+    {
+      resolve: (message: ServerResponse) => void
+      reject: (error: Error) => void
+      timer: ReturnType<typeof setTimeout>
+    }
+  >()
+  private decoder = new MessageDecoder<ServerResponse | ServerEvent>(parseServerMessage)
+  private attached = false
+  private currentSessionId: string | 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 {
+    const socket = this.socket
+    this.socket = null
+    this.attached = false
+    this.currentSessionId = 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('Remote backend socket is unavailable')
+    }
+
+    return this.socket
+  }
+
+  private send(request: ClientRequest): Promise<ServerResponse> {
+    const socket = this.getConnectedSocket()
+    logDebug('backend.remote.send', { id: request.id, type: request.type })
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(request.id)
+        logDebug('backend.remote.timeout', { id: request.id, type: request.type })
+        reject(
+          new Error(`IPC request timed out after ${IPC_REQUEST_TIMEOUT_MS}ms: ${request.type}`)
+        )
+      }, IPC_REQUEST_TIMEOUT_MS)
+      this.pending.set(request.id, { reject, resolve, timer })
+      socket.write(encodeMessage(request), (error) => {
+        if (error) {
+          clearTimeout(timer)
+          this.pending.delete(request.id)
+          logDebug('backend.remote.sendError', {
+            error: error.message,
+            id: request.id,
+            type: request.type,
+          })
+          reject(error)
+        }
+      })
+    })
+  }
+
+  private async sendExpectOk(request: ClientRequest): 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 reportCommandError(context: string, error: unknown, tabId?: string): void {
+    const message = error instanceof Error ? error.message : String(error)
+    logDebug('backend.remote.commandError', { context, error: message, tabId })
+    if (tabId) {
+      this.emit('error', tabId, message)
+    }
+  }
+
+  private handleServerEvent(message: ServerEvent): void {
+    logDebug('backend.remote.event', { type: message.type })
+    switch (message.type) {
+      case 'tabRender':
+        this.emit(
+          'render',
+          message.payload.tabId,
+          message.payload.viewport,
+          message.payload.terminalModes
+        )
+        break
+      case 'tabExit':
+        this.emit('exit', message.payload.tabId, message.payload.exitCode)
+        break
+      case 'tabError':
+        this.emit('error', message.payload.tabId, message.payload.message)
+        break
+    }
+  }
+
+  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')
+
+    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}`)
+    })
+    socket.on('close', () => {
+      if (this.socket !== socket) {
+        return
+      }
+      logDebug('backend.remote.socketClose')
+      this.resetConnection('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)
+              this.pending.delete(message.id)
+              pending.resolve(message)
+            }
+          } else {
+            this.handleServerEvent(message)
+          }
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        logDebug('backend.remote.socketError', { error: message })
+        this.resetConnection(`Remote backend parse error: ${message}`)
+      }
+    })
+
+    const response = await this.send({
+      id: crypto.randomUUID(),
+      payload: { ...options, protocolVersion: IPC_PROTOCOL_VERSION },
+      type: 'attach',
+    })
+
+    if (response.type !== 'attachResult') {
+      logDebug('backend.remote.attach.unexpected', { type: response.type })
+      this.resetConnection(`Unexpected attach response: ${response.type}`)
+      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}`
+      )
+      throw new ProtocolMismatchError(IPC_PROTOCOL_VERSION, response.payload.protocolVersion)
+    }
+
+    this.attached = true
+
+    logDebug('backend.remote.attach.success', {
+      activeTabId: response.payload.activeTabId,
+      sessionId: options.sessionId,
+      tabs: response.payload.tabs.length,
+    })
+
+    return response.payload
+  }
+
+  createSession(options: {
+    tabId: string
+    assistant: AssistantId
+    title: string
+    command: string
+    args?: string[]
+    cols: number
+    rows: number
+    cwd?: string
+  }): void {
+    if (!this.attached) {
+      logDebug('backend.remote.skipCreateBeforeAttach', { tabId: options.tabId })
+      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)
+    )
+  }
+
+  write(tabId: string, input: string): void {
+    if (!this.attached) {
+      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 },
+      type: 'write',
+    }).catch((error) => this.reportCommandError('write', error, tabId))
+  }
+
+  scrollViewport(tabId: string, deltaLines: number): void {
+    if (!this.attached) {
+      return
+    }
+    logDebug('backend.remote.scroll', { deltaLines, sessionId: this.currentSessionId, tabId })
+    void this.sendExpectOk({
+      id: crypto.randomUUID(),
+      payload: { deltaLines, tabId },
+      type: 'scroll',
+    }).catch((error) => this.reportCommandError('scroll', error, tabId))
+  }
+
+  scrollViewportToBottom(tabId: string): void {
+    if (!this.attached) {
+      return
+    }
+    logDebug('backend.remote.scrollToBottom', { sessionId: this.currentSessionId, tabId })
+    void this.sendExpectOk({
+      id: crypto.randomUUID(),
+      payload: { tabId },
+      type: 'scrollToBottom',
+    }).catch((error) => this.reportCommandError('scrollToBottom', error, tabId))
+  }
+
+  setActiveTab(tabId: string | null): void {
+    if (!this.attached) {
+      return
+    }
+    logDebug('backend.remote.setActiveTab', { sessionId: this.currentSessionId, tabId })
+    void this.sendExpectOk({
+      id: crypto.randomUUID(),
+      payload: { tabId },
+      type: 'setActiveTab',
+    }).catch((error) => this.reportCommandError('setActiveTab', error))
+  }
+
+  resizeAll(cols: number, rows: number): void {
+    if (!this.attached) {
+      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 },
+      type: 'resizeClient',
+    }).catch((error) => this.reportCommandError('resizeClient', error))
+  }
+
+  resizeTab(tabId: string, cols: number, rows: number): void {
+    if (!this.attached) {
+      return
+    }
+    logDebug('backend.remote.resizeTab', { cols, rows, sessionId: this.currentSessionId, tabId })
+    void this.sendExpectOk({
+      id: crypto.randomUUID(),
+      payload: { cols, rows, tabId },
+      type: 'resizeTab',
+    }).catch((error) => this.reportCommandError('resizeTab', error, tabId))
+  }
+
+  disposeSession(tabId: string): void {
+    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)
+    )
+  }
+
+  disposeAll(): void {
+    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)
+    )
+  }
+
+  async destroy(keepSessions = true): Promise<void> {
+    logDebug('backend.remote.destroy', { keepSessions })
+    if (!keepSessions) {
+      this.disposeAll()
+    }
+    this.resetConnection('Remote backend destroyed')
+  }
+}

package/src/session-backend/types.ts

@@ -0,0 +1,47 @@
+import type { EventEmitter } from 'node:events'
+
+import type {
+  TabSession,
+  TerminalModeState,
+  TerminalSnapshot,
+  WorkspaceSnapshotV1,
+} from '../state/types'
+
+export type SessionBackendEvents = {
+  render: [tabId: string, viewport: TerminalSnapshot, terminalModes: TerminalModeState]
+  exit: [tabId: string, exitCode: number]
+  error: [tabId: string, message: string]
+}
+
+export interface BackendAttachResult {
+  tabs: TabSession[]
+  activeTabId: string | null
+}
+
+export interface SessionBackend extends EventEmitter<SessionBackendEvents> {
+  attach(options: {
+    sessionId: string
+    cols: number
+    rows: number
+    workspaceSnapshot?: WorkspaceSnapshotV1
+  }): Promise<BackendAttachResult | null>
+  createSession(options: {
+    tabId: string
+    assistant: TabSession['assistant']
+    title: string
+    command: string
+    args?: string[]
+    cols: number
+    rows: number
+    cwd?: string
+  }): void
+  write(tabId: string, input: string): void
+  scrollViewport(tabId: string, deltaLines: number): void
+  scrollViewportToBottom(tabId: string): void
+  setActiveTab(tabId: string | null): void
+  resizeAll(cols: number, rows: number): void
+  resizeTab(tabId: string, cols: number, rows: number): void
+  disposeSession(tabId: string): void
+  disposeAll(): void
+  destroy(keepSessions?: boolean): Promise<void> | void
+}

package/src/state/app-store.ts

@@ -0,0 +1,19 @@
+import { useStore } from 'zustand'
+import { createStore } from 'zustand/vanilla'
+
+import type { AppAction, AppState } from './types'
+
+import { appReducer, createInitialState } from './store'
+
+export interface AppStore extends AppState {
+  dispatch: (action: AppAction) => void
+}
+
+export const appStore = createStore<AppStore>((set) => ({
+  ...createInitialState(),
+  dispatch: (action: AppAction) => set((state) => appReducer(state, action)),
+}))
+
+export function useAppStore<T>(selector: (state: AppStore) => T): T {
+  return useStore(appStore, selector)
+}