devmentorai-server 1.2.2 → 1.2.3

package/dist/server.js

@@ -18,7 +18,7 @@ import {
   toImageRelativePath,
   toRelativePath,
   toUrlPath
-} from "./chunk-APCRFDFH.js";
+} from "./chunk-CAHB75ZH.js";
 
 // src/server.ts
 import Fastify from "fastify";
@@ -175,12 +175,13 @@ var createSessionSchema = z.object({
 });
 var updateSessionSchema = z.object({
   name: z.string().min(1).max(100).optional(),
-  status: z.enum(["active", "paused", "closed"]).optional()
+  status: z.enum(["active", "paused", "closed"]).optional(),
+  model: z.string().min(1).optional()
 });
 async function sessionRoutes(fastify) {
   fastify.get("/sessions", async (request, reply) => {
-    const page = parseInt(request.query.page || "1", 10);
-    const pageSize = parseInt(request.query.pageSize || "50", 10);
+    const page = Number.parseInt(request.query.page || "1", 10);
+    const pageSize = Number.parseInt(request.query.pageSize || "50", 10);
     const sessions = fastify.sessionService.listSessions(page, pageSize);
     return reply.send({
       success: true,
@@ -235,6 +236,24 @@ async function sessionRoutes(fastify) {
   fastify.patch("/sessions/:id", async (request, reply) => {
     try {
       const body = updateSessionSchema.parse(request.body);
+      const currentSession = fastify.sessionService.getSession(request.params.id);
+      if (!currentSession) {
+        return reply.code(404).send({
+          success: false,
+          error: {
+            code: "NOT_FOUND",
+            message: "Session not found"
+          }
+        });
+      }
+      if (body.model && body.model !== currentSession.model) {
+        await fastify.copilotService.switchSessionModel(
+          currentSession.id,
+          currentSession.type,
+          body.model,
+          currentSession.systemPrompt
+        );
+      }
       const session = fastify.sessionService.updateSession(request.params.id, body);
       if (!session) {
         return reply.code(404).send({
@@ -337,8 +356,8 @@ async function sessionRoutes(fastify) {
         }
       });
     }
-    const page = parseInt(request.query.page || "1", 10);
-    const pageSize = parseInt(request.query.pageSize || "100", 10);
+    const page = Number.parseInt(request.query.page || "1", 10);
+    const pageSize = Number.parseInt(request.query.pageSize || "100", 10);
     const messages = fastify.sessionService.listMessages(request.params.id, page, pageSize);
     return reply.send({
       success: true,
@@ -1035,8 +1054,13 @@ async function chatRoutes(fastify) {
         reply.raw.end();
       };
       const streamComplete = new Promise((resolve2) => {
+        const cleanupTimers = () => {
+          clearTimeout(globalTimeout);
+          clearInterval(idleCheckInterval);
+        };
         const globalTimeout = setTimeout(() => {
           console.warn("[ChatRoute] Global stream timeout reached");
+          cleanupTimers();
           endStream("timeout");
           fastify.copilotService.abortRequest(sessionId).catch(() => {
           });
@@ -1046,6 +1070,7 @@ async function chatRoutes(fastify) {
           const idleTime = Date.now() - lastActivityTime;
           if (idleTime > IDLE_TIMEOUT_MS && !streamEnded) {
             console.warn(`[ChatRoute] Stream idle for ${idleTime}ms, ending`);
+            cleanupTimers();
             endStream("idle_timeout");
             fastify.copilotService.abortRequest(sessionId).catch(() => {
             });
@@ -1087,26 +1112,41 @@ async function chatRoutes(fastify) {
               });
               break;
             case "session.idle":
-              clearTimeout(globalTimeout);
-              clearInterval(idleCheckInterval);
+              cleanupTimers();
               endStream("completed");
               resolve2();
               break;
           }
         };
-        fastify.copilotService.streamMessage(
+        const streamStart = fastify.copilotService.streamMessage(
           sessionId,
           userPrompt,
           body.context,
           handleEvent,
           copilotAttachments.length > 0 ? copilotAttachments : void 0
         );
+        streamStart.catch((streamError) => {
+          console.error("[ChatRoute] Failed to start Copilot stream:", streamError);
+          cleanupTimers();
+          if (!streamEnded) {
+            sendSSE({
+              type: "error",
+              data: {
+                error: streamError instanceof Error ? streamError.message : "Failed to start stream"
+              }
+            });
+            endStream("copilot_error");
+          }
+          resolve2();
+        });
       });
-      request.raw.on("close", async () => {
+      request.raw.on("close", () => {
         if (!streamEnded) {
           console.log("[ChatRoute] Client disconnected, aborting");
           streamEnded = true;
-          await fastify.copilotService.abortRequest(sessionId);
+          fastify.copilotService.abortRequest(sessionId).catch((abortError) => {
+            console.error("[ChatRoute] Failed to abort request after disconnect:", abortError);
+          });
           reply.raw.end();
         }
       });
@@ -1213,143 +1253,56 @@ async function chatRoutes(fastify) {
 }
 
 // src/routes/models.ts
-var AVAILABLE_MODELS = [
-  // Free tier (0x)
-  {
-    id: "gpt-4.1",
-    name: "GPT-4.1",
-    description: "Fast and capable model for most tasks",
-    provider: "openai",
-    isDefault: true,
-    pricingTier: "free",
-    pricingMultiplier: 0
-  },
-  {
-    id: "gpt-4o",
-    name: "GPT-4o",
-    description: "Multimodal model with vision capabilities",
-    provider: "openai",
-    isDefault: false,
-    pricingTier: "free",
-    pricingMultiplier: 0
-  },
-  {
-    id: "gpt-5-mini",
-    name: "GPT-5 Mini",
-    description: "Fast, lightweight model for simple tasks",
-    provider: "openai",
-    isDefault: false,
-    pricingTier: "free",
-    pricingMultiplier: 0
-  },
-  // Cheap tier (0.33x)
-  {
-    id: "claude-haiku-4.5",
-    name: "Claude Haiku 4.5",
-    description: "Fast, efficient model for quick tasks",
-    provider: "anthropic",
-    isDefault: false,
-    pricingTier: "cheap",
-    pricingMultiplier: 0.33
-  },
-  {
-    id: "gpt-5.1-codex-mini",
-    name: "GPT-5.1 Codex Mini",
-    description: "Compact coding model",
-    provider: "openai",
-    isDefault: false,
-    pricingTier: "cheap",
-    pricingMultiplier: 0.33
-  },
-  // Standard tier (1x)
-  {
-    id: "gpt-5",
-    name: "GPT-5",
-    description: "Most capable model for complex reasoning",
-    provider: "openai",
-    isDefault: false,
-    pricingTier: "standard",
-    pricingMultiplier: 1
-  },
-  {
-    id: "gpt-5.1",
-    name: "GPT-5.1",
-    description: "Enhanced reasoning and analysis",
-    provider: "openai",
-    isDefault: false,
-    pricingTier: "standard",
-    pricingMultiplier: 1
-  },
-  {
-    id: "gpt-5.1-codex",
-    name: "GPT-5.1 Codex",
-    description: "Specialized for code generation",
-    provider: "openai",
-    isDefault: false,
-    pricingTier: "standard",
-    pricingMultiplier: 1
-  },
-  {
-    id: "gpt-5.2",
-    name: "GPT-5.2",
-    description: "Latest generation model",
-    provider: "openai",
-    isDefault: false,
-    pricingTier: "standard",
-    pricingMultiplier: 1
-  },
-  {
-    id: "claude-sonnet-4",
-    name: "Claude Sonnet 4",
-    description: "Balanced model for general use",
-    provider: "anthropic",
-    isDefault: false,
-    pricingTier: "standard",
-    pricingMultiplier: 1
-  },
-  {
-    id: "claude-sonnet-4.5",
-    name: "Claude Sonnet 4.5",
-    description: "Enhanced balanced model",
-    provider: "anthropic",
-    isDefault: false,
-    pricingTier: "standard",
-    pricingMultiplier: 1
-  },
-  {
-    id: "gemini-3-pro-preview",
-    name: "Gemini 3 Pro (Preview)",
-    description: "Google's latest model",
-    provider: "google",
-    isDefault: false,
-    pricingTier: "standard",
-    pricingMultiplier: 1
-  },
-  // Premium tier (3x)
-  {
-    id: "claude-opus-4.5",
-    name: "Claude Opus 4.5",
-    description: "Premium model for complex analysis",
-    provider: "anthropic",
-    isDefault: false,
-    pricingTier: "premium",
-    pricingMultiplier: 3
+var TIER_ORDER = ["free", "cheap", "standard", "premium"];
+var FALLBACK_MODEL = {
+  id: "gpt-4.1",
+  name: "GPT-4.1",
+  description: "Recommended baseline model for DevMentorAI sessions",
+  provider: "openai",
+  available: true,
+  isDefault: true,
+  pricingTier: "free",
+  pricingMultiplier: 0
+};
+function sortModelsByTierAndName(models) {
+  return [...models].sort((a, b) => {
+    const aTier = a.pricingTier || "standard";
+    const bTier = b.pricingTier || "standard";
+    const tierDiff = TIER_ORDER.indexOf(aTier) - TIER_ORDER.indexOf(bTier);
+    if (tierDiff !== 0) return tierDiff;
+    return a.name.localeCompare(b.name);
+  });
+}
+async function getModelsPayload(fastify) {
+  const response = await fastify.copilotService.listModels();
+  if (!response.models || response.models.length === 0) {
+    return {
+      models: [FALLBACK_MODEL],
+      default: FALLBACK_MODEL.id
+    };
   }
-];
+  const sortedModels = sortModelsByTierAndName(response.models);
+  const defaultModel = sortedModels.find((model) => model.id === response.default)?.id || sortedModels.find((model) => model.isDefault)?.id || FALLBACK_MODEL.id;
+  return {
+    models: sortedModels.map((model) => ({
+      ...model,
+      isDefault: model.id === defaultModel
+    })),
+    default: defaultModel
+  };
+}
 async function modelsRoutes(fastify) {
   fastify.get("/models", async (_request, reply) => {
-    const defaultModel = AVAILABLE_MODELS.find((m) => m.isDefault);
+    const payload = await getModelsPayload(fastify);
     return reply.send({
       success: true,
-      data: {
-        models: AVAILABLE_MODELS,
-        default: defaultModel?.id || "gpt-4.1"
-      }
+      data: payload
     });
   });
   fastify.get("/models/:id", async (request, reply) => {
     const modelId = request.params.id;
-    const model = AVAILABLE_MODELS.find((m) => m.id === modelId);
+    const payload = await getModelsPayload(fastify);
+    const model = payload.models.find((m) => m.id === modelId);
     if (!model) {
       return reply.code(404).send({
         success: false,
@@ -1366,6 +1319,24 @@ async function modelsRoutes(fastify) {
   });
 }
 
+// src/routes/account.ts
+async function accountRoutes(fastify) {
+  fastify.get("/account/auth", async (_request, reply) => {
+    const auth = await fastify.copilotService.getAuthStatus();
+    return reply.send({
+      success: true,
+      data: auth
+    });
+  });
+  fastify.get("/account/quota", async (_request, reply) => {
+    const quota = await fastify.copilotService.getQuota();
+    return reply.send({
+      success: true,
+      data: quota
+    });
+  });
+}
+
 // src/routes/images.ts
 import fs2 from "fs";
 import path2 from "path";
@@ -1918,6 +1889,7 @@ var MCP_SERVERS = {
     tools: ["*"]
   }
 };
+var RECOMMENDED_DEFAULT_MODEL = "gpt-4.1";
 var CopilotService = class {
   constructor(sessionService) {
     this.sessionService = sessionService;
@@ -1945,6 +1917,190 @@ var CopilotService = class {
   isMockMode() {
     return this.mockMode;
   }
+  async getAuthStatus() {
+    if (this.mockMode || !this.client) {
+      return {
+        isAuthenticated: false,
+        login: null,
+        reason: "Copilot SDK unavailable (mock mode)"
+      };
+    }
+    try {
+      const client = this.client;
+      if (!client.getAuthStatus) {
+        return {
+          isAuthenticated: false,
+          login: null,
+          reason: "Copilot auth API not available in this SDK version"
+        };
+      }
+      const auth = await client.getAuthStatus();
+      return {
+        isAuthenticated: Boolean(auth?.isAuthenticated),
+        login: typeof auth?.login === "string" ? auth.login : null
+      };
+    } catch (error) {
+      return {
+        isAuthenticated: false,
+        login: null,
+        reason: error instanceof Error ? error.message : "Failed to get auth status"
+      };
+    }
+  }
+  async listModels() {
+    if (this.mockMode || !this.client) {
+      return { models: [], default: RECOMMENDED_DEFAULT_MODEL };
+    }
+    try {
+      const client = this.client;
+      if (!client.listModels) {
+        return { models: [], default: RECOMMENDED_DEFAULT_MODEL };
+      }
+      const rawModels = await client.listModels();
+      if (!Array.isArray(rawModels)) {
+        return { models: [], default: RECOMMENDED_DEFAULT_MODEL };
+      }
+      const models = rawModels.map((raw) => this.normalizeModel(raw)).filter((model) => Boolean(model?.id));
+      const recommendedAvailable = models.some((model) => model.id === RECOMMENDED_DEFAULT_MODEL);
+      const sdkDefault = models.find((model) => model.isDefault)?.id;
+      const fallbackFirst = models[0]?.id;
+      const defaultModel = recommendedAvailable && RECOMMENDED_DEFAULT_MODEL || sdkDefault || fallbackFirst || RECOMMENDED_DEFAULT_MODEL;
+      const modelsWithDefaultFlag = models.map((model) => ({
+        ...model,
+        isDefault: model.id === defaultModel
+      }));
+      return { models: modelsWithDefaultFlag, default: defaultModel };
+    } catch (error) {
+      console.error("[CopilotService] Failed to list models:", error);
+      return { models: [], default: RECOMMENDED_DEFAULT_MODEL };
+    }
+  }
+  async getQuota() {
+    if (this.mockMode || !this.client) {
+      return {
+        used: null,
+        included: null,
+        remaining: null,
+        percentageUsed: null,
+        percentageRemaining: null,
+        raw: {}
+      };
+    }
+    try {
+      const client = this.client;
+      const quotaData = await client.rpc?.account?.getQuota?.();
+      if (!quotaData || typeof quotaData !== "object") {
+        return {
+          used: null,
+          included: null,
+          remaining: null,
+          percentageUsed: null,
+          percentageRemaining: null,
+          raw: {}
+        };
+      }
+      return this.normalizeQuota(quotaData);
+    } catch (error) {
+      return {
+        used: null,
+        included: null,
+        remaining: null,
+        percentageUsed: null,
+        percentageRemaining: null,
+        raw: {
+          error: error instanceof Error ? error.message : "Failed to get quota"
+        }
+      };
+    }
+  }
+  async switchSessionModel(sessionId, type, model, systemPrompt) {
+    const existing = this.sessions.get(sessionId);
+    if (existing?.session && !this.mockMode) {
+      try {
+        await existing.session.abort().catch(() => void 0);
+        await existing.session.destroy();
+      } catch (error) {
+        console.warn(`[CopilotService] Failed to destroy previous session before model switch: ${sessionId}`, error);
+      }
+    }
+    this.sessions.delete(sessionId);
+    if (this.client && !this.mockMode) {
+      try {
+        await this.client.deleteSession(sessionId);
+      } catch {
+      }
+    }
+    await this.createCopilotSession(sessionId, type, model, systemPrompt);
+  }
+  normalizeModel(raw) {
+    const id = typeof raw.id === "string" ? raw.id : "";
+    const name = typeof raw.name === "string" ? raw.name : id;
+    const description = typeof raw.description === "string" && raw.description.trim().length > 0 ? raw.description : `AI model ${id}`;
+    const provider = typeof raw.provider === "string" && raw.provider.trim().length > 0 ? raw.provider : this.inferProviderFromModelId(id);
+    const multiplier = typeof raw.billing?.multiplier === "number" && Number.isFinite(raw.billing.multiplier) ? raw.billing.multiplier : void 0;
+    const supportedReasoningEfforts = Array.isArray(raw.supportedReasoningEfforts) ? raw.supportedReasoningEfforts.filter((effort) => typeof effort === "string") : void 0;
+    return {
+      id,
+      name,
+      description,
+      provider,
+      available: true,
+      isDefault: Boolean(raw.isDefault),
+      pricingMultiplier: multiplier,
+      pricingTier: this.mapPricingTier(multiplier),
+      supportedReasoningEfforts
+    };
+  }
+  inferProviderFromModelId(modelId) {
+    const normalized = modelId.toLowerCase();
+    if (normalized.startsWith("gpt")) return "openai";
+    if (normalized.startsWith("claude")) return "anthropic";
+    if (normalized.startsWith("gemini")) return "google";
+    return "unknown";
+  }
+  mapPricingTier(multiplier) {
+    if (multiplier === 0) return "free";
+    if (typeof multiplier === "number" && multiplier > 0 && multiplier < 1) return "cheap";
+    if (typeof multiplier === "number" && multiplier > 1) return "premium";
+    return "standard";
+  }
+  normalizeQuota(raw) {
+    const used = this.readNumber(raw, ["used", "consumed", "usage", "quotaUsed", "totalUsed"]);
+    const included = this.readNumber(raw, ["included", "limit", "quota", "total", "quotaTotal", "allowed"]);
+    const computedRemaining = typeof included === "number" && typeof used === "number" ? Math.max(included - used, 0) : null;
+    const remaining = this.readNumber(raw, ["remaining", "left", "available"]) ?? computedRemaining;
+    const computedPercentageUsed = typeof included === "number" && included > 0 && typeof used === "number" ? Math.min(100, used / included * 100) : null;
+    const percentageUsed = this.readNumber(raw, ["percentageUsed", "usedPercent", "percentUsed"]) ?? computedPercentageUsed;
+    const percentageRemaining = this.readNumber(raw, ["percentageRemaining", "remainingPercent", "percentRemaining"]) ?? (typeof percentageUsed === "number" ? Math.max(0, 100 - percentageUsed) : null);
+    return {
+      used,
+      included,
+      remaining,
+      percentageUsed,
+      percentageRemaining,
+      periodStart: this.readString(raw, ["periodStart", "startAt", "windowStart"]),
+      periodEnd: this.readString(raw, ["periodEnd", "endAt", "windowEnd"]),
+      raw
+    };
+  }
+  readNumber(source, keys) {
+    for (const key of keys) {
+      const value = source[key];
+      if (typeof value === "number" && Number.isFinite(value)) return value;
+      if (typeof value === "string") {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) return parsed;
+      }
+    }
+    return null;
+  }
+  readString(source, keys) {
+    for (const key of keys) {
+      const value = source[key];
+      if (typeof value === "string" && value.trim().length > 0) return value;
+    }
+    return null;
+  }
   async createCopilotSession(sessionId, type, model, systemPrompt, enableMcp = false) {
     if (this.mockMode || !this.client) {
       this.sessions.set(sessionId, {
@@ -2002,6 +2158,7 @@ var CopilotService = class {
       return true;
     } catch (resumeError) {
       console.log(`[CopilotService] Could not resume session ${sessionId}, will try to create new`);
+      console.log("[CopilotService] Resume error:", resumeError);
     }
     try {
       const dbSession = this.sessionService.getSession(sessionId);
@@ -2052,7 +2209,7 @@ ${fullPrompt}`;
       });
       const response = await copilotSession.session.sendAndWait({ prompt: fullPrompt });
       console.log(`[CopilotService] Received response for session ${sessionId}`);
-      console.log(`[CopilotService] Response: ${response?.data}...`);
+      console.log("[CopilotService] Response payload:", response?.data);
       console.log(`[CopilotService] responseContent: ${responseContent}...`);
       return response?.data.content || responseContent;
     }, 3, 1e3);
@@ -2088,7 +2245,7 @@ User request: ${prompt}`;
     if (onEvent) {
       copilotSession.session.on(onEvent);
     }
-    copilotSession.session.send({
+    await copilotSession.session.send({
       prompt: fullPrompt,
       attachments
     });
@@ -2105,7 +2262,8 @@ User request: ${prompt}`;
       } catch (error) {
         lastError = error instanceof Error ? error : new Error(String(error));
         const nonRetryableErrors = ["authentication", "invalid_session", "rate_limit"];
-        if (nonRetryableErrors.some((e) => lastError.message.toLowerCase().includes(e))) {
+        const errorMessage = (lastError?.message || "").toLowerCase();
+        if (nonRetryableErrors.some((e) => errorMessage.includes(e))) {
           throw lastError;
         }
         if (attempt < maxRetries) {
@@ -2167,6 +2325,7 @@ User request: ${prompt}`;
         await this.client.deleteSession(sessionId);
         console.log(`[CopilotService] Session ${sessionId} files deleted from disk`);
       } catch (error) {
+        console.log("[CopilotService] deleteSession error:", error);
         console.log(`[CopilotService] Could not delete session files (may not exist): ${sessionId}`);
       }
     }
@@ -2317,6 +2476,10 @@ var SessionService = class {
       updates.push("status = ?");
       values.push(request.status);
     }
+    if (request.model !== void 0) {
+      updates.push("model = ?");
+      values.push(request.model);
+    }
     if (updates.length === 0) return session;
     updates.push("updated_at = ?");
     values.push(formatDate());
@@ -2400,7 +2563,7 @@ var SessionService = class {
    * Save context for a session (associated with a message)
    */
   saveContext(sessionId, contextJson, messageId, pageUrl, pageTitle, platform) {
-    const id = `ctx_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const id = `ctx_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
     const now = formatDate();
     const stmt = this.db.prepare(`
       INSERT INTO session_contexts (id, session_id, message_id, context_json, page_url, page_title, platform, extracted_at)
@@ -2608,7 +2771,7 @@ function initDatabase() {
 }
 
 // src/server.ts
-var PORT = parseInt(process.env.DEVMENTORAI_PORT || "", 10) || DEFAULT_CONFIG.DEFAULT_PORT;
+var PORT = Number.parseInt(process.env.DEVMENTORAI_PORT || "", 10) || DEFAULT_CONFIG.DEFAULT_PORT;
 var HOST = "0.0.0.0";
 var DEBUG_MODE = true;
 function truncate(str, maxLen = 500) {
@@ -2697,6 +2860,7 @@ async function createServer() {
   await fastify.register(sessionRoutes, { prefix: "/api" });
   await fastify.register(chatRoutes, { prefix: "/api" });
   await fastify.register(modelsRoutes, { prefix: "/api" });
+  await fastify.register(accountRoutes, { prefix: "/api" });
   await fastify.register(updatesRoutes, { prefix: "/api" });
   await fastify.register(imagesRoutes, { prefix: "/api/images" });
   registerToolsRoutes(fastify, copilotService);
@@ -2704,19 +2868,37 @@ async function createServer() {
 }
 async function main() {
   const fastify = await createServer();
-  const shutdown = async () => {
-    fastify.log.info("Shutting down...");
+  let shuttingDown = false;
+  const shutdown = async (reason, error) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    fastify.log.warn({ reason }, "Shutting down...");
+    if (error) {
+      fastify.log.error({ err: error }, "Fatal process error");
+    }
+    let exitCode = 0;
     try {
       await fastify.copilotService.shutdown();
       await fastify.close();
-      process.exit(0);
     } catch (err) {
+      exitCode = 1;
       fastify.log.error({ err }, "Error during shutdown");
-      process.exit(1);
+    } finally {
+      process.exit(exitCode);
     }
   };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", () => {
+    void shutdown("SIGINT");
+  });
+  process.on("SIGTERM", () => {
+    void shutdown("SIGTERM");
+  });
+  process.on("unhandledRejection", (reason) => {
+    fastify.log.error({ err: reason }, "Unhandled promise rejection");
+  });
+  process.on("uncaughtException", (error) => {
+    void shutdown("UNCAUGHT_EXCEPTION", error);
+  });
   try {
     await fastify.listen({ port: PORT, host: HOST });
     fastify.log.info(`\u{1F680} DevMentorAI backend running at http://${HOST}:${PORT}`);
@@ -2725,7 +2907,12 @@ async function main() {
     process.exit(1);
   }
 }
-main();
+try {
+  await main();
+} catch (error) {
+  console.error("[DevMentorAI] Fatal startup error:", error);
+  process.exit(1);
+}
 export {
   createServer
 };