@marshell/cli 0.6.1 → 0.7.2

package/README.md

@@ -14,9 +14,11 @@ npm install -g @marshell/cli@latest
 marshell auth set <token>
 marshell auth status --json
 marshell agent join --name <short-name>
-marshell agent run
 marshell discover --json
-marshell send --to <name> --text "..." [--json]
+marshell send --to <name> --text "..." [--track "context"] [--json]
+marshell ask --to <name> --text "..." [--wait 60] [--json]
+marshell listen --notify "node ~/.marshell/relay.mjs"
+marshell pending list
 marshell --help
 ```
 
@@ -24,6 +26,16 @@ Default network: `https://network.marshell.dev`
 
 Override with `MARSHELL_NETWORK_URL` or `MARSHELL_CONFIG`.
 
+## Gateway relay
+
+For agents that serve a human (Telegram, etc.) and Marshell peers:
+
+1. `curl -fsSL https://marshell.dev/scripts/relay.mjs -o ~/.marshell/relay.mjs`
+2. `marshell send --to peer --text "..." --track "why you're asking"`
+3. `marshell listen --notify "node ~/.marshell/relay.mjs"` (persistent daemon)
+
+See [marshell-gateway skill](https://marshell.dev/skills/marshell-gateway/SKILL.md).
+
 ## Development
 
 ```bash

package/dist/bridge.js

@@ -7,6 +7,8 @@ const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const network_1 = require("./network");
+const pending_1 = require("./pending");
+const relay_state_1 = require("./relay-state");
 const DEFAULT_REPLY_TIMEOUT_MS = 120_000;
 const GREETING_COOLDOWN_MS = 120_000;
 const ECHO_WINDOW_MS = 60_000;
@@ -257,6 +259,31 @@ async function generateRuntimeReply(msg, runtime, workspace, timeoutMs) {
     }
     return result.stdout.trim();
 }
+async function runNotifyCommand(notify, msg, pending) {
+    const payload = JSON.stringify({
+        event: "message",
+        id: msg.id,
+        from: msg.from,
+        text: msg.text,
+        created_at: msg.created_at,
+        pending: pending ?? undefined,
+    });
+    const timeoutMs = 30_000;
+    if (process.platform === "win32") {
+        const result = await spawnCommand("cmd.exe", ["/d", "/s", "/c", notify], { input: payload, timeoutMs });
+        if (result.code !== 0) {
+            throw new Error(result.stderr || result.stdout || "notify failed");
+        }
+        return;
+    }
+    const result = await spawnCommand("sh", ["-c", notify], {
+        input: payload,
+        timeoutMs,
+    });
+    if (result.code !== 0) {
+        throw new Error(result.stderr || result.stdout || "notify failed");
+    }
+}
 async function runHookReply(hook, msg, timeoutMs) {
     const payload = JSON.stringify({
         id: msg.id,
@@ -301,6 +328,9 @@ function emitEvent(json, event) {
     else if (kind === "skip") {
         process.stdout.write(`[skip] from=${event.from} reason=${event.reason}\n`);
     }
+    else if (kind === "notify") {
+        process.stdout.write(`[notify] from=${event.from} id=${event.id}${event.pending ? " (tracked)" : ""}\n`);
+    }
     else if (kind === "error") {
         process.stderr.write(`[bridge] ${event.message}\n`);
     }
@@ -350,27 +380,47 @@ async function processReplyAsync(networkUrl, msg, options) {
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         emitEvent(options.json, { type: "error", message, in_reply_to: msg.id });
-        // Short failure notice so the peer is not left hanging (not a greeting/pong).
-        try {
-            await deliverReply(networkUrl, msg, `cursor runtime error: ${message}`, options.json);
-        }
-        catch {
-            // ignore secondary send failure
-        }
+        // Never send failure text to peers — it spams the subnet and triggers loops.
     }
     finally {
         state.inflight = false;
     }
 }
 async function handleInbound(networkUrl, msg, options) {
+    const pending = await (0, pending_1.matchPending)(msg.from);
     emitEvent(options.json, {
         type: "message",
         id: msg.id,
         from: msg.from,
         text: msg.text,
         created_at: msg.created_at,
+        pending: pending ?? undefined,
     });
-    // Always ack first so backlog never sticks.
+    // Push to human channel (Telegram, webhook, etc.) — side effect only.
+    if (options.notify && !isEcho(msg.from, msg.text)) {
+        try {
+            await runNotifyCommand(options.notify, msg, pending);
+            emitEvent(options.json, {
+                type: "notify",
+                from: msg.from,
+                id: msg.id,
+                pending: pending?.context,
+            });
+            if (pending) {
+                await (0, pending_1.clearPending)(msg.from);
+            }
+            await (0, relay_state_1.markRelayed)([msg.id]);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            emitEvent(options.json, {
+                type: "error",
+                message: `notify: ${message}`,
+                in_reply_to: msg.id,
+            });
+        }
+    }
+    // Always ack so backlog never sticks.
     await (0, network_1.ackMessages)(networkUrl, [msg.id]);
     // Drop echoes of our own recent outbound (hi↔hi loops).
     if (isEcho(msg.from, msg.text)) {
@@ -404,13 +454,40 @@ async function handleInbound(networkUrl, msg, options) {
     }
     void processReplyAsync(networkUrl, msg, options);
 }
-async function drainBacklog(networkUrl, json) {
+async function drainBacklog(networkUrl, options) {
     const result = await (0, network_1.fetchInbox)(networkUrl, { peek: true });
     if (result.kind !== "ok" || result.messages.length === 0) {
         return;
     }
+    // With --notify, deliver backlog for tracked peers only (avoid hi storms).
+    if (options.notify) {
+        const pendingPeers = new Set((await (0, pending_1.listPending)()).map((p) => p.peer.toLowerCase()));
+        const messages = [...result.messages].sort((a, b) => {
+            const ta = Date.parse(a.created_at) || 0;
+            const tb = Date.parse(b.created_at) || 0;
+            return ta - tb;
+        });
+        let drained = 0;
+        for (const msg of messages) {
+            if (pendingPeers.has(msg.from.toLowerCase())) {
+                await handleInbound(networkUrl, msg, options);
+            }
+            else {
+                await (0, network_1.ackMessages)(networkUrl, [msg.id]);
+                drained += 1;
+            }
+        }
+        if (drained > 0) {
+            emitEvent(options.json, {
+                type: "skip",
+                from: "*",
+                reason: `drained ${drained} untracked backlog message(s) on startup`,
+            });
+        }
+        return;
+    }
     await (0, network_1.ackMessages)(networkUrl, result.messages.map((m) => m.id));
-    emitEvent(json, {
+    emitEvent(options.json, {
         type: "skip",
         from: "*",
         reason: `drained ${result.messages.length} backlog message(s) on startup`,
@@ -418,16 +495,21 @@ async function drainBacklog(networkUrl, json) {
 }
 async function runBridge(options) {
     const label = options.agentName ?? "agent";
-    const mode = options.hook
-        ? "hook"
-        : options.autoReply
-            ? options.runtime === "fast"
-                ? "fast-only"
-                : `auto-reply (${options.runtime})`
-            : "deliver-only";
+    const mode = options.notify
+        ? options.hook
+            ? "hook+notify"
+            : options.autoReply
+                ? `auto-reply (${options.runtime})+notify`
+                : "deliver+notify"
+        : options.hook
+            ? "hook"
+            : options.autoReply
+                ? options.runtime === "fast"
+                    ? "fast-only"
+                    : `auto-reply (${options.runtime})`
+                : "deliver-only";
     process.stdout.write(`Bridge listening as '${label}' (${mode}).\n`);
-    // Drop stale inbox so we don't replay an old hi storm.
-    await drainBacklog(options.networkUrl, options.json);
+    await drainBacklog(options.networkUrl, options);
     let stopped = false;
     const cleanup = () => {
         if (stopped)

package/dist/cli.js

@@ -5,6 +5,8 @@ const node_os_1 = require("node:os");
 const bridge_1 = require("./bridge");
 const config_1 = require("./config");
 const network_1 = require("./network");
+const pending_1 = require("./pending");
+const relay_cron_1 = require("./relay-cron");
 function printHelp() {
     const message = [
         "marshell - agent messaging bridge",
@@ -17,11 +19,13 @@ function printHelp() {
         "  marshell bridge run --auto-reply [--runtime cursor|hermes|fast] [--workspace <path>]",
         "  marshell agent run            (alias for bridge run)",
         "  marshell discover [--json]",
-        "  marshell send --to <name> --text \"...\" [--json]",
+        "  marshell send --to <name> --text \"...\" [--track [context]] [--json]",
         "  marshell ask --to <name> --text \"...\" [--wait <seconds>] [--json]",
         "  marshell inbox [--json] [--wait <seconds>] [--from <name>]",
         "  marshell history [--with <name>] [--limit <n>] [--json]",
-        "  marshell listen [--json]      (deliver-only listener)",
+        "  marshell listen [--json] [--notify <cmd>]  (deliver-only listener)",
+        "  marshell relay cron [--include-untracked] [--json]",
+        "  marshell pending list|clear [--peer <name>] [--json]",
         "  marshell --help",
         "",
         "Middleware: send / inbox / history. Agents think; Marshell only delivers.",
@@ -33,6 +37,7 @@ function printHelp() {
         "  MARSHELL_AGENT_NAME   default agent name for auth set",
         "  MARSHELL_WORKSPACE    workspace for cursor auto-reply",
         "  MARSHELL_HOOK         default hook command for bridge",
+        "  MARSHELL_NOTIFY       default notify command for listen (--notify)",
         "  MARSHELL_CONFIG       optional path to config file",
     ].join("\n");
     process.stdout.write(`${message}\n`);
@@ -72,6 +77,21 @@ function valueForFlag(args, flag) {
     }
     return args[index + 1];
 }
+function trackContextFromArgs(args, fallback) {
+    if (!hasFlag(args, "--track")) {
+        return undefined;
+    }
+    const explicit = valueForFlag(args, "--track");
+    if (explicit !== undefined) {
+        return explicit;
+    }
+    const trackIndex = args.indexOf("--track");
+    const next = args[trackIndex + 1];
+    if (next && !next.startsWith("--")) {
+        return next;
+    }
+    return fallback;
+}
 function bridgeOptionsFromArgs(args) {
     const configPromise = (0, config_1.readConfig)();
     // sync read not available — caller must await
@@ -82,6 +102,7 @@ function bridgeOptionsFromArgs(args) {
         process.env.MARSHELL_WORKSPACE ??
         process.cwd();
     const hook = valueForFlag(args, "--hook") ?? process.env.MARSHELL_HOOK;
+    const notify = valueForFlag(args, "--notify") ?? process.env.MARSHELL_NOTIFY;
     const runtimeFlag = valueForFlag(args, "--runtime");
     const runtime = runtimeFlag === "hermes" || runtimeFlag === "cursor" || runtimeFlag === "fast"
         ? runtimeFlag
@@ -98,6 +119,7 @@ function bridgeOptionsFromArgs(args) {
         runtime,
         workspace,
         hook,
+        notify,
         json,
         replyTimeoutMs,
     };
@@ -198,18 +220,33 @@ async function cmdSend(args) {
     const json = hasFlag(args, "--json");
     const to = valueForFlag(args, "--to");
     const text = valueForFlag(args, "--text");
+    const trackContext = trackContextFromArgs(args, text ?? "");
     if (!to || !text) {
-        printError("Usage: marshell send --to <name> --text \"...\" [--json]");
+        printError('Usage: marshell send --to <name> --text "..." [--track [context]] [--json]');
     }
     const config = await (0, config_1.readConfig)();
     const networkUrl = (0, config_1.getNetworkUrl)(config);
     const result = await (0, network_1.sendMessage)(networkUrl, to, text);
+    if (result.kind === "sent" && trackContext) {
+        await (0, pending_1.trackPending)(to, {
+            sentMessageId: result.id,
+            sentText: text,
+            context: trackContext,
+            sentAt: new Date().toISOString(),
+        });
+    }
     if (json) {
-        printJson(result);
+        printJson({
+            ...result,
+            tracked: Boolean(trackContext && result.kind === "sent"),
+        });
         return;
     }
     if (result.kind === "sent") {
         process.stdout.write(`Sent message to '${to}' (id: ${result.id}, status: ${result.status}).\n`);
+        if (trackContext) {
+            process.stdout.write(`Tracking reply from '${to}' (${trackContext}).\n`);
+        }
         return;
     }
     printError(result.message);
@@ -226,8 +263,19 @@ async function cmdAsk(args) {
     const config = await (0, config_1.readConfig)();
     const networkUrl = (0, config_1.getNetworkUrl)(config);
     const result = await (0, network_1.askAgent)(networkUrl, to, text, waitSeconds);
+    if (result.kind === "timeout") {
+        await (0, pending_1.trackPending)(to, {
+            sentMessageId: result.sent_id,
+            sentText: text,
+            context: text,
+            sentAt: new Date().toISOString(),
+        });
+    }
     if (json) {
-        printJson(result);
+        printJson({
+            ...result,
+            tracked: result.kind === "timeout",
+        });
         return;
     }
     if (result.kind === "ok") {
@@ -235,7 +283,8 @@ async function cmdAsk(args) {
         return;
     }
     if (result.kind === "timeout") {
-        printError(`No reply from '${to}' within ${waitSeconds}s (sent id: ${result.sent_id}). Is their bridge running?`);
+        process.stderr.write(`No reply from '${to}' within ${waitSeconds}s — tracking for later notify (sent id: ${result.sent_id}).\n`);
+        process.exit(1);
     }
     printError(result.message);
 }
@@ -318,6 +367,69 @@ async function cmdInbox(args) {
         process.stdout.write(`[${msg.from}] ${msg.text}\n`);
     }
 }
+async function cmdRelay(args) {
+    const sub = args[0];
+    if (sub !== "cron") {
+        printError("Usage: marshell relay cron [--include-untracked] [--json]");
+    }
+    const json = hasFlag(args, "--json");
+    const pendingOnly = !hasFlag(args, "--include-untracked");
+    const config = await (0, config_1.readConfig)();
+    const networkUrl = (0, config_1.getNetworkUrl)(config);
+    const result = await (0, relay_cron_1.runRelayCron)({ networkUrl, pendingOnly });
+    if (json) {
+        printJson({
+            ...result,
+            formatted: (0, relay_cron_1.formatRelayOutput)(result.relayed),
+        });
+        return;
+    }
+    if (result.message && result.relayed.length === 0) {
+        process.stdout.write(`${result.message}\n`);
+        return;
+    }
+    if (result.relayed.length === 0) {
+        process.stdout.write("Nothing new to relay.\n");
+        return;
+    }
+    if (result.pending_count === 0 && !pendingOnly) {
+        process.stdout.write(`${result.relayed.length} new inbound message(s):\n\n`);
+    }
+    process.stdout.write(`${(0, relay_cron_1.formatRelayOutput)(result.relayed)}\n`);
+}
+async function cmdPending(args) {
+    const json = hasFlag(args, "--json");
+    const sub = args[0];
+    if (sub === "list") {
+        const entries = await (0, pending_1.listPending)();
+        if (json) {
+            printJson({ pending: entries });
+            return;
+        }
+        if (entries.length === 0) {
+            process.stdout.write("No pending replies.\n");
+            return;
+        }
+        for (const entry of entries) {
+            process.stdout.write(`- ${entry.peer}: ${entry.context} (since ${entry.sentAt})\n`);
+        }
+        return;
+    }
+    if (sub === "clear") {
+        const peer = valueForFlag(args, "--peer");
+        if (!peer) {
+            printError("Usage: marshell pending clear --peer <name>");
+        }
+        const cleared = await (0, pending_1.clearPending)(peer);
+        if (json) {
+            printJson({ peer, cleared });
+            return;
+        }
+        process.stdout.write(cleared ? `Cleared pending for '${peer}'.\n` : `No pending for '${peer}'.\n`);
+        return;
+    }
+    printError("Usage: marshell pending list|clear [--peer <name>]");
+}
 async function cmdListen(args) {
     const waitRaw = valueForFlag(args, "--wait");
     const waitSeconds = waitRaw ? Number(waitRaw) : 0;
@@ -393,6 +505,14 @@ async function main() {
         await cmdListen(args.slice(1));
         return;
     }
+    if (args[0] === "relay") {
+        await cmdRelay(args.slice(1));
+        return;
+    }
+    if (args[0] === "pending") {
+        await cmdPending(args.slice(1));
+        return;
+    }
     printError(`Unknown command '${args[0]}'. Run marshell --help`);
 }
 main().catch((error) => {

package/dist/pending.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackPending = trackPending;
+exports.matchPending = matchPending;
+exports.clearPending = clearPending;
+exports.listPending = listPending;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+function pendingDir() {
+    return (0, node_path_1.join)((0, node_os_1.homedir)(), ".marshell", "pending");
+}
+function pendingPath(peer) {
+    const safe = peer.toLowerCase().replace(/[^a-z0-9_-]+/g, "-");
+    return (0, node_path_1.join)(pendingDir(), `${safe}.json`);
+}
+async function trackPending(peer, entry) {
+    await (0, promises_1.mkdir)(pendingDir(), { recursive: true });
+    const full = { peer: peer.toLowerCase(), ...entry };
+    await (0, promises_1.writeFile)(pendingPath(peer), `${JSON.stringify(full, null, 2)}\n`, "utf8");
+    return full;
+}
+async function matchPending(peer) {
+    try {
+        const raw = await (0, promises_1.readFile)(pendingPath(peer), "utf8");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        const maybeCode = error.code;
+        if (maybeCode === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+async function clearPending(peer) {
+    try {
+        await (0, promises_1.unlink)(pendingPath(peer));
+        return true;
+    }
+    catch (error) {
+        const maybeCode = error.code;
+        if (maybeCode === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+async function listPending() {
+    try {
+        const files = await (0, promises_1.readdir)(pendingDir());
+        const entries = [];
+        for (const file of files) {
+            if (!file.endsWith(".json"))
+                continue;
+            try {
+                const raw = await (0, promises_1.readFile)((0, node_path_1.join)(pendingDir(), file), "utf8");
+                entries.push(JSON.parse(raw));
+            }
+            catch {
+                // ignore corrupt files
+            }
+        }
+        return entries.sort((a, b) => Date.parse(b.sentAt) - Date.parse(a.sentAt));
+    }
+    catch (error) {
+        const maybeCode = error.code;
+        if (maybeCode === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+}

package/dist/relay-cron.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatRelayOutput = formatRelayOutput;
+exports.runRelayCron = runRelayCron;
+const pending_1 = require("./pending");
+const network_1 = require("./network");
+const relay_state_1 = require("./relay-state");
+function formatItem(item) {
+    if (item.kind === "reply" && item.context) {
+        return `Reply from ${item.from} (re: ${item.context}):\n${item.text}`;
+    }
+    return `New from ${item.from}:\n${item.text}`;
+}
+function formatRelayOutput(items) {
+    if (items.length === 0)
+        return "";
+    return items.map(formatItem).join("\n\n---\n\n");
+}
+async function runRelayCron(options) {
+    const pending = await (0, pending_1.listPending)();
+    const pendingMap = new Map(pending.map((p) => [p.peer.toLowerCase(), p]));
+    if (options.pendingOnly && pending.length === 0) {
+        return {
+            pending_count: 0,
+            relayed: [],
+            skipped_relayed: 0,
+            message: "No pending tracked sends — list is empty.",
+        };
+    }
+    const inbox = await (0, network_1.fetchInbox)(options.networkUrl, { peek: true });
+    if (inbox.kind === "error") {
+        throw new Error(inbox.message);
+    }
+    const unrelayed = await (0, relay_state_1.filterUnrelayed)(inbox.messages);
+    const skippedRelayed = inbox.messages.length - unrelayed.length;
+    const items = [];
+    const toAck = [];
+    const peersToClear = new Set();
+    for (const msg of unrelayed) {
+        const peer = msg.from.toLowerCase();
+        const tracked = pendingMap.get(peer);
+        if (tracked) {
+            items.push(buildItem(msg, tracked, "reply"));
+            toAck.push(msg.id);
+            peersToClear.add(peer);
+        }
+        else if (!options.pendingOnly) {
+            items.push(buildItem(msg, null, "new"));
+            toAck.push(msg.id);
+        }
+    }
+    if (toAck.length > 0) {
+        await (0, network_1.ackMessages)(options.networkUrl, toAck);
+        await (0, relay_state_1.markRelayed)(toAck);
+    }
+    for (const peer of peersToClear) {
+        await (0, pending_1.clearPending)(peer);
+    }
+    let message;
+    if (items.length === 0 && pending.length > 0) {
+        const names = pending.map((p) => p.peer).join(", ");
+        message = `Waiting for replies from: ${names}`;
+    }
+    return {
+        pending_count: pending.length,
+        relayed: items,
+        skipped_relayed: skippedRelayed,
+        message,
+    };
+}
+function buildItem(msg, pending, kind) {
+    return {
+        kind: pending ? "reply" : kind,
+        from: msg.from,
+        text: msg.text,
+        id: msg.id,
+        context: pending?.context,
+    };
+}

package/dist/relay-state.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterUnrelayed = filterUnrelayed;
+exports.markRelayed = markRelayed;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const MAX_IDS = 500;
+function statePath() {
+    return (0, node_path_1.join)((0, node_os_1.homedir)(), ".marshell", "relay-state.json");
+}
+async function readState() {
+    try {
+        const raw = await (0, promises_1.readFile)(statePath(), "utf8");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        const maybeCode = error.code;
+        if (maybeCode === "ENOENT") {
+            return { relayedIds: [], updatedAt: new Date().toISOString() };
+        }
+        throw error;
+    }
+}
+async function writeState(state) {
+    await (0, promises_1.mkdir)((0, node_path_1.join)((0, node_os_1.homedir)(), ".marshell"), { recursive: true });
+    await (0, promises_1.writeFile)(statePath(), `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+async function filterUnrelayed(messages) {
+    const state = await readState();
+    const seen = new Set(state.relayedIds);
+    return messages.filter((m) => !seen.has(m.id));
+}
+async function markRelayed(ids) {
+    if (ids.length === 0)
+        return;
+    const state = await readState();
+    const merged = [...new Set([...state.relayedIds, ...ids])];
+    const trimmed = merged.length > MAX_IDS ? merged.slice(merged.length - MAX_IDS) : merged;
+    await writeState({
+        relayedIds: trimmed,
+        updatedAt: new Date().toISOString(),
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marshell/cli",
-  "version": "0.6.1",
+  "version": "0.7.2",
   "description": "Marshell CLI — join a subnet, discover agents, send messages",
   "license": "MIT",
   "type": "commonjs",
@@ -10,6 +10,7 @@
   "files": [
     "bin",
     "dist",
+    "scripts",
     "README.md"
   ],
   "scripts": {

package/scripts/relay.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+/**
+ * Marshell relay — notify script for gateway agents (Harvey, etc.)
+ *
+ * Receives JSON on stdin from `marshell listen --notify`:
+ *   { event, id, from, text, created_at, pending?: { context, sentText, ... } }
+ *
+ * Env:
+ *   MARSHELL_NOTIFY_WEBHOOK  POST JSON payload to this URL
+ *   MARSHELL_NOTIFY_FORMAT   "text" (default) | "json"
+ */
+import { readFileSync } from "node:fs";
+
+async function main() {
+  const raw = readFileSync(0, "utf8").trim();
+  if (!raw) {
+    process.exit(0);
+  }
+
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch {
+    process.stderr.write("relay: invalid JSON on stdin\n");
+    process.exit(1);
+  }
+
+  const from = payload.from ?? "unknown";
+  const text = payload.text ?? "";
+  const pending = payload.pending;
+  const context = pending?.context ?? pending?.sentText;
+
+  const format = process.env.MARSHELL_NOTIFY_FORMAT ?? "text";
+  const webhook = process.env.MARSHELL_NOTIFY_WEBHOOK?.trim();
+
+  let message;
+  if (context) {
+    message = `Reply from ${from} (re: ${context}):\n${text}`;
+  } else {
+    message = `New from ${from}:\n${text}`;
+  }
+
+  if (webhook) {
+    const body = JSON.stringify({
+      ...payload,
+      message,
+      relay: true,
+    });
+    const res = await fetch(webhook, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body,
+    });
+    if (!res.ok) {
+      process.stderr.write(`relay: webhook ${res.status}\n`);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+
+  if (format === "json") {
+    process.stdout.write(`${JSON.stringify({ ...payload, message })}\n`);
+  } else {
+    process.stdout.write(`${message}\n`);
+  }
+}
+
+main().catch((err) => {
+  process.stderr.write(`relay: ${err instanceof Error ? err.message : String(err)}\n`);
+  process.exit(1);
+});