agent-relay-server 0.4.13 → 0.4.15

package/codex/relay.ts

@@ -1,125 +0,0 @@
-import { hostname } from "node:os";
-
-export type RelayAgentStatus = "online" | "idle" | "busy" | "offline";
-
-export interface RelayMessage {
-  id: number;
-  from: string;
-  to: string;
-  subject?: string;
-  body: string;
-  replyTo?: number;
-  claimable?: boolean;
-  meta?: Record<string, unknown>;
-  createdAt: number;
-}
-
-export interface RelayConfig {
-  relayUrl: string;
-  cwd: string;
-  rig: string;
-  capabilities: string[];
-  tags: string[];
-  threadId: string;
-  model?: string;
-  appServerUrl: string;
-}
-
-export function buildAgentIdentity(config: RelayConfig): { id: string; name: string; machine: string; project: string } {
-  const machine = hostname();
-  const project = config.cwd.split("/").filter(Boolean).at(-1) || "unknown";
-  const shortThread = config.threadId.replace(/[^a-zA-Z0-9]/g, "").slice(0, 8) || "thread";
-  const id = `${machine}-${config.rig}-${project}-${shortThread}`;
-  const name = `${project} (${config.rig} @ ${machine})`;
-  return { id, name, machine, project };
-}
-
-export class RelayClient {
-  constructor(private readonly baseUrl: string, private readonly log: (msg: string) => void = () => {}) {}
-
-  async registerAgent(config: RelayConfig): Promise<{ agentId: string; project: string }> {
-    const identity = buildAgentIdentity(config);
-    const payload = {
-      id: identity.id,
-      name: identity.name,
-      machine: identity.machine,
-      rig: config.rig,
-      tags: config.tags,
-      capabilities: config.capabilities,
-      status: "online",
-      meta: {
-        client: "codex-live",
-        threadId: config.threadId,
-        appServerUrl: config.appServerUrl,
-        cwd: config.cwd,
-        model: config.model || null,
-      },
-    };
-
-    await this.json("POST", "/api/agents", payload);
-    return { agentId: identity.id, project: identity.project };
-  }
-
-  async heartbeat(agentId: string): Promise<void> {
-    await this.json("POST", `/api/agents/${encodeURIComponent(agentId)}/heartbeat`);
-  }
-
-  async setStatus(agentId: string, status: RelayAgentStatus): Promise<void> {
-    await this.json("PATCH", `/api/agents/${encodeURIComponent(agentId)}/status`, { status });
-  }
-
-  async setReady(agentId: string, ready: boolean): Promise<void> {
-    await this.json("PATCH", `/api/agents/${encodeURIComponent(agentId)}/ready`, { ready });
-  }
-
-  async pollMessages(agentId: string, sinceId: number): Promise<RelayMessage[]> {
-    const url = new URL(`/api/messages`, this.baseUrl);
-    url.searchParams.set("for", agentId);
-    url.searchParams.set("unread", "true");
-    if (sinceId > 0) url.searchParams.set("sinceId", String(sinceId));
-    const response = await fetch(url, { headers: this.headers() });
-    if (!response.ok) {
-      throw new Error(`relay poll failed: ${response.status} ${response.statusText}`);
-    }
-    return (await response.json()) as RelayMessage[];
-  }
-
-  async claimMessage(messageId: number, agentId: string): Promise<boolean> {
-    const response = await fetch(new URL(`/api/messages/${messageId}/claim`, this.baseUrl), {
-      method: "POST",
-      headers: this.headers({ "Content-Type": "application/json" }),
-      body: JSON.stringify({ agentId }),
-    });
-
-    if (response.ok) return true;
-    if (response.status === 409) return false;
-    if (response.status === 400 || response.status === 404) return false;
-    throw new Error(`relay claim failed: ${response.status} ${response.statusText}`);
-  }
-
-  async markRead(messageId: number, agentId: string): Promise<void> {
-    await this.json("PATCH", `/api/messages/${messageId}`, { readBy: agentId });
-  }
-
-  private async json(method: string, path: string, body?: unknown): Promise<unknown> {
-    const response = await fetch(new URL(path, this.baseUrl), {
-      method,
-      headers: this.headers({ "Content-Type": "application/json" }),
-      body: body === undefined ? undefined : JSON.stringify(body),
-    });
-
-    if (!response.ok) {
-      const text = await response.text();
-      this.log(`relay error ${method} ${path}: ${response.status} ${text}`);
-      throw new Error(`relay ${method} ${path} failed: ${response.status}`);
-    }
-
-    if (response.status === 204) return null;
-    return response.json().catch(() => null);
-  }
-
-  private headers(base: Record<string, string> = {}): Record<string, string> {
-    const token = process.env.AGENT_RELAY_TOKEN;
-    return token ? { ...base, "X-Agent-Relay-Token": token } : base;
-  }
-}

package/codex/smoke/fallback.ts

@@ -1,128 +0,0 @@
-import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { tmpdir } from "node:os";
-
-const ROOT_DIR = resolve(import.meta.dir, "../..");
-
-function log(message: string): void {
-  console.error(`[codex-fallback-smoke] ${message}`);
-}
-
-async function waitForExit(process: Bun.Subprocess, timeoutMs: number): Promise<number> {
-  const started = Date.now();
-  while (Date.now() - started < timeoutMs) {
-    if (process.exitCode !== null) return process.exitCode;
-    await Bun.sleep(100);
-  }
-  try {
-    process.kill();
-  } catch {
-    // Process already exited.
-  }
-  throw new Error(`timed out waiting for process to exit after ${timeoutMs}ms`);
-}
-
-function writeFakeCodex(path: string): void {
-  const script = `#!/usr/bin/env bash
-set -euo pipefail
-
-if [[ "\${1:-}" == "plugin" && "\${2:-}" == "marketplace" && "\${3:-}" == "add" ]]; then
-  exit 0
-fi
-
-if [[ "\${1:-}" == "app-server" && "\${2:-}" == "--listen" ]]; then
-  url="\${3:-}"
-  port="\${url##*:}"
-  exec node -e 'const net=require("node:net"); const port=Number(process.argv[1]); const server=net.createServer((socket)=>socket.destroy()); server.listen(port,"127.0.0.1"); setInterval(()=>{},1000);' "$port"
-fi
-
-if [[ "\${1:-}" == "--remote" ]]; then
-  sleep 6
-  exit 0
-fi
-
-echo "fake codex: unsupported args: $*" >&2
-exit 64
-`;
-  writeFileSync(path, script, "utf8");
-  chmodSync(path, 0o755);
-}
-
-function parseRuntimeDir(output: string): string | null {
-  const match = output.match(/^Runtime:\s+(.+)$/m);
-  return match?.[1]?.trim() || null;
-}
-
-async function main(): Promise<void> {
-  const tempHome = mkdtempSync(join(tmpdir(), "agent-relay-codex-fallback-"));
-  const fakeBin = join(tempHome, "fake-bin");
-  mkdirSync(fakeBin, { recursive: true });
-
-  const fakeCodexPath = join(fakeBin, "codex");
-  writeFakeCodex(fakeCodexPath);
-
-  const env = {
-    ...process.env,
-    HOME: tempHome,
-    USERPROFILE: tempHome,
-    PATH: `${fakeBin}:${process.env.PATH || ""}`,
-    AGENT_RELAY_URL: process.env.AGENT_RELAY_URL || "http://127.0.0.1:4850",
-  };
-
-  log("starting launcher with fake codex runtime (hooks intentionally not fired)");
-  const run = Bun.spawn(["bun", "run", "bin/agent-relay-codex.ts", "start"], {
-    cwd: ROOT_DIR,
-    env,
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-
-  const exitCode = await waitForExit(run, 25_000);
-  const stderr = await new Response(run.stderr).text();
-  const stdout = await new Response(run.stdout).text();
-
-  if (exitCode !== 0) {
-    throw new Error(`launcher exited ${exitCode}\nstdout:\n${stdout}\nstderr:\n${stderr}`);
-  }
-
-  const runtimeDir = parseRuntimeDir(`${stdout}\n${stderr}`);
-  if (!runtimeDir) {
-    throw new Error(`missing runtime directory in launcher output\nstdout:\n${stdout}\nstderr:\n${stderr}`);
-  }
-
-  const fallbackPidPath = join(runtimeDir, "auto", "sidecar.pid");
-  const fallbackLogPath = join(runtimeDir, "auto", "sidecar.log");
-  const sidecarPidsPath = join(runtimeDir, "sidecar-pids.txt");
-  const launcherLogPath = join(runtimeDir, "launcher.log");
-
-  if (!existsSync(fallbackPidPath)) {
-    throw new Error(`fallback pid file missing: ${fallbackPidPath}`);
-  }
-  if (!existsSync(sidecarPidsPath)) {
-    throw new Error(`sidecar-pids missing: ${sidecarPidsPath}`);
-  }
-  if (!existsSync(launcherLogPath)) {
-    throw new Error(`launcher log missing: ${launcherLogPath}`);
-  }
-
-  const pid = readFileSync(fallbackPidPath, "utf8").trim();
-  const pidsFile = readFileSync(sidecarPidsPath, "utf8");
-  const launcherLog = readFileSync(launcherLogPath, "utf8");
-  if (!pid || !pidsFile.includes(pid)) {
-    throw new Error(`fallback pid ${pid || "<empty>"} not recorded in sidecar-pids.txt`);
-  }
-  if (!launcherLog.includes("HOOK_FALLBACK_STARTED reason=HOOK_HANDSHAKE_TIMEOUT")) {
-    throw new Error(`fallback reason code missing in launcher log\nlog:\n${launcherLog}`);
-  }
-
-  log(`fallback sidecar created pid ${pid}`);
-  if (existsSync(fallbackLogPath)) {
-    log(`fallback log file present at ${fallbackLogPath}`);
-  }
-  log("fallback smoke passed");
-}
-
-main().catch((error) => {
-  log(error instanceof Error ? error.stack || error.message : String(error));
-  process.exitCode = 1;
-});

package/codex/start-live.sh

@@ -1,64 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-ROOT_DIR=$(cd "$(dirname "$0")/.." && pwd)
-CODEX_DIR="$ROOT_DIR/codex"
-RUNTIME_DIR="$CODEX_DIR/runtime"
-APP_LOG="$RUNTIME_DIR/app-server.log"
-APP_PID="$RUNTIME_DIR/app-server.pid"
-APP_URL_FILE="$RUNTIME_DIR/app-server.url"
-STATE_FILE="${CODEX_LIVE_STATE_PATH:-$RUNTIME_DIR/live-state.json}"
-CODEX_APP_SERVER_URL="${CODEX_APP_SERVER_URL:-ws://127.0.0.1:4501}"
-STARTED_APP_SERVER=0
-
-mkdir -p "$RUNTIME_DIR"
-
-cleanup() {
-  if [ "$STARTED_APP_SERVER" = "1" ] && [ -f "$APP_PID" ]; then
-    pid=$(cat "$APP_PID" 2>/dev/null || true)
-    if [ -n "${pid:-}" ] && kill -0 "$pid" 2>/dev/null; then
-      kill "$pid" 2>/dev/null || true
-    fi
-    rm -f "$APP_PID"
-  fi
-}
-trap cleanup EXIT INT TERM
-
-if [ -f "$APP_PID" ]; then
-  pid=$(cat "$APP_PID" 2>/dev/null || true)
-  if [ -n "${pid:-}" ] && kill -0 "$pid" 2>/dev/null; then
-    echo "app-server already running (pid=$pid) at $(cat "$APP_URL_FILE" 2>/dev/null || echo "$CODEX_APP_SERVER_URL")"
-  else
-    rm -f "$APP_PID"
-  fi
-fi
-
-if [ ! -f "$APP_PID" ]; then
-  setsid bash -lc "exec codex app-server --listen '$CODEX_APP_SERVER_URL' >>'$APP_LOG' 2>&1 < /dev/null" &
-  pid=$!
-  STARTED_APP_SERVER=1
-  printf '%s\n' "$pid" > "$APP_PID"
-  printf '%s\n' "$CODEX_APP_SERVER_URL" > "$APP_URL_FILE"
-
-  for _ in $(seq 1 50); do
-    if grep -qiE 'listening|ws://' "$APP_LOG" 2>/dev/null; then
-      break
-    fi
-    if ! kill -0 "$pid" 2>/dev/null; then
-      echo "app-server exited early; see $APP_LOG" >&2
-      exit 1
-    fi
-    sleep 0.2
-  done
-
-  echo "started app-server pid=$pid url=$CODEX_APP_SERVER_URL"
-fi
-
-echo "state file: $STATE_FILE"
-echo "connect Codex TUI with: codex --remote $CODEX_APP_SERVER_URL"
-echo "if sidecar creates a new thread first, inspect $STATE_FILE for threadId and use: codex resume <threadId> --remote $CODEX_APP_SERVER_URL"
-
-export CODEX_APP_SERVER_URL
-export CODEX_LIVE_CWD="${CODEX_LIVE_CWD:-$ROOT_DIR}"
-export CODEX_LIVE_STATE_PATH="$STATE_FILE"
-exec bun run "$CODEX_DIR/live-sidecar.ts"