vibe-coding-master 0.3.4 → 0.3.6

package/dist/backend/adapters/filesystem.js

@@ -1,58 +1,70 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 export function createNodeFileSystemAdapter() {
+    const runFileOperation = createFileOperationRunner();
     return {
         async pathExists(targetPath) {
             try {
-                await fs.access(targetPath);
+                await runFileOperation(() => fs.access(targetPath));
                 return true;
             }
-            catch {
-                return false;
+            catch (error) {
+                if (isMissingPathError(error)) {
+                    return false;
+                }
+                throw error;
             }
         },
         async ensureDir(targetPath) {
-            await fs.mkdir(targetPath, { recursive: true });
+            await runFileOperation(() => fs.mkdir(targetPath, { recursive: true }));
         },
         async readDir(targetPath) {
-            return fs.readdir(targetPath);
+            return runFileOperation(() => fs.readdir(targetPath));
         },
         async readText(targetPath) {
-            return fs.readFile(targetPath, "utf8");
+            return runFileOperation(() => fs.readFile(targetPath, "utf8"));
         },
         async readTextTail(targetPath, maxBytes) {
-            const handle = await fs.open(targetPath, "r");
-            try {
-                const stat = await handle.stat();
-                const length = Math.min(Math.max(0, Math.floor(maxBytes)), stat.size);
-                const position = stat.size - length;
-                const buffer = Buffer.alloc(length);
-                await handle.read(buffer, 0, length, position);
-                return buffer.toString("utf8");
-            }
-            finally {
-                await handle.close();
-            }
+            return runFileOperation(async () => {
+                const handle = await fs.open(targetPath, "r");
+                try {
+                    const stat = await handle.stat();
+                    const length = Math.min(Math.max(0, Math.floor(maxBytes)), stat.size);
+                    const position = stat.size - length;
+                    const buffer = Buffer.alloc(length);
+                    await handle.read(buffer, 0, length, position);
+                    return buffer.toString("utf8");
+                }
+                finally {
+                    await handle.close();
+                }
+            });
         },
         async writeText(targetPath, content) {
-            await fs.mkdir(path.dirname(targetPath), { recursive: true });
-            await fs.writeFile(targetPath, content, "utf8");
+            await runFileOperation(async () => {
+                await fs.mkdir(path.dirname(targetPath), { recursive: true });
+                await fs.writeFile(targetPath, content, "utf8");
+            });
         },
         async appendText(targetPath, content) {
-            await fs.mkdir(path.dirname(targetPath), { recursive: true });
-            await fs.appendFile(targetPath, content, "utf8");
+            await runFileOperation(async () => {
+                await fs.mkdir(path.dirname(targetPath), { recursive: true });
+                await fs.appendFile(targetPath, content, "utf8");
+            });
         },
         async readJson(targetPath) {
-            return JSON.parse(await fs.readFile(targetPath, "utf8"));
+            return JSON.parse(await runFileOperation(() => fs.readFile(targetPath, "utf8")));
         },
         async writeJson(targetPath, value) {
             await this.writeText(targetPath, `${JSON.stringify(value, null, 2)}\n`);
         },
         async writeJsonAtomic(targetPath, value) {
-            await fs.mkdir(path.dirname(targetPath), { recursive: true });
-            const tempPath = `${targetPath}.${process.pid}.tmp`;
-            await fs.writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-            await fs.rename(tempPath, targetPath);
+            await runFileOperation(async () => {
+                await fs.mkdir(path.dirname(targetPath), { recursive: true });
+                const tempPath = `${targetPath}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
+                await fs.writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+                await fs.rename(tempPath, targetPath);
+            });
         },
         async ensureFile(targetPath, content, options = {}) {
             if (!options.overwrite && await this.pathExists(targetPath)) {
@@ -62,13 +74,75 @@ export function createNodeFileSystemAdapter() {
             return true;
         },
         async removePath(targetPath, options = {}) {
-            await fs.rm(targetPath, {
+            await runFileOperation(() => fs.rm(targetPath, {
                 recursive: options.recursive ?? false,
                 force: options.force ?? false
-            });
+            }));
+        }
+    };
+}
+const DEFAULT_FILE_OPERATION_CONCURRENCY = 32;
+const OPEN_FILE_RETRY_DELAYS_MS = [25, 50, 100, 200, 400, 800];
+function createFileOperationRunner(maxConcurrent = DEFAULT_FILE_OPERATION_CONCURRENCY) {
+    let active = 0;
+    const waiters = [];
+    async function acquire() {
+        if (active < maxConcurrent) {
+            active += 1;
+            return;
+        }
+        await new Promise((resolve) => waiters.push(resolve));
+    }
+    function release() {
+        const next = waiters.shift();
+        if (next) {
+            next();
+            return;
+        }
+        active = Math.max(0, active - 1);
+    }
+    return async (operation) => {
+        await acquire();
+        try {
+            return await retryOpenFileLimit(operation);
+        }
+        finally {
+            release();
         }
     };
 }
+async function retryOpenFileLimit(operation) {
+    let attempt = 0;
+    for (;;) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            const delayMs = OPEN_FILE_RETRY_DELAYS_MS[attempt];
+            if (!isOpenFileLimitError(error) || delayMs === undefined) {
+                throw error;
+            }
+            attempt += 1;
+            await delay(delayMs);
+        }
+    }
+}
+function isOpenFileLimitError(error) {
+    const code = getErrorCode(error);
+    return code === "EMFILE" || code === "ENFILE";
+}
+function isMissingPathError(error) {
+    const code = getErrorCode(error);
+    return code === "ENOENT" || code === "ENOTDIR";
+}
+function getErrorCode(error) {
+    return typeof error === "object" && error !== null && "code" in error
+        ? String(error.code)
+        : undefined;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 export function resolveRepoPath(repoRoot, repoRelativePath) {
     if (path.isAbsolute(repoRelativePath)) {
         return repoRelativePath;

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/translation-routes.js

@@ -60,6 +60,11 @@ export function registerTranslationRoutes(app, deps) {
         await deps.translationService.clearSession(request.params.sessionId);
         return { ok: true };
     });
+    app.post("/api/translation/sessions/:sessionId/stop", async (request) => {
+        await requireCurrentProject(deps.projectService);
+        await deps.translationService.stopSession(request.params.sessionId);
+        return { ok: true };
+    });
     app.post("/api/translation/sessions/:sessionId/retry/:translationId", async (request) => {
         await requireCurrentProject(deps.projectService);
         return deps.translationService.retryTranslation(request.params.sessionId, request.params.translationId);

package/dist/backend/gateway/channels/weixin-ilink-channel.js

@@ -47,14 +47,14 @@ export function createWeixinIlinkChannel(options = {}) {
     async function fetchJson(input) {
         const controller = input.timeoutMs !== undefined ? new AbortController() : undefined;
         const timeout = controller ? setTimeout(() => controller.abort(), input.timeoutMs) : undefined;
-        const signal = combineSignals(controller?.signal, input.signal);
+        const combinedSignal = combineSignals(controller?.signal, input.signal);
         const url = new URL(input.endpoint, ensureTrailingSlash(input.requestBaseUrl));
         try {
             const response = await fetchImpl(url, {
                 method: input.method,
                 headers: input.jsonHeaders === false ? buildIlinkAppHeaders() : buildJsonHeaders(input.token),
                 body: input.body === undefined ? undefined : JSON.stringify(input.body),
-                signal
+                signal: combinedSignal.signal
             });
             const rawText = await response.text();
             if (!response.ok) {
@@ -66,6 +66,7 @@ export function createWeixinIlinkChannel(options = {}) {
             if (timeout) {
                 clearTimeout(timeout);
             }
+            combinedSignal.cleanup();
         }
     }
     async function post(input) {
@@ -285,10 +286,22 @@ function randomWechatUin() {
 }
 function combineSignals(first, second) {
     if (!first) {
-        return second;
+        return {
+            signal: second,
+            cleanup() { }
+        };
     }
     if (!second) {
-        return first;
+        return {
+            signal: first,
+            cleanup() { }
+        };
+    }
+    if (first === second) {
+        return {
+            signal: first,
+            cleanup() { }
+        };
     }
     const controller = new AbortController();
     const abort = () => controller.abort();
@@ -297,7 +310,13 @@ function combineSignals(first, second) {
     if (first.aborted || second.aborted) {
         controller.abort();
     }
-    return controller.signal;
+    return {
+        signal: controller.signal,
+        cleanup() {
+            first.removeEventListener("abort", abort);
+            second.removeEventListener("abort", abort);
+        }
+    };
 }
 function stringOrUndefined(value) {
     return typeof value === "string" ? value : undefined;

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

@@ -25,28 +25,52 @@ export function createGatewayService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     let pollAbort = null;
     let pollLoopPromise = null;
+    let pollStartingPromise = null;
     let qrLogin = null;
     let lastFailedTranslation = null;
     function isRunning() {
         return Boolean(pollAbort && !pollAbort.signal.aborted);
     }
     async function ensurePolling() {
-        const settings = await deps.settings.loadSettings();
-        if (!settings.binding.token || isRunning()) {
+        if (isRunning()) {
             return;
         }
-        pollAbort = new AbortController();
-        pollLoopPromise = pollLoop(pollAbort.signal).finally(() => {
-            pollAbort = null;
-            pollLoopPromise = null;
+        if (pollStartingPromise) {
+            await pollStartingPromise;
+            return;
+        }
+        pollStartingPromise = (async () => {
+            const settings = await deps.settings.loadSettings();
+            if (!settings.binding.token || isRunning()) {
+                return;
+            }
+            const controller = new AbortController();
+            pollAbort = controller;
+            const loop = pollLoop(controller.signal).finally(() => {
+                if (pollAbort === controller) {
+                    pollAbort = null;
+                }
+                if (pollLoopPromise === loop) {
+                    pollLoopPromise = null;
+                }
+            });
+            pollLoopPromise = loop;
+        })().finally(() => {
+            pollStartingPromise = null;
         });
+        await pollStartingPromise;
     }
     async function stopPolling() {
+        await pollStartingPromise?.catch(() => undefined);
         if (!pollAbort) {
             return;
         }
-        pollAbort.abort();
+        const controller = pollAbort;
+        controller.abort();
         await pollLoopPromise?.catch(() => undefined);
+        if (pollAbort === controller) {
+            pollAbort = null;
+        }
     }
     function toAccount(settings) {
         if (!settings.binding.token) {
@@ -643,7 +667,7 @@ export function createGatewayService(deps) {
             await ensurePolling();
         },
         stop() {
-            void stopPolling();
+            return stopPolling();
         },
         async getStatus() {
             const settings = await syncDesktopContext(await deps.settings.loadSettings());
@@ -802,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 });
@@ -111,7 +115,7 @@ export async function createServer(deps, options = {}) {
         await deps.gatewayService.start();
     });
     app.addHook("onClose", async () => {
-        deps.gatewayService.stop();
+        await deps.gatewayService.stop();
     });
     if (options.staticDir) {
         await app.register(fastifyStatic, {
@@ -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

@@ -703,6 +703,10 @@ export function createTranslationService(deps) {
             });
             return () => {
                 state.listeners.delete(listener);
+                if (state.listeners.size === 0 && state.unsubscribeTranscript) {
+                    state.unsubscribeTranscript();
+                    state.unsubscribeTranscript = undefined;
+                }
             };
         },
         async clearSession(sessionId) {
@@ -795,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 {};