@co0ontty/wand 4.39.0 → 4.40.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "9896125e169fcac60a7a4fd7093eb675dfec329d",
-  "builtAt": "2026-08-08T07:24:00.026Z",
-  "version": "4.39.0",
+  "commit": "039e06a3e112daed7a0815a38eef48a36f7b31f7",
+  "builtAt": "2026-08-09T03:33:04.966Z",
+  "version": "4.40.0",
   "channel": "stable"
 }

package/dist/process-manager.d.ts

@@ -60,6 +60,8 @@ export declare class ProcessManager extends EventEmitter {
         thinkingEffort?: SessionSnapshot["thinkingEffort"];
         sessionSource?: SessionSource;
         automationId?: string;
+        workspaceId?: string;
+        workspaceTaskId?: string;
         interactiveShell?: boolean;
     }): Promise<SessionSnapshot>;
     list(): SessionSnapshot[];
@@ -176,6 +178,8 @@ export declare class ProcessManager extends EventEmitter {
         rows?: number;
         sessionSource?: SessionSource;
         automationId?: string;
+        workspaceId?: string;
+        workspaceTaskId?: string;
     }): Promise<SessionSnapshot>;
     private shouldAutoApprovePermissions;
     private processCommandForMode;

package/dist/process-manager.js

@@ -1032,6 +1032,8 @@ export class ProcessManager extends EventEmitter {
             id,
             sessionSource: opts?.sessionSource ?? inheritedSessionSource ?? "interactive",
             automationId: opts?.automationId ?? inheritedAutomationId,
+            workspaceId: opts?.workspaceId,
+            workspaceTaskId: opts?.workspaceTaskId,
             provider,
             command,
             cwd: resolvedCwd,
@@ -1844,6 +1846,8 @@ export class ProcessManager extends EventEmitter {
             ptyRows: record.ptyRows,
             ptyOutputSeq: record.ptyOutputSeq ?? 0,
             ptyLaunchMarkerToken: record.ptyLaunchMarkerToken ?? null,
+            workspaceId: record.workspaceId,
+            workspaceTaskId: record.workspaceTaskId,
         };
     }
     /** Lightweight snapshot for list views — omits output and messages. */

package/dist/server-file-routes.js

@@ -1,7 +1,7 @@
 import crypto from "node:crypto";
 import { exec } from "node:child_process";
 import { createReadStream } from "node:fs";
-import { lstat, readdir, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { lstat, mkdir, readdir, readFile, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
 import { promisify } from "node:util";
@@ -220,6 +220,124 @@ export function registerFileRoutes(app, deps) {
             res.status(400).json({ error: getErrorMessage(error, "保存文件失败。") });
         }
     }));
+    app.post("/api/file-create", asyncRoute(async (req, res) => {
+        const body = (req.body ?? {});
+        const filePath = typeof body.path === "string" ? body.path.trim() : "";
+        if (!filePath) {
+            res.status(400).json({ error: "缺少 path 参数。" });
+            return;
+        }
+        const resolvedPath = path.resolve(filePath);
+        if (isBlockedFolderPath(resolvedPath)) {
+            res.status(403).json({ error: "访问被拒绝：无法在系统目录下创建文件。" });
+            return;
+        }
+        try {
+            await writeFile(resolvedPath, "", { flag: "wx", encoding: "utf-8" });
+            const fileStat = await stat(resolvedPath);
+            res.json({ ok: true, path: resolvedPath, size: fileStat.size, mtime: fileStat.mtime.toISOString() });
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === "EEXIST") {
+                res.status(409).json({ error: "文件已存在。", path: resolvedPath });
+                return;
+            }
+            res.status(400).json({ error: getErrorMessage(error, "创建文件失败。") });
+        }
+    }));
+    app.post("/api/dir-create", asyncRoute(async (req, res) => {
+        const body = (req.body ?? {});
+        const dirPath = typeof body.path === "string" ? body.path.trim() : "";
+        if (!dirPath) {
+            res.status(400).json({ error: "缺少 path 参数。" });
+            return;
+        }
+        const resolvedPath = path.resolve(dirPath);
+        if (isBlockedFolderPath(resolvedPath)) {
+            res.status(403).json({ error: "访问被拒绝：无法在系统目录下创建文件夹。" });
+            return;
+        }
+        try {
+            await mkdir(resolvedPath, { recursive: true });
+            const fileStat = await stat(resolvedPath);
+            res.json({ ok: true, path: resolvedPath, mtime: fileStat.mtime.toISOString() });
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "创建文件夹失败。") });
+        }
+    }));
+    app.post("/api/file-rename", asyncRoute(async (req, res) => {
+        const body = (req.body ?? {});
+        const fromRaw = typeof body.from === "string" ? body.from.trim() : "";
+        const toRaw = typeof body.to === "string" ? body.to.trim() : "";
+        if (!fromRaw || !toRaw) {
+            res.status(400).json({ error: "缺少 from 或 to 参数。" });
+            return;
+        }
+        const fromPath = path.resolve(fromRaw);
+        const toPath = path.resolve(toRaw);
+        if (isBlockedFolderPath(fromPath) || isBlockedFolderPath(toPath)) {
+            res.status(403).json({ error: "访问被拒绝：无法操作系统目录。" });
+            return;
+        }
+        if (fromPath === toPath) {
+            res.status(400).json({ error: "源路径与目标路径相同。" });
+            return;
+        }
+        try {
+            const fromStat = await lstat(fromPath);
+            try {
+                const toStat = await lstat(toPath);
+                // macOS 默认大小写不敏感；仅当两个路径实际指向同一 inode 时允许
+                // foo.ts → Foo.ts 这种大小写重命名，其余目标一律拒绝覆盖。
+                if (fromStat.dev !== toStat.dev || fromStat.ino !== toStat.ino) {
+                    res.status(409).json({ error: "目标路径已存在。" });
+                    return;
+                }
+            }
+            catch (targetError) {
+                if (targetError.code !== "ENOENT")
+                    throw targetError;
+            }
+            await rename(fromPath, toPath);
+            res.json({ ok: true, from: fromPath, to: toPath });
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === "ENOENT") {
+                res.status(404).json({ error: "源路径不存在。" });
+                return;
+            }
+            res.status(400).json({ error: getErrorMessage(error, "重命名/移动失败。") });
+        }
+    }));
+    app.post("/api/file-delete", asyncRoute(async (req, res) => {
+        const body = (req.body ?? {});
+        const targetPath = typeof body.path === "string" ? body.path.trim() : "";
+        if (!targetPath) {
+            res.status(400).json({ error: "缺少 path 参数。" });
+            return;
+        }
+        const resolvedPath = path.resolve(targetPath);
+        if (isBlockedFolderPath(resolvedPath)) {
+            res.status(403).json({ error: "访问被拒绝：无法删除系统目录。" });
+            return;
+        }
+        try {
+            const fileStat = await stat(resolvedPath);
+            await rm(resolvedPath, { recursive: fileStat.isDirectory(), force: false });
+            res.json({ ok: true, path: resolvedPath, wasDirectory: fileStat.isDirectory() });
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === "ENOENT") {
+                res.status(404).json({ error: "路径不存在。" });
+                return;
+            }
+            res.status(400).json({ error: getErrorMessage(error, "删除失败。") });
+        }
+    }));
     app.get("/api/file-raw", asyncRoute(async (req, res) => {
         const filePath = typeof req.query.path === "string" ? req.query.path : "";
         const asDownload = req.query.download === "1" || req.query.download === "true";

package/dist/server-session-routes.js

@@ -525,6 +525,8 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                 thinkingEffort: typeof body.thinkingEffort === "string"
                     ? body.thinkingEffort
                     : config.defaultThinkingEffort,
+                workspaceId: body.workspaceId,
+                workspaceTaskId: body.workspaceTaskId,
                 ...origin,
             });
             onSessionCreated?.(snapshot.cwd);

package/dist/server-workspace-routes.d.ts

@@ -0,0 +1,16 @@
+import type { Express } from "express";
+import type { SessionRegistry } from "./session-registry.js";
+import type { WandStorage } from "./storage.js";
+import type { LayoutNode, TaskWindowLayout } from "./types.js";
+/** 校验并清洗前端提交的布局树；非法输入返回 null（空工作空间）。 */
+export declare function sanitizeLayout(value: unknown): LayoutNode | null;
+/** 校验任务级工作窗口集合；旧版单棵布局会兼容升级成一个 window。 */
+export declare function sanitizeTaskLayout(value: unknown): TaskWindowLayout | null;
+/**
+ * Workspace（多标签 / 分屏项目）REST 路由。
+ *
+ * 设计要点：
+ * - POST 只建项目实体，**不启动任何会话**；会话由工作空间内「+」标签按需创建并绑定 workspaceId。
+ * - 布局树由前端 allotment 构造，PUT 时经 sanitizeLayout 校验/规整后落库。
+ */
+export declare function registerWorkspaceRoutes(app: Express, storage: WandStorage, sessions?: SessionRegistry): void;

package/dist/server-workspace-routes.js

@@ -0,0 +1,373 @@
+import path from "node:path";
+import crypto from "node:crypto";
+import { existsSync, statSync } from "node:fs";
+import { asyncRoute } from "./express-async.js";
+import { getErrorMessage } from "./error-utils.js";
+import { expandHomePath } from "./middleware/path-safety.js";
+import { prepareSessionWorktree } from "./git-worktree.js";
+import { runGit } from "./git-utils.js";
+const PROVIDERS = new Set(["claude", "codex", "opencode", "grok", "qoder", "pi"]);
+function parseDefaultProvider(value) {
+    return typeof value === "string" && PROVIDERS.has(value) ? value : undefined;
+}
+/** Resolve + validate a workspace cwd: expand home, require an existing directory. */
+function resolveWorkspaceCwd(raw) {
+    const expanded = expandHomePath(typeof raw === "string" ? raw : "");
+    if (!expanded.trim())
+        throw new Error("请选择项目目录。");
+    const resolved = path.resolve(expanded);
+    if (!existsSync(resolved))
+        throw new Error(`目录不存在：${resolved}`);
+    if (!statSync(resolved).isDirectory())
+        throw new Error(`不是目录：${resolved}`);
+    return resolved;
+}
+function cleanupTaskWorktree(worktree) {
+    if (!worktree?.repoRoot)
+        return;
+    try {
+        runGit(["worktree", "remove", "--force", worktree.path], worktree.repoRoot);
+    }
+    catch { /* best effort */ }
+    try {
+        runGit(["branch", "-D", worktree.branch], worktree.repoRoot);
+    }
+    catch { /* best effort */ }
+}
+function deleteSessions(storage, sessions, sessionIds) {
+    for (const sessionId of new Set(sessionIds)) {
+        if (sessions)
+            sessions.deleteWithProviderHistory(sessionId);
+        else
+            storage.deleteSession(sessionId);
+    }
+}
+// ── Layout validation / sanitization（前端 PUT 与测试共用）──
+function sanitizePaneTab(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const v = value;
+    const id = typeof v.id === "string" && v.id ? v.id : null;
+    if (!id)
+        return null;
+    if (v.kind === "session") {
+        if (typeof v.sessionId !== "string" || !v.sessionId)
+            return null;
+        return { id, kind: "session", sessionId: v.sessionId };
+    }
+    if (v.kind === "editor" || v.kind === "preview") {
+        if (typeof v.path !== "string" || !v.path)
+            return null;
+        return { id, kind: v.kind, path: v.path };
+    }
+    return null;
+}
+function sanitizeLayoutNode(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const v = value;
+    if (v.type === "pane") {
+        const rawTabs = Array.isArray(v.tabs) ? v.tabs : [];
+        const tabs = rawTabs
+            .map(sanitizePaneTab)
+            .filter((tab) => tab !== null);
+        const tabCount = Math.max(1, tabs.length);
+        const active = typeof v.active === "number" && Number.isFinite(v.active)
+            ? Math.max(0, Math.min(Math.floor(v.active), tabCount - 1))
+            : 0;
+        return { type: "pane", tabs, active };
+    }
+    if (v.type === "split") {
+        if (v.dir !== "h" && v.dir !== "v")
+            return null;
+        const kids = Array.isArray(v.children) ? v.children : [];
+        if (kids.length !== 2)
+            return null;
+        const a = sanitizeLayoutNode(kids[0]);
+        const b = sanitizeLayoutNode(kids[1]);
+        if (!a || !b)
+            return null;
+        const ratio = typeof v.ratio === "number" && Number.isFinite(v.ratio)
+            ? Math.max(0.05, Math.min(0.95, v.ratio))
+            : 0.5;
+        return { type: "split", dir: v.dir, ratio, children: [a, b] };
+    }
+    return null;
+}
+/** 校验并清洗前端提交的布局树；非法输入返回 null（空工作空间）。 */
+export function sanitizeLayout(value) {
+    return sanitizeLayoutNode(value);
+}
+function layoutHasTab(node, tabId) {
+    if (node.type === "pane")
+        return node.tabs.some((tab) => tab.id === tabId);
+    return layoutHasTab(node.children[0], tabId) || layoutHasTab(node.children[1], tabId);
+}
+function firstLayoutTabId(node) {
+    if (node.type === "pane")
+        return node.tabs[node.active]?.id ?? node.tabs[0]?.id;
+    return firstLayoutTabId(node.children[0]) ?? firstLayoutTabId(node.children[1]);
+}
+/** 校验任务级工作窗口集合；旧版单棵布局会兼容升级成一个 window。 */
+export function sanitizeTaskLayout(value) {
+    const legacy = sanitizeLayoutNode(value);
+    if (legacy) {
+        return {
+            type: "windows",
+            windows: [{ id: "window-legacy", layout: legacy, activeTabId: firstLayoutTabId(legacy) }],
+            activeWindowId: "window-legacy",
+        };
+    }
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    if (record.type !== "windows" || !Array.isArray(record.windows))
+        return null;
+    const used = new Set();
+    const windows = record.windows.slice(0, 128).flatMap((candidate) => {
+        if (!candidate || typeof candidate !== "object")
+            return [];
+        const window = candidate;
+        const id = typeof window.id === "string" ? window.id.trim().slice(0, 160) : "";
+        const layout = sanitizeLayoutNode(window.layout);
+        if (!id || used.has(id) || !layout)
+            return [];
+        used.add(id);
+        const requestedActive = typeof window.activeTabId === "string" ? window.activeTabId : undefined;
+        const activeTabId = requestedActive && layoutHasTab(layout, requestedActive)
+            ? requestedActive
+            : firstLayoutTabId(layout);
+        return [{ id, layout, ...(activeTabId ? { activeTabId } : {}) }];
+    });
+    const requestedWindow = typeof record.activeWindowId === "string" ? record.activeWindowId : null;
+    const activeWindowId = windows.some((window) => window.id === requestedWindow)
+        ? requestedWindow
+        : windows[0]?.id ?? null;
+    return { type: "windows", windows, activeWindowId };
+}
+/**
+ * Workspace（多标签 / 分屏项目）REST 路由。
+ *
+ * 设计要点：
+ * - POST 只建项目实体，**不启动任何会话**；会话由工作空间内「+」标签按需创建并绑定 workspaceId。
+ * - 布局树由前端 allotment 构造，PUT 时经 sanitizeLayout 校验/规整后落库。
+ */
+export function registerWorkspaceRoutes(app, storage, sessions) {
+    // 列出所有项目（按最近打开排序）
+    app.get("/api/workspaces", (_req, res) => {
+        res.json(storage.listWorkspaces());
+    });
+    // 新建项目：名称 + 目录 + 默认 IDE，不启动会话
+    app.post("/api/workspaces", asyncRoute(async (req, res) => {
+        const body = req.body;
+        const name = typeof body.name === "string" ? body.name.trim() : "";
+        if (!name) {
+            res.status(400).json({ error: "请输入项目名称。" });
+            return;
+        }
+        let cwd;
+        try {
+            cwd = resolveWorkspaceCwd(body.cwd);
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "目录无效。") });
+            return;
+        }
+        const defaultProvider = parseDefaultProvider(body.defaultProvider);
+        const workspace = storage.createWorkspace({ name, cwd, defaultProvider });
+        res.status(201).json(workspace);
+    }));
+    // 项目详情：meta + 会话 + 布局；访问即更新 lastOpenedAt
+    app.get("/api/workspaces/:id", (req, res) => {
+        const workspace = storage.getWorkspace(req.params.id);
+        if (!workspace) {
+            res.status(404).json({ error: "未找到该项目。" });
+            return;
+        }
+        storage.touchWorkspace(workspace.id);
+        res.json({ ...workspace, sessions: storage.listSessionsByWorkspace(workspace.id) });
+    });
+    // 改名 / 目录 / 默认 IDE
+    app.patch("/api/workspaces/:id", (req, res) => {
+        const existing = storage.getWorkspace(req.params.id);
+        if (!existing) {
+            res.status(404).json({ error: "未找到该项目。" });
+            return;
+        }
+        const body = req.body;
+        const patch = {};
+        if (typeof body.name === "string" && body.name.trim())
+            patch.name = body.name.trim();
+        if (body.cwd !== undefined) {
+            try {
+                patch.cwd = resolveWorkspaceCwd(body.cwd);
+            }
+            catch (error) {
+                res.status(400).json({ error: getErrorMessage(error, "目录无效。") });
+                return;
+            }
+        }
+        if (body.defaultProvider === null) {
+            patch.defaultProvider = null;
+        }
+        else if (body.defaultProvider !== undefined) {
+            const parsed = parseDefaultProvider(body.defaultProvider);
+            if (parsed)
+                patch.defaultProvider = parsed;
+        }
+        storage.updateWorkspace(existing.id, patch);
+        res.json(storage.getWorkspace(existing.id));
+    });
+    // 删除项目；cascade=true 连带删会话，否则仅解绑
+    app.delete("/api/workspaces/:id", (req, res) => {
+        const cascade = req.query.cascade === "1" || req.query.cascade === "true";
+        const existing = storage.getWorkspace(req.params.id);
+        if (!existing) {
+            res.status(404).json({ error: "未找到该项目。" });
+            return;
+        }
+        const tasks = storage.listWorkspaceTasks(existing.id);
+        if (cascade) {
+            deleteSessions(storage, sessions, [
+                ...storage.listSessionsByWorkspace(existing.id).map((session) => session.id),
+                ...tasks.flatMap((task) => storage.listSessionsByWorkspaceTask(task.id).map((session) => session.id)),
+            ]);
+        }
+        else {
+            // 非级联删除可以保留项目根目录里的会话，但隔离任务的 cwd 会随
+            // worktree 一起消失，因此必须删除这些会话，不能留下僵尸记录。
+            deleteSessions(storage, sessions, tasks.flatMap((task) => task.worktree
+                ? storage.listSessionsByWorkspaceTask(task.id).map((session) => session.id)
+                : []));
+        }
+        for (const task of tasks) {
+            if (cascade || task.worktree)
+                cleanupTaskWorktree(task.worktree);
+        }
+        storage.deleteWorkspace(existing.id, { cascade });
+        res.json({ ok: true });
+    });
+    // 保存布局树（标签 + 分屏）
+    app.put("/api/workspaces/:id/layout", (req, res) => {
+        const existing = storage.getWorkspace(req.params.id);
+        if (!existing) {
+            res.status(404).json({ error: "未找到该项目。" });
+            return;
+        }
+        const body = req.body;
+        const layout = sanitizeLayout(body === null || typeof body !== "object" ? undefined : body.layout);
+        storage.saveWorkspaceLayout(existing.id, layout);
+        res.json({ ok: true, layout });
+    });
+    // ── 任务（Task = 命名 + 独立 worktree + 一组标签）──
+    // 列出某工作空间下的任务
+    app.get("/api/workspaces/:id/tasks", (req, res) => {
+        const workspace = storage.getWorkspace(req.params.id);
+        if (!workspace) {
+            res.status(404).json({ error: "未找到该项目。" });
+            return;
+        }
+        res.json(storage.listWorkspaceTasks(workspace.id));
+    });
+    // 新建任务：命名 + 创建独立 worktree（非 git 仓库时退化为直接用项目目录）
+    app.post("/api/workspaces/:id/tasks", asyncRoute(async (req, res) => {
+        const workspace = storage.getWorkspace(req.params.id);
+        if (!workspace) {
+            res.status(404).json({ error: "未找到该项目。" });
+            return;
+        }
+        const body = req.body;
+        const name = typeof body.name === "string" ? body.name.trim() : "";
+        if (!name) {
+            res.status(400).json({ error: "请输入任务名称。" });
+            return;
+        }
+        const baseRef = typeof body.baseRef === "string" && body.baseRef.trim() ? body.baseRef.trim() : undefined;
+        let worktree = null;
+        let worktreeError;
+        try {
+            const setup = prepareSessionWorktree({
+                cwd: workspace.cwd,
+                // 用随机短 id 作分支后缀，避免同名任务撞分支。
+                sessionId: crypto.randomUUID(),
+                spec: { taskName: name, baseRef },
+            });
+            worktree = setup.worktree;
+        }
+        catch (error) {
+            // 非 git 仓库 / 基线不存在：任务照常创建，但无 worktree 隔离。
+            worktreeError = getErrorMessage(error, "无法创建 worktree，将在项目目录直接运行。");
+        }
+        const task = storage.createWorkspaceTask({ workspaceId: workspace.id, name, worktree });
+        res.status(201).json({
+            ...task,
+            cwd: worktree?.path ?? workspace.cwd,
+            isolated: worktree !== null,
+            worktreeError,
+        });
+    }));
+    // 任务详情：meta + 该任务下的会话；访问即更新 lastOpenedAt
+    app.get("/api/workspace-tasks/:taskId", (req, res) => {
+        const task = storage.getWorkspaceTask(req.params.taskId);
+        if (!task) {
+            res.status(404).json({ error: "未找到该任务。" });
+            return;
+        }
+        storage.touchWorkspaceTask(task.id);
+        const workspace = storage.getWorkspace(task.workspaceId);
+        res.json({
+            ...task,
+            cwd: task.worktree?.path ?? workspace?.cwd ?? "",
+            sessions: storage.listSessionsByWorkspaceTask(task.id),
+        });
+    });
+    // 改名 / 状态
+    app.patch("/api/workspace-tasks/:taskId", (req, res) => {
+        const existing = storage.getWorkspaceTask(req.params.taskId);
+        if (!existing) {
+            res.status(404).json({ error: "未找到该任务。" });
+            return;
+        }
+        const body = req.body;
+        const patch = {};
+        if (typeof body.name === "string" && body.name.trim())
+            patch.name = body.name.trim();
+        if (body.status === "active" || body.status === "done")
+            patch.status = body.status;
+        storage.updateWorkspaceTask(existing.id, patch);
+        res.json(storage.getWorkspaceTask(existing.id));
+    });
+    // 删除任务；cascade=true 连带删会话，否则仅解绑；尽力清理 worktree
+    app.delete("/api/workspace-tasks/:taskId", (req, res) => {
+        const existing = storage.getWorkspaceTask(req.params.taskId);
+        if (!existing) {
+            res.status(404).json({ error: "未找到该任务。" });
+            return;
+        }
+        // 删除隔离任务必然会移除其 cwd，因此即使调用方没有显式传 cascade，
+        // 也必须同步删除会话；非隔离任务仍保留旧的“默认解绑”API 语义。
+        const cascade = req.query.cascade === "1"
+            || req.query.cascade === "true"
+            || existing.worktree !== null;
+        if (cascade) {
+            deleteSessions(storage, sessions, storage.listSessionsByWorkspaceTask(existing.id).map((session) => session.id));
+        }
+        // 尽力清理 worktree 与分支；失败不阻塞删除任务行。
+        if (cascade)
+            cleanupTaskWorktree(existing.worktree);
+        storage.deleteWorkspaceTask(existing.id, { cascade });
+        res.json({ ok: true });
+    });
+    // 保存任务的标签 / 分屏布局
+    app.put("/api/workspace-tasks/:taskId/layout", (req, res) => {
+        const existing = storage.getWorkspaceTask(req.params.taskId);
+        if (!existing) {
+            res.status(404).json({ error: "未找到该任务。" });
+            return;
+        }
+        const body = req.body;
+        const layout = sanitizeTaskLayout(body === null || typeof body !== "object" ? undefined : body.layout);
+        storage.saveWorkspaceTaskLayout(existing.id, layout);
+        res.json({ ok: true, layout });
+    });
+}

package/dist/server.js

@@ -26,6 +26,7 @@ import { registerMissionRoutes } from "./server-mission-routes.js";
 import { Missions } from "./missions.js";
 import { refreshProviderCliUpdateState, registerAdminUpdateRoutes, registerPublicUpdateRoutes, ServerUpdateState, } from "./server-update-routes.js";
 import { parseSessionCreationOrigin, registerClaudeHistoryRoutes, registerSessionRoutes } from "./server-session-routes.js";
+import { registerWorkspaceRoutes } from "./server-workspace-routes.js";
 import { resolveSessionCwd } from "./session-cwd.js";
 import { getErrorMessage } from "./error-utils.js";
 import { asyncRoute, jsonErrorHandler } from "./express-async.js";
@@ -938,6 +939,7 @@ export async function startServer(config, configPath, options = {}) {
         recordRecentPath(storage, cwd);
     });
     registerClaudeHistoryRoutes(app, processes, structuredSessions, storage, sessionRegistry);
+    registerWorkspaceRoutes(app, storage, sessionRegistry);
     registerMissionRoutes(app, missions);
     registerUploadRoutes(app, processes);
     app.post("/api/optimize-prompt", asyncRoute(async (req, res) => {
@@ -1023,6 +1025,8 @@ export async function startServer(config, configPath, options = {}) {
                     worktreeEnabled: body.worktreeEnabled === true,
                     cols: reqCols,
                     rows: reqRows,
+                    workspaceId: body.workspaceId,
+                    workspaceTaskId: body.workspaceTaskId,
                     ...origin,
                 })
                 : processes.start(command, body.cwd, body.mode ?? config.defaultMode, initialInput || undefined, {
@@ -1032,6 +1036,8 @@ export async function startServer(config, configPath, options = {}) {
                     cols: reqCols,
                     rows: reqRows,
                     thinkingEffort: body.thinkingEffort ?? config.defaultThinkingEffort,
+                    workspaceId: body.workspaceId,
+                    workspaceTaskId: body.workspaceTaskId,
                     ...origin,
                 }));
             recordRecentPath(storage, snapshot.cwd);

package/dist/storage.d.ts

@@ -1,4 +1,4 @@
-import { SessionSnapshot, ConversationTurn, StructuredSessionState } from "./types.js";
+import { SessionSnapshot, ConversationTurn, StructuredSessionState, Workspace, LayoutNode, TaskWindowLayout, WorkspaceDefaultProvider, WorkspaceTask, WorkspaceTaskWorktree, WorkspaceTaskStatus } from "./types.js";
 import type { AgentActivityItem, Mission, MissionAttempt, MissionReviewComment, MissionReviewStatus, MissionStatus } from "./mission-types.js";
 import { type PasswordVault, type PasswordVaultItem, type PasswordVaultItemFilter, type PasswordVaultItemInput } from "./password-manager.js";
 export declare const DEFAULT_DB_FILE = "wand.db";
@@ -40,6 +40,46 @@ export declare class WandStorage {
     listSessionDirectoryNames(): Map<string, string>;
     /** Set a workspace label, or remove it when name is null/blank. */
     setSessionDirectoryName(directoryPath: string, name: string | null): void;
+    listWorkspaces(): Workspace[];
+    getWorkspace(id: string): Workspace | null;
+    createWorkspace(input: {
+        name: string;
+        cwd: string;
+        defaultProvider?: WorkspaceDefaultProvider;
+    }): Workspace;
+    updateWorkspace(id: string, patch: {
+        name?: string;
+        cwd?: string;
+        defaultProvider?: WorkspaceDefaultProvider | null;
+    }): void;
+    saveWorkspaceLayout(id: string, layout: LayoutNode | null): void;
+    touchWorkspace(id: string): void;
+    deleteWorkspace(id: string, options?: {
+        cascade?: boolean;
+    }): void;
+    listSessionsByWorkspace(workspaceId: string): SessionSnapshot[];
+    /** 显式更新某会话的工作空间归属（用于创建时绑定）。 */
+    setSessionWorkspaceId(sessionId: string, workspaceId: string | null): void;
+    listWorkspaceTasks(workspaceId: string): WorkspaceTask[];
+    getWorkspaceTask(id: string): WorkspaceTask | null;
+    createWorkspaceTask(input: {
+        workspaceId: string;
+        name: string;
+        worktree?: WorkspaceTaskWorktree | null;
+        status?: WorkspaceTaskStatus;
+    }): WorkspaceTask;
+    updateWorkspaceTask(id: string, patch: {
+        name?: string;
+        status?: WorkspaceTaskStatus;
+        worktree?: WorkspaceTaskWorktree | null;
+    }): void;
+    saveWorkspaceTaskLayout(id: string, layout: TaskWindowLayout | null): void;
+    touchWorkspaceTask(id: string): void;
+    deleteWorkspaceTask(id: string, options?: {
+        cascade?: boolean;
+    }): void;
+    listSessionsByWorkspaceTask(taskId: string): SessionSnapshot[];
+    setSessionWorkspaceTaskId(sessionId: string, taskId: string | null): void;
     /** Get password from database */
     getPassword(): string | null;
     /** Set password in database */