@bytespell/amux 0.0.10 → 0.0.12

package/.claude/settings.local.json

@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(git config:*)",
+      "Bash(gh repo create:*)",
+      "Bash(gh org:*)",
+      "Bash(gh api:*)",
+      "Bash(npm publish:*)"
+    ]
+  }
+}

package/CLAUDE.md

@@ -0,0 +1,104 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code when working with this repository.
+
+## What is amux?
+
+**amux** (Agent Multiplexer) is a library for building agent-powered HTTP servers. Think of it like tmux, but for AI agents over HTTP. It provides:
+
+1. **Session management**: Spawn, manage, and multiplex multiple ACP agent sessions
+2. **WebSocket API**: Real-time streaming communication with agents
+3. **State persistence**: Session history, preferences, and replay
+4. **System context injection**: Customize agent behavior with injected knowledge
+
+## Project Structure
+
+```
+amux/
+├── src/
+│   ├── index.ts          # Public API exports
+│   ├── cli.ts            # CLI entry point
+│   ├── server.ts         # Express + WebSocket server factory
+│   ├── session.ts        # AgentSession - core session management
+│   ├── client.ts         # AmuxClient - ACP client implementation
+│   ├── terminal.ts       # TerminalManager - PTY management
+│   ├── state.ts          # StateManager - persistence
+│   ├── session-updates.ts # ACP update normalization
+│   └── types.ts          # TypeScript types
+├── package.json
+└── tsconfig.json
+```
+
+## Key Concepts
+
+### AgentSession
+
+The core class that manages an ACP agent lifecycle:
+- Spawns agent processes (claude-code-acp, codex-acp, pi-acp)
+- Handles ACP protocol communication
+- Manages session state and history
+- Supports system context injection
+
+### AmuxClient
+
+Implements the ACP Client interface:
+- Filesystem operations (read/write files)
+- Terminal management (spawn commands, get output)
+- Permission request handling
+- Session update broadcasting
+
+### Server Factory
+
+`createAmuxServer()` provides a batteries-included server:
+- Express app with API routes
+- WebSocket server on `/ws`
+- Automatic agent spawning
+- History replay on reconnect
+
+## Build Commands
+
+```bash
+npm run build      # Compile TypeScript
+npm run dev        # Watch mode
+npm run typecheck  # Type check only
+npm run test       # Run tests
+```
+
+## API Design
+
+The public API has three levels:
+
+1. **High-level**: `createAmuxServer(config)` - Full server in one call
+2. **Mid-level**: `attachAmux(app, server, config)` - Attach to existing Express app
+3. **Low-level**: `AgentSession` class - Full control over session management
+
+## State Storage
+
+By default, state is stored in `~/.local/state/amux/`:
+- `instance-{id}.json` - Per-instance state (cwd, sessionId, agentType)
+- `session-{id}-history.json` - Session event history for replay
+- `sessions.json` - Session registry with metadata
+
+## WebSocket Protocol
+
+The WebSocket API on `/ws` uses JSON messages. Key message types:
+
+**Client → Server:**
+- `prompt` - Send user message
+- `cancel` - Cancel current operation
+- `permission_response` - Respond to permission request
+- `change_cwd`, `new_session`, `change_agent`, etc.
+
+**Server → Client:**
+- `ready` - Connection established
+- `session_update` - Streaming updates from agent
+- `permission_request` - Agent needs permission
+- `history_replay` - Replay events on reconnect
+- `error` - Error occurred
+
+## Testing
+
+When adding features:
+1. Unit test individual components (StateManager, TerminalManager, etc.)
+2. Integration test the full server with a mock agent
+3. Test WebSocket message handling

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ashley Hauck
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,204 @@
+# amux
+
+**Agent Multiplexer** - EventEmitter-based agent session management.
+
+Manage ACP agent sessions (Claude Code, Codex, Pi) with a simple event-driven interface. Transport-agnostic core with an optional WebSocket adapter.
+
+## Installation
+
+```bash
+npm install @bytespell/amux
+```
+
+You'll also need at least one ACP agent:
+
+```bash
+npm install @zed-industries/claude-code-acp  # Claude Code
+npm install @zed-industries/codex-acp        # Codex
+npm install pi-acp                           # Pi
+```
+
+## Quick Start
+
+### With WebSocket Adapter
+
+```typescript
+import { AgentSession, createWsAdapter } from '@bytespell/amux';
+import { WebSocketServer } from 'ws';
+import { createServer } from 'http';
+
+const server = createServer();
+const wss = new WebSocketServer({ server, path: '/ws' });
+
+const session = new AgentSession({
+  instanceId: process.env.INSTANCE_ID ?? 'default',
+  basePath: process.cwd(),
+  systemContext: 'You are a helpful assistant...',
+});
+
+// Wire up WebSocket
+createWsAdapter(session, wss);
+
+// Start the agent
+await session.spawnAgent();
+
+server.listen(3000);
+```
+
+### Events Only (Bring Your Own Transport)
+
+```typescript
+import { AgentSession } from '@bytespell/amux';
+
+const session = new AgentSession({
+  instanceId: 'my-instance',
+  basePath: process.cwd(),
+});
+
+// Subscribe to events
+session.on('ready', (data) => {
+  console.log('Agent ready:', data.agent.name);
+});
+
+session.on('update', (update) => {
+  // Handle streaming updates
+  if (update.sessionUpdate === 'agent_message_chunk') {
+    process.stdout.write(update.content.text);
+  }
+});
+
+session.on('permission_request', (data) => {
+  // Auto-approve for demo
+  session.respondToPermission(data.requestId, data.options[0].optionId);
+});
+
+session.on('error', (data) => {
+  console.error('Error:', data.message);
+});
+
+// Start and prompt
+await session.spawnAgent();
+await session.prompt('Hello, what can you do?');
+```
+
+## API
+
+### `AgentSession`
+
+Core class for managing an ACP agent session. Extends `EventEmitter`.
+
+```typescript
+const session = new AgentSession({
+  instanceId: string;       // Unique ID for state isolation
+  basePath: string;         // Path to node_modules with agent binaries
+  systemContext?: string;   // Injected context for the agent
+  fixedCwd?: string;        // Lock working directory
+  agentType?: string;       // 'claude-code' | 'codex' | 'pi'
+  stateDir?: string;        // Custom state directory
+});
+```
+
+#### Methods
+
+```typescript
+await session.spawnAgent()              // Start the agent process
+await session.prompt(message)           // Send a prompt
+await session.cancel()                  // Cancel current operation
+session.respondToPermission(id, optId)  // Respond to permission request
+await session.newSession()              // Create new session
+await session.changeCwd(path)           // Change working directory
+await session.changeAgent(type)         // Switch agent type
+session.listSessions()                  // List available sessions
+session.loadHistory()                   // Get current session history
+session.shutdown()                      // Cleanup and stop
+```
+
+#### Events
+
+```typescript
+session.on('connecting', () => {})
+session.on('ready', (data) => {})           // Agent initialized
+session.on('update', (update) => {})        // Session update (streaming)
+session.on('turn_start', () => {})          // Prompt started
+session.on('turn_end', () => {})            // Prompt completed
+session.on('permission_request', (data) => {})
+session.on('prompt_complete', (data) => {})
+session.on('session_created', (data) => {})
+session.on('session_switched', (data) => {})
+session.on('history_replay', (data) => {})
+session.on('error', (data) => {})
+session.on('agent_exit', (data) => {})
+```
+
+### `createWsAdapter(session, wss, options?)`
+
+Wire up a WebSocket server to an AgentSession.
+
+```typescript
+import { createWsAdapter } from '@bytespell/amux';
+
+const adapter = createWsAdapter(session, wss, {
+  sendHistoryOnConnect: true,  // Default: true
+});
+
+adapter.clientCount()  // Get connected clients
+adapter.broadcast(msg) // Send custom message to all
+adapter.close()        // Close all connections
+```
+
+#### WebSocket Protocol
+
+**Client → Server:**
+```typescript
+{ type: 'prompt', message: 'Hello' }
+{ type: 'cancel' }
+{ type: 'permission_response', requestId: '...', optionId: '...' }
+{ type: 'change_cwd', path: '/new/path' }
+{ type: 'new_session' }
+{ type: 'change_agent', agentType: 'codex' }
+{ type: 'list_sessions' }
+{ type: 'switch_session', sessionId: '...' }
+```
+
+**Server → Client:**
+```typescript
+{ type: 'ready', cwd: '...', sessionId: '...', ... }
+{ type: 'session_update', update: { sessionUpdate: '...', ... } }
+{ type: 'permission_request', requestId: '...', toolCall: {...}, options: [...] }
+{ type: 'history_replay', events: [...], eventCount: 42 }
+{ type: 'error', message: '...' }
+```
+
+## System Context
+
+Inject context to customize agent behavior:
+
+```typescript
+const session = new AgentSession({
+  instanceId: 'docs-helper',
+  basePath: __dirname,
+  systemContext: `
+# Documentation Assistant
+
+You help users write documentation for this project.
+
+Key conventions:
+- Use markdown format
+- Include code examples
+- Keep explanations concise
+  `,
+});
+```
+
+## State Persistence
+
+Sessions are persisted to `~/.local/state/amux/` by default:
+- Instance state (cwd, sessionId, agentType)
+- Session history (for replay on reconnect)
+- Session registry (list all sessions)
+
+Override with `stateDir` option.
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * amux CLI
+ *
+ * Quick way to start an amux server from the command line.
+ *
+ * Usage:
+ *   amux                          # Start with defaults
+ *   amux --context ./CONTEXT.md   # Start with system context from file
+ *   amux --cwd /path/to/project   # Start with fixed working directory
+ *   amux --port 3000              # Start on specific port
+ */
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAEA;;;;;;;;;;GAUG"}

package/dist/cli.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+/**
+ * amux CLI
+ *
+ * Quick way to start an amux server from the command line.
+ *
+ * Usage:
+ *   amux                          # Start with defaults
+ *   amux --context ./CONTEXT.md   # Start with system context from file
+ *   amux --cwd /path/to/project   # Start with fixed working directory
+ *   amux --port 3000              # Start on specific port
+ */
+import fs from 'fs';
+import path from 'path';
+import { createAmuxServer } from './server.js';
+function parseArgs() {
+    const args = {};
+    const argv = process.argv.slice(2);
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--help' || arg === '-h') {
+            args.help = true;
+        }
+        else if (arg === '--port' || arg === '-p') {
+            args.port = parseInt(argv[++i] ?? '', 10);
+        }
+        else if (arg === '--context' || arg === '-c') {
+            args.context = argv[++i];
+        }
+        else if (arg === '--cwd' || arg === '-d') {
+            args.cwd = argv[++i];
+        }
+        else if (arg === '--agent' || arg === '-a') {
+            args.agent = argv[++i];
+        }
+    }
+    return args;
+}
+function printHelp() {
+    console.log(`
+amux - ACP Multiplexer
+
+Start an agent-powered HTTP server with multiplexed sessions.
+
+USAGE:
+  amux [OPTIONS]
+
+OPTIONS:
+  -p, --port <port>       Port to listen on (default: 3000 or PORT env)
+  -c, --context <file>    Load system context from a markdown file
+  -d, --cwd <path>        Fixed working directory for all sessions
+  -a, --agent <type>      Agent type: claude-code, codex, pi (default: claude-code)
+  -h, --help              Show this help message
+
+EXAMPLES:
+  # Start with defaults
+  amux
+
+  # Start with system context
+  amux --context ./PLUGIN_GUIDE.md
+
+  # Start for a specific project
+  amux --cwd /path/to/project --context ./CONTEXT.md
+
+  # Use a different agent
+  amux --agent codex
+
+ENVIRONMENT:
+  PORT          Server port (overridden by --port)
+  INSTANCE_ID   Unique instance identifier for state isolation
+`);
+}
+async function main() {
+    const args = parseArgs();
+    if (args.help) {
+        printHelp();
+        process.exit(0);
+    }
+    // Load system context if specified
+    let systemContext;
+    if (args.context) {
+        const contextPath = path.resolve(args.context);
+        if (!fs.existsSync(contextPath)) {
+            console.error(`Error: Context file not found: ${contextPath}`);
+            process.exit(1);
+        }
+        systemContext = fs.readFileSync(contextPath, 'utf-8');
+        console.log(`[amux] Loaded system context from ${contextPath} (${systemContext.length} bytes)`);
+    }
+    // Resolve fixed cwd if specified
+    let fixedCwd;
+    if (args.cwd) {
+        fixedCwd = path.resolve(args.cwd);
+        if (!fs.existsSync(fixedCwd)) {
+            console.error(`Error: Working directory not found: ${fixedCwd}`);
+            process.exit(1);
+        }
+        console.log(`[amux] Using fixed working directory: ${fixedCwd}`);
+    }
+    const { start, shutdown } = createAmuxServer({
+        port: args.port,
+        systemContext,
+        fixedCwd,
+        agentType: args.agent,
+    });
+    // Handle shutdown gracefully
+    process.on('SIGINT', () => {
+        console.log('\n[amux] Received SIGINT, shutting down...');
+        shutdown();
+        process.exit(0);
+    });
+    await start();
+}
+main().catch((err) => {
+    console.error('[amux] Fatal error:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"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"}

package/dist/client.d.ts

@@ -0,0 +1,68 @@
+import type * as acp from '@agentclientprotocol/sdk';
+import type { TerminalManager } from './terminal.js';
+import type { StoredEvent } from './types.js';
+/**
+ * Callback for routing events
+ */
+type EventCallback = (event: StoredEvent) => void;
+/**
+ * Pending permission request tracking
+ */
+interface PendingPermission {
+    resolve: (value: acp.RequestPermissionResponse) => void;
+    reject: (reason: Error) => void;
+    timeout: ReturnType<typeof setTimeout>;
+}
+/**
+ * ACP Client implementation.
+ * Bridges agent notifications to WebSocket clients and handles
+ * file operations and terminal management.
+ */
+export declare class AmuxClient implements acp.Client {
+    private terminalManager;
+    private onEvent;
+    pendingPermissions: Map<string, PendingPermission>;
+    constructor(terminalManager: TerminalManager, onEvent: EventCallback);
+    /**
+     * Handle permission request from agent
+     */
+    requestPermission(params: acp.RequestPermissionRequest): Promise<acp.RequestPermissionResponse>;
+    /**
+     * Handle permission response from UI
+     */
+    handlePermissionResponse(requestId: string, optionId: string): void;
+    /**
+     * Handle session update from agent
+     */
+    sessionUpdate(params: acp.SessionNotification): Promise<void>;
+    /**
+     * Write text file (ACP fs capability)
+     */
+    writeTextFile(params: acp.WriteTextFileRequest): Promise<acp.WriteTextFileResponse>;
+    /**
+     * Read text file (ACP fs capability)
+     */
+    readTextFile(params: acp.ReadTextFileRequest): Promise<acp.ReadTextFileResponse>;
+    /**
+     * Create terminal (ACP terminal capability)
+     */
+    createTerminal(params: acp.CreateTerminalRequest): Promise<acp.CreateTerminalResponse>;
+    /**
+     * Get terminal output (ACP terminal capability)
+     */
+    terminalOutput(params: acp.TerminalOutputRequest): Promise<acp.TerminalOutputResponse>;
+    /**
+     * Wait for terminal exit (ACP terminal capability)
+     */
+    waitForTerminalExit(params: acp.WaitForTerminalExitRequest): Promise<acp.WaitForTerminalExitResponse>;
+    /**
+     * Kill terminal (ACP terminal capability)
+     */
+    killTerminal(params: acp.KillTerminalCommandRequest): Promise<acp.KillTerminalCommandResponse>;
+    /**
+     * Release terminal (ACP terminal capability)
+     */
+    releaseTerminal(params: acp.ReleaseTerminalRequest): Promise<acp.ReleaseTerminalResponse>;
+}
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,GAAG,MAAM,0BAA0B,CAAC;AAGrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;GAEG;AACH,KAAK,aAAa,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;AAElD;;GAEG;AACH,UAAU,iBAAiB;IACzB,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,CAAC,yBAAyB,KAAK,IAAI,CAAC;IACxD,MAAM,EAAE,CAAC,MAAM,EAAE,KAAK,KAAK,IAAI,CAAC;IAChC,OAAO,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;CACxC;AAED;;;;GAIG;AACH,qBAAa,UAAW,YAAW,GAAG,CAAC,MAAM;IAIzC,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,OAAO;IAJjB,kBAAkB,iCAAwC;gBAGhD,eAAe,EAAE,eAAe,EAChC,OAAO,EAAE,aAAa;IAGhC;;OAEG;IACG,iBAAiB,CAAC,MAAM,EAAE,GAAG,CAAC,wBAAwB,GAAG,OAAO,CAAC,GAAG,CAAC,yBAAyB,CAAC;IAuBrG;;OAEG;IACH,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAWnE;;OAEG;IACG,aAAa,CAAC,MAAM,EAAE,GAAG,CAAC,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBnE;;OAEG;IACG,aAAa,CAAC,MAAM,EAAE,GAAG,CAAC,oBAAoB,GAAG,OAAO,CAAC,GAAG,CAAC,qBAAqB,CAAC;IAUzF;;OAEG;IACG,YAAY,CAAC,MAAM,EAAE,GAAG,CAAC,mBAAmB,GAAG,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC;IAUtF;;OAEG;IACG,cAAc,CAAC,MAAM,EAAE,GAAG,CAAC,qBAAqB,GAAG,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAC;IAI5F;;OAEG;IACG,cAAc,CAAC,MAAM,EAAE,GAAG,CAAC,qBAAqB,GAAG,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAC;IAI5F;;OAEG;IACG,mBAAmB,CAAC,MAAM,EAAE,GAAG,CAAC,0BAA0B,GAAG,OAAO,CAAC,GAAG,CAAC,2BAA2B,CAAC;IAI3G;;OAEG;IACG,YAAY,CAAC,MAAM,EAAE,GAAG,CAAC,0BAA0B,GAAG,OAAO,CAAC,GAAG,CAAC,2BAA2B,CAAC;IAIpG;;OAEG;IACG,eAAe,CAAC,MAAM,EAAE,GAAG,CAAC,sBAAsB,GAAG,OAAO,CAAC,GAAG,CAAC,uBAAuB,CAAC;CAGhG"}

package/dist/client.js

@@ -0,0 +1,135 @@
+import fs from 'fs';
+import crypto from 'crypto';
+import { isToolCallUpdate, normalizeSessionUpdate } from './session-updates.js';
+/**
+ * ACP Client implementation.
+ * Bridges agent notifications to WebSocket clients and handles
+ * file operations and terminal management.
+ */
+export class AmuxClient {
+    terminalManager;
+    onEvent;
+    pendingPermissions = new Map();
+    constructor(terminalManager, onEvent) {
+        this.terminalManager = terminalManager;
+        this.onEvent = onEvent;
+    }
+    /**
+     * Handle permission request from agent
+     */
+    async requestPermission(params) {
+        console.log('[amux] Permission request:', params.toolCall?.title);
+        // Send permission request
+        const requestId = crypto.randomUUID();
+        this.onEvent({
+            type: 'permission_request',
+            requestId,
+            toolCall: params.toolCall,
+            options: params.options,
+        });
+        // Wait for response from client (with timeout)
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingPermissions.delete(requestId);
+                resolve({ outcome: { outcome: 'cancelled' } });
+            }, 300000); // 5 minute timeout
+            this.pendingPermissions.set(requestId, { resolve, reject, timeout });
+        });
+    }
+    /**
+     * Handle permission response from UI
+     */
+    handlePermissionResponse(requestId, optionId) {
+        const pending = this.pendingPermissions.get(requestId);
+        if (pending) {
+            clearTimeout(pending.timeout);
+            this.pendingPermissions.delete(requestId);
+            pending.resolve({
+                outcome: { outcome: 'selected', optionId },
+            });
+        }
+    }
+    /**
+     * Handle session update from agent
+     */
+    async sessionUpdate(params) {
+        const update = params.update;
+        // Normalize the update (convert Claude-style diffs to unified format)
+        const normalized = normalizeSessionUpdate(update);
+        // Route to session
+        this.onEvent({ type: 'session_update', update: normalized });
+        // Log updates for debugging
+        if (update.sessionUpdate === 'agent_message_chunk') {
+            // Don't log every chunk
+        }
+        else if (isToolCallUpdate(update)) {
+            console.log(`[amux] Tool call: ${update.title} (${update.status}) id=${update.toolCallId}`);
+        }
+        else if (update.sessionUpdate === 'tool_call_update') {
+            // Don't log every update
+        }
+        else if (update.sessionUpdate === 'current_mode_update') {
+            console.log(`[amux] Mode update: ${update.currentModeId}`);
+        }
+        else {
+            console.log(`[amux] Session update: ${update.sessionUpdate}`);
+        }
+    }
+    /**
+     * Write text file (ACP fs capability)
+     */
+    async writeTextFile(params) {
+        console.log('[amux] Write text file:', params.path);
+        try {
+            fs.writeFileSync(params.path, params.content);
+            return {};
+        }
+        catch (err) {
+            throw new Error(`Failed to write file: ${err.message}`);
+        }
+    }
+    /**
+     * Read text file (ACP fs capability)
+     */
+    async readTextFile(params) {
+        console.log('[amux] Read text file:', params.path);
+        try {
+            const content = fs.readFileSync(params.path, 'utf-8');
+            return { content };
+        }
+        catch (err) {
+            throw new Error(`Failed to read file: ${err.message}`);
+        }
+    }
+    /**
+     * Create terminal (ACP terminal capability)
+     */
+    async createTerminal(params) {
+        return this.terminalManager.create(params);
+    }
+    /**
+     * Get terminal output (ACP terminal capability)
+     */
+    async terminalOutput(params) {
+        return this.terminalManager.getOutput(params.terminalId);
+    }
+    /**
+     * Wait for terminal exit (ACP terminal capability)
+     */
+    async waitForTerminalExit(params) {
+        return this.terminalManager.waitForExit(params.terminalId);
+    }
+    /**
+     * Kill terminal (ACP terminal capability)
+     */
+    async killTerminal(params) {
+        return this.terminalManager.kill(params.terminalId);
+    }
+    /**
+     * Release terminal (ACP terminal capability)
+     */
+    async releaseTerminal(params) {
+        return this.terminalManager.release(params.terminalId);
+    }
+}
+//# sourceMappingURL=client.js.map