hivecode-mcp 0.12.4 → 0.13.1

package/hive-stop-hook.js

@@ -57,6 +57,7 @@ import fs from 'fs'
 import path from 'path'
 import { mentionsName, unansweredFor } from './hive-mailbox.js'
 import { isArmed, listenCommand, listenHow, listenOrder } from './hive-listen.js'
+import { readAgents, agentForHook } from './hive-session.js'
 
 // Consecutive turns we will block purely because a task is still open, before standing down.
 // Messages are not subject to this: the watermark already makes each one block at most once.
@@ -205,12 +206,14 @@ function obligations({ chat, tasks, me, seen, taskBlocks, nudged = [] }) {
 }
 
 /** Walk up from `start` looking for the session file; the hook's cwd is usually but not always
- *  the folder the MCP server was launched in. */
-function findSession(start) {
+ *  the folder the MCP server was launched in. That folder can have started several agents (two
+ *  Claude Code sessions in one repo), so the record is the one for THIS hook's conversation, and
+ *  none at all when that cannot be told (hive-session.js). */
+function findSession(start, hook = {}) {
   let dir = path.resolve(start)
   for (let i = 0; i < 4; i++) {
     const p = path.join(dir, SESSION_FILE)
-    if (fs.existsSync(p)) return { root: dir, session: readJson(p) }
+    if (fs.existsSync(p)) return { root: dir, session: agentForHook(readAgents(p), hook) }
     const up = path.dirname(dir)
     if (up === dir) break
     dir = up
@@ -230,7 +233,7 @@ async function main() {
     // GUARD 1: this stop is already the product of a block. Never stack another on it.
     if (hook.stop_hook_active || Number(hook.executionNum) > 0) return allow()
 
-    const found = findSession(hook.cwd || (Array.isArray(hook.workspacePaths) && hook.workspacePaths[0]) || process.cwd())
+    const found = findSession(hook.cwd || (Array.isArray(hook.workspacePaths) && hook.workspacePaths[0]) || process.cwd(), hook)
     if (!found || !found.session || !found.session.dir || !found.session.name) return allow() // not in a room
 
     const { root, session } = found
@@ -258,7 +261,7 @@ async function main() {
     let listening = null, listenLine = ''
     if (how && cfg.relay && cfg.room && !session.authed && !cfg.token) {
       listening = isArmed({ name: session.name, room: cfg.room, session: String(hook.session_id || hook.conversationId || process.env.ANTIGRAVITY_CONVERSATION_ID || '') })
-      listenLine = listenOrder(how, listenCommand({ relay: cfg.relay, room: cfg.room, name: session.name }))
+      listenLine = listenOrder(how, listenCommand({ relay: cfg.relay, room: cfg.room, name: session.name, app: APP }))
     }
 
     const d = decide({

package/hive-time.js

@@ -0,0 +1,71 @@
+/**
+ * Unified timestamp parsing and formatting for Hivecode chat and receipts.
+ * Single source of truth used by:
+ *   1. public/control.html (browser Control Room ago() and chat timestamps)
+ *   2. hive-mailbox.js (hive_read_chat formatMessage)
+ *   3. sync.js (HIVE_CHAT.md renderChat)
+ *
+ * Handles:
+ *   - Unix microseconds (> 1e14), as emitted by hive-slack.js, hive-mcp-http.js, hive-gate.js
+ *   - Unix milliseconds (> 1e11)
+ *   - Existing "HH:MM:SS" strings (passed through as-is per Claude's directive)
+ */
+
+export function toMillis(at) {
+  if (at == null || at === '') return null
+  const num = typeof at === 'number' ? at : Number(at)
+  if (!isNaN(num) && num > 0) {
+    if (num > 1e14) {
+      // Unix microseconds (> 100,000,000,000,000)
+      return Math.round(num / 1000)
+    }
+    if (num > 1e11) {
+      // Unix milliseconds (> 100,000,000,000)
+      return Math.round(num)
+    }
+    if (num > 1e9) {
+      // Unix seconds (> 1,000,000,000)
+      return Math.round(num * 1000)
+    }
+    return Math.round(num)
+  }
+  return null
+}
+
+export function ago(at, now = Date.now()) {
+  if (!at) return ''
+  if (typeof at === 'string') {
+    const num = Number(at)
+    if (!isNaN(num) && num > 1e11) {
+      return ago(num, now)
+    }
+    // String with clock time or text: print as is (matches control.html behavior)
+    return at
+  }
+  const ms = toMillis(at)
+  if (ms == null) return String(at)
+  const d = Math.max(0, now - ms)
+  const m = Math.floor(d / 60000)
+  if (m < 1) return 'now'
+  if (m < 60) return `${m}m`
+  const h = Math.floor(m / 60)
+  return h < 24 ? `${h}h` : `${Math.floor(h / 24)}d`
+}
+
+export function formatTime(at, now = Date.now()) {
+  if (!at) return ''
+  if (typeof at === 'string') {
+    const num = Number(at)
+    if (!isNaN(num) && num > 1e11) {
+      return formatTime(num, now)
+    }
+    return at
+  }
+  const ms = toMillis(at)
+  if (ms == null) return String(at)
+  return new Date(ms).toTimeString().slice(0, 8)
+}
+
+export function formatAt(at, { ago: isAgo = false, now = Date.now() } = {}) {
+  return isAgo ? ago(at, now) : formatTime(at, now)
+}

package/hive-webhook.js

@@ -0,0 +1,54 @@
+// hive-webhook -- one Slack or Discord incoming-webhook URL, and the rule for what may be sent to it.
+//
+// Shared by the GitHub watcher (hive-github.js) and the room notifier (hive-notify.js): the same
+// URL works for both, and the same two promises hold for both.
+//   1. Nothing with a key or token in it leaves: every message is scrubbed first.
+//   2. A notification that fails is logged and dropped, never retried in a loop and never a reason
+//      to stop: it is a courtesy, the work is the point.
+import { findSecrets } from './hive-secrets.js'
+
+/** Every key or token in `text` replaced. Run on everything that goes to GitHub or a webhook. */
+export function scrub(text) {
+  let s = String(text || '')
+  for (const f of findSecrets(s, { tokens: true })) s = s.split(f.value).join(`[${f.kind} removed]`)
+  return s
+}
+
+export function cleanError(e, url) {
+  let s = String(e && (e.message || e) || 'unknown error')
+  if (url) s = s.split(url).join('[webhook url removed]')
+  try {
+    const u = new URL(url)
+    if (u.pathname && u.pathname !== '/') s = s.split(u.pathname).join('[path removed]')
+  } catch { }
+  s = scrub(s)
+  s = s.replace(/Failed to parse URL from .+/i, 'Failed to parse URL')
+  return s
+}
+
+/** `send(text)` resolves true when the webhook took it. Slack wants {text}, Discord {content}; any
+ *  other host gets Slack format ({text}). */
+export function makeNotifier(url, { fetchImpl = globalThis.fetch, log = () => {} } = {}) {
+  if (!url) return async () => false
+  let host = ''
+  try { host = new URL(url).hostname.toLowerCase() } catch { host = '' }
+  const slack = /(^|\.)slack\.com$/.test(host)
+  const discord = /(^|\.)discord(app)?\.com$/.test(host)
+  const kind = discord ? 'discord' : slack ? 'slack' : 'other'
+  const send = async (text) => {
+    const msg = scrub(text)
+    // allowed_mentions: an issue titled "@everyone" must not page a whole Discord server.
+    const body = discord ? { content: msg.slice(0, 1900), allowed_mentions: { parse: [] } } : { text: msg }
+    try {
+      const r = await fetchImpl(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body), signal: AbortSignal.timeout(10000) })
+      if (!r.ok) { log(`notification not delivered: HTTP ${r.status}`); return false }
+      return true
+    } catch (e) {
+      log(`notification not delivered: ${cleanError(e, url)}`)
+      return false
+    }
+  }
+  send.host = host
+  send.kind = kind
+  return send
+}