assistme 0.2.7 → 0.2.9

package/src/commands/job.ts

@@ -1,6 +1,7 @@
 import { Command } from "commander";
 import chalk from "chalk";
-import { getCurrentUserId, getSupabase } from "../db/supabase.js";
+import { getCurrentUserId } from "../db/supabase.js";
+import { callMcpHandler } from "../db/api-client.js";
 import { log } from "../utils/logger.js";
 import {
   createScheduledTask,
@@ -150,11 +151,10 @@ export function registerJobCommands(program: Command): void {
         );
 
         // Link job_id
-        const sb = getSupabase();
-        await sb
-          .from("agent_scheduled_tasks")
-          .update({ job_id: job.jobId })
-          .eq("id", task.id);
+        await callMcpHandler("schedule.link_job", {
+          task_id: task.id,
+          job_id: job.jobId,
+        });
 
         log.success(`Job "${name}" scheduled: ${opts.cron} (${tz})`);
         console.log(`  Skills: ${job.skills.length}`);

package/src/commands/status.ts

@@ -1,6 +1,6 @@
 import { Command } from "commander";
 import chalk from "chalk";
-import { getCurrentUserId, getSupabase } from "../db/supabase.js";
+import { getCurrentUserId, getActiveSessions } from "../db/supabase.js";
 import { log } from "../utils/logger.js";
 
 export function registerStatusCommand(program: Command): void {
@@ -9,16 +9,9 @@ export function registerStatusCommand(program: Command): void {
     .description("Check the status of the current agent session")
     .action(async () => {
       try {
-        const userId = await getCurrentUserId();
-        const sb = getSupabase();
+        await getCurrentUserId();
 
-        const { data: sessions } = await sb
-          .from("agent_sessions")
-          .select("*")
-          .eq("user_id", userId)
-          .in("status", ["online", "busy"])
-          .order("started_at", { ascending: false })
-          .limit(5);
+        const sessions = await getActiveSessions(5);
 
         if (!sessions || sessions.length === 0) {
           console.log(chalk.yellow("No active sessions found."));

package/src/db/api-client.ts

@@ -0,0 +1,68 @@
+import { getConfig } from "../utils/config.js";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// ── Auth Store (shared with supabase.ts) ────────────────────────────
+
+const AUTH_DIR = join(homedir(), ".config", "assistme");
+const AUTH_FILE = join(AUTH_DIR, "auth.json");
+
+function readAuthStore(): Record<string, string> {
+  try {
+    if (existsSync(AUTH_FILE)) {
+      return JSON.parse(readFileSync(AUTH_FILE, "utf-8"));
+    }
+  } catch {
+    // Corrupted file — start fresh
+  }
+  return {};
+}
+
+/**
+ * Get the raw MCP token from the local auth store.
+ * Throws if not authenticated.
+ */
+export function getRawToken(): string {
+  const store = readAuthStore();
+  const token = store["mcp_token"];
+  if (!token || !token.startsWith("am_")) {
+    throw new Error("Not authenticated. Run `assistme login`.");
+  }
+  return token;
+}
+
+/**
+ * Call the mcp-handler edge function.
+ *
+ * @param action  Dot-separated action (e.g. "session.create", "task.poll_and_claim")
+ * @param params  Action parameters
+ * @param overrideToken  Optional token override (used during login before token is persisted)
+ */
+export async function callMcpHandler<T = unknown>(
+  action: string,
+  params: Record<string, unknown> = {},
+  overrideToken?: string,
+): Promise<T> {
+  const config = getConfig();
+  const token = overrideToken || getRawToken();
+  const url = `${config.supabaseUrl}/functions/v1/mcp-handler`;
+
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`,
+      apikey: config.supabaseAnonKey,
+    },
+    body: JSON.stringify({ action, params }),
+  });
+
+  const body = await response.json();
+
+  if (!response.ok || body.error) {
+    throw new Error(body.error || `Request failed: ${response.status}`);
+  }
+
+  return body.data as T;
+}

package/src/db/supabase.test.ts

@@ -1,81 +1,11 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 
-// ── Supabase Mock ────────────────────────────────────────────────
-// The supabase module caches the client singleton. We use a STABLE mock
-// that persists across tests, with `_setResult()` to reconfigure per-test.
+// ── callMcpHandler Mock ─────────────────────────────────────────
+const mockCallMcpHandler = vi.fn();
 
-let finalResult: Record<string, unknown> = { data: [], error: null };
-
-const chain: Record<string, unknown> = {};
-const chainMethods = [
-  "select",
-  "insert",
-  "update",
-  "delete",
-  "eq",
-  "neq",
-  "not",
-  "or",
-  "in",
-  "order",
-  "limit",
-  "single",
-  "from",
-  "lt",
-];
-for (const method of chainMethods) {
-  chain[method] = vi.fn().mockImplementation(() => chain);
-}
-// Make chain thenable — always resolves to current finalResult
-chain.then = function (resolve: (value: unknown) => void) {
-  return resolve(finalResult);
-};
-chain.single = vi.fn().mockImplementation(() => ({
-  ...chain,
-  then: (resolve: (value: unknown) => void) => resolve(finalResult),
-}));
-
-const mockFrom = vi.fn().mockReturnValue(chain);
-const mockRpc = vi.fn().mockImplementation(() => ({
-  then: (resolve: (value: unknown) => void) => resolve(finalResult),
-}));
-const mockAuth = {
-  setSession: vi.fn().mockResolvedValue({
-    data: { user: { id: "user-123" } },
-    error: null,
-  }),
-  getSession: vi.fn().mockResolvedValue({
-    data: { session: { access_token: "test" } },
-  }),
-  getUser: vi.fn().mockResolvedValue({
-    data: { user: { id: "user-123" } },
-    error: null,
-  }),
-  signOut: vi.fn().mockResolvedValue(undefined),
-};
-
-const stableMockClient = {
-  from: mockFrom,
-  rpc: mockRpc,
-  auth: mockAuth,
-};
-
-function setResult(result: Record<string, unknown>) {
-  finalResult = result;
-  chain.then = function (resolve: (value: unknown) => void) {
-    return resolve(result);
-  };
-  chain.single = vi.fn().mockImplementation(() => ({
-    ...chain,
-    then: (resolve: (value: unknown) => void) => resolve(result),
-  }));
-  mockRpc.mockImplementation(() => ({
-    then: (resolve: (value: unknown) => void) => resolve(result),
-  }));
-}
-
-vi.mock("@supabase/supabase-js", () => ({
-  createClient: () => stableMockClient,
+vi.mock("./api-client.js", () => ({
+  callMcpHandler: (...args: unknown[]) => mockCallMcpHandler(...args),
+  getRawToken: () => "am_test_token_123",
 }));
 
 vi.mock("../utils/config.js", () => ({
@@ -112,7 +42,6 @@ const {
   updateHeartbeat,
   endSession,
   setSessionBusy,
-  pollPendingTasks,
   claimTask,
   completeTask,
   failTask,
@@ -122,48 +51,38 @@ const {
   getCurrentUserId,
 } = await import("./supabase.js");
 
-describe("Supabase DB Layer", () => {
+describe("Supabase DB Layer (edge function)", () => {
   beforeEach(() => {
     vi.clearAllMocks();
-    // Restore chain mocks (clearAllMocks resets them)
-    for (const method of chainMethods) {
-      chain[method] = vi.fn().mockImplementation(() => chain);
-    }
-    chain.single = vi.fn().mockImplementation(() => ({
-      ...chain,
-      then: (resolve: (value: unknown) => void) => resolve(finalResult),
-    }));
-    mockFrom.mockReturnValue(chain);
-    setResult({ data: [], error: null });
     resetEventSequence();
   });
 
   describe("createSession()", () => {
-    it("inserts a new session and returns it", async () => {
+    it("calls session.create action and returns session data", async () => {
       const sessionData = {
         id: "sess-001",
         user_id: "user-123",
         session_name: "Test",
         status: "online",
       };
-      setResult({ data: sessionData, error: null });
+      mockCallMcpHandler.mockResolvedValueOnce(sessionData);
 
       const result = await createSession("user-123", "Test", "/tmp", "0.1.0");
 
-      expect(mockRpc).toHaveBeenCalledWith(
-        "mcp_create_session",
+      expect(mockCallMcpHandler).toHaveBeenCalledWith(
+        "session.create",
         expect.objectContaining({
-          p_session_name: "Test",
-          p_workspace_path: "/tmp",
-          p_version: "0.1.0",
+          session_name: "Test",
+          workspace_path: "/tmp",
+          version: "0.1.0",
         })
       );
       expect(result.id).toBe("sess-001");
       expect(result.status).toBe("online");
     });
 
-    it("throws on DB error", async () => {
-      setResult({ data: null, error: { message: "insert failed" } });
+    it("throws on edge function error", async () => {
+      mockCallMcpHandler.mockRejectedValueOnce(new Error("Failed to create session"));
 
       await expect(createSession("user-123", "Test", "/tmp", "0.1.0")).rejects.toThrow(
         "Failed to create session"
@@ -172,152 +91,120 @@ describe("Supabase DB Layer", () => {
   });
 
   describe("updateHeartbeat()", () => {
-    it("updates the heartbeat timestamp", async () => {
-      setResult({ error: null });
+    it("calls session.heartbeat action", async () => {
+      mockCallMcpHandler.mockResolvedValueOnce(undefined);
       await updateHeartbeat("sess-001");
-      expect(mockRpc).toHaveBeenCalledWith(
-        "mcp_heartbeat",
+      expect(mockCallMcpHandler).toHaveBeenCalledWith(
+        "session.heartbeat",
         expect.objectContaining({
-          p_session_id: "sess-001",
+          session_id: "sess-001",
         })
       );
     });
   });
 
   describe("endSession()", () => {
-    it("sets session to offline", async () => {
-      setResult({ error: null });
+    it("calls session.end action", async () => {
+      mockCallMcpHandler.mockResolvedValueOnce(undefined);
       await endSession("sess-001");
-      expect(mockRpc).toHaveBeenCalledWith(
-        "mcp_end_session",
+      expect(mockCallMcpHandler).toHaveBeenCalledWith(
+        "session.end",
         expect.objectContaining({
-          p_session_id: "sess-001",
+          session_id: "sess-001",
         })
       );
     });
   });
 
   describe("setSessionBusy()", () => {
-    it("sets session to busy", async () => {
-      setResult({ error: null });
+    it("calls session.set_busy action", async () => {
+      mockCallMcpHandler.mockResolvedValueOnce(undefined);
       await setSessionBusy("sess-001", true);
-      expect(mockRpc).toHaveBeenCalledWith(
-        "mcp_set_session_busy",
+      expect(mockCallMcpHandler).toHaveBeenCalledWith(
+        "session.set_busy",
         expect.objectContaining({
-          p_session_id: "sess-001",
-          p_busy: true,
+          session_id: "sess-001",
+          busy: true,
         })
       );
     });
   });
 
-  describe("pollPendingTasks()", () => {
-    it("returns empty array when no tasks", async () => {
-      setResult({ data: [], error: null });
-      const tasks = await pollPendingTasks("sess-001");
-      expect(tasks).toEqual([]);
-    });
-
-    it("returns tasks with prompt extracted from metadata", async () => {
-      setResult({
-        data: [
-          {
-            id: "msg-001",
-            session_id: "sess-001",
-            status: "pending",
-            content: "",
-            metadata: { prompt: "hello world" },
-          },
-        ],
-        error: null,
-      });
-
-      const tasks = await pollPendingTasks("sess-001");
-      expect(tasks).toHaveLength(1);
-      expect(tasks[0].prompt).toBe("hello world");
-    });
-
-    it("returns empty array on error", async () => {
-      setResult({ data: null, error: { message: "query failed" } });
-      const tasks = await pollPendingTasks("sess-001");
-      expect(tasks).toEqual([]);
-    });
-  });
-
   describe("claimTask()", () => {
-    it("updates status to running", async () => {
-      setResult({ error: null });
+    it("calls task.claim action", async () => {
+      mockCallMcpHandler.mockResolvedValueOnce(true);
       await claimTask("msg-001");
-      expect(mockRpc).toHaveBeenCalledWith(
-        "mcp_claim_task",
+      expect(mockCallMcpHandler).toHaveBeenCalledWith(
+        "task.claim",
         expect.objectContaining({
-          p_message_id: "msg-001",
+          message_id: "msg-001",
         })
       );
     });
-
-    it("throws on DB error", async () => {
-      setResult({ error: { message: "claim failed" } });
-      await expect(claimTask("msg-001")).rejects.toThrow("Failed to claim task");
-    });
   });
 
   describe("completeTask()", () => {
-    it("updates status to completed with result", async () => {
-      setResult({ data: { metadata: {} }, error: null });
+    it("calls task.complete action", async () => {
+      mockCallMcpHandler.mockResolvedValueOnce(undefined);
       await completeTask("msg-001", "Task completed successfully");
-      expect(mockRpc).toHaveBeenCalledWith(
-        "mcp_complete_task",
+      expect(mockCallMcpHandler).toHaveBeenCalledWith(
+        "task.complete",
         expect.objectContaining({
-          p_message_id: "msg-001",
-          p_result: "Task completed successfully",
+          message_id: "msg-001",
+          result: "Task completed successfully",
         })
       );
     });
   });
 
   describe("failTask()", () => {
-    it("updates status to failed with error", async () => {
-      setResult({ data: { metadata: {} }, error: null });
+    it("calls task.fail action", async () => {
+      mockCallMcpHandler.mockResolvedValueOnce(undefined);
       await failTask("msg-001", "Something went wrong");
-      expect(mockRpc).toHaveBeenCalledWith(
-        "mcp_fail_task",
+      expect(mockCallMcpHandler).toHaveBeenCalledWith(
+        "task.fail",
         expect.objectContaining({
-          p_message_id: "msg-001",
-          p_error: "Something went wrong",
+          message_id: "msg-001",
+          error: "Something went wrong",
         })
       );
     });
   });
 
   describe("emitEvent()", () => {
-    it("inserts events to message_events table", async () => {
-      setResult({ error: null });
+    it("calls event.emit action with sequence number", async () => {
+      mockCallMcpHandler.mockResolvedValue(undefined);
 
       await emitEvent("msg-001", "text_delta", { text: "hello" });
       await emitEvent("msg-001", "text_delta", { text: "world" });
 
-      expect(mockRpc).toHaveBeenCalledWith(
-        "mcp_emit_event",
+      expect(mockCallMcpHandler).toHaveBeenCalledWith(
+        "event.emit",
+        expect.objectContaining({
+          message_id: "msg-001",
+          event_type: "text_delta",
+          seq: 1,
+        })
+      );
+      expect(mockCallMcpHandler).toHaveBeenCalledWith(
+        "event.emit",
         expect.objectContaining({
-          p_message_id: "msg-001",
-          p_event_type: "text_delta",
+          seq: 2,
         })
       );
     });
   });
 
   describe("loginWithToken()", () => {
-    it("validates am_ token via RPC and returns user ID", async () => {
-      setResult({ data: [{ out_user_id: "user-123" }], error: null });
+    it("validates am_ token via edge function and returns user ID", async () => {
+      mockCallMcpHandler.mockResolvedValueOnce({ user_id: "user-123", email: null });
 
       const userId = await loginWithToken("am_valid_test_token");
       expect(userId).toBe("user-123");
-      expect(mockRpc).toHaveBeenCalledWith(
-        "validate_mcp_token",
-        expect.objectContaining({
-          p_token_hash: expect.any(String),
-        })
+      expect(mockCallMcpHandler).toHaveBeenCalledWith(
+        "auth.validate_token",
+        {},
+        "am_valid_test_token"
       );
     });
 
@@ -325,16 +212,16 @@ describe("Supabase DB Layer", () => {
       await expect(loginWithToken("not-am-token")).rejects.toThrow("Invalid token format");
     });
 
-    it("throws on RPC validation failure", async () => {
-      setResult({ data: null, error: { message: "validation failed" } });
+    it("throws on edge function validation failure", async () => {
+      mockCallMcpHandler.mockRejectedValueOnce(new Error("Token validation failed"));
 
       await expect(loginWithToken("am_bad_token")).rejects.toThrow("Token validation failed");
     });
   });
 
   describe("getCurrentUserId()", () => {
-    it("returns user ID when authenticated", async () => {
-      setResult({ data: [{ out_user_id: "user-123" }], error: null });
+    it("returns user ID from auth.validate_token", async () => {
+      mockCallMcpHandler.mockResolvedValueOnce({ user_id: "user-123" });
       const userId = await getCurrentUserId();
       expect(userId).toBe("user-123");
     });