relay-companion 0.1.0

package/bin/relay.js

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+import { spawnSync, spawn } from "node:child_process";
+import readline from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { RelayClient } from "../src/client.js";
+import { writeConfig, readConfig, apiUrl, webUrl } from "../src/config.js";
+import { runTaskDaemon, pollTaskRuntimeOnce } from "../src/task-daemon.js";
+import { runMcpServer } from "../src/mcp.js";
+import { runSetupInstall, runUninstall } from "../src/install.js";
+import { openRelay, openTask } from "../src/materializer.js";
+
+function parseFlags(argv) {
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const key = a.slice(2);
+      const next = argv[i + 1];
+      if (next === undefined || next.startsWith("--")) flags[key] = true;
+      else {
+        flags[key] = next;
+        i++;
+      }
+    } else positional.push(a);
+  }
+  return { flags, positional };
+}
+
+async function prompt(question, fallback = "") {
+  const rl = readline.createInterface({ input: stdin, output: stdout });
+  const answer = (await rl.question(question)).trim();
+  rl.close();
+  return answer || fallback;
+}
+
+async function cmdPair(flags) {
+  const url = flags.api || (await prompt(`Relay API URL [${apiUrl()}]: `, apiUrl()));
+  const appUrl = flags.web || webUrl();
+  let code = flags.code;
+  if (!code) code = await prompt("Pairing code (from your Relay app): ");
+  const name = flags.name || (await prompt(`Device name [${os.hostname()}]: `, os.hostname()));
+  writeConfig({ apiUrl: url, webUrl: appUrl });
+  const client = new RelayClient({ url });
+  const res = await client.registerDevice({ pairingCode: code, name, platform: process.platform });
+  writeConfig({ apiUrl: url, webUrl: appUrl, deviceToken: res.deviceToken, deviceId: res.deviceId, user: res.user });
+  console.log(`Paired as ${res.user.name} <${res.user.email}>. This device is now connected to Relay.`);
+}
+
+/** Register the Relay tools into Claude Code + Codex and start the receive daemon. */
+function applyInstall() {
+  const { installed, missing, daemon } = 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}.`);
+  }
+  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).");
+  }
+  if (installed.length) console.log("Open Claude Code or Codex and your Relay tools are ready.");
+}
+
+/** Full setup: pair this device, then install the tools + daemon. */
+async function cmdSetup(flags) {
+  await cmdPair(flags);
+  console.log("");
+  applyInstall();
+}
+
+/** Install the tools + daemon on a device that is already paired. */
+async function cmdInstall() {
+  if (!readConfig().deviceToken) {
+    throw new Error("This device is not paired yet. Run `relay setup` with a pairing code first.");
+  }
+  applyInstall();
+}
+
+/** Remove the Relay tools from both agents and stop the background daemon. */
+async function cmdUninstall() {
+  runUninstall();
+  console.log("Removed Relay from Claude Code and Codex, and stopped the background daemon.");
+}
+
+async function cmdWhoami() {
+  const cfg = readConfig();
+  if (!cfg.deviceToken) {
+    console.log("Not paired. Run: relay pair");
+    return;
+  }
+  const client = new RelayClient();
+  const me = await client.me();
+  console.log(`${me.user.name} <${me.user.email}>  (api: ${apiUrl()})`);
+}
+
+async function cmdTasksOnce() {
+  const out = await pollTaskRuntimeOnce({ log: (m) => console.log(`[relay] ${m}`) });
+  console.log(
+    `Processed ${out.sessions.length} task session(s), ${out.messages.length} message(s), ${out.notifications.length} Relay companion item(s).`,
+  );
+}
+
+function absoluteWebTarget(pathOrUrl = "/app/tasks") {
+  if (/^https?:\/\//i.test(pathOrUrl)) return pathOrUrl;
+  const path = pathOrUrl.startsWith("/") ? pathOrUrl : `/${pathOrUrl}`;
+  return `${webUrl()}${path}`;
+}
+
+function openUrl(url) {
+  const command = process.platform === "darwin"
+    ? "open"
+    : process.platform === "win32"
+      ? "cmd"
+      : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  const result = spawnSync(command, args, { stdio: "ignore" });
+  if (result.status !== 0) {
+    console.log(url);
+    return false;
+  }
+  return true;
+}
+
+// `relay open <id> --host <host>` — materialize the staged Relay row into a real
+// native agent session inside the already-running Claude Desktop or Codex, then
+// print { url, skipExternalOpen, openedInHost } so the overlay can fall back to
+// shell.openExternal(url) when the host wasn't foregrounded directly.
+//
+// `relay open --task <taskId> --host <host>` — same materialization, but seeded
+// from a Relay task (active or completed): the session opens with the task's
+// objective + state and an instruction to call relay_task_status(taskId) for live
+// detail. Prints the identical JSON contract.
+async function cmdOpen(positional, flags) {
+  const log = (m) => process.stderr.write(`[relay] ${m}\n`);
+  const host = String(flags.host || "claude").toLowerCase();
+  if (flags.task) {
+    const result = await openTask({ taskId: String(flags.task), host, log });
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  const id = positional[0] || flags.id;
+  if (!id) throw new Error("Usage: relay open <id> --host claude|codex  (or: relay open --task <taskId> --host claude|codex)");
+  const result = await openRelay({ id, host, log });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function cmdOpenNotification(flags) {
+  let target = flags.url;
+  if (!target && flags.task) target = `/app/tasks/${encodeURIComponent(flags.task)}`;
+  if (!target && flags.message) target = "/app/relays";
+  target ||= "/app/tasks";
+  const url = absoluteWebTarget(target);
+  const opened = openUrl(url);
+  console.log(opened ? `Opened ${url}` : `Open this Relay URL: ${url}`);
+}
+
+async function cmdAnswerQuestion(flags) {
+  const taskId = flags.task || flags.taskId;
+  const messageId = flags.message || flags.messageId;
+  let answer = flags.answer;
+  if (!taskId || !messageId) {
+    throw new Error("Usage: relay answer-question --task TASK_ID --message MESSAGE_ID --answer ANSWER");
+  }
+  if (!answer) answer = await prompt("Answer: ");
+  const client = new RelayClient();
+  await client.answerHumanQuestion(taskId, messageId, {
+    answerMarkdown: answer,
+    idempotencyKey: `human_answer_${Date.now()}`,
+  });
+  console.log("Sent answer to Relay. The waiting task agent will resume on the next daemon poll.");
+}
+
+/** Launch the desktop Relay companion pill (Electron overlay). */
+function cmdPill() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const overlayMain = path.resolve(here, "../overlay/main.cjs");
+  // require("electron") returns the path to the electron binary when resolved under node.
+  let electronPath;
+  try {
+    const require = createRequire(import.meta.url);
+    electronPath = require("electron");
+  } catch (error) {
+    throw new Error(
+      "Electron is not installed. Run `npm install` in packages/companion first. (" +
+        (error && error.message ? error.message : error) +
+        ")",
+    );
+  }
+  if (typeof electronPath !== "string") {
+    throw new Error("Could not resolve the Electron binary. Run `npm install` in packages/companion.");
+  }
+  const child = spawn(electronPath, [overlayMain], {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env },
+  });
+  child.unref();
+  console.log("Relay pill launched. It shows when Claude Code or Codex is running.");
+}
+
+async function main() {
+  const [command, ...rest] = process.argv.slice(2);
+  const { flags, positional } = parseFlags(rest);
+  switch (command) {
+    case "setup":
+      return cmdSetup(flags);
+    case "pair":
+      return cmdPair(flags);
+    case "install":
+      return cmdInstall();
+    case "uninstall":
+      return cmdUninstall();
+    case "whoami":
+      return cmdWhoami();
+    case "tasks":
+      return cmdTasksOnce();
+    case "open":
+      return cmdOpen(positional, flags);
+    case "open-notification":
+      return cmdOpenNotification(flags);
+    case "answer-question":
+    case "answer":
+      return cmdAnswerQuestion(flags);
+    case "daemon":
+      return runTaskDaemon({ intervalMs: Number(flags.interval) || 4000 });
+    case "pill":
+      return cmdPill();
+    case "mcp":
+      return runMcpServer();
+    default:
+      console.log(
+        [
+          "Relay companion",
+          "",
+          "Usage:",
+          "  relay setup [--code CODE] [--name NAME]               Pair this machine and add Relay to Claude Code + Codex",
+          "  relay install                                         Add Relay to your agents (device already paired)",
+          "  relay uninstall                                       Remove Relay from your agents and stop the daemon",
+          "  relay pair [--api URL] [--web URL] [--code CODE]      Pair this machine only (no agent install)",
+          "  relay tasks                                           Pull and process task agent runtime once",
+          "  relay open <id> --host claude|codex                  Materialize a staged Relay row into a native agent session",
+          "  relay open --task <taskId> --host claude|codex       Materialize a Relay task into a native agent session",
+          "  relay open-notification [--url PATH] [--task ID]      Open a Relay companion target in the browser",
+          "  relay answer-question --task ID --message ID --answer TEXT",
+          "  relay daemon [--interval MS]                          Run the task runtime daemon",
+          "  relay pill                                            Launch the desktop Relay companion pill",
+          "  relay mcp                                             Run the MCP server (for your agent)",
+          "  relay whoami                                          Show the paired account",
+        ].join("\n"),
+      );
+  }
+}
+
+main().catch((err) => {
+  console.error(err.message || err);
+  process.exit(1);
+});