@zhanguym/chatroom 1.0.0

package/dist/plugins/web/runtime.js

@@ -0,0 +1,31 @@
+export class WebRuntime {
+    workspaces;
+    git;
+    operations;
+    processes;
+    computer;
+    mcpTools;
+    constructor(workspaces, git, operations, processes, computer, mcpTools) {
+        this.workspaces = workspaces;
+        this.git = git;
+        this.operations = operations;
+        this.processes = processes;
+        this.computer = computer;
+        this.mcpTools = mcpTools;
+    }
+    processKill(processId, force = false) {
+        return this.operations.run({
+            pluginId: "process",
+            source: "gui",
+            action: force ? "kill" : "terminate",
+            processId,
+            input: { processId, force },
+        }, async () => this.processes.kill(processId, force));
+    }
+    listProcesses() {
+        return this.processes.summaries();
+    }
+    getProcess(processId) {
+        return this.processes.read(processId);
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { PluginMcpRegistrar } from "#mcp/server/plugin-mcp-registrar";
+import type { WorkspaceService } from "./workspace-service.js";
+export declare function registerWorkspaceTools(mcp: PluginMcpRegistrar, workspaces: WorkspaceService): void;

package/dist/plugins/workspace/mcp.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { closedRead } from "#mcp/server/tool-support";
+const workspaceInfoSchema = z.object({
+    root: z.string(),
+    name: z.string(),
+    summary: z.string().nullable(),
+    presetPrompt: z.string().nullable(),
+    instructions: z.string().nullable(),
+    skills: z.array(z.object({
+        name: z.string(),
+        description: z.string(),
+        path: z.string(),
+    })),
+});
+export function registerWorkspaceTools(mcp, workspaces) {
+    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() }),
+        outputSchema: workspaceInfoSchema,
+        annotations: closedRead,
+        action: "info",
+    }, (input) => workspaces.info(input.root));
+}

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

@@ -0,0 +1,6 @@
+import type { WorkspaceFs } from "./workspace-fs.js";
+import type { WorkspaceSkill } from "./types.js";
+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>;
+export declare function readSkills(fs: WorkspaceFs): Promise<WorkspaceSkill[]>;

package/dist/plugins/workspace/metadata.js

@@ -0,0 +1,111 @@
+import path from "node:path";
+import { ChatRoomError } from "#core/errors/chatroom-error";
+const SKILL_ROOTS = [".agents/skills", ".claude/skills", ".chatroom/skills"];
+const MAX_METADATA_BYTES = 64 * 1024;
+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 entriesByRoot = await Promise.all(SKILL_ROOTS.map(async (root) => {
+        try {
+            return await fs.list(root, { recursive: true, maxEntries: 2000 });
+        }
+        catch (error) {
+            if (error instanceof ChatRoomError && error.code === "NOT_FOUND")
+                return [];
+            throw error;
+        }
+    }));
+    const paths = entriesByRoot.flatMap((entries) => entries
+        .filter((entry) => entry.type === "file" && entry.path.endsWith("/SKILL.md"))
+        .map((entry) => entry.path));
+    return Promise.all([...new Set(paths)].sort().map(async (skillPath) => {
+        const fallbackName = path.posix.basename(path.posix.dirname(skillPath));
+        try {
+            const file = await fs.read(skillPath, { maxBytes: MAX_METADATA_BYTES });
+            const metadata = parseSkillFrontmatter(file.content);
+            return {
+                name: metadata.name || fallbackName,
+                description: metadata.description,
+                path: skillPath,
+            };
+        }
+        catch (error) {
+            if (!(error instanceof ChatRoomError) || error.code !== "NOT_FOUND")
+                throw error;
+            return { name: fallbackName, description: "", path: skillPath };
+        }
+    }));
+}
+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/, "")
+        .replaceAll("\r\n", "\n")
+        .split("\n");
+    if (lines[0]?.trim() !== "---")
+        return { name: "", description: "" };
+    const end = lines.findIndex((line, index) => index > 0 && ["---", "..."].includes(line.trim()));
+    if (end < 0)
+        return { name: "", description: "" };
+    const values = new Map();
+    for (let index = 1; index < end; index++) {
+        const match = /^([A-Za-z0-9_-]+):(?:\s*(.*))?$/.exec(lines[index] ?? "");
+        if (!match)
+            continue;
+        const key = match[1] ?? "";
+        if (key !== "name" && key !== "description")
+            continue;
+        const raw = match[2] ?? "";
+        if (/^[>|][+-]?\d?$/.test(raw.trim())) {
+            const block = [];
+            while (index + 1 < end) {
+                const next = lines[index + 1] ?? "";
+                if (next && !/^\s/.test(next))
+                    break;
+                index++;
+                block.push(next.replace(/^\s+/, ""));
+            }
+            values.set(key, raw.trim().startsWith(">")
+                ? block.join(" ").replace(/\s+/g, " ").trim()
+                : block.join("\n").trim());
+            continue;
+        }
+        values.set(key, parseYamlScalar(raw));
+    }
+    return {
+        name: values.get("name")?.trim() ?? "",
+        description: values.get("description")?.trim() ?? "",
+    };
+}
+function parseYamlScalar(value) {
+    const trimmed = value.trim();
+    if (trimmed.length >= 2 && trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return trimmed.slice(1, -1);
+        }
+    }
+    if (trimmed.length >= 2 && trimmed.startsWith("'") && trimmed.endsWith("'"))
+        return trimmed.slice(1, -1).replaceAll("''", "'");
+    return trimmed;
+}

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

@@ -0,0 +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 function createWorkspacePlugin(): InternalPlugin;

package/dist/plugins/workspace/plugin.js

@@ -0,0 +1,22 @@
+import { createServiceToken } from "#plugins/types";
+import { registerWorkspaceTools } from "./mcp.js";
+import { WorkspaceService } from "./workspace-service.js";
+export const WorkspaceServiceToken = createServiceToken("workspace");
+export function createWorkspacePlugin() {
+    let service = null;
+    return {
+        id: "workspace",
+        async activate(context) {
+            service = await WorkspaceService.create(context.config.allowedRoots);
+            context.services.provide(WorkspaceServiceToken, service);
+        },
+        registerMcp(mcp) {
+            if (!service)
+                throw new Error("Workspace plugin is not active");
+            registerWorkspaceTools(mcp, service);
+        },
+        deactivate() {
+            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/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,28 @@
+import type { WorkspaceFile } from "./types.js";
+export declare class WorkspaceFs {
+    readonly root: string;
+    private constructor();
+    static create(root: string): Promise<WorkspaceFs>;
+    read(relativePath: string, options?: {
+        maxBytes?: number;
+    }): Promise<{
+        content: string;
+        bytes: number;
+        truncated: boolean;
+    }>;
+    readBytes(relativePath: string, options?: {
+        maxBytes?: number;
+    }): Promise<{
+        data: Buffer;
+        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

@@ -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";
+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

@@ -0,0 +1,15 @@
+import type { WorkspaceEntry, WorkspaceInfo } from "./types.js";
+import { WorkspaceFs } from "./workspace-fs.js";
+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

@@ -0,0 +1,140 @@
+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";
+import { readInstructions, readPresetPrompt, readSkills, readSummary, } from "./metadata.js";
+import { WorkspaceFs } from "./workspace-fs.js";
+export class WorkspaceService {
+    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 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(allowedRoot, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                if (!entry.isDirectory() ||
+                    entry.isSymbolicLink() ||
+                    entry.name.startsWith("."))
+                    continue;
+                const candidate = await realpath(path.join(allowedRoot, entry.name)).catch(() => null);
+                if (candidate && this.isWorkspaceRoot(candidate))
+                    roots.add(candidate);
+            }
+        }
+        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 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 [summary, presetPrompt, instructions, skills] = await Promise.all([
+            readSummary(fs),
+            readPresetPrompt(fs),
+            readInstructions(fs),
+            readSkills(fs),
+        ]);
+        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 === "~")
+        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

@@ -0,0 +1,9 @@
+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;
+export declare function requireString(value: unknown, name: string): string;
+export declare function boundedIntegerQuery(value: unknown, fallback: number, min: number, max: number): number;
+export declare function bodyRecord(value: unknown): Record<string, unknown>;
+export declare function requireStringArray(value: unknown, name: string): string[];
+export declare function parseCookie(header: string | undefined, name: string): string | null;
+export declare function escapeHtml(value: string): string;