amp-acp 0.1.0

package/README.md

@@ -0,0 +1,45 @@
+# ACP adapter for Amp
+
+Use [Amp](https://ampcode.com) from ACP-compatible clients such as [Zed](https://zed.dev).
+
+## Prerequisites
+
+- [Amp CLI](https://ampcode.com) installed and authenticated (`amp login`)
+- Node.js (for running the adapter)
+
+## Installation
+
+```bash
+npm install -g amp-acp
+```
+
+Or run locally:
+
+```bash
+npm install
+npm start
+```
+
+## Usage
+
+1. Start the adapter:
+   ```bash
+   amp-acp
+   ```
+
+2. In Zed:
+   - Open Settings → External Agents (ACP)
+   - Connect to the adapter
+   - Start a new Amp thread
+
+## How it Works
+
+- Streams Amp's Claude Code–compatible JSON over ACP
+- Renders Amp messages and interactions in Zed
+- Tool permissions are handled by Amp (no additional configuration needed)
+
+## Troubleshooting
+
+**Connection fails**: Ensure `amp login` was successful and the CLI is in your PATH.
+
+**Adapter not found**: Check that `amp-acp` is running before connecting from Zed.

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "amp-acp",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "bin": {
+    "amp-acp": "./src/index.js"
+  },
+  "description": "ACP adapter that bridges Amp CLI to Agent Client Protocol (Zed external agent)",
+  "license": "Apache-2.0",
+  "scripts": {
+    "start": "node src/index.js",
+    "lint": "echo 'no lint'",
+    "test": "node -e 'console.log(\"OK\")'"
+  },
+  "dependencies": {
+    "@agentclientprotocol/sdk": "0.4.8"
+  }
+}

package/src/index.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+// stdout is reserved for ACP stream. Redirect logs to stderr.
+console.log = console.error;
+console.info = console.error;
+console.warn = console.error;
+console.debug = console.error;
+
+import { runAcp } from './run-acp.js';
+
+runAcp();
+
+// Keep process alive
+process.stdin.resume();

package/src/run-acp.js

@@ -0,0 +1,10 @@
+import { AgentSideConnection, ndJsonStream } from '@agentclientprotocol/sdk';
+import { nodeToWebReadable, nodeToWebWritable } from './utils.js';
+import { AmpAcpAgent } from './server.js';
+
+export function runAcp() {
+  const input = nodeToWebWritable(process.stdout);
+  const output = nodeToWebReadable(process.stdin);
+  const stream = ndJsonStream(input, output);
+  new AgentSideConnection((client) => new AmpAcpAgent(client), stream);
+}

package/src/server.js

@@ -0,0 +1,215 @@
+import { RequestError } from '@agentclientprotocol/sdk';
+import { spawn } from 'node:child_process';
+import readline from 'node:readline';
+import { toAcpNotifications } from './to-acp.js';
+
+export class AmpAcpAgent {
+  constructor(client) {
+    this.client = client;
+    this.sessions = new Map();
+  }
+
+  async initialize(request) {
+    this.clientCapabilities = request.clientCapabilities;
+    return {
+      protocolVersion: 1,
+      agentCapabilities: {
+        promptCapabilities: { image: true, embeddedContext: true },
+      },
+      authMethods: [],
+    };
+  }
+
+  async newSession(params) {
+    const sessionId = `S-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+
+    this.sessions.set(sessionId, {
+      proc: null,
+      rl: null,
+      queue: null,
+      cancelled: false,
+      active: false,
+    });
+
+    return {
+      sessionId,
+      models: { currentModelId: 'default', availableModels: [{ modelId: 'default', name: 'Default', description: 'Amp default' }] },
+      modes: {
+        currentModeId: 'default',
+        availableModes: [
+          { id: 'default', name: 'Always Ask', description: 'Prompts for permission on first use of each tool' },
+          { id: 'acceptEdits', name: 'Accept Edits', description: 'Automatically accepts file edit permissions for the session' },
+          { id: 'bypassPermissions', name: 'Bypass Permissions', description: 'Skips all permission prompts' },
+          { id: 'plan', name: 'Plan Mode', description: 'Analyze but not modify files or execute commands' },
+        ],
+      },
+    };
+  }
+
+  async authenticate(_params) {
+    throw RequestError.authRequired();
+  }
+
+  async prompt(params) {
+    const s = this.sessions.get(params.sessionId);
+    if (!s) throw new Error('Session not found');
+    s.cancelled = false;
+    s.active = true;
+
+    // Start a fresh Amp process per turn (amp -x is single-turn). Avoid reusing prior proc to prevent races.
+    const proc = spawn('amp', ['-x', '--stream-json', '--stream-json-input'], {
+      cwd: params.cwd || process.cwd(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: process.env,
+    });
+    const rl = readline.createInterface({ input: proc.stdout });
+    const queue = createJsonQueue(rl);
+    // Capture exit to clean state
+    proc.on('close', () => {
+      // Do not null out queue while a turn may still await next(); just signal end
+      try { queue?.end?.(); } catch {}
+    });
+    // Optionally log stderr (redirected to our stderr by default)
+    proc.stderr?.on('data', (d) => {
+      console.error(`[amp] ${d.toString()}`.trim());
+    });
+    s.proc = proc;
+    s.rl = rl;
+    s.queue = queue;
+    // Don't wait for init; amp will emit it before assistant/user events
+
+    // Build Amp user message JSON line from ACP prompt chunks
+    const content = [];
+    for (const chunk of params.prompt) {
+      switch (chunk.type) {
+        case 'text':
+          content.push({ type: 'text', text: chunk.text });
+          break;
+        case 'resource_link':
+          content.push({ type: 'text', text: chunk.uri });
+          break;
+        case 'resource':
+          if ('text' in chunk.resource) {
+            content.push({ type: 'text', text: chunk.resource.uri });
+            content.push({ type: 'text', text: `\n<context ref="${chunk.resource.uri}">\n${chunk.resource.text}\n</context>` });
+          }
+          break;
+        case 'image':
+          if (chunk.data) {
+            content.push({ type: 'image', source: { type: 'base64', data: chunk.data, media_type: chunk.mimeType } });
+          } else if (chunk.uri && chunk.uri.startsWith('http')) {
+            content.push({ type: 'image', source: { type: 'url', url: chunk.uri } });
+          }
+          break;
+        default:
+          break;
+      }
+    }
+
+    const userMsg = {
+      type: 'user',
+      message: { role: 'user', content },
+      parent_tool_use_id: null,
+      session_id: params.sessionId,
+    };
+
+    s.proc.stdin.write(JSON.stringify(userMsg) + '\n');
+
+    try {
+      while (true) {
+        const msg = await s.queue.next();
+        if (msg == null) {
+          return { stopReason: s.cancelled ? 'cancelled' : 'refusal' };
+        }
+        switch (msg.type) {
+        case 'system':
+          // ignore init/compact/etc
+          break;
+        case 'assistant': {
+          const notifs = toAcpNotifications(msg, params.sessionId);
+          for (const n of notifs) await this.client.sessionUpdate(n);
+          break;
+        }
+        case 'user': {
+          // Skip echoing user messages to avoid duplicates in the client UI
+          break;
+        }
+        case 'result': {
+          if (msg.subtype === 'success') return { stopReason: 'end_turn' };
+          if (msg.subtype === 'error_max_turns') return { stopReason: 'max_turn_requests' };
+          return { stopReason: 'refusal' };
+        }
+        default:
+          break;
+        }
+      }
+      throw new Error('Session did not end in result');
+    } finally {
+      s.active = false;
+      s.cancelled = false;
+    }
+  }
+
+  async cancel(params) {
+    const s = this.sessions.get(params.sessionId);
+    if (!s) return {};
+    if (s.active && s.proc) {
+      s.cancelled = true;
+      try { s.proc.kill('SIGINT'); } catch {}
+      // ensure readers unblock
+      try { s.queue?.end?.(); } catch {}
+    }
+    return {};
+  }
+
+  async setSessionModel(_params) { return {}; }
+
+  async setSessionMode(_params) { return {}; }
+
+  async readTextFile(params) { return this.client.readTextFile(params); }
+  async writeTextFile(params) { return this.client.writeTextFile(params); }
+}
+
+function createJsonQueue(rl) {
+  const buf = [];
+  const waiters = [];
+  rl.on('line', (line) => {
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      return; // ignore non-JSON
+    }
+    if (waiters.length) {
+      const resolve = waiters.shift();
+      resolve(obj);
+    } else {
+      buf.push(obj);
+    }
+  });
+  let ended = false;
+  function end() {
+    if (ended) return;
+    ended = true;
+    while (waiters.length) {
+      const resolve = waiters.shift();
+      resolve(null);
+    }
+  }
+  rl.on('close', end);
+  rl.on('SIGINT', end);
+  return {
+    next() {
+      return new Promise((resolve) => {
+        if (buf.length) {
+          resolve(buf.shift());
+        } else if (ended) {
+          resolve(null);
+        } else {
+          waiters.push(resolve);
+        }
+      });
+    },
+    end,
+  };
+}

package/src/to-acp.js

@@ -0,0 +1,91 @@
+// Minimal conversion from Amp stream JSON events (Claude Code compatible)
+// into ACP sessionUpdate notifications. Based on zed-industries/claude-code-acp.
+
+export function toAcpNotifications(message, sessionId) {
+  const content = message.message?.content;
+  if (typeof content === 'string') {
+    return [
+      {
+        sessionId,
+        update: {
+          sessionUpdate: message.type === 'assistant' ? 'agent_message_chunk' : 'user_message_chunk',
+          content: { type: 'text', text: content },
+        },
+      },
+    ];
+  }
+  const output = [];
+  if (!Array.isArray(content)) return output;
+  for (const chunk of content) {
+    let update = null;
+    switch (chunk.type) {
+      case 'text':
+        update = {
+          sessionUpdate: message.type === 'assistant' ? 'agent_message_chunk' : 'user_message_chunk',
+          content: { type: 'text', text: chunk.text },
+        };
+        break;
+      case 'image':
+        update = {
+          sessionUpdate: message.type === 'assistant' ? 'agent_message_chunk' : 'user_message_chunk',
+          content: {
+            type: 'image',
+            data: chunk.source?.type === 'base64' ? chunk.source.data : '',
+            mimeType: chunk.source?.type === 'base64' ? chunk.source.media_type : '',
+            uri: chunk.source?.type === 'url' ? chunk.source.url : undefined,
+          },
+        };
+        break;
+      case 'thinking':
+        update = {
+          sessionUpdate: 'agent_thought_chunk',
+          content: { type: 'text', text: chunk.thinking },
+        };
+        break;
+      case 'tool_use':
+        update = {
+          toolCallId: chunk.id,
+          sessionUpdate: 'tool_call',
+          rawInput: safeJson(chunk.input),
+          status: 'pending',
+          title: chunk.name || 'Tool',
+          kind: 'other',
+          content: [],
+        };
+        break;
+      case 'tool_result':
+        update = {
+          toolCallId: chunk.tool_use_id,
+          sessionUpdate: 'tool_call_update',
+          status: chunk.is_error ? 'failed' : 'completed',
+          content: toAcpContentArray(chunk.content, chunk.is_error),
+        };
+        break;
+      default:
+        break;
+    }
+    if (update) output.push({ sessionId, update });
+  }
+  return output;
+}
+
+function toAcpContentArray(content, isError = false) {
+  if (Array.isArray(content) && content.length > 0) {
+    return content.map((c) => ({
+      type: 'content',
+      content: c.type === 'text' ? { type: 'text', text: isError ? wrapCode(c.text) : c.text } : c,
+    }));
+  }
+  if (typeof content === 'string' && content.length > 0) {
+    return [{ type: 'content', content: { type: 'text', text: isError ? wrapCode(content) : content } }];
+  }
+  return [];
+}
+
+function wrapCode(t) {
+  return '```\n' + t + '\n```';
+}
+
+function safeJson(x) {
+  try { return JSON.parse(JSON.stringify(x)); } catch { return undefined; }
+}

package/src/utils.js

@@ -0,0 +1,27 @@
+import { WritableStream, ReadableStream } from 'node:stream/web';
+
+export function nodeToWebWritable(nodeStream) {
+  return new WritableStream({
+    write(chunk) {
+      return new Promise((resolve, reject) => {
+        nodeStream.write(Buffer.from(chunk), (err) => {
+          if (err) reject(err); else resolve();
+        });
+      });
+    },
+  });
+}
+
+export function nodeToWebReadable(nodeStream) {
+  return new ReadableStream({
+    start(controller) {
+      nodeStream.on('data', (chunk) => controller.enqueue(new Uint8Array(chunk)));
+      nodeStream.on('end', () => controller.close());
+      nodeStream.on('error', (err) => controller.error(err));
+    },
+  });
+}
+
+export function unreachable(x) {
+  throw new Error(`unreachable: ${JSON.stringify(x)}`);
+}