vibe-coding-master 0.4.27 → 0.4.29

package/dist/backend/api/runtime-state-routes.js

@@ -0,0 +1,104 @@
+import { isOpenFileLimitError, VcmError } from "../errors.js";
+export function registerRuntimeStateRoutes(app, deps) {
+    app.get("/api/projects/runtime-state", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const taskSlug = request.query.taskSlug?.trim();
+        const [translatorSession, translationState, harnessEngineerSession, harnessFeedbackState] = await Promise.all([
+            deps.sessionService.getProjectTranslatorSession(project.repoRoot).then((session) => session ?? null),
+            deps.translationWorkerService.getState(project.repoRoot, { visibility: "public" }),
+            deps.sessionService.getProjectHarnessEngineerSession(project.repoRoot).then((session) => session ?? null),
+            deps.harnessFeedbackService.getState(project.repoRoot, taskSlug || undefined)
+        ]);
+        if (!taskSlug) {
+            return {
+                translatorSession,
+                translationState,
+                harnessEngineerSession,
+                harnessStatus: null,
+                harnessBootstrapStatus: null,
+                harnessFeedbackState
+            };
+        }
+        try {
+            const task = await deps.taskService.loadTask(project.repoRoot, taskSlug);
+            const [harnessStatus, harnessBootstrapStatus] = await Promise.all([
+                withOpenFileLimitFallback(() => deps.harnessService.getHarnessStatus(task.worktreePath), (error) => degradedHarnessStatus(error)),
+                withOpenFileLimitFallback(() => deps.harnessService.getBootstrapStatus(project.repoRoot, task.worktreePath), (error) => degradedBootstrapStatus(error))
+            ]);
+            return {
+                translatorSession,
+                translationState,
+                harnessEngineerSession,
+                harnessStatus,
+                harnessBootstrapStatus,
+                harnessFeedbackState
+            };
+        }
+        catch (error) {
+            if (isOpenFileLimitError(error)) {
+                return {
+                    translatorSession,
+                    translationState,
+                    harnessEngineerSession,
+                    harnessStatus: degradedHarnessStatus(error),
+                    harnessBootstrapStatus: degradedBootstrapStatus(error),
+                    harnessFeedbackState
+                };
+            }
+            throw error;
+        }
+    });
+}
+async function requireCurrentProject(projectService) {
+    const project = await projectService.getCurrentProject();
+    if (!project) {
+        throw new VcmError({
+            code: "PROJECT_NOT_CONNECTED",
+            message: "Connect a repository first.",
+            statusCode: 409
+        });
+    }
+    return project;
+}
+function degradedHarnessStatus(error) {
+    return {
+        version: 1,
+        harnessRevision: 0,
+        initialized: false,
+        files: [],
+        needsApply: false,
+        plannedChanges: [],
+        warnings: [
+            `Harness status is temporarily unavailable because the backend hit the open-files limit: ${errorMessage(error)}`
+        ]
+    };
+}
+function degradedBootstrapStatus(error) {
+    return {
+        status: "not_ready",
+        canStart: false,
+        checks: [{
+                key: "fixed-harness",
+                label: "Fixed harness",
+                status: "unknown",
+                detail: `Backend open-files limit reached: ${errorMessage(error)}`
+            }],
+        warnings: [
+            `Harness bootstrap status is temporarily unavailable because the backend hit the open-files limit: ${errorMessage(error)}`
+        ]
+    };
+}
+async function withOpenFileLimitFallback(run, fallback) {
+    try {
+        return await run();
+    }
+    catch (error) {
+        if (isOpenFileLimitError(error)) {
+            return fallback(error);
+        }
+        throw error;
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

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

@@ -28,6 +28,61 @@ export function registerTaskRoutes(app, deps) {
             throw error;
         }
     });
+    app.get("/api/tasks/:taskSlug/workspace-state", async (request) => {
+        const taskSlug = request.params.taskSlug;
+        let repoRoot = "unknown";
+        try {
+            const project = await requireCurrentProject(deps.projectService);
+            repoRoot = project.repoRoot;
+            const config = await deps.projectService.loadConfig(project.repoRoot);
+            const task = await deps.taskService.loadTask(project.repoRoot, taskSlug);
+            const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+            const context = {
+                repoRoot: project.repoRoot,
+                taskRepoRoot,
+                stateRepoRoot: taskRepoRoot,
+                stateRoot: config.stateRoot,
+                handoffDir: task.handoffDir,
+                taskSlug
+            };
+            const [taskStatus, messages, orchestration, roundState] = await Promise.all([
+                withOpenFileLimitFallback(() => deps.statusService.getTaskStatus(project.repoRoot, taskSlug), (error) => degradedTaskStatus(project.repoRoot, taskSlug, error)),
+                withOpenFileLimitFallback(() => deps.messageService.listMessages(context), () => []),
+                withOpenFileLimitFallback(() => deps.messageService.getOrchestrationState(context), () => ({
+                    taskSlug,
+                    mode: "auto",
+                    updatedAt: new Date().toISOString()
+                })),
+                withOpenFileLimitFallback(() => deps.roundService.getSessionRoundState({
+                    repoRoot: project.repoRoot,
+                    stateRepoRoot: taskRepoRoot,
+                    stateRoot: config.stateRoot,
+                    taskSlug
+                }), () => degradedRoundState(taskSlug))
+            ]);
+            return {
+                taskStatus,
+                messages,
+                orchestration,
+                roundState
+            };
+        }
+        catch (error) {
+            if (isOpenFileLimitError(error)) {
+                return {
+                    taskStatus: degradedTaskStatus(repoRoot, taskSlug, error),
+                    messages: [],
+                    orchestration: {
+                        taskSlug,
+                        mode: "auto",
+                        updatedAt: new Date().toISOString()
+                    },
+                    roundState: degradedRoundState(taskSlug)
+                };
+            }
+            throw error;
+        }
+    });
     app.post("/api/tasks/:taskSlug/cleanup", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
@@ -96,6 +151,32 @@ function degradedTaskStatus(repoRoot, taskSlug, error) {
         ]
     };
 }
+function degradedRoundState(taskSlug) {
+    return {
+        taskSlug,
+        status: "stopped",
+        turnCount: 0,
+        completedTurnCount: 0,
+        totalRoundCount: 0,
+        totalTurnCount: 0,
+        totalCompletedTurnCount: 0,
+        totalCcActiveMs: 0,
+        currentRoundCcActiveMs: 0,
+        roles: [],
+        updatedAt: new Date().toISOString()
+    };
+}
+async function withOpenFileLimitFallback(run, fallback) {
+    try {
+        return await run();
+    }
+    catch (error) {
+        if (isOpenFileLimitError(error)) {
+            return fallback(error);
+        }
+        throw error;
+    }
+}
 function degradedArtifactSummary(handoffDir) {
     const roleCommandsDir = `${handoffDir}/role-commands`;
     const messagesDir = `${handoffDir}/messages`;

package/dist/backend/server.js

@@ -41,6 +41,7 @@ import { registerHarnessRoutes } from "./api/harness-routes.js";
 import { registerMessageRoutes } from "./api/message-routes.js";
 import { registerProjectRoutes } from "./api/project-routes.js";
 import { registerRoundRoutes } from "./api/round-routes.js";
+import { registerRuntimeStateRoutes } from "./api/runtime-state-routes.js";
 import { registerSessionRoutes } from "./api/session-routes.js";
 import { registerTaskRoutes } from "./api/task-routes.js";
 import { registerTranslationRoutes } from "./api/translation-routes.js";
@@ -90,11 +91,20 @@ export async function createServer(deps, options = {}) {
         sessionService: deps.sessionService,
         taskService: deps.taskService
     });
+    registerRuntimeStateRoutes(app, {
+        projectService: deps.projectService,
+        taskService: deps.taskService,
+        sessionService: deps.sessionService,
+        translationWorkerService: deps.translationWorkerService,
+        harnessService: deps.harnessService,
+        harnessFeedbackService: deps.harnessFeedbackService
+    });
     registerTaskRoutes(app, {
         projectService: deps.projectService,
         taskService: deps.taskService,
         sessionService: deps.sessionService,
         statusService: deps.statusService,
+        messageService: deps.messageService,
         translationService: deps.translationService,
         roundService: deps.roundService
     });

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

@@ -476,6 +476,7 @@ export function createSessionService(deps) {
                 await deps.runtime.stop(existing.id);
             }
             deps.registry.remove(existing.id);
+            await clearPersistedTranslatorSession(deps.fs, repoRoot);
             return launchProjectTranslatorSession(repoRoot, input, "fresh");
         },
         async getProjectTranslatorSession(repoRoot) {
@@ -601,6 +602,7 @@ export function createSessionService(deps) {
                 await deps.runtime.stop(existing.id);
             }
             deps.registry.remove(existing.id);
+            await clearPersistedHarnessEngineerSession(deps.fs, repoRoot);
             return launchProjectHarnessEngineerSession(repoRoot, input, "fresh");
         },
         async getProjectHarnessEngineerSession(repoRoot) {
@@ -737,6 +739,9 @@ export function createSessionService(deps) {
                 await deps.runtime.stop(existing.id);
             }
             deps.registry.remove(existing.id);
+            const config = await deps.projectService.loadConfig(repoRoot);
+            const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+            await clearPersistedRoleSessionRecord(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, taskSlug, role, now());
             return launchRoleSession(repoRoot, taskSlug, role, input, "fresh");
         },
         async getRoleSession(repoRoot, taskSlug, role) {
@@ -1125,6 +1130,23 @@ async function persistTaskSession(fs, repoRoot, stateRoot, session) {
         }
     });
 }
+async function clearPersistedRoleSessionRecord(fs, repoRoot, stateRoot, taskSlug, role, updatedAt) {
+    const sessionPath = getTaskSessionPath(repoRoot, stateRoot, taskSlug);
+    const current = await fs.pathExists(sessionPath)
+        ? await fs.readJson(sessionPath)
+        : createEmptyTaskSessionRecord(taskSlug, updatedAt);
+    await fs.writeJsonAtomic(sessionPath, {
+        ...current,
+        updatedAt,
+        roles: {
+            ...current.roles,
+            [role]: {
+                id: null,
+                status: "not_started"
+            }
+        }
+    });
+}
 async function persistRoleSessionRecord(fs, baseRepoRoot, taskRepoRoot, stateRoot, session) {
     if (session.role === TRANSLATOR_ROLE) {
         await persistTranslatorSession(fs, baseRepoRoot, session);
@@ -1150,6 +1172,9 @@ async function persistTranslatorSession(fs, repoRoot, session) {
         }
     });
 }
+async function clearPersistedTranslatorSession(fs, repoRoot) {
+    await removePersistedProjectSessionFile(fs, repoRoot, TRANSLATOR_SESSION_PATH);
+}
 async function persistHarnessEngineerSession(fs, repoRoot, session) {
     if (!hasConfirmedClaudeSessionId(session)) {
         return;
@@ -1164,6 +1189,24 @@ async function persistHarnessEngineerSession(fs, repoRoot, session) {
         }
     });
 }
+async function clearPersistedHarnessEngineerSession(fs, repoRoot) {
+    await removePersistedProjectSessionFile(fs, repoRoot, HARNESS_ENGINEER_SESSION_PATH);
+}
+async function removePersistedProjectSessionFile(fs, repoRoot, relativePath) {
+    const sessionPath = resolveRepoPath(repoRoot, relativePath);
+    if (!(await fs.pathExists(sessionPath))) {
+        return;
+    }
+    if (!fs.removePath) {
+        throw new VcmError({
+            code: "SESSION_CLEAR_UNAVAILABLE",
+            message: "VCM cannot clear the persisted Claude session file in this runtime.",
+            statusCode: 500,
+            hint: `Remove ${relativePath} manually before restarting the role.`
+        });
+    }
+    await fs.removePath(sessionPath, { force: true });
+}
 function isProjectRoleSessionFile(value) {
     return "record" in value && typeof value.record === "object" && value.record !== null;
 }