@marshell/cli 0.7.1 → 0.7.4

package/dist/bridge.js

@@ -8,6 +8,7 @@ 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;
@@ -395,7 +396,7 @@ async function handleInbound(networkUrl, msg, options) {
         created_at: msg.created_at,
         pending: pending ?? undefined,
     });
-    // Push to human channel (Telegram, webhook, etc.) — side effect only.
+    // Push to human channel. On failure, leave message in inbox for `relay cron`.
     if (options.notify && !isEcho(msg.from, msg.text)) {
         try {
             await runNotifyCommand(options.notify, msg, pending);
@@ -408,6 +409,7 @@ async function handleInbound(networkUrl, msg, options) {
             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);
@@ -416,9 +418,10 @@ async function handleInbound(networkUrl, msg, options) {
                 message: `notify: ${message}`,
                 in_reply_to: msg.id,
             });
+            // Do not ack — cron will retry delivery to the human.
+            return;
         }
     }
-    // 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)) {

package/dist/cli.js

@@ -6,6 +6,7 @@ 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",
@@ -23,6 +24,7 @@ function printHelp() {
         "  marshell inbox [--json] [--wait <seconds>] [--from <name>]",
         "  marshell history [--with <name>] [--limit <n>] [--json]",
         "  marshell listen [--json] [--notify <cmd>]  (deliver-only listener)",
+        "  marshell relay cron [--include-untracked] [--json]",
         "  marshell pending list|clear [--peer <name>] [--json]",
         "  marshell --help",
         "",
@@ -365,6 +367,32 @@ 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.relayed.length > 0) {
+        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`);
+        return;
+    }
+    process.stdout.write(result.message ?? "Nothing new to relay.\n");
+}
 async function cmdPending(args) {
     const json = hasFlag(args, "--json");
     const sub = args[0];
@@ -473,6 +501,10 @@ 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;

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.7.1",
+  "version": "0.7.4",
   "description": "Marshell CLI — join a subnet, discover agents, send messages",
   "license": "MIT",
   "type": "commonjs",

package/scripts/relay.mjs

@@ -37,7 +37,7 @@ async function main() {
   if (context) {
     message = `Reply from ${from} (re: ${context}):\n${text}`;
   } else {
-    message = `Message from ${from}:\n${text}`;
+    message = `New from ${from}:\n${text}`;
   }
 
   if (webhook) {
@@ -58,11 +58,21 @@ async function main() {
     process.exit(0);
   }
 
-  if (format === "json") {
-    process.stdout.write(`${JSON.stringify({ ...payload, message })}\n`);
-  } else {
-    process.stdout.write(`${message}\n`);
+  // Without a webhook, stdout is only a log — not human delivery. Fail so
+  // listener leaves inbox intact and `marshell relay cron` can deliver.
+  if (process.env.MARSHELL_ALLOW_STDOUT_RELAY === "1") {
+    if (format === "json") {
+      process.stdout.write(`${JSON.stringify({ ...payload, message })}\n`);
+    } else {
+      process.stdout.write(`${message}\n`);
+    }
+    process.exit(0);
   }
+
+  process.stderr.write(
+    "relay: MARSHELL_NOTIFY_WEBHOOK not set — use relay cron for human delivery\n",
+  );
+  process.exit(1);
 }
 
 main().catch((err) => {