@co0ontty/wand 1.20.4 → 1.21.4

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

@@ -4,5 +4,5 @@ import { StructuredSessionManager } from "./structured-session-manager.js";
 import { WandStorage } from "./storage.js";
 import { ExecutionMode, WandConfig } from "./types.js";
 export declare function getErrorMessage(error: unknown, fallback: string): string;
-export declare function registerSessionRoutes(app: Express, processes: ProcessManager, structured: StructuredSessionManager, storage: WandStorage, defaultMode: ExecutionMode, config: WandConfig): void;
+export declare function registerSessionRoutes(app: Express, processes: ProcessManager, structured: StructuredSessionManager, storage: WandStorage, defaultMode: ExecutionMode, config: WandConfig, onSessionCreated?: (cwd: string | undefined | null) => void): void;
 export declare function registerClaudeHistoryRoutes(app: Express, processes: ProcessManager, storage: WandStorage): void;

package/dist/server-session-routes.js

@@ -136,7 +136,7 @@ function canMergeSession(snapshot) {
 function isMergeActionAllowed(snapshot) {
     return snapshot.status !== "running";
 }
-export function registerSessionRoutes(app, processes, structured, storage, defaultMode, config) {
+export function registerSessionRoutes(app, processes, structured, storage, defaultMode, config, onSessionCreated) {
     app.get("/api/sessions", (_req, res) => {
         const all = listAllSessionsSlim(processes, structured);
         console.log("[WAND] GET /api/sessions count:", all.length, "sessions:", all.map(s => ({ id: s.id.substring(0, 8), kind: s.sessionKind, runner: s.runner, status: s.status })));
@@ -146,19 +146,27 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
         const body = req.body;
         console.log("[WAND] POST /api/structured-sessions body:", JSON.stringify({ cwd: body.cwd, mode: body.mode, runner: body.runner, provider: body.provider, worktreeEnabled: body.worktreeEnabled === true, hasPrompt: !!body.prompt, model: body.model }));
         try {
-            if (body.provider && body.provider !== "claude") {
-                res.status(400).json({ error: "结构化会话当前仅支持 Claude provider。" });
+            if (body.provider && body.provider !== "claude" && body.provider !== "codex") {
+                res.status(400).json({ error: "结构化会话当前仅支持 Claude 或 Codex provider。" });
                 return;
             }
+            const provider = body.provider === "codex" ? "codex" : "claude";
             const snapshot = structured.createSession({
                 cwd: body.cwd?.trim() || process.cwd(),
                 mode: normalizeMode(body.mode, defaultMode),
-                prompt: body.prompt,
-                runner: body.runner ?? "claude-cli-print",
+                provider,
+                runner: body.runner ?? (provider === "codex" ? "codex-cli-exec" : "claude-cli-print"),
                 worktreeEnabled: body.worktreeEnabled === true,
                 model: typeof body.model === "string" ? body.model.trim() : undefined,
             });
             console.log("[WAND] structured session created:", JSON.stringify({ id: snapshot.id, sessionKind: snapshot.sessionKind, runner: snapshot.runner, status: snapshot.status }));
+            onSessionCreated?.(body.cwd ?? snapshot.cwd);
+            const prompt = body.prompt?.trim();
+            if (prompt) {
+                const finished = await structured.sendMessage(snapshot.id, prompt);
+                res.status(201).json(finished);
+                return;
+            }
             res.status(201).json(snapshot);
         }
         catch (error) {
@@ -472,7 +480,9 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             }
             const newMode = body.mode ? normalizeMode(body.mode, defaultMode) : normalizeMode(existingSession.mode, defaultMode);
             const resumeCommand = `${command} --resume ${claudeSessionId}`;
-            const newSnapshot = processes.start(resumeCommand, existingSession.cwd, newMode, undefined, { reuseId: sessionId });
+            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 newSnapshot = processes.start(resumeCommand, existingSession.cwd, newMode, undefined, { reuseId: sessionId, cols: reqCols, rows: reqRows });
             res.status(201).json(newSnapshot);
         }
         catch (error) {
@@ -509,7 +519,9 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                 }
                 const newMode = body.mode ? normalizeMode(body.mode, defaultMode) : normalizeMode(existingSession.mode, defaultMode);
                 const resumeCommand = `${command} --resume ${claudeSessionId}`;
-                const newSnapshot = processes.start(resumeCommand, existingSession.cwd, newMode, undefined, { reuseId: existingSession.id });
+                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 newSnapshot = processes.start(resumeCommand, existingSession.cwd, newMode, undefined, { reuseId: existingSession.id, cols: reqCols, rows: reqRows });
                 res.status(201).json({ resumedClaudeSessionId: claudeSessionId, ...newSnapshot });
             }
             else {
@@ -520,7 +532,9 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                 }
                 const newMode = normalizeMode(body.mode, defaultMode);
                 const resumeCommand = `claude --resume ${claudeSessionId}`;
-                const newSnapshot = processes.start(resumeCommand, cwd, newMode);
+                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 newSnapshot = processes.start(resumeCommand, cwd, newMode, undefined, { cols: reqCols, rows: reqRows });
                 res.status(201).json({ resumedClaudeSessionId: claudeSessionId, ...newSnapshot });
             }
         }

package/dist/server.d.ts

@@ -1,6 +1,9 @@
 import { ProcessManager } from "./process-manager.js";
 import { StructuredSessionManager } from "./structured-session-manager.js";
+import { WandStorage } from "./storage.js";
 import { WandConfig } from "./types.js";
+/** Persist a cwd to recent paths. Used by both REST and session creation hooks. */
+export declare function recordRecentPath(storage: WandStorage, cwd: string | undefined | null): void;
 export interface ServerUrl {
     url: string;
     scheme: "HTTP" | "HTTPS";

package/dist/server.js

@@ -16,6 +16,7 @@ import { ensureCertificates } from "./cert.js";
 import { isExecutionMode, normalizeCardDefaults, resolveConfigDir, saveConfig } from "./config.js";
 import { getCachedModels, refreshModels } from "./models.js";
 import { ProcessManager } from "./process-manager.js";
+import { SessionLogger } from "./session-logger.js";
 import { StructuredSessionManager } from "./structured-session-manager.js";
 import { generatePwaManifest, generateServiceWorker } from "./pwa.js";
 import { getErrorMessage, registerClaudeHistoryRoutes, registerSessionRoutes } from "./server-session-routes.js";
@@ -481,6 +482,33 @@ function parseStoredPathList(raw) {
     }
 }
 const MAX_RECENT_PATHS = 10;
+/** Persist a cwd to recent paths. Used by both REST and session creation hooks. */
+export function recordRecentPath(storage, cwd) {
+    if (!cwd)
+        return;
+    const trimmed = cwd.trim();
+    if (!trimmed)
+        return;
+    let resolved;
+    try {
+        resolved = normalizeFolderPath(trimmed);
+    }
+    catch {
+        return;
+    }
+    if (isBlockedFolderPath(resolved))
+        return;
+    const stored = storage.getConfigValue("recent_paths");
+    let recent = parseStoredPathList(stored);
+    recent = recent.filter((r) => normalizeFolderPath(r.path) !== resolved);
+    recent.unshift({
+        path: resolved,
+        name: path.basename(resolved),
+        lastUsedAt: new Date().toISOString(),
+    });
+    recent = recent.slice(0, MAX_RECENT_PATHS);
+    storage.setConfigValue("recent_paths", JSON.stringify(recent));
+}
 // ── File language detection ──
 function getLanguageFromExt(ext, filePath) {
     const map = {
@@ -514,7 +542,8 @@ export async function startServer(config, configPath) {
     const configDir = resolveConfigDir(configPath);
     const avatarSeed = await ensureAvatarSeed(configDir);
     const processes = new ProcessManager(config, storage, configDir);
-    const structuredSessions = new StructuredSessionManager(storage, config);
+    const structuredLogger = new SessionLogger(configDir, config.shortcutLogMaxBytes);
+    const structuredSessions = new StructuredSessionManager(storage, config, structuredLogger);
     const useHttps = config.https === true;
     const protocol = useHttps ? "https" : "http";
     const nodeModulesDir = path.join(RUNTIME_ROOT_DIR, "node_modules");
@@ -695,7 +724,10 @@ export async function startServer(config, configPath) {
             defaultMode: config.defaultMode,
             defaultCwd: config.defaultCwd,
             commandPresets: config.commandPresets,
-            structuredRunners: [{ label: "Claude Structured", runner: "claude-cli-print" }],
+            structuredRunners: [
+                { label: "Claude Structured", runner: "claude-cli-print" },
+                { label: "Codex Structured", runner: "codex-cli-exec" },
+            ],
             structuredChatPersona,
             cardDefaults: config.cardDefaults,
             updateAvailable: cachedUpdateInfo?.updateAvailable ?? false,
@@ -847,6 +879,7 @@ export async function startServer(config, configPath) {
         const cached = getCachedModels();
         res.json({
             models: cached.models,
+            codexModels: cached.codexModels,
             claudeVersion: cached.claudeVersion,
             refreshedAt: cached.refreshedAt,
             defaultModel: config.defaultModel ?? "",
@@ -857,6 +890,7 @@ export async function startServer(config, configPath) {
             const refreshed = await refreshModels();
             res.json({
                 models: refreshed.models,
+                codexModels: refreshed.codexModels,
                 claudeVersion: refreshed.claudeVersion,
                 refreshedAt: refreshed.refreshedAt,
                 defaultModel: config.defaultModel ?? "",
@@ -919,7 +953,9 @@ export async function startServer(config, configPath) {
             updateInFlight = false;
         }
     });
-    registerSessionRoutes(app, processes, structuredSessions, storage, config.defaultMode, config);
+    registerSessionRoutes(app, processes, structuredSessions, storage, config.defaultMode, config, (cwd) => {
+        recordRecentPath(storage, cwd);
+    });
     registerClaudeHistoryRoutes(app, processes, storage);
     registerUploadRoutes(app, processes);
     app.post("/api/optimize-prompt", express.json({ limit: "256kb" }), async (req, res) => {
@@ -1098,18 +1134,12 @@ export async function startServer(config, configPath) {
             res.status(403).json({ error: "访问被拒绝：无法保存系统敏感目录。" });
             return;
         }
-        const stored = storage.getConfigValue("recent_paths");
-        let recent = parseStoredPathList(stored);
-        recent = recent.filter((r) => normalizeFolderPath(r.path) !== resolvedRecentPath);
-        const newRecent = {
+        recordRecentPath(storage, resolvedRecentPath);
+        res.json({
             path: resolvedRecentPath,
             name: path.basename(resolvedRecentPath),
             lastUsedAt: new Date().toISOString(),
-        };
-        recent.unshift(newRecent);
-        recent = recent.slice(0, MAX_RECENT_PATHS);
-        storage.setConfigValue("recent_paths", JSON.stringify(recent));
-        res.json(newRecent);
+        });
     });
     app.get("/api/validate-path", async (req, res) => {
         const inputPath = typeof req.query.path === "string" ? req.query.path : "";
@@ -1215,11 +1245,16 @@ export async function startServer(config, configPath) {
         try {
             const rawModel = typeof body.model === "string" ? body.model.trim() : "";
             const effectiveModel = rawModel || (config.defaultModel ?? "").trim() || 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 snapshot = processes.start(body.command, body.cwd, normalizeMode(body.mode, config.defaultMode), initialInput || undefined, {
                 worktreeEnabled: body.worktreeEnabled === true,
                 provider: body.provider,
                 model: effectiveModel,
+                cols: reqCols,
+                rows: reqRows,
             });
+            recordRecentPath(storage, body.cwd ?? snapshot.cwd);
             res.status(201).json(snapshot);
         }
         catch (error) {
@@ -1304,6 +1339,8 @@ export async function startServer(config, configPath) {
     }
     // Start configured background sessions after the server is already reachable.
     processes.runStartupCommands();
+    // Pre-warm model cache (probes claude --version + codex debug models).
+    refreshModels().catch(() => { });
     // ── Auto-update endpoints ──
     app.get("/api/auto-update", (_req, res) => {
         const web = storage.getConfigValue("autoUpdateWeb") === "true";

package/dist/session-logger.d.ts

@@ -24,10 +24,13 @@ export interface ShortcutLogContext {
  * 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 declare class SessionLogger {
     private readonly baseDir;
@@ -48,6 +51,14 @@ export declare class SessionLogger {
     readPtyOutput(sessionId: string): string | null;
     /** Append a native mode NDJSON event */
     appendStreamEvent(sessionId: string, event: unknown): void;
+    /** Append raw stdout chunk from a structured-mode child process. */
+    appendStructuredStdout(sessionId: string, chunk: string): void;
+    /** Append raw stderr chunk from a structured-mode child process. */
+    appendStructuredStderr(sessionId: string, chunk: string): void;
+    /** Append a spawn metadata record (args, pid, cwd, exit, errors, …) for a structured run. */
+    appendStructuredSpawn(sessionId: string, meta: Record<string, unknown>): void;
+    /** Read recent stderr tail (for surfacing in failure messages). */
+    readStructuredStderrTail(sessionId: string, maxBytes?: number): string;
     /** Save the current structured messages snapshot */
     saveMessages(sessionId: string, messages: ConversationTurn[]): void;
     /** Save session metadata */

package/dist/session-logger.js

@@ -12,10 +12,13 @@ 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;
@@ -122,6 +125,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 {

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,12 +14,13 @@ interface CreateStructuredSessionOptions {
 export declare class StructuredSessionManager {
     private readonly storage;
     private readonly config;
+    private readonly logger;
     private readonly sessions;
     private readonly pendingChildren;
     private readonly interruptedWith;
     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;
     list(): SessionSnapshot[];
@@ -49,6 +52,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
@@ -65,7 +70,12 @@ export declare class StructuredSessionManager {
     private compactContentBlocks;
     private normalizeToolInput;
     private normalizeToolResultContent;
+    private extractCodexText;
+    private extractCodexItemBlock;
+    private upsertCodexBlock;
+    private finishStructuredFailure;
     private extractModelName;
     private extractUsage;
+    private extractCodexUsage;
 }
 export {};