@zhanguym/chatroom 1.0.0

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

@@ -0,0 +1,428 @@
+import { mkdtemp, open, rm, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { ChatRoomError } from "#core/errors/chatroom-error";
+const MAX_PATHS = 512;
+export class GitService {
+    commands;
+    constructor(commands) {
+        this.commands = commands;
+    }
+    async status(cwd) {
+        const root = await this.repositoryRoot(cwd);
+        if (!root)
+            return null;
+        const result = await this.run(root, [
+            "status",
+            "--porcelain=v2",
+            "--branch",
+            "-z",
+            "--untracked-files=all",
+        ]);
+        return parseStatus(result.stdout);
+    }
+    async diff(cwd, filePath, maxPreviewBytes = 2 * 1024 * 1024) {
+        const root = await this.requireRepository(cwd);
+        await this.requireHead(root);
+        const paths = filePath ? await this.relatedPaths(root, [filePath]) : [];
+        return this.withSnapshotIndex(root, async ({ env, tempDir }) => {
+            const patchPath = path.join(tempDir, "changes.patch");
+            await this.run(root, [
+                "diff",
+                "--cached",
+                "--binary",
+                "--no-ext-diff",
+                "--no-renames",
+                `--output=${patchPath}`,
+                "HEAD",
+                ...(paths.length ? ["--", ...paths] : []),
+            ], env);
+            return readPatch(patchPath, maxPreviewBytes);
+        });
+    }
+    async stage(cwd, paths) {
+        const root = await this.requireRepository(cwd);
+        await this.run(root, [
+            "add",
+            "-A",
+            "--",
+            ...(await this.relatedPaths(root, paths)),
+        ]);
+        return this.requireStatus(root);
+    }
+    async unstage(cwd, paths) {
+        const root = await this.requireRepository(cwd);
+        const expanded = await this.relatedPaths(root, paths);
+        if (await this.head(root))
+            await this.run(root, ["restore", "--staged", "--", ...expanded]);
+        else
+            await this.run(root, ["rm", "--cached", "-r", "--", ...expanded]);
+        return this.requireStatus(root);
+    }
+    async restore(cwd, filePath) {
+        const root = await this.requireRepository(cwd);
+        const requested = normalizePath(filePath);
+        const status = await this.requireStatus(root);
+        const change = status.changes.find((item) => item.path === requested || item.originalPath === requested);
+        if (!change)
+            throw new ChatRoomError("NOT_FOUND", `No Git change found for path: ${requested}`);
+        if (change.kind === "untracked") {
+            await this.run(root, ["clean", "-f", "--", change.path]);
+            return this.requireStatus(root);
+        }
+        await this.requireHead(root);
+        const paths = [
+            change.path,
+            ...(change.originalPath ? [change.originalPath] : []),
+        ];
+        const tracked = [];
+        const untracked = [];
+        for (const file of [...new Set(paths)]) {
+            if (await this.pathExistsInHead(root, file))
+                tracked.push(file);
+            else
+                untracked.push(file);
+        }
+        if (tracked.length)
+            await this.run(root, [
+                "restore",
+                "--source=HEAD",
+                "--staged",
+                "-W",
+                "--",
+                ...tracked,
+            ]);
+        if (untracked.length) {
+            await this.run(root, ["restore", "--staged", "--", ...untracked]).catch(() => undefined);
+            await this.run(root, ["clean", "-f", "--", ...untracked]);
+        }
+        return this.requireStatus(root);
+    }
+    async commit(cwd, message) {
+        const root = await this.requireRepository(cwd);
+        const normalized = message.trim();
+        if (!normalized)
+            throw new ChatRoomError("INVALID_INPUT", "Commit message is required");
+        if (normalized.length > 10_000)
+            throw new ChatRoomError("INVALID_INPUT", "Commit message is too long");
+        await this.run(root, ["commit", "-m", normalized]);
+        return this.requireStatus(root);
+    }
+    async branches(cwd) {
+        const root = await this.requireRepository(cwd);
+        const result = await this.run(root, [
+            "for-each-ref",
+            "--format=%(HEAD)%00%(refname:short)%00%(upstream:short)",
+            "refs/heads",
+        ]);
+        return result.stdout
+            .split(/\r?\n/)
+            .filter(Boolean)
+            .map((line) => {
+            const [head = "", name = "", upstream = ""] = line.split("\0");
+            return {
+                name,
+                current: head.trim() === "*",
+                upstream: upstream || null,
+            };
+        })
+            .filter((branch) => Boolean(branch.name));
+    }
+    async createBranch(cwd, name) {
+        const root = await this.requireRepository(cwd);
+        const branch = await this.validateBranchName(root, name);
+        await this.run(root, ["switch", "-c", branch]);
+        return this.requireStatus(root);
+    }
+    async switchBranch(cwd, name) {
+        const root = await this.requireRepository(cwd);
+        const branch = await this.validateBranchName(root, name);
+        await this.run(root, ["switch", branch]);
+        return this.requireStatus(root);
+    }
+    async deleteBranch(cwd, name) {
+        const root = await this.requireRepository(cwd);
+        const branch = await this.validateBranchName(root, name);
+        await this.run(root, ["branch", "-d", branch]);
+        return this.requireStatus(root);
+    }
+    async log(cwd, limit = 30) {
+        const root = await this.requireRepository(cwd);
+        if (!(await this.head(root)))
+            return [];
+        const count = Math.min(Math.max(Math.trunc(limit), 1), 100);
+        const result = await this.run(root, [
+            "log",
+            `-n${count}`,
+            "--pretty=format:%H%x1f%h%x1f%an%x1f%aI%x1f%s%x1e",
+        ]);
+        return result.stdout
+            .split("\x1e")
+            .map((record) => record.trim())
+            .filter(Boolean)
+            .map((record) => {
+            const [hash = "", shortHash = "", author = "", date = "", subject = "",] = record.split("\x1f");
+            return { hash, shortHash, author, date, subject };
+        });
+    }
+    async fetch(cwd) {
+        const root = await this.requireRepository(cwd);
+        await this.run(root, ["fetch", "--all", "--prune"]);
+        return this.requireStatus(root);
+    }
+    async pull(cwd) {
+        const root = await this.requireRepository(cwd);
+        await this.run(root, ["pull", "--ff-only"]);
+        return this.requireStatus(root);
+    }
+    async push(cwd) {
+        const root = await this.requireRepository(cwd);
+        await this.run(root, ["push"]);
+        return this.requireStatus(root);
+    }
+    run(cwd, args, env) {
+        return this.commands.run({
+            cwd,
+            command: "git",
+            args,
+            timeoutMs: 120_000,
+            env: { LC_ALL: "C", LANG: "C", ...(env ?? {}) },
+        });
+    }
+    async repositoryRoot(cwd) {
+        try {
+            const root = path.resolve((await this.run(cwd, ["rev-parse", "--show-toplevel"])).stdout.trim());
+            return root === path.resolve(cwd) ? root : null;
+        }
+        catch (error) {
+            if (isNotRepositoryError(error))
+                return null;
+            throw error;
+        }
+    }
+    async requireRepository(cwd) {
+        const root = await this.repositoryRoot(cwd);
+        if (!root)
+            throw new ChatRoomError("INVALID_INPUT", "Workspace is not a Git repository");
+        return root;
+    }
+    async requireStatus(cwd) {
+        const status = await this.status(cwd);
+        if (!status)
+            throw new ChatRoomError("INVALID_INPUT", "Workspace is not a Git repository");
+        return status;
+    }
+    async head(cwd) {
+        try {
+            return ((await this.run(cwd, ["rev-parse", "--verify", "HEAD"])).stdout.trim() || null);
+        }
+        catch (error) {
+            if (isMissingHeadError(error))
+                return null;
+            throw error;
+        }
+    }
+    async requireHead(cwd) {
+        const head = await this.head(cwd);
+        if (!head)
+            throw new ChatRoomError("CONFLICT", "Git operation requires at least one commit");
+        return head;
+    }
+    async relatedPaths(cwd, paths) {
+        const normalized = normalizePaths(paths);
+        const status = await this.requireStatus(cwd);
+        const output = new Set(normalized);
+        for (const requested of normalized) {
+            const change = status.changes.find((item) => item.path === requested || item.originalPath === requested);
+            if (change?.path)
+                output.add(change.path);
+            if (change?.originalPath)
+                output.add(change.originalPath);
+        }
+        return [...output];
+    }
+    async pathExistsInHead(cwd, filePath) {
+        try {
+            await this.run(cwd, ["cat-file", "-e", `HEAD:${filePath}`]);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async validateBranchName(cwd, name) {
+        const normalized = name.trim();
+        if (!normalized)
+            throw new ChatRoomError("INVALID_INPUT", "Branch name is required");
+        await this.run(cwd, ["check-ref-format", "--branch", normalized]);
+        return normalized;
+    }
+    async withSnapshotIndex(cwd, useIndex) {
+        const tempDir = await mkdtemp(path.join(os.tmpdir(), "chatroom-git-"));
+        const env = { GIT_INDEX_FILE: path.join(tempDir, "index") };
+        try {
+            await this.run(cwd, ["read-tree", "HEAD"], env);
+            await this.run(cwd, ["add", "-A", "--", "."], env);
+            return await useIndex({ env, tempDir });
+        }
+        finally {
+            await rm(tempDir, { recursive: true, force: true }).catch(() => undefined);
+        }
+    }
+}
+function parseStatus(output) {
+    let branch = null;
+    let head = null;
+    let upstream = null;
+    let ahead = 0;
+    let behind = 0;
+    const changes = [];
+    const records = output.split("\0");
+    for (let index = 0; index < records.length; index += 1) {
+        const record = records[index];
+        if (!record)
+            continue;
+        if (record.startsWith("# branch.oid ")) {
+            const value = record.slice("# branch.oid ".length);
+            head = value === "(initial)" ? null : value || null;
+            continue;
+        }
+        if (record.startsWith("# branch.head ")) {
+            const value = record.slice("# branch.head ".length);
+            branch = value === "(detached)" ? null : value || null;
+            continue;
+        }
+        if (record.startsWith("# branch.upstream ")) {
+            upstream = record.slice("# branch.upstream ".length) || null;
+            continue;
+        }
+        if (record.startsWith("# branch.ab ")) {
+            const match = /^\+(\d+) -(\d+)$/.exec(record.slice("# branch.ab ".length));
+            if (match) {
+                ahead = Number(match[1]);
+                behind = Number(match[2]);
+            }
+            continue;
+        }
+        const type = record[0];
+        if (type === "?") {
+            changes.push({
+                path: record.slice(2),
+                originalPath: null,
+                indexStatus: "?",
+                workingTreeStatus: "?",
+                kind: "untracked",
+            });
+            continue;
+        }
+        if (type === "!")
+            continue;
+        const fields = record.split(" ");
+        if (type === "1" && fields.length >= 9) {
+            pushTrackedChange(changes, fields[1], fields.slice(8).join(" "), null);
+            continue;
+        }
+        if (type === "2" && fields.length >= 10) {
+            const originalPath = records[++index] || null;
+            pushTrackedChange(changes, fields[1], fields.slice(9).join(" "), originalPath);
+            continue;
+        }
+        if (type === "u" && fields.length >= 11) {
+            pushTrackedChange(changes, fields[1], fields.slice(10).join(" "), null);
+        }
+    }
+    return {
+        branch,
+        head,
+        upstream,
+        ahead,
+        behind,
+        changes: changes.sort((a, b) => a.path.localeCompare(b.path)),
+    };
+}
+function pushTrackedChange(changes, xy, filePath, originalPath) {
+    const indexStatus = normalizePorcelainStatus(xy[0]);
+    const workingTreeStatus = normalizePorcelainStatus(xy[1]);
+    changes.push({
+        path: filePath,
+        originalPath,
+        indexStatus,
+        workingTreeStatus,
+        kind: changeKind(indexStatus, workingTreeStatus),
+    });
+}
+function normalizePorcelainStatus(value) {
+    return !value || value === "." ? " " : value;
+}
+function changeKind(indexStatus, workingTreeStatus) {
+    const pair = `${indexStatus}${workingTreeStatus}`;
+    if (pair === "??")
+        return "untracked";
+    if (["DD", "AU", "UD", "UA", "DU", "AA", "UU"].includes(pair) ||
+        indexStatus === "U" ||
+        workingTreeStatus === "U")
+        return "conflicted";
+    if (pair.includes("R"))
+        return "renamed";
+    if (pair.includes("C"))
+        return "copied";
+    if (pair.includes("A"))
+        return "added";
+    if (pair.includes("D"))
+        return "deleted";
+    return "modified";
+}
+function normalizePaths(paths) {
+    if (!Array.isArray(paths) || paths.length < 1)
+        throw new ChatRoomError("INVALID_INPUT", "At least one file path is required");
+    if (paths.length > MAX_PATHS)
+        throw new ChatRoomError("INVALID_INPUT", "Too many file paths");
+    return [...new Set(paths.map(normalizePath))];
+}
+function normalizePath(input) {
+    if (typeof input !== "string" || !input || input.includes("\0"))
+        throw new ChatRoomError("INVALID_INPUT", "File path is required");
+    if (path.isAbsolute(input) ||
+        path.win32.isAbsolute(input) ||
+        /^\\\\/.test(input))
+        throw new ChatRoomError("FORBIDDEN", "Absolute Git paths are not allowed");
+    const parts = input
+        .split(/[\\/]+/)
+        .filter((part) => part !== "" && part !== ".");
+    if (parts.length === 0 || parts.some((part) => part === ".."))
+        throw new ChatRoomError("FORBIDDEN", "Invalid Git path");
+    return parts.join("/");
+}
+async function readPatch(patchPath, maxBytes) {
+    const size = (await stat(patchPath)).size;
+    const previewBytes = Math.min(size, maxBytes);
+    const handle = await open(patchPath, "r");
+    try {
+        const buffer = Buffer.alloc(previewBytes);
+        const { bytesRead } = await handle.read(buffer, 0, previewBytes, 0);
+        return {
+            diff: buffer.subarray(0, bytesRead).toString("utf8"),
+            truncated: size > previewBytes,
+        };
+    }
+    finally {
+        await handle.close();
+    }
+}
+function gitErrorText(error) {
+    if (!(error instanceof ChatRoomError))
+        return "";
+    const details = error.details;
+    return `${String(details?.stdout ?? "")}\n${String(details?.stderr ?? "")}`.toLowerCase();
+}
+function isNotRepositoryError(error) {
+    return gitErrorText(error).includes("not a git repository");
+}
+function isMissingHeadError(error) {
+    const text = gitErrorText(error);
+    return (text.includes("needed a single revision") ||
+        text.includes("unknown revision") ||
+        text.includes("bad revision") ||
+        text.includes("ambiguous argument 'head'") ||
+        text.includes("not a valid object name head"));
+}

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

@@ -0,0 +1,4 @@
+import type { InternalPlugin } from "#plugins/types";
+import { GitService } from "./git-service.js";
+export declare const GitServiceToken: import("#plugins/types").ServiceToken<GitService>;
+export declare function createGitPlugin(): InternalPlugin;

package/dist/plugins/git/plugin.js

@@ -0,0 +1,12 @@
+import { CommandRunner } from "#core/runtime/command-runner";
+import { createServiceToken } from "#plugins/types";
+import { GitService } from "./git-service.js";
+export const GitServiceToken = createServiceToken("git");
+export function createGitPlugin() {
+    return {
+        id: "git",
+        activate(context) {
+            context.services.provide(GitServiceToken, new GitService(new CommandRunner()));
+        },
+    };
+}

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

@@ -0,0 +1,32 @@
+export type GitChangeKind = "modified" | "added" | "deleted" | "renamed" | "copied" | "untracked" | "conflicted";
+export interface GitChange {
+    path: string;
+    originalPath: string | null;
+    indexStatus: string;
+    workingTreeStatus: string;
+    kind: GitChangeKind;
+}
+export interface GitStatus {
+    branch: string | null;
+    head: string | null;
+    upstream: string | null;
+    ahead: number;
+    behind: number;
+    changes: GitChange[];
+}
+export interface GitDiff {
+    diff: string;
+    truncated: boolean;
+}
+export interface GitBranch {
+    name: string;
+    current: boolean;
+    upstream: string | null;
+}
+export interface GitCommit {
+    hash: string;
+    shortHash: string;
+    author: string;
+    date: string;
+    subject: string;
+}

package/dist/plugins/git/types.js

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

package/dist/plugins/plugin-manager.d.ts

@@ -0,0 +1,11 @@
+import type { McpServer } from "@modelcontextprotocol/server";
+import type { InternalPlugin, PluginContext } from "./types.js";
+export declare class PluginManager {
+    private readonly context;
+    private readonly plugins;
+    private readonly active;
+    constructor(context: PluginContext, plugins: InternalPlugin[]);
+    start(): Promise<void>;
+    registerMcp(server: McpServer): void;
+    stop(): Promise<void>;
+}

package/dist/plugins/plugin-manager.js

@@ -0,0 +1,63 @@
+import { PluginMcpRegistrar } from "#mcp/server/plugin-mcp-registrar";
+export class PluginManager {
+    context;
+    plugins;
+    active = [];
+    constructor(context, plugins) {
+        this.context = context;
+        this.plugins = plugins;
+    }
+    async start() {
+        try {
+            for (const plugin of this.plugins) {
+                this.active.push(plugin);
+                try {
+                    await plugin.activate(this.context);
+                    this.context.logs.info("plugin", "plugin.activated", `Plugin activated: ${plugin.id}`, { pluginId: plugin.id });
+                }
+                catch (error) {
+                    this.context.logs.error("plugin", "plugin.activate_failed", `Plugin activation failed: ${plugin.id}`, { pluginId: plugin.id, error });
+                    throw error;
+                }
+            }
+            for (const plugin of this.active) {
+                if (!plugin.registerMcp)
+                    continue;
+                plugin.registerMcp(new PluginMcpRegistrar(null, this.context.operations, plugin.id, this.context.mcpTools));
+            }
+        }
+        catch (error) {
+            try {
+                await this.stop();
+            }
+            catch (cleanupError) {
+                throw new AggregateError([error, cleanupError], "Plugin startup failed and rollback encountered errors");
+            }
+            throw error;
+        }
+    }
+    registerMcp(server) {
+        for (const plugin of this.active) {
+            if (!plugin.registerMcp)
+                continue;
+            plugin.registerMcp(new PluginMcpRegistrar(server, this.context.operations, plugin.id, this.context.mcpTools));
+        }
+    }
+    async stop() {
+        const errors = [];
+        for (const plugin of [...this.active].reverse()) {
+            try {
+                await plugin.deactivate?.();
+            }
+            catch (error) {
+                this.context.logs.error("plugin", "plugin.deactivate_failed", `Plugin deactivation failed: ${plugin.id}`, { pluginId: plugin.id, error });
+                errors.push(error);
+            }
+        }
+        this.active.length = 0;
+        if (errors.length === 1)
+            throw errors[0];
+        if (errors.length > 1)
+            throw new AggregateError(errors, "Multiple plugins failed to stop");
+    }
+}

package/dist/plugins/process/backend.d.ts

@@ -0,0 +1,18 @@
+export interface BackendProcess {
+    readonly pid: number | null;
+    write(data: string): void;
+    kill(signal?: NodeJS.Signals): void;
+    onStdout(listener: (chunk: Buffer) => void): void;
+    onStderr(listener: (chunk: Buffer) => void): void;
+    onExit(listener: (exit: {
+        exitCode: number | null;
+        signal: string | null;
+    }) => void): void;
+}
+export interface ProcessBackend {
+    readonly kind: "pipe" | "pty";
+    start(command: string, args: string[], options: {
+        cwd: string;
+        env: NodeJS.ProcessEnv;
+    }): Promise<BackendProcess>;
+}

package/dist/plugins/process/backend.js

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

package/dist/plugins/process/head-tail-buffer.d.ts

@@ -0,0 +1,17 @@
+interface BufferSnapshot {
+    text: string;
+    bytesSeen: number;
+    outputTruncated: boolean;
+}
+export declare class HeadTailBuffer {
+    private readonly headLimit;
+    private readonly tailLimit;
+    private head;
+    private tail;
+    private bytesSeen;
+    constructor(totalLimitBytes?: number);
+    append(chunk: Buffer | string): void;
+    snapshot(): BufferSnapshot;
+    private pushTail;
+}
+export {};

package/dist/plugins/process/head-tail-buffer.js

@@ -0,0 +1,49 @@
+export class HeadTailBuffer {
+    headLimit;
+    tailLimit;
+    head = Buffer.alloc(0);
+    tail = Buffer.alloc(0);
+    bytesSeen = 0;
+    constructor(totalLimitBytes = 256 * 1024) {
+        if (totalLimitBytes < 128)
+            throw new RangeError("Buffer limit must be at least 128 bytes");
+        this.headLimit = Math.floor(totalLimitBytes / 2);
+        this.tailLimit = totalLimitBytes - this.headLimit;
+    }
+    append(chunk) {
+        const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        this.bytesSeen += data.length;
+        if (this.head.length < this.headLimit) {
+            const needed = this.headLimit - this.head.length;
+            this.head = Buffer.concat([this.head, data.subarray(0, needed)]);
+            if (data.length <= needed)
+                return;
+            this.pushTail(data.subarray(needed));
+            return;
+        }
+        this.pushTail(data);
+    }
+    snapshot() {
+        const stored = this.head.length + this.tail.length;
+        const truncated = this.bytesSeen > stored;
+        if (!truncated) {
+            return {
+                text: Buffer.concat([this.head, this.tail]).toString("utf8"),
+                bytesSeen: this.bytesSeen,
+                outputTruncated: false,
+            };
+        }
+        return {
+            text: `${this.head.toString("utf8")}\n…[${this.bytesSeen - stored} bytes truncated]…\n${this.tail.toString("utf8")}`,
+            bytesSeen: this.bytesSeen,
+            outputTruncated: true,
+        };
+    }
+    pushTail(data) {
+        const combined = Buffer.concat([this.tail, data]);
+        this.tail =
+            combined.length > this.tailLimit
+                ? combined.subarray(combined.length - this.tailLimit)
+                : combined;
+    }
+}

package/dist/plugins/process/infrastructure/pipe-process-backend.d.ts

@@ -0,0 +1,8 @@
+import type { BackendProcess, ProcessBackend } from "../backend.js";
+export declare class PipeProcessBackend implements ProcessBackend {
+    readonly kind: "pipe";
+    start(command: string, args: string[], options: {
+        cwd: string;
+        env: NodeJS.ProcessEnv;
+    }): Promise<BackendProcess>;
+}