hivecode-mcp 0.14.2 → 0.14.4

package/hive-transport.js

@@ -24,7 +24,8 @@
 // set when node started, so the WebSocket died with ENOTFOUND, the long-poll probe died the same
 // way, and hive_join said "the relay refused the connection" about a relay it never reached. Now:
 //   - proxyFor(url) picks the proxy: HIVE_PROXY (a URL, or off), else HTTPS_PROXY for wss:/https:
-//     and HTTP_PROXY for ws:/http:. NO_PROXY is honoured; loopback never goes through a proxy.
+//     and HTTP_PROXY for ws:/http:. NO_PROXY is honoured; loopback never goes through a proxy,
+//     including where node's env-proxy mode would send it there (directFetch).
 //   - Both pipes ride an HTTP CONNECT tunnel through it: the WebSocket (an agent for `ws`) and the
 //     long-poll requests (fetchFor). Through a tunnel to a wss:// relay the proxy sees only
 //     "CONNECT host:443"; the path and query -- where the room token rides -- stay inside TLS.
@@ -184,13 +185,46 @@ function tunnelAgent(proxy, secure, kind = 'fetch') {
 
 /** A fetch-shaped call carried over the tunnel agent: just what offersPoll and PollSocket use. */
 function proxyFetch(proxy, url, init = {}) {
+  return agentFetch(url, init, (secure) => tunnelAgent(proxy, secure))
+}
+
+// DIRECT MEANS DIRECT, EVEN WHERE NODE APPLIES THE ENV PROXY ITSELF. With env-proxy mode on
+// (NODE_USE_ENV_PROXY=1 or --use-env-proxy, what Antigravity's VMs run), the built-in fetch AND http's
+// global agent send every request through http(s)_proxy unless node's own NO_PROXY exempts it. So a
+// call proxyFor() had decided was direct -- loopback, a NO_PROXY match, HIVE_PROXY=off -- went to the
+// proxy anyway: a self-hosted relay on localhost was "unreachable" for an invite revoke or the /health
+// probe while its WebSockets worked (antigravity-VM, 9 Nov 2026; tests/loopback-direct-fetch-test.mjs).
+// Measured on node 22.23 and 24.22: an agent of our own is never proxied. Used only in env-proxy mode,
+// so everywhere else a direct call is still the built-in fetch, exactly as before.
+// Node fixes the mode ONCE, AT STARTUP: clearing NODE_USE_ENV_PROXY later does not turn it off (a
+// first version read it per call, and proxy-fetch-test, which clears it mid-run, still went to the
+// proxy). So the mode is read when this module loads -- the nearest point to node's own decision --
+// and a per-call env can only add it, never take it away.
+const envProxyIn = (env) => {
+  if (/^(1|true|yes|on)$/i.test(String((env && env.NODE_USE_ENV_PROXY) || '').trim())) return true
+  return /(^|\s)--use-env-proxy(\s|=|$)/.test(String((env && env.NODE_OPTIONS) || ''))
+}
+const ENV_PROXY_AT_START = envProxyIn(process.env) || process.execArgv.includes('--use-env-proxy')
+const envProxyMode = (env = process.env) => ENV_PROXY_AT_START || envProxyIn(env)
+const directAgents = new Map()
+function directAgent(secure) {
+  let a = directAgents.get(secure)
+  if (!a) { a = new (secure ? https.Agent : http.Agent)({ keepAlive: true, maxFreeSockets: 4 }); directAgents.set(secure, a) }
+  return a
+}
+function directFetch(url, init = {}) {
+  return agentFetch(url, init, directAgent)
+}
+
+/** The request behind proxyFetch and directFetch: `agentFor(secure)` picks the agent that carries it. */
+function agentFetch(url, init, agentFor) {
   return new Promise((resolve, reject) => {
     const u = new URL(url)
     const secure = u.protocol === 'https:'
     const body = init.body == null ? null : Buffer.from(init.body)
     const headers = { ...(init.headers || {}) }
     if (body) headers['content-length'] = String(body.length)
-    const req = (secure ? https : http).request(u, { method: init.method || 'GET', headers, agent: tunnelAgent(proxy, secure) }, (res) => {
+    const req = (secure ? https : http).request(u, { method: init.method || 'GET', headers, agent: agentFor(secure) }, (res) => {
       const chunks = []
       res.on('data', (c) => chunks.push(c))
       res.on('error', reject)
@@ -218,10 +252,11 @@ function proxyFetch(proxy, url, init = {}) {
   })
 }
 
-/** The fetch to reach `url` with: through the proxy tunnel when one applies, else the built-in one. */
+/** The fetch to reach `url` with: through the proxy tunnel when one applies, else direct (see directFetch). */
 export function fetchFor(url, env = process.env) {
   const p = proxyFor(url, env)
-  return p ? (u, init) => proxyFetch(p, u, init) : globalThis.fetch
+  if (p) return (u, init) => proxyFetch(p, u, init)
+  return envProxyMode(env) ? directFetch : globalThis.fetch
 }
 
 /**
@@ -373,6 +408,7 @@ export class PollSocket extends SocketShape {
   _lost(reason, code = 1006) {
     if (this.readyState === CLOSED) return
     this.readyState = CLOSED
+    clearTimeout(this._closeTimer)
     if (this._sid) this._req('close', undefined, {}, 5000).catch(() => { })
     fire(this, 'close', { type: 'close', code, reason, wasClean: false, target: this })
   }
@@ -392,7 +428,7 @@ export class PollSocket extends SocketShape {
     // A proxy that cuts long requests shows up as a failure after a long wait: hold shorter.
     if (startedAt && now - startedAt > 5000 && this._hold > 4000) this._hold = Math.max(4000, Math.floor(this._hold / 2))
     await sleep(Math.min(2000, 250 * 2 ** Math.min(3, Math.floor((now - this._troubleSince) / 5000))))
-    return this.readyState === OPEN
+    return this.readyState === OPEN || this.readyState === CLOSING
   }
   _ok() { this._troubleSince = 0 }
   async _recvLoop() {
@@ -429,17 +465,18 @@ export class PollSocket extends SocketShape {
     if (!this._flushQueued) { this._flushQueued = true; setImmediate(() => { this._flushQueued = false; this._flush() }) }
   }
   async _flush() {
-    if (this._sending || !this._outbox.length || this.readyState !== OPEN) return
+    const live = () => this.readyState === OPEN || this.readyState === CLOSING
+    if (this._sending || !this._outbox.length || !live()) { this._closeIfDrained(); return }
     this._sending = true
     try {
-      while (this._outbox.length && this.readyState === OPEN) {
+      while (this._outbox.length && live()) {
         let n = 0, bytes = 0
         while (n < this._outbox.length && n < 512 && (n === 0 || bytes + this._outbox[n].length <= 4 * 1048576)) { bytes += this._outbox[n].length; n++ }
         const batch = this._outbox.slice(0, n)
         const first = this._outSeq
         const body = packFrames(batch)
         for (;;) {
-          if (this.readyState !== OPEN) return
+          if (!live()) return
           const started = Date.now()
           let r
           try { r = await this._req('send', body, { 'content-type': 'application/octet-stream', 'x-hive-seq': String(first) }, 60000) }
@@ -455,17 +492,54 @@ export class PollSocket extends SocketShape {
         this._outbox.splice(0, n)
         this._outSeq = first + n
       }
-    } finally { this._sending = false }
+    } finally { this._sending = false; this._closeIfDrained() }
   }
+  // CLOSE DELIVERS WHAT WAS SENT FIRST, as a WebSocket's does (0.14.3 P0-1). A WebSocket hands its
+  // bytes to the OS on send(), so ws.close() still delivers them; this socket keeps them in _outbox
+  // until the relay accepts them, and close() used to drop that array: an edit made just before the
+  // agent left never reached the room while hive_edit had already said it was syncing (8-9 Nov mock
+  // run, both Antigravity VM agents). Now close() keeps sending for up to CLOSE_DRAIN_MS, then ends
+  // the session. The pending request keeps the process alive meanwhile, so an exit waits for it.
   close(code = 1000, reason = '') {
     if (this.readyState === CLOSING || this.readyState === CLOSED) return
+    if (this.readyState === OPEN && (this._outbox.length || this._sending)) {
+      this.readyState = CLOSING
+      this._closeWith = { code, reason }
+      this._closeTimer = setTimeout(() => this._endClose(false), PollSocket.CLOSE_DRAIN_MS)
+      this._flush()
+      return
+    }
+    this._closeWith = { code, reason }
+    this._endClose(true)
+  }
+  _closeIfDrained() {
+    if (this.readyState === CLOSING && !this._sending && !this._outbox.length) this._endClose(true)
+  }
+  _endClose(drained) {
+    if (this.readyState === CLOSED) return
+    clearTimeout(this._closeTimer)
     const had = !!this._sid
+    const { code, reason } = this._closeWith || { code: 1000, reason: '' }
     this.readyState = CLOSED
     if (had) this._req('close', undefined, {}, 5000).catch(() => { })
-    setImmediate(() => fire(this, 'close', { type: 'close', code, reason, wasClean: true, target: this }))
+    setImmediate(() => fire(this, 'close', { type: 'close', code, reason, wasClean: drained, target: this }))
+  }
+  /** Resolves once nothing is waiting to reach the relay (or the socket is gone): the drain, observable. */
+  drained(timeoutMs = PollSocket.CLOSE_DRAIN_MS) {
+    const end = Date.now() + timeoutMs
+    return new Promise((resolve) => {
+      const tick = () => {
+        if (this.readyState === CLOSED || (!this._outbox.length && !this._sending)) return resolve(!this._outbox.length)
+        if (Date.now() >= end) return resolve(false)
+        setTimeout(tick, 25)
+      }
+      tick()
+    })
   }
-  terminate() { this.close(1006, 'terminated') }
+  // terminate is for a dead link (the liveness check): nothing can be delivered on it, so no drain.
+  terminate() { this._closeWith = { code: 1006, reason: 'terminated' }; this._endClose(false) }
 }
+PollSocket.CLOSE_DRAIN_MS = 10000
 
 /**
  * The socket every provider gets: a WebSocket, or long-poll where WebSockets are refused (above).

package/icr.js

@@ -802,12 +802,17 @@ export function structuralMerge(base, a, b, opts = {}) {
   // ASYNC/AWAIT SYNCHRONIZATION (intent):
   // When a declaration was synchronous in base and became ASYNC in the merged result,
   // upgrade call sites inside async callers with `await` so the contract holds.
+  // ONLY a function that EXISTED in the base as sync (0.14.3 P0-5). A function new in this merge was
+  // written async by its author, together with its callers: nothing was "made async" under anyone.
+  // Counting it rewrote authored lines (`return f()` -> `return await f()`, credited to the author,
+  // silently), and two peers making the same insert at once stacked in the shared text: the room's
+  // own server.js read `return await await await admitMux(req, q)` (9 Nov).
   const asyncUpgrades = []
   if (lang.isAsyncDecl && lang.upgradeCallSitesToAwait) {
     for (const name of mergedNames) {
-      const wasAsyncInBase = baseNames.has(name) ? lang.isAsyncDecl(base, name) : false
+      const wasSyncInBase = baseNames.has(name) && !lang.isAsyncDecl(base, name)
       const isAsyncInMerged = lang.isAsyncDecl(merged, name)
-      if (!wasAsyncInBase && isAsyncInMerged) {
+      if (wasSyncInBase && isAsyncInMerged) {
         const upgraded = lang.upgradeCallSitesToAwait(merged, name)
         if (upgraded !== merged && lang.parses(upgraded)) {
           merged = upgraded

package/lang-js.js

@@ -230,45 +230,63 @@ function isAsyncDecl(src, name) {
 
 // Upgrade free call sites of `fnName` to `await fnName(...)` if they are inside an async parent
 // and not already awaited.
+//
+// Left alone (0.14.3 P0-5): a call that is already awaited (`await f()`, `await (f())`); a call that
+// IS the value an async function returns (`return f()`, `async () => f()`) -- OUTSIDE a try, where
+// returning the promise resolves to the same value. Inside a try (its block or its catch) `return f()`
+// is NOT the same once f is async: a rejection escapes the catch and a finally runs before f settles,
+// so there it is upgraded, which is what the feature is for (Claude-cloud's review). A call that is an
+// argument of an awaited call (`await g(f())`) is NOT awaited by that await and is upgraded too.
+// Each position is inserted at most once.
 function upgradeCallSitesToAwait(src, fnName) {
   try {
     const ast = parse(src)
-    const spots = []
+    const spots = new Set()
 
-    function walkAST(node, parent, isAsyncScope = false) {
+    // awaited: this node IS the operand of an await (through parentheses or an optional chain only).
+    // inTry: this node sits in a try block or catch clause of the current function.
+    function walkAST(node, parent, isAsyncScope = false, awaited = false, inTry = false) {
       if (!node || typeof node.type !== 'string') return
 
       let childAsyncScope = isAsyncScope
+      let childInTry = inTry
       if (node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
         childAsyncScope = !!node.async
+        childInTry = false // a nested function has its own try scopes
       }
+      const passAwait = node.type === 'AwaitExpression' ? true
+        : (node.type === 'ParenthesizedExpression' || node.type === 'ChainExpression') ? awaited : false
 
       if (node.type === 'CallExpression') {
         let isTarget = false
         if (node.callee.type === 'Identifier' && node.callee.name === fnName) isTarget = true
         if (isTarget && childAsyncScope) {
-          const alreadyAwaited = parent && parent.type === 'AwaitExpression'
-          if (!alreadyAwaited) {
-            spots.push(node.start)
-          }
+          const alreadyAwaited = awaited || (parent && parent.type === 'AwaitExpression')
+          const returnedAsIs = !inTry && parent && (parent.type === 'ReturnStatement' ||
+            (parent.type === 'ArrowFunctionExpression' && parent.body === node))
+          if (!alreadyAwaited && !returnedAsIs) spots.add(node.start)
         }
       }
 
       for (const k of Object.keys(node)) {
         if (k === 'type' || k === 'start' || k === 'end' || k === 'loc' || k === 'range') continue
         const v = node[k]
+        // A try's block and its catch clause are "in try"; its finally is not (a return there is final).
+        const kInTry = node.type === 'TryStatement' ? (k === 'block' || k === 'handler') || childInTry : childInTry
         if (Array.isArray(v)) {
-          for (const c of v) walkAST(c, node, childAsyncScope)
+          for (const c of v) walkAST(c, node, childAsyncScope, passAwait, kInTry)
         } else if (v && typeof v.type === 'string') {
-          walkAST(v, node, childAsyncScope)
+          walkAST(v, node, childAsyncScope, passAwait, kInTry)
         }
       }
     }
 
     walkAST(ast, null, false)
-    if (!spots.length) return src
+    if (!spots.size) return src
 
-    spots.sort((a, b) => b - a)
+    const order = [...spots].sort((a, b) => b - a)
+    spots.clear()
+    for (const p of order) spots.add(p)
     let out = src
     for (const pos of spots) {
       out = out.slice(0, pos) + 'await ' + out.slice(pos)
@@ -279,6 +297,31 @@ function upgradeCallSitesToAwait(src, fnName) {
   }
 }
 
+// STACKED AWAITS LEFT BY A CRDT UNION (0.14.3 P0-5-3). Two peers making the same sync -> async
+// change at once each insert `await ` before the same call; the shared text keeps BOTH inserts, so
+// the room reads `await await f()`. No merge can prevent that (each peer's merge is right on its own),
+// so the engine removes it afterwards. Returns the [start, end) spans to delete: for every
+// `await await x`, the OUTER `await` and the whitespace after it, and only when nothing but whitespace
+// separates the two (so `await (await x)`, a comment, or a string is never touched). On the same
+// converged text every peer computes the same spans, so their deletes are of the same characters.
+function stackedAwaits(src) {
+  let ast
+  try { ast = parse(src) } catch { return [] }
+  const spans = []
+  const walk = (node) => {
+    if (!node || typeof node.type !== 'string') return
+    if (node.type === 'AwaitExpression' && node.argument && node.argument.type === 'AwaitExpression' &&
+        /^await\s+$/.test(src.slice(node.start, node.argument.start))) spans.push([node.start, node.argument.start])
+    for (const k of Object.keys(node)) {
+      if (k === 'type' || k === 'start' || k === 'end' || k === 'loc' || k === 'range') continue
+      const v = node[k]
+      if (Array.isArray(v)) { for (const c of v) walk(c) } else if (v && typeof v.type === 'string') walk(v)
+    }
+  }
+  walk(ast)
+  return spans.sort((a, b) => a[0] - b[0])
+}
+
 // Find callers of `fnName` that are synchronous (cannot be auto-awaited without changing the caller's signature)
 function syncCallSitesOf(src, fnName) {
   const syncCallers = []
@@ -641,6 +684,7 @@ export const javascript = {
   declBody,
   isAsyncDecl,
   upgradeCallSitesToAwait,
+  stackedAwaits,        // spans of `await await` a CRDT union left (P0-5-3)
   syncCallSitesOf,
   renameRefs,           // rewrites every matching identifier (kept for reference)
   renameFreeRefs,       // scope-aware — only rewrites references that resolve to the binding

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hivecode-mcp",
-  "version": "0.14.2",
+  "version": "0.14.4",
   "description": "MCP server that lets any AI coding agent join a Hivecode room — humans and multiple AI agents edit one live codebase with folder-scoped permissions and approval gates.",
   "type": "module",
   "license": "MIT",
@@ -36,8 +36,13 @@
     "hive-version.js",
     "hive-pr-staleness.js",
     "hive-pr.js",
-    "hive-branch.js", "hive-land.js", "hive-repos.js", "hive-room-mode.js", "hive-room-watcher.js",
+    "hive-branch.js",
+    "hive-land.js",
+    "hive-repos.js",
+    "hive-room-mode.js",
+    "hive-room-watcher.js",
     "hive-mailbox.js",
+    "hive-seen.js",
     "hive-obligations.js",
     "hive-receipts.js",
     "hive-throttle.js",
@@ -134,7 +139,7 @@
     "test:substrate:authority": "node substrate-authority-test.js",
     "test:substrate:all": "node substrate-test.js && node substrate-live-test.js && node substrate-enforce-test.js && node substrate-authority-test.js",
     "test:recover": "node tests/recover-test.mjs",
-    "test:mailbox": "node tests/mailbox-test.mjs && node tests/mcp-wait-test.mjs && node tests/mailbox-noise-test.mjs",
+    "test:mailbox": "node tests/mailbox-test.mjs && node tests/mcp-wait-test.mjs && node tests/mailbox-noise-test.mjs && node tests/mail-identity-test.mjs",
     "test:stophook": "node tests/stop-hook-test.mjs",
     "test:limits": "node tests/limits-test.mjs && node tests/rate-hold-test.mjs && node tests/persist-batch-test.mjs",
     "test:merge": "node tests/diff3-test.mjs && node tests/merge-balloon-test.mjs && node tests/icr-merge-test.js && node tests/icr-gap-comments-test.mjs && node tests/icr-comment-fuzz-test.mjs",
@@ -188,5 +193,9 @@
     "doc": "docs",
     "test": "tests"
   },
-  "author": "Ganesh Shivlal Kute <support@getgrm.tech>"
+  "author": "Ganesh Shivlal Kute <support@getgrm.tech>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ganesh-Kute/HiveCode.git"
+  }
 }