@chatroomcp/chatroom 0.2.2 → 0.2.3

package/README.md

@@ -8,7 +8,7 @@
   English | <a href="./docs/README.zh-CN.md">简体中文</a> | <a href="https://doc.chatroomcp.com/">Documentation</a>
 </p>
 
-ChatRoom is a local MCP runtime that lets ChatGPT work with projects and processes on your device. Its WebUI provides workspace browsing, Git repository management, process monitoring, ChatRoom Cloud controls, and plugin-attributed operation logs.
+ChatRoom is a local MCP runtime that lets ChatGPT work with projects on your local device, run processes, or perform computer control. Its WebUI provides workspace browsing, Git repository and process management, computer control, ChatRoom Cloud management, and plugin-attributed operation logs.
 
 ## Install
 
@@ -20,6 +20,8 @@ chatroom init
 chatroom serve
 ```
 
+Windows users can also use [ChatRoom-Windows-Portable](https://github.com/dayearnew/ChatRoom-Windows-Portable) without configuring any dependencies themselves.
+
 Default local endpoints:
 
 ```text
@@ -27,13 +29,13 @@ WebUI  http://127.0.0.1:8765/
 MCP    http://127.0.0.1:8765/mcp
 ```
 
-`chatroom init` creates `~/.config/chatroom/config.json` and uses `~/Projects` as the default allowed workspace root.
+`chatroom init` creates the [configuration file](https://doc.chatroomcp.com/configuration) and uses `~/Projects` as the default allowed workspace root.
 
 ## Use with ChatGPT
 
 ChatGPT connects to ChatRoom through its MCP endpoint. For remote access, either enable ChatRoom Cloud from the WebUI or expose ChatRoom through your own HTTPS ingress and configure the corresponding public URL.
 
-Create a custom MCP app in ChatGPT Developer Mode, use the ChatRoom `/mcp` URL, and complete OAuth authorization with the `ownerToken` stored in `~/.config/chatroom/config.json`.
+Create a custom MCP app in ChatGPT Developer Mode, use the ChatRoom `/mcp` URL, and complete OAuth authorization with the `ownerToken` in the [configuration file](https://doc.chatroomcp.com/configuration).
 
 See [Use ChatRoom with ChatGPT](https://doc.chatroomcp.com/chatgpt) for the current ChatGPT setup flow.
 

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

@@ -1,11 +1,26 @@
 import { Router } from "express";
 import { ChatRoomError } from "../../../core/errors/chatroom-error.js";
 import { asyncRoute, requireString, } from "../../../presentation/http/http-utils.js";
+const MAX_WRITE_BYTES = 1024 * 1024;
 export function createWorkspaceApiRouter(application) {
     const router = Router();
     router.get("/workspaces", asyncRoute(async (_req, res) => {
         res.json(await application.workspaces.list());
     }));
+    router.post("/workspaces", asyncRoute(async (req, res) => {
+        const body = bodyRecord(req.body);
+        const parent = requireString(body.parent, "parent");
+        const name = requireString(body.name, "name");
+        res.json(await application.operations.run({
+            pluginId: "workspace",
+            source: "gui",
+            action: "create",
+            input: { parent, name },
+        }, () => application.workspaces.createProject(parent, name)));
+    }));
+    router.get("/workspace/roots", (_req, res) => {
+        res.json(application.workspaces.roots());
+    });
     router.get("/workspace", asyncRoute(async (req, res) => {
         res.json(await application.workspaces.info(requireString(req.query.root, "root")));
     }));
@@ -20,6 +35,22 @@ export function createWorkspaceApiRouter(application) {
             maxBytes: 2 * 1024 * 1024,
         }));
     }));
+    router.put("/workspace/file", asyncRoute(async (req, res) => {
+        const body = bodyRecord(req.body);
+        const fs = await application.workspaces.fs(requireString(body.root, "root"));
+        const filePath = requireString(body.path, "path");
+        if (typeof body.content !== "string")
+            throw new ChatRoomError("INVALID_INPUT", "content must be a string");
+        const bytes = Buffer.byteLength(body.content, "utf8");
+        if (bytes > MAX_WRITE_BYTES)
+            throw new ChatRoomError("INVALID_INPUT", `File content exceeds ${MAX_WRITE_BYTES} bytes`);
+        res.json(await application.operations.run({
+            pluginId: "workspace",
+            source: "gui",
+            action: "file.write",
+            input: { root: fs.root, path: filePath, bytes },
+        }, () => fs.write(filePath, body.content)));
+    }));
     router.get("/workspace/file/image", asyncRoute(async (req, res) => {
         const filePath = requireString(req.query.path, "path");
         const mime = imageMime(filePath);
@@ -37,6 +68,11 @@ export function createWorkspaceApiRouter(application) {
     }));
     return router;
 }
+function bodyRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
 function imageMime(filePath) {
     switch (filePath.split(".").pop()?.toLowerCase()) {
         case "png":

package/dist/plugins/workspace/mcp.js

@@ -2,6 +2,9 @@ import { z } from "zod";
 import { closedRead } from "../../mcp/server/tool-support.js";
 const workspaceInfoSchema = z.object({
     root: z.string(),
+    name: z.string(),
+    summary: z.string().nullable(),
+    presetPrompt: z.string().nullable(),
     instructions: z.string().nullable(),
     skills: z.array(z.object({
         name: z.string(),
@@ -12,7 +15,7 @@ const workspaceInfoSchema = z.object({
 export function registerWorkspaceTools(mcp, workspaces) {
     mcp.registerTool("workspace_info", {
         title: "Workspace info",
-        description: "Read project instructions and skill metadata for a directory within the configured allowed roots.",
+        description: "Read the complete workspace context for a project, including its summary, preset prompt, project instructions, and skill metadata.",
         inputSchema: z.object({ root: z.string() }),
         outputSchema: workspaceInfoSchema,
         annotations: closedRead,

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

@@ -1,4 +1,6 @@
 import type { WorkspaceFs } from "./workspace-fs.js";
 import type { WorkspaceSkill } from "./types.js";
+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>;
 export declare function readSkills(fs: WorkspaceFs): Promise<WorkspaceSkill[]>;

package/dist/plugins/workspace/metadata.js

@@ -2,16 +2,15 @@ import path from "node:path";
 import { ChatRoomError } from "../../core/errors/chatroom-error.js";
 const SKILL_ROOTS = [".agents/skills", ".claude/skills", ".chatroom/skills"];
 const MAX_METADATA_BYTES = 64 * 1024;
-export async function readInstructions(fs) {
-    try {
-        return (await fs.read("AGENTS.md", { maxBytes: MAX_METADATA_BYTES }))
-            .content;
-    }
-    catch (error) {
-        if (error instanceof ChatRoomError && error.code === "NOT_FOUND")
-            return null;
-        throw error;
-    }
+const MAX_SUMMARY_BYTES = 8 * 1024;
+export function readSummary(fs) {
+    return readOptionalText(fs, ".chatroom/summary.md", MAX_SUMMARY_BYTES);
+}
+export function readPresetPrompt(fs) {
+    return readOptionalText(fs, ".chatroom/prompt.md", MAX_METADATA_BYTES);
+}
+export function readInstructions(fs) {
+    return readOptionalText(fs, "AGENTS.md", MAX_METADATA_BYTES);
 }
 export async function readSkills(fs) {
     const paths = [];
@@ -49,6 +48,17 @@ export async function readSkills(fs) {
         }
     }));
 }
+async function readOptionalText(fs, relativePath, maxBytes) {
+    try {
+        const content = (await fs.read(relativePath, { maxBytes })).content;
+        return content.trim() ? content : null;
+    }
+    catch (error) {
+        if (error instanceof ChatRoomError && error.code === "NOT_FOUND")
+            return null;
+        throw error;
+    }
+}
 function parseSkillFrontmatter(content) {
     const lines = content
         .replace(/^\uFEFF/, "")

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

@@ -1,5 +1,7 @@
 export interface WorkspaceEntry {
     root: string;
+    name: string;
+    summary: string | null;
 }
 export interface WorkspaceSkill {
     name: string;
@@ -8,6 +10,9 @@ export interface WorkspaceSkill {
 }
 export interface WorkspaceInfo {
     root: string;
+    name: string;
+    summary: string | null;
+    presetPrompt: string | null;
     instructions: string | null;
     skills: WorkspaceSkill[];
 }

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

@@ -17,9 +17,12 @@ export declare class WorkspaceFs {
         bytes: number;
         truncated: boolean;
     }>;
+    write(relativePath: string, content: string): Promise<WorkspaceFile>;
     list(relativePath?: string, options?: {
         recursive?: boolean;
         maxEntries?: number;
     }): Promise<WorkspaceFile[]>;
+    private lexical;
+    private resolveWritable;
     private resolveReadable;
 }

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

@@ -1,4 +1,5 @@
-import { lstat, open, readdir, realpath, stat } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, open, readdir, realpath, rename, rm, stat, writeFile, } from "node:fs/promises";
 import path from "node:path";
 import { ChatRoomError } from "../../core/errors/chatroom-error.js";
 export class WorkspaceFs {
@@ -44,6 +45,44 @@ export class WorkspaceFs {
             await handle.close();
         }
     }
+    async write(relativePath, content) {
+        if (typeof content !== "string")
+            throw new ChatRoomError("INVALID_INPUT", "File content must be a string");
+        const normalized = normalizeRelative(relativePath);
+        if (normalized === ".")
+            throw new ChatRoomError("INVALID_INPUT", "File path is required");
+        const target = await this.resolveWritable(normalized);
+        let mode = 0o644;
+        try {
+            const info = await lstat(target);
+            if (!info.isFile())
+                throw new ChatRoomError("INVALID_INPUT", `Not a file: ${relativePath}`);
+            mode = info.mode & 0o777;
+        }
+        catch (error) {
+            if (error instanceof ChatRoomError)
+                throw error;
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        const temporary = `${target}.chatroom-${randomUUID()}.tmp`;
+        try {
+            await writeFile(temporary, content, {
+                encoding: "utf8",
+                flag: "wx",
+                mode,
+            });
+            await rename(temporary, target);
+        }
+        finally {
+            await rm(temporary, { force: true }).catch(() => undefined);
+        }
+        return {
+            path: normalized,
+            type: "file",
+            size: Buffer.byteLength(content, "utf8"),
+        };
+    }
     async list(relativePath = ".", options = {}) {
         const start = await this.resolveReadable(relativePath);
         if (!(await stat(start)).isDirectory())
@@ -73,11 +112,61 @@ export class WorkspaceFs {
         await walk(start);
         return output;
     }
-    async resolveReadable(relativePath) {
+    lexical(relativePath) {
         const normalized = normalizeRelative(relativePath);
-        const lexical = path.resolve(this.root, ...normalized.split("/"));
-        if (!inside(this.root, lexical))
+        const absolute = path.resolve(this.root, ...normalized.split("/"));
+        if (!inside(this.root, absolute))
             throw new ChatRoomError("FORBIDDEN", "Path escapes workspace");
+        return absolute;
+    }
+    async resolveWritable(relativePath) {
+        const target = this.lexical(relativePath);
+        const relative = path.relative(this.root, target);
+        const parts = relative.split(path.sep).filter(Boolean);
+        let current = this.root;
+        for (let index = 0; index < parts.length - 1; index++) {
+            current = path.join(current, parts[index]);
+            let info;
+            try {
+                info = await lstat(current);
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+                try {
+                    await mkdir(current, { recursive: false, mode: 0o700 });
+                }
+                catch (mkdirError) {
+                    if (mkdirError.code !== "EEXIST")
+                        throw mkdirError;
+                }
+                info = await lstat(current);
+            }
+            if (info.isSymbolicLink())
+                throw new ChatRoomError("FORBIDDEN", `Writes through symlinked directories are not allowed: ${relativePath}`);
+            if (!info.isDirectory())
+                throw new ChatRoomError("INVALID_INPUT", `Parent is not a directory: ${parts[index]}`);
+            const canonical = await realpath(current);
+            if (!inside(this.root, canonical))
+                throw new ChatRoomError("FORBIDDEN", "Write path escapes workspace");
+        }
+        try {
+            const targetInfo = await lstat(target);
+            if (targetInfo.isSymbolicLink())
+                throw new ChatRoomError("FORBIDDEN", `Writes through symlinks are not allowed: ${relativePath}`);
+            if (!targetInfo.isFile())
+                throw new ChatRoomError("INVALID_INPUT", `Not a file: ${relativePath}`);
+        }
+        catch (error) {
+            if (error instanceof ChatRoomError)
+                throw error;
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        return target;
+    }
+    async resolveReadable(relativePath) {
+        const lexical = this.lexical(relativePath);
         const canonical = await realpath(lexical).catch((error) => {
             if (error.code === "ENOENT")
                 throw new ChatRoomError("NOT_FOUND", `Path does not exist: ${relativePath}`);

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

@@ -4,8 +4,12 @@ export declare class WorkspaceService {
     private readonly allowedRoots;
     private constructor();
     static create(allowedRoots: string[]): Promise<WorkspaceService>;
+    roots(): string[];
     list(): Promise<WorkspaceEntry[]>;
     resolve(input: string): Promise<string>;
+    createProject(parentInput: string, nameInput: string): Promise<WorkspaceEntry>;
     info(input: string): Promise<WorkspaceInfo>;
     fs(input: string): Promise<WorkspaceFs>;
+    private isWorkspaceRoot;
+    private resolveAllowedRoot;
 }

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

@@ -1,8 +1,8 @@
-import { readdir, realpath, stat } from "node:fs/promises";
+import { mkdir, readdir, realpath, stat } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { ChatRoomError } from "../../core/errors/chatroom-error.js";
-import { readInstructions, readSkills } from "./metadata.js";
+import { readInstructions, readPresetPrompt, readSkills, readSummary, } from "./metadata.js";
 import { WorkspaceFs } from "./workspace-fs.js";
 export class WorkspaceService {
     allowedRoots;
@@ -20,6 +20,9 @@ export class WorkspaceService {
         }));
         return new WorkspaceService([...new Set(canonicalRoots)]);
     }
+    roots() {
+        return [...this.allowedRoots];
+    }
     async list() {
         const roots = new Set();
         for (const allowedRoot of this.allowedRoots) {
@@ -36,13 +39,20 @@ export class WorkspaceService {
                     entry.name.startsWith("."))
                     continue;
                 const candidate = await realpath(path.join(allowedRoot, entry.name)).catch(() => null);
-                if (candidate && inside(allowedRoot, candidate))
+                if (candidate && this.isWorkspaceRoot(candidate))
                     roots.add(candidate);
             }
         }
-        return [...roots]
+        return Promise.all([...roots]
             .sort((a, b) => a.localeCompare(b))
-            .map((root) => ({ root }));
+            .map(async (root) => {
+            const fs = await WorkspaceFs.create(root);
+            return {
+                root,
+                name: path.basename(root),
+                summary: await readSummary(fs),
+            };
+        }));
     }
     async resolve(input) {
         if (typeof input !== "string" || !input.trim())
@@ -52,22 +62,74 @@ export class WorkspaceService {
         });
         if (!(await stat(canonical)).isDirectory())
             throw new ChatRoomError("INVALID_INPUT", `Workspace root is not a directory: ${input}`);
-        if (!this.allowedRoots.some((root) => inside(root, canonical)))
-            throw new ChatRoomError("FORBIDDEN", "Workspace is outside configured allowedRoots", { root: canonical });
+        if (!this.isWorkspaceRoot(canonical))
+            throw new ChatRoomError("FORBIDDEN", "Workspace must be a direct child of a configured allowed root", { root: canonical });
         return canonical;
     }
+    async createProject(parentInput, nameInput) {
+        const parent = await this.resolveAllowedRoot(parentInput);
+        const name = validateProjectName(nameInput);
+        const target = path.join(parent, name);
+        try {
+            await mkdir(target, { recursive: false });
+        }
+        catch (error) {
+            if (error.code === "EEXIST")
+                throw new ChatRoomError("CONFLICT", `Workspace already exists: ${target}`);
+            throw error;
+        }
+        await mkdir(path.join(target, ".chatroom"));
+        const root = await realpath(target);
+        return { root, name: path.basename(root), summary: null };
+    }
     async info(input) {
         const root = await this.resolve(input);
         const fs = await WorkspaceFs.create(root);
-        const [instructions, skills] = await Promise.all([
+        const [summary, presetPrompt, instructions, skills] = await Promise.all([
+            readSummary(fs),
+            readPresetPrompt(fs),
             readInstructions(fs),
             readSkills(fs),
         ]);
-        return { root, instructions, skills };
+        return {
+            root,
+            name: path.basename(root),
+            summary,
+            presetPrompt,
+            instructions,
+            skills,
+        };
     }
     async fs(input) {
         return WorkspaceFs.create(await this.resolve(input));
     }
+    isWorkspaceRoot(candidate) {
+        return this.allowedRoots.some((root) => path.dirname(candidate) === root);
+    }
+    async resolveAllowedRoot(input) {
+        if (typeof input !== "string" || !input.trim())
+            throw new ChatRoomError("INVALID_INPUT", "Allowed root is required");
+        const canonical = await realpath(expandHome(input)).catch(() => {
+            throw new ChatRoomError("NOT_FOUND", `Allowed root does not exist: ${input}`);
+        });
+        if (!this.allowedRoots.includes(canonical))
+            throw new ChatRoomError("FORBIDDEN", "Project can only be created directly under a configured allowed root");
+        return canonical;
+    }
+}
+function validateProjectName(input) {
+    if (typeof input !== "string")
+        throw new ChatRoomError("INVALID_INPUT", "Project name is required");
+    const name = input.trim();
+    if (!name ||
+        name === "." ||
+        name === ".." ||
+        name.startsWith(".") ||
+        name.includes("/") ||
+        name.includes("\\") ||
+        name.includes("\0"))
+        throw new ChatRoomError("INVALID_INPUT", "Invalid project name");
+    return name;
 }
 function expandHome(input) {
     if (input === "~")
@@ -76,10 +138,3 @@ function expandHome(input) {
         return path.join(os.homedir(), input.slice(2));
     return path.resolve(input);
 }
-function inside(root, candidate) {
-    const relative = path.relative(root, candidate);
-    return (relative === "" ||
-        (!relative.startsWith(`..${path.sep}`) &&
-            relative !== ".." &&
-            !path.isAbsolute(relative)));
-}