@chatroomcp/chatroom 0.2.0 → 0.2.2

package/dist/plugins/workspace/{infrastructure/workspace-fs.d.ts → workspace-fs.d.ts}

@@ -1,7 +1,6 @@
-import type { ChangeSet, FileInfo, PatchReplacement, SearchMatch } from "../domain/filesystem.js";
+import type { WorkspaceFile } from "./types.js";
 export declare class WorkspaceFs {
     readonly root: string;
-    private readonly realRoot;
     private constructor();
     static create(root: string): Promise<WorkspaceFs>;
     read(relativePath: string, options?: {
@@ -18,21 +17,9 @@ export declare class WorkspaceFs {
         bytes: number;
         truncated: boolean;
     }>;
-    write(relativePath: string, content: string): Promise<{
-        path: string;
-        bytes: number;
-    }>;
     list(relativePath?: string, options?: {
         recursive?: boolean;
         maxEntries?: number;
-    }): Promise<FileInfo[]>;
-    search(query: string, options?: {
-        path?: string;
-        maxResults?: number;
-    }): Promise<SearchMatch[]>;
-    patch(replacements: PatchReplacement[]): Promise<ChangeSet>;
-    private normalizeRelative;
-    private lexical;
+    }): Promise<WorkspaceFile[]>;
     private resolveReadable;
-    private resolveWritable;
 }

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

@@ -0,0 +1,111 @@
+import { lstat, open, readdir, realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import { ChatRoomError } from "../../core/errors/chatroom-error.js";
+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 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;
+    }
+    async resolveReadable(relativePath) {
+        const normalized = normalizeRelative(relativePath);
+        const lexical = path.resolve(this.root, ...normalized.split("/"));
+        if (!inside(this.root, lexical))
+            throw new ChatRoomError("FORBIDDEN", "Path escapes workspace");
+        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

@@ -1,46 +1,11 @@
-import type { Workspace, WorkspaceMode } from "./domain/workspace.js";
-import type { WorkspaceStateRepository } from "./domain/repository.js";
-import { WorkspaceFs } from "./infrastructure/workspace-fs.js";
-import type { GitService } from "./git/git-service.js";
-import type { WorktreeReviewService } from "./worktree-review-service.js";
-interface OpenWorkspaceRequest {
-    path: string;
-    mode?: WorkspaceMode;
-}
+import type { WorkspaceEntry, WorkspaceInfo } from "./types.js";
+import { WorkspaceFs } from "./workspace-fs.js";
 export declare class WorkspaceService {
-    private readonly repository;
-    private readonly git;
-    private readonly review;
     private readonly allowedRoots;
-    private readonly dataDir;
-    private readonly pending;
-    private readonly filesystems;
-    private readonly workspaces;
     private constructor();
-    static create(repository: WorkspaceStateRepository, git: GitService, review: WorktreeReviewService, allowedRoots: string[], dataDir: string): Promise<WorkspaceService>;
-    open(request: OpenWorkspaceRequest): Promise<Workspace>;
-    get(workspaceId: string): Workspace;
-    list(): Workspace[];
-    discoverGitWorkspaces(): Promise<Workspace[]>;
-    private discoverGitWorkspace;
-    markUsed(workspaceId: string): Workspace;
-    fs(workspaceId: string): Promise<WorkspaceFs>;
-    refresh(workspaceId: string): Promise<Workspace>;
-    remove(workspaceId: string, force?: boolean): Promise<Workspace>;
-    previewWorktreeApply(workspaceId: string): Promise<import("./domain/review.js").WorktreeApplyPreview>;
-    previewWorktreeFileDiff(workspaceId: string, filePath: string): Promise<import("./domain/review.js").WorktreeFileDiff>;
-    applyWorktree(workspaceId: string, paths?: string[]): Promise<{
-        workspaceId: string;
-        bytes: number;
-        paths: string[];
-        conflicts: string[];
-    }>;
-    private openLocked;
-    private createWorkspace;
-    private restorePersistedWorkspaces;
-    private isRecordValid;
-    private reconcileManagedWorktrees;
-    private removeManagedContainer;
-    private validateSourceRoot;
+    static create(allowedRoots: string[]): Promise<WorkspaceService>;
+    list(): Promise<WorkspaceEntry[]>;
+    resolve(input: string): Promise<string>;
+    info(input: string): Promise<WorkspaceInfo>;
+    fs(input: string): Promise<WorkspaceFs>;
 }
-export {};

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

@@ -1,339 +1,85 @@
-/**
- * Owns persistent Workspace identity, allowed-root validation, checkout/worktree creation, and workspace capabilities.
- * Workspace lifetime is deliberately independent from MCP or HTTP connection lifetime.
- */
-import { existsSync, realpathSync } from "node:fs";
-import { mkdir, readdir, realpath, rm } from "node:fs/promises";
+import { readdir, realpath, stat } from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
-import { randomUUID } from "node:crypto";
 import { ChatRoomError } from "../../core/errors/chatroom-error.js";
-import { WorkspaceFs } from "./infrastructure/workspace-fs.js";
-import { discoverInstructions, discoverSkills, exists, expandHome, inside, toRecord, } from "./workspace-helpers.js";
+import { readInstructions, readSkills } from "./metadata.js";
+import { WorkspaceFs } from "./workspace-fs.js";
 export class WorkspaceService {
-    repository;
-    git;
-    review;
     allowedRoots;
-    dataDir;
-    pending = new Map();
-    filesystems = new Map();
-    workspaces = new Map();
-    constructor(repository, git, review, allowedRoots, dataDir) {
-        this.repository = repository;
-        this.git = git;
-        this.review = review;
+    constructor(allowedRoots) {
         this.allowedRoots = allowedRoots;
-        this.dataDir = dataDir;
     }
-    static async create(repository, git, review, allowedRoots, dataDir) {
-        // Canonicalize allowed roots once at startup so later comparisons use stable real paths.
-        const canonicalRoots = [];
-        for (const root of allowedRoots) {
-            const expanded = expandHome(root);
-            const canonical = await realpath(expanded).catch(() => {
+    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}`);
             });
-            canonicalRoots.push(canonical);
-        }
-        await mkdir(path.join(dataDir, "worktrees"), {
-            recursive: true,
-            mode: 0o700,
-        });
-        const service = new WorkspaceService(repository, git, review, canonicalRoots, dataDir);
-        await service.restorePersistedWorkspaces();
-        await service.reconcileManagedWorktrees();
-        return service;
-    }
-    async open(request) {
-        const mode = request.mode ?? "checkout";
-        const sourceRoot = await this.validateSourceRoot(request.path);
-        if (mode === "worktree")
-            return this.openLocked(sourceRoot, mode);
-        const key = `checkout:${sourceRoot}`;
-        // Coalesce concurrent opens of the same logical workspace instead of racing worktree creation or persistence.
-        const existingPending = this.pending.get(key);
-        if (existingPending)
-            return existingPending;
-        const operation = this.openLocked(sourceRoot, mode).finally(() => this.pending.delete(key));
-        this.pending.set(key, operation);
-        return operation;
-    }
-    get(workspaceId) {
-        const workspace = this.workspaces.get(workspaceId);
-        if (!workspace)
-            throw new ChatRoomError("NOT_FOUND", `Unknown WorkspaceId: ${workspaceId}`);
-        if (!this.isRecordValid(workspace)) {
-            this.filesystems.delete(workspace.id);
-            this.workspaces.delete(workspace.id);
-            this.repository.remove(workspace.id);
-            throw new ChatRoomError("NOT_FOUND", `Workspace no longer exists: ${workspaceId}`);
-        }
-        return workspace;
-    }
-    list() {
-        const valid = [];
-        for (const workspace of this.workspaces.values()) {
-            if (this.isRecordValid(workspace)) {
-                valid.push(workspace);
-                continue;
-            }
-            this.filesystems.delete(workspace.id);
-            this.workspaces.delete(workspace.id);
-            this.repository.remove(workspace.id);
-        }
-        return valid.sort((a, b) => b.lastUsedAt.localeCompare(a.lastUsedAt));
-    }
-    async discoverGitWorkspaces() {
-        for (const root of this.allowedRoots) {
-            await this.discoverGitWorkspace(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)]);
+    }
+    async list() {
+        const roots = new Set();
+        for (const allowedRoot of this.allowedRoots) {
             let entries;
             try {
-                entries = await readdir(root, { withFileTypes: true });
+                entries = await readdir(allowedRoot, { withFileTypes: true });
             }
             catch {
                 continue;
             }
             for (const entry of entries) {
-                if (!entry.isDirectory() || entry.isSymbolicLink())
+                if (!entry.isDirectory() ||
+                    entry.isSymbolicLink() ||
+                    entry.name.startsWith("."))
                     continue;
-                await this.discoverGitWorkspace(path.join(root, entry.name));
-            }
-        }
-        return this.list();
-    }
-    async discoverGitWorkspace(candidate) {
-        if (!(await exists(path.join(candidate, ".git"))))
-            return;
-        const existing = [...this.workspaces.values()].find((workspace) => workspace.root === candidate && workspace.mode === "checkout");
-        if (existing && this.isRecordValid(existing))
-            return;
-        if (existing) {
-            this.workspaces.delete(existing.id);
-            this.repository.remove(existing.id);
-        }
-        await this.createWorkspace(candidate, candidate, "checkout");
-    }
-    markUsed(workspaceId) {
-        const workspace = this.get(workspaceId);
-        workspace.lastUsedAt = new Date().toISOString();
-        this.repository.upsert(toRecord(workspace));
-        return workspace;
-    }
-    async fs(workspaceId) {
-        const workspace = this.markUsed(workspaceId);
-        const existing = this.filesystems.get(workspaceId);
-        if (existing)
-            return existing;
-        const filesystem = await WorkspaceFs.create(workspace.root);
-        this.filesystems.set(workspaceId, filesystem);
-        return filesystem;
-    }
-    async refresh(workspaceId) {
-        const workspace = this.get(workspaceId);
-        const fs = await this.fs(workspaceId);
-        const gitInfo = await this.git.info(workspace.root);
-        workspace.instructions = await discoverInstructions(fs);
-        workspace.skills = await discoverSkills(fs);
-        workspace.capabilities = {
-            filesystem: "read-write",
-            git: gitInfo.isRepository,
-            skills: workspace.skills.length > 0,
-        };
-        return workspace;
-    }
-    async remove(workspaceId, force = false) {
-        const workspace = this.get(workspaceId);
-        if (workspace.mode === "checkout") {
-            this.filesystems.delete(workspace.id);
-            this.workspaces.delete(workspace.id);
-            this.repository.remove(workspace.id);
-            return workspace;
-        }
-        const gitInfo = await this.git.info(workspace.root);
-        if (gitInfo.dirty && !force)
-            throw new ChatRoomError("CONFLICT", "Worktree contains uncommitted changes");
-        await this.git.removeWorktree(workspace.sourceRoot, workspace.root, force);
-        await this.git.pruneWorktrees(workspace.sourceRoot).catch(() => undefined);
-        this.filesystems.delete(workspace.id);
-        this.workspaces.delete(workspace.id);
-        this.repository.remove(workspace.id);
-        await this.removeManagedContainer(workspace.root);
-        return workspace;
-    }
-    async previewWorktreeApply(workspaceId) {
-        return this.review.preview(this.get(workspaceId));
-    }
-    async previewWorktreeFileDiff(workspaceId, filePath) {
-        return this.review.fileDiff(this.get(workspaceId), filePath);
-    }
-    async applyWorktree(workspaceId, paths) {
-        const workspace = this.get(workspaceId);
-        const result = await this.review.apply(workspace, paths);
-        this.markUsed(workspace.id);
-        return { workspaceId: workspace.id, ...result };
-    }
-    async openLocked(sourceRoot, mode) {
-        if (mode === "checkout") {
-            const existing = [...this.workspaces.values()].find((workspace) => workspace.root === sourceRoot && workspace.mode === "checkout");
-            if (existing) {
-                this.filesystems.set(existing.id, await WorkspaceFs.create(existing.root));
-                return this.refresh(existing.id);
+                const candidate = await realpath(path.join(allowedRoot, entry.name)).catch(() => null);
+                if (candidate && inside(allowedRoot, candidate))
+                    roots.add(candidate);
             }
-            return this.createWorkspace(sourceRoot, sourceRoot, mode);
-        }
-        const uuid = randomUUID();
-        const id = `ws_${uuid}`;
-        const container = path.join(this.dataDir, "worktrees", uuid.replaceAll("-", "").slice(0, 8));
-        const target = path.join(container, path.basename(sourceRoot) || "workspace");
-        await mkdir(container, { recursive: true, mode: 0o700 });
-        let worktreeCreated = false;
-        try {
-            await this.git.createWorktree(sourceRoot, target);
-            worktreeCreated = true;
-            return await this.createWorkspace(target, sourceRoot, mode, id);
-        }
-        catch (error) {
-            this.filesystems.delete(id);
-            this.workspaces.delete(id);
-            this.repository.remove(id);
-            if (worktreeCreated)
-                await this.git
-                    .removeWorktree(sourceRoot, target, true)
-                    .catch(() => undefined);
-            await this.git.pruneWorktrees(sourceRoot).catch(() => undefined);
-            await rm(container, { recursive: true, force: true }).catch(() => undefined);
-            throw error;
         }
+        return [...roots]
+            .sort((a, b) => a.localeCompare(b))
+            .map((root) => ({ root }));
     }
-    async createWorkspace(root, sourceRoot, mode, id = `ws_${randomUUID()}`) {
-        const fs = await WorkspaceFs.create(root);
-        this.filesystems.set(id, fs);
-        const gitInfo = await this.git.info(root);
-        const now = new Date().toISOString();
-        const skills = await discoverSkills(fs);
-        const workspace = {
-            id,
-            root,
-            sourceRoot,
-            mode,
-            createdAt: now,
-            lastUsedAt: now,
-            instructions: await discoverInstructions(fs),
-            skills,
-            capabilities: {
-                filesystem: "read-write",
-                git: gitInfo.isRepository,
-                skills: skills.length > 0,
-            },
-        };
-        this.workspaces.set(workspace.id, workspace);
-        this.repository.upsert(toRecord(workspace));
-        return workspace;
-    }
-    async restorePersistedWorkspaces() {
-        for (const record of this.repository.list()) {
-            if (!this.isRecordValid(record)) {
-                this.repository.remove(record.id);
-                if (record.mode === "worktree")
-                    await this.removeManagedContainer(record.root);
-                continue;
-            }
-            try {
-                const fs = await WorkspaceFs.create(record.root);
-                const gitInfo = await this.git.info(record.root);
-                const skills = await discoverSkills(fs);
-                const workspace = {
-                    ...record,
-                    instructions: await discoverInstructions(fs),
-                    skills,
-                    capabilities: {
-                        filesystem: "read-write",
-                        git: gitInfo.isRepository,
-                        skills: skills.length > 0,
-                    },
-                };
-                this.filesystems.set(record.id, fs);
-                this.workspaces.set(record.id, workspace);
-            }
-            catch {
-                this.repository.remove(record.id);
-                if (record.mode === "worktree")
-                    await this.removeManagedContainer(record.root);
-            }
-        }
-    }
-    isRecordValid(record) {
-        if (!existsSync(record.root) || !existsSync(record.sourceRoot))
-            return false;
-        try {
-            const sourceRoot = realpathSync(record.sourceRoot);
-            if (!this.allowedRoots.some((root) => inside(root, sourceRoot)))
-                return false;
-            if (record.mode === "checkout")
-                return realpathSync(record.root) === sourceRoot;
-            const managedRoot = realpathSync(path.join(this.dataDir, "worktrees"));
-            return inside(managedRoot, realpathSync(record.root));
-        }
-        catch {
-            return false;
-        }
-    }
-    async reconcileManagedWorktrees() {
-        const pruned = new Set();
-        for (const workspace of [...this.workspaces.values()]) {
-            if (workspace.mode !== "worktree")
-                continue;
-            if (await exists(workspace.sourceRoot)) {
-                if (!pruned.has(workspace.sourceRoot)) {
-                    await this.git
-                        .pruneWorktrees(workspace.sourceRoot)
-                        .catch(() => undefined);
-                    pruned.add(workspace.sourceRoot);
-                }
-            }
-            if (await exists(workspace.root))
-                continue;
-            this.filesystems.delete(workspace.id);
-            this.workspaces.delete(workspace.id);
-            this.repository.remove(workspace.id);
-            await this.removeManagedContainer(workspace.root);
-        }
-        const managedRoot = path.join(this.dataDir, "worktrees");
-        const knownContainers = new Set([...this.workspaces.values()]
-            .filter((workspace) => workspace.mode === "worktree")
-            .map((workspace) => path.resolve(path.dirname(workspace.root))));
-        for (const entry of await readdir(managedRoot, { withFileTypes: true })) {
-            const container = path.resolve(managedRoot, entry.name);
-            if (knownContainers.has(container))
-                continue;
-            if (entry.isSymbolicLink()) {
-                await rm(container, { force: true }).catch(() => undefined);
-                continue;
-            }
-            if (entry.isDirectory())
-                await rm(container, { recursive: true, force: true });
-        }
-    }
-    async removeManagedContainer(worktreeRoot) {
-        const managedRoot = path.join(this.dataDir, "worktrees");
-        if (!inside(managedRoot, worktreeRoot))
-            return;
-        const container = path.dirname(worktreeRoot);
-        if (container === managedRoot)
-            return;
-        await rm(container, { recursive: true, force: true }).catch(() => undefined);
-    }
-    async validateSourceRoot(input) {
-        if (!input || typeof input !== "string")
-            throw new ChatRoomError("INVALID_INPUT", "Workspace path is required");
+    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 path does not exist: ${input}`);
+            throw new ChatRoomError("NOT_FOUND", `Workspace root does not exist: ${input}`);
         });
-        if (!this.allowedRoots.some((root) => inside(root, canonical))) {
-            throw new ChatRoomError("FORBIDDEN", "Workspace is outside configured allowedRoots", {
-                path: canonical,
-            });
-        }
+        if (!(await stat(canonical)).isDirectory())
+            throw new ChatRoomError("INVALID_INPUT", `Workspace root is not a directory: ${input}`);
+        if (!this.allowedRoots.some((root) => inside(root, canonical)))
+            throw new ChatRoomError("FORBIDDEN", "Workspace is outside configured allowedRoots", { root: canonical });
         return canonical;
     }
+    async info(input) {
+        const root = await this.resolve(input);
+        const fs = await WorkspaceFs.create(root);
+        const [instructions, skills] = await Promise.all([
+            readInstructions(fs),
+            readSkills(fs),
+        ]);
+        return { root, instructions, skills };
+    }
+    async fs(input) {
+        return WorkspaceFs.create(await this.resolve(input));
+    }
+}
+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);
+}
+function inside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return (relative === "" ||
+        (!relative.startsWith(`..${path.sep}`) &&
+            relative !== ".." &&
+            !path.isAbsolute(relative)));
 }

package/dist/presentation/http/http-utils.d.ts

@@ -1,4 +1,3 @@
-/** Shared Express helpers for async error propagation and typed ChatRoom error responses. */
 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;

package/dist/presentation/http/oauth-router.d.ts

@@ -1,4 +1,3 @@
-/** OAuth and owner-session HTTP routes backed by AuthService rather than protocol-specific persistence logic. */
 import { Router } from "express";
 import type { AuthService } from "../../auth/auth-service.js";
 import type { IngressPolicy } from "../../auth/ingress-policy.js";

package/dist/presentation/http/oauth-router.js

@@ -1,4 +1,3 @@
-/** OAuth and owner-session HTTP routes backed by AuthService rather than protocol-specific persistence logic. */
 import { Router } from "express";
 import { asChatRoomError, ChatRoomError, } from "../../core/errors/chatroom-error.js";
 import { escapeHtml, requireString } from "./http-utils.js";