@co0ontty/wand 4.42.1 → 4.43.0

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

@@ -16,6 +16,7 @@ interface ResolvedUpdateAsset {
     size: number;
     source: "local" | "github";
     releaseNotes?: string;
+    sha256?: string;
 }
 export interface PublicUpdateRoutesDependencies {
     resolveLatestApk(channel: "stable" | "beta"): Promise<ResolvedUpdateAsset | null>;

package/dist/server-update-routes.js

@@ -31,6 +31,8 @@ export function registerPublicUpdateRoutes(app, deps) {
             source: latest.source,
             channel,
             releaseNotes: updateAvailable ? (latest.releaseNotes ?? null) : null,
+            // 本地分发时为 hex SHA-256，Android 客户端下载后校验；GitHub 来源为 null。
+            sha256: updateAvailable ? (latest.sha256 ?? null) : null,
         });
     }));
     app.get("/android/download", asyncRoute(async (req, res) => {

package/dist/server-workspace-routes.js

@@ -5,6 +5,8 @@ import { asyncRoute } from "./express-async.js";
 import { getErrorMessage } from "./error-utils.js";
 import { expandHomePath } from "./middleware/path-safety.js";
 import { checkSessionWorktreeMergeabilityAsync, cleanupWorktreeSync, prepareSessionWorktree, resolveWorktreeTargetBranchAsync, } from "./git-worktree.js";
+import { resolveSessionDisplayTitle } from "./session-transport.js";
+import { attachUnboundSessionsToWorkspace, backfillSessionWorkspaces, } from "./workspace-binding.js";
 const PROVIDERS = new Set(["claude", "codex", "opencode", "grok", "qoder", "pi"]);
 function parseDefaultProvider(value) {
     return typeof value === "string" && PROVIDERS.has(value) ? value : undefined;
@@ -29,11 +31,13 @@ function deleteSessions(storage, sessions, sessionIds) {
             storage.deleteSession(sessionId);
     }
 }
-function workspaceWithWorktreeCount(storage, workspace) {
+function workspaceWithCounts(storage, workspace, sessionCounts) {
     const worktreeCount = storage.listWorkspaceTasks(workspace.id)
         .filter((task) => task.worktree !== null)
         .length;
-    return { ...workspace, worktreeCount };
+    const sessionCount = sessionCounts?.get(workspace.id)
+        ?? storage.listSessionsByWorkspace(workspace.id).length;
+    return { ...workspace, worktreeCount, sessionCount };
 }
 // ── Layout validation / sanitization（前端 PUT 与测试共用）──
 function sanitizePaneTab(value) {
@@ -148,7 +152,9 @@ export function sanitizeTaskLayout(value) {
 export function registerWorkspaceRoutes(app, storage, sessions) {
     // 列出所有项目（按最近打开排序）
     app.get("/api/workspaces", (_req, res) => {
-        res.json(storage.listWorkspaces().map((workspace) => workspaceWithWorktreeCount(storage, workspace)));
+        backfillSessionWorkspaces(storage);
+        const sessionCounts = storage.countSessionsByWorkspace();
+        res.json(storage.listWorkspaces().map((workspace) => workspaceWithCounts(storage, workspace, sessionCounts)));
     });
     // 新建项目：名称 + 目录 + 默认 IDE，不启动会话
     app.post("/api/workspaces", asyncRoute(async (req, res) => {
@@ -168,7 +174,8 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
         }
         const defaultProvider = parseDefaultProvider(body.defaultProvider);
         const workspace = storage.createWorkspace({ name, cwd, defaultProvider });
-        res.status(201).json({ ...workspace, worktreeCount: 0 });
+        const attached = attachUnboundSessionsToWorkspace(storage, workspace);
+        res.status(201).json({ ...workspace, worktreeCount: 0, sessionCount: attached });
     }));
     // 项目详情：meta + 会话 + 布局；访问即更新 lastOpenedAt
     app.get("/api/workspaces/:id", (req, res) => {
@@ -179,8 +186,11 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
         }
         storage.touchWorkspace(workspace.id);
         res.json({
-            ...workspaceWithWorktreeCount(storage, workspace),
-            sessions: storage.listSessionsByWorkspace(workspace.id),
+            ...workspaceWithCounts(storage, workspace),
+            sessions: storage.listSessionsByWorkspace(workspace.id).map((session) => ({
+                ...session,
+                title: resolveSessionDisplayTitle(session),
+            })),
         });
     });
     // 改名 / 目录 / 默认 IDE
@@ -213,7 +223,7 @@ export function registerWorkspaceRoutes(app, storage, sessions) {
         }
         storage.updateWorkspace(existing.id, patch);
         const updated = storage.getWorkspace(existing.id);
-        res.json(updated ? workspaceWithWorktreeCount(storage, updated) : null);
+        res.json(updated ? workspaceWithCounts(storage, updated) : null);
     });
     // 删除项目；cascade=true 连带删会话，否则仅解绑
     app.delete("/api/workspaces/:id", (req, res) => {

package/dist/server.js

@@ -28,6 +28,7 @@ import { refreshProviderCliUpdateState, registerAdminUpdateRoutes, registerPubli
 import { parseSessionCreationOrigin, registerClaudeHistoryRoutes, registerSessionRoutes } from "./server-session-routes.js";
 import { registerWorkspaceRoutes } from "./server-workspace-routes.js";
 import { resolveSessionCwd } from "./session-cwd.js";
+import { resolveWorkspaceIdForNewSession } from "./workspace-binding.js";
 import { getErrorMessage } from "./error-utils.js";
 import { asyncRoute, jsonErrorHandler } from "./express-async.js";
 import { checkPackageUpdateAsync, installPackageGloballyAsync, normalizeUpdateChannel, resolveGlobalWandCli, } from "./npm-update-utils.js";
@@ -1020,23 +1021,25 @@ export async function startServer(config, configPath, options = {}) {
                 : undefined;
             const reqCols = typeof body.cols === "number" && Number.isFinite(body.cols) ? body.cols : undefined;
             const reqRows = typeof body.rows === "number" && Number.isFinite(body.rows) ? body.rows : undefined;
+            const sessionCwd = resolveSessionCwd(body.cwd, config.defaultCwd);
+            const workspaceId = resolveWorkspaceIdForNewSession(storage, sessionCwd, body.workspaceId);
             const snapshot = await (interactiveShell
-                ? processes.startShell(body.cwd, body.mode ?? "default", {
+                ? processes.startShell(sessionCwd, body.mode ?? "default", {
                     worktreeEnabled: body.worktreeEnabled === true,
                     cols: reqCols,
                     rows: reqRows,
-                    workspaceId: body.workspaceId,
+                    workspaceId,
                     workspaceTaskId: body.workspaceTaskId,
                     ...origin,
                 })
-                : processes.start(command, body.cwd, body.mode ?? config.defaultMode, initialInput || undefined, {
+                : processes.start(command, sessionCwd, body.mode ?? config.defaultMode, initialInput || undefined, {
                     worktreeEnabled: body.worktreeEnabled === true,
                     provider,
                     model: effectiveModel,
                     cols: reqCols,
                     rows: reqRows,
                     thinkingEffort: body.thinkingEffort ?? config.defaultThinkingEffort,
-                    workspaceId: body.workspaceId,
+                    workspaceId,
                     workspaceTaskId: body.workspaceTaskId,
                     ...origin,
                 }));

package/dist/storage.d.ts

@@ -60,6 +60,14 @@ export declare class WandStorage {
     listSessionsByWorkspace(workspaceId: string): SessionSnapshot[];
     /** 显式更新某会话的工作空间归属（用于创建时绑定）。 */
     setSessionWorkspaceId(sessionId: string, workspaceId: string | null): void;
+    /** Lightweight count of persisted sessions grouped by workspace. */
+    countSessionsByWorkspace(): Map<string, number>;
+    /** Sessions not yet attached to a project. Omits messages/output. */
+    listUnboundSessionBindings(): Array<{
+        id: string;
+        cwd: string;
+        worktree: SessionSnapshot["worktree"];
+    }>;
     listWorkspaceTasks(workspaceId: string): WorkspaceTask[];
     getWorkspaceTask(id: string): WorkspaceTask | null;
     createWorkspaceTask(input: {

package/dist/storage.js

@@ -861,6 +861,29 @@ export class WandStorage {
     setSessionWorkspaceId(sessionId, workspaceId) {
         this.db.prepare("UPDATE command_sessions SET workspace_id = ? WHERE id = ?").run(workspaceId, sessionId);
     }
+    /** Lightweight count of persisted sessions grouped by workspace. */
+    countSessionsByWorkspace() {
+        const rows = this.db
+            .prepare(`SELECT workspace_id AS id, COUNT(*) AS n
+         FROM command_sessions
+         WHERE workspace_id IS NOT NULL AND workspace_id != ''
+         GROUP BY workspace_id`)
+            .all();
+        return new Map(rows.map((row) => [row.id, Number(row.n) || 0]));
+    }
+    /** Sessions not yet attached to a project. Omits messages/output. */
+    listUnboundSessionBindings() {
+        const rows = this.db
+            .prepare(`SELECT id, cwd, worktree_info
+         FROM command_sessions
+         WHERE workspace_id IS NULL OR workspace_id = ''`)
+            .all();
+        return rows.map((row) => ({
+            id: row.id,
+            cwd: row.cwd,
+            worktree: parseWorktreeInfo(row.worktree_info) ?? null,
+        }));
+    }
     // ── Workspace tasks（任务 = 命名 + 独立 worktree + 一组标签）──
     listWorkspaceTasks(workspaceId) {
         const rows = this.db
@@ -1111,7 +1134,7 @@ export class WandStorage {
     deleteExpiredAuthSessions(now) {
         this.db.prepare("DELETE FROM auth_sessions WHERE expires_at < ?").run(now);
     }
-    // ============ Missions / Agent Inbox ============
+    // ============ Missions ============
     saveMission(mission) {
         this.db.prepare(`INSERT INTO missions (
          id, title, prompt, cwd, status, base_ref, shared_directories, copy_paths, created_at, updated_at

package/dist/terminal-daemon-client.d.ts

@@ -11,12 +11,32 @@ export declare class TerminalDaemonClient implements TerminalHost {
     private readonly inventory;
     private readonly handles;
     private readonly pendingEvents;
+    private disposed;
+    private reconnectTimer;
+    private reconnectDelayMs;
+    private reconnectFailureLogged;
     constructor(socketPath: string, token: string);
     connect(): Promise<void>;
     attach(sessionId: string, afterSeq?: number): TerminalAttachResult | null;
     createOrAttach(request: TerminalSpawnRequest, afterSeq?: number): Promise<TerminalAttachResult>;
     forget(sessionId: string): void;
     disconnect(): void;
+    /**
+     * Socket teardown path. Without a reconnect, a daemon restart would leave
+     * every RemoteTerminalProcess silently dead while ProcessManager keeps the
+     * session status at "running" forever.
+     */
+    private handleDisconnect;
+    private scheduleReconnect;
+    private tryReconnect;
+    /**
+     * Diff the pre-disconnect inventory against the daemon's fresh `list`.
+     * Sessions that vanished (daemon restart/forget) or exited while we were
+     * disconnected get a synthetic exit delivered to their existing handle so
+     * ProcessManager finalizes them; live sessions replay chunks missed during
+     * the gap.
+     */
+    private reconcileAfterReconnect;
     request(method: TerminalDaemonRequest["method"], params?: Record<string, unknown>): Promise<unknown>;
     reportOperationError(sessionId: string, error: unknown): void;
     private resultFromState;

package/dist/terminal-daemon-client.js

@@ -5,6 +5,8 @@ import process from "node:process";
 import { TERMINAL_DAEMON_PROTOCOL_VERSION, terminalDaemonPaths, } from "./terminal-daemon-protocol.js";
 import { appendTerminalChunkWindow, InProcessTerminalHost, } from "./terminal-host.js";
 import { appendWindow, PTY_OUTPUT_MAX_SIZE } from "./pty-text-utils.js";
+const TERMINAL_DAEMON_RECONNECT_INITIAL_MS = 500;
+const TERMINAL_DAEMON_RECONNECT_MAX_MS = 10_000;
 class RemoteTerminalProcess {
     sessionId;
     incarnationId;
@@ -106,11 +108,17 @@ export class TerminalDaemonClient {
     inventory = new Map();
     handles = new Map();
     pendingEvents = new Map();
+    disposed = false;
+    reconnectTimer = null;
+    reconnectDelayMs = TERMINAL_DAEMON_RECONNECT_INITIAL_MS;
+    reconnectFailureLogged = false;
     constructor(socketPath, token) {
         this.socketPath = socketPath;
         this.token = token;
     }
     async connect() {
+        if (this.disposed)
+            throw new Error("Terminal daemon client disposed");
         if (this.socket && !this.socket.destroyed)
             return;
         const socket = net.createConnection(this.socketPath);
@@ -127,13 +135,33 @@ export class TerminalDaemonClient {
             socket.once("error", onError);
         });
         socket.on("data", (data) => this.consume(data.toString("utf8")));
-        socket.on("close", () => this.rejectPending(new Error("Terminal daemon disconnected")));
-        socket.on("error", (error) => this.rejectPending(error));
-        await this.request("hello");
-        const sessions = await this.request("list");
-        this.inventory.clear();
-        for (const session of sessions)
-            this.inventory.set(session.sessionId, session);
+        socket.on("close", () => this.handleDisconnect());
+        socket.on("error", (error) => {
+            this.rejectPending(error instanceof Error ? error : new Error(String(error)));
+            this.handleDisconnect();
+        });
+        try {
+            await this.request("hello");
+            const previous = new Map(this.inventory);
+            const sessions = await this.request("list");
+            this.inventory.clear();
+            for (const session of sessions)
+                this.inventory.set(session.sessionId, session);
+            if (previous.size > 0) {
+                this.reconcileAfterReconnect(previous);
+                process.stderr.write("[wand] Reconnected to terminal daemon; reconciled PTY inventory.\n");
+            }
+        }
+        catch (error) {
+            if (!this.disposed) {
+                try {
+                    socket.destroy();
+                }
+                catch { /* best-effort cleanup */ }
+                this.handleDisconnect();
+            }
+            throw error;
+        }
     }
     attach(sessionId, afterSeq = 0) {
         const state = this.inventory.get(sessionId);
@@ -156,6 +184,11 @@ export class TerminalDaemonClient {
         void this.request("forget", { sessionId }).catch((error) => this.reportOperationError(sessionId, error));
     }
     disconnect() {
+        this.disposed = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
         const socket = this.socket;
         this.socket = null;
         if (socket && !socket.destroyed)
@@ -164,6 +197,78 @@ export class TerminalDaemonClient {
         this.handles.clear();
         this.pendingEvents.clear();
     }
+    /**
+     * Socket teardown path. Without a reconnect, a daemon restart would leave
+     * every RemoteTerminalProcess silently dead while ProcessManager keeps the
+     * session status at "running" forever.
+     */
+    handleDisconnect() {
+        if (this.socket?.destroyed)
+            this.socket = null;
+        this.rejectPending(new Error("Terminal daemon disconnected"));
+        if (this.disposed)
+            return;
+        this.scheduleReconnect();
+    }
+    scheduleReconnect() {
+        if (this.disposed || this.reconnectTimer)
+            return;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            void this.tryReconnect();
+        }, this.reconnectDelayMs);
+        this.reconnectTimer.unref?.();
+        this.reconnectDelayMs = Math.min(this.reconnectDelayMs * 2, TERMINAL_DAEMON_RECONNECT_MAX_MS);
+    }
+    async tryReconnect() {
+        if (this.disposed)
+            return;
+        try {
+            await this.connect();
+            this.reconnectDelayMs = TERMINAL_DAEMON_RECONNECT_INITIAL_MS;
+            this.reconnectFailureLogged = false;
+        }
+        catch (error) {
+            if (this.disposed)
+                return;
+            if (!this.reconnectFailureLogged) {
+                this.reconnectFailureLogged = true;
+                process.stderr.write(`[wand] Terminal daemon reconnect failed: ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+            this.scheduleReconnect();
+        }
+    }
+    /**
+     * Diff the pre-disconnect inventory against the daemon's fresh `list`.
+     * Sessions that vanished (daemon restart/forget) or exited while we were
+     * disconnected get a synthetic exit delivered to their existing handle so
+     * ProcessManager finalizes them; live sessions replay chunks missed during
+     * the gap.
+     */
+    reconcileAfterReconnect(previous) {
+        for (const [sessionId, oldState] of previous) {
+            const current = this.inventory.get(sessionId);
+            const handle = this.handles.get(sessionId);
+            const handleMatches = !!handle && handle.incarnationId === oldState.incarnationId;
+            const stillRunning = !!current
+                && current.incarnationId === oldState.incarnationId
+                && current.status === "running";
+            if (stillRunning && handleMatches) {
+                for (const chunk of current.chunks) {
+                    if (chunk.seq > oldState.seq)
+                        handle.acceptData(chunk);
+                }
+                continue;
+            }
+            const exitedOnDaemon = !!current
+                && current.incarnationId === oldState.incarnationId
+                && current.status === "exited";
+            const exitCode = exitedOnDaemon ? current.exitCode ?? -1 : -1;
+            this.handles.delete(sessionId);
+            if (handleMatches)
+                handle.acceptExit({ exitCode });
+        }
+    }
     async request(method, params) {
         const socket = this.socket;
         if (!socket || socket.destroyed || !socket.writable)

package/dist/types.d.ts

@@ -344,6 +344,8 @@ export interface InputRequest {
      * and continue receiving progress through the existing event stream.
      */
     respondImmediately?: boolean;
+    /** PTY input can request a small acknowledgement instead of a full session detail payload. */
+    responseMode?: "snapshot" | "accepted";
     /** Current UI view: "chat" or "terminal". Chat view uses PTY-derived structured messages. */
     view?: "chat" | "terminal";
     autonomyPolicy?: AutonomyPolicy;