@co0ontty/wand 1.6.2 → 1.9.0

package/dist/structured-session-manager.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
+import { prepareSessionWorktree } from "./git-worktree.js";
 const STREAM_EMIT_DEBOUNCE_MS = 16;
 function isRunningAsRoot() {
     return process.getuid?.() === 0 || process.geteuid?.() === 0;
@@ -25,6 +26,15 @@ function withSummary(snapshot) {
 function shouldAutoApproveForMode(mode) {
     return mode === "full-access" || mode === "managed" || mode === "auto-edit";
 }
+function buildStructuredOutputPayload(snapshot) {
+    return {
+        output: snapshot.output,
+        messages: snapshot.messages,
+        queuedMessages: snapshot.queuedMessages,
+        sessionKind: "structured",
+        structuredState: snapshot.structuredState,
+    };
+}
 export class StructuredSessionManager {
     storage;
     config;
@@ -41,13 +51,16 @@ export class StructuredSessionManager {
             const restored = {
                 ...snapshot,
                 sessionKind: "structured",
+                provider: snapshot.provider ?? "claude",
                 runner: snapshot.runner ?? "claude-cli-print",
                 status: restoredStatus,
                 autoApprovePermissions: snapshot.autoApprovePermissions ?? shouldAutoApproveForMode(snapshot.mode),
                 approvalStats: snapshot.approvalStats ?? { tool: 0, command: 0, file: 0, total: 0 },
+                queuedMessages: snapshot.queuedMessages ?? [],
                 pendingEscalation: null,
                 permissionBlocked: false,
                 structuredState: {
+                    provider: snapshot.structuredState?.provider ?? snapshot.provider ?? "claude",
                     runner: snapshot.runner ?? "claude-cli-print",
                     model: snapshot.structuredState?.model,
                     lastError: snapshot.structuredState?.lastError ?? null,
@@ -75,23 +88,31 @@ export class StructuredSessionManager {
         const id = randomUUID();
         const startedAt = new Date().toISOString();
         const prompt = options.prompt?.trim();
+        const worktreeSetup = options.worktreeEnabled
+            ? prepareSessionWorktree({ cwd: options.cwd, sessionId: id })
+            : null;
         const snapshot = {
             id,
             sessionKind: "structured",
+            provider: "claude",
             runner: options.runner ?? "claude-cli-print",
             command: "claude -p --output-format stream-json",
-            cwd: options.cwd,
+            cwd: worktreeSetup?.cwd ?? options.cwd,
             mode: options.mode,
-            status: prompt ? "running" : "stopped",
+            worktreeEnabled: Boolean(worktreeSetup),
+            worktree: worktreeSetup?.worktree ?? null,
+            status: "running",
             exitCode: null,
             startedAt,
-            endedAt: prompt ? null : startedAt,
+            endedAt: null,
             output: "",
             archived: false,
             archivedAt: null,
             claudeSessionId: null,
             messages: [],
+            queuedMessages: [],
             structuredState: {
+                provider: "claude",
                 runner: options.runner ?? "claude-cli-print",
                 inFlight: false,
                 activeRequestId: null,
@@ -119,7 +140,6 @@ export class StructuredSessionManager {
             const child = this.pendingChildren.get(id);
             const childAlive = child && !child.killed && child.exitCode === null;
             if (!childAlive) {
-                // Auto-recover: inFlight is stuck but child process is gone or dead
                 if (child)
                     this.pendingChildren.delete(id);
                 const recovered = {
@@ -137,7 +157,18 @@ export class StructuredSessionManager {
                 session = recovered;
             }
             else {
-                throw new Error("结构化会话正在处理中，请稍后再试。");
+                const queue = [...(session.queuedMessages ?? [])];
+                if (queue.length >= 10) {
+                    throw new Error("排队消息已满（最多 10 条），请等待当前消息处理完成。");
+                }
+                const queued = {
+                    ...session,
+                    queuedMessages: [...queue, prompt],
+                };
+                this.sessions.set(id, queued);
+                this.storage.saveSession(queued);
+                this.emitStructuredSnapshot(queued);
+                return queued;
             }
         }
         const userTurn = {
@@ -152,7 +183,7 @@ export class StructuredSessionManager {
             endedAt: null,
             messages: [...(session.messages ?? []), userTurn],
             structuredState: {
-                ...(session.structuredState ?? { runner: "claude-cli-print", lastError: null, inFlight: false, activeRequestId: null }),
+                ...(session.structuredState ?? { provider: "claude", runner: "claude-cli-print", lastError: null, inFlight: false, activeRequestId: null }),
                 inFlight: true,
                 activeRequestId: requestId,
                 lastError: null,
@@ -160,15 +191,11 @@ export class StructuredSessionManager {
         };
         this.sessions.set(id, updated);
         this.storage.saveSession(updated);
-        this.emit({
-            type: "output",
-            sessionId: id,
-            data: { output: updated.output, messages: updated.messages, sessionKind: "structured" },
-        });
+        this.emitStructuredSnapshot(updated);
         this.emit({
             type: "status",
             sessionId: id,
-            data: { status: "running", sessionKind: "structured" },
+            data: { status: "running", sessionKind: "structured", queuedMessages: updated.queuedMessages, structuredState: updated.structuredState },
         });
         try {
             await this.runClaudeStreaming(id, updated, prompt);
@@ -197,13 +224,9 @@ export class StructuredSessionManager {
             this.emit({
                 type: "status",
                 sessionId: id,
-                data: { status: failed.status, error: message, sessionKind: "structured" },
-            });
-            this.emit({
-                type: "ended",
-                sessionId: id,
-                data: { status: failed.status, exitCode: 1, messages: failed.messages, sessionKind: "structured", structuredState: failed.structuredState },
+                data: { status: failed.status, error: message, sessionKind: "structured", queuedMessages: failed.queuedMessages, structuredState: failed.structuredState },
             });
+            this.emitStructuredSnapshot(failed, "ended");
             throw error;
         }
     }
@@ -268,14 +291,14 @@ export class StructuredSessionManager {
             pendingEscalation: null,
             permissionBlocked: false,
             structuredState: {
-                ...(session.structuredState ?? { runner: "claude-cli-print", lastError: null, inFlight: false, activeRequestId: null }),
+                ...(session.structuredState ?? { provider: "claude", runner: "claude-cli-print", lastError: null, inFlight: false, activeRequestId: null }),
                 inFlight: false,
                 activeRequestId: null,
             },
         };
         this.sessions.set(id, stopped);
         this.storage.saveSession(stopped);
-        this.emit({ type: "ended", sessionId: id, data: { status: stopped.status, exitCode: null, messages: stopped.messages, sessionKind: "structured" } });
+        this.emitStructuredSnapshot(stopped, "ended");
         return stopped;
     }
     delete(id) {
@@ -297,6 +320,58 @@ export class StructuredSessionManager {
         }
         return session;
     }
+    buildQueuedPlaceholderTurns(session) {
+        return (session.queuedMessages ?? []).map((text) => ({
+            role: "user",
+            content: [{ type: "text", text, __queued: true }],
+        }));
+    }
+    buildRenderableMessages(session) {
+        return [
+            ...(session.messages ?? []),
+            ...this.buildQueuedPlaceholderTurns(session),
+        ];
+    }
+    emitStructuredSnapshot(session, eventType = "output") {
+        const payload = buildStructuredOutputPayload(session);
+        const data = {
+            ...payload,
+            messages: this.buildRenderableMessages(session),
+            status: session.status,
+            exitCode: session.exitCode,
+        };
+        this.emit({
+            type: eventType,
+            sessionId: session.id,
+            data,
+        });
+    }
+    async flushNextQueuedMessage(sessionId) {
+        const current = this.sessions.get(sessionId);
+        if (!current || (current.queuedMessages?.length ?? 0) === 0) {
+            return;
+        }
+        if (current.structuredState?.inFlight) {
+            return;
+        }
+        const [nextInput, ...restQueue] = current.queuedMessages ?? [];
+        if (!nextInput) {
+            return;
+        }
+        const nextSession = {
+            ...current,
+            queuedMessages: restQueue,
+        };
+        this.sessions.set(sessionId, nextSession);
+        this.storage.saveSession(nextSession);
+        this.emitStructuredSnapshot(nextSession);
+        try {
+            await this.sendMessage(sessionId, nextInput);
+        }
+        catch (error) {
+            console.error("[WAND] flushNextQueuedMessage failed:", error);
+        }
+    }
     emit(event) {
         if (this.emitEvent) {
             this.emitEvent(event);
@@ -431,7 +506,7 @@ export class StructuredSessionManager {
                 this.emit({
                     type: "output",
                     sessionId,
-                    data: { output: current.output, messages: current.messages, sessionKind: "structured" },
+                    data: buildStructuredOutputPayload(current),
                 });
             };
             const scheduleEmit = () => {
@@ -462,12 +537,16 @@ export class StructuredSessionManager {
                     ...current,
                     claudeSessionId: turnState.sessionId ?? current.claudeSessionId,
                     messages: msgs,
+                    output: turnState.result || current.output,
                     structuredState: {
                         ...current.structuredState,
                         model: turnState.model ?? current.structuredState?.model,
                     },
                 };
                 this.sessions.set(sessionId, patched);
+                // Persist streaming progress so a server restart does not roll back the
+                // latest assistant turn to the pre-stream snapshot.
+                this.storage.saveSession(patched);
             };
             const processLine = (line) => {
                 const trimmed = line.trim();
@@ -590,16 +669,8 @@ export class StructuredSessionManager {
                     };
                     this.sessions.set(sessionId, failed);
                     this.storage.saveSession(failed);
-                    this.emit({
-                        type: "output",
-                        sessionId,
-                        data: { output: failed.output, messages: failed.messages, sessionKind: "structured" },
-                    });
-                    this.emit({
-                        type: "ended",
-                        sessionId,
-                        data: { status: failed.status, exitCode: failed.exitCode, messages: failed.messages, sessionKind: "structured", structuredState: failed.structuredState },
-                    });
+                    this.emitStructuredSnapshot(failed);
+                    this.emitStructuredSnapshot(failed, "ended");
                     reject(new Error(errorText));
                     return;
                 }
@@ -639,16 +710,8 @@ export class StructuredSessionManager {
                 };
                 this.sessions.set(sessionId, finished);
                 this.storage.saveSession(finished);
-                this.emit({
-                    type: "output",
-                    sessionId,
-                    data: { output: finished.output, messages: finished.messages, sessionKind: "structured" },
-                });
-                this.emit({
-                    type: "ended",
-                    sessionId,
-                    data: { status: finished.status, exitCode: 0, messages: finished.messages, sessionKind: "structured", structuredState: finished.structuredState },
-                });
+                this.emitStructuredSnapshot(finished);
+                this.emitStructuredSnapshot(finished, "ended");
                 // Auto-continue after plan mode exit: when Claude calls ExitPlanMode,
                 // the `-p` process exits because stdin is "ignore" and it cannot get
                 // user confirmation.  Detect this and automatically resume execution
@@ -657,8 +720,6 @@ export class StructuredSessionManager {
                 if (lastToolUse && lastToolUse.name === "ExitPlanMode" && turnState.sessionId) {
                     console.log("[WAND] ExitPlanMode detected – auto-continuing plan execution for session:", sessionId);
                     resolve();
-                    // Schedule the continuation outside the current promise chain so it
-                    // does not block the close handler.
                     setImmediate(() => {
                         this.sendMessage(sessionId, "Plan approved. Proceed with the implementation.").catch((err) => {
                             console.error("[WAND] Auto-continue after ExitPlanMode failed:", err);
@@ -667,6 +728,9 @@ export class StructuredSessionManager {
                     return;
                 }
                 resolve();
+                setImmediate(() => {
+                    void this.flushNextQueuedMessage(sessionId);
+                });
             });
         });
     }

package/dist/types.d.ts

@@ -1,5 +1,6 @@
 export type SessionKind = "pty" | "structured";
 export type SessionCreateKind = "pty" | "structured";
+export type SessionProvider = "claude" | "codex";
 export type SessionRunner = "claude-cli" | "claude-cli-print" | "pty";
 export type ExecutionMode = "assist" | "agent" | "agent-max" | "default" | "auto-edit" | "full-access" | "native" | "managed";
 export type AutonomyPolicy = "assist" | "agent" | "agent-max";
@@ -46,6 +47,21 @@ export interface StructuredChatPersonaConfig {
     user?: StructuredChatPersonaRoleConfig;
     assistant?: StructuredChatPersonaRoleConfig;
 }
+export interface DefaultPanelStateConfig {
+    sessionsDrawerOpen?: boolean;
+    filePanelOpen?: boolean;
+    shortcutsExpanded?: boolean;
+    claudeHistoryExpanded?: boolean;
+    chatMessageExpanded?: boolean;
+    structuredThinkingExpanded?: boolean;
+    structuredToolGroupExpanded?: boolean;
+    structuredInlineToolExpanded?: boolean;
+    structuredTerminalExpanded?: boolean;
+    structuredToolCardExpanded?: boolean;
+}
+export interface UiPreferencesConfig {
+    defaultPanelState?: DefaultPanelStateConfig;
+}
 export interface WandConfig {
     host: string;
     port: number;
@@ -63,12 +79,52 @@ export interface WandConfig {
     shortcutLogMaxBytes?: number;
     /** Preferred response language for Claude (e.g. "中文", "English"). Empty string means no override. */
     language?: string;
+    /** UI defaults used for initializing panel open/expanded state. */
+    uiPreferences?: UiPreferencesConfig;
+}
+interface WorktreeInfo {
+    branch: string;
+    path: string;
+}
+export interface WorktreeMergeInfo {
+    targetBranch?: string;
+    mergedAt?: string;
+    mergeCommit?: string;
+    cleanupDone?: boolean;
+    lastError?: string;
+    conflict?: boolean;
+}
+export interface WorktreeMergeCheckResult {
+    ok: boolean;
+    sourceBranch: string;
+    targetBranch: string;
+    worktreePath: string;
+    repoRoot: string;
+    hasUncommittedChanges: boolean;
+    aheadCount: number;
+    hasConflicts: boolean;
+    recommendedAction: "merge" | "noop" | "resolve-conflict";
+    reason?: string;
+}
+export interface WorktreeMergeResult {
+    ok: boolean;
+    sourceBranch: string;
+    targetBranch: string;
+    repoRoot: string;
+    mergeCommit?: string;
+    mergedAt?: string;
+    cleanupDone: boolean;
+    conflict: boolean;
+    errorCode?: string;
+    reason?: string;
 }
 export interface CommandRequest {
     command: string;
+    provider?: SessionProvider;
     cwd?: string;
     mode?: ExecutionMode;
     initialInput?: string;
+    worktreeEnabled?: boolean;
 }
 export interface InputRequest {
     input?: string;
@@ -143,6 +199,7 @@ export interface ConversationTurn {
     };
 }
 export interface StructuredSessionState {
+    provider?: SessionProvider;
     runner: SessionRunner;
     model?: string;
     lastError: string | null;
@@ -152,10 +209,15 @@ export interface StructuredSessionState {
 export interface SessionSnapshot {
     id: string;
     sessionKind?: SessionKind;
+    provider?: SessionProvider;
     runner?: SessionRunner;
     command: string;
     cwd: string;
     mode: ExecutionMode;
+    worktreeEnabled?: boolean;
+    worktree?: WorktreeInfo | null;
+    worktreeMergeStatus?: "ready" | "checking" | "merging" | "merged" | "failed";
+    worktreeMergeInfo?: WorktreeMergeInfo | null;
     autonomyPolicy?: AutonomyPolicy;
     approvalPolicy?: ApprovalPolicy;
     allowedScopes?: EscalationScope[];
@@ -178,6 +240,8 @@ export interface SessionSnapshot {
     claudeSessionId: string | null;
     /** Structured conversation messages derived from PTY output. */
     messages?: ConversationTurn[];
+    /** Pending structured user inputs queued while an assistant response is in flight. */
+    queuedMessages?: string[];
     structuredState?: StructuredSessionState;
     /** Session lifecycle state */
     lifecycleState?: "running" | "idle" | "archived";
@@ -255,3 +319,4 @@ export interface TaskData {
 export interface SessionEndData {
     exitCode: number | null;
 }
+export {};