wave-code 1.0.9 → 1.1.0

package/dist/stdio/agentBridge.js

@@ -1,999 +0,0 @@
-/**
- * AgentBridge — wraps the SDK Agent and translates between the JSON-RPC-like
- * stdio protocol and Agent method calls / callbacks.
- *
- * Multi-tenant: maintains a Map<sessionId, {agent, storedConfig}> so a single
- * `wave --stdio` process can host multiple sessions. Session-scoped requests
- * carry `sessionId` on the JSON-RPC envelope for routing; global requests
- * (listSessions/searchFiles/auth/plugins) don't require it but may use it
- * for workdir fallback.
- *
- * Responsibilities:
- * - Route incoming requests to the appropriate Agent method (by sessionId)
- * - Translate AgentCallbacks into outgoing notifications (with sessionId)
- * - Implement the canUseTool permission flow over the stdio protocol
- * - Handle config updates by destroying and recreating the Agent
- */
-import { Agent, listSessions, searchFiles, generateRandomName, getDefaultRemoteBranch, getMessageContent, PromptHistoryManager, AuthService, PluginCore, validateWorktreeRemovalPath, loadUserConfigEnv, } from "wave-agent-sdk";
-import { INVALID_PARAMS as PROTOCOL_INVALID_PARAMS, INTERNAL_ERROR as PROTOCOL_INTERNAL_ERROR, METHOD_NOT_FOUND as PROTOCOL_METHOD_NOT_FOUND, } from "./protocol.js";
-import { execFileSync } from "node:child_process";
-import { mkdirSync, existsSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { basename, extname, join } from "node:path";
-import { createWorktree, removeWorktree } from "../utils/worktree.js";
-import { logger } from "../utils/logger.js";
-import { isUserCheckpointMessage } from "../utils/rewindCheckpoints.js";
-export class AgentBridge {
-    constructor(options) {
-        this.sessions = new Map();
-        /** Pending approval requests, keyed by requestId. Stored with the resolve +
-         * context so a re-attached client can list and respond to them (daemon mode:
-         * approvals outlive any single connection). */
-        this.pendingPermissions = new Map();
-        this.permissionCounter = 0;
-        this.emit = options.emit;
-        // Mirror the user-level settings env WAVE_SERVER_URL into process.env
-        // before any agent initializes. getAuthStatus (webviewReady →
-        // pushInitialState) can run before the first agent, and AuthService falls
-        // back to the default URL otherwise — refreshing a custom-domain token
-        // against the wrong host 401s into a logged-out state.
-        const userEnv = loadUserConfigEnv();
-        if (userEnv.WAVE_SERVER_URL) {
-            process.env.WAVE_SERVER_URL = userEnv.WAVE_SERVER_URL;
-        }
-    }
-    // ── Public API ────────────────────────────────────────────────
-    async handleRequest(method, params, sessionId) {
-        const p = (params ?? {});
-        switch (method) {
-            // ── Lifecycle ──
-            case "initialize":
-                return this.initialize(p);
-            case "destroy":
-                return this.destroy(sessionId);
-            case "restoreSession":
-                return this.restoreSession(p.sessionId, sessionId);
-            case "listSessions":
-                return this.listSessions(p.workdir, sessionId);
-            case "getSessionInfo":
-                return this.getSessionInfo(sessionId);
-            case "listPendingPermissions":
-                return this.listPendingPermissions();
-            case "listDaemonSessions":
-                return this.listDaemonSessions();
-            case "updateConfig":
-                return this.updateConfig(p, sessionId);
-            case "getConfiguredModels":
-                return this.getConfiguredModels(sessionId);
-            case "setModel":
-                return this.setModel(p.model, sessionId);
-            // ── Messages ──
-            case "sendMessage":
-                return this.sendMessage(p, sessionId);
-            case "bang":
-                return this.bang(p.command, sessionId);
-            case "askBtw":
-                return this.askBtw(p.question, sessionId);
-            case "abortMessage":
-                return this.abortMessage(sessionId);
-            case "clearMessages":
-                return this.clearMessages(sessionId);
-            case "rewindToMessage":
-                return this.rewindToMessage(p.messageId, sessionId);
-            case "listRewindCheckpoints":
-                return this.listRewindCheckpoints(sessionId);
-            case "deleteQueuedMessage":
-                return this.deleteQueuedMessage(p.index, sessionId);
-            case "updateQueuedMessage":
-                return this.updateQueuedMessage(p.id, p.text, p.images, sessionId);
-            case "deleteQueuedMessageById":
-                return this.deleteQueuedMessageById(p.id, sessionId);
-            case "getMessages":
-                return this.getMessages(sessionId);
-            case "getFullMessageThread":
-                return this.getFullMessageThread(sessionId);
-            // ── Permissions ──
-            case "setPermissionMode":
-                return this.setPermissionMode(p.mode, sessionId);
-            case "getPermissionMode":
-                return this.getPermissionMode(sessionId);
-            // ── MCP ──
-            case "getMcpServers":
-                return this.getMcpServers(sessionId);
-            case "connectMcpServer":
-                return this.connectMcpServer(p.serverName, sessionId);
-            case "disconnectMcpServer":
-                return this.disconnectMcpServer(p.serverName, sessionId);
-            // ── Commands ──
-            case "getSlashCommands":
-                return this.getSlashCommands(sessionId);
-            case "getSubagentConfigurations":
-                return this.getSubagentConfigurations(sessionId);
-            // ── File / History (global — no session required) ──
-            case "searchFiles":
-                return this.searchFiles(p, sessionId);
-            case "writeArtifactFile":
-                return this.writeArtifactFile(p);
-            case "getPromptHistory":
-                return this.getPromptHistory(p.workdir, sessionId);
-            case "searchPromptHistory":
-                return this.searchPromptHistory(p.query, p.workdir, sessionId);
-            // ── Auth (global — no session required) ──
-            case "getAuthStatus":
-                return this.getAuthStatus();
-            case "login":
-                return this.login(p.serverUrl);
-            case "logout":
-                return this.logout();
-            // ── Plugins (global — no session required) ──
-            case "listPlugins":
-                return this.listPlugins(p.workdir, sessionId);
-            case "installPlugin":
-                return this.installPlugin(p.pluginId, p.scope, p.workdir, sessionId);
-            case "uninstallPlugin":
-                return this.uninstallPlugin(p.pluginId, p.workdir, sessionId);
-            case "enablePlugin":
-                return this.enablePlugin(p.pluginId, p.scope, p.workdir, sessionId);
-            case "disablePlugin":
-                return this.disablePlugin(p.pluginId, p.scope, p.workdir, sessionId);
-            case "getProjectSettings":
-                return this.getProjectSettings(p.workdir, sessionId);
-            case "setBuiltinPluginEnabled":
-                return this.setBuiltinPluginEnabled(p.pluginId, p.enabled, p.scope, p.workdir, sessionId);
-            case "updatePlugin":
-                return this.updatePlugin(p.pluginId, p.workdir, sessionId);
-            case "listMarketplaces":
-                return this.listMarketplaces(p.workdir, sessionId);
-            case "addMarketplace":
-                return this.addMarketplace(p.input, p.scope, p.workdir, sessionId);
-            case "removeMarketplace":
-                return this.removeMarketplace(p.name, p.scope, p.workdir, sessionId);
-            case "updateMarketplace":
-                return this.updateMarketplace(p.name, p.workdir, sessionId);
-            case "compact":
-                return this.compact(p.customInstructions, sessionId);
-            // ── Background tasks ──
-            case "getBackgroundTaskOutput":
-                return this.getBackgroundTaskOutput(p.taskId, sessionId);
-            case "stopBackgroundTask":
-                return this.stopBackgroundTask(p.taskId, sessionId);
-            case "backgroundCurrentTask":
-                return this.backgroundCurrentTask(sessionId);
-            case "getWorkflowRuns":
-                return this.getWorkflowRuns(sessionId);
-            case "stopWorkflowRun":
-                return this.stopWorkflowRun(p.runId, sessionId);
-            // ── Git / worktree (global — no session required) ──
-            case "listGitBranches":
-                return this.listGitBranches(p.workdir);
-            case "createWorktree":
-                return this.createWorktreeSession(p);
-            case "removeWorktree":
-                return this.removeWorktreeSession(p);
-            default:
-                throw new RpcError(PROTOCOL_METHOD_NOT_FOUND, `Method not found: ${method}`);
-        }
-    }
-    handleNotification(method, params) {
-        if (method === "permissionResponse") {
-            const p = params;
-            // requestId is process-level unique; lookup doesn't need sessionId
-            const entry = this.pendingPermissions.get(p.requestId);
-            if (entry) {
-                this.pendingPermissions.delete(p.requestId);
-                entry.resolve(p.decision);
-            }
-        }
-    }
-    // ── Lifecycle ─────────────────────────────────────────────────
-    async initialize(params) {
-        // Re-attach (daemon mode): if the target session is already live in this
-        // process, reuse it instead of creating a second agent writing to the same
-        // transcript. The live agent keeps running across client detach/attach.
-        if (params.restoreSessionId) {
-            const live = this.sessions.get(params.restoreSessionId);
-            if (live) {
-                return {
-                    sessionId: live.agent.sessionId,
-                    workingDirectory: live.agent.workingDirectory,
-                    permissionMode: live.agent.getPermissionMode(),
-                    latestTotalTokens: live.agent.latestTotalTokens,
-                };
-            }
-        }
-        const ctx = {};
-        const callbacks = this.createCallbacks(ctx);
-        const options = {
-            callbacks,
-            logger,
-            workdir: params.workdir,
-            restoreSessionId: params.restoreSessionId,
-            apiKey: params.apiKey,
-            baseURL: params.baseURL,
-            defaultHeaders: params.defaultHeaders,
-            model: params.model,
-            fastModel: params.fastModel,
-            language: params.language,
-            permissionMode: params.permissionMode,
-            tools: params.tools,
-            allowedTools: params.allowedTools,
-            disallowedTools: params.disallowedTools,
-            plugins: params.pluginDirs?.map((path) => ({ type: "local", path })),
-            mcpServers: params.mcpServers,
-            worktreeName: params.worktreeName,
-            isNewWorktree: params.isNewWorktree,
-            canUseTool: (context) => this.canUseTool(context, ctx),
-        };
-        const agent = await Agent.create(options);
-        ctx.agent = agent;
-        ctx.registeredSessionId = agent.sessionId;
-        this.sessions.set(agent.sessionId, {
-            agent,
-            storedConfig: { ...params },
-        });
-        return {
-            sessionId: agent.sessionId,
-            workingDirectory: agent.workingDirectory,
-            permissionMode: agent.getPermissionMode(),
-            latestTotalTokens: agent.latestTotalTokens,
-        };
-    }
-    async destroy(sessionId) {
-        if (sessionId) {
-            const entry = this.sessions.get(sessionId);
-            if (entry) {
-                await entry.agent.destroy();
-                this.sessions.delete(sessionId);
-            }
-        }
-        return null;
-    }
-    /**
-     * True when every hosted session has settled: not generating, nothing queued,
-     * and no background work (background bash / subagents / workflows) — the same
-     * condition `wave -p` waits on before exiting (print-cli.ts). Pending
-     * permission approvals keep the owning agent's isLoading true, so they are
-     * covered without an explicit check.
-     */
-    isIdle() {
-        for (const entry of this.sessions.values()) {
-            const agent = entry.agent;
-            if (agent.isLoading ||
-                agent.hasPendingMessages ||
-                agent.hasRunningBackgroundWork) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Destroy every hosted session agent. Each Agent.destroy() saves its
-     * transcript, drains in-flight auto-memory extraction, and cleans up
-     * background tasks/subagents. Best-effort: one failing destroy must not
-     * block the rest of the shutdown.
-     */
-    async destroyAll() {
-        const entries = [...this.sessions.values()];
-        this.sessions.clear();
-        await Promise.all(entries.map((entry) => entry.agent.destroy().catch(() => { })));
-    }
-    async restoreSession(restoreId, sessionId) {
-        const entry = this.requireSession(sessionId);
-        // Re-attach to a live session: the SDK restore would no-op (target is
-        // already current). Emit the current messages so the freshly attached
-        // client — whose router registered only after initialize returned and so
-        // missed any earlier notifications — gets a snapshot without replay.
-        if (entry.agent.sessionId === restoreId) {
-            this.emit("messagesChange", { messages: entry.agent.messages }, entry.agent.sessionId);
-            // The re-attached client also missed the loading state that settled
-            // before its router registered — replay it or the client's
-            // isStreaming/running indicator stays false while the live session
-            // keeps generating.
-            this.emit("loadingChange", {
-                loading: entry.agent.isLoading,
-                latestTotalTokens: entry.agent.latestTotalTokens,
-            }, entry.agent.sessionId);
-            return null;
-        }
-        await entry.agent.restoreSession(restoreId);
-        return null;
-    }
-    async listSessions(workdir, sessionId) {
-        const sessions = await listSessions(workdir || this.getSessionWorkdir(sessionId) || process.cwd());
-        return { sessions };
-    }
-    // ── Git / worktree ────────────────────────────────────────────
-    listGitBranches(workdir) {
-        if (!workdir) {
-            throw new RpcError(PROTOCOL_INTERNAL_ERROR, "workdir is required");
-        }
-        const gitOpts = {
-            cwd: workdir,
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "pipe"],
-        };
-        let branchesRaw;
-        try {
-            branchesRaw = execFileSync("git", ["for-each-ref", "--format=%(refname:short)", "refs/heads"], gitOpts).trim();
-        }
-        catch {
-            throw new RpcError(PROTOCOL_INTERNAL_ERROR, `Not a git repository (or git unavailable): ${workdir}`);
-        }
-        const branches = branchesRaw
-            ? branchesRaw
-                .split("\n")
-                .map((b) => b.trim())
-                .filter(Boolean)
-            : [];
-        let current = null;
-        try {
-            const head = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], gitOpts).trim();
-            // Detached HEAD prints "HEAD" — treat as no current branch.
-            current = head && head !== "HEAD" ? head : null;
-        }
-        catch {
-            current = null;
-        }
-        return { branches, current };
-    }
-    async createWorktreeSession(params) {
-        if (!params.workdir) {
-            throw new RpcError(PROTOCOL_INTERNAL_ERROR, "workdir is required");
-        }
-        const name = params.name?.trim() || generateRandomName();
-        try {
-            const session = await createWorktree(name, params.workdir, {
-                baseBranch: params.baseBranch,
-            });
-            return {
-                name: session.name,
-                path: session.path,
-                branch: session.branch,
-                repoRoot: session.repoRoot,
-                baseBranch: params.baseBranch ?? getDefaultRemoteBranch(params.workdir),
-                isNew: session.isNew,
-            };
-        }
-        catch (e) {
-            throw new RpcError(PROTOCOL_INTERNAL_ERROR, e.message);
-        }
-    }
-    async removeWorktreeSession(params) {
-        // Align with Claude Code v2.1.216+: refuse to remove a worktree whose path
-        // is a symlink or resolves outside the repo root. Already-removed (missing)
-        // paths pass validation so removal stays idempotent.
-        try {
-            validateWorktreeRemovalPath(params.path, params.repoRoot);
-        }
-        catch (e) {
-            throw new RpcError(PROTOCOL_INTERNAL_ERROR, e.message);
-        }
-        // Trigger the WorktreeRemove hook (before git removal, non-blocking) using
-        // the session that runs in this worktree, if it is still registered.
-        for (const entry of this.sessions.values()) {
-            if (entry.agent.workingDirectory === params.path) {
-                try {
-                    await entry.agent.triggerWorktreeRemoveHook(params.path);
-                }
-                catch (e) {
-                    logger.warn("WorktreeRemove hooks execution failed:", e);
-                }
-                break;
-            }
-        }
-        // removeWorktree is best-effort/idempotent: already-removed worktrees or
-        // branches only log, never throw.
-        await removeWorktree({
-            name: "",
-            path: params.path,
-            branch: params.branch,
-            repoRoot: params.repoRoot,
-            hasUncommittedChanges: false,
-            hasNewCommits: false,
-            isNew: false,
-        });
-        return { ok: true };
-    }
-    getSessionInfo(sessionId) {
-        const entry = this.requireSession(sessionId);
-        return {
-            sessionId: entry.agent.sessionId,
-            workingDirectory: entry.agent.workingDirectory,
-            latestTotalTokens: entry.agent.latestTotalTokens,
-            permissionMode: entry.agent.getPermissionMode(),
-            availableTools: entry.agent.getAvailableToolNames(),
-        };
-    }
-    async updateConfig(params, sessionId) {
-        const entry = this.requireSession(sessionId);
-        const currentSessionId = entry.agent.sessionId;
-        // Merge new config into stored config
-        entry.storedConfig = { ...entry.storedConfig, ...params };
-        // Destroy and recreate within the same session slot
-        await entry.agent.destroy();
-        this.sessions.delete(currentSessionId);
-        const ctx = {};
-        const callbacks = this.createCallbacks(ctx);
-        const options = {
-            callbacks,
-            workdir: entry.storedConfig.workdir,
-            restoreSessionId: currentSessionId,
-            apiKey: entry.storedConfig.apiKey,
-            baseURL: entry.storedConfig.baseURL,
-            defaultHeaders: entry.storedConfig.defaultHeaders,
-            model: entry.storedConfig.model,
-            fastModel: entry.storedConfig.fastModel,
-            language: entry.storedConfig.language,
-            permissionMode: entry.storedConfig.permissionMode,
-            tools: entry.storedConfig.tools,
-            allowedTools: entry.storedConfig.allowedTools,
-            disallowedTools: entry.storedConfig.disallowedTools,
-            plugins: entry.storedConfig.pluginDirs?.map((p) => ({
-                type: "local",
-                path: p,
-            })),
-            mcpServers: entry.storedConfig.mcpServers,
-            // Keep worktree context (permission safety) across recreation, but never
-            // re-fire WorktreeCreate — the hook ran at initial creation.
-            worktreeName: entry.storedConfig.worktreeName,
-            canUseTool: (context) => this.canUseTool(context, ctx),
-        };
-        const agent = await Agent.create(options);
-        ctx.agent = agent;
-        ctx.registeredSessionId = agent.sessionId;
-        this.sessions.set(agent.sessionId, {
-            agent,
-            storedConfig: { ...entry.storedConfig },
-        });
-        return { sessionId: agent.sessionId };
-    }
-    getConfiguredModels(sessionId) {
-        const entry = this.requireSession(sessionId);
-        return {
-            models: entry.agent.getConfiguredModels(),
-            currentModel: entry.agent.getModelConfig().model,
-        };
-    }
-    async setModel(model, sessionId) {
-        const entry = this.requireSession(sessionId);
-        entry.agent.setModel(model);
-        // Keep storedConfig in sync: updateConfig recreates the agent from
-        // storedConfig, so without this a later config save would revert the
-        // model chosen here.
-        entry.storedConfig = { ...entry.storedConfig, model };
-        return null;
-    }
-    // ── Messages ──────────────────────────────────────────────────
-    async sendMessage(params, sessionId) {
-        const entry = this.requireSession(sessionId);
-        if (params.force) {
-            entry.agent.abortMessage();
-        }
-        // Save prompt to history (mirrors VSCE chatSession.ts:236-242)
-        try {
-            await PromptHistoryManager.addEntry(params.text, entry.agent.sessionId, {}, entry.agent.workingDirectory);
-        }
-        catch {
-            // Best-effort; don't block message sending on history save failure
-        }
-        await entry.agent.sendMessage(params.text, this.persistDataUrlImages(params.images));
-        return null;
-    }
-    /**
-     * Webview hosts (desktop/vscode/jetbrains) send pasted images as inline
-     * data URLs — there is no local file behind them. Persist each to a temp
-     * file so the model gets a real path it can reference with tools (aligned
-     * with Claude Code's `[Image source: <path>]` metadata). Real paths pass
-     * through untouched; unparseable data URLs pass through as-is and are
-     * skipped by the SDK rather than blocking the message.
-     */
-    persistDataUrlImages(images) {
-        if (!images || images.length === 0)
-            return images;
-        return images.map((img) => {
-            if (!img.path.startsWith("data:"))
-                return img;
-            const match = /^data:([^;,]+);base64,(.*)$/s.exec(img.path);
-            if (!match)
-                return img;
-            try {
-                const mimeType = match[1];
-                const ext = mimeType.split("/")[1]?.replace("jpeg", "jpg") || "png";
-                const filePath = join(tmpdir(), `wave-image-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.${ext}`);
-                writeFileSync(filePath, Buffer.from(match[2], "base64"));
-                return { path: filePath, mimeType };
-            }
-            catch (error) {
-                logger.warn("Failed to persist pasted image to temp file:", error);
-                return img;
-            }
-        });
-    }
-    async bang(command, sessionId) {
-        const entry = this.requireSession(sessionId);
-        await entry.agent.bang(command);
-        return null;
-    }
-    async askBtw(question, sessionId) {
-        const entry = this.requireSession(sessionId);
-        return entry.agent.askBtw(question, undefined, 
-        // Stream partial content to the client so webview hosts can render the
-        // answer incrementally (thinking and content travel on separate
-        // channels so the panel can drop thinking text once content starts).
-        (content) => {
-            if (sessionId) {
-                this.emit("btwContent", { question, content, type: "content" }, sessionId);
-            }
-        }, (content) => {
-            if (sessionId) {
-                this.emit("btwContent", { question, content, type: "thinking" }, sessionId);
-            }
-        });
-    }
-    async abortMessage(sessionId) {
-        const entry = this.requireSession(sessionId);
-        entry.agent.abortMessage();
-        return null;
-    }
-    async clearMessages(sessionId) {
-        const entry = this.requireSession(sessionId);
-        entry.agent.clearMessages();
-        return null;
-    }
-    async rewindToMessage(messageId, sessionId) {
-        const entry = this.requireSession(sessionId);
-        const { messages } = await entry.agent.getFullMessageThread();
-        // 压缩是 append-only：同 id 消息（压缩前历史 + 压缩后 append 的重复）会
-        // 在磁盘完整线程中出现多次。用户看到的折叠视图对应最后一次出现，
-        // 因此匹配最后一个而非第一个，避免回滚时连压缩摘要一起删掉。
-        const index = messages.map((m) => m.id).lastIndexOf(messageId);
-        if (index === -1) {
-            throw new RpcError(PROTOCOL_INTERNAL_ERROR, `Message not found: ${messageId}`);
-        }
-        const message = messages[index];
-        const textBlock = message.blocks.find((b) => b.type === "text");
-        await entry.agent.truncateHistory(index);
-        return { inputContent: textBlock?.content || "" };
-    }
-    async listRewindCheckpoints(sessionId) {
-        const entry = this.requireSession(sessionId);
-        const { messages } = await entry.agent.getFullMessageThread();
-        // 压缩 append-only 后同 id 消息在磁盘完整线程中重复出现（压缩前历史 +
-        // 压缩后 append 的重复）。按 id 去重并保留最后一次出现（与折叠后的
-        // UI/内存视图一致），避免弹窗把同一条用户消息显示两遍。
-        const checkpointMap = new Map();
-        for (const m of messages) {
-            if (isUserCheckpointMessage(m) && m.id) {
-                checkpointMap.set(m.id, {
-                    id: m.id,
-                    content: getMessageContent(m).replace(/\s+/g, " ").trim(),
-                });
-            }
-        }
-        return { checkpoints: Array.from(checkpointMap.values()) };
-    }
-    deleteQueuedMessage(index, sessionId) {
-        const entry = this.requireSession(sessionId);
-        entry.agent.removeQueuedMessage(index);
-        return null;
-    }
-    updateQueuedMessage(id, text, images, sessionId) {
-        const entry = this.requireSession(sessionId);
-        const ok = entry.agent.updateQueuedMessageById(id, {
-            content: text,
-            images: this.persistDataUrlImages(images),
-        });
-        return { ok };
-    }
-    deleteQueuedMessageById(id, sessionId) {
-        const entry = this.requireSession(sessionId);
-        entry.agent.removeQueuedMessageById(id);
-        return null;
-    }
-    getMessages(sessionId) {
-        const entry = this.requireSession(sessionId);
-        return { messages: entry.agent.messages };
-    }
-    async getFullMessageThread(sessionId) {
-        const entry = this.requireSession(sessionId);
-        return entry.agent.getFullMessageThread();
-    }
-    async compact(customInstructions, sessionId) {
-        const entry = this.requireSession(sessionId);
-        await entry.agent.compact(customInstructions);
-        return null;
-    }
-    // ── Background tasks ──
-    getBackgroundTaskOutput(taskId, sessionId) {
-        const entry = this.requireSession(sessionId);
-        return { output: entry.agent.getBackgroundTaskOutput(taskId) };
-    }
-    stopBackgroundTask(taskId, sessionId) {
-        const entry = this.requireSession(sessionId);
-        const success = entry.agent.stopBackgroundTask(taskId);
-        return { success };
-    }
-    async backgroundCurrentTask(sessionId) {
-        const entry = this.requireSession(sessionId);
-        await entry.agent.backgroundCurrentTask();
-        return null;
-    }
-    async getWorkflowRuns(sessionId) {
-        const entry = this.requireSession(sessionId);
-        const runs = await entry.agent.getWorkflowRuns();
-        return {
-            runs: runs.map((r) => {
-                const { completionPromise, ...rest } = r;
-                void completionPromise;
-                return rest;
-            }),
-        };
-    }
-    stopWorkflowRun(runId, sessionId) {
-        const entry = this.requireSession(sessionId);
-        entry.agent.stopWorkflowRun(runId);
-        return { success: true };
-    }
-    // ── Permissions ───────────────────────────────────────────────
-    async setPermissionMode(mode, sessionId) {
-        const entry = this.requireSession(sessionId);
-        await entry.agent.setPermissionMode(mode);
-        return null;
-    }
-    getPermissionMode(sessionId) {
-        const entry = this.requireSession(sessionId);
-        return { mode: entry.agent.getPermissionMode() };
-    }
-    // ── MCP ───────────────────────────────────────────────────────
-    getMcpServers(sessionId) {
-        const entry = this.requireSession(sessionId);
-        return { servers: entry.agent.getMcpServers() };
-    }
-    async connectMcpServer(serverName, sessionId) {
-        const entry = this.requireSession(sessionId);
-        const success = await entry.agent.connectMcpServer(serverName);
-        return { success };
-    }
-    async disconnectMcpServer(serverName, sessionId) {
-        const entry = this.requireSession(sessionId);
-        const success = await entry.agent.disconnectMcpServer(serverName);
-        return { success };
-    }
-    // ── Commands ──────────────────────────────────────────────────
-    getSlashCommands(sessionId) {
-        const entry = this.requireSession(sessionId);
-        return { commands: entry.agent.getSlashCommands() };
-    }
-    getSubagentConfigurations(sessionId) {
-        const entry = this.requireSession(sessionId);
-        return { configurations: entry.agent.getSubagentConfigurations() };
-    }
-    // ── File / History (global) ───────────────────────────────────
-    async searchFiles(params, sessionId) {
-        const files = await searchFiles(params.query, {
-            maxResults: params.maxResults,
-            workingDirectory: params.workdir || this.getSessionWorkdir(sessionId) || process.cwd(),
-        });
-        return { files };
-    }
-    /**
-     * Writes an uploaded file (from the desktop/webview "+上传文件" flow) into the
-     * artifacts dir on THIS machine — i.e. where the agent runs. Remote sessions
-     * call this over the ssh tunnel so the returned path is reachable by the
-     * remote agent's tools; local sessions never hit this (desktop writes locally
-     * itself).
-     */
-    async writeArtifactFile(params) {
-        // Artifacts are keyed by basename only — reject anything that could escape
-        // the artifacts dir via path traversal.
-        const safeName = basename(params.name || "");
-        if (!safeName || safeName === "." || safeName === "..") {
-            throw new RpcError(PROTOCOL_INVALID_PARAMS, `Invalid artifact file name: ${params.name}`);
-        }
-        const artifactsDir = join(tmpdir(), "wave-artifacts");
-        mkdirSync(artifactsDir, { recursive: true });
-        let finalPath = join(artifactsDir, safeName);
-        let counter = 1;
-        while (existsSync(finalPath)) {
-            const ext = extname(safeName);
-            const baseName = basename(safeName, ext);
-            finalPath = join(artifactsDir, `${baseName}_${counter}${ext}`);
-            counter++;
-        }
-        writeFileSync(finalPath, Buffer.from(params.contentBase64 || "", "base64"));
-        return { path: finalPath };
-    }
-    async getPromptHistory(workdir, sessionId) {
-        const history = await PromptHistoryManager.getHistory({
-            workdir: workdir || this.getSessionWorkdir(sessionId),
-        });
-        return { history };
-    }
-    async searchPromptHistory(query, workdir, sessionId) {
-        const history = await PromptHistoryManager.searchHistory(query, {
-            workdir: workdir || this.getSessionWorkdir(sessionId),
-        });
-        return { history };
-    }
-    // ── canUseTool flow ───────────────────────────────────────────
-    canUseTool(context, ctx) {
-        const requestId = `perm_${++this.permissionCounter}`;
-        return new Promise((resolve) => {
-            this.pendingPermissions.set(requestId, {
-                resolve,
-                sessionId: ctx.registeredSessionId,
-                context,
-            });
-            this.emit("permissionRequest", { requestId, context }, ctx.registeredSessionId);
-        });
-    }
-    /** Attach snapshot: re-surface approvals that are still pending after a
-     * client disconnected (daemon mode). Responding to any listed requestId
-     * resolves the in-process promise. */
-    listPendingPermissions() {
-        return {
-            requests: [...this.pendingPermissions.entries()].map(([requestId, entry]) => ({
-                requestId,
-                sessionId: entry.sessionId,
-                context: entry.context,
-            })),
-        };
-    }
-    /** Daemon list: expose the in-memory session registry (live sessions only,
-     * not disk-scanning). Registration order is preserved. */
-    listDaemonSessions() {
-        return {
-            sessions: [...this.sessions.entries()].map(([sessionId, entry]) => ({
-                sessionId,
-                workingDirectory: entry.agent.workingDirectory,
-                isLoading: entry.agent.isLoading,
-                messageCount: entry.agent.messages.length,
-            })),
-        };
-    }
-    // ── Auth (global) ────────────────────────────────────────────
-    async getAuthStatus() {
-        const authService = AuthService.getInstance();
-        await authService.checkAndRefreshTokenIfNeeded();
-        return {
-            isAuthenticated: authService.isSSOAuthenticated(),
-            user: authService.getAuthUser(),
-            serverUrl: authService.getServerUrl(),
-        };
-    }
-    async login(serverUrl) {
-        const authService = AuthService.getInstance();
-        await authService.login({
-            onAuthUrl: (url) => {
-                this.emit("authUrl", { url });
-            },
-            serverUrl,
-        });
-        return { user: authService.getAuthUser() };
-    }
-    async logout() {
-        const authService = AuthService.getInstance();
-        await authService.clearAuth();
-        return null;
-    }
-    // ── Plugins (global) ─────────────────────────────────────────
-    getPluginCore(workdir, sessionId) {
-        const resolvedWorkdir = workdir || this.getSessionWorkdir(sessionId) || process.cwd();
-        if (!this.pluginCore || this.pluginCoreWorkdir !== resolvedWorkdir) {
-            this.pluginCore = new PluginCore(resolvedWorkdir);
-            this.pluginCoreWorkdir = resolvedWorkdir;
-        }
-        return this.pluginCore;
-    }
-    async listPlugins(workdir, sessionId) {
-        const core = this.getPluginCore(workdir, sessionId);
-        const { plugins, mergedEnabled } = await core.listPlugins();
-        return {
-            plugins: plugins.map((p) => {
-                const pluginId = `${p.name}@${p.marketplace}`;
-                return {
-                    id: pluginId,
-                    name: p.name,
-                    description: p.description,
-                    marketplace: p.marketplace,
-                    installed: p.installed,
-                    version: p.version,
-                    enabled: mergedEnabled[pluginId] !== false,
-                    scope: p.scope,
-                };
-            }),
-        };
-    }
-    async installPlugin(pluginId, scope, workdir, sessionId) {
-        return this.getPluginCore(workdir, sessionId).installPlugin(pluginId, scope);
-    }
-    async uninstallPlugin(pluginId, workdir, sessionId) {
-        await this.getPluginCore(workdir, sessionId).uninstallPlugin(pluginId);
-        return null;
-    }
-    async enablePlugin(pluginId, scope, workdir, sessionId) {
-        return this.getPluginCore(workdir, sessionId).enablePlugin(pluginId, scope);
-    }
-    async disablePlugin(pluginId, scope, workdir, sessionId) {
-        return this.getPluginCore(workdir, sessionId).disablePlugin(pluginId, scope);
-    }
-    async getProjectSettings(workdir, sessionId) {
-        return {
-            enabledPlugins: this.getPluginCore(workdir, sessionId).getMergedEnabledPlugins(),
-        };
-    }
-    async setBuiltinPluginEnabled(pluginId, enabled, scope, workdir, sessionId) {
-        const core = this.getPluginCore(workdir, sessionId);
-        const targetScope = scope ?? "project";
-        if (enabled) {
-            await core.enablePlugin(pluginId, targetScope);
-        }
-        else {
-            await core.disablePlugin(pluginId, targetScope);
-        }
-        return { enabledPlugins: core.getMergedEnabledPlugins() };
-    }
-    async updatePlugin(pluginId, workdir, sessionId) {
-        return this.getPluginCore(workdir, sessionId).updatePlugin(pluginId);
-    }
-    async listMarketplaces(workdir, sessionId) {
-        return this.getPluginCore(workdir, sessionId).listMarketplaces();
-    }
-    async addMarketplace(input, scope, workdir, sessionId) {
-        return this.getPluginCore(workdir, sessionId).addMarketplace(input, scope);
-    }
-    async removeMarketplace(name, scope, workdir, sessionId) {
-        await this.getPluginCore(workdir, sessionId).removeMarketplace(name, scope);
-        return null;
-    }
-    async updateMarketplace(name, workdir, sessionId) {
-        await this.getPluginCore(workdir, sessionId).updateMarketplace(name);
-        return null;
-    }
-    // ── Callbacks → Notifications ─────────────────────────────────
-    createCallbacks(ctx) {
-        return {
-            onUserMessageAdded: () => {
-                const msg = this.findLastUserMessage(ctx.agent);
-                if (msg)
-                    this.emit("userMessageAdded", { message: msg }, ctx.registeredSessionId);
-            },
-            onAssistantMessageAdded: (messageId) => {
-                const msg = ctx.agent?.messages.find((m) => m.id === messageId);
-                if (msg)
-                    this.emit("assistantMessageAdded", { message: msg }, ctx.registeredSessionId);
-            },
-            onAssistantContentUpdated: (params) => {
-                // Wire carries only the delta; consumers accumulate (spec: 流式通知纯增量负载).
-                this.emit("assistantContentUpdated", {
-                    messageId: params.messageId,
-                    chunk: params.chunk,
-                    stage: params.stage,
-                }, ctx.registeredSessionId);
-            },
-            onAssistantReasoningUpdated: (params) => {
-                this.emit("assistantReasoningUpdated", {
-                    messageId: params.messageId,
-                    chunk: params.chunk,
-                    stage: params.stage,
-                }, ctx.registeredSessionId);
-            },
-            onToolBlockUpdated: (params) => {
-                // Streaming stages carry only the parametersChunk delta; start/running
-                // (one-time snapshots) and end (authoritative full value) keep
-                // `parameters` (spec: 流式通知纯增量负载).
-                const { parameters, ...rest } = params;
-                void parameters;
-                const wireParams = params.stage === "streaming" ? rest : params;
-                this.emit("toolBlockUpdated", wireParams, ctx.registeredSessionId);
-            },
-            onErrorBlockAdded: (error) => {
-                this.emit("errorBlockAdded", { error }, ctx.registeredSessionId);
-            },
-            onLoadingChange: (loading) => {
-                this.emit("loadingChange", {
-                    loading,
-                    latestTotalTokens: ctx.agent?.latestTotalTokens,
-                }, ctx.registeredSessionId);
-            },
-            onCommandRunningChange: (running) => {
-                this.emit("commandRunningChange", { running }, ctx.registeredSessionId);
-            },
-            onQueuedMessagesChange: (messages) => {
-                this.emit("queuedMessagesChange", { messages }, ctx.registeredSessionId);
-            },
-            onTasksChange: (tasks) => {
-                this.emit("tasksChange", { tasks }, ctx.registeredSessionId);
-            },
-            onBackgroundTasksChange: (tasks) => {
-                const summaries = tasks.map((t) => ({
-                    id: t.id,
-                    type: t.type,
-                    status: t.status,
-                    startTime: t.startTime,
-                    endTime: t.endTime,
-                    command: t.command,
-                    description: t.description,
-                    exitCode: t.exitCode,
-                    runtime: t.runtime,
-                    outputPath: t.outputPath,
-                }));
-                this.emit("backgroundTasksChange", { tasks: summaries }, ctx.registeredSessionId);
-            },
-            onSessionIdChange: (newSessionId) => {
-                const oldSessionId = ctx.registeredSessionId;
-                // Emit with the OLD sessionId so the client's router can deliver it
-                this.emit("sessionIdChange", { sessionId: newSessionId }, oldSessionId);
-                // Update the sessions Map key atomically (single-threaded, no await)
-                if (oldSessionId && oldSessionId !== newSessionId) {
-                    const entry = this.sessions.get(oldSessionId);
-                    if (entry) {
-                        this.sessions.delete(oldSessionId);
-                        this.sessions.set(newSessionId, entry);
-                    }
-                }
-                ctx.registeredSessionId = newSessionId;
-            },
-            onPermissionModeChange: (mode) => {
-                this.emit("permissionModeChange", { mode }, ctx.registeredSessionId);
-            },
-            onWorkdirChange: (newCwd) => {
-                this.emit("workdirChange", { workdir: newCwd }, ctx.registeredSessionId);
-            },
-            onMcpServersChange: (servers) => {
-                this.emit("mcpServersChange", { servers }, ctx.registeredSessionId);
-            },
-            onAddBangMessage: (command, messageId) => {
-                this.emit("bangMessageAdded", { command, messageId }, ctx.registeredSessionId);
-            },
-            onUpdateBangMessage: (command, output, messageId) => {
-                this.emit("bangMessageUpdated", { command, output, messageId }, ctx.registeredSessionId);
-            },
-            onCompleteBangMessage: (command, exitCode, messageId, output) => {
-                this.emit("bangMessageCompleted", { command, exitCode, messageId, output }, ctx.registeredSessionId);
-            },
-            onNotificationMessageAdded: (params) => {
-                const msg = ctx.agent?.messages.find((m) => m.role === "user" &&
-                    m.blocks.some((b) => b.type === "task_notification" &&
-                        b.taskId === params.taskId));
-                this.emit("notificationMessageAdded", { ...params, message: msg }, ctx.registeredSessionId);
-            },
-            onCompactBlockAdded: (content) => {
-                this.emit("compactBlockAdded", { content }, ctx.registeredSessionId);
-            },
-            onCompactionStateChange: (isCompacting) => {
-                this.emit("compactionStateChange", { isCompacting }, ctx.registeredSessionId);
-            },
-        };
-    }
-    findLastUserMessage(agent) {
-        const userMessages = agent?.messages.filter((m) => m.role === "user") ?? [];
-        return userMessages[userMessages.length - 1];
-    }
-    // ── Utils ─────────────────────────────────────────────────────
-    requireSession(sessionId) {
-        if (!sessionId) {
-            throw new RpcError(PROTOCOL_INTERNAL_ERROR, "sessionId is required for this request");
-        }
-        const entry = this.sessions.get(sessionId);
-        if (!entry) {
-            throw new RpcError(PROTOCOL_INTERNAL_ERROR, `Session not found: ${sessionId}`);
-        }
-        return entry;
-    }
-    getSessionWorkdir(sessionId) {
-        if (!sessionId)
-            return undefined;
-        return this.sessions.get(sessionId)?.agent.workingDirectory;
-    }
-}
-// ── Error class for protocol errors ─────────────────────────────
-export class RpcError extends Error {
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-    }
-    toJsonRpcError() {
-        return { code: this.code, message: this.message };
-    }
-}