relay-companion 0.1.4 → 0.1.6

package/bin/relay.js

@@ -11,6 +11,7 @@ import { writeConfig, readConfig, apiUrl, DEFAULT_API_URL, DEFAULT_WEB_URL } fro
 import { runTaskDaemon, pollTaskRuntimeOnce } from "../src/task-daemon.js";
 import { runMcpServer } from "../src/mcp.js";
 import { runSetupInstall, runUninstall } from "../src/install.js";
+import { liveToolRequirement, requiredLiveHosts, shouldRequireLiveTools } from "../src/setup-activation.js";
 import { openRelay, openTask } from "../src/materializer.js";
 import { resetCompanionStateForAccount } from "../src/notifications.js";
 import { finishSetupOpenRelay, normalizeSetupHost, setupOpenRelayToken, setupOpenStatus } from "../src/setup-open.js";
@@ -60,14 +61,45 @@ async function cmdPair(flags, { promptForDefaults = true } = {}) {
   console.log(`Paired as ${res.user.name} <${res.user.email}>. This device is now connected to Relay.`);
 }
 
+function printActivationStatus(activation) {
+  if (!activation) return;
+  if (activation.host === "Codex") {
+    if (activation.currentSessionReady) {
+      if (activation.readinessMode === "deferred_tool_search") {
+        console.log("Relay tools are available in this Codex session through Codex tool search (`relay_send`).");
+        return;
+      }
+      console.log("Relay tools are live in this Codex session (`relay_send` verified).");
+      return;
+    }
+    if (activation.serverCatalogHasTool) {
+      console.log(
+        "Relay was added to Codex and the MCP server advertises relay_send, but this open Codex session has not exposed relay_send to the agent yet.",
+      );
+      return;
+    }
+    const detail = activation.reason ? ` (${activation.reason})` : "";
+    console.log(`Relay was added to Codex, but this open Codex session does not expose relay_send yet${detail}.`);
+    return;
+  }
+  if (activation.host === "Claude Code") {
+    if (activation.ok) {
+      console.log("Relay was added to Claude Code for new sessions. Existing Claude Code sessions may need their MCP tools reloaded from inside Claude.");
+    } else {
+      console.log("Relay could not verify the Claude Code MCP registration.");
+    }
+  }
+}
+
 /** Register the Relay tools into Claude Code + Codex and start the receive daemon. */
-function applyInstall() {
-  const { installed, missing, daemon, pill } = runSetupInstall();
+async function applyInstall({ requireLiveTools = false, requiredHosts = requiredLiveHosts() } = {}) {
+  const { installed, missing, daemon, pill, activations = [] } = await runSetupInstall();
   if (installed.length) console.log(`Added Relay to ${installed.join(" and ")} on this machine.`);
   for (const m of missing) {
     if (!/registration failed/.test(m)) console.log(`${m} was not found here, so it was skipped.`);
     else console.log(`Could not register ${m}.`);
   }
+  for (const activation of activations) printActivationStatus(activation);
   if (daemon.ok) console.log("Relay is running in the background and will start automatically when you log in.");
   else if (daemon.reason === "autostart_unsupported_platform") {
     console.log("Run `relay daemon` to receive relays (background autostart is macOS-only for now).");
@@ -76,14 +108,26 @@ function applyInstall() {
   else if (pill?.reason === "pill_runtime_missing") {
     console.log("Run `relay pill` to open the Relay pill.");
   }
-  if (installed.length) console.log("Open Claude Code or Codex and your Relay tools are ready.");
+  const liveRequirement = liveToolRequirement({ activations, requiredHosts });
+  if (requireLiveTools && installed.length && !liveRequirement.ok) {
+    const hostLabel = liveRequirement.missingHosts.length
+      ? liveRequirement.missingHosts.join(" and ")
+      : "this running agent session";
+    throw new Error(
+      `Relay paired and installed, but ${hostLabel} cannot call relay_send yet. Setup is not ready in the current agent.`,
+    );
+  }
+  return { installed, missing, daemon, pill, activations };
 }
 
 /** Full setup: pair this device, then install the tools + daemon. */
 async function cmdSetup(flags) {
   await cmdPair(flags, { promptForDefaults: Boolean(flags.interactive) });
   console.log("");
-  applyInstall();
+  await applyInstall({
+    requireLiveTools: Boolean(flags["require-live-tools"]) || shouldRequireLiveTools(),
+    requiredHosts: requiredLiveHosts(),
+  });
   const token = setupOpenRelayToken(flags);
   if (token) {
     console.log("");
@@ -109,7 +153,7 @@ async function cmdInstall() {
   if (!readConfig().deviceToken) {
     throw new Error("This device is not paired yet. Run `relay setup` with a pairing code first.");
   }
-  applyInstall();
+  await applyInstall({ requireLiveTools: shouldRequireLiveTools(), requiredHosts: requiredLiveHosts() });
 }
 
 /** Remove the Relay tools from both agents and stop the background daemon. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relay-companion",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Relay companion: connects local coding agents to Relay tasks, approvals, and connector tools.",
   "type": "module",
   "bin": {

package/src/install.js

@@ -4,6 +4,7 @@ import os from "node:os";
 import path from "node:path";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
+import { activateCodexMcp, verifyClaudeMcpRegistration } from "./setup-activation.js";
 
 // Persistent install of the Relay companion into the user's local agents.
 //
@@ -175,21 +176,26 @@ export function installPillAutostart(bin = relayBinPath()) {
  * Detect Claude Code + Codex, register the Relay MCP into each present, and
  * start the receive daemon. Returns a summary for the CLI to print.
  */
-export function runSetupInstall() {
+export async function runSetupInstall() {
   const bin = resolveStableBin();
   const installed = [];
   const missing = [];
+  const activations = [];
   if (commandExists("claude")) {
-    if (installClaudeCode(bin)) installed.push("Claude Code");
-    else missing.push("Claude Code (registration failed)");
+    if (installClaudeCode(bin)) {
+      installed.push("Claude Code");
+      activations.push(verifyClaudeMcpRegistration());
+    } else missing.push("Claude Code (registration failed)");
   } else missing.push("Claude Code");
   if (commandExists("codex")) {
-    if (installCodex(bin)) installed.push("Codex");
-    else missing.push("Codex (registration failed)");
+    if (installCodex(bin)) {
+      installed.push("Codex");
+      activations.push(await activateCodexMcp());
+    } else missing.push("Codex (registration failed)");
   } else missing.push("Codex");
   const daemon = installDaemonAutostart(bin);
   const pill = installPillAutostart(bin);
-  return { installed, missing, daemon, pill };
+  return { installed, missing, daemon, pill, activations };
 }
 
 /** Remove the Relay MCP from both agents and stop/clear the background daemon. */

package/src/setup-activation.js

@@ -0,0 +1,238 @@
+import { spawn, spawnSync } from "node:child_process";
+import readline from "node:readline";
+
+const DEFAULT_TIMEOUT_MS = 12_000;
+
+export function hasMcpTool(statusResponse, serverName = "relay", toolName = "relay_send") {
+  const servers = Array.isArray(statusResponse?.data) ? statusResponse.data : [];
+  const server = servers.find((item) => item?.name === serverName);
+  if (!server) return false;
+  if (Array.isArray(server.tools)) return server.tools.some((tool) => tool?.name === toolName);
+  return Boolean(server.tools?.[toolName]);
+}
+
+export function serverNames(statusResponse) {
+  return (Array.isArray(statusResponse?.data) ? statusResponse.data : [])
+    .map((item) => item?.name)
+    .filter(Boolean);
+}
+
+export function shouldRequireLiveTools(env = process.env) {
+  return Boolean(env.CODEX_THREAD_ID || env.CLAUDECODE || env.CLAUDE_CODE_SESSION_ID);
+}
+
+export function requiredLiveHosts(env = process.env) {
+  const hosts = [];
+  if (env.CODEX_THREAD_ID) hosts.push("Codex");
+  if (env.CLAUDECODE || env.CLAUDE_CODE_SESSION_ID) hosts.push("Claude Code");
+  return hosts;
+}
+
+export function liveToolRequirement({ activations = [], requiredHosts = [] } = {}) {
+  const readyHosts = new Set(
+    activations
+      .filter((activation) => activation?.currentSessionReady)
+      .map((activation) => activation.host)
+      .filter(Boolean),
+  );
+  if (requiredHosts.length) {
+    const missingHosts = requiredHosts.filter((host) => !readyHosts.has(host));
+    return { ok: missingHosts.length === 0, readyHosts: Array.from(readyHosts), missingHosts };
+  }
+  return { ok: readyHosts.size > 0, readyHosts: Array.from(readyHosts), missingHosts: [] };
+}
+
+function codexCatalogDetail(statusResponse, serverName = "relay", toolName = "relay_send") {
+  const servers = Array.isArray(statusResponse?.data) ? statusResponse.data : [];
+  const server = servers.find((item) => item?.name === serverName);
+  return {
+    serverCatalogReady: Boolean(server),
+    serverCatalogHasTool: hasMcpTool(statusResponse, serverName, toolName),
+    serverNames: serverNames(statusResponse),
+  };
+}
+
+class JsonlRpcClient {
+  constructor({ command = "codex", args = ["app-server", "proxy"], cwd = process.cwd(), timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+    this.command = command;
+    this.args = args;
+    this.cwd = cwd;
+    this.timeoutMs = timeoutMs;
+    this.nextId = 1;
+    this.pending = new Map();
+    this.proc = null;
+    this.stderr = "";
+  }
+
+  async start() {
+    if (this.proc) return;
+    this.proc = spawn(this.command, this.args, {
+      cwd: this.cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env },
+    });
+    this.proc.stderr.on("data", (chunk) => {
+      this.stderr += chunk.toString();
+    });
+    this.proc.on("error", (error) => {
+      this.rejectAll(error);
+      this.proc = null;
+    });
+    this.proc.on("exit", (code, signal) => {
+      const exitLabel = signal || (code ?? "unknown");
+      const err = new Error(`codex app-server proxy exited (${exitLabel})`);
+      if (this.stderr.trim()) err.stderr = this.stderr.trim();
+      this.rejectAll(err);
+      this.proc = null;
+    });
+    readline.createInterface({ input: this.proc.stdout, crlfDelay: Infinity }).on("line", (line) => {
+      if (!line.trim()) return;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        return;
+      }
+      if (message.id == null || !this.pending.has(message.id)) return;
+      const pending = this.pending.get(message.id);
+      this.pending.delete(message.id);
+      clearTimeout(pending.timer);
+      if (message.error) {
+        const err = new Error(message.error.message || `${pending.method} failed`);
+        err.code = message.error.code;
+        err.data = message.error.data;
+        pending.reject(err);
+      } else {
+        pending.resolve(message.result ?? {});
+      }
+    });
+  }
+
+  rejectAll(error) {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pending.clear();
+  }
+
+  request(method, params = undefined, timeoutMs = this.timeoutMs) {
+    if (!this.proc) return Promise.reject(new Error("codex app-server proxy is not running"));
+    const id = this.nextId++;
+    const payload = params === undefined ? { method, id } : { method, id, params };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.pending.set(id, { method, resolve, reject, timer });
+      this.proc.stdin.write(`${JSON.stringify(payload)}\n`);
+    });
+  }
+
+  notify(method, params = {}) {
+    if (!this.proc) throw new Error("codex app-server proxy is not running");
+    this.proc.stdin.write(`${JSON.stringify({ method, params })}\n`);
+  }
+
+  async stop() {
+    if (!this.proc) return;
+    this.proc.kill("SIGTERM");
+    this.proc = null;
+  }
+}
+
+function classifyCodexActivationError(error) {
+  const text = `${error?.message || ""}\n${error?.stderr || ""}\n${error?.data ? JSON.stringify(error.data) : ""}`;
+  if (/app-server-control|control socket|No such file|not running|missing/i.test(text)) {
+    return "codex_control_socket_unavailable";
+  }
+  if (/experimentalApi/i.test(text)) return "codex_experimental_api_rejected";
+  return "codex_reload_failed";
+}
+
+export async function activateCodexMcp({
+  client = null,
+  command = "codex",
+  cwd = process.cwd(),
+  threadId = process.env.CODEX_THREAD_ID,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+} = {}) {
+  const rpc = client || new JsonlRpcClient({ command, cwd, timeoutMs });
+  try {
+    await rpc.start();
+    await rpc.request("initialize", {
+      clientInfo: {
+        name: "relay_setup",
+        title: "Relay Setup",
+        version: "0.1.0",
+      },
+      capabilities: {
+        experimentalApi: true,
+        optOutNotificationMethods: ["item/agentMessage/delta", "command/exec/outputDelta", "process/outputDelta"],
+      },
+    }, timeoutMs);
+    rpc.notify("initialized", {});
+    await rpc.request("config/mcpServer/reload", null, timeoutMs);
+
+    const deadline = Date.now() + timeoutMs;
+    let lastStatus = null;
+    let catalog = {
+      serverCatalogReady: false,
+      serverCatalogHasTool: false,
+      serverNames: [],
+    };
+    do {
+      lastStatus = await rpc.request("mcpServerStatus/list", {
+        detail: "toolsAndAuthOnly",
+        limit: 100,
+        ...(threadId ? { threadId } : {}),
+      }, timeoutMs);
+      catalog = codexCatalogDetail(lastStatus);
+      if (catalog.serverCatalogHasTool) break;
+      await new Promise((resolve) => setTimeout(resolve, 300));
+    } while (Date.now() < deadline);
+
+    return {
+      host: "Codex",
+      ok: catalog.serverCatalogHasTool,
+      currentSessionReady: catalog.serverCatalogHasTool,
+      reason: catalog.serverCatalogHasTool
+        ? "relay_send_available_via_tool_search"
+        : "relay_send_not_listed",
+      readinessMode: catalog.serverCatalogHasTool ? "deferred_tool_search" : undefined,
+      verifiedTool: catalog.serverCatalogHasTool ? "relay_send" : undefined,
+      ...catalog,
+    };
+  } catch (error) {
+    return {
+      host: "Codex",
+      ok: false,
+      currentSessionReady: false,
+      reason: classifyCodexActivationError(error),
+      detail: error?.stderr || error?.message || String(error),
+    };
+  } finally {
+    await rpc.stop?.();
+  }
+}
+
+export function verifyClaudeMcpRegistration({ runCommand, command = "claude" } = {}) {
+  const run = runCommand || ((cmd, args) => spawnSyncCompat(cmd, args));
+  const res = run(command, ["mcp", "get", "relay"]);
+  return {
+    host: "Claude Code",
+    ok: Boolean(res.ok),
+    currentSessionReady: false,
+    reason: res.ok ? "registered_for_new_sessions" : "registration_not_visible",
+    detail: res.out || "",
+  };
+}
+
+function spawnSyncCompat(cmd, args) {
+  const res = spawnSync(cmd, args, { encoding: "utf8", timeout: 10_000 });
+  return {
+    ok: !res.error && res.status === 0,
+    out: `${res.stdout || ""}${res.stderr || ""}`.trim(),
+  };
+}