@almyty/acp-server 1.0.0

package/dist/proxy.js

@@ -0,0 +1,209 @@
+/**
+ * HTTP proxy client to the almyty backend REST API.
+ *
+ * Provides typed methods for agent discovery, invocation, streaming,
+ * and autonomous run management. All stdout is reserved for the ACP
+ * protocol; diagnostics go to stderr.
+ */
+import { createParser } from 'eventsource-parser';
+/** Default timeouts (ms). */
+const DISCOVERY_TIMEOUT_MS = 15_000;
+const INVOKE_TIMEOUT_MS = 120_000;
+export class AlmytyProxy {
+    baseUrl;
+    token;
+    constructor(baseUrl, token) {
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+        this.token = token;
+    }
+    // ── Agent discovery ────────────────────────────────────────────
+    async listAgents() {
+        const data = await this.get('/agents', DISCOVERY_TIMEOUT_MS);
+        // Backend returns { success, data: [...], pagination } or { agents: [...] }
+        const list = Array.isArray(data?.data) ? data.data : (data?.agents || (Array.isArray(data) ? data : []));
+        return list;
+    }
+    async getAgent(id) {
+        const data = await this.get(`/agents/${encodeURIComponent(id)}`, DISCOVERY_TIMEOUT_MS);
+        return data?.data || data;
+    }
+    // ── Workflow invocation ────────────────────────────────────────
+    async invokeAgent(id, input) {
+        return this.post(`/agents/${encodeURIComponent(id)}/invoke`, input, INVOKE_TIMEOUT_MS);
+    }
+    /**
+     * Stream a workflow agent execution via SSE. Yields StreamEvent objects
+     * as they arrive. The caller is responsible for consuming the async
+     * iterator; aborting the signal will terminate the stream.
+     */
+    async *streamAgent(id, input, signal) {
+        yield* this.ssePost(`/agents/${encodeURIComponent(id)}/stream`, input, signal);
+    }
+    // ── Autonomous run management ──────────────────────────────────
+    async startRun(id, input) {
+        const data = await this.post(`/agents/${encodeURIComponent(id)}/runs`, { input }, INVOKE_TIMEOUT_MS);
+        return data?.data || data;
+    }
+    async getRun(agentId, runId) {
+        const data = await this.get(`/agents/${encodeURIComponent(agentId)}/runs/${encodeURIComponent(runId)}`, DISCOVERY_TIMEOUT_MS);
+        return data?.data || data;
+    }
+    async sendRunInput(agentId, runId, input) {
+        return this.post(`/agents/${encodeURIComponent(agentId)}/runs/${encodeURIComponent(runId)}/input`, input, INVOKE_TIMEOUT_MS);
+    }
+    async cancelRun(agentId, runId) {
+        await this.post(`/agents/${encodeURIComponent(agentId)}/runs/${encodeURIComponent(runId)}/cancel`, {}, DISCOVERY_TIMEOUT_MS);
+    }
+    /**
+     * Stream an autonomous run via SSE. Similar to streamAgent but uses the
+     * run-specific SSE endpoint.
+     */
+    async *streamRun(agentId, runId, signal) {
+        yield* this.sseGet(`/agents/${encodeURIComponent(agentId)}/runs/${encodeURIComponent(runId)}/stream`, signal);
+    }
+    // ── Internal HTTP helpers ──────────────────────────────────────
+    headers() {
+        return {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${this.token}`,
+        };
+    }
+    async get(path, timeoutMs) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const resp = await fetch(`${this.baseUrl}${path}`, {
+                method: 'GET',
+                headers: this.headers(),
+                signal: controller.signal,
+            });
+            if (!resp.ok) {
+                const text = await resp.text().catch(() => '');
+                throw new Error(`GET ${path} failed (${resp.status}): ${text}`);
+            }
+            return (await resp.json());
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === 'AbortError') {
+                throw new Error(`GET ${path} timed out after ${Math.round(timeoutMs / 1000)}s`);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async post(path, body, timeoutMs) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const resp = await fetch(`${this.baseUrl}${path}`, {
+                method: 'POST',
+                headers: this.headers(),
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            if (!resp.ok) {
+                const text = await resp.text().catch(() => '');
+                throw new Error(`POST ${path} failed (${resp.status}): ${text}`);
+            }
+            return (await resp.json());
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === 'AbortError') {
+                throw new Error(`POST ${path} timed out after ${Math.round(timeoutMs / 1000)}s`);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /**
+     * Consume an SSE stream from a POST endpoint. Uses eventsource-parser
+     * to handle the text/event-stream format.
+     */
+    async *ssePost(path, body, signal) {
+        const controller = new AbortController();
+        const combinedSignal = signal
+            ? AbortSignal.any([signal, controller.signal])
+            : controller.signal;
+        const resp = await fetch(`${this.baseUrl}${path}`, {
+            method: 'POST',
+            headers: {
+                ...this.headers(),
+                Accept: 'text/event-stream',
+            },
+            body: JSON.stringify(body),
+            signal: combinedSignal,
+        });
+        if (!resp.ok) {
+            const text = await resp.text().catch(() => '');
+            throw new Error(`SSE POST ${path} failed (${resp.status}): ${text}`);
+        }
+        yield* this.consumeSse(resp);
+    }
+    /**
+     * Consume an SSE stream from a GET endpoint.
+     */
+    async *sseGet(path, signal) {
+        const controller = new AbortController();
+        const combinedSignal = signal
+            ? AbortSignal.any([signal, controller.signal])
+            : controller.signal;
+        const resp = await fetch(`${this.baseUrl}${path}`, {
+            method: 'GET',
+            headers: {
+                ...this.headers(),
+                Accept: 'text/event-stream',
+            },
+            signal: combinedSignal,
+        });
+        if (!resp.ok) {
+            const text = await resp.text().catch(() => '');
+            throw new Error(`SSE GET ${path} failed (${resp.status}): ${text}`);
+        }
+        yield* this.consumeSse(resp);
+    }
+    /**
+     * Parse an SSE response body into StreamEvent objects.
+     */
+    async *consumeSse(resp) {
+        const body = resp.body;
+        if (!body)
+            return;
+        // Buffer for events parsed by eventsource-parser
+        const events = [];
+        let done = false;
+        const parser = createParser({
+            onEvent(event) {
+                let data;
+                try {
+                    data = JSON.parse(event.data);
+                }
+                catch {
+                    data = { raw: event.data };
+                }
+                events.push({ event: event.event || 'message', data });
+            },
+        });
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        try {
+            while (!done) {
+                const { value, done: readerDone } = await reader.read();
+                done = readerDone;
+                if (value) {
+                    parser.feed(decoder.decode(value, { stream: !done }));
+                }
+                // Yield any buffered events
+                while (events.length > 0) {
+                    yield events.shift();
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}

package/dist/session.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Session manager for the ACP server.
+ *
+ * Maps ACP session IDs to almyty agent state: agent ID, agent mode
+ * (workflow/autonomous), conversation context, and active run tracking.
+ */
+/** Persisted state for one ACP session. */
+export interface Session {
+    /** ACP session ID (UUID). */
+    id: string;
+    /** almyty agent ID this session is bound to. */
+    agentId: string;
+    /** Agent execution mode. */
+    mode: 'workflow' | 'autonomous';
+    /** Conversation ID for autonomous multi-turn sessions. */
+    conversationId?: string;
+    /** Currently in-flight run ID (for cancellation). */
+    activeRunId?: string;
+    /** AbortController for the active streaming request. */
+    abortController?: AbortController;
+    /** Timestamp of last activity (epoch ms). */
+    lastActivity: number;
+    /** User-requested session mode (e.g. "plan", "code"). Stored but not enforced. */
+    userMode?: string;
+}
+export declare class SessionManager {
+    private readonly sessions;
+    /**
+     * Create a new session bound to the given agent.
+     */
+    create(agentId: string, mode: 'workflow' | 'autonomous'): Session;
+    /**
+     * Look up a session by ID. Returns undefined if not found.
+     */
+    get(sessionId: string): Session | undefined;
+    /**
+     * List all active sessions.
+     */
+    list(): Session[];
+    /**
+     * Update fields on an existing session.
+     */
+    update(sessionId: string, patch: Partial<Pick<Session, 'conversationId' | 'activeRunId' | 'abortController' | 'userMode'>>): void;
+    /**
+     * Abort any in-flight work for a session and clear the active run.
+     */
+    cancel(sessionId: string): void;
+    /**
+     * Close and remove a session, aborting any in-flight work.
+     */
+    close(sessionId: string): boolean;
+    /**
+     * Close all sessions. Called during shutdown.
+     */
+    closeAll(): void;
+}

package/dist/session.js

@@ -0,0 +1,77 @@
+/**
+ * Session manager for the ACP server.
+ *
+ * Maps ACP session IDs to almyty agent state: agent ID, agent mode
+ * (workflow/autonomous), conversation context, and active run tracking.
+ */
+import { randomUUID } from 'node:crypto';
+export class SessionManager {
+    sessions = new Map();
+    /**
+     * Create a new session bound to the given agent.
+     */
+    create(agentId, mode) {
+        const session = {
+            id: randomUUID(),
+            agentId,
+            mode,
+            lastActivity: Date.now(),
+        };
+        this.sessions.set(session.id, session);
+        return session;
+    }
+    /**
+     * Look up a session by ID. Returns undefined if not found.
+     */
+    get(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    /**
+     * List all active sessions.
+     */
+    list() {
+        return Array.from(this.sessions.values());
+    }
+    /**
+     * Update fields on an existing session.
+     */
+    update(sessionId, patch) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        Object.assign(session, patch);
+        session.lastActivity = Date.now();
+    }
+    /**
+     * Abort any in-flight work for a session and clear the active run.
+     */
+    cancel(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        session.abortController?.abort();
+        session.abortController = undefined;
+        session.activeRunId = undefined;
+        session.lastActivity = Date.now();
+    }
+    /**
+     * Close and remove a session, aborting any in-flight work.
+     */
+    close(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return false;
+        session.abortController?.abort();
+        this.sessions.delete(sessionId);
+        return true;
+    }
+    /**
+     * Close all sessions. Called during shutdown.
+     */
+    closeAll() {
+        for (const session of this.sessions.values()) {
+            session.abortController?.abort();
+        }
+        this.sessions.clear();
+    }
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@almyty/acp-server",
+  "version": "1.0.0",
+  "description": "ACP agent server for almyty — expose any almyty agent via the Agent Client Protocol",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "almyty-acp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "acp",
+    "agent-client-protocol",
+    "ai-agents",
+    "almyty",
+    "zed",
+    "jetbrains"
+  ],
+  "author": "almyty",
+  "license": "BSL-1.1",
+  "dependencies": {
+    "eventsource-parser": "^3.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.1.0"
+  }
+}