@gethmy/mcp 2.3.1 → 2.3.2

package/dist/lib/auto-session.js

@@ -1,214 +1,195 @@
-/**
- * Auto-Session Tracking
- *
- * Automatically detects agent session boundaries by monitoring tool calls.
- * Sessions auto-start when card-mutating tools are called, and auto-end
- * after 10 minutes of inactivity or when a different card is worked on.
- *
- * Agent identity is resolved from the MCP client's `initialize` handshake
- * (clientInfo.name), so "Claude Code", "Cursor", "Codex", etc. are
- * detected automatically — no hardcoded fallback needed.
- */
-/** Well-known MCP client names → human-friendly display names */
-const CLIENT_DISPLAY_NAMES = {
-    "claude-code": "Claude Code",
-    "claude-desktop": "Claude Desktop",
-    cursor: "Cursor",
-    windsurf: "Windsurf",
-    cline: "Cline",
-    continue: "Continue",
-    "codex-cli": "OpenAI Codex",
-    zed: "Zed",
-    "gemini-cli": "Gemini CLI",
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/auto-session.ts
+var CLIENT_DISPLAY_NAMES = {
+  "claude-code": "Claude Code",
+  "claude-desktop": "Claude Desktop",
+  cursor: "Cursor",
+  windsurf: "Windsurf",
+  cline: "Cline",
+  continue: "Continue",
+  "codex-cli": "OpenAI Codex",
+  zed: "Zed",
+  "gemini-cli": "Gemini CLI"
 };
-/** Derive a slug-style identifier from a client name */
 function toIdentifier(name) {
-    return name.toLowerCase().replace(/\s+/g, "-");
+  return name.toLowerCase().replace(/\s+/g, "-");
 }
-/** Resolve agent identity from MCP client info */
-export function resolveAgentIdentity(info) {
-    if (!info?.name) {
-        return { agentIdentifier: "unknown", agentName: "Unknown Agent" };
-    }
-    const key = toIdentifier(info.name);
-    const displayName = CLIENT_DISPLAY_NAMES[key] ?? info.name; // use raw name if not in map
-    return { agentIdentifier: key, agentName: displayName };
+function resolveAgentIdentity(info) {
+  if (!info?.name) {
+    return { agentIdentifier: "unknown", agentName: "Unknown Agent" };
+  }
+  const key = toIdentifier(info.name);
+  const displayName = CLIENT_DISPLAY_NAMES[key] ?? info.name;
+  return { agentIdentifier: key, agentName: displayName };
 }
-/** Tools that trigger auto-start of a session */
-export const AUTO_START_TRIGGERS = new Set([
-    "harmony_generate_prompt",
-    "harmony_update_card",
-    "harmony_move_card",
-    "harmony_create_subtask",
-    "harmony_toggle_subtask",
-    "harmony_add_label_to_card",
-    "harmony_remove_label_from_card",
+var AUTO_START_TRIGGERS = new Set([
+  "harmony_generate_prompt",
+  "harmony_update_card",
+  "harmony_move_card",
+  "harmony_create_subtask",
+  "harmony_toggle_subtask",
+  "harmony_add_label_to_card",
+  "harmony_remove_label_from_card"
 ]);
-export const INACTIVITY_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
-const CHECK_INTERVAL_MS = 60 * 1000; // 60 seconds
-const activeSessions = new Map();
-let inactivityTimer = null;
-let endCallback = null;
-let clientGetter = null;
-let clientInfoGetter = null;
-/**
- * Initialize auto-session tracking.
- * @param callback Called when an auto-session ends (runs the learning pipeline)
- * @param getClient Function to get the current API client
- * @param getClientInfo Function to get MCP client identity from the initialize handshake
- */
-export function initAutoSession(callback, getClient, getClientInfo) {
-    endCallback = callback;
-    clientGetter = getClient;
-    clientInfoGetter = getClientInfo ?? null;
-    if (inactivityTimer)
-        clearInterval(inactivityTimer);
-    inactivityTimer = setInterval(checkInactivity, CHECK_INTERVAL_MS);
+var INACTIVITY_TIMEOUT_MS = 10 * 60 * 1000;
+var CHECK_INTERVAL_MS = 60 * 1000;
+var activeSessions = new Map;
+var inactivityTimer = null;
+var endCallback = null;
+var clientGetter = null;
+var clientInfoGetter = null;
+function initAutoSession(callback, getClient, getClientInfo) {
+  endCallback = callback;
+  clientGetter = getClient;
+  clientInfoGetter = getClientInfo ?? null;
+  if (inactivityTimer)
+    clearInterval(inactivityTimer);
+  inactivityTimer = setInterval(checkInactivity, CHECK_INTERVAL_MS);
 }
-/**
- * Track activity on a card. Auto-starts a session if needed.
- */
-export async function trackActivity(cardId, options) {
-    const now = Date.now();
-    const existing = activeSessions.get(cardId);
-    if (existing) {
-        // Update last activity timestamp
-        existing.lastActivityAt = now;
-        return;
-    }
-    // Only auto-start if the tool is a trigger
-    if (!options?.autoStart)
-        return;
-    const client = options?.client ?? clientGetter?.();
-    if (!client)
-        return;
-    // Collect auto-sessions on other cards to end (avoid mutating map during iteration)
-    const toEnd = [];
-    for (const [otherCardId, session] of activeSessions) {
-        if (otherCardId !== cardId && !session.isExplicit) {
-            toEnd.push(otherCardId);
-        }
+async function trackActivity(cardId, options) {
+  const now = Date.now();
+  const existing = activeSessions.get(cardId);
+  if (existing) {
+    existing.lastActivityAt = now;
+    return;
+  }
+  if (!options?.autoStart)
+    return;
+  const client = options?.client ?? clientGetter?.();
+  if (!client)
+    return;
+  const toEnd = [];
+  for (const [otherCardId, session] of activeSessions) {
+    if (otherCardId !== cardId && !session.isExplicit) {
+      toEnd.push(otherCardId);
     }
-    for (const otherCardId of toEnd) {
-        await autoEndSession(client, otherCardId, "completed");
-    }
-    // Resolve agent identity from MCP client info
-    const info = clientInfoGetter?.() ?? null;
-    const { agentIdentifier, agentName } = resolveAgentIdentity(info);
-    // Start a new auto-session
-    try {
-        await client.startAgentSession(cardId, {
-            agentIdentifier,
-            agentName,
-            status: "working",
-        });
-    }
-    catch {
-        // Session start failed (might already have one), still track locally
-    }
-    activeSessions.set(cardId, {
-        cardId,
-        startedAt: now,
-        lastActivityAt: now,
-        isExplicit: false,
-        agentIdentifier,
-        agentName,
+  }
+  for (const otherCardId of toEnd) {
+    await autoEndSession(client, otherCardId, "completed");
+  }
+  const info = clientInfoGetter?.() ?? null;
+  const { agentIdentifier, agentName } = resolveAgentIdentity(info);
+  try {
+    await client.startAgentSession(cardId, {
+      agentIdentifier,
+      agentName,
+      status: "working"
     });
+  } catch {}
+  activeSessions.set(cardId, {
+    cardId,
+    startedAt: now,
+    lastActivityAt: now,
+    isExplicit: false,
+    agentIdentifier,
+    agentName
+  });
 }
-/**
- * Mark a session as explicitly started (won't be auto-ended by card switching or inactivity).
- * Optionally accepts the real agent identifier/name to store in the session.
- */
-export function markExplicit(cardId, options) {
-    const existing = activeSessions.get(cardId);
-    if (existing) {
-        existing.isExplicit = true;
-        if (options?.agentIdentifier)
-            existing.agentIdentifier = options.agentIdentifier;
-        if (options?.agentName)
-            existing.agentName = options.agentName;
-    }
-    else {
-        // Track the explicit session even if we didn't auto-start it
-        activeSessions.set(cardId, {
-            cardId,
-            startedAt: Date.now(),
-            lastActivityAt: Date.now(),
-            isExplicit: true,
-            agentIdentifier: options?.agentIdentifier ?? "explicit",
-            agentName: options?.agentName ?? "Explicit Agent",
-        });
-    }
+function markExplicit(cardId, options) {
+  const existing = activeSessions.get(cardId);
+  if (existing) {
+    existing.isExplicit = true;
+    if (options?.agentIdentifier)
+      existing.agentIdentifier = options.agentIdentifier;
+    if (options?.agentName)
+      existing.agentName = options.agentName;
+  } else {
+    activeSessions.set(cardId, {
+      cardId,
+      startedAt: Date.now(),
+      lastActivityAt: Date.now(),
+      isExplicit: true,
+      agentIdentifier: options?.agentIdentifier ?? "explicit",
+      agentName: options?.agentName ?? "Explicit Agent"
+    });
+  }
 }
-/**
- * Remove a session from tracking (called when session is explicitly ended).
- */
-export function untrack(cardId) {
-    activeSessions.delete(cardId);
+function untrack(cardId) {
+  activeSessions.delete(cardId);
 }
-/**
- * End all active auto-sessions (called on process shutdown).
- */
-export async function shutdownAllSessions() {
-    const client = clientGetter?.();
-    if (!client)
-        return;
-    // Snapshot keys to avoid mutating map during iteration
-    const cardIds = [...activeSessions.keys()];
-    const promises = cardIds.map((cardId) => autoEndSession(client, cardId, "paused"));
-    await Promise.allSettled(promises);
+async function shutdownAllSessions() {
+  const client = clientGetter?.();
+  if (!client)
+    return;
+  const cardIds = [...activeSessions.keys()];
+  const promises = cardIds.map((cardId) => autoEndSession(client, cardId, "paused"));
+  await Promise.allSettled(promises);
 }
-/**
- * Clean up the interval timer (for tests).
- */
-export function destroyAutoSession() {
-    if (inactivityTimer) {
-        clearInterval(inactivityTimer);
-        inactivityTimer = null;
-    }
-    activeSessions.clear();
-    endCallback = null;
-    clientGetter = null;
-    clientInfoGetter = null;
+function destroyAutoSession() {
+  if (inactivityTimer) {
+    clearInterval(inactivityTimer);
+    inactivityTimer = null;
+  }
+  activeSessions.clear();
+  endCallback = null;
+  clientGetter = null;
+  clientInfoGetter = null;
 }
-/**
- * Get a snapshot of active sessions (for testing/debugging).
- */
-export function getActiveSessions() {
-    return activeSessions;
+function getActiveSessions() {
+  return activeSessions;
 }
-/**
- * Run inactivity check immediately (exported for testing).
- * In production, called by the setInterval timer every 60s.
- */
-export function checkInactivity() {
-    const now = Date.now();
-    const client = clientGetter?.();
-    if (!client)
-        return;
-    // Snapshot keys to avoid mutating map during iteration
-    const entries = [...activeSessions.entries()];
-    for (const [cardId, session] of entries) {
-        if (session.isExplicit)
-            continue;
-        if (now - session.lastActivityAt > INACTIVITY_TIMEOUT_MS) {
-            autoEndSession(client, cardId, "completed").catch(() => { });
-        }
+function checkInactivity() {
+  const now = Date.now();
+  const client = clientGetter?.();
+  if (!client)
+    return;
+  const entries = [...activeSessions.entries()];
+  for (const [cardId, session] of entries) {
+    if (session.isExplicit)
+      continue;
+    if (now - session.lastActivityAt > INACTIVITY_TIMEOUT_MS) {
+      autoEndSession(client, cardId, "completed").catch(() => {});
     }
+  }
 }
-// --- Internal ---
 async function autoEndSession(client, cardId, status) {
-    activeSessions.delete(cardId);
-    try {
-        await client.endAgentSession(cardId, { status });
-    }
-    catch {
-        // Best-effort end
-    }
-    try {
-        await endCallback?.(client, cardId, status);
-    }
-    catch {
-        // Best-effort pipeline
-    }
+  activeSessions.delete(cardId);
+  try {
+    await client.endAgentSession(cardId, { status });
+  } catch {}
+  try {
+    await endCallback?.(client, cardId, status);
+  } catch {}
 }
+export {
+  untrack,
+  trackActivity,
+  shutdownAllSessions,
+  resolveAgentIdentity,
+  markExplicit,
+  initAutoSession,
+  getActiveSessions,
+  destroyAutoSession,
+  checkInactivity,
+  INACTIVITY_TIMEOUT_MS,
+  AUTO_START_TRIGGERS
+};