const CLAUDE_PERMISSION_REPLY_RE = /^(yes|no)\s+([a-km-z]{5})$/i;

const QUEUE_LIMIT = 1_000;

const CONVERSATIONS_LIST_LIMIT = 500;

const MESSAGES_READ_LIMIT = 200;

const EVENTS_POLL_LIMIT = 200;

const EVENTS_WAIT_TIMEOUT_LIMIT_MS = 300_000;

const PENDING_CLAUDE_PERMISSION_TTL_MS = 60 * 60 * 1_000;

const PENDING_APPROVAL_DEFAULT_TTL_MS = 30 * 60 * 1_000;

const PENDING_SWEEP_INTERVAL_MS = 5 * 60 * 1_000;

function clampPositiveInteger(value: number | undefined, fallback: number, max: number): number {

if (typeof value !== "number" || !Number.isFinite(value)) {

return fallback;

}

return Math.min(max, Math.max(1, Math.floor(value)));

}

/** Connects the MCP server surface to a Gateway client and queues channel events for polling. */

export class OpenClawChannelBridge {

private gateway: GatewayClient | null = null;

includeLastMessage?: boolean;

}): Promise<ConversationDescriptor[]> {

await this.waitUntilReady();

const limit = clampPositiveInteger(params?.limit, 50, CONVERSATIONS_LIST_LIMIT);

const response: SessionListResult = await this.requestGateway("sessions.list", {

limit: params?.limit ?? 50,

limit,

search: params?.search,

includeDerivedTitles: params?.includeDerivedTitles ?? true,

includeLastMessage: params?.includeLastMessage ?? true,

limit = 20,

): Promise<NonNullable<ChatHistoryResult["messages"]>> {

await this.waitUntilReady();

const requestLimit = clampPositiveInteger(limit, 20, MESSAGES_READ_LIMIT);

const response: ChatHistoryResult = await this.requestGateway("sessions.get", {

key: sessionKey,

limit,

limit: requestLimit,

});

return response.messages ?? [];

}

/** Poll queued events after a cursor without consuming them. */

pollEvents(filter: WaitFilter, limit = 20): { events: QueueEvent[]; nextCursor: number } {

const events = this.queue.filter((event) => matchEventFilter(event, filter)).slice(0, limit);

const eventLimit = clampPositiveInteger(limit, 20, EVENTS_POLL_LIMIT);

const events = this.queue

.filter((event) => matchEventFilter(event, filter))

.slice(0, eventLimit);

const nextCursor = events.at(-1)?.cursor ?? filter.afterCursor;

return { events, nextCursor };

}

if (existing) {

return existing;

}

const waitTimeoutMs = clampPositiveInteger(timeoutMs, 30_000, EVENTS_WAIT_TIMEOUT_LIMIT_MS);

return await new Promise<QueueEvent | null>((resolve) => {

const waiter: PendingWaiter = {

filter,

},

timeout: null,

};

if (timeoutMs > 0) {

waiter.timeout = setTimeout(() => {

waiter.resolve(null);

}, timeoutMs);

}

waiter.timeout = setTimeout(() => {

waiter.resolve(null);

}, waitTimeoutMs);

this.pendingWaiters.add(waiter);

});

}