adhdev 0.9.12 → 0.9.14

package/dist/cli/index.js

@@ -9487,14 +9487,14 @@ async function handleOpenPanel(h, args) {
     success: revealState.visible || focusState.focused
   };
 }
-function handlePtyInput(h, args) {
+async function handlePtyInput(h, args) {
   const { cliType, data, targetSessionId } = args || {};
   if (!data) return { success: false, error: "data required" };
   const adapter = h.getCliAdapter(targetSessionId || cliType);
   if (!adapter || typeof adapter.writeRaw !== "function") {
     return { success: false, error: `CLI adapter not found: ${targetSessionId || cliType || "unknown"}` };
   }
-  adapter.writeRaw(data);
+  await adapter.writeRaw(data);
   return { success: true };
 }
 function handlePtyResize(_h, args) {
@@ -9671,7 +9671,7 @@ async function executeProviderScript(h, args, scriptName) {
       if (cliCommand?.type === "send_message" && cliCommand.text) {
         await adapter.sendMessage(cliCommand.text);
       } else if (cliCommand?.type === "pty_write" && cliCommand.text && adapter.writeRaw) {
-        adapter.writeRaw(cliCommand.text + "\r");
+        await adapter.writeRaw(cliCommand.text + "\r");
       }
       applyProviderPatch(h, args, parsed.payload);
       return {
@@ -13971,6 +13971,29 @@ var init_provider_cli_adapter = __esm({
         }
         await this.sendMessage(promptText);
       }
+      async writeToPty(data) {
+        if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
+        await this.ptyProcess.write(data);
+      }
+      resetPendingSendState(reason) {
+        this.isWaitingForResponse = false;
+        this.responseBuffer = "";
+        this.currentTurnScope = null;
+        this.submitPendingUntil = 0;
+        this.clearIdleFinishCandidate(reason);
+        if (this.responseTimeout) {
+          clearTimeout(this.responseTimeout);
+          this.responseTimeout = null;
+        }
+        if (this.submitRetryTimer) {
+          clearTimeout(this.submitRetryTimer);
+          this.submitRetryTimer = null;
+        }
+        if (this.finishRetryTimer) {
+          clearTimeout(this.finishRetryTimer);
+          this.finishRetryTimer = null;
+        }
+      }
       async sendMessage(text) {
         if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
         const allowInputDuringGeneration = this.provider.allowInputDuringGeneration === true;
@@ -14065,19 +14088,29 @@ var init_provider_cli_adapter = __esm({
             if (this.isWaitingForResponse) this.finishResponse();
           }, this.timeouts.maxResponse);
         };
-        await new Promise((resolve18) => {
+        await new Promise((resolve18, reject) => {
           let resolved = false;
           const resolveOnce = () => {
             if (resolved) return;
             resolved = true;
             resolve18();
           };
+          const rejectOnce = (error48) => {
+            if (resolved) return;
+            this.resetPendingSendState("send_write_failed");
+            resolved = true;
+            reject(error48);
+          };
+          const writeRetryKey = (mode) => {
+            void this.writeToPty(this.sendKey).catch((error48) => {
+              LOG.warn("CLI", `[${this.cliType}] ${mode} write failed: ${error48?.message || error48}`);
+            });
+          };
           const submit = () => {
             if (!this.ptyProcess) {
               resolveOnce();
               return;
             }
-            commitUserTurn();
             this.submitPendingUntil = 0;
             const screenText = this.terminalScreen.getText();
             this.recordTrace("submit_write", {
@@ -14085,7 +14118,6 @@ var init_provider_cli_adapter = __esm({
               sendKey: this.sendKey,
               screenText: summarizeCliTraceText(screenText, 500)
             });
-            this.ptyProcess.write(this.sendKey);
             const retrySubmitIfStuck = (attempt) => {
               this.submitRetryTimer = null;
               if (!this.ptyProcess || !this.isWaitingForResponse || this.submitRetryUsed) return;
@@ -14105,19 +14137,21 @@ var init_provider_cli_adapter = __esm({
                 sendKey: this.sendKey,
                 screenText: summarizeCliTraceText(screenText2, 500)
               });
-              this.ptyProcess.write(this.sendKey);
+              writeRetryKey("submit_retry");
               if (attempt >= 3) {
                 this.submitRetryUsed = true;
                 return;
               }
               this.submitRetryTimer = setTimeout(() => retrySubmitIfStuck(attempt + 1), retryDelayMs);
             };
-            this.submitRetryTimer = setTimeout(() => retrySubmitIfStuck(1), retryDelayMs);
-            startResponseTimeout();
-            resolveOnce();
+            void this.writeToPty(this.sendKey).then(() => {
+              commitUserTurn();
+              this.submitRetryTimer = setTimeout(() => retrySubmitIfStuck(1), retryDelayMs);
+              startResponseTimeout();
+              resolveOnce();
+            }, rejectOnce);
           };
           if (this.submitStrategy === "immediate") {
-            commitUserTurn();
             this.submitPendingUntil = 0;
             this.recordTrace("submit_write", {
               mode: "immediate",
@@ -14125,37 +14159,38 @@ var init_provider_cli_adapter = __esm({
               sendKey: this.sendKey,
               screenText: summarizeCliTraceText(this.terminalScreen.getText(), 500)
             });
-            this.ptyProcess.write(text + this.sendKey);
-            this.submitRetryTimer = setTimeout(() => {
-              this.submitRetryTimer = null;
-              if (!this.ptyProcess || !this.isWaitingForResponse || this.submitRetryUsed) return;
-              if (this.currentStatus === "waiting_approval") return;
-              if (this.hasMeaningfulResponseBuffer(normalizedPromptSnippet)) return;
-              const screenText = this.terminalScreen.getText();
-              if (!promptLikelyVisible(screenText, normalizedPromptSnippet)) return;
-              const liveApproval = this.runParseApproval(screenText) || this.runParseApproval(this.recentOutputBuffer);
-              if (liveApproval) return;
-              const liveStatus = this.runDetectStatus(screenText) || this.runDetectStatus(this.recentOutputBuffer);
-              if (liveStatus === "generating" || liveStatus === "waiting_approval") return;
-              LOG.info("CLI", `[${this.cliType}] Retrying submit key for stuck prompt (attempt 1)`);
-              this.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
-              this.recordTrace("submit_write", {
-                mode: "immediate_retry",
-                attempt: 1,
-                sendKey: this.sendKey,
-                screenText: summarizeCliTraceText(screenText, 500)
-              });
-              this.ptyProcess.write(this.sendKey);
-              this.submitRetryUsed = true;
-            }, retryDelayMs);
-            startResponseTimeout();
-            resolveOnce();
+            void this.writeToPty(text + this.sendKey).then(() => {
+              commitUserTurn();
+              this.submitRetryTimer = setTimeout(() => {
+                this.submitRetryTimer = null;
+                if (!this.ptyProcess || !this.isWaitingForResponse || this.submitRetryUsed) return;
+                if (this.currentStatus === "waiting_approval") return;
+                if (this.hasMeaningfulResponseBuffer(normalizedPromptSnippet)) return;
+                const screenText = this.terminalScreen.getText();
+                if (!promptLikelyVisible(screenText, normalizedPromptSnippet)) return;
+                const liveApproval = this.runParseApproval(screenText) || this.runParseApproval(this.recentOutputBuffer);
+                if (liveApproval) return;
+                const liveStatus = this.runDetectStatus(screenText) || this.runDetectStatus(this.recentOutputBuffer);
+                if (liveStatus === "generating" || liveStatus === "waiting_approval") return;
+                LOG.info("CLI", `[${this.cliType}] Retrying submit key for stuck prompt (attempt 1)`);
+                this.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
+                this.recordTrace("submit_write", {
+                  mode: "immediate_retry",
+                  attempt: 1,
+                  sendKey: this.sendKey,
+                  screenText: summarizeCliTraceText(screenText, 500)
+                });
+                writeRetryKey("immediate_retry");
+                this.submitRetryUsed = true;
+              }, retryDelayMs);
+              startResponseTimeout();
+              resolveOnce();
+            }, rejectOnce);
             return;
           }
           if (submitDelayMs > 0) {
             this.submitPendingUntil = Date.now() + submitDelayMs;
           }
-          this.ptyProcess.write(text);
           this.recordTrace("submit_write", {
             mode: "type_then_submit",
             text: summarizeCliTraceText(text, 500),
@@ -14192,7 +14227,7 @@ var init_provider_cli_adapter = __esm({
             }
             setTimeout(waitForEchoAndSubmit, 50);
           };
-          waitForEchoAndSubmit();
+          void this.writeToPty(text).then(() => waitForEchoAndSubmit(), rejectOnce);
         });
       }
       getPartialResponse() {
@@ -14347,12 +14382,12 @@ var init_provider_cli_adapter = __esm({
       isReady() {
         return this.ready;
       }
-      writeRaw(data) {
+      async writeRaw(data) {
         this.recordTrace("write_raw", {
           keys: JSON.stringify(data),
           length: data.length
         });
-        this.ptyProcess?.write(data);
+        await this.writeToPty(data);
       }
       resolveModal(buttonIndex) {
         let modal = this.activeModal || this.runParseApproval(this.recentOutputBuffer);
@@ -14898,7 +14933,7 @@ var init_cli_provider_instance = __esm({
         if (cliCommand?.type === "send_message" && cliCommand.text) {
           await this.adapter.sendMessage(cliCommand.text);
         } else if (cliCommand?.type === "pty_write" && cliCommand.text) {
-          this.adapter.writeRaw(cliCommand.text + "\r");
+          await this.adapter.writeRaw(cliCommand.text + "\r");
         }
         this.applyProviderResponse(parsed.payload, { phase: "immediate" });
       }
@@ -38684,10 +38719,14 @@ var init_router = __esm({
                 currentInstalled = parsed?.dependencies?.[pkgName]?.version || null;
               } catch {
               }
-              if (currentInstalled === latest) {
+              const runningVersion = typeof this.deps.statusVersion === "string" ? this.deps.statusVersion.trim().replace(/^v/, "") : null;
+              if (currentInstalled === latest && runningVersion === latest) {
                 LOG.info("Upgrade", `Already on latest version v${latest}; skipping install`);
                 return { success: true, upgraded: false, alreadyLatest: true, version: latest };
               }
+              if (currentInstalled === latest && runningVersion && runningVersion !== latest) {
+                LOG.info("Upgrade", `Installed package is v${latest}, but running daemon is v${runningVersion}; scheduling restart`);
+              }
               spawnDetachedDaemonUpgradeHelper({
                 packageName: pkgName,
                 targetVersion: latest,
@@ -42873,7 +42912,7 @@ async function handleCliRaw(ctx, req, res) {
   }
   try {
     if (typeof adapter.writeRaw === "function") {
-      adapter.writeRaw(keys);
+      await adapter.writeRaw(keys);
       ctx.json(res, 200, { sent: true, type: target.type, instanceId: target.instanceId, keysLength: keys.length });
     } else {
       ctx.json(res, 400, { error: "writeRaw not available on this adapter" });
@@ -45836,7 +45875,7 @@ var init_session_host_transport = __esm({
         this.exitCallbacks.add(callback);
       }
       write(data) {
-        this.enqueue(async () => {
+        return this.enqueue(async () => {
           let response = await this.client.request({
             type: "send_input",
             payload: {
@@ -46138,9 +46177,11 @@ var init_session_host_transport = __esm({
         };
       }
       enqueue(action) {
-        this.operationChain = this.operationChain.then(() => this.ready).then(action).catch((error48) => {
+        const operation = this.operationChain.then(() => this.ready).then(action);
+        this.operationChain = operation.catch((error48) => {
           LOG.warn("CLI", `[session-host:${this.options.runtimeId}] ${error48?.message || error48}`);
         });
+        return operation;
       }
       async closeClient(destroy = false) {
         if (this.closed) return;
@@ -78731,14 +78772,41 @@ function routeDataChannelMessage(peerId, msg, peers, handlers) {
       return;
     }
     if (parsed.type === "pty_input") {
-      const permission = peers.get(peerId)?.sharePermission;
+      const peer = peers.get(peerId);
+      const permission = peer?.sharePermission;
+      const sendPtyInputError = (sessionId2, reason, error48) => {
+        const message = error48 instanceof Error ? error48.message : typeof error48 === "string" ? error48 : void 0;
+        sendToPeer(peer, {
+          type: "session_io_error",
+          sessionId: sessionId2,
+          reason,
+          ...message ? { error: message } : {}
+        });
+      };
       if (permission) {
         log(`pty_input: REJECTED \u2014 permission=${permission} peer=${peerId}`);
+        const sessionId2 = typeof (parsed.sessionId || parsed.targetSessionId || parsed.cliId || parsed.cliType) === "string" ? parsed.sessionId || parsed.targetSessionId || parsed.cliId || parsed.cliType : "";
+        sendPtyInputError(sessionId2, "permission_denied");
+        return;
+      }
+      const sessionIdCandidate = parsed.sessionId || parsed.targetSessionId || parsed.cliId || parsed.cliType || "";
+      const sessionId = typeof sessionIdCandidate === "string" ? sessionIdCandidate : "";
+      if (!sessionId || typeof parsed.data !== "string" || parsed.data.length === 0) {
+        sendPtyInputError(sessionId, "invalid_payload");
+        return;
+      }
+      if (!handlers.ptyInputHandler) {
+        sendPtyInputError(sessionId, "handler_unavailable");
         return;
       }
-      const sessionId = parsed.sessionId || parsed.targetSessionId || parsed.cliId || parsed.cliType || "";
-      if (handlers.ptyInputHandler && parsed.data && sessionId) {
-        handlers.ptyInputHandler(sessionId, parsed.data);
+      try {
+        Promise.resolve(handlers.ptyInputHandler(sessionId, parsed.data)).catch((error48) => {
+          log(`pty_input write failed: peer=${peerId} sessionId=${sessionId} error=${error48?.message || error48}`);
+          sendPtyInputError(sessionId, "write_failed", error48);
+        });
+      } catch (error48) {
+        log(`pty_input write failed: peer=${peerId} sessionId=${sessionId} error=${error48?.message || error48}`);
+        sendPtyInputError(sessionId, "write_failed", error48);
       }
       return;
     }
@@ -87072,21 +87140,65 @@ function isAdhdevProcess(pid) {
     return true;
   }
 }
-function getDaemonPid(ref = {}) {
-  const pidFile = getDaemonPidFile(ref);
+function getDaemonHealthPid(ref = {}) {
+  const port = resolveDaemonPort(ref);
   try {
-    if (!fs23.existsSync(pidFile)) return null;
-    const pid = parseInt(fs23.readFileSync(pidFile, "utf-8").trim(), 10);
+    const { execFileSync: execFileSync5 } = require("child_process");
+    const probe = `
+            const http = require('http');
+            const req = http.get('http://127.0.0.1:${port}/health', { timeout: 1500 }, (res) => {
+                let body = '';
+                res.setEncoding('utf8');
+                res.on('data', (chunk) => { body += chunk; });
+                res.on('end', () => {
+                    if (res.statusCode !== 200) return;
+                    try {
+                        const json = JSON.parse(body || '{}');
+                        if (Number.isFinite(json.pid)) process.stdout.write(String(json.pid));
+                    } catch {}
+                });
+            });
+            req.on('error', () => {});
+            req.on('timeout', () => { req.destroy(); });
+        `;
+    const result = execFileSync5(process.execPath, ["-e", probe], {
+      encoding: "utf-8",
+      timeout: 3e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const pid = parseInt(result, 10);
     return Number.isFinite(pid) ? pid : null;
   } catch {
     return null;
   }
 }
+function getDaemonPid(ref = {}) {
+  const pidFile = getDaemonPidFile(ref);
+  try {
+    if (fs23.existsSync(pidFile)) {
+      const pid = parseInt(fs23.readFileSync(pidFile, "utf-8").trim(), 10);
+      if (Number.isFinite(pid)) return pid;
+    }
+  } catch {
+  }
+  return getDaemonHealthPid(ref);
+}
 function stopDaemon(ref = {}) {
   const pidFile = getDaemonPidFile(ref);
+  let pid = null;
+  try {
+    if (fs23.existsSync(pidFile)) {
+      const pidFromFile = parseInt(fs23.readFileSync(pidFile, "utf-8").trim(), 10);
+      if (Number.isFinite(pidFromFile)) pid = pidFromFile;
+    }
+  } catch {
+    removeDaemonPid(ref);
+  }
+  if (pid === null) {
+    pid = getDaemonHealthPid(ref);
+  }
+  if (pid === null) return false;
   try {
-    if (!fs23.existsSync(pidFile)) return false;
-    const pid = parseInt(fs23.readFileSync(pidFile, "utf-8").trim());
     process.kill(pid, "SIGTERM");
     removeDaemonPid(ref);
     return true;
@@ -87116,7 +87228,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.12" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.14" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;
@@ -87638,24 +87750,25 @@ ${err?.stack || ""}`);
                 return { id: req.id, success: result.success, entries: result.files, error: result.error };
               }
             });
-            this.p2p.onPtyInput((sessionId, data) => {
+            this.p2p.onPtyInput(async (sessionId, data) => {
               if (!this.isCliSession(sessionId)) {
                 this.logPtyInputDrop(sessionId, "not_cli_session");
-                return;
+                throw new Error("not_cli_session");
               }
               const found = this.components.cliManager.findAdapter(sessionId, { instanceKey: sessionId });
               if (!found) {
                 this.logPtyInputDrop(sessionId, "adapter_not_found");
-                return;
+                throw new Error("adapter_not_found");
               }
               if (typeof found.adapter.writeRaw !== "function") {
                 this.logPtyInputDrop(sessionId, "writeRaw_missing");
-                return;
+                throw new Error("writeRaw_missing");
               }
               try {
-                found.adapter.writeRaw(data);
-              } catch {
+                await found.adapter.writeRaw(data);
+              } catch (error48) {
                 this.logPtyInputDrop(sessionId, "write_failed");
+                throw error48;
               }
             });
             this.p2p.onPtyResize((sessionId, cols, rows) => {