grok-bot-cli 0.3.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grok-bot-cli",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "CLI for Grok Bot agents and groups: create, update, message, inspect threads, and automate cleanup",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -16,7 +16,16 @@ function print(value) {
 function fail(err) {
   let message = err instanceof Error ? err.message : String(err);
   message = redactSecrets(message);
-  process.stderr.write(message + "\n");
+  if (jsonErrors && err instanceof Error) {
+    const out = { error: message };
+    if (err.delivery !== undefined) out.delivery = err.delivery;
+    if (err.threadId !== undefined) out.threadId = err.threadId;
+    if (err.turnId !== undefined) out.turnId = err.turnId;
+    if (err.targetId !== undefined) out.targetId = err.targetId;
+    process.stderr.write(JSON.stringify(out) + "\n");
+  } else {
+    process.stderr.write(message + "\n");
+  }
   process.exit(1);
 }
 
@@ -118,7 +127,19 @@ function hasFlag(args, name) {
   return true;
 }
 
+/** Peel a trailing flag that `--` does not protect; free-text commands keep mid-text tokens. */
+function takeTrailingFlag(args, name) {
+  const stop = args.indexOf("--");
+  const end = stop === -1 ? args.length : stop;
+  if (end > 0 && args[end - 1] === name) {
+    args.splice(end - 1, 1);
+    return true;
+  }
+  return false;
+}
+
 /** Peel global CLI options only from the leading argv (before the command). */
+let jsonErrors = false;
 function takeLeadingGlobals(args) {
   let json = false;
   let gateway = false;
@@ -134,6 +155,7 @@ function takeLeadingGlobals(args) {
     }
     if (a === "--json") {
       json = true;
+      jsonErrors = true;
       args.shift();
       continue;
     }
@@ -301,6 +323,11 @@ function formatCodexThread(t) {
 }
 
 async function runCodex(sub, rest, json) {
+  // Structured subcommands take no free text, so --json peels anywhere. Send
+  // peels a trailing --json only; mid-message tokens stay message content.
+  if (sub === "status" || sub === "list-threads") {
+    if (hasFlag(rest, "--json")) { json = true; jsonErrors = true; }
+  }
   if (sub === "status") {
     const status = await codexStatus();
     print(json ? status : formatCodexStatus(status));
@@ -319,6 +346,7 @@ async function runCodex(sub, rest, json) {
   }
   if (sub === "send") {
     const threadId = rest.shift();
+    if (takeTrailingFlag(rest, "--json")) { json = true; jsonErrors = true; }
     if (rest[0] === "--") rest.shift();
     const message = rest.join(" ").trim();
     if (!threadId || threadId.startsWith("-") || !message) throw new StoreError("gbot codex send <threadId> <message...>");
@@ -379,7 +407,7 @@ async function main(argv) {
   if (cmd === "history") {
     const options = args.slice(1);
     // Command-local flags (globals only peel from argv before the command).
-    if (hasFlag(options, "--json")) json = true;
+    if (hasFlag(options, "--json")) { json = true; jsonErrors = true; }
     const showPath = hasFlag(options, "--path");
     const search = takeFlag(options, "--search");
     const limitRaw = takeFlag(options, "--limit");
@@ -405,6 +433,12 @@ async function main(argv) {
     return;
   }
 
+  // Peel command-local --json before touching the backend so auth/gateway
+  // failures honor it. Send peels a trailing --json only (mid-text tokens stay
+  // message content); `--` protects everything after it.
+  if (cmd === "send" && takeTrailingFlag(rest, "--json")) { json = true; jsonErrors = true; }
+  if ((cmd === "thread" || cmd === "chat") && hasFlag(rest, "--json")) { json = true; jsonErrors = true; }
+
   const backend = await openBackend({ root: rootFlag, gateway, files: filesMode });
 
   if (cmd === "bots" && sub === "list") {
@@ -514,7 +548,7 @@ async function main(argv) {
 
   if (cmd === "send") {
     const ref = sub;
-    if (hasFlag(rest, "--json")) json = true;
+    if (hasFlag(rest, "--json")) { json = true; jsonErrors = true; }
     const message = rest.join(" ").trim();
     if (!ref || !message) throw new StoreError("gbot send <bot-or-group> <message...>");
     const out = await backend.send(ref, message);
@@ -528,9 +562,7 @@ async function main(argv) {
   if (cmd === "thread" || cmd === "chat") {
     const ref = sub;
     if (!ref) throw new StoreError("gbot thread <bot-or-group> [--limit N] [--root MESSAGE_ID] [--full]");
-    if (hasFlag(rest, "--json")) json = true;
-    const full = rest.includes("--full");
-    if (full) rest.splice(rest.indexOf("--full"), 1);
+    const full = hasFlag(rest, "--full");
     const limitRaw = takeFlag(rest, "--limit");
     const rootId = takeFlag(rest, "--root");
     const limit = limitRaw ? Number(limitRaw) : 40;

package/src/codex-bridge.js

@@ -173,10 +173,15 @@ export function connectCodexAppServer(path, { timeoutMs = 15000 } = {}) {
     let fragOpcode = null;
     let fragParts = [];
     let fragBytes = 0;
+    // Absolute handshake deadline: socket timeouts reset on any bytes, so trickled
+    // headers must not extend this. Per-request timers stay absolute after upgrade.
+    const handshakeTimer = setTimeout(() => failAll(new Error("Timed out connecting to Codex app-server at " + path)), timeoutMs);
+    if (typeof handshakeTimer.unref === "function") handshakeTimer.unref();
 
     const failAll = (err) => {
       if (closed) return;
       closed = true;
+      clearTimeout(handshakeTimer);
       if (err && err.delivery == null) err.delivery = pending.size ? "unknown" : "rejected";
       for (const { reject: rej } of pending.values()) rej(err);
       pending.clear();
@@ -212,15 +217,20 @@ export function connectCodexAppServer(path, { timeoutMs = 15000 } = {}) {
       close() {
         if (closed) return;
         closed = true;
+        clearTimeout(handshakeTimer);
         const err = new Error("Codex client closed");
         err.delivery = pending.size ? "unknown" : "rejected";
         for (const { reject: rej } of pending.values()) rej(err);
         pending.clear();
-        if (!socket.destroyed) {
-          if (upgraded) write(0x8, Buffer.from([0x03, 0xe8]));
-          socket.end();
-          socket.unref();
-        }
+        // Best-effort close frame, then guaranteed destruction so no path leaks the socket.
+        if (!socket.destroyed && upgraded) write(0x8, Buffer.from([0x03, 0xe8]));
+        if (socket.destroyed) return;
+        const forceDestroy = setTimeout(() => { try { socket.destroy(); } catch { /* already gone */ } }, 1000);
+        if (typeof forceDestroy.unref === "function") forceDestroy.unref();
+        socket.end(() => {
+          clearTimeout(forceDestroy);
+          try { socket.destroy(); } catch { /* already gone */ }
+        });
       },
     };
 
@@ -256,10 +266,13 @@ export function connectCodexAppServer(path, { timeoutMs = 15000 } = {}) {
         failAll(new Error("Codex app-server sent an unreadable message: " + err.message));
         return;
       }
+      if (!msg || typeof msg !== "object" || Array.isArray(msg)) {
+        failAll(new Error("Codex app-server sent a malformed message"));
+        return;
+      }
       onMessage(msg);
     };
 
-    socket.setTimeout(timeoutMs, () => failAll(new Error("Timed out connecting to Codex app-server at " + path)));
     socket.once("error", (err) => failAll(new Error("Could not connect to Codex app-server at " + path + ": " + err.message)));
     socket.once("close", () => failAll(new Error("Codex app-server closed the connection")));
     socket.once("connect", () => socket.write(upgradeRequest(key)));
@@ -271,11 +284,13 @@ export function connectCodexAppServer(path, { timeoutMs = 15000 } = {}) {
           if (buf.length > WS_MAX_HEADER_BYTES) failAll(new Error("Codex app-server handshake headers exceed " + WS_MAX_HEADER_BYTES + " bytes"));
           return;
         }
+        // Terminated headers hit the cap too; size is checked before any decoding.
+        if (end > WS_MAX_HEADER_BYTES) return failAll(new Error("Codex app-server handshake headers exceed " + WS_MAX_HEADER_BYTES + " bytes"));
         const head = buf.subarray(0, end).toString();
         buf = buf.subarray(end + 4);
         if (!validateUpgradeHead(head, key)) return failAll(new Error("Codex app-server refused the WebSocket upgrade: " + head.split("\r\n")[0]));
         upgraded = true;
-        socket.setTimeout(0);
+        clearTimeout(handshakeTimer);
         resolve(client);
       }
       for (;;) {
@@ -290,6 +305,7 @@ export function connectCodexAppServer(path, { timeoutMs = 15000 } = {}) {
           return;
         }
         buf = frame.rest;
+        if (frame.payload.length > WS_MAX_MESSAGE_BYTES) return failAll(new Error("Codex app-server frame exceeds " + WS_MAX_MESSAGE_BYTES + " bytes"));
         if (frame.masked) return failProtocol("server frames must not be masked");
         if (frame.opcode >= 0x8) {
           if (!frame.fin || frame.payload.length > 125) return failProtocol("bad control frame");

package/src/gateway.js

@@ -82,11 +82,32 @@ export function hasGatewayAuth() {
   return Boolean(gatewayOverride() || accessTokenFromEnv() || hasGrokBotGatewaySession());
 }
 
-async function readJson(res) {
-  const text = await res.text();
-  if (text.length > GATEWAY_MAX_RESPONSE_BYTES) {
-    throw new GatewayError("Gateway response too large (" + text.length + " bytes, limit " + GATEWAY_MAX_RESPONSE_BYTES + ")");
+async function readTextCapped(res, maxBytes) {
+  if (!res.body || typeof res.body.getReader !== "function") {
+    const text = await res.text();
+    if (Buffer.byteLength(text, "utf8") > maxBytes) {
+      throw new GatewayError("Gateway response too large (over " + maxBytes + " bytes)");
+    }
+    return text;
+  }
+  const reader = res.body.getReader();
+  const chunks = [];
+  let bytes = 0;
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    bytes += value.byteLength ?? value.length;
+    if (bytes > maxBytes) {
+      try { await reader.cancel(); } catch { /* already closed */ }
+      throw new GatewayError("Gateway response too large (over " + maxBytes + " bytes)");
+    }
+    chunks.push(value);
   }
+  return Buffer.concat(chunks.map((c) => Buffer.from(c.buffer ?? c, c.byteOffset ?? 0, c.byteLength ?? c.length))).toString("utf8");
+}
+
+async function readJson(res) {
+  const text = await readTextCapped(res, GATEWAY_MAX_RESPONSE_BYTES);
   if (!text) return {};
   try {
     return JSON.parse(text);
@@ -343,8 +364,10 @@ export async function sendPrompt(session, ref, prompt, extra = {}) {
     }
     throw err;
   }
-  const messageId = data && typeof data.messageId === "string" ? data.messageId : null;
-  return { target: rec, result: data, delivery: "accepted", ...(messageId ? { messageId } : {}) };
+  const messageId = data && typeof data === "object" && typeof data.messageId === "string" ? data.messageId : null;
+  // Only a confirmed receipt counts as accepted; anything else is unknown, never a silent accept.
+  // ponytail: full send/execution correlation envelope stays in #37.
+  return { target: rec, result: data && typeof data === "object" ? data : {}, delivery: messageId ? "accepted" : "unknown", ...(messageId ? { messageId } : {}) };
 }
 
 export async function getTranscriptTail(session, ref, limit = 40) {