@zhanguym/chatroom 1.1.0-beta.0 → 1.1.0

package/dist/app/external-access-registry.d.ts

@@ -10,6 +10,7 @@ export declare class ExternalAccessRegistry {
     constructor(config: ChatRoomConfig["auth"]);
     setCloud(state: ExternalAccessState): void;
     clearCloud(): void;
+    publicWebBaseUrl(): string | null;
     baseUrlForHost(kind: ExternalAccessKind, hostname: string): string | null;
     matches(kind: ExternalAccessKind, hostname: string): boolean;
     hasHost(hostname: string): boolean;

package/dist/app/external-access-registry.js

@@ -13,6 +13,9 @@ export class ExternalAccessRegistry {
     clearCloud() {
         this.cloud = { mcpBaseUrl: null, webBaseUrl: null };
     }
+    publicWebBaseUrl() {
+        return this.cloud.webBaseUrl ?? this.selfHosted.webBaseUrl;
+    }
     baseUrlForHost(kind, hostname) {
         for (const url of this.urls(kind))
             if (new URL(url).hostname === hostname)

package/dist/infrastructure/logging/system-log.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { stripVTControlCharacters } from "node:util";
 import { SecretRedactor } from "#core/operations/redactor";
 export class SystemLog {
     store;
@@ -35,7 +36,7 @@ export class SystemLog {
     }
     write(level, module, event, message, data) {
         const redacted = this.redactor.redact({
-            message,
+            message: stripVTControlCharacters(message),
             ...(data ? { data: normalizeValue(data) } : {}),
         });
         const record = {

package/dist/plugins/computer/computer-native-backend.js

@@ -5,9 +5,17 @@ export class NativeComputerBackend {
     host = new ComputerNativeHost();
     restartWhenGranted = new Set();
     async status() {
-        const value = await this.readStatus().catch(() => ({
+        const value = await this.readStatus().catch((error) => ({
             platform: this.host.platform,
             helper: "unavailable",
+            ...(error instanceof ChatRoomError &&
+                error.code === "UNSUPPORTED" &&
+                error.details &&
+                typeof error.details === "object" &&
+                "reason" in error.details &&
+                error.details.reason === "no_x11_session"
+                ? { unavailableReason: "no_x11_session" }
+                : {}),
             permissions: {
                 accessibility: "unknown",
                 screenRecording: "unknown",

package/dist/plugins/computer/computer-native-host.js

@@ -62,8 +62,17 @@ export class ComputerNativeHost {
             const child = this.child;
             if (!child || child.killed || child.stdin.destroyed)
                 this.rejectRequest(id, transportError);
-            else
-                child.stdin.write(line);
+            else {
+                try {
+                    child.stdin.write(line, (error) => {
+                        if (error)
+                            this.failTransport(child, error);
+                    });
+                }
+                catch (error) {
+                    this.failTransport(child, error instanceof Error ? error : new Error(String(error)));
+                }
+            }
         }
         return promise;
     }
@@ -104,8 +113,12 @@ export class ComputerNativeHost {
                 return this.startMacHelper(generation);
             case "windows":
                 return this.startPipeHelper(windowsHelperPath(), "Windows", process.env, generation);
-            case "linux":
-                return this.startPipeHelper(linuxHelperPath(), "Linux X11", linuxDesktopEnvironment(), generation);
+            case "linux": {
+                const env = linuxDesktopEnvironment();
+                if (!env.DISPLAY)
+                    return Promise.reject(new ChatRoomError("UNSUPPORTED", "Linux Computer Use requires an active X11 graphical session", { reason: "no_x11_session" }));
+                return this.startPipeHelper(linuxHelperPath(), "Linux X11", env, generation);
+            }
             case "unsupported":
                 return Promise.reject(new ChatRoomError("UNSUPPORTED", "Computer Use is supported only on macOS, Windows, and Linux X11"));
         }
@@ -182,6 +195,7 @@ export class ComputerNativeHost {
             env,
         });
         this.child = child;
+        child.stdin.on("error", (error) => this.failTransport(child, error));
         this.lines = createInterface({ input: child.stdout });
         this.lines.on("line", (line) => this.handleLine(line));
         child.stderr.on("data", (chunk) => console.error("[computer-helper]", String(chunk).trimEnd()));
@@ -204,8 +218,10 @@ export class ComputerNativeHost {
         cancelStarting?.(error);
         if (isCurrentSocket)
             this.socket = null;
-        if (isCurrentChild)
+        if (isCurrentChild) {
+            this.child?.kill();
             this.child = null;
+        }
         this.lines?.close();
         this.lines = null;
         this.cleanupSocketPath();

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

@@ -23,6 +23,7 @@ export interface ComputerDisplay {
 export interface ComputerStatus {
     platform: ComputerPlatform;
     helper: ComputerHelperState;
+    unavailableReason?: "no_x11_session";
     permissions: ComputerPermissions;
     displays: ComputerDisplay[];
     settings: ComputerSettings;

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

@@ -47,7 +47,7 @@ export function createWorkspaceApiRouter(application) {
         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,
         }));
@@ -103,12 +103,25 @@ export function createWorkspaceApiRouter(application) {
                 : 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 fs = await requestWorkspaceFs(req, application);
         const file = await fs.readBytes(filePath, {
             maxBytes: MAX_IMAGE_PREVIEW_BYTES,
         });
@@ -121,6 +134,8 @@ export function createWorkspaceApiRouter(application) {
             '"';
         const requestedVersion = typeof req.query.v === "string" ? req.query.v : null;
         res.setHeader("Content-Type", mime);
+        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
@@ -136,6 +151,11 @@ export function createWorkspaceApiRouter(application) {
     }));
     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":
@@ -153,6 +173,8 @@ function imageMime(filePath) {
             return "image/bmp";
         case "ico":
             return "image/x-icon";
+        case "svg":
+            return "image/svg+xml";
         default:
             return null;
     }
@@ -162,3 +184,98 @@ function attachmentFileName(value) {
     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/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,3 +1,5 @@
+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({
@@ -20,7 +22,7 @@ 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.",
@@ -37,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/plugin.js

@@ -6,9 +6,11 @@ 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) {
+            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);
@@ -16,10 +18,11 @@ export function createWorkspacePlugin() {
         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/workspace-fs.d.ts

@@ -23,6 +23,16 @@ export declare class WorkspaceFs {
         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?: {

package/dist/plugins/workspace/workspace-fs.js

@@ -68,6 +68,45 @@ export class WorkspaceFs {
         }
         throw new ChatRoomError("CONFLICT", `File changed while being read: ${relativePath}`);
     }
+    async openReadable(relativePath) {
+        const target = await resolveReadableWithin(this.root, relativePath);
+        const handle = await open(target, "r");
+        try {
+            const info = await handle.stat();
+            if (!info.isFile())
+                throw new ChatRoomError("INVALID_INPUT", `Not a file: ${relativePath}`);
+            return { handle, bytes: info.size, modifiedAt: info.mtime.toISOString() };
+        }
+        catch (error) {
+            await handle.close();
+            throw error;
+        }
+    }
+    async readChunk(relativePath, offset, maxBytes) {
+        const { handle, bytes, modifiedAt } = await this.openReadable(relativePath);
+        try {
+            if (!Number.isSafeInteger(offset) || offset < 0 || offset > bytes)
+                throw new ChatRoomError("INVALID_INPUT", "Invalid file offset");
+            if (!Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > 262144)
+                throw new ChatRoomError("INVALID_INPUT", "Invalid file chunk size");
+            const length = Math.min(maxBytes, bytes - offset);
+            const buffer = Buffer.alloc(length);
+            let position = 0;
+            while (position < length) {
+                const { bytesRead } = await handle.read(buffer, position, length - position, offset + position);
+                if (bytesRead === 0)
+                    break;
+                position += bytesRead;
+            }
+            const after = await handle.stat();
+            if (after.size !== bytes || after.mtime.toISOString() !== modifiedAt)
+                throw new ChatRoomError("CONFLICT", "File changed while reading");
+            return { data: buffer.subarray(0, position), bytes, modifiedAt };
+        }
+        finally {
+            await handle.close();
+        }
+    }
     async write(relativePath, content) {
         if (typeof content !== "string")
             throw new ChatRoomError("INVALID_INPUT", "File content must be a string");

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

@@ -9,6 +9,8 @@ export declare class WorkspaceService implements WorkspaceAccess {
     roots(): string[];
     list(): Promise<WorkspaceEntry[]>;
     resolve(input: string): Promise<string>;
+    resolveAlias(alias: string): Promise<string>;
+    fsByAlias(alias: string): Promise<WorkspaceFs>;
     createProject(parentInput: string, nameInput: string): Promise<WorkspaceEntry>;
     projectFiles(input: string, maxFiles?: number): Promise<string[]>;
     projectFilesResult(input: string, maxFiles?: number): Promise<{

package/dist/plugins/workspace/workspace-service.js

@@ -51,6 +51,24 @@ export class WorkspaceService {
     async resolve(input) {
         return this.rootsPolicy.resolveWorkspace(input);
     }
+    async resolveAlias(alias) {
+        const name = validateProjectName(alias);
+        const matches = [];
+        for (const parent of this.rootsPolicy.roots()) {
+            const candidate = path.join(parent, name);
+            const canonical = await realpath(candidate).catch(() => null);
+            if (canonical === candidate)
+                matches.push(candidate);
+        }
+        if (matches.length === 0)
+            throw new ChatRoomError("NOT_FOUND", "Workspace not found");
+        if (matches.length > 1)
+            throw new ChatRoomError("CONFLICT", "Workspace alias is ambiguous");
+        return this.resolve(matches[0]);
+    }
+    async fsByAlias(alias) {
+        return WorkspaceFs.create(await this.resolveAlias(alias));
+    }
     async createProject(parentInput, nameInput) {
         const parent = await this.rootsPolicy.resolveAllowedRoot(parentInput);
         const name = validateProjectName(nameInput);