vibe-coding-master 0.3.5 → 0.3.7

package/dist/backend/adapters/filesystem.js

@@ -1,5 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { isOpenFileLimitError } from "../errors.js";
 export function createNodeFileSystemAdapter() {
     const runFileOperation = createFileOperationRunner();
     return {
@@ -81,7 +82,7 @@ export function createNodeFileSystemAdapter() {
         }
     };
 }
-const DEFAULT_FILE_OPERATION_CONCURRENCY = 32;
+const DEFAULT_FILE_OPERATION_CONCURRENCY = 8;
 const OPEN_FILE_RETRY_DELAYS_MS = [25, 50, 100, 200, 400, 800];
 function createFileOperationRunner(maxConcurrent = DEFAULT_FILE_OPERATION_CONCURRENCY) {
     let active = 0;
@@ -127,10 +128,6 @@ async function retryOpenFileLimit(operation) {
         }
     }
 }
-function isOpenFileLimitError(error) {
-    const code = getErrorCode(error);
-    return code === "EMFILE" || code === "ENFILE";
-}
 function isMissingPathError(error) {
     const code = getErrorCode(error);
     return code === "ENOENT" || code === "ENOTDIR";

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

@@ -0,0 +1,5 @@
+export function registerDiagnosticsRoutes(app, deps) {
+    app.get("/api/diagnostics/runtime", async () => {
+        return deps.diagnosticsService.getRuntimeDiagnostics();
+    });
+}

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

@@ -1,8 +1,16 @@
-import { VcmError } from "../errors.js";
+import { isOpenFileLimitError, VcmError } from "../errors.js";
 export function registerHarnessRoutes(app, deps) {
     app.get("/api/projects/harness", async () => {
         const project = await requireCurrentProject(deps.projectService);
-        return deps.harnessService.getHarnessStatus(project.repoRoot);
+        try {
+            return await deps.harnessService.getHarnessStatus(project.repoRoot);
+        }
+        catch (error) {
+            if (isOpenFileLimitError(error)) {
+                return degradedHarnessStatus(error);
+            }
+            throw error;
+        }
     });
     app.post("/api/projects/harness/apply", async () => {
         const project = await requireCurrentProject(deps.projectService);
@@ -10,13 +18,51 @@ export function registerHarnessRoutes(app, deps) {
     });
     app.get("/api/projects/harness/bootstrap", async () => {
         const project = await requireCurrentProject(deps.projectService);
-        return deps.harnessService.getBootstrapStatus(project.repoRoot);
+        try {
+            return await deps.harnessService.getBootstrapStatus(project.repoRoot);
+        }
+        catch (error) {
+            if (isOpenFileLimitError(error)) {
+                return degradedBootstrapStatus(error);
+            }
+            throw error;
+        }
     });
     app.post("/api/projects/harness/bootstrap/start", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         return deps.harnessService.startHarnessBootstrap(project.repoRoot, request.body ?? {});
     });
 }
+function degradedHarnessStatus(error) {
+    return {
+        version: 1,
+        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)}`
+        ]
+    };
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 async function requireCurrentProject(projectService) {
     const project = await projectService.getCurrentProject();
     if (!project) {

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

@@ -1,4 +1,4 @@
-import { VcmError } from "../errors.js";
+import { isOpenFileLimitError, VcmError } from "../errors.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerMessageRoutes(app, deps) {
     app.get("/api/tasks/:taskSlug/messages", async (request) => {
@@ -22,7 +22,20 @@ export function registerMessageRoutes(app, deps) {
     });
     app.get("/api/tasks/:taskSlug/orchestration", async (request) => {
         const context = await getRouteContext(deps, request.params.taskSlug);
-        return deps.messageService.getOrchestrationState(context);
+        try {
+            return await deps.messageService.getOrchestrationState(context);
+        }
+        catch (error) {
+            if (isOpenFileLimitError(error)) {
+                return {
+                    taskSlug: request.params.taskSlug,
+                    mode: "auto",
+                    updatedAt: new Date().toISOString(),
+                    warning: `Backend open-files limit reached while reading orchestration state: ${errorMessage(error)}`
+                };
+            }
+            throw error;
+        }
     });
     app.put("/api/tasks/:taskSlug/orchestration", async (request) => {
         const context = await getRouteContext(deps, request.params.taskSlug);
@@ -39,6 +52,9 @@ export function registerMessageRoutes(app, deps) {
         });
     });
 }
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 async function getRouteContext(deps, taskSlug) {
     const project = await requireCurrentProject(deps.projectService);
     const config = await deps.projectService.loadConfig(project.repoRoot);

package/dist/backend/errors.js

@@ -27,3 +27,9 @@ export function toVcmError(error) {
         statusCode: 500
     });
 }
+export function isOpenFileLimitError(error) {
+    const code = typeof error === "object" && error !== null && "code" in error
+        ? String(error.code)
+        : undefined;
+    return code === "EMFILE" || code === "ENFILE";
+}

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

@@ -826,6 +826,11 @@ export function createGatewayService(deps) {
                 preview: output.text,
                 error: output.translationError
             });
+        },
+        getDiagnostics() {
+            return {
+                polling: isRunning()
+            };
         }
     };
     function getLatestPmReply(settings) {

package/dist/backend/server.js

@@ -17,6 +17,7 @@ import { createNodeFileSystemAdapter } from "./adapters/filesystem.js";
 import { createNodePtyTerminalRuntime } from "./runtime/node-pty-runtime.js";
 import { createOpenAiCompatibleTranslationProvider } from "./adapters/translation-provider.js";
 import { registerGatewayRoutes } from "./api/gateway-routes.js";
+import { registerDiagnosticsRoutes } from "./api/diagnostics-routes.js";
 import { createWeixinIlinkChannel } from "./gateway/channels/weixin-ilink-channel.js";
 import { createGatewayAuditLog } from "./gateway/gateway-audit-log.js";
 import { createGatewayService } from "./gateway/gateway-service.js";
@@ -30,6 +31,7 @@ import { createRoundService } from "./services/round-service.js";
 import { createStatusService } from "./services/status-service.js";
 import { createTaskService } from "./services/task-service.js";
 import { createTranslationService } from "./services/translation-service.js";
+import { createDiagnosticsService } from "./services/diagnostics-service.js";
 import { registerAppSettingsRoutes } from "./api/app-settings-routes.js";
 import { registerArtifactRoutes } from "./api/artifact-routes.js";
 import { registerClaudeHookRoutes } from "./api/claude-hook-routes.js";
@@ -54,10 +56,12 @@ export async function createServer(deps, options = {}) {
             error: {
                 code: vcmError.code,
                 message: vcmError.message,
-                hint: vcmError.hint
+                hint: vcmError.hint,
+                runtime: deps.diagnosticsService.getErrorRuntimeInfo()
             }
         });
     });
+    registerDiagnosticsRoutes(app, { diagnosticsService: deps.diagnosticsService });
     registerAppSettingsRoutes(app, { appSettings: deps.appSettings });
     registerClaudeHookRoutes(app, { claudeHookService: deps.claudeHookService });
     registerCodexHookRoutes(app, { codexHookService: deps.codexHookService });
@@ -148,7 +152,7 @@ export function createDefaultServerDeps(options = {}) {
     const runtime = createNodePtyTerminalRuntime({ fs });
     const registry = createSessionRegistry();
     const artifactService = createArtifactService(fs);
-    const projectService = createProjectService({ fs, git, claude, appSettings });
+    const projectService = createProjectService({ fs, git, appSettings });
     const harnessService = createHarnessService({
         fs,
         runtime,
@@ -248,6 +252,12 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         roundService
     });
+    const diagnosticsService = createDiagnosticsService({
+        appRoot: getAppRoot(),
+        runtime,
+        gatewayService,
+        translationService
+    });
     return {
         appSettings,
         projectService,
@@ -264,7 +274,8 @@ export function createDefaultServerDeps(options = {}) {
         statusService,
         translationService,
         gatewayService,
-        runtime
+        runtime,
+        diagnosticsService
     };
 }
 export function getDefaultStaticDir() {

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

@@ -0,0 +1,74 @@
+import { readFileSync } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+export function createDiagnosticsService(deps) {
+    const version = readPackageVersion(deps.appRoot);
+    return {
+        async getRuntimeDiagnostics() {
+            const runtimeSessions = deps.runtime.listSessions();
+            return {
+                version,
+                pid: process.pid,
+                cwd: process.cwd(),
+                execPath: process.execPath,
+                nodeVersion: process.version,
+                platform: process.platform,
+                arch: process.arch,
+                uptimeSeconds: Math.round(process.uptime()),
+                fdCount: await readFdCount(),
+                openFilesLimit: await readOpenFilesLimit(),
+                runtimeSessions: {
+                    total: runtimeSessions.length,
+                    running: runtimeSessions.filter((session) => session.status === "running").length
+                },
+                gateway: deps.gatewayService.getDiagnostics(),
+                translation: deps.translationService.getDiagnostics()
+            };
+        },
+        getErrorRuntimeInfo() {
+            return {
+                version,
+                pid: process.pid,
+                cwd: process.cwd()
+            };
+        }
+    };
+}
+function readPackageVersion(appRoot) {
+    const packageJsonPath = path.join(appRoot, "package.json");
+    try {
+        const raw = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        return typeof raw.version === "string" && raw.version.trim() ? raw.version : "unknown";
+    }
+    catch {
+        return process.env.npm_package_version || "unknown";
+    }
+}
+async function readFdCount() {
+    try {
+        return (await fs.readdir("/proc/self/fd")).length;
+    }
+    catch {
+        return null;
+    }
+}
+async function readOpenFilesLimit() {
+    try {
+        const limits = await fs.readFile("/proc/self/limits", "utf8");
+        const line = limits.split("\n").find((candidate) => candidate.startsWith("Max open files"));
+        if (!line) {
+            return null;
+        }
+        const match = line.match(/^Max open files\s+(\S+)\s+(\S+)/);
+        if (!match) {
+            return null;
+        }
+        return {
+            soft: match[1] ?? "unknown",
+            hard: match[2] ?? "unknown"
+        };
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -139,9 +139,6 @@ export function createProjectService(deps) {
                 warnings.push(`Unable to read Git ahead/behind status. ${getErrorHint(caught)}`);
             }
         }
-        if (!(await deps.claude.isAvailable(config.claudeCommand))) {
-            warnings.push("Claude Code command is not available. You can still inspect artifacts, but sessions will not start.");
-        }
         const pullDisabledReason = getPullDisabledReason({ isDirty, upstreamBranch });
         return {
             repoRoot,

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

@@ -799,6 +799,21 @@ export function createTranslationService(deps) {
                 userPrompt: prompt.userPrompt
             });
             return result.text.trim();
+        },
+        getDiagnostics() {
+            let transcriptWatchers = 0;
+            let listeners = 0;
+            for (const state of sessionStates.values()) {
+                if (state.unsubscribeTranscript) {
+                    transcriptWatchers += 1;
+                }
+                listeners += state.listeners.size;
+            }
+            return {
+                sessions: sessionStates.size,
+                transcriptWatchers,
+                listeners
+            };
         }
     };
     async function writeToCurrentRole(repoRoot, taskSlug, role, text) {

package/dist/shared/types/diagnostics.js

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