@co0ontty/wand 4.77.0 → 4.78.0

package/dist/types.d.ts

@@ -526,6 +526,13 @@ export interface ConversationAuthor {
     avatar?: string;
     leader?: boolean;
     provider?: SessionProvider;
+    /**
+     * 这条发言**实际使用候选**的模型 id（真值，不是展示文案；`"default"` 表示跟随该 provider
+     * 的服务端默认模型）。老数据没有这个字段，读端要能只按 provider 显示。
+     */
+    model?: string;
+    /** 实际使用候选的思考深度（`off/standard/deep/max` 或 `provider:<原生档位>`）；同上，可缺省。 */
+    thinkingEffort?: string;
     /** 这条发言对应的成员会话，可点开看完整过程。 */
     sessionId?: string;
 }

package/dist/upload-routes.d.ts

@@ -1,3 +1,3 @@
 import type { Express } from "express";
-import type { ProcessManager } from "./process-manager.js";
-export declare function registerUploadRoutes(app: Express, processes: ProcessManager): void;
+import type { SessionRegistry } from "./session-registry.js";
+export declare function registerUploadRoutes(app: Express, sessions: Pick<SessionRegistry, "getLatest">): void;

package/dist/upload-routes.js

@@ -7,7 +7,7 @@ const MAX_FILES = 5;
 function sanitizeFilename(name) {
     return name.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 200);
 }
-export function registerUploadRoutes(app, processes) {
+export function registerUploadRoutes(app, sessions) {
     const storage = multer.diskStorage({
         destination(_req, _file, cb) {
             const cwd = _req.uploadCwd;
@@ -32,12 +32,19 @@ export function registerUploadRoutes(app, processes) {
     });
     function requireUploadSession(req, res, next) {
         const sessionId = req.params.id;
-        const session = processes.get(sessionId);
+        // Group chats are structured relay sessions; ProcessManager does not own them.
+        // Resolve through the same registry used by the rest of the session API so
+        // PTY, structured and stored sessions all upload into their own cwd.
+        const session = sessions.getLatest(sessionId);
         if (!session) {
             res.status(404).json({ error: "会话不存在。" });
             return;
         }
-        req.uploadCwd = session.cwd || "/tmp";
+        if (!session.cwd || !path.isAbsolute(session.cwd)) {
+            res.status(400).json({ error: "会话工作目录无效。" });
+            return;
+        }
+        req.uploadCwd = session.cwd;
         next();
     }
     app.post("/api/sessions/:id/upload", requireUploadSession, upload.array("files", MAX_FILES), (req, res) => {

package/dist/wand-task-sync.d.ts

@@ -1,6 +1,6 @@
 import type { WandStorage } from "./storage.js";
-import { type WandTask, type WandTaskTitleSource } from "./task-types.js";
-import type { SessionSnapshot, Workspace, WorkspaceTask } from "./types.js";
+import type { WandTask } from "./task-types.js";
+import type { SessionSnapshot } from "./types.js";
 /** 未命名任务的占位名；服务端新建时写入，自动命名成功后被真实标题覆盖。 */
 export declare const UNNAMED_WORKSPACE_TASK_NAME = "\u672A\u547D\u540D\u4EFB\u52A1";
 export declare function isUnnamedWorkspaceTaskName(name: string): boolean;
@@ -18,35 +18,3 @@ export declare function isAutoNameableBoardTask(card: Pick<WandTask, "title" | "
 export declare function taskAutoNameSourceText(storage: WandStorage, card: WandTask): string;
 /** 输入指纹：内容没变就没必要再总结一次，也避免自动标题与模型结果来回震荡。 */
 export declare function taskAutoNameSignature(source: string): string;
-/** Identity is the task id, never its title. Same-named tasks stay independent. */
-export declare function ensureBoardTaskForWorkspaceTask(storage: WandStorage, task: WorkspaceTask, workspace: Workspace, options?: {
-    titleSource?: WandTaskTitleSource;
-    description?: string;
-    parentTaskId?: string | null;
-}): WandTask;
-/** A board task always has a sidebar container, even before its first session. */
-export declare function ensureWorkspaceTaskForBoardTask(storage: WandStorage, card: WandTask): WorkspaceTask;
-/** Atomic exclusive ownership change. Never changes cwd, messages, or execution state. */
-export declare function moveSessionToWorkspaceTask(storage: WandStorage, sessionId: string, taskId: string | null): void;
-/** Reconcile legacy records by explicit ids. Unassigned sessions remain unassigned. */
-export declare function syncSidebarTasksFromBoard(storage: WandStorage): void;
-/**
- * 会话建立 / 移动后立刻把任务归属同步到看板卡片，卡片不必等下一次 `GET /api/wand-tasks`
- * 的全量兜底同步，也不必等某个客户端碰巧拉了看板列表。
- * 看板侧的写入失败只记日志：会话已经跑起来了，不能因为看板同步失败把创建请求打断。
- */
-export declare function syncWorkspaceTaskToBoard(storage: WandStorage, workspaceTaskId: string | null | undefined): void;
-/**
- * 兜底全量同步：只处理「会话带着 workspace_task_id 但卡片上还没有绑定」的历史 / 外部写入。
- * 正常路径由 `syncWorkspaceTaskToBoard` 在会话建立时点完成。
- */
-export declare function syncUngroupedSessionsToBoard(storage: WandStorage): void;
-/** Status and title projection is centralized in the storage writer. */
-export declare function syncClosedBoardTask(storage: WandStorage, task: WandTask): void;
-export declare function archiveBoardTask(storage: WandStorage, id: string): WandTask | null;
-/**
- * 归档侧栏任务是软删除：终端继续运行、worktree 与布局都保留，只有看板卡片进入
- * 归档文件夹、侧栏不再显示。恢复方式是看板里把卡片拖回任一列（或右键恢复）。
- */
-export declare function archiveWorkspaceTask(storage: WandStorage, task: WorkspaceTask): WandTask | null;
-export declare function archiveBoardTaskForWorkspaceTask(storage: WandStorage, workspaceTaskId: string): void;

package/dist/wand-task-sync.js

@@ -1,10 +1,5 @@
 import { createHash } from "node:crypto";
-import { getErrorMessage } from "./error-utils.js";
 import { provisionalTaskTitleFromDescription } from "./task-title.js";
-import { isSessionProvider } from "./session-provider.js";
-import { isThinkingEffort } from "./structured-provider-common.js";
-import { isClosedWandTaskStatus, normalizeWandTaskAgentMode } from "./task-types.js";
-import { firstLayoutTabId } from "./layout-tree.js";
 /** 未命名任务的占位名；服务端新建时写入，自动命名成功后被真实标题覆盖。 */
 export const UNNAMED_WORKSPACE_TASK_NAME = "未命名任务";
 /** 历史客户端（Android / 桌面）留空时回传的默认名，同样视为未命名。 */
@@ -91,204 +86,3 @@ export function taskAutoNameSourceText(storage, card) {
 export function taskAutoNameSignature(source) {
     return createHash("sha1").update(source).digest("hex");
 }
-function agentFromSession(session) {
-    if (!isSessionProvider(session.provider))
-        return null;
-    const effort = session.thinkingEffort;
-    return {
-        provider: session.provider,
-        model: session.selectedModel || session.structuredState?.model || "default",
-        thinkingEffort: isThinkingEffort(effort) ? effort : "off",
-        mode: normalizeWandTaskAgentMode(session.provider, session.mode),
-        // 会话形态按会话自身的 sessionKind 还原，PTY 会话不会在「再指派」时被误当结构化。
-        kind: (session.sessionKind ?? "pty") === "structured" ? "structured" : "pty",
-    };
-}
-/** Identity is the task id, never its title. Same-named tasks stay independent. */
-export function ensureBoardTaskForWorkspaceTask(storage, task, workspace, options = {}) {
-    const existing = storage.getWandTaskByWorkspaceTaskId(task.id);
-    if (existing)
-        return existing;
-    return storage.createWandTask({
-        workspaceId: workspace.kind === "global" ? null : workspace.id,
-        workspaceTaskId: task.id,
-        parentTaskId: options.parentTaskId ?? null,
-        title: task.name,
-        // 占位名（未命名任务 / 新任务 / 空）走自动命名；用户填过名就是 user，永不被模型覆盖。
-        titleSource: options.titleSource ?? (isUnnamedWorkspaceTaskName(task.name) ? "auto" : "user"),
-        description: options.description ?? "",
-        status: task.status === "done" ? "done" : "todo",
-        milestoneId: task.milestoneId ?? null,
-    });
-}
-/** A board task always has a sidebar container, even before its first session. */
-export function ensureWorkspaceTaskForBoardTask(storage, card) {
-    const existing = card.workspaceTaskId ? storage.getWorkspaceTask(card.workspaceTaskId) : null;
-    if (existing)
-        return existing;
-    const workspace = card.workspaceId ? storage.getWorkspace(card.workspaceId) : storage.ensureGlobalWorkspace();
-    if (!workspace)
-        throw new Error("任务所属工作区不存在。");
-    const task = storage.createWorkspaceTask({
-        workspaceId: workspace.id,
-        name: card.title,
-        status: isClosedWandTaskStatus(card.status) ? "done" : "active",
-        milestoneId: card.milestoneId,
-    });
-    storage.updateWandTask(card.id, { workspaceTaskId: task.id });
-    return task;
-}
-function removeSessionTab(node, sessionId) {
-    if (node.type === "split")
-        return {
-            ...node,
-            children: [removeSessionTab(node.children[0], sessionId), removeSessionTab(node.children[1], sessionId)],
-        };
-    const activeId = node.tabs[node.active]?.id;
-    const tabs = node.tabs.filter((tab) => tab.kind !== "session" || tab.sessionId !== sessionId);
-    const active = tabs.findIndex((tab) => tab.id === activeId);
-    return { ...node, tabs, active: active >= 0 ? active : Math.min(node.active, Math.max(0, tabs.length - 1)) };
-}
-/** Remove stale source tabs so opening an old task cannot re-open a moved session. */
-function detachSessionLayout(storage, task, sessionId) {
-    if (!task.layout) {
-        storage.saveWorkspaceTaskLayout(task.id, null);
-        return;
-    }
-    const windows = task.layout.windows.map((window) => {
-        const layout = removeSessionTab(window.layout, sessionId);
-        return { ...window, layout, activeTabId: firstLayoutTabId(layout) };
-    });
-    storage.saveWorkspaceTaskLayout(task.id, { ...task.layout, windows });
-}
-/** Atomic exclusive ownership change. Never changes cwd, messages, or execution state. */
-export function moveSessionToWorkspaceTask(storage, sessionId, taskId) {
-    storage.transaction(() => {
-        const session = storage.getSession(sessionId);
-        if (!session)
-            throw new Error("未找到该会话。");
-        const target = taskId ? storage.getWorkspaceTask(taskId) : null;
-        if (taskId && !target)
-            throw new Error("未找到目标任务。");
-        const source = session.workspaceTaskId ? storage.getWorkspaceTask(session.workspaceTaskId) : null;
-        if (source && source.id !== target?.id)
-            detachSessionLayout(storage, source, sessionId);
-        // Explicit task metadata is owned by storage, not by a runner checkpoint.
-        storage.setSessionWorkspaceTaskId(sessionId, target?.id ?? null);
-        for (const card of storage.listWandTasks()) {
-            if (card.workspaceTaskId !== target?.id)
-                storage.unbindWandTaskSession(card.id, sessionId);
-        }
-        if (!target)
-            return;
-        const workspace = storage.getWorkspace(target.workspaceId);
-        if (!workspace)
-            throw new Error("目标工作区不存在。");
-        storage.setSessionWorkspaceId(sessionId, workspace.id);
-        const card = ensureBoardTaskForWorkspaceTask(storage, target, workspace);
-        const newlyBound = !storage.listWandTaskSessionIds(card.id).includes(sessionId);
-        storage.bindWandTaskSession(card.id, sessionId);
-        if (newlyBound && card.status === "todo")
-            storage.updateWandTask(card.id, { status: "doing" });
-    });
-}
-/** Reconcile legacy records by explicit ids. Unassigned sessions remain unassigned. */
-export function syncSidebarTasksFromBoard(storage) {
-    storage.transaction(() => {
-        for (const card of storage.listWandTasks()) {
-            // Deleted sidebar tasks leave an archived card, not a resurrected container.
-            if (!card.workspaceTaskId && card.status === "archived")
-                continue;
-            const task = ensureWorkspaceTaskForBoardTask(storage, card);
-            for (const sessionId of storage.listWandTaskSessionIds(card.id)) {
-                // 只需要归属两列：不要用 getSession()，那会解析十几 MB 的 messages。
-                const session = storage.getSessionWorkspace(sessionId);
-                if (!session)
-                    continue;
-                if (session.workspaceTaskId && session.workspaceTaskId !== task.id) {
-                    storage.unbindWandTaskSession(card.id, sessionId);
-                }
-                else if (session.workspaceTaskId !== task.id || session.workspaceId !== task.workspaceId) {
-                    storage.setSessionWorkspaceTaskId(sessionId, task.id);
-                    storage.setSessionWorkspaceId(sessionId, task.workspaceId);
-                }
-            }
-        }
-    });
-}
-/** 单个任务的会话归属落到看板卡片：补卡片、按会话补 Agent、绑定会话、todo → doing。 */
-function syncTaskSessionsToBoard(storage, task, workspace) {
-    storage.transaction(() => {
-        let card = ensureBoardTaskForWorkspaceTask(storage, task, workspace);
-        const sessions = storage.listSessionsByWorkspaceTaskSlim(task.id);
-        const agent = sessions.map(agentFromSession).find((value) => value !== null);
-        const bound = new Set(storage.listWandTaskSessionIds(card.id));
-        const started = card.status === "todo" && sessions.some((session) => !bound.has(session.id));
-        if ((!card.agent && agent) || started) {
-            card = storage.updateWandTask(card.id, {
-                ...(!card.agent && agent ? { agent } : {}),
-                ...(started ? { status: "doing" } : {}),
-            }) ?? card;
-        }
-        for (const session of sessions)
-            storage.bindWandTaskSession(card.id, session.id);
-    });
-}
-/**
- * 会话建立 / 移动后立刻把任务归属同步到看板卡片，卡片不必等下一次 `GET /api/wand-tasks`
- * 的全量兜底同步，也不必等某个客户端碰巧拉了看板列表。
- * 看板侧的写入失败只记日志：会话已经跑起来了，不能因为看板同步失败把创建请求打断。
- */
-export function syncWorkspaceTaskToBoard(storage, workspaceTaskId) {
-    if (!workspaceTaskId)
-        return;
-    try {
-        const task = storage.getWorkspaceTask(workspaceTaskId);
-        const workspace = task ? storage.getWorkspace(task.workspaceId) : null;
-        if (!task || !workspace)
-            return;
-        syncTaskSessionsToBoard(storage, task, workspace);
-    }
-    catch (error) {
-        console.error(`[WandTask] Failed to sync task ${workspaceTaskId} onto the board:`, getErrorMessage(error));
-    }
-}
-/**
- * 兜底全量同步：只处理「会话带着 workspace_task_id 但卡片上还没有绑定」的历史 / 外部写入。
- * 正常路径由 `syncWorkspaceTaskToBoard` 在会话建立时点完成。
- */
-export function syncUngroupedSessionsToBoard(storage) {
-    syncSidebarTasksFromBoard(storage);
-    for (const workspace of storage.listWorkspaces()) {
-        for (const task of storage.listWorkspaceTasks(workspace.id))
-            syncTaskSessionsToBoard(storage, task, workspace);
-    }
-}
-/** Status and title projection is centralized in the storage writer. */
-export function syncClosedBoardTask(storage, task) {
-    if (isClosedWandTaskStatus(task.status) && task.workspaceTaskId) {
-        storage.updateWorkspaceTask(task.workspaceTaskId, { status: "done" });
-    }
-}
-export function archiveBoardTask(storage, id) {
-    return storage.updateWandTask(id, { status: "archived" });
-}
-/**
- * 归档侧栏任务是软删除：终端继续运行、worktree 与布局都保留，只有看板卡片进入
- * 归档文件夹、侧栏不再显示。恢复方式是看板里把卡片拖回任一列（或右键恢复）。
- */
-export function archiveWorkspaceTask(storage, task) {
-    return storage.transaction(() => {
-        const card = storage.getWandTaskByWorkspaceTaskId(task.id);
-        // 先归档卡片，再把侧栏任务标成已完成：反向投影见到 archived 就不会降级成 done。
-        if (card)
-            storage.updateWandTask(card.id, { status: "archived" });
-        storage.updateWorkspaceTask(task.id, { status: "done" });
-        return card ? storage.getWandTask(card.id) : null;
-    });
-}
-export function archiveBoardTaskForWorkspaceTask(storage, workspaceTaskId) {
-    const linked = storage.getWandTaskByWorkspaceTaskId(workspaceTaskId);
-    if (linked && !isClosedWandTaskStatus(linked.status))
-        storage.updateWandTask(linked.id, { status: "done" });
-}

package/dist/web-ui/asset-version.d.ts

@@ -0,0 +1,5 @@
+export interface VersionedWebAsset {
+    content: string;
+    hash: string;
+}
+export declare function versionWebAsset(content: string): VersionedWebAsset;

package/dist/web-ui/asset-version.js

@@ -0,0 +1,5 @@
+import { createHash } from "node:crypto";
+// The hash covers the bytes actually sent (including server-side JS substitutions).
+export function versionWebAsset(content) {
+    return { content, hash: createHash("sha256").update(content).digest("hex").slice(0, 16) };
+}