devmentorai-server 1.2.2 → 1.3.0

package/dist/server.js

@@ -18,7 +18,7 @@ import {
   toImageRelativePath,
   toRelativePath,
   toUrlPath
-} from "./chunk-APCRFDFH.js";
+} from "./chunk-X4NL4LWR.js";
 
 // src/server.ts
 import Fastify from "fastify";
@@ -66,6 +66,11 @@ var THUMBNAIL_CONFIG = {
   quality: 60,
   format: "jpeg"
 };
+var FULL_IMAGE_CONFIG = {
+  maxDimension: 2e3,
+  quality: 80,
+  format: "jpeg"
+};
 function parseDataUrl(dataUrl) {
   const match = dataUrl.match(/^data:(image\/[^;]+);base64,(.+)$/);
   if (!match) return null;
@@ -86,14 +91,11 @@ async function generateThumbnail(buffer) {
     withoutEnlargement: true
   }).jpeg({ quality: THUMBNAIL_CONFIG.quality }).toBuffer();
 }
-function getExtensionForMimeType(mimeType) {
-  const extensions = {
-    "image/jpeg": "jpg",
-    "image/png": "png",
-    "image/webp": "webp",
-    "image/gif": "gif"
-  };
-  return extensions[mimeType] || "jpg";
+async function generateFullImage(buffer) {
+  return sharp(buffer).resize(FULL_IMAGE_CONFIG.maxDimension, FULL_IMAGE_CONFIG.maxDimension, {
+    fit: "inside",
+    withoutEnlargement: true
+  }).jpeg({ quality: FULL_IMAGE_CONFIG.quality }).toBuffer();
 }
 function getFullImagePath(sessionId, messageId, index, extension) {
   const messageDir = getMessageImagesDir(sessionId, messageId);
@@ -117,10 +119,11 @@ async function processMessageImages(sessionId, messageId, images, backendUrl) {
       const thumbnailBuffer = await generateThumbnail(buffer);
       const thumbnailAbsPath = getThumbnailPath(sessionId, messageId, index);
       fs.writeFileSync(thumbnailAbsPath, thumbnailBuffer);
-      const extension = getExtensionForMimeType(mimeType);
+      const fullImageBuffer = await generateFullImage(buffer);
+      const extension = "jpg";
       const fullImageAbsPath = getFullImagePath(sessionId, messageId, index, extension);
-      fs.writeFileSync(fullImageAbsPath, buffer);
-      console.log(`[ThumbnailService] Saved full image to ${fullImageAbsPath}`);
+      fs.writeFileSync(fullImageAbsPath, fullImageBuffer);
+      console.log(`[ThumbnailService] Saved compressed full image to ${fullImageAbsPath}`);
       const thumbnailRelativePath = toRelativePath(thumbnailAbsPath);
       const thumbnailUrlPath = toUrlPath(toImageRelativePath(thumbnailAbsPath));
       const fullImageUrlPath = toUrlPath(toImageRelativePath(fullImageAbsPath));
@@ -175,12 +178,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 +239,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 +359,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,
@@ -833,12 +855,23 @@ var imagePayloadSchema = z2.object({
   mimeType: z2.enum(["image/png", "image/jpeg", "image/webp"]),
   source: z2.enum(["screenshot", "paste", "drop"])
 });
+var preUploadedImageSchema = z2.object({
+  id: z2.string(),
+  fullImagePath: z2.string(),
+  mimeType: z2.string(),
+  thumbnailUrl: z2.string().optional(),
+  fullImageUrl: z2.string().optional(),
+  dimensions: z2.object({ width: z2.number(), height: z2.number() }).optional(),
+  fileSize: z2.number().optional()
+});
 var sendMessageSchema = z2.object({
   prompt: z2.string().min(1),
   context: simpleContextSchema.optional(),
   fullContext: fullContextSchema.optional(),
   useContextAwareMode: z2.boolean().optional(),
-  images: z2.array(imagePayloadSchema).max(5).optional()
+  images: z2.array(imagePayloadSchema).max(5).optional(),
+  /** Pre-uploaded image references (already processed on disk) */
+  preUploadedImages: z2.array(preUploadedImageSchema).max(5).optional()
 });
 async function chatRoutes(fastify) {
   const buildPrompt = (body) => {
@@ -945,6 +978,7 @@ async function chatRoutes(fastify) {
       console.log(`[ChatRoute] Using ${promptType} prompt for streaming`);
       let processedImagesRaw = [];
       let processedImages = [];
+      let copilotAttachments = [];
       const host = request.headers.host || `${request.hostname}:3847`;
       const backendUrl = `http://${host}`;
       const userMessage = fastify.sessionService.addMessage(
@@ -958,9 +992,30 @@ async function chatRoutes(fastify) {
           contextAware: body.useContextAwareMode
         } : { contextAware: body.useContextAwareMode }
       );
-      if (body.images && body.images.length > 0) {
+      if (body.preUploadedImages && body.preUploadedImages.length > 0) {
+        console.log(`[ChatRoute] Using ${body.preUploadedImages.length} pre-uploaded images`);
+        copilotAttachments = body.preUploadedImages.map((img, index) => ({
+          type: "file",
+          path: img.fullImagePath,
+          displayName: `image_${index + 1}.${(img.mimeType || "image/jpeg").split("/")[1] || "jpg"}`
+        }));
+        processedImages = body.preUploadedImages.map((img) => ({
+          id: img.id,
+          source: "screenshot",
+          mimeType: img.mimeType || "image/jpeg",
+          dimensions: img.dimensions || { width: 0, height: 0 },
+          fileSize: img.fileSize || 0,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          thumbnailUrl: img.thumbnailUrl,
+          fullImageUrl: img.fullImageUrl
+        }));
+        fastify.sessionService.updateMessageMetadata(userMessage.id, {
+          ...userMessage.metadata,
+          images: processedImages
+        });
+      } else if (body.images && body.images.length > 0) {
         try {
-          console.log(`[ChatRoute] Processing ${body.images.length} images for message ${userMessage.id}`);
+          console.log(`[ChatRoute] Processing ${body.images.length} inline images for message ${userMessage.id}`);
           processedImagesRaw = await processMessageImages(
             sessionId,
             userMessage.id,
@@ -972,16 +1027,16 @@ async function chatRoutes(fastify) {
             ...userMessage.metadata,
             images: processedImages
           });
+          copilotAttachments = processedImagesRaw.map((img, index) => ({
+            type: "file",
+            path: img.fullImagePath,
+            displayName: `image_${index + 1}.${img.mimeType.split("/")[1] || "jpg"}`
+          }));
           console.log(`[ChatRoute] Processed ${processedImages.length} images successfully`);
         } catch (err) {
           console.error("[ChatRoute] Failed to process images:", err);
         }
       }
-      const copilotAttachments = processedImagesRaw.map((img, index) => ({
-        type: "file",
-        path: img.fullImagePath,
-        displayName: `image_${index + 1}.${img.mimeType.split("/")[1] || "jpg"}`
-      }));
       if (copilotAttachments.length > 0) {
         console.log(`[ChatRoute] Built ${copilotAttachments.length} attachments for Copilot:`, copilotAttachments);
       }
@@ -1035,8 +1090,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 +1106,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 +1148,47 @@ 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) {
+            if (!reply.raw.headersSent) {
+              reply.raw.setHeader("Content-Type", "text/event-stream");
+              reply.raw.setHeader("Cache-Control", "no-cache");
+              reply.raw.setHeader("Connection", "keep-alive");
+              reply.raw.setHeader("Access-Control-Allow-Origin", "*");
+            }
+            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();
         }
       });
@@ -1122,6 +1204,12 @@ async function chatRoutes(fastify) {
           }
         });
       }
+      if (!reply.raw.headersSent) {
+        reply.raw.setHeader("Content-Type", "text/event-stream");
+        reply.raw.setHeader("Cache-Control", "no-cache");
+        reply.raw.setHeader("Connection", "keep-alive");
+        reply.raw.setHeader("Access-Control-Allow-Origin", "*");
+      }
       const errorEvent = {
         type: "error",
         data: { error: error instanceof Error ? error.message : "Unknown error" }
@@ -1213,143 +1301,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,7 +1367,26 @@ 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 { z as z3 } from "zod";
 import fs2 from "fs";
 import path2 from "path";
 var MIME_TYPES = {
@@ -1376,7 +1396,68 @@ var MIME_TYPES = {
   "webp": "image/webp",
   "gif": "image/gif"
 };
+var uploadImageSchema = z3.object({
+  id: z3.string(),
+  dataUrl: z3.string(),
+  mimeType: z3.enum(["image/png", "image/jpeg", "image/webp"]),
+  source: z3.enum(["screenshot", "paste", "drop"])
+});
+var uploadBodySchema = z3.object({
+  images: z3.array(uploadImageSchema).min(1).max(5)
+});
 async function imagesRoutes(fastify) {
+  fastify.post(
+    "/upload/:sessionId/:messageId",
+    async (request, reply) => {
+      try {
+        const { sessionId, messageId } = request.params;
+        const body = uploadBodySchema.parse(request.body);
+        const host = request.headers.host || `${request.hostname}:3847`;
+        const backendUrl = `http://${host}`;
+        console.log(`[ImagesRoute] Pre-uploading ${body.images.length} images for ${sessionId}/${messageId}`);
+        const processedImagesRaw = await processMessageImages(
+          sessionId,
+          messageId,
+          body.images,
+          backendUrl
+        );
+        const processedImages = toImageAttachments(processedImagesRaw);
+        const responseImages = processedImagesRaw.map((img, i) => ({
+          id: img.id,
+          thumbnailUrl: img.thumbnailUrl,
+          fullImageUrl: img.fullImageUrl,
+          fullImagePath: img.fullImagePath,
+          mimeType: img.mimeType,
+          dimensions: img.dimensions,
+          fileSize: img.fileSize
+        }));
+        console.log(`[ImagesRoute] Pre-upload complete: ${responseImages.length} images processed`);
+        return reply.send({
+          success: true,
+          data: { images: responseImages }
+        });
+      } catch (error) {
+        if (error instanceof z3.ZodError) {
+          return reply.code(400).send({
+            success: false,
+            error: {
+              code: "VALIDATION_ERROR",
+              message: "Invalid upload body",
+              details: error.errors
+            }
+          });
+        }
+        console.error("[ImagesRoute] Upload failed:", error);
+        return reply.code(500).send({
+          success: false,
+          error: {
+            code: "UPLOAD_ERROR",
+            message: error instanceof Error ? error.message : "Failed to process images"
+          }
+        });
+      }
+    }
+  );
   fastify.get(
     "/:sessionId/:messageId/:filename",
     async (request, reply) => {
@@ -1502,7 +1583,7 @@ function registerToolsRoutes(app, copilotService) {
 }
 
 // src/services/copilot.service.ts
-import { CopilotClient } from "@github/copilot-sdk";
+import { CopilotClient, approveAll } from "@github/copilot-sdk";
 
 // src/tools/devops-tools.ts
 import * as fs3 from "fs/promises";
@@ -1900,11 +1981,61 @@ var analyzeErrorTool = {
     return result;
   }
 };
+var fetchUrlTool = {
+  name: "fetch_url",
+  description: "Fetch the text content of a public URL. Use this to read documentation, github issues, or other public web pages when the user shares a URL.",
+  parameters: {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description: "The HTTP or HTTPS URL to fetch"
+      }
+    },
+    required: ["url"]
+  },
+  handler: async (params) => {
+    const targetUrl = params.url;
+    if (!targetUrl.startsWith("http://") && !targetUrl.startsWith("https://")) {
+      return `Error: Only HTTP/HTTPS URLs are supported, got "${targetUrl}"`;
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 1e4);
+      const response = await fetch(targetUrl, {
+        signal: controller.signal,
+        headers: {
+          "User-Agent": "DevMentorAI/1.0",
+          "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,text/plain;q=0.8"
+        }
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        return `Error: Server responded with status ${response.status} ${response.statusText}`;
+      }
+      const contentType = response.headers.get("content-type") || "";
+      const text = await response.text();
+      const MAX_LENGTH = 15e3;
+      if (text.length > MAX_LENGTH) {
+        return text.substring(0, MAX_LENGTH) + `
+
+[Content truncated at ${MAX_LENGTH} characters]`;
+      }
+      return text;
+    } catch (error) {
+      if (error.name === "AbortError") {
+        return `Error: Request to ${targetUrl} timed out after 10 seconds.`;
+      }
+      return `Error fetching URL: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+};
 var devopsTools = [
   readFileTool,
   listDirectoryTool,
   analyzeConfigTool,
-  analyzeErrorTool
+  analyzeErrorTool,
+  fetchUrlTool
 ];
 function getToolByName(name) {
   return devopsTools.find((tool) => tool.name === name);
@@ -1918,6 +2049,7 @@ var MCP_SERVERS = {
     tools: ["*"]
   }
 };
+var RECOMMENDED_DEFAULT_MODEL = "gpt-4.1";
 var CopilotService = class {
   constructor(sessionService) {
     this.sessionService = sessionService;
@@ -1945,6 +2077,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, {
@@ -1965,7 +2281,8 @@ var CopilotService = class {
       customAgents: agentConfig ? [agentConfig] : void 0,
       systemMessage: systemPrompt ? { content: systemPrompt } : void 0,
       tools,
-      mcpServers
+      mcpServers,
+      onPermissionRequest: approveAll
     });
     this.sessions.set(sessionId, { sessionId, session, type });
   }
@@ -1995,13 +2312,14 @@ var CopilotService = class {
       return true;
     }
     try {
-      const session = await this.client.resumeSession(sessionId);
+      const session = await this.client.resumeSession(sessionId, { onPermissionRequest: approveAll });
       const dbSession = this.sessionService.getSession(sessionId);
       this.sessions.set(sessionId, { sessionId, session, type: dbSession?.type || "general" });
       console.log(`[CopilotService] Session ${sessionId} resumed from disk`);
       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 +2370,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 +2406,7 @@ User request: ${prompt}`;
     if (onEvent) {
       copilotSession.session.on(onEvent);
     }
-    copilotSession.session.send({
+    await copilotSession.session.send({
       prompt: fullPrompt,
       attachments
     });
@@ -2105,7 +2423,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 +2486,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 +2637,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 +2724,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 +2932,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) {
@@ -2618,6 +2942,9 @@ function truncate(str, maxLen = 500) {
 }
 async function createServer() {
   const fastify = Fastify({
+    // Allow large payloads for image uploads (data URLs can be 10-30MB for full-page screenshots)
+    bodyLimit: 50 * 1024 * 1024,
+    // 50MB
     logger: {
       level: DEBUG_MODE ? "debug" : "info",
       transport: {
@@ -2697,6 +3024,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 +3032,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 +3071,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
 };