@k1e1n04/mav 0.1.0

package/src/agent-launch.ts

@@ -0,0 +1,43 @@
+import { randomUUID } from 'node:crypto'
+
+export const DEFAULT_CMDS: Record<string, { cmd: string; args: string[]; resumeArgs?: string[] }> = {
+  'claude-code': { cmd: 'claude', args: [] },
+  'codex': { cmd: 'codex', args: [] },
+  'gemini-cli': { cmd: 'gemini', args: [] },
+  'copilot': { cmd: 'copilot', args: [] },
+}
+
+export function getAgentDefaults(type: string): { cmd: string; args: string[]; resumeArgs?: string[] } {
+  return DEFAULT_CMDS[type] ?? { cmd: type, args: [] }
+}
+
+/** ツールごとのセッション管理方法を返す */
+export function resolveSessionArgs(
+  type: string,
+  baseArgs: string[],
+  savedSessionId: string | undefined,
+  hasSavedState: boolean,
+): { args: string[]; newSessionId?: string } {
+  switch (type) {
+    case 'claude-code':
+    case 'gemini-cli': {
+      if (savedSessionId) {
+        return { args: [...baseArgs, '--resume', savedSessionId] }
+      }
+      const id = randomUUID()
+      return { args: [...baseArgs, '--session-id', id], newSessionId: id }
+    }
+    case 'copilot': {
+      const id = savedSessionId ?? randomUUID()
+      return { args: [...baseArgs, '--session-id', id], newSessionId: savedSessionId ? undefined : id }
+    }
+    case 'codex': {
+      if (hasSavedState) {
+        return { args: ['resume', '--last'] }
+      }
+      return { args: baseArgs }
+    }
+    default:
+      return { args: baseArgs }
+  }
+}

package/src/agent.ts

@@ -0,0 +1,243 @@
+import { EventEmitter } from 'node:events'
+import * as pty from 'node-pty'
+import type { AgentConfig } from './config.js'
+import { getProcessCwd } from './process-cwd.js'
+
+export type SessionStatus = 'running' | 'idle' | 'done' | 'error'
+
+const counters: Record<string, number> = {}
+
+export class AgentSession extends EventEmitter {
+  private static readonly IDLE_TIMEOUT_MS = 1500
+  private static readonly DISPLAY_NAME_MAX_LENGTH = 25
+  private static readonly DISPLAY_NAME_MIN_LENGTH = 3
+  private static readonly CWD_POLL_INTERVAL_MS = 1000
+
+  readonly id: string
+  readonly type: string
+  readonly cmd: string
+  cwd: string
+  displayName: string
+  baseArgs: string[] = []
+  status: SessionStatus = 'running'
+  logBuffer: string[] = []
+  lastPrompt: string = ''
+  sessionId?: string
+
+  private ptyProcess: pty.IPty | undefined
+  private exited = false
+  private idleTimer: ReturnType<typeof setTimeout> | null = null
+  private cwdPollTimer: ReturnType<typeof setInterval> | null = null
+  private displayNameLocked = false
+  private initialInputBuffer = ''
+
+  constructor(config: AgentConfig, cols: number, rows: number) {
+    super()
+    counters[config.type] = (counters[config.type] ?? 0) + 1
+    this.id = `${config.type}#${counters[config.type]}`
+    this.type = config.type
+    this.cmd = config.cmd
+    this.cwd = config.cwd ?? process.cwd()
+    this.displayName = `${config.type} ${counters[config.type]}`
+
+    let proc: pty.IPty
+    try {
+      proc = pty.spawn(config.cmd, config.args, {
+        name: 'xterm-256color',
+        cols,
+        rows,
+        cwd: this.cwd,
+        env: process.env as Record<string, string>,
+      })
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      this.exited = true
+      this.status = 'error'
+      this.logBuffer.push(`Error: failed to spawn '${config.cmd}': ${msg}\r\n`)
+      process.nextTick(() => this.emit('exit', 1))
+      return
+    }
+
+    this.ptyProcess = proc
+
+    this.ptyProcess.onData((data) => {
+      this.updateCwdFromOutput(data)
+      this.appendLog(data)
+      this.setStatus('running')
+      this.scheduleIdleTimer()
+      this.emit('data', data)
+    })
+
+    this.ptyProcess.onExit(({ exitCode }) => {
+      this.clearIdleTimer()
+      this.clearCwdPollTimer()
+      this.setStatus(exitCode === 0 ? 'done' : 'error')
+      this.exited = true
+      this.ptyProcess = undefined
+      this.emit('exit', exitCode)
+    })
+
+    this.startCwdPolling()
+  }
+
+  /** 保存されたdisplayNameを復元し、以降の入力で上書きされないようにロックする */
+  restoreDisplayName(name: string): void {
+    this.displayName = name
+    this.displayNameLocked = true
+    this.emit('name', name)
+  }
+
+  write(data: string): void {
+    if (this.exited) return
+    this.updateDisplayNameFromInput(data)
+    this.ptyProcess?.write(data)
+  }
+
+  kill(): void {
+    if (this.exited) return
+    this.clearIdleTimer()
+    this.clearCwdPollTimer()
+    this.ptyProcess?.kill()
+  }
+
+  resize(cols: number, rows: number): void {
+    if (this.exited) return
+    this.ptyProcess?.resize(cols, rows)
+  }
+
+  private appendLog(chunk: string): void {
+    this.logBuffer.push(chunk)
+    if (this.logBuffer.length > 500) {
+      this.logBuffer.splice(0, this.logBuffer.length - 500)
+    }
+  }
+
+  private setStatus(nextStatus: SessionStatus): void {
+    if (this.status === nextStatus) {
+      return
+    }
+    this.status = nextStatus
+    this.emit('status', nextStatus)
+  }
+
+  private scheduleIdleTimer(): void {
+    if (this.exited) return
+    this.clearIdleTimer()
+    this.idleTimer = setTimeout(() => {
+      this.idleTimer = null
+      if (this.exited) return
+      this.setStatus('idle')
+    }, AgentSession.IDLE_TIMEOUT_MS)
+  }
+
+  private clearIdleTimer(): void {
+    if (!this.idleTimer) {
+      return
+    }
+    clearTimeout(this.idleTimer)
+    this.idleTimer = null
+  }
+
+  private startCwdPolling(): void {
+    if (this.cwdPollTimer || !this.ptyProcess) {
+      return
+    }
+
+    this.cwdPollTimer = setInterval(() => {
+      if (this.exited || !this.ptyProcess) {
+        return
+      }
+
+      this.updateCwd(getProcessCwd(this.ptyProcess.pid))
+    }, AgentSession.CWD_POLL_INTERVAL_MS)
+  }
+
+  private clearCwdPollTimer(): void {
+    if (!this.cwdPollTimer) {
+      return
+    }
+
+    clearInterval(this.cwdPollTimer)
+    this.cwdPollTimer = null
+  }
+
+  private updateDisplayNameFromInput(data: string): void {
+    if (this.displayNameLocked) {
+      return
+    }
+
+    this.initialInputBuffer += data
+
+    // DCS/APC/PM/SOS シーケンス（Warp など一部ターミナルがstdinに送る）を除去してから
+    // ユーザー入力の改行を探す。これらのシーケンスは CR/LF を含むことがあり、
+    // そのまま処理すると表示名がターミナル固有の文字列で汚染される。
+    const cleaned = this.initialInputBuffer.replace(/\x1b[P_^X][^\x1b]*(?:\x1b\\)?/g, '')
+
+    const newlineIndex = cleaned.search(/\r|\n/)
+    if (newlineIndex === -1) {
+      return
+    }
+
+    const firstLine = cleaned.slice(0, newlineIndex)
+    this.initialInputBuffer = ''
+
+    const normalized = AgentSession.normalizeDisplayName(firstLine)
+    if (normalized.length < AgentSession.DISPLAY_NAME_MIN_LENGTH) {
+      return
+    }
+
+    this.displayNameLocked = true
+    this.displayName = normalized
+    this.emit('name', normalized)
+  }
+
+  private updateCwdFromOutput(data: string): void {
+    this.updateCwd(AgentSession.extractOsc7Cwd(data))
+  }
+
+  private updateCwd(nextCwd: string | null): void {
+    if (!nextCwd || nextCwd === this.cwd) {
+      return
+    }
+
+    this.cwd = nextCwd
+    this.emit('cwd', nextCwd)
+  }
+
+  private static extractOsc7Cwd(data: string): string | null {
+    const matches = [...data.matchAll(/\x1b\]7;([^\x07\x1b]+)(?:\x07|\x1b\\)/g)]
+    const rawUrl = matches.at(-1)?.[1]
+    if (!rawUrl) {
+      return null
+    }
+
+    try {
+      const url = new URL(rawUrl)
+      if (url.protocol !== 'file:') {
+        return null
+      }
+
+      return decodeURIComponent(url.pathname || '')
+    } catch {
+      return null
+    }
+  }
+
+  private static normalizeDisplayName(input: string): string {
+    const withoutAnsi = input
+      .replace(/\x1b[P_^X][^\x1b]*(?:\x1b\\)?/g, '')  // DCS, APC, PM, SOS（複数文字シーケンス）
+      .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, '')
+      .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '')
+      .replace(/\x1b[@-Z\\-_]/g, '')
+    const collapsed = withoutAnsi
+      .replace(/[\x00-\x1f\x7f]+/g, ' ')
+      .replace(/\s+/g, ' ')
+      .trim()
+
+    if (collapsed.length <= AgentSession.DISPLAY_NAME_MAX_LENGTH) {
+      return collapsed
+    }
+
+    return `${collapsed.slice(0, AgentSession.DISPLAY_NAME_MAX_LENGTH - 3).trimEnd()}...`
+  }
+}

package/src/config.ts

@@ -0,0 +1,51 @@
+import { readFileSync, existsSync } from 'node:fs'
+import { load as yamlLoad } from 'js-yaml'
+import { getAgentDefaults } from './agent-launch.js'
+
+export interface AgentConfig {
+  type: string
+  cmd: string
+  args: string[]
+  cwd?: string
+  resumeArgs?: string[]
+}
+
+export interface MavConfig {
+  agents: AgentConfig[]
+}
+
+const DEFAULT_CONFIG: MavConfig = {
+  agents: [],
+}
+
+export function loadConfig(configPath: string): MavConfig {
+  if (!existsSync(configPath)) {
+    return DEFAULT_CONFIG
+  }
+
+  const raw = readFileSync(configPath, 'utf-8')
+  const parsed = yamlLoad(raw) as { agents?: Array<{ type: string; cmd?: string; args?: string[] }> }
+
+  if (!parsed?.agents || !Array.isArray(parsed.agents)) {
+    return DEFAULT_CONFIG
+  }
+
+  const agents: AgentConfig[] = parsed.agents
+    .filter((a): a is { type: string; cmd?: string; args?: string[]; resumeArgs?: string[] } =>
+      typeof a?.type === 'string' && a.type.length > 0
+    )
+    .map((a) => {
+      const defaults = getAgentDefaults(a.type)
+      const cmd = typeof a.cmd === 'string' && a.cmd.trim().length > 0
+        ? a.cmd
+        : defaults.cmd
+      return {
+        type: a.type,
+        cmd,
+        args: Array.isArray(a.args) ? a.args : defaults.args,
+        resumeArgs: Array.isArray(a.resumeArgs) ? a.resumeArgs : defaults.resumeArgs,
+      }
+    })
+
+  return { agents }
+}

package/src/current-session.ts

@@ -0,0 +1,34 @@
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+export interface CurrentSessionSnapshot {
+  id: string
+  type: string
+  displayName: string
+  cwd: string
+}
+
+export interface CurrentSessionState {
+  sessionId: string
+  agentType: string
+  displayName: string
+  cwd: string
+  updatedAt: string
+}
+
+export function saveCurrentSessionState(path: string, session: CurrentSessionSnapshot): void {
+  const state: CurrentSessionState = {
+    sessionId: session.id,
+    agentType: session.type,
+    displayName: session.displayName,
+    cwd: session.cwd,
+    updatedAt: new Date().toISOString(),
+  }
+
+  mkdirSync(dirname(path), { recursive: true })
+  writeFileSync(path, JSON.stringify(state), 'utf-8')
+}
+
+export function clearCurrentSessionState(path: string): void {
+  rmSync(path, { force: true })
+}

package/src/index.ts

@@ -0,0 +1,121 @@
+import { homedir } from 'node:os'
+import { join, dirname } from 'node:path'
+import { loadConfig } from './config.js'
+import { clearCurrentSessionState, saveCurrentSessionState } from './current-session.js'
+import { loadState, saveState } from './state.js'
+import { SessionManager } from './session-manager.js'
+import { App } from './ui/app.js'
+import type { AgentSession } from './agent.js'
+import { resolveSessionArgs } from './agent-launch.js'
+
+export interface StartOptions {
+  configPath?: string
+  agentType?: string
+}
+
+export function start(options: StartOptions = {}): SessionManager {
+  const configPath =
+    options.configPath ?? join(homedir(), '.config', 'mav', 'config.yaml')
+  const statePath = join(dirname(configPath), 'state.json')
+  const currentSessionPath = join(homedir(), '.local', 'state', 'mav', 'current-session.json')
+  const config = loadConfig(configPath)
+
+  const agentsToStart = options.agentType
+    ? config.agents.filter((a) => a.type === options.agentType)
+    : config.agents
+
+  if (agentsToStart.length === 0 && options.agentType) {
+    console.error(`No agents found for type: ${options.agentType}`)
+    process.exit(1)
+  }
+
+  const savedState = loadState(statePath)
+
+  const manager = new SessionManager()
+  const app = new App(manager, statePath)
+  const publishSelectedSession = () => {
+    const session = manager.selectedSession
+    if (!session) {
+      clearCurrentSessionState(currentSessionPath)
+      return
+    }
+
+    saveCurrentSessionState(currentSessionPath, {
+      id: session.id,
+      type: session.type,
+      displayName: session.displayName,
+      cwd: session.cwd,
+    })
+  }
+
+  const typeCounters: Record<string, number> = {}
+  const configSessionIds = new Set<string>()
+
+  for (const agentConfig of agentsToStart) {
+    typeCounters[agentConfig.type] = (typeCounters[agentConfig.type] ?? 0) + 1
+    const predictedId = `${agentConfig.type}#${typeCounters[agentConfig.type]}`
+    const savedSession = savedState?.sessions[predictedId]
+
+    const { args, newSessionId } = resolveSessionArgs(
+      agentConfig.type,
+      agentConfig.args,
+      savedSession?.sessionId,
+      savedSession != null,
+    )
+
+    const session = manager.addSession({ ...agentConfig, args }) as AgentSession & { sessionId?: string }
+    session.baseArgs = agentConfig.args
+    configSessionIds.add(session.id)
+
+    if (newSessionId != null) {
+      session.sessionId = newSessionId
+    }
+  }
+
+  // configに定義されていないが保存済みセッション（動的追加分）を再作成する
+  if (savedState) {
+    for (const [stateId, savedSession] of Object.entries(savedState.sessions)) {
+      if (configSessionIds.has(stateId) || !savedSession.agentBase) continue
+
+      const rc = savedSession.agentBase
+      const { args, newSessionId } = resolveSessionArgs(
+        rc.type,
+        rc.args,
+        savedSession.sessionId,
+        true,
+      )
+      const session = manager.addSession({ type: rc.type, cmd: rc.cmd, args }) as AgentSession & { sessionId?: string }
+      session.baseArgs = rc.args
+      if (newSessionId != null) {
+        session.sessionId = newSessionId
+      }
+    }
+  }
+
+  if (savedState) {
+    manager.restoreLogBuffers(savedState)
+  }
+
+  manager.on('selection', () => {
+    publishSelectedSession()
+  })
+
+  manager.on('cwd', (sessionId: string) => {
+    if (manager.selectedSession?.id !== sessionId) {
+      return
+    }
+    publishSelectedSession()
+  })
+
+  publishSelectedSession()
+
+  // q/Ctrl+C 以外の終了（ウィンドウ閉じ等）でも state を保存する
+  const saveOnExit = () => {
+    try { saveState(statePath, manager) } catch { /* ignore */ }
+  }
+  process.once('SIGTERM', () => { saveOnExit(); process.exit(0) })
+  process.once('SIGHUP', () => { saveOnExit(); process.exit(0) })
+
+  app.start()
+  return manager
+}

package/src/process-cwd.ts

@@ -0,0 +1,31 @@
+import { execFileSync } from 'node:child_process'
+import { readlinkSync } from 'node:fs'
+
+export function getProcessCwd(pid: number, platform: NodeJS.Platform = process.platform): string | null {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return null
+  }
+
+  try {
+    if (platform === 'linux') {
+      return readlinkSync(`/proc/${pid}/cwd`)
+    }
+
+    if (platform === 'darwin') {
+      const output = execFileSync(
+        'lsof',
+        ['-a', '-d', 'cwd', '-p', String(pid), '-Fn'],
+        { encoding: 'utf8' },
+      )
+      const cwdLine = output
+        .split('\n')
+        .find((line) => line.startsWith('n/') || line === 'n/')
+
+      return cwdLine ? cwdLine.slice(1) : null
+    }
+  } catch {
+    return null
+  }
+
+  return null
+}

package/src/session-manager.ts

@@ -0,0 +1,122 @@
+import { EventEmitter } from 'node:events'
+import { AgentSession } from './agent.js'
+import type { AgentConfig } from './config.js'
+import type { MavState } from './state.js'
+
+type SessionListeners = {
+  onData: (chunk: string) => void
+  onExit: (code: number) => void
+  onStatus: (status: string) => void
+  onName: (name: string) => void
+  onCwd: (cwd: string) => void
+}
+
+export class SessionManager extends EventEmitter {
+  sessions: AgentSession[] = []
+  selectedIndex: number = -1
+  private sessionListeners = new Map<string, SessionListeners>()
+
+  private emitSelection(): void {
+    this.emit('selection', this.selectedSession)
+  }
+
+  addSession(config: AgentConfig, cols = 80, rows = 24): AgentSession {
+    const session = new AgentSession(config, cols, rows)
+
+    const onData = (chunk: string) => { this.emit('data', session.id, chunk) }
+    const onExit = (code: number) => { this.emit('exit', session.id, code) }
+    const onStatus = (status: string) => { this.emit('status', session.id, status) }
+    const onName = (name: string) => { this.emit('name', session.id, name) }
+    const onCwd = (cwd: string) => { this.emit('cwd', session.id, cwd) }
+
+    session.on('data', onData)
+    session.on('exit', onExit)
+    session.on('status', onStatus)
+    session.on('name', onName)
+    session.on('cwd', onCwd)
+    this.sessionListeners.set(session.id, { onData, onExit, onStatus, onName, onCwd })
+
+    this.sessions.push(session)
+
+    if (this.selectedIndex === -1) {
+      this.selectedIndex = 0
+      this.emitSelection()
+    }
+
+    return session
+  }
+
+  removeSession(id: string): void {
+    const idx = this.sessions.findIndex((s) => s.id === id)
+    if (idx === -1) return
+
+    const session = this.sessions[idx]!
+    const ls = this.sessionListeners.get(id)
+    if (ls) {
+      session.off('data', ls.onData)
+      session.off('exit', ls.onExit)
+      session.off('status', ls.onStatus)
+      session.off('name', ls.onName)
+      session.off('cwd', ls.onCwd)
+      this.sessionListeners.delete(id)
+    }
+    session.kill()
+    this.sessions.splice(idx, 1)
+
+    if (this.sessions.length === 0) {
+      this.selectedIndex = -1
+    } else if (idx < this.selectedIndex) {
+      this.selectedIndex -= 1
+    } else if (this.selectedIndex >= this.sessions.length) {
+      this.selectedIndex = this.sessions.length - 1
+    }
+
+    this.emitSelection()
+  }
+
+  selectSession(index: number): void {
+    if (index < 0 || index >= this.sessions.length) return
+    this.selectedIndex = index
+    this.emitSelection()
+  }
+
+  get selectedSession(): AgentSession | null {
+    if (this.selectedIndex === -1) return null
+    return this.sessions[this.selectedIndex] ?? null
+  }
+
+  restoreLogBuffers(state: MavState): void {
+    for (const session of this.sessions) {
+      const saved = state.sessions[session.id]
+      if (saved) {
+        session.logBuffer = Array.isArray(saved.logBuffer)
+          ? saved.logBuffer.filter((chunk): chunk is string => typeof chunk === 'string')
+          : []
+        if (saved.sessionId != null) {
+          session.sessionId = saved.sessionId
+        }
+        if (saved.displayName) {
+          session.restoreDisplayName(saved.displayName)
+        }
+      }
+    }
+  }
+
+  killAll(): void {
+    for (const session of this.sessions) {
+      const ls = this.sessionListeners.get(session.id)
+      if (ls) {
+        session.off('data', ls.onData)
+        session.off('exit', ls.onExit)
+        session.off('status', ls.onStatus)
+        session.off('name', ls.onName)
+        session.off('cwd', ls.onCwd)
+      }
+      session.kill()
+    }
+    this.sessions = []
+    this.sessionListeners.clear()
+    this.selectedIndex = -1
+    this.emitSelection()
+  }
+}

package/src/state.ts

@@ -0,0 +1,49 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs'
+import { dirname } from 'node:path'
+import type { SessionManager } from './session-manager.js'
+import type { SessionStatus } from './agent.js'
+
+export interface SessionState {
+  logBuffer: string[]
+  status: SessionStatus
+  sessionId?: string
+  displayName?: string
+  /** configに定義されていない動的セッションを再起動時に復元するための情報 */
+  agentBase?: {
+    type: string
+    cmd: string
+    args: string[]
+  }
+}
+
+export interface MavState {
+  sessions: Record<string, SessionState>
+}
+
+export function saveState(path: string, manager: SessionManager): void {
+  const state: MavState = { sessions: {} }
+  for (const session of manager.sessions) {
+    state.sessions[session.id] = {
+      logBuffer: [...session.logBuffer],
+      status: session.status,
+      ...(session.sessionId != null && { sessionId: session.sessionId }),
+      displayName: session.displayName,
+      agentBase: {
+        type: session.type,
+        cmd: session.cmd,
+        args: [...session.baseArgs],
+      },
+    }
+  }
+  mkdirSync(dirname(path), { recursive: true })
+  writeFileSync(path, JSON.stringify(state), 'utf-8')
+}
+
+export function loadState(path: string): MavState | null {
+  try {
+    const raw = readFileSync(path, 'utf-8')
+    return JSON.parse(raw) as MavState
+  } catch {
+    return null
+  }
+}

package/src/types/neo-blessed.d.ts

@@ -0,0 +1,5 @@
+declare module 'neo-blessed' {
+  export * from 'blessed'
+  declare const _default: typeof import('blessed')
+  export { _default as default }
+}