assistme 0.2.7 → 0.2.9

package/src/agent/memory.ts

@@ -1,4 +1,4 @@
-import { getSupabase } from "../db/supabase.js";
+import { callMcpHandler } from "../db/api-client.js";
 import { log } from "../utils/logger.js";
 
 export type MemoryCategory =
@@ -26,10 +26,8 @@ export interface Memory {
 // ── Memory Manager ──────────────────────────────────────────────────
 
 export class MemoryManager {
-  private userId: string;
-
-  constructor(userId: string) {
-    this.userId = userId;
+  constructor(_userId: string) {
+    // userId is no longer needed — auth is handled by the MCP token in callMcpHandler
   }
 
   /**
@@ -46,74 +44,38 @@ export class MemoryManager {
       expiresInDays?: number;
     }
   ): Promise<Memory> {
-    const sb = getSupabase();
-
     const expiresAt = options?.expiresInDays
       ? new Date(
           Date.now() + options.expiresInDays * 86400_000
         ).toISOString()
       : null;
 
-    const { data, error } = await sb
-      .from("agent_memories")
-      .insert({
-        user_id: this.userId,
-        category,
-        content,
-        importance: options?.importance ?? 5,
-        tags: options?.tags ?? [],
-        source_message_id: options?.sourceMessageId ?? null,
-        expires_at: expiresAt,
-      })
-      .select()
-      .single();
+    const data = await callMcpHandler<Memory>("memory.store", {
+      category,
+      content,
+      importance: options?.importance ?? 5,
+      tags: options?.tags ?? [],
+      source_message_id: options?.sourceMessageId ?? null,
+      expires_at: expiresAt,
+    });
 
-    if (error) throw new Error(`Failed to store memory: ${error.message}`);
     log.debug(`Memory stored: [${category}] ${content.slice(0, 80)}...`);
-    return data as Memory;
+    return data;
   }
 
   /**
    * Search memories by query text. Uses ILIKE + tag containment.
    */
   async search(query: string, limit = 10): Promise<Memory[]> {
-    const sb = getSupabase();
-
-    // Sanitize query for use in ILIKE to prevent injection
-    const sanitized = query.replace(/[%_]/g, "\\$&");
-
-    const { data, error } = await sb
-      .from("agent_memories")
-      .select("*")
-      .eq("user_id", this.userId)
-      .or(
-        `content.ilike.%${sanitized}%,tags.cs.{${sanitized}}`
-      )
-      .order("importance", { ascending: false })
-      .limit(limit);
-
-    if (error) {
-      log.warn(`Memory search failed: ${error.message}`);
+    try {
+      return await callMcpHandler<Memory[]>("memory.search", {
+        query,
+        limit,
+      });
+    } catch (err) {
+      log.warn(`Memory search failed: ${err instanceof Error ? err.message : err}`);
       return [];
     }
-
-    // Increment access_count for each matched memory individually
-    if (data && data.length > 0) {
-      const now = new Date().toISOString();
-      await Promise.all(
-        data.map((m) =>
-          sb
-            .from("agent_memories")
-            .update({
-              access_count: m.access_count + 1,
-              last_accessed_at: now,
-            })
-            .eq("id", m.id)
-        )
-      );
-    }
-
-    return (data || []) as Memory[];
   }
 
   /**
@@ -122,49 +84,13 @@ export class MemoryManager {
    * Automatically filters out expired memories.
    */
   async getContext(maxItems = 20): Promise<Memory[]> {
-    const sb = getSupabase();
-    const now = new Date().toISOString();
-
-    // Get instructions first (always relevant)
-    const { data: instructions } = await sb
-      .from("agent_memories")
-      .select("*")
-      .eq("user_id", this.userId)
-      .eq("category", "instruction")
-      .or(`expires_at.is.null,expires_at.gt.${now}`)
-      .order("importance", { ascending: false })
-      .limit(5);
-
-    // Get preferences
-    const { data: preferences } = await sb
-      .from("agent_memories")
-      .select("*")
-      .eq("user_id", this.userId)
-      .eq("category", "preference")
-      .or(`expires_at.is.null,expires_at.gt.${now}`)
-      .order("importance", { ascending: false })
-      .limit(5);
-
-    // Get most important general memories
-    const { data: general } = await sb
-      .from("agent_memories")
-      .select("*")
-      .eq("user_id", this.userId)
-      .not("category", "in", '("instruction","preference")')
-      .or(`expires_at.is.null,expires_at.gt.${now}`)
-      .order("importance", { ascending: false })
-      .order("updated_at", { ascending: false })
-      .limit(maxItems - 10);
-
-    const all = [
-      ...(instructions || []),
-      ...(preferences || []),
-      ...(general || []),
-    ] as Memory[];
+    const all = await callMcpHandler<Memory[]>("memory.get_context", {
+      max_items: maxItems,
+    });
 
     // Deduplicate by id
     const seen = new Set<string>();
-    return all.filter((m) => {
+    return (all || []).filter((m) => {
       if (seen.has(m.id)) return false;
       seen.add(m.id);
       return true;
@@ -210,22 +136,11 @@ export class MemoryManager {
     category?: MemoryCategory,
     limit = 20
   ): Promise<Memory[]> {
-    const sb = getSupabase();
-    let query = sb
-      .from("agent_memories")
-      .select("*")
-      .eq("user_id", this.userId)
-      .order("importance", { ascending: false })
-      .order("created_at", { ascending: false })
-      .limit(limit);
-
-    if (category) {
-      query = query.eq("category", category);
-    }
-
-    const { data, error } = await query;
-    if (error) throw new Error(`Failed to list memories: ${error.message}`);
-    return (data || []) as Memory[];
+    const data = await callMcpHandler<Memory[]>("memory.list", {
+      category: category || null,
+      limit,
+    });
+    return data || [];
   }
 
   async add(
@@ -238,29 +153,13 @@ export class MemoryManager {
   }
 
   async remove(memoryId: string): Promise<void> {
-    const sb = getSupabase();
-    const { error } = await sb
-      .from("agent_memories")
-      .delete()
-      .eq("id", memoryId)
-      .eq("user_id", this.userId);
-
-    if (error) throw new Error(`Failed to delete memory: ${error.message}`);
+    await callMcpHandler("memory.remove", { memory_id: memoryId });
   }
 
   async clear(category?: MemoryCategory): Promise<number> {
-    const sb = getSupabase();
-    let query = sb
-      .from("agent_memories")
-      .delete()
-      .eq("user_id", this.userId);
-
-    if (category) {
-      query = query.eq("category", category);
-    }
-
-    const { error, count } = await query.select("id");
-    if (error) throw new Error(`Failed to clear memories: ${error.message}`);
-    return count || 0;
+    const result = await callMcpHandler<{ count: number }>("memory.clear", {
+      category: category || null,
+    });
+    return result.count;
   }
 }

package/src/agent/scheduler.ts

@@ -1,4 +1,4 @@
-import { getSupabase, getCurrentUserId } from "../db/supabase.js";
+import { callMcpHandler } from "../db/api-client.js";
 import { log } from "../utils/logger.js";
 
 const SCHEDULER_INTERVAL = 30_000; // Check every 30 seconds
@@ -35,10 +35,8 @@ export function getNextRunTime(cronExpr: string, timezone: string, fromDate?: Da
 
   const [minExpr, hourExpr, domExpr, monExpr, dowExpr] = parts;
 
-  // Simple cron parser — handles: *, */N, N, N-M, N,M
   function parseField(expr: string, min: number, max: number): number[] {
     const values: number[] = [];
-
     for (const part of expr.split(",")) {
       if (part === "*") {
         for (let i = min; i <= max; i++) values.push(i);
@@ -52,7 +50,6 @@ export function getNextRunTime(cronExpr: string, timezone: string, fromDate?: Da
         values.push(parseInt(part));
       }
     }
-
     return values.sort((a, b) => a - b);
   }
 
@@ -60,17 +57,14 @@ export function getNextRunTime(cronExpr: string, timezone: string, fromDate?: Da
   const hours = parseField(hourExpr, 0, 23);
   const daysOfMonth = parseField(domExpr, 1, 31);
   const months = parseField(monExpr, 1, 12);
-  const daysOfWeek = parseField(dowExpr, 0, 6); // 0 = Sunday
+  const daysOfWeek = parseField(dowExpr, 0, 6);
 
   const useUTC = timezone === "UTC";
 
-  // Find the next matching time after 'now'
-  const candidate = new Date(now.getTime() + 60_000); // Start from next minute
+  const candidate = new Date(now.getTime() + 60_000);
   candidate.setSeconds(0, 0);
 
-  // Search up to 366 days ahead
   for (let i = 0; i < 527040; i++) {
-    // 366 * 24 * 60
     const m = useUTC ? candidate.getUTCMinutes() : candidate.getMinutes();
     const h = useUTC ? candidate.getUTCHours() : candidate.getHours();
     const dom = useUTC ? candidate.getUTCDate() : candidate.getDate();
@@ -87,10 +81,9 @@ export function getNextRunTime(cronExpr: string, timezone: string, fromDate?: Da
       return candidate;
     }
 
-    candidate.setTime(candidate.getTime() + 60_000); // Advance 1 minute
+    candidate.setTime(candidate.getTime() + 60_000);
   }
 
-  // Fallback: 24 hours from now
   return new Date(now.getTime() + 86400_000);
 }
 
@@ -103,10 +96,8 @@ export class Scheduler {
     this.onScheduledTask = onScheduledTask;
     this.running = true;
 
-    // Initialize next_run_at for tasks that don't have it yet
     await this.initializeNextRuns();
 
-    // Check for due tasks periodically
     this.timer = setInterval(() => this.checkDueTasks(), SCHEDULER_INTERVAL);
     log.info("Scheduler started (checking every 30s)");
   }
@@ -121,22 +112,15 @@ export class Scheduler {
 
   private async initializeNextRuns(): Promise<void> {
     try {
-      const userId = await getCurrentUserId();
-      const sb = getSupabase();
-      const { data } = await sb
-        .from("agent_scheduled_tasks")
-        .select("*")
-        .eq("user_id", userId)
-        .eq("enabled", true)
-        .is("next_run_at", null);
+      const data = await callMcpHandler<ScheduledTask[]>("schedule.get_uninitialized");
 
       if (data) {
         for (const task of data) {
           const nextRun = getNextRunTime(task.cron_expression, task.timezone);
-          await sb
-            .from("agent_scheduled_tasks")
-            .update({ next_run_at: nextRun.toISOString() })
-            .eq("id", task.id);
+          await callMcpHandler("schedule.update", {
+            task_id: task.id,
+            next_run_at: nextRun.toISOString(),
+          });
         }
       }
     } catch (err) {
@@ -148,44 +132,37 @@ export class Scheduler {
     if (!this.running || !this.onScheduledTask) return;
 
     try {
-      const userId = await getCurrentUserId();
-      const sb = getSupabase();
-
-      const { data: dueTasks } = await sb
-        .from("agent_scheduled_tasks")
-        .select("*")
-        .eq("user_id", userId)
-        .eq("enabled", true)
-        .lte("next_run_at", new Date().toISOString())
-        .order("next_run_at", { ascending: true })
-        .limit(1);
+      const dueTasks = await callMcpHandler<ScheduledTask[]>("schedule.check_due");
 
       if (!dueTasks || dueTasks.length === 0) return;
 
-      const task = dueTasks[0] as ScheduledTask;
+      const task = dueTasks[0];
       log.info(`Scheduled task due: "${task.name}"`);
 
-      // Calculate next run before executing
       const nextRun = getNextRunTime(task.cron_expression, task.timezone);
 
       // Update: set running, advance next_run_at
-      await sb
-        .from("agent_scheduled_tasks")
-        .update({
-          last_run_at: new Date().toISOString(),
-          next_run_at: nextRun.toISOString(),
-          run_count: task.run_count + 1,
-        })
-        .eq("id", task.id);
+      await callMcpHandler("schedule.update", {
+        task_id: task.id,
+        last_run_at: new Date().toISOString(),
+        next_run_at: nextRun.toISOString(),
+        run_count: task.run_count + 1,
+      });
 
       // Execute
       try {
         await this.onScheduledTask(task);
 
-        await sb.from("agent_scheduled_tasks").update({ last_error: null }).eq("id", task.id);
+        await callMcpHandler("schedule.update", {
+          task_id: task.id,
+          last_error: null,
+        });
       } catch (err) {
         const errMsg = err instanceof Error ? err.message : String(err);
-        await sb.from("agent_scheduled_tasks").update({ last_error: errMsg }).eq("id", task.id);
+        await callMcpHandler("schedule.update", {
+          task_id: task.id,
+          last_error: errMsg,
+        });
         log.error(`Scheduled task "${task.name}" failed: ${errMsg}`);
       }
     } catch (err) {
@@ -197,68 +174,45 @@ export class Scheduler {
 // ── CRUD helpers for CLI commands ──────────────────────────────────
 
 export async function createScheduledTask(
-  userId: string,
+  _userId: string,
   name: string,
   prompt: string,
   cronExpression: string,
   timezone = "UTC"
 ): Promise<ScheduledTask> {
-  const sb = getSupabase();
   const nextRun = getNextRunTime(cronExpression, timezone);
 
-  const { data, error } = await sb
-    .from("agent_scheduled_tasks")
-    .insert({
-      user_id: userId,
-      name,
-      prompt,
-      cron_expression: cronExpression,
-      timezone,
-      next_run_at: nextRun.toISOString(),
-    })
-    .select()
-    .single();
-
-  if (error) throw new Error(`Failed to create schedule: ${error.message}`);
-  return data as ScheduledTask;
+  return callMcpHandler<ScheduledTask>("schedule.create", {
+    name,
+    prompt,
+    cron_expression: cronExpression,
+    timezone,
+    next_run_at: nextRun.toISOString(),
+  });
 }
 
-export async function listScheduledTasks(userId: string): Promise<ScheduledTask[]> {
-  const sb = getSupabase();
-  const { data, error } = await sb
-    .from("agent_scheduled_tasks")
-    .select("*")
-    .eq("user_id", userId)
-    .order("created_at", { ascending: false });
-
-  if (error) throw new Error(`Failed to list schedules: ${error.message}`);
-  return (data || []) as ScheduledTask[];
+export async function listScheduledTasks(_userId: string): Promise<ScheduledTask[]> {
+  return callMcpHandler<ScheduledTask[]>("schedule.list");
 }
 
 export async function toggleScheduledTask(taskId: string, enabled: boolean): Promise<void> {
-  const sb = getSupabase();
-  const update: Record<string, unknown> = { enabled };
+  const params: Record<string, unknown> = { task_id: taskId, enabled };
+
   if (enabled) {
-    // Recalculate next run when re-enabling
-    const { data } = await sb
-      .from("agent_scheduled_tasks")
-      .select("cron_expression, timezone")
-      .eq("id", taskId)
-      .single();
-    if (data) {
-      const nextRun = getNextRunTime(data.cron_expression, data.timezone);
-      update.next_run_at = nextRun.toISOString();
+    // Need to recalculate next run when re-enabling
+    const taskData = await callMcpHandler<{ cron_expression: string; timezone: string }>(
+      "schedule.get_task",
+      { task_id: taskId },
+    );
+    if (taskData) {
+      const nextRun = getNextRunTime(taskData.cron_expression, taskData.timezone);
+      params.next_run_at = nextRun.toISOString();
     }
   }
 
-  const { error } = await sb.from("agent_scheduled_tasks").update(update).eq("id", taskId);
-
-  if (error) throw new Error(`Failed to toggle schedule: ${error.message}`);
+  await callMcpHandler("schedule.toggle", params);
 }
 
 export async function deleteScheduledTask(taskId: string): Promise<void> {
-  const sb = getSupabase();
-  const { error } = await sb.from("agent_scheduled_tasks").delete().eq("id", taskId);
-
-  if (error) throw new Error(`Failed to delete schedule: ${error.message}`);
+  await callMcpHandler("schedule.delete", { task_id: taskId });
 }

package/src/agent/session.test.ts

@@ -15,17 +15,6 @@ const mockSession = {
   metadata: {},
 };
 
-// Build a fluent Supabase chain that does nothing
-const chain: Record<string, unknown> = {};
-const methods = [
-  "select", "insert", "update", "delete", "eq", "neq", "not",
-  "or", "in", "order", "limit", "single", "from", "lt",
-];
-for (const method of methods) {
-  chain[method] = vi.fn().mockReturnValue(chain);
-}
-chain.then = (resolve: (value: unknown) => void) => resolve({ data: [], error: null });
-
 const mockCreateSession = vi.fn().mockResolvedValue(mockSession);
 const mockUpdateHeartbeat = vi.fn().mockResolvedValue(undefined);
 const mockEndSession = vi.fn().mockResolvedValue(undefined);
@@ -35,6 +24,8 @@ const mockClaimTask = vi.fn().mockResolvedValue(true);
 const mockCreateTask = vi.fn().mockResolvedValue({ id: "task-001", prompt: "test" });
 const mockGetOrCreateCliConversation = vi.fn().mockResolvedValue("conv-001");
 
+const mockCleanupStaleSessions = vi.fn().mockResolvedValue(0);
+
 vi.mock("../db/supabase.js", () => ({
   createSession: (...args: unknown[]) => mockCreateSession(...args),
   updateHeartbeat: (...args: unknown[]) => mockUpdateHeartbeat(...args),
@@ -44,7 +35,12 @@ vi.mock("../db/supabase.js", () => ({
   claimTask: (...args: unknown[]) => mockClaimTask(...args),
   createTask: (...args: unknown[]) => mockCreateTask(...args),
   getOrCreateCliConversation: (...args: unknown[]) => mockGetOrCreateCliConversation(...args),
-  getSupabase: vi.fn().mockReturnValue({ from: vi.fn().mockReturnValue(chain) }),
+  cleanupStaleSessions: (...args: unknown[]) => mockCleanupStaleSessions(...args),
+  pollAndClaimJobRun: vi.fn().mockResolvedValue(null),
+}));
+
+vi.mock("../db/api-client.js", () => ({
+  callMcpHandler: vi.fn().mockResolvedValue(null),
 }));
 
 vi.mock("../utils/config.js", () => ({

package/src/agent/session.ts

@@ -8,11 +8,12 @@ import {
   claimTask,
   createTask,
   getOrCreateCliConversation,
-  getSupabase,
+  cleanupStaleSessions,
   AgentSession,
   ConversationMessage,
   PendingJobRun,
 } from "../db/supabase.js";
+import { callMcpHandler } from "../db/api-client.js";
 import { getConfig } from "../utils/config.js";
 import { log } from "../utils/logger.js";
 import { Scheduler, ScheduledTask } from "./scheduler.js";
@@ -21,7 +22,6 @@ import { JobRunner } from "./job-runner.js";
 const DEFAULT_HEARTBEAT_INTERVAL = 30_000; // 30 seconds
 const DEFAULT_POLL_INTERVAL = 2_000; // 2 seconds
 const MAX_POLL_INTERVAL = 30_000; // Max backoff: 30 seconds
-const STALE_SESSION_THRESHOLD = 120_000; // 2 minutes without heartbeat = stale
 
 export class SessionManager {
   private session: AgentSession | null = null;
@@ -93,9 +93,6 @@ export class SessionManager {
     return this.session;
   }
 
-  /**
-   * Schedule the next poll with exponential backoff on failures.
-   */
   private schedulePoll(): void {
     if (!this.running) return;
 
@@ -126,10 +123,6 @@ export class SessionManager {
     }
   }
 
-  /**
-   * Execute a pending job run triggered from the web UI.
-   * Loads the job, builds the agentic prompt, and processes it as a chat task.
-   */
   private async executeJobRun(jobRun: PendingJobRun): Promise<void> {
     if (!this.session || !this.userId || !this.conversationId || !this.onTask)
       return;
@@ -157,11 +150,10 @@ export class SessionManager {
 
     // Link session to run record (non-critical)
     try {
-      const sb = getSupabase();
-      await sb
-        .from("agent_job_runs")
-        .update({ session_id: this.session.id })
-        .eq("id", jobRun.id);
+      await callMcpHandler("job.link_run_session", {
+        run_id: jobRun.id,
+        session_id: this.session.id,
+      });
     } catch (linkErr) {
       log.debug(`Failed to link session to job run: ${linkErr}`);
     }
@@ -253,50 +245,19 @@ export class SessionManager {
     this.schedulePoll();
   }
 
-  /**
-   * Mark sessions as offline if they haven't sent a heartbeat recently.
-   * Runs once on startup to clean up orphaned sessions from crashed processes.
-   */
   private async cleanupStaleSessions(): Promise<void> {
-    if (!this.userId) return;
+    if (!this.userId || !this.session) return;
 
     try {
-      const sb = getSupabase();
-      const threshold = new Date(
-        Date.now() - STALE_SESSION_THRESHOLD
-      ).toISOString();
-
-      const { data: stale } = await sb
-        .from("agent_sessions")
-        .select("id")
-        .eq("user_id", this.userId)
-        .in("status", ["online", "busy"])
-        .lt("last_heartbeat_at", threshold)
-        .neq("id", this.session?.id || "");
-
-      if (stale && stale.length > 0) {
-        for (const s of stale) {
-          await sb
-            .from("agent_sessions")
-            .update({
-              status: "offline",
-              ended_at: new Date().toISOString(),
-              metadata: { ended_reason: "stale_session_cleanup" },
-            })
-            .eq("id", s.id);
-        }
-        log.info(`Cleaned up ${stale.length} stale session(s)`);
+      const cleaned = await cleanupStaleSessions(this.session.id);
+      if (cleaned > 0) {
+        log.info(`Cleaned up ${cleaned} stale session(s)`);
       }
     } catch (err) {
       log.debug(`Stale session cleanup error: ${err}`);
     }
   }
 
-  /**
-   * Submit a task from the interactive prompt or scheduled job.
-   * Sets processing=true BEFORE creating the task so the poll loop
-   * never races to pick it up.
-   */
   async submitTask(prompt: string): Promise<void> {
     if (!this.session || !this.userId || !this.conversationId || !this.onTask) {
       throw new Error("Session not started");
@@ -328,9 +289,6 @@ export class SessionManager {
     }
   }
 
-  /**
-   * Stop the session with a safety timeout to prevent hanging on shutdown.
-   */
   async stop(timeoutMs = 5_000): Promise<void> {
     this.running = false;
     this.scheduler.stop();
@@ -347,7 +305,6 @@ export class SessionManager {
 
     if (this.session) {
       try {
-        // Wrap DB call with a deadline to avoid hanging on shutdown
         await Promise.race([
           endSession(this.session.id),
           new Promise<never>((_, reject) =>