relay-companion 0.1.0 → 0.1.2

package/bin/relay.js

@@ -7,11 +7,12 @@ 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 { writeConfig, readConfig, apiUrl, DEFAULT_API_URL, DEFAULT_WEB_URL } 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";
+import { resetCompanionStateForAccount } from "../src/notifications.js";
 
 function parseFlags(argv) {
   const flags = {};
@@ -38,22 +39,29 @@ async function prompt(question, fallback = "") {
   return answer || fallback;
 }
 
-async function cmdPair(flags) {
-  const url = flags.api || (await prompt(`Relay API URL [${apiUrl()}]: `, apiUrl()));
-  const appUrl = flags.web || webUrl();
+async function cmdPair(flags, { promptForDefaults = true } = {}) {
+  let url = flags.api || process.env.RELAY_API_URL;
+  if (!url) {
+    url = promptForDefaults ? await prompt(`Relay API URL [${apiUrl()}]: `, apiUrl()) : DEFAULT_API_URL;
+  }
+  const appUrl = flags.web || process.env.RELAY_WEB_URL || DEFAULT_WEB_URL;
   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()));
+  let name = flags.name;
+  if (!name) {
+    name = promptForDefaults ? await prompt(`Device name [${os.hostname()}]: `, 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 });
+  resetCompanionStateForAccount({ user: res.user, deviceId: res.deviceId });
   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();
+  const { installed, missing, daemon, pill } = 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.`);
@@ -63,12 +71,16 @@ function applyInstall() {
   else if (daemon.reason === "autostart_unsupported_platform") {
     console.log("Run `relay daemon` to receive relays (background autostart is macOS-only for now).");
   }
+  if (pill?.ok) console.log("The Relay pill is open and will start automatically when you log in.");
+  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.");
 }
 
 /** Full setup: pair this device, then install the tools + daemon. */
 async function cmdSetup(flags) {
-  await cmdPair(flags);
+  await cmdPair(flags, { promptForDefaults: Boolean(flags.interactive) });
   console.log("");
   applyInstall();
 }
@@ -137,7 +149,7 @@ function openUrl(url) {
 // 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();
+  const host = String(flags.host || flags.in || "claude").toLowerCase();
   if (flags.task) {
     const result = await openTask({ taskId: String(flags.task), host, log });
     console.log(JSON.stringify(result, null, 2));
@@ -239,6 +251,7 @@ async function main() {
           "",
           "Usage:",
           "  relay setup [--code CODE] [--name NAME]               Pair this machine and add Relay to Claude Code + Codex",
+          "  relay setup --interactive                             Prompt for API URL and device name during setup",
           "  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)",

package/overlay/inbox.html

@@ -66,6 +66,21 @@
   .card.has-unread .sq0 { fill:var(--accent); }
   .word { font-family:var(--serif); font-size:19px; font-weight:500; letter-spacing:-.01em; color:var(--ink); line-height:1; }
   .spacer { flex:1 1 auto; }
+  .minimize-hint {
+    margin-right:10px;
+    font-size:11px;
+    font-weight:500;
+    color:var(--muted-3);
+    line-height:1;
+    transition:color .18s var(--settle), opacity .18s var(--settle), width .18s var(--settle), margin .18s var(--settle);
+  }
+  .lockup:hover .minimize-hint { color:var(--muted-2); }
+  .card.collapsed .minimize-hint {
+    width:0;
+    margin-right:0;
+    overflow:hidden;
+    opacity:0;
+  }
   .count {
     font-family:var(--mono); font-size:13px; font-weight:500; font-variant-numeric:tabular-nums;
     color:var(--accent); line-height:1; transition:color .3s var(--settle);
@@ -381,6 +396,7 @@
       </svg>
       <span class="word">relay</span>
       <span class="spacer"></span>
+      <span class="minimize-hint">Minimize</span>
       <span class="count zero" id="count">0</span>
     </div>
 
@@ -700,6 +716,7 @@
     task_cancelled: "Task cancelled",
     task_failed: "Task failed",
     connector_reauth: "Reconnect needed",
+    plain_relay: "Relay",
   };
   function relayKindLabel(kind) { return RELAY_KIND_LABEL[kind] || "Relay"; }
   // The clean split: Relays shows ONLY the urgent quick-reply (human_question) and
@@ -721,7 +738,7 @@
       // single-line subjects. Source: HumanResponse.question (protocol.ts), the real question.
       return firstLine(body, 240) || title || relayKindLabel(kind);
     }
-    if (kind === "task_completed" || kind === "result") {
+    if (kind === "plain_relay" || kind === "task_completed" || kind === "result") {
       return title || firstLine(body, 90) || relayKindLabel(kind);
     }
     // plain message / notice: subject is the first meaningful body line

package/overlay/main.cjs

@@ -69,6 +69,7 @@ async function relayClient() {
 }
 
 app.setName("Relay");
+const gotSingleInstanceLock = app.requestSingleInstanceLock();
 
 // ---- config / account ----------------------------------------------------
 
@@ -121,7 +122,35 @@ function taskWebUrl(taskId) {
 
 function readStore() {
   try {
-    return JSON.parse(fs.readFileSync(STATE_PATH, "utf8")) || {};
+    const store = JSON.parse(fs.readFileSync(STATE_PATH, "utf8")) || {};
+    const cfg = readConfigFile();
+    const current = {
+      userId: (cfg.user && cfg.user.id) || "",
+      email: (cfg.user && cfg.user.email) || "",
+      deviceId: cfg.deviceId || "",
+    };
+    if (current.userId || current.email) {
+      const account = store.account || {};
+      const missingAccount = !account.userId && !account.email;
+      const wrongUserId = account.userId && current.userId && account.userId !== current.userId;
+      const wrongEmail = account.email && current.email && account.email !== current.email;
+      if (missingAccount || wrongUserId || wrongEmail) {
+        const next = {
+          version: 1,
+          account: { ...current, resetAt: new Date().toISOString() },
+          profile: { name: "", handle: "", email: "", inboxDir: "", contactCardRoots: [], transport: { type: "relay_api" } },
+          contacts: [],
+          packets: {},
+          meetingNotes: {},
+          setup: {},
+          emailThreads: {},
+          chats: {},
+        };
+        writeStateAtomic(next);
+        return next;
+      }
+    }
+    return store;
   } catch {
     return {};
   }
@@ -294,12 +323,18 @@ function ackPacket(packetId) {
   if (!packetId) return;
   const store = readStore();
   if (!store.packets || !store.packets[packetId]) return;
+  const row = store.packets[packetId];
   store.packets[packetId] = {
-    ...store.packets[packetId],
+    ...row,
     state: "read",
     updatedAt: new Date().toISOString(),
   };
   writeStateAtomic(store);
+  if (row.relayNotificationKind === "plain_relay") {
+    relayClient()
+      .then((client) => client.markRead(packetId, { idempotencyKey: idempotencyKey("read") }))
+      .catch((error) => console.error("[overlay] relay mark-read failed:", error && error.message));
+  }
   pushInbox(true).catch(() => {});
 }
 
@@ -752,11 +787,21 @@ ipcMain.handle("relay:soundBytes", (_e, name) => {
   return null; // gracefully null when no sound is available
 });
 
-app.whenReady().then(() => {
-  if (process.platform === "darwin" && app.dock) app.dock.hide(); // accessory: no dock icon, no NC banners
-  createWindow();
-});
+if (!gotSingleInstanceLock) {
+  app.quit();
+} else {
+  app.on("second-instance", () => {
+    if (!win || win.isDestroyed()) return;
+    pollHosts();
+    maybeShow();
+  });
 
-app.on("window-all-closed", () => {
-  /* keep running as a background agent; relaunched by launchd KeepAlive if it dies */
-});
+  app.whenReady().then(() => {
+    if (process.platform === "darwin" && app.dock) app.dock.hide(); // accessory: no dock icon, no NC banners
+    createWindow();
+  });
+
+  app.on("window-all-closed", () => {
+    /* keep running as a background agent; relaunched at login by launchd */
+  });
+}

package/package.json

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

package/src/client.js

@@ -46,6 +46,34 @@ export class RelayClient {
     return this.#req("GET", "/v1/task-relays");
   }
 
+  sendRelay(payload) {
+    return this.#req("POST", "/v1/relays", payload);
+  }
+
+  inbox() {
+    return this.#req("GET", "/v1/inbox");
+  }
+
+  fetchRelay(id) {
+    return this.#req("GET", `/v1/relays/${encodeURIComponent(id)}`);
+  }
+
+  acknowledge(id, payload = {}) {
+    return this.#req("POST", `/v1/relays/${encodeURIComponent(id)}/ack`, payload);
+  }
+
+  markRead(id, payload = {}) {
+    return this.#req("POST", `/v1/relays/${encodeURIComponent(id)}/read`, payload);
+  }
+
+  openRelay(token) {
+    return this.#req("GET", `/v1/open/${encodeURIComponent(token)}`, undefined, { auth: false });
+  }
+
+  openRelayPacket(token) {
+    return this.#req("GET", `/v1/open/${encodeURIComponent(token)}/packet`, undefined, { auth: false });
+  }
+
   createFileUpload(payload) {
     return this.#req("POST", "/v1/files", payload);
   }

package/src/config.js

@@ -2,6 +2,9 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
+export const DEFAULT_API_URL = "https://aia6vj5pgp.us-east-1.awsapprunner.com";
+export const DEFAULT_WEB_URL = "https://sendrelays.com";
+
 /**
  * Companion configuration lives in ~/.relay/config.json. It holds the device
  * token issued at pairing and the API base URL. Environment variables override
@@ -36,7 +39,7 @@ export function apiUrl() {
   return (
     process.env.RELAY_API_URL ||
     readConfig().apiUrl ||
-    "https://aia6vj5pgp.us-east-1.awsapprunner.com"
+    DEFAULT_API_URL
   );
 }
 
@@ -44,7 +47,7 @@ export function webUrl() {
   return (
     process.env.RELAY_WEB_URL ||
     readConfig().webUrl ||
-    "http://localhost:3000"
+    DEFAULT_WEB_URL
   ).replace(/\/$/, "");
 }
 

package/src/install.js

@@ -2,6 +2,7 @@ import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 
 // Persistent install of the Relay companion into the user's local agents.
@@ -12,6 +13,7 @@ import { fileURLToPath } from "node:url";
 // It also installs a launchd agent that keeps the receive daemon running.
 
 const DAEMON_LAUNCH_LABEL = "work.relay.companion";
+const PILL_LAUNCH_LABEL = "work.relay.companion.pill";
 
 export const PACKAGE_NAME = "relay-companion";
 
@@ -20,6 +22,17 @@ export function relayBinPath() {
   return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../bin/relay.js");
 }
 
+function packageRootForBin(bin = relayBinPath()) {
+  return path.resolve(path.dirname(bin), "..");
+}
+
+function plistEscape(value) {
+  return String(value)
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;");
+}
+
 /**
  * A STABLE path to the companion CLI that the agents and the daemon can keep
  * launching. When `setup` runs from npx (an ephemeral cache that gets cleaned),
@@ -49,6 +62,16 @@ function run(cmd, args) {
   };
 }
 
+function electronPathForPackageRoot(packageRoot) {
+  try {
+    const require = createRequire(path.join(packageRoot, "package.json"));
+    const electronPath = require("electron");
+    return typeof electronPath === "string" && electronPath ? electronPath : null;
+  } catch {
+    return null;
+  }
+}
+
 /** Whether an agent CLI is on PATH. */
 export function commandExists(cmd) {
   const res = spawnSync(cmd, ["--version"], { encoding: "utf8", timeout: 8000 });
@@ -85,17 +108,59 @@ export function installDaemonAutostart(bin = relayBinPath(), node = process.exec
   <key>Label</key><string>${DAEMON_LAUNCH_LABEL}</string>
   <key>ProgramArguments</key>
   <array>
-    <string>${node}</string>
-    <string>${bin}</string>
+    <string>${plistEscape(node)}</string>
+    <string>${plistEscape(bin)}</string>
     <string>daemon</string>
   </array>
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key><true/>
-  <key>StandardOutPath</key><string>${logPath}</string>
-  <key>StandardErrorPath</key><string>${logPath}</string>
+  <key>StandardOutPath</key><string>${plistEscape(logPath)}</string>
+  <key>StandardErrorPath</key><string>${plistEscape(logPath)}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key><string>${plistEscape(pathEnv)}</string>
+  </dict>
+</dict>
+</plist>
+`;
+  fs.writeFileSync(plistPath, plist);
+  run("launchctl", ["unload", plistPath]); // ignore if not loaded
+  const res = run("launchctl", ["load", plistPath]);
+  return { ok: res.ok, plistPath, logPath };
+}
+
+/** Install + load a launchd agent that starts the visible Relay pill (macOS). */
+export function installPillAutostart(bin = relayBinPath()) {
+  if (process.platform !== "darwin") return { ok: false, reason: "autostart_unsupported_platform" };
+  const packageRoot = packageRootForBin(bin);
+  const electronPath = electronPathForPackageRoot(packageRoot);
+  const overlayMain = path.join(packageRoot, "overlay", "main.cjs");
+  if (!electronPath || !fs.existsSync(overlayMain)) {
+    return { ok: false, reason: "pill_runtime_missing", electronPath, overlayMain };
+  }
+
+  const home = os.homedir();
+  const plistPath = path.join(home, "Library", "LaunchAgents", `${PILL_LAUNCH_LABEL}.plist`);
+  const logPath = path.join(home, ".relay", "pill.log");
+  fs.mkdirSync(path.dirname(plistPath), { recursive: true });
+  fs.mkdirSync(path.dirname(logPath), { recursive: true });
+  const pathEnv = "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin";
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${PILL_LAUNCH_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${plistEscape(electronPath)}</string>
+    <string>${plistEscape(overlayMain)}</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>StandardOutPath</key><string>${plistEscape(logPath)}</string>
+  <key>StandardErrorPath</key><string>${plistEscape(logPath)}</string>
   <key>EnvironmentVariables</key>
   <dict>
-    <key>PATH</key><string>${pathEnv}</string>
+    <key>PATH</key><string>${plistEscape(pathEnv)}</string>
   </dict>
 </dict>
 </plist>
@@ -123,7 +188,8 @@ export function runSetupInstall() {
     else missing.push("Codex (registration failed)");
   } else missing.push("Codex");
   const daemon = installDaemonAutostart(bin);
-  return { installed, missing, daemon };
+  const pill = installPillAutostart(bin);
+  return { installed, missing, daemon, pill };
 }
 
 /** Remove the Relay MCP from both agents and stop/clear the background daemon. */
@@ -138,5 +204,12 @@ export function runUninstall() {
     } catch {
       /* already gone */
     }
+    const pillPlistPath = path.join(os.homedir(), "Library", "LaunchAgents", `${PILL_LAUNCH_LABEL}.plist`);
+    run("launchctl", ["unload", pillPlistPath]);
+    try {
+      fs.unlinkSync(pillPlistPath);
+    } catch {
+      /* already gone */
+    }
   }
 }

package/src/materializer.js

@@ -87,7 +87,7 @@ function readRowContent(rowState) {
 // real API. Returns a normalized "row" the host writers consume.
 async function resolveRow(id, { log = () => {} } = {}) {
   const rowState = getRowState(id);
-  if (!rowState) throw new Error(`Unknown Relay row: ${id}`);
+  if (!rowState) return resolvePublicOpenToken(id, { log });
   const content = readRowContent(rowState);
   // The staged content packet carries the same fields under different names
   // (briefingMarkdown/displayTitle/sender). Merge so either source satisfies the
@@ -132,6 +132,48 @@ async function resolveRow(id, { log = () => {} } = {}) {
   return { row, rowState };
 }
 
+async function resolvePublicOpenToken(token, { log = () => {} } = {}) {
+  try {
+    const { RelayClient } = await import("./client.js");
+    const client = new RelayClient();
+    const response = await client.openRelayPacket(token);
+    const packet = response?.packet;
+    if (!packet || typeof packet !== "object") throw new Error("packet missing");
+    const rowState = {
+      id: token,
+      direction: "inbound",
+      state: "unread",
+      kind: packet.kind || "message",
+      relayNotificationKind: "plain_relay",
+      senderName: packet.sender?.name || "Someone",
+      title: packet.title || "Relay",
+      displayTitle: packet.title || "Relay",
+      bodyMarkdown: packet.bodyMarkdown || "",
+      briefingMarkdown: packet.bodyMarkdown || "",
+      createdAt: packet.createdAt || new Date().toISOString(),
+      attachments: packet.attachments || [],
+      attachmentUrls: response.attachmentUrls || {},
+      materializationDeferredReason: "public_open_token",
+      materializedSurfaces: { codex: false, claudeCode: false, claudeCowork: false },
+    };
+    const row = {
+      ...packet,
+      ...rowState,
+      id: token,
+      sender: packet.sender || (rowState.senderName ? { name: rowState.senderName } : null),
+      recipient: packet.recipient || null,
+      displayTitle: rowState.displayTitle,
+      title: rowState.title,
+      bodyMarkdown: rowState.bodyMarkdown,
+      briefingMarkdown: renderRelayRowBriefing(rowState),
+    };
+    return { row, rowState };
+  } catch (error) {
+    log(`relay public open failed: ${error instanceof Error ? error.message : String(error)}`);
+    throw new Error(`Unknown Relay row or open token: ${token}`);
+  }
+}
+
 // Fetch the verified task object for a row that points at a task. The real API
 // shape of GET /v1/tasks/:taskId (RelayClient.getTask) is `{ task: Task }` — a
 // wrapper object, never a bare Task — so we unwrap response.task. Returns the

package/src/mcp.js

@@ -4,6 +4,66 @@ import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprot
 import { RelayClient } from "./client.js";
 
 export const TOOLS = [
+  {
+    name: "relay_send",
+    description:
+      "Send an ordinary Relay message or handoff to another person. Use this for the normal product flow when the human says things like 'send Sven a relay asking how he is doing' or 'relay this context to Jordan'. This is NOT a task and does not create an agent coordination run. If the recipient has Relay, it appears in their Relay companion pill and Relays list; if they do not have Relay, Relay emails them a public link saying the sender sent a relay, with options to open it in Claude or Codex without creating an account. Do not use task-only tools for this ordinary communication path.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        recipient: {
+          type: "object",
+          description: "Who should receive the relay. Prefer contactId or relayUserId when known; email is fine for someone not on Relay.",
+          properties: {
+            contactId: { type: "string" },
+            relayUserId: { type: "string" },
+            email: { type: "string" },
+            name: { type: "string" },
+          },
+        },
+        kind: { type: "string", enum: ["message", "handoff"], description: "Use message for notes/questions; handoff for larger context takeovers." },
+        title: { type: "string" },
+        bodyMarkdown: { type: "string" },
+        userInstructions: { type: "string", description: "Optional private instruction for how the recipient's agent should handle a handoff." },
+        targetSurfaces: {
+          type: "array",
+          items: { type: "string", enum: ["codex", "claude_code", "claude_desktop", "claude_cowork"] },
+        },
+        attachments: { type: "array", items: { type: "object" } },
+        idempotencyKey: { type: "string" },
+      },
+      required: ["recipient", "title", "bodyMarkdown", "idempotencyKey"],
+    },
+  },
+  {
+    name: "relay_contacts_search",
+    description:
+      "Search this human's Relay contact book before sending an ordinary relay. Use it when the human gives a name like 'Sven' and you need the correct person/email. If results are ambiguous, ask the human which contact they meant rather than guessing.",
+    inputSchema: {
+      type: "object",
+      properties: { query: { type: "string" } },
+      required: ["query"],
+    },
+  },
+  {
+    name: "relay_inbox_list",
+    description:
+      "List ordinary Relay messages addressed to this human. This does not list task coordination relays; use relay_task_status for task state.",
+    inputSchema: { type: "object", properties: {} },
+  },
+  {
+    name: "relay_acknowledge",
+    description:
+      "Acknowledge an ordinary Relay after it has been handled locally. This removes it from the active ordinary inbox.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        relayId: { type: "string" },
+        idempotencyKey: { type: "string" },
+      },
+      required: ["relayId", "idempotencyKey"],
+    },
+  },
   {
     name: "relay_task_create",
     description:
@@ -260,6 +320,26 @@ function text(obj) {
 
 export async function handleCall(client, name, args) {
   switch (name) {
+    case "relay_send":
+      return text(
+        await client.sendRelay({
+          recipient: args.recipient,
+          kind: args.kind || "message",
+          title: args.title,
+          bodyMarkdown: args.bodyMarkdown,
+          userInstructions: args.userInstructions || "",
+          source: { host: "relay-mcp" },
+          targetSurfaces: args.targetSurfaces || [],
+          attachments: args.attachments || [],
+          idempotencyKey: args.idempotencyKey,
+        }),
+      );
+    case "relay_contacts_search":
+      return text(await client.searchContacts(args.query));
+    case "relay_inbox_list":
+      return text(await client.inbox());
+    case "relay_acknowledge":
+      return text(await client.acknowledge(args.relayId, { idempotencyKey: args.idempotencyKey }));
     case "relay_task_create":
       return text(
         await client.createTask({

package/src/notifications.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { webUrl } from "./config.js";
+import { currentUser, readConfig, webUrl } from "./config.js";
 import { relayBinPath } from "./install.js";
 
 const DEFAULT_COMPANION_STATE = {
@@ -224,6 +224,48 @@ function writeCompanionState(statePath, state) {
   fs.renameSync(tmp, statePath);
 }
 
+function accountMarker({ user = currentUser(), deviceId = readConfig().deviceId || "" } = {}) {
+  return {
+    userId: user?.id || "",
+    email: user?.email || "",
+    deviceId: deviceId || "",
+  };
+}
+
+function stateBelongsToAccount(state, marker) {
+  if (!marker.userId && !marker.email) return true;
+  const account = state.account || {};
+  if (!account.userId && !account.email) return false;
+  if (account.userId && marker.userId && account.userId !== marker.userId) return false;
+  if (account.email && marker.email && account.email !== marker.email) return false;
+  return true;
+}
+
+export function resetCompanionStateForAccount(
+  { user = currentUser(), deviceId = readConfig().deviceId || "", force = false } = {},
+  { statePath = companionStatePath() } = {},
+) {
+  const marker = accountMarker({ user, deviceId });
+  const existing = readCompanionState(statePath);
+  if (!force && stateBelongsToAccount(existing, marker)) {
+    if (!existing.account) {
+      existing.account = { ...marker, resetAt: null };
+      writeCompanionState(statePath, existing);
+    }
+    return { reset: false, statePath };
+  }
+  const next = {
+    ...structuredClone(DEFAULT_COMPANION_STATE),
+    account: { ...marker, resetAt: new Date().toISOString() },
+    profile: {
+      ...structuredClone(DEFAULT_COMPANION_STATE.profile),
+      transport: { type: "relay_api" },
+    },
+  };
+  writeCompanionState(statePath, next);
+  return { reset: true, statePath };
+}
+
 function notificationUrgency(kind) {
   if (kind === "human_question") return "blocking";
   if (kind === "task_request" || kind === "share_approval") return "action_required";
@@ -410,3 +452,67 @@ export function stageRelayCompanionItem(notification, { statePath = companionSta
 export function defaultStageRelayCompanionItem(notification) {
   return stageRelayCompanionItem(notification);
 }
+
+export function stagePlainRelayItem({ item, packet, attachmentUrls = {} }, { statePath = companionStatePath() } = {}) {
+  if (!item?.relayId) throw new Error("stagePlainRelayItem requires an inbox item with relayId");
+  const state = readCompanionState(statePath);
+  state.packets ||= {};
+  state.chats ||= {};
+  const now = new Date().toISOString();
+  const existing = state.packets[item.relayId] || {};
+  const content = {
+    ...(packet || {}),
+    id: item.relayId,
+    briefingMarkdown: packet?.bodyMarkdown || item.preview || "",
+    attachmentUrls,
+    delivery: {
+      transport: "relay_api",
+      targetSurfaces: packet?.targetSurfaces || ["codex", "claude_code"],
+      recipientInboxDir: "",
+      outboxPath: null,
+      inboxPath: null,
+    },
+  };
+  const contentPath = writeNotificationPacketContent({ id: item.relayId }, content, statePath);
+  const readState = existing.state === "read" || item.state === "read" ? "read" : "unread";
+  const row = {
+    ...existing,
+    id: item.relayId,
+    direction: "inbound",
+    state: readState,
+    kind: item.kind || packet?.kind || "message",
+    relayNotificationKind: "plain_relay",
+    urgency: "normal",
+    senderName: item.sender?.name || packet?.sender?.name || "Someone",
+    title: item.title || packet?.title || item.preview || "Relay",
+    displayTitle: item.title || packet?.title || item.displayTitle || "Relay",
+    briefingMarkdown: packet?.bodyMarkdown || item.preview || "",
+    bodyMarkdown: packet?.bodyMarkdown || item.preview || "",
+    createdAt: item.createdAt || packet?.createdAt || now,
+    updatedAt: item.updatedAt || now,
+    stagedAt: now,
+    actionUrl: "/app/relays",
+    action: { type: "open", url: "/app/relays" },
+    quickReply: false,
+    taskId: null,
+    participantId: null,
+    messageId: null,
+    provider: null,
+    contentPath,
+    filePath: contentPath,
+    attachments: packet?.attachments || [],
+    attachmentUrls,
+    materializationDeferredReason: "relay_pill",
+    materializedSurfaces: existing.materializedSurfaces || { codex: false, claudeCode: false, claudeCowork: false },
+  };
+  state.packets[item.relayId] = row;
+  writeCompanionState(statePath, state);
+  return {
+    ok: true,
+    transport: "relay_companion",
+    statePath,
+    itemId: item.relayId,
+    actionUrl: row.actionUrl,
+    contentPath,
+  };
+}

package/src/task-daemon.js

@@ -13,6 +13,7 @@ import {
   defaultStageRelayCompanionItem,
   freshNotifications,
   markNotificationsProcessed,
+  stagePlainRelayItem as defaultStagePlainRelayItem,
 } from "./notifications.js";
 
 function idempotencyKey(prefix) {
@@ -55,6 +56,26 @@ function markTaskEventsProcessed(ledger, events) {
   }
 }
 
+function freshPlainRelays(ledger, items) {
+  ledger.plainRelays ||= {};
+  return items.filter((item) => {
+    const seen = ledger.plainRelays[item.relayId];
+    return !seen || seen.updatedAt !== item.updatedAt || seen.state !== item.state;
+  });
+}
+
+function markPlainRelaysProcessed(ledger, items) {
+  ledger.plainRelays ||= {};
+  const processedAt = new Date().toISOString();
+  for (const item of items) {
+    ledger.plainRelays[item.relayId] = {
+      state: item.state,
+      updatedAt: item.updatedAt || item.createdAt || "",
+      processedAt,
+    };
+  }
+}
+
 async function pollVisibleTaskEvents({ client, ledger, tasks, log }) {
   if (typeof client.taskEvents !== "function") return [];
   const visibleEvents = [];
@@ -76,7 +97,32 @@ async function pollVisibleTaskEvents({ client, ledger, tasks, log }) {
   return visibleEvents;
 }
 
-async function pollHumanNotifications({ client, ledger, stageCompanionItem, log }) {
+async function pollPlainInbox({ client, ledger, stagePlainRelay, log }) {
+  if (typeof client.inbox !== "function" || typeof client.fetchRelay !== "function") return [];
+  try {
+    const inbox = await client.inbox();
+    const fresh = freshPlainRelays(ledger, inbox.items || []);
+    const staged = [];
+    for (const item of fresh) {
+      try {
+        const relay = await client.fetchRelay(item.relayId);
+        stagePlainRelay({ item, packet: relay.packet, attachmentUrls: relay.attachmentUrls || {} });
+        staged.push(item);
+        log(`staged ordinary Relay from ${item.sender?.name || "someone"}: ${item.title || item.relayId}`);
+      } catch (err) {
+        log(`ordinary Relay staging failed for ${item.relayId}: ${err.message}`);
+      }
+    }
+    if (staged.length) markPlainRelaysProcessed(ledger, staged);
+    return staged;
+  } catch (err) {
+    log(`ordinary Relay inbox polling failed: ${err.message}`);
+    return [];
+  }
+}
+
+async function pollHumanNotifications({ client, ledger, stageCompanionItem, stagePlainRelay, log }) {
+  const ordinaryRelays = await pollPlainInbox({ client, ledger, stagePlainRelay, log });
   try {
     const [me, tasks, relays, connectors] = await Promise.all([
       client.me(),
@@ -103,10 +149,10 @@ async function pollHumanNotifications({ client, ledger, stageCompanionItem, log
       }
     }
     if (staged.length) markNotificationsProcessed(ledger, staged);
-    return { notifications: staged, events };
+    return { notifications: staged, ordinaryRelays, events };
   } catch (err) {
     log(`Relay companion attention polling failed: ${err.message}`);
-    return { notifications: [], events: [] };
+    return { notifications: [], ordinaryRelays, events: [] };
   }
 }
 
@@ -114,10 +160,16 @@ export async function pollTaskRuntimeOnce({
   client = new RelayClient(),
   log = () => {},
   stageCompanionItem = defaultStageRelayCompanionItem,
+  stagePlainRelay = defaultStagePlainRelayItem,
   adapters,
 } = {}) {
   const ledger = readTaskLedger();
-  const inbox = await client.agentInbox();
+  let inbox = { messages: [], sessions: [] };
+  try {
+    inbox = await client.agentInbox();
+  } catch (err) {
+    log(`task agent inbox polling failed: ${err.message}`);
+  }
   const fresh = freshMessages(ledger, inbox.messages || []);
   const processedMessageIds = new Set();
   const processedMessages = [];
@@ -179,9 +231,15 @@ export async function pollTaskRuntimeOnce({
     }
   }
 
-  const humanPolling = await pollHumanNotifications({ client, ledger, stageCompanionItem, log });
+  const humanPolling = await pollHumanNotifications({ client, ledger, stageCompanionItem, stagePlainRelay, log });
   writeTaskLedger(ledger);
-  return { sessions: touched, messages: processedMessages, notifications: humanPolling.notifications, events: humanPolling.events };
+  return {
+    sessions: touched,
+    messages: processedMessages,
+    notifications: humanPolling.notifications,
+    ordinaryRelays: humanPolling.ordinaryRelays,
+    events: humanPolling.events,
+  };
 }
 
 export async function runTaskDaemon({ intervalMs = 4000 } = {}) {
@@ -194,9 +252,15 @@ export async function runTaskDaemon({ intervalMs = 4000 } = {}) {
   for (;;) {
     try {
       const result = await pollTaskRuntimeOnce({ client, log });
-      if (result.sessions.length || result.messages.length || result.notifications.length || result.events.length) {
+      if (
+        result.sessions.length ||
+        result.messages.length ||
+        result.notifications.length ||
+        result.ordinaryRelays.length ||
+        result.events.length
+      ) {
         log(
-          `processed ${result.sessions.length} session(s), ${result.messages.length} message(s), ${result.notifications.length} Relay companion item(s), ${result.events.length} event(s)`,
+          `processed ${result.sessions.length} session(s), ${result.messages.length} message(s), ${result.notifications.length} task attention item(s), ${result.ordinaryRelays.length} ordinary relay(s), ${result.events.length} event(s)`,
         );
       }
     } catch (err) {