@co0ontty/wand 1.20.4 → 1.21.5

package/dist/session-logger.js

@@ -12,14 +12,19 @@ const DEFAULT_SHORTCUT_LOG_MAX_BYTES = 10 * 1024 * 1024;
  * SessionLogger saves raw session content to local files for debugging and analysis.
  *
  * Directory structure: .wand/sessions/{sessionId}/
- *   - pty-output.log       Raw PTY output (current, rotated when > 50 MB)
- *   - pty-output.log.1..3  Rotated PTY output backups
- *   - stream-events.jsonl  NDJSON events from native mode (append-only)
- *   - messages.json        Final structured messages (overwritten on each update)
+ *   - pty-output.log              Raw PTY output (current, rotated when > 50 MB)
+ *   - pty-output.log.1..3         Rotated PTY output backups
+ *   - stream-events.jsonl         NDJSON events from native mode (append-only)
+ *   - messages.json               Final structured messages (overwritten on each update)
+ *   - structured-stdout.log       Raw stdout from `codex exec` / `claude -p` child (append-only)
+ *   - structured-stderr.log       Raw stderr from the same child (append-only)
+ *   - structured-spawns.jsonl     One line per spawn: args/pid/cwd/exit/error metadata
  */
 export class SessionLogger {
     baseDir;
     dirs = new Map();
+    /** Cached on-disk size of hot-path log files so we can rotate without stat'ing on every chunk. */
+    logSizes = new Map();
     shortcutLogMaxBytes;
     constructor(configDir, shortcutLogMaxBytes) {
         this.baseDir = path.join(configDir, "sessions");
@@ -43,6 +48,10 @@ export class SessionLogger {
             // ignore
         }
         this.dirs.set(sessionId, dir);
+        // Seed the size cache from disk on first use; subsequent appends maintain
+        // the counter in memory so the hot path no longer touches stat/exists.
+        const sizes = { pty: tryStatSize(path.join(dir, "pty-output.log")), shortcut: tryStatSize(path.join(dir, "shortcut-interactions.jsonl")) };
+        this.logSizes.set(sessionId, sizes);
         return dir;
     }
     /**
@@ -75,15 +84,14 @@ export class SessionLogger {
     appendPtyOutput(sessionId, chunk) {
         try {
             const dir = this.ensureDir(sessionId);
-            const logPath = path.join(dir, "pty-output.log");
-            // Check size and rotate if needed
-            if (existsSync(logPath)) {
-                const stats = statSync(logPath);
-                if (stats.size >= PTY_LOG_MAX_SIZE) {
-                    this.rotatePtyLog(dir);
-                }
+            const sizes = this.logSizes.get(sessionId);
+            if (sizes.pty >= PTY_LOG_MAX_SIZE) {
+                this.rotatePtyLog(dir);
+                sizes.pty = 0;
             }
+            const logPath = path.join(dir, "pty-output.log");
             appendFileSync(logPath, chunk);
+            sizes.pty += Buffer.byteLength(chunk);
         }
         catch {
             // Non-critical — don't let logging failures affect main flow
@@ -122,6 +130,51 @@ export class SessionLogger {
             // Non-critical
         }
     }
+    /** Append raw stdout chunk from a structured-mode child process. */
+    appendStructuredStdout(sessionId, chunk) {
+        try {
+            const dir = this.ensureDir(sessionId);
+            appendFileSync(path.join(dir, "structured-stdout.log"), chunk);
+        }
+        catch {
+            // Non-critical
+        }
+    }
+    /** Append raw stderr chunk from a structured-mode child process. */
+    appendStructuredStderr(sessionId, chunk) {
+        try {
+            const dir = this.ensureDir(sessionId);
+            appendFileSync(path.join(dir, "structured-stderr.log"), chunk);
+        }
+        catch {
+            // Non-critical
+        }
+    }
+    /** Append a spawn metadata record (args, pid, cwd, exit, errors, …) for a structured run. */
+    appendStructuredSpawn(sessionId, meta) {
+        try {
+            const dir = this.ensureDir(sessionId);
+            const entry = JSON.stringify({ ts: new Date().toISOString(), ...meta }) + "\n";
+            appendFileSync(path.join(dir, "structured-spawns.jsonl"), entry);
+        }
+        catch {
+            // Non-critical
+        }
+    }
+    /** Read recent stderr tail (for surfacing in failure messages). */
+    readStructuredStderrTail(sessionId, maxBytes = 4096) {
+        try {
+            const dir = this.ensureDir(sessionId);
+            const filePath = path.join(dir, "structured-stderr.log");
+            if (!existsSync(filePath))
+                return "";
+            const content = readFileSync(filePath, "utf8");
+            return content.length <= maxBytes ? content : content.slice(content.length - maxBytes);
+        }
+        catch {
+            return "";
+        }
+    }
     /** Save the current structured messages snapshot */
     saveMessages(sessionId, messages) {
         try {
@@ -152,6 +205,7 @@ export class SessionLogger {
             // Non-critical
         }
         this.dirs.delete(sessionId);
+        this.logSizes.delete(sessionId);
     }
     /** Append a shortcut key interaction log entry (for analyzing auto-confirm gaps) */
     appendShortcutLog(sessionId, shortcutKey, tailLines, ctx) {
@@ -159,6 +213,7 @@ export class SessionLogger {
             return;
         try {
             const dir = this.ensureDir(sessionId);
+            const sizes = this.logSizes.get(sessionId);
             const logPath = path.join(dir, "shortcut-interactions.jsonl");
             const entry = JSON.stringify({
                 ts: new Date().toISOString(),
@@ -169,35 +224,41 @@ export class SessionLogger {
                 input: ctx?.input,
                 tail: tailLines,
             }) + "\n";
-            // Check size and truncate if needed
-            if (existsSync(logPath)) {
-                const size = statSync(logPath).size;
-                if (size + entry.length > this.shortcutLogMaxBytes) {
-                    this.truncateShortcutLog(logPath);
-                }
+            const entryBytes = Buffer.byteLength(entry);
+            if (sizes.shortcut + entryBytes > this.shortcutLogMaxBytes) {
+                sizes.shortcut = this.truncateShortcutLog(logPath);
             }
             appendFileSync(logPath, entry);
+            sizes.shortcut += entryBytes;
         }
         catch {
             // Non-critical
         }
     }
-    /** Truncate shortcut log by keeping only the most recent half of entries */
+    /** Truncate shortcut log by keeping only the most recent half of entries. Returns the new on-disk size. */
     truncateShortcutLog(logPath) {
         try {
             const content = readFileSync(logPath, "utf8");
             const lines = content.split("\n").filter(Boolean);
-            // Keep the latter half
             const keepFrom = Math.floor(lines.length / 2);
             const trimmed = lines.slice(keepFrom).join("\n") + "\n";
             writeFileSync(logPath, trimmed);
+            return Buffer.byteLength(trimmed);
         }
         catch {
-            // If truncation fails, delete the file to prevent unbounded growth
             try {
                 unlinkSync(logPath);
             }
             catch { /* ignore */ }
+            return 0;
         }
     }
 }
+function tryStatSize(filePath) {
+    try {
+        return existsSync(filePath) ? statSync(filePath).size : 0;
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/structured-session-manager.d.ts

@@ -1,9 +1,11 @@
+import { SessionLogger } from "./session-logger.js";
 import { WandStorage } from "./storage.js";
-import { ExecutionMode, ProcessEvent, SessionRunner, SessionSnapshot, WandConfig } from "./types.js";
+import { ExecutionMode, ProcessEvent, SessionProvider, SessionRunner, SessionSnapshot, WandConfig } from "./types.js";
 interface CreateStructuredSessionOptions {
     cwd: string;
     mode: ExecutionMode;
     prompt?: string;
+    provider?: SessionProvider;
     runner?: SessionRunner;
     worktreeEnabled?: boolean;
     /** 用户指定的 Claude 模型（别名或完整 ID）。留空则 spawn 时不加 --model。 */
@@ -12,14 +14,33 @@ interface CreateStructuredSessionOptions {
 export declare class StructuredSessionManager {
     private readonly storage;
     private readonly config;
+    private readonly logger;
     private readonly sessions;
     private readonly pendingChildren;
+    private readonly pendingSdkAbort;
     private readonly interruptedWith;
+    /** Last wall-clock time (ms) we did a full saveSession for a streaming session. */
+    private readonly lastStreamSaveAt;
+    /**
+     * Idempotency keys we've already accepted, mapped to their wall-clock timestamp.
+     * Android WebView 在进程恢复时偶尔会重发上一个未收到响应的 POST（HTTP/2 stream
+     * reset 等场景），客户端 JS 没有重试逻辑也拦不住。这里用 (sessionId, key) 永
+     * 久去重，重复就抛错让前端弹 toast 提示，**不**做任何处理。timestamp 仅用于
+     * map 大小溢出时按时间裁剪。
+     */
+    private readonly seenIdempotencyKeys;
     private emitEvent;
     private archiveTimer;
-    constructor(storage: WandStorage, config: WandConfig);
+    constructor(storage: WandStorage, config: WandConfig, logger?: SessionLogger | null);
     private archiveExpiredSessions;
     setEventEmitter(emitEvent: (event: ProcessEvent) => void): void;
+    /**
+     * In-memory snapshot is updated unconditionally; the SQLite write is rate-
+     * limited to once per STREAM_SAVE_THROTTLE_MS. Caller must still invoke
+     * `storage.saveSession` directly at terminal events (close / failure) so the
+     * final state is durable.
+     */
+    private saveStreamingSnapshot;
     list(): SessionSnapshot[];
     /** Return lightweight snapshots for the session list (no output/messages). */
     listSlim(): SessionSnapshot[];
@@ -27,6 +48,7 @@ export declare class StructuredSessionManager {
     createSession(options: CreateStructuredSessionOptions): SessionSnapshot;
     sendMessage(id: string, input: string, opts?: {
         interrupt?: boolean;
+        idempotencyKey?: string;
     }): Promise<SessionSnapshot>;
     /** Approve a pending permission request. */
     approvePermission(sessionId: string): SessionSnapshot;
@@ -49,6 +71,8 @@ export declare class StructuredSessionManager {
     private resolvePermission;
     private incrementApprovalStats;
     private buildPermissionArgs;
+    private buildCodexArgs;
+    private runCodexStreaming;
     /**
      * Spawn `claude -p --output-format stream-json` and parse NDJSON lines as
      * they arrive, emitting incremental WebSocket events so the UI can render
@@ -61,11 +85,30 @@ export declare class StructuredSessionManager {
      *   outside CWD). stdin is always "ignore" — no ACP bidirectional control.
      */
     private runClaudeStreaming;
+    /**
+     * Use @anthropic-ai/claude-agent-sdk instead of spawning claude -p directly.
+     * The SDK still spawns the claude binary but provides typed AsyncGenerator<SDKMessage>
+     * messages, so we skip NDJSON parsing. Options are 1:1 with the CLI flags.
+     *
+     * Streaming is enabled via includePartialMessages: true — the SDK emits
+     * SDKPartialAssistantMessage (type: "stream_event") with BetaRawMessageStreamEvent
+     * payloads for incremental text/thinking/tool_use updates, followed by a final
+     * SDKAssistantMessage with the authoritative complete content.
+     */
+    private runClaudeSdkStreaming;
+    private _runClaudeSdkStreamingAsync;
     private extractAssistantMessage;
     private compactContentBlocks;
     private normalizeToolInput;
     private normalizeToolResultContent;
+    private extractCodexText;
+    private extractCodexItemBlock;
+    private upsertCodexBlock;
+    private finishStructuredFailure;
     private extractModelName;
     private extractUsage;
+    /** Extract usage from an SDKResultSuccess message (sdk runner). */
+    private extractSdkUsage;
+    private extractCodexUsage;
 }
 export {};