mixdog 0.7.18 → 0.8.1

package/src/channels/tool-defs.mjs

@@ -1,170 +0,0 @@
-export const TOOL_DEFS = [
-  {
-    name: "reply",
-    title: "Discord Reply",
-    annotations: { title: "Discord Reply", readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
-    description: "Reply on channel.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        chat_id: { type: "string" },
-        text: { type: "string" },
-        reply_to: { type: "string" },
-        files: {
-          type: "array",
-          items: { type: "string" }
-        },
-        embeds: {
-          type: "array",
-          items: { type: "object", additionalProperties: true }
-        },
-        components: {
-          type: "array",
-          items: { type: "object", additionalProperties: true }
-        }
-      },
-      required: ["chat_id", "text"]
-    }
-  },
-  {
-    name: "react",
-    title: "Reaction",
-    annotations: { title: "Reaction", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-    description: "React to message.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        chat_id: { type: "string" },
-        message_id: { type: "string" },
-        emoji: { type: "string" }
-      },
-      required: ["chat_id", "message_id", "emoji"]
-    }
-  },
-  {
-    name: "edit_message",
-    title: "Edit Message",
-    annotations: { title: "Edit Message", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
-    description: "Edit bot message.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        chat_id: { type: "string" },
-        message_id: { type: "string" },
-        text: { type: "string" },
-        embeds: {
-          type: "array",
-          items: { type: "object", additionalProperties: true }
-        },
-        components: {
-          type: "array",
-          items: { type: "object", additionalProperties: true }
-        }
-      },
-      required: ["chat_id", "message_id", "text"]
-    }
-  },
-  {
-    name: "download_attachment",
-    title: "Download Attachment",
-    annotations: { title: "Download Attachment", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-    description: "Download attachments.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        chat_id: { type: "string" },
-        message_id: { type: "string" }
-      },
-      required: ["chat_id", "message_id"]
-    }
-  },
-  {
-    name: "fetch",
-    title: "Fetch",
-    annotations: { title: "Fetch", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-    description: "Discord-only: fetch recent messages from a Discord channel. Requires channel (id); optional limit (count). NOT for URLs or web pages — use web_fetch for those.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        channel: { type: "string" },
-        limit: { type: "number" }
-      },
-      required: ["channel"]
-    }
-  },
-  {
-    name: "schedule_status",
-    title: "Schedule Status",
-    annotations: { title: "Schedule Status", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    description: "Show schedules.",
-    inputSchema: {
-      type: "object",
-      properties: {}
-    }
-  },
-  {
-    name: "trigger_schedule",
-    title: "Trigger Schedule",
-    annotations: { title: "Trigger Schedule", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
-    description: "Run a scheduled task immediately by name (fire it now). Requires name.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        name: { type: "string" }
-      },
-      required: ["name"]
-    }
-  },
-  {
-    name: "schedule_control",
-    title: "Schedule Control",
-    annotations: { title: "Schedule Control", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
-    description: 'Defer or skip a schedule (not run it now): action=defer (push by `minutes`) | skip_today. Requires name + action.',
-    inputSchema: {
-      type: "object",
-      properties: {
-        name: { type: "string" },
-        action: { type: "string", enum: ["defer", "skip_today"] },
-        minutes: { type: "number" }
-      },
-      required: ["name", "action"]
-    }
-  },
-  {
-    name: "activate_channel_bridge",
-    title: "Activate Channel Bridge",
-    annotations: { title: "Activate Channel Bridge", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    description: "Set channel bridge active.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        active: { type: "boolean" }
-      },
-      required: ["active"]
-    }
-  },
-  // memory and recall_memory tools are now provided by memory-service.mjs via MCP
-  {
-    name: "reload_config",
-    title: "Reload Config",
-    annotations: { title: "Reload Config", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    description: "Reload config.",
-    inputSchema: { type: "object", properties: {} }
-  },
-  {
-    name: "inject_command",
-    title: "Inject Claude Code Slash Command",
-    annotations: { title: "Inject Claude Code Slash Command", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
-    description: "Inject slash command.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        command: {
-          type: "string",
-          enum: ["reload-plugins", "clear"]
-        }
-      },
-      required: ["command"]
-    }
-  }
-];

package/src/daemon/host.mjs

@@ -1,118 +0,0 @@
-/**
- * Daemon host — one shared backend process per plugin data dir.
- *
- * `ensureDaemon(dataDir)` is the thin-client entry: connect to a running
- * daemon, or spawn one (serialized so N cold-start terminals don't storm) and
- * connect. `runDaemon(dataDir)` is the daemon process entry: it claims the
- * owner lock (singleton invariant — a loser exits), listens on the shared pipe,
- * and serves every connected client.
- *
- * The daemon process delegates per-session request routing to
- * `serveDaemon` in server-main.mjs, so each connection is a real
- * Claude Code session.
- *
- * Ownership is the owner lock + pipe ownership, both liveness-based (ESRCH ⇒
- * dead). No time-boxed "run anyway" escape: a loser attaches or exits.
- */
-import { spawn } from 'child_process'
-import * as fs from 'fs'
-import * as path from 'path'
-import * as os from 'os'
-import { fileURLToPath } from 'url'
-import { connect } from './transport.mjs'
-
-const __filename = fileURLToPath(import.meta.url)
-// The daemon BODY lives in server-main (reached via `server.mjs --daemon`); the
-// host only spawns it and connects clients. server.mjs is two levels up from
-// src/daemon/. Pipe ownership (transport.listen → null) is the singleton arbiter.
-const SERVER_ENTRY = path.join(path.dirname(__filename), '..', '..', 'server.mjs')
-const RUNTIME_ROOT = process.env.MIXDOG_RUNTIME_ROOT || path.join(os.tmpdir(), 'mixdog')
-
-function pidAlive(pid) {
-  if (!Number.isFinite(pid) || pid <= 0) return false
-  try { process.kill(pid, 0); return true }
-  catch (e) { return e.code !== 'ESRCH' } // ESRCH ⇒ dead; EPERM/other ⇒ alive
-}
-
-function lockDir(dataDir) {
-  const dir = dataDir && dataDir.length ? dataDir : RUNTIME_ROOT
-  try { fs.mkdirSync(dir, { recursive: true }) } catch {}
-  return dir
-}
-const spawnLockPath = (dataDir) => path.join(lockDir(dataDir), '.daemon-spawn.lock')
-
-// Atomic create-or-fail lock holding our pid. Reclaims a lock whose holder pid
-// is dead. Returns true if we now hold it.
-function tryAcquireLock(file) {
-  for (let attempt = 0; attempt < 2; attempt++) {
-    try {
-      fs.writeFileSync(file, String(process.pid), { flag: 'wx' })
-      return true
-    } catch (e) {
-      if (e.code !== 'EEXIST') return false
-      let holder = 0
-      try { holder = Number(fs.readFileSync(file, 'utf8')) } catch {}
-      if (holder === process.pid) return true
-      if (pidAlive(holder)) return false
-      try { fs.unlinkSync(file) } catch {} // stale holder dead — reclaim and retry
-    }
-  }
-  return false
-}
-function releaseLock(file) {
-  try {
-    if (Number(fs.readFileSync(file, 'utf8')) === process.pid) fs.unlinkSync(file)
-  } catch {}
-}
-
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
-
-// Poll-connect until a daemon is listening or the budget expires.
-async function waitForDaemon(dataDir, budgetMs) {
-  const deadline = Date.now() + budgetMs
-  for (;;) {
-    try { return await connect(dataDir, { timeoutMs: 1000 }) } catch {}
-    if (Date.now() >= deadline) throw new Error('daemon did not come up within budget')
-    await sleep(150)
-  }
-}
-
-function spawnDaemonProcess(dataDir) {
-  const child = spawn(process.env.BUN_EXEC_PATH || process.execPath, [SERVER_ENTRY, '--daemon', dataDir], {
-    detached: true,
-    stdio: 'ignore',
-    env: { ...process.env, MIXDOG_DAEMON_MODE: '1', MIXDOG_DAEMON_DATA_DIR: dataDir },
-    ...(process.platform === 'win32' ? { windowsHide: true } : {}),
-  })
-  child.unref()
-  return child
-}
-
-// Thin-client entry: return a framed connection to the shared daemon, spawning
-// it if needed. Spawning is serialized via the spawn lock so N co-booting
-// terminals produce one daemon; the owner lock inside runDaemon is the final
-// singleton arbiter if two ever race through.
-export async function ensureDaemon(dataDir) {
-  const deadline = Date.now() + 30000 // final safety bound, not the recovery path
-  for (;;) {
-    // 1) Already running?
-    try { return await connect(dataDir, { timeoutMs: 1200 }) } catch {}
-    // 2) Become the spawner. tryAcquireLock reclaims a DEAD holder, so a
-    //    spawner that died before its daemon listened is recovered here on the
-    //    next pass — liveness-based, not a fixed wait that wedges all waiters.
-    const spawnLock = spawnLockPath(dataDir)
-    if (tryAcquireLock(spawnLock)) {
-      try {
-        spawnDaemonProcess(dataDir)
-        return await waitForDaemon(dataDir, 30000)
-      } finally {
-        releaseLock(spawnLock)
-      }
-    }
-    // 3) A live client is spawning — briefly wait for its pipe, then loop back
-    //    to retry both (1) connect and (2) dead-holder reclaim.
-    try { return await connect(dataDir, { timeoutMs: 800 }) } catch {}
-    if (Date.now() >= deadline) throw new Error('daemon did not come up within budget')
-    await sleep(150)
-  }
-}

package/src/daemon/mcp-transport.mjs

@@ -1,47 +0,0 @@
-/**
- * MCP Transport adapter over a daemon framed connection.
- *
- * Lets the daemon hand each accepted client connection to its own MCP SDK
- * `Server` instance, so the SDK does protocol-correct initialize / capabilities
- * / tools negotiation per connection while we only supply the wire. The SDK
- * `Transport` contract is minimal: start / send / close + onmessage / onclose /
- * onerror. Our framed connection already speaks NDJSON JSON-RPC objects, so the
- * adapter is a thin pass-through.
- */
-export class FramedServerTransport {
-  constructor(conn, opts = {}) {
-    this._conn = conn
-    // Out-of-band control-frame sink (session-identity handshake). Control
-    // frames carry a `__mixdog` marker, no jsonrpc, and must NOT reach the SDK.
-    this._onControl = typeof opts.onControl === 'function' ? opts.onControl : null
-    this._started = false
-    // SDK assigns these before/after start(); call them if present.
-    this.onmessage = undefined
-    this.onclose = undefined
-    this.onerror = undefined
-  }
-
-  async start() {
-    if (this._started) return
-    this._started = true
-    this._conn.onMessage((msg) => {
-      if (msg && msg.__mixdog) {
-        try { this._onControl?.(msg) } catch (e) { this.onerror?.(e) }
-        return
-      }
-      try { this.onmessage?.(msg) }
-      catch (e) { this.onerror?.(e) }
-    })
-    this._conn.onClose(() => {
-      try { this.onclose?.() } catch {}
-    })
-  }
-
-  async send(message) {
-    this._conn.send(message)
-  }
-
-  async close() {
-    this._conn.close()
-  }
-}

package/src/daemon/session.mjs

@@ -1,100 +0,0 @@
-/**
- * Per-connection Session — the unit of isolation in the shared daemon.
- *
- * Today `server-main` is one process per Claude Code terminal, so session
- * identity (sessionId, cwd, transcript, instanceId, lead pid) lives in process
- * globals / env (`SESSION_ID`, `MIXDOG_SESSION_CWD`, …). In the daemon, one
- * process serves N terminals, so that state must move OFF process globals and
- * onto a Session keyed by the client connection. `cwd` is the highest-risk
- * field: it is mutable (the `cwd` tool changes it) and must never leak from one
- * client to another — the old `MIXDOG_SESSION_CWD` env is replaced by
- * `session.cwd`, threaded per call into `dispatchTool` and worker payloads.
- *
- * Identity-only and install/process-scoped state (shared DB, plugin config,
- * the single memory/channels services) deliberately stays OUT of Session.
- */
-
-import { _safeProcessCwd } from '../shared/user-cwd.mjs'
-
-// Fields a thin client sends in its `initialize` handshake. Everything is
-// optional so a minimal client still gets a usable session.
-//   { sessionId, cwd, transcriptPath, leadPid, instanceId, env }
-export class Session {
-  constructor(conn, init = {}) {
-    this.conn = conn
-    this.sessionId = init.sessionId || null
-    // Mutable per-session working dir. Resolution order at call time:
-    //   session.cwd ?? init default ?? process.cwd(). NEVER read a global env.
-    this.cwd = init.cwd || null
-    // Optional live cwd resolver. The boot session (single stdio client) sets
-    // this to pwd() so it keeps tracking the legacy MIXDOG_SESSION_CWD env and
-    // stays behaviour-identical; daemon sessions leave it null and own a static
-    // per-connection `cwd` instead.
-    this.cwdFn = typeof init.cwdFn === 'function' ? init.cwdFn : null
-    // Optional write-side hook for cwd. The boot session points this at the
-    // legacy MIXDOG_SESSION_CWD env (which cwdFn=pwd reads back); daemon
-    // sessions leave it null and `setCwd` mutates this.cwd directly.
-    this.setCwdFn = typeof init.setCwdFn === 'function' ? init.setCwdFn : null
-    this.transcriptPath = init.transcriptPath || null
-    this.leadPid = Number.isFinite(init.leadPid) ? init.leadPid : null
-    this.clientHostPid = Number.isFinite(init.clientHostPid) ? init.clientHostPid : null
-    // Per-session runtime seat (was server.mjs `instanceId` = process.pid).
-    this.instanceId = init.instanceId || init.sessionId || null
-    // Opaque per-session scratch for state that is process-global today and
-    // gets migrated incrementally (lead guard, recent-bash tracker, recap
-    // status). Keyed by feature name so each wiring step claims its own slot
-    // without widening this constructor.
-    this.scratch = new Map()
-    this.createdAt = init.now ?? null // stamped by caller; daemon avoids Date.now at construct
-  }
-
-  // The cwd a tool call should resolve against. Falls back to the process cwd
-  // only when the session never advertised one (never another session's cwd).
-  resolveCwd() {
-    // Fallback uses _safeProcessCwd(), NOT captureOriginalUserCwd(): a daemon
-    // serves N terminals, so the fallback must consult NO per-session signal
-    // (MIXDOG_SESSION_CWD / user-cwd.txt) — that would leak one terminal's cwd
-    // into another. _safeProcessCwd() reads only the install-scoped
-    // CLAUDE_PLUGIN_ROOT to guard the daemon-launch-dir == plugin-cache case
-    // down to homedir(), surfacing a missing cwd as ENOENT (absolute paths
-    // required) instead of a silent stale read under the plugin cache.
-    return (this.cwdFn ? this.cwdFn() : this.cwd) || _safeProcessCwd()
-  }
-
-  // Per-session cwd write (the `cwd set` tool). The boot session routes to its
-  // legacy env via setCwdFn so cwdFn=pwd keeps reading it; daemon sessions
-  // store it on the session so one terminal's cwd never leaks into another.
-  setCwd(value) {
-    if (this.setCwdFn) this.setCwdFn(value)
-    else this.cwd = value
-  }
-}
-
-/**
- * Registry of live sessions keyed by connection. One Session per connection;
- * a reconnecting client (daemon restart) re-initializes and gets a fresh
- * Session carrying the same sessionId (resume semantics land with M4 reconnect).
- */
-export class SessionRegistry {
-  constructor() {
-    this._byConn = new Map()
-  }
-
-  open(conn, init) {
-    const session = new Session(conn, init)
-    this._byConn.set(conn, session)
-    return session
-  }
-
-  get(conn) {
-    return this._byConn.get(conn) || null
-  }
-
-  close(conn) {
-    this._byConn.delete(conn)
-  }
-
-  get size() {
-    return this._byConn.size
-  }
-}

package/src/daemon/thin-client.mjs

@@ -1,71 +0,0 @@
-/**
- * Thin client — bridges one Claude Code terminal's stdio to the shared daemon.
- *
- * Every per-terminal `server.mjs` invocation (spawned by run-mcp) runs this
- * instead of the heavy in-process backend. It connects to the shared daemon
- * (spawning it if needed) and pipes NDJSON JSON-RPC both ways: run-mcp/CC stdin
- * → daemon, daemon → stdout. When the daemon connection drops, the thin client
- * exits; run-mcp then respawns this server.mjs (which re-attaches or re-spawns
- * the daemon), reusing run-mcp's existing initialize cache/replay.
- *
- * Session identity is advertised out-of-band via a `__mixdog` control frame
- * that the daemon transport filters BEFORE the MCP SDK sees it, so it has no
- * ordering dependency on the MCP initialize handshake.
- */
-import { ensureDaemon } from './host.mjs'
-import { explicitSessionCwd, readLastSessionCwd } from '../shared/user-cwd.mjs'
-
-export async function runThinClient(dataDir) {
-  const conn = await ensureDaemon(dataDir)
-
-  // daemon → CC (stdout)
-  conn.onMessage((msg) => {
-    try { process.stdout.write(JSON.stringify(msg) + '\n') } catch {}
-  })
-  // daemon gone → exit so run-mcp respawns us and we re-attach/re-spawn it
-  conn.onClose(() => process.exit(0))
-
-  // Advertise this terminal's identity (filtered out-of-band on the daemon).
-  try {
-    const rawLeadPid = Number(process.env.MIXDOG_SUPERVISOR_PID)
-    const leadPid = Number.isFinite(rawLeadPid) && rawLeadPid > 0 ? rawLeadPid : undefined
-    const hasEnvSessionCwd = typeof process.env.MIXDOG_SESSION_CWD === 'string' && process.env.MIXDOG_SESSION_CWD.length > 0
-    const advertisedCwd = hasEnvSessionCwd
-      ? (explicitSessionCwd() || readLastSessionCwd(leadPid) || undefined)
-      : (readLastSessionCwd(leadPid) || explicitSessionCwd() || undefined)
-    conn.send({
-      __mixdog: 'session',
-      sessionId: process.env.MIXDOG_SESSION_ID || undefined,
-      // Advertise an explicit session cwd so the daemon Session never falls
-      // back to its own process.cwd() (the plugin CACHE dir), which would make
-      // every bridge worker resolve paths under ...\plugins\cache\...\<ver>.
-      // explicitSessionCwd() = MIXDOG_SESSION_CWD (if it exists) ?? user-cwd.txt
-      // (rewritten every session start); it NEVER returns process.cwd().
-      cwd: advertisedCwd,
-      leadPid,
-      transcriptPath: process.env.MIXDOG_TRANSCRIPT_PATH || undefined,
-      clientHostPid: Number(process.env.MIXDOG_OWNER_HOST_PID) || undefined,
-    })
-  } catch {}
-
-  // CC/run-mcp (stdin, NDJSON) → daemon
-  let buf = ''
-  process.stdin.setEncoding('utf8')
-  process.stdin.on('data', (chunk) => {
-    buf += chunk
-    let nl
-    while ((nl = buf.indexOf('\n')) >= 0) {
-      const line = buf.slice(0, nl)
-      buf = buf.slice(nl + 1)
-      if (!line) continue
-      let obj
-      try { obj = JSON.parse(line) } catch { continue }
-      conn.send(obj)
-    }
-  })
-  process.stdin.on('end', () => process.exit(0))
-  process.stdin.on('close', () => process.exit(0))
-
-  // Keep the process alive; the pipes drive everything.
-  await new Promise(() => {})
-}

package/src/daemon/transport.mjs

@@ -1,163 +0,0 @@
-/**
- * Daemon transport — NDJSON JSON-RPC over a per-data-dir named pipe.
- *
- * Replaces the per-terminal `run-mcp ↔ server.mjs` stdio link with a single
- * shared endpoint: one daemon process listens; N thin clients (one per Claude
- * Code terminal) connect. This module is PURE transport — framing, accept,
- * connect, liveness. It carries no session or JSON-RPC semantics; the daemon
- * host layers those on top via the `onConnection` callback.
- *
- * Pipe ownership is the singleton primitive: on Windows a second `listen()`
- * fails with EADDRINUSE, on Unix we probe-then-unlink. `listen()` returning
- * null means "a live daemon already owns this pipe — attach as a client".
- */
-import net from 'net'
-import { createHash } from 'crypto'
-import { unlinkSync, mkdirSync } from 'fs'
-import path from 'path'
-import os from 'os'
-
-// Inbound frame guardrail (mirrors run-mcp's MAX_LINE_BYTES). A JSON-RPC line
-// is newline-terminated; an unterminated line growing past this cap signals a
-// runaway producer. 4 MB comfortably fits any legitimate tool result.
-const MAX_LINE_BYTES = 4 * 1024 * 1024
-
-const RUNTIME_ROOT = process.env.MIXDOG_RUNTIME_ROOT || path.join(os.tmpdir(), 'mixdog')
-
-// One pipe per plugin data dir so distinct installs / data dirs never collide.
-function daemonPipePath(dataDir) {
-  const hash = createHash('sha1').update(String(dataDir || 'default')).digest('hex').slice(0, 12)
-  if (process.platform === 'win32') return `\\\\.\\pipe\\mixdog-daemon-${hash}`
-  return path.join(RUNTIME_ROOT, `mixdog-daemon-${hash}.sock`)
-}
-
-// Wrap a net.Socket in NDJSON framing. `send(obj)` writes one JSON line;
-// `onMessage(cb)` fires per parsed object; `onClose(cb)` fires once on
-// socket end/error. Non-JSON lines are dropped (never throw on the socket).
-function frameConnection(socket) {
-  let buf = ''
-  let closed = false
-  const msgHandlers = []
-  const closeHandlers = []
-  socket.setEncoding('utf8')
-  socket.on('data', (chunk) => {
-    buf += chunk
-    let nl
-    while ((nl = buf.indexOf('\n')) >= 0) {
-      const line = buf.slice(0, nl)
-      buf = buf.slice(nl + 1)
-      if (!line) continue
-      let obj
-      try { obj = JSON.parse(line) } catch { continue }
-      for (const h of msgHandlers) { try { h(obj) } catch (e) { try { process.stderr.write(`[transport] message handler failed: ${e?.message ?? e}\n`) } catch {} } }
-    }
-    if (buf.length > MAX_LINE_BYTES) {
-      // Runaway unterminated frame — drop the connection rather than grow
-      // unbounded. A well-behaved peer never produces a 4 MB line without a \n.
-      try { socket.destroy() } catch {}
-    }
-  })
-  const fireClose = () => {
-    if (closed) return
-    closed = true
-    for (const h of closeHandlers) { try { h() } catch {} }
-  }
-  socket.on('close', fireClose)
-  socket.on('error', fireClose)
-  return {
-    socket,
-    send(obj) {
-      if (closed) return false
-      try { return socket.write(JSON.stringify(obj) + '\n') } catch { return false }
-    },
-    onMessage(cb) { msgHandlers.push(cb) },
-    onClose(cb) { closeHandlers.push(cb) },
-    close() { try { socket.end() } catch {} },
-    get closed() { return closed },
-  }
-}
-
-// Start the daemon endpoint. Resolves the net.Server on success, or `null`
-// when another live daemon already owns the pipe (this process must attach as
-// a client instead). `onConnection(conn)` is invoked with a framed connection
-// per accepted client.
-export async function listen({ dataDir, onConnection }) {
-  const pipePath = daemonPipePath(dataDir)
-  if (process.platform !== 'win32') {
-    // Unix domain sockets need the parent dir to exist; RUNTIME_ROOT may not.
-    try { mkdirSync(path.dirname(pipePath), { recursive: true }) } catch {}
-  }
-  // Fresh server per attempt: a net.Server that emitted 'error' cannot be
-  // re-listened reliably, so the Unix retry below recreates it each time.
-  const attempt = () => new Promise((resolve, reject) => {
-    const server = net.createServer((socket) => {
-      try { onConnection(frameConnection(socket)) } catch {}
-    })
-    const onErr = (e) => { server.removeListener('listening', onOk); reject(e) }
-    const onOk = () => { server.removeListener('error', onErr); resolve(server) }
-    server.once('error', onErr)
-    server.once('listening', onOk)
-    server.listen(pipePath)
-  })
-  if (process.platform === 'win32') {
-    // Windows named pipes reject a second listener with EADDRINUSE on their own,
-    // so no pre-listen probe is needed.
-    try { return await attempt() }
-    catch (e) { if (isAddrInUse(e)) return null; throw e }
-  }
-  // Unix: a leftover socket file from a crashed daemon makes bind fail with
-  // EADDRINUSE. Only unlink when a probe says nothing answers — and re-probe
-  // after every failed bind, so if a sibling rebinds in the probe→unlink
-  // window we see it alive on the next pass and attach instead of stealing it.
-  // (runDaemon calls this under the owner lock, which already serializes
-  // dataDir entry; this loop closes the residual TOCTOU window.)
-  for (let i = 0; i < 3; i++) {
-    try { return await attempt() }
-    catch (e) {
-      if (!isAddrInUse(e)) throw e
-      if (await probeAlive(pipePath)) return null
-      try { unlinkSync(pipePath) } catch {}
-    }
-  }
-  return null
-}
-
-// Connect to an existing daemon. Resolves a framed connection or rejects
-// (ENOENT / ECONNREFUSED when no daemon is listening, or on timeout).
-export function connect(dataDir, { timeoutMs = 2000 } = {}) {
-  const pipePath = daemonPipePath(dataDir)
-  return new Promise((resolve, reject) => {
-    const socket = net.connect(pipePath)
-    const timer = setTimeout(() => {
-      try { socket.destroy() } catch {}
-      reject(new Error('daemon connect timeout'))
-    }, timeoutMs)
-    socket.once('connect', () => { clearTimeout(timer); resolve(frameConnection(socket)) })
-    socket.once('error', (e) => { clearTimeout(timer); reject(e) })
-  })
-}
-
-function isAddrInUse(e) {
-  const msg = String(e?.message || e || '')
-  return e?.code === 'EADDRINUSE' || msg.includes('EADDRINUSE') || msg.includes('Failed to listen')
-}
-
-// Resolves true if something is listening on the pipe (daemon alive), false on
-// ECONNREFUSED / ENOENT (dead/absent). Other errors / timeout resolve true so
-// we err on NOT stealing a possibly-live peer's socket.
-function probeAlive(pipePath) {
-  return new Promise((resolve) => {
-    let done = false
-    const finish = (alive) => {
-      if (done) return
-      done = true
-      try { c.destroy() } catch {}
-      clearTimeout(t)
-      resolve(alive)
-    }
-    const c = net.connect(pipePath)
-    const t = setTimeout(() => finish(true), 500)
-    c.once('connect', () => finish(true))
-    c.once('error', (e) => finish(!(e?.code === 'ECONNREFUSED' || e?.code === 'ENOENT')))
-  })
-}