agents-relay 1.0.4 → 1.0.6

package/skills/chatgpt-browser-worker/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: chatgpt-browser-worker
+description: Submit an isolated one-shot ChatGPT browser worker task through browser-harness with a required durable output destination.
+---
+
+# ChatGPT browser worker
+
+Use this skill to hand one self-contained task to ChatGPT through the authenticated
+browser session. The caller does not manage ChatGPT threads, model selection,
+thinking level, polling, or result retrieval.
+
+## Output contract
+
+Every task handed to this worker MUST declare exactly one durable output mode
+before the worker is launched.
+
+### 1. Task / PR output
+
+Use this for repository or managed-task work.
+
+The task prompt must identify the exact managed task/PR that owns the result.
+The worker performs the requested work directly against that task/PR and records
+its final outcome there.
+
+Output:
+task/PR
+<exact managed task/PR identity and required final action>
+
+### 2. File output
+
+Use this for research, analysis, reports, or other artifact-producing work.
+
+The task prompt must name the exact file path. That file is the authoritative
+result.
+
+Output:
+file
+<exact file path>
+
+A Browser ChatGPT worker task without one of these output declarations is
+invalid and must not be launched. The orchestrator chooses and writes the output
+contract when it creates the worker task; the worker must not invent or change
+the destination.
+
+Progress and terminal success/failure are always reported through the normal
+Neo event contract. Events are execution observability, not a third output mode.
+
+## Runtime behavior
+
+The worker is one-shot. It opens an isolated worker-owned ChatGPT tab, submits
+the complete task, verifies that ChatGPT accepted the submission, closes its
+owned tab, and returns. ChatGPT continues the task independently and publishes
+the result through the declared output contract.
+
+The worker must never interact through a pre-existing user ChatGPT tab.
+Browser details, transient conversation identity, submission verification,
+model/default-thinking behavior, and tab cleanup are implementation concerns of
+the worker and are not part of the caller-facing contract.
+
+The runtime entry point is the browser-worker agent. Callers launch that agent
+with the complete task prompt and declared output; they do not call helper
+scripts directly.

package/skills/chatgpt-browser-worker/agents/browser-worker.agent.md

@@ -0,0 +1,42 @@
+---
+name: browser-worker
+description: Submit one isolated ChatGPT browser task and return after the task is accepted.
+type: worker
+---
+
+# Browser Worker Agent
+
+You are the runtime owner for the `chatgpt-browser-worker` skill. Load and follow
+that skill and the `browser-harness` skill before execution.
+
+The outer orchestrator gives you one complete task. That task MUST already
+contain exactly one output declaration defined by the skill:
+
+- `task/PR` with the exact managed task/PR identity and required final action; or
+- `file` with the exact authoritative output path.
+
+If the output declaration is missing or ambiguous, do not invent one.
+
+## Runtime rules
+
+- Use `browser-harness` for every ChatGPT browser interaction.
+- Execute only a one-shot submission. Do not expose or operate a
+  create/resume/status/result/continue lifecycle for callers.
+- Always create a fresh worker-owned tab. Never type, upload, click New chat,
+  select a Project, or submit through a pre-existing user ChatGPT tab.
+- Use Temporary Chat and the account's existing default model/thinking
+  settings. Do not change model or thinking settings.
+- Upload requested files, submit the complete task prompt, and verify that the
+  submission became a new user turn.
+- Once submission is verified, close the worker-owned tab and return. Do not
+  wait for the assistant response and do not reopen or poll the conversation.
+- Treat any observed conversation/thread identity only as diagnostic evidence,
+  never as a resumable handle.
+- Progress and terminal success/failure for the actual delegated task are
+  reported through the normal Neo event contract by the executing task. The
+  final durable result goes to the declared task/PR or file output.
+- Stop on authentication, MFA, consent, or ambiguous browser state rather than
+  bypassing it.
+
+Helper scripts under `scripts/` are implementation details. Callers must not
+invoke them directly.

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

@@ -0,0 +1,171 @@
+import atexit
+import json
+import os
+import re
+import time
+
+from browser_harness import *
+
+
+CFG = json.load(open("__CFG_PATH__", encoding="utf-8"))
+_OWNED_TABS = []
+
+
+def _new_owned_tab(url):
+    target_id = cdp("Target.createTarget", url="about:blank", background=True)["targetId"]
+    switch_tab(target_id)
+    _OWNED_TABS.append(target_id)
+    if url != "about:blank":
+        goto_url(url)
+    return target_id
+
+
+def _close_owned_tabs():
+    while _OWNED_TABS:
+        try:
+            close_tab(_OWNED_TABS.pop())
+        except Exception:
+            pass
+
+
+atexit.register(_close_owned_tabs)
+
+
+def _composer():
+    selector = js("""(() => {
+      const preferred = document.querySelector('#prompt-textarea');
+      if (preferred) {
+        const r=preferred.getBoundingClientRect();
+        if (r.width>0 && r.height>0) return '#prompt-textarea';
+      }
+      const fallback = [...document.querySelectorAll('textarea,[contenteditable="true"]')]
+        .find(e => { const r=e.getBoundingClientRect(); return r.width>0 && r.height>0 && !e.disabled; });
+      if (!fallback) return null;
+      return fallback.tagName === 'TEXTAREA' ? 'textarea' : '[contenteditable="true"]';
+    })()""")
+    if not selector:
+        raise RuntimeError("Temporary Chat composer was not observed")
+    return selector
+
+
+def _composer_text(selector):
+    return js(f"""(() => {{
+      const e=document.querySelector({json.dumps(selector)});
+      return e ? ((e.innerText ?? e.value) || '') : '';
+    }})()""") or ""
+
+
+def _attachment_names():
+    return js(r"""(() => [...document.querySelectorAll('button[aria-label^="Remove file"]')]
+      .map(b => (b.getAttribute('aria-label') || '').replace(/^Remove file\s+\d+:\s*/, ''))
+      .filter(Boolean))()""") or []
+
+
+def _upload_files(paths):
+    if not paths:
+        return []
+    selector = js("""(() => {
+      for (const s of ['#upload-files','#upload-media','input[name="upload-media"]','input[type="file"]'])
+        if (document.querySelector(s)) return s;
+      return null;
+    })()""")
+    if not selector:
+        raise RuntimeError("ChatGPT file input was not observed")
+    for path in 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]
+
+
+def _user_turns():
+    return js("""(() => [...document.querySelectorAll('[data-message-author-role="user"]')]
+      .map(e => ({text:e.innerText.trim(), id:e.getAttribute('data-message-id') || ''}))
+      .filter(e => e.text))()""") or []
+
+
+def _click_send():
+    ok = js("""(() => {
+      const b=document.querySelector('button[data-testid="send-button"],button[aria-label="Send prompt"]');
+      if (!b || b.disabled || b.getAttribute('aria-disabled') === 'true') return false;
+      b.click(); return true;
+    })()""")
+    if not ok:
+        raise RuntimeError("Temporary Chat Send prompt button was not observed ready")
+
+
+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 prompt.strip() in turns[-1]["text"]:
+            return turns[-1]
+        time.sleep(.25)
+    raise RuntimeError("Temporary Chat prompt did not become an observed user turn")
+
+
+def _diagnostic_thread_id():
+    match = re.search(r"/c/([^/?#]+)", page_info().get("url", ""))
+    return match.group(1) if match else None
+
+
+_new_owned_tab("https://chatgpt.com/")
+wait_for_load()
+
+enabled = js("""(() => {
+  const matches=[...document.querySelectorAll('button')].filter(
+    b => (b.getAttribute('aria-label') || '').trim() === 'Temporary chat'
+  );
+  if (matches.length !== 1) return false;
+  matches[0].click();
+  return true;
+})()""")
+if not enabled:
+    raise RuntimeError("Temporary Chat toggle was not uniquely observed")
+
+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")
+
+attachments = _upload_files(CFG.get("file", []))
+selector = _composer()
+before_count = len(_user_turns())
+fill_input(selector, CFG["prompt"], clear_first=True)
+if CFG["prompt"].strip() not in _composer_text(selector):
+    info = 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}};
+    }})()""")
+    click_at_xy(info["x"], info["y"])
+    press_key("CTRL+A")
+    type_text(CFG["prompt"])
+if CFG["prompt"].strip() not in _composer_text(selector):
+    raise RuntimeError("Temporary Chat prompt was not observed in the composer")
+
+_click_send()
+user_turn = _wait_user_turn(before_count, CFG["prompt"])
+
+print(json.dumps({
+    "operation": "submit",
+    "status": "submitted",
+    "temporary": True,
+    "attachments": attachments,
+    "diagnostic_thread_id": _diagnostic_thread_id(),
+    "user_message_id": user_turn.get("id") or None,
+    "verified": True,
+}, ensure_ascii=False))

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

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+"""Submit one isolated Temporary Chat task through browser-harness."""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import tempfile
+
+
+BH_SCRIPT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "_temporary_bh.py")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--prompt", required=True)
+    parser.add_argument("--file", action="append", default=[])
+    args = parser.parse_args()
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as handle:
+        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)
+        return subprocess.run(["browser-harness"], input=code, text=True, timeout=180).returncode
+    finally:
+        os.unlink(config_path)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())