mixdog 0.7.1

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

@@ -0,0 +1,36 @@
+import { existsSync, readFileSync, unlinkSync } from "fs";
+import { setTimeout as delay } from "timers/promises";
+import { getControlPath, getControlResponsePath } from "./runtime-paths.mjs";
+import { writeJsonAtomicSync } from "../../shared/atomic-file.mjs";
+async function controlClaudeSession(instanceId, command, timeoutMs = 3e3) {
+  const controlPath = getControlPath(instanceId);
+  const id = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  // Per-request response file avoids concurrent callers unlinking each other's responses
+  const responsePath = getControlResponsePath(instanceId) + `.${id}`;
+  const sharedResponsePath = getControlResponsePath(instanceId);
+  try {
+    unlinkSync(sharedResponsePath);
+  } catch {
+  }
+  writeJsonAtomicSync(controlPath, { id, command, requestedAt: Date.now(), responsePath }, { compact: true, lock: true });
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    if (existsSync(responsePath) || existsSync(sharedResponsePath)) {
+      try {
+        const readPath = existsSync(responsePath) ? responsePath : sharedResponsePath;
+        const payload = JSON.parse(readFileSync(readPath, "utf8"));
+        if (payload.id === id) return payload;
+      } catch {
+      }
+    }
+    await delay(100);
+  }
+  return {
+    ok: false,
+    mode: "unsupported",
+    message: "session control timeout"
+  };
+}
+export {
+  controlClaudeSession
+};

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

@@ -0,0 +1,103 @@
+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/settings.mjs

@@ -0,0 +1,11 @@
+import { readFileSync } from "fs";
+function tryRead(path) {
+  try {
+    return readFileSync(path, "utf8").trim();
+  } catch {
+    return null;
+  }
+}
+export {
+  tryRead
+};

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

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,219 @@
+/**
+ * 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

@@ -0,0 +1,140 @@
+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
+};