vibe-coding-master 0.0.6 → 0.0.8

package/README.md

@@ -2,41 +2,32 @@
 
 VibeCodingMaster is a local GUI workspace for managing multiple Claude Code role sessions around one engineering task.
 
-It is designed for long-running coding work where one Claude Code conversation is not enough. VCM gives the user a task workspace with four role sessions:
+VCM is designed for long-running coding work where one Claude Code conversation is not enough. It gives the user a task workspace with four embedded Claude Code sessions:
 
 - `project-manager`
 - `architect`
 - `coder`
 - `reviewer`
 
-Each role runs as a real Claude Code process inside an embedded terminal. The GUI lets the user start, stop, resume, switch, inspect, and manually intervene in those sessions without juggling several terminal windows.
+Each role runs as a real Claude Code process inside an embedded terminal. The GUI lets the user start, stop, resume, restart, switch, observe, and manually intervene in those sessions without juggling separate terminal windows.
 
-## What It Does
-
-```text
-Open local GUI
-  -> connect a Git repository
-  -> create a task
-  -> start Claude Code role sessions
-  -> talk to Claude Code through embedded terminals
-  -> let project-manager coordinate architect / coder / reviewer
-  -> approve or automate role-to-role messages
-  -> resume interrupted role sessions later
-```
-
-Current V1 capabilities:
+## Current V1 Capabilities
 
 - GUI-first task workspace.
-- Embedded Claude Code terminals powered by `node-pty`.
-- One Claude Code session per role.
-- Role session recovery with persisted Claude session ids and `claude --resume`.
-- Permission mode selection before start/restart:
-  - default
+- Collapsible sidebar with repository connection, workflow, settings, harness status, task creation, and task list.
+- Recent repository path dropdown, stored locally with the five most recent paths.
+- Embedded Claude Code terminals powered by `node-pty` and `xterm.js`.
+- One Claude Code session per role, with role tabs in the task header.
+- Role session recovery through persisted Claude session ids and `claude --resume`.
+- Permission mode selection before start, resume, or restart:
+  - `default`
   - `bypassPermissions`
   - `--dangerously-skip-permissions`
 - PM-mediated role messaging through `vcmctl`.
 - Manual and automatic orchestration modes.
-- Durable task state, session state, raw logs, handoff artifacts, and message history.
+- VCM harness installer for `CLAUDE.md`, `.claude/agents/*.md`, and the VCM-managed `.gitignore` block.
+- Translation panel powered by an OpenAI-compatible low-cost model.
+- Durable task state, session state, raw terminal logs, handoff artifacts, and message history.
 
 ## Requirements
 
@@ -56,20 +47,16 @@ From npm:
 
 ```bash
 npm install -g vibe-coding-master
-```
-
-Then start the packaged app:
-
-```bash
 vcm
 ```
 
-The published package also installs `vcmctl`, which Claude Code role sessions use internally for VCM message bus commands.
+The package also installs `vcmctl`, which Claude Code role sessions use internally to send VCM messages.
 
 From source:
 
 ```bash
 npm install
+npm run dev
 ```
 
 ## Run Locally
@@ -107,7 +94,7 @@ Then open:
 http://127.0.0.1:4173/
 ```
 
-If installed globally from npm, `vcm` runs the production-style app and serves the GUI from the backend port:
+The global `vcm` command runs the production-style app and serves the GUI from the backend port:
 
 ```text
 http://127.0.0.1:4173/
@@ -115,7 +102,7 @@ http://127.0.0.1:4173/
 
 ## Run In VS Code Dev Containers
 
-VCM works well inside a VS Code `devContainer` as long as VCM, Claude Code, and the target repository are all inside the same container filesystem.
+VCM works inside a VS Code `devContainer` when VCM, Claude Code, and the target repository all run inside the same container filesystem.
 
 Add port forwarding to `.devcontainer/devcontainer.json`:
 
@@ -133,39 +120,141 @@ Add port forwarding to `.devcontainer/devcontainer.json`:
 }
 ```
 
-Use:
-
-```bash
-npm install
-npm run dev
-```
-
-Open the forwarded `5173` port for development mode. If you run `npm run build && npm start`, only `4173` is required.
+Use the path as seen from inside the container, for example `/workspace`.
 
 Important container notes:
 
-- Install Claude Code inside the container, or make the `claude` command available in the container PATH.
+- Install Claude Code inside the container, or make `claude` available in the container `PATH`.
 - Make sure Claude Code authentication works inside the container.
-- Make sure the container has network access to Claude services.
-- Use the path as seen from inside the container, for example `/workspace`.
-- VCM accepts normal repositories by checking `/workspace/.git` directly; it does not require global Git `safe.directory` config to connect.
-- Keep the user project, `.vcm`, and `.ai/handoffs` on the same mounted workspace so paths are consistent.
+- Make sure the container has network access to Claude services and to the translation provider if translation is enabled.
+- VCM accepts normal Git repositories by checking `.git` directly. It also supports `.git` files that point to worktree gitdirs.
+- VCM uses per-command `git -c safe.directory=...` for Git metadata reads and does not require global `git config --global --add safe.directory`.
 - Treat the container as the sandbox boundary, especially when using relaxed Claude Code permission modes.
 
 ## Basic Usage
 
 1. Start VCM.
 2. Open the GUI.
-3. Connect a Git repository.
-4. Create a task.
-5. Select a role tab.
-6. Choose the Claude Code permission mode for that role.
-7. Click `Start`.
-8. Talk to `project-manager` first.
-9. Let PM delegate to `architect`, `coder`, or `reviewer`.
-10. Inspect and approve role messages in the `Messages` panel.
+3. In the sidebar, open `Repository Path`, enter a repository path or choose one from `Recent`, then click `Connect`.
+4. Review `VCM Harness`; if files need install/update, click `Install / Update`.
+5. Review any changed harness files and commit them if they look right.
+6. Create a task from `New Task` with a single task name.
+7. Select the task from `Tasks`.
+8. Use the role tabs in the task header to switch between `Project Manager`, `Architect`, `Coder`, and `Reviewer`.
+9. Choose the permission mode for the active role.
+10. Click `Start`, `Resume`, `Restart`, or `Stop` as needed.
+11. Talk mostly to `project-manager`; let PM coordinate the other roles through VCM messaging.
+
+The recommended flow is:
+
+```text
+project-manager
+  -> architect architecture plan
+  -> coder implementation and validation
+  -> reviewer independent review
+  -> architect docs sync / architecture drift check
+  -> project-manager final acceptance, commit, and PR
+```
+
+The workflow status is shown in the sidebar `Workflow` section. It is a soft guide in V1: VCM highlights missing or incomplete handoff artifacts and suggests the next step, but it does not hard-block the user from manually starting or switching roles.
+
+## Task Worktree Management
 
-The recommended flow is to mostly talk to `project-manager`. The PM role should coordinate the other roles through VCM messaging instead of asking the user to copy prompts between terminals.
+VCM uses task-level worktree management:
+
+```text
+one task = one branch + one git worktree + one handoff directory + one role-session set
+```
+
+The default when creating a task:
+
+- task name: `<task>`
+- branch: `feature/<task>`
+- worktree path: `.ai/vcm/worktrees/<task>` inside the connected base repository
+- role session cwd: that task worktree
+
+VCM will not create worktrees per role. `project-manager`, `architect`, `coder`, and `reviewer` for the same task share the same task worktree.
+
+VCM will not offer a separate `Create task worktree` button after a task exists, and a task should not be switched to another branch/worktree after creation.
+
+Because worktrees live under `.ai/vcm/worktrees/`, the connected repository must ignore `.ai/vcm/`. Apply the VCM Harness before creating tasks so `.gitignore` contains the managed ignore block. The base repository must also be clean because the task branch/worktree is created from the connected repo's current `HEAD`.
+
+When a task is complete, VCM provides a guarded cleanup action that removes the task worktree and VCM task metadata. Cleanup refuses to remove a dirty task worktree unless a force cleanup is requested through the API. Branch deletion stays separate and requires explicit confirmation.
+
+## Sidebar UI
+
+The left sidebar is intentionally compact and collapsible:
+
+- `Repository Path`: path input on one row; `Recent` and `Connect` on the next row.
+- `Repository`: connected path, branch, and working tree state. `Working tree: uncommitted changes` means `git status --porcelain` is not empty.
+- `Workflow`: current soft gate and five workflow steps.
+- `Settings`: `Messages`, `Events`, and the `Auto orchestration` on/off toggle.
+- `VCM Harness`: status for `CLAUDE.md`, role agent files, and `.gitignore`.
+- `New Task`: one `task name` input.
+- `Tasks`: task list and task status.
+
+All sidebar sections are collapsed by default. When no task is selected, `Repository Path` opens by default.
+
+## Translation
+
+The `Translate` button in the role toolbar opens a translation panel beside the embedded terminal. The terminal and translation panel split the available width evenly.
+
+Translation settings are local and stored in:
+
+```text
+~/.vcm/settings.json
+```
+
+The same file stores recent repository paths. The translation API key is stored locally under `translation.secrets.apiKey`; it is not written to the connected repository, `.ai/handoffs`, raw terminal logs, or git diffs.
+
+Translation behavior:
+
+- Provider type is OpenAI-compatible chat completions.
+- Prompt slots are `zh-to-en`, `zh-to-en-with-context`, and `en-to-zh`.
+- The settings modal shows default prompts and allows per-slot overrides.
+- Claude Code output translation reads semantic Claude transcript JSONL files under `~/.claude/projects`, not raw PTY output.
+- Assistant prose is shown as English source while translating, then replaced by the translated Chinese result.
+- Tool calls and tool results are preserved as dim one-line rows such as `● Bash({"command":"npm test"})`.
+- User input uses one textarea. Press `Enter` to translate or send the current English draft; press `Shift+Enter` for a newline.
+- After user input is translated, the English draft replaces the original text in the same textarea.
+- `Send English` writes the current English draft to the active embedded terminal and submits it.
+- The translation panel `Auto-send` toggle sends the translated draft automatically when translation succeeds without warnings.
+
+## Project Harness
+
+VCM works best when the connected repository contains VCM collaboration rules as normal project files. On first connect, VCM checks:
+
+```text
+CLAUDE.md
+.gitignore
+.claude/agents/project-manager.md
+.claude/agents/architect.md
+.claude/agents/coder.md
+.claude/agents/reviewer.md
+```
+
+If a file is missing, VCM can create a recommended default. If a file already exists, VCM preserves user-authored content and only inserts or replaces a managed block:
+
+```md
+<!-- VCM:BEGIN version=1 -->
+VCM-managed rules live here.
+<!-- VCM:END -->
+```
+
+For `.gitignore`, VCM uses a gitignore-native managed block:
+
+```gitignore
+# VCM:BEGIN version=1
+.ai/vcm/
+.vcm/
+# VCM:END
+```
+
+`.ai/vcm/` is the active VCM local control area. `.vcm/` is ignored only as a legacy safety rule so older local state cannot be accidentally committed during migration.
+
+After applying harness changes, VCM reports the exact files changed and reminds the user to review and commit them before starting long-running work.
+
+Role sessions learn VCM rules from `CLAUDE.md` and `.claude/agents/*.md`. VCM does not paste a long context block into the terminal at session start.
 
 ## Message Bus
 
@@ -175,9 +264,9 @@ Role communication works like this:
 
 ```text
 Claude Code role
-  -> runs vcmctl send / vcmctl reply
+  -> runs vcmctl send / vcmctl reply / vcmctl result
   -> vcmctl calls VCM backend API
-  -> backend validates policy and persists the message
+  -> backend validates message policy and persists the message
   -> backend writes to the target embedded terminal when allowed
 ```
 
@@ -190,26 +279,28 @@ vcmctl result --body-file /tmp/result.md --artifact .ai/handoffs/task/implementa
 vcmctl inbox
 ```
 
-Files are still used for durability and auditability:
+Durable message and handoff files:
 
 ```text
-.vcm/messages/<task>.jsonl
-.vcm/orchestration/<task>.json
+.ai/vcm/messages/<task>.jsonl
+.ai/vcm/orchestration/<task>.json
 .ai/handoffs/<task>/messages/<message-id>.md
 .ai/handoffs/<task>/role-commands/
 .ai/handoffs/<task>/logs/
 ```
 
+The backend also keeps a compatibility role-command dispatch endpoint, but the primary workflow is PM-mediated `vcmctl` messaging.
+
 ## Orchestration Modes
 
-VCM has a task-level `Auto orchestration` switch.
+VCM has a task-level `Auto orchestration` switch in the sidebar `Settings` section.
 
 When it is off, VCM is in manual mode:
 
 - Roles may send messages through `vcmctl`.
-- Messages appear in the GUI.
+- Messages appear in the `Messages` modal.
 - The user can inspect them.
-- Clicking `Stage` writes the message prompt into the target embedded terminal input line.
+- Clicking `Stage` writes a prompt into the target embedded terminal input line.
 - VCM does not press Enter for the user.
 
 When it is on, VCM is in auto mode:
@@ -217,13 +308,62 @@ When it is on, VCM is in auto mode:
 - Backend policy still applies.
 - PM can send work to `architect`, `coder`, or `reviewer`.
 - Non-PM roles can reply only to `project-manager`.
-- If the target role session is running and orchestration is not paused, VCM can deliver the message directly to the target terminal.
+- If the target role session is running, VCM writes a `[VCM MESSAGE]` envelope to the target terminal and submits it.
 
-High-risk work should still stop for human review.
+The backend state model still contains a `paused` field for compatibility with existing API routes, but the current GUI exposes only a single on/off orchestration toggle.
 
 ## Resume Behavior
 
-Each role session stores a Claude session id under `.vcm/sessions`. If VCM exits or a task is interrupted, reopen the task and use `Resume` for the role. VCM starts Claude Code with `claude --resume <session-id>` where supported by Claude Code.
+Each role session stores its Claude session id and transcript path under:
+
+```text
+.ai/vcm/sessions/<task>.json
+```
+
+Session buttons behave as follows:
+
+- `Start`: creates a fresh UUID, builds `claude --agent <role> --session-id <uuid>`, and stores the transcript path.
+- `Resume`: reuses the persisted Claude session id and builds `claude --agent <role> --resume <uuid>`.
+- `Restart`: stops the current process if needed, creates a new UUID, and starts a fresh Claude session.
+- `Stop`: stops the embedded terminal process and leaves the persisted Claude session id resumable.
+
+## Local Project Files
+
+For a connected repository, VCM uses:
+
+```text
+.ai/vcm/config.json
+.ai/vcm/tasks/<task>.json
+.ai/vcm/sessions/<task>.json
+.ai/vcm/messages/<task>.jsonl
+.ai/vcm/orchestration/<task>.json
+.ai/vcm/worktrees/<task>/
+.ai/handoffs/<task>/architecture-plan.md
+.ai/handoffs/<task>/implementation-log.md
+.ai/handoffs/<task>/validation-log.md
+.ai/handoffs/<task>/review-report.md
+.ai/handoffs/<task>/docs-sync-report.md
+.ai/handoffs/<task>/role-commands/{architect,coder,reviewer}.md
+.ai/handoffs/<task>/logs/{project-manager,architect,coder,reviewer}.log
+```
+
+## Packaging
+
+The npm package publishes built output, not raw TypeScript entry files. `package.json` includes:
+
+- `bin.vcm`: `dist/main.js`
+- `bin.vcmctl`: `dist/cli/vcmctl.js`
+- `files`: `dist`, `dist-frontend`, `docs`, `scripts`, `README.md`
+- `prepack`: `npm run build && npm run verify:package`
+
+Use this before publishing:
+
+```bash
+npm run typecheck
+npm test
+npm run build
+npm run verify:package
+```
 
 ## Validation
 
@@ -237,9 +377,10 @@ npm run build
 
 - VCM does not use tmux.
 - VCM does not auto-confirm Claude Code permission prompts.
-- VCM does not deeply parse Claude Code output.
 - VCM does not isolate roles with separate worktrees in V1.
-- File writes still happen in the connected repository environment.
+- VCM does not translate Claude output from raw PTY output; translation reads Claude transcript JSONL files.
+- VCM does not write translation output into handoff artifacts unless a user or role explicitly copies it there.
+- Role file writes happen in the task worktree when a task has a worktree.
 - The safest sandbox today is a container or VM boundary controlled by the user.
 
 See also:
@@ -247,4 +388,4 @@ See also:
 - `docs/product-design.md`
 - `docs/v1-architecture-design.md`
 - `docs/v1-implementation-plan.md`
-- `docs/v1-message-bus-orchestration-design.md`
+- `docs/cc-best-practices.md`

package/dist/backend/adapters/filesystem.js

@@ -46,6 +46,19 @@ export function createNodeFileSystemAdapter() {
             }
             await this.writeText(targetPath, content);
             return true;
+        },
+        async copyDir(sourcePath, targetPath) {
+            await fs.cp(sourcePath, targetPath, {
+                recursive: true,
+                force: false,
+                errorOnExist: false
+            });
+        },
+        async removePath(targetPath, options = {}) {
+            await fs.rm(targetPath, {
+                recursive: options.recursive ?? false,
+                force: options.force ?? false
+            });
         }
     };
 }

package/dist/backend/adapters/git-adapter.js

@@ -22,6 +22,9 @@ export function createGitAdapter(runner) {
             return result.stdout.trim() || "detached";
         },
         async isDirty(repoRoot) {
+            return (await this.getStatusPorcelain(repoRoot)).trim().length > 0;
+        },
+        async getStatusPorcelain(repoRoot) {
             const result = await runGit(runner, repoRoot, ["status", "--porcelain"]);
             if (result.exitCode !== 0) {
                 throw new VcmError({
@@ -31,7 +34,82 @@ export function createGitAdapter(runner) {
                     hint: result.stderr
                 });
             }
-            return result.stdout.trim().length > 0;
+            return result.stdout;
+        },
+        async isIgnored(repoRoot, repoRelativePath) {
+            const result = await runGit(runner, repoRoot, ["check-ignore", "-q", "--", repoRelativePath]);
+            if (result.exitCode === 0) {
+                return true;
+            }
+            if (result.exitCode === 1) {
+                return false;
+            }
+            throw new VcmError({
+                code: "GIT_ERROR",
+                message: `Unable to check whether Git ignores ${repoRelativePath}.`,
+                statusCode: 400,
+                hint: result.stderr
+            });
+        },
+        async branchExists(repoRoot, branch) {
+            const result = await runGit(runner, repoRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`]);
+            if (result.exitCode === 0) {
+                return true;
+            }
+            if (result.exitCode === 1) {
+                return false;
+            }
+            throw new VcmError({
+                code: "GIT_ERROR",
+                message: `Unable to check Git branch: ${branch}`,
+                statusCode: 400,
+                hint: result.stderr
+            });
+        },
+        async createWorktree(input) {
+            const result = await runGit(runner, input.repoRoot, [
+                "worktree",
+                "add",
+                "-b",
+                input.branch,
+                input.worktreePath,
+                input.baseRef ?? "HEAD"
+            ]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_WORKTREE_CREATE_FAILED",
+                    message: `Unable to create task worktree: ${input.worktreePath}`,
+                    statusCode: 400,
+                    hint: result.stderr
+                });
+            }
+        },
+        async removeWorktree(repoRoot, worktreePath, options = {}) {
+            const args = ["worktree", "remove"];
+            if (options.force) {
+                args.push("--force");
+            }
+            args.push(worktreePath);
+            const result = await runGit(runner, repoRoot, args);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_WORKTREE_REMOVE_FAILED",
+                    message: `Unable to remove task worktree: ${worktreePath}`,
+                    statusCode: 400,
+                    hint: result.stderr
+                });
+            }
+        },
+        async deleteBranch(repoRoot, branch, options = {}) {
+            const result = await runGit(runner, repoRoot, ["branch", options.force ? "-D" : "-d", branch]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_BRANCH_DELETE_FAILED",
+                    message: `Unable to delete Git branch: ${branch}`,
+                    statusCode: 400,
+                    hint: result.stderr
+                });
+            }
         }
     };
 }

package/dist/backend/adapters/translation-provider.js

@@ -0,0 +1,145 @@
+export class TranslationProviderError extends Error {
+    code;
+    elapsedMs;
+    constructor(message, code, elapsedMs = 0) {
+        super(message);
+        this.name = "TranslationProviderError";
+        this.code = code;
+        this.elapsedMs = elapsedMs;
+    }
+}
+export function createOpenAiCompatibleTranslationProvider(fetchImpl = fetch) {
+    return {
+        async testConnection(settings, secrets) {
+            const startedAt = performance.now();
+            try {
+                await this.translate({
+                    settings,
+                    secrets,
+                    systemPrompt: "Reply with exactly: ok",
+                    userPrompt: "ok"
+                });
+                return {
+                    ok: true,
+                    model: settings.model,
+                    elapsedMs: Math.round(performance.now() - startedAt)
+                };
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    model: settings.model,
+                    elapsedMs: Math.round(performance.now() - startedAt),
+                    error: error instanceof Error ? error.message : "Translation provider failed."
+                };
+            }
+        },
+        async translate(input) {
+            const apiKey = input.secrets.apiKey?.trim();
+            if (!apiKey) {
+                throw new TranslationProviderError("Translation API key is not configured.", "config");
+            }
+            const startedAt = performance.now();
+            const elapsed = () => Math.round(performance.now() - startedAt);
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), input.settings.requestTimeoutMs);
+            const externalAbort = () => controller.abort();
+            if (input.signal) {
+                if (input.signal.aborted) {
+                    controller.abort();
+                }
+                else {
+                    input.signal.addEventListener("abort", externalAbort, { once: true });
+                }
+            }
+            try {
+                const response = await fetchImpl(buildChatCompletionsUrl(input.settings.baseUrl), {
+                    method: "POST",
+                    headers: {
+                        "content-type": "application/json",
+                        authorization: `Bearer ${apiKey}`
+                    },
+                    body: JSON.stringify({
+                        model: input.settings.model,
+                        messages: [
+                            { role: "system", content: input.systemPrompt },
+                            { role: "user", content: input.userPrompt }
+                        ],
+                        temperature: input.settings.temperature,
+                        stream: false
+                    }),
+                    signal: controller.signal
+                });
+                const rawText = await response.text();
+                let payload = null;
+                try {
+                    payload = rawText ? JSON.parse(rawText) : null;
+                }
+                catch {
+                    if (!response.ok) {
+                        throw new TranslationProviderError(rawText || response.statusText, `HTTP ${response.status}`, elapsed());
+                    }
+                    throw new TranslationProviderError("Translation provider returned invalid JSON.", "parse", elapsed());
+                }
+                if (!response.ok) {
+                    throw new TranslationProviderError(extractErrorMessage(payload) ?? response.statusText, `HTTP ${response.status}`, elapsed());
+                }
+                const content = extractContent(payload);
+                if (!content) {
+                    throw new TranslationProviderError("Translation provider returned empty content.", "parse", elapsed());
+                }
+                return {
+                    text: content,
+                    elapsedMs: elapsed(),
+                    tokenUsage: parseOpenAiUsage(payload?.usage)
+                };
+            }
+            catch (error) {
+                if (error instanceof TranslationProviderError) {
+                    throw error;
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                const code = message.toLowerCase().includes("abort") ? "timeout" : "network";
+                throw new TranslationProviderError(message, code, elapsed());
+            }
+            finally {
+                clearTimeout(timeout);
+                input.signal?.removeEventListener("abort", externalAbort);
+            }
+        }
+    };
+}
+export function buildChatCompletionsUrl(baseUrl) {
+    return `${baseUrl.replace(/\/$/, "")}/chat/completions`;
+}
+export function parseOpenAiUsage(raw) {
+    if (!raw || typeof raw !== "object") {
+        return undefined;
+    }
+    const usage = raw;
+    const input = typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0;
+    const output = typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0;
+    const total = typeof usage.total_tokens === "number" ? usage.total_tokens : input + output;
+    if (input === 0 && output === 0 && total === 0) {
+        return undefined;
+    }
+    return { input, output, total };
+}
+function extractContent(payload) {
+    const choices = payload?.choices;
+    if (!Array.isArray(choices) || choices.length === 0) {
+        return null;
+    }
+    const content = choices[0].message?.content;
+    return typeof content === "string" ? content.trim() : null;
+}
+function extractErrorMessage(payload) {
+    const error = payload?.error;
+    if (!error) {
+        return null;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    return error.message ?? JSON.stringify(error);
+}