@marshell/cli 0.5.0 → 0.6.1

package/dist/bridge.js

@@ -0,0 +1,461 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryFastReply = tryFastReply;
+exports.handleInbound = handleInbound;
+exports.runBridge = runBridge;
+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 DEFAULT_REPLY_TIMEOUT_MS = 120_000;
+const GREETING_COOLDOWN_MS = 120_000;
+const ECHO_WINDOW_MS = 60_000;
+const peers = new Map();
+function peerState(name) {
+    const key = name.toLowerCase();
+    let state = peers.get(key);
+    if (!state) {
+        state = { lastGreetingAt: 0, recentOutbound: [], inflight: false };
+        peers.set(key, state);
+    }
+    return state;
+}
+function rememberOutbound(peer, text) {
+    const state = peerState(peer);
+    const now = Date.now();
+    state.recentOutbound.push({ text: text.trim().toLowerCase(), at: now });
+    state.recentOutbound = state.recentOutbound.filter((item) => now - item.at < ECHO_WINDOW_MS);
+}
+function isEcho(peer, text) {
+    const normalized = text.trim().toLowerCase();
+    const state = peerState(peer);
+    const now = Date.now();
+    return state.recentOutbound.some((item) => {
+        if (now - item.at >= ECHO_WINDOW_MS)
+            return false;
+        if (item.text === normalized)
+            return true;
+        // Peer quoting/acking our last reply ("got it — acknowledged").
+        if (normalized.includes(item.text) || item.text.includes(normalized)) {
+            return item.text.length >= 4 && normalized.length <= item.text.length + 40;
+        }
+        return false;
+    });
+}
+function isGreeting(text) {
+    return /^(hi|hello|hey|yo|sup|picun)[!.?\s]*$/i.test(text.trim());
+}
+/** Short acks / reactions — deliver only, never auto-reply (stops chat spam). */
+function isAckOnly(text) {
+    const t = text.trim();
+    if (!t)
+        return true;
+    if (/^[\p{Emoji_Presentation}\p{Extended_Pictographic}\s\p{P}]+$/u.test(t)) {
+        return true;
+    }
+    if (/^(got it|ok|okay|k|kk|thanks|thank you|thx|ty|cool|nice|great|ack|acknowledged|roger|copy|noted|np|no problem|sounds good|sg|lgtm|sure|yep|yeah|yes|no|nah|👍|✅)[.!*]*$/i.test(t)) {
+        return true;
+    }
+    // Very short non-questions are almost always reactions.
+    if (t.length <= 16 && !/[?]/.test(t) && !/\bwho\b|\bwhat\b|\bhow\b/i.test(t)) {
+        return true;
+    }
+    return false;
+}
+/** Only spend LLM budget on real questions / tasks. */
+function needsReply(text) {
+    const t = text.trim();
+    if (!t || isGreeting(t) || isAckOnly(t) || /^pong$/i.test(t)) {
+        return false;
+    }
+    if (/[?]/.test(t))
+        return true;
+    if (/\b(who are you|who're you|what are you|and you are)\b/i.test(t)) {
+        return true;
+    }
+    if (/^(who|what|where|when|why|how|can|could|would|please|tell|ask|explain|list|show|find|read|check|run|write|fix|deploy|summarize)\b/i.test(t)) {
+        return true;
+    }
+    // Longer messages are likely real tasks.
+    return t.length >= 48;
+}
+/**
+ * Instant replies — no LLM. Never reply in a way that loops with another bridge.
+ * ping → pong (pong alone is ignored)
+ * greetings → one-shot per peer, non-greeting text
+ * echo:… → body
+ */
+function tryFastReply(msg, options) {
+    const text = msg.text.trim();
+    if (/^ping$/i.test(text)) {
+        return "pong";
+    }
+    // Never auto-reply to "pong" — breaks ping/pong loops.
+    if (/^pong$/i.test(text)) {
+        return null;
+    }
+    if (isGreeting(text)) {
+        if (options?.allowGreeting === false) {
+            return null;
+        }
+        const state = peerState(msg.from);
+        const now = Date.now();
+        if (now - state.lastGreetingAt < GREETING_COOLDOWN_MS) {
+            return null;
+        }
+        state.lastGreetingAt = now;
+        // Reply must NOT match isGreeting / ping, or peer bridge will loop.
+        return `hey ${msg.from} — here. send a question anytime.`;
+    }
+    if (text.toLowerCase().startsWith("echo:")) {
+        const body = text.slice(5).trim();
+        return body || "(empty)";
+    }
+    // Identity questions — answer without spawning LLM (reliable + instant).
+    if (/\bwho are you\b|\bwho're you\b|\bwhat are you\b|\band you are\??\s*$/i.test(text)) {
+        return "I'm cursor — Marshell agent on this machine (codebase workspace).";
+    }
+    return null;
+}
+/** Resolve a CLI binary so Windows .cmd wrappers work under spawn(shell:false). */
+function resolveRuntimeCommand(command) {
+    if (process.platform === "win32" && command === "agent") {
+        const base = (0, node_path_1.join)(process.env.LOCALAPPDATA ?? "", "cursor-agent");
+        const versionsDir = (0, node_path_1.join)(base, "versions");
+        if ((0, node_fs_1.existsSync)(versionsDir)) {
+            const versions = (0, node_fs_1.readdirSync)(versionsDir)
+                .filter((name) => /^\d{4}\./.test(name))
+                .sort()
+                .reverse();
+            for (const version of versions) {
+                const nodePath = (0, node_path_1.join)(versionsDir, version, "node.exe");
+                const entry = (0, node_path_1.join)(versionsDir, version, "index.js");
+                if ((0, node_fs_1.existsSync)(nodePath) && (0, node_fs_1.existsSync)(entry)) {
+                    return { command: nodePath, argsPrefix: [entry] };
+                }
+            }
+        }
+        const agentCmd = (0, node_path_1.join)(base, "agent.cmd");
+        if ((0, node_fs_1.existsSync)(agentCmd)) {
+            return { command: agentCmd, argsPrefix: [] };
+        }
+    }
+    return { command, argsPrefix: [] };
+}
+function killProcessTree(pid) {
+    if (!pid)
+        return;
+    if (process.platform === "win32") {
+        (0, node_child_process_1.spawn)("taskkill", ["/pid", String(pid), "/T", "/F"], {
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        return;
+    }
+    try {
+        process.kill(-pid, "SIGKILL");
+    }
+    catch {
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+function spawnCommand(command, args, options) {
+    const timeoutMs = options?.timeoutMs ?? DEFAULT_REPLY_TIMEOUT_MS;
+    return new Promise((resolve) => {
+        const child = process.platform === "win32"
+            ? (0, node_child_process_1.spawn)(command, args, {
+                cwd: options?.cwd,
+                env: process.env,
+                windowsHide: true,
+                shell: false,
+            })
+            : (0, node_child_process_1.spawn)(command, args, {
+                cwd: options?.cwd,
+                env: process.env,
+                detached: true,
+            });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const finish = (code, errText) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({
+                code,
+                stdout,
+                stderr: errText ? `${stderr}\n${errText}`.trim() : stderr,
+            });
+        };
+        const timer = setTimeout(() => {
+            killProcessTree(child.pid);
+            finish(124, `timeout after ${Math.round(timeoutMs / 1000)}s`);
+        }, timeoutMs);
+        if (options?.input) {
+            child.stdin.write(options.input);
+            child.stdin.end();
+        }
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("close", (code) => {
+            finish(code ?? 1);
+        });
+        child.on("error", (error) => {
+            finish(1, error.message);
+        });
+    });
+}
+async function generateRuntimeReply(msg, runtime, workspace, timeoutMs) {
+    const prompt = [
+        `You are Marshell agent listening on this machine.`,
+        `Peer agent "${msg.from}" sent you a message.`,
+        "Answer using the local workspace when relevant.",
+        "If they ask who you are, say you are the cursor agent on this Marshell subnet.",
+        "Reply with ONLY the answer text. No tools, no marshell CLI, no meta commentary.",
+        "",
+        "Message:",
+        msg.text,
+    ].join("\n");
+    if (runtime === "cursor") {
+        const resolved = resolveRuntimeCommand("agent");
+        const result = await spawnCommand(resolved.command, [
+            ...resolved.argsPrefix,
+            "-p",
+            "--trust",
+            "--mode",
+            "ask",
+            "--workspace",
+            workspace,
+            "--output-format",
+            "text",
+            prompt,
+        ], { timeoutMs });
+        if (result.code === 124) {
+            throw new Error(`auto-reply timed out (${Math.round(timeoutMs / 1000)}s)`);
+        }
+        if (result.code !== 0) {
+            throw new Error(result.stderr || result.stdout || "cursor agent failed");
+        }
+        return result.stdout.trim();
+    }
+    const result = await spawnCommand("hermes", ["-z", prompt], { timeoutMs });
+    if (result.code === 124) {
+        throw new Error(`auto-reply timed out (${Math.round(timeoutMs / 1000)}s)`);
+    }
+    if (result.code !== 0) {
+        throw new Error(result.stderr || result.stdout || "hermes failed");
+    }
+    return result.stdout.trim();
+}
+async function runHookReply(hook, msg, timeoutMs) {
+    const payload = JSON.stringify({
+        id: msg.id,
+        from: msg.from,
+        text: msg.text,
+        created_at: msg.created_at,
+    });
+    if (process.platform === "win32") {
+        const result = await spawnCommand("cmd.exe", ["/d", "/s", "/c", hook], { input: payload, timeoutMs });
+        if (result.code === 124) {
+            throw new Error(`hook timed out (${Math.round(timeoutMs / 1000)}s)`);
+        }
+        if (result.code !== 0) {
+            throw new Error(result.stderr || result.stdout || "hook failed");
+        }
+        return result.stdout.trim();
+    }
+    const result = await spawnCommand("sh", ["-c", hook], {
+        input: payload,
+        timeoutMs,
+    });
+    if (result.code === 124) {
+        throw new Error(`hook timed out (${Math.round(timeoutMs / 1000)}s)`);
+    }
+    if (result.code !== 0) {
+        throw new Error(result.stderr || result.stdout || "hook failed");
+    }
+    return result.stdout.trim();
+}
+function emitEvent(json, event) {
+    if (json) {
+        process.stdout.write(`${JSON.stringify(event)}\n`);
+        return;
+    }
+    const kind = event.type;
+    if (kind === "message") {
+        process.stdout.write(`[message] from=${event.from} id=${event.id}\n${event.text}\n`);
+    }
+    else if (kind === "reply") {
+        process.stdout.write(`[reply] to=${event.to} id=${event.id}\n`);
+    }
+    else if (kind === "skip") {
+        process.stdout.write(`[skip] from=${event.from} reason=${event.reason}\n`);
+    }
+    else if (kind === "error") {
+        process.stderr.write(`[bridge] ${event.message}\n`);
+    }
+}
+async function deliverReply(networkUrl, msg, reply, json) {
+    const sent = await (0, network_1.sendMessage)(networkUrl, msg.from, reply);
+    if (sent.kind !== "sent") {
+        throw new Error(sent.message);
+    }
+    rememberOutbound(msg.from, reply);
+    emitEvent(json, {
+        type: "reply",
+        to: msg.from,
+        id: sent.id,
+        in_reply_to: msg.id,
+        text: reply,
+    });
+}
+async function processReplyAsync(networkUrl, msg, options) {
+    const state = peerState(msg.from);
+    if (state.inflight) {
+        emitEvent(options.json, {
+            type: "skip",
+            from: msg.from,
+            reason: "peer already has an inflight reply",
+            id: msg.id,
+        });
+        return;
+    }
+    state.inflight = true;
+    try {
+        let reply = tryFastReply(msg);
+        if (!reply && options.hook) {
+            reply = await runHookReply(options.hook, msg, options.replyTimeoutMs);
+        }
+        else if (!reply && options.autoReply && options.runtime !== "fast") {
+            reply = await generateRuntimeReply(msg, options.runtime, options.workspace, options.replyTimeoutMs);
+        }
+        if (!reply) {
+            return;
+        }
+        if (!reply.trim()) {
+            throw new Error("empty reply");
+        }
+        await deliverReply(networkUrl, msg, reply.trim(), options.json);
+    }
+    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
+        }
+    }
+    finally {
+        state.inflight = false;
+    }
+}
+async function handleInbound(networkUrl, msg, options) {
+    emitEvent(options.json, {
+        type: "message",
+        id: msg.id,
+        from: msg.from,
+        text: msg.text,
+        created_at: msg.created_at,
+    });
+    // Always ack first 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)) {
+        emitEvent(options.json, {
+            type: "skip",
+            from: msg.from,
+            reason: "echo of our recent outbound",
+            id: msg.id,
+        });
+        return;
+    }
+    const fast = tryFastReply(msg);
+    if (fast) {
+        await deliverReply(networkUrl, msg, fast, options.json);
+        return;
+    }
+    // Greetings / acks / reactions: deliver only, no reply spam.
+    if (!needsReply(msg.text)) {
+        emitEvent(options.json, {
+            type: "skip",
+            from: msg.from,
+            reason: "no-reply (ack/greeting/trivial)",
+            id: msg.id,
+        });
+        return;
+    }
+    const willReply = Boolean(options.hook) ||
+        (options.autoReply && options.runtime !== "fast");
+    if (!willReply) {
+        return;
+    }
+    void processReplyAsync(networkUrl, msg, options);
+}
+async function drainBacklog(networkUrl, json) {
+    const result = await (0, network_1.fetchInbox)(networkUrl, { peek: true });
+    if (result.kind !== "ok" || result.messages.length === 0) {
+        return;
+    }
+    await (0, network_1.ackMessages)(networkUrl, result.messages.map((m) => m.id));
+    emitEvent(json, {
+        type: "skip",
+        from: "*",
+        reason: `drained ${result.messages.length} backlog message(s) on startup`,
+    });
+}
+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";
+    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);
+    let stopped = false;
+    const cleanup = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        process.stdout.write("Bridge stopped.\n");
+        process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    while (!stopped) {
+        const result = await (0, network_1.fetchInbox)(options.networkUrl, {
+            peek: true,
+            waitSeconds: 30,
+        });
+        if (result.kind === "error") {
+            process.stderr.write(`inbox error: ${result.message}\n`);
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+            continue;
+        }
+        // Newest first — real questions beat greeting backlog.
+        const messages = [...result.messages].sort((a, b) => {
+            const ta = Date.parse(a.created_at) || 0;
+            const tb = Date.parse(b.created_at) || 0;
+            return tb - ta;
+        });
+        for (const msg of messages) {
+            await handleInbound(options.networkUrl, msg, options);
+        }
+    }
+}

package/dist/cli.js

@@ -1,29 +1,38 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const node_child_process_1 = require("node:child_process");
 const node_os_1 = require("node:os");
+const bridge_1 = require("./bridge");
 const config_1 = require("./config");
 const network_1 = require("./network");
 function printHelp() {
     const message = [
-        "marshell - Phase 0 CLI",
+        "marshell - agent messaging bridge",
         "",
         "Usage:",
         "  marshell auth set <token> [--name <name>]",
         "  marshell auth status [--json]",
         "  marshell agent join --name <name>",
-        "  marshell agent run [--auto-reply] [--workspace <path>] [--runtime cursor|hermes]",
+        "  marshell bridge run [--json] [--hook <cmd>]",
+        "  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 ask --to <name> --text \"...\" [--wait <seconds>] [--json]",
         "  marshell inbox [--json] [--wait <seconds>] [--from <name>]",
-        "  marshell listen [--json] [--wait <seconds>] [--auto-reply]",
+        "  marshell history [--with <name>] [--limit <n>] [--json]",
+        "  marshell listen [--json]      (deliver-only listener)",
         "  marshell --help",
         "",
+        "Middleware: send / inbox / history. Agents think; Marshell only delivers.",
+        "  inbox  = unread only (empty after read)",
+        "  history = last 24h with a peer (use this to recall past chats)",
+        "",
         "Environment:",
         "  MARSHELL_NETWORK_URL  default: https://network.marshell.dev",
         "  MARSHELL_AGENT_NAME   default agent name for auth set",
-        "  MARSHELL_WORKSPACE    workspace for --auto-reply (cursor runtime)",
+        "  MARSHELL_WORKSPACE    workspace for cursor auto-reply",
+        "  MARSHELL_HOOK         default hook command for bridge",
         "  MARSHELL_CONFIG       optional path to config file",
     ].join("\n");
     process.stdout.write(`${message}\n`);
@@ -63,6 +72,36 @@ function valueForFlag(args, flag) {
     }
     return args[index + 1];
 }
+function bridgeOptionsFromArgs(args) {
+    const configPromise = (0, config_1.readConfig)();
+    // sync read not available — caller must await
+    void configPromise;
+    const autoReply = hasFlag(args, "--auto-reply");
+    const json = hasFlag(args, "--json");
+    const workspace = valueForFlag(args, "--workspace") ??
+        process.env.MARSHELL_WORKSPACE ??
+        process.cwd();
+    const hook = valueForFlag(args, "--hook") ?? process.env.MARSHELL_HOOK;
+    const runtimeFlag = valueForFlag(args, "--runtime");
+    const runtime = runtimeFlag === "hermes" || runtimeFlag === "cursor" || runtimeFlag === "fast"
+        ? runtimeFlag
+        : process.platform === "win32"
+            ? "cursor"
+            : "hermes";
+    const timeoutRaw = valueForFlag(args, "--reply-timeout");
+    const replyTimeoutMs = timeoutRaw
+        ? Math.max(5, Number(timeoutRaw)) * 1000
+        : 120_000;
+    return {
+        networkUrl: "",
+        autoReply,
+        runtime,
+        workspace,
+        hook,
+        json,
+        replyTimeoutMs,
+    };
+}
 async function cmdAuthSet(args) {
     const named = valueForFlag(args, "--name");
     const tokenArg = args.filter((a, i) => {
@@ -99,6 +138,7 @@ async function cmdAuthStatus(args) {
     const payload = {
         hasToken: Boolean(config.token),
         hasAgentKey: Boolean(config.agentKey),
+        agentName: config.agentName ?? null,
         networkUrl,
         health,
     };
@@ -128,140 +168,30 @@ async function cmdAgentJoin(args) {
     }
     printError(result.message);
 }
-function runCommandCapture(command, args, options) {
-    return new Promise((resolve) => {
-        const child = (0, node_child_process_1.spawn)(command, args, {
-            cwd: options?.cwd,
-            env: process.env,
-            shell: process.platform === "win32",
-        });
-        let stdout = "";
-        let stderr = "";
-        child.stdout.on("data", (chunk) => {
-            stdout += chunk.toString();
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr += chunk.toString();
-        });
-        child.on("close", (code) => {
-            resolve({ code: code ?? 1, stdout, stderr });
-        });
-        child.on("error", (error) => {
-            resolve({ code: 1, stdout, stderr: error.message });
-        });
-    });
-}
-async function generateAutoReply(msg, runtime, workspace) {
-    const prompt = [
-        `Another Marshell agent named "${msg.from}" sent you this request.`,
-        "Answer it using the local workspace/codebase.",
-        "Do NOT run marshell CLI commands — your stdout is delivered automatically as the reply.",
-        "Do NOT mention Ask mode, Agent mode, tools, or that you are an AI.",
-        "Reply with ONLY the answer text. No preamble.",
-        "",
-        "Request:",
-        msg.text,
-    ].join("\n");
-    if (runtime === "cursor") {
-        const result = await runCommandCapture("agent", [
-            "-p",
-            "--trust",
-            "--force",
-            "--workspace",
-            workspace,
-            "--output-format",
-            "text",
-            prompt,
-        ]);
-        if (result.code !== 0) {
-            throw new Error(result.stderr || result.stdout || "cursor agent failed");
-        }
-        return result.stdout.trim();
-    }
-    const result = await runCommandCapture("hermes", ["-z", prompt]);
-    if (result.code !== 0) {
-        throw new Error(result.stderr || result.stdout || "hermes failed");
-    }
-    return result.stdout.trim();
-}
-async function handleInboundMessage(networkUrl, msg, autoReply, runtime, workspace) {
-    process.stdout.write(`[message] from=${msg.from} id=${msg.id}\n${msg.text}\n`);
-    if (!autoReply) {
-        await (0, network_1.ackMessages)(networkUrl, [msg.id]);
-        return;
-    }
-    try {
-        process.stdout.write(`[auto-reply] generating response via ${runtime}…\n`);
-        const reply = await generateAutoReply(msg, runtime, workspace);
-        if (!reply) {
-            throw new Error("empty reply from runtime");
-        }
-        const sent = await (0, network_1.sendMessage)(networkUrl, msg.from, reply);
-        if (sent.kind !== "sent") {
-            throw new Error(sent.message);
-        }
-        process.stdout.write(`[auto-reply] sent to ${msg.from} (id: ${sent.id})\n`);
-        await (0, network_1.ackMessages)(networkUrl, [msg.id]);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        process.stderr.write(`[auto-reply] failed: ${message}\n`);
-        // leave message in inbox for retry
-    }
-}
-async function cmdAgentRun(args = []) {
-    const autoReply = hasFlag(args, "--auto-reply");
-    const workspace = valueForFlag(args, "--workspace") ??
-        process.env.MARSHELL_WORKSPACE ??
-        process.cwd();
-    const runtimeFlag = valueForFlag(args, "--runtime");
-    const runtime = runtimeFlag === "hermes" || runtimeFlag === "cursor"
-        ? runtimeFlag
-        : process.platform === "win32"
-            ? "cursor"
-            : "hermes";
+async function cmdBridgeRun(args = []) {
     const config = await (0, config_1.readConfig)();
-    const networkUrl = (0, config_1.getNetworkUrl)(config);
-    process.stdout.write(`Listening as '${config.agentName ?? "agent"}'${autoReply ? ` (auto-reply via ${runtime})` : ""}.\n`);
-    let stopped = false;
-    const cleanup = () => {
-        if (stopped)
-            return;
-        stopped = true;
-        process.stdout.write("Exiting agent loop.\n");
-        process.exit(0);
-    };
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
-    while (!stopped) {
-        const result = await (0, network_1.fetchInbox)(networkUrl, { peek: true });
-        if (result.kind === "error") {
-            process.stderr.write(`inbox error: ${result.message}\n`);
-        }
-        else {
-            for (const msg of result.messages) {
-                await handleInboundMessage(networkUrl, msg, autoReply, runtime, workspace);
-            }
-        }
-        await new Promise((resolve) => setTimeout(resolve, 2000));
-    }
+    const opts = bridgeOptionsFromArgs(args);
+    opts.networkUrl = (0, config_1.getNetworkUrl)(config);
+    opts.agentName = config.agentName;
+    await (0, bridge_1.runBridge)(opts);
 }
 async function cmdDiscover(args) {
     const json = hasFlag(args, "--json");
     const config = await (0, config_1.readConfig)();
     const networkUrl = (0, config_1.getNetworkUrl)(config);
-    const discovered = await (0, network_1.discoverPeers)(networkUrl);
+    const { peers } = await (0, network_1.discoverPeers)(networkUrl);
     if (json) {
-        printJson({ peers: discovered.peers });
+        printJson({ peers });
         return;
     }
-    if (discovered.peers.length === 0) {
-        process.stdout.write("No peers discovered.\n");
+    if (peers.length === 0) {
+        process.stdout.write("No peers found.\n");
         return;
     }
-    process.stdout.write(`Discovered ${discovered.peers.length} peer(s):\n`);
-    for (const peer of discovered.peers) {
-        process.stdout.write(`- ${JSON.stringify(peer)}\n`);
+    for (const peer of peers) {
+        const name = typeof peer.name === "string" ? peer.name : "?";
+        const status = typeof peer.status === "string" ? peer.status : "unknown";
+        process.stdout.write(`- ${name} (${status})\n`);
     }
 }
 async function cmdSend(args) {
@@ -284,6 +214,55 @@ async function cmdSend(args) {
     }
     printError(result.message);
 }
+async function cmdAsk(args) {
+    const json = hasFlag(args, "--json");
+    const to = valueForFlag(args, "--to");
+    const text = valueForFlag(args, "--text");
+    const waitRaw = valueForFlag(args, "--wait");
+    const waitSeconds = waitRaw ? Number(waitRaw) : 120;
+    if (!to || !text) {
+        printError("Usage: marshell ask --to <name> --text \"...\" [--wait <seconds>] [--json]");
+    }
+    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 (json) {
+        printJson(result);
+        return;
+    }
+    if (result.kind === "ok") {
+        process.stdout.write(`${result.reply}\n`);
+        return;
+    }
+    if (result.kind === "timeout") {
+        printError(`No reply from '${to}' within ${waitSeconds}s (sent id: ${result.sent_id}). Is their bridge running?`);
+    }
+    printError(result.message);
+}
+async function cmdHistory(args) {
+    const json = hasFlag(args, "--json");
+    const withPeer = valueForFlag(args, "--with");
+    const limitRaw = valueForFlag(args, "--limit");
+    const limit = limitRaw ? Number(limitRaw) : 50;
+    const config = await (0, config_1.readConfig)();
+    const networkUrl = (0, config_1.getNetworkUrl)(config);
+    const result = await (0, network_1.fetchHistory)(networkUrl, { with: withPeer, limit });
+    if (result.kind === "error") {
+        printError(result.message);
+    }
+    if (json) {
+        printJson({ agent: result.agent, messages: result.messages });
+        return;
+    }
+    if (result.messages.length === 0) {
+        process.stdout.write("No messages in the last 24h.\n");
+        return;
+    }
+    for (const msg of [...result.messages].reverse()) {
+        const arrow = msg.direction === "out" ? "→" : "←";
+        process.stdout.write(`${msg.created_at} ${arrow} ${msg.peer}: ${msg.text}\n`);
+    }
+}
 async function cmdInbox(args) {
     const json = hasFlag(args, "--json");
     const from = valueForFlag(args, "--from");
@@ -324,6 +303,9 @@ async function cmdInbox(args) {
     const messages = from
         ? result.messages.filter((m) => m.from.toLowerCase() === from.toLowerCase())
         : result.messages;
+    if (messages.length > 0) {
+        await (0, network_1.ackMessages)(networkUrl, messages.map((m) => m.id));
+    }
     if (json) {
         printJson({ messages, agent: result.agent });
         return;
@@ -337,14 +319,14 @@ async function cmdInbox(args) {
     }
 }
 async function cmdListen(args) {
-    const json = hasFlag(args, "--json");
     const waitRaw = valueForFlag(args, "--wait");
     const waitSeconds = waitRaw ? Number(waitRaw) : 0;
+    const json = hasFlag(args, "--json");
     if (waitSeconds > 0) {
         await cmdInbox(["--wait", String(waitSeconds), ...(json ? ["--json"] : [])]);
         return;
     }
-    await cmdAgentRun(args);
+    await cmdBridgeRun(args);
 }
 async function main() {
     const args = process.argv.slice(2);
@@ -373,11 +355,20 @@ async function main() {
             return;
         }
         if (sub === "run") {
-            await cmdAgentRun(rest);
+            await cmdBridgeRun(rest);
             return;
         }
         printError("Unknown agent command. Try: marshell agent join|run");
     }
+    if (args[0] === "bridge") {
+        const sub = args[1];
+        const rest = args.slice(2);
+        if (sub === "run") {
+            await cmdBridgeRun(rest);
+            return;
+        }
+        printError("Unknown bridge command. Try: marshell bridge run");
+    }
     if (args[0] === "discover") {
         await cmdDiscover(args.slice(1));
         return;
@@ -386,10 +377,18 @@ async function main() {
         await cmdSend(args.slice(1));
         return;
     }
+    if (args[0] === "ask") {
+        await cmdAsk(args.slice(1));
+        return;
+    }
     if (args[0] === "inbox") {
         await cmdInbox(args.slice(1));
         return;
     }
+    if (args[0] === "history") {
+        await cmdHistory(args.slice(1));
+        return;
+    }
     if (args[0] === "listen") {
         await cmdListen(args.slice(1));
         return;

package/dist/network.js

@@ -7,6 +7,8 @@ exports.sendMessage = sendMessage;
 exports.fetchInbox = fetchInbox;
 exports.ackMessages = ackMessages;
 exports.waitForInbox = waitForInbox;
+exports.fetchHistory = fetchHistory;
+exports.askAgent = askAgent;
 exports.toWsUrl = toWsUrl;
 const config_1 = require("./config");
 function normalizeBaseUrl(raw) {
@@ -123,8 +125,11 @@ async function joinAgent(baseUrl, name) {
     }
 }
 async function discoverPeers(baseUrl) {
-    const headers = await authHeaders("token");
+    // Prefer agent_key — survives join-token rotation.
+    const config = await (0, config_1.readConfig)();
+    const kind = config.agentKey ? "agent" : "token";
     try {
+        const headers = await authHeaders(kind);
         const response = await fetch(withPath(baseUrl, "/v1/peers"), {
             method: "GET",
             headers,
@@ -169,7 +174,14 @@ async function sendMessage(baseUrl, to, text) {
 async function fetchInbox(baseUrl, options) {
     try {
         const headers = await authHeaders("agent");
-        const qs = options?.peek ? "?peek=1" : "";
+        const params = new URLSearchParams();
+        if (options?.peek) {
+            params.set("peek", "1");
+        }
+        if (options?.waitSeconds && options.waitSeconds > 0) {
+            params.set("wait", String(Math.min(120, options.waitSeconds)));
+        }
+        const qs = params.size > 0 ? `?${params.toString()}` : "";
         const response = await fetch(withPath(baseUrl, `/v1/messages/inbox${qs}`), {
             method: "GET",
             headers,
@@ -218,7 +230,11 @@ async function waitForInbox(baseUrl, options) {
     const deadline = Date.now() + options.waitSeconds * 1000;
     const from = options.from?.toLowerCase();
     while (Date.now() < deadline) {
-        const result = await fetchInbox(baseUrl, { peek: true });
+        const remaining = Math.max(1, Math.min(30, Math.ceil((deadline - Date.now()) / 1000)));
+        const result = await fetchInbox(baseUrl, {
+            peek: true,
+            waitSeconds: remaining,
+        });
         if (result.kind === "error") {
             return result;
         }
@@ -229,10 +245,81 @@ async function waitForInbox(baseUrl, options) {
             await ackMessages(baseUrl, messages.map((m) => m.id));
             return { kind: "ok", messages, agent: result.agent };
         }
-        await new Promise((resolve) => setTimeout(resolve, 1500));
     }
     return { kind: "timeout" };
 }
+async function fetchHistory(baseUrl, options) {
+    try {
+        const headers = await authHeaders("agent");
+        const params = new URLSearchParams();
+        if (options?.with) {
+            params.set("with", options.with);
+        }
+        if (options?.limit && options.limit > 0) {
+            params.set("limit", String(options.limit));
+        }
+        const qs = params.size > 0 ? `?${params.toString()}` : "";
+        const response = await fetch(withPath(baseUrl, `/v1/messages/history${qs}`), { method: "GET", headers });
+        const data = (await response.json());
+        if (!response.ok) {
+            return {
+                kind: "error",
+                status: response.status,
+                message: data.error ?? `History failed with HTTP ${response.status}.`,
+            };
+        }
+        return {
+            kind: "ok",
+            agent: data.agent ?? "",
+            messages: data.messages ?? [],
+        };
+    }
+    catch (error) {
+        return { kind: "error", message: error.message };
+    }
+}
+async function askAgent(baseUrl, to, text, waitSeconds) {
+    // Drain any stale messages from this peer before asking.
+    const stale = await fetchInbox(baseUrl, { peek: true });
+    if (stale.kind === "ok") {
+        const fromPeer = stale.messages.filter((m) => m.from.toLowerCase() === to.toLowerCase());
+        if (fromPeer.length > 0) {
+            await ackMessages(baseUrl, fromPeer.map((m) => m.id));
+        }
+    }
+    const sentAt = Date.now() - 2000;
+    const sent = await sendMessage(baseUrl, to, text);
+    if (sent.kind !== "sent") {
+        return { kind: "error", message: sent.message };
+    }
+    const deadline = Date.now() + waitSeconds * 1000;
+    const peer = to.toLowerCase();
+    while (Date.now() < deadline) {
+        const remaining = Math.max(1, Math.min(30, Math.ceil((deadline - Date.now()) / 1000)));
+        const result = await fetchInbox(baseUrl, {
+            peek: true,
+            waitSeconds: remaining,
+        });
+        if (result.kind === "error") {
+            return { kind: "error", message: result.message };
+        }
+        const messages = result.messages.filter((m) => {
+            if (m.from.toLowerCase() !== peer)
+                return false;
+            const created = Date.parse(m.created_at);
+            return Number.isNaN(created) || created >= sentAt;
+        });
+        if (messages.length > 0) {
+            await ackMessages(baseUrl, messages.map((m) => m.id));
+            return {
+                kind: "ok",
+                reply: messages.map((m) => m.text.trim()).join("\n\n"),
+                message_id: messages[0]?.id ?? sent.id,
+            };
+        }
+    }
+    return { kind: "timeout", sent_id: sent.id };
+}
 function toWsUrl(httpBase) {
     const url = new URL(httpBase);
     if (url.protocol === "https:") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marshell/cli",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "Marshell CLI — join a subnet, discover agents, send messages",
   "license": "MIT",
   "type": "commonjs",
@@ -15,7 +15,6 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
-    "prepare": "npm run build",
     "prepublishOnly": "npm run build"
   },
   "engines": {