@zhanguym/chatroom 1.0.0 → 1.1.0-beta.0

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

@@ -3,6 +3,6 @@ import { WebRuntime } from "./runtime.js";
 interface WebPluginService {
     application: WebRuntime;
 }
-export declare const WebServiceToken: import("#plugins/types").ServiceToken<WebPluginService>;
+export declare const WebServiceToken: import("#app/service-registry").ServiceToken<WebPluginService>;
 export declare function createWebPlugin(): InternalPlugin;
 export {};

package/dist/plugins/web/plugin.js

@@ -1,8 +1,9 @@
-import { createServiceToken } from "#plugins/types";
+import { createServiceToken } from "#app/service-registry";
 import { ComputerServiceToken } from "#plugins/computer/plugin";
-import { GitServiceToken } from "#plugins/git/plugin";
-import { ProcessService } from "#plugins/process/plugin";
+import { GitAccessToken } from "#app/git-access";
+import { ProcessServiceToken } from "#plugins/process/plugin";
 import { WorkspaceServiceToken } from "#plugins/workspace/plugin";
+import { AgentServiceToken } from "#plugins/agent/plugin";
 import { WebRuntime } from "./runtime.js";
 export const WebServiceToken = createServiceToken("web");
 export function createWebPlugin() {
@@ -10,7 +11,7 @@ export function createWebPlugin() {
         id: "web",
         activate(context) {
             context.services.provide(WebServiceToken, {
-                application: new WebRuntime(context.services.require(WorkspaceServiceToken), context.services.require(GitServiceToken), context.operations, context.services.require(ProcessService), context.services.require(ComputerServiceToken), context.mcpTools),
+                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),
             });
         },
     };

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

@@ -1,18 +1,21 @@
 import type { OperationLog } from "#operations/operation-log";
 import type { ComputerService } from "#plugins/computer/computer-service";
-import type { GitService } from "#plugins/git/git-service";
+import type { GitAccess } from "#app/git-access";
 import type { ProcessSupervisor } from "#plugins/process/process-supervisor";
 import type { WorkspaceService } from "#plugins/workspace/workspace-service";
+import type { AgentRuntime } from "#plugins/agent/runtime";
 import type { McpToolControl } from "#mcp/server/tool-control";
 export declare class WebRuntime {
     readonly workspaces: WorkspaceService;
-    readonly git: GitService;
+    readonly git: GitAccess;
     readonly operations: OperationLog;
     readonly processes: ProcessSupervisor;
     readonly computer: ComputerService;
+    readonly agents: AgentRuntime;
     readonly mcpTools: McpToolControl;
-    constructor(workspaces: WorkspaceService, git: GitService, operations: OperationLog, processes: ProcessSupervisor, computer: ComputerService, mcpTools: McpToolControl);
+    constructor(workspaces: WorkspaceService, git: GitAccess, operations: OperationLog, processes: ProcessSupervisor, computer: ComputerService, agents: AgentRuntime, mcpTools: McpToolControl);
     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;
+    getProcessSummary(processId: string): import("./api-types.js").ProcessSummary;
 }

package/dist/plugins/web/runtime.js

@@ -4,13 +4,15 @@ export class WebRuntime {
     operations;
     processes;
     computer;
+    agents;
     mcpTools;
-    constructor(workspaces, git, operations, processes, computer, mcpTools) {
+    constructor(workspaces, git, operations, processes, computer, agents, mcpTools) {
         this.workspaces = workspaces;
         this.git = git;
         this.operations = operations;
         this.processes = processes;
         this.computer = computer;
+        this.agents = agents;
         this.mcpTools = mcpTools;
     }
     processKill(processId, force = false) {
@@ -28,4 +30,7 @@ export class WebRuntime {
     getProcess(processId) {
         return this.processes.read(processId);
     }
+    getProcessSummary(processId) {
+        return this.processes.summary(processId);
+    }
 }

package/dist/plugins/workspace/mcp.js

@@ -1,5 +1,13 @@
 import { z } from "zod";
 import { closedRead } from "#mcp/server/tool-support";
+const workspaceEntrySchema = z.object({
+    root: z.string(),
+    name: z.string(),
+    summary: z.string().nullable(),
+});
+const workspaceListSchema = z.object({
+    workspaces: z.array(workspaceEntrySchema),
+});
 const workspaceInfoSchema = z.object({
     root: z.string(),
     name: z.string(),
@@ -13,6 +21,14 @@ const workspaceInfoSchema = z.object({
     })),
 });
 export function registerWorkspaceTools(mcp, workspaces) {
+    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.",
+        inputSchema: z.object({}),
+        outputSchema: workspaceListSchema,
+        annotations: closedRead,
+        action: "list",
+    }, 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.",

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

@@ -1,5 +1,5 @@
 import type { WorkspaceFs } from "./workspace-fs.js";
-import type { WorkspaceSkill } from "./types.js";
+import type { WorkspaceSkill } from "#app/workspace-access";
 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>;

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

@@ -1,4 +1,4 @@
 import type { InternalPlugin } from "#plugins/types";
 import { WorkspaceService } from "./workspace-service.js";
-export declare const WorkspaceServiceToken: import("#plugins/types").ServiceToken<WorkspaceService>;
+export declare const WorkspaceServiceToken: import("#app/service-registry").ServiceToken<WorkspaceService>;
 export declare function createWorkspacePlugin(): InternalPlugin;

package/dist/plugins/workspace/plugin.js

@@ -1,4 +1,6 @@
-import { createServiceToken } from "#plugins/types";
+import { GitAccessToken } from "#app/git-access";
+import { WorkspaceAccessToken } from "#app/workspace-access";
+import { createServiceToken } from "#app/service-registry";
 import { registerWorkspaceTools } from "./mcp.js";
 import { WorkspaceService } from "./workspace-service.js";
 export const WorkspaceServiceToken = createServiceToken("workspace");
@@ -7,8 +9,9 @@ export function createWorkspacePlugin() {
     return {
         id: "workspace",
         async activate(context) {
-            service = await WorkspaceService.create(context.config.allowedRoots);
+            service = await WorkspaceService.create(context.config.allowedRoots, context.services.require(GitAccessToken));
             context.services.provide(WorkspaceServiceToken, service);
+            context.services.provide(WorkspaceAccessToken, service);
         },
         registerMcp(mcp) {
             if (!service)

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

@@ -1,23 +1,6 @@
-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;
+    modifiedAt?: string;
 }

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

@@ -3,12 +3,17 @@ export declare class WorkspaceFs {
     readonly root: string;
     private constructor();
     static create(root: string): Promise<WorkspaceFs>;
+    fileInfo(relativePath: string): Promise<{
+        bytes: number;
+        modifiedAt: string;
+    }>;
     read(relativePath: string, options?: {
         maxBytes?: number;
     }): Promise<{
         content: string;
         bytes: number;
         truncated: boolean;
+        modifiedAt: string;
     }>;
     readBytes(relativePath: string, options?: {
         maxBytes?: number;
@@ -16,13 +21,14 @@ export declare class WorkspaceFs {
         data: Buffer;
         bytes: number;
         truncated: boolean;
+        modifiedAt: string;
     }>;
     write(relativePath: string, content: string): Promise<WorkspaceFile>;
+    writeBytes(relativePath: string, content: Uint8Array): Promise<WorkspaceFile>;
     list(relativePath?: string, options?: {
         recursive?: boolean;
         maxEntries?: number;
+        excludeDirectoryNames?: readonly string[];
+        offset?: number;
     }): Promise<WorkspaceFile[]>;
-    private lexical;
-    private resolveWritable;
-    private resolveReadable;
 }

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

@@ -1,7 +1,7 @@
-import { randomUUID } from "node:crypto";
-import { lstat, mkdir, open, readdir, realpath, rename, rm, stat, writeFile, } from "node:fs/promises";
+import { lstat, open, readdir, realpath, stat } from "node:fs/promises";
 import path from "node:path";
 import { ChatRoomError } from "#core/errors/chatroom-error";
+import { normalizeRelativePath, resolveReadableWithin, resolveWritableWithin, writeBytesAtomicWithin, } from "#core/fs/safe-directory";
 export class WorkspaceFs {
     root;
     constructor(root) {
@@ -16,42 +16,65 @@ export class WorkspaceFs {
             throw new ChatRoomError("INVALID_INPUT", `Workspace root is not a directory: ${root}`);
         return new WorkspaceFs(canonical);
     }
+    async fileInfo(relativePath) {
+        const target = await resolveReadableWithin(this.root, relativePath);
+        const info = await stat(target);
+        if (!info.isFile())
+            throw new ChatRoomError("INVALID_INPUT", `Not a file: ${relativePath}`);
+        return { bytes: info.size, modifiedAt: info.mtime.toISOString() };
+    }
     async read(relativePath, options = {}) {
         const result = await this.readBytes(relativePath, options);
         return {
             content: result.data.toString("utf8"),
             bytes: result.bytes,
             truncated: result.truncated,
+            modifiedAt: result.modifiedAt,
         };
     }
     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 target = await resolveReadableWithin(this.root, 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();
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            const handle = await open(target, "r");
+            try {
+                const before = await handle.stat();
+                if (!before.isFile())
+                    throw new ChatRoomError("INVALID_INPUT", `Not a file: ${relativePath}`);
+                const readSize = Math.min(before.size, maxBytes);
+                const buffer = Buffer.alloc(readSize);
+                let bytesRead = 0;
+                while (bytesRead < readSize) {
+                    const result = await handle.read(buffer, bytesRead, readSize - bytesRead, bytesRead);
+                    if (result.bytesRead === 0)
+                        break;
+                    bytesRead += result.bytesRead;
+                }
+                const after = await handle.stat();
+                const stable = before.size === after.size &&
+                    before.mtimeMs === after.mtimeMs &&
+                    before.ctimeMs === after.ctimeMs;
+                if (stable)
+                    return {
+                        data: buffer.subarray(0, bytesRead),
+                        bytes: after.size,
+                        truncated: after.size > maxBytes,
+                        modifiedAt: after.mtime.toISOString(),
+                    };
+            }
+            finally {
+                await handle.close();
+            }
         }
+        throw new ChatRoomError("CONFLICT", `File changed while being read: ${relativePath}`);
     }
     async write(relativePath, content) {
         if (typeof content !== "string")
             throw new ChatRoomError("INVALID_INPUT", "File content must be a string");
-        const normalized = normalizeRelative(relativePath);
+        const normalized = normalizeRelativePath(relativePath);
         if (normalized === ".")
             throw new ChatRoomError("INVALID_INPUT", "File path is required");
-        const target = await this.resolveWritable(normalized);
+        const target = await resolveWritableWithin(this.root, normalized);
         let mode = 0o644;
         try {
             const info = await lstat(target);
@@ -65,34 +88,41 @@ export class WorkspaceFs {
             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);
-        }
+        await writeBytesAtomicWithin(this.root, normalized, Buffer.from(content, "utf8"), mode);
         return {
             path: normalized,
             type: "file",
             size: Buffer.byteLength(content, "utf8"),
         };
     }
+    async writeBytes(relativePath, content) {
+        const normalized = normalizeRelativePath(relativePath);
+        if (normalized === ".")
+            throw new ChatRoomError("INVALID_INPUT", "File path is required");
+        await writeBytesAtomicWithin(this.root, normalized, content);
+        return {
+            path: normalized,
+            type: "file",
+            size: content.byteLength,
+        };
+    }
     async list(relativePath = ".", options = {}) {
-        const start = await this.resolveReadable(relativePath);
+        const start = await resolveReadableWithin(this.root, relativePath);
         if (!(await stat(start)).isDirectory())
             throw new ChatRoomError("INVALID_INPUT", `Not a directory: ${relativePath}`);
         const maxEntries = Math.min(options.maxEntries ?? 1000, 10000);
+        const offset = Math.max(0, options.offset ?? 0);
+        const excluded = new Set(options.excludeDirectoryNames ?? []);
         const output = [];
+        let seen = 0;
         const walk = async (directory) => {
-            for (const entry of await readdir(directory, { withFileTypes: true })) {
+            const entries = await readdir(directory, { withFileTypes: true });
+            entries.sort((left, right) => left.name.localeCompare(right.name));
+            for (const entry of entries) {
                 if (output.length >= maxEntries)
                     return;
+                if (entry.isDirectory() && excluded.has(entry.name))
+                    continue;
                 const absolute = path.join(directory, entry.name);
                 const info = await lstat(absolute);
                 const type = info.isSymbolicLink()
@@ -100,11 +130,19 @@ export class WorkspaceFs {
                     : info.isDirectory()
                         ? "directory"
                         : "file";
-                output.push({
-                    path: path.relative(this.root, absolute).split(path.sep).join("/"),
-                    type,
-                    size: info.size,
-                });
+                const relative = path
+                    .relative(this.root, absolute)
+                    .split(path.sep)
+                    .join("/");
+                if (seen >= offset) {
+                    output.push({
+                        path: relative,
+                        type,
+                        size: info.size,
+                        modifiedAt: info.mtime.toISOString(),
+                    });
+                }
+                seen += 1;
                 if (options.recursive && entry.isDirectory() && !entry.isSymbolicLink())
                     await walk(absolute);
             }
@@ -112,89 +150,4 @@ export class WorkspaceFs {
         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-root-policy.d.ts

@@ -0,0 +1,9 @@
+export declare class WorkspaceRootPolicy {
+    private readonly allowedRoots;
+    private constructor();
+    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

@@ -0,0 +1,56 @@
+import { realpath, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { ChatRoomError } from "#core/errors/chatroom-error";
+export class WorkspaceRootPolicy {
+    allowedRoots;
+    constructor(allowedRoots) {
+        this.allowedRoots = allowedRoots;
+    }
+    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;
+        }));
+        return new WorkspaceRootPolicy([...new Set(canonicalRoots)]);
+    }
+    roots() {
+        return [...this.allowedRoots];
+    }
+    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}`);
+        });
+        if (!this.allowedRoots.includes(canonical))
+            throw new ChatRoomError("FORBIDDEN", "Project can only be created directly under a configured allowed root");
+        return canonical;
+    }
+}
+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/plugins/workspace/workspace-service.d.ts

@@ -1,15 +1,20 @@
-import type { WorkspaceEntry, WorkspaceInfo } from "./types.js";
+import type { GitAccess } from "#app/git-access";
+import type { WorkspaceAccess, WorkspaceEntry, WorkspaceInfo } from "#app/workspace-access";
 import { WorkspaceFs } from "./workspace-fs.js";
-export declare class WorkspaceService {
-    private readonly allowedRoots;
+export declare class WorkspaceService implements WorkspaceAccess {
+    private readonly rootsPolicy;
+    private readonly git;
     private constructor();
-    static create(allowedRoots: string[]): Promise<WorkspaceService>;
+    static create(allowedRoots: string[], git: Pick<GitAccess, "projectFiles">): Promise<WorkspaceService>;
     roots(): string[];
     list(): Promise<WorkspaceEntry[]>;
     resolve(input: string): Promise<string>;
     createProject(parentInput: string, nameInput: string): Promise<WorkspaceEntry>;
+    projectFiles(input: string, maxFiles?: number): Promise<string[]>;
+    projectFilesResult(input: string, maxFiles?: number): Promise<{
+        paths: string[];
+        truncated: boolean;
+    }>;
     info(input: string): Promise<WorkspaceInfo>;
     fs(input: string): Promise<WorkspaceFs>;
-    private isWorkspaceRoot;
-    private resolveAllowedRoot;
 }