@xopcai/xopc 0.0.231 → 0.0.232

package/dist/src/gateway/hono/routes/{mobile.js → device-push.js}

@@ -1,5 +1,6 @@
 import { registerNotificationDevice, removeNotificationDevice, updateNotificationDevicePreferences } from "../../../notifications/device-store.js";
-//#region src/gateway/hono/routes/mobile.ts
+import { getGatewayPrincipal } from "../../security/gateway-principal.js";
+//#region src/gateway/hono/routes/device-push.ts
 function stringField(value, maxLength) {
 	return typeof value === "string" && value.trim().length > 0 && value.trim().length <= maxLength ? value.trim() : null;
 }
@@ -34,22 +35,34 @@ function parsePermission(value) {
 function parseLocale(value) {
 	return value === "en" || value === "zh" ? value : null;
 }
-function registerMobileRoutes(authenticated, _deps) {
-	authenticated.post("/api/mobile/devices/register", async (c) => {
+function currentDeviceId(c) {
+	const principal = getGatewayPrincipal(c);
+	return principal.kind === "device" && principal.deviceId ? principal.deviceId : null;
+}
+function registerDevicePushRoutes(authenticated) {
+	authenticated.put("/api/devices/me/push", async (c) => {
+		const deviceId = currentDeviceId(c);
+		if (!deviceId) return c.json({
+			ok: false,
+			error: "Device access required"
+		}, 403);
 		const body = await c.req.json().catch(() => null);
-		const id = stringField(body?.id, 160);
+		if (body && ("id" in body || "deviceId" in body)) return c.json({
+			ok: false,
+			error: "Device identity must come from authentication"
+		}, 400);
 		const pushToken = stringField(body?.pushToken, 1024);
 		const platform = parsePlatform(body?.platform);
 		const permissions = parsePermission(body?.permissions);
 		const preferences = parsePreferences(body?.preferences);
 		const locale = parseLocale(body?.locale);
 		const appVersion = body?.appVersion === void 0 ? void 0 : stringField(body.appVersion, 128);
-		if (!id || !pushToken || !platform || !permissions || !locale || preferences === null || appVersion === null) return c.json({
+		if (!pushToken || !platform || !permissions || !locale || preferences === null || appVersion === null) return c.json({
 			ok: false,
-			error: "Invalid mobile device registration"
+			error: "Invalid push registration"
 		}, 400);
 		const device = registerNotificationDevice({
-			id,
+			deviceId,
 			pushToken,
 			platform,
 			permissions,
@@ -62,28 +75,37 @@ function registerMobileRoutes(authenticated, _deps) {
 			device
 		}, 201);
 	});
-	authenticated.patch("/api/mobile/devices/:id/preferences", async (c) => {
+	authenticated.patch("/api/devices/me/push/preferences", async (c) => {
+		const deviceId = currentDeviceId(c);
+		if (!deviceId) return c.json({
+			ok: false,
+			error: "Device access required"
+		}, 403);
 		const preferences = parsePreferences(await c.req.json().catch(() => null));
 		if (preferences === null || preferences === void 0) return c.json({
 			ok: false,
 			error: "Invalid notification preferences"
 		}, 400);
-		const device = updateNotificationDevicePreferences(c.req.param("id"), preferences);
-		if (!device) return c.json({
-			ok: false,
-			error: "Mobile device not found"
-		}, 404);
-		return c.json({
+		const device = updateNotificationDevicePreferences(deviceId, preferences);
+		return device ? c.json({
 			ok: true,
 			device
-		});
+		}) : c.json({
+			ok: false,
+			error: "Push registration not found"
+		}, 404);
 	});
-	authenticated.delete("/api/mobile/devices/:id", (c) => {
+	authenticated.delete("/api/devices/me/push", (c) => {
+		const deviceId = currentDeviceId(c);
+		if (!deviceId) return c.json({
+			ok: false,
+			error: "Device access required"
+		}, 403);
 		return c.json({
 			ok: true,
-			removed: removeNotificationDevice(c.req.param("id"))
+			removed: removeNotificationDevice(deviceId)
 		});
 	});
 }
 //#endregion
-export { registerMobileRoutes };
+export { registerDevicePushRoutes };

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

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

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

@@ -0,0 +1,214 @@
+import { runSqliteWriteTransaction } from "../../../storage/sqlite/transaction.js";
+import { DEFAULT_MOBILE_SCOPES } from "../../security/gateway-scopes.js";
+import { createDevice, issueDeviceTokenPair, listDevices, revokeDevice, rotateDeviceRefreshToken } from "../../../storage/sqlite/device-access-repository.js";
+import { getGatewayIdentityPublicKeyRaw, getOrCreateGatewayIdentity, signGatewayPayload } from "../../../storage/sqlite/gateway-identity-repository.js";
+import { consumeDevicePairingToken, createDevicePairingSetup, isDevicePairingSetupActive } from "../../../storage/sqlite/device-pairing-repository.js";
+import { resolveSecureDeviceRoutes } from "../../device-routes.js";
+import { getGatewayPrincipal } from "../../security/gateway-principal.js";
+import os from "node:os";
+import { z } from "zod";
+//#region src/gateway/hono/routes/devices.ts
+const refreshRequestSchema = z.strictObject({
+	refreshToken: z.string().min(1).max(256),
+	timestamp: z.number().int().positive(),
+	nonce: z.string().min(16).max(128),
+	requestId: z.string().uuid(),
+	nextRefreshToken: z.string().min(80).max(256),
+	signature: z.string().min(1).max(256)
+});
+const pairingExchangeSchema = z.strictObject({
+	pairingToken: z.string().min(1).max(256),
+	device: z.strictObject({
+		displayName: z.string().trim().min(1).max(80),
+		platform: z.enum(["ios", "android"]),
+		publicKeyJwk: z.strictObject({
+			kty: z.literal("EC"),
+			crv: z.literal("P-256"),
+			x: z.string().min(40).max(64),
+			y: z.string().min(40).max(64)
+		})
+	})
+});
+const pairingProbeSchema = z.strictObject({ pairingId: z.string().uuid() });
+function pairingLinkPayload(input) {
+	return Buffer.from(JSON.stringify({
+		version: 2,
+		...input
+	})).toString("base64url");
+}
+function registerDeviceAuthPublicRoutes(app) {
+	app.post("/api/device-auth/refresh", async (c) => {
+		const parsed = refreshRequestSchema.safeParse(await c.req.json().catch(() => null));
+		if (!parsed.success) return c.json({
+			ok: false,
+			error: {
+				code: "BAD_REQUEST",
+				message: "Invalid refresh request"
+			}
+		}, 400);
+		try {
+			return c.json({
+				ok: true,
+				payload: rotateDeviceRefreshToken(parsed.data)
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: {
+					code: "REFRESH_DENIED",
+					message: error instanceof Error ? error.message : "Refresh denied"
+				}
+			}, 401);
+		}
+	});
+	app.post("/api/device-pairing/probe", async (c) => {
+		const parsed = pairingProbeSchema.safeParse(await c.req.json().catch(() => null));
+		if (!parsed.success || !isDevicePairingSetupActive(parsed.data.pairingId)) return c.json({
+			ok: false,
+			error: {
+				code: "PAIRING_NOT_FOUND",
+				message: "Pairing setup not found"
+			}
+		}, 404);
+		const identity = getOrCreateGatewayIdentity();
+		const payload = Buffer.from(JSON.stringify({
+			gatewayId: identity.id,
+			pairingId: parsed.data.pairingId,
+			issuedAt: Date.now()
+		})).toString("base64url");
+		return c.json({
+			ok: true,
+			signedPayload: payload,
+			signature: signGatewayPayload(payload)
+		});
+	});
+	app.post("/api/device-pairing/exchange", async (c) => {
+		const parsed = pairingExchangeSchema.safeParse(await c.req.json().catch(() => null));
+		if (!parsed.success) return c.json({
+			ok: false,
+			error: {
+				code: "BAD_REQUEST",
+				message: "Invalid pairing request"
+			}
+		}, 400);
+		const completed = runSqliteWriteTransaction(() => {
+			const pairing = consumeDevicePairingToken(parsed.data.pairingToken);
+			if (!pairing.ok && "reason" in pairing) return {
+				success: false,
+				reason: pairing.reason
+			};
+			const device = createDevice({
+				displayName: parsed.data.device.displayName,
+				platform: parsed.data.device.platform,
+				publicKeyJwk: parsed.data.device.publicKeyJwk,
+				scopes: DEFAULT_MOBILE_SCOPES
+			});
+			return {
+				success: true,
+				device,
+				routes: pairing.routes,
+				tokens: issueDeviceTokenPair(device.id)
+			};
+		});
+		if ("reason" in completed) return c.json({
+			ok: false,
+			error: {
+				code: "PAIRING_DENIED",
+				message: `Pairing ${completed.reason}`
+			}
+		}, 401);
+		const identity = getOrCreateGatewayIdentity();
+		const payload = Buffer.from(JSON.stringify({
+			gateway: {
+				id: identity.id,
+				name: os.hostname()
+			},
+			device: {
+				id: completed.device.id,
+				scopes: completed.device.scopes
+			},
+			routes: completed.routes,
+			tokens: completed.tokens
+		})).toString("base64url");
+		return c.json({
+			ok: true,
+			signedPayload: payload,
+			signature: signGatewayPayload(payload)
+		}, 201);
+	});
+}
+function registerDeviceRoutes(authenticated, deps) {
+	authenticated.get("/api/device-pairing/readiness", (c) => {
+		const routes = resolveSecureDeviceRoutes(deps.service.currentConfig);
+		return c.json({
+			ok: true,
+			ready: routes.length > 0,
+			routes
+		});
+	});
+	authenticated.post("/api/device-pairing/setups", (c) => {
+		const routes = resolveSecureDeviceRoutes(deps.service.currentConfig);
+		if (routes.length === 0) return c.json({
+			ok: false,
+			error: {
+				code: "NO_SECURE_ROUTE",
+				message: "Configure XOPC Secure Link, Tailscale Serve, or an HTTPS public URL first"
+			}
+		}, 409);
+		const setup = createDevicePairingSetup(routes);
+		const identity = getOrCreateGatewayIdentity();
+		const encoded = pairingLinkPayload({
+			pairingToken: setup.token,
+			gatewayId: identity.id,
+			gatewayName: os.hostname(),
+			gatewayPublicKey: getGatewayIdentityPublicKeyRaw(identity),
+			routes,
+			expiresAt: setup.expiresAt
+		});
+		return c.json({
+			ok: true,
+			setup: {
+				id: setup.id,
+				universalLink: `https://link.xopc.ai/connect#p=${encoded}`,
+				expiresAt: setup.expiresAt,
+				routes
+			}
+		}, 201);
+	});
+	authenticated.get("/api/devices", (c) => c.json({
+		ok: true,
+		devices: listDevices()
+	}));
+	authenticated.get("/api/devices/me", (c) => {
+		const principal = getGatewayPrincipal(c);
+		if (principal.kind !== "device" || !principal.deviceId) return c.json({
+			ok: false,
+			error: {
+				code: "DEVICE_REQUIRED",
+				message: "Device access required"
+			}
+		}, 403);
+		const device = listDevices().find((candidate) => candidate.id === principal.deviceId);
+		return device ? c.json({
+			ok: true,
+			device
+		}) : c.json({
+			ok: false,
+			error: {
+				code: "NOT_FOUND",
+				message: "Device not found"
+			}
+		}, 404);
+	});
+	authenticated.delete("/api/devices/:deviceId", (c) => {
+		const deviceId = c.req.param("deviceId");
+		const revoked = revokeDevice(deviceId);
+		if (revoked) deps.service.realtime.disconnectPrincipal(deviceId);
+		return c.json({
+			ok: true,
+			revoked
+		});
+	});
+}
+//#endregion
+export { registerDeviceAuthPublicRoutes, registerDeviceRoutes };

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

@@ -35,6 +35,10 @@ function errorResponse(c, error) {
 	if (error instanceof FileServiceError) return c.json({ error: { message: error.message } }, error.status);
 	throw error;
 }
+function contentDisposition(disposition, fileName) {
+	const sanitized = fileName.replace(/[\u0000-\u001f\u007f]/g, "_");
+	return `${disposition}; filename="${sanitized.replace(/[^\x20-\x7e]/g, "_").replace(/["\\]/g, "_")}"; filename*=UTF-8''${encodeURIComponent(sanitized).replace(/['()*]/g, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`)}`;
+}
 async function collectFiles(files, spaceId, query, max) {
 	const output = [];
 	const directories = [""];
@@ -122,7 +126,7 @@ function registerFilesRoutes(authenticated, deps) {
 			if (c.req.header("if-none-match") === resource.revision) return c.body(null, 304);
 			c.header("Content-Type", resource.mimeType);
 			c.header("ETag", resource.revision);
-			c.header("Content-Disposition", `inline; filename="${resource.name.replace(/["\r\n]/g, "_")}"`);
+			c.header("Content-Disposition", contentDisposition("inline", resource.name));
 			return c.body(await readFile(absolutePath));
 		} catch (error) {
 			return errorResponse(c, error);

package/dist/src/gateway/hono/routes/global-defaults.js

@@ -1,17 +1,13 @@
-import { CapabilityPresetSchema, init_schema } from "../../../agent-manifest/schema.js";
+import { AgentDefaultsSchema } from "../../../agent-config/schema.js";
+import { init_agent_config } from "../../../agent-config/index.js";
 import { listGlobalDefaults, prepareUpdateGlobalDefaults } from "../../global-defaults-admin.js";
 //#region src/gateway/hono/routes/global-defaults.ts
-init_schema();
+init_agent_config();
 function parsePatchBody(raw) {
 	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return { error: "body must be an object" };
 	const body = raw;
-	const out = {};
-	if (Object.hasOwn(body, "models")) {
-		const parsed = CapabilityPresetSchema.pick({ models: true }).safeParse({ models: body.models });
-		if (!parsed.success) return { error: `models ${parsed.error.issues[0]?.message ?? "is invalid"}` };
-		out.models = parsed.data.models;
-	}
-	return out;
+	const parsed = AgentDefaultsSchema.safeParse(body.defaults);
+	return parsed.success ? { defaults: parsed.data } : { error: `defaults ${parsed.error.issues[0]?.message ?? "is invalid"}` };
 }
 function isParseError(value) {
 	return typeof value === "object" && value !== null && "error" in value && typeof value.error === "string";

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

@@ -7,12 +7,13 @@ import { registerStatusRoutes } from "./status.js";
 import { registerProjectsRoutes } from "./projects.js";
 import { registerProjectSkillRoutes } from "./project-skills.js";
 import { registerSearchRoutes } from "./search.js";
-import { registerMobileRoutes } from "./mobile.js";
+import { registerDevicePushRoutes } from "./device-push.js";
 import { registerNotificationRoutes } from "./notifications.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 { registerDeviceRoutes } from "./devices.js";
 import { registerLocalAppsRoutes } from "./local-apps.js";
 import { registerWorkDiscoveryRoutes } from "./work-discovery.js";
 import { registerUnderstandingSourceRoutes } from "./understanding-sources.js";
@@ -35,12 +36,13 @@ function registerCoreAuthenticatedRoutes(authenticated, deps) {
 	registerTaskRoutes(authenticated, deps);
 	registerProactiveRoutes(authenticated, deps);
 	registerSearchRoutes(authenticated, deps);
-	registerMobileRoutes(authenticated, deps);
+	registerDevicePushRoutes(authenticated);
 	registerNotificationRoutes(authenticated, deps);
 	registerInteractionStateRoutes(authenticated, deps);
 	registerComposerHistoryRoutes(authenticated, deps);
 	registerEndpointToolRoutes(authenticated, deps);
 	registerRealtimeRoutes(authenticated, deps);
+	registerDeviceRoutes(authenticated, deps);
 }
 function registerAuthenticatedRoutes(app, authenticated, deps) {
 	registerCoreAuthenticatedRoutes(authenticated, deps);

package/dist/src/gateway/hono/routes/lazy-bundles.js

@@ -117,15 +117,11 @@ const AUTHENTICATED_LAZY_ROUTE_BUNDLES = [
 		}
 	},
 	{
-		id: "capability-presets",
-		match: (path) => startsWithAny(path, ["/api/capability-presets", "/api/global-defaults"]),
+		id: "global-defaults",
+		match: (path) => startsWithAny(path, ["/api/global-defaults"]),
 		load: async () => {
-			const { registerCapabilityPresetsRoutes } = await import("./capability-presets.js");
 			const { registerGlobalDefaultsRoutes } = await import("./global-defaults.js");
-			return { register: (authenticated, deps) => {
-				registerCapabilityPresetsRoutes(authenticated, deps);
-				registerGlobalDefaultsRoutes(authenticated, deps);
-			} };
+			return { register: registerGlobalDefaultsRoutes };
 		}
 	},
 	{
@@ -220,7 +216,7 @@ const AUTHENTICATED_LAZY_ROUTE_BUNDLES = [
 	},
 	{
 		id: "shares",
-		match: (path) => startsWithAny(path, ["/api/shares"]),
+		match: (path) => startsWithAny(path, ["/api/shares"]) || /^\/api\/sessions\/[^/]+\/(?:share-preview|shares|hosted-shares)(?:\/.*)?$/.test(path),
 		load: async () => {
 			const { registerShareRoutes } = await import("./shares.js");
 			return { register: registerShareRoutes };
@@ -323,18 +319,6 @@ const APP_LAZY_ROUTE_BUNDLES = [{
 		const { registerSharePublicRoutes } = await import("./shares.js");
 		return { registerOnApp: registerSharePublicRoutes };
 	}
-}, {
-	id: "tunnel-public",
-	prefixes: [
-		"/api/tunnel/pair/ping",
-		"/api/tunnel/pair/validate-url",
-		"/api/tunnel/exchange-token"
-	],
-	match: (path) => path === "/api/tunnel/exchange-token" || path === "/api/tunnel/pair/ping" || path === "/api/tunnel/pair/validate-url",
-	load: async () => {
-		const { registerTunnelPublicRoutes } = await import("./tunnel.js");
-		return { registerOnApp: registerTunnelPublicRoutes };
-	}
 }];
 function findAuthenticatedLazyRouteBundle(path) {
 	return AUTHENTICATED_LAZY_ROUTE_BUNDLES.find((bundle) => bundle.match(path));

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

@@ -12,13 +12,13 @@ import "../../../capabilities/readiness/index.js";
 import { getImageGenerationProvider, reloadImageGenerationProviders, resolveImageGenerationCredentialMode } from "../../../agent/image/generation/provider-registry.js";
 import { SessionConfigStore } from "../../../session/config-store.js";
 import { deleteCustomImageProvider, listCustomImageProviders, upsertCustomImageProvider } from "../../custom-image-providers.js";
-import { getDomesticProviderPreset, getDomesticProviderPresetIds } from "../../../providers/domestic-presets.js";
-import { getOnboardingFeaturedProviders, getProviderHint, getRecommendedModelsForProvider, isRecommendedModel, sortModelsForPicker, sortProvidersForPicker } from "../../../providers/presentation.js";
 import { getAgentImageGenerationConfig, getImageGenerationCatalog, prepareImageGenerationSetup, verifyImageGenerationCredential } from "../../image-generation-setup.js";
 import { discoverProviderModels, isProviderApiDiscoverable } from "../../../providers/model-discovery.js";
 import { getXopcCloudCatalogCoordinator } from "../../../providers/xopc-cloud-catalog-coordinator.js";
 import { respondStartupUnavailable } from "../lib/startup-unavailable.js";
+import { getDomesticProviderPreset, getDomesticProviderPresetIds } from "../../../providers/domestic-presets.js";
 import { auditModelReferences } from "../../../providers/model-reference-auditor.js";
+import { getOnboardingFeaturedProviders, getProviderHint, getRecommendedModelsForProvider, isRecommendedModel, sortModelsForPicker, sortProvidersForPicker } from "../../../providers/presentation.js";
 import { XopcCloudAccountError, XopcCloudAccountService } from "../../../providers/xopc-cloud-account-service.js";
 //#region src/gateway/hono/routes/models.ts
 init_models_json();

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

@@ -1,4 +1,5 @@
 import { realtimeClientKindSchema } from "../../../../packages/realtime-protocol/src/index.js";
+import { getGatewayPrincipal } from "../../security/gateway-principal.js";
 import { z } from "zod";
 //#region src/gateway/hono/routes/realtime.ts
 const ticketRequestSchema = z.strictObject({
@@ -16,9 +17,15 @@ function registerRealtimeRoutes(authenticated, deps) {
 			}
 		}, 400);
 		try {
+			const principal = getGatewayPrincipal(c);
 			return c.json({
 				ok: true,
-				payload: deps.service.realtime.tickets.issue(parsed.data.clientId, parsed.data.clientKind)
+				payload: deps.service.realtime.tickets.issue(parsed.data.clientId, parsed.data.clientKind, {
+					principalId: principal.principalId,
+					...principal.deviceId ? { deviceId: principal.deviceId } : {},
+					...principal.accessSessionId ? { accessSessionId: principal.accessSessionId } : {},
+					scopes: principal.scopes
+				})
 			});
 		} catch (error) {
 			return c.json({

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

@@ -1,5 +1,5 @@
 import { getDefaultModelSync, init_providers, resolveModel } from "../../../providers/index.js";
-import { getGatewayAgentEffectiveManifest } from "../../agents-admin.js";
+import { getGatewayAgentEffectiveConfig } from "../../agents-admin.js";
 import { isSTTAvailable } from "../../../voice/stt/availability.js";
 import { mergeSttConfigFromAppConfig } from "../../../voice/stt/config.js";
 import "../../../voice/stt/index.js";
@@ -14,9 +14,6 @@ function stableValue(value) {
 function contentHash(value) {
 	return createHash("sha256").update(JSON.stringify(stableValue(value))).digest("hex");
 }
-function asRecord(value) {
-	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
 function buildEvalRuntimeIdentity(service, agentId) {
 	const config = service.currentConfig;
 	if (!config) return {
@@ -24,16 +21,13 @@ function buildEvalRuntimeIdentity(service, agentId) {
 		error: "Gateway configuration is unavailable",
 		status: 503
 	};
-	const effective = getGatewayAgentEffectiveManifest(config, agentId);
+	const effective = getGatewayAgentEffectiveConfig(config, agentId);
 	if ("error" in effective) return {
 		ok: false,
 		error: effective.error,
 		status: effective.status ?? 400
 	};
-	const manifest = asRecord(effective.data.manifest);
-	const models = asRecord(manifest.models);
-	const tools = asRecord(manifest.tools);
-	const skills = manifest.skills ?? [];
+	const agentConfig = effective.data.config;
 	return {
 		ok: true,
 		payload: {
@@ -41,13 +35,12 @@ function buildEvalRuntimeIdentity(service, agentId) {
 			version: service.getHealth().version,
 			buildCommit: process.env.XOPC_BUILD_COMMIT?.trim() || process.env.GITHUB_SHA?.trim() || null,
 			agentId,
-			modelRef: models.primary ?? null,
-			thinkingLevel: manifest.thinkingDefault ?? null,
-			manifestHash: contentHash(effective.data.manifest),
-			systemPromptConfigHash: contentHash(manifest.systemPrompt ?? null),
-			toolPolicyHash: contentHash(tools),
-			skillPolicyHash: contentHash(skills),
-			presetChain: effective.data.sources
+			modelRef: agentConfig.models.chat.primary,
+			thinkingLevel: null,
+			configHash: contentHash(agentConfig),
+			toolPolicyHash: contentHash(agentConfig.tools),
+			skillPolicyHash: contentHash(agentConfig.skills),
+			sources: effective.data.sources
 		}
 	};
 }

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

@@ -1,5 +1,3 @@
 import type { Hono } from 'hono';
 import type { AuthenticatedRouteDeps } from './deps.js';
-import type { GatewayService } from '../../service.js';
-export declare function registerTunnelPublicRoutes(app: Hono, service: GatewayService): void;
 export declare function registerTunnelRoutes(authenticated: Hono, deps: AuthenticatedRouteDeps): void;