@zhanguym/chatroom 1.2.0 → 1.3.2

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

@@ -10,6 +10,50 @@ export function createWorkspaceApiRouter(application) {
     router.get("/workspaces", asyncRoute(async (_req, res) => {
         res.json(await application.workspaces.list());
     }));
+    router.get("/workspaces/manage", asyncRoute(async (_req, res) => {
+        res.json(await application.workspaces.listAll());
+    }));
+    router.post("/workspaces/register", asyncRoute(async (req, res) => {
+        const body = bodyRecord(req.body);
+        const projectPath = requireString(body.path, "path");
+        const name = body.name === undefined || body.name === null
+            ? null
+            : requireString(body.name, "name");
+        res.json(await application.operations.run({
+            pluginId: "workspace",
+            source: "gui",
+            action: "register",
+            input: { path: projectPath, name },
+        }, () => application.workspaces.registerProject(projectPath, name)));
+    }));
+    router.patch("/workspaces/:workspaceId", asyncRoute(async (req, res) => {
+        const body = bodyRecord(req.body);
+        res.json(await application.workspaces.renameProject(requireString(req.params.workspaceId, "workspaceId"), requireString(body.name, "name")));
+    }));
+    router.delete("/workspaces/:workspaceId/cleanup", asyncRoute(async (req, res) => {
+        const workspaceId = requireString(req.params.workspaceId, "workspaceId");
+        const project = (await application.workspaces.listAll()).find((item) => item.id === workspaceId);
+        if (!project)
+            throw new ChatRoomError("NOT_FOUND", "Workspace not found");
+        if (project.status === "available")
+            throw new ChatRoomError("CONFLICT", "Available workspaces cannot be cleaned up");
+        const sessions = application.agents
+            .listSessions()
+            .filter((session) => session.workspaceId === workspaceId);
+        if (sessions.some((session) => session.status === "running" || session.status === "waiting_input"))
+            throw new ChatRoomError("CONFLICT", "Stop active Agent sessions before cleaning up this workspace");
+        for (const session of sessions)
+            await application.agents.deleteSession(session.id);
+        await application.workspaces.cleanupProject(workspaceId);
+        res.status(204).end();
+    }));
+    router.delete("/workspaces/:workspaceId", asyncRoute(async (req, res) => {
+        await application.workspaces.removeProject(requireString(req.params.workspaceId, "workspaceId"));
+        res.status(204).end();
+    }));
+    router.post("/workspaces/:workspaceId/restore", asyncRoute(async (req, res) => {
+        res.json(await application.workspaces.restoreProject(requireString(req.params.workspaceId, "workspaceId")));
+    }));
     router.post("/workspaces", asyncRoute(async (req, res) => {
         const body = bodyRecord(req.body);
         const parent = requireString(body.parent, "parent");
@@ -25,10 +69,10 @@ export function createWorkspaceApiRouter(application) {
         res.json(application.workspaces.roots());
     });
     router.get("/workspace", asyncRoute(async (req, res) => {
-        res.json(await application.workspaces.info(requireString(req.query.root, "root")));
+        res.json(await application.workspaces.info(requireString(req.query.workspaceId, "workspaceId")));
     }));
     router.get("/workspace/files", asyncRoute(async (req, res) => {
-        const fs = await application.workspaces.fs(requireString(req.query.root, "root"));
+        const fs = await application.workspaces.fs(requireString(req.query.workspaceId, "workspaceId"));
         const filePath = typeof req.query.path === "string" ? req.query.path : ".";
         const limit = boundedIntegerQuery(req.query.limit, 300, 1, 500);
         const offset = boundedIntegerQuery(req.query.offset, 0, 0, 100000);
@@ -44,7 +88,7 @@ export function createWorkspaceApiRouter(application) {
         });
     }));
     router.get("/workspace/project-files", asyncRoute(async (req, res) => {
-        res.json(await application.workspaces.projectFilesResult(requireString(req.query.root, "root")));
+        res.json(await application.workspaces.projectFilesResult(requireString(req.query.workspaceId, "workspaceId")));
     }));
     router.get("/workspace/file", asyncRoute(async (req, res) => {
         const fs = await requestWorkspaceFs(req, application);
@@ -54,7 +98,8 @@ export function createWorkspaceApiRouter(application) {
     }));
     router.put("/workspace/file", asyncRoute(async (req, res) => {
         const body = bodyRecord(req.body);
-        const fs = await application.workspaces.fs(requireString(body.root, "root"));
+        const workspaceId = requireString(body.workspaceId, "workspaceId");
+        const fs = await application.workspaces.fs(workspaceId);
         const filePath = requireString(body.path, "path");
         if (typeof body.content !== "string")
             throw new ChatRoomError("INVALID_INPUT", "content must be a string");
@@ -65,23 +110,31 @@ export function createWorkspaceApiRouter(application) {
             pluginId: "workspace",
             source: "gui",
             action: "file.write",
-            input: { root: fs.root, path: filePath, bytes },
+            input: { workspaceId, path: filePath, bytes },
         }, () => fs.write(filePath, body.content)));
     }));
     router.post("/workspace/attachment", express.raw({
         type: "application/octet-stream",
         limit: MAX_ATTACHMENT_BYTES,
     }), asyncRoute(async (req, res) => {
-        const root = requireString(req.query.root, "root");
+        const workspaceId = requireString(req.query.workspaceId, "workspaceId");
         const sessionId = requireString(req.query.sessionId, "sessionId");
         if (!/^[A-Za-z0-9_-]+$/.test(sessionId))
             throw new ChatRoomError("INVALID_INPUT", "Invalid attachment session id");
         const originalName = requireString(req.query.name, "name");
         if (!Buffer.isBuffer(req.body))
             throw new ChatRoomError("INVALID_INPUT", "Attachment body must be binary");
-        const fs = await application.workspaces.fs(root);
+        if (req.body.byteLength === 0)
+            throw new ChatRoomError("INVALID_INPUT", "Attachment is empty");
+        const expectedSize = req.headers["x-chatroom-upload-size"];
+        if (expectedSize !== undefined &&
+            (typeof expectedSize !== "string" ||
+                !/^\d+$/.test(expectedSize) ||
+                Number(expectedSize) !== req.body.byteLength))
+            throw new ChatRoomError("INVALID_INPUT", "Attachment size mismatch");
+        const fs = await application.workspaces.fs(workspaceId);
         const session = application.agents.getSession(sessionId);
-        if (session.workspaceRoot !== fs.root)
+        if (session.workspaceId !== workspaceId)
             throw new ChatRoomError("FORBIDDEN", "Agent session belongs to another workspace");
         const filePath = ".chatroom/agent-attachments/" +
             sessionId +
@@ -93,7 +146,7 @@ export function createWorkspaceApiRouter(application) {
             pluginId: "workspace",
             source: "gui",
             action: "attachment.upload",
-            input: { root: fs.root, path: filePath, bytes: req.body.byteLength },
+            input: { workspaceId, path: filePath, bytes: req.body.byteLength },
         }, () => fs.writeBytes(filePath, req.body));
         res.json({
             ...file,
@@ -152,9 +205,7 @@ 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"));
+    return application.workspaces.fs(requireString(req.query.workspaceId, "workspaceId"));
 }
 function imageMime(filePath) {
     switch (filePath.split(".").pop()?.toLowerCase()) {

package/dist/plugins/web/plugin.js

@@ -11,7 +11,7 @@ export function createWebPlugin() {
         id: "web",
         activate(context) {
             context.services.provide(WebServiceToken, {
-                application: new WebRuntime(context.services.require(WorkspaceServiceToken), context.services.require(GitAccessToken), context.operations, context.services.require(ProcessServiceToken), context.services.require(ComputerServiceToken), context.services.require(AgentServiceToken), context.mcpTools, context.customMcp),
+                application: new WebRuntime(context.services.require(WorkspaceServiceToken), context.services.require(GitAccessToken), context.operations, context.services.require(ProcessServiceToken), context.services.require(ComputerServiceToken), context.services.require(AgentServiceToken), context.mcpTools, context.customMcp, context.agentMcpTools, context.agentCustomMcp),
             });
         },
     };

package/dist/plugins/web/runtime.d.ts

@@ -15,7 +15,9 @@ export declare class WebRuntime {
     readonly agents: AgentRuntime;
     readonly mcpTools: McpToolControl;
     readonly customMcp: CustomMcpManager;
-    constructor(workspaces: WorkspaceService, git: GitAccess, operations: OperationLog, processes: ProcessSupervisor, computer: ComputerService, agents: AgentRuntime, mcpTools: McpToolControl, customMcp: CustomMcpManager);
+    readonly agentMcpTools: McpToolControl;
+    readonly agentCustomMcp: CustomMcpManager;
+    constructor(workspaces: WorkspaceService, git: GitAccess, operations: OperationLog, processes: ProcessSupervisor, computer: ComputerService, agents: AgentRuntime, mcpTools: McpToolControl, customMcp: CustomMcpManager, agentMcpTools: McpToolControl, agentCustomMcp: CustomMcpManager);
     processKill(processId: string, force?: boolean): Promise<import("./api-types.js").ProcessSnapshot>;
     listProcesses(): import("./api-types.js").ProcessSummary[];
     getProcess(processId: string): import("./api-types.js").ProcessSnapshot;

package/dist/plugins/web/runtime.js

@@ -7,7 +7,9 @@ export class WebRuntime {
     agents;
     mcpTools;
     customMcp;
-    constructor(workspaces, git, operations, processes, computer, agents, mcpTools, customMcp) {
+    agentMcpTools;
+    agentCustomMcp;
+    constructor(workspaces, git, operations, processes, computer, agents, mcpTools, customMcp, agentMcpTools, agentCustomMcp) {
         this.workspaces = workspaces;
         this.git = git;
         this.operations = operations;
@@ -16,6 +18,8 @@ export class WebRuntime {
         this.agents = agents;
         this.mcpTools = mcpTools;
         this.customMcp = customMcp;
+        this.agentMcpTools = agentMcpTools;
+        this.agentCustomMcp = agentCustomMcp;
     }
     processKill(processId, force = false) {
         return this.operations.run({

package/dist/plugins/workspace/mcp.js

@@ -3,17 +3,19 @@ import { ChatRoomError } from "#core/errors/chatroom-error";
 import { z } from "zod";
 import { closedRead } from "#mcp/server/tool-support";
 const workspaceEntrySchema = z.object({
-    root: z.string(),
+    id: z.string(),
+    path: z.string(),
     name: z.string(),
     summary: z.string().nullable(),
+    status: z.enum(["available", "missing", "restore_pending", "unregistered"]),
+    source: z.enum(["configured", "manual", "both", "history"]),
+    manuallyRegistered: z.boolean(),
+    discovered: z.boolean(),
 });
 const workspaceListSchema = z.object({
     workspaces: z.array(workspaceEntrySchema),
 });
-const workspaceInfoSchema = z.object({
-    root: z.string(),
-    name: z.string(),
-    summary: z.string().nullable(),
+const workspaceInfoSchema = workspaceEntrySchema.extend({
     presetPrompt: z.string().nullable(),
     instructions: z.string().nullable(),
     skills: z.array(z.object({
@@ -25,7 +27,7 @@ const workspaceInfoSchema = z.object({
 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.",
+        description: "List available projects with stable workspace IDs, display names, paths, and project summaries. Use the ID for all subsequent workspace operations; the path is informational and is not an identifier.",
         inputSchema: z.object({}),
         outputSchema: workspaceListSchema,
         annotations: closedRead,
@@ -33,27 +35,28 @@ export function registerWorkspaceTools(mcp, workspaces, webBaseUrl) {
     }, async () => ({ workspaces: await workspaces.list() }));
     mcp.registerTool("workspace_info", {
         title: "Workspace info",
-        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() }),
+        description: "Read the complete context for a project by workspace ID, including summary, preset prompt, project instructions, and skill metadata.",
+        inputSchema: z.object({ workspaceId: z.string().min(1) }),
         outputSchema: workspaceInfoSchema,
         annotations: closedRead,
         action: "info",
-    }, (input) => workspaces.info(input.root));
+    }, (input) => workspaces.info(input.workspaceId));
     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. " +
+        description: "Read a file from a project identified by workspaceId 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(),
+            workspaceId: z.string().min(1),
+            path: z.string().min(1),
             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({
+            workspaceId: z.string(),
             mode: z.enum(["content", "link"]),
             path: z.string(),
             name: z.string(),
@@ -69,7 +72,7 @@ export function registerWorkspaceTools(mcp, workspaces, webBaseUrl) {
         action: "file.get",
         audit: {
             input: (input) => ({
-                root: input.root,
+                workspaceId: input.workspaceId,
                 path: input.path,
                 mode: input.mode,
                 offset: input.mode === "content" ? input.offset : undefined,
@@ -85,7 +88,7 @@ export function registerWorkspaceTools(mcp, workspaces, webBaseUrl) {
             },
         },
     }, async (input) => {
-        const fs = await workspaces.fs(input.root);
+        const fs = await workspaces.fs(input.workspaceId);
         const name = path.posix.basename(input.path.replaceAll("\\", "/"));
         if (input.mode === "link") {
             const base = webBaseUrl();
@@ -93,9 +96,10 @@ export function registerWorkspaceTools(mcp, workspaces, webBaseUrl) {
                 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("workspaceId", input.workspaceId);
             url.searchParams.set("path", input.path);
             return {
+                workspaceId: input.workspaceId,
                 mode: "link",
                 path: input.path,
                 name,
@@ -134,6 +138,7 @@ export function registerWorkspaceTools(mcp, workspaces, webBaseUrl) {
         }
         const next = input.offset + consumed;
         return {
+            workspaceId: input.workspaceId,
             mode: "content",
             path: input.path,
             name,

package/dist/plugins/workspace/plugin.js

@@ -11,7 +11,7 @@ export function createWorkspacePlugin() {
         id: "workspace",
         async activate(context) {
             webBaseUrl = () => context.externalAccess.publicWebBaseUrl();
-            service = await WorkspaceService.create(context.config.allowedRoots, context.services.require(GitAccessToken));
+            service = await WorkspaceService.create(context.config.allowedRoots, context.services.require(GitAccessToken), context.database);
             context.services.provide(WorkspaceServiceToken, service);
             context.services.provide(WorkspaceAccessToken, service);
         },

package/dist/plugins/workspace/workspace-root-policy.d.ts

@@ -4,6 +4,5 @@ export declare class WorkspaceRootPolicy {
     static create(allowedRoots: string[]): Promise<WorkspaceRootPolicy>;
     roots(): string[];
     isWorkspaceRoot(candidate: string): boolean;
-    resolveWorkspace(input: string): Promise<string>;
     resolveAllowedRoot(input: string): Promise<string>;
 }

package/dist/plugins/workspace/workspace-root-policy.js

@@ -9,12 +9,28 @@ export class WorkspaceRootPolicy {
     }
     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}`);
-            });
-            if (!(await stat(canonical)).isDirectory())
-                throw new ChatRoomError("INVALID_INPUT", `Allowed root is not a directory: ${root}`);
-            return canonical;
+            let candidate = expandHome(root);
+            const missing = [];
+            while (true) {
+                let canonical;
+                try {
+                    canonical = await realpath(candidate);
+                }
+                catch (error) {
+                    const code = error.code;
+                    if (code !== "ENOENT" && code !== "ENOTDIR")
+                        throw new ChatRoomError("NOT_FOUND", "Allowed root cannot be resolved: " + root);
+                    const parent = path.dirname(candidate);
+                    if (parent === candidate)
+                        throw new ChatRoomError("NOT_FOUND", "Allowed root cannot be resolved: " + root);
+                    missing.push(path.basename(candidate));
+                    candidate = parent;
+                    continue;
+                }
+                if (!(await stat(canonical)).isDirectory())
+                    throw new ChatRoomError("INVALID_INPUT", "Allowed root is not a directory: " + root);
+                return path.join(canonical, ...missing.reverse());
+            }
         }));
         return new WorkspaceRootPolicy([...new Set(canonicalRoots)]);
     }
@@ -24,26 +40,16 @@ export class WorkspaceRootPolicy {
     isWorkspaceRoot(candidate) {
         return this.allowedRoots.some((root) => path.dirname(candidate) === root);
     }
-    async resolveWorkspace(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 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}`);
+            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");
+        if (!(await stat(canonical)).isDirectory())
+            throw new ChatRoomError("INVALID_INPUT", "Allowed root is not a directory: " + input);
         return canonical;
     }
 }

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

@@ -1,22 +1,34 @@
 import type { GitAccess } from "#app/git-access";
 import type { WorkspaceAccess, WorkspaceEntry, WorkspaceInfo } from "#app/workspace-access";
+import type { AppDatabase } from "#infrastructure/database/app-database";
 import { WorkspaceFs } from "./workspace-fs.js";
 export declare class WorkspaceService implements WorkspaceAccess {
     private readonly rootsPolicy;
     private readonly git;
+    private readonly repository;
     private constructor();
-    static create(allowedRoots: string[], git: Pick<GitAccess, "projectFiles">): Promise<WorkspaceService>;
+    static create(allowedRoots: string[], git: Pick<GitAccess, "projectFiles">, database: AppDatabase): Promise<WorkspaceService>;
     roots(): string[];
     list(): Promise<WorkspaceEntry[]>;
-    resolve(input: string): Promise<string>;
-    resolveAlias(alias: string): Promise<string>;
-    fsByAlias(alias: string): Promise<WorkspaceFs>;
+    listAll(): Promise<WorkspaceEntry[]>;
+    resolve(workspaceId: string): Promise<string>;
+    registerProject(pathInput: string, nameInput?: string | null): Promise<WorkspaceEntry>;
+    renameProject(workspaceId: string, nameInput: string): Promise<WorkspaceEntry>;
+    removeProject(workspaceId: string): Promise<void>;
+    cleanupProject(workspaceId: string): Promise<void>;
+    restoreProject(workspaceId: string): Promise<WorkspaceEntry>;
     createProject(parentInput: string, nameInput: string): Promise<WorkspaceEntry>;
-    projectFiles(input: string, maxFiles?: number): Promise<string[]>;
-    projectFilesResult(input: string, maxFiles?: number): Promise<{
+    projectFiles(workspaceId: string, maxFiles?: number): Promise<string[]>;
+    projectFilesResult(workspaceId: string, maxFiles?: number): Promise<{
         paths: string[];
         truncated: boolean;
     }>;
-    info(input: string): Promise<WorkspaceInfo>;
-    fs(input: string): Promise<WorkspaceFs>;
+    info(workspaceId: string): Promise<WorkspaceInfo>;
+    fs(workspaceId: string): Promise<WorkspaceFs>;
+    private refreshDiscovery;
+    private refreshWorkspaceStatuses;
+    private entries;
+    private toEntry;
+    private entry;
+    private requireRecord;
 }