cursor-opencode-provider 0.6.4 → 0.6.6

package/dist/protocol/git-diff.js

@@ -0,0 +1,372 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+import { encodeMessage } from "./messages.js";
+const execFileAsync = promisify(execFile);
+/** aiserver.v1.GetDiffRequest.OutputFormat */
+export const GIT_DIFF_FORMAT_UNSPECIFIED = 0;
+export const GIT_DIFF_FORMAT_NAME_STATUS = 1;
+export const GIT_DIFF_FORMAT_NAME_STATUS_AND_NUMSTAT = 2;
+export const GIT_DIFF_FORMAT_FILE_DIFFS = 3;
+export const GIT_DIFF_FORMAT_DIFFS_WITH_BEFORE_AND_AFTER = 4;
+const DEFAULT_REMOTE_BRANCHES = ["main", "master", "develop"];
+const GIT_TIMEOUT_MS = 30_000;
+const GIT_MAX_BUFFER = 32 * 1024 * 1024;
+const GIT_ENV = {
+    ...process.env,
+    GIT_TERMINAL_PROMPT: "0",
+    GIT_OPTIONAL_LOCKS: "0",
+};
+function gitErrorMessage(error, fallback) {
+    if (!error || typeof error !== "object")
+        return fallback;
+    const err = error;
+    const stderr = typeof err.stderr === "string" ? err.stderr.trim() : "";
+    if (stderr)
+        return stderr.split("\n")[0] ?? stderr;
+    if (typeof err.message === "string" && err.message)
+        return err.message;
+    return fallback;
+}
+async function git(cwd, args, options) {
+    try {
+        const { stdout, stderr } = await execFileAsync("git", args, {
+            cwd,
+            encoding: "utf8",
+            timeout: GIT_TIMEOUT_MS,
+            maxBuffer: GIT_MAX_BUFFER,
+            env: GIT_ENV,
+        });
+        return {
+            stdout: options?.trim === false ? stdout : stdout.trimEnd(),
+            stderr: stderr ?? "",
+            code: 0,
+        };
+    }
+    catch (error) {
+        const err = error;
+        const code = typeof err.code === "number" ? err.code : 1;
+        if (options?.ignoreExit) {
+            return {
+                stdout: options.trim === false ? (err.stdout ?? "") : (err.stdout ?? "").trimEnd(),
+                stderr: err.stderr ?? "",
+                code,
+            };
+        }
+        throw new Error(gitErrorMessage(error, `git ${args.join(" ")} failed`));
+    }
+}
+function str(value) {
+    return typeof value === "string" ? value : "";
+}
+function num(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string" && value.trim() !== "" && Number.isFinite(Number(value))) {
+        return Number(value);
+    }
+    return undefined;
+}
+function resolveGitCwd(requestCwd, workspaceRoot) {
+    const root = path.resolve(workspaceRoot || process.cwd());
+    const requested = requestCwd.trim();
+    if (!requested)
+        return root;
+    return path.isAbsolute(requested) ? path.resolve(requested) : path.resolve(root, requested);
+}
+async function resolveDefaultBase(cwd) {
+    try {
+        const head = (await git(cwd, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"])).stdout.trim();
+        if (head)
+            return head;
+    }
+    catch {
+        /* try origin/<main|master|develop> */
+    }
+    for (const name of DEFAULT_REMOTE_BRANCHES) {
+        const ref = `origin/${name}`;
+        try {
+            await git(cwd, ["rev-parse", "--verify", ref]);
+            return ref;
+        }
+        catch {
+            /* next candidate */
+        }
+    }
+    try {
+        const remotes = (await git(cwd, ["branch", "-r"])).stdout.split("\n")
+            .map((line) => line.trim())
+            .find((line) => line.startsWith("origin/"));
+        if (remotes)
+            return remotes;
+    }
+    catch {
+        /* try init.defaultBranch */
+    }
+    try {
+        const configured = (await git(cwd, ["config", "--get", "init.defaultBranch"])).stdout.trim();
+        if (configured)
+            return configured;
+    }
+    catch {
+        /* no default */
+    }
+    throw new Error("Could not determine default branch");
+}
+function stripDiffPrefix(value) {
+    return value.replace(/^[abiwco12]\//, "");
+}
+function parseDiffGitPaths(line) {
+    if (!line.startsWith("diff --git "))
+        return undefined;
+    const rest = line.slice("diff --git ".length).trim();
+    const match = rest.match(/^(?:[abiwco12]\/)?(.+?) (?:[abiwco12]\/)?(.+)$/);
+    if (!match)
+        return undefined;
+    return { from: stripDiffPrefix(match[1]), to: stripDiffPrefix(match[2]) };
+}
+function parsePathHeader(line) {
+    const body = line.replace(/^(---|\+\+\+)\s+/, "");
+    const tab = body.indexOf("\t");
+    const raw = (tab >= 0 ? body.slice(0, tab) : body).trim().replace(/^["']|["']$/g, "");
+    if (raw === "/dev/null")
+        return "/dev/null";
+    return stripDiffPrefix(raw);
+}
+/** Parse `git diff --no-color` into aiserver.v1.FileDiff rows (CLI `Oc` / `FR`). */
+export function parseUnifiedDiff(text) {
+    if (!text || /^\s+$/.test(text))
+        return [];
+    const diffs = [];
+    let current;
+    let chunk;
+    let remainingOld = 0;
+    let remainingNew = 0;
+    let oldLine = 0;
+    let newLine = 0;
+    let inHunk = false;
+    const startFile = (from = "", to = "") => {
+        current = { from, to, chunks: [], added: 0, removed: 0 };
+        diffs.push(current);
+        chunk = undefined;
+        inHunk = false;
+    };
+    const ensureFile = () => {
+        if (!current)
+            startFile();
+    };
+    const appendNoNewline = (line) => {
+        if (!chunk || chunk.lines.length === 0)
+            return;
+        chunk.lines.push(line);
+    };
+    for (const line of text.split("\n")) {
+        if (inHunk && chunk && current) {
+            if (line === "\") {
+                appendNoNewline(line);
+                continue;
+            }
+            if (line.startsWith("-")) {
+                chunk.lines.push(line);
+                current.removed++;
+                oldLine++;
+                remainingOld--;
+            }
+            else if (line.startsWith("+")) {
+                chunk.lines.push(line);
+                current.added++;
+                newLine++;
+                remainingNew--;
+            }
+            else if (line.startsWith(" ") || line === "") {
+                chunk.lines.push(line.length === 0 ? " " : line);
+                oldLine++;
+                newLine++;
+                remainingOld--;
+                remainingNew--;
+            }
+            else {
+                inHunk = false;
+            }
+            if (inHunk && remainingOld <= 0 && remainingNew <= 0)
+                inHunk = false;
+            if (inHunk)
+                continue;
+        }
+        if (line.startsWith("diff --git ")) {
+            const paths = parseDiffGitPaths(line);
+            startFile(paths?.from ?? "", paths?.to ?? "");
+            continue;
+        }
+        if (line.startsWith("new file mode ")) {
+            ensureFile();
+            current.from = "/dev/null";
+            continue;
+        }
+        if (line.startsWith("deleted file mode ")) {
+            ensureFile();
+            current.to = "/dev/null";
+            continue;
+        }
+        if (line.startsWith("--- ")) {
+            ensureFile();
+            current.from = parsePathHeader(line);
+            continue;
+        }
+        if (line.startsWith("+++ ")) {
+            ensureFile();
+            current.to = parsePathHeader(line);
+            continue;
+        }
+        const hunk = /^@@\s+-(\d+),?(\d+)?\s+\+(\d+),?(\d+)?\s@@/.exec(line);
+        if (hunk) {
+            ensureFile();
+            oldLine = Number(hunk[1]);
+            newLine = Number(hunk[3]);
+            remainingOld = hunk[2] !== undefined ? Number(hunk[2]) : 1;
+            remainingNew = hunk[4] !== undefined ? Number(hunk[4]) : 1;
+            chunk = {
+                content: line,
+                lines: [],
+                old_start: Number(hunk[1]),
+                old_lines: remainingOld,
+                new_start: Number(hunk[3]),
+                new_lines: remainingNew,
+            };
+            current.chunks.push(chunk);
+            inHunk = true;
+        }
+    }
+    return diffs;
+}
+function effectiveFormat(raw) {
+    switch (raw) {
+        case GIT_DIFF_FORMAT_NAME_STATUS:
+        case GIT_DIFF_FORMAT_NAME_STATUS_AND_NUMSTAT:
+        case GIT_DIFF_FORMAT_FILE_DIFFS:
+        case GIT_DIFF_FORMAT_DIFFS_WITH_BEFORE_AND_AFTER:
+            return raw;
+        default:
+            return GIT_DIFF_FORMAT_FILE_DIFFS;
+    }
+}
+async function collectUntrackedDiffs(cwd, maxFiles) {
+    if (maxFiles <= 0)
+        return [];
+    const listed = (await git(cwd, ["ls-files", "--others", "--exclude-standard"])).stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .slice(0, maxFiles);
+    const extra = [];
+    for (const file of listed) {
+        const raw = await git(cwd, ["diff", "--no-color", "--no-index", "/dev/null", file], {
+            ignoreExit: true,
+            trim: false,
+        });
+        extra.push(...parseUnifiedDiff(raw.stdout));
+    }
+    return extra;
+}
+export async function executeGitDiff(request, workspaceRoot) {
+    const cwd = resolveGitCwd(str(request.cwd), workspaceRoot);
+    if (!fs.existsSync(cwd)) {
+        throw new Error(`git_diff cwd does not exist: ${cwd}`);
+    }
+    const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"]).catch((error) => {
+        throw new Error(gitErrorMessage(error, "not a git repository"));
+    });
+    if (inside.stdout.trim() !== "true") {
+        throw new Error("not a git repository");
+    }
+    const ref = str(request.ref);
+    let base = str(request.base_ref);
+    if (!base)
+        base = await resolveDefaultBase(cwd);
+    if (request.merge_base === true) {
+        base = (await git(cwd, ["merge-base", base, ref || "HEAD"])).stdout.trim();
+    }
+    const args = ["diff", "--no-color"];
+    if (request.include_space_changes !== true)
+        args.push("--ignore-space-change");
+    const contextLines = num(request.unified_context_lines);
+    if (contextLines !== undefined && contextLines > 0)
+        args.push(`-U${contextLines}`);
+    args.push(base);
+    if (ref)
+        args.push(ref);
+    const targetPaths = Array.isArray(request.target_paths)
+        ? request.target_paths.filter((item) => typeof item === "string" && item.length > 0)
+        : [];
+    if (targetPaths.length > 0) {
+        args.push("--");
+        args.push(...targetPaths);
+    }
+    const diffText = (await git(cwd, args, { trim: false })).stdout;
+    const diffs = parseUnifiedDiff(diffText);
+    diffs.push(...await collectUntrackedDiffs(cwd, num(request.max_untracked_files) ?? 0));
+    const format = effectiveFormat(num(request.output_format));
+    if (format !== GIT_DIFF_FORMAT_FILE_DIFFS && format !== GIT_DIFF_FORMAT_DIFFS_WITH_BEFORE_AND_AFTER) {
+        for (const diff of diffs)
+            diff.chunks = [];
+    }
+    const response = {
+        diff: {
+            diffs,
+            diff_type: 0,
+        },
+    };
+    if (request.return_head_sha === true) {
+        response.head_sha = (await git(cwd, ["rev-parse", "HEAD"])).stdout.trim();
+        const status = (await git(cwd, ["status", "--porcelain=v1", "--untracked-files=all"])).stdout.trim();
+        response.has_uncommitted_changes = status.length > 0;
+    }
+    return response;
+}
+function throwAndClose(execId, error) {
+    return [
+        encodeMessage("AgentClientMessage", {
+            exec_client_control_message: {
+                throw: { id: execId, error },
+            },
+        }),
+        encodeMessage("AgentClientMessage", {
+            exec_client_control_message: {
+                stream_close: { id: execId },
+            },
+        }),
+    ];
+}
+/**
+ * Answer exec #44. GetDiffResponse has no error oneof — failures use
+ * exec_client_control_message.throw, matching Cursor CLI `class Dc`.
+ */
+export async function buildGitDiffExecMessages(input) {
+    let response;
+    try {
+        response = await executeGitDiff(input.request, input.workspaceRoot);
+    }
+    catch (error) {
+        return throwAndClose(input.execId, error.message || "git_diff failed");
+    }
+    const responseBytes = encodeMessage("GetDiffResponse", response);
+    const maxBytes = num(input.request.max_response_bytes) ?? 0;
+    if (maxBytes > 0 && responseBytes.byteLength > maxBytes) {
+        return throwAndClose(input.execId, `GetDiffResponseTooLarge: ${responseBytes.byteLength} bytes exceeds the ${maxBytes} byte limit`);
+    }
+    return [
+        encodeMessage("AgentClientMessage", {
+            exec_client_message: {
+                id: input.execId,
+                local_execution_time_ms: 0,
+                git_diff_response: response,
+            },
+        }),
+        encodeMessage("AgentClientMessage", {
+            exec_client_control_message: {
+                stream_close: { id: input.execId },
+            },
+        }),
+    ];
+}

package/dist/protocol/messages.js

@@ -653,6 +653,199 @@ export function createMessageTypes() {
         { id: 2, name: "working_directory", type: "string" },
         { id: 3, name: "error", type: "string" },
     ]);
+    // ── Soft-deny stubs for known unsupported Cursor-native exec variants ──
+    // These are encode-only: enough to emit a populated deny, not full success.
+    // Canonical field numbers from agent.proto ExecClientMessage.
+    // ShellResult is also the live reply for exec #2 shell_args (OpenCode bash).
+    addType(root, "ShellSuccess", [
+        { id: 1, name: "command", type: "string" },
+        { id: 2, name: "working_directory", type: "string" },
+        { id: 3, name: "exit_code", type: "int32" },
+        { id: 4, name: "signal", type: "string" },
+        { id: 5, name: "stdout", type: "string" },
+        { id: 6, name: "stderr", type: "string" },
+        { id: 7, name: "execution_time", type: "int32" },
+        { id: 9, name: "shell_id", type: "uint32" },
+        { id: 11, name: "pid", type: "uint32" },
+        { id: 12, name: "ms_to_wait", type: "int32" },
+        { id: 13, name: "local_execution_time_ms", type: "int32" },
+        { id: 14, name: "background_reason", type: "uint32" },
+    ]);
+    addType(root, "ShellFailure", [
+        { id: 1, name: "command", type: "string" },
+        { id: 2, name: "working_directory", type: "string" },
+        { id: 3, name: "exit_code", type: "int32" },
+        { id: 4, name: "signal", type: "string" },
+        { id: 5, name: "stdout", type: "string" },
+        { id: 6, name: "stderr", type: "string" },
+        { id: 7, name: "execution_time", type: "int32" },
+        { id: 10, name: "abort_reason", type: "uint32" },
+        { id: 11, name: "aborted", type: "bool" },
+    ]);
+    addType(root, "ShellTimeout", [
+        { id: 1, name: "command", type: "string" },
+        { id: 2, name: "working_directory", type: "string" },
+        { id: 3, name: "timeout_ms", type: "int32" },
+    ]);
+    addType(root, "ShellResult", [
+        { id: 1, name: "success", type: "ShellSuccess" },
+        { id: 2, name: "failure", type: "ShellFailure" },
+        { id: 3, name: "timeout", type: "ShellTimeout" },
+        { id: 4, name: "rejected", type: "ShellRejected" },
+        { id: 102, name: "is_background", type: "bool" },
+        { id: 104, name: "pid", type: "uint32" },
+    ], [{ name: "result", fields: ["success", "failure", "timeout", "rejected"] }]);
+    addType(root, "DiagnosticsError", [
+        { id: 1, name: "path", type: "string" },
+        { id: 2, name: "error", type: "string" },
+    ]);
+    addType(root, "DiagnosticsResult", [
+        { id: 2, name: "error", type: "DiagnosticsError" },
+    ], [{ name: "result", fields: ["error"] }]);
+    addType(root, "FetchError", [
+        { id: 1, name: "url", type: "string" },
+        { id: 2, name: "error", type: "string" },
+    ]);
+    addType(root, "FetchResult", [
+        { id: 2, name: "error", type: "FetchError" },
+    ], [{ name: "result", fields: ["error"] }]);
+    addType(root, "RecordScreenFailure", [
+        { id: 1, name: "error", type: "string" },
+    ]);
+    addType(root, "RecordScreenResult", [
+        { id: 4, name: "failure", type: "RecordScreenFailure" },
+    ], [{ name: "result", fields: ["failure"] }]);
+    addType(root, "ComputerUseError", [
+        { id: 1, name: "error", type: "string" },
+    ]);
+    addType(root, "ComputerUseResult", [
+        { id: 2, name: "error", type: "ComputerUseError" },
+    ], [{ name: "result", fields: ["error"] }]);
+    addType(root, "WriteShellStdinError", [
+        { id: 1, name: "error", type: "string" },
+    ]);
+    addType(root, "WriteShellStdinResult", [
+        { id: 2, name: "error", type: "WriteShellStdinError" },
+    ], [{ name: "result", fields: ["error"] }]);
+    addType(root, "SubagentAwaitError", [
+        { id: 1, name: "agent_id", type: "string" },
+        { id: 2, name: "error", type: "string" },
+    ]);
+    addType(root, "SubagentAwaitResult", [
+        { id: 4, name: "error", type: "SubagentAwaitError" },
+    ], [{ name: "result", fields: ["error"] }]);
+    addType(root, "SmartModeClassifierError", [
+        { id: 1, name: "error", type: "string" },
+    ]);
+    addType(root, "SmartModeClassifierResult", [
+        { id: 2, name: "error", type: "SmartModeClassifierError" },
+    ], [{ name: "result", fields: ["error"] }]);
+    addType(root, "CanvasDiagnosticsError", [
+        { id: 1, name: "path", type: "string" },
+        { id: 2, name: "error", type: "string" },
+    ]);
+    addType(root, "CanvasDiagnosticsResult", [
+        { id: 2, name: "error", type: "CanvasDiagnosticsError" },
+    ], [{ name: "result", fields: ["error"] }]);
+    addType(root, "ShellAllowlistPrecheckResult", [
+        { id: 1, name: "allowlisted", type: "bool" },
+    ]);
+    addType(root, "McpAllowlistPrecheckResult", [
+        { id: 1, name: "allowlisted", type: "bool" },
+    ]);
+    addType(root, "WebFetchAllowlistPrecheckResult", [
+        { id: 1, name: "allowlisted", type: "bool" },
+    ]);
+    addType(root, "ForceBackgroundShellResult", [
+        { id: 1, name: "status", type: "uint32" },
+    ]);
+    addType(root, "ForceBackgroundSubagentResult", [
+        { id: 1, name: "status", type: "uint32" },
+    ]);
+    addType(root, "ConversationSearchHit", [
+        { id: 1, name: "conversation_id", type: "string" },
+        { id: 2, name: "title", type: "string" },
+        { id: 3, name: "source", type: "uint32" },
+        { id: 4, name: "updated_at_ms", type: "int64" },
+        { id: 5, name: "snippet", type: "string" },
+    ]);
+    addType(root, "ConversationSearchSuccess", [
+        { id: 1, name: "hits", type: "ConversationSearchHit", repeated: true },
+        { id: 2, name: "truncated", type: "bool" },
+        { id: 3, name: "partial", type: "bool" },
+        { id: 4, name: "rebuilding", type: "bool" },
+    ]);
+    addType(root, "ConversationSearchError", [
+        { id: 1, name: "error", type: "string" },
+    ]);
+    addType(root, "ConversationSearchResult", [
+        { id: 1, name: "success", type: "ConversationSearchSuccess" },
+        { id: 2, name: "error", type: "ConversationSearchError" },
+    ], [{ name: "result", fields: ["success", "error"] }]);
+    addType(root, "AgentStoreConflictError", [
+        { id: 1, name: "error", type: "string" },
+    ]);
+    addType(root, "AgentStoreConflictResult", [
+        { id: 2, name: "error", type: "AgentStoreConflictError" },
+    ], [{ name: "result", fields: ["error"] }]);
+    addType(root, "AdoptResult", [
+        { id: 1, name: "source_agent_id", type: "string" },
+        { id: 2, name: "target_agent_id", type: "string" },
+        { id: 3, name: "project_root_id", type: "string" },
+        { id: 5, name: "error", type: "string" },
+    ], [{ name: "result", fields: ["error"] }]);
+    // aiserver.v1.GetDiffRequest / GetDiffResponse (exec #44). Enums as uint32
+    // so protobufjs json decode does not stringify output_format / diff_type.
+    addType(root, "GitDiffChunk", [
+        { id: 1, name: "content", type: "string" },
+        { id: 2, name: "lines", type: "string", repeated: true },
+        { id: 3, name: "old_start", type: "int32" },
+        { id: 4, name: "old_lines", type: "int32" },
+        { id: 5, name: "new_start", type: "int32" },
+        { id: 6, name: "new_lines", type: "int32" },
+    ]);
+    addType(root, "GitFileDiff", [
+        { id: 1, name: "from", type: "string" },
+        { id: 2, name: "to", type: "string" },
+        { id: 3, name: "chunks", type: "GitDiffChunk", repeated: true },
+        { id: 4, name: "added", type: "int32" },
+        { id: 5, name: "removed", type: "int32" },
+        { id: 6, name: "before_file_contents", type: "string" },
+        { id: 7, name: "after_file_contents", type: "string" },
+        { id: 8, name: "is_generated", type: "bool" },
+    ]);
+    addType(root, "GitDiff", [
+        { id: 1, name: "diffs", type: "GitFileDiff", repeated: true },
+        { id: 2, name: "diff_type", type: "uint32" },
+    ]);
+    addType(root, "GitDiffSubmoduleDiff", [
+        { id: 1, name: "relative_path", type: "string" },
+        { id: 2, name: "diff", type: "GitDiff" },
+        { id: 3, name: "errored", type: "bool" },
+    ]);
+    addType(root, "GetDiffRequest", [
+        { id: 1, name: "cwd", type: "string" },
+        { id: 2, name: "ref", type: "string" },
+        { id: 3, name: "base_ref", type: "string" },
+        { id: 4, name: "merge_base", type: "bool" },
+        { id: 5, name: "target_paths", type: "string", repeated: true },
+        { id: 6, name: "unified_context_lines", type: "int32" },
+        { id: 7, name: "max_untracked_files", type: "int32" },
+        { id: 8, name: "output_format", type: "uint32" },
+        { id: 9, name: "submodule_recurse_depth", type: "int32" },
+        { id: 10, name: "include_space_changes", type: "bool" },
+        { id: 11, name: "committed_only", type: "bool" },
+        { id: 12, name: "compute_patch_id", type: "bool" },
+        { id: 13, name: "return_head_sha", type: "bool" },
+        { id: 14, name: "max_response_bytes", type: "int32" },
+    ]);
+    addType(root, "GetDiffResponse", [
+        { id: 1, name: "diff", type: "GitDiff" },
+        { id: 2, name: "submodule_diffs", type: "GitDiffSubmoduleDiff", repeated: true },
+        { id: 3, name: "patch_id", type: "string" },
+        { id: 4, name: "head_sha", type: "string" },
+        { id: 5, name: "has_uncommitted_changes", type: "bool" },
+    ]);
     // Cursor's non-blocking shell path is a separate exec variant from the
     // foreground ShellStream above. The host only needs the fields used at the
     // OpenCode boundary; protobufjs safely skips the richer classifier/approval
@@ -965,6 +1158,7 @@ export function createMessageTypes() {
         { id: 1, name: "id", type: "uint32" },
         { id: 15, name: "exec_id", type: "string" },
         { id: 19, name: "span", type: "string" },
+        { id: 2, name: "shell_args", type: "ShellArgs" },
         { id: 3, name: "write_args", type: "WriteArgs" },
         { id: 4, name: "delete_args", type: "DeleteArgs" },
         { id: 5, name: "grep_args", type: "GrepArgs" },
@@ -978,6 +1172,7 @@ export function createMessageTypes() {
         { id: 18, name: "read_mcp_resource_exec_args", type: "ReadMcpResourceExecArgs" },
         { id: 28, name: "subagent_args", type: "SubagentArgs" },
         { id: 36, name: "mcp_state_exec_args", type: "McpStateExecArgs" },
+        { id: 44, name: "git_diff_request", type: "GetDiffRequest" },
         { id: 45, name: "pi_read_args", type: "PiReadToolArgs" },
         { id: 46, name: "pi_bash_args", type: "PiBashToolArgs" },
         { id: 47, name: "pi_edit_args", type: "PiEditToolArgs" },
@@ -986,10 +1181,10 @@ export function createMessageTypes() {
         { id: 50, name: "pi_find_args", type: "PiFindToolArgs" },
         { id: 51, name: "pi_ls_args", type: "PiLsToolArgs" },
     ], [{ name: "args", fields: [
-                "write_args", "delete_args", "grep_args", "read_args", "ls_args",
+                "shell_args", "write_args", "delete_args", "grep_args", "read_args", "ls_args",
                 "request_context_args", "mcp_args", "shell_stream_args", "background_shell_spawn_args",
                 "list_mcp_resources_exec_args", "read_mcp_resource_exec_args", "mcp_state_exec_args",
-                "subagent_args",
+                "subagent_args", "git_diff_request",
                 "pi_read_args", "pi_bash_args", "pi_edit_args", "pi_write_args",
                 "pi_grep_args", "pi_find_args", "pi_ls_args",
             ] }]);
@@ -998,19 +1193,35 @@ export function createMessageTypes() {
         { id: 1, name: "id", type: "uint32" },
         { id: 15, name: "exec_id", type: "string" },
         { id: 39, name: "local_execution_time_ms", type: "uint64" },
+        { id: 2, name: "shell_result", type: "ShellResult" },
         { id: 3, name: "write_result", type: "WriteResult" },
         { id: 4, name: "delete_result", type: "DeleteResult" },
         { id: 5, name: "grep_result", type: "GrepResult" },
         { id: 7, name: "read_result", type: "ReadResult" },
         { id: 8, name: "ls_result", type: "LsResult" },
+        { id: 9, name: "diagnostics_result", type: "DiagnosticsResult" },
         { id: 10, name: "request_context_result", type: "RequestContextResult" },
         { id: 11, name: "mcp_result", type: "McpResult" },
         { id: 14, name: "shell_stream", type: "ShellStream" },
         { id: 16, name: "background_shell_spawn_result", type: "BackgroundShellSpawnResult" },
         { id: 17, name: "list_mcp_resources_exec_result", type: "ListMcpResourcesExecResult" },
         { id: 18, name: "read_mcp_resource_exec_result", type: "ReadMcpResourceExecResult" },
+        { id: 20, name: "fetch_result", type: "FetchResult" },
+        { id: 21, name: "record_screen_result", type: "RecordScreenResult" },
+        { id: 22, name: "computer_use_result", type: "ComputerUseResult" },
+        { id: 23, name: "write_shell_stdin_result", type: "WriteShellStdinResult" },
         { id: 28, name: "subagent_result", type: "SubagentResult" },
+        { id: 29, name: "redacted_read_result", type: "ReadResult" },
+        { id: 30, name: "force_background_shell_result", type: "ForceBackgroundShellResult" },
+        { id: 31, name: "force_background_subagent_result", type: "ForceBackgroundSubagentResult" },
         { id: 36, name: "mcp_state_exec_result", type: "McpStateExecResult" },
+        { id: 37, name: "subagent_await_result", type: "SubagentAwaitResult" },
+        { id: 38, name: "smart_mode_classifier_result", type: "SmartModeClassifierResult" },
+        { id: 40, name: "canvas_diagnostics_result", type: "CanvasDiagnosticsResult" },
+        { id: 41, name: "shell_allowlist_precheck_result", type: "ShellAllowlistPrecheckResult" },
+        { id: 42, name: "mcp_allowlist_precheck_result", type: "McpAllowlistPrecheckResult" },
+        { id: 43, name: "web_fetch_allowlist_precheck_result", type: "WebFetchAllowlistPrecheckResult" },
+        { id: 44, name: "git_diff_response", type: "GetDiffResponse" },
         { id: 46, name: "pi_read_result", type: "PiReadExecResult" },
         { id: 47, name: "pi_bash_result", type: "PiBashExecResult" },
         { id: 48, name: "pi_edit_result", type: "PiEditExecResult" },
@@ -1018,13 +1229,25 @@ export function createMessageTypes() {
         { id: 50, name: "pi_grep_result", type: "PiGrepExecResult" },
         { id: 51, name: "pi_find_result", type: "PiFindExecResult" },
         { id: 52, name: "pi_ls_result", type: "PiLsExecResult" },
+        { id: 53, name: "conversation_search_result", type: "ConversationSearchResult" },
+        { id: 54, name: "agent_store_conflict_result", type: "AgentStoreConflictResult" },
+        { id: 55, name: "mini_swe_agent_bash_result", type: "ShellResult" },
+        { id: 56, name: "adopt_result", type: "AdoptResult" },
     ], [{ name: "result", fields: [
-                "write_result", "delete_result", "grep_result", "read_result", "ls_result",
-                "request_context_result", "mcp_result", "shell_stream", "background_shell_spawn_result",
-                "list_mcp_resources_exec_result", "read_mcp_resource_exec_result", "mcp_state_exec_result",
-                "subagent_result",
+                "shell_result", "write_result", "delete_result", "grep_result", "read_result", "ls_result",
+                "diagnostics_result", "request_context_result", "mcp_result", "shell_stream", "background_shell_spawn_result",
+                "list_mcp_resources_exec_result", "read_mcp_resource_exec_result",
+                "fetch_result", "record_screen_result", "computer_use_result", "write_shell_stdin_result",
+                "subagent_result", "redacted_read_result",
+                "force_background_shell_result", "force_background_subagent_result",
+                "mcp_state_exec_result",
+                "subagent_await_result", "smart_mode_classifier_result", "canvas_diagnostics_result",
+                "shell_allowlist_precheck_result", "mcp_allowlist_precheck_result", "web_fetch_allowlist_precheck_result",
+                "git_diff_response",
                 "pi_read_result", "pi_bash_result", "pi_edit_result", "pi_write_result",
                 "pi_grep_result", "pi_find_result", "pi_ls_result",
+                "conversation_search_result", "agent_store_conflict_result",
+                "mini_swe_agent_bash_result", "adopt_result",
             ] }]);
     addType(root, "ExecServerControlMessage", [
         { id: 1, name: "abort", type: "ExecServerAbort" },