@xopcai/xopc 0.0.188 → 0.0.189

package/dist/src/agent/streaming/reasoning-visibility-sse.d.ts

@@ -1,15 +0,0 @@
-/**
- * Outbound SSE visibility for session `reasoningLevel`.
- * Single choke point: call from the queue push path so agent subscribe stays free of policy branches.
- *
- * Note: Does not alter persisted messages or agent state; history/UI may still strip thinking separately.
- */
-import type { ReasoningLevel } from '../transcript/thinking-types.js';
-export type SseStreamEvent = {
-    type: string;
-    [key: string]: unknown;
-};
-/**
- * @returns `null` to drop the event; unchanged `event` otherwise.
- */
-export declare function applyReasoningVisibilityToSseEvent(event: SseStreamEvent, reasoningLevel: ReasoningLevel): SseStreamEvent | null;

package/dist/src/gateway/agent-run-relay.d.ts

@@ -1,19 +0,0 @@
-/**
- * Multicast buffer for a single web agent run so multiple HTTP SSE consumers can
- * attach through POST /api/agent/resume while one
- * background pump drains processDirectStreaming.
- */
-export type RelayEvent = {
-    type: string;
-} & Record<string, unknown>;
-export declare class AgentRunRelay {
-    private readonly maxEvents;
-    private runs;
-    constructor(maxEvents?: number);
-    ensureRun(runId: string, sessionKey: string): void;
-    getSessionKey(runId: string): string | undefined;
-    hasRun(runId: string): boolean;
-    publish(runId: string, event: RelayEvent): RelayEvent | undefined;
-    complete(runId: string): void;
-    subscribe(runId: string): AsyncGenerator<RelayEvent>;
-}

package/dist/src/gateway/agent-run-relay.js

@@ -1,169 +0,0 @@
-import { createLogger } from "../utils/logger/index.js";
-import { init_logger } from "../utils/logger.js";
-//#region src/gateway/agent-run-relay.ts
-init_logger();
-const log = createLogger("Gateway:AgentRunRelay");
-const COMPLETE_TTL_MS = 5 * 6e4;
-const MAX_EVENTS = 8e3;
-const COMPACT_TO_RATIO = .75;
-const MAX_MERGED_DELTA_CHARS = 16 * 1024;
-const REPLAY_DELTA_TYPES = new Set([
-	"assistant_delta",
-	"thinking_delta",
-	"command_output_delta",
-	"review_delta"
-]);
-function eventSeq(event) {
-	return typeof event.seq === "number" ? event.seq : void 0;
-}
-function findEventAtOrAfter(events, seq) {
-	let low = 0;
-	let high = events.length;
-	while (low < high) {
-		const middle = low + Math.floor((high - low) / 2);
-		if ((eventSeq(events[middle]) ?? Number.MAX_SAFE_INTEGER) < seq) low = middle + 1;
-		else high = middle;
-	}
-	return events[low];
-}
-function recordValue(value) {
-	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
-function sameDeltaStream(left, right) {
-	if (left.type !== right.type || !REPLAY_DELTA_TYPES.has(left.type)) return false;
-	const leftPayload = recordValue(left.payload);
-	const rightPayload = recordValue(right.payload);
-	if (!leftPayload || !rightPayload) return false;
-	return [
-		"messageId",
-		"toolCallId",
-		"reviewId",
-		"stream"
-	].every((key) => leftPayload[key] === rightPayload[key]);
-}
-function mergeReplayDelta(events, event) {
-	const previous = events.at(-1);
-	if (!previous || !sameDeltaStream(previous, event)) return false;
-	const previousPayload = recordValue(previous.payload);
-	const payload = recordValue(event.payload);
-	const previousDelta = previousPayload?.delta;
-	const delta = payload?.delta;
-	if (typeof previousDelta !== "string" || typeof delta !== "string") return false;
-	if (previousDelta.length + delta.length > MAX_MERGED_DELTA_CHARS) return false;
-	events[events.length - 1] = {
-		...previous,
-		payload: {
-			...previousPayload,
-			delta: previousDelta + delta
-		}
-	};
-	return true;
-}
-function compactEvents(events, targetSize) {
-	let remaining = Math.max(0, events.length - targetSize);
-	const retained = [];
-	const removedByType = {};
-	for (const event of events) {
-		if (remaining > 0 && REPLAY_DELTA_TYPES.has(event.type)) {
-			remaining -= 1;
-			removedByType[event.type] = (removedByType[event.type] ?? 0) + 1;
-			continue;
-		}
-		retained.push(event);
-	}
-	if (remaining > 0) for (const event of retained.splice(0, remaining)) removedByType[event.type] = (removedByType[event.type] ?? 0) + 1;
-	return {
-		events: retained,
-		removedByType
-	};
-}
-var AgentRunRelay = class {
-	runs = /* @__PURE__ */ new Map();
-	constructor(maxEvents = MAX_EVENTS) {
-		this.maxEvents = maxEvents;
-		if (!Number.isInteger(maxEvents) || maxEvents < 2) throw new Error("AgentRunRelay maxEvents must be an integer greater than 1");
-	}
-	ensureRun(runId, sessionKey) {
-		if (this.runs.has(runId)) return;
-		this.runs.set(runId, {
-			sessionKey,
-			events: [],
-			nextSeq: 1,
-			done: false,
-			waiters: [],
-			subscriberCount: 0,
-			compactionWarned: false
-		});
-	}
-	getSessionKey(runId) {
-		return this.runs.get(runId)?.sessionKey;
-	}
-	hasRun(runId) {
-		return this.runs.has(runId);
-	}
-	publish(runId, event) {
-		const state = this.runs.get(runId);
-		if (!state) return void 0;
-		const relayed = {
-			...event,
-			runId,
-			seq: state.nextSeq++
-		};
-		const merged = state.subscriberCount === 0 && mergeReplayDelta(state.events, relayed);
-		if (!merged && state.events.length >= this.maxEvents) {
-			const targetSize = Math.max(1, Math.floor(this.maxEvents * COMPACT_TO_RATIO));
-			const compacted = compactEvents(state.events, targetSize);
-			state.events = compacted.events;
-			if (!state.compactionWarned) {
-				state.compactionWarned = true;
-				log.warn({
-					runId,
-					max: this.maxEvents,
-					retained: state.events.length,
-					removedByType: compacted.removedByType
-				}, "Relay replay buffer compacted; old delta events are no longer resumable");
-			}
-		}
-		if (!merged) state.events.push(relayed);
-		const waiters = state.waiters.splice(0);
-		for (const w of waiters) w();
-		return relayed;
-	}
-	complete(runId) {
-		const state = this.runs.get(runId);
-		if (!state) return;
-		state.done = true;
-		const waiters = state.waiters.splice(0);
-		for (const w of waiters) w();
-		if (state.cleanupTimer) clearTimeout(state.cleanupTimer);
-		state.cleanupTimer = setTimeout(() => {
-			this.runs.delete(runId);
-		}, COMPLETE_TTL_MS);
-	}
-	async *subscribe(runId) {
-		const state = this.runs.get(runId);
-		if (!state) throw new Error("UNKNOWN_RUN");
-		state.subscriberCount += 1;
-		try {
-			let nextSeq = eventSeq(state.events[0]) ?? state.nextSeq;
-			while (true) {
-				const earliestSeq = eventSeq(state.events[0]);
-				if (earliestSeq !== void 0 && nextSeq < earliestSeq) nextSeq = earliestSeq;
-				const available = findEventAtOrAfter(state.events, nextSeq);
-				if (available) {
-					nextSeq = (eventSeq(available) ?? nextSeq) + 1;
-					yield available;
-					continue;
-				}
-				if (state.done) break;
-				await new Promise((resolve) => {
-					state.waiters.push(resolve);
-				});
-			}
-		} finally {
-			state.subscriberCount -= 1;
-		}
-	}
-};
-//#endregion
-export { AgentRunRelay };

package/dist/src/gateway/hono/sse.d.ts

@@ -1,53 +0,0 @@
-import type { Context } from 'hono';
-import type { GatewayService } from '../service.js';
-/** Close long-lived gateway event streams before the HTTP server starts draining. */
-export declare function closeAllEventStreams(): void;
-export interface SSEHandlerConfig {
-    service: GatewayService;
-    maxSseConnections?: number;
-}
-/**
- * POST /api/agent/resume — Re-attach to an in-progress agent run via SSE.
- *
- * Request body: { runId, sessionKey }
- * The relay replays retained buffered events from the beginning and then live-tails
- * until the run completes.
- *
- * SSE events are the active run's retained and live stream events.
- */
-export declare function createAgentResumeHandler(config: SSEHandlerConfig): (c: Context) => Promise<Response>;
-/**
- * POST /api/send — Send a message through a channel (non-streaming).
- */
-export declare function createSendHandler(config: SSEHandlerConfig): (c: Context) => Promise<(Response & import("hono").TypedResponse<{
-    ok: false;
-    error: {
-        code: string;
-        message: string;
-    };
-}, 400, "json">) | (Response & import("hono").TypedResponse<{
-    ok: true;
-    payload: {
-        sent: boolean;
-        messageId?: string;
-    };
-}, import("hono/dist/types/utils/http-status.js").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    ok: false;
-    error: {
-        code: string;
-        message: string;
-    };
-}, 500, "json">)>;
-/**
- * GET /api/events — Server-pushed event stream (SSE).
- *
- * The client opens this long-lived connection to receive:
- *   - channel status changes
- *   - config reload notifications
- *   - cron execution results
- *   - any other server-initiated events
- *
- * Supports Last-Event-ID for reconnection.
- * Enforces maximum connection limit to prevent DoS.
- */
-export declare function createEventsSSEHandler(config: SSEHandlerConfig): (c: Context) => Promise<Response>;

package/dist/src/gateway/hono/sse.js

@@ -1,207 +0,0 @@
-import { updateAsyncLogContext } from "../../utils/logger/context.js";
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-import { stringifySSEData } from "./sse-json.js";
-import { streamSSE } from "hono/streaming";
-//#region src/gateway/hono/sse.ts
-init_logger();
-const log = createLogger("Gateway:SSE");
-const activeConnections = /* @__PURE__ */ new Map();
-/** Close long-lived gateway event streams before the HTTP server starts draining. */
-function closeAllEventStreams() {
-	for (const controller of activeConnections.values()) controller.abort();
-}
-/**
-* POST /api/agent/resume — Re-attach to an in-progress agent run via SSE.
-*
-* Request body: { runId, sessionKey }
-* The relay replays retained buffered events from the beginning and then live-tails
-* until the run completes.
-*
-* SSE events are the active run's retained and live stream events.
-*/
-function createAgentResumeHandler(config) {
-	const { service } = config;
-	return async (c) => {
-		const body = await c.req.json().catch(() => null);
-		if (!body || typeof body !== "object") return c.json({
-			ok: false,
-			error: {
-				code: "BAD_REQUEST",
-				message: "Invalid JSON body"
-			}
-		}, 400);
-		const { runId, sessionKey } = body;
-		if (typeof sessionKey === "string" && sessionKey.trim()) updateAsyncLogContext({ sessionKey: sessionKey.trim() });
-		if (!runId || typeof runId !== "string") return c.json({
-			ok: false,
-			error: {
-				code: "BAD_REQUEST",
-				message: "Missing required field: runId"
-			}
-		}, 400);
-		if (!service.agentRunner.runRelay.hasRun(runId)) return c.json({
-			ok: false,
-			error: {
-				code: "NOT_FOUND",
-				message: "Run not found or already expired"
-			}
-		}, 404);
-		c.header("X-Accel-Buffering", "no");
-		return streamSSE(c, async (stream) => {
-			let eventId = 0;
-			try {
-				for await (const event of service.agentRunner.runRelay.subscribe(runId)) await stream.writeSSE({
-					id: typeof event.seq === "number" ? String(event.seq) : String(++eventId),
-					event: event.type || "message",
-					data: stringifySSEData(event)
-				});
-			} catch (error) {
-				log.error({
-					err: error,
-					runId
-				}, "Resume stream failed");
-				await stream.writeSSE({
-					id: String(++eventId),
-					event: "error",
-					data: stringifySSEData({
-						type: "error",
-						runId,
-						sessionKey: typeof sessionKey === "string" ? sessionKey : "",
-						timestamp: Date.now(),
-						payload: {
-							code: "INTERNAL_ERROR",
-							message: error instanceof Error ? error.message : "Unknown error"
-						}
-					})
-				});
-			}
-		});
-	};
-}
-/**
-* POST /api/send — Send a message through a channel (non-streaming).
-*/
-function createSendHandler(config) {
-	const { service } = config;
-	return async (c) => {
-		const body = await c.req.json().catch(() => ({}));
-		const channel = body.channel;
-		const chatId = body.chatId;
-		const content = body.content;
-		if (!channel || !chatId || !content) return c.json({
-			ok: false,
-			error: {
-				code: "BAD_REQUEST",
-				message: "Missing required fields: channel, chatId, content"
-			}
-		}, 400);
-		try {
-			const result = await service.sendMessage(channel, chatId, content);
-			return c.json({
-				ok: true,
-				payload: result
-			});
-		} catch (error) {
-			log.error({ err: error }, "Send failed");
-			return c.json({
-				ok: false,
-				error: {
-					code: "INTERNAL_ERROR",
-					message: error instanceof Error ? error.message : "Unknown error"
-				}
-			}, 500);
-		}
-	};
-}
-/**
-* GET /api/events — Server-pushed event stream (SSE).
-*
-* The client opens this long-lived connection to receive:
-*   - channel status changes
-*   - config reload notifications
-*   - cron execution results
-*   - any other server-initiated events
-*
-* Supports Last-Event-ID for reconnection.
-* Enforces maximum connection limit to prevent DoS.
-*/
-function createEventsSSEHandler(config) {
-	const { service } = config;
-	const maxConnections = config.maxSseConnections ?? 100;
-	return async (c) => {
-		if (activeConnections.size >= maxConnections) {
-			log.warn({
-				current: activeConnections.size,
-				max: maxConnections
-			}, "SSE connection limit reached");
-			return c.json({
-				ok: false,
-				error: {
-					code: "TOO_MANY_CONNECTIONS",
-					message: "Maximum SSE connections exceeded"
-				}
-			}, 503);
-		}
-		const lastEventId = c.req.header("Last-Event-ID") || void 0;
-		const sessionId = c.req.header("X-Session-Id") || c.req.query("sessionId") || crypto.randomUUID();
-		updateAsyncLogContext({ sessionId: String(sessionId) });
-		const abortController = new AbortController();
-		activeConnections.set(sessionId, abortController);
-		return streamSSE(c, async (stream) => {
-			let aborted = false;
-			await stream.writeSSE({
-				id: "0",
-				event: "connected",
-				data: JSON.stringify({ sessionId })
-			});
-			const cleanup = service.subscribe(sessionId, async (event) => {
-				if (aborted) return;
-				try {
-					await stream.writeSSE({
-						id: event.id,
-						event: event.type,
-						data: JSON.stringify(event.payload)
-					});
-				} catch {}
-			});
-			if (lastEventId) {
-				const missed = service.getEventsSince(sessionId, lastEventId);
-				for (const event of missed) await stream.writeSSE({
-					id: event.id,
-					event: event.type,
-					data: JSON.stringify(event.payload)
-				});
-			}
-			const keepAlive = setInterval(async () => {
-				if (aborted) {
-					clearInterval(keepAlive);
-					return;
-				}
-				try {
-					await stream.writeSSE({
-						event: "ping",
-						data: ""
-					});
-				} catch {
-					clearInterval(keepAlive);
-				}
-			}, 3e4);
-			await new Promise((resolve) => {
-				const finish = () => {
-					aborted = true;
-					clearInterval(keepAlive);
-					cleanup();
-					activeConnections.delete(sessionId);
-					log.debug({ sessionId }, "Event stream disconnected");
-					resolve();
-				};
-				stream.onAbort(finish);
-				abortController.signal.addEventListener("abort", () => stream.abort(), { once: true });
-				if (abortController.signal.aborted) stream.abort();
-			});
-		});
-	};
-}
-//#endregion
-export { closeAllEventStreams, createAgentResumeHandler, createEventsSSEHandler, createSendHandler };

package/dist/src/gateway/service/sse-hub.d.ts

@@ -1,10 +0,0 @@
-import type { ServiceEvent } from './types.js';
-export type GatewaySseListener = (event: ServiceEvent) => Promise<void> | void;
-export declare class GatewaySseHub {
-    private eventCounter;
-    private subscribers;
-    private eventBuffers;
-    subscribe(sessionId: string, listener: GatewaySseListener): () => void;
-    emit(type: string, payload: unknown): void;
-    getEventsSince(sessionId: string, lastEventId: string): ServiceEvent[];
-}

package/dist/src/gateway/service/sse-hub.js

@@ -1,53 +0,0 @@
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-//#region src/gateway/service/sse-hub.ts
-init_logger();
-const log = createLogger("Gateway:Service");
-const EVENT_BUFFER_SIZE = 200;
-var GatewaySseHub = class {
-	eventCounter = 0;
-	subscribers = /* @__PURE__ */ new Map();
-	eventBuffers = /* @__PURE__ */ new Map();
-	subscribe(sessionId, listener) {
-		this.subscribers.set(sessionId, listener);
-		if (!this.eventBuffers.has(sessionId)) this.eventBuffers.set(sessionId, []);
-		log.debug({ sessionId }, "Event subscriber added");
-		return () => {
-			this.subscribers.delete(sessionId);
-			setTimeout(() => {
-				if (!this.subscribers.has(sessionId)) this.eventBuffers.delete(sessionId);
-			}, 5 * 6e4);
-			log.debug({ sessionId }, "Event subscriber removed");
-		};
-	}
-	emit(type, payload) {
-		const event = {
-			id: String(++this.eventCounter),
-			type,
-			payload
-		};
-		for (const [sessionId, listener] of this.subscribers) {
-			const buf = this.eventBuffers.get(sessionId) || [];
-			buf.push(event);
-			if (buf.length > EVENT_BUFFER_SIZE) buf.shift();
-			this.eventBuffers.set(sessionId, buf);
-			try {
-				listener(event);
-			} catch (err) {
-				log.warn({
-					sessionId,
-					err
-				}, "Failed to deliver event to subscriber");
-			}
-		}
-	}
-	getEventsSince(sessionId, lastEventId) {
-		const buf = this.eventBuffers.get(sessionId);
-		if (!buf) return [];
-		const idx = buf.findIndex((e) => e.id === lastEventId);
-		if (idx === -1) return buf;
-		return buf.slice(idx + 1);
-	}
-};
-//#endregion
-export { GatewaySseHub };

package/dist/src/tui/sse-consumer.d.ts

@@ -1,15 +0,0 @@
-import type { ParsedSSEEvent } from './tui-types.js';
-/**
- * Consume an SSE stream from a `ReadableStream<Uint8Array>` (Node.js 22+ fetch body).
- *
- * Parses the standard SSE wire format:
- *   event: <name>\n
- *   data: <json>\n
- *   id: <id>\n
- *   \n
- *
- * Calls `onEvent` for each complete event block.
- */
-export declare function consumeSSEStream(body: ReadableStream<Uint8Array>, onEvent: (event: ParsedSSEEvent) => void, signal?: AbortSignal): Promise<void>;
-/** Parse SSE data field as JSON, returning null on failure. */
-export declare function parseSSEData<T = unknown>(data: string): T | null;

package/dist/src/tui/sse-consumer.js

@@ -1,73 +0,0 @@
-//#region src/tui/sse-consumer.ts
-/**
-* Consume an SSE stream from a `ReadableStream<Uint8Array>` (Node.js 22+ fetch body).
-*
-* Parses the standard SSE wire format:
-*   event: <name>\n
-*   data: <json>\n
-*   id: <id>\n
-*   \n
-*
-* Calls `onEvent` for each complete event block.
-*/
-async function consumeSSEStream(body, onEvent, signal) {
-	const reader = body.getReader();
-	const decoder = new TextDecoder();
-	let buffer = "";
-	let currentEvent = "";
-	let currentData = "";
-	let currentId = "";
-	try {
-		while (true) {
-			if (signal?.aborted) break;
-			const { done, value } = await reader.read();
-			if (done) break;
-			buffer += decoder.decode(value, { stream: true });
-			const lines = buffer.split("\n");
-			buffer = lines.pop() ?? "";
-			for (const line of lines) {
-				if (line === "") {
-					if (currentData) onEvent({
-						event: currentEvent || "message",
-						data: currentData,
-						id: currentId || void 0
-					});
-					currentEvent = "";
-					currentData = "";
-					currentId = "";
-					continue;
-				}
-				if (line.startsWith(":")) continue;
-				const colonIndex = line.indexOf(":");
-				if (colonIndex === -1) continue;
-				const field = line.slice(0, colonIndex);
-				const valueStart = line[colonIndex + 1] === " " ? colonIndex + 2 : colonIndex + 1;
-				const fieldValue = line.slice(valueStart);
-				switch (field) {
-					case "event":
-						currentEvent = fieldValue;
-						break;
-					case "data":
-						currentData = currentData ? `${currentData}\n${fieldValue}` : fieldValue;
-						break;
-					case "id":
-						currentId = fieldValue;
-						break;
-				}
-			}
-		}
-	} finally {
-		buffer += decoder.decode();
-		reader.releaseLock();
-	}
-}
-/** Parse SSE data field as JSON, returning null on failure. */
-function parseSSEData(data) {
-	try {
-		return JSON.parse(data);
-	} catch {
-		return null;
-	}
-}
-//#endregion
-export { consumeSSEStream, parseSSEData };