@bytespell/amux 0.0.12 → 0.0.15

package/src/session-updates.test.ts

@@ -0,0 +1,265 @@
+import { describe, it, expect } from 'vitest';
+import {
+  isToolCallUpdate,
+  isToolCallUpdateMessage,
+  normalizeSessionUpdate,
+} from './session-updates.js';
+import type * as acp from '@agentclientprotocol/sdk';
+
+describe('isToolCallUpdate', () => {
+  it('returns true for tool_call updates', () => {
+    const update = {
+      sessionUpdate: 'tool_call',
+      id: 'test',
+      title: 'Test',
+      status: 'pending',
+    } as acp.SessionUpdate;
+    expect(isToolCallUpdate(update)).toBe(true);
+  });
+
+  it('returns false for other update types', () => {
+    const update = {
+      sessionUpdate: 'agent_message_chunk',
+      content: { type: 'text', text: 'hello' },
+    } as acp.SessionUpdate;
+    expect(isToolCallUpdate(update)).toBe(false);
+  });
+});
+
+describe('isToolCallUpdateMessage', () => {
+  it('returns true for tool_call_update updates', () => {
+    const update = {
+      sessionUpdate: 'tool_call_update',
+      id: 'test',
+    } as acp.SessionUpdate;
+    expect(isToolCallUpdateMessage(update)).toBe(true);
+  });
+
+  it('returns false for other update types', () => {
+    const update = {
+      sessionUpdate: 'tool_call',
+      id: 'test',
+      title: 'Test',
+      status: 'pending',
+    } as acp.SessionUpdate;
+    expect(isToolCallUpdateMessage(update)).toBe(false);
+  });
+});
+
+describe('normalizeSessionUpdate', () => {
+  it('passes through non-tool updates unchanged', () => {
+    const update: acp.SessionUpdate = {
+      sessionUpdate: 'agent_message_chunk',
+      content: { type: 'text', text: 'hello' },
+    };
+    const result = normalizeSessionUpdate(update);
+    expect(result).toEqual(update);
+  });
+
+  it('passes through turn_start unchanged', () => {
+    const update: acp.SessionUpdate = {
+      sessionUpdate: 'turn_start',
+    };
+    const result = normalizeSessionUpdate(update);
+    expect(result).toEqual(update);
+  });
+
+  it('passes through turn_end unchanged', () => {
+    const update: acp.SessionUpdate = {
+      sessionUpdate: 'turn_end',
+    };
+    const result = normalizeSessionUpdate(update);
+    expect(result).toEqual(update);
+  });
+
+  it('passes through tool_call without content unchanged', () => {
+    const update = {
+      sessionUpdate: 'tool_call',
+      id: 'test',
+      title: 'Test Tool',
+      status: 'pending',
+    } as acp.SessionUpdate;
+    const result = normalizeSessionUpdate(update);
+    expect(result).toEqual(update);
+  });
+
+  it('passes through tool_call with non-diff content unchanged', () => {
+    const update = {
+      sessionUpdate: 'tool_call',
+      id: 'test',
+      title: 'Test Tool',
+      status: 'pending',
+      content: [{ type: 'text', text: 'some output' }],
+    } as acp.SessionUpdate;
+    const result = normalizeSessionUpdate(update);
+    expect(result).toEqual(update);
+  });
+
+  it('normalizes tool_call with diff content', () => {
+    const update = {
+      sessionUpdate: 'tool_call',
+      id: 'test',
+      title: 'Edit File',
+      status: 'completed',
+      content: [
+        {
+          type: 'diff',
+          oldText: 'old content',
+          newText: 'new content',
+          path: '/path/to/file.ts',
+        },
+      ],
+    } as acp.SessionUpdate;
+
+    const result = normalizeSessionUpdate(update);
+
+    // Should have same structure but with normalized diff
+    expect(result.sessionUpdate).toBe('tool_call');
+    expect((result as { content?: acp.ToolCallContent[] }).content).toHaveLength(1);
+
+    const diffContent = (result as { content: acp.ToolCallContent[] }).content[0];
+    expect(diffContent.type).toBe('diff');
+
+    // The newText should now contain unified diff format
+    const normalizedDiff = diffContent as { newText: string; oldText: string; path: string };
+    expect(normalizedDiff.newText).toContain('Index: /path/to/file.ts');
+    expect(normalizedDiff.newText).toContain('---');
+    expect(normalizedDiff.newText).toContain('+++');
+    expect(normalizedDiff.newText).toContain('-old content');
+    expect(normalizedDiff.newText).toContain('+new content');
+    expect(normalizedDiff.oldText).toBe('');
+    expect(normalizedDiff.path).toBe('/path/to/file.ts');
+  });
+
+  it('normalizes tool_call_update with diff content', () => {
+    const update = {
+      sessionUpdate: 'tool_call_update',
+      id: 'test',
+      content: [
+        {
+          type: 'diff',
+          oldText: 'line1\nline2',
+          newText: 'line1\nmodified',
+          path: 'test.ts',
+        },
+      ],
+    } as acp.SessionUpdate;
+
+    const result = normalizeSessionUpdate(update);
+    const diffContent = (result as { content: acp.ToolCallContent[] }).content[0] as {
+      newText: string;
+    };
+
+    expect(diffContent.newText).toContain('-line1');
+    expect(diffContent.newText).toContain('-line2');
+    expect(diffContent.newText).toContain('+line1');
+    expect(diffContent.newText).toContain('+modified');
+  });
+
+  it('handles empty oldText (new file creation)', () => {
+    const update = {
+      sessionUpdate: 'tool_call',
+      id: 'test',
+      title: 'Write File',
+      status: 'completed',
+      content: [
+        {
+          type: 'diff',
+          oldText: '',
+          newText: 'new file content',
+          path: 'new-file.ts',
+        },
+      ],
+    } as acp.SessionUpdate;
+
+    const result = normalizeSessionUpdate(update);
+    const diffContent = (result as { content: acp.ToolCallContent[] }).content[0] as {
+      newText: string;
+    };
+
+    expect(diffContent.newText).toContain('@@ -0,0 +1,1 @@');
+    expect(diffContent.newText).toContain('+new file content');
+    // No removed lines in the diff body (lines starting with - followed by content, not headers)
+    const lines = diffContent.newText.split('\n');
+    const removedLines = lines.filter(l => l.startsWith('-') && !l.startsWith('---'));
+    expect(removedLines).toHaveLength(0);
+  });
+
+  it('handles multi-line diffs', () => {
+    const update = {
+      sessionUpdate: 'tool_call',
+      id: 'test',
+      title: 'Edit File',
+      status: 'completed',
+      content: [
+        {
+          type: 'diff',
+          oldText: 'line1\nline2\nline3',
+          newText: 'line1\nmodified\nline3\nline4',
+          path: 'file.ts',
+        },
+      ],
+    } as acp.SessionUpdate;
+
+    const result = normalizeSessionUpdate(update);
+    const diffContent = (result as { content: acp.ToolCallContent[] }).content[0] as {
+      newText: string;
+    };
+
+    // Should have correct line counts in header
+    expect(diffContent.newText).toContain('@@ -1,3 +1,4 @@');
+  });
+
+  it('uses "file" as default path when path is missing', () => {
+    const update = {
+      sessionUpdate: 'tool_call',
+      id: 'test',
+      title: 'Edit',
+      status: 'completed',
+      content: [
+        {
+          type: 'diff',
+          oldText: 'old',
+          newText: 'new',
+          // path intentionally omitted
+        },
+      ],
+    } as acp.SessionUpdate;
+
+    const result = normalizeSessionUpdate(update);
+    const diffContent = (result as { content: acp.ToolCallContent[] }).content[0] as {
+      newText: string;
+      path: string;
+    };
+
+    expect(diffContent.newText).toContain('Index: file');
+    expect(diffContent.path).toBe('file');
+  });
+
+  it('preserves mixed content types in tool_call', () => {
+    const update = {
+      sessionUpdate: 'tool_call',
+      id: 'test',
+      title: 'Complex Tool',
+      status: 'completed',
+      content: [
+        { type: 'text', text: 'Before diff' },
+        {
+          type: 'diff',
+          oldText: 'old',
+          newText: 'new',
+          path: 'file.ts',
+        },
+        { type: 'text', text: 'After diff' },
+      ],
+    } as acp.SessionUpdate;
+
+    const result = normalizeSessionUpdate(update);
+    const content = (result as { content: acp.ToolCallContent[] }).content;
+
+    expect(content).toHaveLength(3);
+    expect(content[0]).toEqual({ type: 'text', text: 'Before diff' });
+    expect(content[1]?.type).toBe('diff');
+    expect(content[2]).toEqual({ type: 'text', text: 'After diff' });
+  });
+});

package/src/session.ts

@@ -1,9 +1,16 @@
-import { spawn, type ChildProcess } from 'child_process';
+import { spawn, execSync, type ChildProcess } from 'child_process';
 import { EventEmitter } from 'events';
 import os from 'os';
 import path from 'path';
+import { fileURLToPath } from 'url';
 import { Writable, Readable } from 'stream';
 
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/** Path to amux's own node_modules/.bin where ACP wrappers are installed */
+const AMUX_BIN_DIR = path.join(__dirname, '..', 'node_modules', '.bin');
+
 import * as acp from '@agentclientprotocol/sdk';
 
 import { AmuxClient } from './client.js';
@@ -20,6 +27,32 @@ import { AGENTS as DEFAULT_AGENTS } from './types.js';
 
 const INIT_TIMEOUT_MS = 90000;
 
+/**
+ * Check if a binary is available on PATH
+ */
+function isOnPath(bin: string): boolean {
+  try {
+    const cmd = process.platform === 'win32' ? 'where' : 'which';
+    execSync(`${cmd} ${bin}`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if an ACP wrapper binary exists in amux's node_modules
+ */
+function hasAcpWrapper(acpBin: string): boolean {
+  const binPath = path.join(AMUX_BIN_DIR, acpBin);
+  try {
+    execSync(`test -x "${binPath}"`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Events emitted by AgentSession
  */
@@ -75,7 +108,6 @@ function withTimeout<T>(promise: Promise<T>, ms: number, operation: string): Pro
  * ```typescript
  * const session = new AgentSession({
  *   instanceId: 'my-instance',
- *   basePath: __dirname,
  * });
  *
  * session.on('ready', (data) => console.log('Ready:', data));
@@ -96,6 +128,7 @@ export class AgentSession extends EventEmitter {
   private agentProcess: ChildProcess | null = null;
   private acpConnection: acp.ClientSideConnection | null = null;
   private _agentCapabilities: acp.AgentCapabilities | null = null;
+  private _changingCwd = false;
 
   // Components
   private terminalManager: TerminalManager;
@@ -104,7 +137,6 @@ export class AgentSession extends EventEmitter {
 
   // Config
   private instanceId: string;
-  private basePath: string;
   private fixedCwd?: string;
   private agents: Record<string, AgentConfig>;
 
@@ -112,7 +144,6 @@ export class AgentSession extends EventEmitter {
     super();
 
     this.instanceId = config.instanceId;
-    this.basePath = config.basePath;
     this.fixedCwd = config.fixedCwd;
     this._systemContext = config.systemContext;
     this.agents = DEFAULT_AGENTS;
@@ -187,10 +218,23 @@ export class AgentSession extends EventEmitter {
   }
 
   /**
-   * Get available agents list
+   * Get available agents list (checks if base CLI is on PATH and ACP wrapper is bundled)
+   */
+  getAvailableAgents(): Array<{ id: string; name: string; installed: boolean }> {
+    return Object.entries(this.agents).map(([id, a]) => ({
+      id,
+      name: a.name,
+      installed: isOnPath(a.cli) && hasAcpWrapper(a.acpBin),
+    }));
+  }
+
+  /**
+   * Get only installed agents
    */
-  getAvailableAgents(): Array<{ id: string; name: string }> {
-    return Object.entries(this.agents).map(([id, a]) => ({ id, name: a.name }));
+  getInstalledAgents(): Array<{ id: string; name: string }> {
+    return this.getAvailableAgents()
+      .filter((a) => a.installed)
+      .map(({ id, name }) => ({ id, name }));
   }
 
   /**
@@ -243,11 +287,29 @@ export class AgentSession extends EventEmitter {
       return;
     }
 
+    // Check if base CLI is installed
+    if (!isOnPath(agent.cli)) {
+      console.error(`[amux] Agent CLI not found on PATH: ${agent.cli}`);
+      this.emit('error', {
+        message: `Agent "${agent.cli}" not found. Install it globally or add it to your PATH.`,
+      });
+      return;
+    }
+
+    // Check if ACP wrapper is bundled
+    const acpBinPath = path.join(AMUX_BIN_DIR, agent.acpBin);
+    if (!hasAcpWrapper(agent.acpBin)) {
+      console.error(`[amux] ACP wrapper not found: ${acpBinPath}`);
+      this.emit('error', {
+        message: `ACP wrapper "${agent.acpBin}" not bundled. This is an amux installation issue.`,
+      });
+      return;
+    }
+
     console.log(`[amux] Spawning ${agent.name} agent in cwd:`, this._cwd);
     this.emit('connecting', {});
 
-    const agentBin = path.join(this.basePath, 'node_modules', '.bin', agent.bin);
-    const newProcess = spawn(agentBin, [], {
+    const newProcess = spawn(acpBinPath, [], {
       stdio: ['pipe', 'pipe', 'pipe'],
       env: { ...process.env },
       cwd: this._cwd,
@@ -323,7 +385,7 @@ export class AgentSession extends EventEmitter {
         sessionRestore,
         capabilities: this._agentCapabilities,
         agent: this.getAgentInfo(),
-        availableAgents: this.getAvailableAgents(),
+        availableAgents: this.getInstalledAgents(),
       });
 
     } catch (err) {
@@ -617,12 +679,29 @@ export class AgentSession extends EventEmitter {
       throw new Error('Working directory is fixed for this session');
     }
 
-    this._cwd = newPath;
-    this._sessionId = null;
-    this.saveState();
+    // Prevent concurrent cwd changes
+    if (this._changingCwd) {
+      console.log('[amux] changeCwd already in progress, ignoring');
+      return;
+    }
 
-    await this.killAgent();
-    await this.spawnAgent();
+    // Same path, nothing to do
+    if (newPath === this._cwd) {
+      console.log('[amux] changeCwd same path, ignoring');
+      return;
+    }
+
+    this._changingCwd = true;
+    try {
+      this._cwd = newPath;
+      this._sessionId = null;
+      this.saveState();
+
+      await this.killAgent();
+      await this.spawnAgent();
+    } finally {
+      this._changingCwd = false;
+    }
   }
 
   /**

package/src/types.ts

@@ -5,7 +5,10 @@ import type * as acp from '@agentclientprotocol/sdk';
  */
 export interface AgentConfig {
   name: string;
-  bin: string;
+  /** The base CLI binary name (for checking if installed) */
+  cli: string;
+  /** The ACP wrapper binary name (bundled with amux) */
+  acpBin: string;
 }
 
 /**
@@ -14,15 +17,18 @@ export interface AgentConfig {
 export const AGENTS: Record<string, AgentConfig> = {
   'claude-code': {
     name: 'Claude Code',
-    bin: 'claude-code-acp',
+    cli: 'claude',
+    acpBin: 'claude-code-acp',
   },
   'codex': {
     name: 'Codex',
-    bin: 'codex-acp',
+    cli: 'codex',
+    acpBin: 'codex-acp',
   },
   'pi': {
     name: 'Pi',
-    bin: 'pi-acp',
+    cli: 'pi',
+    acpBin: 'pi-acp',
   },
 };
 
@@ -71,9 +77,6 @@ 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;
 

package/tsconfig.json

@@ -18,5 +18,5 @@
     "noUnusedParameters": true
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
+  "exclude": ["node_modules", "dist", "src/**/*.test.ts"]
 }

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['src/**/*.test.ts'],
+  },
+});