assistme 0.2.8 → 0.2.9

package/src/db/supabase.ts

@@ -1,15 +1,8 @@
-import { createClient, SupabaseClient } from "@supabase/supabase-js";
-import { createHash } from "crypto";
-import { getConfig } from "../utils/config.js";
-import { log } from "../utils/logger.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
-
-// ── Well-Known Agent Profile IDs ─────────────────────────────────────
-
-export const CLI_AGENT_ID = "00000000-0000-0000-0000-000000000001";
-export const DAYBOX_AGENT_ID = "00000000-0000-0000-0000-000000000002";
+import { callMcpHandler } from "./api-client.js";
+import { log } from "../utils/logger.js";
 
 // ── Auth Store (persists am_ token to disk) ──────────────────────────
 
@@ -38,46 +31,11 @@ function writeAuthStore(data: Record<string, string>) {
   writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
 }
 
-// ── Supabase Client (anon key only, no auth session) ────────────────
-
-let supabase: SupabaseClient | null = null;
-
-export function getSupabase(): SupabaseClient {
-  if (!supabase) {
-    const config = getConfig();
-    if (!config.supabaseUrl || !config.supabaseAnonKey) {
-      throw new Error(
-        "Supabase not configured. Run `assistme config set supabaseUrl <url>` first."
-      );
-    }
-    supabase = createClient(config.supabaseUrl, config.supabaseAnonKey, {
-      auth: { persistSession: false },
-    });
-  }
-  return supabase;
-}
-
-// ── Token Hash ──────────────────────────────────────────────────────
-
-function hashToken(token: string): string {
-  return createHash("sha256").update(token).digest("hex");
-}
-
-/** Get stored token hash (computed from persisted am_ token). */
-function getTokenHash(): string {
-  const store = readAuthStore();
-  const token = store["mcp_token"];
-  if (!token || !token.startsWith("am_")) {
-    throw new Error("Not authenticated. Run `assistme login`.");
-  }
-  return hashToken(token);
-}
-
 // ── Auth ─────────────────────────────────────────────────────────────
 
 /**
  * Login using an am_ MCP token.
- * Validates against DB via validate_mcp_token RPC, stores locally.
+ * Validates against DB via edge function, stores locally.
  */
 export async function loginWithToken(mcpToken: string): Promise<string> {
   if (!mcpToken.startsWith("am_")) {
@@ -86,34 +44,25 @@ export async function loginWithToken(mcpToken: string): Promise<string> {
     );
   }
 
-  const hash = hashToken(mcpToken);
-  const sb = getSupabase();
-
-  const { data, error } = await sb.rpc("validate_mcp_token", {
-    p_token_hash: hash,
-  });
-
-  if (error) throw new Error(`Token validation failed: ${error.message}`);
-  if (!data || data.length === 0) throw new Error("Invalid or expired token");
+  const result = await callMcpHandler<{ user_id: string; email: string | null }>(
+    "auth.validate_token",
+    {},
+    mcpToken,
+  );
 
   // Persist token
   const store = readAuthStore();
   store["mcp_token"] = mcpToken;
   writeAuthStore(store);
 
-  return data[0].out_user_id;
+  return result.user_id;
 }
 
 export async function getCurrentUserId(): Promise<string> {
-  const hash = getTokenHash();
-  const sb = getSupabase();
-  const { data, error } = await sb.rpc("validate_mcp_token", {
-    p_token_hash: hash,
-  });
-  if (error || !data || data.length === 0) {
-    throw new Error("Token expired or revoked. Run `assistme login`.");
-  }
-  return data[0].out_user_id;
+  const result = await callMcpHandler<{ user_id: string }>(
+    "auth.validate_token",
+  );
+  return result.user_id;
 }
 
 export async function logout(): Promise<void> {
@@ -145,61 +94,71 @@ export async function createSession(
   workspacePath: string,
   version: string
 ): Promise<AgentSession> {
-  const sb = getSupabase();
-  const { data, error } = await sb.rpc("mcp_create_session", {
-    p_token_hash: getTokenHash(),
-    p_session_name: sessionName,
-    p_workspace_path: workspacePath,
-    p_version: version,
-    p_model: getConfig().model || null,
+  const { getConfig } = await import("../utils/config.js");
+  const data = await callMcpHandler<AgentSession>("session.create", {
+    session_name: sessionName,
+    workspace_path: workspacePath,
+    version,
+    model: getConfig().model || null,
   });
-
-  if (error) throw new Error(`Failed to create session: ${error.message}`);
-  return data as AgentSession;
+  return data;
 }
 
 export async function updateHeartbeat(sessionId: string): Promise<void> {
-  const sb = getSupabase();
-  const { error } = await sb.rpc("mcp_heartbeat", {
-    p_token_hash: getTokenHash(),
-    p_session_id: sessionId,
-  });
-  if (error) log.warn(`Heartbeat update failed: ${error.message}`);
+  try {
+    await callMcpHandler("session.heartbeat", { session_id: sessionId });
+  } catch (err) {
+    log.warn(`Heartbeat update failed: ${err instanceof Error ? err.message : err}`);
+  }
 }
 
 export async function endSession(sessionId: string): Promise<void> {
-  const sb = getSupabase();
-  const { error } = await sb.rpc("mcp_end_session", {
-    p_token_hash: getTokenHash(),
-    p_session_id: sessionId,
-  });
-  if (error) log.error(`Failed to end session: ${error.message}`);
+  try {
+    await callMcpHandler("session.end", { session_id: sessionId });
+  } catch (err) {
+    log.error(`Failed to end session: ${err instanceof Error ? err.message : err}`);
+  }
 }
 
 export async function setSessionBusy(
   sessionId: string,
   busy: boolean
 ): Promise<void> {
-  const sb = getSupabase();
-  await sb.rpc("mcp_set_session_busy", {
-    p_token_hash: getTokenHash(),
-    p_session_id: sessionId,
-    p_busy: busy,
+  await callMcpHandler("session.set_busy", {
+    session_id: sessionId,
+    busy,
   });
 }
 
+export async function cleanupStaleSessions(
+  currentSessionId: string,
+  thresholdMs = 120_000
+): Promise<number> {
+  try {
+    const result = await callMcpHandler<{ cleaned: number }>(
+      "session.cleanup_stale",
+      { current_session_id: currentSessionId, threshold_ms: thresholdMs },
+    );
+    return result.cleaned;
+  } catch {
+    return 0;
+  }
+}
+
+export async function getActiveSessions(
+  limit = 5
+): Promise<AgentSession[]> {
+  return callMcpHandler<AgentSession[]>("session.get_active", { limit });
+}
+
 // ── Conversation Management ─────────────────────────────────────────
 
 export async function getOrCreateCliConversation(
   _userId: string,
   _sessionId: string
 ): Promise<string> {
-  const sb = getSupabase();
-  const { data, error } = await sb.rpc("mcp_get_or_create_conversation", {
-    p_token_hash: getTokenHash(),
-  });
-  if (error) throw new Error(`Failed to get conversation: ${error.message}`);
-  return data as string;
+  const data = await callMcpHandler<string>("conversation.get_or_create");
+  return data;
 }
 
 // ── Message / Task Management ────────────────────────────────────────
@@ -228,77 +187,46 @@ export async function createTask(
   sessionId: string,
   prompt: string
 ): Promise<ConversationMessage> {
-  const sb = getSupabase();
-  const { data, error } = await sb.rpc("mcp_create_task", {
-    p_token_hash: getTokenHash(),
-    p_conversation_id: conversationId,
-    p_session_id: sessionId,
-    p_prompt: prompt,
+  const data = await callMcpHandler<Record<string, unknown>>("task.create", {
+    conversation_id: conversationId,
+    session_id: sessionId,
+    prompt,
   });
-
-  if (error) throw new Error(`Failed to create task: ${error.message}`);
   return { ...data, prompt } as ConversationMessage;
 }
 
-export async function pollPendingTasks(
-  sessionId: string
-): Promise<ConversationMessage[]> {
-  const sb = getSupabase();
-  const { data, error } = await sb.rpc("mcp_poll_tasks", {
-    p_token_hash: getTokenHash(),
-    p_session_id: sessionId,
-  });
-
-  if (error) {
-    log.warn(`Task poll failed: ${error.message}`);
-    return [];
-  }
-
-  const rows = (data || []) as Record<string, unknown>[];
-  return rows.map((row) => ({
-    ...row,
-    prompt:
-      (row.metadata as Record<string, unknown>)?.prompt || row.content || "",
-  })) as ConversationMessage[];
-}
-
 /**
- * Atomically poll ONE pending task and claim it in a single DB call.
+ * Atomically poll ONE pending task and claim it in a single call.
  * Uses FOR UPDATE SKIP LOCKED — concurrent CLIs will never grab the same task.
  * Returns null if no pending task exists.
  */
 export async function pollAndClaimTask(
   sessionId: string
 ): Promise<ConversationMessage | null> {
-  const sb = getSupabase();
-  const { data, error } = await sb.rpc("mcp_poll_and_claim_task", {
-    p_token_hash: getTokenHash(),
-    p_session_id: sessionId,
-  });
+  try {
+    const data = await callMcpHandler<Record<string, unknown> | null>(
+      "task.poll_and_claim",
+      { session_id: sessionId },
+    );
+
+    if (!data) return null;
 
-  if (error) {
-    log.warn(`Poll-and-claim failed: ${error.message}`);
+    return {
+      ...data,
+      prompt:
+        (data.metadata as Record<string, unknown>)?.prompt || data.content || "",
+    } as ConversationMessage;
+  } catch (err) {
+    log.warn(`Poll-and-claim failed: ${err instanceof Error ? err.message : err}`);
     return null;
   }
-
-  if (!data) return null;
-
-  const row = data as Record<string, unknown>;
-  return {
-    ...row,
-    prompt:
-      (row.metadata as Record<string, unknown>)?.prompt || row.content || "",
-  } as ConversationMessage;
 }
 
 export async function claimTask(messageId: string): Promise<boolean> {
-  const sb = getSupabase();
-  const { data, error } = await sb.rpc("mcp_claim_task", {
-    p_token_hash: getTokenHash(),
-    p_message_id: messageId,
+  const data = await callMcpHandler<boolean>("task.claim", {
+    message_id: messageId,
   });
-  if (error) throw new Error(`Failed to claim task: ${error.message}`);
-  return data as boolean;
+  return data;
 }
 
 export async function completeTask(
@@ -306,27 +234,25 @@ export async function completeTask(
   resultSummary: string,
   tokenUsage?: Record<string, number>
 ): Promise<void> {
-  const sb = getSupabase();
-  const { error } = await sb.rpc("mcp_complete_task", {
-    p_token_hash: getTokenHash(),
-    p_message_id: messageId,
-    p_result: resultSummary,
-    p_token_usage: tokenUsage || null,
+  await callMcpHandler("task.complete", {
+    message_id: messageId,
+    result: resultSummary,
+    token_usage: tokenUsage || null,
   });
-  if (error) throw new Error(`Failed to complete task: ${error.message}`);
 }
 
 export async function failTask(
   messageId: string,
   errorMessage: string
 ): Promise<void> {
-  const sb = getSupabase();
-  const { error } = await sb.rpc("mcp_fail_task", {
-    p_token_hash: getTokenHash(),
-    p_message_id: messageId,
-    p_error: errorMessage,
-  });
-  if (error) log.error(`Failed to update task status: ${error.message}`);
+  try {
+    await callMcpHandler("task.fail", {
+      message_id: messageId,
+      error: errorMessage,
+    });
+  } catch (err) {
+    log.error(`Failed to update task status: ${err instanceof Error ? err.message : err}`);
+  }
 }
 
 // ── Job Run Polling ─────────────────────────────────────────────────
@@ -344,20 +270,17 @@ export interface PendingJobRun {
  * Returns null if no pending job run exists.
  */
 export async function pollAndClaimJobRun(
-  userId: string
+  _userId: string
 ): Promise<PendingJobRun | null> {
-  const sb = getSupabase();
-  const { data, error } = await sb.rpc("claim_pending_job_run", {
-    p_user_id: userId,
-  });
-
-  if (error) {
-    log.debug(`Job run poll failed: ${error.message}`);
+  try {
+    const data = await callMcpHandler<PendingJobRun | null>(
+      "job.claim_pending_run",
+    );
+    return data;
+  } catch (err) {
+    log.debug(`Job run poll failed: ${err instanceof Error ? err.message : err}`);
     return null;
   }
-
-  if (!data) return null;
-  return data as PendingJobRun;
 }
 
 // ── Conversation History ─────────────────────────────────────────────
@@ -376,37 +299,33 @@ export async function getConversationHistory(
   excludeMessageId: string,
   limit: number = 20
 ): Promise<HistoryEntry[]> {
-  const sb = getSupabase();
-
-  const { data, error } = await sb
-    .from("conversation_messages")
-    .select("id, role, content, status, metadata, created_at")
-    .eq("conversation_id", conversationId)
-    .in("status", ["completed", "failed"])
-    .neq("id", excludeMessageId)
-    .order("created_at", { ascending: false })
-    .limit(limit);
-
-  if (error) {
-    log.debug(`Failed to fetch conversation history: ${error.message}`);
+  try {
+    const rows = await callMcpHandler<Array<Record<string, unknown>>>(
+      "conversation.get_history",
+      {
+        conversation_id: conversationId,
+        exclude_message_id: excludeMessageId,
+        limit,
+      },
+    );
+
+    return (rows || [])
+      .reverse() // chronological order (oldest first)
+      .map((row) => {
+        const prompt =
+          ((row.metadata as Record<string, unknown>)?.prompt as string) || "";
+        const content = (row.content as string) || "";
+        const response =
+          row.status === "failed"
+            ? `[Task failed] ${content}`
+            : content;
+        return { prompt, response };
+      })
+      .filter((entry) => entry.prompt && entry.response);
+  } catch (err) {
+    log.debug(`Failed to fetch conversation history: ${err instanceof Error ? err.message : err}`);
     return [];
   }
-
-  const rows = (data || []) as Array<Record<string, unknown>>;
-
-  return rows
-    .reverse() // chronological order (oldest first)
-    .map((row) => {
-      const prompt =
-        ((row.metadata as Record<string, unknown>)?.prompt as string) || "";
-      const content = (row.content as string) || "";
-      const response =
-        row.status === "failed"
-          ? `[Task failed] ${content}`
-          : content;
-      return { prompt, response };
-    })
-    .filter((entry) => entry.prompt && entry.response);
 }
 
 // ── Event Streaming ─────────────────────────────────────────────────
@@ -432,33 +351,17 @@ export async function emitEvent(
   eventType: EventType,
   eventData: Record<string, unknown>
 ): Promise<void> {
-  const sb = getSupabase();
   eventSequence++;
-  const { error } = await sb.rpc("mcp_emit_event", {
-    p_token_hash: getTokenHash(),
-    p_message_id: messageId,
-    p_event_type: eventType,
-    p_event_data: eventData,
-    p_seq: eventSequence,
-  });
-  if (error) log.warn(`Failed to emit event: ${error.message}`);
-}
-
-export async function emitEvents(
-  messageId: string,
-  events: Array<{ type: EventType; data: Record<string, unknown> }>
-): Promise<void> {
-  const sb = getSupabase();
-  const eventsJson = events.map((e) => {
-    eventSequence++;
-    return { type: e.type, data: e.data, seq: eventSequence };
-  });
-  const { error } = await sb.rpc("mcp_emit_events", {
-    p_token_hash: getTokenHash(),
-    p_message_id: messageId,
-    p_events: eventsJson,
-  });
-  if (error) log.warn(`Failed to emit events batch: ${error.message}`);
+  try {
+    await callMcpHandler("event.emit", {
+      message_id: messageId,
+      event_type: eventType,
+      event_data: eventData,
+      seq: eventSequence,
+    });
+  } catch (err) {
+    log.warn(`Failed to emit event: ${err instanceof Error ? err.message : err}`);
+  }
 }
 
 // ── Action Request Helpers ──────────────────────────────────────────
@@ -467,23 +370,17 @@ export async function setActionRequest(
   messageId: string,
   actionData: Record<string, unknown>
 ): Promise<void> {
-  const sb = getSupabase();
-  const { error } = await sb.rpc("mcp_set_action_request", {
-    p_token_hash: getTokenHash(),
-    p_message_id: messageId,
-    p_action_data: actionData,
+  await callMcpHandler("action.set_request", {
+    message_id: messageId,
+    action_data: actionData,
   });
-  if (error) throw new Error(`Failed to set action request: ${error.message}`);
 }
 
 export async function pollActionResponse(
   messageId: string
 ): Promise<Record<string, unknown> | null> {
-  const sb = getSupabase();
-  const { data, error } = await sb.rpc("mcp_poll_action_response", {
-    p_token_hash: getTokenHash(),
-    p_message_id: messageId,
-  });
-  if (error) throw new Error(`Failed to poll action response: ${error.message}`);
-  return data as Record<string, unknown> | null;
+  return callMcpHandler<Record<string, unknown> | null>(
+    "action.poll_response",
+    { message_id: messageId },
+  );
 }