@almyty/acp-server 1.2.0 → 1.5.0

package/README.md

@@ -54,8 +54,10 @@ almyty is the full-stack platform for AI agents, agnostic by design: any LLM, an
 API turned into tools, served over MCP, A2A, UTCP, and Agent Skills. Open source,
 no lock-in.
 
-- Website — https://almyty.com
-- Docs — https://docs.almyty.com
-- Source — https://github.com/almyty-inc/almyty
+- Website: https://almyty.com
+- Docs: https://docs.almyty.com
+- Source: https://github.com/almyty-inc/almyty
+
+This CLI is part of the `@almyty/*` suite (versioned together at 1.x) and works with the almyty platform 0.1 and later.
 
 Apache-2.0 © Almyty Inc.

package/dist/__tests__/dispatch.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/dispatch.test.js

@@ -0,0 +1,129 @@
+/**
+ * Unit tests for the stdio line dispatcher.
+ *
+ * The behaviour under test is the one readline makes easy to get wrong:
+ * every line already sitting in the stdin pipe is delivered in a single
+ * synchronous burst, so the lazy agent resolution has to be guarded by the
+ * in-flight promise rather than by the settled value.
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { createLineHandler } from '../dispatch.js';
+/** A stand-in agent that records everything it is handed. */
+class RecordingAgent {
+    seen = [];
+    async handleMessage(msg) {
+        this.seen.push(msg);
+    }
+}
+const req = (id, method) => JSON.stringify(id === null ? { jsonrpc: '2.0', method } : { jsonrpc: '2.0', id, method });
+describe('createLineHandler', () => {
+    it('resolves the agent once for a burst of lines and shares it', async () => {
+        const agents = [];
+        const resolveAgent = vi.fn(async () => {
+            // A real resolution is at least one HTTP round-trip away.
+            await new Promise((r) => setTimeout(r, 10));
+            const agent = new RecordingAgent();
+            agents.push(agent);
+            return agent;
+        });
+        const handleLine = createLineHandler({ resolveAgent, send: vi.fn() });
+        // readline delivers a buffered burst synchronously, one call per line,
+        // without awaiting any of them.
+        await Promise.all([
+            handleLine(req(1, 'initialize')),
+            handleLine(req(2, 'session/new')),
+            handleLine(req(3, 'session/list')),
+        ]);
+        expect(resolveAgent).toHaveBeenCalledTimes(1);
+        expect(agents).toHaveLength(1);
+        expect(agents[0].seen.map((m) => m.id)).toEqual(expect.arrayContaining([1, 2, 3]));
+        expect(agents[0].seen).toHaveLength(3);
+    });
+    it('reuses the resolved agent for later lines', async () => {
+        const agent = new RecordingAgent();
+        const resolveAgent = vi.fn(async () => agent);
+        const handleLine = createLineHandler({ resolveAgent, send: vi.fn() });
+        await handleLine(req(1, 'initialize'));
+        await handleLine(req(2, 'session/new'));
+        expect(resolveAgent).toHaveBeenCalledTimes(1);
+        expect(agent.seen).toHaveLength(2);
+    });
+    it('answers every line of a burst when resolution fails, and retries later', async () => {
+        const send = vi.fn();
+        const resolveAgent = vi
+            .fn()
+            .mockRejectedValueOnce(new Error('No auth token. Run: npx @almyty/auth login'))
+            .mockResolvedValueOnce(new RecordingAgent());
+        const handleLine = createLineHandler({ resolveAgent, send });
+        await Promise.all([handleLine(req(1, 'initialize')), handleLine(req(2, 'session/new'))]);
+        expect(resolveAgent).toHaveBeenCalledTimes(1);
+        expect(send).toHaveBeenCalledTimes(2);
+        for (const [msg] of send.mock.calls) {
+            expect(msg.error.code).toBe(-32603);
+            expect(msg.error.message).toBe('No auth token. Run: npx @almyty/auth login');
+        }
+        expect(send.mock.calls.map(([m]) => m.id)).toEqual([1, 2]);
+        // The failed memo is cleared, so a later message tries again.
+        send.mockClear();
+        await handleLine(req(3, 'initialize'));
+        expect(resolveAgent).toHaveBeenCalledTimes(2);
+        expect(send).not.toHaveBeenCalled();
+    });
+    it('ignores blank lines without resolving an agent', async () => {
+        const resolveAgent = vi.fn(async () => new RecordingAgent());
+        const send = vi.fn();
+        const handleLine = createLineHandler({ resolveAgent, send });
+        await handleLine('');
+        await handleLine('   \t ');
+        expect(resolveAgent).not.toHaveBeenCalled();
+        expect(send).not.toHaveBeenCalled();
+    });
+    it('answers unparseable input with a parse error and no agent resolution', async () => {
+        const resolveAgent = vi.fn(async () => new RecordingAgent());
+        const send = vi.fn();
+        const handleLine = createLineHandler({ resolveAgent, send });
+        await handleLine('{not json');
+        expect(resolveAgent).not.toHaveBeenCalled();
+        expect(send).toHaveBeenCalledWith({
+            jsonrpc: '2.0',
+            id: null,
+            error: { code: -32700, message: 'Parse error' },
+        });
+    });
+    it('rejects a malformed envelope that still carries an id', async () => {
+        const send = vi.fn();
+        const handleLine = createLineHandler({ resolveAgent: vi.fn(), send });
+        await handleLine(JSON.stringify({ jsonrpc: '1.0', id: 7, method: 'initialize' }));
+        await handleLine(JSON.stringify({ jsonrpc: '2.0', id: 8 })); // no method
+        expect(send.mock.calls.map(([m]) => m)).toEqual([
+            { jsonrpc: '2.0', id: 7, error: { code: -32600, message: 'Invalid request' } },
+            { jsonrpc: '2.0', id: 8, error: { code: -32600, message: 'Invalid request' } },
+        ]);
+    });
+    it('stays silent for a malformed notification', async () => {
+        const send = vi.fn();
+        const handleLine = createLineHandler({ resolveAgent: vi.fn(), send });
+        await handleLine(JSON.stringify({ jsonrpc: '2.0' }));
+        expect(send).not.toHaveBeenCalled();
+    });
+    it('turns a thrown handler into an internal error for requests only', async () => {
+        const send = vi.fn();
+        const log = vi.fn();
+        const agent = {
+            handleMessage: vi.fn(async () => {
+                throw new Error('boom');
+            }),
+        };
+        const handleLine = createLineHandler({ resolveAgent: async () => agent, send, log });
+        await handleLine(req(9, 'session/new'));
+        expect(send).toHaveBeenCalledWith({
+            jsonrpc: '2.0',
+            id: 9,
+            error: { code: -32603, message: 'Internal error' },
+        });
+        send.mockClear();
+        await handleLine(req(null, 'session/cancel')); // notification: no id
+        expect(send).not.toHaveBeenCalled();
+        expect(log).toHaveBeenCalledTimes(2);
+    });
+});

package/dist/__tests__/integration.test.js

@@ -3,51 +3,66 @@
  * connect via stdin/stdout ndjson, run the full ACP lifecycle.
  *
  * Uses a mock HTTP server standing in for the almyty backend.
+ *
+ * No sleep before the first request: stdin is a pipe, so anything written
+ * before the child finishes booting is buffered by the OS and delivered to
+ * readline the moment the loop attaches. Readiness is the handshake reply
+ * itself, and every read goes through one persistent reader so a response
+ * can never land between two short-lived ones.
  */
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
 import { spawn } from 'node:child_process';
 import { createServer } from 'node:http';
-import { createInterface } from 'node:readline';
 import { resolve } from 'node:path';
 // ── Mock backend ────────────────────────────────────────────────
+/**
+ * Agent ids are UUIDs everywhere in almyty; the server only takes its
+ * `GET /agents/:id` fast path for a UUID and otherwise resolves the
+ * argument as a name or slug against `GET /agents`.
+ */
+const AGENT_ID = '7c9e6679-7425-40de-944b-e07fc1f90ae7';
 const MOCK_AGENT = {
-    id: 'agent-123',
+    id: AGENT_ID,
     name: 'Test Agent',
+    slug: 'test-agent',
     description: 'A test agent',
     mode: 'autonomous',
     status: 'active',
     pipeline: { nodes: [], edges: [] },
 };
 function createMockBackend() {
-    return new Promise((resolve) => {
+    return new Promise((resolveReady) => {
+        const requests = [];
         const server = createServer((req, res) => {
             let body = '';
             req.on('data', (chunk) => (body += chunk));
             req.on('end', () => {
                 const url = req.url || '';
+                requests.push(`${req.method} ${url}`);
                 res.setHeader('Content-Type', 'application/json');
                 // Auth profile check
                 if (url === '/auth/profile') {
                     res.end(JSON.stringify({ id: 'user-1', email: 'test@test.com', organizations: [{ id: 'org-1', name: 'Test', role: 'owner' }] }));
                     return;
                 }
-                // List agents
-                if (url.startsWith('/agents') && req.method === 'GET' && !url.includes('/')) {
+                // List agents — "/agents", optionally with a query string, but not
+                // a sub-resource such as "/agents/:id".
+                if (req.method === 'GET' && /^\/agents(\?|$)/.test(url)) {
                     res.end(JSON.stringify({ agents: [MOCK_AGENT] }));
                     return;
                 }
                 // Get agent by ID
-                if (url.match(/\/agents\/agent-123$/) && req.method === 'GET') {
+                if (req.method === 'GET' && new RegExp(`^/agents/${AGENT_ID}(\\?|$)`).test(url)) {
                     res.end(JSON.stringify(MOCK_AGENT));
                     return;
                 }
                 // Start run
-                if (url.match(/\/agents\/agent-123\/runs$/) && req.method === 'POST') {
+                if (req.method === 'POST' && new RegExp(`^/agents/${AGENT_ID}/runs$`).test(url)) {
                     res.end(JSON.stringify({ id: 'run-1', status: 'completed', output: { message: 'Hello from the agent' } }));
                     return;
                 }
                 // Get run
-                if (url.match(/\/agents\/agent-123\/runs\/run-1$/) && req.method === 'GET') {
+                if (req.method === 'GET' && new RegExp(`^/agents/${AGENT_ID}/runs/run-1$`).test(url)) {
                     res.end(JSON.stringify({ id: 'run-1', status: 'completed', output: { message: 'Hello from the agent' } }));
                     return;
                 }
@@ -58,87 +73,173 @@ function createMockBackend() {
         });
         server.listen(0, '127.0.0.1', () => {
             const addr = server.address();
-            resolve({ server, port: addr.port });
+            resolveReady({ server, port: addr.port, requests });
         });
     });
 }
-// ── ndjson helpers ───────────────────────────────────────────────
-function sendRequest(proc, method, params, id) {
-    const msg = JSON.stringify({ jsonrpc: '2.0', id: id ?? 1, method, params: params ?? {} });
-    proc.stdin.write(msg + '\n');
-}
-function readResponses(proc, count, timeoutMs = 10000) {
-    return new Promise((resolve, reject) => {
-        const results = [];
-        const rl = createInterface({ input: proc.stdout });
-        const timer = setTimeout(() => {
-            rl.close();
-            resolve(results); // return what we have
-        }, timeoutMs);
-        rl.on('line', (line) => {
+// ── ndjson client ────────────────────────────────────────────────
+const ENTRY_POINT = resolve(__dirname, '../../dist/index.js');
+/**
+ * One reader over the child's stdout for the whole test: responses are
+ * matched by id, notifications are collected separately, and nothing is
+ * dropped between requests.
+ */
+class AcpClient {
+    proc;
+    notifications = [];
+    stderr = [];
+    buffer = '';
+    responses = new Map();
+    waiters = new Map();
+    exited = null;
+    constructor(port, agentRef = 'test-agent') {
+        this.proc = spawn('node', [ENTRY_POINT, agentRef], {
+            env: {
+                ...process.env,
+                ALMYTY_URL: `http://127.0.0.1:${port}`,
+                ALMYTY_TOKEN: 'test-token',
+            },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.proc.stdout.on('data', (chunk) => this.onStdout(String(chunk)));
+        this.proc.stderr.on('data', (chunk) => this.stderr.push(String(chunk)));
+        this.proc.on('exit', (code, signal) => {
+            this.exited = `child exited (code=${code}, signal=${signal})`;
+        });
+    }
+    onStdout(chunk) {
+        this.buffer += chunk;
+        let nl;
+        while ((nl = this.buffer.indexOf('\n')) >= 0) {
+            const line = this.buffer.slice(0, nl).trim();
+            this.buffer = this.buffer.slice(nl + 1);
+            if (!line)
+                continue;
+            let msg;
             try {
-                results.push(JSON.parse(line));
-                if (results.length >= count) {
-                    clearTimeout(timer);
-                    rl.close();
-                    resolve(results);
-                }
+                msg = JSON.parse(line);
             }
             catch {
-                // skip malformed lines
+                continue; // skip malformed lines
             }
+            if (msg.id === undefined || msg.id === null) {
+                this.notifications.push(msg);
+                continue;
+            }
+            const waiter = this.waiters.get(msg.id);
+            if (waiter) {
+                this.waiters.delete(msg.id);
+                waiter(msg);
+            }
+            else {
+                this.responses.set(msg.id, msg);
+            }
+        }
+    }
+    send(method, params, id) {
+        this.proc.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
+    }
+    /** Write several requests as a single chunk, so they arrive together. */
+    sendBurst(requests) {
+        const payload = requests
+            .map((r) => JSON.stringify({ jsonrpc: '2.0', id: r.id, method: r.method, params: r.params ?? {} }))
+            .join('\n');
+        this.proc.stdin.write(payload + '\n');
+    }
+    response(id, timeoutMs = 20_000) {
+        const already = this.responses.get(id);
+        if (already) {
+            this.responses.delete(id);
+            return Promise.resolve(already);
+        }
+        return new Promise((resolveMsg, reject) => {
+            const timer = setTimeout(() => {
+                this.waiters.delete(id);
+                reject(new Error(`Timed out after ${timeoutMs}ms waiting for response id=${id}. ` +
+                    `${this.exited ?? 'child still running'}. stderr: ${this.stderr.join('')}`));
+            }, timeoutMs);
+            this.waiters.set(id, (msg) => {
+                clearTimeout(timer);
+                resolveMsg(msg);
+            });
         });
-    });
+    }
+    /** Send a request and wait for its response. */
+    request(method, params, id, timeoutMs = 20_000) {
+        this.send(method, params, id);
+        return this.response(id, timeoutMs);
+    }
+    kill() {
+        this.proc.kill('SIGTERM');
+    }
 }
 // ── Tests ───────────────────────────────────────────────────────
 describe('ACP server integration', () => {
-    let mockBackend;
-    let backendPort;
-    let proc;
+    let backend;
+    let client;
     beforeAll(async () => {
-        const backend = await createMockBackend();
-        mockBackend = backend.server;
-        backendPort = backend.port;
+        backend = await createMockBackend();
     });
     afterAll(() => {
-        proc?.kill('SIGTERM');
-        mockBackend?.close();
+        backend?.server.close();
     });
-    it('completes full lifecycle: initialize -> authenticate -> session/new -> session/prompt', async () => {
-        const entryPoint = resolve(__dirname, '../../dist/index.js');
-        proc = spawn('node', [entryPoint, 'agent-123'], {
-            env: {
-                ...process.env,
-                ALMYTY_URL: `http://127.0.0.1:${backendPort}`,
-                ALMYTY_TOKEN: 'test-token',
-            },
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        // Give the process a moment to start
-        await new Promise((r) => setTimeout(r, 500));
-        // 1. Initialize
-        sendRequest(proc, 'initialize', { protocolVersion: 1, clientCapabilities: {} }, 1);
-        const [initResp] = await readResponses(proc, 1, 5000);
+    beforeEach(() => {
+        backend.requests.length = 0;
+    });
+    afterEach(() => {
+        client?.kill();
+        client = undefined;
+    });
+    it('completes full lifecycle: initialize -> authenticate -> session/new -> session/close', async () => {
+        client = new AcpClient(backend.port);
+        // 1. Initialize — the reply is the readiness signal.
+        const initResp = await client.request('initialize', { protocolVersion: 1, clientCapabilities: {} }, 1);
+        expect(initResp.error).toBeUndefined();
         expect(initResp.id).toBe(1);
         expect(initResp.result).toBeDefined();
         expect(initResp.result.protocolVersion).toBe(1);
+        expect(initResp.result.agentInfo.name).toBe('Test Agent');
         // 2. Authenticate
-        sendRequest(proc, 'authenticate', { methodId: 'env_var' }, 2);
-        const [authResp] = await readResponses(proc, 1, 5000);
+        const authResp = await client.request('authenticate', { methodId: 'almyty_token' }, 2);
         expect(authResp.id).toBe(2);
         expect(authResp.error).toBeUndefined();
+        expect(authResp.result.authenticated).toBe(true);
         // 3. Session new
-        sendRequest(proc, 'session/new', { cwd: '/tmp' }, 3);
-        const [sessionResp] = await readResponses(proc, 1, 5000);
+        const sessionResp = await client.request('session/new', { cwd: '/tmp' }, 3);
         expect(sessionResp.id).toBe(3);
+        expect(sessionResp.error).toBeUndefined();
         expect(sessionResp.result?.sessionId).toBeDefined();
         const sessionId = sessionResp.result.sessionId;
-        // 4. Close session
-        sendRequest(proc, 'session/close', { sessionId }, 4);
-        const [closeResp] = await readResponses(proc, 1, 5000);
+        // 4. Close session — the session must still exist on the same agent.
+        const closeResp = await client.request('session/close', { sessionId }, 4);
         expect(closeResp.id).toBe(4);
         expect(closeResp.error).toBeUndefined();
-        // Clean up
-        proc.kill('SIGTERM');
-    }, 30000);
+        expect(closeResp.result.closed).toBe(true);
+    }, 60_000);
+    /**
+     * Regression guard for the lazy-init race: readline delivers every line
+     * already buffered in the pipe in one synchronous burst, so a batch of
+     * requests arriving before the first agent resolution settles used to
+     * build one agent — and one SessionManager — per line. Sessions created
+     * by one message were then invisible to the next.
+     */
+    it('shares one agent across requests that arrive in a single burst', async () => {
+        client = new AcpClient(backend.port);
+        client.sendBurst([
+            { id: 1, method: 'initialize', params: { protocolVersion: 1, clientCapabilities: {} } },
+            { id: 2, method: 'session/new', params: { cwd: '/tmp' } },
+        ]);
+        const initResp = await client.response(1);
+        const sessionResp = await client.response(2);
+        expect(initResp.result?.protocolVersion).toBe(1);
+        const sessionId = sessionResp.result?.sessionId;
+        expect(sessionId).toBeDefined();
+        // The agent was resolved exactly once, not once per buffered line.
+        const listCalls = backend.requests.filter((r) => r === 'GET /agents');
+        expect(listCalls).toHaveLength(1);
+        // And the session lives on the agent that later requests reach.
+        const closeResp = await client.request('session/close', { sessionId }, 3);
+        expect(closeResp.error).toBeUndefined();
+        expect(closeResp.result.closed).toBe(true);
+    }, 60_000);
 });

package/dist/dispatch.d.ts

@@ -0,0 +1,34 @@
+/**
+ * stdio line dispatch for the ACP server.
+ *
+ * Owns the one piece of state the readline loop cannot own safely: the
+ * lazily-resolved agent. `readline` delivers every complete line already
+ * sitting in the stdin pipe in a single synchronous burst, so an async
+ * `if (!agent) agent = await resolveAgent()` guard inside the line handler
+ * is checked by every line in that burst before any of them assigns — each
+ * line then builds its own agent, with its own SessionManager and its own
+ * (empty) cached agent info. Sessions created by one message are invisible
+ * to the next, `initialize` caches the agent mode on an instance nobody
+ * keeps, and the backend is asked for the agent list once per line.
+ *
+ * Resolution is therefore memoised on the in-flight promise, not on the
+ * settled value. A failed resolution clears the memo so a later message
+ * can retry (the backend may simply have been down).
+ */
+import type { JsonRpcRequest, JsonRpcResponse, JsonRpcNotification } from './agent.js';
+/** The surface of AlmytyAcpAgent the dispatcher depends on. */
+export interface MessageHandler {
+    handleMessage(msg: JsonRpcRequest): Promise<void>;
+}
+export interface LineHandlerOptions {
+    /** Build the agent. Called at most once per successful resolution. */
+    resolveAgent: () => Promise<MessageHandler>;
+    /** Write a JSON-RPC message back to the client. */
+    send: (msg: JsonRpcResponse | JsonRpcNotification) => void;
+    /** Diagnostic sink. Defaults to stderr — stdout is the protocol. */
+    log?: (text: string) => void;
+}
+/**
+ * Build the `line` handler for the ndjson stdio loop.
+ */
+export declare function createLineHandler({ resolveAgent, send, log, }: LineHandlerOptions): (line: string) => Promise<void>;

package/dist/dispatch.js

@@ -0,0 +1,72 @@
+/**
+ * stdio line dispatch for the ACP server.
+ *
+ * Owns the one piece of state the readline loop cannot own safely: the
+ * lazily-resolved agent. `readline` delivers every complete line already
+ * sitting in the stdin pipe in a single synchronous burst, so an async
+ * `if (!agent) agent = await resolveAgent()` guard inside the line handler
+ * is checked by every line in that burst before any of them assigns — each
+ * line then builds its own agent, with its own SessionManager and its own
+ * (empty) cached agent info. Sessions created by one message are invisible
+ * to the next, `initialize` caches the agent mode on an instance nobody
+ * keeps, and the backend is asked for the agent list once per line.
+ *
+ * Resolution is therefore memoised on the in-flight promise, not on the
+ * settled value. A failed resolution clears the memo so a later message
+ * can retry (the backend may simply have been down).
+ */
+const PARSE_ERROR = -32700;
+const INVALID_REQUEST = -32600;
+const INTERNAL_ERROR = -32603;
+/**
+ * Build the `line` handler for the ndjson stdio loop.
+ */
+export function createLineHandler({ resolveAgent, send, log = (text) => void process.stderr.write(text), }) {
+    let pending = null;
+    const agentOnce = () => {
+        if (!pending) {
+            pending = resolveAgent().catch((err) => {
+                pending = null;
+                throw err;
+            });
+        }
+        return pending;
+    };
+    return async function handleLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(trimmed);
+        }
+        catch {
+            send({ jsonrpc: '2.0', id: null, error: { code: PARSE_ERROR, message: 'Parse error' } });
+            return;
+        }
+        if (!msg || msg.jsonrpc !== '2.0' || !msg.method) {
+            if (msg && msg.id !== undefined) {
+                send({ jsonrpc: '2.0', id: msg.id, error: { code: INVALID_REQUEST, message: 'Invalid request' } });
+            }
+            return;
+        }
+        let agent;
+        try {
+            agent = await agentOnce();
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            send({ jsonrpc: '2.0', id: msg.id ?? null, error: { code: INTERNAL_ERROR, message } });
+            return;
+        }
+        try {
+            await agent.handleMessage(msg);
+        }
+        catch (err) {
+            log(`[acp] Error: ${err}\n`);
+            if (msg.id !== undefined && msg.id !== null) {
+                send({ jsonrpc: '2.0', id: msg.id, error: { code: INTERNAL_ERROR, message: 'Internal error' } });
+            }
+        }
+    };
+}

package/dist/index.js

@@ -17,18 +17,32 @@ import * as readline from 'node:readline';
 import { resolveCredentials } from './auth.js';
 import { AlmytyProxy } from './proxy.js';
 import { AlmytyAcpAgent } from './agent.js';
+import { createLineHandler } from './dispatch.js';
+import { VERSION } from './version.js';
 // ── Argument parsing ─────────────────────────────────────────────
 const args = process.argv.slice(2);
 const HELP_FLAGS = ['--help', '-h'];
+const VERSION_FLAGS = ['--version', '-v'];
+// Checked before help so `almyty-acp --version --help` answers the
+// narrower question, and before the no-args branch so asking the server
+// what it is never exits non-zero.
+if (args.some((a) => VERSION_FLAGS.includes(a))) {
+    process.stdout.write(`${VERSION}\n`);
+    process.exit(0);
+}
 if (args.some((a) => HELP_FLAGS.includes(a)) || args.length === 0) {
     const text = `
-@almyty/acp-server — Expose any almyty agent via the Agent Client Protocol
+@almyty/acp-server v${VERSION} — Expose any almyty agent via the Agent Client Protocol
 
 Usage:
   almyty-acp <agent>
   almyty-acp my-agent
   almyty-acp acme/my-agent
 
+Options:
+  -h, --help     Show this help.
+  -v, --version  Print the version.
+
 Authentication:
   npx @almyty/auth login
 
@@ -89,46 +103,20 @@ async function main() {
     // Start listening on stdin IMMEDIATELY — Zed expects the process
     // to be ready for JSON-RPC as soon as it spawns. Agent resolution
     // and auth happen lazily on first `initialize` message.
+    //
+    // Resolution is memoised inside createLineHandler: readline hands us
+    // every line already buffered in the pipe in one burst, so the guard
+    // has to be the in-flight promise, not the settled agent.
     let agent = null;
-    const rl = readline.createInterface({ input: process.stdin, terminal: false });
-    rl.on('line', async (line) => {
-        const trimmed = line.trim();
-        if (!trimmed)
-            return;
-        let msg;
-        try {
-            msg = JSON.parse(trimmed);
-        }
-        catch {
-            send({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } });
-            return;
-        }
-        if (!msg.jsonrpc || msg.jsonrpc !== '2.0' || !msg.method) {
-            if (msg.id !== undefined) {
-                send({ jsonrpc: '2.0', id: msg.id, error: { code: -32600, message: 'Invalid request' } });
-            }
-            return;
-        }
-        // Lazy init: resolve credentials + agent on first message
-        if (!agent) {
-            try {
-                agent = await resolveAgent(agentArg, send);
-            }
-            catch (err) {
-                send({ jsonrpc: '2.0', id: msg.id ?? null, error: { code: -32603, message: err.message } });
-                return;
-            }
-        }
-        try {
-            await agent.handleMessage(msg);
-        }
-        catch (err) {
-            process.stderr.write(`[acp] Error: ${err}\n`);
-            if (msg.id !== undefined && msg.id !== null) {
-                send({ jsonrpc: '2.0', id: msg.id, error: { code: -32603, message: 'Internal error' } });
-            }
-        }
+    const handleLine = createLineHandler({
+        resolveAgent: async () => {
+            agent = await resolveAgent(agentArg, send);
+            return agent;
+        },
+        send,
     });
+    const rl = readline.createInterface({ input: process.stdin, terminal: false });
+    rl.on('line', handleLine);
     // Handle stdin close (client disconnected)
     rl.on('close', () => {
         process.stderr.write('[acp] Client disconnected. Shutting down.\n');

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare function readVersion(fallback?: string): string;
+export declare const VERSION: string;

package/dist/version.js

@@ -0,0 +1,24 @@
+/**
+ * The server's own version, read from its package.json at startup.
+ *
+ * Every other CLI in the suite answers `--version`; this one shipped
+ * without it, so the only way to tell which build a client had loaded
+ * was to diff the file. Reading package.json rather than restating the
+ * number keeps it honest across a publish: a literal does not move when
+ * the release workflow bumps the manifest. Both `dist/version.js` and
+ * `src/version.ts` sit one directory below the package root, so the same
+ * relative path resolves for the built bin and for `tsx src/index.ts`.
+ */
+import { readFileSync } from 'node:fs';
+export function readVersion(fallback = '0.0.0') {
+    try {
+        const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
+        return typeof pkg.version === 'string' && pkg.version.length > 0
+            ? pkg.version
+            : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+export const VERSION = readVersion();

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@almyty/acp-server",
-  "version": "1.2.0",
+  "version": "1.5.0",
   "publishConfig": {
     "access": "public"
   },
-  "description": "Expose any almyty agent over the Agent Client Protocol (ACP) \u2014 drop your agent into ACP-compatible editors and clients.",
+  "description": "Expose any almyty agent over the Agent Client Protocol (ACP) — drop your agent into ACP-compatible editors and clients.",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -48,5 +48,8 @@
   },
   "bugs": {
     "url": "https://github.com/almyty-inc/almyty/issues"
+  },
+  "overrides": {
+    "postcss": "^8.5.23"
   }
 }

package/dist/__tests__/events.test.js

@@ -1 +0,0 @@
-"use strict";