@co0ontty/wand 1.3.4 → 1.4.0

package/dist/process-manager.js

@@ -9,7 +9,7 @@ import { SessionLogger } from "./session-logger.js";
 import { SessionLifecycleManager } from "./session-lifecycle.js";
 import { ClaudePtyBridge } from "./claude-pty-bridge.js";
 import { appendWindow, hasExplicitConfirmSyntax, hasPermissionActionContext, normalizePromptText } from "./pty-text-utils.js";
-import { getResumeCommandSessionId, hasLiveProjectConversation, hasRealConversationMessages, hasStoredProjectConversation, shouldAllowResume, shouldDisplayResumeAction, } from "./resume-policy.js";
+import { getResumeCommandSessionId, hasRealConversationMessages, } from "./resume-policy.js";
 /** Check if the current process is running as root (UID 0). */
 function isRunningAsRoot() {
     return process.getuid?.() === 0 || process.geteuid?.() === 0;
@@ -26,20 +26,6 @@ export class SessionInputError extends Error {
         this.name = "SessionInputError";
     }
 }
-const PROMPT_PATTERNS = [
-    /(?:^|\b)(?:press\s+)?(?:y|yes)\s*(?:\/|\bor\b)\s*(?:n|no)(?:\b|$)/i,
-    /\[(?:y|yes)\s*\/\s*(?:n|no)\]/i,
-    /\((?:y|yes)\s*\/\s*(?:n|no)\)/i,
-    /\((?:y|yes)\s*\/\s*(?:n|no)\s*\/\s*always\)/i,
-    /\bcontinue\?\s*(?:\((?:y|yes)\s*\/\s*(?:n|no)\))?/i,
-    /\bare you sure\??/i,
-    /\bdo you want to continue\??/i,
-    /\bdo you want to (?:create|write|delete|modify|execute)\b/i,
-    /\bconfirm(?:\s+execution|\s+changes|\s+action)?\??/i,
-    /\bproceed\?\s*(?:\((?:y|yes)\s*\/\s*(?:n|no)\))?/i,
-    /\benter to confirm\b/i,
-    /\bgrant\b.*\bpermission\b/i,
-];
 const REAL_CONVERSATION_MIN_LINES = 2;
 const DISCOVERY_RECENT_WINDOW_MS = 10 * 60 * 1000;
 const START_TIME_SKEW_MS = 30 * 1000;
@@ -89,132 +75,6 @@ function readClaudeProjectSessionDetails(filePath, id) {
         return null;
     }
 }
-function hasVisibleProjectConversation(messages) {
-    return shouldDisplayResumeAction(messages);
-}
-function hasRecoverableProjectConversation(messages) {
-    return shouldAllowResume({ claudeSessionId: "resume-candidate", messages });
-}
-function shouldBindLiveProjectSessionId(messages) {
-    return hasLiveProjectConversation(messages);
-}
-function shouldBackfillStoredProjectSessionId(messages) {
-    return hasStoredProjectConversation(messages);
-}
-function shouldDisplayVisibleProjectSessionId(messages) {
-    return hasVisibleProjectConversation(messages);
-}
-function shouldResumeRecoverableProjectSessionId(messages) {
-    return hasRecoverableProjectConversation(messages);
-}
-function canBindLiveProjectSession(record) {
-    return shouldBindLiveProjectSessionId(record.messages);
-}
-function canBackfillStoredProjectSession(record) {
-    return shouldBackfillStoredProjectSessionId(record.messages);
-}
-function canDisplayVisibleProjectSession(messages) {
-    return shouldDisplayVisibleProjectSessionId(messages);
-}
-function canResumeRecoverableProjectSession(messages) {
-    return shouldResumeRecoverableProjectSessionId(messages);
-}
-function shouldAdoptProjectSessionDuringRuntime(record) {
-    return canBindLiveProjectSession(record);
-}
-function shouldAdoptProjectSessionDuringBackfill(record) {
-    return canBackfillStoredProjectSession(record);
-}
-function shouldAdoptProjectSessionForUi(messages) {
-    return canDisplayVisibleProjectSession(messages);
-}
-function shouldAdoptProjectSessionForResume(messages) {
-    return canResumeRecoverableProjectSession(messages);
-}
-function hasRuntimeProjectAdoption(messages) {
-    return shouldAdoptProjectSessionForUi(messages);
-}
-function hasBackfillProjectAdoption(messages) {
-    return shouldBackfillStoredProjectSessionId(messages);
-}
-function hasUiProjectAdoption(messages) {
-    return shouldAdoptProjectSessionForUi(messages);
-}
-function hasResumeProjectAdoption(messages) {
-    return shouldAdoptProjectSessionForResume(messages);
-}
-function shouldAdoptProjectSession(record) {
-    return shouldAdoptProjectSessionDuringRuntime(record);
-}
-function shouldAdoptStoredProjectSession(record) {
-    return shouldAdoptProjectSessionDuringBackfill(record);
-}
-function shouldAdoptUiProjectSession(messages) {
-    return hasUiProjectAdoption(messages);
-}
-function shouldAdoptResumeProjectSession(messages) {
-    return hasResumeProjectAdoption(messages);
-}
-function canUseProjectSessionAtRuntime(record) {
-    return shouldAdoptProjectSession(record);
-}
-function canUseProjectSessionAtBackfill(record) {
-    return shouldAdoptStoredProjectSession(record);
-}
-function canUseProjectSessionAtUi(messages) {
-    return shouldAdoptUiProjectSession(messages);
-}
-function canUseProjectSessionAtResume(messages) {
-    return shouldAdoptResumeProjectSession(messages);
-}
-function hasProjectSessionRuntimeEligibility(messages) {
-    return shouldAdoptProjectSessionDuringRuntime({ messages: messages ?? [] });
-}
-function hasProjectSessionBackfillEligibility(messages) {
-    return shouldAdoptProjectSessionDuringBackfill({ messages: messages ?? [] });
-}
-function hasProjectSessionUiEligibility(messages) {
-    return canUseProjectSessionAtUi(messages);
-}
-function hasProjectSessionResumeEligibility(messages) {
-    return canUseProjectSessionAtResume(messages);
-}
-function shouldClaimProjectSessionDuringRuntime(messages) {
-    return hasProjectSessionRuntimeEligibility(messages);
-}
-function shouldClaimProjectSessionDuringBackfill(messages) {
-    return hasProjectSessionBackfillEligibility(messages);
-}
-function shouldClaimProjectSessionForUi(messages) {
-    return hasProjectSessionUiEligibility(messages);
-}
-function shouldClaimProjectSessionForResume(messages) {
-    return hasProjectSessionResumeEligibility(messages);
-}
-function hasClaimableProjectSessionRuntime(messages) {
-    return shouldClaimProjectSessionDuringRuntime(messages);
-}
-function hasClaimableProjectSessionBackfill(messages) {
-    return shouldClaimProjectSessionDuringBackfill(messages);
-}
-function hasClaimableProjectSessionUi(messages) {
-    return shouldClaimProjectSessionForUi(messages);
-}
-function hasClaimableProjectSessionResume(messages) {
-    return shouldClaimProjectSessionForResume(messages);
-}
-function isClaimableProjectSessionRuntime(messages) {
-    return hasClaimableProjectSessionRuntime(messages);
-}
-function isClaimableProjectSessionBackfill(messages) {
-    return hasClaimableProjectSessionBackfill(messages);
-}
-function isClaimableProjectSessionUi(messages) {
-    return hasClaimableProjectSessionUi(messages);
-}
-function isClaimableProjectSessionResume(messages) {
-    return hasClaimableProjectSessionResume(messages);
-}
 function listClaudeProjectSessionCandidates(cwd) {
     const projectDir = getClaudeProjectDir(cwd);
     try {
@@ -557,14 +417,15 @@ export class ProcessManager extends EventEmitter {
             onStateChange: (sessionId, oldState, newState) => {
                 this.emitEvent({ type: "status", sessionId, data: { oldState, newState } });
             },
-            onIdle: (sessionId) => {
-                console.error(`[ProcessManager] Session ${sessionId} is now idle`);
-            },
+            onIdle: (_sessionId) => { },
             onArchived: (sessionId, reason) => {
                 console.error(`[ProcessManager] Session ${sessionId} archived: ${reason}`);
             },
         });
         for (const snapshot of this.storage.loadSessions()) {
+            if ((snapshot.sessionKind ?? "pty") !== "pty") {
+                continue;
+            }
             const isClaudeCmd = /^claude\b/.test(snapshot.command.trim());
             const resumeCommandSessionId = getResumeCommandSessionId(snapshot.command);
             // Sessions restored from storage have ptyProcess: null — the old server's PTY
@@ -599,7 +460,8 @@ export class ProcessManager extends EventEmitter {
                     knownClaudeTaskIds: undefined,
                     claudeTaskDiscoveryTimer: null,
                     knownClaudeProjectMtimes: isClaudeCmd ? listClaudeProjectSessionMtimes(updated.cwd) : undefined,
-                    claudeSessionId: resumeCommandSessionId ?? updated.claudeSessionId
+                    claudeSessionId: resumeCommandSessionId ?? updated.claudeSessionId,
+                    approvalStats: { tool: 0, command: 0, file: 0, total: 0 }
                 });
                 this.lifecycleManager.register(snapshot.id, "idle");
                 console.error(`[ProcessManager] Restored session ${snapshot.id} marked as exited (PTY orphaned)`);
@@ -631,7 +493,8 @@ export class ProcessManager extends EventEmitter {
                     knownClaudeTaskIds: undefined,
                     claudeTaskDiscoveryTimer: null,
                     knownClaudeProjectMtimes: isClaudeCmd ? listClaudeProjectSessionMtimes(snapshot.cwd) : undefined,
-                    claudeSessionId: resumeCommandSessionId ?? snapshot.claudeSessionId
+                    claudeSessionId: resumeCommandSessionId ?? snapshot.claudeSessionId,
+                    approvalStats: { tool: 0, command: 0, file: 0, total: 0 }
                 });
                 this.lifecycleManager.register(snapshot.id, "archived");
             }
@@ -741,7 +604,8 @@ export class ProcessManager extends EventEmitter {
             lastEmittedTask: null,
             knownClaudeTaskIds: knownClaudeTaskIds ?? undefined,
             claudeTaskDiscoveryTimer: null,
-            knownClaudeProjectMtimes: knownClaudeProjectMtimes ?? undefined
+            knownClaudeProjectMtimes: knownClaudeProjectMtimes ?? undefined,
+            approvalStats: { tool: 0, command: 0, file: 0, total: 0 }
         };
         // Create PTY bridge for this session
         record.ptyBridge = new ClaudePtyBridge({
@@ -844,7 +708,7 @@ export class ProcessManager extends EventEmitter {
                 process.stderr.write(`[wand] Cannot send initial input: session not ready\n`);
                 return;
             }
-            process.stderr.write(`[wand] Sending initial input: ${initialInput}\n`);
+            process.stderr.write(`[wand] Sending initial input (${initialInput.length} chars)\n`);
             // Track initial input via bridge for Chat mode
             if (current.ptyBridge) {
                 current.ptyBridge.onUserInput(initialInput);
@@ -1012,35 +876,16 @@ export class ProcessManager extends EventEmitter {
     sendInput(id, input, view, shortcutKey) {
         const record = this.mustGet(id);
         if (record.status !== "running") {
-            console.error("[ProcessManager] Rejecting input for non-running session", {
-                sessionId: id,
-                status: record.status,
-                hasPty: !!record.ptyProcess,
-                inputLength: input.length,
-                view: view ?? "chat"
-            });
+            console.error(`[ProcessManager] Rejecting input: session ${id} not running (${record.status})`);
             throw new SessionInputError("Session is not running.", "SESSION_NOT_RUNNING", id, record.status);
         }
         // Update lifecycle
         this.lifecycleManager.touch(id);
         this.lifecycleManager.startThinking(id);
         if (!record.ptyProcess) {
-            console.error("[ProcessManager] Rejecting input because PTY is missing", {
-                sessionId: id,
-                status: record.status,
-                hasPty: !!record.ptyProcess,
-                inputLength: input.length,
-                view: view ?? "chat"
-            });
+            console.error(`[ProcessManager] Rejecting input: session ${id} has no PTY`);
             throw new SessionInputError("Session is not running.", "SESSION_NO_PTY", id, record.status);
         }
-        console.error("[ProcessManager] Sending input to session", {
-            sessionId: id,
-            status: record.status,
-            hasPty: !!record.ptyProcess,
-            inputLength: input.length,
-            view: view ?? "chat"
-        });
         // Log shortcut key interactions for auto-confirm and mode analysis
         if (shortcutKey) {
             const outputLines = record.output.split("\n");
@@ -1233,6 +1078,8 @@ export class ProcessManager extends EventEmitter {
         const messages = record.ptyBridge?.getMessages() ?? record.messages;
         return {
             id: record.id,
+            sessionKind: "pty",
+            runner: "pty",
             command: record.command,
             cwd: record.cwd,
             mode: record.mode,
@@ -1253,7 +1100,9 @@ export class ProcessManager extends EventEmitter {
             messages: messages.length > 0 ? messages : undefined,
             resumedFromSessionId: record.resumedFromSessionId ?? undefined,
             resumedToSessionId: record.resumedToSessionId ?? undefined,
-            autoRecovered: record.autoRecovered ?? false
+            autoRecovered: record.autoRecovered ?? false,
+            autoApprovePermissions: record.autoApprovePermissions || undefined,
+            approvalStats: record.approvalStats.total > 0 ? record.approvalStats : undefined
         };
     }
     isPermissionBlocked(record) {
@@ -1274,6 +1123,15 @@ export class ProcessManager extends EventEmitter {
     denyPermission(id) {
         return this.resolvePermission(id, "deny");
     }
+    toggleAutoApprove(id) {
+        const record = this.mustGet(id);
+        record.autoApprovePermissions = !record.autoApprovePermissions;
+        if (record.ptyBridge) {
+            record.ptyBridge.setAutoApprove(record.autoApprovePermissions);
+        }
+        this.persist(record);
+        return this.snapshot(record);
+    }
     /**
      * Canonical permission resolution method.
      * All other permission methods delegate to this.
@@ -1493,11 +1351,9 @@ export class ProcessManager extends EventEmitter {
             || claudeConfirmPrompt
             || toolPermissionPrompt
             || (hasExplicitConfirmSyntax(normalized)
-                && hasPermissionActionContext(normalized)
-                && PROMPT_PATTERNS.some((pattern) => pattern.test(normalized)));
+                && hasPermissionActionContext(normalized));
         if (shouldConfirm) {
             record.lastAutoConfirmAt = now;
-            process.stderr.write(`[wand] Auto-confirming prompt for ${record.mode} mode\n`);
             // Always auto-confirm by sending Enter directly
             ptyProcess.write("\r");
         }
@@ -1562,15 +1418,50 @@ export class ProcessManager extends EventEmitter {
                 });
                 break;
             }
-            case "permission.resolved":
+            case "permission.resolved": {
+                // Increment approval stats before clearing pendingEscalation
+                const resolvedScope = record.pendingEscalation?.scope;
+                if (resolvedScope) {
+                    if (resolvedScope === "run_command" || resolvedScope === "dangerous_shell") {
+                        record.approvalStats.command++;
+                    }
+                    else if (resolvedScope === "write_file") {
+                        record.approvalStats.file++;
+                    }
+                    else {
+                        record.approvalStats.tool++;
+                    }
+                    record.approvalStats.total++;
+                }
                 record.pendingEscalation = null;
                 record.ptyPermissionBlocked = false;
                 this.emitEvent({
                     type: "status",
                     sessionId: event.sessionId,
-                    data: { permissionBlocked: false },
+                    data: {
+                        permissionBlocked: false,
+                        approvalStats: record.approvalStats,
+                    },
                 });
+                // Log auto-approve events to shortcut-interactions.jsonl for analysis
+                const resolvedData = event.data;
+                if (resolvedData?.autoApproved) {
+                    const outputLines = record.output.split("\n");
+                    const tailLines = outputLines.slice(-8).join("\n");
+                    this.logger.appendShortcutLog(record.id, "auto_approve", tailLines, {
+                        mode: record.mode,
+                        scope: resolvedScope ?? "unknown",
+                        autoApprove: record.autoApprovePermissions,
+                        permissionBlocked: true,
+                        input: "\r",
+                        approveType: resolvedData.approveType,
+                        score: resolvedData.score,
+                        matched: resolvedData.matched,
+                        falsePositive: resolvedData.falsePositive,
+                    });
+                }
                 break;
+            }
             case "session.id":
                 // Claude session ID captured - already handled in onData
                 break;
@@ -1633,15 +1524,42 @@ export class ProcessManager extends EventEmitter {
         return false;
     }
     processCommandForMode(command, mode) {
+        const isClaudeCmd = /^(?:claude|npx\s+claude|[^\s]+\/claude)(?:\s|$)/.test(command);
+        if (!isClaudeCmd)
+            return command;
+        let result = command;
+        // Skip if command already contains --permission-mode
+        const hasPermFlag = /--permission-mode\s/.test(command);
+        if (!hasPermFlag) {
+            if (isRunningAsRoot()) {
+                // Root: Claude CLI refuses --permission-mode bypassPermissions.
+                // Use acceptEdits + --allowedTools to auto-approve all tool calls
+                // regardless of whether the target path is inside or outside the CWD.
+                if (mode === "managed" || mode === "full-access" || mode === "auto-edit") {
+                    result += " --permission-mode acceptEdits";
+                    result += " --allowedTools Bash Edit Write Read Glob Grep NotebookEdit WebFetch WebSearch";
+                }
+            }
+            else {
+                // Non-root: use bypassPermissions for full-access (skips all prompts),
+                // acceptEdits for auto-edit (auto-accepts file writes, prompts for bash).
+                if (mode === "full-access" || mode === "managed") {
+                    result += " --permission-mode bypassPermissions";
+                }
+                else if (mode === "auto-edit") {
+                    result += " --permission-mode acceptEdits";
+                }
+            }
+        }
         // In managed mode, append a system prompt instructing Claude to act autonomously
         // without asking the user for confirmation, since the user may not be monitoring.
-        if (mode === "managed" && /^(?:claude|npx\s+claude|[^\s]+\/claude)(?:\s|$)/.test(command)) {
+        if (mode === "managed") {
             const autonomousPrompt = "You are running in a fully managed, autonomous mode. The user may not be available to respond to questions or confirmations in a timely manner. You MUST make all decisions independently — choose the best approach yourself instead of asking the user for preferences, confirmations, or clarifications. If multiple approaches are viable, pick the one you judge most appropriate and proceed. Never block on user input unless the task is fundamentally ambiguous and cannot be reasonably inferred. Be decisive and self-directed.";
             // Escape single quotes for shell safety
             const escaped = autonomousPrompt.replace(/'/g, "'\\''");
-            return `${command} --append-system-prompt '${escaped}'`;
+            result += ` --append-system-prompt '${escaped}'`;
         }
-        return command;
+        return result;
     }
 }
 function clampDimension(value, min, max) {

package/dist/pty-text-utils.d.ts

@@ -11,5 +11,17 @@ export declare function isNoiseLine(line: string): boolean;
 export declare function appendWindow(buffer: string, chunk: string, maxSize: number): string;
 export declare function hasExplicitConfirmSyntax(normalized: string): boolean;
 export declare function hasPermissionActionContext(normalized: string): boolean;
+interface PermissionScore {
+    score: number;
+    matched: string[];
+}
+/** Minimum score threshold for fallback permission detection */
+export declare const FALLBACK_SCORE_THRESHOLD = 8;
+/**
+ * Score how likely the recent output contains a permission prompt.
+ * Evaluates the last few lines of normalized text against weighted keywords.
+ */
+export declare function scorePermissionLikelihood(normalized: string): PermissionScore;
 /** Normalize prompt text for permission detection (strip ANSI, collapse whitespace). */
 export declare function normalizePromptText(value: string): string;
+export {};

package/dist/pty-text-utils.js

@@ -77,8 +77,10 @@ const EXPLICIT_CONFIRM_PATTERNS = [
     /\[(?:y|yes)\s*\/\s*(?:n|no)\]/i,
     /\((?:y|yes)\s*\/\s*(?:n|no)\)/i,
     /\((?:y|yes)\s*\/\s*(?:n|no)\s*\/\s*always\)/i,
-    /\byes\b.*\bno\b/i,
+    /\byes\b[\s\S]*\bno\b/i,
     /\benter to confirm\b/i,
+    // Claude CLI numbered selection menus: "❯ 1. Yes" + "N. No"
+    /❯\s*1\.\s*yes\b/i,
 ];
 const PERMISSION_ACTION_PATTERNS = [
     /\bgrant\b.*\bpermission\b/i,
@@ -92,6 +94,40 @@ export function hasExplicitConfirmSyntax(normalized) {
 export function hasPermissionActionContext(normalized) {
     return PERMISSION_ACTION_PATTERNS.some((pattern) => pattern.test(normalized));
 }
+const PERMISSION_KEYWORD_WEIGHTS = [
+    { pattern: /\bdo you want to proceed\b/i, weight: 5, label: "do you want to proceed" },
+    { pattern: /\bwould you like to proceed\b/i, weight: 5, label: "would you like to proceed" },
+    { pattern: /\bdo you want to\b/i, weight: 4, label: "do you want to" },
+    { pattern: /\bwould you like to\b/i, weight: 4, label: "would you like to" },
+    { pattern: /\benter to confirm\b/i, weight: 4, label: "enter to confirm" },
+    { pattern: /\bgrant\b[\s\S]*\bpermission\b/i, weight: 4, label: "grant permission" },
+    { pattern: /❯\s*1\./i, weight: 3, label: "❯ 1." },
+    { pattern: /\b1\.\s*yes\b/i, weight: 3, label: "1. yes" },
+    { pattern: /\bdon'?t ask again\b/i, weight: 2, label: "don't ask again" },
+    { pattern: /\b(?:bash|shell)\s*command\b/i, weight: 2, label: "bash/shell command" },
+    { pattern: /\b(?:run|read|write|edit)\s+(?:file|command|shell)\b/i, weight: 2, label: "run/read/write action" },
+    { pattern: /\ballow\b.*\breading\b/i, weight: 2, label: "allow reading" },
+];
+/** Minimum score threshold for fallback permission detection */
+export const FALLBACK_SCORE_THRESHOLD = 8;
+/**
+ * Score how likely the recent output contains a permission prompt.
+ * Evaluates the last few lines of normalized text against weighted keywords.
+ */
+export function scorePermissionLikelihood(normalized) {
+    // Take the last ~5 lines
+    const lines = normalized.split("\n");
+    const tail = lines.slice(-8).join("\n");
+    let score = 0;
+    const matched = [];
+    for (const { pattern, weight, label } of PERMISSION_KEYWORD_WEIGHTS) {
+        if (pattern.test(tail)) {
+            score += weight;
+            matched.push(label);
+        }
+    }
+    return { score, matched };
+}
 /** Normalize prompt text for permission detection (strip ANSI, collapse whitespace). */
 export function normalizePromptText(value) {
     return value

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

@@ -1,6 +1,8 @@
 import { Express } from "express";
 import { ProcessManager } from "./process-manager.js";
+import { StructuredSessionManager } from "./structured-session-manager.js";
 import { WandStorage } from "./storage.js";
 import { ExecutionMode } from "./types.js";
-export declare function registerSessionRoutes(app: Express, processes: ProcessManager, storage: WandStorage, defaultMode: ExecutionMode): void;
+export declare function getErrorMessage(error: unknown, fallback: string): string;
+export declare function registerSessionRoutes(app: Express, processes: ProcessManager, structured: StructuredSessionManager, storage: WandStorage, defaultMode: ExecutionMode): void;
 export declare function registerClaudeHistoryRoutes(app: Express, processes: ProcessManager, storage: WandStorage): void;