mixdog 0.9.4 → 0.9.5

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

@@ -5,7 +5,6 @@ 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 { resolvePluginData } from "../../shared/plugin-paths.mjs";
-import { isHolidaySync } from "./holidays.mjs";
 const DATA_DIR = resolvePluginData();
 const CONFIG_FILE = MIXDOG_CONFIG_PATH;
 const DEFAULT_ACCESS = {
@@ -18,34 +17,16 @@ const DEFAULT_CONFIG = {
   discord: { token: "" },
   telegram: { token: "" },
   access: DEFAULT_ACCESS,
-  mainChannel: "main",
-  channelsConfig: {
-    main: { channelId: "", mode: "interactive" }
-  }
+  channel: { channelId: "" }
 };
-// Shared defaults layer (DND / per-channel respectQuiet). Merge
-// semantics: user values win; defaults only fill missing fields.
-// Helper is exported so the setup UI and runtime both produce the same
-// shape when the file has missing sections.
+// Shared defaults layer. Merge semantics: user values win; defaults
+// only fill missing fields. Helper is exported so the setup UI and
+// runtime both produce the same shape when the file has missing sections.
 const CONFIG_DEFAULTS = {
-  quiet: { schedule: "23:00-09:00", holidays: false },
-  schedules: { respectQuiet: true },
-  webhook: { enabled: true, respectQuiet: false }
+  webhook: { enabled: true }
 };
-const DEFAULT_HOLIDAY_COUNTRY = "KR";
-function normalizeHolidaySetting(value) {
-  if (value === true) return DEFAULT_HOLIDAY_COUNTRY;
-  if (typeof value === "string") {
-    const code = value.trim().toUpperCase();
-    return /^[A-Z]{2}$/.test(code) ? code : false;
-  }
-  return false;
-}
 function applyDefaults(config) {
   const out = { ...(config || {}) };
-  out.quiet = { ...CONFIG_DEFAULTS.quiet, ...(out.quiet || {}) };
-  out.quiet.holidays = normalizeHolidaySetting(out.quiet.holidays);
-  out.schedules = { ...CONFIG_DEFAULTS.schedules, ...(out.schedules || {}) };
   out.webhook = { ...CONFIG_DEFAULTS.webhook, ...(out.webhook || {}) };
   return out;
 }
@@ -57,126 +38,31 @@ function channelIdForBackend(entry = {}, backend = "discord") {
   return String(entry?.discordChannelId || (entry?.telegramChatId ? "" : entry?.channelId) || "");
 }
 
-function channelsConfigForBackend(rawChannelsConfig = {}, backend = "discord") {
-  return Object.fromEntries(Object.entries(rawChannelsConfig || {}).map(([name, entry]) => {
-    const value = entry && typeof entry === "object" ? entry : {};
-    const channelId = channelIdForBackend(value, backend);
-    return [name, { ...value, channelId }];
-  }));
-}
-
-/**
- * Shared DND / quiet-window helper used by scheduler + webhook.
- *
- * Signature contract (as of 0.1.62):
- *   isInQuietWindow(cfg, now = new Date(), tz = null) -> boolean
- *
- * `cfg` accepts exactly two shapes (top-level config with `.quiet`
- * subtree, or a flat `{ schedule, holidays }` descriptor); anything
- * else returns `false`.
- *
- * `tz` is an optional IANA timezone. When set, both the schedule
- * window (HH:MM) and the holiday/weekend day are evaluated in that
- * zone; when absent, the host's local timezone is used (unchanged
- * behavior for callers that omit it, e.g. webhook.mjs).
- *
- * Behavior:
- *   - Schedule window uses "HH:MM-HH:MM". Midnight-crossing windows
- *     (start > end, e.g. "23:00-09:00") are honored. When start === end
- *     the window is treated as empty/never (preserved doc-ambiguous
- *     behavior — callers should avoid that shape).
- *   - `holidays` enabled AND today is a recognized holiday  => true,
- *     regardless of schedule window.
- *   - `holidays === false` or missing => holidays ignored.
- *
- * Holiday detection strategy (0.1.63):
- *   Sync, non-blocking lookup via holidays.mjs `isHolidaySync`, backed
- *   by a pre-warmed in-memory cache (Nager-sourced). The `holidays`
- *   value doubles as the ISO country code (`true` => default country).
- *   - cache WARM  => real public-holiday data (weekday holidays count).
- *   - cache COLD  => documented fallback: weekend-only (Sat/Sun), while
- *     an async warm is kicked off for the next evaluation. No blocking
- *     I/O and no heuristics beyond this weekend fallback.
- *
- * Exported so scheduler.mjs and webhook.mjs can share one implementation.
- */
-// Day-of-week and HH:MM for `now`, in `tz` when given, else host-local.
-// An invalid IANA `tz` makes `Intl.DateTimeFormat` throw a RangeError;
-// we catch it once and fall back to host-local rather than propagating.
-function quietDayTime(now, tz) {
-  if (tz) {
-    try {
-      const parts = new Intl.DateTimeFormat("en-US", {
-        hour12: false, timeZone: tz,
-        hour: "2-digit", minute: "2-digit", weekday: "short",
-      }).formatToParts(now).reduce((acc, p) => { acc[p.type] = p.value; return acc; }, {});
-      const hour = parts.hour === "24" ? "00" : parts.hour;
-      const dowMap = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 };
-      return {
-        dow: dowMap[parts.weekday] ?? now.getDay(),
-        hhmm: `${hour}:${parts.minute}`,
-      };
-    } catch {
-      // Invalid timezone — fall through to host-local.
+// Resolve the single active-backend channel id from the config's `channel`
+// section. Backward compat (read-side only, no on-disk migration): when
+// `channel` is absent, fall back to the legacy `channelsConfig[mainChannel]`
+// entry (or the first entry that carries an id).
+function resolveChannelId(raw = {}, backend = "discord") {
+  const channel = raw.channel && typeof raw.channel === "object" ? raw.channel : null;
+  if (channel) return channelIdForBackend(channel, backend);
+  const legacy = raw.channelsConfig && typeof raw.channelsConfig === "object" ? raw.channelsConfig : null;
+  if (legacy) {
+    const mainName = raw.mainChannel ?? "main";
+    const preferred = legacy[mainName];
+    if (preferred && typeof preferred === "object") {
+      const id = channelIdForBackend(preferred, backend);
+      if (id) return id;
     }
-  }
-  return {
-    dow: now.getDay(),
-    hhmm: `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`,
-  };
-}
-// Return the target calendar day as a plain 'YYYY-MM-DD' string, in `tz`
-// when given (else host-local). A string (not a Date) keeps the holiday
-// contract symmetric: isHolidaySync compares the same string, so there
-// is no UTC<->local round-trip to shift the day on UTC+12..+14 hosts.
-// An invalid IANA `tz` throws a RangeError; catch once, fall to local.
-function quietHolidayDateStr(now, tz) {
-  if (tz) {
-    try {
-      const parts = new Intl.DateTimeFormat("en-CA", {
-        timeZone: tz, year: "numeric", month: "2-digit", day: "2-digit",
-      }).formatToParts(now).reduce((acc, p) => { acc[p.type] = p.value; return acc; }, {});
-      return `${parts.year}-${parts.month}-${parts.day}`;
-    } catch {
-      // Invalid timezone — fall through to host-local.
+    for (const entry of Object.values(legacy)) {
+      if (entry && typeof entry === "object") {
+        const id = channelIdForBackend(entry, backend);
+        if (id) return id;
+      }
     }
   }
-  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+  return "";
 }
-function isInQuietWindow(cfg, now = new Date(), tz = null) {
-  if (!cfg || typeof cfg !== "object") return false;
-  // Auto-detect shape: prefer cfg.quiet when present, else treat cfg as
-  // the flat { schedule, holidays } descriptor.
-  const quiet = cfg.quiet && typeof cfg.quiet === "object" ? cfg.quiet : cfg;
-  const schedule = quiet.schedule;
-  const holidaysOn = quiet.holidays === true || (typeof quiet.holidays === "string" && !!quiet.holidays.trim());
-  const country = quiet.holidays === true
-    ? DEFAULT_HOLIDAY_COUNTRY
-    : (typeof quiet.holidays === "string" ? quiet.holidays.trim().toUpperCase() : null);
-
-  // Holiday branch: toggle on AND today qualifies => quiet regardless of window.
-  // Sync, pre-warmed cache lookup; cold cache falls back to weekend-only.
-  if (holidaysOn) {
-    const holiday = isHolidaySync(quietHolidayDateStr(now, tz), country);
-    if (holiday === true) return true;
-    if (holiday === null) {
-      // Cold cache: documented Sat/Sun fallback until the async warm lands.
-      const { dow } = quietDayTime(now, tz);
-      if (dow === 0 || dow === 6) return true;
-    }
-    // Warm cache + not a holiday: fall through to the schedule window.
-  }
 
-  // Schedule window check (TZ-aware when tz is set; host-local otherwise).
-  if (!schedule || typeof schedule !== "string") return false;
-  const parts = schedule.split("-");
-  if (parts.length !== 2) return false;
-  const [start, end] = parts;
-  // start === end => empty window (never matches); documented caveat.
-  const { hhmm } = quietDayTime(now, tz);
-  if (start > end) return hhmm >= start || hhmm < end; // midnight-crossing
-  return hhmm >= start && hhmm < end;
-}
 function loadConfig() {
   try {
     let raw = readSection("channels");
@@ -207,12 +93,16 @@ function loadConfig() {
     // Anything else falls back to the discord default.
     const backend = raw.backend === "telegram" ? "telegram" : "discord";
     const telegramToken = getTelegramToken();
-    const rawChannelsConfig = { ...DEFAULT_CONFIG.channelsConfig, ...(raw.channelsConfig || {}) };
+    const channelId = resolveChannelId(raw, backend);
+    // Drop legacy multi-channel keys from the returned shape; the runtime
+    // reads only the resolved `channelId` now (read-side compat lives in
+    // resolveChannelId — no on-disk migration).
+    const { channelsConfig: _legacyChannels, mainChannel: _legacyMain, ...rawRest } = raw;
     return applyDefaults({
       ...DEFAULT_CONFIG,
-      ...raw,
+      ...rawRest,
       backend,
-      channelsConfig: channelsConfigForBackend(rawChannelsConfig, backend),
+      channelId,
       discord: { ...DEFAULT_CONFIG.discord, ...(({ token: _, ...rest }) => rest)(raw.discord || {}), ...(discordToken && !discordTokenProblem ? { token: discordToken } : {}) },
       // Merge the keychain-resolved telegram token (harmless when backend is
       // discord; the secret never lands in the on-disk config either way).
@@ -235,7 +125,7 @@ function loadConfig() {
       updateSection("channels", () => DEFAULT_CONFIG);
       process.stderr.write(
         `mixdog: default channels config created in ${MIXDOG_CONFIG_PATH}
-  edit discord.token and channelsConfig.main.channelId to connect.
+  edit discord.token and channel.channelId to connect.
 `
       );
       return applyDefaults(DEFAULT_CONFIG);
@@ -290,9 +180,9 @@ function createBackend(config) {
       configPath: CONFIG_FILE,
       access: config.access,
       // Single-source channel setup: the main chat is auto-allowed inside
-      // TelegramBackend.loadAccess() so a configured channelsConfig.main.channelId
+      // TelegramBackend.loadAccess() so a configured channel.channelId
       // is enough for both inbound gating and outbound.
-      mainChannelId: config.channelsConfig?.main?.channelId
+      mainChannelId: config.channelId
     }, tgStateDir);
   }
   const discordToken = getDiscordToken();
@@ -311,9 +201,9 @@ function createBackend(config) {
     configPath: CONFIG_FILE,
     access: config.access,
     // Single-source channel setup: the main channel is auto-allowed inside
-    // DiscordBackend.loadAccess() so a configured channelsConfig.main.channelId
+    // DiscordBackend.loadAccess() so a configured channel.channelId
     // is enough for both inbound and outbound — no separate access.channels entry.
-    mainChannelId: config.channelsConfig?.main?.channelId
+    mainChannelId: config.channelId
   }, stateDir);
 }
 const PROFILE_FILE = join(DATA_DIR, "profile.json");
@@ -326,11 +216,9 @@ function loadProfileConfig() {
 }
 export {
   DATA_DIR,
-  DEFAULT_HOLIDAY_COUNTRY,
   createBackend,
   getDiscordToken,
   getTelegramToken,
-  isInQuietWindow,
   loadConfig,
   loadProfileConfig
 };

package/src/runtime/channels/lib/event-pipeline.mjs

@@ -3,11 +3,11 @@ import { applyParser, evaluateFilter, applyTemplate } from "./executor.mjs";
 class EventPipeline {
   rules;
   queue;
-  constructor(config, channelsConfig) {
+  constructor(config, channelId) {
     const rawRules = config?.rules;
     this.rules = (Array.isArray(rawRules) ? rawRules : [])
       .filter((r) => r && typeof r === "object" && r.enabled !== false);
-    this.queue = new EventQueue(config?.queue, channelsConfig);
+    this.queue = new EventQueue(config?.queue, channelId);
   }
   getQueue() {
     return this.queue;
@@ -18,11 +18,11 @@ class EventPipeline {
   stop() {
     this.queue.stop();
   }
-  reloadConfig(config, channelsConfig) {
+  reloadConfig(config, channelId) {
     const rawRules = config?.rules;
     this.rules = (Array.isArray(rawRules) ? rawRules : [])
       .filter((r) => r && typeof r === "object" && r.enabled !== false);
-    this.queue.reloadConfig(config?.queue, channelsConfig);
+    this.queue.reloadConfig(config?.queue, channelId);
   }
   // ── Source: webhook ───────────────────────────────────────────────
   /** Handle an incoming webhook event */

package/src/runtime/channels/lib/event-queue.mjs

@@ -38,7 +38,7 @@ function finiteInt(value, { min, max, def }) {
 }
 class EventQueue {
   config;
-  channelsConfig;
+  channelId;
   tickTimer = null;
   batchTimer = null;
   _processQueueRunning = false;
@@ -54,9 +54,9 @@ class EventQueue {
   // Counter is 8-digit zero-padded so lex sort matches numeric order.
   enqueueSeq = 0;
   // track files already notified during active state
-  constructor(config, channelsConfig) {
+  constructor(config, channelId) {
     this.config = config ?? {};
-    this.channelsConfig = channelsConfig ?? null;
+    this.channelId = channelId ?? "";
   }
   setInjectHandler(fn) {
     this.injectFn = fn;
@@ -101,10 +101,10 @@ class EventQueue {
       this.initialTickTimer = null;
     }
   }
-  reloadConfig(config, channelsConfig) {
+  reloadConfig(config, channelId) {
     this.stop();
     this.config = config ?? {};
-    this.channelsConfig = channelsConfig ?? null;
+    this.channelId = channelId ?? "";
     this.start();
   }
   // ── Enqueue ───────────────────────────────────────────────────────
@@ -392,10 +392,16 @@ ${p.item.prompt}`).join("\n\n")}`;
       return false;
     }
   }
-  resolveChannel(label) {
-    if (!label || !this.channelsConfig) return "";
-    const entry = this.channelsConfig?.[label];
-    return entry?.channelId ?? label;
+  // The frontmatter `channel` key is a boolean-ish flag: any non-empty value
+  // except "false" means post to the single main channel; absent → inject.
+  // A pure-digit / snowflake value is honored verbatim as an explicit id
+  // override (matches resolveWebhookChannelId in index.mjs).
+  resolveChannel(flag) {
+    if (flag == null) return "";
+    const v = String(flag).trim();
+    if (v === "" || v.toLowerCase() === "false") return "";
+    if (/^-?\d+$/.test(v)) return v;
+    return this.channelId ?? "";
   }
   /** Remove items from queue — after processing, dismissal, or any resolution */
   resolveItems(name, status = "done") {

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

@@ -59,52 +59,15 @@ function createInboundRouting({ getConfig, getInstanceId, getChannelOwnerPath })
 
   function resolveInboundRoute(chatId, parentChatId) {
     const config = getConfig();
-    const main = config.channelsConfig?.main;
-    const findEntry = (id) => {
-      if (!id || !config.channelsConfig) return null;
-      if (typeof main === "object" && main !== null && main.channelId === id) {
-        return { label: "main", entry: main };
-      }
-      for (const [label, entry] of Object.entries(config.channelsConfig)) {
-        if (typeof entry === "object" && entry !== null && entry.channelId === id) {
-          return { label, entry };
-        }
-      }
-      return null;
-    };
-    // Prefer a direct channelsConfig match on the thread/channel id; fall back
-    // to the parent channel id so thread messages inherit the parent's label
-    // and mode (e.g. monitor) instead of being routed as untagged interactive.
-    const direct = findEntry(chatId);
-    if (direct) {
-      const mode = direct.entry.mode === "monitor" ? "monitor" : (direct.entry.mode || "interactive");
-      return { targetChatId: chatId, sourceChatId: chatId, sourceLabel: direct.label, sourceMode: mode };
-    }
-    if (parentChatId) {
-      const viaParent = findEntry(parentChatId);
-      if (viaParent) {
-        const mode = viaParent.entry.mode === "monitor" ? "monitor" : (viaParent.entry.mode || "interactive");
-        return { targetChatId: chatId, sourceChatId: parentChatId, sourceLabel: viaParent.label, sourceMode: mode };
-      }
-    }
+    // Single main channel: there is no per-channel label/mode map anymore.
+    // Every inbound message routes as interactive to its own chat id.
     return { targetChatId: chatId, sourceChatId: chatId, sourceLabel: undefined, sourceMode: "interactive" };
   }
 
-  // ── Reverse-lookup channelId → human label from channelsConfig ──────────────
-  function labelForChannelId(channelId) {
-    const config = getConfig();
-    if (!channelId || !config.channelsConfig) return channelId;
-    for (const [label, entry] of Object.entries(config.channelsConfig)) {
-      if (entry?.channelId === channelId) return label;
-    }
-    return channelId;
-  }
-
   return {
     writeChannelOwner,
     shouldDropDuplicateInbound,
     resolveInboundRoute,
-    labelForChannelId,
   };
 }
 

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

@@ -22,28 +22,15 @@ class PendingInteractionStore {
     this.patch(userId, channelId, { _msgId: messageId });
   }
 }
-function getPendingSelectUpdate(customId, values) {
-  const value = values?.[0];
-  if (!value) return null;
-  const scheduleMatch = customId.match(/^sched_(add|edit)_(period|exec|mode)$/);
-  if (scheduleMatch) {
-    return { [scheduleMatch[2]]: value };
-  }
-  if (customId === "quiet_holidays_select") {
-    return { holidays: value };
-  }
-  if (customId === "activity_mode_select") {
-    return { activityMode: value };
-  }
-  return null;
-}
 function buildModalRequestSpec(customId, pending, profile) {
   switch (customId) {
     case "sched_add_next": {
       const fields = [
         { id: "name", label: "Name", required: true },
         { id: "time", label: "Cron expression (e.g. 0 9 * * 1-5)", required: true },
-        { id: "channel", label: "Channel", required: false, value: "general" }
+        // Single main channel: `channel` is a boolean-ish flag (true → post
+        // to the main channel, empty/false → inject into the Lead session).
+        { id: "channel", label: "Post to channel? (true / false)", required: false, value: "true" }
       ];
       if (pending.exec?.includes("script")) {
         fields.push({ id: "script", label: "Script filename", required: true });
@@ -54,19 +41,10 @@ function buildModalRequestSpec(customId, pending, profile) {
         fields
       };
     }
-    case "quiet_set_next":
-      return {
-        customId: "modal_quiet",
-        title: "Quiet Hours",
-        fields: [
-          { id: "schedule", label: "Schedule quiet hours (e.g. 23:00-07:00)", required: false }
-        ]
-      };
     case "sched_edit_next": {
       const fields = [
         { id: "time", label: "Cron expression (e.g. 0 9 * * 1-5)", required: false },
-        { id: "channel", label: "Channel", required: false },
-        { id: "dnd", label: "Quiet hours (e.g. 23:00-07:00, leave empty to disable)", required: false }
+        { id: "channel", label: "Post to channel? (true / false)", required: false }
       ];
       if (pending.exec?.includes("script")) {
         fields.push({ id: "script", label: "Script filename", required: false });
@@ -77,15 +55,6 @@ function buildModalRequestSpec(customId, pending, profile) {
         fields
       };
     }
-    case "activity_add_next":
-      return {
-        customId: "modal_activity_add",
-        title: "Add Activity Channel",
-        fields: [
-          { id: "name", label: "Channel Name", required: true },
-          { id: "id", label: "Channel ID", required: true }
-        ]
-      };
     case "profile_edit":
       return {
         customId: "modal_profile_edit",
@@ -101,84 +70,7 @@ function buildModalRequestSpec(customId, pending, profile) {
       return null;
   }
 }
-function buildModalExecutionPlan(customId, pending, fields) {
-  switch (customId) {
-    case "modal_sched_add": {
-      const params = {
-        time: fields.time,
-        channel: fields.channel || "general",
-        mode: pending.mode || "non-interactive",
-        period: pending.period || "daily",
-        exec: pending.exec || "prompt"
-      };
-      if (fields.script) params.script = fields.script;
-      return {
-        commands: [{ target: "bot", args: ["schedule", "add", fields.name], params }],
-        followup: { target: "bot", args: ["schedule", "list"], params: {} }
-      };
-    }
-    case "modal_quiet": {
-      const commands = [];
-      if (fields.schedule) commands.push({ target: "bot", args: ["quiet", "schedule", fields.schedule], params: {} });
-      if (pending.holidays && pending.holidays !== "none") {
-        commands.push({ target: "bot", args: ["quiet", "holidays", pending.holidays], params: {} });
-      }
-      return {
-        commands,
-        followup: { target: "bot", args: ["quiet", "list"], params: {} }
-      };
-    }
-    case "modal_sched_edit": {
-      const name = pending.editName;
-      if (!name) return null;
-      const params = {};
-      if (fields.time) params.time = fields.time;
-      if (fields.channel) params.channel = fields.channel;
-      if (pending.period) params.period = pending.period;
-      if (pending.exec) params.exec = pending.exec;
-      if (pending.mode) params.mode = pending.mode;
-      if (fields.script) params.script = fields.script;
-      const commands = [
-        { target: "bot", args: ["schedule", "edit", name], params }
-      ];
-      if (fields.dnd) {
-        commands.push({ target: "bot", args: ["quiet", "schedule", fields.dnd], params: {} });
-      }
-      return {
-        commands,
-        followup: { target: "bot", args: ["schedule", "detail", name], params: {} }
-      };
-    }
-    case "modal_activity_add":
-      return {
-        commands: [{
-          target: "bot",
-          args: ["activity", "add", fields.name],
-          params: {
-            id: fields.id,
-            mode: pending.activityMode || "interactive"
-          }
-        }],
-        followup: { target: "bot", args: ["activity", "list"], params: {} }
-      };
-    case "modal_profile_edit": {
-      const params = {};
-      if (fields.name) params.name = fields.name;
-      if (fields.role) params.role = fields.role;
-      if (fields.lang) params.lang = fields.lang;
-      if (fields.tone) params.tone = fields.tone;
-      return {
-        commands: Object.keys(params).length > 0 ? [{ target: "profile", args: ["set"], params }] : [],
-        followup: { target: "bot", args: ["profile", "list"], params: {} }
-      };
-    }
-    default:
-      return null;
-  }
-}
 export {
   PendingInteractionStore,
-  buildModalExecutionPlan,
-  buildModalRequestSpec,
-  getPendingSelectUpdate
+  buildModalRequestSpec
 };