@chatroomcp/chatroom 0.1.3

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

@@ -0,0 +1,41 @@
+import { Router } from "express";
+import { z } from "zod";
+import { CLOUD_SERVICE_SCHEMA } from "../../cloud/types.js";
+import { asyncRoute } from "../../../presentation/http/http-utils.js";
+export function createCloudApiRouter(controller, operations) {
+    const router = Router();
+    router.get("/cloud/status", (_req, res) => res.json(controller.status()));
+    router.post("/cloud/sync", asyncRoute(async (_req, res) => res.json(await operations.run({ pluginId: "cloud", source: "gui", action: "sync" }, () => controller.syncStatus()))));
+    router.post("/cloud/management", asyncRoute(async (_req, res) => res.json(await operations.run({ pluginId: "cloud", source: "gui", action: "management" }, () => controller.managementUrl()))));
+    router.post("/cloud/restore", asyncRoute(async (req, res) => {
+        const body = z
+            .object({ recoveryKey: z.string().min(20) })
+            .strict()
+            .parse(req.body);
+        res.json(await operations.run({ pluginId: "cloud", source: "gui", action: "restore", input: body }, () => controller.restore(body.recoveryKey)));
+    }));
+    router.post("/cloud/recovery-key", asyncRoute(async (_req, res) => res.json(await operations.run({ pluginId: "cloud", source: "gui", action: "recovery-key.replace" }, async () => ({ recoveryKey: await controller.replaceRecoveryKey() })))));
+    router.post("/cloud/prefix", asyncRoute(async (req, res) => {
+        const body = z
+            .object({ prefix: z.string().min(1).max(64) })
+            .strict()
+            .parse(req.body);
+        res.json(await operations.run({
+            pluginId: "cloud",
+            source: "gui",
+            action: "prefix.set",
+            input: body,
+        }, () => controller.setPrefix(body.prefix)));
+    }));
+    router.post("/cloud/services/:service", asyncRoute(async (req, res) => {
+        const service = CLOUD_SERVICE_SCHEMA.parse(req.params.service);
+        const body = z.object({ enabled: z.boolean() }).strict().parse(req.body);
+        res.json(await operations.run({
+            pluginId: "cloud",
+            source: "gui",
+            action: "service.set",
+            input: { service, enabled: body.enabled },
+        }, () => controller.setService(service, body.enabled)));
+    }));
+    return router;
+}

package/dist/plugins/web/http/process-api-router.d.ts

@@ -0,0 +1,3 @@
+import { Router } from "express";
+import type { WebRuntime } from "../runtime.js";
+export declare function createProcessApiRouter(application: WebRuntime): Router;

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

@@ -0,0 +1,16 @@
+import { Router } from "express";
+import { asyncRoute, requireString, } from "../../../presentation/http/http-utils.js";
+export function createProcessApiRouter(application) {
+    const router = Router();
+    router.get("/processes", (_req, res) => res.json(application.listProcesses()));
+    router.get("/processes/:processId", (req, res) => {
+        res.json(application.getProcess(requireString(req.params.processId, "processId")));
+    });
+    router.post("/processes/:processId/terminate", asyncRoute(async (req, res) => {
+        res.json(await application.processKill(requireString(req.params.processId, "processId"), false));
+    }));
+    router.post("/processes/:processId/kill", asyncRoute(async (req, res) => {
+        res.json(await application.processKill(requireString(req.params.processId, "processId"), true));
+    }));
+    return router;
+}

package/dist/plugins/web/http/workspace-api-router.d.ts

@@ -0,0 +1,3 @@
+import { Router } from "express";
+import type { WebRuntime } from "../runtime.js";
+export declare function createWorkspaceApiRouter(application: WebRuntime): Router;

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

@@ -0,0 +1,82 @@
+import { Router } from "express";
+import { ChatRoomError } from "../../../core/errors/chatroom-error.js";
+import { asyncRoute, requireString, } from "../../../presentation/http/http-utils.js";
+export function createWorkspaceApiRouter(application) {
+    const router = Router();
+    router.get("/workspaces", asyncRoute(async (_req, res) => {
+        res.json(await application.discoverWorkspaces());
+    }));
+    router.get("/workspaces/:workspaceId", asyncRoute(async (req, res) => {
+        const workspaceId = requireString(req.params.workspaceId, "workspaceId");
+        const workspace = application.getWorkspace(workspaceId);
+        const git = workspace.capabilities.git
+            ? await application.gitInfoQuery(workspace.id)
+            : null;
+        res.json({ ...workspace, git });
+    }));
+    router.get("/workspaces/:workspaceId/files", asyncRoute(async (req, res) => {
+        const workspaceId = requireString(req.params.workspaceId, "workspaceId");
+        const filePath = typeof req.query.path === "string" ? req.query.path : ".";
+        const recursive = req.query.recursive === "1";
+        res.json(await application.listWorkspaceFiles(workspaceId, filePath, recursive));
+    }));
+    router.get("/workspaces/:workspaceId/file", asyncRoute(async (req, res) => {
+        const workspaceId = requireString(req.params.workspaceId, "workspaceId");
+        const filePath = requireString(req.query.path, "path");
+        res.json(await application.readWorkspaceFile(workspaceId, filePath, 2 * 1024 * 1024));
+    }));
+    router.get("/workspaces/:workspaceId/file/image", asyncRoute(async (req, res) => {
+        const workspaceId = requireString(req.params.workspaceId, "workspaceId");
+        const filePath = requireString(req.query.path, "path");
+        const mime = imageMime(filePath);
+        if (!mime)
+            throw new ChatRoomError("INVALID_INPUT", "File type is not supported for image preview");
+        const file = await application.readWorkspaceFileBytes(workspaceId, filePath, 10 * 1024 * 1024);
+        if (file.truncated)
+            throw new ChatRoomError("INVALID_INPUT", "Image is too large to preview");
+        res.setHeader("Content-Type", mime);
+        res.setHeader("Content-Length", String(file.data.byteLength));
+        res.setHeader("Cache-Control", "no-store");
+        res.setHeader("X-Content-Type-Options", "nosniff");
+        res.send(file.data);
+    }));
+    router.get("/workspaces/:workspaceId/worktree/diff", asyncRoute(async (req, res) => {
+        res.json(await application.previewWorktreeApply(requireString(req.params.workspaceId, "workspaceId")));
+    }));
+    router.get("/workspaces/:workspaceId/worktree/diff/file", asyncRoute(async (req, res) => {
+        const workspaceId = requireString(req.params.workspaceId, "workspaceId");
+        res.json(await application.previewWorktreeFileDiff(workspaceId, requireString(req.query.path, "path")));
+    }));
+    router.post("/workspaces/:workspaceId/worktree/apply", asyncRoute(async (req, res) => {
+        const workspaceId = requireString(req.params.workspaceId, "workspaceId");
+        const body = (req.body ?? {});
+        if (body.paths !== undefined &&
+            (!Array.isArray(body.paths) ||
+                body.paths.some((value) => typeof value !== "string")))
+            throw new ChatRoomError("INVALID_INPUT", "paths must be an array of file paths");
+        res.json(await application.applyWorktree(workspaceId, body.paths));
+    }));
+    return router;
+}
+function imageMime(filePath) {
+    const extension = filePath.split(".").pop()?.toLowerCase();
+    switch (extension) {
+        case "png":
+            return "image/png";
+        case "jpg":
+        case "jpeg":
+            return "image/jpeg";
+        case "gif":
+            return "image/gif";
+        case "webp":
+            return "image/webp";
+        case "avif":
+            return "image/avif";
+        case "bmp":
+            return "image/bmp";
+        case "ico":
+            return "image/x-icon";
+        default:
+            return null;
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { InternalPlugin } from "../types.js";
+import { WebRuntime } from "./runtime.js";
+interface WebPluginService {
+    application: WebRuntime;
+}
+export declare const WebServiceToken: import("../types.js").ServiceToken<WebPluginService>;
+export declare function createWebPlugin(): InternalPlugin;
+export {};

package/dist/plugins/web/plugin.js

@@ -0,0 +1,17 @@
+import { createServiceToken } from "../types.js";
+import { WorkspaceService } from "../workspace/plugin.js";
+import { ProcessService } from "../process/plugin.js";
+import { WebRuntime } from "./runtime.js";
+export const WebServiceToken = createServiceToken("web");
+export function createWebPlugin() {
+    return {
+        id: "web",
+        activate(context) {
+            const workspace = context.services.require(WorkspaceService);
+            const processes = context.services.require(ProcessService);
+            context.services.provide(WebServiceToken, {
+                application: new WebRuntime(workspace.workspaces, context.operations, processes, workspace.git),
+            });
+        },
+    };
+}

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

@@ -0,0 +1,36 @@
+import type { OperationLog } from "../../operations/operation-log.js";
+import type { WorkspaceService } from "../workspace/workspace-service.js";
+import type { ProcessSupervisor } from "../process/process-supervisor.js";
+import type { GitService } from "../workspace/git/git-service.js";
+export declare class WebRuntime {
+    readonly workspaces: WorkspaceService;
+    readonly operations: OperationLog;
+    readonly processes: ProcessSupervisor;
+    readonly git: GitService;
+    constructor(workspaces: WorkspaceService, operations: OperationLog, processes: ProcessSupervisor, git: GitService);
+    previewWorktreeApply(workspaceId: string): Promise<import("./api-types.js").WorktreeApplyPreview>;
+    previewWorktreeFileDiff(workspaceId: string, filePath: string): Promise<import("./api-types.js").WorktreeFileDiff>;
+    applyWorktree(workspaceId: string, paths?: string[]): Promise<{
+        workspaceId: string;
+        bytes: number;
+        paths: string[];
+        conflicts: string[];
+    }>;
+    processKill(processId: string, force?: boolean): Promise<import("./api-types.js").ProcessSnapshot>;
+    listProcesses(): import("./api-types.js").ProcessSnapshot[];
+    getProcess(processId: string): import("./api-types.js").ProcessSnapshot;
+    discoverWorkspaces(): Promise<import("../workspace/domain/workspace.js").Workspace[]>;
+    getWorkspace(workspaceId: string): import("../workspace/domain/workspace.js").Workspace;
+    readWorkspaceFile(workspaceId: string, filePath: string, maxBytes?: number): Promise<{
+        content: string;
+        bytes: number;
+        truncated: boolean;
+    }>;
+    readWorkspaceFileBytes(workspaceId: string, filePath: string, maxBytes: number): Promise<{
+        data: Buffer;
+        bytes: number;
+        truncated: boolean;
+    }>;
+    listWorkspaceFiles(workspaceId: string, filePath?: string, recursive?: boolean): Promise<import("../workspace/domain/filesystem.js").FileInfo[]>;
+    gitInfoQuery(workspaceId: string): Promise<import("../workspace/domain/git.js").GitInfo>;
+}

package/dist/plugins/web/runtime.js

@@ -0,0 +1,66 @@
+export class WebRuntime {
+    workspaces;
+    operations;
+    processes;
+    git;
+    constructor(workspaces, operations, processes, git) {
+        this.workspaces = workspaces;
+        this.operations = operations;
+        this.processes = processes;
+        this.git = git;
+    }
+    previewWorktreeApply(workspaceId) {
+        return this.workspaces.previewWorktreeApply(workspaceId);
+    }
+    previewWorktreeFileDiff(workspaceId, filePath) {
+        return this.workspaces.previewWorktreeFileDiff(workspaceId, filePath);
+    }
+    applyWorktree(workspaceId, paths) {
+        return this.operations.run({
+            pluginId: "workspace",
+            source: "gui",
+            action: "worktree.apply",
+            workspaceId,
+            input: { workspaceId, paths: paths ?? null },
+        }, () => this.workspaces.applyWorktree(workspaceId, paths));
+    }
+    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.list();
+    }
+    getProcess(processId) {
+        return this.processes.read(processId);
+    }
+    discoverWorkspaces() {
+        return this.workspaces.discoverGitWorkspaces();
+    }
+    getWorkspace(workspaceId) {
+        return this.workspaces.get(workspaceId);
+    }
+    async readWorkspaceFile(workspaceId, filePath, maxBytes) {
+        const fs = await this.workspaces.fs(workspaceId);
+        return fs.read(filePath, {
+            ...(maxBytes === undefined ? {} : { maxBytes }),
+        });
+    }
+    async readWorkspaceFileBytes(workspaceId, filePath, maxBytes) {
+        const fs = await this.workspaces.fs(workspaceId);
+        return fs.readBytes(filePath, { maxBytes });
+    }
+    async listWorkspaceFiles(workspaceId, filePath = ".", recursive = false) {
+        const fs = await this.workspaces.fs(workspaceId);
+        return fs.list(filePath, { recursive });
+    }
+    gitInfoQuery(workspaceId) {
+        const workspace = this.workspaces.markUsed(workspaceId);
+        return this.git.info(workspace.root);
+    }
+}

package/dist/plugins/workspace/domain/filesystem.d.ts

@@ -0,0 +1,25 @@
+/** Workspace filesystem value types. */
+export interface FileInfo {
+    path: string;
+    type: "file" | "directory" | "symlink";
+    size: number;
+    modifiedAt: string;
+}
+export interface SearchMatch {
+    path: string;
+    line: number;
+    column: number;
+    preview: string;
+}
+export interface PatchReplacement {
+    path: string;
+    oldText: string;
+    newText: string;
+    occurrence?: number | "all";
+}
+export interface ChangeSet {
+    files: string[];
+    replacements: number;
+    bytesBefore: number;
+    bytesAfter: number;
+}

package/dist/plugins/workspace/domain/filesystem.js

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

package/dist/plugins/workspace/domain/git.d.ts

@@ -0,0 +1,7 @@
+export interface GitInfo {
+    isRepository: boolean;
+    branch: string | null;
+    head: string | null;
+    dirty: boolean;
+    root: string | null;
+}

package/dist/plugins/workspace/domain/git.js

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

package/dist/plugins/workspace/domain/repository.d.ts

@@ -0,0 +1,16 @@
+import type { WorkspaceMode } from "./workspace.js";
+export interface WorkspaceRecord {
+    id: string;
+    root: string;
+    sourceRoot: string;
+    mode: WorkspaceMode;
+    createdAt: string;
+    lastUsedAt: string;
+}
+export interface WorkspaceStateRepository {
+    upsert(workspace: WorkspaceRecord): void;
+    get(workspaceId: string): WorkspaceRecord | null;
+    findByRoot(root: string, mode: WorkspaceMode): WorkspaceRecord | null;
+    list(): WorkspaceRecord[];
+    remove(workspaceId: string): void;
+}

package/dist/plugins/workspace/domain/repository.js

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

package/dist/plugins/workspace/domain/review.d.ts

@@ -0,0 +1,28 @@
+type WorktreeFileStatus = "added" | "modified" | "deleted" | "type-changed";
+export interface WorktreeReviewFile {
+    path: string;
+    status: WorktreeFileStatus;
+    additions: number | null;
+    deletions: number | null;
+    binary: boolean;
+}
+export interface WorktreeApplyPreview {
+    files: Array<WorktreeReviewFile & {
+        applied: boolean;
+        conflict: boolean;
+    }>;
+    totalFiles: number;
+    pendingFiles: number;
+    appliedFiles: number;
+    mergeableFiles: number;
+    conflictFiles: number;
+    canApply: boolean;
+    reason: "no-changes" | "merge-conflicts" | "head-mismatch" | null;
+}
+export interface WorktreeFileDiff {
+    path: string;
+    diff: string;
+    bytes: number;
+    truncated: boolean;
+}
+export {};

package/dist/plugins/workspace/domain/review.js

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

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

@@ -0,0 +1,23 @@
+/**
+ * Domain model for a persistent ChatRoom workspace.
+ * Workspace identity is persistent and independent from transport connection lifetime.
+ */
+/** `checkout` uses sourceRoot directly; `worktree` uses a managed detached Git worktree. */
+export type WorkspaceMode = "checkout" | "worktree";
+interface WorkspaceCapabilities {
+    filesystem: "read-write";
+    git: boolean;
+    skills: boolean;
+}
+export interface Workspace {
+    id: string;
+    root: string;
+    sourceRoot: string;
+    mode: WorkspaceMode;
+    createdAt: string;
+    lastUsedAt: string;
+    instructions: string[];
+    skills: string[];
+    capabilities: WorkspaceCapabilities;
+}
+export {};

package/dist/plugins/workspace/domain/workspace.js

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

package/dist/plugins/workspace/git/git-command-runner.d.ts

@@ -0,0 +1,6 @@
+import type { CommandRunner } from "../../../core/runtime/command-runner.js";
+export declare class GitCommandRunner {
+    private readonly commands;
+    constructor(commands: CommandRunner);
+    run(cwd: string, args: string[], env?: Record<string, string>): Promise<import("../../../core/runtime/command-runner.js").CommandResult>;
+}

package/dist/plugins/workspace/git/git-command-runner.js

@@ -0,0 +1,15 @@
+export class GitCommandRunner {
+    commands;
+    constructor(commands) {
+        this.commands = commands;
+    }
+    run(cwd, args, env) {
+        return this.commands.run({
+            cwd,
+            command: "git",
+            args,
+            timeoutMs: 120_000,
+            env: { LC_ALL: "C", LANG: "C", ...(env ?? {}) },
+        });
+    }
+}

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

@@ -0,0 +1,14 @@
+import type { GitInfo } from "../domain/git.js";
+import type { GitCommandRunner } from "./git-command-runner.js";
+export declare class GitService {
+    private readonly runner;
+    constructor(runner: GitCommandRunner);
+    info(cwd: string): Promise<GitInfo>;
+    head(cwd: string): Promise<string | null>;
+    branch(cwd: string): Promise<string | null>;
+    status(cwd: string): Promise<string>;
+    diff(cwd: string): Promise<string>;
+    createWorktree(sourceRoot: string, target: string): Promise<void>;
+    removeWorktree(sourceRoot: string, target: string, force?: boolean): Promise<void>;
+    pruneWorktrees(sourceRoot: string): Promise<void>;
+}

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

@@ -0,0 +1,107 @@
+import path from "node:path";
+import { ChatRoomError } from "../../../core/errors/chatroom-error.js";
+export class GitService {
+    runner;
+    constructor(runner) {
+        this.runner = runner;
+    }
+    async info(cwd) {
+        try {
+            const root = (await this.runner.run(cwd, ["rev-parse", "--show-toplevel"])).stdout.trim();
+            const [head, branch, status] = await Promise.all([
+                this.head(cwd),
+                this.branch(cwd),
+                this.runner.run(cwd, ["status", "--porcelain"]),
+            ]);
+            return {
+                isRepository: true,
+                branch,
+                head,
+                dirty: status.stdout.trim().length > 0,
+                root: path.resolve(root),
+            };
+        }
+        catch (error) {
+            if (isNotRepositoryError(error))
+                return {
+                    isRepository: false,
+                    branch: null,
+                    head: null,
+                    dirty: false,
+                    root: null,
+                };
+            throw error;
+        }
+    }
+    async head(cwd) {
+        try {
+            return ((await this.runner.run(cwd, ["rev-parse", "--verify", "HEAD"])).stdout.trim() || null);
+        }
+        catch (error) {
+            if (isMissingHeadError(error))
+                return null;
+            throw error;
+        }
+    }
+    async branch(cwd) {
+        const value = (await this.runner.run(cwd, ["branch", "--show-current"])).stdout.trim();
+        return value || null;
+    }
+    async status(cwd) {
+        return (await this.runner.run(cwd, ["status", "--short", "--branch"]))
+            .stdout;
+    }
+    async diff(cwd) {
+        const [unstaged, staged] = await Promise.all([
+            this.runner.run(cwd, ["diff", "--no-ext-diff", "--unified=3"]),
+            this.runner.run(cwd, [
+                "diff",
+                "--cached",
+                "--no-ext-diff",
+                "--unified=3",
+            ]),
+        ]);
+        return [unstaged.stdout, staged.stdout].filter(Boolean).join("\n");
+    }
+    async createWorktree(sourceRoot, target) {
+        const info = await this.info(sourceRoot);
+        if (!info.isRepository)
+            throw new ChatRoomError("INVALID_INPUT", "Worktree mode requires a Git repository");
+        if (!info.head)
+            throw new ChatRoomError("CONFLICT", "Worktree mode requires at least one Git commit; repository HEAD does not exist");
+        await this.runner.run(sourceRoot, [
+            "worktree",
+            "add",
+            "--detach",
+            target,
+            "HEAD",
+        ]);
+    }
+    async removeWorktree(sourceRoot, target, force = false) {
+        await this.runner.run(sourceRoot, [
+            "worktree",
+            "remove",
+            ...(force ? ["--force"] : []),
+            target,
+        ]);
+    }
+    async pruneWorktrees(sourceRoot) {
+        await this.runner.run(sourceRoot, ["worktree", "prune"]);
+    }
+}
+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'"));
+}

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

@@ -0,0 +1,33 @@
+import type { WorktreeFileDiff, WorktreeReviewFile } from "../domain/review.js";
+import type { GitCommandRunner } from "./git-command-runner.js";
+import type { GitService } from "./git-service.js";
+interface WorktreeMergeFile extends WorktreeReviewFile {
+    applied: boolean;
+    conflict: boolean;
+}
+export declare class GitSnapshotService {
+    private readonly runner;
+    private readonly git;
+    constructor(runner: GitCommandRunner, git: GitService);
+    fileDiff(cwd: string, filePath: string, maxPreviewBytes?: number): Promise<WorktreeFileDiff>;
+    apply(worktreeRoot: string, sourceRoot: string, requestedPaths?: string[]): Promise<{
+        bytes: number;
+        paths: string[];
+        conflicts: string[];
+    }>;
+    applyState(worktreeRoot: string, sourceRoot: string): Promise<{
+        files: WorktreeMergeFile[];
+    }>;
+    private analyze;
+    private mergeTrees;
+    private snapshot;
+    private treeForPaths;
+    private baseTree;
+    private writeTree;
+    private stageAll;
+    private stateFromIndex;
+    private writeHeadPatch;
+    private writeTreePatch;
+    private withIndex;
+}
+export {};