mercury-agent 0.9.0 → 0.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mercury-agent",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Personal AI assistant for chat platforms (WhatsApp, Slack, Discord, Telegram)",
   "license": "MIT",
   "author": "Avishai Tsabari",

package/src/core/permissions.ts

@@ -1,3 +1,4 @@
+import { logger } from "../logger.js";
 import type { Db } from "../storage/db.js";
 import { matchesConfiguredId } from "./global-admin.js";
 
@@ -139,6 +140,36 @@ function toPermissionSet(list: string[]): Set<string> {
  */
 export const seededSpaces = new Set<string>();
 
+/**
+ * (space, caller) pairs whose config-admin re-promotion was already logged —
+ * once per process, not per message (resolveRole runs on every message).
+ * Exported for test isolation (tests should clear this in beforeEach).
+ */
+export const warnedRepromotions = new Set<string>();
+
+/**
+ * A stored non-admin role was overridden back to admin because the caller is
+ * listed in config.admins. The override is deliberate (config admins are
+ * always admins), but it must be visible: an operator's explicit demotion
+ * otherwise silently doesn't hold. Deduped once per (space, caller) per
+ * process.
+ */
+function warnConfigAdminRepromotion(
+  spaceId: string,
+  callerId: string,
+  source: "re-seed" | "self-heal",
+): void {
+  // NUL separator: caller ids contain ":" (e.g. "whatsapp:..."), so a ":"
+  // join could collide distinct (space, caller) pairs.
+  const key = `${spaceId}\u0000${callerId}`;
+  if (warnedRepromotions.has(key)) return;
+  warnedRepromotions.add(key);
+  logger.warn(
+    "Config admin re-promoted: stored role overridden — remove from config.admins to demote",
+    { spaceId, callerId, source },
+  );
+}
+
 // ---------------------------------------------------------------------------
 // System callers
 // ---------------------------------------------------------------------------
@@ -252,13 +283,19 @@ export function resolveRole(
   if (isSystemCaller(platformUserId)) return "system";
 
   if (seededAdmins.length > 0 && !seededSpaces.has(spaceId)) {
-    db.seedAdmins(spaceId, seededAdmins);
+    for (const id of db.seedAdmins(spaceId, seededAdmins)) {
+      warnConfigAdminRepromotion(spaceId, id, "re-seed");
+    }
     seededSpaces.add(spaceId);
   }
 
+  // Read before upsertMember, which inserts a fresh "member" row on first
+  // contact — a null here distinguishes "never seen" from "operator demoted".
+  const storedRole = db.getRole(spaceId, platformUserId);
+
   db.upsertMember(spaceId, platformUserId, displayName);
 
-  const role = db.getRole(spaceId, platformUserId) ?? "member";
+  const role = storedRole ?? "member";
 
   // Seeded rows are keyed by the raw config string, which may differ from the
   // canonical caller id (format looseness, WhatsApp LID vs phone JID). When the
@@ -269,6 +306,11 @@ export function resolveRole(
     role === "member" &&
     matchesConfiguredId(platformUserId, seededAdmins, db)
   ) {
+    // Warn only when a member row pre-existed (a stored demotion being
+    // overridden) — a first-contact self-heal has nothing to override.
+    if (storedRole === "member") {
+      warnConfigAdminRepromotion(spaceId, platformUserId, "self-heal");
+    }
     db.setRole(spaceId, platformUserId, "admin", "seed");
     return "admin";
   }

package/src/core/routes/chat.ts

@@ -147,7 +147,14 @@ export function createChatRoute(core: MercuryCoreRuntime): Hono {
     }
 
     if (authenticated) {
-      core.db.seedAdmins(spaceId, [callerId]);
+      // Fires at most once per actual override: after the re-promotion the
+      // row is admin again, so later requests return an empty list.
+      for (const id of core.db.seedAdmins(spaceId, [callerId])) {
+        logger.warn(
+          "Authenticated chat caller re-promoted: stored role overridden",
+          { spaceId, callerId: id },
+        );
+      }
     }
 
     const ingress: IngressMessage = {

package/src/core/routes/dashboard.ts

@@ -993,9 +993,11 @@ export function createDashboardRoutes(ctx: DashboardContext) {
                 <span class="truncate">${escapeHtml(truncate(t.prompt, 25))}</span>
                 <span class="muted">${formatFutureTime(t.nextRunAt)}</span>
                 ${t.silent === 1 ? '<span class="badge muted">silent</span>' : '<span class="badge">chat</span>'}
-                <button class="btn btn-sm" 
-                        hx-post="/dashboard/api/tasks/${t.id}/run" 
+                <button class="btn btn-sm"
+                        hx-post="/dashboard/api/tasks/${t.id}/run"
                         hx-swap="none"
+                        hx-sync="this:drop"
+                        hx-disabled-elt="this"
                         title="Run now">▶</button>
               </div>
             `,
@@ -1495,7 +1497,7 @@ export function createDashboardRoutes(ctx: DashboardContext) {
                 <td><span class="badge ${t.silent === 1 ? "muted" : ""}">${t.silent === 1 ? "silent" : "chat"}</span></td>
                 <td><span class="badge ${t.active ? "green" : ""}">${t.active ? "active" : "paused"}</span></td>
                 <td class="actions">
-                  <button class="btn btn-sm" hx-post="/dashboard/api/tasks/${t.id}/run" hx-swap="none" title="Run now">▶</button>
+                  <button class="btn btn-sm" hx-post="/dashboard/api/tasks/${t.id}/run" hx-swap="none" hx-sync="this:drop" hx-disabled-elt="this" title="Run now">▶</button>
                   ${
                     t.active
                       ? `<button class="btn btn-sm" hx-post="/dashboard/api/tasks/${t.id}/pause" hx-swap="none" title="Pause">⏸</button>`
@@ -2472,7 +2474,7 @@ export function createDashboardRoutes(ctx: DashboardContext) {
 
   // ─── Dashboard Actions (no auth required, admin-only UI) ────────────────
 
-  app.post("/api/tasks/:id/run", async (c) => {
+  app.post("/api/tasks/:id/run", (c) => {
     const taskId = Number.parseInt(c.req.param("id"), 10);
     const task = core.db.listTasks().find((t) => t.id === taskId);
 
@@ -2480,12 +2482,20 @@ export function createDashboardRoutes(ctx: DashboardContext) {
       return c.json({ error: "Task not found" }, 404);
     }
 
-    const triggered = await core.scheduler.triggerTask(taskId);
-    if (!triggered) {
+    // Returns as soon as the run starts — never awaits the agent run, which
+    // takes minutes and would leave the ▶ button dead for its whole duration.
+    const result = core.scheduler.triggerTask(taskId);
+    if (result === "not-found") {
       return c.json({ error: "Task not found or inactive" }, 400);
     }
+    if (result === "already-running") {
+      return c.json({ error: `Task #${taskId} is already running` }, 409);
+    }
+    if (result === "unavailable") {
+      return c.json({ error: "Scheduler is not running" }, 503);
+    }
 
-    return c.json({ ok: true });
+    return c.json({ ok: true, started: true });
   });
 
   app.post("/api/tasks/:id/pause", (c) => {

package/src/core/routes/tasks.ts

@@ -1,6 +1,5 @@
 import { CronExpressionParser } from "cron-parser";
 import { Hono } from "hono";
-import { logger } from "../../logger.js";
 import { checkPerm, type Env, getApiCtx, getAuth } from "../api-types.js";
 
 export const tasks = new Hono<Env>();
@@ -161,10 +160,17 @@ tasks.post("/:id/run", (c) => {
     return c.json({ error: "Task is paused" }, 400);
   }
 
-  // Trigger async - don't wait for completion
-  scheduler.triggerTask(taskId).catch((err) => {
-    logger.error("Task trigger failed", { taskId, error: String(err) });
-  });
+  // Returns immediately — the run continues in the background.
+  const result = scheduler.triggerTask(taskId);
+  if (result === "already-running") {
+    return c.json({ error: "Task is already running", id: taskId }, 409);
+  }
+  if (result === "not-found") {
+    return c.json({ error: "Task not found" }, 404);
+  }
+  if (result === "unavailable") {
+    return c.json({ error: "Scheduler is not running" }, 503);
+  }
 
   return c.json({ id: taskId, triggered: true });
 });

package/src/core/task-scheduler.ts

@@ -1,6 +1,7 @@
 import { CronExpressionParser } from "cron-parser";
 import { logger } from "../logger.js";
 import type { Db } from "../storage/db.js";
+import type { ScheduledTask } from "../types.js";
 
 type TaskHandler = (task: {
   id: number;
@@ -10,9 +11,26 @@ type TaskHandler = (task: {
   silent: boolean;
 }) => Promise<void>;
 
+/**
+ * Outcome of a manual trigger. `started` means the run was handed to the
+ * handler — it is *not* finished; agent runs take minutes. `unavailable`
+ * means the scheduler was never started, which is a server-state problem
+ * rather than anything about the task.
+ */
+export type TriggerResult =
+  | "started"
+  | "not-found"
+  | "already-running"
+  | "unavailable";
+
 export class TaskScheduler {
   private timer: NodeJS.Timeout | null = null;
   private handler: TaskHandler | null = null;
+  /**
+   * Task ids with a run in flight. Both the poll and manual triggers mark
+   * here, so a task can never have two concurrent runs regardless of source.
+   */
+  private readonly running = new Set<number>();
 
   constructor(
     private readonly db: Db,
@@ -28,40 +46,25 @@ export class TaskScheduler {
       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", {
+          // A manual trigger may still be running this task. Skip rather than
+          // start a second run — the task stays due (its bookkeeping has not
+          // been applied), so the next poll picks it up once the run ends.
+          if (this.running.has(task.id)) {
+            logger.info("Skipping due task — a run is already in flight", {
               taskId: task.id,
               spaceId: task.spaceId,
-              error: error instanceof Error ? error.message : String(error),
             });
+            continue;
           }
 
-          // 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,
-            });
-          }
+          // `due` is a snapshot taken before the loop, and each iteration
+          // awaits a full agent run — minutes, during which a manual trigger
+          // can have run, rescheduled or deleted a later entry, and the user
+          // can have paused it. Re-read before committing to the run.
+          const fresh = this.db.getTask(task.id);
+          if (!fresh?.active || fresh.nextRunAt > Date.now()) continue;
+
+          await this.runTask(fresh, true);
         }
       } catch (error) {
         logger.error(
@@ -122,18 +125,89 @@ export class TaskScheduler {
     }
   }
 
-  async triggerTask(taskId: number): Promise<boolean> {
-    if (!this.handler) return false;
+  /**
+   * Run one task through the handler, holding an in-flight mark for its whole
+   * duration.
+   *
+   * `applyBookkeeping` performs what the poll has always done around a run:
+   * advance `next_run_at` for cron tasks *before* executing, delete one-shot
+   * `at` tasks *after*. Both happen regardless of handler success. A manual
+   * trigger of a task that is not yet due passes `false` — an early preview
+   * run must not consume the schedule the user set up.
+   */
+  private async runTask(
+    task: ScheduledTask,
+    applyBookkeeping: boolean,
+  ): Promise<void> {
+    const handler = this.handler;
+    if (!handler) {
+      // Unreachable: start() assigns the handler before the first tick, and
+      // triggerTask returns "unavailable" without getting here.
+      logger.error("Refusing to run a task before the scheduler started", {
+        taskId: task.id,
+        spaceId: task.spaceId,
+      });
+      return;
+    }
+
+    this.running.add(task.id);
+    try {
+      if (applyBookkeeping && 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),
+        });
+      }
+
+      if (applyBookkeeping && task.at) {
+        this.db.deleteTaskById(task.id);
+        logger.info("One-shot task completed and deleted", {
+          taskId: task.id,
+          spaceId: task.spaceId,
+        });
+      }
+    } finally {
+      this.running.delete(task.id);
+    }
+  }
+
+  /**
+   * Start a manual run of a task. Returns **immediately** with the verdict —
+   * the run itself continues in the background, so callers must never await
+   * completion (an agent run can take minutes, and a route that holds the
+   * connection open for it gives the UI no feedback at all).
+   *
+   * A task already running — whether triggered manually or by the poll — is
+   * rejected with `already-running` rather than queued behind the first run.
+   */
+  triggerTask(taskId: number): TriggerResult {
+    if (!this.handler) return "unavailable";
     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;
+    if (!task?.active) return "not-found";
+    if (this.running.has(task.id)) return "already-running";
+
+    // Already-due tasks get the poll's bookkeeping; running one manually must
+    // clear its due state, or the 5 s poll fires it again on its own.
+    const applyBookkeeping = task.nextRunAt <= Date.now();
+
+    // runTask's body runs synchronously up to its first await, so the
+    // in-flight mark is set before this returns — a second click in the same
+    // tick sees it and loses the race. Not awaited: fire-and-forget by design.
+    void this.runTask(task, applyBookkeeping);
+    return "started";
   }
 }

package/src/dashboard/index.html

@@ -496,6 +496,36 @@
 
     :focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; }
 
+    /* ─── Toast ──────────────────────────────────────────────────────────── */
+
+    #toast {
+      position: fixed;
+      bottom: 16px;
+      left: 50%;
+      transform: translateX(-50%);
+      z-index: 50;
+      display: flex;
+      flex-direction: column;
+      gap: 8px;
+      pointer-events: none;
+    }
+
+    .toast {
+      background: var(--surface-elevated);
+      border: 1px solid var(--border);
+      border-left: 3px solid var(--accent);
+      border-radius: var(--radius);
+      padding: 10px 14px;
+      max-width: 90vw;
+      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.4);
+    }
+
+    .toast.error { border-left-color: var(--color-error); }
+    .toast.success { border-left-color: var(--color-success); }
+
+    /* htmx sets [disabled] via hx-disabled-elt while a request is in flight */
+    .btn[disabled] { opacity: 0.5; cursor: default; }
+
     @media (prefers-reduced-motion: reduce) {
       .badge.pulse,
       .status.active::before { animation: none; }
@@ -601,6 +631,8 @@
     </main>
   </div>
 
+  <div id="toast" aria-live="polite"></div>
+
   <script>
     // Navigation (global for hx-on/htmx; Biome cannot see HTML callers)
     globalThis.setActiveNav = function setActiveNav(el) {
@@ -692,6 +724,38 @@
       }
     });
 
+    // Transient feedback. Actions use hx-swap="none", so without this the page
+    // just silently refreshes and a rejected action looks identical to an
+    // accepted one.
+    function showToast(message, kind) {
+      const host = document.getElementById('toast');
+      if (!host) return;
+      const el = document.createElement('div');
+      el.className = 'toast ' + (kind || '');
+      el.textContent = message;
+      host.appendChild(el);
+      setTimeout(() => el.remove(), 5000);
+    }
+
+    // "Run now" is fire-and-forget: the agent run takes minutes, so the only
+    // signal the user gets is this toast. 409 means a run is already in flight.
+    document.body.addEventListener('htmx:afterRequest', (e) => {
+      const path = e.detail.requestConfig?.path || '';
+      if (!/\/api\/tasks\/\d+\/run$/.test(path)) return;
+      const xhr = e.detail.xhr;
+      if (xhr.status === 409) {
+        showToast('That task is already running — the first run is still in progress.', 'error');
+      } else if (xhr.status >= 400) {
+        let message = 'Could not start the task.';
+        try {
+          message = JSON.parse(xhr.response)?.error || message;
+        } catch { /* non-JSON error body — keep the generic message */ }
+        showToast(message, 'error');
+      } else {
+        showToast('Task started — the reply arrives when the run finishes.', 'success');
+      }
+    });
+
     // Refresh current page after htmx actions (like delete, pause, etc.)
     document.body.addEventListener('htmx:afterRequest', (e) => {
       if (e.detail.requestConfig.verb !== 'get') {

package/src/storage/db.ts

@@ -1349,9 +1349,23 @@ export class Db {
     return result.changes > 0;
   }
 
-  seedAdmins(spaceId: string, adminIds: string[]): void {
+  /**
+   * Seed admin roles. Returns the ids whose existing row held a non-admin
+   * role and was overridden back to admin, so the caller can log the
+   * re-promotion (this layer stays log-free).
+   */
+  seedAdmins(spaceId: string, adminIds: string[]): string[] {
     const now = Date.now();
+    const repromoted: string[] = [];
     for (const id of adminIds) {
+      const existing = this.db
+        .query(
+          "SELECT role FROM space_roles WHERE space_id = ? AND platform_user_id = ?",
+        )
+        .get(spaceId, id) as { role: string } | null;
+      if (existing && existing.role !== "admin") {
+        repromoted.push(id);
+      }
       this.db
         .query(
           `INSERT INTO space_roles(space_id, platform_user_id, role, granted_by, created_at, updated_at)
@@ -1362,6 +1376,7 @@ export class Db {
         )
         .run(spaceId, id, now, now);
     }
+    return repromoted;
   }
 
   // --- Space Config ---