@chatroomcp/chatroom 0.2.1 → 0.2.3

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

@@ -1,339 +1,140 @@
-/**
- * Owns persistent Workspace identity, allowed-root validation, checkout/worktree creation, and workspace capabilities.
- * Workspace lifetime is deliberately independent from MCP or HTTP connection lifetime.
- */
-import { existsSync, realpathSync } from "node:fs";
-import { mkdir, readdir, realpath, rm } from "node:fs/promises";
+import { mkdir, readdir, realpath, stat } from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
-import { randomUUID } from "node:crypto";
 import { ChatRoomError } from "../../core/errors/chatroom-error.js";
-import { WorkspaceFs } from "./infrastructure/workspace-fs.js";
-import { discoverInstructions, discoverSkills, exists, expandHome, inside, toRecord, } from "./workspace-helpers.js";
+import { readInstructions, readPresetPrompt, readSkills, readSummary, } from "./metadata.js";
+import { WorkspaceFs } from "./workspace-fs.js";
 export class WorkspaceService {
-    repository;
-    git;
-    review;
     allowedRoots;
-    dataDir;
-    pending = new Map();
-    filesystems = new Map();
-    workspaces = new Map();
-    constructor(repository, git, review, allowedRoots, dataDir) {
-        this.repository = repository;
-        this.git = git;
-        this.review = review;
+    constructor(allowedRoots) {
         this.allowedRoots = allowedRoots;
-        this.dataDir = dataDir;
     }
-    static async create(repository, git, review, allowedRoots, dataDir) {
-        // Canonicalize allowed roots once at startup so later comparisons use stable real paths.
-        const canonicalRoots = [];
-        for (const root of allowedRoots) {
-            const expanded = expandHome(root);
-            const canonical = await realpath(expanded).catch(() => {
+    static async create(allowedRoots) {
+        const canonicalRoots = await Promise.all(allowedRoots.map(async (root) => {
+            const canonical = await realpath(expandHome(root)).catch(() => {
                 throw new ChatRoomError("NOT_FOUND", `Allowed root does not exist: ${root}`);
             });
-            canonicalRoots.push(canonical);
-        }
-        await mkdir(path.join(dataDir, "worktrees"), {
-            recursive: true,
-            mode: 0o700,
-        });
-        const service = new WorkspaceService(repository, git, review, canonicalRoots, dataDir);
-        await service.restorePersistedWorkspaces();
-        await service.reconcileManagedWorktrees();
-        return service;
-    }
-    async open(request) {
-        const mode = request.mode ?? "checkout";
-        const sourceRoot = await this.validateSourceRoot(request.path);
-        if (mode === "worktree")
-            return this.openLocked(sourceRoot, mode);
-        const key = `checkout:${sourceRoot}`;
-        // Coalesce concurrent opens of the same logical workspace instead of racing worktree creation or persistence.
-        const existingPending = this.pending.get(key);
-        if (existingPending)
-            return existingPending;
-        const operation = this.openLocked(sourceRoot, mode).finally(() => this.pending.delete(key));
-        this.pending.set(key, operation);
-        return operation;
-    }
-    get(workspaceId) {
-        const workspace = this.workspaces.get(workspaceId);
-        if (!workspace)
-            throw new ChatRoomError("NOT_FOUND", `Unknown WorkspaceId: ${workspaceId}`);
-        if (!this.isRecordValid(workspace)) {
-            this.filesystems.delete(workspace.id);
-            this.workspaces.delete(workspace.id);
-            this.repository.remove(workspace.id);
-            throw new ChatRoomError("NOT_FOUND", `Workspace no longer exists: ${workspaceId}`);
-        }
-        return workspace;
-    }
-    list() {
-        const valid = [];
-        for (const workspace of this.workspaces.values()) {
-            if (this.isRecordValid(workspace)) {
-                valid.push(workspace);
-                continue;
-            }
-            this.filesystems.delete(workspace.id);
-            this.workspaces.delete(workspace.id);
-            this.repository.remove(workspace.id);
-        }
-        return valid.sort((a, b) => b.lastUsedAt.localeCompare(a.lastUsedAt));
-    }
-    async discoverGitWorkspaces() {
-        for (const root of this.allowedRoots) {
-            await this.discoverGitWorkspace(root);
+            if (!(await stat(canonical)).isDirectory())
+                throw new ChatRoomError("INVALID_INPUT", `Allowed root is not a directory: ${root}`);
+            return canonical;
+        }));
+        return new WorkspaceService([...new Set(canonicalRoots)]);
+    }
+    roots() {
+        return [...this.allowedRoots];
+    }
+    async list() {
+        const roots = new Set();
+        for (const allowedRoot of this.allowedRoots) {
             let entries;
             try {
-                entries = await readdir(root, { withFileTypes: true });
+                entries = await readdir(allowedRoot, { withFileTypes: true });
             }
             catch {
                 continue;
             }
             for (const entry of entries) {
-                if (!entry.isDirectory() || entry.isSymbolicLink())
+                if (!entry.isDirectory() ||
+                    entry.isSymbolicLink() ||
+                    entry.name.startsWith("."))
                     continue;
-                await this.discoverGitWorkspace(path.join(root, entry.name));
+                const candidate = await realpath(path.join(allowedRoot, entry.name)).catch(() => null);
+                if (candidate && this.isWorkspaceRoot(candidate))
+                    roots.add(candidate);
             }
         }
-        return this.list();
-    }
-    async discoverGitWorkspace(candidate) {
-        if (!(await exists(path.join(candidate, ".git"))))
-            return;
-        const existing = [...this.workspaces.values()].find((workspace) => workspace.root === candidate && workspace.mode === "checkout");
-        if (existing && this.isRecordValid(existing))
-            return;
-        if (existing) {
-            this.workspaces.delete(existing.id);
-            this.repository.remove(existing.id);
-        }
-        await this.createWorkspace(candidate, candidate, "checkout");
-    }
-    markUsed(workspaceId) {
-        const workspace = this.get(workspaceId);
-        workspace.lastUsedAt = new Date().toISOString();
-        this.repository.upsert(toRecord(workspace));
-        return workspace;
-    }
-    async fs(workspaceId) {
-        const workspace = this.markUsed(workspaceId);
-        const existing = this.filesystems.get(workspaceId);
-        if (existing)
-            return existing;
-        const filesystem = await WorkspaceFs.create(workspace.root);
-        this.filesystems.set(workspaceId, filesystem);
-        return filesystem;
-    }
-    async refresh(workspaceId) {
-        const workspace = this.get(workspaceId);
-        const fs = await this.fs(workspaceId);
-        const gitInfo = await this.git.info(workspace.root);
-        workspace.instructions = await discoverInstructions(fs);
-        workspace.skills = await discoverSkills(fs);
-        workspace.capabilities = {
-            filesystem: "read-write",
-            git: gitInfo.isRepository,
-            skills: workspace.skills.length > 0,
-        };
-        return workspace;
-    }
-    async remove(workspaceId, force = false) {
-        const workspace = this.get(workspaceId);
-        if (workspace.mode === "checkout") {
-            this.filesystems.delete(workspace.id);
-            this.workspaces.delete(workspace.id);
-            this.repository.remove(workspace.id);
-            return workspace;
-        }
-        const gitInfo = await this.git.info(workspace.root);
-        if (gitInfo.dirty && !force)
-            throw new ChatRoomError("CONFLICT", "Worktree contains uncommitted changes");
-        await this.git.removeWorktree(workspace.sourceRoot, workspace.root, force);
-        await this.git.pruneWorktrees(workspace.sourceRoot).catch(() => undefined);
-        this.filesystems.delete(workspace.id);
-        this.workspaces.delete(workspace.id);
-        this.repository.remove(workspace.id);
-        await this.removeManagedContainer(workspace.root);
-        return workspace;
-    }
-    async previewWorktreeApply(workspaceId) {
-        return this.review.preview(this.get(workspaceId));
-    }
-    async previewWorktreeFileDiff(workspaceId, filePath) {
-        return this.review.fileDiff(this.get(workspaceId), filePath);
-    }
-    async applyWorktree(workspaceId, paths) {
-        const workspace = this.get(workspaceId);
-        const result = await this.review.apply(workspace, paths);
-        this.markUsed(workspace.id);
-        return { workspaceId: workspace.id, ...result };
+        return Promise.all([...roots]
+            .sort((a, b) => a.localeCompare(b))
+            .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())
+            throw new ChatRoomError("INVALID_INPUT", "Workspace root is required");
+        const canonical = await realpath(expandHome(input)).catch(() => {
+            throw new ChatRoomError("NOT_FOUND", `Workspace root does not exist: ${input}`);
+        });
+        if (!(await stat(canonical)).isDirectory())
+            throw new ChatRoomError("INVALID_INPUT", `Workspace root is not a directory: ${input}`);
+        if (!this.isWorkspaceRoot(canonical))
+            throw new ChatRoomError("FORBIDDEN", "Workspace must be a direct child of a configured allowed root", { root: canonical });
+        return canonical;
     }
-    async openLocked(sourceRoot, mode) {
-        if (mode === "checkout") {
-            const existing = [...this.workspaces.values()].find((workspace) => workspace.root === sourceRoot && workspace.mode === "checkout");
-            if (existing) {
-                this.filesystems.set(existing.id, await WorkspaceFs.create(existing.root));
-                return this.refresh(existing.id);
-            }
-            return this.createWorkspace(sourceRoot, sourceRoot, mode);
-        }
-        const uuid = randomUUID();
-        const id = `ws_${uuid}`;
-        const container = path.join(this.dataDir, "worktrees", uuid.replaceAll("-", "").slice(0, 8));
-        const target = path.join(container, path.basename(sourceRoot) || "workspace");
-        await mkdir(container, { recursive: true, mode: 0o700 });
-        let worktreeCreated = false;
+    async createProject(parentInput, nameInput) {
+        const parent = await this.resolveAllowedRoot(parentInput);
+        const name = validateProjectName(nameInput);
+        const target = path.join(parent, name);
         try {
-            await this.git.createWorktree(sourceRoot, target);
-            worktreeCreated = true;
-            return await this.createWorkspace(target, sourceRoot, mode, id);
+            await mkdir(target, { recursive: false });
         }
         catch (error) {
-            this.filesystems.delete(id);
-            this.workspaces.delete(id);
-            this.repository.remove(id);
-            if (worktreeCreated)
-                await this.git
-                    .removeWorktree(sourceRoot, target, true)
-                    .catch(() => undefined);
-            await this.git.pruneWorktrees(sourceRoot).catch(() => undefined);
-            await rm(container, { recursive: true, force: true }).catch(() => undefined);
+            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 createWorkspace(root, sourceRoot, mode, id = `ws_${randomUUID()}`) {
+    async info(input) {
+        const root = await this.resolve(input);
         const fs = await WorkspaceFs.create(root);
-        this.filesystems.set(id, fs);
-        const gitInfo = await this.git.info(root);
-        const now = new Date().toISOString();
-        const skills = await discoverSkills(fs);
-        const workspace = {
-            id,
+        const [summary, presetPrompt, instructions, skills] = await Promise.all([
+            readSummary(fs),
+            readPresetPrompt(fs),
+            readInstructions(fs),
+            readSkills(fs),
+        ]);
+        return {
             root,
-            sourceRoot,
-            mode,
-            createdAt: now,
-            lastUsedAt: now,
-            instructions: await discoverInstructions(fs),
+            name: path.basename(root),
+            summary,
+            presetPrompt,
+            instructions,
             skills,
-            capabilities: {
-                filesystem: "read-write",
-                git: gitInfo.isRepository,
-                skills: skills.length > 0,
-            },
         };
-        this.workspaces.set(workspace.id, workspace);
-        this.repository.upsert(toRecord(workspace));
-        return workspace;
     }
-    async restorePersistedWorkspaces() {
-        for (const record of this.repository.list()) {
-            if (!this.isRecordValid(record)) {
-                this.repository.remove(record.id);
-                if (record.mode === "worktree")
-                    await this.removeManagedContainer(record.root);
-                continue;
-            }
-            try {
-                const fs = await WorkspaceFs.create(record.root);
-                const gitInfo = await this.git.info(record.root);
-                const skills = await discoverSkills(fs);
-                const workspace = {
-                    ...record,
-                    instructions: await discoverInstructions(fs),
-                    skills,
-                    capabilities: {
-                        filesystem: "read-write",
-                        git: gitInfo.isRepository,
-                        skills: skills.length > 0,
-                    },
-                };
-                this.filesystems.set(record.id, fs);
-                this.workspaces.set(record.id, workspace);
-            }
-            catch {
-                this.repository.remove(record.id);
-                if (record.mode === "worktree")
-                    await this.removeManagedContainer(record.root);
-            }
-        }
+    async fs(input) {
+        return WorkspaceFs.create(await this.resolve(input));
     }
-    isRecordValid(record) {
-        if (!existsSync(record.root) || !existsSync(record.sourceRoot))
-            return false;
-        try {
-            const sourceRoot = realpathSync(record.sourceRoot);
-            if (!this.allowedRoots.some((root) => inside(root, sourceRoot)))
-                return false;
-            if (record.mode === "checkout")
-                return realpathSync(record.root) === sourceRoot;
-            const managedRoot = realpathSync(path.join(this.dataDir, "worktrees"));
-            return inside(managedRoot, realpathSync(record.root));
-        }
-        catch {
-            return false;
-        }
+    isWorkspaceRoot(candidate) {
+        return this.allowedRoots.some((root) => path.dirname(candidate) === root);
     }
-    async reconcileManagedWorktrees() {
-        const pruned = new Set();
-        for (const workspace of [...this.workspaces.values()]) {
-            if (workspace.mode !== "worktree")
-                continue;
-            if (await exists(workspace.sourceRoot)) {
-                if (!pruned.has(workspace.sourceRoot)) {
-                    await this.git
-                        .pruneWorktrees(workspace.sourceRoot)
-                        .catch(() => undefined);
-                    pruned.add(workspace.sourceRoot);
-                }
-            }
-            if (await exists(workspace.root))
-                continue;
-            this.filesystems.delete(workspace.id);
-            this.workspaces.delete(workspace.id);
-            this.repository.remove(workspace.id);
-            await this.removeManagedContainer(workspace.root);
-        }
-        const managedRoot = path.join(this.dataDir, "worktrees");
-        const knownContainers = new Set([...this.workspaces.values()]
-            .filter((workspace) => workspace.mode === "worktree")
-            .map((workspace) => path.resolve(path.dirname(workspace.root))));
-        for (const entry of await readdir(managedRoot, { withFileTypes: true })) {
-            const container = path.resolve(managedRoot, entry.name);
-            if (knownContainers.has(container))
-                continue;
-            if (entry.isSymbolicLink()) {
-                await rm(container, { force: true }).catch(() => undefined);
-                continue;
-            }
-            if (entry.isDirectory())
-                await rm(container, { recursive: true, force: true });
-        }
-    }
-    async removeManagedContainer(worktreeRoot) {
-        const managedRoot = path.join(this.dataDir, "worktrees");
-        if (!inside(managedRoot, worktreeRoot))
-            return;
-        const container = path.dirname(worktreeRoot);
-        if (container === managedRoot)
-            return;
-        await rm(container, { recursive: true, force: true }).catch(() => undefined);
-    }
-    async validateSourceRoot(input) {
-        if (!input || typeof input !== "string")
-            throw new ChatRoomError("INVALID_INPUT", "Workspace path is required");
+    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", `Workspace path does not exist: ${input}`);
+            throw new ChatRoomError("NOT_FOUND", `Allowed root does not exist: ${input}`);
         });
-        if (!this.allowedRoots.some((root) => inside(root, canonical))) {
-            throw new ChatRoomError("FORBIDDEN", "Workspace is outside configured allowedRoots", {
-                path: canonical,
-            });
-        }
+        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 === "~")
+        return os.homedir();
+    if (input.startsWith("~/") || input.startsWith("~\\"))
+        return path.join(os.homedir(), input.slice(2));
+    return path.resolve(input);
+}

package/dist/presentation/http/http-utils.d.ts

@@ -1,4 +1,3 @@
-/** Shared Express helpers for async error propagation and typed ChatRoom error responses. */
 import type { Request, Response, NextFunction, RequestHandler } from "express";
 export declare function asyncRoute(handler: (req: Request, res: Response, next: NextFunction) => Promise<unknown>): RequestHandler;
 export declare function errorMiddleware(error: unknown, _req: Request, res: Response, _next: NextFunction): void;

package/dist/presentation/http/oauth-router.d.ts

@@ -1,4 +1,3 @@
-/** OAuth and owner-session HTTP routes backed by AuthService rather than protocol-specific persistence logic. */
 import { Router } from "express";
 import type { AuthService } from "../../auth/auth-service.js";
 import type { IngressPolicy } from "../../auth/ingress-policy.js";

package/dist/presentation/http/oauth-router.js

@@ -1,4 +1,3 @@
-/** OAuth and owner-session HTTP routes backed by AuthService rather than protocol-specific persistence logic. */
 import { Router } from "express";
 import { asChatRoomError, ChatRoomError, } from "../../core/errors/chatroom-error.js";
 import { escapeHtml, requireString } from "./http-utils.js";