mixdog 0.9.24 → 0.9.26

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

@@ -3,7 +3,7 @@ import { join } from "path";
 import { DiscordBackend } from "../backends/discord.mjs";
 import { TelegramBackend } from "../backends/telegram.mjs";
 import { readSection, updateSection, CONFIG_PATH as MIXDOG_CONFIG_PATH, getDiscordToken, getTelegramToken, diagnoseDiscordTokenValue } from "../../shared/config.mjs";
-import { listSchedules } from "../../shared/schedules-store.mjs";
+import { listSchedules } from "../../shared/schedules-db.mjs";
 import { resolvePluginData } from "../../shared/plugin-paths.mjs";
 const DATA_DIR = resolvePluginData();
 const CONFIG_FILE = MIXDOG_CONFIG_PATH;
@@ -63,19 +63,21 @@ function resolveChannelId(raw = {}, backend = "discord") {
   return "";
 }
 
-function loadConfig() {
+async function loadConfig() {
   try {
     let raw = readSection("channels");
     raw = raw && typeof raw === "object" ? raw : {};
-    // Schedules live in the Mixdog data dir under `schedules/<name>/` (single
-    // source of truth). The legacy `raw.schedules.items` / `raw.nonInteractive`
-    // / `raw.interactive` arrays in mixdog-config.json are no longer read.
-    const scheduleEntries = listSchedules().filter((s) => s.enabled !== false);
-    // Channel-presence routing (no `type` field): an entry WITH a channel is
-    // dispatched directly to that channel; an entry WITHOUT a channel is
-    // injected into the current (Lead) session. Mirrors the webhook model.
-    raw.nonInteractive = scheduleEntries.filter((i) => !!i.channel);
-    raw.interactive = scheduleEntries.filter((i) => !i.channel);
+    // Schedules are the PG `scheduler.schedules` table (single source of
+    // truth). The legacy SCHEDULE.md store and the `raw.schedules.items` /
+    // `raw.nonInteractive` / `raw.interactive` arrays in mixdog-config.json
+    // are no longer read. Done one-shots are dropped so they never re-arm.
+    const scheduleEntries = (await listSchedules())
+      .filter((s) => s.enabled !== false && s.status !== "done");
+    // `target` drives routing: 'channel' → non-interactive dispatch to the
+    // schedule's channel_id; 'session' → inject into the current (Lead)
+    // session. Mirrors the webhook model.
+    raw.nonInteractive = scheduleEntries.filter((s) => s.target === "channel");
+    raw.interactive = scheduleEntries.filter((s) => s.target === "session");
     const accessChannels = { ...raw.access?.channels ?? {} };
     // voice config lives at the top level of mixdog-config.json (peer of
     // channels), so readSection("channels") never sees it. Pull it explicitly.

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

@@ -10,6 +10,9 @@ import { isNetworkError, retryOnNetwork } from "./network-retry.mjs";
 // preserving): serial inbound queue, backend.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,
   getConfig,
@@ -283,6 +286,46 @@ async function handleInbound(msg, route, options = {}) {
     }
   }
   const hasVoiceAtt = voiceAtts.length > 0;
+  // ── Inbound image attachments → downloaded local paths (vision) ──────
+  // Mirror the voice path: download image/* attachments to the inbox and
+  // hand their local paths downstream so the agent session can attach them
+  // as real image content blocks. A short per-attempt timeout bounds the
+  // serial inboundQueue against a slow/broken image; on failure we degrade
+  // to the metadata-only marker (attMeta below) instead of dropping.
+  const imageAtts = msg.attachments.filter((a) => isImageAttachment(a.contentType));
+  let imagePaths = [];
+  if (imageAtts.length > 0) {
+    try {
+      const files = (await retryOnNetwork(
+        () => getBackend().downloadAttachment(msg.chatId, msg.messageId, {
+          timeoutMs: 20_000,
+          filter: (a) => isImageAttachment(a.contentType),
+        }),
+        { label: "image.download" }
+      )) || [];
+      imagePaths = imageAtts
+        .map((a) => files.find((df) => df.id === a.id) ?? null)
+        .filter(Boolean)
+        .map((f) => f.path)
+        .filter((p) => typeof p === "string" && p.length > 0);
+      if (imagePaths.length > 0) {
+        process.stderr.write(`mixdog: inbound images downloaded (${imagePaths.length})\n`);
+      }
+    } catch (err) {
+      const netFail = isNetworkError(err);
+      process.stderr.write(`mixdog: image.download error${netFail ? " (network, retries exhausted)" : ""}: ${err}\n`);
+      const marker = netFail
+        ? "[attachment: image download failed (network)]"
+        : "[attachment: image download failed]";
+      text = text ? `${text} ${marker}` : marker;
+    }
+  }
+  // An image-only message can arrive with empty text; channelNotificationModelContent
+  // drops empty content (runtime-core), which would strip meta.image_paths and lose
+  // the image. Give it a non-empty marker so the notification (and its images) flow.
+  if (imagePaths.length > 0 && !String(text || "").trim()) {
+    text = "[image]";
+  }
   const attMeta = msg.attachments.length > 0 && !hasVoiceAtt ? {
     attachment_count: String(msg.attachments.length),
     attachments: msg.attachments.map((a) => `${a.name} (${a.contentType}, ${(a.size / 1024).toFixed(0)}KB)`).join("; ")
@@ -300,7 +343,8 @@ async function handleInbound(msg, route, options = {}) {
       ...route.sourceLabel ? { source_label: route.sourceLabel } : {}
     } : {},
     ...attMeta,
-    ...msg.imagePath ? { image_path: msg.imagePath } : {}
+    ...msg.imagePath ? { image_path: msg.imagePath } : {},
+    ...imagePaths.length > 0 ? { image_paths: JSON.stringify(imagePaths) } : {}
   };
   const notificationContent = messageBody;
   sendNotifyToParent("notifications/claude/channel", {

package/src/runtime/channels/lib/memory-client.mjs

@@ -4,6 +4,7 @@ import os from 'node:os'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { createStandaloneMemoryRuntime } from '../../../standalone/memory-runtime-proxy.mjs'
+import { readServicePort, markServiceUnreachable, isConnRefuseError } from '../../shared/service-discovery.mjs'
 
 const RUNTIME_ROOT = process.env.MIXDOG_RUNTIME_ROOT
   ? path.resolve(process.env.MIXDOG_RUNTIME_ROOT)
@@ -60,9 +61,28 @@ function isConnRefusedLike(err) {
     || /ECONNREFUSED|missing memory_port|memory-service timeout/i.test(msg)
 }
 
+// A discovery advert validates only the owner pid, which can be a recycled pid
+// living on an unrelated process while its advertised port is dead. This client
+// has no separate /health probe, so on a connect-level failure we distrust the
+// port: mark it unreachable (readServicePort then skips it → legacy fallback)
+// and drop the port cache so the next getMemoryPort re-resolves.
+function _distrustMemoryPort(port, err) {
+  // Connection-level failures ONLY. A 'memory-service timeout' means the daemon
+  // is slow-but-alive — distrusting it would false-route to legacy/buffer.
+  if (port && isConnRefuseError(err)) {
+    markServiceUnreachable('memory', port)
+    _portCache = null
+  }
+}
+
 async function getMemoryPort() {
   const now = Date.now()
   if (_portCache && (now - _portCache.ts) < 5_000) return _portCache.port
+  // Prefer the single-writer discovery advert (discovery/memory.json), which
+  // validates the owner pid is alive. Fall back to the legacy
+  // active-instance.json memory_port field for cross-version compat.
+  const advertPort = readServicePort('memory', { requirePid: false })
+  if (advertPort) { _portCache = { port: advertPort, mtime: 0, ts: now }; return advertPort }
   try {
     const stat = await fs.promises.stat(ACTIVE_INSTANCE_FILE)
     const mtime = stat.mtimeMs
@@ -115,8 +135,8 @@ async function memoryFetch(method, endpoint, body = null, timeoutMs = 10_000, {
         resolve(parsed)
       })
     })
-    req.on('error', reject)
-    req.on('timeout', () => { req.destroy(); reject(new Error('memory-service timeout')) })
+    req.on('error', err => { _distrustMemoryPort(port, err); reject(err) })
+    req.on('timeout', () => { req.destroy(); const err = new Error('memory-service timeout'); _distrustMemoryPort(port, err); reject(err) })
     if (payload) req.write(payload)
     req.end()
   })

package/src/runtime/channels/lib/owned-runtime.mjs

@@ -407,7 +407,7 @@ async function refreshBridgeOwnership(options = {}) {
 async function reloadRuntimeConfig() {
   const previousBackend = getBackend();
   const previousBackendName = previousBackend?.name || "";
-  setConfig(loadConfig());
+  setConfig(await loadConfig());
   scheduler.reloadConfig(
     getConfig().nonInteractive ?? [],
     getConfig().interactive ?? [],