@synkro-sh/cli 1.3.26 → 1.3.28

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 = ""
@@ -2339,7 +2373,7 @@ async function refreshToken() {
   const creds = loadCredentials();
   if (!creds?.refresh_token) return false;
   try {
-    const response = await fetch(`${SYNKRO_WEB_AUTH_URL}/api/auth/refresh`, {
+    const response = await fetch(`${SYNKRO_API_URL}/api/auth/refresh`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ refresh_token: creds.refresh_token })
@@ -2348,6 +2382,7 @@ async function refreshToken() {
     const data = await response.json();
     if (data.access_token) {
       saveCredentials({
+        ...creds,
         access_token: data.access_token,
         refresh_token: data.refresh_token || creds.refresh_token
       });
@@ -2379,7 +2414,7 @@ function clearCredentials() {
     unlinkSync2(AUTH_FILE);
   }
 }
-var PORT, RAW_WEB_AUTH_URL, SYNKRO_WEB_AUTH_URL, AUTH_FILE, ERROR_HTML, refreshPromise;
+var PORT, RAW_WEB_AUTH_URL, SYNKRO_WEB_AUTH_URL, AUTH_FILE, RAW_API_URL, SYNKRO_API_URL, ERROR_HTML, refreshPromise;
 var init_stub = __esm({
   "cli/auth/stub.ts"() {
     "use strict";
@@ -2387,6 +2422,8 @@ var init_stub = __esm({
     RAW_WEB_AUTH_URL = process.env.SYNKRO_WEB_AUTH_URL;
     SYNKRO_WEB_AUTH_URL = RAW_WEB_AUTH_URL && /^https?:\/\//.test(RAW_WEB_AUTH_URL) ? RAW_WEB_AUTH_URL : "https://app.synkro.sh";
     AUTH_FILE = process.env.SYNKRO_AUTH_FILE || join3(homedir3(), ".synkro", "credentials.json");
+    RAW_API_URL = process.env.SYNKRO_CRUD_URL || process.env.SYNKRO_API_URL;
+    SYNKRO_API_URL = RAW_API_URL && /^https?:\/\//.test(RAW_API_URL) ? RAW_API_URL : "https://api.synkro.sh";
     ERROR_HTML = `
 <!DOCTYPE html>
 <html>
@@ -2448,6 +2485,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 +3371,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.28")}`
   ];
   if (safeUserId) lines.push(`SYNKRO_USER_ID=${shellQuoteSingle(safeUserId)}`);
   if (safeOrgId) lines.push(`SYNKRO_ORG_ID=${shellQuoteSingle(safeOrgId)}`);
@@ -4000,6 +4038,7 @@ async function statusCommand() {
   const gatewayUrl = (config.SYNKRO_GATEWAY_URL || "https://api.synkro.sh").replace(/^['"]|['"]$/g, "");
   let serverTier = config.SYNKRO_TIER || "(unset)";
   let serverInference = config.SYNKRO_INFERENCE || "fast";
+  await ensureValidToken();
   const token = getAccessToken();
   if (token) {
     try {