@chatroomcp/chatroom 0.1.3

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

@@ -0,0 +1,340 @@
+/**
+ * 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)}`;
+}

package/dist/plugins/workspace/infrastructure/workspace-repository.d.ts

@@ -0,0 +1,12 @@
+import type { WorkspaceRecord, WorkspaceStateRepository } from "../domain/repository.js";
+import type { WorkspaceMode } from "../domain/workspace.js";
+import type { AppDatabase } from "../../../infrastructure/database/app-database.js";
+export declare class WorkspaceRepository implements WorkspaceStateRepository {
+    private readonly database;
+    constructor(database: AppDatabase);
+    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/infrastructure/workspace-repository.js

@@ -0,0 +1,51 @@
+export class WorkspaceRepository {
+    database;
+    constructor(database) {
+        this.database = database;
+    }
+    upsert(workspace) {
+        this.database.raw
+            .prepare(`
+          INSERT INTO workspaces(id,root,source_root,mode,created_at,last_used_at)
+          VALUES(?,?,?,?,?,?)
+          ON CONFLICT(id) DO UPDATE SET
+            root=excluded.root,
+            source_root=excluded.source_root,
+            mode=excluded.mode,
+            last_used_at=excluded.last_used_at
+        `)
+            .run(workspace.id, workspace.root, workspace.sourceRoot, workspace.mode, workspace.createdAt, workspace.lastUsedAt);
+    }
+    get(workspaceId) {
+        const row = this.database.raw
+            .prepare("SELECT * FROM workspaces WHERE id=?")
+            .get(workspaceId);
+        return row ? fromRow(row) : null;
+    }
+    findByRoot(root, mode) {
+        const row = this.database.raw
+            .prepare("SELECT * FROM workspaces WHERE root=? AND mode=?")
+            .get(root, mode);
+        return row ? fromRow(row) : null;
+    }
+    list() {
+        return this.database.raw
+            .prepare("SELECT * FROM workspaces ORDER BY last_used_at DESC")
+            .all().map(fromRow);
+    }
+    remove(workspaceId) {
+        this.database.raw
+            .prepare("DELETE FROM workspaces WHERE id=?")
+            .run(workspaceId);
+    }
+}
+function fromRow(row) {
+    return {
+        id: row.id,
+        root: row.root,
+        sourceRoot: row.source_root,
+        mode: row.mode,
+        createdAt: row.created_at,
+        lastUsedAt: row.last_used_at,
+    };
+}

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

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/server";
+import type { OperationLog } from "../../operations/operation-log.js";
+import type { WorkspaceService } from "./workspace-service.js";
+export declare function registerWorkspaceTools(server: McpServer, workspaces: WorkspaceService, operations: OperationLog): void;

package/dist/plugins/workspace/mcp.js

@@ -0,0 +1,168 @@
+import { z } from "zod";
+import { changeSetSchema, closedRead, destructiveLocalMutation, fileInfoSchema, fileReadOutputSchema, fileWriteOutputSchema, localMutation, localWrite, mcpTool, searchMatchSchema, workspaceOutputSchema, } from "../../mcp/server/tool-support.js";
+export function registerWorkspaceTools(server, workspaces, operations) {
+    server.registerTool("open_workspace", {
+        title: "Open workspace",
+        description: "Open or reuse an approved checkout, or create a new isolated managed Git worktree from the source checkout HEAD.",
+        inputSchema: z.object({
+            path: z.string(),
+            mode: z.enum(["checkout", "worktree"]).optional(),
+        }),
+        outputSchema: workspaceOutputSchema,
+        annotations: localMutation,
+    }, mcpTool((input) => operations.run({ pluginId: "workspace", source: "mcp", action: "open", input }, () => workspaces.open({
+        path: input.path,
+        ...(input.mode ? { mode: input.mode } : {}),
+    }))));
+    server.registerTool("remove_workspace", {
+        title: "Remove workspace",
+        description: "Unregister a checkout workspace or remove a managed worktree. Dirty worktrees require force=true.",
+        inputSchema: z.object({
+            workspaceId: z.string(),
+            force: z.boolean().optional(),
+        }),
+        outputSchema: z.object({
+            removed: z.boolean(),
+            workspaceId: z.string(),
+            mode: z.enum(["checkout", "worktree"]),
+        }),
+        annotations: destructiveLocalMutation,
+    }, mcpTool(async (input) => {
+        const removed = await operations.run({
+            pluginId: "workspace",
+            source: "mcp",
+            action: "remove",
+            workspaceId: input.workspaceId,
+            input,
+        }, () => workspaces.remove(input.workspaceId, input.force ?? false));
+        return { removed: true, workspaceId: removed.id, mode: removed.mode };
+    }));
+    server.registerTool("fs_read", {
+        title: "Read file",
+        description: "Read a workspace-relative file through the ChatRoom filesystem boundary.",
+        inputSchema: z.object({
+            workspaceId: z.string(),
+            path: z.string(),
+            maxBytes: z
+                .number()
+                .int()
+                .positive()
+                .max(16 * 1024 * 1024)
+                .optional(),
+        }),
+        outputSchema: fileReadOutputSchema,
+        annotations: closedRead,
+    }, mcpTool(async (input) => {
+        const fs = await workspaces.fs(input.workspaceId);
+        return operations.run({
+            pluginId: "workspace",
+            source: "mcp",
+            action: "fs.read",
+            workspaceId: input.workspaceId,
+            input,
+        }, () => fs.read(input.path, input.maxBytes === undefined ? {} : { maxBytes: input.maxBytes }));
+    }));
+    server.registerTool("fs_write", {
+        title: "Write file",
+        description: "Atomically write a workspace-relative file.",
+        inputSchema: z.object({
+            workspaceId: z.string(),
+            path: z.string(),
+            content: z.string(),
+        }),
+        outputSchema: fileWriteOutputSchema,
+        annotations: localWrite,
+    }, mcpTool(async (input) => {
+        const fs = await workspaces.fs(input.workspaceId);
+        return operations.run({
+            pluginId: "workspace",
+            source: "mcp",
+            action: "fs.write",
+            workspaceId: input.workspaceId,
+            input,
+        }, () => fs.write(input.path, input.content));
+    }));
+    server.registerTool("fs_list", {
+        title: "List files",
+        description: "List files under a workspace-relative directory.",
+        inputSchema: z.object({
+            workspaceId: z.string(),
+            path: z.string().default("."),
+            recursive: z.boolean().default(false),
+        }),
+        outputSchema: z.object({ files: z.array(fileInfoSchema) }),
+        annotations: closedRead,
+    }, mcpTool(async (input) => {
+        const fs = await workspaces.fs(input.workspaceId);
+        return {
+            files: await operations.run({
+                pluginId: "workspace",
+                source: "mcp",
+                action: "fs.list",
+                workspaceId: input.workspaceId,
+                input,
+            }, () => fs.list(input.path, { recursive: input.recursive })),
+        };
+    }));
+    server.registerTool("fs_search", {
+        title: "Search files",
+        description: "Search text under a workspace.",
+        inputSchema: z.object({
+            workspaceId: z.string(),
+            query: z.string().min(1),
+            path: z.string().default("."),
+            maxResults: z.number().int().positive().max(2000).default(200),
+        }),
+        outputSchema: z.object({ matches: z.array(searchMatchSchema) }),
+        annotations: closedRead,
+    }, mcpTool(async (input) => {
+        const fs = await workspaces.fs(input.workspaceId);
+        return {
+            matches: await operations.run({
+                pluginId: "workspace",
+                source: "mcp",
+                action: "fs.search",
+                workspaceId: input.workspaceId,
+                input,
+            }, () => fs.search(input.query, {
+                path: input.path,
+                maxResults: input.maxResults,
+            })),
+        };
+    }));
+    server.registerTool("fs_patch", {
+        title: "Transactional patch",
+        description: "Validate all replacements before committing a multi-file text patch.",
+        inputSchema: z.object({
+            workspaceId: z.string(),
+            replacements: z
+                .array(z.object({
+                path: z.string(),
+                oldText: z.string().min(1),
+                newText: z.string(),
+                occurrence: z
+                    .union([z.number().int().positive(), z.literal("all")])
+                    .optional(),
+            }))
+                .min(1),
+        }),
+        outputSchema: changeSetSchema,
+        annotations: destructiveLocalMutation,
+    }, mcpTool(async (input) => {
+        const fs = await workspaces.fs(input.workspaceId);
+        return operations.run({
+            pluginId: "workspace",
+            source: "mcp",
+            action: "fs.patch",
+            workspaceId: input.workspaceId,
+            input,
+        }, () => fs.patch(input.replacements.map((item) => ({
+            path: item.path,
+            oldText: item.oldText,
+            newText: item.newText,
+            ...(item.occurrence === undefined
+                ? {}
+                : { occurrence: item.occurrence }),
+        }))));
+    }));
+}

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

@@ -0,0 +1,10 @@
+import type { InternalPlugin } from "../types.js";
+import { GitService } from "./git/git-service.js";
+import { WorkspaceService as WorkspaceRuntime } from "./workspace-service.js";
+interface WorkspacePluginService {
+    workspaces: WorkspaceRuntime;
+    git: GitService;
+}
+export declare const WorkspaceService: import("../types.js").ServiceToken<WorkspacePluginService>;
+export declare function createWorkspacePlugin(): InternalPlugin;
+export {};

package/dist/plugins/workspace/plugin.js

@@ -0,0 +1,37 @@
+import { CommandRunner } from "../../core/runtime/command-runner.js";
+import { createServiceToken } from "../types.js";
+import { GitCommandRunner } from "./git/git-command-runner.js";
+import { GitService } from "./git/git-service.js";
+import { GitSnapshotService } from "./git/git-snapshot-service.js";
+import { WorkspaceRepository } from "./infrastructure/workspace-repository.js";
+import { registerWorkspaceTools } from "./mcp.js";
+import { WorkspaceService as WorkspaceRuntime } from "./workspace-service.js";
+import { WorktreeReviewService } from "./worktree-review-service.js";
+export const WorkspaceService = createServiceToken("workspace");
+export function createWorkspacePlugin() {
+    let value = null;
+    let operations = null;
+    return {
+        id: "workspace",
+        async activate(context) {
+            const gitRunner = new GitCommandRunner(new CommandRunner());
+            const git = new GitService(gitRunner);
+            const snapshots = new GitSnapshotService(gitRunner, git);
+            const review = new WorktreeReviewService(git, snapshots);
+            const workspaces = await WorkspaceRuntime.create(new WorkspaceRepository(context.database), git, review, context.config.allowedRoots, context.config.dataDir);
+            await workspaces.discoverGitWorkspaces();
+            value = { workspaces, git };
+            operations = context.operations;
+            context.services.provide(WorkspaceService, value);
+        },
+        registerMcp(server) {
+            if (!value || !operations)
+                throw new Error("Workspace plugin is not active");
+            registerWorkspaceTools(server, value.workspaces, operations);
+        },
+        deactivate() {
+            value = null;
+            operations = null;
+        },
+    };
+}

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

@@ -0,0 +1,9 @@
+import type { WorkspaceFs } from "./infrastructure/workspace-fs.js";
+import type { WorkspaceRecord } from "./domain/repository.js";
+import type { Workspace } from "./domain/workspace.js";
+export declare function discoverInstructions(fs: WorkspaceFs): Promise<string[]>;
+export declare function discoverSkills(fs: WorkspaceFs): Promise<string[]>;
+export declare function expandHome(input: string): string;
+export declare function inside(root: string, candidate: string): boolean;
+export declare function exists(target: string): Promise<boolean>;
+export declare function toRecord(workspace: Workspace): WorkspaceRecord;