@synkro-sh/cli 1.3.26 → 1.3.27

package/dist/bootstrap.js

@@ -1677,7 +1677,7 @@ Commands:
   status               - print "running"/"stopped"
 """
 
-import os, sys, json, socket, time, signal, fcntl, re
+import os, sys, json, socket, time, signal, fcntl, re, select
 import subprocess, threading
 from pathlib import Path
 
@@ -1707,27 +1707,49 @@ def log(msg):
         pass
 
 
+STALL_TIMEOUT_SEC = int(os.environ.get("SYNKRO_DAEMON_STALL_TIMEOUT", "10"))
+
 def _read_response(proc, timeout=45):
     acc = []
     deadline = time.time() + timeout
+    last_data = time.time()
+    fd = proc.stdout.fileno()
+    buf = ""
     while True:
-        if time.time() > deadline:
+        remaining = deadline - time.time()
+        if remaining <= 0:
             log("read timeout")
             return ""
-        line = proc.stdout.readline()
-        if not line:
+        if time.time() - last_data > STALL_TIMEOUT_SEC:
+            log(f"stall timeout: no data for {STALL_TIMEOUT_SEC}s")
             return ""
-        try:
-            obj = json.loads(line)
-        except json.JSONDecodeError:
+        ready, _, _ = select.select([fd], [], [], min(remaining, 2.0))
+        if not ready:
+            if proc.poll() is not None:
+                log("process exited during read")
+                return ""
             continue
-        t = obj.get("type")
-        if t == "assistant":
-            for c in obj.get("message", {}).get("content", []):
-                if c.get("type") == "text":
-                    acc.append(c["text"])
-        elif t == "result":
-            return "".join(acc)
+        chunk = os.read(fd, 65536)
+        if not chunk:
+            return ""
+        last_data = time.time()
+        buf += chunk.decode("utf-8", errors="replace")
+        while "\\n" in buf:
+            line, buf = buf.split("\\n", 1)
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                obj = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            t = obj.get("type")
+            if t == "assistant":
+                for c in obj.get("message", {}).get("content", []):
+                    if c.get("type") == "text":
+                        acc.append(c["text"])
+            elif t == "result":
+                return "".join(acc)
 
 
 def _send_msg(proc, text):
@@ -1757,6 +1779,7 @@ class WarmGrader:
         self._warm_thread = None
         self._lock = threading.Lock()
         self._total_grades = 0
+        self._prewarm_ok = True
         self._start_prewarm()
 
     def _make_proc(self):
@@ -1786,27 +1809,32 @@ class WarmGrader:
             log("pre-warming process")
             proc = self._make_proc()
             _send_msg(proc, "Ready")
-            resp = _read_response(proc, timeout=30)
+            resp = _read_response(proc, timeout=15)
             if resp:
                 with self._lock:
                     old = self._warm_proc
                     self._warm_proc = proc
+                    self._prewarm_ok = True
                 if old:
                     self._kill_proc(old)
                 log(f"pre-warm ready ({len(resp)} chars)")
             else:
                 log("pre-warm response empty")
                 self._kill_proc(proc)
+                self._prewarm_ok = False
         except Exception as e:
             log(f"pre-warm failed: {e}")
+            self._prewarm_ok = False
 
     def _start_prewarm(self):
         self._warm_thread = threading.Thread(target=self._prewarm, daemon=True)
         self._warm_thread.start()
 
     def grade(self, prompt):
-        if self._warm_thread:
-            self._warm_thread.join(timeout=60)
+        if self._warm_thread and self._prewarm_ok:
+            self._warm_thread.join(timeout=8)
+        elif self._warm_thread and not self._prewarm_ok:
+            log("skipping prewarm join (last prewarm failed)")
 
         with self._lock:
             proc = self._warm_proc
@@ -1817,11 +1845,17 @@ class WarmGrader:
             log("no warm process, cold fallback")
             proc = self._make_proc()
             warm = False
+        elif proc.stdin.closed:
+            log("warm process stdin closed, cold fallback")
+            self._kill_proc(proc)
+            proc = self._make_proc()
+            warm = False
 
+        wall_limit = int(os.environ.get("SYNKRO_DAEMON_WALL_TIMEOUT", "12"))
         t0 = time.time()
         try:
             _send_msg(proc, prompt)
-            resp = _read_response(proc, timeout=GRADE_TIMEOUT_SEC)
+            resp = _read_response(proc, timeout=min(GRADE_TIMEOUT_SEC, wall_limit))
         except Exception as e:
             log(f"grade error: {e}")
             resp = ""
@@ -2448,6 +2482,7 @@ async function callApi(method, endpoint, body) {
     throw new Error("API URL not configured. Run `synkro install` first.");
   }
   const url = `${API_URL}${endpoint}`;
+  await ensureValidToken();
   const accessToken = getAccessToken();
   const headers = {
     "Content-Type": "application/json"
@@ -3333,7 +3368,7 @@ function writeConfigEnv(opts) {
     `SYNKRO_CREDENTIALS_PATH=${shellQuoteSingle(credsPath)}`,
     `SYNKRO_TIER=${shellQuoteSingle(safeTier)}`,
     `SYNKRO_INFERENCE=${shellQuoteSingle(safeInference)}`,
-    `SYNKRO_VERSION=${shellQuoteSingle("1.3.26")}`
+    `SYNKRO_VERSION=${shellQuoteSingle("1.3.27")}`
   ];
   if (safeUserId) lines.push(`SYNKRO_USER_ID=${shellQuoteSingle(safeUserId)}`);
   if (safeOrgId) lines.push(`SYNKRO_ORG_ID=${shellQuoteSingle(safeOrgId)}`);