@within-7/minto 0.0.5-dev.1

package/dist/services/mentionProcessor.js

@@ -0,0 +1,201 @@
+import { emitReminderEvent } from "./systemReminder.js";
+import { getAvailableAgentTypes } from "../utils/agentLoader.js";
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { getCwd } from "../utils/state.js";
+import { debug as debugLogger } from "../utils/debugLogger.js";
+class MentionProcessorService {
+  // Centralized mention patterns - single source of truth
+  static MENTION_PATTERNS = {
+    runAgent: /@(run-agent-[\w\-]+)/g,
+    agent: /@(agent-[\w\-]+)/g,
+    // Legacy support
+    askModel: /@(ask-[\w\-]+)/g,
+    file: /@([a-zA-Z0-9/._-]+(?:\.[a-zA-Z0-9]+)?)/g
+  };
+  agentCache = /* @__PURE__ */ new Map();
+  lastAgentCheck = 0;
+  CACHE_TTL = 6e4;
+  // 1 minute cache
+  /**
+   * Process mentions in user input and emit appropriate events
+   * This follows the event-driven philosophy of system reminders
+   */
+  async processMentions(input) {
+    const result = {
+      agents: [],
+      files: [],
+      hasAgentMentions: false,
+      hasFileMentions: false
+    };
+    try {
+      const agentMentions = this.extractAgentMentions(input);
+      if (agentMentions.length > 0) {
+        await this.refreshAgentCache();
+        for (const { mention, agentType, isAskModel } of agentMentions) {
+          if (isAskModel || this.agentCache.has(agentType)) {
+            result.agents.push({
+              type: "agent",
+              mention,
+              resolved: agentType,
+              exists: true,
+              metadata: isAskModel ? { type: "ask-model" } : void 0
+            });
+            result.hasAgentMentions = true;
+            this.emitAgentMentionEvent(mention, agentType, isAskModel);
+          }
+        }
+      }
+      const fileMatches = [...input.matchAll(MentionProcessorService.MENTION_PATTERNS.file)];
+      const processedAgentMentions = new Set(agentMentions.map((am) => am.mention));
+      for (const match of fileMatches) {
+        const mention = match[1];
+        if (mention.startsWith("run-agent-") || mention.startsWith("agent-") || mention.startsWith("ask-") || processedAgentMentions.has(mention)) {
+          continue;
+        }
+        const filePath = this.resolveFilePath(mention);
+        if (existsSync(filePath)) {
+          result.files.push({
+            type: "file",
+            mention,
+            resolved: filePath,
+            exists: true
+          });
+          result.hasFileMentions = true;
+          emitReminderEvent("file:mentioned", {
+            filePath,
+            originalMention: mention,
+            timestamp: Date.now()
+          });
+        }
+      }
+      return result;
+    } catch (error) {
+      console.warn("[MentionProcessor] Failed to process mentions:", {
+        input: input.substring(0, 100) + (input.length > 100 ? "..." : ""),
+        error: error instanceof Error ? error.message : error
+      });
+      return {
+        agents: [],
+        files: [],
+        hasAgentMentions: false,
+        hasFileMentions: false
+      };
+    }
+  }
+  // Removed identifyMention method as it's no longer needed with separate processing
+  /**
+   * Resolve file path relative to current working directory
+   */
+  resolveFilePath(mention) {
+    return resolve(getCwd(), mention);
+  }
+  /**
+   * Refresh the agent cache periodically
+   * This avoids hitting the agent loader on every mention
+   */
+  async refreshAgentCache() {
+    const now = Date.now();
+    if (now - this.lastAgentCheck < this.CACHE_TTL) {
+      return;
+    }
+    try {
+      const agents = await getAvailableAgentTypes();
+      const previousCacheSize = this.agentCache.size;
+      this.agentCache.clear();
+      for (const agent of agents) {
+        this.agentCache.set(agent.agentType, true);
+      }
+      this.lastAgentCheck = now;
+      if (agents.length !== previousCacheSize) {
+        debugLogger.info("MENTION_PROCESSOR_CACHE_REFRESHED", {
+          agentCount: agents.length,
+          previousCacheSize,
+          cacheAge: now - this.lastAgentCheck
+        });
+      }
+    } catch (error) {
+      console.warn("[MentionProcessor] Failed to refresh agent cache, keeping existing cache:", {
+        error: error instanceof Error ? error.message : error,
+        cacheSize: this.agentCache.size,
+        lastRefresh: new Date(this.lastAgentCheck).toISOString()
+      });
+    }
+  }
+  /**
+   * Extract agent mentions with unified pattern matching
+   * Consolidates run-agent, agent, and ask-model detection logic
+   */
+  extractAgentMentions(input) {
+    const mentions = [];
+    const runAgentMatches = [...input.matchAll(MentionProcessorService.MENTION_PATTERNS.runAgent)];
+    for (const match of runAgentMatches) {
+      const mention = match[1];
+      const agentType = mention.replace(/^run-agent-/, "");
+      mentions.push({ mention, agentType, isAskModel: false });
+    }
+    const agentMatches = [...input.matchAll(MentionProcessorService.MENTION_PATTERNS.agent)];
+    for (const match of agentMatches) {
+      const mention = match[1];
+      const agentType = mention.replace(/^agent-/, "");
+      mentions.push({ mention, agentType, isAskModel: false });
+    }
+    const askModelMatches = [...input.matchAll(MentionProcessorService.MENTION_PATTERNS.askModel)];
+    for (const match of askModelMatches) {
+      const mention = match[1];
+      mentions.push({ mention, agentType: mention, isAskModel: true });
+    }
+    return mentions;
+  }
+  /**
+   * Emit agent mention event with proper typing
+   * Centralized event emission to ensure consistency
+   */
+  emitAgentMentionEvent(mention, agentType, isAskModel) {
+    try {
+      const eventData = {
+        originalMention: mention,
+        timestamp: Date.now()
+      };
+      if (isAskModel) {
+        emitReminderEvent("ask-model:mentioned", {
+          ...eventData,
+          modelName: mention
+        });
+      } else {
+        emitReminderEvent("agent:mentioned", {
+          ...eventData,
+          agentType
+        });
+      }
+      debugLogger.info("MENTION_PROCESSOR_EVENT_EMITTED", {
+        type: isAskModel ? "ask-model" : "agent",
+        mention,
+        agentType: isAskModel ? void 0 : agentType
+      });
+    } catch (error) {
+      debugLogger.error("MENTION_PROCESSOR_EVENT_FAILED", {
+        mention,
+        agentType,
+        isAskModel,
+        error: error instanceof Error ? error.message : error
+      });
+    }
+  }
+  /**
+   * Clear caches - useful for testing or reset
+   */
+  clearCache() {
+    this.agentCache.clear();
+    this.lastAgentCheck = 0;
+  }
+}
+const mentionProcessor = new MentionProcessorService();
+const processMentions = (input) => mentionProcessor.processMentions(input);
+const clearMentionCache = () => mentionProcessor.clearCache();
+export {
+  clearMentionCache,
+  mentionProcessor,
+  processMentions
+};
+//# sourceMappingURL=mentionProcessor.js.map

package/dist/services/mentionProcessor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/services/mentionProcessor.ts"],
+  "sourcesContent": ["/**\n * Mention Processor Service\n * Handles @agent and @file mentions through the system reminder infrastructure\n * Designed to integrate naturally with the existing event-driven architecture\n */\n\nimport { emitReminderEvent } from './systemReminder'\nimport { getAvailableAgentTypes } from '@utils/agentLoader'\nimport { existsSync } from 'fs'\nimport { resolve } from 'path'\nimport { getCwd } from '@utils/state'\nimport { debug as debugLogger } from '@utils/debugLogger'\n\nexport interface MentionContext {\n  type: 'agent' | 'file'\n  mention: string\n  resolved: string\n  exists: boolean\n  metadata?: any\n}\n\nexport interface ProcessedMentions {\n  agents: MentionContext[]\n  files: MentionContext[]\n  hasAgentMentions: boolean\n  hasFileMentions: boolean\n}\n\nclass MentionProcessorService {\n  // Centralized mention patterns - single source of truth\n  private static readonly MENTION_PATTERNS = {\n    runAgent: /@(run-agent-[\\w\\-]+)/g,\n    agent: /@(agent-[\\w\\-]+)/g,  // Legacy support\n    askModel: /@(ask-[\\w\\-]+)/g,\n    file: /@([a-zA-Z0-9/._-]+(?:\\.[a-zA-Z0-9]+)?)/g\n  } as const\n\n  private agentCache: Map<string, boolean> = new Map()\n  private lastAgentCheck: number = 0\n  private CACHE_TTL = 60000 // 1 minute cache\n\n  /**\n   * Process mentions in user input and emit appropriate events\n   * This follows the event-driven philosophy of system reminders\n   */\n  public async processMentions(input: string): Promise<ProcessedMentions> {\n    const result: ProcessedMentions = {\n      agents: [],\n      files: [],\n      hasAgentMentions: false,\n      hasFileMentions: false,\n    }\n\n    try {\n\n    // Process agent mentions with unified logic to eliminate code duplication\n    const agentMentions = this.extractAgentMentions(input)\n    if (agentMentions.length > 0) {\n      await this.refreshAgentCache()\n      \n      for (const { mention, agentType, isAskModel } of agentMentions) {\n        if (isAskModel || this.agentCache.has(agentType)) {\n          result.agents.push({\n            type: 'agent',\n            mention,\n            resolved: agentType,\n            exists: true,\n            metadata: isAskModel ? { type: 'ask-model' } : undefined\n          })\n          result.hasAgentMentions = true\n          \n          // Emit appropriate event based on mention type\n          this.emitAgentMentionEvent(mention, agentType, isAskModel)\n        }\n      }\n    }\n    \n    // No longer process @xxx format - treat as regular text (emails, etc.)\n\n    // Process file mentions (exclude agent and ask-model mentions)\n    const fileMatches = [...input.matchAll(MentionProcessorService.MENTION_PATTERNS.file)]\n    const processedAgentMentions = new Set(agentMentions.map(am => am.mention))\n    \n    for (const match of fileMatches) {\n      const mention = match[1]\n      \n      // Skip if this is an agent or ask-model mention (already processed)\n      if (mention.startsWith('run-agent-') || mention.startsWith('agent-') || mention.startsWith('ask-') || processedAgentMentions.has(mention)) {\n        continue\n      }\n      \n      // Check if it's a file\n      const filePath = this.resolveFilePath(mention)\n      if (existsSync(filePath)) {\n        result.files.push({\n          type: 'file',\n          mention,\n          resolved: filePath,\n          exists: true,\n        })\n        result.hasFileMentions = true\n        \n        // Emit file mention event for system reminder to handle\n        emitReminderEvent('file:mentioned', {\n          filePath: filePath,\n          originalMention: mention,\n          timestamp: Date.now(),\n        })\n      }\n    }\n\n      return result\n    } catch (error) {\n      console.warn('[MentionProcessor] Failed to process mentions:', {\n        input: input.substring(0, 100) + (input.length > 100 ? '...' : ''),\n        error: error instanceof Error ? error.message : error\n      })\n      \n      // Return empty result on error to maintain system stability\n      return {\n        agents: [],\n        files: [],\n        hasAgentMentions: false,\n        hasFileMentions: false,\n      }\n    }\n  }\n\n  // Removed identifyMention method as it's no longer needed with separate processing\n\n  /**\n   * Resolve file path relative to current working directory\n   */\n  private resolveFilePath(mention: string): string {\n    // Simple consistent logic: mention is always relative to current directory\n    return resolve(getCwd(), mention)\n  }\n\n  /**\n   * Refresh the agent cache periodically\n   * This avoids hitting the agent loader on every mention\n   */\n  private async refreshAgentCache(): Promise<void> {\n    const now = Date.now()\n    if (now - this.lastAgentCheck < this.CACHE_TTL) {\n      return // Cache is still fresh\n    }\n\n    try {\n      const agents = await getAvailableAgentTypes()\n      const previousCacheSize = this.agentCache.size\n      this.agentCache.clear()\n      \n      for (const agent of agents) {\n        // Store only the agent type without prefix for consistent lookup\n        this.agentCache.set(agent.agentType, true)\n      }\n      \n      this.lastAgentCheck = now\n      \n      // Log cache refresh for debugging mention resolution issues\n      if (agents.length !== previousCacheSize) {\n        debugLogger.info('MENTION_PROCESSOR_CACHE_REFRESHED', {\n          agentCount: agents.length,\n          previousCacheSize,\n          cacheAge: now - this.lastAgentCheck,\n        })\n      }\n    } catch (error) {\n      console.warn('[MentionProcessor] Failed to refresh agent cache, keeping existing cache:', {\n        error: error instanceof Error ? error.message : error,\n        cacheSize: this.agentCache.size,\n        lastRefresh: new Date(this.lastAgentCheck).toISOString()\n      })\n      // Keep existing cache on error to maintain functionality\n    }\n  }\n\n  /**\n   * Extract agent mentions with unified pattern matching\n   * Consolidates run-agent, agent, and ask-model detection logic\n   */\n  private extractAgentMentions(input: string): Array<{ mention: string; agentType: string; isAskModel: boolean }> {\n    const mentions: Array<{ mention: string; agentType: string; isAskModel: boolean }> = []\n    \n    // Process @run-agent-xxx format (preferred)\n    const runAgentMatches = [...input.matchAll(MentionProcessorService.MENTION_PATTERNS.runAgent)]\n    for (const match of runAgentMatches) {\n      const mention = match[1]\n      const agentType = mention.replace(/^run-agent-/, '')\n      mentions.push({ mention, agentType, isAskModel: false })\n    }\n    \n    // Process @agent-xxx format (legacy)\n    const agentMatches = [...input.matchAll(MentionProcessorService.MENTION_PATTERNS.agent)]\n    for (const match of agentMatches) {\n      const mention = match[1]\n      const agentType = mention.replace(/^agent-/, '')\n      mentions.push({ mention, agentType, isAskModel: false })\n    }\n    \n    // Process @ask-model mentions\n    const askModelMatches = [...input.matchAll(MentionProcessorService.MENTION_PATTERNS.askModel)]\n    for (const match of askModelMatches) {\n      const mention = match[1]\n      mentions.push({ mention, agentType: mention, isAskModel: true })\n    }\n    \n    return mentions\n  }\n  \n  /**\n   * Emit agent mention event with proper typing\n   * Centralized event emission to ensure consistency\n   */\n  private emitAgentMentionEvent(mention: string, agentType: string, isAskModel: boolean): void {\n    try {\n      const eventData = {\n        originalMention: mention,\n        timestamp: Date.now(),\n      }\n\n      if (isAskModel) {\n        emitReminderEvent('ask-model:mentioned', {\n          ...eventData,\n          modelName: mention,\n        })\n      } else {\n        emitReminderEvent('agent:mentioned', {\n          ...eventData,\n          agentType,\n        })\n      }\n      \n      // Debug log for mention event emission tracking\n      debugLogger.info('MENTION_PROCESSOR_EVENT_EMITTED', {\n        type: isAskModel ? 'ask-model' : 'agent',\n        mention,\n        agentType: isAskModel ? undefined : agentType,\n      })\n    } catch (error) {\n      debugLogger.error('MENTION_PROCESSOR_EVENT_FAILED', {\n        mention,\n        agentType,\n        isAskModel,\n        error: error instanceof Error ? error.message : error,\n      })\n    }\n  }\n\n  /**\n   * Clear caches - useful for testing or reset\n   */\n  public clearCache(): void {\n    this.agentCache.clear()\n    this.lastAgentCheck = 0\n  }\n}\n\n// Export singleton instance\nexport const mentionProcessor = new MentionProcessorService()\n\n/**\n * Process mentions in user input\n * This is the main API for the mention processor\n */\nexport const processMentions = (input: string) => \n  mentionProcessor.processMentions(input)\n\n/**\n * Clear mention processor caches\n */\nexport const clearMentionCache = () =>\n  mentionProcessor.clearCache()\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/services/modelAdapterFactory.js

@@ -0,0 +1,47 @@
+import { ResponsesAPIAdapter } from "./adapters/responsesAPI.js";
+import { ChatCompletionsAdapter } from "./adapters/chatCompletions.js";
+import { getModelCapabilities } from "../constants/modelCapabilities.js";
+class ModelAdapterFactory {
+  /**
+   * Create appropriate adapter based on model configuration
+   */
+  static createAdapter(modelProfile) {
+    const capabilities = getModelCapabilities(modelProfile.modelName);
+    const apiType = this.determineAPIType(modelProfile, capabilities);
+    switch (apiType) {
+      case "responses_api":
+        return new ResponsesAPIAdapter(capabilities, modelProfile);
+      case "chat_completions":
+      default:
+        return new ChatCompletionsAdapter(capabilities, modelProfile);
+    }
+  }
+  /**
+   * Determine which API should be used
+   */
+  static determineAPIType(modelProfile, capabilities) {
+    if (capabilities.apiArchitecture.primary !== "responses_api") {
+      return "chat_completions";
+    }
+    const isOfficialOpenAI = !modelProfile.baseURL || modelProfile.baseURL.includes("api.openai.com");
+    if (!isOfficialOpenAI) {
+      if (capabilities.apiArchitecture.fallback === "chat_completions") {
+        return "chat_completions";
+      }
+      return capabilities.apiArchitecture.primary;
+    }
+    return capabilities.apiArchitecture.primary;
+  }
+  /**
+   * Check if model should use Responses API
+   */
+  static shouldUseResponsesAPI(modelProfile) {
+    const capabilities = getModelCapabilities(modelProfile.modelName);
+    const apiType = this.determineAPIType(modelProfile, capabilities);
+    return apiType === "responses_api";
+  }
+}
+export {
+  ModelAdapterFactory
+};
+//# sourceMappingURL=modelAdapterFactory.js.map

package/dist/services/modelAdapterFactory.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/services/modelAdapterFactory.ts"],
+  "sourcesContent": ["import { ModelAPIAdapter } from './adapters/base'\nimport { ResponsesAPIAdapter } from './adapters/responsesAPI'\nimport { ChatCompletionsAdapter } from './adapters/chatCompletions'\nimport { getModelCapabilities } from '@constants/modelCapabilities'\nimport { ModelProfile, getGlobalConfig } from '@utils/config'\nimport { ModelCapabilities } from '@minto-types/modelCapabilities'\n\nexport class ModelAdapterFactory {\n  /**\n   * Create appropriate adapter based on model configuration\n   */\n  static createAdapter(modelProfile: ModelProfile): ModelAPIAdapter {\n    const capabilities = getModelCapabilities(modelProfile.modelName)\n    \n    // Determine which API to use\n    const apiType = this.determineAPIType(modelProfile, capabilities)\n    \n    // Create corresponding adapter\n    switch (apiType) {\n      case 'responses_api':\n        return new ResponsesAPIAdapter(capabilities, modelProfile)\n      case 'chat_completions':\n      default:\n        return new ChatCompletionsAdapter(capabilities, modelProfile)\n    }\n  }\n  \n  /**\n   * Determine which API should be used\n   */\n  private static determineAPIType(\n    modelProfile: ModelProfile,\n    capabilities: ModelCapabilities\n  ): 'responses_api' | 'chat_completions' {\n    // If model doesn't support Responses API, use Chat Completions directly\n    if (capabilities.apiArchitecture.primary !== 'responses_api') {\n      return 'chat_completions'\n    }\n    \n    // Check if this is official OpenAI endpoint\n    const isOfficialOpenAI = !modelProfile.baseURL || \n      modelProfile.baseURL.includes('api.openai.com')\n    \n    // Non-official endpoints use Chat Completions (even if model supports Responses API)\n    if (!isOfficialOpenAI) {\n      // If there's a fallback option, use fallback\n      if (capabilities.apiArchitecture.fallback === 'chat_completions') {\n        return 'chat_completions'\n      }\n      // Otherwise use primary (might fail, but let it try)\n      return capabilities.apiArchitecture.primary\n    }\n    \n    // For now, always use Responses API for supported models when on official endpoint\n    // Streaming fallback will be handled at runtime if needed\n    \n    // Use primary API type\n    return capabilities.apiArchitecture.primary\n  }\n  \n  /**\n   * Check if model should use Responses API\n   */\n  static shouldUseResponsesAPI(modelProfile: ModelProfile): boolean {\n    const capabilities = getModelCapabilities(modelProfile.modelName)\n    const apiType = this.determineAPIType(modelProfile, capabilities)\n    return apiType === 'responses_api'\n  }\n}\n"],
+  "mappings": "AACA,SAAS,2BAA2B;AACpC,SAAS,8BAA8B;AACvC,SAAS,4BAA4B;AAI9B,MAAM,oBAAoB;AAAA;AAAA;AAAA;AAAA,EAI/B,OAAO,cAAc,cAA6C;AAChE,UAAM,eAAe,qBAAqB,aAAa,SAAS;AAGhE,UAAM,UAAU,KAAK,iBAAiB,cAAc,YAAY;AAGhE,YAAQ,SAAS;AAAA,MACf,KAAK;AACH,eAAO,IAAI,oBAAoB,cAAc,YAAY;AAAA,MAC3D,KAAK;AAAA,MACL;AACE,eAAO,IAAI,uBAAuB,cAAc,YAAY;AAAA,IAChE;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,OAAe,iBACb,cACA,cACsC;AAEtC,QAAI,aAAa,gBAAgB,YAAY,iBAAiB;AAC5D,aAAO;AAAA,IACT;AAGA,UAAM,mBAAmB,CAAC,aAAa,WACrC,aAAa,QAAQ,SAAS,gBAAgB;AAGhD,QAAI,CAAC,kBAAkB;AAErB,UAAI,aAAa,gBAAgB,aAAa,oBAAoB;AAChE,eAAO;AAAA,MACT;AAEA,aAAO,aAAa,gBAAgB;AAAA,IACtC;AAMA,WAAO,aAAa,gBAAgB;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA,EAKA,OAAO,sBAAsB,cAAqC;AAChE,UAAM,eAAe,qBAAqB,aAAa,SAAS;AAChE,UAAM,UAAU,KAAK,iBAAiB,cAAc,YAAY;AAChE,WAAO,YAAY;AAAA,EACrB;AACF;",
+  "names": []
+}

package/dist/services/notifier.js

@@ -0,0 +1,35 @@
+import { getGlobalConfig } from "../utils/config.js";
+function sendITerm2Notification({ message, title }) {
+  const displayString = title ? `${title}:
+${message}` : message;
+  try {
+    process.stdout.write(`\x1B]9;
+
+${displayString}\x07`);
+  } catch {
+  }
+}
+function sendTerminalBell() {
+  process.stdout.write("\x07");
+}
+async function sendNotification(notif) {
+  const channel = getGlobalConfig().preferredNotifChannel;
+  switch (channel) {
+    case "iterm2":
+      sendITerm2Notification(notif);
+      break;
+    case "terminal_bell":
+      sendTerminalBell();
+      break;
+    case "iterm2_with_bell":
+      sendITerm2Notification(notif);
+      sendTerminalBell();
+      break;
+    case "notifications_disabled":
+      break;
+  }
+}
+export {
+  sendNotification
+};
+//# sourceMappingURL=notifier.js.map

package/dist/services/notifier.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/services/notifier.ts"],
+  "sourcesContent": ["import { getGlobalConfig } from '@utils/config'\n\nexport type NotificationOptions = {\n  message: string\n  title?: string\n}\n\nfunction sendITerm2Notification({ message, title }: NotificationOptions): void {\n  const displayString = title ? `${title}:\\n${message}` : message\n  try {\n    process.stdout.write(`\\x1b]9;\\n\\n${displayString}\\x07`)\n  } catch {\n    // Ignore errors\n  }\n}\n\nfunction sendTerminalBell(): void {\n  process.stdout.write('\\x07')\n}\n\nexport async function sendNotification(\n  notif: NotificationOptions,\n): Promise<void> {\n  const channel = getGlobalConfig().preferredNotifChannel\n  switch (channel) {\n    case 'iterm2':\n      sendITerm2Notification(notif)\n      break\n    case 'terminal_bell':\n      sendTerminalBell()\n      break\n    case 'iterm2_with_bell':\n      sendITerm2Notification(notif)\n      sendTerminalBell()\n      break\n    case 'notifications_disabled':\n      // Do nothing\n      break\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,uBAAuB;AAOhC,SAAS,uBAAuB,EAAE,SAAS,MAAM,GAA8B;AAC7E,QAAM,gBAAgB,QAAQ,GAAG,KAAK;AAAA,EAAM,OAAO,KAAK;AACxD,MAAI;AACF,YAAQ,OAAO,MAAM;AAAA;AAAA,EAAc,aAAa,MAAM;AAAA,EACxD,QAAQ;AAAA,EAER;AACF;AAEA,SAAS,mBAAyB;AAChC,UAAQ,OAAO,MAAM,MAAM;AAC7B;AAEA,eAAsB,iBACpB,OACe;AACf,QAAM,UAAU,gBAAgB,EAAE;AAClC,UAAQ,SAAS;AAAA,IACf,KAAK;AACH,6BAAuB,KAAK;AAC5B;AAAA,IACF,KAAK;AACH,uBAAiB;AACjB;AAAA,IACF,KAAK;AACH,6BAAuB,KAAK;AAC5B,uBAAiB;AACjB;AAAA,IACF,KAAK;AAEH;AAAA,EACJ;AACF;",
+  "names": []
+}

package/dist/services/oauth.js

@@ -0,0 +1,247 @@
+import * as crypto from "crypto";
+import * as http from "http";
+import * as url from "url";
+import { OAUTH_CONFIG } from "../constants/oauth.js";
+import { openBrowser } from "../utils/browser.js";
+import { logError } from "../utils/log.js";
+import { resetAnthropicClient } from "./claude.js";
+import {
+  getGlobalConfig,
+  saveGlobalConfig,
+  normalizeApiKeyForConfig
+} from "../utils/config.js";
+function base64URLEncode(buffer) {
+  return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function generateCodeVerifier() {
+  return base64URLEncode(crypto.randomBytes(32));
+}
+async function generateCodeChallenge(verifier) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(verifier);
+  const digest = await crypto.subtle.digest("SHA-256", data);
+  return base64URLEncode(Buffer.from(digest));
+}
+class OAuthService {
+  server = null;
+  codeVerifier;
+  expectedState = null;
+  pendingCodePromise = null;
+  constructor() {
+    this.codeVerifier = generateCodeVerifier();
+  }
+  generateAuthUrls(codeChallenge, state) {
+    function makeUrl(isManual) {
+      const authUrl = new URL(OAUTH_CONFIG.AUTHORIZE_URL);
+      authUrl.searchParams.append("client_id", OAUTH_CONFIG.CLIENT_ID);
+      authUrl.searchParams.append("response_type", "code");
+      authUrl.searchParams.append(
+        "redirect_uri",
+        isManual ? OAUTH_CONFIG.MANUAL_REDIRECT_URL : `http://localhost:${OAUTH_CONFIG.REDIRECT_PORT}/callback`
+      );
+      authUrl.searchParams.append("scope", OAUTH_CONFIG.SCOPES.join(" "));
+      authUrl.searchParams.append("code_challenge", codeChallenge);
+      authUrl.searchParams.append("code_challenge_method", "S256");
+      authUrl.searchParams.append("state", state);
+      return authUrl.toString();
+    }
+    return {
+      autoUrl: makeUrl(false),
+      manualUrl: makeUrl(true)
+    };
+  }
+  async startOAuthFlow(authURLHandler) {
+    const codeChallenge = await generateCodeChallenge(this.codeVerifier);
+    const state = base64URLEncode(crypto.randomBytes(32));
+    this.expectedState = state;
+    const { autoUrl, manualUrl } = this.generateAuthUrls(codeChallenge, state);
+    const onReady = async () => {
+      await authURLHandler(manualUrl);
+      await openBrowser(autoUrl);
+    };
+    const { authorizationCode, useManualRedirect } = await new Promise((resolve, reject) => {
+      this.pendingCodePromise = { resolve, reject };
+      this.startLocalServer(state, onReady);
+    });
+    const {
+      access_token: accessToken,
+      account,
+      organization
+    } = await this.exchangeCodeForTokens(
+      authorizationCode,
+      state,
+      useManualRedirect
+    );
+    if (account) {
+      const accountInfo = {
+        accountUuid: account.uuid,
+        emailAddress: account.email_address,
+        organizationUuid: organization?.uuid
+      };
+      const config = getGlobalConfig();
+      config.oauthAccount = accountInfo;
+      saveGlobalConfig(config);
+    }
+    return { accessToken };
+  }
+  startLocalServer(state, onReady) {
+    if (this.server) {
+      this.closeServer();
+    }
+    this.server = http.createServer(
+      (req, res) => {
+        const parsedUrl = url.parse(req.url || "", true);
+        if (parsedUrl.pathname === "/callback") {
+          const authorizationCode = parsedUrl.query.code;
+          const returnedState = parsedUrl.query.state;
+          if (!authorizationCode) {
+            res.writeHead(400);
+            res.end("Authorization code not found");
+            if (this.pendingCodePromise) {
+              this.pendingCodePromise.reject(
+                new Error("No authorization code received")
+              );
+            }
+            return;
+          }
+          if (returnedState !== state) {
+            res.writeHead(400);
+            res.end("Invalid state parameter");
+            if (this.pendingCodePromise) {
+              this.pendingCodePromise.reject(
+                new Error("Invalid state parameter")
+                // Possible CSRF attack
+              );
+            }
+            return;
+          }
+          res.writeHead(302, {
+            Location: OAUTH_CONFIG.SUCCESS_URL
+          });
+          res.end();
+          this.processCallback({
+            authorizationCode,
+            state,
+            useManualRedirect: false
+          });
+        } else {
+          res.writeHead(404);
+          res.end();
+        }
+      }
+    );
+    this.server.listen(OAUTH_CONFIG.REDIRECT_PORT, async () => {
+      onReady?.();
+    });
+    this.server.on("error", (err) => {
+      const portError = err;
+      if (portError.code === "EADDRINUSE") {
+        const error = new Error(
+          `Port ${OAUTH_CONFIG.REDIRECT_PORT} is already in use. Please ensure no other applications are using this port.`
+        );
+        logError(error);
+        this.closeServer();
+        if (this.pendingCodePromise) {
+          this.pendingCodePromise.reject(error);
+        }
+        return;
+      } else {
+        logError(err);
+        this.closeServer();
+        if (this.pendingCodePromise) {
+          this.pendingCodePromise.reject(err);
+        }
+        return;
+      }
+    });
+  }
+  async exchangeCodeForTokens(authorizationCode, state, useManualRedirect = false) {
+    const requestBody = {
+      grant_type: "authorization_code",
+      code: authorizationCode,
+      redirect_uri: useManualRedirect ? OAUTH_CONFIG.MANUAL_REDIRECT_URL : `http://localhost:${OAUTH_CONFIG.REDIRECT_PORT}/callback`,
+      client_id: OAUTH_CONFIG.CLIENT_ID,
+      code_verifier: this.codeVerifier,
+      state
+    };
+    const response = await fetch(OAUTH_CONFIG.TOKEN_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(requestBody)
+    });
+    if (!response.ok) {
+      throw new Error(`Token exchange failed: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  processCallback({
+    authorizationCode,
+    state,
+    useManualRedirect
+  }) {
+    this.closeServer();
+    if (state !== this.expectedState) {
+      if (this.pendingCodePromise) {
+        this.pendingCodePromise.reject(
+          new Error("Invalid state parameter")
+          // Possible CSRF attack
+        );
+        this.pendingCodePromise = null;
+      }
+      return;
+    }
+    if (this.pendingCodePromise) {
+      this.pendingCodePromise.resolve({ authorizationCode, useManualRedirect });
+      this.pendingCodePromise = null;
+    }
+  }
+  closeServer() {
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+  }
+}
+async function createAndStoreApiKey(accessToken) {
+  try {
+    const createApiKeyResp = await fetch(OAUTH_CONFIG.API_KEY_URL, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${accessToken}` }
+    });
+    let apiKeyData;
+    let errorText = "";
+    try {
+      apiKeyData = await createApiKeyResp.json();
+    } catch (_e) {
+      errorText = await createApiKeyResp.text();
+    }
+    if (createApiKeyResp.ok && apiKeyData && apiKeyData.raw_key) {
+      const apiKey = apiKeyData.raw_key;
+      const config = getGlobalConfig();
+      if (!config.customApiKeyResponses) {
+        config.customApiKeyResponses = { approved: [], rejected: [] };
+      }
+      if (!config.customApiKeyResponses.approved) {
+        config.customApiKeyResponses.approved = [];
+      }
+      const normalizedKey = normalizeApiKeyForConfig(apiKey);
+      if (!config.customApiKeyResponses.approved.includes(normalizedKey)) {
+        config.customApiKeyResponses.approved.push(normalizedKey);
+      }
+      saveGlobalConfig(config);
+      resetAnthropicClient();
+      return apiKey;
+    }
+    return null;
+  } catch (error) {
+    throw error;
+  }
+}
+export {
+  OAuthService,
+  createAndStoreApiKey
+};
+//# sourceMappingURL=oauth.js.map

package/dist/services/oauth.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/services/oauth.ts"],
+  "sourcesContent": ["import * as crypto from 'crypto'\nimport * as http from 'http'\nimport { IncomingMessage, ServerResponse } from 'http'\nimport * as url from 'url'\n\nimport { OAUTH_CONFIG } from '@constants/oauth'\nimport { openBrowser } from '@utils/browser'\nimport { logError } from '@utils/log'\nimport { resetAnthropicClient } from './claude'\nimport {\n  AccountInfo,\n  getGlobalConfig,\n  saveGlobalConfig,\n  normalizeApiKeyForConfig,\n} from '@utils/config'\n\n// Base64URL encoding function (RFC 4648)\nfunction base64URLEncode(buffer: Buffer): string {\n  return buffer\n    .toString('base64')\n    .replace(/\\+/g, '-')\n    .replace(/\\//g, '_')\n    .replace(/=/g, '')\n}\n\nfunction generateCodeVerifier(): string {\n  return base64URLEncode(crypto.randomBytes(32))\n}\n\nasync function generateCodeChallenge(verifier: string): Promise<string> {\n  const encoder = new TextEncoder()\n  const data = encoder.encode(verifier)\n  const digest = await crypto.subtle.digest('SHA-256', data)\n  return base64URLEncode(Buffer.from(digest))\n}\n\ntype OAuthTokenExchangeResponse = {\n  access_token: string\n  account?: {\n    uuid: string\n    email_address: string\n  }\n  organization?: {\n    uuid: string\n    name: string\n  }\n}\n\nexport type OAuthResult = {\n  accessToken: string\n}\n\nexport class OAuthService {\n  private server: http.Server | null = null\n  private codeVerifier: string\n  private expectedState: string | null = null\n  private pendingCodePromise: {\n    resolve: (result: {\n      authorizationCode: string\n      useManualRedirect: boolean\n    }) => void\n    reject: (err: Error) => void\n  } | null = null\n\n  constructor() {\n    this.codeVerifier = generateCodeVerifier()\n  }\n\n  private generateAuthUrls(\n    codeChallenge: string,\n    state: string,\n  ): { autoUrl: string; manualUrl: string } {\n    function makeUrl(isManual: boolean): string {\n      const authUrl = new URL(OAUTH_CONFIG.AUTHORIZE_URL)\n      authUrl.searchParams.append('client_id', OAUTH_CONFIG.CLIENT_ID)\n      authUrl.searchParams.append('response_type', 'code')\n      authUrl.searchParams.append(\n        'redirect_uri',\n        isManual\n          ? OAUTH_CONFIG.MANUAL_REDIRECT_URL\n          : `http://localhost:${OAUTH_CONFIG.REDIRECT_PORT}/callback`,\n      )\n      authUrl.searchParams.append('scope', OAUTH_CONFIG.SCOPES.join(' '))\n      authUrl.searchParams.append('code_challenge', codeChallenge)\n      authUrl.searchParams.append('code_challenge_method', 'S256')\n      authUrl.searchParams.append('state', state)\n      return authUrl.toString()\n    }\n\n    return {\n      autoUrl: makeUrl(false),\n      manualUrl: makeUrl(true),\n    }\n  }\n\n  async startOAuthFlow(\n    authURLHandler: (url: string) => Promise<void>,\n  ): Promise<OAuthResult> {\n    const codeChallenge = await generateCodeChallenge(this.codeVerifier)\n    const state = base64URLEncode(crypto.randomBytes(32))\n    this.expectedState = state\n    const { autoUrl, manualUrl } = this.generateAuthUrls(codeChallenge, state)\n\n    const onReady = async () => {\n      await authURLHandler(manualUrl)\n      await openBrowser(autoUrl)\n    }\n\n    const { authorizationCode, useManualRedirect } = await new Promise<{\n      authorizationCode: string\n      useManualRedirect: boolean\n    }>((resolve, reject) => {\n      this.pendingCodePromise = { resolve, reject }\n      this.startLocalServer(state, onReady)\n    })\n\n    // Exchange code for tokens\n    const {\n      access_token: accessToken,\n      account,\n      organization,\n    } = await this.exchangeCodeForTokens(\n      authorizationCode,\n      state,\n      useManualRedirect,\n    )\n\n    // Store account info\n    if (account) {\n      const accountInfo: AccountInfo = {\n        accountUuid: account.uuid,\n        emailAddress: account.email_address,\n        organizationUuid: organization?.uuid,\n      }\n      const config = getGlobalConfig()\n      config.oauthAccount = accountInfo\n      saveGlobalConfig(config)\n    }\n\n    return { accessToken }\n  }\n\n  private startLocalServer(state: string, onReady?: () => void): void {\n    if (this.server) {\n      this.closeServer()\n    }\n    this.server = http.createServer(\n      (req: IncomingMessage, res: ServerResponse) => {\n        const parsedUrl = url.parse(req.url || '', true)\n\n        if (parsedUrl.pathname === '/callback') {\n          const authorizationCode = parsedUrl.query.code as string\n          const returnedState = parsedUrl.query.state as string\n\n          if (!authorizationCode) {\n            res.writeHead(400)\n            res.end('Authorization code not found')\n            if (this.pendingCodePromise) {\n              this.pendingCodePromise.reject(\n                new Error('No authorization code received'),\n              )\n            }\n            return\n          }\n\n          if (returnedState !== state) {\n            res.writeHead(400)\n            res.end('Invalid state parameter')\n            if (this.pendingCodePromise) {\n              this.pendingCodePromise.reject(\n                new Error('Invalid state parameter'), // Possible CSRF attack\n              )\n            }\n            return\n          }\n\n          res.writeHead(302, {\n            Location: OAUTH_CONFIG.SUCCESS_URL,\n          })\n          res.end()\n\n          \n\n          this.processCallback({\n            authorizationCode,\n            state,\n            useManualRedirect: false,\n          })\n        } else {\n          res.writeHead(404)\n          res.end()\n        }\n      },\n    )\n\n    this.server.listen(OAUTH_CONFIG.REDIRECT_PORT, async () => {\n      onReady?.()\n    })\n\n    this.server.on('error', (err: Error) => {\n      const portError = err as NodeJS.ErrnoException\n      if (portError.code === 'EADDRINUSE') {\n        const error = new Error(\n          `Port ${OAUTH_CONFIG.REDIRECT_PORT} is already in use. Please ensure no other applications are using this port.`,\n        )\n        logError(error)\n        this.closeServer()\n        if (this.pendingCodePromise) {\n          this.pendingCodePromise.reject(error)\n        }\n        return\n      } else {\n        logError(err)\n        this.closeServer()\n        if (this.pendingCodePromise) {\n          this.pendingCodePromise.reject(err)\n        }\n        return\n      }\n    })\n  }\n\n  private async exchangeCodeForTokens(\n    authorizationCode: string,\n    state: string,\n    useManualRedirect: boolean = false,\n  ): Promise<OAuthTokenExchangeResponse> {\n    const requestBody = {\n      grant_type: 'authorization_code',\n      code: authorizationCode,\n      redirect_uri: useManualRedirect\n        ? OAUTH_CONFIG.MANUAL_REDIRECT_URL\n        : `http://localhost:${OAUTH_CONFIG.REDIRECT_PORT}/callback`,\n      client_id: OAUTH_CONFIG.CLIENT_ID,\n      code_verifier: this.codeVerifier,\n      state,\n    }\n\n    const response = await fetch(OAUTH_CONFIG.TOKEN_URL, {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/json',\n      },\n      body: JSON.stringify(requestBody),\n    })\n\n    if (!response.ok) {\n      throw new Error(`Token exchange failed: ${response.statusText}`)\n    }\n\n    const data = await response.json()\n    return data\n  }\n\n  processCallback({\n    authorizationCode,\n    state,\n    useManualRedirect,\n  }: {\n    authorizationCode: string\n    state: string\n    useManualRedirect: boolean\n  }): void {\n    this.closeServer()\n\n    if (state !== this.expectedState) {\n      if (this.pendingCodePromise) {\n        this.pendingCodePromise.reject(\n          new Error('Invalid state parameter'), // Possible CSRF attack\n        )\n        this.pendingCodePromise = null\n      }\n      return\n    }\n\n    if (this.pendingCodePromise) {\n      this.pendingCodePromise.resolve({ authorizationCode, useManualRedirect })\n      this.pendingCodePromise = null\n    }\n  }\n\n  private closeServer(): void {\n    if (this.server) {\n      this.server.close()\n      this.server = null\n    }\n  }\n}\n\nexport async function createAndStoreApiKey(\n  accessToken: string,\n): Promise<string | null> {\n  try {\n    // Call create_api_key endpoint\n    const createApiKeyResp = await fetch(OAUTH_CONFIG.API_KEY_URL, {\n      method: 'POST',\n      headers: { Authorization: `Bearer ${accessToken}` },\n    })\n\n    let apiKeyData\n    let errorText = ''\n\n    try {\n      apiKeyData = await createApiKeyResp.json()\n    } catch (_e) {\n      // If response is not valid JSON, get as text for error logging\n      errorText = await createApiKeyResp.text()\n    }\n\n    \n\n    if (createApiKeyResp.ok && apiKeyData && apiKeyData.raw_key) {\n      const apiKey = apiKeyData.raw_key\n\n      // Store in global config\n      const config = getGlobalConfig()\n\n      // Note: API key is now managed per model profile\n\n      // Add to approved list\n      if (!config.customApiKeyResponses) {\n        config.customApiKeyResponses = { approved: [], rejected: [] }\n      }\n      if (!config.customApiKeyResponses.approved) {\n        config.customApiKeyResponses.approved = []\n      }\n\n      const normalizedKey = normalizeApiKeyForConfig(apiKey)\n      if (!config.customApiKeyResponses.approved.includes(normalizedKey)) {\n        config.customApiKeyResponses.approved.push(normalizedKey)\n      }\n\n      // Save config\n      saveGlobalConfig(config)\n\n      // Reset the Anthropic client to force creation with new API key\n      resetAnthropicClient()\n\n      return apiKey\n    }\n\n    return null\n  } catch (error) {\n    \n    throw error\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}