@chatroomcp/chatroom 0.2.2 → 0.2.5

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)));
-}