@stevederico/dotbot 0.16.0

package/storage/MongoAdapter.js

@@ -0,0 +1,291 @@
+import crypto from 'crypto';
+import { SessionStore } from './SessionStore.js';
+import { toStandardFormat } from '../core/normalize.js';
+
+/**
+ * Default system prompt builder for DotBot agent
+ *
+ * @param {Object} options - Agent identity overrides
+ * @param {string} [options.agentName='Dottie'] - Display name
+ * @param {string} [options.agentPersonality=''] - Personality/tone
+ * @returns {string} System prompt
+ */
+export function defaultSystemPrompt({ agentName = 'Dottie', agentPersonality = '' } = {}) {
+  const now = new Date().toISOString();
+  return `You are a helpful personal AI assistant called ${agentName}.${agentPersonality ? `\nYour personality and tone: ${agentPersonality}. Embody this in all responses.` : ''}
+You have access to tools for searching the web, reading/writing files, fetching URLs, running code, long-term memory, and scheduled tasks.
+The current date and time is ${now}.
+
+Use tools when they would help answer the user's question — don't guess when you can look things up.
+Keep responses concise and useful. When you use a tool, explain what you found.
+
+Memory guidelines:
+- When the user shares personal info (name, preferences, projects, goals), save it with memory_save.
+- When the user references past conversations or asks "do you remember", search with memory_search.
+- When the user asks to forget something, use memory_search to find the key, then memory_delete to remove it.
+- Be selective — only save things worth recalling in future conversations.
+- Don't announce every memory save unless the user would want to know.
+
+Scheduling guidelines:
+- When the user asks for a reminder, periodic check, or recurring job, use schedule_job.
+- Write the prompt as if the user is asking you to do something when the job fires.
+- For recurring jobs, suggest a reasonable interval if the user doesn't specify one.
+
+Follow-up suggestions:
+- At the end of every response, suggest one natural follow-up question the user might ask next.
+- Format: <followup>Your suggested question here</followup>
+- Keep it short, specific to the conversation context, and genuinely useful.
+- Do not include the followup tag when using tools or in error responses.`;
+}
+
+/**
+ * MongoDB-backed SessionStore implementation
+ */
+export class MongoSessionStore extends SessionStore {
+  constructor() {
+    super();
+    this.collection = null;
+    this.prefsFetcher = null;
+    this.systemPromptBuilder = defaultSystemPrompt;
+    this.heartbeatEnsurer = null;
+  }
+
+  /**
+   * Initialize MongoDB session store
+   *
+   * @param {import('mongodb').Db} db - MongoDB database instance
+   * @param {Object} [options={}] - Initialization options
+   * @param {Function} [options.prefsFetcher] - Async function (userId) => { agentName, agentPersonality }
+   * @param {Function} [options.systemPromptBuilder] - Function ({ agentName, agentPersonality }) => string
+   * @param {Function} [options.heartbeatEnsurer] - Async function (userId) => Promise<Object|null>
+   */
+  async init(db, options = {}) {
+    this.collection = db.collection('sessions');
+    this.prefsFetcher = options.prefsFetcher || null;
+    this.systemPromptBuilder = options.systemPromptBuilder || defaultSystemPrompt;
+    this.heartbeatEnsurer = options.heartbeatEnsurer || null;
+
+    await this.collection.createIndex({ id: 1 }, { unique: true }).catch(() => {});
+    await this.collection.createIndex({ owner: 1, updatedAt: -1 }).catch(() => {});
+
+    // Migrate legacy sessions: documents without an `owner` field
+    const legacy = await this.collection.find({ owner: { $exists: false } }).toArray();
+    for (const doc of legacy) {
+      const oldId = doc.id;
+      const newId = crypto.randomUUID();
+      const firstUserMsg = doc.messages?.find((m) => m.role === 'user');
+      const title = firstUserMsg ? firstUserMsg.content.slice(0, 60) : '';
+      await this.collection.updateOne(
+        { _id: doc._id },
+        { $set: { id: newId, owner: oldId, title, updatedAt: doc.updatedAt || new Date() } }
+      );
+    }
+
+    if (legacy.length > 0) {
+      console.log(`[sessions] migrated ${legacy.length} legacy session(s)`);
+    }
+
+    // Migrate existing sessions to standard message format.
+    // Detects provider-specific messages by checking for Anthropic content arrays
+    // or OpenAI tool_calls properties, then normalizes them. Idempotent — already
+    // normalized sessions pass through unchanged.
+    const allSessions = await this.collection.find({}).toArray();
+    let migrated = 0;
+    for (const doc of allSessions) {
+      if (!Array.isArray(doc.messages) || doc.messages.length === 0) continue;
+
+      const needsNormalization = doc.messages.some(
+        (m) => (m.role === 'assistant' && Array.isArray(m.content)) ||
+               (m.role === 'assistant' && m.tool_calls) ||
+               (m.role === 'tool') ||
+               (m.role === 'user' && Array.isArray(m.content) && m.content.some(b => b.type === 'tool_result'))
+      );
+
+      if (needsNormalization) {
+        const normalized = toStandardFormat(doc.messages);
+        await this.collection.updateOne(
+          { _id: doc._id },
+          { $set: { messages: normalized } }
+        );
+        migrated++;
+      }
+    }
+
+    if (migrated > 0) {
+      console.log(`[sessions] normalized messages in ${migrated} session(s)`);
+    }
+
+    console.log('[sessions] initialized with MongoDB (multi-session)');
+  }
+
+  /**
+   * Build system prompt with current timestamp
+   *
+   * @param {string} owner - User ID
+   * @returns {Promise<string>} System prompt
+   */
+  async buildSystemPrompt(owner) {
+    const prefs = this.prefsFetcher ? await this.prefsFetcher(owner) : {};
+    return this.systemPromptBuilder(prefs);
+  }
+
+  async createSession(owner, model = 'gpt-oss:20b', provider = 'ollama') {
+    if (!this.collection) throw new Error('Sessions not initialized. Call init() first.');
+
+    const session = {
+      id: crypto.randomUUID(),
+      owner,
+      title: '',
+      messages: [{ role: 'system', content: await this.buildSystemPrompt(owner) }],
+      model,
+      provider,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+    await this.collection.insertOne(session);
+    return session;
+  }
+
+  async getOrCreateDefaultSession(owner) {
+    if (!this.collection) throw new Error('Sessions not initialized. Call init() first.');
+
+    let session = await this.collection.findOne({ owner }, { sort: { updatedAt: -1 } });
+    if (!session) {
+      session = await this.createSession(owner);
+    } else {
+      // Refresh system prompt timestamp
+      session.messages[0] = { role: 'system', content: await this.buildSystemPrompt(owner) };
+    }
+    if (this.heartbeatEnsurer) {
+      this.heartbeatEnsurer(owner).catch((err) => {
+        console.error(`[session] failed to ensure heartbeat for ${owner}:`, err.message);
+      });
+    }
+    return session;
+  }
+
+  async getSession(sessionId, owner) {
+    if (!this.collection) throw new Error('Sessions not initialized. Call init() first.');
+
+    const session = await this.collection.findOne({ id: sessionId, owner });
+    if (!session) return null;
+
+    // Refresh system prompt timestamp
+    session.messages[0] = { role: 'system', content: await this.buildSystemPrompt(owner) };
+    return session;
+  }
+
+  async getSessionInternal(sessionId) {
+    if (!this.collection) throw new Error('Sessions not initialized. Call init() first.');
+
+    const session = await this.collection.findOne({ id: sessionId });
+    if (!session) return null;
+
+    session.messages[0] = { role: 'system', content: await this.buildSystemPrompt(session.owner) };
+    return session;
+  }
+
+  /**
+   * Save session with normalized messages.
+   * Converts any provider-specific message formats to standard format before persisting.
+   *
+   * @param {string} sessionId - Session UUID
+   * @param {Array} messages - Messages (provider-specific or standard format)
+   * @param {string} model - Model identifier
+   * @param {string} [provider] - Provider name
+   */
+  async saveSession(sessionId, messages, model, provider) {
+    const update = {
+      messages: toStandardFormat(messages),
+      model,
+      updatedAt: new Date(),
+    };
+
+    if (provider) {
+      update.provider = provider;
+    }
+
+    // Auto-populate title from first user message if empty
+    const session = await this.collection.findOne({ id: sessionId });
+    if (session && !session.title) {
+      const firstUserMsg = update.messages.find((m) => m.role === 'user');
+      if (firstUserMsg && typeof firstUserMsg.content === 'string') {
+        update.title = firstUserMsg.content.slice(0, 60);
+      }
+    }
+
+    await this.collection.updateOne({ id: sessionId }, { $set: update });
+  }
+
+  /**
+   * Add a message to a session, normalizing to standard format before saving.
+   *
+   * @param {string} sessionId - Session UUID
+   * @param {Object} message - Message object (any provider format)
+   * @returns {Promise<Object>} Updated session
+   */
+  async addMessage(sessionId, message) {
+    const session = await this.getSessionInternal(sessionId);
+    if (!session) throw new Error(`Session ${sessionId} not found`);
+    if (!message._ts) message._ts = Date.now();
+    // Normalize the single message by running it through toStandardFormat,
+    // then append all resulting messages (may be 0 if it was a bare tool_result)
+    const normalized = toStandardFormat([message]);
+    session.messages.push(...normalized);
+    await this.saveSession(sessionId, session.messages, session.model);
+    return session;
+  }
+
+  async setModel(sessionId, model) {
+    await this.collection.updateOne({ id: sessionId }, { $set: { model, updatedAt: new Date() } });
+  }
+
+  async setProvider(sessionId, provider) {
+    await this.collection.updateOne({ id: sessionId }, { $set: { provider, updatedAt: new Date() } });
+  }
+
+  async clearSession(sessionId) {
+    const session = await this.collection.findOne({ id: sessionId });
+    const messages = [{ role: 'system', content: await this.buildSystemPrompt(session?.owner) }];
+    await this.collection.updateOne(
+      { id: sessionId },
+      { $set: { messages, updatedAt: new Date() } }
+    );
+  }
+
+  async listSessions(owner) {
+    return await this.collection
+      .aggregate([
+        { $match: { owner } },
+        { $sort: { updatedAt: -1 } },
+        { $limit: 50 },
+        {
+          $project: {
+            id: 1,
+            title: 1,
+            model: 1,
+            provider: 1,
+            createdAt: 1,
+            updatedAt: 1,
+            messageCount: { $size: { $ifNull: ['$messages', []] } }
+          }
+        }
+      ])
+      .toArray()
+      .then((docs) =>
+        docs.map((d) => ({
+          id: d.id,
+          title: d.title || '',
+          model: d.model,
+          provider: d.provider || 'ollama',
+          createdAt: d.createdAt,
+          updatedAt: d.updatedAt,
+          messageCount: d.messageCount || 0,
+        }))
+      );
+  }
+
+  async deleteSession(sessionId, owner) {
+    return await this.collection.deleteOne({ id: sessionId, owner });
+  }
+}

package/storage/MongoCronAdapter.js

@@ -0,0 +1,347 @@
+import { CronStore } from './CronStore.js';
+import {
+  HEARTBEAT_INTERVAL_MS,
+  HEARTBEAT_CONCURRENCY,
+  HEARTBEAT_PROMPT,
+  runWithConcurrency,
+  parseInterval,
+} from './cron_constants.js';
+
+/**
+ * MongoDB-backed CronStore implementation
+ */
+export class MongoCronStore extends CronStore {
+  constructor() {
+    super();
+    this.collection = null;
+    this.onTaskFire = null;
+    this.pollInterval = null;
+  }
+
+  /**
+   * Initialize MongoDB cron store
+   *
+   * @param {import('mongodb').Db} db - MongoDB database instance
+   * @param {Object} options
+   * @param {Function} options.onTaskFire - Callback when a task fires: (task) => Promise<void>
+   */
+  async init(db, options = {}) {
+    this.collection = db.collection('cron_tasks');
+    this.onTaskFire = options.onTaskFire;
+
+    await this.collection.createIndex({ nextRunAt: 1 }).catch(() => {});
+    await this.collection.createIndex({ sessionId: 1 }).catch(() => {});
+    await this.collection.createIndex({ userId: 1, name: 1 }).catch(() => {});
+
+    // Deduplicate existing heartbeats before adding the unique index
+    const dupes = await this.collection.aggregate([
+      { $match: { name: 'heartbeat', enabled: true, userId: { $exists: true } } },
+      { $sort: { createdAt: -1 } },
+      { $group: { _id: '$userId', ids: { $push: '$_id' }, count: { $sum: 1 } } },
+      { $match: { count: { $gt: 1 } } },
+    ]).toArray();
+    if (dupes.length > 0) {
+      const idsToRemove = dupes.flatMap(d => d.ids.slice(1));
+      const result = await this.collection.deleteMany({ _id: { $in: idsToRemove } });
+      console.log(`[cron] cleaned up ${result.deletedCount} duplicate heartbeat(s) for ${dupes.length} user(s)`);
+    }
+
+    // One enabled heartbeat per user — enforced at DB level
+    await this.collection.createIndex(
+      { userId: 1, name: 1, enabled: 1 },
+      { unique: true, partialFilterExpression: { name: 'heartbeat', enabled: true } }
+    ).catch(() => {});
+
+    // Start polling every 30 seconds
+    this.pollInterval = setInterval(() => this.checkTasks(), 30 * 1000);
+    // Also check immediately on startup
+    await this.checkTasks();
+
+    console.log('[cron] initialized with MongoDB, polling every 30s');
+  }
+
+  stop() {
+    if (this.pollInterval) clearInterval(this.pollInterval);
+  }
+
+  /**
+   * Check for tasks that are due and fire them
+   */
+  async checkTasks() {
+    if (!this.collection || !this.onTaskFire) return;
+
+    try {
+      const now = new Date();
+
+      const dueTasks = await this.collection
+        .find({ nextRunAt: { $lte: now }, enabled: true })
+        .toArray();
+
+      if (dueTasks.length === 0) return;
+
+      const heartbeats = dueTasks.filter(t => t.name === 'heartbeat');
+      const others = dueTasks.filter(t => t.name !== 'heartbeat');
+
+      /** Process a single task: fire callback, then update schedule */
+      const processTask = async (task) => {
+        try {
+          await this.onTaskFire(task);
+          if (task.recurring && task.intervalMs) {
+            const nextRun = new Date(now.getTime() + task.intervalMs);
+            await this.collection.updateOne(
+              { _id: task._id },
+              { $set: { nextRunAt: nextRun, lastRunAt: now } }
+            );
+          } else {
+            await this.collection.updateOne(
+              { _id: task._id },
+              { $set: { enabled: false, lastRunAt: now } }
+            );
+          }
+        } catch (err) {
+          console.error(`[cron] error firing task ${task.name}:`, err.message);
+        }
+      };
+
+      // Heartbeats run in parallel with a concurrency cap
+      if (heartbeats.length > 0) {
+        console.log(`[cron] firing ${heartbeats.length} heartbeat(s) (concurrency: ${HEARTBEAT_CONCURRENCY})`);
+        await runWithConcurrency(
+          heartbeats.map(t => () => processTask(t)),
+          HEARTBEAT_CONCURRENCY
+        );
+      }
+
+      // Other tasks (user-scheduled) run sequentially
+      for (const task of others) {
+        await processTask(task);
+      }
+    } catch (err) {
+      console.error(`[cron] checkTasks query failed:`, err.message);
+    }
+  }
+
+  async createTask({ name, prompt, sessionId, userId, runAt, intervalMs, recurring, taskId }) {
+    const task = {
+      name,
+      prompt,
+      sessionId: sessionId || 'default',
+      nextRunAt: new Date(runAt),
+      intervalMs: intervalMs || null,
+      recurring: recurring || false,
+      enabled: true,
+      createdAt: new Date(),
+      lastRunAt: null,
+    };
+    if (userId) task.userId = userId;
+    if (taskId) task.taskId = taskId;
+
+    const result = await this.collection.insertOne(task);
+    return { id: result.insertedId, ...task };
+  }
+
+  async listTasks(sessionId) {
+    return await this.collection
+      .find({ sessionId: sessionId || 'default', name: { $ne: 'heartbeat' } })
+      .sort({ nextRunAt: 1 })
+      .toArray()
+      .then((docs) =>
+        docs.map((d) => ({
+          id: d._id.toString(),
+          name: d.name,
+          prompt: d.prompt,
+          nextRunAt: d.nextRunAt,
+          recurring: d.recurring,
+          intervalMs: d.intervalMs,
+          enabled: d.enabled,
+          lastRunAt: d.lastRunAt,
+        }))
+      );
+  }
+
+  async listTasksBySessionIds(sessionIds, userId = null) {
+    if (!this.collection || sessionIds.length === 0) return [];
+    const query = { sessionId: { $in: [...sessionIds, 'default'] }, name: { $ne: 'heartbeat' } };
+    if (userId) {
+      query.$or = [
+        { userId: userId },
+        { userId: { $exists: false } },
+        { userId: null }
+      ];
+    }
+    return await this.collection
+      .find(query)
+      .sort({ nextRunAt: 1 })
+      .toArray()
+      .then(docs => docs.map(d => ({
+        id: d._id.toString(),
+        name: d.name,
+        prompt: d.prompt,
+        sessionId: d.sessionId,
+        nextRunAt: d.nextRunAt,
+        recurring: d.recurring,
+        intervalMs: d.intervalMs,
+        enabled: d.enabled,
+        lastRunAt: d.lastRunAt,
+        createdAt: d.createdAt,
+      })));
+  }
+
+  async getTask(id) {
+    const { ObjectId } = await import('mongodb');
+    const task = await this.collection.findOne({ _id: new ObjectId(id) });
+    if (!task) return null;
+    return {
+      id: task._id.toString(),
+      name: task.name,
+      prompt: task.prompt,
+      sessionId: task.sessionId,
+      nextRunAt: task.nextRunAt,
+      recurring: task.recurring,
+      intervalMs: task.intervalMs,
+      enabled: task.enabled,
+      lastRunAt: task.lastRunAt,
+      createdAt: task.createdAt,
+    };
+  }
+
+  async deleteTask(id) {
+    const { ObjectId } = await import('mongodb');
+    return await this.collection.deleteOne({ _id: new ObjectId(id) });
+  }
+
+  async toggleTask(id, enabled) {
+    const { ObjectId } = await import('mongodb');
+    return await this.collection.updateOne(
+      { _id: new ObjectId(id) },
+      { $set: { enabled } }
+    );
+  }
+
+  async updateTask(id, updates) {
+    const { ObjectId } = await import('mongodb');
+    const updateFields = {};
+    if (updates.name !== undefined) updateFields.name = updates.name;
+    if (updates.prompt !== undefined) updateFields.prompt = updates.prompt;
+    if (updates.runAt !== undefined) updateFields.nextRunAt = new Date(updates.runAt);
+    if (updates.intervalMs !== undefined) updateFields.intervalMs = updates.intervalMs;
+    if (updates.recurring !== undefined) updateFields.recurring = updates.recurring;
+
+    return await this.collection.updateOne(
+      { _id: new ObjectId(id) },
+      { $set: updateFields }
+    );
+  }
+
+  async ensureHeartbeat(userId) {
+    if (!this.collection || !userId) {
+      console.log(`[cron] ensureHeartbeat skipped: collection=${!!this.collection}, userId=${userId}`);
+      return null;
+    }
+
+    const jitter = Math.floor(Math.random() * HEARTBEAT_INTERVAL_MS);
+    const now = new Date();
+
+    // Atomic upsert — eliminates race conditions
+    const result = await this.collection.updateOne(
+      { userId, name: 'heartbeat', enabled: true },
+      {
+        $setOnInsert: {
+          name: 'heartbeat',
+          prompt: HEARTBEAT_PROMPT,
+          userId,
+          sessionId: 'default',
+          nextRunAt: new Date(now.getTime() + jitter),
+          intervalMs: HEARTBEAT_INTERVAL_MS,
+          recurring: true,
+          enabled: true,
+          createdAt: now,
+          lastRunAt: null,
+        },
+      },
+      { upsert: true }
+    );
+
+    if (result.upsertedId) {
+      console.log(`[cron] created heartbeat for user ${userId}, first run in ${Math.round(jitter / 60000)}m`);
+      return { id: result.upsertedId };
+    }
+
+    // Auto-update stale prompt
+    const existing = await this.collection.findOne({ userId, name: 'heartbeat', enabled: true });
+    if (existing && existing.prompt !== HEARTBEAT_PROMPT) {
+      await this.collection.updateOne({ _id: existing._id }, { $set: { prompt: HEARTBEAT_PROMPT } });
+      console.log(`[cron] updated heartbeat prompt for user ${userId}`);
+    }
+
+    return null;
+  }
+
+  async getHeartbeatStatus(userId) {
+    if (!this.collection || !userId) return null;
+    const task = await this.collection.findOne({ userId, name: 'heartbeat' });
+    if (!task) return null;
+    return {
+      id: task._id.toString(),
+      enabled: task.enabled,
+      nextRunAt: task.nextRunAt,
+      lastRunAt: task.lastRunAt,
+      createdAt: task.createdAt,
+      intervalMs: task.intervalMs,
+      prompt: task.prompt,
+    };
+  }
+
+  async resetHeartbeat(userId) {
+    if (!this.collection || !userId) return null;
+
+    // Delete existing heartbeat(s)
+    await this.collection.deleteMany({ userId, name: 'heartbeat' });
+    console.log(`[cron] deleted existing heartbeat(s) for user ${userId}`);
+
+    // Create fresh heartbeat
+    const jitter = Math.floor(Math.random() * HEARTBEAT_INTERVAL_MS);
+    const now = new Date();
+    const task = {
+      name: 'heartbeat',
+      prompt: HEARTBEAT_PROMPT,
+      userId,
+      sessionId: 'default',
+      nextRunAt: new Date(now.getTime() + jitter),
+      intervalMs: HEARTBEAT_INTERVAL_MS,
+      recurring: true,
+      enabled: true,
+      createdAt: now,
+      lastRunAt: null,
+    };
+    const result = await this.collection.insertOne(task);
+    console.log(`[cron] created new heartbeat for user ${userId}, first run in ${Math.round(jitter / 60000)}m`);
+    return { id: result.insertedId, ...task };
+  }
+
+  async triggerHeartbeatNow(userId) {
+    if (!this.collection || !userId || !this.onTaskFire) return false;
+
+    const heartbeat = await this.collection.findOne({ userId, name: 'heartbeat', enabled: true });
+    if (!heartbeat) {
+      console.log(`[cron] manual trigger failed: no enabled heartbeat for user ${userId}`);
+      return false;
+    }
+
+    console.log(`[cron] manually triggering heartbeat for user ${userId}`);
+    try {
+      await this.onTaskFire(heartbeat);
+      await this.collection.updateOne(
+        { _id: heartbeat._id },
+        { $set: { lastRunAt: new Date() } }
+      );
+      return true;
+    } catch (err) {
+      console.error(`[cron] manual trigger error:`, err.message);
+      return false;
+    }
+  }
+}
+
+// Re-export utility functions for tool definitions (from cron_constants.js)
+export { parseInterval, HEARTBEAT_INTERVAL_MS, HEARTBEAT_PROMPT } from './cron_constants.js';