mixdog 0.7.18 → 0.8.1

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

@@ -1,103 +0,0 @@
-import { readFileSync, readdirSync, statSync } from "fs";
-import { execFileSync } from "child_process";
-import { basename, join, resolve } from "path";
-import { homedir } from "os";
-
-function cwdToProjectSlug(cwd) {
-  return resolve(cwd).replace(/\\/g, "/").replace(/^([A-Za-z]):/, "$1-").replace(/\//g, "-");
-}
-function getParentPid(pid) {
-  try {
-    if (process.platform === "win32") {
-      // windowsHide + stdio:['ignore','pipe','ignore'] suppresses the
-      // conhost flash that otherwise appears on every call. This routine
-      // runs inside the parent-PID walk of discoverCurrentClaudeSession,
-      // which fires per transcript watchDebounce tick (every Claude Code
-      // message updates the transcript), so without these flags users
-      // see a powershell.exe console window pop in/out repeatedly during
-      // any chat activity — including while the config UI is loading.
-      const out2 = execFileSync("powershell.exe", [
-        "-NoProfile",
-        "-NonInteractive",
-        "-WindowStyle", "Hidden",
-        "-Command",
-        `(Get-CimInstance Win32_Process -Filter "ProcessId=${pid}").ParentProcessId`
-      ], {
-        encoding: "utf8",
-        windowsHide: true,
-        stdio: ["ignore", "pipe", "ignore"]
-      }).trim();
-      const parsed2 = parseInt(out2, 10);
-      return Number.isFinite(parsed2) ? parsed2 : null;
-    }
-    const out = execFileSync("ps", ["-o", "ppid=", "-p", String(pid)], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-      windowsHide: true
-    }).trim();
-    const parsed = parseInt(out, 10);
-    return Number.isFinite(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function readSessionRecord(pid) {
-  const sessionFile = join(homedir(), ".claude", "sessions", `${pid}.json`);
-  try {
-    const sessionFileStat = statSync(sessionFile);
-    const session = JSON.parse(readFileSync(sessionFile, "utf8"));
-    if (!session.sessionId) return null;
-    return {
-      pid,
-      sessionId: session.sessionId,
-      cwd: resolve(session.cwd ?? process.cwd()),
-      transcriptPath: typeof session.transcriptPath === "string" && session.transcriptPath
-        ? resolve(session.transcriptPath)
-        : "",
-      startedAt: typeof session.startedAt === "number" ? session.startedAt : 0,
-      updatedAt: typeof session.updatedAt === "number" ? session.updatedAt : sessionFileStat.mtimeMs,
-      kind: typeof session.kind === "string" ? session.kind : "",
-      entrypoint: typeof session.entrypoint === "string" ? session.entrypoint : "",
-      sessionFile
-    };
-  } catch {
-    return null;
-  }
-}
-function isInteractiveSession(session) {
-  if (!session) return false;
-  return session.kind === "interactive" || !session.kind && session.entrypoint === "cli";
-}
-function discoverCurrentClaudeSession() {
-  let pid = process.ppid;
-  for (let depth = 0; pid && pid > 1 && depth < 6; depth += 1) {
-    const session = readSessionRecord(pid);
-    if (session) return session;
-    pid = getParentPid(pid);
-  }
-  return null;
-}
-function listInteractiveClaudeSessions() {
-  const sessionsDir = join(homedir(), ".claude", "sessions");
-  try {
-    return readdirSync(sessionsDir).filter((file) => file.endsWith(".json")).map((file) => parseInt(basename(file, ".json"), 10)).filter((pid) => Number.isFinite(pid)).map((pid) => readSessionRecord(pid)).filter(isInteractiveSession).sort((a, b) => {
-      if (b.startedAt !== a.startedAt) return b.startedAt - a.startedAt;
-      return b.pid - a.pid;
-    });
-  } catch {
-    return [];
-  }
-}
-function getLatestInteractiveClaudeSession() {
-  return listInteractiveClaudeSessions()[0] ?? null;
-}
-
-export {
-  cwdToProjectSlug,
-  getParentPid,
-  readSessionRecord,
-  isInteractiveSession,
-  discoverCurrentClaudeSession,
-  listInteractiveClaudeSessions,
-  getLatestInteractiveClaudeSession
-};

package/src/channels/lib/state-file.mjs

@@ -1,68 +0,0 @@
-import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
-import { dirname } from "path";
-import { writeJsonAtomicSync } from "../../shared/atomic-file.mjs";
-function ensureDir(dirPath) {
-  mkdirSync(dirPath, { recursive: true });
-}
-function removeFileIfExists(filePath) {
-  try {
-    unlinkSync(filePath);
-  } catch (err) {
-    if (err.code !== "ENOENT") {
-      throw err;
-    }
-  }
-}
-function readJsonFile(filePath, fallback) {
-  try {
-    return JSON.parse(readFileSync(filePath, "utf8"));
-  } catch {
-    return fallback;
-  }
-}
-function readJsonFileStrict(filePath) {
-  const raw = readFileSync(filePath, "utf8");
-  return JSON.parse(raw);
-}
-function writeTextFile(filePath, value) {
-  ensureDir(dirname(filePath));
-  writeFileSync(filePath, value);
-}
-function writeJsonFile(filePath, value) {
-  writeJsonAtomicSync(filePath, value, { compact: true, lock: true, fsyncDir: true });
-}
-class JsonStateFile {
-  constructor(filePath, fallback) {
-    this.filePath = filePath;
-    this.fallback = fallback;
-  }
-  read() {
-    return readJsonFile(this.filePath, this.fallback);
-  }
-  write(value) {
-    writeJsonFile(this.filePath, value);
-    return value;
-  }
-  ensure() {
-    writeJsonFile(this.filePath, this.read());
-  }
-  update(mutator) {
-    let draft;
-    try {
-      draft = readJsonFileStrict(this.filePath);
-    } catch (err) {
-      process.stderr.write(`[state-file] REFUSING update: parse error for ${this.filePath}: ${err.message}\n`);
-      throw err;
-    }
-    mutator(draft);
-    return this.write(draft);
-  }
-}
-export {
-  JsonStateFile,
-  ensureDir,
-  readJsonFile,
-  removeFileIfExists,
-  writeJsonFile,
-  writeTextFile
-};

package/src/channels/lib/status-snapshot.mjs

@@ -1,219 +0,0 @@
-/**
- * status-snapshot.mjs — v0.1.19
- *
- * Writes <DATA_DIR>/channels/status-snapshot.json every 10 seconds so that
- * setup-server can read cross-process state (cron next-fire, deferred count,
- * Discord unread, ngrok tunnel URL) without IPC.
- *
- * Atomic write: tmp → rename so readers never see a partial file.
- *
- * Usage (from channels/index.mjs):
- *   import { startSnapshotWriter } from './lib/status-snapshot.mjs';
- *   startSnapshotWriter(scheduler, backend, webhookServer);
- */
-
-import * as fs from 'fs';
-import * as http from 'http';
-import * as path from 'path';
-import { DATA_DIR } from './config.mjs';
-import { writeJsonAtomicSync } from '../../shared/atomic-file.mjs';
-
-const SNAPSHOT_DIR  = path.join(DATA_DIR, 'channels');
-const SNAPSHOT_PATH = path.join(SNAPSHOT_DIR, 'status-snapshot.json');
-const INTERVAL_MS   = 10_000;
-const HEARTBEAT_MS  = 60_000; // force-write even when content is unchanged
-
-let _lastSnapshotJson  = null;
-let _lastSnapshotWrite = 0;
-
-// ── In-memory Discord unread tracking ────────────────────────────────────────
-// Key: channelId  Value: { label, latestSeenId, unseenCount }
-// No persistence across restarts — clean start is fine for v1.
-const _discordUnread = new Map();
-
-/**
- * Called whenever the backend observes messages for a channelId.
- * `messages` is the array returned by backend.fetchMessages().
- * We record the most-recently-seen message id and count messages
- * received since the last call as "unread since last fetch".
- * Pass { markRead: true } for live gateway messages that were already
- * delivered into the bridge.
- */
-export function recordFetchedMessages(channelId, channelLabel, messages, options = {}) {
-  if (!Array.isArray(messages) || messages.length === 0) return;
-  const prev = _discordUnread.get(channelId);
-  const prevLatestId = prev?.latestSeenId ?? null;
-  const newLatestId  = messages[messages.length - 1]?.id ?? null;
-
-  // Count messages newer than the last seen id (BigInt-compare Discord snowflakes).
-  let unseenCount = 0;
-  if (options.markRead === true) {
-    unseenCount = 0;
-  } else if (prevLatestId) {
-    for (const m of messages) {
-      try {
-        if (BigInt(m.id) > BigInt(prevLatestId)) unseenCount++;
-      } catch { unseenCount++; }
-    }
-  }
-  // First call: zero unread (baseline, not retroactive).
-
-  _discordUnread.set(channelId, {
-    label: channelLabel ?? channelId,
-    latestSeenId: newLatestId,
-    unseenCount,
-  });
-}
-
-// ── Ngrok tunnel URL probe ───────────────────────────────────────────────────
-async function probeNgrokUrl() {
-  return new Promise((resolve) => {
-    const timer = setTimeout(() => { try { req && req.destroy(); } catch {} resolve(null); }, 400);
-    let req;
-    try {
-      req = http.get('http://127.0.0.1:4040/api/tunnels', (res) => {
-        clearTimeout(timer);
-        let body = '';
-        res.on('data', d => { body += d; });
-        res.on('end', () => {
-          try {
-            const parsed = JSON.parse(body);
-            const tunnel = (parsed.tunnels || []).find(t => t.public_url);
-            resolve(tunnel ? tunnel.public_url : null);
-          } catch { resolve(null); }
-        });
-      });
-      req.on('error', () => { clearTimeout(timer); resolve(null); });
-      req.setTimeout(400, () => { clearTimeout(timer); try { req.destroy(); } catch {} resolve(null); });
-    } catch { clearTimeout(timer); resolve(null); }
-  });
-}
-
-// ── Snapshot computation ─────────────────────────────────────────────────────
-// The legacy HH:MM / everyNm / hourly next-fire fallback was removed: the
-// scheduler accepts cron expressions exclusively (scheduler.mjs:68), so the
-// fallback could only produce stale next-fire timestamps for entries that
-// never actually fire under the cron-only scheduler.
-async function computeSnapshot(scheduler) {
-  const now = Date.now();
-
-  // ── Schedules ──────────────────────────────────────────────────────────────
-  let nextSchedule = null;   // { name, fireAt, kind }
-  const deferred  = [];
-
-  if (scheduler) {
-    // Cron-expression next-fire via node-cron ScheduledTask.nextDate().
-    if (scheduler.cronJobs && scheduler.cronJobs.size > 0) {
-      for (const [name, task] of scheduler.cronJobs) {
-        if (scheduler.shouldSkip && scheduler.shouldSkip(name)) continue;
-        try {
-          // node-cron ScheduledTask exposes nextDate() / getNextDate()
-          // depending on the installed version; try both.
-          const nd =
-            (typeof task.nextDate  === 'function' ? task.nextDate()  : null) ??
-            (typeof task.getNextDate === 'function' ? task.getNextDate() : null);
-          if (!nd) continue;
-          const fireAt = nd instanceof Date ? nd.getTime() : Number(nd);
-          if (!isFinite(fireAt)) continue;
-          if (!nextSchedule || fireAt < nextSchedule.fireAt) {
-            nextSchedule = { name, fireAt, kind: 'cron' };
-          }
-        } catch { /* node-cron version mismatch — skip */ }
-      }
-    }
-
-    // Deferred entries
-    if (scheduler.deferred) {
-      for (const [name, until] of scheduler.deferred) {
-        if (until > now) deferred.push({ name, until });
-      }
-    }
-  }
-
-  // ── Discord unread ─────────────────────────────────────────────────────────
-  const unreadList = [];
-  let totalUnread  = 0;
-  for (const [channelId, entry] of _discordUnread) {
-    unreadList.push({
-      channelId,
-      channelLabel: entry.label,
-      count: entry.unseenCount,
-    });
-    totalUnread += entry.unseenCount;
-  }
-
-  // ── Ngrok tunnel URL ───────────────────────────────────────────────────────
-  const tunnelUrl = await probeNgrokUrl();
-
-  return {
-    writtenAt: now,
-    schedules: {
-      next: nextSchedule
-        ? { name: nextSchedule.name, fireAt: nextSchedule.fireAt, kind: nextSchedule.kind }
-        : null,
-      deferred,
-      deferredCount: deferred.length,
-    },
-    discord: {
-      unread: unreadList,
-      totalUnread,
-    },
-    ngrok: {
-      tunnelUrl,
-    },
-  };
-}
-
-// ── Atomic writer ────────────────────────────────────────────────────────────
-async function writeSnapshot(scheduler) {
-  try {
-    const snap = await computeSnapshot(scheduler);
-    const json = JSON.stringify(snap, null, 2);
-    const now = Date.now();
-    if (json === _lastSnapshotJson && (now - _lastSnapshotWrite) < HEARTBEAT_MS) {
-      return; // unchanged within heartbeat window — skip disk write
-    }
-    _lastSnapshotJson  = json;
-    _lastSnapshotWrite = now;
-    writeJsonAtomicSync(SNAPSHOT_PATH, snap, { lock: true, fsyncDir: true });
-  } catch (err) {
-    // Non-fatal — statusline degrades gracefully when snapshot is absent.
-    process.stderr.write(
-      `mixdog status-snapshot: write failed: ${err?.message ?? err}\n`
-    );
-  }
-}
-
-// ── Public API ────────────────────────────────────────────────────────────────
-let _scheduler = null;
-let _snapshotTimer = null;
-
-/**
- * Start the snapshot writer.
- * Call once from channels/index.mjs after the scheduler is created.
- * Re-entrant: calling again replaces the scheduler reference.
- */
-export function startSnapshotWriter(scheduler) {
-  _scheduler = scheduler;
-
-  // Write immediately on startup
-  void writeSnapshot(_scheduler);
-
-  // Then every 10 seconds
-  if (!_snapshotTimer) {
-    _snapshotTimer = setInterval(() => {
-      void writeSnapshot(_scheduler);
-    }, INTERVAL_MS);
-    // Don't prevent process exit
-    if (_snapshotTimer.unref) _snapshotTimer.unref();
-  }
-}
-
-/** Stop the writer and remove the snapshot file. */
-export function stopSnapshotWriter() {
-  if (_snapshotTimer) {
-    clearInterval(_snapshotTimer);
-    _snapshotTimer = null;
-  }
-  try { fs.unlinkSync(SNAPSHOT_PATH); } catch {}
-}

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

@@ -1,140 +0,0 @@
-import { basename } from "path";
-import { safeCodeBlock } from "./format.mjs";
-
-// Texts that should never be forwarded to Discord (Claude's internal status lines)
-const SKIP_TEXTS = /* @__PURE__ */ new Set([
-  "No response requested.",
-  "No response requested",
-  "Waiting for user response.",
-  "Waiting for user response"
-]);
-
-/** Hidden tools — skip both tool_use and tool_result */
-const HIDDEN_TOOLS = /* @__PURE__ */ new Set([
-  "ToolSearch",
-  "SendMessage",
-  "TeamCreate",
-  "TaskCreate",
-  "TaskUpdate",
-  "TaskList",
-  "TaskGet"
-]);
-
-/** Check if a tool name is recall_memory */
-function isRecallMemory(name) {
-  return name === "recall_memory"
-    || name === "mcp__plugin_mixdog_mixdog__recall_memory"
-    || name === "mcp__plugin_mixdog_trib-plugin__recall_memory";
-}
-/** Check if a file path points to a memory file */
-function isMemoryFile(filePath) {
-  if (!filePath) return false;
-  const normalized = filePath.replace(/\\/g, "/");
-  if (normalized.includes(".claude/projects/") && normalized.includes("/memory/")) return true;
-  if (basename(normalized) === "MEMORY.md") return true;
-  return false;
-}
-/** Check if a tool should be hidden */
-function isHidden(name) {
-  if (HIDDEN_TOOLS.has(name)) return true;
-  if (name.includes("plugin_mixdog") && !name.endsWith("recall_memory") || name === "reply" || name === "react" || name === "edit_message" || name === "fetch" || name === "download_attachment") return true;
-  return false;
-}
-/**
- * Build a per-call dedup key for tool-log queue items.
- * Uses the full (unsquished) tool args so that two Reads on distinct files
- * sharing a basename, or two Grep/Glob calls sharing only a pattern prefix,
- * do not collapse onto the same key and suppress the second send.
- * Returns "" to fall back to md5(formatted) at delivery time.
- */
-function buildDedupKey(name, input) {
-  if (!name || !input || typeof input !== "object") return "";
-  switch (name) {
-    case "Read":
-      return input.file_path ? "read:" + input.file_path : "";
-    case "Grep":
-      return "grep:" + (input.pattern ?? "") + ":" + (input.path ?? "");
-    case "Glob":
-      return "glob:" + (input.pattern ?? "") + ":" + (input.path ?? "");
-    default:
-      return "";
-  }
-}
-/** Build a tool log line from the tool name and input. */
-function buildToolLine(name, input, hiddenCheck = isHidden) {
-  if (hiddenCheck(name)) return null;
-  let displayName = name;
-  let summary = "";
-  let detail = "";
-  const isSearchTool = name === "Read" || name === "Grep" || name === "Glob";
-  switch (name) {
-    case "Bash": {
-      const desc = (input?.description || "").substring(0, 50);
-      summary = desc || "Bash";
-      detail = (input?.command || "").substring(0, 500);
-      break;
-    }
-    case "Read":
-      summary = input?.file_path ? basename(input.file_path) : "";
-      break;
-    case "Grep":
-      summary = '"' + (input?.pattern || "").substring(0, 25) + '"';
-      break;
-    case "Glob":
-      summary = (input?.pattern || "").substring(0, 25);
-      break;
-    case "Edit":
-    case "Write":
-      summary = input?.file_path ? basename(input.file_path) : "";
-      detail = input?.file_path || "";
-      break;
-    case "Agent": {
-      summary = input?.name || input?.subagent_type || "agent";
-      let d = (input?.prompt || "").substring(0, 200);
-      const backticks = (d.match(/```/g) || []).length;
-      if (backticks % 2 === 1) d += "\n```";
-      if (d.length < (input?.prompt || "").length) d += "...";
-      detail = d;
-      break;
-    }
-    case "TeamCreate":
-      summary = input?.team_name || "";
-      detail = input?.description || "";
-      break;
-    case "TaskCreate":
-      summary = (input?.subject || "").substring(0, 50);
-      break;
-    case "Skill":
-      summary = input?.skill || "";
-      break;
-    default:
-      if (name.startsWith("mcp__")) {
-        const parts = name.split("__");
-        displayName = "mcp";
-        summary = parts[parts.length - 1] || "";
-      } else {
-        summary = name;
-      }
-      break;
-  }
-  if (!summary) return null;
-  let toolLine = displayName === summary ? "\u25CF **" + displayName + "**" : "\u25CF **" + displayName + "** (" + summary + ")";
-  if (!isSearchTool && detail && detail !== summary) {
-    const lines = detail.substring(0, 500).split("\n");
-    const shown = lines.slice(0, 5);
-    let block = shown.join("\n");
-    if (lines.length > 5) block += "\n... +" + (lines.length - 5) + " lines";
-    toolLine += "\n" + safeCodeBlock(block);
-  }
-  return toolLine;
-}
-
-export {
-  SKIP_TEXTS,
-  HIDDEN_TOOLS,
-  isRecallMemory,
-  isMemoryFile,
-  isHidden,
-  buildDedupKey,
-  buildToolLine
-};