vibelet 1.2.136 → 1.2.138

package/dist/runtime-version.cjs

@@ -1,2 +1,2 @@
-var c=require("node:fs"),n=require("node:path"),p="@vibelet/cli";function i(r){try{let e=JSON.parse((0,c.readFileSync)(r,"utf8"));if(e.name===p&&typeof e.version=="string"&&e.version.length>0)return e.version}catch{}return null}function l(){return"1.2.136"}var a=l();process.stdout.write(`${a}
+var c=require("node:fs"),n=require("node:path"),p="@vibelet/cli";function i(r){try{let e=JSON.parse((0,c.readFileSync)(r,"utf8"));if(e.name===p&&typeof e.version=="string"&&e.version.length>0)return e.version}catch{}return null}function l(){return"1.2.138"}var a=l();process.stdout.write(`${a}
 `);

package/dist/vibelet.mjs

@@ -11768,7 +11768,7 @@ __nccwpck_require__.d(__webpack_exports__, {
   gJ: () => (/* binding */ terminalControlTokenPath)
 });
 
-// UNUSED EXPORTS: buildClaudeSessionIdArgs, buildClaudeTerminalArgs, buildResumeNativeArgs, cleanupClaudeTerminalHookFiles, collectProcessTreePids, createClaudeTerminalHookFiles, createTerminalModeState, exitCodeFromChildExit, extractInitialSessionId, formatTerminalControlScreen, hasClaudeContinueArg, hasClaudeResumePickerArg, hasClaudeSettingsArg, requestSwitchBackWhenReady, resolveNativeAgentCommand, stopNativeChild
+// UNUSED EXPORTS: buildClaudeSessionIdArgs, buildClaudeTerminalArgs, buildResumeNativeArgs, cleanupClaudeTerminalHookFiles, collectProcessTreePids, connectTerminalControl, createClaudeTerminalHookFiles, createTerminalModeState, exitCodeFromChildExit, extractInitialSessionId, formatTerminalControlScreen, hasClaudeContinueArg, hasClaudeResumePickerArg, hasClaudeSettingsArg, monitorTerminalControlUntilChildExit, requestSwitchBackWhenReady, resolveNativeAgentCommand, stopNativeChild
 
 // EXTERNAL MODULE: external "node:child_process"
 var external_node_child_process_ = __nccwpck_require__(1421);
@@ -11814,6 +11814,7 @@ const TAKEOVER_STOP_TIMEOUT_MS = 3000;
 const TAKEOVER_MODE_SETTLE_TIMEOUT_MS = TAKEOVER_STOP_TIMEOUT_MS + 2000;
 const SWITCHBACK_RESTORE_NOTICE_MS = 1200;
 const SWITCHBACK_BUSY_RETRY_DELAY_MS = 750;
+const TERMINAL_CONTROL_RECONNECT_DELAY_MS = 1000;
 const CLAUDE_HOOK_SECRET_HEADER = 'x-vibelet-claude-hook-secret';
 const ANSI_CLEAR_SCREEN = '\x1b[2J\x1b[H';
 const ANSI_HIDE_CURSOR = '\x1b[?25l';
@@ -12549,6 +12550,25 @@ async function connectTerminalControl({
   let activeChild = child;
   let activeChildExit = childExit;
   let heartbeatTimer = null;
+  let resolveClosed;
+  let closedResolved = false;
+  const closed = new Promise((resolve) => {
+    resolveClosed = resolve;
+  });
+
+  function resolveCloseOnce(code, reason) {
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+    requester.rejectAll('terminal_control_closed');
+    if (closedResolved) return;
+    closedResolved = true;
+    resolveClosed({
+      code,
+      reason: Buffer.isBuffer(reason) ? reason.toString('utf8') : String(reason ?? ''),
+    });
+  }
 
   async function sendSession(mode = getMode()) {
     if (!terminalId || !currentSessionId) return { ok: true };
@@ -12613,9 +12633,8 @@ async function connectTerminalControl({
     sendResponse(msg.id, true, { mode: 'remoteDaemon' });
   });
 
-  ws.on('close', () => {
-    if (heartbeatTimer) clearInterval(heartbeatTimer);
-    requester.rejectAll('terminal_control_closed');
+  ws.on('close', (code, reason) => {
+    resolveCloseOnce(code, reason);
   });
 
   const hello = await requester.sendRequest('terminal.hello', {
@@ -12651,6 +12670,10 @@ async function connectTerminalControl({
   if (typeof heartbeatTimer.unref === 'function') heartbeatTimer.unref();
 
   return {
+    closed,
+    getTerminalId() {
+      return terminalId;
+    },
     getSessionId() {
       return currentSessionId;
     },
@@ -12673,12 +12696,68 @@ async function connectTerminalControl({
       });
     },
     close() {
-      if (heartbeatTimer) clearInterval(heartbeatTimer);
-      ws.close();
+      if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+        heartbeatTimer = null;
+      }
+      if (ws.readyState === wrapper.OPEN || ws.readyState === wrapper.CONNECTING) {
+        ws.close();
+      }
     },
   };
 }
 
+async function monitorTerminalControlUntilChildExit({
+  childExit,
+  getControl,
+  setControl,
+  connectControl,
+  shouldReconnect = () => true,
+  retryDelayMs = TERMINAL_CONTROL_RECONNECT_DELAY_MS,
+  onControlDisconnected,
+  onReconnectFailure,
+}) {
+  const delayMs = Math.max(1, Number(retryDelayMs) || TERMINAL_CONTROL_RECONNECT_DELAY_MS);
+  const childExitEvent = childExit.then((exit) => ({ type: 'childExit', exit }));
+
+  while (true) {
+    const currentControl = getControl();
+    const waiters = [childExitEvent];
+    if (currentControl?.closed) {
+      waiters.push(
+        currentControl.closed.then((closeInfo) => ({
+          type: 'controlClosed',
+          control: currentControl,
+          closeInfo,
+        })),
+      );
+    }
+    if (!currentControl || !shouldReconnect()) {
+      waiters.push(waitMs(delayMs).then(() => ({ type: 'retry' })));
+    }
+
+    const event = await Promise.race(waiters);
+    if (event.type === 'childExit') {
+      return event.exit;
+    }
+
+    if (event.type === 'controlClosed' && getControl() === event.control) {
+      setControl(null);
+      onControlDisconnected?.(event.control, event.closeInfo);
+    }
+
+    if (getControl() || !shouldReconnect()) {
+      continue;
+    }
+
+    try {
+      setControl(await connectControl());
+    } catch (error) {
+      onReconnectFailure?.(error);
+    }
+  }
+}
+
 async function runManagedNativeTerminal({
   agent,
   args,
@@ -12716,11 +12795,49 @@ async function runManagedNativeTerminal({
   let signalHandlers = null;
   const modeState = createTerminalModeState('localNative');
   let control = null;
+  let terminalId = claudeHookFiles?.terminalId ?? null;
+
+  function rememberControlState(nextControl) {
+    const nextTerminalId = nextControl?.getTerminalId?.();
+    if (nextTerminalId) terminalId = nextTerminalId;
+    const nextSessionId = nextControl?.getSessionId?.();
+    if (nextSessionId) initialSessionId = nextSessionId;
+  }
 
   try {
     while (true) {
       activeChild = await spawnNativeChild(command, nativeArgs, { cwd, env });
       const childExit = waitForChildExit(activeChild);
+      let reportedTerminalControlFailure = false;
+      const reportTerminalControlFailure = (prefix, error) => {
+        if (reportedTerminalControlFailure) return;
+        reportedTerminalControlFailure = true;
+        stderr.write(`${prefix}: ${error instanceof Error ? error.message : String(error)}\n`);
+      };
+      const connectActiveControl = async () => {
+        const nextControl = await connectTerminalControl({
+          agent,
+          cwd,
+          argv,
+          child: activeChild,
+          childExit,
+          cliVersion,
+          port,
+          token,
+          initialSessionId,
+          requestedTerminalId: terminalId ?? claudeHookFiles?.terminalId,
+          getMode: () => modeState.getMode(),
+          setMode: (nextMode) => modeState.setMode(nextMode),
+          stderr,
+        });
+        rememberControlState(nextControl);
+        reportedTerminalControlFailure = false;
+        return nextControl;
+      };
+      const setActiveControl = (nextControl) => {
+        control = nextControl;
+        rememberControlState(nextControl);
+      };
       if (!signalHandlers) {
         signalHandlers = installTerminalSignalHandlers(
           () => activeChild,
@@ -12732,30 +12849,32 @@ async function runManagedNativeTerminal({
         stderr.write('Vibelet terminal control is unavailable; running native TUI without App takeover.\n');
       } else if (!control) {
         try {
-          control = await connectTerminalControl({
-            agent,
-            cwd,
-            argv,
-            child: activeChild,
-            childExit,
-            cliVersion,
-            port,
-            token,
-            initialSessionId,
-            requestedTerminalId: claudeHookFiles?.terminalId,
-            getMode: () => modeState.getMode(),
-            setMode: (nextMode) => modeState.setMode(nextMode),
-            stderr,
-          });
+          setActiveControl(await connectActiveControl());
         } catch (error) {
-          stderr.write(`Vibelet terminal control failed: ${error instanceof Error ? error.message : String(error)}\n`);
+          reportTerminalControlFailure('Vibelet terminal control failed', error);
         }
       } else {
         control.setChild(activeChild, childExit);
         await control.sendSession('localNative');
+        rememberControlState(control);
       }
 
-      const exit = await childExit;
+      const exit = token
+        ? await monitorTerminalControlUntilChildExit({
+            childExit,
+            getControl: () => control,
+            setControl: setActiveControl,
+            connectControl: connectActiveControl,
+            shouldReconnect: () => modeState.getMode() === 'localNative',
+            onControlDisconnected: (closedControl) => {
+              rememberControlState(closedControl);
+              stderr.write('Vibelet terminal control disconnected; reconnecting so App takeover can resume.\n');
+            },
+            onReconnectFailure: (error) => {
+              reportTerminalControlFailure('Vibelet terminal control reconnect failed', error);
+            },
+          })
+        : await childExit;
       if (modeState.getMode() === 'switchingToRemote') {
         await modeState.waitUntilModeLeaves('switchingToRemote', TAKEOVER_MODE_SETTLE_TIMEOUT_MS);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibelet",
-  "version": "1.2.136",
+  "version": "1.2.138",
   "description": "Cross-platform CLI for installing and running the Vibelet daemon",
   "homepage": "https://vibelet.icu",
   "files": [