assistme 0.1.4 → 0.1.6

package/dist/{chunk-VWSNGP65.js → chunk-QXT7DH44.js}

@@ -138,22 +138,6 @@ function writeAuthStore(data) {
   ensureAuthDir();
   writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2), { mode: 384 });
 }
-var fileStorage = {
-  getItem(key) {
-    const store = readAuthStore();
-    return store[key] ?? null;
-  },
-  setItem(key, value) {
-    const store = readAuthStore();
-    store[key] = value;
-    writeAuthStore(store);
-  },
-  removeItem(key) {
-    const store = readAuthStore();
-    delete store[key];
-    writeAuthStore(store);
-  }
-};
 var supabase = null;
 function getSupabase() {
   if (!supabase) {
@@ -164,12 +148,7 @@ function getSupabase() {
       );
     }
     supabase = createClient(config2.supabaseUrl, config2.supabaseAnonKey, {
-      auth: {
-        storage: fileStorage,
-        autoRefreshToken: false,
-        // We handle refresh via am_ token
-        persistSession: true
-      }
+      auth: { persistSession: false }
     });
   }
   return supabase;
@@ -177,16 +156,13 @@ function getSupabase() {
 function hashToken(token) {
   return createHash("sha256").update(token).digest("hex");
 }
-async function authenticateWithMcpToken(mcpToken) {
-  const tokenHash = hashToken(mcpToken);
-  const sb = getSupabase();
-  const { data, error } = await sb.rpc("login_with_mcp_token", {
-    p_token_hash: tokenHash
-  });
-  if (error) throw new Error(`Token validation failed: ${error.message}`);
-  if (data?.error) throw new Error(data.error);
-  if (!data?.access_token) throw new Error("Token validation returned no session");
-  return data;
+function getTokenHash() {
+  const store = readAuthStore();
+  const token = store["mcp_token"];
+  if (!token || !token.startsWith("am_")) {
+    throw new Error("Not authenticated. Run `assistme login`.");
+  }
+  return hashToken(token);
 }
 async function loginWithToken(mcpToken) {
   if (!mcpToken.startsWith("am_")) {
@@ -194,195 +170,149 @@ async function loginWithToken(mcpToken) {
       "Invalid token format. Use an am_ token from the web page."
     );
   }
-  const { access_token, user_id } = await authenticateWithMcpToken(mcpToken);
-  const store = readAuthStore();
-  store["mcp_token"] = mcpToken;
-  writeAuthStore(store);
+  const hash = hashToken(mcpToken);
   const sb = getSupabase();
-  const { data, error } = await sb.auth.setSession({
-    access_token,
-    refresh_token: "mcp_managed"
-    // placeholder; we refresh via am_ token
+  const { data, error } = await sb.rpc("validate_mcp_token", {
+    p_token_hash: hash
   });
-  if (error) throw new Error(`Login failed: ${error.message}`);
-  if (!data.user) throw new Error("Login failed: no user returned");
-  return data.user.id;
-}
-async function refreshWithCliToken() {
+  if (error) throw new Error(`Token validation failed: ${error.message}`);
+  if (!data || data.length === 0) throw new Error("Invalid or expired token");
   const store = readAuthStore();
-  const mcpToken = store["mcp_token"];
-  if (!mcpToken || !mcpToken.startsWith("am_")) return null;
-  try {
-    const { access_token } = await authenticateWithMcpToken(mcpToken);
-    const sb = getSupabase();
-    const { data, error } = await sb.auth.setSession({
-      access_token,
-      refresh_token: "mcp_managed"
-    });
-    if (error || !data.user) return null;
-    return data.user.id;
-  } catch {
-    return null;
-  }
-}
-async function getSession() {
-  const sb = getSupabase();
-  const { data } = await sb.auth.getSession();
-  return data.session;
+  store["mcp_token"] = mcpToken;
+  writeAuthStore(store);
+  return data[0].out_user_id;
 }
 async function getCurrentUserId() {
+  const hash = getTokenHash();
   const sb = getSupabase();
-  const { data, error } = await sb.auth.getUser();
-  if (error || !data.user) {
-    const refreshed = await refreshWithCliToken();
-    if (refreshed) return refreshed;
-    throw new Error("Not authenticated. Run `assistme login`.");
+  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.user.id;
+  return data[0].out_user_id;
 }
 async function logout() {
-  const sb = getSupabase();
-  await sb.auth.signOut();
   try {
     writeAuthStore({});
   } catch {
   }
 }
-async function createSession(userId, sessionName, workspacePath, version) {
+async function createSession(_userId, sessionName, workspacePath, version) {
   const sb = getSupabase();
-  const { data, error } = await sb.from("agent_sessions").insert({
-    user_id: userId,
-    session_name: sessionName,
-    status: "online",
-    workspace_path: workspacePath,
-    agent_version: version,
-    metadata: { model: getConfig().model }
-  }).select().single();
+  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
+  });
   if (error) throw new Error(`Failed to create session: ${error.message}`);
   return data;
 }
 async function updateHeartbeat(sessionId) {
   const sb = getSupabase();
-  const { error } = await sb.from("agent_sessions").update({ last_heartbeat_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", sessionId);
+  const { error } = await sb.rpc("mcp_heartbeat", {
+    p_token_hash: getTokenHash(),
+    p_session_id: sessionId
+  });
   if (error) log.warn(`Heartbeat update failed: ${error.message}`);
 }
 async function endSession(sessionId) {
   const sb = getSupabase();
-  const { error } = await sb.from("agent_sessions").update({
-    status: "offline",
-    ended_at: (/* @__PURE__ */ new Date()).toISOString()
-  }).eq("id", sessionId);
+  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}`);
 }
 async function setSessionBusy(sessionId, busy) {
   const sb = getSupabase();
-  await sb.from("agent_sessions").update({ status: busy ? "busy" : "online" }).eq("id", sessionId);
+  await sb.rpc("mcp_set_session_busy", {
+    p_token_hash: getTokenHash(),
+    p_session_id: sessionId,
+    p_busy: busy
+  });
 }
-async function getOrCreateCliConversation(userId, sessionId) {
+async function getOrCreateCliConversation(_userId, _sessionId) {
   const sb = getSupabase();
-  const { data: existing } = await sb.from("conversations").select("id").eq("agent", "cli").eq("created_by", userId).order("created_at", { ascending: false }).limit(1);
-  if (existing && existing.length > 0) {
-    return existing[0].id;
-  }
-  const { data: conv, error: convErr } = await sb.from("conversations").insert({
-    conversation_type: "direct",
-    agent: "cli",
-    created_by: userId
-  }).select("id").single();
-  if (convErr || !conv) {
-    throw new Error(`Failed to create conversation: ${convErr?.message}`);
-  }
-  await sb.from("conversation_participants").insert([
-    { conversation_id: conv.id, user_id: userId, role: "member" },
-    { conversation_id: conv.id, user_id: CLI_AGENT_ID, role: "member" }
-  ]);
-  return conv.id;
+  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;
 }
-async function createTask(conversationId, userId, sessionId, prompt) {
+async function createTask(conversationId, _userId, sessionId, prompt) {
   const sb = getSupabase();
-  const { data: rpcResult, error: rpcError } = await sb.rpc(
-    "create_task_pair",
-    {
-      p_conversation_id: conversationId,
-      p_user_id: userId,
-      p_agent_id: CLI_AGENT_ID,
-      p_session_id: sessionId,
-      p_prompt: prompt
-    }
-  );
-  if (!rpcError && rpcResult) {
-    return { ...rpcResult, prompt };
-  }
-  if (rpcError) {
-    log.debug(`create_task_pair RPC unavailable, using fallback: ${rpcError.message}`);
-  }
-  const { error: userErr } = await sb.from("conversation_messages").insert({
-    conversation_id: conversationId,
-    sender_id: userId,
-    role: "user",
-    content: prompt
+  const { data, error } = await sb.rpc("mcp_create_task", {
+    p_token_hash: getTokenHash(),
+    p_conversation_id: conversationId,
+    p_session_id: sessionId,
+    p_prompt: prompt
   });
-  if (userErr) throw new Error(`Failed to create user message: ${userErr.message}`);
-  const { data, error } = await sb.from("conversation_messages").insert({
-    conversation_id: conversationId,
-    sender_id: CLI_AGENT_ID,
-    role: "assistant",
-    content: "",
-    status: "pending",
-    session_id: sessionId,
-    metadata: { prompt }
-  }).select().single();
   if (error) throw new Error(`Failed to create task: ${error.message}`);
   return { ...data, prompt };
 }
 async function pollPendingTasks(sessionId) {
   const sb = getSupabase();
-  const { data, error } = await sb.from("conversation_messages").select("*").eq("session_id", sessionId).eq("status", "pending").order("created_at", { ascending: true }).limit(1);
+  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 [];
   }
-  return (data || []).map((row) => ({
+  const rows = data || [];
+  return rows.map((row) => ({
     ...row,
     prompt: row.metadata?.prompt || row.content || ""
   }));
 }
+async function pollAndClaimTask(sessionId) {
+  const sb = getSupabase();
+  const { data, error } = await sb.rpc("mcp_poll_and_claim_task", {
+    p_token_hash: getTokenHash(),
+    p_session_id: sessionId
+  });
+  if (error) {
+    log.warn(`Poll-and-claim failed: ${error.message}`);
+    return null;
+  }
+  if (!data) return null;
+  const row = data;
+  return {
+    ...row,
+    prompt: row.metadata?.prompt || row.content || ""
+  };
+}
 async function claimTask(messageId) {
   const sb = getSupabase();
-  const { error } = await sb.from("conversation_messages").update({
-    status: "running",
-    metadata: { started_at: (/* @__PURE__ */ new Date()).toISOString() }
-  }).eq("id", messageId).eq("status", "pending");
+  const { data, error } = await sb.rpc("mcp_claim_task", {
+    p_token_hash: getTokenHash(),
+    p_message_id: messageId
+  });
   if (error) throw new Error(`Failed to claim task: ${error.message}`);
+  return data;
 }
 async function completeTask(messageId, resultSummary, tokenUsage) {
   const sb = getSupabase();
-  const { data: current } = await sb.from("conversation_messages").select("metadata").eq("id", messageId).single();
-  const existingMeta = current?.metadata || {};
-  const { error } = await sb.from("conversation_messages").update({
-    content: resultSummary,
-    status: "completed",
-    metadata: {
-      ...existingMeta,
-      completed_at: (/* @__PURE__ */ new Date()).toISOString(),
-      token_usage: tokenUsage || null
-    }
-  }).eq("id", messageId);
+  const { error } = await sb.rpc("mcp_complete_task", {
+    p_token_hash: getTokenHash(),
+    p_message_id: messageId,
+    p_result: resultSummary,
+    p_token_usage: tokenUsage || null
+  });
   if (error) throw new Error(`Failed to complete task: ${error.message}`);
 }
 async function failTask(messageId, errorMessage) {
   const sb = getSupabase();
-  const { data: current } = await sb.from("conversation_messages").select("metadata").eq("id", messageId).single();
-  const existingMeta = current?.metadata || {};
-  const { error } = await sb.from("conversation_messages").update({
-    status: "failed",
-    content: errorMessage,
-    metadata: {
-      ...existingMeta,
-      completed_at: (/* @__PURE__ */ new Date()).toISOString(),
-      error_message: errorMessage
-    }
-  }).eq("id", messageId);
+  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}`);
 }
 var eventSequence = 0;
@@ -392,26 +322,26 @@ function resetEventSequence() {
 async function emitEvent(messageId, eventType, eventData) {
   const sb = getSupabase();
   eventSequence++;
-  const { error } = await sb.from("message_events").insert({
-    message_id: messageId,
-    event_type: eventType,
-    event_data: eventData,
-    sequence_number: 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}`);
 }
 async function emitEvents(messageId, events) {
   const sb = getSupabase();
-  const rows = events.map((e) => {
+  const eventsJson = events.map((e) => {
     eventSequence++;
-    return {
-      message_id: messageId,
-      event_type: e.type,
-      event_data: e.data,
-      sequence_number: 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
   });
-  const { error } = await sb.from("message_events").insert(rows);
   if (error) log.warn(`Failed to emit events batch: ${error.message}`);
 }
 
@@ -428,8 +358,6 @@ export {
   DAYBOX_AGENT_ID,
   getSupabase,
   loginWithToken,
-  refreshWithCliToken,
-  getSession,
   getCurrentUserId,
   logout,
   createSession,
@@ -439,6 +367,7 @@ export {
   getOrCreateCliConversation,
   createTask,
   pollPendingTasks,
+  pollAndClaimTask,
   claimTask,
   completeTask,
   failTask,