@borgee/agents-host 0.2.2 → 0.2.26

package/dist/gateway/localhost-gateway.js

@@ -0,0 +1,857 @@
+import { existsSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { BorgeeError, PermissionDeniedError } from '@borgee/plugin-sdk';
+import { SqliteConnectionsStateStore } from '../connections-state-store.js';
+import { evaluateGatewayAuthorization, } from '../policy/gateway-authorization.js';
+import { resolveConnectionsStatePath } from '../state-paths.js';
+import { findTaskForThread } from '../task-thread-resolution.js';
+import { extractVisibleMentionIds } from '../visible-mentions.js';
+const LOOPBACK_HOST = '127.0.0.1';
+export const LOCALHOST_GATEWAY_HISTORY_LIMIT = 20;
+const LOCALHOST_GATEWAY_BODY_LIMIT_BYTES = 32 * 1024;
+export const LOCALHOST_GATEWAY_COLLABORATION_BODY_LIMIT_BYTES = 512;
+export const LOCALHOST_GATEWAY_COLLABORATION_BODY_MAX_WORDS = 12;
+export const LOCALHOST_GATEWAY_COLLABORATION_TARGET_COOLDOWN_MS = 5_000;
+class RestartableConnectionsStateStore {
+    createStore;
+    activeStore = null;
+    constructor(createStore) {
+        this.createStore = createStore;
+    }
+    loadProviderSessions(provider, agentId) {
+        return this.ensureStore().loadProviderSessions(provider, agentId);
+    }
+    saveProviderSessions(provider, agentId, sessions) {
+        this.ensureStore().saveProviderSessions(provider, agentId, sessions);
+    }
+    hasTokenBinding(token) {
+        return this.ensureStore().hasTokenBinding(token);
+    }
+    loadTokenBinding(token) {
+        return this.ensureStore().loadTokenBinding(token);
+    }
+    loadTokenBindingForChannel(agentId, channelId) {
+        return this.ensureStore().loadTokenBindingForChannel(agentId, channelId);
+    }
+    replaceTokenBinding(binding) {
+        this.ensureStore().replaceTokenBinding(binding);
+    }
+    deleteTokenBinding(token) {
+        this.ensureStore().deleteTokenBinding(token);
+    }
+    revokeTokenBinding(token) {
+        this.ensureStore().revokeTokenBinding(token);
+    }
+    revokeAllTokenBindings() {
+        this.ensureStore().revokeAllTokenBindings();
+    }
+    close() {
+        this.activeStore?.close();
+        this.activeStore = null;
+    }
+    ensureStore() {
+        if (!this.activeStore) {
+            this.activeStore = this.createStore();
+        }
+        return this.activeStore;
+    }
+}
+class InMemoryGatewayTokenRegistry {
+    resolveBaseUrl;
+    tokenFactory;
+    activateRollback;
+    byChannel = new Map();
+    byToken = new Map();
+    pendingTokensByChannel = new Map();
+    constructor(resolveBaseUrl, tokenFactory, activateRollback = () => { }) {
+        this.resolveBaseUrl = resolveBaseUrl;
+        this.tokenFactory = tokenFactory;
+        this.activateRollback = activateRollback;
+    }
+    activate() {
+        this.activateRollback();
+    }
+    resolveBootstrap(channelId, options) {
+        const baseUrl = this.resolveBaseUrl();
+        if (!baseUrl) {
+            throw new Error('localhost gateway is not started');
+        }
+        const token = this.issuePendingToken(channelId);
+        return {
+            baseUrl,
+            token,
+            ...(options?.collaboration?.enabled
+                ? {
+                    collaboration: {
+                        enabled: true,
+                    },
+                    turnExecutionId: options.collaboration.turnExecutionId,
+                }
+                : {}),
+        };
+    }
+    publishPayload(channelId, payloadPath, payload) {
+        const channelContext = this.getOrCreateChannel(channelId);
+        const pendingToken = this.pendingTokensByChannel.get(channelId);
+        if (pendingToken && pendingToken !== channelContext.token) {
+            this.byToken.delete(channelContext.token);
+            channelContext.token = pendingToken;
+            this.byToken.set(channelContext.token, channelContext);
+        }
+        this.pendingTokensByChannel.delete(channelId);
+        channelContext.payloadPath = payloadPath;
+        channelContext.payload = payload;
+    }
+    lookup(token) {
+        return this.byToken.get(token) ?? null;
+    }
+    clearChannel(channelId) {
+        const channelContext = this.byChannel.get(channelId);
+        this.pendingTokensByChannel.delete(channelId);
+        if (!channelContext) {
+            return;
+        }
+        this.byChannel.delete(channelId);
+        this.byToken.delete(channelContext.token);
+    }
+    issuePendingToken(channelId) {
+        const existing = this.byChannel.get(channelId);
+        let token = this.issueUniqueToken();
+        while (token === existing?.token
+            || [...this.pendingTokensByChannel.values()].some((pendingToken) => pendingToken === token)) {
+            token = this.issueUniqueToken();
+        }
+        this.pendingTokensByChannel.set(channelId, token);
+        return token;
+    }
+    getOrCreateChannel(channelId) {
+        const existing = this.byChannel.get(channelId);
+        if (existing) {
+            return existing;
+        }
+        const created = {
+            channelId,
+            token: this.issueUniqueToken(),
+        };
+        this.byChannel.set(channelId, created);
+        this.byToken.set(created.token, created);
+        return created;
+    }
+    issueUniqueToken() {
+        let token = this.tokenFactory();
+        while (this.byToken.has(token)) {
+            token = this.tokenFactory();
+        }
+        return token;
+    }
+    close() { }
+}
+class DurableGatewayTokenRegistry {
+    resolveBaseUrl;
+    tokenFactory;
+    tokenBindingStore;
+    resolveStableAgentId;
+    closeTokenBindingStoreOnClose;
+    byChannel = new Map();
+    pendingBindingsByChannel = new Map();
+    constructor(resolveBaseUrl, tokenFactory, tokenBindingStore, resolveStableAgentId, closeTokenBindingStoreOnClose) {
+        this.resolveBaseUrl = resolveBaseUrl;
+        this.tokenFactory = tokenFactory;
+        this.tokenBindingStore = tokenBindingStore;
+        this.resolveStableAgentId = resolveStableAgentId;
+        this.closeTokenBindingStoreOnClose = closeTokenBindingStoreOnClose;
+    }
+    activate() { }
+    resolveBootstrap(channelId, options) {
+        const baseUrl = this.resolveBaseUrl();
+        if (!baseUrl) {
+            throw new Error('localhost gateway is not started');
+        }
+        const agentId = this.currentAgentId();
+        const existingBinding = this.tokenBindingStore.loadTokenBindingForChannel(agentId, channelId);
+        let token = this.tokenFactory();
+        while (token === existingBinding?.token
+            || this.tokenBindingStore.hasTokenBinding(token)
+            || [...this.pendingBindingsByChannel.values()].some((pendingBinding) => pendingBinding.token === token)) {
+            token = this.tokenFactory();
+        }
+        this.pendingBindingsByChannel.set(channelId, { token, agentId });
+        return {
+            baseUrl,
+            token,
+            ...(options?.collaboration?.enabled
+                ? {
+                    collaboration: {
+                        enabled: true,
+                    },
+                    turnExecutionId: options.collaboration.turnExecutionId,
+                }
+                : {}),
+        };
+    }
+    publishPayload(channelId, payloadPath, payload) {
+        const pendingBinding = this.pendingBindingsByChannel.get(channelId);
+        if (pendingBinding) {
+            this.tokenBindingStore.replaceTokenBinding({
+                token: pendingBinding.token,
+                agentId: pendingBinding.agentId,
+                channelId,
+            });
+            this.pendingBindingsByChannel.delete(channelId);
+        }
+        this.byChannel.set(channelId, {
+            payloadPath,
+            payload,
+        });
+    }
+    lookup(token) {
+        const binding = this.tokenBindingStore.loadTokenBinding(token);
+        if (!binding) {
+            return null;
+        }
+        const agentId = this.resolveStableAgentId()?.trim();
+        if (!agentId) {
+            return null;
+        }
+        if (binding.agentId !== agentId) {
+            this.tokenBindingStore.revokeTokenBinding(token);
+            return null;
+        }
+        const payloadState = this.byChannel.get(binding.channelId);
+        return {
+            token: binding.token,
+            agentId: binding.agentId,
+            channelId: binding.channelId,
+            payloadPath: payloadState?.payloadPath,
+            payload: payloadState?.payload,
+        };
+    }
+    clearChannel(channelId) {
+        this.pendingBindingsByChannel.delete(channelId);
+        this.byChannel.delete(channelId);
+        const agentId = this.resolveStableAgentId()?.trim();
+        if (!agentId) {
+            return;
+        }
+        const binding = this.tokenBindingStore.loadTokenBindingForChannel(agentId, channelId);
+        if (!binding) {
+            return;
+        }
+        this.tokenBindingStore.revokeTokenBinding(binding.token);
+    }
+    close() {
+        this.byChannel.clear();
+        this.pendingBindingsByChannel.clear();
+        if (this.closeTokenBindingStoreOnClose) {
+            this.tokenBindingStore.close();
+        }
+    }
+    currentAgentId() {
+        const agentId = this.resolveStableAgentId()?.trim();
+        if (!agentId) {
+            throw new Error('localhost gateway token binding requires a stable agent id');
+        }
+        return agentId;
+    }
+}
+class DisabledLocalhostGatewayController {
+    activateRollback;
+    enabled = false;
+    contextPublisher = undefined;
+    constructor(activateRollback = () => { }) {
+        this.activateRollback = activateRollback;
+    }
+    async start() {
+        this.activateRollback();
+    }
+    async stop() { }
+}
+class LoopbackLocalhostGatewayController {
+    controlPlane;
+    logger;
+    collaborationEnabled;
+    policyAuditGateEnabled;
+    policyMode;
+    auditSink;
+    authorizeCollaborationSend;
+    readCollaborationDraft;
+    enabled = true;
+    contextPublisher;
+    server = null;
+    baseUrl = null;
+    constructor(controlPlane, logger, collaborationEnabled, policyAuditGateEnabled, policyMode, auditSink, authorizeCollaborationSend, readCollaborationDraft, contextPublisherFactory) {
+        this.controlPlane = controlPlane;
+        this.logger = logger;
+        this.collaborationEnabled = collaborationEnabled;
+        this.policyAuditGateEnabled = policyAuditGateEnabled;
+        this.policyMode = policyMode;
+        this.auditSink = auditSink;
+        this.authorizeCollaborationSend = authorizeCollaborationSend;
+        this.readCollaborationDraft = readCollaborationDraft;
+        this.contextPublisher = contextPublisherFactory(() => this.baseUrl);
+    }
+    async start() {
+        if (this.server) {
+            return;
+        }
+        const server = createServer((request, response) => {
+            void this.handleRequest(request, response).catch((error) => {
+                this.logger?.error('localhost gateway request failed', { error });
+                this.sendJson(response, 500, { error: 'internal_error' });
+            });
+        });
+        await new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(0, LOOPBACK_HOST, () => {
+                server.off('error', reject);
+                resolve();
+            });
+        });
+        const address = server.address();
+        if (!address || typeof address === 'string') {
+            server.close();
+            throw new Error('localhost gateway failed to resolve a loopback address');
+        }
+        this.server = server;
+        this.baseUrl = `http://${LOOPBACK_HOST}:${address.port}`;
+        try {
+            this.contextPublisher.activate();
+        }
+        catch (error) {
+            await new Promise((resolve, reject) => {
+                server.close((closeError) => {
+                    this.server = null;
+                    this.baseUrl = null;
+                    if (closeError) {
+                        reject(closeError);
+                        return;
+                    }
+                    resolve();
+                });
+            }).catch((closeError) => {
+                this.logger?.error('localhost gateway shutdown failed after rollback cleanup error', { error: closeError });
+            });
+            throw error;
+        }
+    }
+    async stop() {
+        const server = this.server;
+        this.server = null;
+        this.baseUrl = null;
+        let thrown;
+        if (server) {
+            await new Promise((resolve, reject) => {
+                server.close((error) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve();
+                });
+            }).catch((error) => {
+                thrown = error;
+            });
+        }
+        try {
+            this.contextPublisher.close();
+        }
+        catch (error) {
+            thrown ??= error;
+        }
+        if (thrown) {
+            throw thrown;
+        }
+    }
+    async handleRequest(request, response) {
+        const baseUrl = this.baseUrl ?? `http://${LOOPBACK_HOST}`;
+        const decision = evaluateGatewayAuthorization({
+            request,
+            baseUrl,
+            allowCollaborationRoutes: this.collaborationEnabled,
+            lookup: (token) => {
+                const binding = this.contextPublisher.lookup(token);
+                if (!binding) {
+                    return null;
+                }
+                return {
+                    channelId: binding.channelId,
+                    agentId: binding.agentId,
+                    payloadAvailable: binding.payload != null,
+                };
+            },
+        });
+        if (decision.allowHeader) {
+            response.setHeader('allow', decision.allowHeader);
+        }
+        if (decision.responseBody) {
+            this.sendJson(response, decision.statusCode, decision.responseBody);
+            this.recordAudit(decision.reason, decision.statusCode, decision.path, request.method ?? 'GET', decision.binding);
+            return;
+        }
+        const binding = decision.token ? this.contextPublisher.lookup(decision.token) : null;
+        if (!binding || !decision.route || decision.route.resource === 'health') {
+            this.sendJson(response, 500, { error: 'internal_error' });
+            this.recordAudit('authorized', 500, decision.path, request.method ?? 'GET', decision.binding);
+            return;
+        }
+        try {
+            switch (decision.route.resource) {
+                case 'bootstrap': {
+                    this.sendJson(response, 200, redactGatewayBootstrap(binding.payload));
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'GET', decision.binding);
+                    return;
+                }
+                case 'me': {
+                    this.sendJson(response, 200, await this.controlPlane.getMe());
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'GET', decision.binding);
+                    return;
+                }
+                case 'history': {
+                    const url = new URL(request.url ?? '/', baseUrl);
+                    const limit = clampHistoryLimit(url.searchParams.get('limit'));
+                    const before = parseOptionalInteger(url.searchParams.get('before'));
+                    const after = parseOptionalInteger(url.searchParams.get('after'));
+                    const messages = await this.controlPlane.readChannelHistory({
+                        channelId: binding.channelId,
+                        before,
+                        after,
+                        limit,
+                    });
+                    this.sendJson(response, 200, { messages });
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'GET', decision.binding);
+                    return;
+                }
+                case 'draft': {
+                    if (!binding.payload?.localhostGateway?.collaboration?.enabled) {
+                        this.sendJson(response, 404, { error: 'not_found' });
+                        this.recordAudit('not-found', 404, decision.path, request.method ?? 'GET', decision.binding);
+                        return;
+                    }
+                    const url = new URL(request.url ?? '/', baseUrl);
+                    const turnExecutionId = readRequiredQueryString(url, 'turnExecutionId');
+                    if (!turnExecutionId) {
+                        this.sendJson(response, 400, { error: 'missing_turn_execution_id' });
+                        this.recordAudit('bad-request', 400, decision.path, request.method ?? 'GET', decision.binding);
+                        return;
+                    }
+                    const draft = this.readCollaborationDraft?.({
+                        channelId: binding.channelId,
+                        turnExecutionId,
+                    }) ?? null;
+                    if (!draft) {
+                        this.sendJson(response, 404, { error: 'not_found' });
+                        this.recordAudit('not-found', 404, decision.path, request.method ?? 'GET', decision.binding);
+                        return;
+                    }
+                    this.sendJson(response, 200, { draft });
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'GET', decision.binding);
+                    return;
+                }
+                case 'tasks': {
+                    if (binding.payload?.taskAssignmentContext?.active === true) {
+                        this.sendJson(response, 400, { error: 'task_thread_collection_not_allowed' });
+                        this.recordAudit('authorized', 400, decision.path, request.method ?? 'GET', decision.binding);
+                        return;
+                    }
+                    if (request.method === 'POST') {
+                        const body = await readGatewayJsonBody(request);
+                        const input = parseCreateTaskInput(binding.channelId, body);
+                        const task = await this.controlPlane.createTask(input);
+                        this.sendJson(response, 200, task);
+                        this.recordAudit('authorized', 200, decision.path, request.method ?? 'POST', decision.binding);
+                        return;
+                    }
+                    const tasks = await this.controlPlane.listTasks({ channelId: binding.channelId });
+                    this.sendJson(response, 200, { tasks });
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'GET', decision.binding);
+                    return;
+                }
+                case 'current-task': {
+                    const task = await this.loadCurrentThreadTask(binding);
+                    if (request.method === 'PATCH') {
+                        const body = await readGatewayJsonBody(request);
+                        const input = parseUpdateTaskInput(task.id, body);
+                        const updatedTask = await this.controlPlane.updateTask(input);
+                        if (!isTaskInAuthorizedScope(binding.channelId, updatedTask)) {
+                            this.sendJson(response, 404, { error: 'not_found' });
+                            this.recordAudit('not-found', 404, decision.path, request.method ?? 'PATCH', decision.binding);
+                            return;
+                        }
+                        this.sendJson(response, 200, updatedTask);
+                        this.recordAudit('authorized', 200, decision.path, request.method ?? 'PATCH', decision.binding);
+                        return;
+                    }
+                    this.sendJson(response, 200, task);
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'GET', decision.binding);
+                    return;
+                }
+                case 'task': {
+                    const task = await this.loadAuthorizedTask(binding.channelId, decision.route);
+                    if (request.method === 'PATCH') {
+                        const body = await readGatewayJsonBody(request);
+                        const input = parseUpdateTaskInput(decision.route.taskId, body);
+                        const updatedTask = await this.controlPlane.updateTask(input);
+                        if (!isTaskInAuthorizedScope(binding.channelId, updatedTask)) {
+                            this.sendJson(response, 404, { error: 'not_found' });
+                            this.recordAudit('not-found', 404, decision.path, request.method ?? 'PATCH', decision.binding);
+                            return;
+                        }
+                        this.sendJson(response, 200, updatedTask);
+                        this.recordAudit('authorized', 200, decision.path, request.method ?? 'PATCH', decision.binding);
+                        return;
+                    }
+                    this.sendJson(response, 200, task);
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'GET', decision.binding);
+                    return;
+                }
+                case 'users': {
+                    if (!binding.payload?.localhostGateway?.collaboration?.enabled) {
+                        this.sendJson(response, 404, { error: 'not_found' });
+                        this.recordAudit('not-found', 404, decision.path, request.method ?? 'GET', decision.binding);
+                        return;
+                    }
+                    this.sendJson(response, 200, {
+                        users: await this.controlPlane.listUsers(),
+                    });
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'GET', decision.binding);
+                    return;
+                }
+                case 'messages': {
+                    if (!binding.payload?.localhostGateway?.collaboration?.enabled) {
+                        this.sendJson(response, 404, { error: 'not_found' });
+                        this.recordAudit('not-found', 404, decision.path, request.method ?? 'POST', decision.binding);
+                        return;
+                    }
+                    const parsedBody = await readCollaborationRequestBody(request);
+                    if (!parsedBody.ok) {
+                        this.sendJson(response, parsedBody.statusCode, { error: parsedBody.error });
+                        this.recordAudit(parsedBody.error, parsedBody.statusCode, decision.path, request.method ?? 'POST', decision.binding);
+                        return;
+                    }
+                    const authorization = this.authorizeCollaborationSend?.({
+                        channelId: binding.channelId,
+                        turnExecutionId: parsedBody.message.turnExecutionId,
+                        mentions: parsedBody.message.mentions ?? [],
+                        replyToId: parsedBody.message.replyToId,
+                    }) ?? { ok: false, statusCode: 403, error: 'collaboration_not_enabled' };
+                    if (!authorization.ok) {
+                        this.sendJson(response, authorization.statusCode, { error: authorization.error });
+                        this.recordAudit(authorization.error ?? 'collaboration_not_enabled', authorization.statusCode, decision.path, request.method ?? 'POST', decision.binding);
+                        return;
+                    }
+                    let posted;
+                    try {
+                        posted = await this.controlPlane.postMessage({
+                            channelId: binding.channelId,
+                            body: parsedBody.message.body,
+                            replyToId: parsedBody.message.replyToId,
+                        });
+                    }
+                    catch (error) {
+                        authorization.rollback?.();
+                        throw error;
+                    }
+                    authorization.commit?.();
+                    this.sendJson(response, 200, posted);
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'POST', decision.binding);
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            const gatewayError = error instanceof GatewayHttpError
+                ? error
+                : mapGatewayControlPlaneError(error, 'authorized');
+            if (gatewayError) {
+                this.sendJson(response, gatewayError.statusCode, gatewayError.responseBody);
+                this.recordAudit(gatewayError.reason, gatewayError.statusCode, decision.path, request.method ?? 'GET', decision.binding);
+                return;
+            }
+            this.recordAudit('authorized', 500, decision.path, request.method ?? 'GET', decision.binding);
+            throw error;
+        }
+    }
+    async loadAuthorizedTask(boundChannelId, route) {
+        let task;
+        try {
+            task = await this.controlPlane.getTask({ taskId: route.taskId });
+        }
+        catch (error) {
+            throw mapGatewayControlPlaneError(error, 'not-found');
+        }
+        if (!isTaskInAuthorizedScope(boundChannelId, task)) {
+            throw new GatewayHttpError(404, { error: 'not_found' }, 'not-found');
+        }
+        return task;
+    }
+    async loadCurrentThreadTask(binding) {
+        let task;
+        const preferredTaskId = binding.payload?.taskAssignmentContext?.currentTaskId;
+        try {
+            task = await findTaskForThread(this.controlPlane, binding.channelId, preferredTaskId);
+        }
+        catch (error) {
+            throw mapGatewayControlPlaneError(error, 'authorized');
+        }
+        if (!task) {
+            throw new GatewayHttpError(404, { error: 'not_found' }, 'not-found');
+        }
+        return task;
+    }
+    sendJson(response, statusCode, payload) {
+        response.statusCode = statusCode;
+        response.setHeader('content-type', 'application/json; charset=utf-8');
+        response.end(`${JSON.stringify(payload)}\n`);
+    }
+    recordAudit(reason, status, path, method, binding) {
+        if (!this.policyAuditGateEnabled) {
+            return;
+        }
+        this.auditSink?.append({
+            timestamp: new Date().toISOString(),
+            surface: 'localhost-gateway',
+            policyMode: this.policyMode,
+            effectiveOutcome: status < 400 ? 'allowed' : 'denied',
+            reason,
+            agentId: binding?.agentId,
+            channelId: binding?.channelId,
+            method,
+            path,
+            status,
+        });
+    }
+}
+function parseOptionalInteger(value) {
+    if (value == null || value.trim().length === 0) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function clampHistoryLimit(value) {
+    const parsed = parseOptionalInteger(value);
+    if (parsed == null || parsed <= 0) {
+        return LOCALHOST_GATEWAY_HISTORY_LIMIT;
+    }
+    return Math.min(parsed, LOCALHOST_GATEWAY_HISTORY_LIMIT);
+}
+function readRequiredQueryString(url, key) {
+    const value = url.searchParams.get(key);
+    if (value == null) {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+class GatewayHttpError extends Error {
+    statusCode;
+    responseBody;
+    reason;
+    constructor(statusCode, responseBody, reason) {
+        super(responseBody.error);
+        this.statusCode = statusCode;
+        this.responseBody = responseBody;
+        this.reason = reason;
+    }
+}
+async function readRequestBody(request, byteLimit) {
+    const chunks = [];
+    let totalBytes = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+        totalBytes += buffer.byteLength;
+        if (totalBytes > byteLimit) {
+            return { ok: false, statusCode: 413, error: 'request_body_too_large' };
+        }
+        chunks.push(buffer);
+    }
+    return {
+        ok: true,
+        text: Buffer.concat(chunks).toString('utf8'),
+    };
+}
+async function readGatewayJsonBody(request) {
+    const bodyText = await readRequestBody(request, LOCALHOST_GATEWAY_BODY_LIMIT_BYTES);
+    if (!bodyText.ok) {
+        throw new GatewayHttpError(bodyText.statusCode, { error: bodyText.error }, bodyText.error);
+    }
+    if (bodyText.text.trim().length === 0) {
+        return {};
+    }
+    try {
+        return JSON.parse(bodyText.text);
+    }
+    catch {
+        throw new GatewayHttpError(400, { error: 'invalid_json' }, 'invalid-json');
+    }
+}
+async function readCollaborationRequestBody(request) {
+    const bodyText = await readRequestBody(request, LOCALHOST_GATEWAY_COLLABORATION_BODY_LIMIT_BYTES);
+    if (!bodyText.ok) {
+        return bodyText;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(bodyText.text);
+    }
+    catch {
+        return { ok: false, statusCode: 400, error: 'invalid_json_body' };
+    }
+    if (!parsed || typeof parsed !== 'object') {
+        return { ok: false, statusCode: 400, error: 'invalid_message_body' };
+    }
+    const message = parsed;
+    if ('mentions' in message) {
+        return { ok: false, statusCode: 400, error: 'deprecated_mentions_not_allowed' };
+    }
+    const body = typeof message.body === 'string' ? message.body.trim() : '';
+    const replyToId = typeof message.replyToId === 'string' && message.replyToId.trim().length > 0
+        ? message.replyToId.trim()
+        : undefined;
+    const turnExecutionId = typeof message.turnExecutionId === 'string' && message.turnExecutionId.trim().length > 0
+        ? message.turnExecutionId.trim()
+        : '';
+    const mentions = extractVisibleMentionIds(body);
+    if (body.length === 0) {
+        return { ok: false, statusCode: 400, error: 'empty_message_body' };
+    }
+    if (/[\r\n]/.test(body)) {
+        return { ok: false, statusCode: 400, error: 'multiline_message_body_not_allowed' };
+    }
+    if (body.split(/\s+/).filter((value) => value.length > 0).length > LOCALHOST_GATEWAY_COLLABORATION_BODY_MAX_WORDS) {
+        return { ok: false, statusCode: 400, error: 'message_body_too_verbose' };
+    }
+    if (!turnExecutionId) {
+        return { ok: false, statusCode: 400, error: 'missing_turn_execution_id' };
+    }
+    if (!replyToId && mentions.length === 0) {
+        return { ok: false, statusCode: 400, error: 'missing_reply_or_mentions' };
+    }
+    return {
+        ok: true,
+        message: {
+            body,
+            replyToId,
+            mentions,
+            turnExecutionId,
+        },
+    };
+}
+function redactGatewayBootstrap(payload) {
+    if (!payload.localhostGateway) {
+        return payload;
+    }
+    return {
+        ...payload,
+        localhostGateway: {
+            baseUrl: payload.localhostGateway.baseUrl,
+            ...(payload.localhostGateway.collaboration
+                ? {
+                    collaboration: payload.localhostGateway.collaboration,
+                }
+                : {}),
+        },
+    };
+}
+function parseCreateTaskInput(channelId, body) {
+    if (!isRecord(body)) {
+        throw new GatewayHttpError(400, { error: 'invalid_json' }, 'invalid-json');
+    }
+    const title = readOptionalString(body.title);
+    if (!title) {
+        throw new GatewayHttpError(400, { error: 'title_required' }, 'bad-request');
+    }
+    return {
+        channelId,
+        title,
+        description: readOptionalString(body.description),
+        assigneeId: readOptionalString(body.assigneeId) ?? readOptionalString(body.assignee_id),
+    };
+}
+function parseUpdateTaskInput(taskId, body) {
+    if (!isRecord(body)) {
+        throw new GatewayHttpError(400, { error: 'invalid_json' }, 'invalid-json');
+    }
+    const input = {
+        taskId,
+        status: readOptionalString(body.status),
+        assigneeId: readOptionalString(body.assigneeId) ?? readOptionalString(body.assignee_id),
+        title: readOptionalString(body.title),
+    };
+    if (input.status === undefined && input.assigneeId === undefined && input.title === undefined) {
+        throw new GatewayHttpError(400, { error: 'no_updates' }, 'bad-request');
+    }
+    return input;
+}
+function isTaskInAuthorizedScope(boundChannelId, task) {
+    return task.channelId === boundChannelId || task.threadId === boundChannelId;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function readOptionalString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function mapGatewayControlPlaneError(error, fallbackReason) {
+    if (error instanceof GatewayHttpError) {
+        return error;
+    }
+    if (error instanceof PermissionDeniedError) {
+        return new GatewayHttpError(403, { error: 'permission_denied' }, 'permission-denied');
+    }
+    if (error instanceof BorgeeError) {
+        switch (error.code) {
+            case 'bpp.task_not_found':
+            case 'bpp.channel_not_found':
+            case 'bpp.guild_not_found':
+                return new GatewayHttpError(404, { error: 'not_found' }, 'not-found');
+            case 'bpp.task_title_required':
+                return new GatewayHttpError(400, { error: 'title_required' }, 'bad-request');
+            case 'bpp.task_no_updates':
+            case 'bpp.payload_malformed':
+            case 'bpp.task_scope_required':
+            case 'bpp.channel_id_required':
+            case 'bpp.task_id_required':
+                return new GatewayHttpError(400, { error: 'bad_request' }, 'bad-request');
+            default:
+                return new GatewayHttpError(502, { error: 'upstream_error' }, fallbackReason);
+        }
+    }
+    return new GatewayHttpError(500, { error: 'internal_error' }, fallbackReason);
+}
+function revokeDurableTokenBindingsIfPresent(stateRootDir) {
+    const normalizedStateRootDir = stateRootDir?.trim();
+    if (!normalizedStateRootDir) {
+        return;
+    }
+    const databasePath = resolveConnectionsStatePath(normalizedStateRootDir);
+    if (!existsSync(databasePath)) {
+        return;
+    }
+    const tokenBindingStore = new SqliteConnectionsStateStore({ stateRootDir: normalizedStateRootDir });
+    try {
+        tokenBindingStore.revokeAllTokenBindings();
+    }
+    finally {
+        tokenBindingStore.close();
+    }
+}
+export function createLocalhostGatewayController(options) {
+    if (!options.gateEnabled) {
+        return new DisabledLocalhostGatewayController(() => revokeDurableTokenBindingsIfPresent(options.stateRootDir));
+    }
+    const contextPublisherFactory = (resolveBaseUrl) => {
+        if (!options.tokenBindingGateEnabled) {
+            return new InMemoryGatewayTokenRegistry(resolveBaseUrl, options.tokenFactory ?? (() => randomUUID()), () => revokeDurableTokenBindingsIfPresent(options.stateRootDir));
+        }
+        const stateRootDir = options.stateRootDir?.trim();
+        if (!stateRootDir) {
+            throw new Error('localhost gateway token binding requires a state root directory');
+        }
+        const closesTokenBindingStoreOnClose = !options.tokenBindingStore;
+        return new DurableGatewayTokenRegistry(resolveBaseUrl, options.tokenFactory ?? (() => randomUUID()), options.tokenBindingStore
+            ?? new RestartableConnectionsStateStore(() => new SqliteConnectionsStateStore({ stateRootDir })), options.resolveStableAgentId ?? (() => undefined), closesTokenBindingStoreOnClose);
+    };
+    return new LoopbackLocalhostGatewayController(options.controlPlane, options.logger, options.collaborationEnabled ?? false, options.policyAuditGateEnabled ?? false, options.policyMode ?? 'audit-only', options.auditSink, options.authorizeCollaborationSend, options.readCollaborationDraft, contextPublisherFactory);
+}