nexrall-code 0.5.185 → 0.5.187

package/dist/index.js

@@ -40550,9 +40550,9 @@ var require_react_development = __commonJS({
               false === didWarnAboutMessageChannel && (didWarnAboutMessageChannel = true, "undefined" === typeof MessageChannel && console.error(
                 "This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."
               ));
-              var channel = new MessageChannel();
-              channel.port1.onmessage = callback;
-              channel.port2.postMessage(void 0);
+              var channel2 = new MessageChannel();
+              channel2.port1.onmessage = callback;
+              channel2.port2.postMessage(void 0);
             };
           }
         return enqueueTaskImpl(task);
@@ -41524,8 +41524,8 @@ var require_scheduler_production = __commonJS({
         localSetImmediate(performWorkUntilDeadline);
       };
     else if ("undefined" !== typeof MessageChannel) {
-      channel = new MessageChannel(), port = channel.port2;
-      channel.port1.onmessage = performWorkUntilDeadline;
+      channel2 = new MessageChannel(), port = channel2.port2;
+      channel2.port1.onmessage = performWorkUntilDeadline;
       schedulePerformWorkUntilDeadline = function() {
         port.postMessage(null);
       };
@@ -41533,7 +41533,7 @@ var require_scheduler_production = __commonJS({
       schedulePerformWorkUntilDeadline = function() {
         localSetTimeout(performWorkUntilDeadline, 0);
       };
-    var channel;
+    var channel2;
     var port;
     function requestHostTimeout(callback, ms) {
       taskTimeoutID = localSetTimeout(function() {
@@ -41797,8 +41797,8 @@ var require_scheduler_development = __commonJS({
           localSetImmediate(performWorkUntilDeadline);
         };
       else if ("undefined" !== typeof MessageChannel) {
-        var channel = new MessageChannel(), port = channel.port2;
-        channel.port1.onmessage = performWorkUntilDeadline;
+        var channel2 = new MessageChannel(), port = channel2.port2;
+        channel2.port1.onmessage = performWorkUntilDeadline;
         schedulePerformWorkUntilDeadline = function() {
           port.postMessage(null);
         };
@@ -66643,6 +66643,157 @@ async function scheduleRunsCommand(id, opts = {}) {
   }
 }
 
+// src/commands/channelCmd.ts
+var CHANNEL_WAIT_EXIT = { OK: 0, FAILED: 1, DISCARDED: 3, TIMEOUT: 4 };
+function mapRelayError(status, error) {
+  if (status === 400)
+    return "the relay refused the request shape (bad session id, nonce or text).";
+  if (status === 401)
+    return "missing token \u2014 pass --token or set NEXRALL_CHANNEL_TOKEN.";
+  if (status === 404)
+    return "no such channel \u2014 it is closed, the terminal is gone, or the token is wrong.";
+  if (status === 413)
+    return "the message is too large for a push (8 KB max).";
+  if (status === 429)
+    return "rate limited \u2014 this channel is being pushed faster than it allows.";
+  if (status === 503)
+    return "the relay is unavailable \u2014 try again in a moment.";
+  return `the relay refused the request (HTTP ${status}${error ? `: ${error}` : ""}).`;
+}
+async function channelPushCommand(textParts, opts, deps = {}) {
+  const fetchFn = deps.fetchFn ?? fetch;
+  const stdout = deps.stdout ?? ((line) => console.log(line));
+  const stderr = deps.stderr ?? ((line) => console.error(paint.dim(line)));
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve14) => setTimeout(resolve14, ms)));
+  const pollMs = deps.pollMs ?? 2e3;
+  const message = (textParts ?? []).join(" ").trim();
+  const base = String(opts.url ?? "").replace(/\/+$/, "");
+  const token = opts.token && opts.token.trim() || (process.env.NEXRALL_CHANNEL_TOKEN ?? "").trim();
+  const timeoutSec = (() => {
+    const t2 = parseFloat(String(opts.timeout ?? ""));
+    return Number.isFinite(t2) && t2 > 0 ? t2 : 180;
+  })();
+  if (!message) {
+    stderr("Usage: nex channel push --url <push URL> [--token <token>] [--wait] <message...>");
+    return CHANNEL_WAIT_EXIT.FAILED;
+  }
+  if (!/^https?:\/\//.test(base)) {
+    stderr("--url must be the push URL printed by `/channel open` (https://\u2026/api/cli-sessions/<id>/push).");
+    return CHANNEL_WAIT_EXIT.FAILED;
+  }
+  if (!token) {
+    stderr("No channel token \u2014 pass --token or set NEXRALL_CHANNEL_TOKEN (env keeps it out of `ps`).");
+    return CHANNEL_WAIT_EXIT.FAILED;
+  }
+  if (opts.wait && !/\/push$/.test(base)) {
+    stderr("--wait needs the \u2026/push URL itself, so the answer can be fetched back from <push URL>/<nonce>.");
+    return CHANNEL_WAIT_EXIT.FAILED;
+  }
+  let res;
+  try {
+    res = await fetchFn(base, {
+      method: "POST",
+      headers: { "content-type": "application/json", "x-channel-token": token },
+      body: JSON.stringify({ text: message, ...opts.source ? { source: opts.source } : {} })
+    });
+  } catch (e2) {
+    stderr(`Push failed: ${e2.message}`);
+    return CHANNEL_WAIT_EXIT.FAILED;
+  }
+  if (res.status !== 202) {
+    let body = {};
+    try {
+      body = await res.json();
+    } catch {
+    }
+    stderr(`\u2716 ${mapRelayError(res.status, body.error)}`);
+    return CHANNEL_WAIT_EXIT.FAILED;
+  }
+  const pushed = await res.json();
+  const nonce = typeof pushed.nonce === "string" ? pushed.nonce : "";
+  if (!nonce) {
+    stderr("The relay answered 202 without a nonce \u2014 there is nothing to watch.");
+    return CHANNEL_WAIT_EXIT.FAILED;
+  }
+  if (!opts.wait) {
+    if (opts.json)
+      stdout(JSON.stringify({ ok: true, nonce, ts: pushed.ts ?? null, status: "pending" }));
+    else
+      stdout(nonce);
+    stderr(`Pushed. The session decides what to do with it (a person, maybe; read the outcome at ${base}/${nonce}).`);
+    return CHANNEL_WAIT_EXIT.OK;
+  }
+  stderr(`Waiting for the session's answer (nonce ${nonce}, up to ${timeoutSec}s)\u2026`);
+  const deadline = Date.now() + timeoutSec * 1e3;
+  let lastStatus = "pending";
+  let lastError = "";
+  for (; ; ) {
+    if (Date.now() >= deadline) {
+      if (opts.json)
+        stdout(JSON.stringify({ ok: false, error: "timeout", nonce, status: lastStatus }));
+      stderr(
+        `\u2716 No answer after ${timeoutSec}s (still ${lastStatus}${lastError ? `; last error: ${lastError}` : ""}). The push was delivered \u2014 the session may still be working on it.`
+      );
+      return CHANNEL_WAIT_EXIT.TIMEOUT;
+    }
+    await sleep(Math.min(pollMs, Math.max(10, deadline - Date.now())));
+    let status;
+    let body = {};
+    try {
+      const r2 = await fetchFn(`${base}/${nonce}`, { headers: { "x-channel-token": token } });
+      status = r2.status;
+      try {
+        body = await r2.json();
+      } catch {
+      }
+    } catch (e2) {
+      lastError = e2.message;
+      continue;
+    }
+    if (status === 404) {
+      if (opts.json)
+        stdout(JSON.stringify({ ok: false, error: body.error ?? "no_channel", nonce }));
+      stderr("\u2716 The channel is gone (closed, terminal exited, or the token changed). The answer died with it.");
+      return CHANNEL_WAIT_EXIT.FAILED;
+    }
+    if (status === 400 || status === 401) {
+      if (opts.json)
+        stdout(JSON.stringify({ ok: false, error: body.error ?? "refused", nonce }));
+      stderr(`\u2716 ${mapRelayError(status, body.error)}`);
+      return CHANNEL_WAIT_EXIT.FAILED;
+    }
+    if (status === 429 || status >= 500) {
+      lastError = `HTTP ${status}`;
+      continue;
+    }
+    if (status !== 200) {
+      lastError = `HTTP ${status}`;
+      continue;
+    }
+    lastStatus = typeof body.status === "string" ? body.status : "pending";
+    if (lastStatus === "discarded") {
+      if (opts.json)
+        stdout(JSON.stringify(body));
+      else
+        stderr("\u{1F4E8} The session discarded the message \u2014 a person there refused it.");
+      return CHANNEL_WAIT_EXIT.DISCARDED;
+    }
+    const answered = lastStatus === "accepted" && (typeof body.reply === "string" || body.noText === true);
+    if (answered) {
+      if (opts.json)
+        stdout(JSON.stringify(body));
+      else if (typeof body.reply === "string")
+        stdout(body.reply);
+      else {
+        stderr(
+          `(The session accepted the message, but the turn produced no text${body.interrupted ? " \u2014 it was interrupted" : ""}.)`
+        );
+      }
+      return CHANNEL_WAIT_EXIT.OK;
+    }
+  }
+}
+
 // src/commands/chat.ts
 import * as readline3 from "readline";
 import * as path31 from "path";
@@ -75417,7 +75568,9 @@ import { createHash as createHash2, randomBytes as randomBytes2 } from "node:cry
 var CHANNEL_TOKEN_PREFIX = "nxch_";
 var CHANNEL_QUEUE_CAP = 10;
 var CHANNEL_TEXT_MAX_CHARS = 8192;
+var CHANNEL_REPLY_MAX_CHARS = 8192;
 var SEEN_NONCE_CAP = 512;
+var AWAITING_REPLY_CAP = 64;
 var NONCE_RE = /^[a-f0-9]{16}$/;
 var SOURCE_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,31}$/;
 function defaultMintToken() {
@@ -75451,6 +75604,8 @@ var SessionChannel = class {
   policy = "ask";
   queue = [];
   seenNonces = /* @__PURE__ */ new Set();
+  /** S13c: nonces delivered but not yet answered by a finished turn. */
+  awaitingReply = /* @__PURE__ */ new Set();
   /** Minted once per open; rotated by a re-open after /channel close. */
   token = null;
   tokenHash = null;
@@ -75584,6 +75739,7 @@ var SessionChannel = class {
       return;
     this.stopped = true;
     this.queue = [];
+    this.awaitingReply.clear();
     if (this.socket?.connected)
       this.emitTo("cli:channel-close", { id: this.id, reason });
     this.token = null;
@@ -75609,6 +75765,39 @@ var SessionChannel = class {
     }
     this.notice({ kind: "delivered", msg, auto, folded: verdict === "queued" });
     this.ack(msg, verdict);
+    if (this.awaitingReply.size >= AWAITING_REPLY_CAP) {
+      this.awaitingReply.delete(this.awaitingReply.values().next().value);
+    }
+    this.awaitingReply.add(msg.nonce);
+  }
+  /**
+   * S13c — close the loop: hand every delivered-but-unanswered push the
+   * closing text of the turn that consumed it (chat.ts calls this when a turn
+   * ends; `null`/blank means the turn said nothing useful, which is reported
+   * as an EXPLICIT no-text marker rather than silence). Frames are keyed by
+   * nonce and stored by the relay, readable only with the channel token.
+   * Returns how many nonces were answered.
+   */
+  publishReplies(reply, opts = {}) {
+    if (this.stopped || this.awaitingReply.size === 0)
+      return 0;
+    const text = (reply ?? "").trim();
+    let body;
+    if (!text)
+      body = { noText: true };
+    else if (text.length > CHANNEL_REPLY_MAX_CHARS) {
+      body = { reply: text.slice(0, CHANNEL_REPLY_MAX_CHARS), truncated: true };
+    } else
+      body = { reply: text };
+    if (opts.interrupted)
+      body.interrupted = true;
+    let answered = 0;
+    for (const nonce of this.awaitingReply) {
+      this.emitTo("cli:channel-result", { id: this.id, nonce, ...body });
+      answered += 1;
+    }
+    this.awaitingReply.clear();
+    return answered;
   }
   /** Shape-check a pushed frame — the relay is a pipe, delivery trusts nothing. */
   validateMessage(payload) {
@@ -97681,6 +97870,7 @@ async function runTurn(messages, modelAlias, workDir, abortSignal, env3, nexrall
   const subPrefix = (meta) => paint.dim(`  \u21B3 ${meta?.agentName ?? "sub-agent"} `);
   let thinkingTokens = 0;
   let axTextBlockOpen = false;
+  let turnReply = "";
   let liveThinkText = "";
   const pushStatus = () => {
     spinner.setThinking(thinkingTokens, liveThinkText);
@@ -97782,6 +97972,9 @@ async function runTurn(messages, modelAlias, workDir, abortSignal, env3, nexrall
         axTextBlockOpen = true;
       }
       mdRender.feed(text);
+      turnReply += text;
+      if (turnReply.length > 32768)
+        turnReply = turnReply.slice(-16384);
     },
     // System notices (mid-run auto-prune/auto-compact housekeeping) are NOT part
     // of the model's own reply — used to go through onText, which spliced
@@ -97801,6 +97994,7 @@ async function runTurn(messages, modelAlias, workDir, abortSignal, env3, nexrall
       if (abortSignal.aborted)
         return;
       mdRender.flush();
+      turnReply = "";
       spinner.stop();
       if (meta?.id)
         toolCalls.set(meta.id, {
@@ -98063,6 +98257,10 @@ async function runTurn(messages, modelAlias, workDir, abortSignal, env3, nexrall
   });
   if (sessionTurns.length > MAX_SESSION_TURNS)
     sessionTurns.splice(0, sessionTurns.length - MAX_SESSION_TURNS);
+  const channel2 = activeSessionChannel();
+  const replied = channel2?.publishReplies(turnReply, { interrupted: abortSignal.aborted }) ?? 0;
+  if (replied > 0)
+    console.log(paint.dim(`  \u21A9 channel result sent (${replied})`));
   return { messages: result, usage: lastUsage };
 }
 function toolIds(isSubTask, meta) {
@@ -101466,6 +101664,11 @@ ${dirList}`;
                 `  Channel ${st.state === "live" ? paint.green("live") : paint.yellow(st.state)} \xB7 policy ${ch.activePolicy} \xB7 ${pending2.length} waiting`
               );
               console.log(paint.dim(`  Push: ${ch.pushUrl}`));
+              console.log(
+                paint.dim(
+                  "  Replies: the pusher reads the turn's answer back \u2014 GET <push URL>/<nonce>, or `nex channel push --wait`."
+                )
+              );
               pending2.forEach(
                 (m2, i2) => console.log(paint.dim(`    #${i2 + 1} (${m2.source}) ${channelPreview(m2.text)}`))
               );
@@ -102911,6 +103114,11 @@ ${text}
                 worktree: worktreeState,
                 disableHooks: noDiscovery,
                 _extraAgentTypes: _cliAgentTypes,
+                // Threaded exactly as runTurn does: a typed fork must not silently
+                // lose the MCP servers the session has connected, and a billed
+                // model run belongs in the audit trail like any other.
+                mcpManager: _mcpManager ?? void 0,
+                audit: currentAudit(),
                 backgroundAgents: willBackground ? cliBackgroundAgents : void 0,
                 // Background: it runs while the user keeps typing, so it can never print
                 // into the transcript. Foreground: the user is waiting and the prompt is
@@ -104094,6 +104302,10 @@ schedule.command("runs <id>").description("Recent runs of a schedule, newest fir
 schedule.action(async () => {
   await scheduleListCommand();
 });
+var channel = program2.command("channel").description("Push messages into a running session from CI or a script (channels)");
+channel.command("push <text...>").description("Push a message into a live session; --wait prints the answer back").requiredOption("--url <url>", "The push URL printed by `/channel open` inside the session").option("--token <token>", "Channel token (prefer NEXRALL_CHANNEL_TOKEN \u2014 argv is visible in `ps`)").option("--source <slug>", "Where it came from, e.g. ci (default: channel)").option("-w, --wait", "Wait for the session's answer and print it (exit 0 answered, 3 discarded, 4 timeout)").option("--timeout <seconds>", "How long --wait waits (default 180)").option("--json", "Machine-readable output").action(async (text, opts) => {
+  process.exitCode = await channelPushCommand(text, opts);
+});
 program2.command("update").description("Update nex to the latest version").option("-c, --check", "Check for updates without installing").option("-y, --yes", "Skip confirmation prompt").action(async (opts) => {
   await updateCommand({ check: opts.check, yes: opts.yes });
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nexrall-code",
-  "version": "0.5.185",
-  "description": "Nexrall Code — AI coding assistant for your terminal (headless agent for scripts, CI and automation)",
+  "version": "0.5.187",
+  "description": "Nexrall Code \u2014 AI coding assistant for your terminal (headless agent for scripts, CI and automation)",
   "keywords": [
     "ai",
     "cli",