@xopcai/xopc 0.0.187 → 0.0.189

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/mcp.js

@@ -1,8 +1,8 @@
 import { canonicalizeConfiguredMcpServer, normalizeConfiguredMcpServers } from "../../../config/mcp-config-normalize.js";
 import { loadMergedBundleMcpConfig } from "../../../agent/mcp/bundle-mcp-config.js";
-import { listBundleMcpServerCapabilitiesForGateway, listBundleMcpServerToolsForGateway } from "../../../agent/mcp/bundle-mcp-materialize.js";
 import { isManagedConnectorServer } from "../../../connectors/materialize.js";
 import { getWorkspacePath } from "../../../config/workspace-path-helpers.js";
+import { listBundleMcpServerCapabilitiesForGateway, listBundleMcpServerToolsForGateway } from "../../../agent/mcp/bundle-mcp-gateway.js";
 //#region src/gateway/hono/routes/mcp.ts
 function registerMcpRoutes(authenticated, deps) {
 	authenticated.get("/api/mcp/servers", (c) => {

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

@@ -17,6 +17,7 @@ import "../../../projects/index.js";
 import { TaskApplicationService } from "../../../tasks/task-application-service.js";
 import { defineTaskContract } from "../../../tasks/task-contract-definition.js";
 import "../../../tasks/index.js";
+import { classifyFileReferenceFsError } from "../../file-reference-errors.js";
 import { createGatewayRouteLogger } from "../lib/route-logger.js";
 import { parseActivityIncludeRelated, parseActivityQuery } from "./activity.js";
 import { fuzzySearchWorkspaceFiles } from "../../workspace-file-search.js";
@@ -996,6 +997,7 @@ function registerProjectsRoutes(authenticated, deps) {
 			}
 		}, resolved.status);
 		let st = null;
+		let statError = null;
 		let absolutePath = resolved.absolutePath;
 		try {
 			absolutePath = await realpath(resolved.absolutePath);
@@ -1007,22 +1009,41 @@ function registerProjectsRoutes(authenticated, deps) {
 				}
 			}, 400);
 			st = await stat(absolutePath);
-		} catch {
-			st = null;
+		} catch (err) {
+			statError = err;
 		}
 		const displayName = path$1.basename(rawPath);
-		if (!st) return c.json({
-			ok: true,
-			payload: {
-				inputPath: rawPath,
-				displayName,
-				scope: "missing",
-				exists: false,
-				absolutePath: resolved.absolutePath,
-				capabilities: ["copyPath"],
-				errorCode: "FILE_NOT_FOUND"
+		if (!st) {
+			const failure = classifyFileReferenceFsError(statError);
+			if (failure.code !== "FILE_NOT_FOUND") {
+				log.warn({
+					err: statError,
+					projectId: resolved.projectId,
+					workspaceRoot: resolved.root,
+					candidate: resolved.absolutePath,
+					errorCode: failure.code
+				}, `Project file reference access failed: ${failure.message}`);
+				return c.json({
+					ok: false,
+					error: {
+						code: failure.code,
+						message: failure.message
+					}
+				}, failure.status === 403 ? 403 : 500);
 			}
-		});
+			return c.json({
+				ok: true,
+				payload: {
+					inputPath: rawPath,
+					displayName,
+					scope: "missing",
+					exists: false,
+					absolutePath: resolved.absolutePath,
+					capabilities: ["copyPath"],
+					errorCode: "FILE_NOT_FOUND"
+				}
+			});
+		}
 		return c.json({
 			ok: true,
 			payload: {

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/workspace.js

@@ -3,6 +3,7 @@ import { validateWritePath } from "../../../agent/sandbox/path-policy.js";
 import { isPathUnderWorkspace, resolveWorkspaceSafePath, toWorkspaceRelativePosix } from "../../workspace-editor-path.js";
 import { getWorkspacePath } from "../../../config/workspace-path-helpers.js";
 import { buildFilePathClassifierContext, classifyFileLocation, displayNameForPath, fileRefSessionKeysMatch, resolveFileReferenceCandidate } from "../../file-path-classifier.js";
+import { classifyFileReferenceFsError } from "../../file-reference-errors.js";
 import { fileReferenceRegistry } from "../../file-reference-registry.js";
 import { resolveHeartbeatMdPath } from "../../workspace-heartbeat-path.js";
 import { createGatewayRouteLogger } from "../lib/route-logger.js";
@@ -407,23 +408,43 @@ function registerWorkspaceRoutes(authenticated, deps) {
 			}
 		});
 		let st = null;
+		let statError = null;
 		try {
 			st = await stat(candidate);
-		} catch {
-			st = null;
+		} catch (err) {
+			statError = err;
 		}
-		if (!st) return c.json({
-			ok: true,
-			payload: {
-				inputPath: rawPath,
-				displayName,
-				scope: "missing",
-				exists: false,
-				absolutePath: candidate,
-				capabilities: fileReferenceCapabilities("missing", false),
-				errorCode: "FILE_NOT_FOUND"
+		if (!st) {
+			const failure = classifyFileReferenceFsError(statError);
+			if (failure.code !== "FILE_NOT_FOUND") {
+				log.warn({
+					err: statError,
+					sessionKey,
+					workspaceRoot,
+					candidate,
+					errorCode: failure.code
+				}, `Workspace file reference access failed: ${failure.message}`);
+				return c.json({
+					ok: false,
+					error: {
+						code: failure.code,
+						message: failure.message
+					}
+				}, failure.status === 403 ? 403 : 500);
 			}
-		});
+			return c.json({
+				ok: true,
+				payload: {
+					inputPath: rawPath,
+					displayName,
+					scope: "missing",
+					exists: false,
+					absolutePath: candidate,
+					capabilities: fileReferenceCapabilities("missing", false),
+					errorCode: "FILE_NOT_FOUND"
+				}
+			});
+		}
 		const { scope, locationKind, manageRoute } = classifyFileLocation(candidate, classifierCtx);
 		const inWorkspace = scope === "workspace";
 		const isDirectory = st.isDirectory();

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;