@xopcai/xopc 0.0.188 → 0.0.190

package/dist/src/mcp/channel-bridge.d.ts

@@ -1,6 +1,6 @@
 import type { Config } from '../config/schema.js';
-import type { ApprovalDecision, ApprovalKind, ClaudeChannelMode, ConversationDescriptor, PendingApproval, QueueEvent, WaitFilter } from './channel-shared.js';
-import { type GatewayCredential } from '../gateway/credential.js';
+import type { ApprovalDecision, ApprovalKind, ConversationDescriptor, PendingApproval, QueueEvent, WaitFilter } from './channel-shared.js';
+import type { GatewayCredential } from '../gateway/credential.js';
 export declare class XopcChannelBridge {
     private readonly cfg;
     private readonly params;
@@ -9,19 +9,16 @@ export declare class XopcChannelBridge {
     private readonly pendingApprovals;
     private cursor;
     private closed;
-    private eventsAbort;
+    private readonly realtimeClientId;
+    private realtime;
     constructor(cfg: Config, params: {
         gatewayUrl?: string;
         gatewayCredential?: GatewayCredential;
-        claudeChannelMode: ClaudeChannelMode;
-        verbose: boolean;
     });
-    setServer(_server: unknown): void;
     start(): Promise<void>;
     close(): Promise<void>;
-    private connectEvents;
-    private runEventsLoop;
-    private handleSseChunk;
+    private connectRealtime;
+    private handleRealtimeEvent;
     private enqueueFromBroadcast;
     private pushEvent;
     listConversations(args: {

package/dist/src/mcp/channel-bridge.js

@@ -1,15 +1,16 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { init_loader, loadConfig } from "../config/loader.js";
-import { gatewayCredentialAuthorization } from "../gateway/credential.js";
-import { loadUndiciRuntimeDeps } from "../infra/undici-fetch.js";
+import { RealtimeClient } from "../../packages/realtime-client/src/index.js";
 import { toConversation } from "./channel-shared.js";
 import { createGatewayHttpClientFromConfig, resolveGatewayHttpBaseUrl } from "./gateway-http-client.js";
+import { createRequire } from "node:module";
 import crypto from "node:crypto";
 //#region src/mcp/channel-bridge.ts
 init_loader();
 init_logger();
 const log = createLogger("Mcp:Bridge");
+const { WebSocket } = createRequire(import.meta.url)("ws");
 const QUEUE_LIMIT = 1e3;
 var XopcChannelBridge = class {
 	client = null;
@@ -17,12 +18,12 @@ var XopcChannelBridge = class {
 	pendingApprovals = /* @__PURE__ */ new Map();
 	cursor = 0;
 	closed = false;
-	eventsAbort = null;
+	realtimeClientId = `mcp-${crypto.randomUUID()}`;
+	realtime = null;
 	constructor(cfg, params) {
 		this.cfg = cfg;
 		this.params = params;
 	}
-	setServer(_server) {}
 	async start() {
 		log.info({ phase: "mcp.bridge.connect" }, "MCP channel bridge starting");
 		this.client = createGatewayHttpClientFromConfig({
@@ -30,7 +31,7 @@ var XopcChannelBridge = class {
 			gatewayUrl: this.params.gatewayUrl,
 			gatewayCredential: this.params.gatewayCredential
 		});
-		this.connectEvents();
+		this.connectRealtime();
 	}
 	async close() {
 		log.info({
@@ -38,84 +39,55 @@ var XopcChannelBridge = class {
 			queueSize: this.queue.length
 		}, "MCP channel bridge closing");
 		this.closed = true;
-		this.eventsAbort?.abort();
-		this.eventsAbort = null;
+		this.realtime?.disconnect();
+		this.realtime = null;
 		this.queue.length = 0;
 		this.pendingApprovals.clear();
 	}
-	connectEvents() {
+	connectRealtime() {
 		if (this.closed) return;
-		this.eventsAbort?.abort();
-		const abort = new AbortController();
-		this.eventsAbort = abort;
 		const baseUrl = resolveGatewayHttpBaseUrl(this.cfg, this.params.gatewayUrl);
-		this.runEventsLoop(baseUrl, this.params.gatewayCredential, abort.signal);
-	}
-	async runEventsLoop(baseUrl, credential, signal) {
-		const url = new URL(`${baseUrl}/api/events`);
-		const authorization = gatewayCredentialAuthorization(credential);
-		try {
-			const res = await loadUndiciRuntimeDeps().fetch(url.toString(), {
-				headers: {
-					Accept: "text/event-stream",
-					...authorization ? { Authorization: authorization } : {}
-				},
-				signal
-			});
-			if (!res.ok || !res.body) {
-				log.warn({
-					phase: "mcp.bridge.sse",
-					status: res.status,
+		this.realtime?.disconnect();
+		this.realtime = new RealtimeClient({
+			clientId: this.realtimeClientId,
+			clientKind: "mcp",
+			getWebSocketUrl: () => {
+				const url = new URL(baseUrl);
+				url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+				url.pathname = "/api/realtime/v1/ws";
+				url.search = "";
+				url.hash = "";
+				return url.toString();
+			},
+			issueTicket: async () => {
+				const response = await this.client.postJson("/api/realtime/tickets", {
+					clientId: this.realtimeClientId,
+					clientKind: "mcp"
+				});
+				if (!response.payload?.ticket) throw new Error(response.error?.message ?? "Realtime ticket response is invalid");
+				return response.payload.ticket;
+			},
+			createWebSocket: (url) => new WebSocket(url),
+			onEvent: (event) => this.handleRealtimeEvent(event),
+			onStateChange: (state, error) => {
+				if (state === "error") log.warn({
+					errorMessage: error,
+					phase: "mcp.bridge.realtime",
 					baseUrl
-				}, `Gateway events SSE connect failed: HTTP ${res.status}`);
-				return;
-			}
-			const reader = res.body.getReader();
-			const decoder = new TextDecoder();
-			let buffer = "";
-			while (!this.closed && !signal.aborted) {
-				const { done, value } = await reader.read();
-				if (done) break;
-				buffer += decoder.decode(value, { stream: true });
-				let splitAt = buffer.indexOf("\n\n");
-				while (splitAt >= 0) {
-					this.handleSseChunk(buffer.slice(0, splitAt));
-					buffer = buffer.slice(splitAt + 2);
-					splitAt = buffer.indexOf("\n\n");
-				}
+				}, `Gateway realtime connection failed: ${error ?? "unknown error"}`);
 			}
-		} catch (err) {
-			const em = err instanceof Error ? err.message : String(err);
-			if (!signal.aborted && !this.closed) log.warn({
-				err,
-				errorMessage: em,
-				phase: "mcp.bridge.sse",
-				baseUrl
-			}, `Gateway events SSE disconnected: ${em}`);
-		}
-		if (!this.closed && !signal.aborted) {
-			await new Promise((resolve) => setTimeout(resolve, 2e3));
-			if (!this.closed) this.connectEvents();
-		}
-	}
-	handleSseChunk(chunk) {
-		let eventName = "message";
-		let data = "";
-		for (const line of chunk.split("\n")) if (line.startsWith("event:")) eventName = line.slice(6).trim();
-		else if (line.startsWith("data:")) data += line.slice(5).trim();
-		if (!data) return;
-		try {
-			const parsed = JSON.parse(data);
-			this.enqueueFromBroadcast({
-				type: eventName,
-				...parsed
-			});
-		} catch {
-			this.enqueueFromBroadcast({
-				type: eventName,
-				raw: data
-			});
-		}
+		});
+		this.realtime.subscribe("gateway");
+		this.realtime.subscribe("sessions");
+		this.realtime.connect();
+	}
+	handleRealtimeEvent(event) {
+		if (event.topic !== "gateway" && event.topic !== "sessions") return;
+		const data = event.data && typeof event.data === "object" && !Array.isArray(event.data) ? event.data : { raw: event.data };
+		this.enqueueFromBroadcast({
+			...data,
+			type: event.event
+		});
 	}
 	enqueueFromBroadcast(data) {
 		const type = String(data.type ?? data.event ?? "");

package/dist/src/mcp/channel-server.js

@@ -10,19 +10,15 @@ init_loader();
 init_package_version();
 async function createXopcChannelMcpServer(opts = {}) {
 	const cfg = opts.config ?? loadConfig();
-	const claudeChannelMode = opts.claudeChannelMode ?? "auto";
-	const capabilities = getChannelMcpCapabilities(claudeChannelMode);
+	const capabilities = getChannelMcpCapabilities(opts.claudeChannelMode ?? "auto");
 	const server = new McpServer({
 		name: "xopc",
 		version: PACKAGE_VERSION
 	}, capabilities ? { capabilities } : void 0);
 	const bridge = new XopcChannelBridge(cfg, {
 		gatewayUrl: opts.gatewayUrl,
-		gatewayCredential: opts.gatewayCredential,
-		claudeChannelMode,
-		verbose: opts.verbose ?? false
+		gatewayCredential: opts.gatewayCredential
 	});
-	bridge.setServer(server);
 	server.server.setNotificationHandler(ClaudePermissionRequestSchema, async ({ params }) => {
 		await bridge.handleClaudePermissionRequest({
 			requestId: params.request_id,

package/dist/src/proactive/execution/context.js

@@ -1,5 +1,5 @@
 import { getSqliteDatabase } from "../../storage/sqlite/transaction.js";
-import { listMemoryRecords } from "../../storage/sqlite/memory-records-repository.js";
+import { listUnderstandings } from "../../storage/sqlite/user-context-repository.js";
 import { getKnowledgeSourceItem } from "../../storage/sqlite/knowledge-repository.js";
 import { getConnectorSyncPolicyForConnection } from "../../storage/sqlite/connector-sync-policy-repository.js";
 import { wrapExternalContent } from "../../gateway/security/external-content.js";
@@ -162,25 +162,20 @@ var UserUnderstandingContextProvider = class {
 	async collect(input) {
 		const scope = eventRows(input.eventIds).at(-1);
 		if (!scope) return emptyContext();
-		const records = listMemoryRecords({
-			workspaceId: scope.workspace_id,
-			...scope.project_id ? { visibleToProjectId: scope.project_id } : { unscopedProjectOnly: true },
-			status: "active",
-			limit: 20
-		}).filter((record) => {
+		const records = listUnderstandings(["active"]).filter((record) => {
 			const now = Date.now();
-			return record.disclosurePolicy === "referenceable" && record.sensitivity !== "secret" && record.sensitivity !== "regulated" && !record.tags?.includes("playbook:disabled") && (!record.validFrom || Date.parse(record.validFrom) <= now) && (!record.validTo || Date.parse(record.validTo) >= now) && (!record.expiresAt || Date.parse(record.expiresAt) >= now) && (!record.reviewAfter || Date.parse(record.reviewAfter) >= now) && !record.conflictGroupId && (record.explicitness === "explicit" || record.importance >= .7);
-		});
+			const scopeMatches = record.scope.type === "global" || record.scope.type === "workspace" && record.scope.id === scope.workspace_id || record.scope.type === "project" && record.scope.id === scope.project_id;
+			return record.disclosurePolicy === "referenceable" && record.sensitivity !== "secret" && record.sensitivity !== "regulated" && scopeMatches && (!record.validFrom || record.validFrom <= now) && (!record.validTo || record.validTo >= now) && (!record.expiresAt || record.expiresAt >= now) && !record.conflictGroupId && (record.explicitness === "explicit" || record.confidence >= .7);
+		}).slice(0, 20);
 		return {
 			content: { records: records.map((record) => ({
-				evidenceId: `memory:${record.id}`,
+				evidenceId: `understanding:${record.id}`,
 				kind: record.kind,
-				content: boundedText(record.content, 1e3),
+				content: boundedText(record.statement, 1e3),
 				confidence: record.confidence,
-				importance: record.importance,
 				updatedAt: record.updatedAt
 			})) },
-			evidenceIds: records.map((record) => `memory:${record.id}`)
+			evidenceIds: records.map((record) => `understanding:${record.id}`)
 		};
 	}
 };

package/dist/src/realtime/broker.d.ts

@@ -0,0 +1,31 @@
+import { type ServerRealtimeMessage } from '@xopcai/realtime-protocol';
+export type RealtimeEvent = Extract<ServerRealtimeMessage, {
+    kind: 'realtime.event';
+}>;
+export type RealtimeGap = Extract<ServerRealtimeMessage, {
+    kind: 'realtime.gap';
+}>;
+export type RealtimeDelivery = RealtimeEvent | RealtimeGap;
+export interface RealtimeTopicPolicy {
+    replayCapacity: number;
+}
+export type RealtimeTopicPolicyResolver = (topic: string) => RealtimeTopicPolicy;
+export interface RealtimeSubscriptionHandle {
+    initial: RealtimeDelivery[];
+    cursor: number;
+    unsubscribe: () => void;
+}
+export declare function defaultRealtimeTopicPolicy(topic: string): RealtimeTopicPolicy;
+export declare class RealtimeBroker {
+    private readonly resolvePolicy;
+    private readonly onListenerError;
+    private readonly topics;
+    constructor(resolvePolicy?: RealtimeTopicPolicyResolver, onListenerError?: (error: unknown, topic: string) => void);
+    publish(topic: string, event: string, data: unknown, now?: number): RealtimeEvent;
+    subscribe(topic: string, afterSeq: number | undefined, listener: (event: RealtimeEvent) => void): RealtimeSubscriptionHandle;
+    removeTopic(topic: string): void;
+    currentSequence(topic: string): number;
+    hasTopic(topic: string): boolean;
+    private replayFrom;
+    private ensureTopic;
+}

package/dist/src/realtime/broker.js

@@ -0,0 +1,114 @@
+import { realtimeEventNameSchema, realtimeTopicSchema } from "../../packages/realtime-protocol/src/index.js";
+import crypto from "node:crypto";
+//#region src/realtime/broker.ts
+const DEFAULT_TOPIC_POLICY = { replayCapacity: 0 };
+function defaultRealtimeTopicPolicy(topic) {
+	if (topic.startsWith("run:")) return { replayCapacity: 8e3 };
+	if (topic.startsWith("session:")) return { replayCapacity: 200 };
+	if (topic === "logs") return { replayCapacity: 500 };
+	if (topic === "gateway" || topic === "sessions") return { replayCapacity: 1e3 };
+	return DEFAULT_TOPIC_POLICY;
+}
+var RealtimeBroker = class {
+	topics = /* @__PURE__ */ new Map();
+	constructor(resolvePolicy = defaultRealtimeTopicPolicy, onListenerError = () => {}) {
+		this.resolvePolicy = resolvePolicy;
+		this.onListenerError = onListenerError;
+	}
+	publish(topic, event, data, now = Date.now()) {
+		realtimeTopicSchema.parse(topic);
+		realtimeEventNameSchema.parse(event);
+		const state = this.ensureTopic(topic);
+		const message = {
+			protocolVersion: 1,
+			messageId: crypto.randomUUID(),
+			kind: "realtime.event",
+			sentAt: now,
+			payload: {
+				topic,
+				seq: state.nextSeq++,
+				event,
+				data
+			}
+		};
+		const capacity = this.resolvePolicy(topic).replayCapacity;
+		if (capacity > 0) {
+			state.events.push(message);
+			if (state.events.length > capacity) state.events.splice(0, state.events.length - capacity);
+		}
+		for (const listener of state.listeners) try {
+			listener(message);
+		} catch (error) {
+			this.onListenerError(error, topic);
+		}
+		return message;
+	}
+	subscribe(topic, afterSeq, listener) {
+		realtimeTopicSchema.parse(topic);
+		const state = this.ensureTopic(topic);
+		state.listeners.add(listener);
+		const initial = afterSeq === void 0 ? [] : this.replayFrom(topic, state, afterSeq);
+		const gap = initial[0]?.kind === "realtime.gap" ? initial[0] : void 0;
+		const currentSeq = state.nextSeq - 1;
+		return {
+			initial,
+			cursor: gap ? gap.payload.earliestSeq - 1 : afterSeq === void 0 ? currentSeq : Math.min(afterSeq, currentSeq),
+			unsubscribe: () => {
+				state.listeners.delete(listener);
+			}
+		};
+	}
+	removeTopic(topic) {
+		this.topics.delete(topic);
+	}
+	currentSequence(topic) {
+		return (this.topics.get(topic)?.nextSeq ?? 1) - 1;
+	}
+	hasTopic(topic) {
+		return this.topics.has(topic);
+	}
+	replayFrom(topic, state, afterSeq) {
+		const currentSeq = state.nextSeq - 1;
+		if (afterSeq > currentSeq) return [{
+			protocolVersion: 1,
+			messageId: crypto.randomUUID(),
+			kind: "realtime.gap",
+			sentAt: Date.now(),
+			payload: {
+				topic,
+				requestedSeq: afterSeq,
+				earliestSeq: state.events[0]?.payload.seq ?? 1,
+				recoverable: false
+			}
+		}];
+		if (currentSeq <= afterSeq) return [];
+		const earliestSeq = state.events[0]?.payload.seq;
+		if (earliestSeq === void 0 || afterSeq + 1 < earliestSeq) return [{
+			protocolVersion: 1,
+			messageId: crypto.randomUUID(),
+			kind: "realtime.gap",
+			sentAt: Date.now(),
+			payload: {
+				topic,
+				requestedSeq: afterSeq,
+				earliestSeq: earliestSeq ?? currentSeq + 1,
+				recoverable: earliestSeq !== void 0
+			}
+		}, ...state.events];
+		return state.events.filter((event) => event.payload.seq > afterSeq);
+	}
+	ensureTopic(topic) {
+		let state = this.topics.get(topic);
+		if (!state) {
+			state = {
+				nextSeq: 1,
+				events: [],
+				listeners: /* @__PURE__ */ new Set()
+			};
+			this.topics.set(topic, state);
+		}
+		return state;
+	}
+};
+//#endregion
+export { RealtimeBroker, defaultRealtimeTopicPolicy };

package/dist/src/realtime/runtime.d.ts

@@ -0,0 +1,20 @@
+import type { IncomingMessage } from 'node:http';
+import type { Socket } from 'node:net';
+import type { EndpointToolRuntime } from '../endpoint-tools/runtime.js';
+import { RealtimeBroker } from './broker.js';
+import { RealtimeTicketStore } from './tickets.js';
+export declare class RealtimeRuntime {
+    private readonly endpointTools?;
+    readonly broker: RealtimeBroker;
+    readonly tickets: RealtimeTicketStore;
+    private readonly preauthBudget;
+    private readonly wss;
+    private readonly topicCleanupTimers;
+    private closed;
+    constructor(endpointTools?: EndpointToolRuntime);
+    handleUpgrade(req: IncomingMessage, socket: Socket, head: Buffer): boolean;
+    close(): void;
+    completeTopic(topic: string, ttlMs?: number): void;
+    private handleConnection;
+    private rawDataToText;
+}