@chatroomcp/chatroom 0.2.1 → 0.2.3

package/dist/plugins/workspace/plugin.js

@@ -1,34 +1,22 @@
-import { CommandRunner } from "../../core/runtime/command-runner.js";
 import { createServiceToken } from "../types.js";
-import { GitCommandRunner } from "./git/git-command-runner.js";
-import { GitService } from "./git/git-service.js";
-import { GitSnapshotService } from "./git/git-snapshot-service.js";
-import { WorkspaceRepository } from "./infrastructure/workspace-repository.js";
 import { registerWorkspaceTools } from "./mcp.js";
-import { WorkspaceService as WorkspaceRuntime } from "./workspace-service.js";
-import { WorktreeReviewService } from "./worktree-review-service.js";
-export const WorkspaceService = createServiceToken("workspace");
+import { WorkspaceService } from "./workspace-service.js";
+export const WorkspaceServiceToken = createServiceToken("workspace");
 export function createWorkspacePlugin() {
-    let value = null;
+    let service = null;
     return {
         id: "workspace",
         async activate(context) {
-            const gitRunner = new GitCommandRunner(new CommandRunner());
-            const git = new GitService(gitRunner);
-            const snapshots = new GitSnapshotService(gitRunner, git);
-            const review = new WorktreeReviewService(git, snapshots);
-            const workspaces = await WorkspaceRuntime.create(new WorkspaceRepository(context.database), git, review, context.config.allowedRoots, context.config.dataDir);
-            await workspaces.discoverGitWorkspaces();
-            value = { workspaces, git };
-            context.services.provide(WorkspaceService, value);
+            service = await WorkspaceService.create(context.config.allowedRoots);
+            context.services.provide(WorkspaceServiceToken, service);
         },
         registerMcp(mcp) {
-            if (!value)
+            if (!service)
                 throw new Error("Workspace plugin is not active");
-            registerWorkspaceTools(mcp, value.workspaces);
+            registerWorkspaceTools(mcp, service);
         },
         deactivate() {
-            value = null;
+            service = null;
         },
     };
 }

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

@@ -0,0 +1,23 @@
+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;
+}

package/dist/plugins/workspace/{infrastructure/workspace-fs.d.ts → workspace-fs.d.ts}

@@ -1,7 +1,6 @@
-import type { ChangeSet, FileInfo, PatchReplacement, SearchMatch } from "../domain/filesystem.js";
+import type { WorkspaceFile } from "./types.js";
 export declare class WorkspaceFs {
     readonly root: string;
-    private readonly realRoot;
     private constructor();
     static create(root: string): Promise<WorkspaceFs>;
     read(relativePath: string, options?: {
@@ -18,21 +17,12 @@ export declare class WorkspaceFs {
         bytes: number;
         truncated: boolean;
     }>;
-    write(relativePath: string, content: string): Promise<{
-        path: string;
-        bytes: number;
-    }>;
+    write(relativePath: string, content: string): Promise<WorkspaceFile>;
     list(relativePath?: string, options?: {
         recursive?: boolean;
         maxEntries?: number;
-    }): Promise<FileInfo[]>;
-    search(query: string, options?: {
-        path?: string;
-        maxResults?: number;
-    }): Promise<SearchMatch[]>;
-    patch(replacements: PatchReplacement[]): Promise<ChangeSet>;
-    private normalizeRelative;
+    }): Promise<WorkspaceFile[]>;
     private lexical;
-    private resolveReadable;
     private resolveWritable;
+    private resolveReadable;
 }

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

@@ -0,0 +1,200 @@
+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 {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    static async create(root) {
+        const canonical = await realpath(path.resolve(root)).catch(() => {
+            throw new ChatRoomError("NOT_FOUND", `Workspace root does not exist: ${root}`);
+        });
+        const info = await stat(canonical);
+        if (!info.isDirectory())
+            throw new ChatRoomError("INVALID_INPUT", `Workspace root is not a directory: ${root}`);
+        return new WorkspaceFs(canonical);
+    }
+    async read(relativePath, options = {}) {
+        const result = await this.readBytes(relativePath, options);
+        return {
+            content: result.data.toString("utf8"),
+            bytes: result.bytes,
+            truncated: result.truncated,
+        };
+    }
+    async readBytes(relativePath, options = {}) {
+        const target = await this.resolveReadable(relativePath);
+        const info = await stat(target);
+        if (!info.isFile())
+            throw new ChatRoomError("INVALID_INPUT", `Not a file: ${relativePath}`);
+        const maxBytes = options.maxBytes ?? 1024 * 1024;
+        const handle = await open(target, "r");
+        try {
+            const readSize = Math.min(info.size, maxBytes);
+            const buffer = Buffer.alloc(readSize);
+            const result = await handle.read(buffer, 0, readSize, 0);
+            return {
+                data: buffer.subarray(0, result.bytesRead),
+                bytes: info.size,
+                truncated: info.size > maxBytes,
+            };
+        }
+        finally {
+            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())
+            throw new ChatRoomError("INVALID_INPUT", `Not a directory: ${relativePath}`);
+        const maxEntries = Math.min(options.maxEntries ?? 1000, 10000);
+        const output = [];
+        const walk = async (directory) => {
+            for (const entry of await readdir(directory, { withFileTypes: true })) {
+                if (output.length >= maxEntries)
+                    return;
+                const absolute = path.join(directory, entry.name);
+                const info = await lstat(absolute);
+                const type = info.isSymbolicLink()
+                    ? "symlink"
+                    : info.isDirectory()
+                        ? "directory"
+                        : "file";
+                output.push({
+                    path: path.relative(this.root, absolute).split(path.sep).join("/"),
+                    type,
+                    size: info.size,
+                });
+                if (options.recursive && entry.isDirectory() && !entry.isSymbolicLink())
+                    await walk(absolute);
+            }
+        };
+        await walk(start);
+        return output;
+    }
+    lexical(relativePath) {
+        const normalized = normalizeRelative(relativePath);
+        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}`);
+            throw error;
+        });
+        if (!inside(this.root, canonical))
+            throw new ChatRoomError("FORBIDDEN", "Symlink escapes workspace");
+        return canonical;
+    }
+}
+function normalizeRelative(input) {
+    if (typeof input !== "string" || input.includes("\0"))
+        throw new ChatRoomError("INVALID_INPUT", "Path must be a valid string");
+    if (path.isAbsolute(input) ||
+        path.win32.isAbsolute(input) ||
+        /^\\\\/.test(input))
+        throw new ChatRoomError("FORBIDDEN", "Absolute paths are not allowed");
+    const parts = input
+        .split(/[\\/]+/)
+        .filter((part) => part !== "" && part !== ".");
+    if (parts.some((part) => part === ".."))
+        throw new ChatRoomError("FORBIDDEN", "Path traversal is not allowed");
+    return parts.join("/") || ".";
+}
+function inside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return (relative === "" ||
+        (!relative.startsWith(`..${path.sep}`) &&
+            relative !== ".." &&
+            !path.isAbsolute(relative)));
+}

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

@@ -1,46 +1,15 @@
-import type { Workspace, WorkspaceMode } from "./domain/workspace.js";
-import type { WorkspaceStateRepository } from "./domain/repository.js";
-import { WorkspaceFs } from "./infrastructure/workspace-fs.js";
-import type { GitService } from "./git/git-service.js";
-import type { WorktreeReviewService } from "./worktree-review-service.js";
-interface OpenWorkspaceRequest {
-    path: string;
-    mode?: WorkspaceMode;
-}
+import type { WorkspaceEntry, WorkspaceInfo } from "./types.js";
+import { WorkspaceFs } from "./workspace-fs.js";
 export declare class WorkspaceService {
-    private readonly repository;
-    private readonly git;
-    private readonly review;
     private readonly allowedRoots;
-    private readonly dataDir;
-    private readonly pending;
-    private readonly filesystems;
-    private readonly workspaces;
     private constructor();
-    static create(repository: WorkspaceStateRepository, git: GitService, review: WorktreeReviewService, allowedRoots: string[], dataDir: string): Promise<WorkspaceService>;
-    open(request: OpenWorkspaceRequest): Promise<Workspace>;
-    get(workspaceId: string): Workspace;
-    list(): Workspace[];
-    discoverGitWorkspaces(): Promise<Workspace[]>;
-    private discoverGitWorkspace;
-    markUsed(workspaceId: string): Workspace;
-    fs(workspaceId: string): Promise<WorkspaceFs>;
-    refresh(workspaceId: string): Promise<Workspace>;
-    remove(workspaceId: string, force?: boolean): Promise<Workspace>;
-    previewWorktreeApply(workspaceId: string): Promise<import("./domain/review.js").WorktreeApplyPreview>;
-    previewWorktreeFileDiff(workspaceId: string, filePath: string): Promise<import("./domain/review.js").WorktreeFileDiff>;
-    applyWorktree(workspaceId: string, paths?: string[]): Promise<{
-        workspaceId: string;
-        bytes: number;
-        paths: string[];
-        conflicts: string[];
-    }>;
-    private openLocked;
-    private createWorkspace;
-    private restorePersistedWorkspaces;
-    private isRecordValid;
-    private reconcileManagedWorktrees;
-    private removeManagedContainer;
-    private validateSourceRoot;
+    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;
 }
-export {};