omnilane 0.34.0 → 0.42.1

package/scripts/lib/live-protocol.sh

@@ -3,16 +3,128 @@
 # Shared live-mailbox protocol differences. Callers provide json_escape().
 
 live_capable_vendors() {
-  printf 'claude, gemini'
+  printf 'claude, gemini, codex, grok'
 }
 
 live_vendor_capable() {
   case "$1" in
-    claude|gemini) return 0 ;;
+    claude|gemini|codex|grok) return 0 ;;
     *) return 1 ;;
   esac
 }
 
+codex_live_surface_available() {
+  local bin="${1:-${CODEX_BIN:-codex}}"
+  command -v "$bin" >/dev/null 2>&1 || return 1
+  command -v python3 >/dev/null 2>&1 || return 1
+  python3 - "$bin" 2>/dev/null <<'PY'
+import json
+import select
+import subprocess
+import sys
+
+process = None
+ok = False
+try:
+    process = subprocess.Popen(
+        [sys.argv[1], "app-server"],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.DEVNULL,
+        text=True,
+        # Stay in the caller's supervised process group. A whole-job SIGKILL
+        # bypasses this probe's finally block, so a private session would leak.
+        start_new_session=False,
+    )
+    request = {
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "initialize",
+        "params": {"clientInfo": {"name": "omnilane-probe", "version": "1"}},
+    }
+    process.stdin.write(json.dumps(request, separators=(",", ":")) + "\n")
+    process.stdin.flush()
+    # Keep stdin open until the reply arrives: codex 0.153.4 exits on EOF
+    # before answering, which made a healthy machine look live-unavailable.
+    if select.select([process.stdout], [], [], 3)[0]:
+        response = json.loads(process.stdout.readline())
+        ok = isinstance(response, dict) and isinstance(response.get("result"), dict)
+except (OSError, ValueError, json.JSONDecodeError):
+    ok = False
+finally:
+    if process is not None and process.poll() is None:
+        try:
+            process.terminate()
+            process.wait(timeout=1)
+        except (OSError, subprocess.TimeoutExpired):
+            try:
+                process.kill()
+            except OSError:
+                pass
+            process.wait()
+sys.exit(0 if ok else 1)
+PY
+}
+
+grok_live_surface_available() {
+  local bin="${1:-${GROK_BIN:-grok}}"
+  command -v "$bin" >/dev/null 2>&1 || return 1
+  command -v python3 >/dev/null 2>&1 || return 1
+
+  python3 - "$bin" 2>/dev/null <<'PY'
+import json
+import select
+import subprocess
+import sys
+
+process = None
+ok = False
+try:
+    process = subprocess.Popen(
+        [sys.argv[1], "agent", "stdio"],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.DEVNULL,
+        text=True,
+        # Stay in the caller's supervised process group. A whole-job SIGKILL
+        # bypasses the probe's finally block, so a private session would leak.
+        start_new_session=False,
+    )
+    request = {
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "initialize",
+        "params": {
+            "protocolVersion": 1,
+            "clientCapabilities": {
+                "fs": {"readTextFile": False, "writeTextFile": False}
+            },
+        },
+    }
+    process.stdin.write(json.dumps(request, separators=(",", ":")) + "\n")
+    process.stdin.flush()
+    # Same as the codex probe: keep stdin open until the reply arrives so an
+    # agent that exits on EOF before answering is not reported unavailable.
+    if select.select([process.stdout], [], [], 3)[0]:
+        response = json.loads(process.stdout.readline())
+        ok = isinstance(response, dict) and isinstance(response.get("result"), dict)
+except (OSError, ValueError, json.JSONDecodeError):
+    ok = False
+finally:
+    if process is not None and process.poll() is None:
+        try:
+            process.terminate()
+            process.wait(timeout=1)
+        except (OSError, subprocess.TimeoutExpired):
+            try:
+                process.kill()
+            except OSError:
+                pass
+            process.wait()
+sys.exit(0 if ok else 1)
+PY
+}
+
 live_encode_message() {
   local vendor="$1" job_id="$2" foreman_session="$3" text="$4"
   case "$vendor" in
@@ -25,15 +137,40 @@ live_encode_message() {
       printf '{"event":"user","message":{"role":"user","content":[{"type":"text","text":"%s"}]}}' \
         "$(json_escape "$text")"
       ;;
+    codex)
+      printf '{"type":"codex-user","text":"%s"}' "$(json_escape "$text")"
+      ;;
+    grok)
+      printf '{"type":"grok-user","text":"%s"}' "$(json_escape "$text")"
+      ;;
     *) return 2 ;;
   esac
 }
 
+# Cheap structural check, not a parse. Two properties matter more here than
+# precision. It must not fork: the drain loop runs one call per stream event
+# between inbox reads, so a per-event process would leave an operator's
+# `jobs.sh send` waiting behind a busy stream. And it must not be able to fail
+# because a parser is missing: a validator that cannot run would judge every
+# event invalid, activity would never refresh, and the idle cap would kill
+# healthy jobs. Strict parsing still guards the places where correctness
+# depends on it (json_file_round_trip_valid).
+live_event_is_valid() {
+  local event="$1" lead trail
+  lead="${event%%[![:space:]]*}"
+  event="${event#"$lead"}"
+  trail="${event##*[![:space:]]}"
+  event="${event%"$trail"}"
+  [[ "$event" == "{"*"}" ]]
+}
+
 live_event_is_result() {
   local vendor="$1" event="$2" pattern
   case "$vendor" in
     claude) pattern='"type"[[:space:]]*:[[:space:]]*"result"' ;;
     gemini) pattern='"event"[[:space:]]*:[[:space:]]*"result"' ;;
+    codex) pattern='"method"[[:space:]]*:[[:space:]]*"turn/completed"' ;;
+    grok) pattern='"method"[[:space:]]*:[[:space:]]*"_x.ai/session/prompt_complete"' ;;
     *) return 2 ;;
   esac
   [[ "$event" =~ $pattern ]]
@@ -51,6 +188,14 @@ live_event_is_success() {
       pattern='"status"[[:space:]]*:[[:space:]]*"SUCCESS"'
       [[ "$event" =~ $pattern ]]
       ;;
+    codex)
+      pattern='"status"[[:space:]]*:[[:space:]]*"completed"'
+      [[ "$event" =~ $pattern ]]
+      ;;
+    grok)
+      pattern='"stopReason"[[:space:]]*:[[:space:]]*"end_turn"'
+      [[ "$event" =~ $pattern ]]
+      ;;
     *) return 2 ;;
   esac
 }