@brimveyn/aimux 1.1.0

package/src/platform/project-search.ts

@@ -0,0 +1,75 @@
+import { $ } from 'bun'
+import { stat } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+
+import type { DirectoryResult } from '../state/types'
+
+import { logDebug } from '../debug/input-log'
+
+export async function searchProjectDirectories(query: string): Promise<DirectoryResult[]> {
+  if (!query.trim()) {
+    return []
+  }
+
+  const home = homedir()
+
+  try {
+    // Step 1: Find all git repos (nothrow: find exits 1 on macOS permission errors)
+    const gitResult =
+      await $`find ${home} -maxdepth 4 -name .git -not -path '*/node_modules/*' -not -path '*/target/*' -not -path '*/dist/*' 2>/dev/null`
+        .quiet()
+        .nothrow()
+    const repoPaths = gitResult
+      .text()
+      .trim()
+      .split('\n')
+      .filter((line) => line.length > 0)
+      .map((p) => p.replace(/\/\.git$/, ''))
+
+    // Step 2: Find workspace parents (dirs with 2+ child repos that aren't repos themselves)
+    const repoSet = new Set(repoPaths)
+    const parentCount = new Map<string, number>()
+    for (const repo of repoPaths) {
+      const parent = dirname(repo)
+      if (!repoSet.has(parent)) {
+        parentCount.set(parent, (parentCount.get(parent) ?? 0) + 1)
+      }
+    }
+    const workspacePaths = [...parentCount.entries()]
+      .filter(([, count]) => count >= 2)
+      .map(([p]) => p)
+    const workspaceSet = new Set(workspacePaths)
+
+    // Step 3: Combine and fuzzy filter
+    const allPaths = [...repoPaths, ...workspacePaths].join('\n')
+    const filtered =
+      await $`printf '%s' ${allPaths} | fzf --filter=${query} --no-sort | head -50`.quiet()
+    const resultPaths = filtered
+      .text()
+      .trim()
+      .split('\n')
+      .filter((line) => line.length > 0)
+
+    // Step 4: Classify each result (shortest paths first, limit to 10)
+    resultPaths.sort((a, b) => a.length - b.length)
+    resultPaths.splice(10)
+    return Promise.all(
+      resultPaths.map(async (path) => {
+        if (workspaceSet.has(path)) {
+          return { path, type: 'workspace' as const }
+        }
+        const gitPath = join(path, '.git')
+        const st = await stat(gitPath).catch(() => null)
+        const type = st !== null && st.isFile() ? 'worktree' : 'git-repo'
+        return { path, type } as const
+      })
+    )
+  } catch (error) {
+    logDebug('platform.projectSearch.error', {
+      error: error instanceof Error ? error.message : String(error),
+      query,
+    })
+    return []
+  }
+}

package/src/pty/command-registry.ts

@@ -0,0 +1,69 @@
+import type { AssistantId } from '../state/types'
+
+export interface AssistantOption {
+  id: AssistantId
+  label: string
+  command: string
+  description: string
+}
+
+const DEFAULT_SHELL = process.env.SHELL || 'sh'
+const SHELL_NAME = DEFAULT_SHELL.split('/').pop() ?? 'shell'
+
+export const ASSISTANT_OPTIONS: AssistantOption[] = [
+  {
+    command: 'claude',
+    description: 'Anthropic Claude CLI',
+    id: 'claude',
+    label: 'Claude',
+  },
+  {
+    command: 'codex',
+    description: 'OpenAI Codex CLI',
+    id: 'codex',
+    label: 'Codex',
+  },
+  {
+    command: 'opencode',
+    description: 'OpenCode CLI',
+    id: 'opencode',
+    label: 'OpenCode',
+  },
+  {
+    command: DEFAULT_SHELL,
+    description: `Plain terminal (${SHELL_NAME})`,
+    id: 'terminal',
+    label: 'Terminal',
+  },
+]
+
+export function getAssistantOption(index: number): AssistantOption {
+  const option = ASSISTANT_OPTIONS[index] ?? ASSISTANT_OPTIONS[0]
+  if (!option) {
+    throw new Error('Assistant options are not configured.')
+  }
+
+  return option
+}
+
+export function getAllAssistantOptions(customCommands: Record<string, string>): AssistantOption[] {
+  const builtinIds = new Set(ASSISTANT_OPTIONS.map((o) => o.id))
+  const customOptions: AssistantOption[] = Object.entries(customCommands)
+    .filter(([id]) => !builtinIds.has(id))
+    .map(([id, command]) => ({
+      command,
+      description: `Custom (${command})`,
+      id,
+      label: id.charAt(0).toUpperCase() + id.slice(1),
+    }))
+  return [...ASSISTANT_OPTIONS, ...customOptions]
+}
+
+export function isCommandAvailable(command: string): boolean {
+  return Bun.which(command) !== null
+}
+
+export function parseCommand(commandString: string): { executable: string; args: string[] } {
+  const parts = commandString.trim().split(/\s+/).filter(Boolean)
+  return { args: parts.slice(1), executable: parts[0] ?? '' }
+}

package/src/pty/pty-manager.ts

@@ -0,0 +1,268 @@
+import { Terminal as XTerm } from '@xterm/headless'
+import { type IPty, spawn } from 'bun-pty'
+import { EventEmitter } from 'node:events'
+
+import type { TerminalModeState, TerminalSnapshot } from '../state/types'
+
+import { areTerminalSnapshotsEqual, snapshotTerminal } from './terminal-snapshot'
+
+type PtyManagerEvents = {
+  render: [tabId: string, viewport: TerminalSnapshot, terminalModes: TerminalModeState]
+  exit: [tabId: string, exitCode: number]
+  error: [tabId: string, message: string]
+}
+
+interface SessionHandle {
+  tabId: string
+  pty: IPty
+  emulator: XTerm
+  lastSnapshot?: TerminalSnapshot
+  lastTerminalModes?: TerminalModeState
+  alternateScrollMode: boolean
+  cursorVisible: boolean
+  pendingModeSequence: string
+  pendingWrites: number
+  pendingExitCode: number | null
+}
+
+const ESC = '\x1b'
+const PRIVATE_MODE_RE = new RegExp(`${ESC}\\[\\?([0-9;]+)([hl])`, 'g')
+
+function getPendingModeSequence(sequence: string): string {
+  const escapeIndex = sequence.lastIndexOf('\x1b')
+  if (escapeIndex === -1) {
+    return ''
+  }
+
+  const suffix = sequence.slice(escapeIndex)
+  return new RegExp(`^${ESC}(?:\\[\\??[0-9;]*)?$`).test(suffix) ? suffix : ''
+}
+
+function trackPrivateModes(
+  alternateScrollMode: boolean,
+  cursorVisible: boolean,
+  pendingSequence: string,
+  data: string
+): {
+  alternateScrollMode: boolean
+  cursorVisible: boolean
+  pendingSequence: string
+} {
+  const sequence = `${pendingSequence}${data}`
+  let nextAlternateScrollMode = alternateScrollMode
+  let nextCursorVisible = cursorVisible
+  for (const match of sequence.matchAll(PRIVATE_MODE_RE)) {
+    const parameters = match[1]?.split(';') ?? []
+    if (parameters.includes('1007')) {
+      nextAlternateScrollMode = match[2] === 'h'
+    }
+    if (parameters.includes('25')) {
+      nextCursorVisible = match[2] === 'h'
+    }
+  }
+
+  return {
+    alternateScrollMode: nextAlternateScrollMode,
+    cursorVisible: nextCursorVisible,
+    pendingSequence: getPendingModeSequence(sequence),
+  }
+}
+
+function getTerminalModes(emulator: XTerm, alternateScrollMode: boolean): TerminalModeState {
+  return {
+    alternateScrollMode,
+    bracketedPasteMode: emulator.modes.bracketedPasteMode,
+    isAlternateBuffer: emulator.buffer.active === emulator.buffer.alternate,
+    mouseTrackingMode: emulator.modes.mouseTrackingMode,
+    sendFocusMode: emulator.modes.sendFocusMode,
+  }
+}
+
+export class PtyManager extends EventEmitter<PtyManagerEvents> {
+  private sessions = new Map<string, SessionHandle>()
+
+  private emitRenderIfChanged(session: SessionHandle): void {
+    const nextSnapshot = snapshotTerminal(session.emulator, session.cursorVisible)
+    const nextTerminalModes = getTerminalModes(session.emulator, session.alternateScrollMode)
+    const snapshotChanged = !areTerminalSnapshotsEqual(session.lastSnapshot, nextSnapshot)
+    const modesChanged =
+      !session.lastTerminalModes ||
+      session.lastTerminalModes.mouseTrackingMode !== nextTerminalModes.mouseTrackingMode ||
+      session.lastTerminalModes.sendFocusMode !== nextTerminalModes.sendFocusMode ||
+      session.lastTerminalModes.alternateScrollMode !== nextTerminalModes.alternateScrollMode ||
+      session.lastTerminalModes.isAlternateBuffer !== nextTerminalModes.isAlternateBuffer ||
+      session.lastTerminalModes.bracketedPasteMode !== nextTerminalModes.bracketedPasteMode
+
+    if (!snapshotChanged && !modesChanged) {
+      return
+    }
+
+    session.lastSnapshot = nextSnapshot
+    session.lastTerminalModes = nextTerminalModes
+    this.emit('render', session.tabId, nextSnapshot, nextTerminalModes)
+  }
+
+  private finalizeSession(session: SessionHandle, exitCode: number): void {
+    const current = this.sessions.get(session.tabId)
+    if (current !== session) {
+      return
+    }
+
+    this.sessions.delete(session.tabId)
+    this.emitRenderIfChanged(session)
+    session.emulator.dispose()
+    this.emit('exit', session.tabId, exitCode)
+  }
+
+  createSession(options: {
+    tabId: string
+    command: string
+    args?: string[]
+    cols: number
+    rows: number
+    cwd?: string
+  }): void {
+    this.disposeSession(options.tabId)
+
+    try {
+      const emulator = new XTerm({
+        allowProposedApi: true,
+        cols: options.cols,
+        rows: options.rows,
+        scrollback: 1000,
+      })
+
+      const pty = spawn(options.command, options.args ?? [], {
+        cols: options.cols,
+        cwd: options.cwd ?? process.cwd(),
+        env: {
+          ...process.env,
+          TERM: 'xterm-256color',
+        },
+        name: 'xterm-256color',
+        rows: options.rows,
+      })
+
+      const session: SessionHandle = {
+        alternateScrollMode: false,
+        cursorVisible: true,
+        emulator,
+        lastSnapshot: undefined,
+        lastTerminalModes: undefined,
+        pendingExitCode: null,
+        pendingModeSequence: '',
+        pendingWrites: 0,
+        pty,
+        tabId: options.tabId,
+      }
+
+      pty.onData((data) => {
+        const trackedModes = trackPrivateModes(
+          session.alternateScrollMode,
+          session.cursorVisible,
+          session.pendingModeSequence,
+          data
+        )
+        session.alternateScrollMode = trackedModes.alternateScrollMode
+        session.cursorVisible = trackedModes.cursorVisible
+        session.pendingModeSequence = trackedModes.pendingSequence
+        session.pendingWrites += 1
+        emulator.write(data, () => {
+          session.pendingWrites -= 1
+          this.emitRenderIfChanged(session)
+
+          if (session.pendingWrites === 0 && session.pendingExitCode !== null) {
+            this.finalizeSession(session, session.pendingExitCode)
+          }
+        })
+      })
+
+      pty.onExit(({ exitCode }) => {
+        const current = this.sessions.get(options.tabId)
+        if (!current || current.pty !== pty) {
+          return
+        }
+
+        if (session.pendingWrites > 0) {
+          session.pendingExitCode = exitCode
+          return
+        }
+
+        this.finalizeSession(session, exitCode)
+      })
+
+      this.sessions.set(options.tabId, session)
+      this.emitRenderIfChanged(session)
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      this.emit('error', options.tabId, `Failed to start session: ${message}`)
+    }
+  }
+
+  write(tabId: string, input: string): void {
+    this.sessions.get(tabId)?.pty.write(input)
+  }
+
+  scrollViewport(tabId: string, deltaLines: number): void {
+    const session = this.sessions.get(tabId)
+    if (!session) {
+      return
+    }
+
+    session.emulator.scrollLines(deltaLines)
+    this.emitRenderIfChanged(session)
+  }
+
+  scrollViewportToBottom(tabId: string): void {
+    const session = this.sessions.get(tabId)
+    if (!session) {
+      return
+    }
+
+    session.emulator.scrollToBottom()
+    this.emitRenderIfChanged(session)
+  }
+
+  resizeAll(cols: number, rows: number): void {
+    const safeCols = Math.max(20, cols)
+    const safeRows = Math.max(8, rows)
+
+    for (const session of this.sessions.values()) {
+      session.pty.resize(safeCols, safeRows)
+      session.emulator.resize(safeCols, safeRows)
+      this.emitRenderIfChanged(session)
+    }
+  }
+
+  resizeSession(tabId: string, cols: number, rows: number): void {
+    const session = this.sessions.get(tabId)
+    if (!session) {
+      return
+    }
+    const safeCols = Math.max(20, cols)
+    const safeRows = Math.max(8, rows)
+    session.pty.resize(safeCols, safeRows)
+    session.emulator.resize(safeCols, safeRows)
+    this.emitRenderIfChanged(session)
+  }
+
+  disposeSession(tabId: string): void {
+    const session = this.sessions.get(tabId)
+    if (!session) {
+      return
+    }
+
+    this.sessions.delete(tabId)
+    session.pty.kill()
+    session.emulator.dispose()
+  }
+
+  disposeAll(): void {
+    for (const session of this.sessions.values()) {
+      session.pty.kill()
+      session.emulator.dispose()
+    }
+
+    this.sessions.clear()
+  }
+}

package/src/pty/terminal-snapshot.ts

@@ -0,0 +1,210 @@
+import type { Terminal } from '@xterm/headless'
+
+import type { TerminalLine, TerminalSnapshot, TerminalSpan } from '../state/types'
+
+import { theme } from '../ui/theme'
+
+const ANSI_PALETTE = [
+  '#000000',
+  '#cd0000',
+  '#00cd00',
+  '#cdcd00',
+  '#0000ee',
+  '#cd00cd',
+  '#00cdcd',
+  '#e5e5e5',
+  '#7f7f7f',
+  '#ff0000',
+  '#00ff00',
+  '#ffff00',
+  '#5c5cff',
+  '#ff00ff',
+  '#00ffff',
+  '#ffffff',
+]
+
+function toHex(value: number): string {
+  return `#${value.toString(16).padStart(6, '0')}`
+}
+
+function paletteToHex(index: number): string {
+  if (index < ANSI_PALETTE.length) {
+    return ANSI_PALETTE[index] ?? ANSI_PALETTE[0] ?? '#000000'
+  }
+
+  if (index >= 232) {
+    const shade = 8 + (index - 232) * 10
+    return toHex((shade << 16) | (shade << 8) | shade)
+  }
+
+  const normalized = index - 16
+  const r = Math.floor(normalized / 36)
+  const g = Math.floor((normalized % 36) / 6)
+  const b = normalized % 6
+  const channel = [0, 95, 135, 175, 215, 255]
+
+  return toHex(((channel[r] ?? 0) << 16) | ((channel[g] ?? 0) << 8) | (channel[b] ?? 0))
+}
+
+function getColorHex(color: number, mode: 'rgb' | 'palette' | 'default'): string | undefined {
+  if (mode === 'default') {
+    return undefined
+  }
+
+  return mode === 'rgb' ? toHex(color) : paletteToHex(color)
+}
+
+function getColorMode(isRgb: boolean, isPalette: boolean): 'rgb' | 'palette' | 'default' {
+  if (isRgb) {
+    return 'rgb'
+  }
+
+  if (isPalette) {
+    return 'palette'
+  }
+
+  return 'default'
+}
+
+function pushSpan(spans: TerminalSpan[], span: TerminalSpan): void {
+  const previous = spans.at(-1)
+  if (
+    previous &&
+    previous.fg === span.fg &&
+    previous.bg === span.bg &&
+    previous.bold === span.bold &&
+    previous.italic === span.italic &&
+    previous.underline === span.underline &&
+    previous.cursor === span.cursor
+  ) {
+    previous.text += span.text
+    return
+  }
+
+  spans.push(span)
+}
+
+function buildLine(
+  terminal: Terminal,
+  lineIndex: number,
+  cursorColumn: number | null,
+  cursorVisible: boolean
+): TerminalLine {
+  const line = terminal.buffer.active.getLine(lineIndex)
+
+  if (!line) {
+    return { spans: [] }
+  }
+
+  const cell = terminal.buffer.active.getNullCell()
+  const spans: TerminalSpan[] = []
+
+  for (let column = 0; column < terminal.cols; column += 1) {
+    const current = line.getCell(column, cell)
+    if (!current || current.getWidth() === 0) {
+      continue
+    }
+
+    const text = current.getChars() || ' '
+    const fgMode = getColorMode(current.isFgRGB(), current.isFgPalette())
+    const bgMode = getColorMode(current.isBgRGB(), current.isBgPalette())
+
+    let fg = getColorHex(current.getFgColor(), fgMode)
+    let bg = getColorHex(current.getBgColor(), bgMode)
+
+    if (current.isInverse()) {
+      const resolvedFg = fg ?? theme.text
+      const resolvedBg = bg ?? theme.background
+      ;[fg, bg] = [resolvedBg, resolvedFg]
+    }
+
+    const isCursorCell = cursorVisible && cursorColumn === column
+    if (isCursorCell) {
+      const resolvedFg = fg ?? theme.text
+      const resolvedBg = bg ?? theme.background
+      ;[fg, bg] = [resolvedBg, resolvedFg]
+    }
+
+    pushSpan(spans, {
+      bg,
+      bold: current.isBold() ? true : undefined,
+      cursor: isCursorCell ? true : undefined,
+      fg,
+      italic: current.isItalic() ? true : undefined,
+      text,
+      underline: current.isUnderline() ? true : undefined,
+    })
+  }
+
+  return { spans }
+}
+
+export function snapshotTerminal(terminal: Terminal, cursorVisible = true): TerminalSnapshot {
+  const buffer = terminal.buffer.active
+  const startLine = buffer.viewportY
+  const cursorRow = buffer.cursorY
+  const cursorColumn = Math.min(buffer.cursorX, Math.max(terminal.cols - 1, 0))
+  const lines: TerminalLine[] = []
+
+  for (let row = 0; row < terminal.rows; row += 1) {
+    lines.push(
+      buildLine(terminal, startLine + row, row === cursorRow ? cursorColumn : null, cursorVisible)
+    )
+  }
+
+  return {
+    baseY: buffer.baseY,
+    cursorVisible,
+    lines,
+    viewportY: buffer.viewportY,
+  }
+}
+
+function areSpansEqual(left: TerminalSpan, right: TerminalSpan): boolean {
+  return (
+    left.text === right.text &&
+    left.fg === right.fg &&
+    left.bg === right.bg &&
+    left.bold === right.bold &&
+    left.italic === right.italic &&
+    left.underline === right.underline &&
+    left.cursor === right.cursor
+  )
+}
+
+function areLinesEqual(left: TerminalLine, right: TerminalLine): boolean {
+  if (left.spans.length !== right.spans.length) {
+    return false
+  }
+
+  return left.spans.every((span, index) => {
+    const other = right.spans[index]
+    return other ? areSpansEqual(span, other) : false
+  })
+}
+
+export function areTerminalSnapshotsEqual(
+  left?: TerminalSnapshot,
+  right?: TerminalSnapshot
+): boolean {
+  if (!left || !right) {
+    return left === right
+  }
+
+  if (left.lines.length !== right.lines.length) {
+    return false
+  }
+
+  if (
+    left.viewportY !== right.viewportY ||
+    left.baseY !== right.baseY ||
+    left.cursorVisible !== right.cursorVisible
+  ) {
+    return false
+  }
+
+  return left.lines.every((line, index) => {
+    const other = right.lines[index]
+    return other ? areLinesEqual(line, other) : false
+  })
+}

package/src/restart-daemon.ts

@@ -0,0 +1,28 @@
+import { getDaemonSocketPath, removeDaemonSocketIfExists } from './daemon/runtime-paths'
+import { findDaemonPid, killDaemon, spawnDetachedDaemon } from './platform/daemon-control'
+
+export async function runRestartDaemon(): Promise<number> {
+  const socketPath = getDaemonSocketPath()
+  const pid = await findDaemonPid(socketPath)
+
+  if (pid !== null) {
+    process.stdout.write(`Stopping daemon (pid ${pid})...\n`)
+    await killDaemon(pid)
+    process.stdout.write('Daemon stopped.\n')
+  } else {
+    process.stdout.write('No running daemon found.\n')
+  }
+
+  removeDaemonSocketIfExists()
+
+  process.stdout.write('Starting daemon...\n')
+  const ok = await spawnDetachedDaemon()
+
+  if (ok) {
+    process.stdout.write('Daemon started.\n')
+    return 0
+  }
+
+  process.stderr.write('Failed to start daemon.\n')
+  return 1
+}