@xopcai/xopc 0.0.188 → 0.0.189

package/dist/src/gateway/hono/routes/agent-stream.js

@@ -1,9 +1,8 @@
+import { endpointTurnClaimSchema } from "../../../../packages/endpoint-tools-protocol/src/index.js";
 import { validateWebchatAttachments, validateWebchatContent } from "../../chat-limits.js";
-import { createAgentResumeHandler, createEventsSSEHandler, createSendHandler } from "../sse.js";
 //#region src/gateway/hono/routes/agent-stream.ts
 function registerAgentStreamRoutes(authenticated, deps) {
-	const { service, chatRateLimitMiddleware, sseConfig } = deps;
-	authenticated.post("/api/agent/resume", chatRateLimitMiddleware, createAgentResumeHandler(sseConfig));
+	const { service, chatRateLimitMiddleware } = deps;
 	authenticated.post("/api/agent/abort", chatRateLimitMiddleware, async (c) => {
 		const body = await c.req.json().catch(() => null);
 		const runId = body && typeof body === "object" && typeof body.runId === "string" ? body.runId.trim() : "";
@@ -70,13 +69,32 @@ function registerAgentStreamRoutes(authenticated, deps) {
 				message: "Missing delivery"
 			}
 		}, 400);
+		const origin = endpointTurnClaimSchema.safeParse(body.origin);
+		if (!origin.success) return c.json({
+			ok: false,
+			error: {
+				code: "BAD_REQUEST",
+				message: "Invalid endpoint origin"
+			}
+		}, 400);
+		if (!service.endpointTools.registry.verifyTurnClaim(origin.data.endpointId, origin.data.token)) return c.json({
+			ok: false,
+			error: {
+				code: "INVALID_ENDPOINT",
+				message: "Endpoint connection is not active"
+			}
+		}, 401);
 		const result = await service.submitSessionInput({
 			sessionKey,
 			clientMessageId: typeof body.clientMessageId === "string" ? body.clientMessageId : "",
 			delivery,
 			content,
 			attachments,
-			thinking: typeof body.thinking === "string" ? body.thinking : void 0
+			thinking: typeof body.thinking === "string" ? body.thinking : void 0,
+			origin: {
+				type: "endpoint",
+				endpointId: origin.data.endpointId
+			}
 		});
 		if (result.ok === false) return c.json({
 			ok: false,
@@ -195,8 +213,33 @@ function registerAgentStreamRoutes(authenticated, deps) {
 			payload: { received: true }
 		});
 	});
-	authenticated.post("/api/send", chatRateLimitMiddleware, createSendHandler(sseConfig));
-	authenticated.get("/api/events", createEventsSSEHandler(sseConfig));
+	authenticated.post("/api/send", chatRateLimitMiddleware, async (c) => {
+		const body = await c.req.json().catch(() => null);
+		const channel = typeof body?.channel === "string" ? body.channel : "";
+		const chatId = typeof body?.chatId === "string" ? body.chatId : "";
+		const content = typeof body?.content === "string" ? body.content : "";
+		if (!channel || !chatId || !content) return c.json({
+			ok: false,
+			error: {
+				code: "BAD_REQUEST",
+				message: "Missing required fields: channel, chatId, content"
+			}
+		}, 400);
+		try {
+			return c.json({
+				ok: true,
+				payload: await service.sendMessage(channel, chatId, content)
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: {
+					code: "INTERNAL_ERROR",
+					message: error instanceof Error ? error.message : "Unknown error"
+				}
+			}, 500);
+		}
+	});
 }
 //#endregion
 export { registerAgentStreamRoutes };

package/dist/src/gateway/hono/routes/auth-registry-extensions.js

@@ -1,8 +1,8 @@
 import { getAllModels, getAvailableModels, init_providers } from "../../../providers/index.js";
 import { ActivationPlanner } from "../../../extensions/activation-planner.js";
 import { mergeActivationContext } from "../../../extensions/activation-context.js";
-import { buildWhenContextSnapshot } from "../../../extensions/when-context.js";
 import { fetchRegistry, listExtensions, searchExtensions } from "../../../extensions/marketplace.js";
+import { buildWhenContextSnapshot } from "../../../extensions/when-context.js";
 import { createOAuthHandler } from "../oauth.js";
 import { createOAuthAsyncHandler } from "../oauth-async.js";
 import { extensionAssetMimeType } from "../lib/extension-assets.js";

package/dist/src/gateway/hono/routes/config-patch/gateway.d.ts

@@ -4,13 +4,13 @@
  * Covers heartbeat, bind/customBindHost/port, tailscale, auth (mode + token +
  * password + rateLimit + trustedProxy), trustedProxies, allowRealIpFallback,
  * dangerouslyAllowHostHeaderOriginFallback, security, share, siteShare, publicUrl, webchat,
- * corsOrigins, maxSseConnections, and channelConnectDefer{Mode,Ids,SkipIds}.
+ * corsOrigins and channelConnectDefer{Mode,Ids,SkipIds}.
  *
  * Validation policy: each subsection that can reject rejects with a 400 and a
  * specific `message`. The dispatcher converts these into `c.json(...)`.
  *
  * Initial-state branches use the same literal defaults the inline code did
- * (loopback + port 18790 + 1800s heartbeat + 100 SSE conn + empty CORS) so
+ * (loopback + port 18790 + 1800s heartbeat + empty CORS) so
  * a brand-new install gets a working gateway after the first PATCH.
  */
 import type { Config } from '../../../../config/schema.js';

package/dist/src/gateway/hono/routes/config-patch/gateway.js

@@ -20,7 +20,6 @@ function ensureGateway(config) {
 			intervalMs: 18e5,
 			includeSystemPromptSection: false
 		},
-		maxSseConnections: 100,
 		corsOrigins: []
 	};
 	return config.gateway;
@@ -98,7 +97,6 @@ function applyGatewayPatch(config, body) {
 				intervalMs: 18e5,
 				includeSystemPromptSection: false
 			},
-			maxSseConnections: 100,
 			corsOrigins: []
 		};
 		else config.gateway.bind = bind;
@@ -123,7 +121,6 @@ function applyGatewayPatch(config, body) {
 				intervalMs: 18e5,
 				includeSystemPromptSection: false
 			},
-			maxSseConnections: 100,
 			corsOrigins: []
 		};
 		else config.gateway.port = Math.floor(body.gateway.port);
@@ -139,7 +136,6 @@ function applyGatewayPatch(config, body) {
 				intervalMs: 18e5,
 				includeSystemPromptSection: false
 			},
-			maxSseConnections: 100,
 			corsOrigins: []
 		};
 		config.gateway.tailscale = { ...config.gateway.tailscale ?? {
@@ -251,21 +247,6 @@ function applyGatewayPatch(config, body) {
 		const gw = ensureGateway(config);
 		gw.corsOrigins = body.gateway.corsOrigins.filter((x) => typeof x === "string" && x.trim().length > 0).map((x) => x.trim());
 	}
-	if (body.gateway?.maxSseConnections !== void 0) {
-		if (typeof body.gateway.maxSseConnections !== "number" || !Number.isFinite(body.gateway.maxSseConnections) || body.gateway.maxSseConnections < 1) return patchError("gateway.maxSseConnections must be a positive integer");
-		if (!config.gateway) config.gateway = {
-			bind: "loopback",
-			port: 18790,
-			heartbeat: {
-				enabled: true,
-				intervalMs: 18e5,
-				includeSystemPromptSection: false
-			},
-			maxSseConnections: Math.floor(body.gateway.maxSseConnections),
-			corsOrigins: []
-		};
-		else config.gateway.maxSseConnections = Math.floor(body.gateway.maxSseConnections);
-	}
 	if (body.gateway?.channelConnectDeferMode !== void 0) {
 		const mode = body.gateway.channelConnectDeferMode;
 		if (mode !== "auto" && mode !== "off" && mode !== "explicit") return patchError("gateway.channelConnectDeferMode must be auto, off, or explicit");

package/dist/src/gateway/hono/routes/deps.d.ts

@@ -1,11 +1,9 @@
 import type { MiddlewareHandler } from 'hono';
 import type { GatewayService } from '../../service.js';
-import type { SSEHandlerConfig } from '../sse.js';
 export interface AuthenticatedRouteDeps {
     service: GatewayService;
     strictRateLimitMiddleware: MiddlewareHandler;
     chatRateLimitMiddleware: MiddlewareHandler;
     xopcCloudPollRateLimitMiddleware: MiddlewareHandler;
     channelRateLimitMiddleware?: MiddlewareHandler;
-    sseConfig: SSEHandlerConfig;
 }

package/dist/src/gateway/hono/routes/endpoint-tools.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from 'hono';
+import type { AuthenticatedRouteDeps } from './deps.js';
+export declare function registerEndpointToolRoutes(authenticated: Hono, deps: AuthenticatedRouteDeps): void;

package/dist/src/gateway/hono/routes/endpoint-tools.js

@@ -0,0 +1,196 @@
+import { endpointPrincipalRegistrationSchema } from "../../../../packages/endpoint-tools-protocol/src/index.js";
+import { createEndpointPrincipal, getEndpointPrincipal, listEndpointPrincipals, revokeEndpointPrincipal } from "../../../storage/sqlite/endpoint-principal-repository.js";
+import { listEndpointToolInvocationAudits } from "../../../storage/sqlite/endpoint-tool-invocation-repository.js";
+import "../../../storage/sqlite/index.js";
+import { parseEndpointPublicKey } from "../../../endpoint-tools/auth.js";
+import { ENDPOINT_UPLOAD_MAX_BYTES, EndpointUploadError } from "../../../endpoint-tools/upload-service.js";
+//#region src/gateway/hono/routes/endpoint-tools.ts
+async function readBoundedBody(body, maxBytes) {
+	if (!body) return new Uint8Array();
+	const reader = body.getReader();
+	const chunks = [];
+	let size = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			size += value.byteLength;
+			if (size > maxBytes) throw new EndpointUploadError("Uploaded file is too large");
+			chunks.push(value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	const bytes = new Uint8Array(size);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return bytes;
+}
+function registerEndpointToolRoutes(authenticated, deps) {
+	authenticated.get("/api/endpoint-tools/principals", (c) => {
+		const endpointsByPrincipal = /* @__PURE__ */ new Map();
+		for (const endpoint of deps.service.endpointTools.registry.list()) {
+			const endpoints = endpointsByPrincipal.get(endpoint.principalId) ?? [];
+			endpoints.push(endpoint);
+			endpointsByPrincipal.set(endpoint.principalId, endpoints);
+		}
+		return c.json({
+			ok: true,
+			payload: listEndpointPrincipals().map(({ publicKey: _publicKey, ...principal }) => ({
+				...principal,
+				endpoints: endpointsByPrincipal.get(principal.id) ?? []
+			}))
+		});
+	});
+	authenticated.post("/api/endpoint-tools/principals", async (c) => {
+		const parsed = endpointPrincipalRegistrationSchema.safeParse(await c.req.json().catch(() => null));
+		if (!parsed.success) return c.json({
+			ok: false,
+			error: {
+				code: "BAD_REQUEST",
+				message: "Invalid endpoint principal"
+			}
+		}, 400);
+		try {
+			parseEndpointPublicKey(parsed.data.publicKey);
+		} catch {
+			return c.json({
+				ok: false,
+				error: {
+					code: "BAD_REQUEST",
+					message: "Invalid endpoint public key"
+				}
+			}, 400);
+		}
+		const existing = getEndpointPrincipal(parsed.data.principalId);
+		if (existing && !existing.revokedAt && existing.displayName === parsed.data.displayName && existing.kind === parsed.data.kind && existing.platform === parsed.data.platform && existing.publicKey === parsed.data.publicKey) return c.json({
+			ok: true,
+			payload: existing
+		}, 200);
+		if (existing) {
+			if (existing.revokedAt) return c.json({
+				ok: false,
+				error: {
+					code: "PRINCIPAL_REVOKED",
+					message: "Endpoint principal was revoked"
+				}
+			}, 403);
+			return c.json({
+				ok: false,
+				error: {
+					code: "CONFLICT",
+					message: "Endpoint principal already exists"
+				}
+			}, 409);
+		}
+		const principal = createEndpointPrincipal({
+			id: parsed.data.principalId,
+			displayName: parsed.data.displayName,
+			kind: parsed.data.kind,
+			platform: parsed.data.platform,
+			publicKey: parsed.data.publicKey
+		});
+		return c.json({
+			ok: true,
+			payload: principal
+		}, 201);
+	});
+	authenticated.delete("/api/endpoint-tools/principals/:principalId", (c) => {
+		const principalId = c.req.param("principalId").trim();
+		if (!principalId) return c.json({
+			ok: false,
+			error: {
+				code: "BAD_REQUEST",
+				message: "Missing principal id"
+			}
+		}, 400);
+		if (!revokeEndpointPrincipal(principalId)) return c.json({
+			ok: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Endpoint principal not found"
+			}
+		}, 404);
+		for (const endpoint of deps.service.endpointTools.registry.list()) if (endpoint.principalId === principalId) deps.service.endpointTools.disconnect(endpoint.endpointId, "Endpoint principal revoked");
+		return c.json({
+			ok: true,
+			payload: {
+				principalId,
+				revoked: true
+			}
+		});
+	});
+	authenticated.get("/api/endpoint-tools/invocations", (c) => {
+		const limit = Number(c.req.query("limit") ?? 100);
+		return c.json({
+			ok: true,
+			payload: listEndpointToolInvocationAudits(Number.isFinite(limit) ? limit : 100)
+		});
+	});
+	authenticated.post("/api/endpoint-tools/invocations/:invocationId/files", async (c) => {
+		const invocationId = c.req.param("invocationId");
+		const endpointId = c.req.header("x-endpoint-id") ?? "";
+		const token = c.req.header("x-endpoint-upload-token") ?? "";
+		const name = c.req.query("name") ?? "";
+		const mimeType = c.req.header("content-type")?.split(";", 1)[0]?.trim() ?? "";
+		if (Number(c.req.header("content-length") ?? 0) > ENDPOINT_UPLOAD_MAX_BYTES) return c.json({
+			ok: false,
+			error: {
+				code: "RESULT_TOO_LARGE",
+				message: "Uploaded file is too large"
+			}
+		}, 413);
+		try {
+			const bytes = await readBoundedBody(c.req.raw.body, ENDPOINT_UPLOAD_MAX_BYTES);
+			const file = deps.service.endpointTools.uploads.upload({
+				invocationId,
+				endpointId,
+				token,
+				name,
+				mimeType,
+				bytes
+			});
+			return c.json({
+				ok: true,
+				payload: {
+					type: "file",
+					fileId: file.fileId,
+					name: file.name,
+					mimeType: file.mimeType,
+					size: file.size,
+					sha256: file.sha256
+				}
+			}, 201);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return c.json({
+				ok: false,
+				error: {
+					code: error instanceof EndpointUploadError ? "INVALID_UPLOAD_GRANT" : "UPLOAD_FAILED",
+					message
+				}
+			}, 400);
+		}
+	});
+	authenticated.get("/api/endpoint-tools/files/:fileId", (c) => {
+		const file = deps.service.endpointTools.uploads.getFile(c.req.param("fileId"));
+		const bytes = file && deps.service.endpointTools.uploads.readFile(file.fileId);
+		if (!file || !bytes) return c.json({
+			ok: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Endpoint file not found"
+			}
+		}, 404);
+		c.header("Content-Type", file.mimeType);
+		c.header("Content-Length", String(file.size));
+		c.header("Content-Disposition", `attachment; filename*=UTF-8''${encodeURIComponent(file.name)}`);
+		const body = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+		return c.body(body);
+	});
+}
+//#endregion
+export { registerEndpointToolRoutes };

package/dist/src/gateway/hono/routes/index.js

@@ -10,6 +10,8 @@ import { registerSearchRoutes } from "./search.js";
 import { registerMobileRoutes } from "./mobile.js";
 import { registerInteractionStateRoutes } from "./interaction-state.js";
 import { registerComposerHistoryRoutes } from "./composer-history.js";
+import { registerEndpointToolRoutes } from "./endpoint-tools.js";
+import { registerRealtimeRoutes } from "./realtime.js";
 import { registerLocalAppsRoutes } from "./local-apps.js";
 import { registerWorkDiscoveryRoutes } from "./work-discovery.js";
 import { registerTaskRoutes } from "./tasks.js";
@@ -33,6 +35,8 @@ function registerCoreAuthenticatedRoutes(authenticated, deps) {
 	registerMobileRoutes(authenticated, deps);
 	registerInteractionStateRoutes(authenticated, deps);
 	registerComposerHistoryRoutes(authenticated, deps);
+	registerEndpointToolRoutes(authenticated, deps);
+	registerRealtimeRoutes(authenticated, deps);
 }
 function registerAuthenticatedRoutes(app, authenticated, deps) {
 	registerCoreAuthenticatedRoutes(authenticated, deps);

package/dist/src/gateway/hono/routes/logs.js

@@ -131,10 +131,6 @@ function registerLogsRoutes(authenticated, _deps) {
 		const { getLogLevel } = await import("../../../utils/logger.js");
 		return c.json({ level: getLogLevel() });
 	});
-	authenticated.get("/api/logs/stream", async (c) => {
-		const { createLogSSEHandler } = await import("../../../utils/logger/log-stream.js");
-		return createLogSSEHandler()(c);
-	});
 }
 //#endregion
 export { registerLogsRoutes };

package/dist/src/gateway/hono/routes/public-gateway.js

@@ -110,10 +110,10 @@ function registerPublicGatewayRoutes(app, service) {
 				"POST /api/sessions/:sessionKey/inputs",
 				"GET  /api/sessions/:sessionKey/input-state",
 				"PATCH/DELETE /api/sessions/:sessionKey/inputs/:inputId",
-				"POST /api/agent/resume          (SSE stream)",
 				"POST /api/agent/abort",
 				"POST /api/send",
-				"GET  /api/events          (SSE stream)",
+				"POST /api/realtime/tickets",
+				"WS   /api/realtime/v1/ws",
 				"GET  /api/channels/catalog",
 				"GET  /api/channels/status",
 				"POST /api/channels/:channelId/actions/:actionId",

package/dist/src/gateway/hono/routes/realtime.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from 'hono';
+import type { AuthenticatedRouteDeps } from './deps.js';
+export declare function registerRealtimeRoutes(authenticated: Hono, deps: AuthenticatedRouteDeps): void;

package/dist/src/gateway/hono/routes/realtime.js

@@ -0,0 +1,35 @@
+import { realtimeClientKindSchema } from "../../../../packages/realtime-protocol/src/index.js";
+import { z } from "zod";
+//#region src/gateway/hono/routes/realtime.ts
+const ticketRequestSchema = z.strictObject({
+	clientId: z.string().min(1).max(160),
+	clientKind: realtimeClientKindSchema
+});
+function registerRealtimeRoutes(authenticated, deps) {
+	authenticated.post("/api/realtime/tickets", async (c) => {
+		const parsed = ticketRequestSchema.safeParse(await c.req.json().catch(() => null));
+		if (!parsed.success) return c.json({
+			ok: false,
+			error: {
+				code: "BAD_REQUEST",
+				message: "Invalid realtime ticket request"
+			}
+		}, 400);
+		try {
+			return c.json({
+				ok: true,
+				payload: deps.service.realtime.tickets.issue(parsed.data.clientId, parsed.data.clientKind)
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: {
+					code: "TICKET_LIMIT",
+					message: error instanceof Error ? error.message : "Ticket issue failed"
+				}
+			}, 503);
+		}
+	});
+}
+//#endregion
+export { registerRealtimeRoutes };

package/dist/src/gateway/hono/routes/workflows.js

@@ -7,9 +7,9 @@ import { messagesToClientHistory } from "../../../session/client-history.js";
 import "../../../workflows/domain/index.js";
 import { resolveWorkflowRunArtifactsDir } from "../../../workflows/store/paths.js";
 import { WorkflowDraftService } from "../../../workflows/draft/workflow-draft-service.js";
-import "../../../workflows/draft/index.js";
 import { WorkflowDraftConflictError, WorkflowDraftStore } from "../../../workflows/authoring/workflow-draft-store.js";
 import "../../../workflows/authoring/index.js";
+import "../../../workflows/draft/index.js";
 import { basename, join } from "node:path";
 import { readFile, stat } from "node:fs/promises";
 //#region src/gateway/hono/routes/workflows.ts

package/dist/src/gateway/hono/routes/you.d.ts

@@ -21,14 +21,5 @@ export declare function buildPersonalPlaybooks(records: MemoryRecord[]): {
     }[];
     updatedAt: string;
 }[];
-export declare function buildInsightSuggestions(records: MemoryRecord[]): {
-    id: string;
-    insight: string;
-    kind: import("../../../agent/memory/types.js").MemoryKind;
-    action: "make_repeatable" | "add_playbook" | "start_progress";
-    evidenceCount: number;
-    confidence: number;
-    sourceName: string;
-}[];
 export declare function buildRoutineAutomationDraftHref(record: Pick<MemoryRecord, 'id' | 'content'>): string;
 export declare function registerYouRoutes(authenticated: Hono, deps: AuthenticatedRouteDeps): void;