mixdog 0.9.3 → 0.9.5

package/src/runtime/channels/lib/session-discovery.mjs

@@ -6,6 +6,35 @@ import { mixdogHome } from "../../shared/plugin-paths.mjs";
 function cwdToProjectSlug(cwd) {
   return resolve(cwd).replace(/\\/g, "/").replace(/^([A-Za-z]):/, "$1-").replace(/\//g, "-");
 }
+// Parent of a live pid never changes for the lifetime of that pid, so a
+// resolved (non-null) parent is cached forever. A null result (pid gone /
+// lookup failed) is cached briefly so a burst of calls during process exit
+// doesn't re-spawn powershell.exe on every tick, but still allows retry.
+// A cached null is only trusted while the pid itself is DEAD: if the pid is
+// still alive, a null parent was a transient lookup failure (e.g. powershell
+// hiccup), and serving it from cache would make every retry inside the
+// first-inbound steal poll (50ms x 500ms window) reuse the failure and time
+// out to the stale binding. Live pid + cached null = treat as cache miss.
+const parentPidCache = new Map(); // pid -> { value: number|null, expiresAt: number|null }
+const NULL_PARENT_TTL_MS = 30_000;
+
+function _pidAlive(pid) {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+function getParentPidCached(pid, fresh = false) {
+  const cached = parentPidCache.get(pid);
+  if (!fresh && cached && (cached.expiresAt === null || cached.expiresAt > Date.now())) {
+    if (cached.value !== null || !_pidAlive(pid)) return cached.value;
+    // fall through: live pid with cached-null parent → retry fresh lookup
+  }
+  if (fresh && cached && cached.expiresAt === null) return cached.value; // resolved parent never changes
+  const value = getParentPid(pid);
+  parentPidCache.set(pid, {
+    value,
+    expiresAt: value === null ? Date.now() + NULL_PARENT_TTL_MS : null
+  });
+  return value;
+}
 function getParentPid(pid) {
   try {
     if (process.platform === "win32") {
@@ -67,12 +96,35 @@ function isInteractiveSession(session) {
   if (!session) return false;
   return session.kind === "interactive" || !session.kind && session.entrypoint === "cli";
 }
-function discoverCurrentClaudeSession() {
-  let pid = process.ppid;
+// Full parent-PID walk result cached per process.ppid for a short TTL so
+// rapid-fire inbound messages / watchDebounce ticks don't repeat the walk.
+// A cache hit still re-verifies the session file exists (cheap fs read)
+// before being trusted, so staleness is bounded by readSessionRecord truth,
+// not just the TTL. Null (no session found) is intentionally NOT cached:
+// right after channel activate the parent session record may not exist yet,
+// and negative-caching would delay the first transcript steal by up to the
+// TTL. Re-walking on miss is cheap because parentPidCache makes the walk
+// spawn-free.
+const sessionWalkCache = new Map(); // ppid -> { session, expiresAt }
+const SESSION_WALK_TTL_MS = 10_000;
+
+function discoverCurrentClaudeSession(options = {}) {
+  const fresh = options.fresh === true;
+  const rootPid = process.ppid;
+  const cached = fresh ? undefined : sessionWalkCache.get(rootPid);
+  if (cached && cached.expiresAt > Date.now()) {
+    const reverified = readSessionRecord(cached.session.pid);
+    if (reverified) return reverified;
+    sessionWalkCache.delete(rootPid);
+  }
+  let pid = rootPid;
   for (let depth = 0; pid && pid > 1 && depth < 6; depth += 1) {
     const session = readSessionRecord(pid);
-    if (session) return session;
-    pid = getParentPid(pid);
+    if (session) {
+      sessionWalkCache.set(rootPid, { session, expiresAt: Date.now() + SESSION_WALK_TTL_MS });
+      return session;
+    }
+    pid = getParentPidCached(pid, fresh);
   }
   return null;
 }

package/src/runtime/channels/lib/tool-dispatch.mjs

@@ -0,0 +1,158 @@
+import { OutputForwarder } from "./output-forwarder.mjs";
+
+// Worker/HTTP tool-call dispatch + bridge auto-connect retry wrapper.
+// Extracted verbatim from channels/index.mjs (behavior-preserving). The
+// `handleToolCall` switch is entangled with ~8 runtime-lifecycle functions
+// (claim/refresh ownership, stop owned runtime, transcript rebind, config
+// reload) plus mutable owner state (channelBridgeActive, bridgeRuntimeConnected)
+// and the forwarder. Those are threaded in as a `lifecycle` bag of lazy
+// getters/functions so the module reads the live file-level references at
+// call time — matching the original in-file closure semantics.
+function createToolDispatch({
+  getForwarder,
+  BACKEND_TOOLS,
+  isChannelsDegraded,
+  dispatchReply,
+  dispatchFetch,
+  lifecycle,
+}) {
+  const {
+    getBridgeRuntimeConnected,
+    getChannelBridgeActive,
+    setChannelBridgeActive,
+    writeBridgeState,
+    stopServerTyping,
+    claimBridgeOwnership,
+    refreshBridgeOwnership,
+    bindPersistedTranscriptIfAny,
+    stopOwnedRuntime,
+    reloadRuntimeConfig,
+  } = lifecycle;
+
+  async function handleToolCall(name, args, _signal) {
+    if (isChannelsDegraded()) {
+      return { content: [{ type: 'text', text: `[channels degraded] ${name} unavailable — restart MCP to recover` }], isError: true }
+    }
+    let result;
+    try {
+      switch (name) {
+        case "reply":
+          result = await dispatchReply(args);
+          break;
+        case "fetch":
+          result = await dispatchFetch(args);
+          break;
+        case "activate_channel_bridge": {
+            const active = args.active === true;
+            const wasActive = getChannelBridgeActive();
+            setChannelBridgeActive(active);
+            writeBridgeState(active);
+            if (active) {
+              // Force-takeover semantics: activation ALWAYS claims the seat
+              // (last-wins overwrite of active-instance.json) and refreshes the
+              // output-forwarder binding onto THIS session — even when the
+              // bridge was already active. `/remote` relies on this to re-occupy
+              // after another session stole ownership, and to re-pin forwarding
+              // to the current session transcript.
+              claimBridgeOwnership(wasActive ? "re-activate takeover" : "bridge activated");
+              try {
+                await refreshBridgeOwnership({ restoreBinding: true });
+                // An already-connected owner returns early from
+                // startOwnedRuntime(), so rebind explicitly to follow the
+                // current (parent-chain) session transcript.
+                if (getBridgeRuntimeConnected()) await bindPersistedTranscriptIfAny();
+              } catch (e) {
+                process.stderr.write(`mixdog: bridge activate refresh failed (non-fatal): ${e?.message || e}\n`);
+              }
+            }
+            if (!active && wasActive) {
+              stopServerTyping();
+              // Tear down the owner-side runtime so Discord/scheduler/webhook/
+              // event-pipeline don't keep running on a deactivated bridge.
+              try { await stopOwnedRuntime("bridge deactivated"); } catch (e) {
+                process.stderr.write(`mixdog: stopOwnedRuntime on deactivate failed: ${e?.message || e}\n`);
+              }
+            }
+            result = { content: [{ type: "text", text: `channel bridge ${active ? "activated" : "deactivated"}` }] };
+            break;
+          }
+        case "reload_config": {
+            await reloadRuntimeConfig();
+            // Extend reload to the agent module so providers/presets/maintenance
+            // hot-reload on the same call (dynamic import: agent/index.mjs does not
+            // import channels, so this stays acyclic and tolerant of load order).
+            let agentReloadMsg = "";
+            if (process.env.MIXDOG_STANDALONE !== '1') {
+              try {
+                const { reloadAgentConfig } = await import("../../agent/index.mjs");
+                await reloadAgentConfig("reload_config tool");
+                agentReloadMsg = ", agent providers/presets/maintenance";
+              } catch (err) {
+                process.stderr.write(`[reload_config] agent reload failed: ${err?.message || String(err)}\n`);
+              }
+            }
+            result = { content: [{ type: "text", text: `config reloaded — schedules, webhooks, events${agentReloadMsg} re-registered` }] };
+            break;
+          }
+        // memory — handled by memory-service.mjs MCP
+        default:
+            result = {
+              content: [{ type: "text", text: `unknown tool: ${name}` }],
+              isError: true
+            };
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      result = {
+        content: [{ type: "text", text: `${name} failed: ${msg}` }],
+        isError: true
+      };
+    }
+    return result;
+  }
+
+  // Bridge auto-connect retry + forwarder-aware tool dispatch wrapper. Used by
+  // both the HTTP MCP path (createHttpMcpServer's CallTool handler can call this)
+  // and the worker IPC handler at the bottom of index.mjs.
+  // Last timestamp a forwardNewText() call was dispatched (debounce for item 4).
+  let _lastForwardMs = 0;
+
+  async function handleToolCallWithBridgeRetry(toolName, args, signal) {
+    const forwarder = getForwarder();
+    // Debounce: only forward when ≥250 ms have elapsed since the last forward,
+    // to avoid one HTTP roundtrip per tool call on rapid-fire sequences.
+    const now = Date.now();
+    if (now - _lastForwardMs >= 250) {
+      _lastForwardMs = now;
+      await forwarder.forwardNewText();
+    }
+    if (BACKEND_TOOLS.has(toolName) && !getBridgeRuntimeConnected()) {
+      // Remote-owner startup: ensure this owner's backend is connected.
+      for (let i = 0; i < 2 && !getBridgeRuntimeConnected(); i++) {
+        try {
+          await refreshBridgeOwnership();
+        } catch {
+        }
+        if (!getBridgeRuntimeConnected()) await new Promise((r) => setTimeout(r, 300));
+      }
+      if (!getBridgeRuntimeConnected()) {
+        return {
+          content: [{ type: "text", text: `Discord auto-connect failed after retries. Check token and network.` }],
+          isError: true
+        };
+      }
+    }
+    const result = await handleToolCall(toolName, args, signal);
+    const toolLine = OutputForwarder.buildToolLine(toolName, args);
+    if (toolLine) {
+      // Distinct from the dispatch-log ok line (server-main.mjs): this forwards
+      // a human-readable tool summary to Discord for the user, not operator stdout.
+      void forwarder.forwardToolLog(toolLine, toolName, args);
+    }
+    return result;
+  }
+
+  return { handleToolCall, handleToolCallWithBridgeRetry };
+}
+
+export { createToolDispatch };

package/src/runtime/channels/lib/tool-format.mjs

@@ -42,7 +42,7 @@ function isMemoryFile(filePath) {
 function isHidden(name) {
   if (HIDDEN_TOOLS.has(name)) return true;
   if (formatToolSurface(name, {}).label === "Memory") return false;
-  if (name === "reply" || name === "react" || name === "edit_message" || name === "fetch" || name === "download_attachment") return true;
+  if (name === "reply" || name === "fetch") return true;
   return false;
 }
 /**

package/src/runtime/channels/lib/transcript-discovery.mjs

@@ -174,7 +174,7 @@ function compareTranscriptCandidates(left, right) {
   if (right.startedAt !== left.startedAt) return right.startedAt - left.startedAt;
   return (right.claudePid ?? 0) - (left.claudePid ?? 0);
 }
-function detectCurrentSessionTranscript() {
+function detectCurrentSessionTranscript(options = {}) {
   const candidates = [];
   const seen = new Set();
   const addCandidate = (candidate) => {
@@ -185,7 +185,7 @@ function detectCurrentSessionTranscript() {
     seen.add(key);
     candidates.push(candidate);
   };
-  addCandidate(sessionTranscriptCandidate(discoverCurrentClaudeSession(), "parent-chain"));
+  addCandidate(sessionTranscriptCandidate(discoverCurrentClaudeSession(options), "parent-chain"));
   for (const session of listInteractiveClaudeSessions()) {
     addCandidate(sessionTranscriptCandidate(session, "sessions-dir"));
   }
@@ -193,8 +193,8 @@ function detectCurrentSessionTranscript() {
   candidates.sort(compareTranscriptCandidates);
   return candidates[0] ?? null;
 }
-function discoverSessionBoundTranscript() {
-  return detectCurrentSessionTranscript();
+function discoverSessionBoundTranscript(options = {}) {
+  return detectCurrentSessionTranscript(options);
 }
 
 export {

package/src/runtime/channels/lib/voice-runtime-fetcher.mjs

@@ -178,13 +178,16 @@ async function _withInstallLock(rootDir, lockName, fn, { pollMs = 250 } = {}) {
 }
 
 async function loadManifest(dataDir) {
+  // Bundled manifest FIRST: it always matches the installed mixdog version.
+  // A stale cached manifest.json from an older install must never shadow it
+  // (caused sha256 mismatches on already-installed machines after upgrades).
+  if (existsSync(BUNDLED_MANIFEST_PATH)) {
+    return JSON.parse(readFileSync(BUNDLED_MANIFEST_PATH, 'utf8'))
+  }
   const cachedPath = join(dataDir, 'voice-runtime', 'manifest.json')
   if (existsSync(cachedPath)) {
     try { return JSON.parse(readFileSync(cachedPath, 'utf8')) } catch {}
   }
-  if (existsSync(BUNDLED_MANIFEST_PATH)) {
-    return JSON.parse(readFileSync(BUNDLED_MANIFEST_PATH, 'utf8'))
-  }
   const res = await fetch(MANIFEST_URL, { signal: AbortSignal.timeout(30_000) })
   if (!res.ok) throw new Error(`[voice-runtime] manifest fetch failed: ${res.status} ${res.statusText}`)
   const manifest = await res.json()

package/src/runtime/channels/lib/voice-transcription.mjs

@@ -0,0 +1,179 @@
+import { spawn } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { createRequire } from "module";
+import { resolveVoiceRuntime } from "./voice-runtime-fetcher.mjs";
+import { ensureReady, transcribe } from "./whisper-server.mjs";
+import { normalizeWhisperLanguage, detectDeviceLanguage } from "./whisper-language.mjs";
+
+const _require = createRequire(import.meta.url);
+
+// Voice-attachment transcription pipeline. Extracted verbatim from
+// channels/index.mjs (behavior-preserving). `config` is read live through the
+// injected getter so runtime config reloads (reloadRuntimeConfig) keep the
+// same semantics as the original file-level `let config` reference.
+function isVoiceAttachment(contentType) {
+  if (typeof contentType !== 'string') return false;
+  const ct = contentType.toLowerCase();
+  return ct.startsWith("audio/") || ct.startsWith("application/ogg");
+}
+
+function runCmd(cmd, args, capture = false) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(cmd, args, {
+      stdio: capture ? ["ignore", "pipe", "ignore"] : "ignore",
+      windowsHide: true
+    });
+    let out = "";
+    if (capture && proc.stdout) proc.stdout.on("data", (d) => {
+      out += d;
+    });
+    proc.on("close", (code) => code === 0 ? resolve(out) : reject(new Error(`${cmd} exit ${code}`)));
+    proc.on("error", reject);
+  });
+}
+
+// Creates the voice-transcription surface bound to a live config getter and
+// data dir. Returns { isVoiceAttachment, transcribeVoice }.
+function createVoiceTranscription({ getConfig, dataDir }) {
+  // ── voice.transcription concurrency queue (max=1 by default, config-driven) ──
+  const _voiceTranscriptionQueue = (() => {
+    let running = 0;
+    const pending = [];
+    function drain() {
+      const limit = getConfig().voice?.transcription?.maxConcurrency ?? 1;
+      while (running < limit && pending.length > 0) {
+        const { fn, resolve, reject } = pending.shift();
+        running++;
+        fn().then(resolve, reject).finally(() => { running--; drain(); });
+      }
+    }
+    return function enqueue(fn) {
+      return new Promise((resolve, reject) => { pending.push({ fn, resolve, reject }); drain(); });
+    };
+  })();
+
+  // ── wav + transcript cache keyed by attachment id ──
+  const _voiceWavCache = new Map();        // attachmentId → wavPath
+  const _voiceTranscriptCache = new Map(); // attachmentId → transcript string
+  const _voiceInflight = new Map();        // attachmentId → Promise<string|null>
+  const _voiceFfmpegInflight = new Map();  // attachmentId|wavPath → Promise<void> single-flight ffmpeg
+
+  async function _probeAudioDurationSec(filePath) {
+    try {
+      const ffprobePath = (() => { try { return _require('ffprobe-static').path; } catch { return 'ffprobe'; } })();
+      return await new Promise((resolve, reject) => {
+        const args = ['-v', 'error', '-show_entries', 'format=duration', '-of', 'default=noprint_wrappers=1:nokey=1', filePath];
+        let out = '';
+        const proc = spawn(ffprobePath, args, { windowsHide: true });
+        proc.stdout.on('data', (d) => { out += d; });
+        proc.on('close', (code) => { code === 0 ? resolve(parseFloat(out.trim()) || null) : reject(new Error(`ffprobe exit ${code}`)); });
+        proc.on('error', reject);
+      });
+    } catch {
+      return null;
+    }
+  }
+
+  async function transcribeVoice(audioPath, { attachmentId } = {}) {
+    const config = getConfig();
+    // ── size gate (config: voice.transcription.maxFileSizeMB) ──
+    const maxSizeBytes = (config.voice?.transcription?.maxFileSizeMB ?? 0) * 1024 * 1024;
+    if (maxSizeBytes > 0) {
+      try {
+        const stat = await fs.promises.stat(audioPath);
+        if (stat.size > maxSizeBytes) {
+          process.stderr.write(`mixdog: voice.transcription skipped — file too large (${(stat.size / 1024 / 1024).toFixed(1)} MB > ${config.voice.transcription.maxFileSizeMB} MB): ${audioPath}\n`);
+          return null;
+        }
+      } catch { /* stat failure: proceed */ }
+    }
+    // ── duration gate (config: voice.transcription.maxDurationSec) ──
+    const maxDurationSec = config.voice?.transcription?.maxDurationSec ?? 0;
+    if (maxDurationSec > 0) {
+      const dur = await _probeAudioDurationSec(audioPath);
+      if (dur !== null && dur > maxDurationSec) {
+        process.stderr.write(`mixdog: voice.transcription skipped — audio too long (${Math.floor(dur)}s > ${maxDurationSec}s): ${audioPath}\n`);
+        return null;
+      }
+    }
+    // ── transcript cache hit ──
+    if (attachmentId && _voiceTranscriptCache.has(attachmentId)) {
+      process.stderr.write(`mixdog: voice.transcription cache hit (${attachmentId})\n`);
+      return _voiceTranscriptCache.get(attachmentId);
+    }
+    if (attachmentId && _voiceInflight.has(attachmentId)) {
+      return _voiceInflight.get(attachmentId);
+    }
+    const p = _voiceTranscriptionQueue(() => _doTranscribeVoice(audioPath, attachmentId));
+    if (attachmentId) {
+      _voiceInflight.set(attachmentId, p);
+      p.catch((err) => {
+        try { process.stderr.write(`mixdog: voice.transcription inflight rejection: ${err?.stack || err}\n`); } catch {}
+      }).finally(() => _voiceInflight.delete(attachmentId));
+    }
+    return p;
+  }
+
+  async function _doTranscribeVoice(audioPath, attachmentId) {
+    const config = getConfig();
+    try {
+      const runtime = resolveVoiceRuntime(dataDir);
+      if (!runtime?.installed) {
+        const missing = [runtime?.binary ? null : 'binary', runtime?.model ? null : 'model', runtime?.ffmpeg ? null : 'ffmpeg'].filter(Boolean).join(' + ');
+        throw new Error(`voice runtime not installed (missing: ${missing}) — open the setup wizard and click "Install voice"`);
+      }
+      const whisperCmd = runtime.whisperCmd;
+      const modelPath = runtime.modelPath;
+      const ffmpegPath = runtime.ffmpegPath;
+      const lang = normalizeWhisperLanguage(config.voice?.language) ?? detectDeviceLanguage();
+      const _cpuCount = (() => { try { return os.cpus().length; } catch { return 2; } })();
+      const threadCount = config.voice?.transcription?.threadCount ?? Math.max(1, Math.ceil(_cpuCount / 4));
+      // ── wav cache keyed by attachment id ──
+      let wavPath;
+      if (attachmentId && _voiceWavCache.has(attachmentId)) {
+        wavPath = _voiceWavCache.get(attachmentId);
+        if (!fs.existsSync(wavPath)) {
+          _voiceWavCache.delete(attachmentId);
+          wavPath = undefined;
+        } else {
+          process.stderr.write(`mixdog: voice.transcription wav cache hit (${attachmentId})\n`);
+        }
+      }
+      if (!wavPath) {
+        wavPath = audioPath.replace(/\.[^.]+$/, ".wav");
+        const sampleRate = config.voice?.transcription?.sampleRate ?? 16000;
+        const channels = config.voice?.transcription?.channels ?? 1;
+        // Single-flight: parallel callers for the same key share one ffmpeg spawn.
+        const _ffmpegKey = attachmentId || wavPath;
+        if (_voiceFfmpegInflight.has(_ffmpegKey)) {
+          await _voiceFfmpegInflight.get(_ffmpegKey);
+        } else {
+          const _ffmpegPromise = runCmd(ffmpegPath, ["-i", audioPath, "-ar", String(sampleRate), "-ac", String(channels), "-threads", String(threadCount), "-y", wavPath]);
+          _voiceFfmpegInflight.set(_ffmpegKey, _ffmpegPromise);
+          try {
+            await _ffmpegPromise;
+            if (attachmentId) _voiceWavCache.set(attachmentId, wavPath);
+          } finally {
+            _voiceFfmpegInflight.delete(_ffmpegKey);
+          }
+        }
+      }
+      process.stderr.write(`mixdog: voice.transcription start runtime=${runtime.kind} cmd=${path.basename(whisperCmd)}\n`);
+      await ensureReady({ serverCmd: runtime.serverCmd, modelPath, threadCount, host: '127.0.0.1' });
+      const text = await transcribe(wavPath, { language: lang });
+      const result = text.trim() || null;
+      if (attachmentId && result) _voiceTranscriptCache.set(attachmentId, result);
+      return result;
+    } catch (err) {
+      if (err?.message?.startsWith('voice runtime not installed')) throw err; // propagate setup errors; caller posts user-visible failure
+      process.stderr.write(`mixdog: voice.transcription failed: ${err}\n`);
+      return null;
+    }
+  }
+
+  return { isVoiceAttachment, transcribeVoice };
+}
+
+export { isVoiceAttachment, runCmd, createVoiceTranscription };