hivecode-mcp 0.13.1 → 0.14.1

package/hive-mux.js

@@ -19,6 +19,7 @@ import * as decoding from 'lib0/decoding'
 import { ObservableV2 } from 'lib0/observable'
 import { WebsocketProvider } from 'y-websocket'
 import { F, encodeFrame, decodeFrame, muxPath, MUX_VERSION } from './hive-mux-proto.js'
+import { relayFetch } from './hive-transport.js' // /health through the proxy, as the sockets go
 
 const messageSync = 0
 
@@ -257,7 +258,7 @@ class MuxConnection {
  * decided once -- HIVE_MUX=1 forces mux, HIVE_MUX=0 forces a socket per file, anything else asks
  * the relay's /health -- and file providers created before the answer are bound when it comes.
  */
-export function createFileTransport({ relay, room, wsOpts = {}, log = () => { }, env = process.env, fetchImpl = globalThis.fetch, onFallback = () => { }, retryMs = 1000, detectForMs = 90000 }) {
+export function createFileTransport({ relay, room, wsOpts = {}, log = () => { }, env = process.env, fetchImpl = relayFetch, onFallback = () => { }, retryMs = 1000, detectForMs = 90000 }) {
   const forced = env.HIVE_MUX === '0' || env.HIVE_MUX === '1'
   let mode = env.HIVE_MUX === '0' ? 'socket' : env.HIVE_MUX === '1' ? 'mux' : null
   let mux = null

package/hive-poll-proto.js

@@ -0,0 +1,50 @@
+// hive-poll-proto.js -- the wire format of the HTTPS long-poll transport (relay-poll.js on the
+// relay, hive-transport.js in clients). It exists for networks that refuse WebSocket upgrades but
+// pass ordinary HTTPS: Antigravity's cloud VMs (their egress proxy answers "403 WebSocket upgrades
+// are not allowed", 7 Nov 2026) and many company proxies.
+//
+// It carries EXACTLY the bytes a WebSocket would: each message is one frame, in order, so every
+// gate on the relay (claims, read-only, the governor, rate limits) sees what it always sees.
+//
+//   POST /_hive_poll/open        JSON {path, v}  -> 200 {sid, holdMs, idleMs, v} | the refusal an upgrade would get
+//   POST /_hive_poll/<sid>/send  frames, header x-hive-seq: the first frame's number (1, 2, 3, ...)
+//                                -> 204 once delivered. A retry of the same numbers is ignored, so a
+//                                lost answer never applies a message twice; a gap is a 409.
+//   POST /_hive_poll/<sid>/recv  header x-hive-ack: the last frame received, x-hive-hold: ms to wait
+//                                -> 200 frames (x-hive-seq: the first one's number) | 204 nothing yet
+//                                Frames up to the ack are forgotten; the rest are sent again, so a
+//                                lost answer loses nothing.
+//   POST /_hive_poll/<sid>/close -> 204
+//   An unknown or ended session answers 404 {gone:true}: the client reconnects and resyncs.
+//
+// The room, the token and the name travel in the open request's BODY, never in a URL: a proxy logs
+// URLs, and a room id is the key to the room.
+export const POLL_PREFIX = '/_hive_poll/'
+export const POLL_VERSION = 1
+
+/** Frames to one buffer: for each, a 4-byte big-endian length, then its bytes. */
+export function packFrames(frames) {
+  let total = 0
+  for (const f of frames) total += 4 + f.length
+  const out = Buffer.allocUnsafe(total)
+  let o = 0
+  for (const f of frames) {
+    out.writeUInt32BE(f.length, o); o += 4
+    Buffer.from(f.buffer, f.byteOffset, f.length).copy(out, o); o += f.length
+  }
+  return out
+}
+
+/** One buffer back to its frames. Throws on anything malformed, so nothing half-read is delivered. */
+export function unpackFrames(buf) {
+  const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf)
+  const out = []
+  let o = 0
+  while (o < b.length) {
+    if (o + 4 > b.length) throw new Error('truncated frame length')
+    const n = b.readUInt32BE(o); o += 4
+    if (o + n > b.length) throw new Error('truncated frame')
+    out.push(b.subarray(o, o + n)); o += n
+  }
+  return out
+}

package/hive-relay-health.js

@@ -35,6 +35,8 @@
 // the only place the wording lives, and tests/relay-diagnosis-test.mjs COUNTS the producers so a
 // third copy fails a test rather than shipping.
 
+import { relayFetch } from './hive-transport.js'
+
 /** A free-tier per-room cap. At or below this, Q431 is the likely refusal and seats are the fix. */
 export const FREE_TIER_ROOM_CAP = 8
 
@@ -67,7 +69,9 @@ export function healthUrlFor(relay) {
 export async function probeRelayHealth(relay, { timeoutMs = 2500, fetchImpl } = {}) {
   const url = healthUrlFor(relay)
   if (!url) return { ok: false, url: null, error: 'no usable relay URL' }
-  const f = fetchImpl || (typeof fetch === 'function' ? fetch : null)
+  // relayFetch, not the built-in fetch: behind a proxy the built-in one cannot reach the relay at all,
+  // and this diagnosis would then blame the relay for what is this machine's network.
+  const f = fetchImpl || relayFetch
   if (!f) return { ok: false, url, error: 'no fetch available in this runtime' }
   try {
     const ac = new AbortController()

package/hive-room-key.js

@@ -22,6 +22,7 @@ import path from 'path'
 import crypto from 'crypto'
 import { sign, decodeUnsafe, keyFingerprint, roomFingerprint, isSecuredRoom, makeSecuredRoomId } from './token.js'
 import { validateMemberName } from './hive-mailbox.js'
+import { relayFetch } from './hive-transport.js' // through the proxy, as every call to the relay
 
 export const keysDir = () => process.env.HIVE_KEYS_DIR || path.join(os.homedir(), '.hivecode', 'keys')
 const keyFile = (room) => path.join(keysDir(), `${room}.json`)
@@ -143,7 +144,7 @@ export async function revokeInvite({ room, relay, name }) {
   const failures = []
   for (const i of live) {
     try {
-      const r = await fetch(`${httpBase(relay || rec.relay)}/__hive/revoke`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ room, token: owner, jti: i.jti }) })
+      const r = await relayFetch(`${httpBase(relay || rec.relay)}/__hive/revoke`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ room, token: owner, jti: i.jti }) })
       const body = await r.json().catch(() => ({}))
       if (r.ok && body.ok) { i.revokedAt = Date.now(); done++; dropped += Number(body.dropped) || 0 }
       else failures.push(`HTTP ${r.status}${body.error ? ` ${body.error}` : ''}`)

package/hive-setup.js

@@ -40,6 +40,7 @@ import { VERSION } from './hive-version.js'
 import { currentRelayFor, controlUrl, PUBLIC_DEFAULT_RELAY } from './hive-privacy.js'
 import { validateMemberName } from './hive-mailbox.js'
 import { installStopHook, installAntigravityStopHook } from './hive-hook-install.js'
+import { relayFetch } from './hive-transport.js' // /health through the proxy, as every call to the relay
 
 export const SERVER_KEY = 'hivecode'
 const BACKUP_SUFFIX = '.before-hivecode'
@@ -340,11 +341,12 @@ function defaultName() {
   return v.ok ? cand : v.suggested
 }
 
-async function wakeRelay(relay) {
+/** Exported for tests/proxy-fetch-test.mjs. */
+export async function wakeRelay(relay) {
   const url = relay.replace(/^wss:/, 'https:').replace(/^ws:/, 'http:').replace(/\/+$/, '') + '/health'
   const t0 = Date.now()
   try {
-    const r = await fetch(url, { signal: AbortSignal.timeout(75000) })
+    const r = await relayFetch(url, { signal: AbortSignal.timeout(75000) })
     return { ok: r.ok, ms: Date.now() - t0, status: r.status }
   } catch (e) { return { ok: false, ms: Date.now() - t0, error: e.name === 'TimeoutError' ? 'no answer in 75s' : e.message } }
 }

package/hive-slack-agent.js

@@ -26,6 +26,9 @@
 
 import WebSocket from 'ws'
 import { startSync, parseLink } from './sync.js'
+import { realpathSync as __hiveRealpath } from 'fs'
+import { resolve as __hiveResolve } from 'path'
+import { fileURLToPath as __hiveFileURLToPath } from 'url'
 import {
   makeQueue,
   slackPost,
@@ -39,6 +42,7 @@ import {
   preflightSocketMode,
   connectSocketMode,
   parseSlackAllow,
+  notFromAPerson,
 } from './hive-slack.js'
 
 export { stopAll, resumeAll, resolveName, route }
@@ -219,7 +223,7 @@ export function makeAgent({
   /** The one entry point for Slack events. Only a message in the configured channel or in a DM, or
    *  the native stop button, does anything; everything else is ignored before any actor lookup. */
   async function onEvent(ev) {
-    if (!ev || ev.bot_id || ev.subtype || (botUserId && ev.user === botUserId)) return { ignored: 'bot_or_subtype' }
+    if (notFromAPerson(ev) || (botUserId && ev.user === botUserId)) return { ignored: 'bot_or_subtype' }
     const targetChannel = ev.channel || channel
     const isDm = ev.channel_type === 'im' || (typeof targetChannel === 'string' && targetChannel.startsWith('D'))
     const here = targetChannel === channel || isDm
@@ -391,6 +395,14 @@ export async function main(argv = process.argv.slice(2), {
   })
 }
 
-if (process.argv[1] && import.meta.url === `file:///${process.argv[1].replace(/\\/g, '/')}`) {
+// Run directly (node <file>, or through an npx / node_modules/.bin symlink)? Compared by real path:
+// the old `file:///${argv[1]}` test built "file:////..." on macOS and Linux, never matched, and the
+// process exited 0 having done nothing.
+function __hiveIsEntry() {
+  if (!process.argv[1]) return false
+  const me = __hiveFileURLToPath(import.meta.url)
+  try { return __hiveRealpath(process.argv[1]) === __hiveRealpath(me) } catch { return __hiveResolve(process.argv[1]) === __hiveResolve(me) }
+}
+if (__hiveIsEntry()) {
   main().then((code) => { if (code !== 0) process.exit(code) })
 }