mixdog 0.7.1

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

@@ -0,0 +1,184 @@
+function stateKey(userId, channelId) {
+  return `${userId}:${channelId}`;
+}
+class PendingInteractionStore {
+  states = /* @__PURE__ */ new Map();
+  get(userId, channelId) {
+    return { ...this.states.get(stateKey(userId, channelId)) ?? {} };
+  }
+  set(userId, channelId, state) {
+    this.states.set(stateKey(userId, channelId), state);
+  }
+  patch(userId, channelId, update) {
+    const next = { ...this.get(userId, channelId), ...update };
+    this.set(userId, channelId, next);
+    return next;
+  }
+  delete(userId, channelId) {
+    this.states.delete(stateKey(userId, channelId));
+  }
+  rememberMessage(userId, channelId, messageId) {
+    if (!messageId) return;
+    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" }
+      ];
+      if (pending.exec?.includes("script")) {
+        fields.push({ id: "script", label: "Script filename", required: true });
+      }
+      return {
+        customId: "modal_sched_add",
+        title: "Add Schedule",
+        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 }
+      ];
+      if (pending.exec?.includes("script")) {
+        fields.push({ id: "script", label: "Script filename", required: false });
+      }
+      return {
+        customId: "modal_sched_edit",
+        title: `${pending.editName ?? "Schedule"} Edit`,
+        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",
+        title: "Edit Profile",
+        fields: [
+          { id: "name", label: "Name", required: false, value: profile.name ?? "" },
+          { id: "role", label: "Role", required: false, value: profile.role ?? "" },
+          { id: "lang", label: "Language (ko / en / ja / zh)", required: false, value: profile.lang ?? "" },
+          { id: "tone", label: "Tone", required: false, value: profile.tone ?? "" }
+        ]
+      };
+    default:
+      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
+};

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

@@ -0,0 +1,149 @@
+import http from 'node:http'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+const RUNTIME_ROOT = process.env.MIXDOG_RUNTIME_ROOT
+  ? path.resolve(process.env.MIXDOG_RUNTIME_ROOT)
+  : path.join(os.tmpdir(), 'mixdog')
+const ACTIVE_INSTANCE_FILE = path.join(RUNTIME_ROOT, 'active-instance.json')
+
+let _portCache = null // { port, mtime, ts }
+
+async function getMemoryPort() {
+  const now = Date.now()
+  if (_portCache && (now - _portCache.ts) < 5_000) return _portCache.port
+  try {
+    const stat = await fs.promises.stat(ACTIVE_INSTANCE_FILE)
+    const mtime = stat.mtimeMs
+    if (_portCache && _portCache.mtime === mtime) {
+      _portCache.ts = now
+      return _portCache.port
+    }
+    const raw = await fs.promises.readFile(ACTIVE_INSTANCE_FILE, 'utf8')
+    const active = JSON.parse(raw)
+    const port = Number(active && active.memory_port)
+    if (!Number.isFinite(port) || port <= 0) return null
+    _portCache = { port, mtime, ts: now }
+    return port
+  } catch {
+    return null
+  }
+}
+
+async function memoryFetch(method, endpoint, body = null, timeoutMs = 10_000) {
+  const port = await getMemoryPort()
+  return new Promise((resolve, reject) => {
+    if (!port) { reject(new Error('active-instance.json missing memory_port')); return }
+    const payload = body ? JSON.stringify(body) : null
+    const req = http.request({
+      hostname: '127.0.0.1',
+      port,
+      path: endpoint,
+      method,
+      headers: payload
+        ? { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) }
+        : {},
+      timeout: timeoutMs,
+    }, res => {
+      let data = ''
+      res.on('data', chunk => { data += chunk })
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)) }
+        catch { resolve({ raw: data }) }
+      })
+    })
+    req.on('error', reject)
+    req.on('timeout', () => { req.destroy(); reject(new Error('memory-service timeout')) })
+    if (payload) req.write(payload)
+    req.end()
+  })
+}
+
+const BUFFER_DIR = path.join(RUNTIME_ROOT, 'memory-buffer')
+
+function normalizeTs(ts) {
+  if (typeof ts === 'number' && Number.isFinite(ts)) {
+    return ts < 1e12 ? ts * 1000 : ts
+  }
+  const parsed = Date.parse(String(ts ?? ''))
+  return Number.isFinite(parsed) ? parsed : Date.now()
+}
+
+export async function appendEntry(data) {
+  const payload = {
+    ts: normalizeTs(data.ts),
+    role: String(data.role ?? 'user'),
+    content: String(data.content ?? ''),
+    sourceRef: String(data.sourceRef ?? `manual:${Date.now()}-${process.pid}`),
+    sessionId: data.sessionId ?? null,
+    cwd: data.cwd ?? null,
+  }
+  // Bounded fast attempt. On failure, buffer to disk immediately and let
+  // the periodic drainer ship buffered entries when the service is back.
+  // Caller is fire-and-forget (channels worker), so capping the tail at
+  // ~3s prevents promises from lingering on minute-long timeouts.
+  try {
+    return await memoryFetch('POST', '/entry', payload, 3_000)
+  } catch (e) {
+    process.stderr.write(`[memory-client] appendEntry failed (${e.message}) — buffering\n`)
+    try {
+      fs.mkdirSync(BUFFER_DIR, { recursive: true })
+      const random = Math.random().toString(36).slice(2, 10)
+      const bufferPath = path.join(BUFFER_DIR, `entry-${Date.now()}-${random}.json`)
+      fs.writeFileSync(bufferPath, JSON.stringify(payload, null, 2))
+      return { ok: false, buffered: true, path: bufferPath }
+    } catch (bufErr) {
+      process.stderr.write(`[memory-client] Failed to buffer entry: ${bufErr.message}\n`)
+      return { ok: false }
+    }
+  }
+}
+
+export async function ingestTranscript(filePath, { cwd } = {}) {
+  try {
+    return await memoryFetch('POST', '/ingest-transcript', { filePath, ...(cwd ? { cwd } : {}) })
+  } catch (e) {
+    process.stderr.write(`[memory-client] ingestTranscript failed: ${e.message}\n`)
+    return { ok: false }
+  }
+}
+
+export async function listCoreMemories(args = {}) {
+  const rawProjectId = args && Object.prototype.hasOwnProperty.call(args, 'project_id')
+    ? args.project_id
+    : args?.projectScope
+  const projectId = rawProjectId == null || rawProjectId === 'all' ? '*' : rawProjectId
+  const result = await memoryFetch('POST', '/api/tool', {
+    name: 'memory',
+    arguments: {
+      action: 'core',
+      op: 'list',
+      project_id: projectId,
+    },
+  }, 30_000)
+  if (!result || result.error) {
+    throw new Error(result?.error || 'core memory list: empty response')
+  }
+  return result
+}
+
+export async function searchMemories(args = {}) {
+  const result = await memoryFetch('POST', '/api/tool', {
+    name: 'search_memories',
+    arguments: args && typeof args === 'object' ? args : {},
+  }, 30_000)
+  if (!result || result.error) {
+    throw new Error(result?.error || 'memory_search: empty response')
+  }
+  return result
+}
+
+export async function isHealthy() {
+  try {
+    const result = await memoryFetch('GET', '/health')
+    return result.status === 'ok'
+  } catch {
+    return false
+  }
+}