@bytespell/amux 0.0.11 → 0.0.13

package/src/state.ts

@@ -0,0 +1,287 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+import type { SessionState, SessionMetadata, StoredEvent } from './types.js';
+
+/**
+ * Default state directory
+ */
+const DEFAULT_STATE_DIR = path.join(
+  os.homedir(),
+  '.local',
+  'state',
+  'amux'
+);
+
+/**
+ * State manager for amux sessions.
+ * Handles persistence of session state and history.
+ */
+export class StateManager {
+  private stateDir: string;
+
+  constructor(stateDir?: string) {
+    this.stateDir = stateDir ?? DEFAULT_STATE_DIR;
+  }
+
+  /**
+   * Get the state file path for a specific instance
+   */
+  private getStateFilePath(instanceId: string): string {
+    return path.join(this.stateDir, `instance-${instanceId}.json`);
+  }
+
+  /**
+   * Get history file path for a session
+   */
+  private getHistoryPath(sessionId: string): string {
+    return path.join(this.stateDir, `session-${sessionId}-history.json`);
+  }
+
+  /**
+   * Get sessions registry file path
+   */
+  private getSessionsRegistryPath(): string {
+    return path.join(this.stateDir, 'sessions.json');
+  }
+
+  /**
+   * Load persisted session state
+   */
+  loadState(instanceId: string): SessionState {
+    console.log('[amux] Loading state for instance:', instanceId);
+    try {
+      const stateFile = this.getStateFilePath(instanceId);
+      if (fs.existsSync(stateFile)) {
+        const data = JSON.parse(fs.readFileSync(stateFile, 'utf-8')) as SessionState;
+        console.log('[amux] Loaded persisted state:', JSON.stringify(data));
+        return data;
+      }
+    } catch (err) {
+      console.log('[amux] Failed to load persisted state:', (err as Error).message);
+    }
+    return {};
+  }
+
+  /**
+   * Save session state to disk
+   */
+  saveState(instanceId: string, state: SessionState): void {
+    try {
+      fs.mkdirSync(this.stateDir, { recursive: true });
+      const stateFile = this.getStateFilePath(instanceId);
+      fs.writeFileSync(stateFile, JSON.stringify(state, null, 2));
+    } catch (err) {
+      console.log('[amux] Failed to save state:', (err as Error).message);
+    }
+  }
+
+  /**
+   * Store event to history for replay
+   */
+  storeEvent(sessionId: string | null, event: StoredEvent): void {
+    if (!sessionId) return;
+
+    // Only store session updates and turn markers
+    const isSessionUpdate = event.type === 'session_update';
+    const isTurnMarker = event.type === 'turn_start' || event.type === 'turn_end';
+
+    if (!isSessionUpdate && !isTurnMarker) {
+      return;
+    }
+
+    try {
+      fs.mkdirSync(this.stateDir, { recursive: true });
+      const historyFile = this.getHistoryPath(sessionId);
+      let events: StoredEvent[] = [];
+      if (fs.existsSync(historyFile)) {
+        const data = fs.readFileSync(historyFile, 'utf-8');
+        events = JSON.parse(data) as StoredEvent[];
+      }
+      events.push(event);
+      fs.writeFileSync(historyFile, JSON.stringify(events));
+    } catch (err) {
+      console.log('[amux] Failed to store event:', (err as Error).message);
+    }
+  }
+
+  /**
+   * Load history for replay
+   */
+  loadHistory(sessionId: string | null): StoredEvent[] {
+    if (!sessionId) return [];
+
+    try {
+      const historyFile = this.getHistoryPath(sessionId);
+      if (fs.existsSync(historyFile)) {
+        const data = fs.readFileSync(historyFile, 'utf-8');
+        return JSON.parse(data) as StoredEvent[];
+      }
+    } catch (err) {
+      console.log('[amux] Failed to load history:', (err as Error).message);
+    }
+    return [];
+  }
+
+  /**
+   * Clear history for a session
+   */
+  clearHistory(sessionId: string | null): void {
+    if (!sessionId) return;
+
+    try {
+      const historyFile = this.getHistoryPath(sessionId);
+      if (fs.existsSync(historyFile)) {
+        fs.unlinkSync(historyFile);
+      }
+    } catch (err) {
+      console.log('[amux] Failed to clear history:', (err as Error).message);
+    }
+  }
+
+  /**
+   * Load sessions registry
+   */
+  private loadSessionsRegistry(): { sessions: SessionMetadata[] } {
+    try {
+      const registryPath = this.getSessionsRegistryPath();
+      if (fs.existsSync(registryPath)) {
+        const data = fs.readFileSync(registryPath, 'utf-8');
+        return JSON.parse(data) as { sessions: SessionMetadata[] };
+      }
+    } catch (err) {
+      console.log('[amux] Failed to load sessions registry:', (err as Error).message);
+    }
+    return { sessions: [] };
+  }
+
+  /**
+   * Save sessions registry
+   */
+  private saveSessionsRegistry(registry: { sessions: SessionMetadata[] }): void {
+    try {
+      fs.mkdirSync(this.stateDir, { recursive: true });
+      const registryPath = this.getSessionsRegistryPath();
+      fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2));
+    } catch (err) {
+      console.log('[amux] Failed to save sessions registry:', (err as Error).message);
+    }
+  }
+
+  /**
+   * Register a new session or update existing one
+   */
+  registerSession(
+    sessionId: string,
+    cwd: string,
+    agentType: string,
+    displayName?: string
+  ): void {
+    const registry = this.loadSessionsRegistry();
+    const existingIndex = registry.sessions.findIndex(s => s.id === sessionId);
+
+    const session: SessionMetadata = {
+      id: sessionId,
+      name: displayName || `Session ${sessionId.slice(0, 8)}`,
+      cwd,
+      messageCount: 0,
+      lastModified: Date.now(),
+      agentType,
+    };
+
+    if (existingIndex >= 0) {
+      // Update existing session, preserve message count
+      const existing = registry.sessions[existingIndex];
+      session.messageCount = existing?.messageCount ?? 0;
+      registry.sessions[existingIndex] = session;
+    } else {
+      // Add new session at the beginning (most recent first)
+      registry.sessions.unshift(session);
+    }
+
+    this.saveSessionsRegistry(registry);
+    console.log(`[amux] Registered session: ${sessionId}`);
+  }
+
+  /**
+   * Update session metadata
+   */
+  updateSessionMetadata(
+    sessionId: string,
+    updates: Partial<Pick<SessionMetadata, 'messageCount' | 'lastModified' | 'name'>>
+  ): void {
+    const registry = this.loadSessionsRegistry();
+    const session = registry.sessions.find(s => s.id === sessionId);
+
+    if (session) {
+      if (updates.messageCount !== undefined) {
+        session.messageCount = updates.messageCount;
+      }
+      if (updates.lastModified !== undefined) {
+        session.lastModified = updates.lastModified;
+      }
+      if (updates.name !== undefined) {
+        session.name = updates.name;
+      }
+      this.saveSessionsRegistry(registry);
+    }
+  }
+
+  /**
+   * Increment message count for a session
+   */
+  incrementSessionMessageCount(sessionId: string): void {
+    const registry = this.loadSessionsRegistry();
+    const session = registry.sessions.find(s => s.id === sessionId);
+
+    if (session) {
+      session.messageCount += 1;
+      session.lastModified = Date.now();
+      this.saveSessionsRegistry(registry);
+    }
+  }
+
+  /**
+   * List all sessions, optionally filtered by cwd
+   */
+  listSessions(cwd?: string): SessionMetadata[] {
+    const registry = this.loadSessionsRegistry();
+    let sessions = registry.sessions;
+
+    // Filter by cwd if provided
+    if (cwd) {
+      sessions = sessions.filter(s => s.cwd === cwd);
+    }
+
+    // Sort by lastModified (most recent first)
+    sessions.sort((a, b) => b.lastModified - a.lastModified);
+
+    return sessions;
+  }
+
+  /**
+   * Get a specific session by ID
+   */
+  getSession(sessionId: string): SessionMetadata | undefined {
+    const registry = this.loadSessionsRegistry();
+    return registry.sessions.find(s => s.id === sessionId);
+  }
+
+  /**
+   * Delete a session from the registry and its history
+   */
+  deleteSession(sessionId: string): void {
+    const registry = this.loadSessionsRegistry();
+    const index = registry.sessions.findIndex(s => s.id === sessionId);
+
+    if (index >= 0) {
+      registry.sessions.splice(index, 1);
+      this.saveSessionsRegistry(registry);
+    }
+
+    // Also clear the history file
+    this.clearHistory(sessionId);
+    console.log(`[amux] Deleted session: ${sessionId}`);
+  }
+}

package/src/terminal.ts

@@ -0,0 +1,164 @@
+import { spawn, type ChildProcess } from 'child_process';
+import crypto from 'crypto';
+import type * as acp from '@agentclientprotocol/sdk';
+
+/**
+ * Terminal state tracking
+ */
+export interface TerminalState {
+  process: ChildProcess;
+  output: string;
+  exitCode: number | null;
+  signal: string | null;
+  truncated: boolean;
+  outputByteLimit: number;
+}
+
+/**
+ * Manages terminal processes for ACP terminal capability.
+ * Handles spawning, output collection, and lifecycle management.
+ */
+export class TerminalManager {
+  private terminals = new Map<string, TerminalState>();
+
+  constructor(private defaultCwd: () => string) {}
+
+  /**
+   * Create a new terminal process
+   */
+  create(params: acp.CreateTerminalRequest): acp.CreateTerminalResponse {
+    console.log('[amux] Create terminal:', params.command);
+    const terminalId = crypto.randomUUID();
+    const outputByteLimit = Number(params.outputByteLimit ?? 1024 * 1024); // Default 1MB
+
+    const termProc = spawn(params.command, params.args ?? [], {
+      cwd: params.cwd ?? this.defaultCwd(),
+      env: params.env
+        ? { ...process.env, ...Object.fromEntries(params.env.map(e => [e.name, e.value])) }
+        : process.env,
+      shell: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    const terminal: TerminalState = {
+      process: termProc,
+      output: '',
+      exitCode: null,
+      signal: null,
+      truncated: false,
+      outputByteLimit,
+    };
+
+    const appendOutput = (data: Buffer): void => {
+      terminal.output += data.toString();
+      // Truncate from beginning if over limit
+      if (terminal.output.length > terminal.outputByteLimit) {
+        terminal.output = terminal.output.slice(-terminal.outputByteLimit);
+        terminal.truncated = true;
+      }
+    };
+
+    termProc.stdout?.on('data', appendOutput);
+    termProc.stderr?.on('data', appendOutput);
+
+    termProc.on('exit', (code, signal) => {
+      console.log(`[amux] Terminal ${terminalId} exited with code ${code}, signal ${signal}`);
+      terminal.exitCode = code ?? null;
+      terminal.signal = signal ?? null;
+    });
+
+    termProc.on('error', (err) => {
+      console.error(`[amux] Terminal ${terminalId} error:`, err.message);
+      terminal.output += `\nError: ${err.message}`;
+      terminal.exitCode = -1;
+    });
+
+    this.terminals.set(terminalId, terminal);
+    console.log(`[amux] Created terminal ${terminalId} for command: ${params.command}`);
+
+    return { terminalId };
+  }
+
+  /**
+   * Get terminal output
+   */
+  getOutput(terminalId: string): acp.TerminalOutputResponse {
+    const terminal = this.terminals.get(terminalId);
+    if (!terminal) {
+      throw new Error(`Terminal ${terminalId} not found`);
+    }
+    return {
+      output: terminal.output,
+      truncated: terminal.truncated,
+      exitStatus: terminal.exitCode !== null || terminal.signal !== null ? {
+        exitCode: terminal.exitCode,
+        signal: terminal.signal,
+      } : undefined,
+    };
+  }
+
+  /**
+   * Wait for terminal to exit
+   */
+  async waitForExit(terminalId: string): Promise<acp.WaitForTerminalExitResponse> {
+    const terminal = this.terminals.get(terminalId);
+    if (!terminal) {
+      throw new Error(`Terminal ${terminalId} not found`);
+    }
+
+    // If already exited, return immediately
+    if (terminal.exitCode !== null || terminal.signal !== null) {
+      return {
+        exitCode: terminal.exitCode,
+        signal: terminal.signal,
+      };
+    }
+
+    // Wait for exit
+    return new Promise((resolve) => {
+      terminal.process.on('exit', (code, signal) => {
+        resolve({
+          exitCode: code ?? null,
+          signal: signal ?? null,
+        });
+      });
+    });
+  }
+
+  /**
+   * Kill a terminal process
+   */
+  kill(terminalId: string): acp.KillTerminalCommandResponse {
+    const terminal = this.terminals.get(terminalId);
+    if (!terminal) {
+      throw new Error(`Terminal ${terminalId} not found`);
+    }
+    terminal.process.kill('SIGTERM');
+    return {};
+  }
+
+  /**
+   * Release a terminal (cleanup)
+   */
+  release(terminalId: string): acp.ReleaseTerminalResponse {
+    const terminal = this.terminals.get(terminalId);
+    if (terminal) {
+      if (terminal.exitCode === null) {
+        terminal.process.kill('SIGKILL');
+      }
+      this.terminals.delete(terminalId);
+    }
+    return {};
+  }
+
+  /**
+   * Kill all terminals (for shutdown)
+   */
+  killAll(): void {
+    for (const [terminalId, terminal] of this.terminals) {
+      console.log(`[amux] Killing terminal ${terminalId}`);
+      terminal.process.kill('SIGKILL');
+    }
+    this.terminals.clear();
+  }
+}

package/src/types.ts

@@ -0,0 +1,88 @@
+import type * as acp from '@agentclientprotocol/sdk';
+
+/**
+ * Agent configuration - maps agent type to binary name
+ */
+export interface AgentConfig {
+  name: string;
+  bin: string;
+}
+
+/**
+ * Built-in agent registry
+ */
+export const AGENTS: Record<string, AgentConfig> = {
+  'claude-code': {
+    name: 'Claude Code',
+    bin: 'claude-code-acp',
+  },
+  'codex': {
+    name: 'Codex',
+    bin: 'codex-acp',
+  },
+  'pi': {
+    name: 'Pi',
+    bin: 'pi-acp',
+  },
+};
+
+/**
+ * Session metadata for persistence
+ */
+export interface SessionMetadata {
+  id: string;
+  name: string;
+  cwd: string;
+  messageCount: number;
+  lastModified: number;
+  agentType: string;
+}
+
+/**
+ * Persisted session state
+ */
+export interface SessionState {
+  cwd?: string;
+  sessionId?: string | null;
+  agentType?: string;
+}
+
+/**
+ * Event stored in history for replay
+ */
+export interface StoredEvent {
+  type: string;
+  update?: acp.SessionUpdate;
+  [key: string]: unknown;
+}
+
+/**
+ * Session restore info sent to UI
+ */
+export interface SessionRestoreInfo {
+  restored: boolean;
+  reason?: string;
+}
+
+/**
+ * Configuration for creating an agent session
+ */
+export interface AgentSessionConfig {
+  /** Unique identifier for this session instance */
+  instanceId: string;
+
+  /** Base path for resolving agent binaries (node_modules/.bin) */
+  basePath: string;
+
+  /** Optional system context to inject (e.g., from a markdown file) */
+  systemContext?: string;
+
+  /** Optional fixed working directory (overrides user selection) */
+  fixedCwd?: string;
+
+  /** Optional initial agent type (defaults to 'claude-code') */
+  agentType?: string;
+
+  /** Optional state directory override */
+  stateDir?: string;
+}