@supen-ai/cli 0.1.6

package/daemon/dist/channels/acp.js

@@ -0,0 +1,916 @@
+import fs from 'fs';
+import path from 'path';
+import { randomUUID } from 'crypto';
+import { ACP_ENABLED, ACP_RELAY_URL } from '../core/config.js';
+import { ensureSession } from '../core/store.js';
+import { logger } from '../core/logger.js';
+import { validateOutboundEndpoint } from '../core/security.js';
+import { submitTask } from '../task-executor.js';
+import { ACPClient } from '../acp-client.js';
+import { registerChannel } from './registry.js';
+// NOTE: This ACP channel is the external transport surface for ACP clients that
+// talk to Supen as a daemon/channel endpoint. It is intentionally separate from
+// the Agent SDK's backend-driver work (for example acpx-backed Codex/Claude
+// adapters). We should not collapse coding-agent backends into a "channel"
+// abstraction here.
+const ACP_JID_PREFIX = 'acp:';
+const MAX_SESSION_MESSAGES = 200;
+let runtimeOpts = null;
+let defaultClient = null;
+const sessionsById = new Map();
+const sessionIdByChatJid = new Map();
+function nowIso() {
+    return new Date().toISOString();
+}
+function buildThreadId(agentId, sessionId) {
+    return `${encodeURIComponent(agentId)}:${encodeURIComponent(sessionId)}`;
+}
+function parseThreadId(threadId) {
+    const parts = threadId.split(':');
+    if (parts.length < 2)
+        return null;
+    try {
+        return {
+            agent_id: decodeURIComponent(parts[0]),
+            session_id: decodeURIComponent(parts[1]),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function buildAcpChatJid(agentId, sessionId) {
+    return `${ACP_JID_PREFIX}${buildThreadId(agentId, sessionId)}`;
+}
+function readJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.setEncoding('utf-8');
+        req.on('data', (chunk) => {
+            body += chunk;
+        });
+        req.on('end', () => {
+            if (!body.trim()) {
+                resolve({});
+                return;
+            }
+            try {
+                resolve(JSON.parse(body));
+            }
+            catch {
+                reject(new Error('Invalid JSON body'));
+            }
+        });
+        req.on('error', reject);
+    });
+}
+function writeJson(res, statusCode, payload) {
+    res.writeHead(statusCode, {
+        'Content-Type': 'application/json',
+    });
+    res.end(JSON.stringify(payload));
+}
+function writeProtocolError(res, statusCode, code, message, details) {
+    writeJson(res, statusCode, {
+        error: {
+            code,
+            message,
+            ...(details ? { details } : {}),
+        },
+    });
+}
+function wantsSse(req, url) {
+    if (url.searchParams.get('stream') === '1')
+        return true;
+    const accept = req.headers.accept;
+    return typeof accept === 'string' && accept.includes('text/event-stream');
+}
+function inferMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === '.md')
+        return 'text/markdown';
+    if (ext === '.base')
+        return 'text/yaml';
+    if (ext === '.txt' || ext === '.log' || ext === '.jsonl')
+        return 'text/plain';
+    if (ext === '.json')
+        return 'application/json';
+    if (ext === '.png')
+        return 'image/png';
+    if (ext === '.jpg' || ext === '.jpeg')
+        return 'image/jpeg';
+    if (ext === '.webp')
+        return 'image/webp';
+    if (ext === '.pdf')
+        return 'application/pdf';
+    return undefined;
+}
+function normalizeContentPart(part) {
+    if (!part)
+        return null;
+    if (typeof part === 'string') {
+        return { type: 'text', text: part };
+    }
+    if (typeof part !== 'object')
+        return null;
+    const value = part;
+    const type = value.type;
+    if ((type === 'text' || type === 'markdown') &&
+        typeof value.text === 'string') {
+        return { type, text: value.text };
+    }
+    if (type === 'artifact') {
+        return {
+            type: 'artifact',
+            name: typeof value.name === 'string' ? value.name : undefined,
+            mime_type: typeof value.mime_type === 'string' ? value.mime_type : undefined,
+            uri: typeof value.uri === 'string' ? value.uri : undefined,
+            path: typeof value.path === 'string' ? value.path : undefined,
+            description: typeof value.description === 'string' ? value.description : undefined,
+            data: typeof value.data === 'string' ? value.data : undefined,
+        };
+    }
+    return null;
+}
+function normalizeContent(content) {
+    if (typeof content === 'string') {
+        return content.trim() ? [{ type: 'text', text: content }] : [];
+    }
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => normalizeContentPart(part))
+            .filter((part) => !!part);
+    }
+    if (content && typeof content === 'object') {
+        const single = normalizeContentPart(content);
+        return single ? [single] : [];
+    }
+    return [];
+}
+function normalizeToolCall(toolCall) {
+    if (!toolCall || typeof toolCall !== 'object')
+        return null;
+    const value = toolCall;
+    const name = typeof value.name === 'string'
+        ? value.name
+        : typeof value.tool_name === 'string'
+            ? value.tool_name
+            : null;
+    if (!name)
+        return null;
+    return {
+        id: typeof value.id === 'string' && value.id
+            ? value.id
+            : typeof value.tool_call_id === 'string' && value.tool_call_id
+                ? value.tool_call_id
+                : randomUUID(),
+        name,
+        arguments: value.arguments && typeof value.arguments === 'object'
+            ? value.arguments
+            : value.input && typeof value.input === 'object'
+                ? value.input
+                : undefined,
+    };
+}
+function normalizeToolResult(toolResult) {
+    if (!toolResult || typeof toolResult !== 'object')
+        return null;
+    const value = toolResult;
+    const toolCallId = typeof value.tool_call_id === 'string'
+        ? value.tool_call_id
+        : typeof value.id === 'string'
+            ? value.id
+            : null;
+    if (!toolCallId)
+        return null;
+    return {
+        tool_call_id: toolCallId,
+        name: typeof value.name === 'string' ? value.name : undefined,
+        result: value.result ?? value.output ?? value.content,
+        is_error: typeof value.is_error === 'boolean'
+            ? value.is_error
+            : typeof value.error === 'boolean'
+                ? value.error
+                : false,
+    };
+}
+export function normalizeAcpEnvelope(input, fallbackRole = 'user') {
+    const raw = input && typeof input === 'object' && 'message' in input
+        ? input.message
+        : input;
+    const value = raw && typeof raw === 'object' ? raw : {};
+    const role = value.role === 'system' ||
+        value.role === 'user' ||
+        value.role === 'assistant' ||
+        value.role === 'tool'
+        ? value.role
+        : fallbackRole;
+    const content = normalizeContent(value.content ?? value.parts ?? value.text ?? value.prompt ?? '');
+    const toolCalls = Array.isArray(value.tool_calls)
+        ? value.tool_calls
+            .map((toolCall) => normalizeToolCall(toolCall))
+            .filter((toolCall) => !!toolCall)
+        : [];
+    const toolResults = Array.isArray(value.tool_results)
+        ? value.tool_results
+            .map((toolResult) => normalizeToolResult(toolResult))
+            .filter((toolResult) => !!toolResult)
+        : [];
+    return {
+        id: typeof value.id === 'string' && value.id ? value.id : randomUUID(),
+        role,
+        content,
+        ...(toolCalls.length ? { tool_calls: toolCalls } : {}),
+        ...(toolResults.length ? { tool_results: toolResults } : {}),
+        ...(value.metadata && typeof value.metadata === 'object'
+            ? { metadata: value.metadata }
+            : {}),
+        created_at: typeof value.created_at === 'string' && value.created_at
+            ? value.created_at
+            : nowIso(),
+    };
+}
+function renderContentForPrompt(content) {
+    return content
+        .map((part) => {
+        if (part.type === 'artifact') {
+            return [
+                '[Artifact]',
+                part.name ? `name: ${part.name}` : null,
+                part.path ? `path: ${part.path}` : null,
+                part.uri ? `uri: ${part.uri}` : null,
+                part.description ? `description: ${part.description}` : null,
+            ]
+                .filter(Boolean)
+                .join('\n');
+        }
+        return part.text;
+    })
+        .filter(Boolean)
+        .join('\n\n');
+}
+function buildPromptFromEnvelope(envelope, mode = 'message') {
+    const parts = [];
+    if (mode === 'tools' && envelope.tool_calls?.length) {
+        parts.push('Execute the requested tool calls and return the results clearly. Include any errors inline.');
+    }
+    else {
+        parts.push(`ACP ${envelope.role} message:`);
+    }
+    const renderedContent = renderContentForPrompt(envelope.content);
+    if (renderedContent)
+        parts.push(renderedContent);
+    if (envelope.tool_calls?.length) {
+        parts.push(`[ACP tool calls]\n${JSON.stringify(envelope.tool_calls, null, 2)}`);
+    }
+    if (envelope.tool_results?.length) {
+        parts.push(`[ACP tool results]\n${JSON.stringify(envelope.tool_results, null, 2)}`);
+    }
+    return parts.join('\n\n').trim();
+}
+function isExecutableEnvelope(envelope) {
+    if (envelope.tool_calls?.length)
+        return true;
+    return envelope.content.some((part) => part.type === 'artifact' ? true : !!part.text.trim());
+}
+function serializeSession(session) {
+    return {
+        id: session.id,
+        thread_id: session.thread_id,
+        agent_id: session.agent_id,
+        session_id: session.session_id,
+        chat_jid: session.chat_jid,
+        created_at: session.created_at,
+        updated_at: session.updated_at,
+        stream_url: session.stream_url,
+        message_url: session.message_url,
+        tools_url: session.tools_url,
+        last_task_id: session.last_task_id || null,
+        metadata: session.metadata || null,
+    };
+}
+function writeSseEvent(res, event, eventName) {
+    if (eventName) {
+        res.write(`event: ${eventName}\n`);
+    }
+    res.write(`data: ${JSON.stringify(event)}\n\n`);
+}
+function broadcastSessionEvent(session, event, eventName) {
+    for (const client of [...session.clients]) {
+        try {
+            writeSseEvent(client, event, eventName);
+        }
+        catch {
+            session.clients.delete(client);
+        }
+    }
+}
+function appendMessage(session, envelope) {
+    session.messages.push(envelope);
+    if (session.messages.length > MAX_SESSION_MESSAGES) {
+        session.messages.splice(0, session.messages.length - MAX_SESSION_MESSAGES);
+    }
+    session.updated_at = nowIso();
+}
+function listAgentManifests() {
+    const opts = runtimeOpts;
+    const uniqueAgents = new Map();
+    for (const project of Object.values(opts?.registeredProjects() || {})) {
+        const agentId = project.agent_id || project.folder;
+        uniqueAgents.set(agentId, agentId);
+    }
+    if (uniqueAgents.size === 0) {
+        uniqueAgents.set('default', 'default');
+    }
+    return [...uniqueAgents.keys()].map((agentId) => ({
+        id: buildThreadId(agentId, agentId),
+        protocol: 'acp',
+        name: `Supen ${agentId}`,
+        description: 'Supen ACP-compatible agent endpoint',
+        version: '1.0.0',
+        agent_id: agentId,
+        endpoints: {
+            agents: '/acp/agents',
+            sessions: '/acp/sessions',
+        },
+        capabilities: {
+            streaming: true,
+            inbound: true,
+            outbound: true,
+            tool_calls: true,
+            tool_results: true,
+            content_types: ['text', 'markdown', 'artifact'],
+        },
+    }));
+}
+function ensureRegisteredProject(agentId, chatJid, timestamp) {
+    const opts = runtimeOpts;
+    if (!opts)
+        return;
+    const projects = opts.registeredProjects();
+    if (!projects[chatJid] && opts.onGroupRegistered) {
+        const project = {
+            name: agentId,
+            folder: agentId,
+            agent_id: agentId,
+            trigger: '',
+            added_at: timestamp,
+            requiresTrigger: false,
+            isMain: false,
+        };
+        opts.onGroupRegistered(chatJid, project);
+    }
+    opts.onChatMetadata(chatJid, timestamp, undefined, 'acp', false);
+}
+function ensureRelaySync(session) {
+    if (!defaultClient || session.relay_sync_started)
+        return;
+    session.relay_sync_started = true;
+    void defaultClient
+        .createSession({
+        agent_id: session.agent_id,
+        session_id: session.session_id,
+        thread_id: session.thread_id,
+        metadata: {
+            origin: 'supen',
+            local_session_id: session.id,
+        },
+    })
+        .then(({ session: remoteSession }) => {
+        session.relay_session_id = remoteSession.id;
+        session.relay_abort = new AbortController();
+        return defaultClient.streamSession(remoteSession.id, {
+            onEvent: async (event) => {
+                await handleRelayEvent(session, event);
+            },
+        }, session.relay_abort.signal);
+    })
+        .catch((err) => {
+        logger.warn({ err, session_id: session.id, relay_url: ACP_RELAY_URL }, 'ACP relay sync unavailable');
+    });
+}
+async function syncEnvelopeToRelay(session, envelope) {
+    if (!defaultClient || !session.relay_session_id)
+        return;
+    try {
+        await defaultClient.sendMessage(session.relay_session_id, {
+            message: {
+                ...envelope,
+                metadata: {
+                    ...(envelope.metadata || {}),
+                    origin: 'supen',
+                    local_session_id: session.id,
+                },
+            },
+        });
+    }
+    catch (err) {
+        logger.warn({ err, session_id: session.id }, 'Failed to sync ACP message');
+    }
+}
+async function syncToolCallsToRelay(session, toolCalls) {
+    if (!defaultClient || !session.relay_session_id || toolCalls.length === 0)
+        return;
+    try {
+        await defaultClient.sendToolCalls(session.relay_session_id, {
+            tool_calls: toolCalls,
+            metadata: {
+                origin: 'supen',
+                local_session_id: session.id,
+            },
+        });
+    }
+    catch (err) {
+        logger.warn({ err, session_id: session.id }, 'Failed to sync ACP tool calls');
+    }
+}
+async function handleRelayEvent(session, event) {
+    const origin = event.message?.metadata && typeof event.message.metadata.origin === 'string'
+        ? event.message.metadata.origin
+        : undefined;
+    if (origin === 'supen')
+        return;
+    if (event.type === 'message' && event.message) {
+        appendMessage(session, event.message);
+        broadcastSessionEvent(session, {
+            type: 'message',
+            session_id: session.id,
+            task_id: session.last_task_id,
+            message: event.message,
+        });
+        if (event.message.role !== 'assistant' ||
+            event.message.tool_calls?.length) {
+            await submitEnvelope(session, event.message, 'acp-relay', 'message', false);
+        }
+        return;
+    }
+    if (event.type === 'tool_call' && event.tool_calls?.length) {
+        const envelope = {
+            id: randomUUID(),
+            role: 'user',
+            content: [],
+            tool_calls: event.tool_calls,
+            created_at: nowIso(),
+            metadata: { origin: 'acp-relay' },
+        };
+        await submitEnvelope(session, envelope, 'acp-relay', 'tools', false);
+        return;
+    }
+    if (event.type === 'tool_result' && event.tool_results?.length) {
+        const envelope = {
+            id: randomUUID(),
+            role: 'tool',
+            content: [],
+            tool_results: event.tool_results,
+            created_at: nowIso(),
+            metadata: { origin: 'acp-relay' },
+        };
+        appendMessage(session, envelope);
+        broadcastSessionEvent(session, {
+            type: 'tool_result',
+            session_id: session.id,
+            task_id: session.last_task_id,
+            tool_results: event.tool_results,
+            message: envelope,
+        });
+    }
+}
+function ensureAcpSessionState(input) {
+    const parsedThread = input.thread_id ? parseThreadId(input.thread_id) : null;
+    const agentId = parsedThread?.agent_id || input.agent_id;
+    const sessionId = parsedThread?.session_id ||
+        input.session_id ||
+        input.thread_id ||
+        randomUUID();
+    const threadId = buildThreadId(agentId, sessionId);
+    const existing = sessionsById.get(threadId);
+    if (existing) {
+        if (input.metadata) {
+            existing.metadata = {
+                ...(existing.metadata || {}),
+                ...input.metadata,
+            };
+        }
+        existing.updated_at = nowIso();
+        return existing;
+    }
+    const chatJid = buildAcpChatJid(agentId, sessionId);
+    const timestamp = nowIso();
+    ensureRegisteredProject(agentId, chatJid, timestamp);
+    ensureSession({
+        agent_id: agentId,
+        session_id: sessionId,
+        channel: 'acp',
+        agent_name: agentId,
+    });
+    const session = {
+        id: threadId,
+        thread_id: threadId,
+        agent_id: agentId,
+        session_id: sessionId,
+        chat_jid: chatJid,
+        created_at: timestamp,
+        updated_at: timestamp,
+        stream_url: `/acp/sessions/${encodeURIComponent(threadId)}?stream=1`,
+        message_url: `/acp/sessions/${encodeURIComponent(threadId)}`,
+        tools_url: `/acp/sessions/${encodeURIComponent(threadId)}/tools`,
+        metadata: input.metadata,
+        messages: [],
+        clients: new Set(),
+    };
+    sessionsById.set(threadId, session);
+    sessionIdByChatJid.set(chatJid, threadId);
+    ensureRelaySync(session);
+    return session;
+}
+function getSessionByRouteId(id) {
+    const decoded = decodeURIComponent(id);
+    const existing = sessionsById.get(decoded);
+    if (existing)
+        return existing;
+    const parsed = parseThreadId(decoded);
+    if (!parsed)
+        return null;
+    return ensureAcpSessionState(parsed);
+}
+async function submitEnvelope(session, envelope, actorId, mode = 'message', syncToHub = true) {
+    appendMessage(session, envelope);
+    broadcastSessionEvent(session, {
+        type: 'message',
+        session_id: session.id,
+        task_id: session.last_task_id,
+        message: envelope,
+    });
+    if (syncToHub) {
+        await syncEnvelopeToRelay(session, envelope);
+    }
+    if (!isExecutableEnvelope(envelope)) {
+        return { accepted: false };
+    }
+    const task = submitTask({
+        agent_id: session.agent_id,
+        session_id: session.session_id,
+        prompt: buildPromptFromEnvelope(envelope, mode),
+        source: 'acp',
+        submitted_by: actorId,
+        submitter_type: 'api_key',
+        metadata: {
+            protocol: 'acp',
+            mode,
+            envelope,
+        },
+    });
+    session.last_task_id = task.id;
+    session.updated_at = nowIso();
+    broadcastSessionEvent(session, {
+        type: 'task',
+        session_id: session.id,
+        task_id: task.id,
+        data: {
+            phase: 'queued',
+            agent_id: session.agent_id,
+            session_id: session.session_id,
+        },
+    });
+    return {
+        accepted: true,
+        task_id: task.id,
+    };
+}
+export async function publishAcpTaskEvent(chatJid, event) {
+    const sessionId = sessionIdByChatJid.get(chatJid);
+    if (!sessionId)
+        return;
+    const session = sessionsById.get(sessionId);
+    if (!session)
+        return;
+    const phase = typeof event.phase === 'string' ? event.phase : 'activity';
+    const payload = {
+        type: 'task',
+        session_id: session.id,
+        task_id: typeof event.task_id === 'string' ? event.task_id : session.last_task_id,
+        data: event,
+    };
+    if (phase === 'message_delta') {
+        broadcastSessionEvent(session, {
+            type: 'message.delta',
+            session_id: session.id,
+            task_id: payload.task_id,
+            data: event,
+        });
+        return;
+    }
+    if (phase === 'tool_call' && Array.isArray(event.tool_calls)) {
+        const toolCalls = event.tool_calls;
+        broadcastSessionEvent(session, {
+            type: 'tool_call',
+            session_id: session.id,
+            task_id: payload.task_id,
+            tool_calls: toolCalls,
+            data: event,
+        });
+        await syncToolCallsToRelay(session, toolCalls);
+        return;
+    }
+    if (phase === 'tool_result' && Array.isArray(event.tool_results)) {
+        broadcastSessionEvent(session, {
+            type: 'tool_result',
+            session_id: session.id,
+            task_id: payload.task_id,
+            tool_results: event.tool_results,
+            data: event,
+        });
+        return;
+    }
+    if (phase === 'failed' || phase === 'timeout' || phase === 'canceled') {
+        broadcastSessionEvent(session, {
+            type: 'error',
+            session_id: session.id,
+            task_id: payload.task_id,
+            error: {
+                code: event.error &&
+                    typeof event.error === 'object' &&
+                    typeof event.error.code === 'string'
+                    ? event.error.code
+                    : phase,
+                message: event.error &&
+                    typeof event.error === 'object' &&
+                    typeof event.error.message === 'string'
+                    ? event.error.message
+                    : `Task ${phase}`,
+            },
+            data: event,
+        });
+        return;
+    }
+    broadcastSessionEvent(session, payload);
+}
+export async function maybeHandleAcpRequest(req, res, url) {
+    if (!url.pathname.startsWith('/acp'))
+        return false;
+    if (!ACP_ENABLED) {
+        writeProtocolError(res, 503, 'acp_disabled', 'ACP channel is disabled');
+        return true;
+    }
+    try {
+        if (url.pathname === '/acp/agents' && req.method === 'GET') {
+            writeJson(res, 200, {
+                protocol: 'acp',
+                agents: listAgentManifests(),
+            });
+            return true;
+        }
+        if (url.pathname === '/acp/sessions' && req.method === 'POST') {
+            const parsed = await readJsonBody(req);
+            const agentId = typeof parsed.agent_id === 'string' && parsed.agent_id.trim()
+                ? parsed.agent_id.trim()
+                : '';
+            if (!agentId) {
+                writeProtocolError(res, 400, 'agent_id_required', 'agent_id is required');
+                return true;
+            }
+            const session = ensureAcpSessionState({
+                agent_id: agentId,
+                session_id: typeof parsed.session_id === 'string' ? parsed.session_id : undefined,
+                thread_id: typeof parsed.thread_id === 'string' ? parsed.thread_id : undefined,
+                metadata: parsed.metadata && typeof parsed.metadata === 'object'
+                    ? parsed.metadata
+                    : undefined,
+            });
+            let taskId;
+            if (parsed.message) {
+                const envelope = normalizeAcpEnvelope(parsed.message);
+                const result = await submitEnvelope(session, envelope, 'acp');
+                taskId = result.task_id;
+            }
+            writeJson(res, taskId ? 202 : 201, {
+                session: serializeSession(session),
+                task_id: taskId || null,
+            });
+            return true;
+        }
+        const sessionToolsMatch = url.pathname.match(/^\/acp\/sessions\/([^/]+)\/tools$/);
+        if (sessionToolsMatch && req.method === 'POST') {
+            const session = getSessionByRouteId(sessionToolsMatch[1]);
+            if (!session) {
+                writeProtocolError(res, 404, 'session_not_found', 'ACP session not found');
+                return true;
+            }
+            const parsed = await readJsonBody(req);
+            const toolCalls = Array.isArray(parsed.tool_calls)
+                ? parsed.tool_calls
+                    .map((toolCall) => normalizeToolCall(toolCall))
+                    .filter((toolCall) => !!toolCall)
+                : [];
+            if (toolCalls.length === 0) {
+                writeProtocolError(res, 400, 'tool_calls_required', 'tool_calls must contain at least one tool call');
+                return true;
+            }
+            const envelope = {
+                id: randomUUID(),
+                role: 'user',
+                content: normalizeContent(parsed.content ?? parsed.prompt ?? ''),
+                tool_calls: toolCalls,
+                created_at: nowIso(),
+                ...(parsed.metadata && typeof parsed.metadata === 'object'
+                    ? { metadata: parsed.metadata }
+                    : {}),
+            };
+            const result = await submitEnvelope(session, envelope, 'acp', 'tools');
+            writeJson(res, 202, {
+                session: serializeSession(session),
+                task_id: result.task_id || null,
+                message: envelope,
+            });
+            return true;
+        }
+        const sessionMatch = url.pathname.match(/^\/acp\/sessions\/([^/]+)$/);
+        if (sessionMatch) {
+            const session = getSessionByRouteId(sessionMatch[1]);
+            if (!session) {
+                writeProtocolError(res, 404, 'session_not_found', 'ACP session not found');
+                return true;
+            }
+            if (req.method === 'GET') {
+                if (wantsSse(req, url)) {
+                    res.writeHead(200, {
+                        'Content-Type': 'text/event-stream',
+                        'Cache-Control': 'no-cache',
+                        Connection: 'keep-alive',
+                        'X-Accel-Buffering': 'no',
+                    });
+                    session.clients.add(res);
+                    writeSseEvent(res, {
+                        type: 'session',
+                        session_id: session.id,
+                        task_id: session.last_task_id,
+                        data: {
+                            session: serializeSession(session),
+                            messages: session.messages.slice(-20),
+                        },
+                    }, 'session');
+                    const heartbeat = setInterval(() => {
+                        try {
+                            res.write(': ping\n\n');
+                        }
+                        catch {
+                            clearInterval(heartbeat);
+                        }
+                    }, 20_000);
+                    req.on('close', () => {
+                        clearInterval(heartbeat);
+                        session.clients.delete(res);
+                    });
+                    return true;
+                }
+                writeJson(res, 200, {
+                    session: serializeSession(session),
+                    messages: session.messages,
+                });
+                return true;
+            }
+            if (req.method === 'POST') {
+                const parsed = await readJsonBody(req);
+                const envelope = normalizeAcpEnvelope(parsed, 'user');
+                const result = await submitEnvelope(session, envelope, 'acp');
+                writeJson(res, result.task_id ? 202 : 200, {
+                    session: serializeSession(session),
+                    task_id: result.task_id || null,
+                    message: envelope,
+                });
+                return true;
+            }
+        }
+    }
+    catch (err) {
+        const statusCode = err && typeof err === 'object' && 'statusCode' in err
+            ? Number(err.statusCode) || 500
+            : 500;
+        const code = err && typeof err === 'object' && 'code' in err
+            ? String(err.code)
+            : 'internal_error';
+        const message = err instanceof Error ? err.message : String(err);
+        logger.error({ err, pathname: url.pathname }, 'ACP request failed');
+        writeProtocolError(res, statusCode, code, message);
+        return true;
+    }
+    return false;
+}
+export class AcpChannel {
+    name = 'acp';
+    opts;
+    connected = false;
+    constructor(opts) {
+        this.opts = opts;
+        runtimeOpts = opts;
+        if (ACP_RELAY_URL) {
+            try {
+                const trustedEndpoint = validateOutboundEndpoint(ACP_RELAY_URL, {
+                    allowedProtocols: ['http:', 'https:'],
+                    label: 'ACP_RELAY_URL',
+                });
+                defaultClient = new ACPClient({
+                    baseUrl: trustedEndpoint.toString(),
+                });
+            }
+            catch (err) {
+                logger.error({ err: err.message, acp_relay_url: ACP_RELAY_URL }, 'ACP channel disabled remote sync due to endpoint security policy');
+                defaultClient = null;
+            }
+        }
+    }
+    async connect() {
+        this.connected = true;
+        logger.info({
+            relay_url: ACP_RELAY_URL || null,
+        }, 'ACP channel ready');
+    }
+    async sendMessage(jid, text, _options) {
+        const sessionId = sessionIdByChatJid.get(jid);
+        if (!sessionId)
+            return;
+        const session = sessionsById.get(sessionId);
+        if (!session || !text.trim())
+            return;
+        const envelope = {
+            id: randomUUID(),
+            role: 'assistant',
+            content: [{ type: 'markdown', text }],
+            created_at: nowIso(),
+        };
+        appendMessage(session, envelope);
+        broadcastSessionEvent(session, {
+            type: 'message',
+            session_id: session.id,
+            task_id: session.last_task_id,
+            message: envelope,
+        });
+        await syncEnvelopeToRelay(session, envelope);
+    }
+    async sendFile(jid, filePath, caption) {
+        const sessionId = sessionIdByChatJid.get(jid);
+        if (!sessionId)
+            return;
+        const session = sessionsById.get(sessionId);
+        if (!session)
+            return;
+        const artifactPart = {
+            type: 'artifact',
+            name: path.basename(filePath),
+            path: filePath,
+            mime_type: inferMimeType(filePath),
+            description: caption,
+        };
+        if (fs.existsSync(filePath)) {
+            artifactPart.uri = filePath;
+        }
+        const envelope = {
+            id: randomUUID(),
+            role: 'assistant',
+            content: [
+                ...(caption ? [{ type: 'markdown', text: caption }] : []),
+                artifactPart,
+            ],
+            created_at: nowIso(),
+        };
+        appendMessage(session, envelope);
+        broadcastSessionEvent(session, {
+            type: 'message',
+            session_id: session.id,
+            task_id: session.last_task_id,
+            message: envelope,
+        });
+        await syncEnvelopeToRelay(session, envelope);
+    }
+    isConnected() {
+        return this.connected;
+    }
+    ownsJid(jid) {
+        return jid.startsWith(ACP_JID_PREFIX);
+    }
+    async disconnect() {
+        this.connected = false;
+        for (const session of sessionsById.values()) {
+            session.relay_abort?.abort();
+            for (const client of session.clients) {
+                try {
+                    client.end();
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            session.clients.clear();
+        }
+        logger.info('ACP channel disconnected');
+    }
+}
+function createAcpChannel(opts) {
+    if (!ACP_ENABLED) {
+        logger.debug('ACP channel disabled (ACP_ENABLED=false)');
+        return null;
+    }
+    return new AcpChannel(opts);
+}
+registerChannel('acp', createAcpChannel);
+//# sourceMappingURL=acp.js.map