mixdog 0.9.96 → 0.9.99

package/src/runtime/channels/lib/config.mjs

@@ -1,7 +1,7 @@
 import { readFileSync, mkdirSync } from "fs";
 import { join } from "path";
-import { DiscordBackend } from "../backends/discord.mjs";
-import { TelegramBackend } from "../backends/telegram.mjs";
+import { DiscordProvider } from "../providers/discord.mjs";
+import { TelegramProvider } from "../providers/telegram.mjs";
 import {
   readSection,
   updateSection,
@@ -22,7 +22,7 @@ const DEFAULT_ACCESS = {
   channels: {}
 };
 const DEFAULT_CONFIG = {
-  backend: "discord",
+  provider: "discord",
   discord: { token: "" },
   telegram: { token: "" },
   access: DEFAULT_ACCESS,
@@ -40,18 +40,18 @@ function applyDefaults(config) {
   return out;
 }
 
-function channelIdForBackend(entry = {}, backend = "discord") {
-  if (backend === "telegram") {
-    return String(entry?.telegramChatId || (entry?.discordChannelId ? "" : entry?.channelId) || "");
+function channelIdForProvider(entry = {}, provider = "discord") {
+  if (provider === "telegram") {
+    return String(entry?.telegramChatId || "");
   }
-  return String(entry?.discordChannelId || (entry?.telegramChatId ? "" : entry?.channelId) || "");
+  return String(entry?.discordChannelId || "");
 }
 
-// Resolve the single active-backend channel id from the config's `channel`
+// Resolve the single active-provider channel id from the config's `channel`
 // section. Disk config carries a single `channel` object only.
-function resolveChannelId(raw = {}, backend = "discord") {
+function resolveChannelId(raw = {}, provider = "discord") {
   const channel = raw.channel && typeof raw.channel === "object" ? raw.channel : null;
-  if (channel) return channelIdForBackend(channel, backend);
+  if (channel) return channelIdForProvider(channel, provider);
   return "";
 }
 
@@ -88,20 +88,20 @@ async function loadConfig({ freshSecrets = false } = {}) {
     if (discordTokenProblem) {
       process.stderr.write(`mixdog: discord token ignored: ${discordTokenProblem}\n`);
     }
-    // Single-backend select: config.backend picks ONE of discord|telegram.
+    // Single-provider select: config.provider picks ONE of discord|telegram.
     // Anything else falls back to the discord default.
-    const backend = raw.backend === "telegram" ? "telegram" : "discord";
+    const provider = raw.provider === "telegram" ? "telegram" : "discord";
     const telegramToken = getTelegramToken();
-    const channelId = resolveChannelId(raw, backend);
+    const channelId = resolveChannelId(raw, provider);
     // The runtime reads only the resolved `channelId`; disk carries a single
     // `channel` object, so spread `raw` directly.
     return applyDefaults({
       ...DEFAULT_CONFIG,
       ...raw,
-      backend,
+      provider,
       channelId,
       discord: { ...DEFAULT_CONFIG.discord, ...(({ token: _, ...rest }) => rest)(raw.discord || {}), ...(discordToken && !discordTokenProblem ? { token: discordToken } : {}) },
-      // Merge the keychain-resolved telegram token (harmless when backend is
+      // Merge the keychain-resolved telegram token (harmless when provider is
       // discord; the secret never lands in the on-disk config either way).
       telegram: { ...DEFAULT_CONFIG.telegram, ...(({ token: _t, ...rest }) => rest)(raw.telegram || {}), ...(telegramToken ? { token: telegramToken } : {}) },
       access: {
@@ -117,7 +117,7 @@ async function loadConfig({ freshSecrets = false } = {}) {
       updateSection("channels", () => DEFAULT_CONFIG);
       process.stderr.write(
         `mixdog: default channels config created in ${MIXDOG_CONFIG_PATH}
-  edit the active backend channel id to connect.
+  edit the active provider channel id to connect.
 `
       );
       return applyDefaults(DEFAULT_CONFIG);
@@ -125,7 +125,7 @@ async function loadConfig({ freshSecrets = false } = {}) {
     throw err;
   }
 }
-const HEADLESS_BACKEND = {
+const HEADLESS_PROVIDER = {
   name: "headless",
   MAX_MESSAGE_LENGTH: 2000,
   formatOutgoing(t) {
@@ -156,31 +156,31 @@ const HEADLESS_BACKEND = {
   on() {
   }
 };
-function createBackend(config) {
+function createProvider(config) {
   // Channels-module toggle is MESSAGING-ONLY: automation (scheduler/webhooks)
-  // keeps the worker alive, so a disabled module runs the headless backend
+  // keeps the worker alive, so a disabled module runs the headless provider
   // instead of blocking the whole runtime.
   if (config.enabled === false) {
     process.stderr.write("mixdog: channels messaging disabled; channel runtime running in headless mode\n");
-    return HEADLESS_BACKEND;
+    return HEADLESS_PROVIDER;
   }
-  // Single-backend select: exactly one backend is constructed based on
-  // config.backend (discord|telegram). The two are mutually exclusive.
-  if (config.backend === "telegram") {
+  // Single-provider select: exactly one provider is constructed based on
+  // config.provider (discord|telegram). The two are mutually exclusive.
+  if (config.provider === "telegram") {
     const telegramToken = getTelegramToken();
     if (!telegramToken) {
       process.stderr.write("mixdog: telegram bot not configured; channel runtime running in headless mode\n");
-      return HEADLESS_BACKEND;
+      return HEADLESS_PROVIDER;
     }
     const tgStateDir = config.telegram?.stateDir ?? join(DATA_DIR, "telegram");
     mkdirSync(tgStateDir, { recursive: true });
-    return new TelegramBackend({
+    return new TelegramProvider({
       ...config.telegram,
       configPath: CONFIG_FILE,
       access: config.access,
       // Single-source channel setup: the main chat is auto-allowed inside
-      // TelegramBackend.loadAccess() so a configured channel.channelId
-      // is enough for both inbound gating and outbound.
+      // TelegramProvider.loadAccess() so the configured Telegram target is
+      // enough for both inbound gating and outbound.
       mainChannelId: config.channelId
     }, tgStateDir);
   }
@@ -189,19 +189,19 @@ function createBackend(config) {
   if (discordTokenProblem) {
     process.stderr.write(`mixdog: discord token ignored: ${discordTokenProblem}\n`);
   }
-  if (config.backend !== "discord" || !discordToken || discordTokenProblem) {
+  if (config.provider !== "discord" || !discordToken || discordTokenProblem) {
     process.stderr.write("mixdog: discord bot not configured; channel runtime running in headless mode\n");
-    return HEADLESS_BACKEND;
+    return HEADLESS_PROVIDER;
   }
   const stateDir = config.discord.stateDir ?? join(DATA_DIR, "discord");
   mkdirSync(stateDir, { recursive: true });
-  return new DiscordBackend({
+  return new DiscordProvider({
     ...config.discord,
     configPath: CONFIG_FILE,
     access: config.access,
     // Single-source channel setup: the main channel is auto-allowed inside
-    // DiscordBackend.loadAccess() so a configured channel.channelId
-    // is enough for both inbound and outbound — no separate access.channels entry.
+    // DiscordProvider.loadAccess() so the configured Discord target is enough
+    // for both inbound and outbound — no separate access.channels entry.
     mainChannelId: config.channelId
   }, stateDir);
 }
@@ -215,7 +215,7 @@ function loadProfileConfig() {
 }
 export {
   DATA_DIR,
-  createBackend,
+  createProvider,
   getDiscordToken,
   getTelegramToken,
   loadConfig,

package/src/runtime/channels/lib/inbound-handler.mjs

@@ -7,14 +7,14 @@ import {
 import { refreshActiveInstance } from "./runtime-paths.mjs";
 import { isNetworkError, retryOnNetwork } from "./network-retry.mjs";
 // Inbound message pipeline extracted from channels/index.mjs (behavior-
-// preserving): serial inbound queue, backend.onMessage transcript (re)bind +
+// preserving): serial inbound queue, provider.onMessage transcript (re)bind +
 // steal logic, and handleInbound voice-transcription + parent notify. Bound to
 // live runtime getters and shared primitives.
 function isImageAttachment(contentType) {
   return typeof contentType === "string" && contentType.toLowerCase().startsWith("image/");
 }
 export function createInboundHandler({
-  getBackend,
+  getProvider,
   getConfig,
   getBridgeRuntimeConnected,
   getChannelBridgeActive,
@@ -55,7 +55,7 @@ const inboundQueue = (() => {
   };
 })();
 
-getBackend().onMessage = (msg) => {
+getProvider().onMessage = (msg) => {
   const receivedAtMs = Number.isFinite(msg.receivedAtMs) ? msg.receivedAtMs : Date.now();
   const onMessageAtMs = Date.now();
   const gateBlocked = (!getBridgeRuntimeConnected() || !getBridgeOwnershipSnapshot().owned)
@@ -72,7 +72,7 @@ getBackend().onMessage = (msg) => {
       msg.__bridgeGateRetries = attempt;
       msg.receivedAtMs = receivedAtMs;
       setTimeout(() => {
-        try { getBackend().onMessage?.(msg); } catch { /* best-effort */ }
+        try { getProvider().onMessage?.(msg); } catch { /* best-effort */ }
       }, 2000 * attempt)?.unref?.();
     } else {
       try { process.stderr.write(`mixdog: inbound message dropped after ${attempt - 1} ${gateBlocked} retries (channel=${msg.chatId}, id=${msg.messageId})\n`); } catch {}
@@ -242,7 +242,7 @@ getBackend().onMessage = (msg) => {
   });
   void (async () => {
     try {
-      await getBackend().react(msg.chatId, msg.messageId, "\u{1F914}");
+      await getProvider().react(msg.chatId, msg.messageId, "\u{1F914}");
     } catch {
     }
     await bindingDone;
@@ -271,7 +271,7 @@ async function handleInbound(msg, route, options = {}) {
         const files = await retryOnNetwork(
           // Short per-attempt timeout (vs the 180s default) bounds worst-case
           // blockage of the serial inboundQueue on a bad voice message.
-          () => getBackend().downloadAttachment(msg.chatId, msg.messageId, { timeoutMs: 20_000 }),
+          () => getProvider().downloadAttachment(msg.chatId, msg.messageId, { timeoutMs: 20_000 }),
           { label: "voice.download" }
         );
         // concurrency handled inside transcribeVoice queue; loop is sequential so last att wins
@@ -312,7 +312,7 @@ async function handleInbound(msg, route, options = {}) {
   if (imageAtts.length > 0) {
     try {
       const files = (await retryOnNetwork(
-        () => getBackend().downloadAttachment(msg.chatId, msg.messageId, {
+        () => getProvider().downloadAttachment(msg.chatId, msg.messageId, {
           timeoutMs: 20_000,
           filter: (a) => isImageAttachment(a.contentType),
         }),

package/src/runtime/channels/lib/interaction-handlers.mjs

@@ -1,12 +1,6 @@
-import * as fs from "fs";
-import * as path from "path";
-// Discord permission-prompt + interaction/modal routing extracted from
-// channels/index.mjs (behavior-preserving). Installs backend.onInteraction /
-// onModalRequest handlers and the terminal tool-exec signal watcher; returns the
-// pending-permission map + marker refresher for the worker IPC handler.
+// Discord interaction/modal routing extracted from channels/index.mjs.
 export function createInteractionHandlers({
-  getBackend,
-  getConfig,
+  getProvider,
   getBridgeRuntimeConnected,
   instanceId,
   getBridgeOwnershipSnapshot,
@@ -14,34 +8,13 @@ export function createInteractionHandlers({
   pendingSetup,
   buildModalRequestSpec,
   loadProfileConfig,
-  getDiscordToken,
   sendNotifyToParent,
   scheduler,
   controlClaudeSession,
   writeTextFile,
   TURN_END_FILE,
-  getPermissionResultPath,
-  TERMINAL_LEAD_PID,
-  localTimestamp,
-  isMixdogDebug,
-  appendSessionStartCriticalLog,
-  DATA_DIR,
-  _bootLog,
-  RUNTIME_ROOT,
 }) {
-function editDiscordMessage(channelId, messageId, label) {
-  // Behavior-preserving: route through the getBackend() abstraction (which uses
-  // discord.js under the hood) instead of issuing a raw REST PATCH. Errors
-  // are swallowed to stderr to match the prior fire-and-forget shape — the
-  // call site never awaited the HTTPS request either.
-  if (!getDiscordToken()) return;
-  const text = `\u{1F510} **Permission Request** \u2014 ${label}`;
-  void getBackend().editMessage(channelId, messageId, text, { components: [] }).catch((err) => {
-    process.stderr.write(`mixdog: editDiscordMessage failed: ${err}
-`);
-  });
-}
-getBackend().onModalRequest = async (rawInteraction) => {
+getProvider().onModalRequest = async (rawInteraction) => {
   if (!getBridgeRuntimeConnected() || !getBridgeOwnershipSnapshot().owned) {
     refreshBridgeOwnershipSafe();
     return;
@@ -67,170 +40,8 @@ getBackend().onModalRequest = async (rawInteraction) => {
   modal.addComponents(...rows);
   await rawInteraction.showModal(modal);
 };
-const pendingPermRequests = new Map();
-const TOOL_EXEC_CONSUMER_MARKER = path.join(RUNTIME_ROOT, '.tool-exec-consumer');
-function refreshToolExecConsumerMarker() {
-  try {
-    if (pendingPermRequests.size > 0) {
-      fs.writeFileSync(TOOL_EXEC_CONSUMER_MARKER, String(Date.now()));
-    } else {
-      try { fs.unlinkSync(TOOL_EXEC_CONSUMER_MARKER); } catch {}
-    }
-  } catch {}
-}
-// Watch for terminal-approved tool executions. The PostToolUse hook writes a
-// signal file per tool call; when we see one, find the oldest pending perm
-// request with a matching tool name and mark its Discord message as
-// "Allowed (terminal)" so users don't see stale active buttons.
-try {
-  try { if (!fs.existsSync(RUNTIME_ROOT)) fs.mkdirSync(RUNTIME_ROOT, { recursive: true }); } catch {}
-  const SIGNAL_RE = /^tool-exec-\d+-[0-9a-f]+\.signal$/;
-  fs.watch(RUNTIME_ROOT, { persistent: false }, (eventType, filename) => {
-    if (!filename || !SIGNAL_RE.test(filename)) return;
-    setTimeout(() => {
-      try {
-        const signalPath = path.join(RUNTIME_ROOT, filename);
-        let raw;
-        try { raw = fs.readFileSync(signalPath, 'utf8'); } catch { return; }
-        let payload;
-        try { payload = JSON.parse(raw); } catch { return; }
-        const toolName = payload?.toolName;
-        if (!toolName) return;
-        const sigFilePath = payload?.filePath || '';
-        let oldestKey = null;
-        let oldestEntry = null;
-        for (const [k, v] of pendingPermRequests) {
-          if (v.toolName !== toolName) continue;
-          // Bind on filePath too. If both sides are empty (non-file tools
-          // like Bash), toolName alone is the match. Otherwise both must
-          // equal — prevents two concurrent Edit/Write requests from
-          // cross-approving each other.
-          const vFilePath = v.filePath || '';
-          if (vFilePath || sigFilePath) {
-            if (vFilePath !== sigFilePath) continue;
-          }
-          if (!oldestEntry || v.createdAt < oldestEntry.createdAt) {
-            oldestKey = k;
-            oldestEntry = v;
-          }
-        }
-        // No matching pending request — leave the signal on disk so a
-        // agent role hook (or other consumer) gets a chance to claim it.
-        if (!oldestKey || !oldestEntry) return;
-        if (oldestEntry.channelId && oldestEntry.messageId) {
-          try {
-            editDiscordMessage(oldestEntry.channelId, oldestEntry.messageId, 'Allowed (terminal)');
-          } catch (err) {
-            try { process.stderr.write(`mixdog channels: tool-exec signal edit failed: ${err && err.message || err}\n`); } catch {}
-          }
-        }
-        pendingPermRequests.delete(oldestKey);
-        refreshToolExecConsumerMarker();
-        // Only unlink once we've confirmed the match and handled it.
-        try { fs.unlinkSync(signalPath); } catch {}
-      } catch (err) {
-        try { process.stderr.write(`mixdog channels: tool-exec signal handler error: ${err && err.message || err}\n`); } catch {}
-      }
-    }, 50);
-  });
-  // Stale-signal sweeper: any signal file older than 60s is removed so
-  // unclaimed files don't accumulate on disk. Runs every 30s.
-  setInterval(() => {
-    try {
-      const now = Date.now();
-      const entries = fs.readdirSync(RUNTIME_ROOT);
-      for (const name of entries) {
-        if (!SIGNAL_RE.test(name)) continue;
-        const p = path.join(RUNTIME_ROOT, name);
-        try {
-          const st = fs.statSync(p);
-          if (now - st.mtimeMs > 60_000) {
-            try { fs.unlinkSync(p); } catch {}
-          }
-        } catch {}
-      }
-    } catch {}
-  }, 30_000)?.unref?.();
-} catch (err) {
-  try { process.stderr.write(`mixdog channels: tool-exec signal watcher setup failed: ${err && err.message || err}\n`); } catch {}
-}
 
-getBackend().onInteraction = (interaction) => {
-  // Channel-route permission reply. Custom_id format: perm-ch-{request_id}-{allow|session|deny}.
-  // request_id is the 5-letter short ID CC generates via shortRequestId().
-  // Emit notifications/claude/channel/permission back to the MCP host; the race
-  // logic in interactiveHandler.ts resolves the pending request and dismisses
-  // every other racer (local dialog, bridge, hook, classifier).
-  if (interaction.customId?.startsWith("perm-ch-")) {
-    const match = interaction.customId.match(/^perm-ch-([a-km-z]{5})-(allow|session|deny)$/);
-    if (!match) return;
-    const [, requestId, action] = match;
-    const access = getConfig().access;
-    if (access?.allowFrom?.length > 0 && !access.allowFrom.includes(interaction.userId)) {
-      process.stderr.write(`mixdog: perm-ch button rejected — user ${interaction.userId} not in allowFrom\n`);
-      return;
-    }
-    const pending = pendingPermRequests.get(requestId);
-    pendingPermRequests.delete(requestId);
-    refreshToolExecConsumerMarker();
-    const params = { request_id: requestId };
-    if (action === 'deny') {
-      params.behavior = 'deny';
-    } else if (action === 'session') {
-      params.behavior = 'allow';
-      const toolName = pending?.toolName;
-      if (toolName) {
-        params.updatedPermissions = [{ type: 'addRules', rules: [{ toolName }], behavior: 'allow', destination: 'session' }];
-      }
-    } else {
-      params.behavior = 'allow';
-    }
-    sendNotifyToParent('notifications/claude/channel/permission', params);
-    const labels = { allow: 'Approved', session: 'Session Approved', deny: 'Denied' };
-    if (interaction.message?.id && interaction.channelId) {
-      editDiscordMessage(interaction.channelId, interaction.message.id, labels[action] || action);
-    }
-    return;
-  }
-  if (interaction.customId?.startsWith("perm-")) {
-    const match = interaction.customId.match(/^perm-([0-9a-f]{32})-(allow|session|deny)$/);
-    if (!match) return;
-    const [, uuid, action] = match;
-    const access = getConfig().access;
-    if (!access) {
-      const _permDropLine = `[${localTimestamp()}] perm interaction dropped: no access getConfig()\n`;
-      if (isMixdogDebug()) {
-        fs.appendFileSync(_bootLog, _permDropLine);
-      } else {
-        appendSessionStartCriticalLog(DATA_DIR, `[channels] ${_permDropLine}`);
-      }
-      return;
-    }
-    if (access.allowFrom?.length > 0 && !access.allowFrom.includes(interaction.userId)) {
-      process.stderr.write(`mixdog: perm button rejected \u2014 user ${interaction.userId} not in allowFrom
-`);
-      return;
-    }
-    const resultPaths = [getPermissionResultPath(instanceId, uuid)];
-    const leadInstanceId = String(TERMINAL_LEAD_PID);
-    if (leadInstanceId && leadInstanceId !== instanceId) {
-      resultPaths.push(getPermissionResultPath(leadInstanceId, uuid));
-    }
-    for (const resultPath of resultPaths) {
-      try {
-        fs.writeFileSync(resultPath, action, { flag: "wx" });
-      } catch (e) {
-        if (e.code !== "EEXIST") {
-          process.stderr.write(`mixdog: writePermissionResult failed: ${e.message}\n`);
-        }
-      }
-    }
-    const labels = { allow: "Approved", session: "Session Approved", deny: "Denied" };
-    if (interaction.message?.id && interaction.channelId) {
-      editDiscordMessage(interaction.channelId, interaction.message.id, labels[action] || action);
-    }
-    return;
-  }
+getProvider().onInteraction = (interaction) => {
   if (!getBridgeRuntimeConnected() || !getBridgeOwnershipSnapshot().owned) {
     refreshBridgeOwnershipSafe();
     return;
@@ -256,5 +67,4 @@ getBackend().onInteraction = (interaction) => {
     }
   });
 };
-  return { pendingPermRequests, refreshToolExecConsumerMarker };
 }