vibe-coding-master 0.6.1 → 0.6.2

package/dist/backend/gateway/gateway-service.js

@@ -21,6 +21,8 @@ const COMMANDS_ALLOWED_WHEN_DISABLED = new Set([
     "projects",
     "tasks"
 ]);
+class HandledGatewayInboundError extends Error {
+}
 export function createGatewayService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const larkRegistration = deps.larkRegistration ?? createLarkRegistrationClient();
@@ -219,6 +221,10 @@ export function createGatewayService(deps) {
             return;
         }
         const command = parseGatewayCommand(update.text);
+        if (command.kind === "plain" && settings.enabled) {
+            await handlePlainInbound(update, command.text);
+            return;
+        }
         try {
             const output = await executeCommand(command, settings);
             await reply(await deps.settings.loadSettings(), update.fromUserId, output);
@@ -247,6 +253,69 @@ export function createGatewayService(deps) {
             });
         }
     }
+    async function handlePlainInbound(update, text) {
+        try {
+            const target = await resolvePlainTextPmTarget(text);
+            if (typeof target === "string") {
+                await reply(await deps.settings.loadSettings(), update.fromUserId, target);
+                await recordInbound(update, "ok", "plain");
+                return;
+            }
+            if (target.settings.translationEnabled) {
+                await reply(await deps.settings.loadSettings(), update.fromUserId, "已收到，正在翻译...");
+            }
+            else {
+                await reply(await deps.settings.loadSettings(), update.fromUserId, "已收到，正在发送给 PM...");
+            }
+            const englishText = target.settings.translationEnabled
+                ? await translatePlainTextForPm(target, text, update)
+                : text;
+            await submitTerminalInput(deps.runtime, target.session.id, englishText);
+            await reply(await deps.settings.loadSettings(), update.fromUserId, target.settings.translationEnabled
+                ? formatGatewayInputTranslationSuccess(englishText)
+                : "已发送给 PM。");
+            await recordInbound(update, "ok", "plain");
+        }
+        catch (error) {
+            if (error instanceof HandledGatewayInboundError) {
+                return;
+            }
+            const message = errorMessage(error);
+            await reply(await deps.settings.loadSettings(), update.fromUserId, `Error: ${message}`);
+            await recordInbound(update, "error", "plain", message);
+        }
+    }
+    async function translatePlainTextForPm(target, text, update) {
+        try {
+            return (await deps.translationService.translateUserInput({
+                repoRoot: target.project.repoRoot,
+                taskRepoRoot: getTaskRuntimeRepoRoot(target.task),
+                taskSlug: target.task.taskSlug,
+                role: "project-manager",
+                text,
+                useContext: false,
+                send: false
+            })).englishPreview;
+        }
+        catch (error) {
+            const message = errorMessage(error);
+            await reply(await deps.settings.loadSettings(), update.fromUserId, formatGatewayInputTranslationFailure(message));
+            await recordInbound(update, "error", "plain", message);
+            throw new HandledGatewayInboundError();
+        }
+    }
+    async function recordInbound(update, result, command, error) {
+        await recordMessageStatus("inbound", result, update.text, error, command);
+        await deps.audit.record({
+            type: "gateway.command",
+            result,
+            messageId: update.messageId,
+            userId: update.fromUserId,
+            command,
+            preview: update.text,
+            error
+        });
+    }
     async function saveInboundMetadata(settings, update, options = {}) {
         const bindMode = options.bind ?? "never";
         return deps.settings.saveSettings({
@@ -633,6 +702,25 @@ export function createGatewayService(deps) {
         return lines.join("\n");
     }
     async function sendPlainTextToPm(text) {
+        const target = await resolvePlainTextPmTarget(text);
+        if (typeof target === "string") {
+            return target;
+        }
+        const englishText = target.settings.translationEnabled
+            ? (await deps.translationService.translateUserInput({
+                repoRoot: target.project.repoRoot,
+                taskRepoRoot: getTaskRuntimeRepoRoot(target.task),
+                taskSlug: target.task.taskSlug,
+                role: "project-manager",
+                text,
+                useContext: false,
+                send: false
+            })).englishPreview
+            : text;
+        await submitTerminalInput(deps.runtime, target.session.id, englishText);
+        return "Sent to PM.";
+    }
+    async function resolvePlainTextPmTarget(text) {
         if (!text.trim()) {
             return "Empty message ignored.";
         }
@@ -657,21 +745,13 @@ export function createGatewayService(deps) {
         if (session.activityStatus === "running") {
             return "PM is still working on the current turn. Please wait and send again later.";
         }
-        const englishText = settings.translationEnabled
-            ? (await deps.translationService.translateUserInput({
-                repoRoot: project.repoRoot,
-                taskRepoRoot: getTaskRuntimeRepoRoot(task),
-                taskSlug: task.taskSlug,
-                role: "project-manager",
-                text,
-                useContext: false,
-                send: false
-            })).englishPreview
-            : text;
-        await submitTerminalInput(deps.runtime, session.id, englishText);
-        return "Sent to PM.";
+        return { project, task, session, settings };
     }
     async function reply(settings, userId, text) {
+        await sendGatewayText(settings, userId, text);
+        await recordMessageStatus("outbound", "ok", text);
+    }
+    async function sendGatewayText(settings, userId, text) {
         const account = toAccount(settings);
         if (!account) {
             return;
@@ -685,7 +765,6 @@ export function createGatewayService(deps) {
             contextToken,
             text
         });
-        await recordMessageStatus("outbound", "ok", text);
     }
     async function recordMessageStatus(direction, result, preview, error, command) {
         const settings = await deps.settings.loadSettings();
@@ -1055,19 +1134,25 @@ export function createGatewayService(deps) {
             if (!text) {
                 return;
             }
-            const output = await renderGatewayPmOutput({
-                settings,
-                repoRoot: input.repoRoot,
-                taskSlug: input.taskSlug,
-                sourceText: text
-            });
-            await resolveChannel(settings).sendText({
-                account,
-                toUserId: boundUserId,
-                chatId: settings.binding.chatIds[boundUserId] ?? settings.binding.homeChatId ?? undefined,
-                contextToken: settings.binding.contextTokens[boundUserId],
-                text: output.text
-            });
+            const roundNotice = await getGatewayRoundNotice(input.repoRoot, input.taskSlug);
+            const originalMessage = formatGatewayPmOriginalReply(text, roundNotice);
+            await sendGatewayText(settings, boundUserId, originalMessage);
+            let output;
+            if (settings.translationEnabled) {
+                output = await renderGatewayPmOutput({
+                    settings,
+                    repoRoot: input.repoRoot,
+                    taskSlug: input.taskSlug,
+                    sourceText: text,
+                    sourceEntryIds: nextEvents.map((event) => event.id)
+                });
+                await sendGatewayText(settings, boundUserId, output.translationFailed
+                    ? formatGatewayPmTranslationFailure(output.translationError)
+                    : formatGatewayPmTranslatedReply(output.text));
+            }
+            else {
+                clearFailedTranslation(input.repoRoot, input.taskSlug);
+            }
             const lastEvent = nextEvents.at(-1);
             const current = await deps.settings.loadSettings();
             await deps.settings.saveSettings({
@@ -1082,19 +1167,19 @@ export function createGatewayService(deps) {
                 lastMessageStatus: {
                     checkedAt: now(),
                     direction: "outbound",
-                    result: output.translationFailed ? "error" : "ok",
+                    result: output?.translationFailed ? "error" : "ok",
                     command: "pm-stop",
-                    preview: output.text.slice(0, 160),
-                    error: output.translationError
+                    preview: (output?.text ?? originalMessage).slice(0, 160),
+                    error: output?.translationError
                 },
                 updatedAt: now()
             });
             await deps.audit.record({
                 type: "gateway.pm_push",
-                result: output.translationFailed ? "error" : "ok",
+                result: output?.translationFailed ? "error" : "ok",
                 command: "pm-stop",
-                preview: output.text,
-                error: output.translationError
+                preview: output ? `${originalMessage}\n\n${output.text}` : originalMessage,
+                error: output?.translationError
             });
         },
         getDiagnostics() {
@@ -1109,12 +1194,75 @@ export function createGatewayService(deps) {
         }
         return settings.latestPmReplies[latestPmReplyKey(settings.currentProjectId, settings.currentTaskSlug)];
     }
+    async function getGatewayRoundNotice(repoRoot, taskSlug) {
+        try {
+            const [projectConfig, task] = await Promise.all([
+                deps.projectService.loadConfig(repoRoot),
+                deps.taskService.loadTask(repoRoot, taskSlug)
+            ]);
+            const round = await deps.roundService.getSessionRoundState({
+                repoRoot,
+                stateRepoRoot: getTaskRuntimeRepoRoot(task),
+                stateRoot: projectConfig.stateRoot,
+                taskSlug
+            });
+            return formatGatewayRoundNotice(round);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    function formatGatewayRoundNotice(round) {
+        const roundLabel = round.roundSequence ? `第 ${round.roundSequence} 轮` : "当前 round";
+        if (round.status === "stopped") {
+            return `${roundLabel}已结束。现在需要你给出下一步指令。`;
+        }
+        const activeRole = round.activeRole ? `，当前角色：${round.activeRole}` : "";
+        return `${roundLabel}运行中${activeRole}。`;
+    }
+    function formatGatewayPmOriginalReply(text, roundNotice) {
+        return [
+            "PM final reply 原文：",
+            "",
+            text.trim(),
+            roundNotice ? "" : undefined,
+            roundNotice ? `Round: ${roundNotice}` : undefined
+        ].filter((line) => line !== undefined).join("\n");
+    }
+    function formatGatewayPmTranslatedReply(text) {
+        return [
+            "PM final reply 翻译：",
+            "",
+            text.trim()
+        ].join("\n");
+    }
+    function formatGatewayPmTranslationFailure(error) {
+        return [
+            GATEWAY_TRANSLATION_FAILURE_TEXT,
+            error ? `原因：${error}` : undefined
+        ].filter((line) => line !== undefined).join("\n");
+    }
+    function formatGatewayInputTranslationSuccess(englishText) {
+        return [
+            "翻译完成，已发送给 PM：",
+            "",
+            englishText.trim()
+        ].join("\n");
+    }
+    function formatGatewayInputTranslationFailure(error) {
+        return [
+            "翻译失败，消息未发送给 PM。",
+            `原因：${error}`,
+            "请重新输入后再试。"
+        ].join("\n");
+    }
     async function renderLatestPmReply(settings, reply) {
         const rendered = await renderGatewayPmOutput({
             settings,
             repoRoot: reply.repoRoot,
             taskSlug: reply.taskSlug,
-            sourceText: reply.text
+            sourceText: reply.text,
+            sourceEntryIds: reply.transcriptEventId ? [reply.transcriptEventId] : undefined
         });
         return {
             ...rendered,
@@ -1134,7 +1282,8 @@ export function createGatewayService(deps) {
                 repoRoot: input.repoRoot,
                 taskSlug: input.taskSlug,
                 role: "project-manager",
-                text: input.sourceText
+                text: input.sourceText,
+                sourceEntryIds: input.sourceEntryIds
             });
             clearFailedTranslation(input.repoRoot, input.taskSlug);
             return {

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

@@ -13,6 +13,8 @@ const TRANSLATION_MODEL = "translator";
 const OUTPUT_TRANSLATION_BATCH_DELAY_MS = 10000;
 const TRANSCRIPT_REPLAY_GRACE_MS = 5000;
 const TRANSLATION_TASK_FEED_RETENTION_LIMIT = 2000;
+const GATEWAY_TRANSLATION_REUSE_GRACE_MS = 1500;
+const GATEWAY_TRANSLATION_REUSE_POLL_MS = 50;
 export function createTranslationService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     const id = deps.id ?? (() => `tr_${Date.now()}_${Math.random().toString(16).slice(2)}`);
@@ -1004,6 +1006,10 @@ export function createTranslationService(deps) {
         },
         async translateGatewayOutput(input) {
             const config = await loadConfig();
+            const reusable = await findReusableGatewayOutputTranslation(input, config);
+            if (reusable) {
+                return reusable.trim();
+            }
             const translation = await translateText({
                 repoRoot: input.repoRoot,
                 taskSlug: input.taskSlug,
@@ -1033,6 +1039,148 @@ export function createTranslationService(deps) {
             };
         }
     };
+    async function findReusableGatewayOutputTranslation(input, config) {
+        const graceDeadline = Date.now() + (input.sourceEntryIds?.length ? GATEWAY_TRANSLATION_REUSE_GRACE_MS : 0);
+        while (true) {
+            const lookup = await lookupGatewayOutputTranslation(input);
+            if (lookup.kind === "translated") {
+                return lookup.text;
+            }
+            if (lookup.kind === "active") {
+                return waitForReusableGatewayOutputTranslation(input, config);
+            }
+            if (!input.sourceEntryIds?.length || Date.now() >= graceDeadline) {
+                return undefined;
+            }
+            await delay(GATEWAY_TRANSLATION_REUSE_POLL_MS);
+        }
+    }
+    async function waitForReusableGatewayOutputTranslation(input, config) {
+        const deadline = Date.now() + config.requestTimeoutMs;
+        while (Date.now() <= deadline) {
+            const lookup = await lookupGatewayOutputTranslation(input);
+            if (lookup.kind === "translated") {
+                return lookup.text;
+            }
+            if (lookup.kind !== "active") {
+                return undefined;
+            }
+            await delay(GATEWAY_TRANSLATION_REUSE_POLL_MS);
+        }
+        throw new VcmError({
+            code: "TRANSLATION_TIMEOUT",
+            message: "Gateway output translation timed out while waiting for the existing PM reply translation.",
+            statusCode: 504
+        });
+    }
+    async function lookupGatewayOutputTranslation(input) {
+        const states = await getGatewayOutputCandidateStates(input);
+        return selectGatewayOutputTranslation(states, input);
+    }
+    async function getGatewayOutputCandidateStates(input) {
+        const states = [];
+        const seen = new Set();
+        const add = (state) => {
+            if (seen.has(state) || !isGatewayOutputCandidateState(state, input)) {
+                return;
+            }
+            seen.add(state);
+            states.push(state);
+        };
+        const roleSession = await getGatewayRoleSession(input);
+        if (roleSession) {
+            const state = await prepareCache({
+                repoRoot: roleSession.cwd,
+                baseRepoRoot: input.repoRoot,
+                taskSlug: input.taskSlug,
+                role: input.role,
+                sessionId: roleSession.id
+            });
+            if (roleSession.status === "running") {
+                startTranscriptTail(roleSession);
+            }
+            add(state);
+        }
+        for (const state of sessionStates.values()) {
+            add(state);
+        }
+        return states;
+    }
+    async function getGatewayRoleSession(input) {
+        try {
+            return await deps.sessionService.getRoleSession(input.repoRoot, input.taskSlug, input.role);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    function isGatewayOutputCandidateState(state, input) {
+        if (state.taskSlug !== input.taskSlug || state.role !== input.role) {
+            return false;
+        }
+        return state.baseRepoRoot === input.repoRoot
+            || state.repoRoot === input.repoRoot
+            || Boolean(state.repoRoot?.startsWith(`${input.repoRoot}${path.sep}`));
+    }
+    function selectGatewayOutputTranslation(states, input) {
+        const sourceEntryIds = normalizeGatewaySourceEntryIds(input.sourceEntryIds);
+        if (sourceEntryIds.length > 0) {
+            const entries = sourceEntryIds
+                .map((entryId) => findGatewayOutputEntryById(states, input, entryId));
+            const foundEntries = entries.filter((entry) => Boolean(entry));
+            if (foundEntries.length === sourceEntryIds.length) {
+                if (foundEntries.some(isActiveTranslationEntry)) {
+                    return { kind: "active" };
+                }
+                if (foundEntries.every(isReusableGatewayOutputEntry)) {
+                    return {
+                        kind: "translated",
+                        text: foundEntries.map((entry) => entry.translatedText).join("\n\n")
+                    };
+                }
+            }
+            else if (foundEntries.some(isActiveTranslationEntry)) {
+                return { kind: "active" };
+            }
+        }
+        const normalizedSourceText = normalizeGatewaySourceText(input.text);
+        const sourceMatches = states
+            .flatMap((state) => state.entries)
+            .filter((entry) => isGatewayOutputEntry(entry, input)
+            && normalizeGatewaySourceText(entry.sourceText) === normalizedSourceText);
+        const translated = [...sourceMatches].reverse().find(isReusableGatewayOutputEntry);
+        if (translated) {
+            return { kind: "translated", text: translated.translatedText };
+        }
+        if (sourceMatches.some(isActiveTranslationEntry)) {
+            return { kind: "active" };
+        }
+        return { kind: "missing" };
+    }
+    function findGatewayOutputEntryById(states, input, entryId) {
+        for (const state of states) {
+            const entry = state.entries.find((candidate) => candidate.id === entryId && isGatewayOutputEntry(candidate, input));
+            if (entry) {
+                return entry;
+            }
+        }
+        return undefined;
+    }
+    function isGatewayOutputEntry(entry, input) {
+        return entry.taskSlug === input.taskSlug
+            && entry.role === input.role
+            && entry.direction === "cc-output-to-user"
+            && entry.sourceKind === "prose";
+    }
+    function isReusableGatewayOutputEntry(entry) {
+        return entry.status === "translated" && Boolean(entry.translatedText.trim());
+    }
+    function normalizeGatewaySourceEntryIds(sourceEntryIds) {
+        return Array.from(new Set((sourceEntryIds ?? []).map((entryId) => entryId.trim()).filter(Boolean)));
+    }
+    function normalizeGatewaySourceText(text) {
+        return text.trim();
+    }
     async function writeToCurrentRole(repoRoot, taskSlug, role, text) {
         const record = await deps.sessionService.getRoleSession(repoRoot, taskSlug, role);
         if (!record || record.status !== "running") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-coding-master",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Local GUI session cockpit for Claude Code role sessions.",
   "type": "module",
   "files": [