@xopcai/xopc 0.0.230 → 0.0.231

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

@@ -0,0 +1,172 @@
+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;
+}
+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", `inline; filename="${resource.name.replace(/["\r\n]/g, "_")}"`);
+			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/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"]),