mercury-agent 0.4.5

package/src/core/space-queue.ts

@@ -0,0 +1,103 @@
+type Work<T> = () => Promise<T>;
+
+export class SpaceQueue {
+  private readonly perSpacePending = new Map<string, Array<() => void>>();
+  private readonly activeSpaces = new Set<string>();
+  private activeGlobal = 0;
+
+  constructor(private readonly maxConcurrency: number) {}
+
+  enqueue<T>(spaceId: string, work: Work<T>): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+      const run = async () => {
+        this.activeGlobal += 1;
+        this.activeSpaces.add(spaceId);
+        try {
+          resolve(await work());
+        } catch (error) {
+          reject(error);
+        } finally {
+          this.activeGlobal -= 1;
+          this.activeSpaces.delete(spaceId);
+          this.startNext(spaceId);
+          this.drainOtherSpaces();
+        }
+      };
+
+      const queue = this.perSpacePending.get(spaceId) ?? [];
+      queue.push(run);
+      this.perSpacePending.set(spaceId, queue);
+      this.drainOtherSpaces();
+    });
+  }
+
+  cancelAll(): number {
+    let total = 0;
+    for (const [_spaceId, queue] of this.perSpacePending) {
+      total += queue.length;
+    }
+    this.perSpacePending.clear();
+    return total;
+  }
+
+  get activeCount(): number {
+    return this.activeGlobal;
+  }
+
+  get pendingCount(): number {
+    let total = 0;
+    for (const queue of this.perSpacePending.values()) {
+      total += queue.length;
+    }
+    return total;
+  }
+
+  waitForActive(timeoutMs: number): Promise<boolean> {
+    if (this.activeGlobal === 0) return Promise.resolve(true);
+    return new Promise<boolean>((resolve) => {
+      const checkInterval = setInterval(() => {
+        if (this.activeGlobal === 0) {
+          clearInterval(checkInterval);
+          resolve(true);
+        }
+      }, 100);
+      setTimeout(() => {
+        clearInterval(checkInterval);
+        resolve(this.activeGlobal === 0);
+      }, timeoutMs);
+    });
+  }
+
+  cancelPending(spaceId: string): number {
+    const queue = this.perSpacePending.get(spaceId);
+    if (!queue || queue.length === 0) return 0;
+    const count = queue.length;
+    this.perSpacePending.delete(spaceId);
+    return count;
+  }
+
+  isActive(spaceId: string): boolean {
+    return this.activeSpaces.has(spaceId);
+  }
+
+  private canStart(spaceId: string): boolean {
+    return (
+      this.activeGlobal < this.maxConcurrency && !this.activeSpaces.has(spaceId)
+    );
+  }
+
+  private startNext(spaceId: string): void {
+    const queue = this.perSpacePending.get(spaceId);
+    if (!queue || queue.length === 0 || !this.canStart(spaceId)) return;
+    const next = queue.shift();
+    if (queue.length === 0) this.perSpacePending.delete(spaceId);
+    next?.();
+  }
+
+  private drainOtherSpaces(): void {
+    for (const spaceId of this.perSpacePending.keys()) {
+      if (this.activeGlobal >= this.maxConcurrency) return;
+      this.startNext(spaceId);
+    }
+  }
+}

package/src/core/storage-cleanup.ts

@@ -0,0 +1,140 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { AppConfig } from "../config.js";
+import type { Logger } from "../logger.js";
+import type { Db } from "../storage/db.js";
+
+interface CleanupOpts {
+  config: AppConfig;
+  db: Db;
+  log: Logger;
+  isSpaceActive: (spaceId: string) => boolean;
+}
+
+interface CleanupResult {
+  spacesScanned: number;
+  spacesSkipped: number;
+  filesDeleted: number;
+  bytesFreed: number;
+  attachmentsNullified: number;
+}
+
+/**
+ * Scan all space directories and delete inbox/outbox files older than their TTL.
+ * Skips spaces with active container runs.
+ */
+export async function runStorageCleanup(
+  opts: CleanupOpts,
+): Promise<CleanupResult> {
+  const { config, db, log, isSpaceActive } = opts;
+  const spacesDir = config.spacesDir;
+  const inboxMaxAge = config.inboxTtlDays * 24 * 60 * 60 * 1000;
+  const outboxMaxAge = config.outboxTtlDays * 24 * 60 * 60 * 1000;
+  const now = Date.now();
+
+  const result: CleanupResult = {
+    spacesScanned: 0,
+    spacesSkipped: 0,
+    filesDeleted: 0,
+    bytesFreed: 0,
+    attachmentsNullified: 0,
+  };
+
+  let spaceDirs: string[];
+  try {
+    spaceDirs = fs
+      .readdirSync(spacesDir, { withFileTypes: true })
+      .filter((e) => e.isDirectory())
+      .map((e) => e.name);
+  } catch {
+    return result;
+  }
+
+  for (const spaceId of spaceDirs) {
+    result.spacesScanned++;
+
+    if (isSpaceActive(spaceId)) {
+      result.spacesSkipped++;
+      continue;
+    }
+
+    const spaceDir = path.join(spacesDir, spaceId);
+    let inboxCleaned = false;
+
+    const inboxResult = cleanDir(
+      path.join(spaceDir, "inbox"),
+      now,
+      inboxMaxAge,
+    );
+    result.filesDeleted += inboxResult.deleted;
+    result.bytesFreed += inboxResult.bytesFreed;
+    if (inboxResult.deleted > 0) inboxCleaned = true;
+
+    const outboxResult = cleanDir(
+      path.join(spaceDir, "outbox"),
+      now,
+      outboxMaxAge,
+    );
+    result.filesDeleted += outboxResult.deleted;
+    result.bytesFreed += outboxResult.bytesFreed;
+
+    if (inboxCleaned) {
+      const nullified = db.clearSpaceAttachments(spaceId);
+      result.attachmentsNullified += nullified;
+    }
+  }
+
+  if (result.filesDeleted > 0) {
+    log.info("Storage cleanup complete", {
+      spacesScanned: result.spacesScanned,
+      spacesSkipped: result.spacesSkipped,
+      filesDeleted: result.filesDeleted,
+      bytesFreed: result.bytesFreed,
+      attachmentsNullified: result.attachmentsNullified,
+    });
+  }
+
+  return result;
+}
+
+function cleanDir(
+  dir: string,
+  now: number,
+  maxAgeMs: number,
+): { deleted: number; bytesFreed: number } {
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return { deleted: 0, bytesFreed: 0 };
+  }
+
+  let deleted = 0;
+  let bytesFreed = 0;
+
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    if (entry.name.startsWith(".")) continue;
+
+    const filePath = path.join(dir, entry.name);
+
+    let stat: fs.Stats;
+    try {
+      stat = fs.statSync(filePath);
+    } catch {
+      continue;
+    }
+
+    if (now - stat.mtimeMs < maxAgeMs) continue;
+
+    try {
+      fs.unlinkSync(filePath);
+      deleted++;
+      bytesFreed += stat.size;
+    } catch {
+      // File may have been deleted between stat and unlink
+    }
+  }
+
+  return { deleted, bytesFreed };
+}

package/src/core/storage-guard.ts

@@ -0,0 +1,24 @@
+import { statfs } from "node:fs/promises";
+import type { AppConfig } from "../config.js";
+
+/**
+ * Check whether the agent's data directory is over its disk quota.
+ * Returns false (fail-open) when:
+ *   - maxDiskMb is unset (local/self-hosted — no enforcement)
+ *   - statfs fails (Windows, unmounted dir)
+ *   - statfs returns 0 total bytes (unknown filesystem)
+ */
+export async function isOverQuota(config: AppConfig): Promise<boolean> {
+  if (!config.maxDiskMb) return false;
+
+  try {
+    const fs = await statfs(config.spacesDir);
+    const totalBytes = fs.blocks * fs.bsize;
+    if (totalBytes === 0) return false;
+    const freeBytes = fs.bavail * fs.bsize;
+    const usedBytes = totalBytes - freeBytes;
+    return usedBytes > config.maxDiskMb * 1024 * 1024;
+  } catch {
+    return false;
+  }
+}

package/src/core/task-scheduler.ts

@@ -0,0 +1,132 @@
+import { CronExpressionParser } from "cron-parser";
+import { logger } from "../logger.js";
+import type { Db } from "../storage/db.js";
+
+type TaskHandler = (task: {
+  id: number;
+  spaceId: string;
+  prompt: string;
+  createdBy: string;
+  silent: boolean;
+}) => Promise<void>;
+
+export class TaskScheduler {
+  private timer: NodeJS.Timeout | null = null;
+  private handler: TaskHandler | null = null;
+
+  constructor(
+    private readonly db: Db,
+    private readonly pollIntervalMs = 5_000,
+  ) {}
+
+  start(handler: TaskHandler) {
+    if (this.timer) return;
+    this.handler = handler;
+    this.recalculateNextRuns();
+
+    const tick = async () => {
+      try {
+        const due = this.db.getDueTasks(Date.now());
+        for (const task of due) {
+          // For cron tasks, update next run before execution
+          // For at-tasks, we'll delete after execution
+          if (task.cron) {
+            const next = this.computeNextRun(
+              task.cron,
+              task.timezone ?? undefined,
+            );
+            this.db.updateTaskNextRun(task.id, next);
+          }
+
+          try {
+            await handler({
+              id: task.id,
+              spaceId: task.spaceId,
+              prompt: task.prompt,
+              createdBy: task.createdBy,
+              silent: task.silent === 1,
+            });
+          } catch (error) {
+            logger.error("Scheduler task handler failed", {
+              taskId: task.id,
+              spaceId: task.spaceId,
+              error: error instanceof Error ? error.message : String(error),
+            });
+          }
+
+          // For at-tasks, delete after execution (regardless of success/failure)
+          if (task.at) {
+            this.db.deleteTaskById(task.id);
+            logger.info("One-shot task completed and deleted", {
+              taskId: task.id,
+              spaceId: task.spaceId,
+            });
+          }
+        }
+      } catch (error) {
+        logger.error(
+          "Scheduler error",
+          error instanceof Error ? error : undefined,
+        );
+      } finally {
+        this.timer = setTimeout(tick, this.pollIntervalMs);
+      }
+    };
+
+    this.timer = setTimeout(tick, this.pollIntervalMs);
+  }
+
+  stop() {
+    if (!this.timer) return;
+    clearTimeout(this.timer);
+    this.timer = null;
+  }
+
+  computeNextRun(cron: string, timezone?: string, from = new Date()): number {
+    try {
+      const interval = CronExpressionParser.parse(cron, {
+        currentDate: from,
+        tz: timezone ?? "UTC",
+      });
+      return interval.next().getTime();
+    } catch {
+      // Timezone rejected by cron-parser — fall back to UTC
+      const interval = CronExpressionParser.parse(cron, { currentDate: from });
+      return interval.next().getTime();
+    }
+  }
+
+  private recalculateNextRuns(): void {
+    const tasks = this.db.listTasks();
+    let updated = 0;
+    for (const task of tasks) {
+      if (!task.active || !task.cron) continue;
+      const correct = this.computeNextRun(
+        task.cron,
+        task.timezone ?? undefined,
+      );
+      if (correct !== task.nextRunAt) {
+        this.db.updateTaskNextRun(task.id, correct);
+        updated++;
+      }
+    }
+    if (updated > 0) {
+      logger.info(`Recalculated next_run_at for ${updated} cron task(s)`);
+    }
+  }
+
+  async triggerTask(taskId: number): Promise<boolean> {
+    if (!this.handler) return false;
+    const task = this.db.getTask(taskId);
+    if (!task?.active) return false;
+
+    await this.handler({
+      id: task.id,
+      spaceId: task.spaceId,
+      prompt: task.prompt,
+      createdBy: task.createdBy,
+      silent: task.silent === 1,
+    });
+    return true;
+  }
+}

package/src/core/telegram-format.ts

@@ -0,0 +1,178 @@
+/**
+ * Convert agent Markdown-style output to Telegram HTML for parse_mode.
+ * Order: escape → [text](url) → (https://…) anchors → ### headers → **bold** → *italic* → collapse nested <b>.
+ */
+
+export const TELEGRAM_MESSAGE_LIMIT = 4096;
+
+export function escapeHtml(text: string): string {
+  return text
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
+
+/** Telegram HTML rejects nested identical tags (e.g. <b><b>x</b></b>). */
+function collapseNestedBold(html: string): string {
+  let out = html;
+  let prev: string;
+  do {
+    prev = out;
+    out = out.replace(/<b>\s*<b>/g, "<b>").replace(/<\/b>\s*<\/b>/g, "</b>");
+  } while (out !== prev);
+  return out;
+}
+
+function hrefAttr(url: string): string {
+  return url.replace(/"/g, "&quot;");
+}
+
+/**
+ * Wrap (https://...) style URLs so the closing ")" is not part of the link target
+ * and Telegram gets a valid <a href>.
+ */
+function parentheticalUrlsToAnchors(html: string): string {
+  return html.replace(
+    /\((https?:\/\/[^)\s<]+)\)/g,
+    (_, url: string) => `(<a href="${hrefAttr(url)}">${url}</a>)`,
+  );
+}
+
+type TelegramOpenTag = "b" | "i" | "a";
+
+/** Tags produced by markdownToTelegramHtml (Telegram HTML parse_mode). */
+function collectOpenTelegramTags(s: string): TelegramOpenTag[] {
+  const stack: TelegramOpenTag[] = [];
+  let i = 0;
+  while (i < s.length) {
+    if (s[i] !== "<") {
+      i++;
+      continue;
+    }
+    if (s.startsWith("</b>", i)) {
+      if (stack[stack.length - 1] === "b") stack.pop();
+      i += 4;
+      continue;
+    }
+    if (s.startsWith("</i>", i)) {
+      if (stack[stack.length - 1] === "i") stack.pop();
+      i += 4;
+      continue;
+    }
+    if (s.startsWith("</a>", i)) {
+      if (stack[stack.length - 1] === "a") stack.pop();
+      i += 4;
+      continue;
+    }
+    if (s.startsWith("<b>", i)) {
+      stack.push("b");
+      i += 3;
+      continue;
+    }
+    if (s.startsWith("<i>", i)) {
+      stack.push("i");
+      i += 3;
+      continue;
+    }
+    if (s.startsWith('<a href="', i)) {
+      const close = s.indexOf('">', i);
+      if (close === -1) break;
+      stack.push("a");
+      i = close + 2;
+      continue;
+    }
+    i++;
+  }
+  return stack;
+}
+
+function closingTagsForStack(stack: TelegramOpenTag[]): string {
+  const closers: Record<TelegramOpenTag, string> = {
+    b: "</b>",
+    i: "</i>",
+    a: "</a>",
+  };
+  let out = "";
+  for (let k = stack.length - 1; k >= 0; k--) {
+    const tag = stack[k];
+    if (tag) out += closers[tag];
+  }
+  return out;
+}
+
+/**
+ * Truncate formatted Telegram HTML without splitting tags or leaving them unclosed.
+ * Avoids HTTP 400 "can't parse entities" when the raw slice cuts inside `<b>` / `</a>` etc.
+ */
+export function truncateTelegramHtml(html: string, maxLen: number): string {
+  if (html.length <= maxLen) return html;
+  if (maxLen <= 0) return "";
+
+  let cut = html.slice(0, maxLen);
+  const stripIncompleteTagTail = (s: string): string => {
+    const lastLt = s.lastIndexOf("<");
+    if (lastLt < 0) return s;
+    if (s.indexOf(">", lastLt) === -1) {
+      return s.slice(0, lastLt);
+    }
+    return s;
+  };
+  cut = stripIncompleteTagTail(cut);
+
+  let suffix = closingTagsForStack(collectOpenTelegramTags(cut));
+  while (cut.length + suffix.length > maxLen && cut.length > 0) {
+    const over = cut.length + suffix.length - maxLen;
+    cut = cut.slice(0, Math.max(0, cut.length - over - 1));
+    cut = stripIncompleteTagTail(cut);
+    suffix = closingTagsForStack(collectOpenTelegramTags(cut));
+  }
+
+  if (cut.length + suffix.length > maxLen) {
+    return escapeHtml(html).slice(0, maxLen);
+  }
+  return cut + suffix;
+}
+
+/**
+ * Convert Markdown-style text to Telegram HTML.
+ * Handles: **bold**, *italic*, [text](url), ### headers, (https://...) URLs.
+ * On error, returns original text.
+ */
+export function markdownToTelegramHtml(text: string): string {
+  try {
+    if (!text || typeof text !== "string") return text;
+
+    // 1. Escape first so all content is safe; replacements use already-escaped content
+    let out = escapeHtml(text);
+
+    // 2. Links [text](url) — url already escaped; only escape " for attr
+    out = out.replace(
+      /\[([^\]]*)\]\(([^)]*)\)/g,
+      (_, linkText, url) => `<a href="${hrefAttr(url)}">${linkText}</a>`,
+    );
+
+    // 3. Plain (https://...) after labels — avoids ")" in href when users tap links
+    out = parentheticalUrlsToAnchors(out);
+
+    // 4. ### headers — before **bold** so "### **Title**" does not yield nested <b>…</b>
+    out = out.replace(
+      /(^|\n)###\s+([^\n]+)(\n)?/g,
+      (_, prefix, header, nl) => `${prefix}<b>${header}</b>${nl ?? "\n"}`,
+    );
+
+    // 5. Bold **text**
+    out = out.replace(/\*\*([^*]+)\*\*/g, (_, content) => `<b>${content}</b>`);
+
+    // 6. Italic *text* (not part of **)
+    out = out.replace(
+      /(?<!\*)\*([^*]+)\*(?!\*)/g,
+      (_, content) => `<i>${content}</i>`,
+    );
+
+    out = collapseNestedBold(out);
+
+    return out;
+  } catch {
+    return text;
+  }
+}