agents-relay 1.0.23 → 1.0.24

package/dist/cli.js

@@ -572,8 +572,8 @@ async function main() {
         task.id = arg(args, '--task-id', randomUUID());
         await store.appendTask(task);
         job.tasks.push(task);
-        if (job.state === 'COMPLETED') {
-            job.state = 'OPEN';
+        if (job.state !== 'RUNNING') {
+            job.state = 'RUNNING';
             job.updatedAt = now;
             await store.saveJob(job);
         }
@@ -597,6 +597,11 @@ async function main() {
         task.error = command === 'retry' ? null : 'Cancelled by user';
         task.updatedAt = new Date().toISOString();
         await store.saveTask(task);
+        if (command === 'retry' && job.state !== 'RUNNING') {
+            job.state = 'RUNNING';
+            job.updatedAt = task.updatedAt;
+            await store.saveJob(job);
+        }
         await saveLocal(localFile, job);
         await publishWake(bus, job, task.id, `${task.id} ${command} requested`);
         console.log(`${id}: ${task.state}`);

package/dist/reconciler.js

@@ -61,6 +61,7 @@ export class Reconciler {
     terminalTimers = new Map();
     terminalExitGraceTimers = new Map();
     continuationLive = new Set();
+    launchFailureClaims = new Set();
     terminalWaiters = new Map();
     reconciling = false;
     constructor(store, options) {
@@ -507,6 +508,12 @@ export class Reconciler {
         live.workerStarted = true;
     }
     async failLaunch(jobId, taskId, executionId, message, phase = 'launch') {
+        const claim = executionId ?? `${jobId}:${taskId}`;
+        if (this.launchFailureClaims.has(claim))
+            return;
+        this.launchFailureClaims.add(claim);
+        const cleanup = setTimeout(() => this.launchFailureClaims.delete(claim), 60000);
+        cleanup.unref();
         const job = await this.store.load(jobId);
         const task = job.tasks.find(item => item.id === taskId);
         if (!task || task.executionId !== executionId || task.state !== 'RUNNING')

package/dist/scheduler.js

@@ -31,7 +31,7 @@ export function schedule(job) {
     const waiting = job.tasks.some(t => ['QUEUED', 'WAITING'].includes(t.state));
     const failed = job.tasks.some(t => t.state === 'FAILED');
     const cancelled = job.tasks.every(t => t.state === 'CANCELLED');
-    const next = failed ? 'FAILED' : active ? 'RUNNING' : blocked ? 'BLOCKED' : waiting ? 'WAITING' : cancelled ? 'CANCELLED' : completionGateSatisfied(job) ? 'COMPLETED' : 'WAITING';
+    const next = active ? 'RUNNING' : failed ? 'FAILED' : blocked ? 'BLOCKED' : waiting ? 'WAITING' : cancelled ? 'CANCELLED' : completionGateSatisfied(job) ? 'COMPLETED' : 'WAITING';
     if (job.state !== next) {
         assertJobTransition(job.state, next);
         job.state = next;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "1.0.23",
+  "version": "1.0.24",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {

package/skills/chatgpt-browser-worker/scripts/_submit_readiness.py

@@ -0,0 +1,30 @@
+"""Bounded polling helpers for ChatGPT submit readiness."""
+from __future__ import annotations
+
+import time
+from collections.abc import Callable, Mapping
+
+
+def wait_until_stable(
+    read_state: Callable[[], Mapping[str, object]],
+    ready: Callable[[Mapping[str, object]], bool],
+    *,
+    timeout: float,
+    interval: float = 0.25,
+    stable_samples: int = 2,
+    phase: str,
+) -> Mapping[str, object]:
+    """Return only after the observable state is ready for stable_samples polls."""
+    deadline = time.monotonic() + timeout
+    stable = 0
+    last_state: Mapping[str, object] = {}
+    while time.monotonic() < deadline:
+        last_state = read_state()
+        if ready(last_state):
+            stable += 1
+            if stable >= stable_samples:
+                return last_state
+        else:
+            stable = 0
+        time.sleep(interval)
+    raise RuntimeError(f"Temporary Chat {phase} was not observed ready")

package/skills/chatgpt-browser-worker/scripts/_temporary_bh.py

@@ -58,6 +58,21 @@ def _composer_text(selector):
     }})()""") or ""
 
 
+def _wait_for_composer(timeout=30):
+    def read_selector():
+        try:
+            return _composer()
+        except RuntimeError:
+            return None
+
+    return wait_until_stable(
+        lambda: {"selector": read_selector()},
+        lambda state: bool(state["selector"]),
+        timeout=timeout,
+        phase="composer readiness",
+    )["selector"]
+
+
 def _same_text(observed, expected):
     normalize = lambda value: re.sub(r"\\s+", " ", value or "").strip()
     return normalize(expected) in normalize(observed)
@@ -73,6 +88,38 @@ def _attachment_names():
       .filter(Boolean))()""") or []
 
 
+def _attachment_state():
+    return js(r"""(() => {
+      const names = [...document.querySelectorAll('button[aria-label^="Remove file"]')]
+        .map(b => (b.getAttribute('aria-label') || '').replace(/^Remove file\s+\d+:\s*/, ''))
+        .filter(Boolean);
+      const pending = [...document.querySelectorAll(
+        '[role="progressbar"], [aria-busy="true"], [data-state="loading"]'
+      )].some(e => {
+        const r=e.getBoundingClientRect();
+        return r.width > 0 && r.height > 0;
+      });
+      return {names, pending};
+    })()""") or {"names": [], "pending": True}
+
+
+def _send_state():
+    return js(r"""(() => {
+      const b=document.querySelector('button[data-testid="send-button"],button[aria-label="Send prompt"]');
+      return {present: !!b, enabled: !!b && !b.disabled && b.getAttribute('aria-disabled') !== 'true'};
+    })()""") or {"present": False, "enabled": False}
+
+
+def _wait_for_attachments(expected, timeout=45):
+    expected = set(expected)
+    wait_until_stable(
+        _attachment_state,
+        lambda state: expected.issubset(state["names"]) and not state["pending"],
+        timeout=timeout,
+        phase="attachment upload readiness",
+    )
+
+
 def _upload_files(paths):
     if not paths:
         return []
@@ -87,13 +134,17 @@ def _upload_files(paths):
         if not os.path.isfile(path):
             raise RuntimeError(f"attachment does not exist: {path}")
         upload_file(selector, path)
-        expected = os.path.basename(path)
-        deadline = time.time() + 20
-        while time.time() < deadline and expected not in _attachment_names():
-            time.sleep(.25)
-        if expected not in _attachment_names():
-            raise RuntimeError(f"attachment was not observed ready: {expected}")
-    return [os.path.basename(path) for path in paths]
+    expected = [os.path.basename(path) for path in paths]
+    if expected:
+        # Presence is a selection signal; upload readiness is checked separately.
+        wait_until_stable(
+            _attachment_state,
+            lambda state: set(expected).issubset(state["names"]),
+            timeout=30,
+            phase="attachment presence",
+        )
+        _wait_for_attachments(expected)
+    return expected
 
 
 def _user_turns():
@@ -109,17 +160,41 @@ def _click_send():
       b.click(); return true;
     })()""")
     if not ok:
-        raise RuntimeError("Temporary Chat Send prompt button was not observed ready")
+        raise RuntimeError("Temporary Chat send readiness changed before click")
+
+
+def _wait_for_send_ready(selector, prompt, attachments):
+    expected = set(attachments)
+
+    def read_state():
+        return {
+            "text": _composer_text(selector),
+            "attachments": _attachment_state(),
+            "send": _send_state(),
+        }
+
+    wait_until_stable(
+        read_state,
+        lambda state: (
+            _normalized_text(prompt) in _normalized_text(state["text"])
+            and expected.issubset(state["attachments"]["names"])
+            and not state["attachments"]["pending"]
+            and state["send"]["enabled"]
+        ),
+        timeout=45 if expected else 15,
+        phase="send readiness",
+    )
 
 
 def _wait_user_turn(before_count, prompt, timeout=20):
     deadline = time.time() + timeout
     while time.time() < deadline:
         turns = _user_turns()
-        if len(turns) > before_count and _normalized_text(prompt) in _normalized_text(turns[-1]["text"]):
-            return turns[-1]
+        for turn in turns[before_count:]:
+            if _normalized_text(prompt) in _normalized_text(turn["text"]):
+                return turn
         time.sleep(.25)
-    raise RuntimeError("Temporary Chat prompt did not become an observed user turn")
+    raise RuntimeError("Temporary Chat submission verification did not observe a new user turn")
 
 
 def _diagnostic_thread_id():
@@ -145,30 +220,59 @@ deadline = time.time() + 20
 while time.time() < deadline:
     if "temporary-chat=true" in page_info().get("url", ""):
         try:
-            _composer()
             break
         except RuntimeError:
             pass
     time.sleep(.25)
 else:
-    raise RuntimeError("Temporary Chat mode did not become ready")
+    raise RuntimeError("Temporary Chat composer readiness was not observed")
 
 attachments = _upload_files(CFG.get("file", []))
-selector = _composer()
+selector = _wait_for_composer()
 before_count = len(_user_turns())
-fill_input(selector, CFG["prompt"], clear_first=True)
-if not _same_text(_composer_text(selector), CFG["prompt"]):
-    info = js(f"""(() => {{
+prompt = CFG["prompt"]
+is_contenteditable = bool(js(f"""(() => {{
+  const e=document.querySelector({json.dumps(selector)});
+  return !!e && e.getAttribute('contenteditable') === 'true';
+}})()"""))
+if is_contenteditable:
+    cleared = js(f"""(() => {{
       const e=document.querySelector({json.dumps(selector)});
-      const r=e.getBoundingClientRect();
-      return {{x:r.x+r.width/2,y:r.y+r.height/2}};
+      if (!e) return false;
+      e.focus();
+      const sel=window.getSelection();
+      const range=document.createRange();
+      range.selectNodeContents(e);
+      sel.removeAllRanges();
+      sel.addRange(range);
+      document.execCommand('delete', false, null);
+      return true;
     }})()""")
-    click_at_xy(info["x"], info["y"])
-    press_key("CTRL+A")
-    type_text(CFG["prompt"])
-if _normalized_text(CFG["prompt"]) not in _normalized_text(_composer_text(selector)):
-    raise RuntimeError("Temporary Chat prompt was not observed in the composer")
+    if not cleared:
+        raise RuntimeError("Temporary Chat contenteditable composer could not be cleared")
+    for offset in range(0, len(prompt), 256):
+        chunk = prompt[offset:offset + 256]
+        inserted = js(f"""(() => {{
+          const e=document.querySelector({json.dumps(selector)});
+          if (!e) return false;
+          e.focus();
+          const ok=document.execCommand('insertText', false, {json.dumps(chunk)});
+          e.dispatchEvent(new InputEvent('input', {{bubbles:true,inputType:'insertText',data:{json.dumps(chunk)}}}));
+          return ok;
+        }})()""")
+        if not inserted:
+            raise RuntimeError(f"Temporary Chat composer rejected prompt chunk at offset {offset}")
+else:
+    fill_input(selector, prompt, clear_first=True)
+
+wait_until_stable(
+    lambda: {"text": _composer_text(selector)},
+    lambda state: _normalized_text(CFG["prompt"]) in _normalized_text(state["text"]),
+    timeout=30,
+    phase="composer readiness",
+)
 
+_wait_for_send_ready(selector, CFG["prompt"], attachments)
 _click_send()
 user_turn = _wait_user_turn(before_count, CFG["prompt"])
 

package/skills/chatgpt-browser-worker/scripts/temporary_bh.py

@@ -10,6 +10,7 @@ import tempfile
 
 
 BH_SCRIPT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "_temporary_bh.py")
+READINESS_HELPER = os.path.join(os.path.dirname(os.path.abspath(__file__)), "_submit_readiness.py")
 
 
 def main() -> int:
@@ -23,7 +24,9 @@ def main() -> int:
         json.dump(vars(args), handle, ensure_ascii=False)
         config_path = handle.name
     try:
-        code = open(BH_SCRIPT, encoding="utf-8").read().replace("__CFG_PATH__", config_path)
+        helper = open(READINESS_HELPER, encoding="utf-8").read()
+        code = helper + "\n" + open(BH_SCRIPT, encoding="utf-8").read()
+        code = code.replace("__CFG_PATH__", config_path)
         return subprocess.run(["browser-harness"], input=code, text=True, timeout=180).returncode
     finally:
         os.unlink(config_path)