@zhanguym/chatroom 1.0.0 → 1.1.0-beta.1

package/dist/plugins/web/http/workspace-api-router.js

@@ -1,7 +1,10 @@
-import { Router } from "express";
+import { randomUUID } from "node:crypto";
+import express, { Router } from "express";
 import { ChatRoomError } from "#core/errors/chatroom-error";
-import { asyncRoute, bodyRecord, requireString, } from "#presentation/http/http-utils";
+import { asyncRoute, bodyRecord, boundedIntegerQuery, requireString, } from "#presentation/http/http-utils";
 const MAX_WRITE_BYTES = 1024 * 1024;
+const MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+const MAX_IMAGE_PREVIEW_BYTES = 32 * 1024 * 1024;
 export function createWorkspaceApiRouter(application) {
     const router = Router();
     router.get("/workspaces", asyncRoute(async (_req, res) => {
@@ -27,10 +30,24 @@ export function createWorkspaceApiRouter(application) {
     router.get("/workspace/files", asyncRoute(async (req, res) => {
         const fs = await application.workspaces.fs(requireString(req.query.root, "root"));
         const filePath = typeof req.query.path === "string" ? req.query.path : ".";
-        res.json(await fs.list(filePath, { recursive: req.query.recursive === "1" }));
+        const limit = boundedIntegerQuery(req.query.limit, 300, 1, 500);
+        const offset = boundedIntegerQuery(req.query.offset, 0, 0, 100000);
+        const page = await fs.list(filePath, {
+            recursive: req.query.recursive === "1",
+            offset,
+            maxEntries: limit + 1,
+        });
+        const hasMore = page.length > limit;
+        res.json({
+            items: page.slice(0, limit),
+            nextOffset: hasMore ? offset + limit : null,
+        });
+    }));
+    router.get("/workspace/project-files", asyncRoute(async (req, res) => {
+        res.json(await application.workspaces.projectFilesResult(requireString(req.query.root, "root")));
     }));
     router.get("/workspace/file", asyncRoute(async (req, res) => {
-        const fs = await application.workspaces.fs(requireString(req.query.root, "root"));
+        const fs = await requestWorkspaceFs(req, application);
         res.json(await fs.read(requireString(req.query.path, "path"), {
             maxBytes: 2 * 1024 * 1024,
         }));
@@ -51,23 +68,94 @@ export function createWorkspaceApiRouter(application) {
             input: { root: fs.root, path: filePath, bytes },
         }, () => fs.write(filePath, body.content)));
     }));
+    router.post("/workspace/attachment", express.raw({
+        type: "application/octet-stream",
+        limit: MAX_ATTACHMENT_BYTES,
+    }), asyncRoute(async (req, res) => {
+        const root = requireString(req.query.root, "root");
+        const sessionId = requireString(req.query.sessionId, "sessionId");
+        if (!/^[A-Za-z0-9_-]+$/.test(sessionId))
+            throw new ChatRoomError("INVALID_INPUT", "Invalid attachment session id");
+        const originalName = requireString(req.query.name, "name");
+        if (!Buffer.isBuffer(req.body))
+            throw new ChatRoomError("INVALID_INPUT", "Attachment body must be binary");
+        const fs = await application.workspaces.fs(root);
+        const session = application.agents.getSession(sessionId);
+        if (session.workspaceRoot !== fs.root)
+            throw new ChatRoomError("FORBIDDEN", "Agent session belongs to another workspace");
+        const filePath = ".chatroom/agent-attachments/" +
+            sessionId +
+            "/" +
+            randomUUID() +
+            "-" +
+            attachmentFileName(originalName);
+        const file = await application.operations.run({
+            pluginId: "workspace",
+            source: "gui",
+            action: "attachment.upload",
+            input: { root: fs.root, path: filePath, bytes: req.body.byteLength },
+        }, () => fs.writeBytes(filePath, req.body));
+        res.json({
+            ...file,
+            name: originalName,
+            mimeType: typeof req.headers["x-chatroom-mime-type"] === "string"
+                ? req.headers["x-chatroom-mime-type"]
+                : null,
+        });
+    }));
+    router.get("/workspace/file/download", asyncRoute(async (req, res) => {
+        const filePath = requireString(req.query.path, "path");
+        const fs = await requestWorkspaceFs(req, application);
+        await streamWorkspaceFile(req, res, fs, filePath, "application/octet-stream", true);
+    }));
+    router.get("/workspace/file/preview", asyncRoute(async (req, res) => {
+        const filePath = requireString(req.query.path, "path");
+        const mime = previewMime(filePath);
+        if (!mime)
+            throw new ChatRoomError("INVALID_INPUT", "Unsupported file preview type");
+        const fs = await requestWorkspaceFs(req, application);
+        await streamWorkspaceFile(req, res, fs, filePath, mime, false);
+    }));
     router.get("/workspace/file/image", asyncRoute(async (req, res) => {
         const filePath = requireString(req.query.path, "path");
         const mime = imageMime(filePath);
         if (!mime)
             throw new ChatRoomError("INVALID_INPUT", "File type is not supported for image preview");
-        const fs = await application.workspaces.fs(requireString(req.query.root, "root"));
-        const file = await fs.readBytes(filePath, { maxBytes: 10 * 1024 * 1024 });
+        const fs = await requestWorkspaceFs(req, application);
+        const file = await fs.readBytes(filePath, {
+            maxBytes: MAX_IMAGE_PREVIEW_BYTES,
+        });
         if (file.truncated)
             throw new ChatRoomError("INVALID_INPUT", "Image is too large to preview");
+        const etag = 'W/"' +
+            file.bytes.toString(16) +
+            "-" +
+            Date.parse(file.modifiedAt).toString(16) +
+            '"';
+        const requestedVersion = typeof req.query.v === "string" ? req.query.v : null;
         res.setHeader("Content-Type", mime);
-        res.setHeader("Content-Length", String(file.data.byteLength));
-        res.setHeader("Cache-Control", "no-store");
+        if (mime === "image/svg+xml")
+            res.setHeader("Content-Security-Policy", "sandbox; default-src 'none'; style-src 'unsafe-inline'");
+        res.setHeader("ETag", etag);
+        res.setHeader("Last-Modified", file.modifiedAt);
+        res.setHeader("Cache-Control", requestedVersion === file.modifiedAt
+            ? "private, max-age=31536000, immutable"
+            : "private, no-cache");
         res.setHeader("X-Content-Type-Options", "nosniff");
+        if (req.headers["if-none-match"] === etag) {
+            res.status(304).end();
+            return;
+        }
+        res.setHeader("Content-Length", String(file.data.byteLength));
         res.send(file.data);
     }));
     return router;
 }
+function requestWorkspaceFs(req, application) {
+    if (req.query.workspace !== undefined)
+        return application.workspaces.fsByAlias(requireString(req.query.workspace, "workspace"));
+    return application.workspaces.fs(requireString(req.query.root, "root"));
+}
 function imageMime(filePath) {
     switch (filePath.split(".").pop()?.toLowerCase()) {
         case "png":
@@ -85,7 +173,109 @@ function imageMime(filePath) {
             return "image/bmp";
         case "ico":
             return "image/x-icon";
+        case "svg":
+            return "image/svg+xml";
         default:
             return null;
     }
 }
+function attachmentFileName(value) {
+    const name = value.split(/[\\/]/).pop()?.trim() ?? "";
+    const safe = name.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+    return (safe || "attachment").slice(0, 160);
+}
+function previewMime(filePath) {
+    switch (filePath.split(".").pop()?.toLowerCase()) {
+        case "pdf":
+            return "application/pdf";
+        case "mp4":
+        case "m4v":
+            return "video/mp4";
+        case "webm":
+            return "video/webm";
+        case "ogv":
+            return "video/ogg";
+        case "mov":
+            return "video/quicktime";
+        case "mp3":
+            return "audio/mpeg";
+        case "m4a":
+            return "audio/mp4";
+        case "aac":
+            return "audio/aac";
+        case "wav":
+            return "audio/wav";
+        case "flac":
+            return "audio/flac";
+        case "oga":
+        case "opus":
+        case "ogg":
+            return "audio/ogg";
+        default:
+            return null;
+    }
+}
+function parseByteRange(header, size) {
+    const match = /^bytes=(\d*)-(\d*)$/.exec(header.trim());
+    if (!match || size === 0 || (!match[1] && !match[2]))
+        return null;
+    let start;
+    let end;
+    if (!match[1]) {
+        const suffix = Number(match[2]);
+        if (!Number.isSafeInteger(suffix) || suffix <= 0)
+            return null;
+        start = Math.max(0, size - suffix);
+        end = size - 1;
+    }
+    else {
+        start = Number(match[1]);
+        end = match[2] ? Number(match[2]) : size - 1;
+        if (!Number.isSafeInteger(start) ||
+            !Number.isSafeInteger(end) ||
+            start >= size ||
+            end < start)
+            return null;
+        end = Math.min(end, size - 1);
+    }
+    return { start, end };
+}
+async function streamWorkspaceFile(req, res, fs, relativePath, mime, download) {
+    const { handle, bytes } = await fs.openReadable(relativePath);
+    const isRange = typeof req.headers.range === "string";
+    const range = isRange ? parseByteRange(req.headers.range, bytes) : null;
+    res.setHeader("Content-Type", mime);
+    res.setHeader("Cache-Control", "private, no-store, no-transform");
+    res.setHeader("X-Content-Type-Options", "nosniff");
+    res.setHeader("Accept-Ranges", "bytes");
+    if (download) {
+        const name = relativePath.replaceAll("\\", "/").split("/").pop() || "download";
+        const fallback = name.replace(/[^\x20-\x7e]/g, "_").replace(/["\\]/g, "_");
+        res.setHeader("Content-Disposition", `attachment; filename="${fallback}"; filename*=UTF-8''${encodeURIComponent(name)}`);
+    }
+    else {
+        res.setHeader("Content-Disposition", "inline");
+    }
+    if (isRange && !range) {
+        res.setHeader("Content-Range", `bytes */${bytes}`);
+        await handle.close();
+        res.status(416).end();
+        return;
+    }
+    const start = range?.start ?? 0;
+    const end = range?.end ?? bytes - 1;
+    if (range) {
+        res.status(206);
+        res.setHeader("Content-Range", `bytes ${start}-${end}/${bytes}`);
+    }
+    res.setHeader("Content-Length", String(Math.max(0, end - start + 1)));
+    if (req.method === "HEAD" || bytes === 0) {
+        await handle.close();
+        res.end();
+        return;
+    }
+    const stream = handle.createReadStream({ start, end, autoClose: true });
+    res.on("close", () => stream.destroy());
+    stream.on("error", (error) => res.destroy(error));
+    stream.pipe(res);
+}

package/dist/plugins/web/plugin.d.ts

@@ -3,6 +3,6 @@ import { WebRuntime } from "./runtime.js";
 interface WebPluginService {
     application: WebRuntime;
 }
-export declare const WebServiceToken: import("#plugins/types").ServiceToken<WebPluginService>;
+export declare const WebServiceToken: import("#app/service-registry").ServiceToken<WebPluginService>;
 export declare function createWebPlugin(): InternalPlugin;
 export {};

package/dist/plugins/web/plugin.js

@@ -1,8 +1,9 @@
-import { createServiceToken } from "#plugins/types";
+import { createServiceToken } from "#app/service-registry";
 import { ComputerServiceToken } from "#plugins/computer/plugin";
-import { GitServiceToken } from "#plugins/git/plugin";
-import { ProcessService } from "#plugins/process/plugin";
+import { GitAccessToken } from "#app/git-access";
+import { ProcessServiceToken } from "#plugins/process/plugin";
 import { WorkspaceServiceToken } from "#plugins/workspace/plugin";
+import { AgentServiceToken } from "#plugins/agent/plugin";
 import { WebRuntime } from "./runtime.js";
 export const WebServiceToken = createServiceToken("web");
 export function createWebPlugin() {
@@ -10,7 +11,7 @@ export function createWebPlugin() {
         id: "web",
         activate(context) {
             context.services.provide(WebServiceToken, {
-                application: new WebRuntime(context.services.require(WorkspaceServiceToken), context.services.require(GitServiceToken), context.operations, context.services.require(ProcessService), context.services.require(ComputerServiceToken), context.mcpTools),
+                application: new WebRuntime(context.services.require(WorkspaceServiceToken), context.services.require(GitAccessToken), context.operations, context.services.require(ProcessServiceToken), context.services.require(ComputerServiceToken), context.services.require(AgentServiceToken), context.mcpTools),
             });
         },
     };

package/dist/plugins/web/runtime.d.ts

@@ -1,18 +1,21 @@
 import type { OperationLog } from "#operations/operation-log";
 import type { ComputerService } from "#plugins/computer/computer-service";
-import type { GitService } from "#plugins/git/git-service";
+import type { GitAccess } from "#app/git-access";
 import type { ProcessSupervisor } from "#plugins/process/process-supervisor";
 import type { WorkspaceService } from "#plugins/workspace/workspace-service";
+import type { AgentRuntime } from "#plugins/agent/runtime";
 import type { McpToolControl } from "#mcp/server/tool-control";
 export declare class WebRuntime {
     readonly workspaces: WorkspaceService;
-    readonly git: GitService;
+    readonly git: GitAccess;
     readonly operations: OperationLog;
     readonly processes: ProcessSupervisor;
     readonly computer: ComputerService;
+    readonly agents: AgentRuntime;
     readonly mcpTools: McpToolControl;
-    constructor(workspaces: WorkspaceService, git: GitService, operations: OperationLog, processes: ProcessSupervisor, computer: ComputerService, mcpTools: McpToolControl);
+    constructor(workspaces: WorkspaceService, git: GitAccess, operations: OperationLog, processes: ProcessSupervisor, computer: ComputerService, agents: AgentRuntime, mcpTools: McpToolControl);
     processKill(processId: string, force?: boolean): Promise<import("./api-types.js").ProcessSnapshot>;
     listProcesses(): import("./api-types.js").ProcessSummary[];
     getProcess(processId: string): import("./api-types.js").ProcessSnapshot;
+    getProcessSummary(processId: string): import("./api-types.js").ProcessSummary;
 }

package/dist/plugins/web/runtime.js

@@ -4,13 +4,15 @@ export class WebRuntime {
     operations;
     processes;
     computer;
+    agents;
     mcpTools;
-    constructor(workspaces, git, operations, processes, computer, mcpTools) {
+    constructor(workspaces, git, operations, processes, computer, agents, mcpTools) {
         this.workspaces = workspaces;
         this.git = git;
         this.operations = operations;
         this.processes = processes;
         this.computer = computer;
+        this.agents = agents;
         this.mcpTools = mcpTools;
     }
     processKill(processId, force = false) {
@@ -28,4 +30,7 @@ export class WebRuntime {
     getProcess(processId) {
         return this.processes.read(processId);
     }
+    getProcessSummary(processId) {
+        return this.processes.summary(processId);
+    }
 }

package/dist/plugins/workspace/mcp.d.ts

@@ -1,3 +1,3 @@
 import type { PluginMcpRegistrar } from "#mcp/server/plugin-mcp-registrar";
 import type { WorkspaceService } from "./workspace-service.js";
-export declare function registerWorkspaceTools(mcp: PluginMcpRegistrar, workspaces: WorkspaceService): void;
+export declare function registerWorkspaceTools(mcp: PluginMcpRegistrar, workspaces: WorkspaceService, webBaseUrl: () => string | null): void;

package/dist/plugins/workspace/mcp.js

@@ -1,5 +1,15 @@
+import path from "node:path";
+import { ChatRoomError } from "#core/errors/chatroom-error";
 import { z } from "zod";
 import { closedRead } from "#mcp/server/tool-support";
+const workspaceEntrySchema = z.object({
+    root: z.string(),
+    name: z.string(),
+    summary: z.string().nullable(),
+});
+const workspaceListSchema = z.object({
+    workspaces: z.array(workspaceEntrySchema),
+});
 const workspaceInfoSchema = z.object({
     root: z.string(),
     name: z.string(),
@@ -12,7 +22,15 @@ const workspaceInfoSchema = z.object({
         path: z.string(),
     })),
 });
-export function registerWorkspaceTools(mcp, workspaces) {
+export function registerWorkspaceTools(mcp, workspaces, webBaseUrl) {
+    mcp.registerTool("workspace_list", {
+        title: "List workspaces",
+        description: "List available projects with their workspace roots, names, and project summaries from the workspace prompt metadata. Use this first to identify the relevant project before calling workspace_info for its full prompt, instructions, and skills.",
+        inputSchema: z.object({}),
+        outputSchema: workspaceListSchema,
+        annotations: closedRead,
+        action: "list",
+    }, async () => ({ workspaces: await workspaces.list() }));
     mcp.registerTool("workspace_info", {
         title: "Workspace info",
         description: "Read the complete workspace context for a project, including its summary, preset prompt, project instructions, and skill metadata.",
@@ -21,4 +39,110 @@ export function registerWorkspaceTools(mcp, workspaces) {
         annotations: closedRead,
         action: "info",
     }, (input) => workspaces.info(input.root));
+    mcp.registerTool("workspace_file_get", {
+        title: "Get workspace file",
+        description: "Read a file from a workspace in bounded chunks, or return a browser download link protected by the normal ChatRoom Web login. " +
+            "Use mode=content with encoding=utf8 for text and encoding=base64 for binary files; advance offset with nextOffset for large files. " +
+            "Use mode=link to give the user a download link when the Web service has a configured public address. " +
+            "Links do not contain credentials and the user must log in to ChatRoom Web to download.",
+        inputSchema: z.object({
+            root: z.string(),
+            path: z.string(),
+            mode: z.enum(["content", "link"]).default("content"),
+            encoding: z.enum(["utf8", "base64"]).default("utf8"),
+            offset: z.number().int().nonnegative().default(0),
+            maxBytes: z.number().int().min(1).max(262144).default(65536),
+        }),
+        outputSchema: z.object({
+            mode: z.enum(["content", "link"]),
+            path: z.string(),
+            name: z.string(),
+            bytes: z.number(),
+            modifiedAt: z.string(),
+            encoding: z.enum(["utf8", "base64"]).optional(),
+            content: z.string().optional(),
+            offset: z.number().optional(),
+            nextOffset: z.number().nullable().optional(),
+            url: z.string().optional(),
+        }),
+        annotations: closedRead,
+        action: "file.get",
+        audit: {
+            input: (input) => ({
+                root: input.root,
+                path: input.path,
+                mode: input.mode,
+                offset: input.mode === "content" ? input.offset : undefined,
+            }),
+            output: (output) => {
+                const result = output;
+                return {
+                    mode: result.mode,
+                    path: result.path,
+                    bytes: result.bytes,
+                    nextOffset: result.nextOffset,
+                };
+            },
+        },
+    }, async (input) => {
+        const fs = await workspaces.fs(input.root);
+        const name = path.posix.basename(input.path.replaceAll("\\", "/"));
+        if (input.mode === "link") {
+            const base = webBaseUrl();
+            if (!base)
+                throw new ChatRoomError("INVALID_INPUT", "No public Web URL is configured; download link is unavailable");
+            const info = await fs.fileInfo(input.path);
+            const url = new URL("/download", base);
+            url.searchParams.set("workspace", path.basename(fs.root));
+            url.searchParams.set("path", input.path);
+            return {
+                mode: "link",
+                path: input.path,
+                name,
+                ...info,
+                url: url.toString(),
+            };
+        }
+        const chunk = await fs.readChunk(input.path, input.offset, input.maxBytes);
+        let content;
+        let consumed = chunk.data.byteLength;
+        if (input.encoding === "utf8") {
+            const decoder = new TextDecoder("utf-8", { fatal: true });
+            let decoded = null;
+            for (let trim = 0; trim < 4 && trim < chunk.data.byteLength; trim += 1) {
+                if (trim > 0 && input.offset + chunk.data.byteLength >= chunk.bytes)
+                    break;
+                try {
+                    consumed = chunk.data.byteLength - trim;
+                    decoded = decoder.decode(chunk.data.subarray(0, consumed));
+                    break;
+                }
+                catch {
+                    // Only incomplete trailing UTF-8 sequences can be repaired.
+                }
+            }
+            if (decoded === null) {
+                if (chunk.data.byteLength === 0)
+                    decoded = "";
+                else
+                    throw new ChatRoomError("INVALID_INPUT", "Invalid UTF-8 data; use base64");
+            }
+            content = decoded;
+        }
+        else {
+            content = chunk.data.toString("base64");
+        }
+        const next = input.offset + consumed;
+        return {
+            mode: "content",
+            path: input.path,
+            name,
+            bytes: chunk.bytes,
+            modifiedAt: chunk.modifiedAt,
+            encoding: input.encoding,
+            content,
+            offset: input.offset,
+            nextOffset: next < chunk.bytes ? next : null,
+        };
+    });
 }

package/dist/plugins/workspace/metadata.d.ts

@@ -1,5 +1,5 @@
 import type { WorkspaceFs } from "./workspace-fs.js";
-import type { WorkspaceSkill } from "./types.js";
+import type { WorkspaceSkill } from "#app/workspace-access";
 export declare function readSummary(fs: WorkspaceFs): Promise<string | null>;
 export declare function readPresetPrompt(fs: WorkspaceFs): Promise<string | null>;
 export declare function readInstructions(fs: WorkspaceFs): Promise<string | null>;

package/dist/plugins/workspace/plugin.d.ts

@@ -1,4 +1,4 @@
 import type { InternalPlugin } from "#plugins/types";
 import { WorkspaceService } from "./workspace-service.js";
-export declare const WorkspaceServiceToken: import("#plugins/types").ServiceToken<WorkspaceService>;
+export declare const WorkspaceServiceToken: import("#app/service-registry").ServiceToken<WorkspaceService>;
 export declare function createWorkspacePlugin(): InternalPlugin;

package/dist/plugins/workspace/plugin.js

@@ -1,22 +1,28 @@
-import { createServiceToken } from "#plugins/types";
+import { GitAccessToken } from "#app/git-access";
+import { WorkspaceAccessToken } from "#app/workspace-access";
+import { createServiceToken } from "#app/service-registry";
 import { registerWorkspaceTools } from "./mcp.js";
 import { WorkspaceService } from "./workspace-service.js";
 export const WorkspaceServiceToken = createServiceToken("workspace");
 export function createWorkspacePlugin() {
     let service = null;
+    let webBaseUrl = () => null;
     return {
         id: "workspace",
         async activate(context) {
-            service = await WorkspaceService.create(context.config.allowedRoots);
+            webBaseUrl = () => context.externalAccess.publicWebBaseUrl();
+            service = await WorkspaceService.create(context.config.allowedRoots, context.services.require(GitAccessToken));
             context.services.provide(WorkspaceServiceToken, service);
+            context.services.provide(WorkspaceAccessToken, service);
         },
         registerMcp(mcp) {
             if (!service)
                 throw new Error("Workspace plugin is not active");
-            registerWorkspaceTools(mcp, service);
+            registerWorkspaceTools(mcp, service, webBaseUrl);
         },
         deactivate() {
             service = null;
+            webBaseUrl = () => null;
         },
     };
 }

package/dist/plugins/workspace/types.d.ts

@@ -1,23 +1,6 @@
-export interface WorkspaceEntry {
-    root: string;
-    name: string;
-    summary: string | null;
-}
-export interface WorkspaceSkill {
-    name: string;
-    description: string;
-    path: string;
-}
-export interface WorkspaceInfo {
-    root: string;
-    name: string;
-    summary: string | null;
-    presetPrompt: string | null;
-    instructions: string | null;
-    skills: WorkspaceSkill[];
-}
 export interface WorkspaceFile {
     path: string;
     type: "file" | "directory" | "symlink";
     size: number;
+    modifiedAt?: string;
 }

package/dist/plugins/workspace/workspace-fs.d.ts

@@ -3,12 +3,17 @@ export declare class WorkspaceFs {
     readonly root: string;
     private constructor();
     static create(root: string): Promise<WorkspaceFs>;
+    fileInfo(relativePath: string): Promise<{
+        bytes: number;
+        modifiedAt: string;
+    }>;
     read(relativePath: string, options?: {
         maxBytes?: number;
     }): Promise<{
         content: string;
         bytes: number;
         truncated: boolean;
+        modifiedAt: string;
     }>;
     readBytes(relativePath: string, options?: {
         maxBytes?: number;
@@ -16,13 +21,24 @@ export declare class WorkspaceFs {
         data: Buffer;
         bytes: number;
         truncated: boolean;
+        modifiedAt: string;
+    }>;
+    openReadable(relativePath: string): Promise<{
+        handle: import("fs/promises").FileHandle;
+        bytes: number;
+        modifiedAt: string;
+    }>;
+    readChunk(relativePath: string, offset: number, maxBytes: number): Promise<{
+        data: Buffer;
+        bytes: number;
+        modifiedAt: string;
     }>;
     write(relativePath: string, content: string): Promise<WorkspaceFile>;
+    writeBytes(relativePath: string, content: Uint8Array): Promise<WorkspaceFile>;
     list(relativePath?: string, options?: {
         recursive?: boolean;
         maxEntries?: number;
+        excludeDirectoryNames?: readonly string[];
+        offset?: number;
     }): Promise<WorkspaceFile[]>;
-    private lexical;
-    private resolveWritable;
-    private resolveReadable;
 }