@chatroomcp/chatroom 0.2.1 → 0.2.2

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

@@ -1,352 +0,0 @@
-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.js";
-export class GitSnapshotService {
-    runner;
-    git;
-    constructor(runner, git) {
-        this.runner = runner;
-        this.git = git;
-    }
-    async fileDiff(cwd, filePath, maxPreviewBytes = 2 * 1024 * 1024) {
-        return this.withIndex(cwd, async ({ env, tempDir }) => {
-            await this.stageAll(cwd, env);
-            const state = await this.stateFromIndex(cwd, env);
-            if (!state.byPath.has(filePath))
-                throw new ChatRoomError("NOT_FOUND", "Worktree file change not found");
-            const patchPath = path.join(tempDir, "file.patch");
-            await this.writeHeadPatch(cwd, env, patchPath, [filePath]);
-            return {
-                path: filePath,
-                ...(await readPatchPreview(patchPath, maxPreviewBytes)),
-            };
-        });
-    }
-    async apply(worktreeRoot, sourceRoot, requestedPaths) {
-        const [worktreeHead, sourceHead, worktree, source] = await Promise.all([
-            this.git.head(worktreeRoot),
-            this.git.head(sourceRoot),
-            this.snapshot(worktreeRoot),
-            this.snapshot(sourceRoot),
-        ]);
-        if (!worktreeHead || !sourceHead || worktreeHead !== sourceHead)
-            throw new ChatRoomError("CONFLICT", "Source checkout HEAD no longer matches the worktree HEAD");
-        if (!worktree.state.files.length)
-            throw new ChatRoomError("CONFLICT", "Worktree has no changes to apply");
-        const baseTree = await this.baseTree(worktreeRoot, worktreeHead);
-        const fullAnalysis = await this.analyze(worktreeRoot, baseTree, source.tree, worktree.tree, worktree.state.files.map((file) => file.path));
-        const reviewed = reviewFiles(worktree.state, source.state, fullAnalysis);
-        const pending = reviewed.filter((file) => !file.applied);
-        const selected = resolveRequestedPaths(pending, requestedPaths);
-        const selectedConflicts = selected
-            .filter((file) => file.conflict)
-            .map((file) => file.path);
-        if (requestedPaths !== undefined && selectedConflicts.length)
-            throw new ChatRoomError("CONFLICT", "Selected worktree files have merge conflicts", {
-                paths: selectedConflicts,
-            });
-        const paths = selected
-            .filter((file) => !file.conflict)
-            .map((file) => file.path);
-        if (!paths.length)
-            throw new ChatRoomError("CONFLICT", "No selected worktree files can be merged automatically", {
-                paths: selectedConflicts,
-            });
-        const selectedTree = await this.treeForPaths(worktreeRoot, paths);
-        const merge = await this.analyze(worktreeRoot, baseTree, source.tree, selectedTree, paths);
-        if (merge.conflicts.size)
-            throw new ChatRoomError("CONFLICT", "Selected worktree files have merge conflicts", {
-                paths: [...merge.conflicts],
-            });
-        return this.withIndex(worktreeRoot, async ({ tempDir }) => {
-            const patchPath = path.join(tempDir, "merge.patch");
-            await this.writeTreePatch(sourceRoot, patchPath, source.tree, merge.mergedTree, paths);
-            const bytes = (await stat(patchPath)).size;
-            if (bytes === 0)
-                throw new ChatRoomError("CONFLICT", "Selected worktree files are already integrated");
-            const [currentWorktreeHead, currentSourceHead, currentSource, currentSelectedTree,] = await Promise.all([
-                this.git.head(worktreeRoot),
-                this.git.head(sourceRoot),
-                this.snapshot(sourceRoot),
-                this.treeForPaths(worktreeRoot, paths),
-            ]);
-            if (currentWorktreeHead !== worktreeHead ||
-                currentSourceHead !== sourceHead ||
-                currentSource.tree !== source.tree ||
-                currentSelectedTree !== selectedTree)
-                throw new ChatRoomError("CONFLICT", "Workspace changed while preparing worktree merge");
-            await this.runner.run(sourceRoot, [
-                "apply",
-                "--check",
-                "--binary",
-                patchPath,
-            ]);
-            await this.runner.run(sourceRoot, ["apply", "--binary", patchPath]);
-            return { bytes, paths, conflicts: selectedConflicts };
-        });
-    }
-    async applyState(worktreeRoot, sourceRoot) {
-        const [worktreeHead, sourceHead, worktree, source] = await Promise.all([
-            this.git.head(worktreeRoot),
-            this.git.head(sourceRoot),
-            this.snapshot(worktreeRoot),
-            this.snapshot(sourceRoot),
-        ]);
-        if (!worktreeHead || !sourceHead || worktreeHead !== sourceHead) {
-            return {
-                files: worktree.state.files.map(({ target, ...file }) => ({
-                    ...file,
-                    applied: source.state.byPath.get(file.path)?.target === target,
-                    conflict: false,
-                })),
-            };
-        }
-        const baseTree = await this.baseTree(worktreeRoot, worktreeHead);
-        const analysis = await this.analyze(worktreeRoot, baseTree, source.tree, worktree.tree, worktree.state.files.map((file) => file.path));
-        return { files: reviewFiles(worktree.state, source.state, analysis) };
-    }
-    async analyze(cwd, baseTree, oursTree, theirsTree, paths) {
-        const merge = await this.mergeTrees(cwd, baseTree, oursTree, theirsTree);
-        const delta = await this.runner.run(cwd, [
-            "diff",
-            "--name-only",
-            "-z",
-            "--no-renames",
-            oursTree,
-            merge.mergedTree,
-            "--",
-            ...paths,
-        ]);
-        return {
-            ...merge,
-            deltaPaths: new Set(delta.stdout.split("\0").filter(Boolean)),
-        };
-    }
-    async mergeTrees(cwd, baseTree, oursTree, theirsTree) {
-        const args = [
-            "merge-tree",
-            "--write-tree",
-            `--merge-base=${baseTree}`,
-            "--messages",
-            "--name-only",
-            "-z",
-            oursTree,
-            theirsTree,
-        ];
-        let stdout;
-        try {
-            stdout = (await this.runner.run(cwd, args)).stdout;
-        }
-        catch (error) {
-            const details = error instanceof ChatRoomError
-                ? error.details
-                : undefined;
-            if (error instanceof ChatRoomError &&
-                error.code === "PROCESS_FAILED" &&
-                details?.exitCode === 1)
-                stdout = String(details.stdout ?? "");
-            else
-                throw error;
-        }
-        const tokens = stdout.split("\0");
-        const mergedTree = tokens[0]?.trim() ?? "";
-        if (!/^[0-9a-f]{40,64}$/.test(mergedTree))
-            throw new ChatRoomError("INTERNAL", "Git merge-tree did not return a merged tree");
-        const conflicts = new Set();
-        for (let index = 1; index < tokens.length && tokens[index] !== ""; index++) {
-            if (tokens[index])
-                conflicts.add(tokens[index]);
-        }
-        return { mergedTree, conflicts };
-    }
-    async snapshot(cwd) {
-        return this.withIndex(cwd, async ({ env }) => {
-            await this.stageAll(cwd, env);
-            const [state, tree] = await Promise.all([
-                this.stateFromIndex(cwd, env),
-                this.writeTree(cwd, env),
-            ]);
-            return { state, tree };
-        });
-    }
-    async treeForPaths(cwd, paths) {
-        return this.withIndex(cwd, async ({ env }) => {
-            await this.runner.run(cwd, ["add", "-A", "--", ...paths], env);
-            return this.writeTree(cwd, env);
-        });
-    }
-    async baseTree(cwd, head) {
-        return (await this.runner.run(cwd, ["rev-parse", `${head}^{tree}`])).stdout.trim();
-    }
-    async writeTree(cwd, env) {
-        return (await this.runner.run(cwd, ["write-tree"], env)).stdout.trim();
-    }
-    async stageAll(cwd, env) {
-        await this.runner.run(cwd, ["add", "-A", "--", "."], env);
-    }
-    async stateFromIndex(cwd, env) {
-        const [raw, numstat] = await Promise.all([
-            this.runner.run(cwd, [
-                "diff",
-                "--cached",
-                "--raw",
-                "-z",
-                "--no-renames",
-                "--abbrev=40",
-                "HEAD",
-            ], env),
-            this.runner.run(cwd, ["diff", "--cached", "--numstat", "-z", "--no-renames", "HEAD"], env),
-        ]);
-        const stats = parseNumstat(numstat.stdout);
-        const tokens = raw.stdout.split("\0");
-        const files = [];
-        for (let index = 0; index + 1 < tokens.length; index += 2) {
-            const header = tokens[index];
-            const filePath = tokens[index + 1];
-            if (!header || !filePath)
-                continue;
-            const match = /^:(\d{6}) (\d{6}) ([0-9a-f]{40}) ([0-9a-f]{40}) ([AMDT])$/.exec(header);
-            if (!match)
-                throw new ChatRoomError("INTERNAL", `Unexpected Git raw diff entry: ${header}`);
-            const statEntry = stats.get(filePath) ?? {
-                additions: null,
-                deletions: null,
-                binary: true,
-            };
-            files.push({
-                path: filePath,
-                status: rawStatus(match[5]),
-                additions: statEntry.additions,
-                deletions: statEntry.deletions,
-                binary: statEntry.binary,
-                target: `${match[2]}:${match[4]}`,
-            });
-        }
-        return { files, byPath: new Map(files.map((file) => [file.path, file])) };
-    }
-    async writeHeadPatch(cwd, env, patchPath, paths) {
-        await this.runner.run(cwd, [
-            "diff",
-            "--cached",
-            "--binary",
-            "--no-ext-diff",
-            "--no-renames",
-            `--output=${patchPath}`,
-            "HEAD",
-            "--",
-            ...paths,
-        ], env);
-    }
-    async writeTreePatch(cwd, patchPath, fromTree, toTree, paths) {
-        await this.runner.run(cwd, [
-            "diff",
-            "--binary",
-            "--no-ext-diff",
-            "--no-renames",
-            `--output=${patchPath}`,
-            fromTree,
-            toTree,
-            "--",
-            ...paths,
-        ]);
-    }
-    async withIndex(cwd, useIndex) {
-        const tempDir = await mkdtemp(path.join(os.tmpdir(), "chatroom-worktree-"));
-        const env = { GIT_INDEX_FILE: path.join(tempDir, "index") };
-        try {
-            await this.runner.run(cwd, ["read-tree", "HEAD"], env);
-            return await useIndex({ env, tempDir });
-        }
-        finally {
-            await rm(tempDir, { recursive: true, force: true }).catch(() => undefined);
-        }
-    }
-}
-function reviewFiles(worktree, source, analysis) {
-    const mappedConflicts = mapConflictPaths(worktree.files, analysis.conflicts);
-    return worktree.files.map(({ target, ...file }) => {
-        const conflict = mappedConflicts.has(file.path);
-        const exact = source.byPath.get(file.path)?.target === target;
-        const integrated = !conflict && !analysis.deltaPaths.has(file.path);
-        return { ...file, applied: exact || integrated, conflict };
-    });
-}
-function mapConflictPaths(files, conflicts) {
-    const mapped = new Set();
-    for (const file of files) {
-        for (const conflict of conflicts) {
-            if (conflict === file.path ||
-                conflict.startsWith(`${file.path}/`) ||
-                file.path.startsWith(`${conflict}/`)) {
-                mapped.add(file.path);
-                break;
-            }
-        }
-    }
-    if (conflicts.size && !mapped.size)
-        for (const file of files)
-            mapped.add(file.path);
-    return mapped;
-}
-function resolveRequestedPaths(pending, requestedPaths) {
-    if (requestedPaths === undefined)
-        return pending;
-    const requested = [...new Set(requestedPaths)];
-    if (!requested.length)
-        throw new ChatRoomError("INVALID_INPUT", "At least one file path is required");
-    const byPath = new Map(pending.map((file) => [file.path, file]));
-    return requested.map((filePath) => {
-        const file = byPath.get(filePath);
-        if (!file)
-            throw new ChatRoomError("CONFLICT", `Worktree file is already applied or unavailable: ${filePath}`);
-        return file;
-    });
-}
-function rawStatus(value) {
-    if (value === "A")
-        return "added";
-    if (value === "D")
-        return "deleted";
-    if (value === "T")
-        return "type-changed";
-    return "modified";
-}
-function parseNumstat(value) {
-    const result = new Map();
-    for (const entry of value.split("\0")) {
-        if (!entry)
-            continue;
-        const first = entry.indexOf("\t");
-        const second = first < 0 ? -1 : entry.indexOf("\t", first + 1);
-        if (first < 0 || second < 0)
-            continue;
-        const additionsText = entry.slice(0, first);
-        const deletionsText = entry.slice(first + 1, second);
-        const filePath = entry.slice(second + 1);
-        const binary = additionsText === "-" || deletionsText === "-";
-        result.set(filePath, {
-            additions: binary ? null : Number(additionsText),
-            deletions: binary ? null : Number(deletionsText),
-            binary,
-        });
-    }
-    return result;
-}
-async function readPatchPreview(patchPath, maxPreviewBytes) {
-    const size = (await stat(patchPath)).size;
-    const previewBytes = Math.min(size, maxPreviewBytes);
-    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"),
-            bytes: size,
-            truncated: size > previewBytes,
-        };
-    }
-    finally {
-        await handle.close();
-    }
-}

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

@@ -1,340 +0,0 @@
-/**
- * Workspace-scoped filesystem implementation and the primary path-containment boundary for ChatRoom file tools.
- * It rejects absolute/traversal paths and prevents reads or writes that escape through symbolic links.
- */
-import { lstat, mkdir, open, readdir, realpath, rename, rm, stat, writeFile, } from "node:fs/promises";
-import path from "node:path";
-import { randomUUID } from "node:crypto";
-import { ChatRoomError } from "../../../core/errors/chatroom-error.js";
-export class WorkspaceFs {
-    root;
-    realRoot;
-    constructor(root, realRoot) {
-        this.root = root;
-        this.realRoot = realRoot;
-    }
-    static async create(root) {
-        const resolved = path.resolve(root);
-        const canonical = await realpath(resolved).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(resolved, 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 size = Math.min(info.size, maxBytes);
-            const buffer = Buffer.alloc(size);
-            const result = await handle.read(buffer, 0, size, 0);
-            return {
-                data: buffer.subarray(0, result.bytesRead),
-                bytes: info.size,
-                truncated: info.size > maxBytes,
-            };
-        }
-        finally {
-            await handle.close();
-        }
-    }
-    async write(relativePath, content) {
-        const target = await this.resolveWritable(relativePath, true);
-        let mode = 0o644;
-        try {
-            mode = (await lstat(target)).mode & 0o777;
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                throw error;
-        }
-        // Write beside the destination and rename atomically so readers never observe partially written content.
-        const temp = `${target}.chatroom-${randomUUID()}.tmp`;
-        await writeFile(temp, content, { flag: "wx", mode });
-        try {
-            await rename(temp, target);
-        }
-        finally {
-            await rm(temp, { force: true }).catch(() => undefined);
-        }
-        return {
-            path: this.normalizeRelative(relativePath),
-            bytes: Buffer.byteLength(content),
-        };
-    }
-    async list(relativePath = ".", options = {}) {
-        const start = await this.resolveReadable(relativePath);
-        const maxEntries = Math.min(options.maxEntries ?? 1000, 10000);
-        const output = [];
-        const walk = async (absolute) => {
-            for (const entry of await readdir(absolute, { withFileTypes: true })) {
-                if (output.length >= maxEntries)
-                    return;
-                const absoluteEntry = path.join(absolute, entry.name);
-                const relative = path
-                    .relative(this.realRoot, absoluteEntry)
-                    .split(path.sep)
-                    .join("/");
-                const info = await lstat(absoluteEntry);
-                const type = info.isSymbolicLink()
-                    ? "symlink"
-                    : info.isDirectory()
-                        ? "directory"
-                        : "file";
-                output.push({
-                    path: relative,
-                    type,
-                    size: info.size,
-                    modifiedAt: info.mtime.toISOString(),
-                });
-                // Never recurse through symlinks; their targets may point outside the workspace.
-                if (options.recursive && entry.isDirectory() && !entry.isSymbolicLink())
-                    await walk(absoluteEntry);
-            }
-        };
-        const startInfo = await stat(start);
-        if (!startInfo.isDirectory())
-            throw new ChatRoomError("INVALID_INPUT", `Not a directory: ${relativePath}`);
-        await walk(start);
-        return output;
-    }
-    async search(query, options = {}) {
-        if (!query)
-            throw new ChatRoomError("INVALID_INPUT", "Search query must not be empty");
-        const maxResults = Math.min(options.maxResults ?? 200, 2000);
-        const files = await this.list(options.path ?? ".", {
-            recursive: true,
-            maxEntries: 10000,
-        });
-        const needle = query.toLocaleLowerCase();
-        const results = [];
-        for (const file of files) {
-            if (results.length >= maxResults ||
-                file.type !== "file" ||
-                file.size > 2 * 1024 * 1024)
-                continue;
-            const data = await this.read(file.path, { maxBytes: 2 * 1024 * 1024 });
-            if (data.content.includes("\0"))
-                continue;
-            const lines = data.content.split(/\r?\n/);
-            for (let lineIndex = 0; lineIndex < lines.length && results.length < maxResults; lineIndex++) {
-                const line = lines[lineIndex] ?? "";
-                const haystack = line.toLocaleLowerCase();
-                const column = haystack.indexOf(needle);
-                if (column !== -1)
-                    results.push({
-                        path: file.path,
-                        line: lineIndex + 1,
-                        column: column + 1,
-                        preview: line.slice(0, 500),
-                    });
-            }
-        }
-        return results;
-    }
-    async patch(replacements) {
-        if (!replacements.length)
-            throw new ChatRoomError("INVALID_INPUT", "Patch must contain at least one replacement");
-        const grouped = new Map();
-        for (const replacement of replacements) {
-            if (!replacement.oldText)
-                throw new ChatRoomError("INVALID_INPUT", `oldText must not be empty: ${replacement.path}`);
-            const key = this.normalizeRelative(replacement.path);
-            grouped.set(key, [...(grouped.get(key) ?? []), replacement]);
-        }
-        // Phase 1 prepares every file completely before any destination is changed.
-        const prepared = [];
-        let replacementCount = 0;
-        let bytesBefore = 0;
-        let bytesAfter = 0;
-        for (const [relative, edits] of grouped) {
-            const target = await this.resolveWritable(relative, false);
-            const mode = (await lstat(target)).mode & 0o777;
-            const before = (await this.read(relative, { maxBytes: 64 * 1024 * 1024 }))
-                .content;
-            let after = before;
-            for (const edit of edits) {
-                const occurrences = countOccurrences(after, edit.oldText);
-                if (occurrences === 0)
-                    throw new ChatRoomError("CONFLICT", `oldText not found in ${relative}`);
-                if (edit.occurrence === "all") {
-                    after = after.split(edit.oldText).join(edit.newText);
-                    replacementCount += occurrences;
-                }
-                else {
-                    const occurrence = edit.occurrence ?? 1;
-                    if (occurrence < 1 || occurrence > occurrences)
-                        throw new ChatRoomError("CONFLICT", `Occurrence ${occurrence} not found in ${relative}`, { occurrences });
-                    after = replaceOccurrence(after, edit.oldText, edit.newText, occurrence);
-                    replacementCount += 1;
-                }
-            }
-            bytesBefore += Buffer.byteLength(before);
-            bytesAfter += Buffer.byteLength(after);
-            const id = randomUUID();
-            prepared.push({
-                relative,
-                target,
-                after,
-                temp: `${target}.chatroom-${id}.tmp`,
-                backup: `${target}.chatroom-${id}.bak`,
-                mode,
-            });
-        }
-        try {
-            for (const item of prepared)
-                await writeFile(item.temp, item.after, { flag: "wx", mode: item.mode });
-        }
-        catch (error) {
-            for (const item of prepared)
-                await rm(item.temp, { force: true }).catch(() => undefined);
-            throw error;
-        }
-        // Phase 2 commits with backups so already-swapped files can be restored if a later rename fails.
-        const committed = [];
-        try {
-            for (const item of prepared) {
-                await rename(item.target, item.backup);
-                try {
-                    await rename(item.temp, item.target);
-                    committed.push(item);
-                }
-                catch (error) {
-                    await rename(item.backup, item.target).catch(() => undefined);
-                    throw error;
-                }
-            }
-        }
-        catch (error) {
-            for (const item of committed.reverse()) {
-                await rm(item.target, { force: true }).catch(() => undefined);
-                await rename(item.backup, item.target).catch(() => undefined);
-            }
-            throw new ChatRoomError("INTERNAL", "Patch commit failed and was rolled back", undefined, {
-                cause: error,
-            });
-        }
-        finally {
-            for (const item of prepared) {
-                await rm(item.temp, { force: true }).catch(() => undefined);
-                await rm(item.backup, { force: true }).catch(() => undefined);
-            }
-        }
-        return {
-            files: prepared.map((item) => item.relative),
-            replacements: replacementCount,
-            bytesBefore,
-            bytesAfter,
-        };
-    }
-    normalizeRelative(input) {
-        // Check both host-native and Windows path syntax so a path cannot become dangerous when moved across platforms.
-        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("/") || ".";
-    }
-    lexical(relativePath) {
-        const normalized = this.normalizeRelative(relativePath);
-        const absolute = path.resolve(this.realRoot, ...normalized.split("/"));
-        if (!inside(this.realRoot, absolute))
-            throw new ChatRoomError("FORBIDDEN", "Path escapes workspace");
-        return absolute;
-    }
-    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;
-        });
-        // realpath resolves symlinks before containment is checked against the canonical workspace root.
-        if (!inside(this.realRoot, canonical))
-            throw new ChatRoomError("FORBIDDEN", "Symlink escapes workspace");
-        return canonical;
-    }
-    async resolveWritable(relativePath, createParents) {
-        const target = this.lexical(relativePath);
-        const relative = path.relative(this.realRoot, target);
-        const parts = relative.split(path.sep).filter(Boolean);
-        let current = this.realRoot;
-        // Walk each existing parent explicitly so writes cannot traverse a symlinked directory.
-        for (let index = 0; index < parts.length - 1; index++) {
-            current = path.join(current, parts[index]);
-            try {
-                const 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.realRoot, canonical))
-                    throw new ChatRoomError("FORBIDDEN", "Write path escapes workspace");
-            }
-            catch (error) {
-                if (error instanceof ChatRoomError)
-                    throw error;
-                if (error.code !== "ENOENT")
-                    throw error;
-                if (!createParents)
-                    throw new ChatRoomError("NOT_FOUND", `Parent directory does not exist: ${relativePath}`);
-                await mkdir(current, { recursive: false, mode: 0o700 });
-            }
-        }
-        try {
-            const targetInfo = await lstat(target);
-            if (targetInfo.isSymbolicLink())
-                throw new ChatRoomError("FORBIDDEN", `Writes through symlinks are not allowed: ${relativePath}`);
-        }
-        catch (error) {
-            if (error instanceof ChatRoomError)
-                throw error;
-            if (error.code !== "ENOENT")
-                throw error;
-        }
-        return target;
-    }
-}
-function inside(root, candidate) {
-    const rel = path.relative(root, candidate);
-    return (rel === "" ||
-        (!rel.startsWith(`..${path.sep}`) && rel !== ".." && !path.isAbsolute(rel)));
-}
-function countOccurrences(text, needle) {
-    let count = 0, index = 0;
-    while ((index = text.indexOf(needle, index)) !== -1) {
-        count++;
-        index += needle.length;
-    }
-    return count;
-}
-function replaceOccurrence(text, needle, replacement, occurrence) {
-    let index = -1, from = 0;
-    for (let i = 0; i < occurrence; i++) {
-        index = text.indexOf(needle, from);
-        from = index + needle.length;
-    }
-    return `${text.slice(0, index)}${replacement}${text.slice(index + needle.length)}`;
-}