@brimveyn/aimux 1.1.0

package/src/daemon/runtime-paths.ts

@@ -0,0 +1,69 @@
+import { chmodSync, constants, existsSync, lstatSync, mkdirSync, unlinkSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+function getRuntimeBaseDir(): string {
+  if (process.env.XDG_RUNTIME_DIR) {
+    return join(process.env.XDG_RUNTIME_DIR, 'aimux')
+  }
+
+  return join(process.env.HOME ?? '.', '.local', 'state', 'aimux')
+}
+
+export function ensureRuntimeDir(): string {
+  const dir = getRuntimeBaseDir()
+  mkdirSync(dir, { recursive: true })
+  try {
+    chmodSync(dir, 0o700)
+  } catch {
+    // best-effort permission tightening
+  }
+  return dir
+}
+
+export function getDaemonSocketPath(): string {
+  return join(ensureRuntimeDir(), 'daemon.sock')
+}
+
+export function ensureParentDir(filePath: string): void {
+  mkdirSync(dirname(filePath), { recursive: true })
+}
+
+export function tightenDaemonSocketPermissions(socketPath: string): void {
+  try {
+    chmodSync(socketPath, 0o600)
+  } catch {
+    // best-effort permission tightening
+  }
+}
+
+export function getDaemonSocketSecurityIssue(socketPath: string): string | null {
+  if (!existsSync(socketPath)) {
+    return 'socket missing'
+  }
+
+  try {
+    const stats = lstatSync(socketPath)
+    if (!stats.isSocket()) {
+      return 'path is not a socket'
+    }
+
+    if (typeof process.getuid === 'function' && stats.uid !== process.getuid()) {
+      return 'socket owner does not match current user'
+    }
+
+    if ((stats.mode & constants.S_IWGRP) !== 0 || (stats.mode & constants.S_IWOTH) !== 0) {
+      return 'socket is writable by group or others'
+    }
+
+    return null
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error)
+  }
+}
+
+export function removeDaemonSocketIfExists(): void {
+  const socketPath = getDaemonSocketPath()
+  if (existsSync(socketPath)) {
+    unlinkSync(socketPath)
+  }
+}

package/src/daemon/session-manager.ts

@@ -0,0 +1,109 @@
+import { EventEmitter } from 'node:events'
+
+import type { TerminalModeState, TerminalSnapshot, WorkspaceSnapshotV1 } from '../state/types'
+
+import { logDebug } from '../debug/input-log'
+import { SessionRegistry } from './session-registry'
+
+type SessionManagerEvents = {
+  render: [
+    sessionId: string,
+    tabId: string,
+    viewport: TerminalSnapshot,
+    terminalModes: TerminalModeState,
+  ]
+  exit: [sessionId: string, tabId: string, exitCode: number]
+  error: [sessionId: string, tabId: string, message: string]
+}
+
+export class SessionManager extends EventEmitter<SessionManagerEvents> {
+  private registries = new Map<string, SessionRegistry>()
+
+  private getOrCreateRegistry(sessionId: string): SessionRegistry {
+    const existing = this.registries.get(sessionId)
+    if (existing) {
+      return existing
+    }
+
+    const registry = new SessionRegistry()
+    registry.on('render', (tabId, viewport, terminalModes) => {
+      this.emit('render', sessionId, tabId, viewport, terminalModes)
+    })
+    registry.on('exit', (tabId, exitCode) => {
+      this.emit('exit', sessionId, tabId, exitCode)
+    })
+    registry.on('error', (tabId, message) => {
+      this.emit('error', sessionId, tabId, message)
+    })
+    this.registries.set(sessionId, registry)
+    return registry
+  }
+
+  attachSession(sessionId: string, snapshot?: WorkspaceSnapshotV1) {
+    logDebug('daemon.sessionManager.attachSession', {
+      hasSnapshot: !!snapshot,
+      sessionId,
+      snapshotTabs: snapshot?.tabs.length ?? 0,
+    })
+    return this.getOrCreateRegistry(sessionId).attachFromSnapshot(snapshot)
+  }
+
+  createTab(sessionId: string, options: Parameters<SessionRegistry['createSession']>[0]): void {
+    logDebug('daemon.sessionManager.createTab', {
+      command: options.command,
+      sessionId,
+      tabId: options.tabId,
+      title: options.title,
+    })
+    this.getOrCreateRegistry(sessionId).createSession(options)
+  }
+
+  write(sessionId: string, tabId: string, data: string): void {
+    this.getOrCreateRegistry(sessionId).write(tabId, data)
+  }
+
+  resize(sessionId: string, cols: number, rows: number): void {
+    this.getOrCreateRegistry(sessionId).resizeAll(cols, rows)
+  }
+
+  resizeTab(sessionId: string, tabId: string, cols: number, rows: number): void {
+    this.getOrCreateRegistry(sessionId).resizeTab(tabId, cols, rows)
+  }
+
+  scroll(sessionId: string, tabId: string, deltaLines: number): void {
+    this.getOrCreateRegistry(sessionId).scrollViewport(tabId, deltaLines)
+  }
+
+  scrollToBottom(sessionId: string, tabId: string): void {
+    this.getOrCreateRegistry(sessionId).scrollViewportToBottom(tabId)
+  }
+
+  setActiveTab(sessionId: string, tabId: string | null): void {
+    this.getOrCreateRegistry(sessionId).setActiveTab(tabId)
+  }
+
+  closeTab(sessionId: string, tabId: string): void {
+    this.getOrCreateRegistry(sessionId).closeTab(tabId)
+  }
+
+  disposeSession(sessionId: string): void {
+    logDebug('daemon.sessionManager.disposeSession', {
+      hadRegistry: this.registries.has(sessionId),
+      sessionId,
+    })
+    const registry = this.registries.get(sessionId)
+    if (!registry) {
+      return
+    }
+    registry.disposeAll()
+    this.registries.delete(sessionId)
+  }
+
+  disposeAll(): void {
+    logDebug('daemon.sessionManager.disposeAll', { sessionCount: this.registries.size })
+    for (const registry of this.registries.values()) {
+      registry.disposeAll()
+    }
+    this.registries.clear()
+  }
+}

package/src/daemon/session-registry.ts

@@ -0,0 +1,207 @@
+import { EventEmitter } from 'node:events'
+
+import type {
+  TabSession,
+  TerminalModeState,
+  TerminalSnapshot,
+  WorkspaceSnapshotV1,
+} from '../state/types'
+
+import { logDebug } from '../debug/input-log'
+import { PtyManager } from '../pty/pty-manager'
+import {
+  normalizeGroupedTabOrder,
+  restoreLayoutTrees,
+  restoreTabsFromWorkspace,
+} from '../state/session-persistence'
+import { createDefaultTerminalModes } from '../state/terminal-modes'
+
+type SessionRegistryEvents = {
+  render: [tabId: string, viewport: TerminalSnapshot, terminalModes: TerminalModeState]
+  exit: [tabId: string, exitCode: number]
+  error: [tabId: string, message: string]
+}
+
+export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
+  private readonly ptyManager = new PtyManager()
+  private tabs = new Map<string, TabSession>()
+  private activeTabId: string | null = null
+
+  constructor() {
+    super()
+    this.ptyManager.on('render', (tabId, viewport, terminalModes) => {
+      const tab = this.tabs.get(tabId)
+      if (!tab) {
+        return
+      }
+      tab.viewport = viewport
+      tab.terminalModes = terminalModes
+      if (tab.status === 'starting') {
+        tab.status = 'running'
+      }
+      logDebug('daemon.registry.render', { status: tab.status, tabId })
+      this.emit('render', tabId, viewport, terminalModes)
+    })
+    this.ptyManager.on('exit', (tabId, exitCode) => {
+      const tab = this.tabs.get(tabId)
+      if (!tab) {
+        return
+      }
+      tab.status = 'exited'
+      tab.exitCode = exitCode
+      tab.activity = undefined
+      logDebug('daemon.registry.exit', { exitCode, tabId })
+      this.emit('exit', tabId, exitCode)
+    })
+    this.ptyManager.on('error', (tabId, message) => {
+      const tab = this.tabs.get(tabId)
+      if (tab) {
+        tab.status = 'error'
+        tab.errorMessage = message
+        tab.activity = undefined
+      }
+      logDebug('daemon.registry.error', { message, tabId })
+      this.emit('error', tabId, message)
+    })
+  }
+
+  attachFromSnapshot(snapshot: WorkspaceSnapshotV1 | undefined): {
+    tabs: TabSession[]
+    activeTabId: string | null
+  } {
+    logDebug('daemon.registry.attach', {
+      existingTabs: this.tabs.size,
+      hasSnapshot: !!snapshot,
+      snapshotTabs: snapshot?.tabs.length ?? 0,
+    })
+    if (this.tabs.size === 0 && snapshot) {
+      const restoredTabs = restoreTabsFromWorkspace(snapshot)
+      for (const tab of restoredTabs) {
+        this.tabs.set(tab.id, tab)
+      }
+      this.activeTabId =
+        snapshot.activeTabId && restoredTabs.some((tab) => tab.id === snapshot.activeTabId)
+          ? snapshot.activeTabId
+          : (restoredTabs[0]?.id ?? null)
+    } else if (this.tabs.size > 0 && snapshot) {
+      for (const persisted of snapshot.tabs) {
+        const existing = this.tabs.get(persisted.id)
+        if (existing) {
+          existing.title = persisted.title
+        }
+      }
+      if (snapshot.activeTabId && this.tabs.has(snapshot.activeTabId)) {
+        this.activeTabId = snapshot.activeTabId
+      }
+    }
+
+    const tabs = this.listTabs()
+    if (!snapshot) {
+      return { activeTabId: this.activeTabId, tabs }
+    }
+
+    const { layoutTrees, tabGroupMap } = restoreLayoutTrees(snapshot, tabs)
+    const orderedSnapshotTabs = snapshot.tabs
+      .map((persistedTab) => this.tabs.get(persistedTab.id))
+      .filter((tab): tab is TabSession => tab !== undefined)
+    const normalizedTabs = normalizeGroupedTabOrder(orderedSnapshotTabs, layoutTrees, tabGroupMap)
+
+    return { activeTabId: this.activeTabId, tabs: normalizedTabs }
+  }
+
+  listTabs(): TabSession[] {
+    return [...this.tabs.values()]
+  }
+
+  createSession(options: {
+    tabId: string
+    assistant: TabSession['assistant']
+    title: string
+    command: string
+    args?: string[]
+    cols: number
+    rows: number
+    cwd?: string
+  }): void {
+    logDebug('daemon.registry.createSession', {
+      args: options.args ?? [],
+      assistant: options.assistant,
+      command: options.command,
+      tabId: options.tabId,
+      title: options.title,
+    })
+    const existing = this.tabs.get(options.tabId)
+    if (!existing) {
+      this.tabs.set(options.tabId, {
+        activity: 'idle',
+        assistant: options.assistant,
+        buffer: '',
+        command: [options.command, ...(options.args ?? [])].join(' '),
+        id: options.tabId,
+        status: 'starting',
+        terminalModes: createDefaultTerminalModes(),
+        title: options.title,
+      })
+    } else {
+      existing.status = 'starting'
+      existing.activity = 'idle'
+      existing.errorMessage = undefined
+      existing.exitCode = undefined
+      existing.viewport = undefined
+      existing.terminalModes = createDefaultTerminalModes()
+      existing.assistant = options.assistant
+      existing.title = options.title
+      existing.command = [options.command, ...(options.args ?? [])].join(' ')
+    }
+
+    this.activeTabId = options.tabId
+    this.ptyManager.createSession(options)
+  }
+
+  write(tabId: string, data: string): void {
+    this.ptyManager.write(tabId, data)
+  }
+
+  resizeAll(cols: number, rows: number): void {
+    this.ptyManager.resizeAll(cols, rows)
+  }
+
+  resizeTab(tabId: string, cols: number, rows: number): void {
+    this.ptyManager.resizeSession(tabId, cols, rows)
+  }
+
+  scrollViewport(tabId: string, deltaLines: number): void {
+    this.ptyManager.scrollViewport(tabId, deltaLines)
+  }
+
+  scrollViewportToBottom(tabId: string): void {
+    this.ptyManager.scrollViewportToBottom(tabId)
+  }
+
+  setActiveTab(tabId: string | null): void {
+    if (tabId === null) {
+      this.activeTabId = null
+      return
+    }
+
+    if (this.tabs.has(tabId)) {
+      this.activeTabId = tabId
+    }
+  }
+
+  closeTab(tabId: string): void {
+    logDebug('daemon.registry.closeTab', { tabId })
+    this.ptyManager.disposeSession(tabId)
+    this.tabs.delete(tabId)
+    if (this.activeTabId === tabId) {
+      this.activeTabId = this.listTabs()[0]?.id ?? null
+    }
+  }
+
+  disposeAll(): void {
+    logDebug('daemon.registry.disposeAll', { tabCount: this.tabs.size })
+    this.ptyManager.disposeAll()
+    this.tabs.clear()
+    this.activeTabId = null
+  }
+}

package/src/debug/input-log.ts

@@ -0,0 +1,29 @@
+import { appendFileSync } from 'node:fs'
+
+const INPUT_DEBUG_LOG_PATH = process.env.AIMUX_INPUT_DEBUG_LOG_PATH ?? '/tmp/aimux-input-debug.log'
+
+export function isInputDebugEnabled(): boolean {
+  const value = process.env.AIMUX_DEBUG_INPUT?.trim().toLowerCase()
+  return value === '1' || value === 'true' || value === 'yes' || value === 'on'
+}
+
+function serialize(value: unknown): string {
+  return JSON.stringify(value)
+}
+
+export function logInputDebug(event: string, details?: Record<string, unknown>): void {
+  if (!isInputDebugEnabled()) {
+    return
+  }
+
+  try {
+    const line = `${new Date().toISOString()} ${event}${details ? ` ${serialize(details)}` : ''}\n`
+    appendFileSync(INPUT_DEBUG_LOG_PATH, line)
+  } catch {
+    // Best-effort debug logging only.
+  }
+}
+
+export const logDebug = logInputDebug
+
+export { INPUT_DEBUG_LOG_PATH }

package/src/doctor.ts

@@ -0,0 +1,106 @@
+import { existsSync } from 'node:fs'
+
+import { CONFIG_PATH, loadConfigResult } from './config'
+import { ASSISTANT_OPTIONS, isCommandAvailable, parseCommand } from './pty/command-registry'
+
+export interface DoctorCheck {
+  name: string
+  ok: boolean
+  details: string
+}
+
+export interface DoctorReport {
+  checks: DoctorCheck[]
+}
+
+function formatStatus(ok: boolean): string {
+  return ok ? 'OK' : 'WARN'
+}
+
+function getConfigDetails(configResult: ReturnType<typeof loadConfigResult>): string {
+  if (configResult.issues.length > 0) {
+    return configResult.issues.join('; ')
+  }
+
+  if (existsSync(CONFIG_PATH)) {
+    return `loaded ${CONFIG_PATH}`
+  }
+
+  return `using defaults (${CONFIG_PATH} not found)`
+}
+
+function getAssistantDetails(
+  configuredCommand: string,
+  args: string[],
+  executable: string
+): string {
+  if (executable.length === 0) {
+    return 'empty command'
+  }
+
+  return args.length > 0 ? `${configuredCommand} (${args.length} args)` : configuredCommand
+}
+
+function getSummaryLine(failedChecks: DoctorCheck[]): string {
+  if (failedChecks.length === 0) {
+    return 'All core checks passed.'
+  }
+
+  return `${failedChecks.length} check(s) need attention before aimux will work reliably.`
+}
+
+export function buildDoctorReport(): DoctorReport {
+  const configResult = loadConfigResult()
+  const config = configResult.config
+  const checks: DoctorCheck[] = []
+
+  checks.push({
+    details: `${process.platform} ${process.arch}`,
+    name: 'platform',
+    ok: process.platform === 'darwin' || process.platform === 'linux',
+  })
+
+  checks.push({
+    details: Bun.version,
+    name: 'bun',
+    ok: typeof Bun.version === 'string' && Bun.version.length > 0,
+  })
+
+  checks.push({
+    details: getConfigDetails(configResult),
+    name: 'config',
+    ok: configResult.issues.length === 0,
+  })
+
+  for (const option of ASSISTANT_OPTIONS) {
+    const configuredCommand = config.customCommands[option.id] ?? option.command
+    const { args, executable } = parseCommand(configuredCommand)
+    checks.push({
+      details: getAssistantDetails(configuredCommand, args, executable),
+      name: `assistant:${option.id}`,
+      ok: executable.length > 0 && isCommandAvailable(executable),
+    })
+  }
+
+  return { checks }
+}
+
+export function formatDoctorReport(report: DoctorReport): string {
+  const lines = ['aimux doctor', '']
+
+  for (const check of report.checks) {
+    lines.push(`${formatStatus(check.ok).padEnd(4)} ${check.name} - ${check.details}`)
+  }
+
+  const failedChecks = report.checks.filter((check) => !check.ok)
+  lines.push('')
+  lines.push(getSummaryLine(failedChecks))
+
+  return lines.join('\n')
+}
+
+export function runDoctor(): number {
+  const report = buildDoctorReport()
+  process.stdout.write(`${formatDoctorReport(report)}\n`)
+  return report.checks.every((check) => check.ok) ? 0 : 1
+}

package/src/git/git-poller.ts

@@ -0,0 +1,49 @@
+import { useEffect } from 'react'
+
+import { appStore } from '../state/app-store'
+import { collectGitStatus } from './git-status'
+
+const BASE_INTERVAL_MS = 1000
+const MAX_INTERVAL_MS = 30_000
+
+interface Options {
+  enabled: boolean
+  projectPath: string | undefined
+}
+
+export function useGitPanelPolling({ enabled, projectPath }: Options): void {
+  useEffect(() => {
+    if (!enabled || !projectPath) return undefined
+
+    appStore.getState().dispatch({ type: 'git-panel-reset' })
+
+    let cancelled = false
+    let timer: ReturnType<typeof setTimeout> | null = null
+    let delay = BASE_INTERVAL_MS
+
+    const schedule = () => {
+      if (cancelled) return
+      timer = setTimeout(() => void tick(), delay)
+    }
+
+    const tick = async () => {
+      const result = await collectGitStatus(projectPath)
+      if (cancelled) return
+      if (result.kind === 'ok') {
+        appStore.getState().dispatch({ payload: result.payload, type: 'git-refresh-success' })
+        delay = BASE_INTERVAL_MS
+      } else {
+        appStore.getState().dispatch({ kind: result.error, type: 'git-refresh-error' })
+        delay = Math.min(delay * 2, MAX_INTERVAL_MS)
+      }
+      schedule()
+    }
+
+    void tick()
+
+    return () => {
+      cancelled = true
+      if (timer) clearTimeout(timer)
+    }
+  }, [enabled, projectPath])
+}