@brimveyn/aimux 1.1.0

package/src/app.tsx

@@ -0,0 +1,247 @@
+import { getDefaultKeymapConfig } from '@brimveyn/aimux-config'
+import { useKeyboard, useRenderer, useTerminalDimensions } from '@opentui/react'
+import { useCallback, useLayoutEffect, useMemo, useReducer, useRef, useState } from 'react'
+
+import type { KeyChord } from './input/keymap/key-chord'
+import type { TrieBinding } from './input/keymap/trie'
+import type { KeyResult, ModeContext, ModeId } from './input/modes/types'
+import type { SessionBackend } from './session-backend/types'
+import type { ThemeId } from './ui/themes'
+
+import { executeSideEffect, type SideEffectContext } from './app-runtime/side-effects'
+import { useBackendRuntime } from './app-runtime/use-backend-runtime'
+import { useDirectorySearch } from './app-runtime/use-directory-search'
+import { useMouseHandlers } from './app-runtime/use-mouse-handlers'
+import { useRendererBindings } from './app-runtime/use-renderer-bindings'
+import { useTerminalResize } from './app-runtime/use-terminal-resize'
+import { useWorkspaceAutosave } from './app-runtime/use-workspace-autosave'
+import { loadConfig } from './config'
+import { deriveModeId } from './input/modes/bridge'
+import { registerAllModes } from './input/modes/handlers'
+import { getHandler, transitionTo } from './input/modes/registry'
+import { type TerminalContentOrigin } from './input/raw-input-handler'
+import { appStore } from './state/app-store'
+import { loadSessionCatalog } from './state/session-catalog'
+import { loadSnippetCatalog } from './state/snippet-catalog'
+import { appReducer, createInitialState } from './state/store'
+import { RootView } from './ui/root'
+import { applyTheme } from './ui/theme'
+
+const keymapHandlers = registerAllModes(getDefaultKeymapConfig())
+
+const WORKSPACE_SAVE_DEBOUNCE_MS = 250
+
+export function App({ backend }: { backend: SessionBackend }) {
+  const renderer = useRenderer()
+  const dimensions = useTerminalDimensions()
+  const [themeId, setThemeId] = useState<ThemeId>(() => {
+    const config = loadConfig()
+    if (config.themeId) {
+      applyTheme(config.themeId)
+    }
+    return config.themeId ?? 'aimux'
+  })
+  const [state, dispatch] = useReducer(appReducer, undefined, () => {
+    const { customCommands, gitPanelRatio, gitPanelVisible } = loadConfig()
+    return createInitialState(customCommands, loadSessionCatalog(), loadSnippetCatalog(), true, {
+      gitPanelRatio,
+      gitPanelVisible,
+    })
+  })
+
+  useLayoutEffect(() => {
+    appStore.setState(state)
+  }, [state])
+
+  const resizingRef = useRef(false)
+  const layoutRef = useRef(state.layout)
+  layoutRef.current = state.layout
+  const activeTab = useMemo(
+    () => state.tabs.find((tab) => tab.id === state.activeTabId),
+    [state.activeTabId, state.tabs]
+  )
+  const currentSession = useMemo(
+    () => state.sessions.find((session) => session.id === state.currentSessionId),
+    [state.currentSessionId, state.sessions]
+  )
+  const activeMouseForwardingEnabled = activeTab?.terminalModes.mouseTrackingMode !== 'none'
+  const activeLocalScrollbackEnabled =
+    !!activeTab && !activeMouseForwardingEnabled && !activeTab.terminalModes.isAlternateBuffer
+
+  const focusModeRef = useRef(state.focusMode)
+  focusModeRef.current = state.focusMode
+
+  const activeTabIdRef = useRef(state.activeTabId)
+  activeTabIdRef.current = state.activeTabId
+  const activeTabRef = useRef(activeTab)
+  activeTabRef.current = activeTab
+
+  const stateRef = useRef(state)
+  stateRef.current = state
+
+  const contentOriginRef = useRef<TerminalContentOrigin>({ cols: 0, rows: 0, x: 0, y: 0 })
+  const currentSessionWorkspaceSnapshot = currentSession?.workspaceSnapshot
+
+  const { clearIdleTimer, clearStartupGrace, startStartupGrace } = useBackendRuntime({
+    activeTabId: state.activeTabId,
+    backend,
+    currentSessionId: state.currentSessionId,
+    currentSessionWorkspaceSnapshot,
+    dispatch,
+    layoutRef,
+    resizingRef,
+  })
+
+  useWorkspaceAutosave(state, WORKSPACE_SAVE_DEBOUNCE_MS)
+  useDirectorySearch(state.modal, dispatch)
+
+  const terminalSize = useTerminalResize({
+    backend,
+    contentOriginRef,
+    dimensions,
+    dispatch,
+    resizingRef,
+    state,
+  })
+
+  const {
+    handlePaneActivate,
+    handleSeparatorDrag,
+    handleSeparatorDragEnd,
+    handleSeparatorDragStart,
+    handleSplitResize,
+    handleTerminalClick,
+    handleTerminalMouseEvent,
+    handleTerminalScrollEvent,
+  } = useMouseHandlers({
+    activeLocalScrollbackEnabled,
+    activeMouseForwardingEnabled,
+    backend,
+    dispatch,
+    renderer,
+    state,
+  })
+
+  // Stable ref to processKeyResult — populated after it is defined below.
+  // Allows handleTerminalShortcut (a stable callback) to reach the latest closure.
+  const processKeyResultRef = useRef<(result: KeyResult, modeId: ModeId) => void>(() => {})
+
+  const handleTerminalShortcut = useCallback((chord: KeyChord): boolean => {
+    const terminalHandler = keymapHandlers.find((h) => h.id === 'terminal-input')
+    if (!terminalHandler) return false
+    const ctx: ModeContext = { state: stateRef.current }
+    const result = terminalHandler.handleChord(chord, ctx)
+    if (!result) return false
+    processKeyResultRef.current(result, 'terminal-input')
+    return true
+  }, [])
+
+  useRendererBindings({
+    activeTabId: state.activeTabId,
+    activeTabIdRef,
+    activeTabRef,
+    activeTabViewportY: activeTab?.viewport?.viewportY ?? null,
+    backend,
+    dispatch,
+    focusMode: state.focusMode,
+    focusModeRef,
+    handleTerminalShortcut,
+    renderer,
+  })
+
+  const sideEffectCtx: SideEffectContext = {
+    activeTab,
+    backend,
+    clearIdleTimer,
+    clearStartupGrace,
+    dispatch,
+    getCurrentSessionProjectPath: () => {
+      if (!state.currentSessionId) return undefined
+      return state.sessions.find((s) => s.id === state.currentSessionId)?.projectPath
+    },
+    renderer,
+    setThemeId,
+    startStartupGrace,
+    state,
+    themeId,
+  }
+
+  function processKeyResult(result: KeyResult, modeId: ModeId): void {
+    for (const action of result.actions) {
+      dispatch(action)
+    }
+
+    if (result.transition) {
+      const transResult = transitionTo(modeId, result.transition, { state })
+      for (const action of transResult.actions) {
+        dispatch(action)
+      }
+      for (const effect of transResult.effects) {
+        executeSideEffect(effect, sideEffectCtx)
+      }
+    }
+
+    for (const effect of result.effects) {
+      executeSideEffect(effect, sideEffectCtx)
+    }
+  }
+
+  // Keep the ref pointing at the latest closure so stable callbacks can invoke it
+  processKeyResultRef.current = processKeyResult
+
+  useLayoutEffect(() => {
+    for (const handler of keymapHandlers) {
+      handler.setTimeoutCallback((binding: TrieBinding) => {
+        const currentState = stateRef.current
+        const modeId = deriveModeId(currentState)
+        if (modeId !== handler.id) return // mode changed during timeout
+        const ctx: ModeContext = { state: currentState }
+        const result = typeof binding.result === 'function' ? binding.result(ctx) : binding.result
+        if (result) processKeyResultRef.current(result, modeId)
+      })
+
+      handler.setPendingChangeCallback((chords) => {
+        dispatch({ chords, type: 'set-pending-chords' })
+      })
+    }
+  }, []) // eslint-disable-line react-hooks/exhaustive-deps
+
+  useKeyboard((key) => {
+    // Global quit: Ctrl+C in any mode except terminal-input
+    if (key.ctrl && key.name === 'c' && state.focusMode !== 'terminal-input') {
+      key.preventDefault()
+      executeSideEffect({ state, type: 'quit' }, sideEffectCtx)
+      return
+    }
+
+    const modeId = deriveModeId(state)
+    const handler = getHandler(modeId)
+    if (!handler) return
+
+    const ctx: ModeContext = { state }
+    const result = handler.handleKey(key, ctx)
+    if (!result) return
+
+    key.preventDefault()
+    processKeyResult(result, modeId)
+  })
+
+  return (
+    <RootView
+      themeId={themeId}
+      contentOrigin={contentOriginRef.current}
+      mouseForwardingEnabled={activeMouseForwardingEnabled}
+      localScrollbackEnabled={activeLocalScrollbackEnabled}
+      onTerminalMouseEvent={handleTerminalMouseEvent}
+      onTerminalScrollEvent={handleTerminalScrollEvent}
+      onTerminalClick={handleTerminalClick}
+      onPaneActivate={handlePaneActivate}
+      onSplitResize={handleSplitResize}
+      onSeparatorDragStart={handleSeparatorDragStart}
+      onSeparatorDrag={handleSeparatorDrag}
+      onSeparatorDragEnd={handleSeparatorDragEnd}
+      terminalCols={terminalSize.cols}
+      terminalRows={terminalSize.rows}
+    />
+  )
+}

package/src/config/loader.ts

@@ -0,0 +1,36 @@
+import { type AimuxUserConfig, resolveConfig, type ResolvedConfig } from '@brimveyn/aimux-config'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import { logDebug } from '../debug/input-log'
+
+const CONFIG_FILENAMES = ['aimux.config.ts', 'aimux.config.js']
+
+/**
+ * Load the user's aimux.config.ts (or .js), merge with defaults, and return
+ * a resolved config. Falls back to pure defaults if no config file exists.
+ */
+export async function loadUserConfig(): Promise<ResolvedConfig> {
+  const configDir = join(homedir(), '.config', 'aimux')
+
+  for (const filename of CONFIG_FILENAMES) {
+    const configPath = join(configDir, filename)
+
+    try {
+      const file = Bun.file(configPath)
+      if (!(await file.exists())) continue
+
+      const mod = await import(configPath)
+      const userConfig: AimuxUserConfig = mod.default ?? mod
+
+      logDebug('config.user.loaded', { path: configPath })
+      return resolveConfig(userConfig)
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      logDebug('config.user.error', { error: message, path: configPath })
+      // Fall through to try next filename or use defaults
+    }
+  }
+
+  return resolveConfig({})
+}

package/src/config.ts

@@ -0,0 +1,146 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+import type { WorkspaceSnapshotV1 } from './state/types'
+
+import { logDebug } from './debug/input-log'
+import { isWorkspaceSnapshotV1 } from './state/validation'
+import { THEME_IDS, type ThemeId } from './ui/themes'
+
+export const CONFIG_PATH = join(process.env.HOME ?? '~', '.config', 'aimux.json')
+
+export interface AimuxConfig {
+  version: 2
+  customCommands: Record<string, string>
+  themeId?: ThemeId
+  gitPanelVisible?: boolean
+  gitPanelRatio?: number
+  workspaceSnapshot?: WorkspaceSnapshotV1
+}
+
+const DEFAULT_CONFIG: AimuxConfig = {
+  customCommands: {},
+  version: 2,
+}
+
+export interface ConfigLoadResult {
+  config: AimuxConfig
+  source: 'defaults' | 'file'
+  issues: string[]
+}
+
+function isThemeId(value: unknown): value is ThemeId {
+  return typeof value === 'string' && THEME_IDS.includes(value as ThemeId)
+}
+
+function isCustomCommandsRecord(value: unknown): value is Record<string, string> {
+  if (typeof value !== 'object' || value === null) {
+    return false
+  }
+
+  return Object.entries(value).every(
+    ([key, entryValue]) =>
+      typeof key === 'string' && key.length > 0 && typeof entryValue === 'string'
+  )
+}
+
+export function loadConfigResult(): ConfigLoadResult {
+  try {
+    if (!existsSync(CONFIG_PATH)) {
+      return { config: DEFAULT_CONFIG, issues: [], source: 'defaults' }
+    }
+
+    const raw = readFileSync(CONFIG_PATH, 'utf8')
+    const parsed = JSON.parse(raw) as {
+      version?: number
+      customCommands?: unknown
+      themeId?: unknown
+      gitPanelVisible?: unknown
+      gitPanelRatio?: unknown
+      workspaceSnapshot?: unknown
+    }
+
+    const issues: string[] = []
+
+    if (parsed.version !== undefined && parsed.version !== 2) {
+      issues.push(`unsupported config version ${String(parsed.version)}`)
+    }
+
+    if (parsed.customCommands !== undefined && !isCustomCommandsRecord(parsed.customCommands)) {
+      issues.push('ignored invalid customCommands')
+    }
+
+    if (parsed.themeId !== undefined && !isThemeId(parsed.themeId)) {
+      issues.push('ignored invalid themeId')
+    }
+
+    const validGitPanelVisible =
+      typeof parsed.gitPanelVisible === 'boolean' ? parsed.gitPanelVisible : undefined
+    if (parsed.gitPanelVisible !== undefined && validGitPanelVisible === undefined) {
+      issues.push('ignored invalid gitPanelVisible')
+    }
+
+    const validGitPanelRatio =
+      typeof parsed.gitPanelRatio === 'number' &&
+      Number.isFinite(parsed.gitPanelRatio) &&
+      parsed.gitPanelRatio > 0 &&
+      parsed.gitPanelRatio < 1
+        ? parsed.gitPanelRatio
+        : undefined
+    if (parsed.gitPanelRatio !== undefined && validGitPanelRatio === undefined) {
+      issues.push('ignored invalid gitPanelRatio')
+    }
+
+    if (
+      parsed.workspaceSnapshot !== undefined &&
+      !isWorkspaceSnapshotV1(parsed.workspaceSnapshot)
+    ) {
+      issues.push('ignored invalid workspaceSnapshot')
+    }
+
+    if (issues.length > 0) {
+      logDebug('config.load.validationIssue', { issues, path: CONFIG_PATH })
+    }
+
+    return {
+      config: {
+        customCommands: isCustomCommandsRecord(parsed.customCommands) ? parsed.customCommands : {},
+        gitPanelRatio: validGitPanelRatio,
+        gitPanelVisible: validGitPanelVisible,
+        themeId: isThemeId(parsed.themeId) ? parsed.themeId : undefined,
+        version: 2,
+        workspaceSnapshot: isWorkspaceSnapshotV1(parsed.workspaceSnapshot)
+          ? parsed.workspaceSnapshot
+          : undefined,
+      },
+      issues,
+      source: 'file',
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    logDebug('config.load.error', { error: message, path: CONFIG_PATH })
+    return {
+      config: DEFAULT_CONFIG,
+      issues: [`failed to load config: ${message}`],
+      source: 'defaults',
+    }
+  }
+}
+
+export function loadConfig(): AimuxConfig {
+  return loadConfigResult().config
+}
+
+export function saveConfig(config: AimuxConfig): boolean {
+  try {
+    mkdirSync(dirname(CONFIG_PATH), { recursive: true })
+    writeFileSync(CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`)
+    return true
+  } catch (error) {
+    logDebug('config.save.error', {
+      error: error instanceof Error ? error.message : String(error),
+      path: CONFIG_PATH,
+    })
+    return false
+  }
+}

package/src/daemon/daemon.ts

@@ -0,0 +1,236 @@
+import { createServer, type Socket } from 'node:net'
+
+import { logDebug } from '../debug/input-log'
+import {
+  type ClientRequest,
+  encodeMessage,
+  IPC_PROTOCOL_VERSION,
+  MessageDecoder,
+  parseClientRequest,
+  type ServerEvent,
+  type ServerResponse,
+} from '../ipc/protocol'
+import { findDaemonPid } from '../platform/daemon-control'
+import {
+  getDaemonSocketPath,
+  removeDaemonSocketIfExists,
+  tightenDaemonSocketPermissions,
+} from './runtime-paths'
+import { SessionManager } from './session-manager'
+
+function send(socket: Socket, message: ServerResponse | ServerEvent): void {
+  socket.write(encodeMessage(message))
+}
+
+function sendOk(socket: Socket, id: string): void {
+  send(socket, { id, payload: {}, type: 'ok' })
+}
+
+function requireSession(socket: Socket, attachedSessions: Map<Socket, string>): string {
+  const sessionId = attachedSessions.get(socket)
+  if (!sessionId) {
+    throw new Error('No session attached')
+  }
+  return sessionId
+}
+
+export async function runDaemon(): Promise<void> {
+  const socketPath = getDaemonSocketPath()
+  logDebug('daemon.start', { pid: process.pid, socketPath })
+
+  const existingPid = await findDaemonPid(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 sockets = new Set<Socket>()
+  const attachedSessions = new Map<Socket, string>()
+
+  sessionManager.on('render', (sessionId, tabId, viewport, terminalModes) => {
+    const event: ServerEvent = { payload: { tabId, terminalModes, viewport }, type: 'tabRender' }
+    for (const socket of sockets) {
+      if (attachedSessions.get(socket) === sessionId) {
+        send(socket, event)
+      }
+    }
+  })
+  sessionManager.on('exit', (sessionId, tabId, exitCode) => {
+    const event: ServerEvent = { payload: { exitCode, tabId }, type: 'tabExit' }
+    for (const socket of sockets) {
+      if (attachedSessions.get(socket) === sessionId) {
+        send(socket, event)
+      }
+    }
+  })
+  sessionManager.on('error', (sessionId, tabId, message) => {
+    const event: ServerEvent = { payload: { message, tabId }, type: 'tabError' }
+    for (const socket of sockets) {
+      if (attachedSessions.get(socket) === sessionId) {
+        send(socket, event)
+      }
+    }
+  })
+
+  const server = createServer((socket) => {
+    logDebug('daemon.client.connected')
+    sockets.add(socket)
+    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)
+                }
+                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 })
+            send(socket, { id: message.id, payload: { message: errorMessage }, 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')
+      sockets.delete(socket)
+      attachedSessions.delete(socket)
+    })
+    socket.on('error', () => {
+      logDebug('daemon.client.error')
+      sockets.delete(socket)
+      attachedSessions.delete(socket)
+    })
+  })
+
+  await new Promise<void>((resolve, reject) => {
+    server.once('error', reject)
+    server.listen(socketPath, () => resolve())
+  })
+  tightenDaemonSocketPermissions(socketPath)
+  logDebug('daemon.listening', { socketPath })
+
+  const gracefulShutdown = (signal: string) => {
+    logDebug(`daemon.${signal}`)
+    sessionManager.disposeAll()
+    server.close()
+    process.exit(0)
+  }
+
+  process.on('SIGTERM', () => gracefulShutdown('sigterm'))
+  process.on('SIGINT', () => gracefulShutdown('sigint'))
+
+  process.on('uncaughtException', (error) => {
+    logDebug('daemon.uncaughtException', { error: error.message, stack: error.stack })
+    sessionManager.disposeAll()
+    server.close()
+    process.exit(1)
+  })
+
+  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)
+  })
+
+  await new Promise<void>(() => {
+    // Keep the daemon process alive until it is terminated.
+  })
+}