vibe-coding-master 0.6.0 → 0.6.2

package/dist/backend/api/project-routes.js

@@ -5,7 +5,7 @@ export function registerProjectRoutes(app, deps) {
     });
     app.post("/api/projects/connect", async (request) => {
         const project = await deps.projectService.connectProject(request.body);
-        await deps.translationWorkerService?.cleanupStartupRuntime(project.repoRoot);
+        await deps.runtimeRecoveryService?.recoverProject(project.repoRoot);
         return project;
     });
     app.get("/api/projects/current", async () => {

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/runtime/node-pty-runtime.js

@@ -28,6 +28,7 @@ export function createNodePtyTerminalRuntime(deps) {
         });
         const session = {
             id: sessionId,
+            repoRoot: input.repoRoot,
             taskSlug: input.taskSlug,
             role: input.role,
             status: "running",

package/dist/backend/server.js

@@ -31,9 +31,11 @@ import { createSessionService } from "./services/session-service.js";
 import { createMessageService } from "./services/message-service.js";
 import { createRoundService } from "./services/round-service.js";
 import { createRuntimeCoordinatorService } from "./services/runtime-coordinator-service.js";
+import { createRuntimeRecoveryService } from "./services/runtime-recovery-service.js";
 import { createStatusService } from "./services/status-service.js";
 import { createTaskService } from "./services/task-service.js";
 import { createTaskLaunchService } from "./services/task-launch-service.js";
+import { createTerminalInterruptService } from "./services/terminal-interrupt-service.js";
 import { createTranslationService } from "./services/translation-service.js";
 import { createDiagnosticsService } from "./services/diagnostics-service.js";
 import { registerAppSettingsRoutes } from "./api/app-settings-routes.js";
@@ -86,7 +88,7 @@ export async function createServer(deps, options = {}) {
     });
     registerProjectRoutes(app, {
         projectService: deps.projectService,
-        translationWorkerService: deps.translationWorkerService
+        runtimeRecoveryService: deps.runtimeRecoveryService
     });
     registerHarnessRoutes(app, {
         projectService: deps.projectService,
@@ -143,7 +145,10 @@ export async function createServer(deps, options = {}) {
         translationService: deps.translationService
     });
     registerGatewayRoutes(app, { gatewayService: deps.gatewayService });
-    registerTerminalWs(app, { runtime: deps.runtime });
+    registerTerminalWs(app, {
+        runtime: deps.runtime,
+        onManualInterrupt: (sessionId) => deps.terminalInterruptService.handleManualInterrupt(sessionId)
+    });
     app.addHook("onReady", async () => {
         await cleanupRecentTranslationRuntime(deps);
         await deps.gatewayService.start();
@@ -314,6 +319,13 @@ export function createDefaultServerDeps(options = {}) {
             return (await projectService.loadConfig(repoRoot)).stateRoot;
         }
     });
+    const runtimeRecoveryService = createRuntimeRecoveryService({
+        fs,
+        runtime,
+        projectService,
+        taskService,
+        translationWorkerService
+    });
     const claudeHookService = createClaudeHookService({
         projectService,
         taskService,
@@ -329,6 +341,13 @@ export function createDefaultServerDeps(options = {}) {
         jobGuard: createJobGuardService(),
         translationWorkerService
     });
+    const terminalInterruptService = createTerminalInterruptService({
+        runtime,
+        projectService,
+        taskService,
+        sessionService,
+        roundService
+    });
     const diagnosticsService = createDiagnosticsService({
         appRoot,
         runtime,
@@ -354,6 +373,8 @@ export function createDefaultServerDeps(options = {}) {
         translationService,
         gatewayService,
         runtimeCoordinator,
+        runtimeRecoveryService,
+        terminalInterruptService,
         runtime,
         diagnosticsService
     };

package/dist/backend/services/claude-hook-service.js

@@ -374,6 +374,11 @@ export function createClaudeHookService(deps) {
         }
         const stateInput = createRoundStateInput(context);
         const currentRoundState = await deps.roundService.getSessionRoundState(stateInput);
+        if (currentRoundState.stopReason === "manual-interrupt"
+            && currentRoundState.status === "stopped"
+            && currentRoundState.activeRole === input.role) {
+            return false;
+        }
         const previousAttempt = currentRoundState.roleRecovery?.role === input.role &&
             currentRoundState.roleRecovery.status !== "failed"
             ? currentRoundState.roleRecovery.attempt

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

@@ -246,6 +246,25 @@ export function createRoundService(deps) {
         recordClaudeHookEvent(input) {
             return recordRoleTurnEvent(input);
         },
+        async recordManualInterrupt(input) {
+            return withTaskLock(input, async () => {
+                const timestamp = now();
+                const state = await load(input);
+                const next = applyManualInterrupt({
+                    state,
+                    taskSlug: input.taskSlug,
+                    role: input.role,
+                    timestamp
+                });
+                if (!manualInterruptWasApplied(state, next, input.role)) {
+                    return toSessionRoundState(state, timestamp);
+                }
+                await save(input, next);
+                clearSettleTimer(input);
+                await updateSessionStatus(input, next.currentRound?.status === "running" ? "running" : "stopped");
+                return toSessionRoundState(next, timestamp);
+            });
+        },
         async setRoleRecovery(input) {
             return withTaskLock(input, async () => {
                 const timestamp = now();
@@ -327,6 +346,7 @@ function applyPromptSubmitted(input) {
             lastTurnStartedAt: input.timestamp,
             settleDeadlineAt: undefined,
             stoppedAt: undefined,
+            stopReason: undefined,
             activeTurnStartedAt: current.activeTurnStartedAt ?? input.timestamp,
             turnCount: current.turnCount + 1,
             roles: appendUniqueRole(current.roles, input.role)
@@ -360,6 +380,7 @@ function applyStop(input) {
         activeRole: input.role,
         lastTurnEndedAt: input.timestamp,
         settleDeadlineAt: addMilliseconds(input.timestamp, input.settleMs),
+        stopReason: undefined,
         activeTurnStartedAt: undefined,
         ccActiveMs: current.ccActiveMs + activeDurationMs,
         completedTurnCount: current.completedTurnCount + 1,
@@ -374,6 +395,47 @@ function applyStop(input) {
         updatedAt: input.timestamp
     };
 }
+function applyManualInterrupt(input) {
+    const current = input.state.currentRound;
+    if (!current || current.status === "stopped" || !current.activeTurnStartedAt || current.activeRole !== input.role) {
+        return {
+            ...input.state,
+            taskSlug: input.taskSlug,
+            updatedAt: input.timestamp
+        };
+    }
+    const activeDurationMs = getDurationMs(current.activeTurnStartedAt, input.timestamp);
+    const stopped = {
+        ...current,
+        status: "stopped",
+        activeRole: input.role,
+        lastTurnEndedAt: input.timestamp,
+        stoppedAt: input.timestamp,
+        stopReason: "manual-interrupt",
+        settleDeadlineAt: undefined,
+        activeTurnStartedAt: undefined,
+        ccActiveMs: current.ccActiveMs + activeDurationMs,
+        completedTurnCount: current.completedTurnCount + 1,
+        roles: appendUniqueRole(current.roles, input.role)
+    };
+    return {
+        ...input.state,
+        taskSlug: input.taskSlug,
+        currentRound: stopped,
+        lastStoppedRound: stopped,
+        totalCompletedTurnCount: input.state.totalCompletedTurnCount + 1,
+        totalCcActiveMs: input.state.totalCcActiveMs + activeDurationMs,
+        pendingUserReply: undefined,
+        updatedAt: input.timestamp
+    };
+}
+function manualInterruptWasApplied(previous, next, role) {
+    return Boolean(previous.currentRound?.status === "running"
+        && previous.currentRound.activeTurnStartedAt
+        && previous.currentRound.activeRole === role
+        && next.currentRound?.stopReason === "manual-interrupt"
+        && next.currentRound.status === "stopped");
+}
 function toSessionRoundState(state, updatedAt) {
     const current = state.currentRound;
     if (!current) {
@@ -407,6 +469,7 @@ function toSessionRoundState(state, updatedAt) {
         lastTurnEndedAt: current.lastTurnEndedAt,
         settleDeadlineAt: current.settleDeadlineAt,
         stoppedAt: current.stoppedAt,
+        stopReason: current.stopReason,
         activeTurnStartedAt: current.activeTurnStartedAt,
         roundSequence: current.sequence,
         turnCount: current.turnCount,
@@ -439,8 +502,10 @@ function computeFlowPause(current, roleRecovery, awaitingUser) {
         return undefined;
     }
     const roundStopped = Boolean(current) && current.status === "stopped" && Boolean(current.id);
+    const nonAlertingStop = roundStopped && (current.stopReason === "manual-interrupt" ||
+        current.stopReason === "runtime-recovery");
     if (roleRecovery?.status === "failed") {
-        return roundStopped
+        return roundStopped && !nonAlertingStop
             ? {
                 paused: true,
                 reason: "role-recovery-failed",
@@ -459,7 +524,7 @@ function computeFlowPause(current, roleRecovery, awaitingUser) {
             messageTruncated: awaitingUser.messageTruncated
         };
     }
-    if (roundStopped) {
+    if (roundStopped && !nonAlertingStop) {
         return {
             paused: true,
             reason: "stopped-no-next-turn",
@@ -633,6 +698,9 @@ function normalizeRound(input) {
             : typeof legacy.pausedAt === "string"
                 ? legacy.pausedAt
                 : undefined,
+        stopReason: input.stopReason === "manual-interrupt" || input.stopReason === "runtime-recovery"
+            ? input.stopReason
+            : undefined,
         activeTurnStartedAt: typeof input.activeTurnStartedAt === "string"
             ? input.activeTurnStartedAt
             : typeof legacy.runningSince === "string"