@co0ontty/wand 4.56.1 → 4.57.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "477c21d747e18e9f4df6942ab0f47bd817f66ff0",
-  "builtAt": "2026-09-10T03:53:28.222Z",
-  "version": "4.56.1",
+  "commit": "d240da17b4bfee37b304e0a51c90506979357d8c",
+  "builtAt": "2026-09-10T04:56:25.817Z",
+  "version": "4.57.0",
   "channel": "stable"
 }

package/dist/server-session-routes.js

@@ -1395,7 +1395,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
     app.post("/api/sessions/:id/approve-permission", (req, res) => {
         try {
             if (sessions.ownerOf(req.params.id) === "structured") {
-                res.status(404).json({ error: "结构化会话没有运行时授权请求。" });
+                res.json(sessionResponseDTO(structured.approvePermission(req.params.id)));
                 return;
             }
             const snapshot = sessions.get(req.params.id);
@@ -1412,7 +1412,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
     app.post("/api/sessions/:id/deny-permission", (req, res) => {
         try {
             if (sessions.ownerOf(req.params.id) === "structured") {
-                res.status(404).json({ error: "结构化会话没有运行时授权请求。" });
+                res.json(sessionResponseDTO(structured.denyPermission(req.params.id)));
                 return;
             }
             const snapshot = sessions.get(req.params.id);
@@ -1429,7 +1429,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
     app.post("/api/sessions/:id/toggle-auto-approve", (req, res) => {
         try {
             if (sessions.ownerOf(req.params.id) === "structured") {
-                res.status(404).json({ error: "结构化会话没有运行时授权请求。" });
+                res.json(sessionResponseDTO(structured.toggleAutoApprove(req.params.id)));
                 return;
             }
             const snapshot = sessions.get(req.params.id);
@@ -1453,7 +1453,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                 return;
             }
             if (sessions.ownerOf(req.params.id) === "structured") {
-                res.status(404).json({ error: "结构化会话没有运行时授权请求。" });
+                res.json(sessionResponseDTO(structured.resolveEscalation(req.params.id, requestId, resolution)));
                 return;
             }
             res.json(sessionResponseDTO(processes.resolveEscalation(req.params.id, requestId, resolution)));

package/dist/structured-permission.d.ts

@@ -0,0 +1,14 @@
+import type { EscalationRequest } from "./types.js";
+export interface StructuredToolPermissionContext {
+    title?: string;
+    description?: string;
+    blockedPath?: string;
+    displayName?: string;
+    toolUseID?: string;
+    decisionReason?: string;
+}
+export declare function inferStructuredEscalation(toolName: string, input: Record<string, unknown>, ctx?: StructuredToolPermissionContext): Pick<EscalationRequest, "scope" | "target" | "reason">;
+export declare function structuredPermissionDenied(message: string): {
+    behavior: "deny";
+    message: string;
+};

package/dist/structured-permission.js

@@ -0,0 +1,56 @@
+const FILE_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+const COMMAND_TOOLS = new Set(["Bash", "BashOutput"]);
+const NETWORK_TOOLS = new Set(["WebFetch", "WebSearch"]);
+const DANGEROUS_SHELL_RE = /\bsudo\b|\brm\s+-[rf]{1,2}\b|\bmkfs\b|\bdd\s+if=|\bshutdown\b|\breboot\b/i;
+function firstString(input, keys) {
+    for (const key of keys) {
+        const value = input[key];
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+function truncateTarget(value) {
+    if (!value)
+        return undefined;
+    const compact = value.replace(/\s+/g, " ").trim();
+    if (!compact)
+        return undefined;
+    return compact.length > 200 ? `${compact.slice(0, 197)}...` : compact;
+}
+export function inferStructuredEscalation(toolName, input, ctx = {}) {
+    let scope = "unknown";
+    let target = firstString(input, ["file_path", "path", "command", "url", "query", "description", "prompt", "name"]);
+    if (FILE_TOOLS.has(toolName)) {
+        scope = "write_file";
+        target = firstString(input, ["file_path", "path"]) ?? target;
+    }
+    else if (COMMAND_TOOLS.has(toolName)) {
+        const command = firstString(input, ["command"]) ?? target;
+        scope = command && DANGEROUS_SHELL_RE.test(command) ? "dangerous_shell" : "run_command";
+        target = command;
+    }
+    else if (NETWORK_TOOLS.has(toolName)) {
+        scope = "network";
+        target = firstString(input, ["url", "query"]) ?? target;
+    }
+    else if (typeof ctx.blockedPath === "string" && ctx.blockedPath.trim()) {
+        scope = "outside_workspace";
+        target = ctx.blockedPath.trim();
+    }
+    if (!target && typeof ctx.blockedPath === "string" && ctx.blockedPath.trim()) {
+        target = ctx.blockedPath.trim();
+    }
+    const reason = (ctx.title?.trim()
+        || ctx.description?.trim()
+        || ctx.decisionReason?.trim()
+        || `需要授权使用 ${toolName}`).slice(0, 300);
+    return {
+        scope,
+        target: truncateTarget(target),
+        reason,
+    };
+}
+export function structuredPermissionDenied(message) {
+    return { behavior: "deny", message };
+}

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

@@ -63,6 +63,10 @@ export declare class StructuredSessionManager {
      * Only populated while an SDK call is in flight.
      */
     private readonly pendingSdkQueries;
+    /** In-flight canUseTool waiters. One pending prompt per session. */
+    private readonly pendingPermissions;
+    /** approve_turn memory, scoped to the current SDK query. */
+    private readonly turnApprovalMemory;
     private readonly interruptedWith;
     private readonly interruptedSkills;
     /**
@@ -172,6 +176,8 @@ export declare class StructuredSessionManager {
     setSessionMode(sessionId: string, mode: ExecutionMode): SessionSnapshot;
     /** Toggle auto-approve for the session. */
     toggleAutoApprove(sessionId: string): SessionSnapshot;
+    approvePermission(sessionId: string): SessionSnapshot;
+    denyPermission(sessionId: string): SessionSnapshot;
     /** Resolve a specific escalation by requestId. */
     resolveEscalation(sessionId: string, requestId: string, resolution: unknown): SessionSnapshot;
     stop(id: string): SessionSnapshot;
@@ -188,6 +194,9 @@ export declare class StructuredSessionManager {
     private flushNextQueuedMessage;
     private emit;
     private incrementApprovalStats;
+    private rememberTurnApproval;
+    private settlePendingPermission;
+    private handleCanUseTool;
     private runCodexStreaming;
     private runGrokStreaming;
     private runOpenCodeStreaming;

package/dist/structured-session-manager.js

@@ -12,6 +12,7 @@ import { CodexRunner } from "./structured-codex-adapter.js";
 import { CodexProtocolReducer } from "./structured-codex-protocol.js";
 import { normalizeStructuredToolResultContent } from "./structured-content.js";
 import { buildAppendSystemPromptParts, buildClaudeSdkThinking, ClaudeCliRunner, derivePermissionPolicy, } from "./structured-claude-adapter.js";
+import { inferStructuredEscalation, structuredPermissionDenied } from "./structured-permission.js";
 import { captureTaskMeta, extractClaudeAssistantMessage, extractClaudeModelName, normalizeClaudeToolInput, stampParentTaskResults, stampSelfTask, tagSubagentBlocks, ClaudeCliProtocolReducer, } from "./structured-claude-protocol.js";
 import { OpenCodeRunner, applyOpenCodeEvent } from "./structured-opencode-adapter.js";
 import { GrokRunner, applyGrokEvent } from "./structured-grok-adapter.js";
@@ -297,6 +298,10 @@ export class StructuredSessionManager {
      * Only populated while an SDK call is in flight.
      */
     pendingSdkQueries = new Map();
+    /** In-flight canUseTool waiters. One pending prompt per session. */
+    pendingPermissions = new Map();
+    /** approve_turn memory, scoped to the current SDK query. */
+    turnApprovalMemory = new Map();
     interruptedWith = new Map();
     interruptedSkills = new Map();
     /**
@@ -475,6 +480,11 @@ export class StructuredSessionManager {
                 continue;
             execution.interrupt();
         }
+        for (const [sessionId, waiter] of this.pendingPermissions) {
+            waiter.resolve(structuredPermissionDenied("服务已关闭"));
+            this.pendingPermissions.delete(sessionId);
+        }
+        this.turnApprovalMemory.clear();
         for (const query of this.pendingSdkQueries.values()) {
             void query.interrupt().catch(() => { });
         }
@@ -1206,11 +1216,15 @@ export class StructuredSessionManager {
             if (!this.isCurrentRequest(id, requestId)) {
                 return current;
             }
+            this.settlePendingPermission(id, undefined, structuredPermissionDenied("会话执行失败"));
+            this.turnApprovalMemory.delete(id);
             const failed = {
                 ...current,
                 status: "failed",
                 exitCode: 1,
                 endedAt: new Date().toISOString(),
+                pendingEscalation: null,
+                permissionBlocked: false,
                 structuredState: {
                     ...current.structuredState,
                     inFlight: false,
@@ -1410,11 +1424,40 @@ export class StructuredSessionManager {
     toggleAutoApprove(sessionId) {
         const session = this.requireSession(sessionId);
         const newVal = !session.autoApprovePermissions;
+        if (newVal && session.pendingEscalation) {
+            const resolved = this.resolveEscalation(sessionId, session.pendingEscalation.requestId, "approve_once");
+            const updated = { ...resolved, autoApprovePermissions: true };
+            this.sessions.set(sessionId, updated);
+            this.storage.updateSessionRuntimeMetadata(updated);
+            this.emit({
+                type: "status",
+                sessionId,
+                data: { sessionKind: "structured", autoApprovePermissions: true },
+            });
+            return updated;
+        }
         const updated = { ...session, autoApprovePermissions: newVal };
         this.sessions.set(sessionId, updated);
         this.storage.updateSessionRuntimeMetadata(updated);
+        this.emit({
+            type: "status",
+            sessionId,
+            data: { sessionKind: "structured", autoApprovePermissions: newVal },
+        });
         return updated;
     }
+    approvePermission(sessionId) {
+        const pending = this.requireSession(sessionId).pendingEscalation;
+        if (!pending)
+            throw new Error("当前会话没有待处理的授权请求。");
+        return this.resolveEscalation(sessionId, pending.requestId, "approve_once");
+    }
+    denyPermission(sessionId) {
+        const pending = this.requireSession(sessionId).pendingEscalation;
+        if (!pending)
+            throw new Error("当前会话没有待处理的授权请求。");
+        return this.resolveEscalation(sessionId, pending.requestId, "deny");
+    }
     /** Resolve a specific escalation by requestId. */
     resolveEscalation(sessionId, requestId, resolution) {
         const session = this.requireSession(sessionId);
@@ -1433,6 +1476,12 @@ export class StructuredSessionManager {
         if (approved && scope) {
             this.incrementApprovalStats(session, scope);
         }
+        if (approved && resolution === "approve_turn") {
+            this.rememberTurnApproval(sessionId, pending.scope, pending.target);
+        }
+        this.settlePendingPermission(sessionId, pending.requestId, approved
+            ? { behavior: "allow" }
+            : structuredPermissionDenied("User rejected permission request"));
         const updated = {
             ...session,
             pendingEscalation: null,
@@ -1453,6 +1502,8 @@ export class StructuredSessionManager {
         return updated;
     }
     stop(id) {
+        this.settlePendingPermission(id, undefined, structuredPermissionDenied("已停止"));
+        this.turnApprovalMemory.delete(id);
         const session = this.requireSession(id);
         this.interruptedWith.delete(id);
         this.interruptedSkills.delete(id);
@@ -1499,6 +1550,8 @@ export class StructuredSessionManager {
         return cancelled;
     }
     delete(id) {
+        this.settlePendingPermission(id, undefined, structuredPermissionDenied("会话已删除"));
+        this.turnApprovalMemory.delete(id);
         const runnerExecution = this.pendingRunnerExecutions.get(id);
         const sdkQuery = this.pendingSdkQueries.get(id);
         const sdkAbort = this.pendingSdkAbort.get(id);
@@ -1643,6 +1696,123 @@ export class StructuredSessionManager {
         stats.total++;
         session.approvalStats = stats;
     }
+    rememberTurnApproval(sessionId, scope, target) {
+        let memory = this.turnApprovalMemory.get(sessionId);
+        if (!memory) {
+            memory = { scopes: new Set(), targets: new Set() };
+            this.turnApprovalMemory.set(sessionId, memory);
+        }
+        memory.scopes.add(scope);
+        if (target)
+            memory.targets.add(target);
+    }
+    settlePendingPermission(sessionId, requestId, result) {
+        const waiter = this.pendingPermissions.get(sessionId);
+        if (!waiter)
+            return;
+        if (requestId !== undefined && waiter.requestId !== requestId)
+            return;
+        this.pendingPermissions.delete(sessionId);
+        waiter.resolve(result);
+    }
+    async handleCanUseTool(sessionId, requestId, toolName, input, ctx) {
+        const deny = (message) => structuredPermissionDenied(message);
+        if (ctx.signal.aborted || this.disposed)
+            return deny("已取消");
+        const current = this.currentSessionForRequest(sessionId, requestId);
+        if (!current)
+            return deny("会话已结束");
+        const inferred = inferStructuredEscalation(toolName, input, ctx);
+        if (current.autoApprovePermissions) {
+            this.incrementApprovalStats(current, inferred.scope);
+            this.storage.updateSessionRuntimeMetadata(current);
+            return { behavior: "allow" };
+        }
+        const memory = this.turnApprovalMemory.get(sessionId);
+        if (memory && (memory.scopes.has(inferred.scope) || (inferred.target && memory.targets.has(inferred.target)))) {
+            return { behavior: "allow" };
+        }
+        const existing = this.pendingPermissions.get(sessionId);
+        if (existing) {
+            await new Promise((resolve) => {
+                const previous = existing.resolve;
+                existing.resolve = (result) => {
+                    previous(result);
+                    resolve(result);
+                };
+            });
+            if (ctx.signal.aborted || this.disposed)
+                return deny("已取消");
+            return this.handleCanUseTool(sessionId, requestId, toolName, input, ctx);
+        }
+        const escalation = {
+            requestId: ctx.toolUseID ? `sdk-${ctx.toolUseID}` : `sdk-${Date.now()}`,
+            scope: inferred.scope,
+            runner: "json",
+            source: "tool_permission_request",
+            target: inferred.target,
+            reason: inferred.reason,
+        };
+        return await new Promise((resolve) => {
+            let settled = false;
+            const finish = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                ctx.signal.removeEventListener("abort", onAbort);
+                if (this.pendingPermissions.get(sessionId)?.requestId === escalation.requestId) {
+                    this.pendingPermissions.delete(sessionId);
+                }
+                resolve(result);
+            };
+            const onAbort = () => {
+                finish(deny("已取消"));
+                const latest = this.currentSessionForRequest(sessionId, requestId);
+                if (latest?.pendingEscalation?.requestId === escalation.requestId) {
+                    const cleared = {
+                        ...latest,
+                        pendingEscalation: null,
+                        permissionBlocked: false,
+                    };
+                    this.sessions.set(sessionId, cleared);
+                    this.storage.updateSessionRuntimeMetadata(cleared);
+                    this.emit({
+                        type: "status",
+                        sessionId,
+                        data: { permissionBlocked: false, sessionKind: "structured" },
+                    });
+                }
+            };
+            ctx.signal.addEventListener("abort", onAbort, { once: true });
+            this.pendingPermissions.set(sessionId, { requestId: escalation.requestId, resolve: finish });
+            const latest = this.currentSessionForRequest(sessionId, requestId);
+            if (!latest || ctx.signal.aborted) {
+                finish(deny("会话已结束"));
+                return;
+            }
+            const updated = {
+                ...latest,
+                pendingEscalation: escalation,
+                permissionBlocked: true,
+            };
+            this.sessions.set(sessionId, updated);
+            this.storage.updateSessionRuntimeMetadata(updated);
+            this.emit({
+                type: "status",
+                sessionId,
+                data: {
+                    sessionKind: "structured",
+                    permissionBlocked: true,
+                    permissionRequest: {
+                        scope: escalation.scope,
+                        target: escalation.target,
+                        prompt: escalation.reason,
+                    },
+                    pendingEscalation: escalation,
+                },
+            });
+        });
+    }
     // ---------------------------------------------------------------------------
     // Streaming codex exec --json execution
     // ---------------------------------------------------------------------------
@@ -2323,6 +2493,7 @@ export class StructuredSessionManager {
     async runClaudeSdkStreaming(sessionId, session, prompt, requestId, skills) {
         const abortController = new AbortController();
         this.pendingSdkAbort.set(sessionId, abortController);
+        this.turnApprovalMemory.delete(sessionId);
         const isManaged = session.mode === "managed";
         let killedForAskUserQuestion = false;
         // 权限策略 + 系统提示词都通过共享 helper 派生，与 CLI runner 一字不差。
@@ -2339,6 +2510,11 @@ export class StructuredSessionManager {
             env: sdkEnv,
             permissionMode: permPolicy.permissionMode,
             ...(permPolicy.permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
+            ...(permPolicy.permissionMode !== "bypassPermissions"
+                ? {
+                    canUseTool: (toolName, input, ctx) => this.handleCanUseTool(sessionId, requestId, toolName, input, ctx),
+                }
+                : {}),
             ...(permPolicy.allowedTools ? { allowedTools: permPolicy.allowedTools } : {}),
             ...(isManaged ? { disallowedTools: ["AskUserQuestion"] } : {}),
             skills,
@@ -2714,6 +2890,8 @@ export class StructuredSessionManager {
             }
         }
         // Cleanup
+        this.settlePendingPermission(sessionId, undefined, structuredPermissionDenied("本轮已结束"));
+        this.turnApprovalMemory.delete(sessionId);
         const releasedAbort = this.releasePendingSdkAbort(sessionId, abortController);
         const releasedQuery = this.releasePendingSdkQuery(sessionId, queryHandle);
         if (releasedAbort || releasedQuery)

package/dist/taskboard-bridge.js

@@ -153,7 +153,18 @@ export function taskboardIntegrationScript() {
       });
   };
   const scan = () => document.querySelectorAll("[data-task-id]").forEach(setup);
-  new MutationObserver(scan).observe(document.documentElement, {childList:true, subtree:true});
+  let readyAnnounced = false;
+  const announceReady = (repeat = false) => {
+    const root = document.getElementById("root");
+    if (!root || !root.childElementCount || window.parent === window || (readyAnnounced && !repeat)) return;
+    readyAnnounced = true;
+    window.parent.postMessage({type:"wand-taskboard-ready"}, location.origin);
+  };
+  new MutationObserver(() => { scan(); announceReady(); }).observe(document.documentElement, {childList:true, subtree:true});
+  window.addEventListener("load", () => announceReady());
+  window.addEventListener("message", (event) => {
+    if (event.origin === location.origin && event.source === window.parent && event.data?.type === "wand-taskboard-ready-request") announceReady(true);
+  });
   scan();
 })();
 </script>`;