@xopcai/xopc 0.0.230 → 0.0.232

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

@@ -0,0 +1,176 @@
+import { FileServiceError, FileSpaceService, fileResourceFromPath, resolveFilePath } from "../../../files/file-service.js";
+import { basename, join } from "node:path";
+import { readFile, writeFile } from "node:fs/promises";
+//#region src/gateway/hono/routes/files.ts
+const services = /* @__PURE__ */ new WeakMap();
+const mutationLocks = /* @__PURE__ */ new Map();
+async function withMutationLock(key, action) {
+	const previous = mutationLocks.get(key) ?? Promise.resolve();
+	let release;
+	const gate = new Promise((resolve) => {
+		release = resolve;
+	});
+	const tail = previous.then(() => gate);
+	mutationLocks.set(key, tail);
+	await previous;
+	try {
+		return await action();
+	} finally {
+		release();
+		if (mutationLocks.get(key) === tail) mutationLocks.delete(key);
+	}
+}
+function getFiles(deps) {
+	const existing = services.get(deps.service);
+	if (existing) return existing;
+	const created = new FileSpaceService(() => deps.service.currentConfig, deps.service.projects, (sessionKey) => deps.service.agentService.getResolvedWorkspaceForSession(sessionKey));
+	services.set(deps.service, created);
+	return created;
+}
+function publicSpace(space) {
+	const { root: _root, ...value } = space;
+	return value;
+}
+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 = [""];
+	while (directories.length && output.length < max) {
+		const directory = directories.shift();
+		const children = await files.children(spaceId, directory);
+		for (const child of children) {
+			if (child.kind === "directory") directories.push(child.relativePath);
+			else if (!query || child.name.toLocaleLowerCase().includes(query)) output.push(child);
+			if (output.length >= max) break;
+		}
+	}
+	return output;
+}
+function registerFilesRoutes(authenticated, deps) {
+	const files = getFiles(deps);
+	authenticated.get("/api/files/spaces", async (c) => {
+		try {
+			return c.json({ spaces: (await files.list()).map(publicSpace) });
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+	authenticated.get("/api/files/contexts/:kind/:id", async (c) => {
+		try {
+			const kind = c.req.param("kind");
+			if (kind !== "agent" && kind !== "project" && kind !== "session") throw new FileServiceError(400, "Invalid context kind");
+			return c.json({ space: publicSpace(await files.forContext(kind, c.req.param("id"))) });
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+	authenticated.get("/api/files/spaces/:id/children", async (c) => {
+		try {
+			return c.json({ items: await files.children(c.req.param("id"), c.req.query("path") ?? "") });
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+	authenticated.get("/api/files/recent", async (c) => {
+		try {
+			const limit = Math.min(100, Math.max(1, Number(c.req.query("limit")) || 50));
+			const spaces = await files.list();
+			const items = (await Promise.all(spaces.map((space) => collectFiles(files, space.id, "", 5e3)))).flat().sort((a, b) => b.modifiedAt - a.modifiedAt).slice(0, limit);
+			return c.json({ items });
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+	authenticated.get("/api/files/search", async (c) => {
+		try {
+			const query = (c.req.query("q") ?? "").trim().toLocaleLowerCase();
+			if (!query) return c.json({ items: [] });
+			const limit = Math.min(100, Math.max(1, Number(c.req.query("limit")) || 50));
+			const requestedSpaceId = c.req.query("spaceId");
+			const spaces = requestedSpaceId ? [await files.get(requestedSpaceId)] : await files.list();
+			const items = (await Promise.all(spaces.map((space) => collectFiles(files, space.id, query, 5e3)))).flat().sort((a, b) => b.modifiedAt - a.modifiedAt).slice(0, limit);
+			return c.json({ items });
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+	authenticated.post("/api/files/resolve", async (c) => {
+		try {
+			const body = await c.req.json();
+			if (!body.spaceId || !body.path) throw new FileServiceError(400, "spaceId and path are required");
+			const space = await files.get(body.spaceId);
+			const absolutePath = await resolveFilePath(space.root, body.path);
+			return c.json({ resource: await fileResourceFromPath(space, absolutePath) });
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+	authenticated.get("/api/files/:id", async (c) => {
+		try {
+			return c.json({ resource: (await files.resource(c.req.param("id"))).resource });
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+	authenticated.get("/api/files/:id/content", async (c) => {
+		try {
+			const { resource, absolutePath } = await files.resource(c.req.param("id"));
+			if (resource.kind !== "file") throw new FileServiceError(400, "Resource is not a file");
+			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", contentDisposition("inline", resource.name));
+			return c.body(await readFile(absolutePath));
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+	authenticated.put("/api/files/:id/content", async (c) => {
+		try {
+			const body = await c.req.json();
+			if (typeof body.content !== "string" || !body.revision) throw new FileServiceError(400, "content and revision are required");
+			const id = c.req.param("id");
+			const resource = await withMutationLock(id, async () => {
+				const current = await files.resource(id);
+				if (!current.resource.capabilities.includes("edit")) throw new FileServiceError(403, "File is not editable");
+				if (body.revision !== current.resource.revision) throw new FileServiceError(409, "File has changed");
+				await writeFile(current.absolutePath, body.content, "utf8");
+				return fileResourceFromPath(current.space, current.absolutePath);
+			});
+			return c.json({ resource });
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+	authenticated.post("/api/files/spaces/:id/upload", async (c) => {
+		try {
+			const space = await files.get(c.req.param("id"));
+			if (!space.writable) throw new FileServiceError(403, "File space is read-only");
+			const form = await c.req.formData();
+			const upload = form.get("file");
+			const directory = String(form.get("directory") ?? "");
+			if (!(upload instanceof File)) throw new FileServiceError(400, "file is required");
+			const name = basename(upload.name).trim();
+			if (!name || name !== upload.name) throw new FileServiceError(400, "Invalid file name");
+			const parent = await resolveFilePath(space.root, directory);
+			const target = await resolveFilePath(space.root, join(directory, name), false);
+			if (target === parent) throw new FileServiceError(400, "Invalid file name");
+			await writeFile(target, new Uint8Array(await upload.arrayBuffer()), { flag: "wx" }).catch((error) => {
+				if (error.code === "EEXIST") throw new FileServiceError(409, "File already exists");
+				throw error;
+			});
+			return c.json({ resource: await fileResourceFromPath(space, target) }, 201);
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
+}
+//#endregion
+export { registerFilesRoutes };

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

@@ -19,6 +19,14 @@ const AUTHENTICATED_LAZY_ROUTE_BUNDLES = [
 			return { register: registerMediaRoutes };
 		}
 	},
+	{
+		id: "files",
+		match: (path) => startsWithAny(path, ["/api/files"]),
+		load: async () => {
+			const { registerFilesRoutes } = await import("./files.js");
+			return { register: registerFilesRoutes };
+		}
+	},
 	{
 		id: "workspace",
 		match: (path) => startsWithAny(path, ["/api/workspace"]),
@@ -109,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 };
 		}
 	},
 	{
@@ -212,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 };
@@ -315,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();