vibe-coding-master 0.3.3 → 0.3.5

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/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());

package/dist/backend/runtime/node-pty-runtime.js

@@ -33,16 +33,22 @@ export function createNodePtyTerminalRuntime(deps) {
             startedAt: now(),
             exitCode: null
         };
+        const logWriter = createTerminalLogWriter(deps.fs, input.logPath, deps.onLogWriteError ?? defaultLogWriteErrorHandler);
         const entry = {
             input,
             session,
             process: child,
-            listeners: new Set()
+            listeners: new Set(),
+            logWriter,
+            disposed: false
         };
         entries.set(session.id, entry);
         child.onData((data) => {
+            if (entry.disposed) {
+                return;
+            }
             entry.session.lastOutputAt = now();
-            void deps.fs.appendText(input.logPath, data);
+            entry.logWriter.append(data);
             emit(entry, {
                 sessionId: session.id,
                 taskSlug: input.taskSlug,
@@ -52,8 +58,13 @@ export function createNodePtyTerminalRuntime(deps) {
             });
         });
         child.onExit(({ exitCode }) => {
+            if (entry.disposed) {
+                return;
+            }
+            entry.disposed = true;
             entry.session.status = exitCode === 0 ? "exited" : "crashed";
             entry.session.exitCode = exitCode;
+            void entry.logWriter.close();
             emit(entry, {
                 sessionId: session.id,
                 taskSlug: input.taskSlug,
@@ -102,12 +113,16 @@ export function createNodePtyTerminalRuntime(deps) {
         },
         async stop(sessionId) {
             const entry = getEntry(entries, sessionId);
+            entry.disposed = true;
             entry.session.status = "exited";
             entry.process.kill();
+            await entry.logWriter.close();
         },
         async restart(sessionId) {
             const entry = getEntry(entries, sessionId);
+            entry.disposed = true;
             entry.process.kill();
+            await entry.logWriter.close();
             return create(entry.input, sessionId);
         },
         subscribe(sessionId, listener, options = {}) {
@@ -139,12 +154,40 @@ export function createNodePtyTerminalRuntime(deps) {
         }
     };
 }
+export function createTerminalLogWriter(fs, logPath, onError) {
+    let closed = false;
+    let pending = Promise.resolve();
+    return {
+        append(data) {
+            if (closed || !data) {
+                return;
+            }
+            pending = pending
+                .then(() => fs.appendText(logPath, data))
+                .catch((error) => {
+                try {
+                    onError(error, logPath);
+                }
+                catch {
+                    // Logging must never break terminal output delivery or future log writes.
+                }
+            });
+        },
+        async close() {
+            closed = true;
+            await pending.catch(() => undefined);
+        }
+    };
+}
 async function readTerminalReplayText(fs, logPath) {
     const data = fs.readTextTail
         ? await fs.readTextTail(logPath, TERMINAL_REPLAY_TAIL_LIMIT_BYTES)
         : tailTerminalReplay(await fs.readText(logPath));
     return tailTerminalReplay(data);
 }
+function defaultLogWriteErrorHandler(error, logPath) {
+    console.warn(`[VCM] Failed to append terminal log: ${logPath}`, error);
+}
 export function tailTerminalReplay(data, limitBytes = TERMINAL_REPLAY_TAIL_LIMIT_BYTES) {
     if (limitBytes <= 0 || Buffer.byteLength(data, "utf8") <= limitBytes) {
         return data;

package/dist/backend/server.js

@@ -111,7 +111,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, {

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) {