chatccc 0.2.252 → 0.2.254

package/dist/src/agent-team/http/board-routes.js

@@ -0,0 +1,213 @@
+import { AGENT_TOOL_OPTIONS, isAgentTool } from "../../agent-tool.js";
+import { readUtf8JsonBody } from "../../agent-rpc-body.js";
+import { BoardService } from "../application/board-service.js";
+import { NodeFilesystemBrowser } from "../infrastructure/filesystem-browser.js";
+import { JsonBoardRepository } from "../repositories/json-board-repository.js";
+import { BoardStoreError } from "../repositories/board-repository.js";
+const API_PREFIX = "/api/agent-team";
+const MAX_REQUEST_BYTES = 256 * 1024;
+export function createAgentTeamRequestHandler(options) {
+    const defaultWorkspace = options.defaultWorkspace ?? process.cwd();
+    const filesystemBrowser = options.filesystemBrowser ?? new NodeFilesystemBrowser({ defaultDirectory: defaultWorkspace });
+    const mainAgentService = () => {
+        if (typeof options.mainAgentService === "function")
+            return options.mainAgentService();
+        return options.mainAgentService ?? null;
+    };
+    return async function handleAgentTeamRequest(req, res) {
+        const url = new URL(req.url ?? "/", "http://127.0.0.1");
+        const pathname = url.pathname;
+        const method = req.method ?? "GET";
+        if (pathname !== API_PREFIX && !pathname.startsWith(`${API_PREFIX}/`))
+            return false;
+        try {
+            if (pathname === `${API_PREFIX}/workspaces` && method === "GET") {
+                jsonReply(res, 200, {
+                    ok: true,
+                    defaultWorkspace,
+                    agentOptions: AGENT_TOOL_OPTIONS,
+                    workspaces: await options.service.listWorkspaces(),
+                });
+                return true;
+            }
+            if (pathname === `${API_PREFIX}/filesystem/locations` && method === "GET") {
+                jsonReply(res, 200, { ok: true, locations: await filesystemBrowser.listLocations() });
+                return true;
+            }
+            if (pathname === `${API_PREFIX}/filesystem/directories` && method === "POST") {
+                const body = await bodyJson(req);
+                const directory = await filesystemBrowser.listDirectories(stringField(body.path, "path"), optionalBooleanField(body.showHidden, "showHidden"));
+                jsonReply(res, 200, { ok: true, directory });
+                return true;
+            }
+            if (pathname === `${API_PREFIX}/filesystem/validate-directory` && method === "POST") {
+                const body = await bodyJson(req);
+                jsonReply(res, 200, { ok: true, path: await filesystemBrowser.validateDirectory(stringField(body.path, "path")) });
+                return true;
+            }
+            if (pathname === `${API_PREFIX}/lookup` && method === "POST") {
+                const body = await bodyJson(req);
+                const board = await options.service.findWorkspace(stringField(body.workspacePath, "workspacePath"));
+                jsonReply(res, 200, board
+                    ? { ok: true, exists: true, boardId: board.boardId }
+                    : { ok: true, exists: false });
+                return true;
+            }
+            if (pathname === `${API_PREFIX}/open` && method === "POST") {
+                const body = await bodyJson(req);
+                const board = await options.service.openWorkspace(stringField(body.workspacePath, "workspacePath"));
+                jsonReply(res, 200, { ok: true, board, binding: await mainAgentService()?.getBinding(board.boardId) ?? null });
+                return true;
+            }
+            if (pathname === `${API_PREFIX}/feishu-contact` && method === "GET") {
+                const manager = requireMainAgentService(mainAgentService());
+                jsonReply(res, 200, { ok: true, contact: await manager.getContact() });
+                return true;
+            }
+            const boardMatch = pathname.match(/^\/api\/agent-team\/boards\/([^/]+)$/);
+            if (boardMatch && method === "GET") {
+                const boardId = decodeURIComponent(boardMatch[1]);
+                jsonReply(res, 200, {
+                    ok: true,
+                    board: await options.service.getBoard(boardId),
+                    binding: await mainAgentService()?.getBinding(boardId) ?? null,
+                });
+                return true;
+            }
+            const relinkMatch = pathname.match(/^\/api\/agent-team\/boards\/([^/]+)\/relink$/);
+            if (relinkMatch && method === "POST") {
+                const body = await bodyJson(req);
+                const boardId = decodeURIComponent(relinkMatch[1]);
+                const workspacePath = stringField(body.workspacePath, "workspacePath");
+                const revision = revisionField(body.expectedRevision);
+                const manager = mainAgentService();
+                const result = manager
+                    ? await manager.relinkWorkspace(boardId, workspacePath, revision)
+                    : { board: await options.service.relinkWorkspace(boardId, workspacePath, revision), binding: null };
+                jsonReply(res, 200, { ok: true, ...result });
+                return true;
+            }
+            const mainAgentMatch = pathname.match(/^\/api\/agent-team\/boards\/([^/]+)\/main-agent$/);
+            if (mainAgentMatch && method === "POST") {
+                const body = await bodyJson(req);
+                if (!isAgentTool(body.agentId)) {
+                    throw new BoardStoreError("invalid_request", `Unsupported primary Agent: ${String(body.agentId)}`, 400);
+                }
+                const result = await requireMainAgentService(mainAgentService()).setPrimaryAgent(decodeURIComponent(mainAgentMatch[1]), body.agentId, revisionField(body.expectedRevision));
+                jsonReply(res, 200, { ok: true, ...result });
+                return true;
+            }
+            const tasksMatch = pathname.match(/^\/api\/agent-team\/boards\/([^/]+)\/tasks$/);
+            if (tasksMatch && method === "POST") {
+                const body = await bodyJson(req);
+                const board = await options.service.createTask(decodeURIComponent(tasksMatch[1]), {
+                    expectedRevision: revisionField(body.expectedRevision),
+                    title: stringField(body.title, "title"),
+                    description: optionalString(body.description, "description"),
+                    columnId: body.columnId,
+                });
+                jsonReply(res, 200, { ok: true, board });
+                return true;
+            }
+            const moveMatch = pathname.match(/^\/api\/agent-team\/boards\/([^/]+)\/tasks\/([^/]+)\/move$/);
+            if (moveMatch && method === "POST") {
+                const body = await bodyJson(req);
+                const board = await options.service.moveTask(decodeURIComponent(moveMatch[1]), decodeURIComponent(moveMatch[2]), {
+                    expectedRevision: revisionField(body.expectedRevision),
+                    columnId: body.columnId,
+                    index: integerField(body.index, "index"),
+                });
+                jsonReply(res, 200, { ok: true, board });
+                return true;
+            }
+            const taskMatch = pathname.match(/^\/api\/agent-team\/boards\/([^/]+)\/tasks\/([^/]+)$/);
+            if (taskMatch && method === "PATCH") {
+                const body = await bodyJson(req);
+                const board = await options.service.updateTask(decodeURIComponent(taskMatch[1]), decodeURIComponent(taskMatch[2]), {
+                    expectedRevision: revisionField(body.expectedRevision),
+                    title: stringField(body.title, "title"),
+                    description: optionalString(body.description, "description"),
+                });
+                jsonReply(res, 200, { ok: true, board });
+                return true;
+            }
+            if (taskMatch && method === "DELETE") {
+                const body = await bodyJson(req);
+                const board = await options.service.deleteTask(decodeURIComponent(taskMatch[1]), decodeURIComponent(taskMatch[2]), {
+                    expectedRevision: revisionField(body.expectedRevision),
+                });
+                jsonReply(res, 200, { ok: true, board });
+                return true;
+            }
+            jsonReply(res, 404, { ok: false, code: "not_found", error: "Agent Team API route not found" });
+            return true;
+        }
+        catch (err) {
+            const error = normalizeError(err);
+            jsonReply(res, error.status, { ok: false, code: error.code, error: error.message });
+            return true;
+        }
+    };
+}
+export const defaultAgentTeamBoardService = new BoardService(new JsonBoardRepository());
+let defaultMainAgentService = null;
+export const handleAgentTeamRequest = createAgentTeamRequestHandler({
+    service: defaultAgentTeamBoardService,
+    mainAgentService: () => defaultMainAgentService,
+});
+export function setDefaultAgentTeamMainAgentService(service) {
+    defaultMainAgentService = service;
+}
+function requireMainAgentService(service) {
+    if (!service) {
+        throw new BoardStoreError("main_agent_unavailable", "飞书主 Agent 服务尚未启动", 503);
+    }
+    return service;
+}
+async function bodyJson(req) {
+    try {
+        return await readUtf8JsonBody(req, MAX_REQUEST_BYTES);
+    }
+    catch (err) {
+        throw new BoardStoreError("invalid_request", `Invalid request body: ${err.message}`, 400);
+    }
+}
+function jsonReply(res, status, value) {
+    res.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+    res.end(JSON.stringify(value));
+}
+function normalizeError(err) {
+    if (err instanceof BoardStoreError)
+        return err;
+    return new BoardStoreError("storage_error", err instanceof Error ? err.message : String(err), 500);
+}
+function stringField(value, name) {
+    if (typeof value !== "string" || !value.trim())
+        throw new BoardStoreError("invalid_request", `${name} must be a non-empty string`, 400);
+    return value;
+}
+function optionalString(value, name) {
+    if (value === undefined || value === null)
+        return "";
+    if (typeof value !== "string")
+        throw new BoardStoreError("invalid_request", `${name} must be a string`, 400);
+    return value;
+}
+function optionalBooleanField(value, name) {
+    if (value === undefined || value === null)
+        return false;
+    if (typeof value !== "boolean")
+        throw new BoardStoreError("invalid_request", `${name} must be a boolean`, 400);
+    return value;
+}
+function integerField(value, name) {
+    if (!Number.isInteger(value))
+        throw new BoardStoreError("invalid_request", `${name} must be an integer`, 400);
+    return value;
+}
+function revisionField(value) {
+    const revision = integerField(value, "expectedRevision");
+    if (revision < 0)
+        throw new BoardStoreError("invalid_request", "expectedRevision must be non-negative", 400);
+    return revision;
+}

package/dist/src/agent-team/infrastructure/filesystem-browser.js

@@ -0,0 +1,112 @@
+import { readdir, realpath, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, parse, resolve } from "node:path";
+import { BoardStoreError } from "../repositories/board-repository.js";
+export class NodeFilesystemBrowser {
+    defaultDirectory;
+    homeDirectory;
+    platform;
+    constructor(options = {}) {
+        this.defaultDirectory = options.defaultDirectory ?? process.cwd();
+        this.homeDirectory = options.homeDirectory ?? homedir();
+        this.platform = options.platform ?? process.platform;
+    }
+    async listLocations() {
+        const current = await this.validateDirectory(this.defaultDirectory);
+        const home = await this.validateDirectory(this.homeDirectory);
+        const locations = [
+            { label: "当前工作目录", path: current, kind: "current" },
+            { label: "用户目录", path: home, kind: "home" },
+        ];
+        if (this.platform === "win32") {
+            const drives = await availableWindowsDrives();
+            for (const drive of drives) {
+                if (!locations.some((location) => samePath(location.path, drive, this.platform))) {
+                    locations.push({ label: drive, path: drive, kind: "drive" });
+                }
+            }
+        }
+        else if (!locations.some((location) => location.path === "/")) {
+            locations.push({ label: "根目录", path: "/", kind: "root" });
+        }
+        return locations;
+    }
+    async listDirectories(inputPath, showHidden) {
+        const canonical = await this.validateDirectory(inputPath);
+        let children;
+        try {
+            children = await readdir(canonical, { withFileTypes: true });
+        }
+        catch (err) {
+            throw filesystemError(err, `无法读取目录：${canonical}`);
+        }
+        const entries = (await Promise.all(children.map(async (child) => {
+            const hidden = child.name.startsWith(".");
+            if (hidden && !showHidden)
+                return null;
+            const childPath = join(canonical, child.name);
+            if (child.isDirectory())
+                return { name: child.name, path: childPath, hidden };
+            if (!child.isSymbolicLink())
+                return null;
+            try {
+                return (await stat(childPath)).isDirectory() ? { name: child.name, path: childPath, hidden } : null;
+            }
+            catch {
+                return null;
+            }
+        }))).filter((entry) => entry !== null);
+        entries.sort((a, b) => a.name.localeCompare(b.name, "zh-CN", { numeric: true, sensitivity: "base" }));
+        const parent = dirname(canonical);
+        return { path: canonical, parentPath: samePath(parent, canonical, this.platform) ? null : parent, entries };
+    }
+    async validateDirectory(inputPath) {
+        if (typeof inputPath !== "string" || !inputPath.trim()) {
+            throw new BoardStoreError("invalid_request", "目录路径不能为空", 400);
+        }
+        const absolute = resolve(inputPath.trim());
+        try {
+            const info = await stat(absolute);
+            if (!info.isDirectory())
+                throw new BoardStoreError("invalid_request", `不是目录：${absolute}`, 400);
+            return await realpath(absolute);
+        }
+        catch (err) {
+            if (err instanceof BoardStoreError)
+                throw err;
+            throw filesystemError(err, `目录不存在或无法访问：${absolute}`);
+        }
+    }
+}
+async function availableWindowsDrives() {
+    const candidates = Array.from({ length: 26 }, (_, index) => `${String.fromCharCode(65 + index)}:\\`);
+    const results = await Promise.all(candidates.map(async (drive) => await isDriveAvailable(drive) ? drive : null));
+    return results.filter((drive) => drive !== null);
+}
+function isDriveAvailable(drive) {
+    return new Promise((resolveAvailability) => {
+        let settled = false;
+        const finish = (available) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            resolveAvailability(available);
+        };
+        const timeout = setTimeout(() => finish(false), 350);
+        stat(drive).then((info) => finish(info.isDirectory())).catch(() => finish(false));
+    });
+}
+function samePath(left, right, platform) {
+    const normalize = (value) => {
+        const root = parse(value).root;
+        const trimmed = value === root ? value : value.replace(/[\\/]+$/, "");
+        return platform === "win32" ? trimmed.toLocaleLowerCase("en-US") : trimmed;
+    };
+    return normalize(left) === normalize(right);
+}
+function filesystemError(err, message) {
+    const code = err?.code;
+    const detail = code === "EACCES" || code === "EPERM" ? "（权限不足）" : "";
+    return new BoardStoreError("invalid_request", `${message}${detail}`, 400);
+}

package/dist/src/agent-team/infrastructure/main-agent-session-runtime.js

@@ -0,0 +1,30 @@
+import { sessionPrefixForTool, setDefaultCwd } from "../../config.js";
+import { isSessionRunning } from "../../session-chat-binding.js";
+import { initClaudeSession, recordChatPlatform, switchChatBinding, } from "../../session.js";
+export function createMainAgentSessionRuntime(platform) {
+    return {
+        createSession(agentId, cwd) {
+            return initClaudeSession(agentId, cwd);
+        },
+        isSessionRunning,
+        async bindSession(input) {
+            const description = `${sessionPrefixForTool(input.agentId)} ${input.newSessionId}`;
+            const result = await switchChatBinding({
+                chatId: input.chatId,
+                chatType: "group",
+                oldSessionId: input.oldSessionId,
+                newSessionId: input.newSessionId,
+                tool: input.agentId,
+                chatName: input.chatName,
+                namePolicy: "fixed",
+                newDescription: description,
+                updateChatInfoFn: (chatId, name, nextDescription) => platform.updateChatInfo(chatId, name, nextDescription),
+            });
+            if (!result.ok)
+                throw result.error ?? new Error("Failed to bind main Agent session");
+            await setDefaultCwd(input.cwd, input.chatId);
+            recordChatPlatform(input.chatId, platform);
+            await platform.setChatAvatar(input.chatId, input.agentId, "new").catch(() => { });
+        },
+    };
+}

package/dist/src/agent-team/main-agent-bootstrap.js

@@ -0,0 +1,15 @@
+import { MainAgentService } from "./application/main-agent-service.js";
+import { defaultAgentTeamBoardService, setDefaultAgentTeamMainAgentService, } from "./http/board-routes.js";
+import { createMainAgentSessionRuntime } from "./infrastructure/main-agent-session-runtime.js";
+import { feishuP2pContactStore } from "./repositories/feishu-p2p-contact-store.js";
+import { JsonMainAgentBindingRepository } from "./repositories/main-agent-binding-repository.js";
+/** Wire runtime dependencies only from index.ts, keeping the standalone Web UI import side-effect free. */
+export function configureAgentTeamMainAgent(platform) {
+    setDefaultAgentTeamMainAgentService(new MainAgentService({
+        boardService: defaultAgentTeamBoardService,
+        bindingRepository: new JsonMainAgentBindingRepository(),
+        contactStore: feishuP2pContactStore,
+        platform,
+        runtime: createMainAgentSessionRuntime(platform),
+    }));
+}

package/dist/src/agent-team/repositories/board-repository.js

@@ -0,0 +1,10 @@
+export class BoardStoreError extends Error {
+    code;
+    status;
+    constructor(code, message, status) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.name = "BoardStoreError";
+    }
+}

package/dist/src/agent-team/repositories/feishu-p2p-contact-store.js

@@ -0,0 +1,64 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export class FeishuP2pContactStore {
+    filePath;
+    operationQueue = Promise.resolve();
+    constructor(options = {}) {
+        this.filePath = options.filePath ?? join(homedir(), ".chatccc", "state", "last-feishu-p2p-contact.json");
+    }
+    async get() {
+        try {
+            return parseContact(JSON.parse(await readFile(this.filePath, "utf8")));
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return null;
+            throw err;
+        }
+    }
+    async record(contact) {
+        const parsed = parseContact(contact);
+        await this.exclusive(async () => {
+            await writeJsonAtomic(this.filePath, parsed);
+        });
+    }
+    async exclusive(operation) {
+        const previous = this.operationQueue;
+        let release;
+        this.operationQueue = new Promise((resolveQueue) => { release = resolveQueue; });
+        await previous;
+        try {
+            return await operation();
+        }
+        finally {
+            release();
+        }
+    }
+}
+function parseContact(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Invalid Feishu P2P contact");
+    const contact = value;
+    if (typeof contact.openId !== "string" || !contact.openId)
+        throw new Error("Feishu P2P contact is missing openId");
+    if (typeof contact.chatId !== "string" || !contact.chatId)
+        throw new Error("Feishu P2P contact is missing chatId");
+    if (typeof contact.receivedAt !== "string" || !contact.receivedAt)
+        throw new Error("Feishu P2P contact is missing receivedAt");
+    return { openId: contact.openId, chatId: contact.chatId, receivedAt: contact.receivedAt };
+}
+async function writeJsonAtomic(path, value) {
+    await mkdir(dirname(path), { recursive: true });
+    const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    await writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    try {
+        await rename(tempPath, path);
+    }
+    catch (err) {
+        await unlink(tempPath).catch(() => { });
+        throw err;
+    }
+}
+export const feishuP2pContactStore = new FeishuP2pContactStore();

package/dist/src/agent-team/repositories/json-board-repository.js

@@ -0,0 +1,209 @@
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, realpath, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { createEmptyBoard, parseBoard } from "../domain/board.js";
+import { BoardStoreError } from "./board-repository.js";
+const EMPTY_INDEX = { schemaVersion: 1, workspaces: [] };
+export class JsonBoardRepository {
+    rootDir;
+    boardsDir;
+    indexPath;
+    now;
+    idFactory;
+    operationQueue = Promise.resolve();
+    constructor(options = {}) {
+        this.rootDir = options.rootDir ?? join(homedir(), ".chatccc", "agent-team");
+        this.boardsDir = join(this.rootDir, "boards");
+        this.indexPath = join(this.rootDir, "workspaces.json");
+        this.now = options.now ?? (() => new Date());
+        this.idFactory = options.idFactory ?? randomUUID;
+    }
+    async findWorkspace(workspacePath) {
+        const canonical = await this.canonicalWorkspace(workspacePath);
+        const normalizedPath = normalizeWorkspaceKey(canonical);
+        const index = await this.readIndex();
+        const record = index.workspaces.find((item) => item.normalizedPath === normalizedPath);
+        return record ? this.readBoard(record.boardId) : null;
+    }
+    async openWorkspace(workspacePath) {
+        return this.exclusive(async () => {
+            const canonical = await this.canonicalWorkspace(workspacePath);
+            const normalizedPath = normalizeWorkspaceKey(canonical);
+            const index = await this.readIndex();
+            let record = index.workspaces.find((item) => item.normalizedPath === normalizedPath);
+            const now = this.now().toISOString();
+            if (!record) {
+                const board = createEmptyBoard({ boardId: this.idFactory(), workspacePath: canonical, now });
+                record = { boardId: board.boardId, workspacePath: canonical, normalizedPath, lastOpenedAt: now };
+                index.workspaces.unshift(record);
+                await this.writeBoard(board);
+                await this.writeIndex(index);
+                return board;
+            }
+            record.workspacePath = canonical;
+            record.lastOpenedAt = now;
+            await this.writeIndex(index);
+            const board = await this.readBoard(record.boardId);
+            if (board.workspacePath !== canonical) {
+                const updated = { ...board, workspacePath: canonical, revision: board.revision + 1, updatedAt: now };
+                await this.writeBoard(updated);
+                return updated;
+            }
+            return board;
+        });
+    }
+    async getBoard(boardId) {
+        return this.readBoard(boardId);
+    }
+    async saveBoard(board, expectedRevision) {
+        await this.exclusive(async () => {
+            const current = await this.readBoard(board.boardId);
+            if (current.revision !== expectedRevision)
+                throw revisionConflict(current.revision, expectedRevision);
+            if (board.revision !== expectedRevision + 1) {
+                throw new BoardStoreError("invalid_request", "Board revision must increase by exactly one", 400);
+            }
+            parseBoard(board);
+            await this.writeBoard(board);
+        });
+    }
+    async listWorkspaces() {
+        const index = await this.readIndex();
+        const sorted = [...index.workspaces].sort((a, b) => b.lastOpenedAt.localeCompare(a.lastOpenedAt)).slice(0, 20);
+        return Promise.all(sorted.map(async (record) => ({
+            boardId: record.boardId,
+            workspacePath: record.workspacePath,
+            lastOpenedAt: record.lastOpenedAt,
+            exists: await directoryExists(record.workspacePath),
+        })));
+    }
+    async relinkWorkspace(boardId, workspacePath, expectedRevision) {
+        return this.exclusive(async () => {
+            const canonical = await this.canonicalWorkspace(workspacePath);
+            const normalizedPath = normalizeWorkspaceKey(canonical);
+            const index = await this.readIndex();
+            const collision = index.workspaces.find((item) => item.normalizedPath === normalizedPath && item.boardId !== boardId);
+            if (collision) {
+                throw new BoardStoreError("workspace_conflict", "The selected directory already has another board", 409);
+            }
+            const current = await this.readBoard(boardId);
+            if (current.revision !== expectedRevision)
+                throw revisionConflict(current.revision, expectedRevision);
+            const now = this.now().toISOString();
+            const record = index.workspaces.find((item) => item.boardId === boardId);
+            if (!record)
+                throw new BoardStoreError("not_found", `Workspace record not found for board ${boardId}`, 404);
+            record.workspacePath = canonical;
+            record.normalizedPath = normalizedPath;
+            record.lastOpenedAt = now;
+            const updated = {
+                ...current,
+                workspacePath: canonical,
+                revision: current.revision + 1,
+                updatedAt: now,
+            };
+            await this.writeBoard(updated);
+            await this.writeIndex(index);
+            return updated;
+        });
+    }
+    async canonicalWorkspace(input) {
+        if (typeof input !== "string" || !input.trim()) {
+            throw new BoardStoreError("invalid_request", "workspacePath must be a non-empty string", 400);
+        }
+        const absolute = resolve(input.trim());
+        let info;
+        try {
+            info = await stat(absolute);
+        }
+        catch {
+            throw new BoardStoreError("invalid_request", `Working directory does not exist: ${absolute}`, 400);
+        }
+        if (!info.isDirectory())
+            throw new BoardStoreError("invalid_request", `Not a directory: ${absolute}`, 400);
+        return realpath(absolute);
+    }
+    boardPath(boardId) {
+        if (!/^[a-zA-Z0-9_-]+$/.test(boardId)) {
+            throw new BoardStoreError("invalid_request", "Invalid board id", 400);
+        }
+        return join(this.boardsDir, `${boardId}.json`);
+    }
+    async readBoard(boardId) {
+        const path = this.boardPath(boardId);
+        try {
+            return parseBoard(JSON.parse(await readFile(path, "utf8")));
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                throw new BoardStoreError("not_found", `Board not found: ${boardId}`, 404);
+            }
+            if (err instanceof BoardStoreError)
+                throw err;
+            throw new BoardStoreError("storage_error", `Failed to read board ${boardId}: ${err.message}`, 500);
+        }
+    }
+    async readIndex() {
+        if (!existsSync(this.indexPath))
+            return { ...EMPTY_INDEX, workspaces: [] };
+        try {
+            const parsed = JSON.parse(await readFile(this.indexPath, "utf8"));
+            if (parsed.schemaVersion !== 1 || !Array.isArray(parsed.workspaces))
+                throw new Error("Invalid workspace index");
+            return { schemaVersion: 1, workspaces: parsed.workspaces };
+        }
+        catch (err) {
+            throw new BoardStoreError("storage_error", `Failed to read workspace index: ${err.message}`, 500);
+        }
+    }
+    async writeBoard(board) {
+        await writeJsonAtomic(this.boardPath(board.boardId), board);
+    }
+    async writeIndex(index) {
+        const deduped = new Map();
+        for (const record of index.workspaces)
+            deduped.set(record.boardId, record);
+        await writeJsonAtomic(this.indexPath, { schemaVersion: 1, workspaces: [...deduped.values()] });
+    }
+    async exclusive(operation) {
+        const previous = this.operationQueue;
+        let release;
+        this.operationQueue = new Promise((resolveQueue) => { release = resolveQueue; });
+        await previous;
+        try {
+            return await operation();
+        }
+        finally {
+            release();
+        }
+    }
+}
+function normalizeWorkspaceKey(path) {
+    const normalized = resolve(path).replace(/[\\/]+$/, "");
+    return process.platform === "win32" ? normalized.toLocaleLowerCase("en-US") : normalized;
+}
+async function directoryExists(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function writeJsonAtomic(path, value) {
+    await mkdir(dirname(path), { recursive: true });
+    const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    await writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    try {
+        await rename(tempPath, path);
+    }
+    catch (err) {
+        await unlink(tempPath).catch(() => { });
+        throw err;
+    }
+}
+function revisionConflict(actual, expected) {
+    return new BoardStoreError("revision_conflict", `Board changed in another page (expected revision ${expected}, current ${actual})`, 409);
+}