@marshell/cli 0.7.2 → 0.7.5

package/dist/bridge.js

@@ -396,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 +408,7 @@ async function handleInbound(networkUrl, msg, options) {
             });
             if (pending) {
                 await (0, pending_1.clearPending)(msg.from);
+                await (0, relay_state_1.clearWaitingReported)(msg.from);
             }
             await (0, relay_state_1.markRelayed)([msg.id]);
         }
@@ -418,9 +419,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

@@ -24,7 +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 relay cron [--quiet] [--include-untracked] [--json]",
         "  marshell pending list|clear [--peer <name>] [--json]",
         "  marshell --help",
         "",
@@ -370,13 +370,14 @@ async function cmdInbox(args) {
 async function cmdRelay(args) {
     const sub = args[0];
     if (sub !== "cron") {
-        printError("Usage: marshell relay cron [--include-untracked] [--json]");
+        printError("Usage: marshell relay cron [--quiet] [--include-untracked] [--json]");
     }
     const json = hasFlag(args, "--json");
+    const quiet = hasFlag(args, "--quiet");
     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 });
+    const result = await (0, relay_cron_1.runRelayCron)({ networkUrl, pendingOnly, quiet });
     if (json) {
         printJson({
             ...result,
@@ -384,18 +385,19 @@ async function cmdRelay(args) {
         });
         return;
     }
-    if (result.message && result.relayed.length === 0) {
-        process.stdout.write(`${result.message}\n`);
+    if (!result.notify) {
         return;
     }
-    if (result.relayed.length === 0) {
-        process.stdout.write("Nothing new to relay.\n");
+    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;
     }
-    if (result.pending_count === 0 && !pendingOnly) {
-        process.stdout.write(`${result.relayed.length} new inbound message(s):\n\n`);
+    if (result.message) {
+        process.stdout.write(`${result.message}\n`);
     }
-    process.stdout.write(`${(0, relay_cron_1.formatRelayOutput)(result.relayed)}\n`);
 }
 async function cmdPending(args) {
     const json = hasFlag(args, "--json");

package/dist/relay-cron.js

@@ -17,6 +17,7 @@ function formatRelayOutput(items) {
     return items.map(formatItem).join("\n\n---\n\n");
 }
 async function runRelayCron(options) {
+    const quiet = options.quiet ?? false;
     const pending = await (0, pending_1.listPending)();
     const pendingMap = new Map(pending.map((p) => [p.peer.toLowerCase(), p]));
     if (options.pendingOnly && pending.length === 0) {
@@ -24,7 +25,10 @@ async function runRelayCron(options) {
             pending_count: 0,
             relayed: [],
             skipped_relayed: 0,
-            message: "No pending tracked sends — list is empty.",
+            message: quiet
+                ? undefined
+                : "No pending tracked sends — list is empty.",
+            notify: !quiet,
         };
     }
     const inbox = await (0, network_1.fetchInbox)(options.networkUrl, { peek: true });
@@ -55,17 +59,46 @@ async function runRelayCron(options) {
     }
     for (const peer of peersToClear) {
         await (0, pending_1.clearPending)(peer);
+        await (0, relay_state_1.clearWaitingReported)(peer);
+    }
+    if (items.length > 0) {
+        return {
+            pending_count: pending.length,
+            relayed: items,
+            skipped_relayed: skippedRelayed,
+            notify: true,
+        };
     }
     let message;
-    if (items.length === 0 && pending.length > 0) {
-        const names = pending.map((p) => p.peer).join(", ");
-        message = `Waiting for replies from: ${names}`;
+    let notify = !quiet;
+    if (pending.length > 0) {
+        const waitingPeers = [];
+        for (const entry of pending) {
+            const shouldReport = await (0, relay_state_1.shouldReportWaiting)(entry.peer, entry.sentAt);
+            if (shouldReport) {
+                waitingPeers.push(entry.peer);
+                await (0, relay_state_1.markWaitingReported)(entry.peer, entry.sentAt);
+            }
+        }
+        if (waitingPeers.length > 0) {
+            message = `Waiting for replies from: ${waitingPeers.join(", ")}`;
+            notify = true;
+        }
+        else if (quiet) {
+            message = undefined;
+            notify = false;
+        }
+        else {
+            message = `Still waiting for: ${pending.map((p) => p.peer).join(", ")}`;
+            notify = true;
+        }
     }
     return {
         pending_count: pending.length,
-        relayed: items,
+        relayed: [],
         skipped_relayed: skippedRelayed,
         message,
+        notify,
     };
 }
 function buildItem(msg, pending, kind) {

package/dist/relay-state.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.filterUnrelayed = filterUnrelayed;
 exports.markRelayed = markRelayed;
+exports.shouldReportWaiting = shouldReportWaiting;
+exports.markWaitingReported = markWaitingReported;
+exports.clearWaitingReported = clearWaitingReported;
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
 const node_os_1 = require("node:os");
@@ -9,21 +12,36 @@ const MAX_IDS = 500;
 function statePath() {
     return (0, node_path_1.join)((0, node_os_1.homedir)(), ".marshell", "relay-state.json");
 }
+function emptyState() {
+    return {
+        relayedIds: [],
+        waitingReported: {},
+        updatedAt: new Date().toISOString(),
+    };
+}
 async function readState() {
     try {
         const raw = await (0, promises_1.readFile)(statePath(), "utf8");
-        return JSON.parse(raw);
+        const parsed = JSON.parse(raw);
+        return {
+            relayedIds: parsed.relayedIds ?? [],
+            waitingReported: parsed.waitingReported ?? {},
+            updatedAt: parsed.updatedAt ?? new Date().toISOString(),
+        };
     }
     catch (error) {
         const maybeCode = error.code;
         if (maybeCode === "ENOENT") {
-            return { relayedIds: [], updatedAt: new Date().toISOString() };
+            return emptyState();
         }
         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 writeStateFile(state);
+}
+async function writeStateFile(state) {
     await (0, promises_1.writeFile)(statePath(), `${JSON.stringify(state, null, 2)}\n`, "utf8");
 }
 async function filterUnrelayed(messages) {
@@ -37,8 +55,37 @@ async function markRelayed(ids) {
     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({
+    await writeStateFile({
+        ...state,
         relayedIds: trimmed,
         updatedAt: new Date().toISOString(),
     });
 }
+/** True if we should tell the human we're waiting on this peer (once per pending). */
+async function shouldReportWaiting(peer, pendingSentAt) {
+    const state = await readState();
+    const key = peer.toLowerCase();
+    return state.waitingReported[key] !== pendingSentAt;
+}
+async function markWaitingReported(peer, pendingSentAt) {
+    const state = await readState();
+    const key = peer.toLowerCase();
+    await writeStateFile({
+        ...state,
+        waitingReported: { ...state.waitingReported, [key]: pendingSentAt },
+        updatedAt: new Date().toISOString(),
+    });
+}
+async function clearWaitingReported(peer) {
+    const state = await readState();
+    const key = peer.toLowerCase();
+    if (!(key in state.waitingReported))
+        return;
+    const next = { ...state.waitingReported };
+    delete next[key];
+    await writeStateFile({
+        ...state,
+        waitingReported: next,
+        updatedAt: new Date().toISOString(),
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marshell/cli",
-  "version": "0.7.2",
+  "version": "0.7.5",
   "description": "Marshell CLI — join a subnet, discover agents, send messages",
   "license": "MIT",
   "type": "commonjs",

package/scripts/relay.mjs

@@ -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) => {