vibe-coding-master 0.0.5 → 0.0.7

package/dist/backend/services/translation-service.js

@@ -0,0 +1,546 @@
+import { TRANSLATION_PROMPT_KEYS } from "../../shared/types/translation.js";
+import { TranslationProviderError } from "../adapters/translation-provider.js";
+import { VcmError } from "../errors.js";
+import { buildTranslationPrompt, getTranslationPromptPreviews, parseTranslationWarning } from "./translation-prompts.js";
+import { createTranslationQueueRegistry } from "./translation-queue.js";
+const DEFAULT_SETTINGS = {
+    version: 1,
+    enabled: false,
+    providerType: "openai-compatible",
+    baseUrl: "https://api.openai.com/v1",
+    model: "gpt-4o-mini",
+    sourceLanguage: "auto",
+    targetLanguage: "zh-CN",
+    workingLanguage: "en",
+    inputMode: "review-before-send",
+    translateOutput: true,
+    translateUserInput: true,
+    contextEnabled: true,
+    preserveTechnicalTokens: true,
+    skipCjkText: true,
+    redactSecrets: true,
+    requestTimeoutMs: 15000,
+    temperature: 0.1
+};
+const TRANSCRIPT_REPLAY_GRACE_MS = 5000;
+export function createTranslationService(deps) {
+    const now = deps.now ?? (() => new Date().toISOString());
+    const id = deps.id ?? (() => `tr_${Date.now()}_${Math.random().toString(16).slice(2)}`);
+    const queues = createTranslationQueueRegistry();
+    const sessionStates = new Map();
+    let cachedConfig = null;
+    async function loadConfig() {
+        if (cachedConfig) {
+            return cachedConfig;
+        }
+        const storedConfig = await deps.appSettings.getTranslationConfig();
+        if (!storedConfig) {
+            cachedConfig = { settings: DEFAULT_SETTINGS, secrets: {} };
+            return cachedConfig;
+        }
+        const rawSettings = storedConfig.settings ?? {};
+        const apiKey = storedConfig.secrets?.apiKey ?? rawSettings.apiKey;
+        cachedConfig = {
+            settings: normalizeSettings(rawSettings),
+            secrets: {
+                ...(storedConfig.secrets ?? {}),
+                ...(apiKey !== undefined ? { apiKey } : {})
+            }
+        };
+        return cachedConfig;
+    }
+    async function saveConfig(config) {
+        cachedConfig = config;
+        await deps.appSettings.updateTranslationConfig(config);
+    }
+    function getState(sessionId) {
+        let state = sessionStates.get(sessionId);
+        if (!state) {
+            state = {
+                listeners: new Set(),
+                seenTranscriptIds: new Set(),
+                entries: []
+            };
+            sessionStates.set(sessionId, state);
+        }
+        return state;
+    }
+    function emit(sessionId, message) {
+        const state = getState(sessionId);
+        for (const listener of state.listeners) {
+            listener(message);
+        }
+    }
+    async function handleTranscriptEvent(sessionId, event) {
+        const state = getState(sessionId);
+        if (state.seenTranscriptIds.has(event.id)) {
+            return;
+        }
+        state.seenTranscriptIds.add(event.id);
+        if (event.kind === "text") {
+            state.lastAssistantText = event.text;
+        }
+        const { settings } = await loadConfig();
+        if (!settings.enabled || !settings.translateOutput) {
+            return;
+        }
+        if (event.kind === "text") {
+            await processClaudeOutputText(sessionId, event.text, event.id);
+            return;
+        }
+        if (event.kind === "question" || event.kind === "todo" || event.kind === "agent") {
+            await processClaudeOutputText(sessionId, formatStructuredTranscriptEvent(event), event.id);
+            return;
+        }
+        if (event.kind === "tool_use" || event.kind === "tool_result") {
+            await pushPreservedTranscriptEntry(sessionId, event.id, formatRawTranscriptEvent(event));
+        }
+    }
+    async function processClaudeOutputText(sessionId, rawText, entryId) {
+        const session = deps.runtime.getSession(sessionId);
+        const roleSession = deps.sessionRegistry.get(sessionId);
+        if (!session && !roleSession) {
+            return;
+        }
+        const { settings, secrets } = await loadConfig();
+        if (!rawText.trim()) {
+            return;
+        }
+        const text = rawText;
+        const baseEntry = {
+            ...createEntry({
+                taskSlug: roleSession?.taskSlug ?? session.taskSlug,
+                role: roleSession?.role ?? session.role,
+                direction: "cc-output-to-user",
+                sourceKind: "prose",
+                sourceText: text,
+                settings,
+                status: "translating",
+                contextUsed: false,
+                id: entryId
+            }),
+            translationStartedAt: now()
+        };
+        pushEntry(sessionId, baseEntry);
+        const queue = queues.getQueue(sessionId);
+        await queue.enqueue(async () => {
+            emit(sessionId, { type: "translation-status", status: "translating" });
+            try {
+                const prompt = buildTranslationPrompt({
+                    direction: "cc-output-to-user",
+                    text,
+                    sourceKind: "prose",
+                    settings
+                });
+                const result = await deps.provider.translate({
+                    settings,
+                    secrets,
+                    systemPrompt: prompt.systemPrompt,
+                    userPrompt: prompt.userPrompt
+                });
+                const completed = {
+                    ...baseEntry,
+                    status: "translated",
+                    translatedText: result.text,
+                    completedAt: now(),
+                    tokenUsage: result.tokenUsage
+                };
+                replaceEntry(sessionId, completed);
+                getState(sessionId).lastAssistantText = text;
+                emit(sessionId, { type: "translation-status", status: "ready" });
+            }
+            catch (error) {
+                const failed = {
+                    ...baseEntry,
+                    status: "failed",
+                    error: error instanceof Error ? error.message : "Translation failed.",
+                    completedAt: now()
+                };
+                replaceEntry(sessionId, failed);
+                emit(sessionId, { type: "translation-status", status: "failed" });
+            }
+        });
+    }
+    function pushEntry(sessionId, entry) {
+        getState(sessionId).entries.push(entry);
+        emit(sessionId, { type: "translation-entry", entry });
+    }
+    async function pushPreservedTranscriptEntry(sessionId, entryId, sourceText) {
+        const session = deps.runtime.getSession(sessionId);
+        const roleSession = deps.sessionRegistry.get(sessionId);
+        if (!session && !roleSession) {
+            return;
+        }
+        const { settings } = await loadConfig();
+        const queue = queues.getQueue(sessionId);
+        await queue.enqueue(async () => {
+            const entry = createEntry({
+                taskSlug: roleSession?.taskSlug ?? session.taskSlug,
+                role: roleSession?.role ?? session.role,
+                direction: "cc-output-to-user",
+                sourceKind: "tool-output",
+                sourceText,
+                settings,
+                status: "preserved",
+                contextUsed: false,
+                id: entryId,
+                translatedText: sourceText,
+                completedAt: now()
+            });
+            pushEntry(sessionId, entry);
+        });
+    }
+    function replaceEntry(sessionId, entry) {
+        const state = getState(sessionId);
+        state.entries = state.entries.map((current) => current.id === entry.id ? entry : current);
+        emit(sessionId, { type: "translation-entry", entry });
+    }
+    function createEntry(input) {
+        return {
+            id: input.id ?? id(),
+            taskSlug: input.taskSlug,
+            role: input.role,
+            direction: input.direction,
+            sourceKind: input.sourceKind,
+            sourceLanguage: input.direction === "user-input-to-english" ? input.settings.sourceLanguage : "en",
+            targetLanguage: input.direction === "user-input-to-english" ? "en" : input.settings.targetLanguage,
+            sourceText: input.sourceText,
+            translatedText: input.translatedText ?? "",
+            status: input.status,
+            contextUsed: input.contextUsed,
+            createdAt: now(),
+            completedAt: input.completedAt,
+            provider: input.settings.providerType,
+            model: input.settings.model
+        };
+    }
+    return {
+        async getSettings() {
+            const { settings, secrets } = await loadConfig();
+            return exposeSettings(settings, secrets);
+        },
+        async updateSettings(input, secrets) {
+            const current = await loadConfig();
+            const next = {
+                settings: normalizeSettings({ ...current.settings, ...input }),
+                secrets: {
+                    ...current.secrets,
+                    ...(secrets?.apiKey !== undefined ? { apiKey: secrets.apiKey } : {})
+                }
+            };
+            await saveConfig(next);
+            return exposeSettings(next.settings, next.secrets);
+        },
+        async getPromptPreviews() {
+            const { settings } = await loadConfig();
+            return getTranslationPromptPreviews(settings);
+        },
+        async testProvider() {
+            const { settings, secrets } = await loadConfig();
+            return deps.provider.testConnection(settings, secrets);
+        },
+        async translateUserInput(input) {
+            const { settings, secrets } = await loadConfig();
+            if (!settings.enabled || !settings.translateUserInput) {
+                throw new VcmError({
+                    code: "TRANSLATION_DISABLED",
+                    message: "Translation input is disabled.",
+                    statusCode: 409
+                });
+            }
+            if (!input.text.trim()) {
+                throw new VcmError({
+                    code: "TRANSLATION_INPUT_EMPTY",
+                    message: "Translation input cannot be empty.",
+                    statusCode: 400
+                });
+            }
+            const roleSession = await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, input.role);
+            const sessionState = roleSession ? getState(roleSession.id) : undefined;
+            const contextText = settings.contextEnabled && input.useContext !== false
+                ? sessionState?.lastAssistantText
+                : undefined;
+            const prompt = buildTranslationPrompt({
+                direction: "user-input-to-english",
+                text: input.text,
+                contextText,
+                settings
+            });
+            const entry = {
+                ...createEntry({
+                    taskSlug: input.taskSlug,
+                    role: input.role,
+                    direction: "user-input-to-english",
+                    sourceKind: "prose",
+                    sourceText: input.text,
+                    settings,
+                    status: "translating",
+                    contextUsed: Boolean(contextText)
+                }),
+                translationStartedAt: now()
+            };
+            if (roleSession) {
+                pushEntry(roleSession.id, entry);
+            }
+            try {
+                const result = await deps.provider.translate({
+                    settings,
+                    secrets,
+                    systemPrompt: prompt.systemPrompt,
+                    userPrompt: prompt.userPrompt
+                });
+                const parsed = prompt.parseWarning ? parseTranslationWarning(result.text) : { text: result.text };
+                const completed = {
+                    ...entry,
+                    status: "translated",
+                    translatedText: parsed.text,
+                    warning: parsed.warning,
+                    completedAt: now(),
+                    tokenUsage: result.tokenUsage
+                };
+                if (roleSession) {
+                    replaceEntry(roleSession.id, completed);
+                }
+                const mode = input.mode ?? settings.inputMode;
+                const shouldSend = input.send === true && mode === "auto-send" && !parsed.warning;
+                if (shouldSend) {
+                    await writeToCurrentRole(input.repoRoot, input.taskSlug, input.role, parsed.text);
+                }
+                return {
+                    translation: completed,
+                    englishPreview: parsed.text,
+                    contextUsed: Boolean(contextText),
+                    requiresReview: mode === "review-before-send" || Boolean(parsed.warning),
+                    sent: shouldSend
+                };
+            }
+            catch (error) {
+                const failed = {
+                    ...entry,
+                    status: "failed",
+                    error: normalizeTranslationError(error),
+                    completedAt: now()
+                };
+                if (roleSession) {
+                    replaceEntry(roleSession.id, failed);
+                }
+                throw new VcmError({
+                    code: "TRANSLATION_FAILED",
+                    message: failed.error ?? "Translation failed.",
+                    statusCode: 502
+                });
+            }
+        },
+        async sendTranslatedInput(input) {
+            await writeToCurrentRole(input.repoRoot, input.taskSlug, input.role, input.englishText);
+        },
+        subscribeToSession(sessionId, listener) {
+            const session = deps.runtime.getSession(sessionId);
+            const roleSession = deps.sessionRegistry.get(sessionId);
+            if (!session && !roleSession) {
+                throw new VcmError({
+                    code: "SESSION_MISSING",
+                    message: `Terminal session does not exist: ${sessionId}`,
+                    statusCode: 404
+                });
+            }
+            const state = getState(sessionId);
+            state.listeners.add(listener);
+            for (const entry of state.entries) {
+                listener({ type: "translation-entry", entry });
+            }
+            if (!state.unsubscribeTranscript) {
+                if (!roleSession) {
+                    listener({
+                        type: "translation-error",
+                        message: "Claude transcript watcher is unavailable for this session."
+                    });
+                }
+                else {
+                    const replaySince = getTranscriptReplaySince(roleSession);
+                    state.unsubscribeTranscript = deps.transcripts.subscribeToRoleSession(roleSession, (event) => {
+                        void handleTranscriptEvent(sessionId, event).catch((error) => {
+                            emit(sessionId, {
+                                type: "translation-error",
+                                message: error instanceof Error ? error.message : "Translation failed."
+                            });
+                        });
+                    }, {
+                        onError(error) {
+                            emit(sessionId, {
+                                type: "translation-error",
+                                message: error.message
+                            });
+                        },
+                        replaySince
+                    });
+                }
+            }
+            void loadConfig().then(({ settings }) => {
+                listener({ type: "translation-status", status: settings.enabled ? "ready" : "paused" });
+            });
+            return () => {
+                state.listeners.delete(listener);
+                if (state.listeners.size === 0 && state.unsubscribeTranscript) {
+                    state.unsubscribeTranscript();
+                    state.unsubscribeTranscript = undefined;
+                }
+            };
+        },
+        clearSession(sessionId) {
+            const state = getState(sessionId);
+            state.entries = [];
+            queues.clearQueue(sessionId);
+        },
+        async retryTranslation(sessionId, translationId) {
+            const state = getState(sessionId);
+            const original = state.entries.find((entry) => entry.id === translationId);
+            if (!original) {
+                throw new VcmError({
+                    code: "TRANSLATION_ENTRY_MISSING",
+                    message: `Translation entry not found: ${translationId}`,
+                    statusCode: 404
+                });
+            }
+            if (original.direction !== "cc-output-to-user") {
+                throw new VcmError({
+                    code: "TRANSLATION_RETRY_UNSUPPORTED",
+                    message: "Only Claude Code output translation entries can be retried.",
+                    statusCode: 400
+                });
+            }
+            await processClaudeOutputText(sessionId, original.sourceText);
+            return state.entries[state.entries.length - 1] ?? original;
+        }
+    };
+    async function writeToCurrentRole(repoRoot, taskSlug, role, text) {
+        const record = await deps.sessionService.getRoleSession(repoRoot, taskSlug, role);
+        if (!record || record.status !== "running") {
+            throw new VcmError({
+                code: "SESSION_NOT_RUNNING",
+                message: `${role} session is not running.`,
+                statusCode: 409
+            });
+        }
+        deps.runtime.write(record.id, formatTerminalSubmit(text));
+    }
+}
+export function formatTerminalSubmit(text) {
+    return `${text.replace(/[\r\n]+$/g, "")}\r`;
+}
+function getTranscriptReplaySince(roleSession) {
+    const rawTimestamp = roleSession.startedAt ?? roleSession.updatedAt;
+    const timestampMs = Date.parse(rawTimestamp);
+    if (!Number.isFinite(timestampMs)) {
+        return undefined;
+    }
+    return new Date(Math.max(0, timestampMs - TRANSCRIPT_REPLAY_GRACE_MS)).toISOString();
+}
+function formatStructuredTranscriptEvent(event) {
+    if (event.kind === "question") {
+        return event.question.questions.map((question, index) => {
+            const title = question.header ? `${question.header}: ${question.question}` : question.question;
+            const options = question.options.map((option) => {
+                const preview = option.preview ? `\n  Preview: ${option.preview}` : "";
+                return `- ${option.label}: ${option.description}${preview}`;
+            });
+            return [`AskUserQuestion ${index + 1}`, title, `Multi-select: ${question.multiSelect ? "yes" : "no"}`, "Options:", ...options]
+                .filter(Boolean)
+                .join("\n");
+        }).join("\n\n");
+    }
+    if (event.kind === "todo") {
+        return [
+            "TodoWrite plan",
+            ...event.todo.todos.map((todo) => {
+                const text = todo.status === "in_progress" && todo.activeForm ? todo.activeForm : todo.content;
+                return `- [${todo.status}] ${text}`;
+            })
+        ].join("\n");
+    }
+    return [
+        `Agent dispatch${event.agent.subagent_type ? `: ${event.agent.subagent_type}` : ""}`,
+        event.agent.description ? `Description: ${event.agent.description}` : "",
+        event.agent.prompt ? `Prompt:\n${event.agent.prompt}` : ""
+    ].filter(Boolean).join("\n");
+}
+function formatRawTranscriptEvent(event) {
+    if (event.kind === "tool_use") {
+        return `● ${event.toolUse.name}(${formatUnknown(event.toolUse.input)})`;
+    }
+    const errorPrefix = event.toolResult.isError ? "[error] " : "";
+    return `⎿ ${errorPrefix}${formatUnknown(event.toolResult.content)}`;
+}
+function formatUnknown(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value === undefined) {
+        return "";
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function normalizeSettings(input) {
+    const { apiKey: _apiKey, ...settings } = input;
+    return {
+        ...DEFAULT_SETTINGS,
+        ...settings,
+        version: 1,
+        providerType: "openai-compatible",
+        workingLanguage: "en",
+        requestTimeoutMs: clampNumber(input.requestTimeoutMs, 3000, 120000, DEFAULT_SETTINGS.requestTimeoutMs),
+        temperature: clampNumber(input.temperature, 0, 1, DEFAULT_SETTINGS.temperature),
+        prompts: normalizePromptMap(input.prompts)
+    };
+}
+function exposeSettings(settings, secrets) {
+    return {
+        ...settings,
+        apiKey: secrets.apiKey ?? ""
+    };
+}
+function normalizePromptMap(input) {
+    if (!input || typeof input !== "object") {
+        return undefined;
+    }
+    const prompts = {};
+    for (const [key, value] of Object.entries(input)) {
+        const normalizedKey = normalizePromptKey(key);
+        if (normalizedKey && typeof value === "string" && value.trim()) {
+            prompts[normalizedKey] = value;
+        }
+    }
+    return Object.keys(prompts).length > 0 ? prompts : undefined;
+}
+function normalizePromptKey(key) {
+    if (TRANSLATION_PROMPT_KEYS.includes(key)) {
+        return key;
+    }
+    if (key === "user-input-to-english") {
+        return "zh-to-en";
+    }
+    if (key === "user-input-to-english-with-context") {
+        return "zh-to-en-with-context";
+    }
+    if (key === "cc-output-to-user") {
+        return "en-to-zh";
+    }
+    return undefined;
+}
+function clampNumber(value, min, max, fallback) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.min(max, Math.max(min, value));
+}
+function normalizeTranslationError(error) {
+    if (error instanceof TranslationProviderError) {
+        return `${error.code}: ${error.message}`;
+    }
+    return error instanceof Error ? error.message : "Translation failed.";
+}

package/dist/backend/templates/handoff.js

@@ -74,3 +74,35 @@ TBD
 TBD
 `;
 }
+export function renderDocsSyncReportTemplate(taskSlug) {
+    return `# Docs Sync Report: ${taskSlug}
+
+## Summary
+
+TBD
+
+## Architecture Drift Check
+
+TBD
+
+## Docs Updated
+
+TBD
+
+## Docs Reviewed And Left Unchanged
+
+TBD
+
+## Public Contract / Module Boundary Notes
+
+TBD
+
+## Remaining Documentation Risks
+
+TBD
+
+## Decision
+
+TBD
+`;
+}

package/dist/backend/templates/harness/architect-agent.js

@@ -0,0 +1,12 @@
+export function renderArchitectHarnessRules() {
+    return `## VCM Architect Rules
+
+- Own architecture planning, module boundaries, file responsibilities, public contracts, test contracts, risk, phases, and stop conditions.
+- Write architecture-plan.md under the current task handoff directory before coder work starts.
+- Do not implement production code.
+- After reviewer completes, perform docs sync and architecture drift checks when requested by project-manager.
+- Update stale architecture/module/testing/security/dependency docs when the final code made them stale.
+- Write docs-sync-report.md with docs changed, docs intentionally left unchanged, remaining documentation risks, and decision.
+- Stop and reply to project-manager if implementation drift changes architecture, public contracts, dependency direction, schema, auth, permission, payment, or design assumptions.
+`;
+}

package/dist/backend/templates/harness/claude-root.js

@@ -0,0 +1,14 @@
+export function renderRootClaudeHarnessRules() {
+    return `## VCM Shared Rules
+
+- This repository uses VibeCodingMaster for multi-session Claude Code work.
+- User-facing work starts with the project-manager role.
+- Canonical task handoffs live under .ai/handoffs/<task-slug>/.
+- Use only the current task's handoff directory for task-specific artifacts.
+- Do not create or write .ai/handoffs/<other-task>/ for the current task.
+- Use vcmctl for role-to-role messaging instead of asking the user to copy prompts.
+- Non-PM roles only reply to project-manager; they do not message other roles directly.
+- High-risk decisions involving schema, auth, permissions, payment, billing, security, data deletion, or unclear user intent must stop for project-manager/user approval.
+- Required workflow gates: architect plan -> coder implementation/validation -> reviewer review -> architect docs sync -> project-manager final acceptance/commit/PR.
+`;
+}

package/dist/backend/templates/harness/coder-agent.js

@@ -0,0 +1,11 @@
+export function renderCoderHarnessRules() {
+    return `## VCM Coder Rules
+
+- Implement only the approved task scope and architecture plan.
+- Read the task spec, architecture-plan.md, relevant module docs, and role command before editing.
+- Add or update direct unit, contract, or regression tests for changed behavior.
+- Maintain implementation-log.md and validation-log.md under the current task handoff directory.
+- Do not change module boundaries, public contracts, dependency direction, or test strategy without project-manager/architect replan.
+- Stop and reply to project-manager when blocked, unclear, or when the plan no longer matches reality.
+`;
+}

package/dist/backend/templates/harness/project-manager-agent.js

@@ -0,0 +1,14 @@
+export function renderProjectManagerHarnessRules() {
+    return `## VCM Project Manager Rules
+
+- You are the user-facing orchestration hub for the VCM task.
+- Clarify the user's request, classify task risk, and choose the role route.
+- Use vcmctl send to assign work to architect, coder, or reviewer.
+- Send role work as durable instructions with artifact refs when possible.
+- Track the workflow gates: architecture plan, implementation/validation, review, docs sync, final acceptance.
+- Request architect post-review docs sync after reviewer completes.
+- Prepare final acceptance, commit, and PR only after reviewer and docs-sync gates pass or an explicit exception is approved.
+- Do not implement non-trivial production code directly.
+- Stop and ask the user for high-risk decisions or unclear requirements.
+`;
+}

package/dist/backend/templates/harness/reviewer-agent.js

@@ -0,0 +1,13 @@
+export function renderReviewerHarnessRules() {
+    return `## VCM Reviewer Rules
+
+- Own independent acceptance review and final test adequacy.
+- Read task spec, architecture-plan.md, implementation-log.md, validation-log.md, and git diff.
+- Verify scope, role compliance, architecture compliance, public contract compliance, validation evidence, docs gaps, and risk.
+- Add or strengthen missing tests only when the fix is small, local, low-risk, and review-scoped.
+- Write review-report.md under the current task handoff directory.
+- Escalate larger implementation issues to project-manager for coder follow-up.
+- Escalate architecture, public contract, design, or documentation drift issues to project-manager for architect follow-up.
+- Do not take over broad implementation and do not weaken tests to pass validation.
+`;
+}

package/dist/backend/ws/translation-ws.js

@@ -0,0 +1,35 @@
+import { WebSocketServer } from "ws";
+import { toVcmError } from "../errors.js";
+export function registerTranslationWs(app, deps) {
+    const wss = new WebSocketServer({ noServer: true });
+    app.server.on("upgrade", (request, socket, head) => {
+        const url = new URL(request.url ?? "/", "http://localhost");
+        const match = /^\/ws\/translation\/([^/]+)$/.exec(url.pathname);
+        if (!match) {
+            return;
+        }
+        wss.handleUpgrade(request, socket, head, (ws) => {
+            bindTranslationSocket(ws, decodeURIComponent(match[1] ?? ""), deps.translationService);
+        });
+    });
+}
+function bindTranslationSocket(ws, sessionId, translationService) {
+    let unsubscribe = () => { };
+    try {
+        unsubscribe = translationService.subscribeToSession(sessionId, (message) => send(ws, message));
+    }
+    catch (error) {
+        const vcmError = toVcmError(error);
+        send(ws, { type: "translation-error", message: vcmError.message });
+        ws.close();
+        return;
+    }
+    ws.on("close", () => {
+        unsubscribe();
+    });
+}
+function send(ws, message) {
+    if (ws.readyState === ws.OPEN) {
+        ws.send(JSON.stringify(message));
+    }
+}

package/dist/shared/types/harness.js

@@ -0,0 +1 @@
+export {};