vibe-coding-master 0.5.5 → 0.6.0

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

@@ -23,4 +23,9 @@ export function registerGatewayRoutes(app, deps) {
     app.post("/api/gateway/binding/reset", async () => {
         return deps.gatewayService.resetBinding();
     });
+    // Arm/disarm the runtime channel-connection switch (process-local, not
+    // persisted). Returns the updated GatewayStatus.
+    app.put("/api/gateway/connection", async (request) => {
+        return deps.gatewayService.setConnectionEnabled(request.body.enabled);
+    });
 }

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

@@ -30,10 +30,20 @@ export function createGatewayService(deps) {
     let qrLogin = null;
     let larkRegistrationState = null;
     let lastFailedTranslation = null;
+    // Runtime channel-connection arming switch. Not persisted: every process starts
+    // disarmed. `ensurePolling` is the single chokepoint that reads it, so no
+    // self-heal path can connect the channel while this is false.
+    let connectionEnabled = false;
     function isRunning() {
         return Boolean(pollAbort && !pollAbort.signal.aborted);
     }
     async function ensurePolling() {
+        // Single chokepoint for the runtime connection switch: while disarmed, no
+        // auto-connect path (boot, getStatus/reconcile self-heal, QR success,
+        // updateSettings) may start the poll loop.
+        if (!connectionEnabled) {
+            return;
+        }
         if (isRunning()) {
             return;
         }
@@ -720,7 +730,7 @@ export function createGatewayService(deps) {
                 await enableGatewayTranslationRuntime();
             }
             await ensurePolling();
-            return deps.settings.expose(settings, isRunning());
+            return deps.settings.expose(settings, isRunning(), connectionEnabled);
         },
         async updateSettings(input) {
             const gatewayStartInput = input.enabled === true
@@ -745,15 +755,31 @@ export function createGatewayService(deps) {
             else {
                 await stopPolling();
             }
-            return deps.settings.expose(settings, isRunning());
+            return deps.settings.expose(settings, isRunning(), connectionEnabled);
         },
         async resetBinding() {
             await stopPolling();
+            // Disarm the connection switch on reset so no connection survives a
+            // binding reset.
+            connectionEnabled = false;
             lastFailedTranslation = null;
             qrLogin = null;
             larkRegistrationState = null;
             const settings = await deps.settings.resetBinding();
-            return deps.settings.expose(settings, isRunning());
+            return deps.settings.expose(settings, isRunning(), connectionEnabled);
+        },
+        async setConnectionEnabled(enabled) {
+            connectionEnabled = enabled;
+            // Armed → connect now if an account is configured; disarmed → abort the
+            // poll loop (the Lark WS closes via the abort path in waitForUpdates).
+            if (enabled) {
+                await ensurePolling();
+            }
+            else {
+                await stopPolling();
+            }
+            const settings = await deps.settings.loadSettings();
+            return deps.settings.expose(settings, isRunning(), connectionEnabled);
         },
         async startQrLogin() {
             const settings = await deps.settings.loadSettings();
@@ -921,7 +947,7 @@ export function createGatewayService(deps) {
             });
             larkRegistrationState = null;
             await ensurePolling();
-            const status = deps.settings.expose(settings, isRunning());
+            const status = deps.settings.expose(settings, isRunning(), connectionEnabled);
             return {
                 status: "confirmed",
                 appIdConfigured: Boolean(result.appId),
@@ -985,7 +1011,7 @@ export function createGatewayService(deps) {
             });
             larkRegistrationState = null;
             await ensurePolling();
-            const status = deps.settings.expose(settings, isRunning());
+            const status = deps.settings.expose(settings, isRunning(), connectionEnabled);
             return {
                 status: "confirmed",
                 appIdConfigured: true,
@@ -1013,7 +1039,9 @@ export function createGatewayService(deps) {
             const settings = await deps.settings.loadSettings();
             const account = toAccount(settings);
             const boundUserId = settings.binding.boundUserId;
-            if (!settings.enabled || !account || !boundUserId) {
+            // A disarmed gateway never touches the channel: skip the outbound push.
+            // The latest reply was already cached above and replays on the next /start.
+            if (!connectionEnabled || !settings.enabled || !account || !boundUserId) {
                 return;
             }
             const cursorKey = `${input.taskSlug}:project-manager:${input.session.claudeSessionId}`;

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

@@ -79,11 +79,12 @@ export function createGatewaySettingsService(deps) {
                 updatedAt: now()
             });
         },
-        expose(settings, running = false) {
+        expose(settings, running = false, connectionEnabled = false) {
             return {
                 version: 1,
                 enabled: settings.enabled,
                 running,
+                connectionEnabled,
                 channel: settings.channel,
                 translationEnabled: settings.translationEnabled,
                 currentProjectId: settings.currentProjectId,

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

@@ -15,6 +15,15 @@ const HARNESS_ENGINEER_SESSION_PATH = ".ai/vcm/harness-engineer/session.json";
 const PROJECT_TRANSLATOR_SCOPE = "__project__";
 const PROJECT_HARNESS_ENGINEER_SCOPE = "__project_harness_engineer__";
 const PROJECT_TOOL_CD_ENTER_DELAY_MS = 500;
+// Project tool sessions launch a Claude Code TUI inside a PTY. The PTY reports
+// "running" the instant it is spawned, which is earlier than the moment the TUI
+// can actually accept pasted input. These bounds drive a quiescence-based
+// readiness wait (first output seen, then no further output for a short window)
+// used before any programmatic input, and as the liveness probe that detects a
+// resume-by-id launch that died before becoming usable.
+const SESSION_READY_POLL_INTERVAL_MS = 100;
+const SESSION_READY_QUIESCENT_POLLS = 3;
+const SESSION_READY_MAX_POLLS = 60;
 export function createSessionService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     async function readCurrentHarnessRevision(repoRoot) {
@@ -201,6 +210,17 @@ export function createSessionService(deps) {
         };
         deps.registry.upsert(record);
         await persistTranslatorSession(deps.fs, repoRoot, record);
+        if (launchMode === "resume") {
+            if ((await waitForSessionInputReady(record.id)) === "exited") {
+                // Resume by claudeSessionId failed (Claude could not reopen the session
+                // and the process exited). Drop the stale id and rebuild a fresh session
+                // so a broken id cannot wedge auto-reconcile on the same resume forever.
+                deps.registry.remove(record.id);
+                await clearPersistedTranslatorSession(deps.fs, repoRoot);
+                return launchProjectTranslatorSession(repoRoot, input, "fresh");
+            }
+            return withHarnessRevisionView(repoRoot, await migrateRunningProjectToolSessionCwd(repoRoot, record, taskContext.taskRepoRoot, { alreadyReady: true }));
+        }
         return withHarnessRevisionView(repoRoot, await migrateRunningProjectToolSessionCwd(repoRoot, record, taskContext.taskRepoRoot));
     }
     async function launchProjectHarnessEngineerSession(repoRoot, input, launchMode) {
@@ -288,6 +308,16 @@ export function createSessionService(deps) {
         };
         deps.registry.upsert(record);
         await persistHarnessEngineerSession(deps.fs, repoRoot, record);
+        if (launchMode === "resume") {
+            if ((await waitForSessionInputReady(record.id)) === "exited") {
+                // Resume by claudeSessionId failed; drop the stale id and rebuild a fresh
+                // session so a broken id cannot wedge auto-reconcile on the same resume.
+                deps.registry.remove(record.id);
+                await clearPersistedHarnessEngineerSession(deps.fs, repoRoot);
+                return launchProjectHarnessEngineerSession(repoRoot, input, "fresh");
+            }
+            return withHarnessRevisionView(repoRoot, await migrateRunningProjectToolSessionCwd(repoRoot, record, taskContext.taskRepoRoot, { alreadyReady: true }));
+        }
         return withHarnessRevisionView(repoRoot, await migrateRunningProjectToolSessionCwd(repoRoot, record, taskContext.taskRepoRoot));
     }
     async function resolveProjectToolTaskContext(repoRoot, input, roleLabel) {
@@ -306,7 +336,42 @@ export function createSessionService(deps) {
             taskRepoRoot: getTaskRuntimeRepoRoot(task)
         };
     }
-    async function migrateRunningProjectToolSessionCwd(repoRoot, session, targetCwd) {
+    // Wait until a freshly spawned/resumed session's TUI is ready to receive
+    // programmatic input, or until it has clearly failed to start. Readiness is
+    // inferred from terminal output quiescence reported by the runtime: once the
+    // session has emitted output and then stayed quiet for SESSION_READY_QUIESCENT_POLLS
+    // consecutive polls, the TUI prompt is treated as input-ready. The wait is
+    // capped at SESSION_READY_MAX_POLLS so a perpetually chatty (or perpetually
+    // silent) session still proceeds best-effort. Returns "exited" if the runtime
+    // session is gone or no longer running, which a resume launch treats as a
+    // resume-by-id failure.
+    async function waitForSessionInputReady(sessionId) {
+        let sawOutput = false;
+        let lastOutputAt;
+        let quietPolls = 0;
+        for (let poll = 0; poll < SESSION_READY_MAX_POLLS; poll += 1) {
+            const live = deps.runtime.getSession(sessionId);
+            if (!live || isExitedStatus(live.status)) {
+                return "exited";
+            }
+            if (live.lastOutputAt) {
+                if (!sawOutput || live.lastOutputAt !== lastOutputAt) {
+                    sawOutput = true;
+                    lastOutputAt = live.lastOutputAt;
+                    quietPolls = 0;
+                }
+                else {
+                    quietPolls += 1;
+                    if (quietPolls >= SESSION_READY_QUIESCENT_POLLS) {
+                        return "ready";
+                    }
+                }
+            }
+            await delay(SESSION_READY_POLL_INTERVAL_MS);
+        }
+        return "ready";
+    }
+    async function migrateRunningProjectToolSessionCwd(repoRoot, session, targetCwd, options = {}) {
         if (session.role !== TRANSLATOR_ROLE
             && session.role !== HARNESS_ENGINEER_ROLE) {
             return session;
@@ -318,6 +383,9 @@ export function createSessionService(deps) {
         if (!runtimeSession || runtimeSession.status !== "running") {
             return session;
         }
+        if (!options.alreadyReady && (await waitForSessionInputReady(session.id)) === "exited") {
+            return session;
+        }
         assertSafeCwdTarget(targetCwd);
         const timestamp = now();
         await submitTerminalInput(deps.runtime, session.id, formatClaudeCdCommand(targetCwd), {
@@ -1293,3 +1361,12 @@ function formatClaudeCdCommand(targetCwd) {
     // newline is the only unsafe character and is rejected by assertSafeCwdTarget.
     return `/cd ${targetCwd}`;
 }
+function isExitedStatus(status) {
+    return status === "exited" || status === "crashed" || status === "missing";
+}
+function delay(ms) {
+    if (ms <= 0) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}