devmentorai-server 1.0.0

package/dist/server.js

@@ -0,0 +1,2704 @@
+import {
+  DEFAULT_CONFIG,
+  IMAGES_DIR,
+  SESSION_TYPE_CONFIGS,
+  deleteDir,
+  ensureDir,
+  fileExists,
+  formatDate,
+  generateMessageId,
+  generateSessionId,
+  getAgentConfig,
+  getDefaultModel,
+  getMessageImagesDir,
+  getSessionImagesDir,
+  getThumbnailPath,
+  toImageRelativePath,
+  toRelativePath,
+  toUrlPath
+} from "./chunk-QFZAYHDT.js";
+
+// src/server.ts
+import Fastify from "fastify";
+import cors from "@fastify/cors";
+
+// src/routes/health.ts
+var startTime = Date.now();
+async function healthRoutes(fastify) {
+  fastify.get("/health", async (_request, reply) => {
+    const copilotService = fastify.copilotService;
+    const healthData = {
+      status: copilotService.isReady() ? "healthy" : "degraded",
+      version: "1.0.0",
+      copilotConnected: copilotService.isReady() && !copilotService.isMockMode(),
+      uptime: Math.floor((Date.now() - startTime) / 1e3),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return reply.send({
+      success: true,
+      data: healthData
+    });
+  });
+}
+
+// src/routes/sessions.ts
+import { z } from "zod";
+
+// src/services/thumbnail-service.ts
+import sharp from "sharp";
+import fs from "fs";
+import path from "path";
+var THUMBNAIL_CONFIG = {
+  maxDimension: 200,
+  quality: 60,
+  format: "jpeg"
+};
+function parseDataUrl(dataUrl) {
+  const match = dataUrl.match(/^data:(image\/[^;]+);base64,(.+)$/);
+  if (!match) return null;
+  const [, mimeType, base64Data] = match;
+  const buffer = Buffer.from(base64Data, "base64");
+  return { buffer, mimeType };
+}
+async function getImageDimensions(buffer) {
+  const metadata = await sharp(buffer).metadata();
+  return {
+    width: metadata.width || 0,
+    height: metadata.height || 0
+  };
+}
+async function generateThumbnail(buffer) {
+  return sharp(buffer).resize(THUMBNAIL_CONFIG.maxDimension, THUMBNAIL_CONFIG.maxDimension, {
+    fit: "inside",
+    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";
+}
+function getFullImagePath(sessionId, messageId, index, extension) {
+  const messageDir = getMessageImagesDir(sessionId, messageId);
+  return path.join(messageDir, `image_${index}.${extension}`);
+}
+async function processMessageImages(sessionId, messageId, images, backendUrl) {
+  if (!images || images.length === 0) return [];
+  const messageDir = getMessageImagesDir(sessionId, messageId);
+  ensureDir(messageDir);
+  const processedImages = [];
+  for (let index = 0; index < images.length; index++) {
+    const image = images[index];
+    try {
+      const parsed = parseDataUrl(image.dataUrl);
+      if (!parsed) {
+        console.error(`[ThumbnailService] Failed to parse data URL for image ${image.id}`);
+        continue;
+      }
+      const { buffer, mimeType } = parsed;
+      const dimensions = await getImageDimensions(buffer);
+      const thumbnailBuffer = await generateThumbnail(buffer);
+      const thumbnailAbsPath = getThumbnailPath(sessionId, messageId, index);
+      fs.writeFileSync(thumbnailAbsPath, thumbnailBuffer);
+      const extension = getExtensionForMimeType(mimeType);
+      const fullImageAbsPath = getFullImagePath(sessionId, messageId, index, extension);
+      fs.writeFileSync(fullImageAbsPath, buffer);
+      console.log(`[ThumbnailService] Saved full image to ${fullImageAbsPath}`);
+      const thumbnailRelativePath = toRelativePath(thumbnailAbsPath);
+      const thumbnailUrlPath = toUrlPath(toImageRelativePath(thumbnailAbsPath));
+      const fullImageUrlPath = toUrlPath(toImageRelativePath(fullImageAbsPath));
+      processedImages.push({
+        id: image.id,
+        source: image.source,
+        mimeType: image.mimeType,
+        dimensions,
+        fileSize: buffer.length,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        thumbnailUrl: `${backendUrl}/api/images/${thumbnailUrlPath}`,
+        thumbnailPath: thumbnailRelativePath,
+        fullImagePath: fullImageAbsPath,
+        fullImageUrl: `${backendUrl}/api/images/${fullImageUrlPath}`
+      });
+      console.log(`[ThumbnailService] Processed image ${index + 1}/${images.length} for message ${messageId}`);
+    } catch (error) {
+      console.error(`[ThumbnailService] Failed to process image ${image.id}:`, error);
+    }
+  }
+  return processedImages;
+}
+function getThumbnailFilePath(sessionId, messageId, index) {
+  const thumbnailPath = getThumbnailPath(sessionId, messageId, index);
+  return fileExists(thumbnailPath) ? thumbnailPath : null;
+}
+function deleteSessionImages(sessionId) {
+  const sessionDir = getSessionImagesDir(sessionId);
+  deleteDir(sessionDir);
+  console.log(`[ThumbnailService] Deleted images for session ${sessionId}`);
+}
+function toImageAttachments(processedImages) {
+  return processedImages.map((img) => ({
+    id: img.id,
+    source: img.source,
+    mimeType: img.mimeType,
+    dimensions: img.dimensions,
+    fileSize: img.fileSize,
+    timestamp: img.timestamp,
+    thumbnailUrl: img.thumbnailUrl,
+    fullImageUrl: img.fullImageUrl
+    // Note: dataUrl is NOT included - it's only used during processing
+  }));
+}
+
+// src/routes/sessions.ts
+var createSessionSchema = z.object({
+  name: z.string().min(1).max(100),
+  type: z.enum(["devops", "writing", "development", "general"]),
+  model: z.string().optional(),
+  systemPrompt: z.string().optional()
+});
+var updateSessionSchema = z.object({
+  name: z.string().min(1).max(100).optional(),
+  status: z.enum(["active", "paused", "closed"]).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 sessions = fastify.sessionService.listSessions(page, pageSize);
+    return reply.send({
+      success: true,
+      data: sessions
+    });
+  });
+  fastify.post("/sessions", async (request, reply) => {
+    try {
+      const body = createSessionSchema.parse(request.body);
+      console.log("[sessionRoutes] Creating session with body:", body);
+      const session = fastify.sessionService.createSession(body);
+      await fastify.copilotService.createCopilotSession(
+        session.id,
+        session.type,
+        session.model,
+        session.systemPrompt
+      );
+      return reply.code(201).send({
+        success: true,
+        data: session
+      });
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        return reply.code(400).send({
+          success: false,
+          error: {
+            code: "VALIDATION_ERROR",
+            message: "Invalid request body",
+            details: { errors: error.errors }
+          }
+        });
+      }
+      throw error;
+    }
+  });
+  fastify.get("/sessions/:id", async (request, reply) => {
+    const session = fastify.sessionService.getSession(request.params.id);
+    if (!session) {
+      return reply.code(404).send({
+        success: false,
+        error: {
+          code: "NOT_FOUND",
+          message: "Session not found"
+        }
+      });
+    }
+    return reply.send({
+      success: true,
+      data: session
+    });
+  });
+  fastify.patch("/sessions/:id", async (request, reply) => {
+    try {
+      const body = updateSessionSchema.parse(request.body);
+      const session = fastify.sessionService.updateSession(request.params.id, body);
+      if (!session) {
+        return reply.code(404).send({
+          success: false,
+          error: {
+            code: "NOT_FOUND",
+            message: "Session not found"
+          }
+        });
+      }
+      return reply.send({
+        success: true,
+        data: session
+      });
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        return reply.code(400).send({
+          success: false,
+          error: {
+            code: "VALIDATION_ERROR",
+            message: "Invalid request body",
+            details: { errors: error.errors }
+          }
+        });
+      }
+      throw error;
+    }
+  });
+  fastify.delete("/sessions/:id", async (request, reply) => {
+    const sessionId = request.params.id;
+    console.log(`[SessionRoute] Deleting session: ${sessionId}`);
+    const session = fastify.sessionService.getSession(sessionId);
+    if (!session) {
+      return reply.code(404).send({
+        success: false,
+        error: {
+          code: "NOT_FOUND",
+          message: "Session not found"
+        }
+      });
+    }
+    try {
+      await fastify.copilotService.destroySession(sessionId);
+    } catch (error) {
+      console.error(`[SessionRoute] Error destroying Copilot session:`, error);
+    }
+    try {
+      deleteSessionImages(sessionId);
+    } catch (error) {
+      console.error(`[SessionRoute] Error deleting session images:`, error);
+    }
+    const deleted = fastify.sessionService.deleteSession(sessionId);
+    console.log(`[SessionRoute] Session ${sessionId} deleted: ${deleted}`);
+    return reply.code(200).send({
+      success: true,
+      data: { deleted, sessionId }
+    });
+  });
+  fastify.post("/sessions/:id/resume", async (request, reply) => {
+    const sessionId = request.params.id;
+    const session = fastify.sessionService.getSession(sessionId);
+    if (!session) {
+      return reply.code(404).send({
+        success: false,
+        error: {
+          code: "NOT_FOUND",
+          message: "Session not found"
+        }
+      });
+    }
+    const resumed = await fastify.copilotService.resumeCopilotSession(sessionId);
+    if (!resumed) {
+      await fastify.copilotService.createCopilotSession(
+        session.id,
+        session.type,
+        session.model,
+        session.systemPrompt
+      );
+    }
+    const updatedSession = fastify.sessionService.updateSession(sessionId, { status: "active" });
+    return reply.send({
+      success: true,
+      data: updatedSession
+    });
+  });
+  fastify.post("/sessions/:id/abort", async (request, reply) => {
+    await fastify.copilotService.abortRequest(request.params.id);
+    return reply.send({
+      success: true
+    });
+  });
+  fastify.get("/sessions/:id/messages", async (request, reply) => {
+    const session = fastify.sessionService.getSession(request.params.id);
+    if (!session) {
+      return reply.code(404).send({
+        success: false,
+        error: {
+          code: "NOT_FOUND",
+          message: "Session not found"
+        }
+      });
+    }
+    const page = parseInt(request.query.page || "1", 10);
+    const pageSize = parseInt(request.query.pageSize || "100", 10);
+    const messages = fastify.sessionService.listMessages(request.params.id, page, pageSize);
+    return reply.send({
+      success: true,
+      data: messages
+    });
+  });
+}
+
+// src/routes/chat.ts
+import { z as z2 } from "zod";
+
+// src/services/context-prompt-builder.ts
+var PLATFORM_CONTEXT_NOTES = {
+  azure: `**Platform:** Azure Portal
+Common diagnostic locations: Activity Log, Diagnose and solve problems, Resource health`,
+  aws: `**Platform:** AWS Console  
+Common diagnostic locations: CloudTrail, CloudWatch Logs, IAM policies`,
+  gcp: `**Platform:** Google Cloud Console
+Common diagnostic locations: Cloud Logging, Error Reporting, IAM bindings`,
+  github: `**Platform:** GitHub
+Common diagnostic locations: Actions tab, Issues, Pull Requests`,
+  gitlab: `**Platform:** GitLab
+Common diagnostic locations: Pipelines, Merge Requests, Project settings`,
+  kubernetes: `**Platform:** Kubernetes Dashboard
+Common diagnostic commands: kubectl logs, kubectl describe, kubectl get events`,
+  jenkins: `**Platform:** Jenkins
+Common diagnostic locations: Console output, Pipeline syntax, Agent status`,
+  datadog: `**Platform:** Datadog
+Common diagnostic locations: Metric graphs, Alert conditions, Integration status`,
+  grafana: `**Platform:** Grafana
+Common diagnostic locations: Query editor, Data source config, Alert rules`,
+  generic: ``
+};
+function formatPageContext(page) {
+  const { platform } = page;
+  const platformLabel = platform.specificProduct || platform.type.toUpperCase();
+  let section = `## Page Context
+`;
+  section += `- **Platform:** ${platformLabel}`;
+  if (platform.confidence < 0.8) {
+    section += ` (confidence: ${Math.round(platform.confidence * 100)}%)`;
+  }
+  section += "\n";
+  section += `- **URL:** ${page.url}
+`;
+  section += `- **Title:** ${page.title}
+`;
+  return section;
+}
+function formatErrors(errors) {
+  if (errors.length === 0) return "";
+  let section = `## Errors and Alerts on Page
+`;
+  section += `${errors.length} issue(s) detected:
+
+`;
+  for (const error of errors) {
+    section += `- **[${error.severity.toUpperCase()}]** ${error.message}
+`;
+    if (error.source) section += `  Source: ${error.source}
+`;
+    if (error.context) section += `  Context: ${error.context}
+`;
+    if (error.stackTrace) section += `  Stack: ${error.stackTrace.slice(0, 200)}...
+`;
+    section += "\n";
+  }
+  return section;
+}
+function formatHeadings(headings) {
+  if (headings.length === 0) return "";
+  let section = `## Page Structure (Headings)
+`;
+  for (const heading of headings.slice(0, 10)) {
+    const indent = "  ".repeat(heading.level - 1);
+    section += `${indent}- ${heading.text}
+`;
+  }
+  return section + "\n";
+}
+function formatRelevantSections(sections) {
+  if (sections.length === 0) return "";
+  let section = `## Relevant UI Elements
+`;
+  for (const s of sections.slice(0, 5)) {
+    section += `### ${s.purpose.replace("-", " ").toUpperCase()}
+`;
+    section += `\`\`\`
+${s.textContent.slice(0, 300)}
+\`\`\`
+
+`;
+  }
+  return section;
+}
+function formatCodeBlocks(codeBlocks) {
+  if (!codeBlocks || codeBlocks.length === 0) return "";
+  let section = `## Code Snippets Found on Page
+`;
+  for (const block of codeBlocks.slice(0, 3)) {
+    const lang = block.attributes.detectedLanguage || "text";
+    section += `### ${lang.toUpperCase()}
+`;
+    section += `\`\`\`${lang}
+${block.textContent.slice(0, 500)}
+\`\`\`
+
+`;
+  }
+  return section;
+}
+function formatTables(tables) {
+  if (!tables || tables.length === 0) return "";
+  let section = `## Data Tables
+`;
+  for (const table of tables.slice(0, 2)) {
+    const rows = table.attributes.rowCount || "?";
+    const cols = table.attributes.columnCount || "?";
+    section += `### Table (${rows} rows \xD7 ${cols} cols)
+`;
+    section += `\`\`\`
+${table.textContent.slice(0, 400)}
+\`\`\`
+
+`;
+  }
+  return section;
+}
+function formatConsoleLogs(logs) {
+  if (!logs || logs.length === 0) return "";
+  const errors = logs.filter((l) => l.level === "error" || l.level === "warn");
+  if (errors.length === 0) return "";
+  let section = `## Browser Console Logs
+`;
+  section += `${errors.length} error/warning message(s):
+
+`;
+  for (const log of errors.slice(0, 5)) {
+    section += `- **${log.level.toUpperCase()}:** ${log.message.slice(0, 200)}
+`;
+    if (log.stackTrace) {
+      section += `  Stack: ${log.stackTrace.slice(0, 150)}...
+`;
+    }
+    section += "\n";
+  }
+  return section;
+}
+function formatNetworkErrors(errors) {
+  if (!errors || errors.length === 0) return "";
+  let section = `## Network Requests Failed
+`;
+  section += `${errors.length} failed request(s):
+
+`;
+  for (const err of errors.slice(0, 5)) {
+    const status = err.status ? `HTTP ${err.status}` : err.errorMessage || "Failed";
+    section += `- **${err.method}** ${err.url.slice(0, 80)}${err.url.length > 80 ? "..." : ""}
+`;
+    section += `  Status: ${status}
+
+`;
+  }
+  return section;
+}
+function formatModalContent(modal) {
+  if (!modal) return "";
+  let section = `## Active Modal/Dialog
+`;
+  const title = modal.attributes.title || "Modal";
+  section += `### ${title}
+`;
+  section += `\`\`\`
+${modal.textContent.slice(0, 400)}
+\`\`\`
+
+`;
+  return section;
+}
+function formatPlatformSpecificContext(platformContext) {
+  if (!platformContext || Object.keys(platformContext).length === 0) return "";
+  let section = `## Platform-Specific Details
+`;
+  for (const [key, value] of Object.entries(platformContext)) {
+    if (value !== void 0 && value !== null) {
+      section += `- **${key}:** ${String(value)}
+`;
+    }
+  }
+  return section + "\n";
+}
+function formatUIState(uiState) {
+  let section = `## UI State
+`;
+  section += `- **Page State:** ${uiState.pageState}
+`;
+  const issues = [];
+  if (uiState.loadingIndicators > 0) issues.push(`${uiState.loadingIndicators} loading indicator(s)`);
+  if (uiState.errorStates > 0) issues.push(`${uiState.errorStates} error state(s)`);
+  if (uiState.emptyStates > 0) issues.push(`${uiState.emptyStates} empty state(s)`);
+  if (uiState.toastNotifications > 0) issues.push(`${uiState.toastNotifications} notification(s)`);
+  if (uiState.formValidationErrors > 0) issues.push(`${uiState.formValidationErrors} form validation error(s)`);
+  if (uiState.disabledButtons > 0) issues.push(`${uiState.disabledButtons} disabled button(s)`);
+  if (uiState.modalOpen) issues.push(`modal/dialog open`);
+  if (issues.length > 0) {
+    section += `- **UI Issues:** ${issues.join(", ")}
+`;
+  }
+  return section + "\n";
+}
+function formatRuntimeErrors(errors) {
+  if (errors.length === 0) return "";
+  let section = `## JavaScript Runtime Errors
+`;
+  section += `${errors.length} runtime error(s) detected:
+
+`;
+  for (const err of errors.slice(0, 5)) {
+    const errType = err.type === "unhandledrejection" ? "Promise Rejection" : "JS Error";
+    section += `- **${errType}:** ${err.message.slice(0, 200)}
+`;
+    if (err.source) {
+      section += `  Source: ${err.source}${err.lineno ? `:${err.lineno}` : ""}${err.colno ? `:${err.colno}` : ""}
+`;
+    }
+    if (err.stack) {
+      section += `  Stack: ${err.stack.slice(0, 150)}...
+`;
+    }
+    section += "\n";
+  }
+  return section;
+}
+function formatSelectedText(selectedText) {
+  if (!selectedText) return "";
+  return `## User Selected Text
+The user has highlighted this text on the page:
+\`\`\`
+${selectedText}
+\`\`\`
+
+`;
+}
+function formatSessionHistory(messages) {
+  if (messages.count === 0 || messages.lastN.length === 0) return "";
+  let section = `## Recent Conversation (${messages.count} messages total)
+`;
+  for (const msg of messages.lastN) {
+    const role = msg.role === "user" ? "User" : "Assistant";
+    section += `**${role}:** ${msg.content.slice(0, 200)}${msg.content.length > 200 ? "..." : ""}
+
+`;
+  }
+  return section;
+}
+var DEFAULT_OPTIONS = {
+  includePlatformNotes: true,
+  includeErrors: true,
+  includeStructure: true,
+  // Phase 2 defaults
+  includeCodeBlocks: true,
+  includeTables: true,
+  includeConsoleLogs: true,
+  includeNetworkErrors: true,
+  includeModal: true,
+  includePlatformSpecific: true,
+  maxContextLength: 1e4
+  // Increased for Phase 2
+};
+function buildContextAwarePrompt(context, userMessage, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  let enrichedPrompt = "";
+  enrichedPrompt += `# Browser Context (from user's authenticated session)
+
+`;
+  enrichedPrompt += `The following context was extracted from the user's browser. `;
+  enrichedPrompt += `This may include private or authenticated content that is not publicly accessible. `;
+  enrichedPrompt += `Use this context to answer the user's question - DO NOT attempt to fetch URLs externally.
+
+`;
+  enrichedPrompt += formatPageContext(context.page);
+  if (context.page.uiState) {
+    enrichedPrompt += formatUIState(context.page.uiState);
+  }
+  if (opts.includePlatformNotes) {
+    const platformNotes = PLATFORM_CONTEXT_NOTES[context.page.platform.type] || PLATFORM_CONTEXT_NOTES.generic;
+    if (platformNotes) {
+      enrichedPrompt += platformNotes + "\n\n";
+    }
+  }
+  if (opts.includePlatformSpecific && context.page.platform.specificContext) {
+    enrichedPrompt += formatPlatformSpecificContext(context.page.platform.specificContext);
+  }
+  if (opts.includeErrors) {
+    enrichedPrompt += formatErrors(context.text.errors);
+  }
+  if (opts.includeConsoleLogs && context.text.consoleLogs) {
+    enrichedPrompt += formatConsoleLogs(context.text.consoleLogs);
+  }
+  if (opts.includeNetworkErrors && context.text.networkErrors) {
+    enrichedPrompt += formatNetworkErrors(context.text.networkErrors);
+  }
+  if (context.text.runtimeErrors?.length > 0) {
+    enrichedPrompt += formatRuntimeErrors(context.text.runtimeErrors);
+  }
+  enrichedPrompt += formatSelectedText(context.text.selectedText);
+  if (opts.includeModal && context.structure.modal) {
+    enrichedPrompt += formatModalContent(context.structure.modal);
+  }
+  if (opts.includeStructure) {
+    enrichedPrompt += formatHeadings(context.text.headings);
+    enrichedPrompt += formatRelevantSections(context.structure.relevantSections);
+  }
+  if (opts.includeCodeBlocks && context.structure.codeBlocks) {
+    enrichedPrompt += formatCodeBlocks(context.structure.codeBlocks);
+  }
+  if (opts.includeTables && context.structure.tables) {
+    enrichedPrompt += formatTables(context.structure.tables);
+  }
+  enrichedPrompt += formatSessionHistory(context.session.previousMessages);
+  if (context.privacy?.privacyMaskingApplied) {
+    enrichedPrompt += `
+**Note:** Some sensitive data (${context.privacy.sensitiveDataTypes?.join(", ") || "various types"}) has been redacted for privacy.
+
+`;
+  }
+  enrichedPrompt += `---
+
+## User Message
+${userMessage}
+`;
+  if (enrichedPrompt.length > (opts.maxContextLength || 1e4)) {
+    enrichedPrompt = truncatePrompt(enrichedPrompt, opts.maxContextLength || 1e4, userMessage);
+  }
+  return { systemPrompt: null, userPrompt: enrichedPrompt };
+}
+function truncatePrompt(prompt, maxLength, userMessage) {
+  const userMessageSection = `## User Message
+${userMessage}
+`;
+  const reservedLength = userMessageSection.length + 500;
+  const availableLength = maxLength - reservedLength;
+  if (availableLength < 500) {
+    return userMessageSection;
+  }
+  const truncatedContext = prompt.slice(0, availableLength);
+  const lastNewline = truncatedContext.lastIndexOf("\n");
+  return truncatedContext.slice(0, lastNewline) + "\n\n[Context truncated for length]\n\n" + userMessageSection;
+}
+function buildSimplePrompt(userMessage, pageUrl, pageTitle, selectedText) {
+  let userPrompt = "";
+  if (pageUrl || pageTitle || selectedText) {
+    userPrompt += `**Context:**
+`;
+    if (pageUrl) userPrompt += `- Page URL: ${pageUrl}
+`;
+    if (pageTitle) userPrompt += `- Page Title: ${pageTitle}
+`;
+    if (selectedText) userPrompt += `- Selected Text: "${selectedText.slice(0, 500)}${selectedText.length > 500 ? "..." : ""}"
+`;
+    userPrompt += "\n**Question:** ";
+  }
+  userPrompt += userMessage;
+  return { systemPrompt: null, userPrompt };
+}
+function validateContext(context) {
+  if (!context || typeof context !== "object") return false;
+  const c = context;
+  if (!c.metadata || typeof c.metadata !== "object") return false;
+  if (!c.page || typeof c.page !== "object") return false;
+  if (!c.text || typeof c.text !== "object") return false;
+  if (!c.session || typeof c.session !== "object") return false;
+  return true;
+}
+function sanitizeContext(context) {
+  const sanitized = JSON.parse(JSON.stringify(context));
+  const sensitivePatterns = [
+    /Bearer\s+[A-Za-z0-9\-_]+/gi,
+    /api[_-]?key[=:]\s*[A-Za-z0-9\-_]+/gi,
+    /password[=:]\s*\S+/gi,
+    /token[=:]\s*[A-Za-z0-9\-_]+/gi
+  ];
+  let visibleText = sanitized.text.visibleText;
+  for (const pattern of sensitivePatterns) {
+    visibleText = visibleText.replace(pattern, "[REDACTED]");
+  }
+  sanitized.text.visibleText = visibleText;
+  const url = new URL(sanitized.page.url);
+  const sensitiveParams = ["token", "key", "secret", "password", "auth"];
+  for (const param of sensitiveParams) {
+    if (url.searchParams.has(param)) {
+      url.searchParams.set(param, "[REDACTED]");
+    }
+  }
+  sanitized.page.url = url.toString();
+  sanitized.page.urlParsed.search = url.search;
+  return sanitized;
+}
+
+// src/routes/chat.ts
+var simpleContextSchema = z2.object({
+  pageUrl: z2.string().optional(),
+  pageTitle: z2.string().optional(),
+  selectedText: z2.string().optional(),
+  action: z2.enum([
+    "explain",
+    "translate",
+    "rewrite",
+    "fix_grammar",
+    "summarize",
+    "expand",
+    "analyze_config",
+    "diagnose_error"
+  ]).optional()
+});
+var fullContextSchema = z2.object({
+  metadata: z2.object({
+    captureTimestamp: z2.string(),
+    captureMode: z2.enum(["auto", "manual"]),
+    browserInfo: z2.object({
+      userAgent: z2.string(),
+      viewport: z2.object({ width: z2.number(), height: z2.number() }),
+      language: z2.string()
+    })
+  }),
+  page: z2.object({
+    url: z2.string(),
+    urlParsed: z2.object({
+      protocol: z2.string(),
+      hostname: z2.string(),
+      pathname: z2.string(),
+      search: z2.string(),
+      hash: z2.string()
+    }),
+    title: z2.string(),
+    platform: z2.object({
+      type: z2.string(),
+      confidence: z2.number(),
+      indicators: z2.array(z2.string()),
+      specificProduct: z2.string().optional()
+    })
+  }),
+  text: z2.object({
+    selectedText: z2.string().optional(),
+    visibleText: z2.string(),
+    headings: z2.array(z2.object({
+      level: z2.number(),
+      text: z2.string()
+    })),
+    errors: z2.array(z2.object({
+      type: z2.enum(["error", "warning", "info"]),
+      message: z2.string(),
+      source: z2.enum(["console", "ui", "network", "dom"]).optional(),
+      severity: z2.enum(["critical", "high", "medium", "low"]),
+      context: z2.string().optional()
+    })),
+    metadata: z2.object({
+      totalLength: z2.number(),
+      truncated: z2.boolean()
+    })
+  }),
+  structure: z2.object({
+    relevantSections: z2.array(z2.any()),
+    errorContainers: z2.array(z2.any()),
+    activeElements: z2.any(),
+    metadata: z2.any()
+  }),
+  session: z2.object({
+    sessionId: z2.string(),
+    sessionType: z2.string(),
+    intent: z2.object({
+      primary: z2.string(),
+      keywords: z2.array(z2.string()),
+      implicitSignals: z2.array(z2.string()),
+      explicitGoal: z2.string().optional()
+    }),
+    previousMessages: z2.object({
+      count: z2.number(),
+      lastN: z2.array(z2.any())
+    })
+  }),
+  privacy: z2.object({
+    redactedFields: z2.array(z2.string()),
+    sensitiveDataDetected: z2.boolean(),
+    consentGiven: z2.boolean(),
+    dataRetention: z2.enum(["session", "none"])
+  })
+}).passthrough();
+var imagePayloadSchema = z2.object({
+  id: z2.string(),
+  dataUrl: z2.string(),
+  mimeType: z2.enum(["image/png", "image/jpeg", "image/webp"]),
+  source: z2.enum(["screenshot", "paste", "drop"])
+});
+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()
+});
+async function chatRoutes(fastify) {
+  const buildPrompt = (body) => {
+    if (body.fullContext && body.useContextAwareMode !== false) {
+      if (validateContext(body.fullContext)) {
+        const sanitizedContext = sanitizeContext(body.fullContext);
+        const { userPrompt: userPrompt2 } = buildContextAwarePrompt(sanitizedContext, body.prompt);
+        return { userPrompt: userPrompt2, promptType: "context-aware" };
+      }
+    }
+    const { userPrompt } = buildSimplePrompt(
+      body.prompt,
+      body.context?.pageUrl,
+      body.context?.pageTitle,
+      body.context?.selectedText
+    );
+    return { userPrompt, promptType: "simple" };
+  };
+  fastify.post("/sessions/:id/chat", async (request, reply) => {
+    try {
+      const body = sendMessageSchema.parse(request.body);
+      const sessionId = request.params.id;
+      const session = fastify.sessionService.getSession(sessionId);
+      if (!session) {
+        return reply.code(404).send({
+          success: false,
+          error: {
+            code: "NOT_FOUND",
+            message: "Session not found"
+          }
+        });
+      }
+      const { userPrompt, promptType } = buildPrompt(body);
+      console.log(`[ChatRoute] Using ${promptType} prompt`);
+      const userMessage = fastify.sessionService.addMessage(
+        sessionId,
+        "user",
+        body.prompt,
+        body.context ? {
+          pageUrl: body.context.pageUrl,
+          selectedText: body.context.selectedText,
+          action: body.context.action
+        } : void 0
+      );
+      if (body.fullContext) {
+        try {
+          fastify.sessionService.saveContext(
+            sessionId,
+            JSON.stringify(body.fullContext),
+            userMessage.id,
+            body.fullContext.page?.url,
+            body.fullContext.page?.title,
+            body.fullContext.page?.platform?.type
+          );
+          console.log(`[ChatRoute] Context saved for message ${userMessage.id}`);
+        } catch (err) {
+          console.error("[ChatRoute] Failed to persist context:", err);
+        }
+      }
+      const response = await fastify.copilotService.sendMessage(
+        sessionId,
+        userPrompt,
+        body.context
+        // NOT passing systemPrompt - preserves Copilot's intelligence
+      );
+      const assistantMessage = fastify.sessionService.addMessage(
+        sessionId,
+        "assistant",
+        response
+      );
+      return reply.send({
+        success: true,
+        data: assistantMessage
+      });
+    } catch (error) {
+      if (error instanceof z2.ZodError) {
+        return reply.code(400).send({
+          success: false,
+          error: {
+            code: "VALIDATION_ERROR",
+            message: "Invalid request body",
+            details: { errors: error.errors }
+          }
+        });
+      }
+      throw error;
+    }
+  });
+  fastify.post("/sessions/:id/chat/stream", async (request, reply) => {
+    try {
+      const body = sendMessageSchema.parse(request.body);
+      const sessionId = request.params.id;
+      const session = fastify.sessionService.getSession(sessionId);
+      if (!session) {
+        return reply.code(404).send({
+          success: false,
+          error: {
+            code: "NOT_FOUND",
+            message: "Session not found"
+          }
+        });
+      }
+      const { userPrompt, promptType } = buildPrompt(body);
+      console.log(`[ChatRoute] Using ${promptType} prompt for streaming`);
+      let processedImagesRaw = [];
+      let processedImages = [];
+      const host = request.headers.host || `${request.hostname}:3847`;
+      const backendUrl = `http://${host}`;
+      const userMessage = fastify.sessionService.addMessage(
+        sessionId,
+        "user",
+        body.prompt,
+        body.context ? {
+          pageUrl: body.context.pageUrl,
+          selectedText: body.context.selectedText,
+          action: body.context.action,
+          contextAware: body.useContextAwareMode
+        } : { contextAware: body.useContextAwareMode }
+      );
+      if (body.images && body.images.length > 0) {
+        try {
+          console.log(`[ChatRoute] Processing ${body.images.length} images for message ${userMessage.id}`);
+          processedImagesRaw = await processMessageImages(
+            sessionId,
+            userMessage.id,
+            body.images,
+            backendUrl
+          );
+          processedImages = toImageAttachments(processedImagesRaw);
+          fastify.sessionService.updateMessageMetadata(userMessage.id, {
+            ...userMessage.metadata,
+            images: processedImages
+          });
+          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);
+      }
+      if (body.fullContext) {
+        try {
+          fastify.sessionService.saveContext(
+            sessionId,
+            JSON.stringify(body.fullContext),
+            userMessage.id,
+            body.fullContext.page?.url,
+            body.fullContext.page?.title,
+            body.fullContext.page?.platform?.type
+          );
+          console.log(`[ChatRoute] Context saved for message ${userMessage.id}`);
+        } catch (err) {
+          console.error("[ChatRoute] Failed to persist context:", err);
+        }
+      }
+      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", "*");
+      let fullContent = "";
+      let assistantMessageId = null;
+      let streamEnded = false;
+      let lastActivityTime = Date.now();
+      const STREAM_TIMEOUT_MS = 12e4;
+      const IDLE_TIMEOUT_MS = 3e4;
+      const sendSSE = (event) => {
+        if (!streamEnded) {
+          reply.raw.write(`data: ${JSON.stringify(event)}
+
+`);
+          lastActivityTime = Date.now();
+        }
+      };
+      const endStream = (reason = "completed") => {
+        if (streamEnded) return;
+        streamEnded = true;
+        console.log(`[ChatRoute] Stream ending: ${reason}. Content length: ${fullContent.length}`);
+        if (fullContent && !assistantMessageId) {
+          const message = fastify.sessionService.addMessage(
+            sessionId,
+            "assistant",
+            fullContent
+          );
+          assistantMessageId = message.id;
+        }
+        sendSSE({ type: "done", data: { messageId: assistantMessageId || void 0, reason } });
+        reply.raw.write("data: [DONE]\n\n");
+        reply.raw.end();
+      };
+      const streamComplete = new Promise((resolve2) => {
+        const globalTimeout = setTimeout(() => {
+          console.warn("[ChatRoute] Global stream timeout reached");
+          endStream("timeout");
+          fastify.copilotService.abortRequest(sessionId).catch(() => {
+          });
+          resolve2();
+        }, STREAM_TIMEOUT_MS);
+        const idleCheckInterval = setInterval(() => {
+          const idleTime = Date.now() - lastActivityTime;
+          if (idleTime > IDLE_TIMEOUT_MS && !streamEnded) {
+            console.warn(`[ChatRoute] Stream idle for ${idleTime}ms, ending`);
+            endStream("idle_timeout");
+            fastify.copilotService.abortRequest(sessionId).catch(() => {
+            });
+            resolve2();
+          }
+        }, 5e3);
+        const handleEvent = (event) => {
+          if (streamEnded) return;
+          console.log("[ChatRoute] Received event:", event.type);
+          lastActivityTime = Date.now();
+          switch (event.type) {
+            case "assistant.message_delta":
+              fullContent += event.data.deltaContent || "";
+              sendSSE({
+                type: "message_delta",
+                data: { deltaContent: event.data.deltaContent }
+              });
+              break;
+            case "assistant.message":
+              fullContent = event.data.content || fullContent;
+              sendSSE({
+                type: "message_complete",
+                data: { content: fullContent }
+              });
+              break;
+            case "tool.execution_start":
+              sendSSE({
+                type: "tool_start",
+                data: {
+                  toolName: event.data.toolName,
+                  toolCallId: event.data.toolCallId
+                }
+              });
+              break;
+            case "tool.execution_complete":
+              sendSSE({
+                type: "tool_complete",
+                data: { toolCallId: event.data.toolCallId }
+              });
+              break;
+            case "session.idle":
+              clearTimeout(globalTimeout);
+              clearInterval(idleCheckInterval);
+              endStream("completed");
+              resolve2();
+              break;
+          }
+        };
+        fastify.copilotService.streamMessage(
+          sessionId,
+          userPrompt,
+          body.context,
+          handleEvent,
+          copilotAttachments.length > 0 ? copilotAttachments : void 0
+        );
+      });
+      request.raw.on("close", async () => {
+        if (!streamEnded) {
+          console.log("[ChatRoute] Client disconnected, aborting");
+          streamEnded = true;
+          await fastify.copilotService.abortRequest(sessionId);
+          reply.raw.end();
+        }
+      });
+      await streamComplete;
+    } catch (error) {
+      if (error instanceof z2.ZodError) {
+        return reply.code(400).send({
+          success: false,
+          error: {
+            code: "VALIDATION_ERROR",
+            message: "Invalid request body",
+            details: error.errors
+          }
+        });
+      }
+      const errorEvent = {
+        type: "error",
+        data: { error: error instanceof Error ? error.message : "Unknown error" }
+      };
+      reply.raw.write(`data: ${JSON.stringify(errorEvent)}
+
+`);
+      reply.raw.write("data: [DONE]\n\n");
+      reply.raw.end();
+    }
+  });
+  fastify.get("/sessions/:id/context", async (request, reply) => {
+    const sessionId = request.params.id;
+    const limit = request.query.limit || 10;
+    const session = fastify.sessionService.getSession(sessionId);
+    if (!session) {
+      return reply.code(404).send({
+        success: false,
+        error: {
+          code: "NOT_FOUND",
+          message: "Session not found"
+        }
+      });
+    }
+    const latestContext = fastify.sessionService.getLatestContext(sessionId);
+    const contextHistory = fastify.sessionService.getContextHistory(sessionId, limit);
+    const contextCount = fastify.sessionService.getContextCount(sessionId);
+    return reply.send({
+      success: true,
+      data: {
+        latest: latestContext,
+        history: contextHistory,
+        totalCount: contextCount
+      }
+    });
+  });
+  fastify.get("/sessions/:id/context/:contextId", async (request, reply) => {
+    const { id: sessionId, contextId } = request.params;
+    const session = fastify.sessionService.getSession(sessionId);
+    if (!session) {
+      return reply.code(404).send({
+        success: false,
+        error: {
+          code: "NOT_FOUND",
+          message: "Session not found"
+        }
+      });
+    }
+    const context = fastify.sessionService.getContext(contextId);
+    if (!context || context.sessionId !== sessionId) {
+      return reply.code(404).send({
+        success: false,
+        error: {
+          code: "NOT_FOUND",
+          message: "Context not found"
+        }
+      });
+    }
+    return reply.send({
+      success: true,
+      data: {
+        ...context,
+        contextData: JSON.parse(context.contextJson)
+      }
+    });
+  });
+  fastify.post("/sessions/:id/context/cleanup", async (request, reply) => {
+    const sessionId = request.params.id;
+    const keepCount = request.body?.keepCount || 20;
+    const session = fastify.sessionService.getSession(sessionId);
+    if (!session) {
+      return reply.code(404).send({
+        success: false,
+        error: {
+          code: "NOT_FOUND",
+          message: "Session not found"
+        }
+      });
+    }
+    const deletedCount = fastify.sessionService.cleanupOldContexts(sessionId, keepCount);
+    return reply.send({
+      success: true,
+      data: {
+        deletedCount,
+        remainingCount: fastify.sessionService.getContextCount(sessionId)
+      }
+    });
+  });
+}
+
+// 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
+  }
+];
+async function modelsRoutes(fastify) {
+  fastify.get("/models", async (_request, reply) => {
+    const defaultModel = AVAILABLE_MODELS.find((m) => m.isDefault);
+    return reply.send({
+      success: true,
+      data: {
+        models: AVAILABLE_MODELS,
+        default: defaultModel?.id || "gpt-4.1"
+      }
+    });
+  });
+  fastify.get("/models/:id", async (request, reply) => {
+    const modelId = request.params.id;
+    const model = AVAILABLE_MODELS.find((m) => m.id === modelId);
+    if (!model) {
+      return reply.code(404).send({
+        success: false,
+        error: {
+          code: "NOT_FOUND",
+          message: `Model '${modelId}' not found`
+        }
+      });
+    }
+    return reply.send({
+      success: true,
+      data: model
+    });
+  });
+}
+
+// src/routes/images.ts
+import fs2 from "fs";
+import path2 from "path";
+var MIME_TYPES = {
+  "jpg": "image/jpeg",
+  "jpeg": "image/jpeg",
+  "png": "image/png",
+  "webp": "image/webp",
+  "gif": "image/gif"
+};
+async function imagesRoutes(fastify) {
+  fastify.get(
+    "/:sessionId/:messageId/:filename",
+    async (request, reply) => {
+      const { sessionId, messageId, filename } = request.params;
+      if (!sessionId?.match(/^session_[a-z0-9]+$/) || !messageId?.match(/^msg_[a-z0-9]+$/)) {
+        return reply.code(400).send({ error: "Invalid session or message ID format" });
+      }
+      let filePath = null;
+      let mimeType = "image/jpeg";
+      const thumbMatch = filename.match(/^thumb_(\d+)\.jpg$/);
+      if (thumbMatch) {
+        const imageIndex = parseInt(thumbMatch[1], 10);
+        filePath = getThumbnailFilePath(sessionId, messageId, imageIndex);
+        mimeType = "image/jpeg";
+      }
+      const imageMatch = filename.match(/^image_(\d+)\.(jpg|jpeg|png|webp|gif)$/i);
+      if (imageMatch) {
+        const ext = imageMatch[2].toLowerCase();
+        mimeType = MIME_TYPES[ext] || "image/jpeg";
+        filePath = path2.join(IMAGES_DIR, sessionId, messageId, filename);
+      }
+      if (!filePath) {
+        return reply.code(400).send({ error: "Invalid filename format" });
+      }
+      if (!fs2.existsSync(filePath)) {
+        console.log(`[ImagesRoute] File not found: ${filePath}`);
+        return reply.code(404).send({ error: "Image not found" });
+      }
+      try {
+        const fileBuffer = fs2.readFileSync(filePath);
+        return reply.code(200).header("Content-Type", mimeType).header("Cache-Control", "public, max-age=31536000, immutable").header("Content-Length", fileBuffer.length).send(fileBuffer);
+      } catch (error) {
+        console.error("[ImagesRoute] Failed to read image file:", error);
+        return reply.code(500).send({ error: "Failed to read image" });
+      }
+    }
+  );
+}
+
+// src/routes/tools.ts
+function registerToolsRoutes(app, copilotService) {
+  app.get("/api/tools", async (request, reply) => {
+    const sessionType = request.query.type || "devops";
+    const tools = copilotService.getAvailableTools(sessionType);
+    return reply.send({
+      success: true,
+      data: tools
+    });
+  });
+  app.post("/api/tools/execute", async (request, reply) => {
+    const { toolName, params } = request.body;
+    if (!toolName) {
+      return reply.status(400).send({
+        success: false,
+        error: "toolName is required"
+      });
+    }
+    const result = await copilotService.executeTool(toolName, params || {});
+    if (!result.success) {
+      return reply.status(400).send({
+        success: false,
+        error: result.error
+      });
+    }
+    return reply.send({
+      success: true,
+      data: {
+        toolName,
+        result: result.result
+      }
+    });
+  });
+  app.post("/api/tools/analyze-config", async (request, reply) => {
+    const { content, type } = request.body;
+    if (!content) {
+      return reply.status(400).send({
+        success: false,
+        error: "content is required"
+      });
+    }
+    const result = await copilotService.executeTool("analyze_config", {
+      content,
+      type: type || "auto"
+    });
+    return reply.send({
+      success: result.success,
+      data: result.result,
+      error: result.error
+    });
+  });
+  app.post("/api/tools/analyze-error", async (request, reply) => {
+    const { error, context } = request.body;
+    if (!error) {
+      return reply.status(400).send({
+        success: false,
+        error: "error is required"
+      });
+    }
+    const result = await copilotService.executeTool("analyze_error", {
+      error,
+      context: context || "general"
+    });
+    return reply.send({
+      success: result.success,
+      data: result.result,
+      error: result.error
+    });
+  });
+}
+
+// src/services/copilot.service.ts
+import { CopilotClient } from "@github/copilot-sdk";
+
+// src/tools/devops-tools.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+var ALLOWED_DIRECTORIES = [
+  process.env.HOME || "/home",
+  "/tmp"
+];
+function isPathAllowed(filePath) {
+  const resolved = path3.resolve(filePath);
+  return ALLOWED_DIRECTORIES.some((dir) => resolved.startsWith(dir));
+}
+var readFileTool = {
+  name: "read_file",
+  description: "Read the contents of a local file. Use this to analyze configuration files, logs, or code.",
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Absolute or relative path to the file to read"
+      },
+      maxLines: {
+        type: "number",
+        description: "Maximum number of lines to read (default: 500)"
+      }
+    },
+    required: ["path"]
+  },
+  handler: async (params) => {
+    const filePath = params.path;
+    const maxLines = params.maxLines || 500;
+    if (!isPathAllowed(filePath)) {
+      return `Error: Access denied. Path "${filePath}" is outside allowed directories.`;
+    }
+    try {
+      const content = await fs3.readFile(filePath, "utf-8");
+      const lines = content.split("\n");
+      if (lines.length > maxLines) {
+        return lines.slice(0, maxLines).join("\n") + `
+
+[Truncated: ${lines.length - maxLines} more lines]`;
+      }
+      return content;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return `Error: File not found: ${filePath}`;
+      }
+      return `Error reading file: ${error}`;
+    }
+  }
+};
+var listDirectoryTool = {
+  name: "list_directory",
+  description: "List contents of a directory. Useful for exploring project structure.",
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Path to the directory to list"
+      },
+      recursive: {
+        type: "boolean",
+        description: "Whether to list recursively (default: false, max depth: 3)"
+      }
+    },
+    required: ["path"]
+  },
+  handler: async (params) => {
+    const dirPath = params.path;
+    const recursive = params.recursive || false;
+    if (!isPathAllowed(dirPath)) {
+      return `Error: Access denied. Path "${dirPath}" is outside allowed directories.`;
+    }
+    async function listDir(dir, depth = 0) {
+      if (depth > 3) return [];
+      const entries = await fs3.readdir(dir, { withFileTypes: true });
+      const results = [];
+      for (const entry of entries) {
+        const prefix = "  ".repeat(depth);
+        const fullPath = path3.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          results.push(`${prefix}\u{1F4C1} ${entry.name}/`);
+          if (recursive) {
+            results.push(...await listDir(fullPath, depth + 1));
+          }
+        } else {
+          const stats = await fs3.stat(fullPath);
+          const size = formatSize(stats.size);
+          results.push(`${prefix}\u{1F4C4} ${entry.name} (${size})`);
+        }
+      }
+      return results;
+    }
+    try {
+      const contents = await listDir(dirPath);
+      return contents.join("\n");
+    } catch (error) {
+      return `Error listing directory: ${error}`;
+    }
+  }
+};
+function formatSize(bytes) {
+  const units = ["B", "KB", "MB", "GB"];
+  let size = bytes;
+  let unitIndex = 0;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  return `${size.toFixed(1)} ${units[unitIndex]}`;
+}
+var analyzeConfigTool = {
+  name: "analyze_config",
+  description: "Analyze a configuration file for DevOps best practices. Supports Kubernetes, Docker, Terraform, and CloudFormation.",
+  parameters: {
+    type: "object",
+    properties: {
+      content: {
+        type: "string",
+        description: "The configuration file content to analyze"
+      },
+      type: {
+        type: "string",
+        enum: ["kubernetes", "docker", "terraform", "cloudformation", "github-actions", "auto"],
+        description: "Type of configuration (auto-detect if not specified)"
+      }
+    },
+    required: ["content"]
+  },
+  handler: async (params) => {
+    const content = params.content;
+    let configType = params.type || "auto";
+    if (configType === "auto") {
+      configType = detectConfigType(content);
+    }
+    const issues = [];
+    const suggestions = [];
+    switch (configType) {
+      case "kubernetes":
+        analyzeKubernetes(content, issues, suggestions);
+        break;
+      case "docker":
+        analyzeDocker(content, issues, suggestions);
+        break;
+      case "terraform":
+        analyzeTerraform(content, issues, suggestions);
+        break;
+      case "cloudformation":
+        analyzeCloudFormation(content, issues, suggestions);
+        break;
+      case "github-actions":
+        analyzeGitHubActions(content, issues, suggestions);
+        break;
+      default:
+        return `Could not determine configuration type. Please specify the type parameter.`;
+    }
+    let result = `## Configuration Analysis (${configType})
+
+`;
+    if (issues.length > 0) {
+      result += `### \u26A0\uFE0F Issues Found
+`;
+      issues.forEach((issue, i) => {
+        result += `${i + 1}. ${issue}
+`;
+      });
+      result += "\n";
+    } else {
+      result += `### \u2705 No Critical Issues Found
+
+`;
+    }
+    if (suggestions.length > 0) {
+      result += `### \u{1F4A1} Suggestions
+`;
+      suggestions.forEach((suggestion, i) => {
+        result += `${i + 1}. ${suggestion}
+`;
+      });
+    }
+    return result;
+  }
+};
+function detectConfigType(content) {
+  if (content.includes("apiVersion:") && content.includes("kind:")) return "kubernetes";
+  if (content.includes("FROM ") || content.includes("COPY ") || content.includes("RUN ")) return "docker";
+  if (content.includes('resource "') || content.includes('provider "')) return "terraform";
+  if (content.includes("AWSTemplateFormatVersion") || content.includes("Resources:")) return "cloudformation";
+  if (content.includes("jobs:") && content.includes("runs-on:")) return "github-actions";
+  return "unknown";
+}
+function analyzeKubernetes(content, issues, suggestions) {
+  if (!content.includes("resources:") || !content.includes("limits:")) {
+    issues.push("Missing resource limits. Pods without limits can consume excessive cluster resources.");
+  }
+  if (!content.includes("securityContext:")) {
+    suggestions.push("Consider adding securityContext to restrict container privileges.");
+  }
+  if (content.includes(":latest")) {
+    issues.push("Using :latest tag. Pin specific image versions for reproducible deployments.");
+  }
+  if (!content.includes("livenessProbe:") && !content.includes("readinessProbe:")) {
+    suggestions.push("Add health probes (livenessProbe/readinessProbe) for better reliability.");
+  }
+  if (!content.includes("namespace:")) {
+    suggestions.push("Explicitly specify namespace to avoid deploying to default namespace.");
+  }
+  if (content.includes("runAsRoot: true") || content.includes("privileged: true")) {
+    issues.push("Container configured to run as root or privileged. This is a security risk.");
+  }
+}
+function analyzeDocker(content, issues, suggestions) {
+  const lines = content.split("\n");
+  const fromLine = lines.find((l) => l.trim().startsWith("FROM "));
+  if (fromLine?.includes(":latest")) {
+    issues.push("Using :latest base image. Pin a specific version for reproducible builds.");
+  }
+  const runCount = lines.filter((l) => l.trim().startsWith("RUN ")).length;
+  if (runCount > 5) {
+    suggestions.push(`${runCount} separate RUN commands. Consider combining them to reduce image layers.`);
+  }
+  if (content.includes("ADD ") && !content.includes(".tar") && !content.includes("http")) {
+    suggestions.push("Use COPY instead of ADD for simple file copying. ADD has extra features that may be unnecessary.");
+  }
+  if (content.includes("COPY . ") || content.includes("COPY ./ ")) {
+    suggestions.push("Copying entire context. Ensure .dockerignore is configured to exclude unnecessary files.");
+  }
+  if (!content.includes("USER ")) {
+    suggestions.push("No USER directive. Consider running as non-root user for security.");
+  }
+  if (!content.includes("AS ") && content.includes("npm install") || content.includes("go build")) {
+    suggestions.push("Consider multi-stage builds to reduce final image size.");
+  }
+}
+function analyzeTerraform(content, issues, suggestions) {
+  if (!content.includes("required_version") && !content.includes("required_providers")) {
+    issues.push("Missing version constraints. Pin Terraform and provider versions for reproducibility.");
+  }
+  const hardcodedPatterns = [
+    /ami-[a-z0-9]+/,
+    /subnet-[a-z0-9]+/,
+    /sg-[a-z0-9]+/,
+    /vpc-[a-z0-9]+/
+  ];
+  for (const pattern of hardcodedPatterns) {
+    if (pattern.test(content)) {
+      suggestions.push("Hardcoded AWS resource IDs detected. Consider using data sources or variables.");
+      break;
+    }
+  }
+  if (!content.includes('backend "')) {
+    suggestions.push("No remote backend configured. Use S3/GCS/Azure for team collaboration.");
+  }
+  if (content.includes("password") || content.includes("secret") || content.includes("api_key")) {
+    if (!content.includes("sensitive = true")) {
+      issues.push("Potentially sensitive variables without sensitive = true flag.");
+    }
+  }
+  if (content.includes("aws_s3_bucket") && !content.includes("server_side_encryption")) {
+    suggestions.push("S3 bucket without explicit encryption configuration.");
+  }
+}
+function analyzeCloudFormation(content, issues, suggestions) {
+  if (content.includes("AWS::RDS::") || content.includes("AWS::S3::Bucket")) {
+    if (!content.includes("DeletionPolicy")) {
+      issues.push("Stateful resources without DeletionPolicy. Data may be lost on stack deletion.");
+    }
+  }
+  if (!content.includes("UpdateReplacePolicy")) {
+    suggestions.push("Consider adding UpdateReplacePolicy for stateful resources.");
+  }
+  suggestions.push("Run `aws cloudformation detect-stack-drift` regularly to catch manual changes.");
+  if (content.includes("Parameters:") && !content.includes("AllowedValues")) {
+    suggestions.push("Consider adding AllowedValues constraints to parameters.");
+  }
+}
+function analyzeGitHubActions(content, issues, suggestions) {
+  if (content.includes("uses: ") && !content.includes("@v") && !content.includes("@sha")) {
+    issues.push("Actions without version pinning. Pin to specific versions or SHA for security.");
+  }
+  if (content.includes("${{ secrets.") && content.includes("echo ")) {
+    issues.push("Potential secret exposure in echo/print commands.");
+  }
+  if (!content.includes("permissions:")) {
+    suggestions.push("Explicitly define job permissions for better security (least privilege).");
+  }
+  if ((content.includes("npm ") || content.includes("pip ") || content.includes("go ")) && !content.includes("actions/cache")) {
+    suggestions.push("Consider adding caching to speed up workflows.");
+  }
+  if (!content.includes("timeout-minutes:")) {
+    suggestions.push("Add timeout-minutes to prevent stuck workflows from running indefinitely.");
+  }
+}
+var analyzeErrorTool = {
+  name: "analyze_error",
+  description: "Analyze error messages or logs to diagnose issues and suggest solutions.",
+  parameters: {
+    type: "object",
+    properties: {
+      error: {
+        type: "string",
+        description: "The error message or log content to analyze"
+      },
+      context: {
+        type: "string",
+        enum: ["kubernetes", "docker", "terraform", "aws", "linux", "nodejs", "python", "general"],
+        description: "Context/environment where the error occurred"
+      }
+    },
+    required: ["error"]
+  },
+  handler: async (params) => {
+    const error = params.error;
+    const context = params.context || "general";
+    const analysis = [];
+    const possibleCauses = [];
+    const solutions = [];
+    if (error.includes("permission denied") || error.includes("EACCES")) {
+      possibleCauses.push("Insufficient file system permissions");
+      solutions.push("Check file/directory permissions with `ls -la`");
+      solutions.push("Try running with appropriate user or `sudo` if necessary");
+    }
+    if (error.includes("connection refused") || error.includes("ECONNREFUSED")) {
+      possibleCauses.push("Target service is not running or not listening on expected port");
+      solutions.push("Verify the service is running: `systemctl status <service>`");
+      solutions.push("Check if the port is open: `netstat -tlnp | grep <port>`");
+    }
+    if (error.includes("out of memory") || error.includes("OOMKilled")) {
+      possibleCauses.push("Application exceeded memory limits");
+      solutions.push("Increase memory limits if possible");
+      solutions.push("Profile memory usage to find leaks");
+      solutions.push("Consider horizontal scaling");
+    }
+    if (error.includes("timeout") || error.includes("ETIMEDOUT")) {
+      possibleCauses.push("Network latency or unreachable endpoint");
+      possibleCauses.push("Slow database queries or API responses");
+      solutions.push("Check network connectivity: `ping`, `traceroute`");
+      solutions.push("Review and optimize slow queries");
+      solutions.push("Consider increasing timeout values");
+    }
+    if (context === "kubernetes") {
+      if (error.includes("CrashLoopBackOff")) {
+        possibleCauses.push("Container fails to start or crashes immediately");
+        solutions.push("Check container logs: `kubectl logs <pod> --previous`");
+        solutions.push("Verify image exists and is pullable");
+        solutions.push("Check resource limits and requests");
+      }
+      if (error.includes("ImagePullBackOff")) {
+        possibleCauses.push("Cannot pull container image");
+        solutions.push("Verify image name and tag");
+        solutions.push("Check image registry credentials (imagePullSecrets)");
+      }
+    }
+    if (context === "docker") {
+      if (error.includes("no space left on device")) {
+        possibleCauses.push("Docker disk space exhausted");
+        solutions.push("Clean up: `docker system prune -a`");
+        solutions.push("Remove unused images: `docker image prune`");
+      }
+    }
+    if (possibleCauses.length === 0) {
+      analysis.push("No specific pattern matched. Consider:");
+      analysis.push("- Searching the error message in documentation");
+      analysis.push("- Checking application logs for more context");
+      analysis.push("- Verifying configuration and environment variables");
+    }
+    let result = `## Error Analysis
+
+`;
+    result += `**Context:** ${context}
+
+`;
+    if (possibleCauses.length > 0) {
+      result += `### Possible Causes
+`;
+      possibleCauses.forEach((cause) => result += `- ${cause}
+`);
+      result += "\n";
+    }
+    if (solutions.length > 0) {
+      result += `### Suggested Solutions
+`;
+      solutions.forEach((solution, i) => result += `${i + 1}. ${solution}
+`);
+      result += "\n";
+    }
+    if (analysis.length > 0) {
+      result += `### Notes
+`;
+      analysis.forEach((note) => result += `${note}
+`);
+    }
+    return result;
+  }
+};
+var devopsTools = [
+  readFileTool,
+  listDirectoryTool,
+  analyzeConfigTool,
+  analyzeErrorTool
+];
+function getToolByName(name) {
+  return devopsTools.find((tool) => tool.name === name);
+}
+
+// src/services/copilot.service.ts
+var MCP_SERVERS = {
+  github: {
+    type: "http",
+    url: "https://api.githubcopilot.com/mcp/",
+    tools: ["*"]
+  }
+};
+var CopilotService = class {
+  constructor(sessionService) {
+    this.sessionService = sessionService;
+  }
+  client = null;
+  sessions = /* @__PURE__ */ new Map();
+  initialized = false;
+  mockMode = false;
+  async initialize() {
+    try {
+      this.client = new CopilotClient();
+      await this.client.start();
+      this.initialized = true;
+      console.log("[CopilotService] Initialized successfully");
+    } catch (error) {
+      console.error("[CopilotService] Failed to initialize:", error);
+      this.mockMode = true;
+      this.initialized = true;
+      console.warn("[CopilotService] Running in mock mode");
+    }
+  }
+  isReady() {
+    return this.initialized;
+  }
+  isMockMode() {
+    return this.mockMode;
+  }
+  async createCopilotSession(sessionId, type, model, systemPrompt, enableMcp = false) {
+    if (this.mockMode || !this.client) {
+      this.sessions.set(sessionId, {
+        sessionId,
+        session: null,
+        type
+      });
+      return;
+    }
+    const agentConfig = getAgentConfig(type);
+    const typeConfig = SESSION_TYPE_CONFIGS[type];
+    const tools = type === "devops" ? this.buildSdkTools() : void 0;
+    const mcpServers = enableMcp ? MCP_SERVERS : void 0;
+    const session = await this.client.createSession({
+      sessionId,
+      model: model || typeConfig.defaultModel,
+      streaming: true,
+      customAgents: agentConfig ? [agentConfig] : void 0,
+      systemMessage: systemPrompt ? { content: systemPrompt } : void 0,
+      tools,
+      mcpServers
+    });
+    this.sessions.set(sessionId, { sessionId, session, type });
+  }
+  /**
+   * Convert our Tool definitions to Copilot SDK Tool format.
+   * The SDK expects tools with a `handler` function — it calls the handler
+   * directly and uses the return value as the tool result (no sendToolResult needed).
+   */
+  buildSdkTools() {
+    return devopsTools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters,
+      handler: async (args) => {
+        console.log(`[CopilotService] Executing tool ${tool.name}`);
+        try {
+          return await tool.handler(args);
+        } catch (error) {
+          console.error(`[CopilotService] Tool ${tool.name} failed:`, error);
+          return `Error: ${error instanceof Error ? error.message : "Unknown error"}`;
+        }
+      }
+    }));
+  }
+  async resumeCopilotSession(sessionId) {
+    if (this.mockMode || !this.client) {
+      return true;
+    }
+    try {
+      const session = await this.client.resumeSession(sessionId);
+      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`);
+    }
+    try {
+      const dbSession = this.sessionService.getSession(sessionId);
+      if (!dbSession) {
+        console.error(`[CopilotService] Session ${sessionId} not found in database`);
+        return false;
+      }
+      await this.createCopilotSession(
+        sessionId,
+        dbSession.type,
+        dbSession.model,
+        dbSession.systemPrompt || void 0,
+        false
+        // MCP disabled by default on recreate
+      );
+      console.log(`[CopilotService] Session ${sessionId} recreated successfully`);
+      return true;
+    } catch (createError) {
+      console.error(`[CopilotService] Failed to create session ${sessionId}:`, createError);
+      return false;
+    }
+  }
+  async sendMessage(sessionId, prompt, context, onEvent) {
+    return this.withRetry(async () => {
+      const copilotSession = this.sessions.get(sessionId);
+      let fullPrompt = prompt;
+      if (context?.selectedText && !prompt.includes(context.selectedText)) {
+        fullPrompt = `Context (selected text):
+${context.selectedText}
+
+User request: ${prompt}`;
+      }
+      if (context?.pageUrl && !prompt.includes(context.pageUrl)) {
+        fullPrompt = `Page: ${context.pageUrl}
+${fullPrompt}`;
+      }
+      if (this.mockMode || !copilotSession?.session) {
+        return this.generateMockResponse(prompt, context);
+      }
+      let responseContent = "";
+      if (onEvent) {
+        copilotSession.session.on(onEvent);
+      }
+      copilotSession.session.on((event) => {
+        if (event.type === "assistant.message") {
+          responseContent = event.data.content || "";
+        }
+      });
+      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] responseContent: ${responseContent}...`);
+      return response?.data.content || responseContent;
+    }, 3, 1e3);
+  }
+  async streamMessage(sessionId, prompt, context, onEvent, attachments) {
+    let copilotSession = this.sessions.get(sessionId);
+    if (!copilotSession?.session && !this.mockMode) {
+      console.log(`[CopilotService] Session ${sessionId} not in memory, attempting auto-resume...`);
+      const resumed = await this.resumeCopilotSession(sessionId);
+      if (resumed) {
+        copilotSession = this.sessions.get(sessionId);
+        console.log(`[CopilotService] Session ${sessionId} auto-resumed successfully`);
+      } else {
+        console.warn(`[CopilotService] Failed to auto-resume session ${sessionId}, falling back to mock`);
+      }
+    }
+    let fullPrompt = prompt;
+    if (context?.selectedText && !prompt.includes(context.selectedText)) {
+      fullPrompt = `Context (selected text):
+${context.selectedText}
+
+User request: ${prompt}`;
+    }
+    if (this.mockMode || !copilotSession?.session) {
+      console.log("[CopilotService] Streaming mock response");
+      await this.streamMockResponse(prompt, context, onEvent);
+      return;
+    }
+    console.log("[CopilotService] Starting real stream for session", sessionId);
+    if (attachments && attachments.length > 0) {
+      console.log(`[CopilotService] Sending ${attachments.length} attachments:`, attachments.map((a) => a.path));
+    }
+    if (onEvent) {
+      copilotSession.session.on(onEvent);
+    }
+    copilotSession.session.send({
+      prompt: fullPrompt,
+      attachments
+    });
+    console.log("[CopilotService] Message sent, waiting for events...");
+  }
+  /**
+   * Retry logic for transient errors
+   */
+  async withRetry(operation, maxRetries = 3, delayMs = 1e3) {
+    let lastError;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        return await operation();
+      } 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))) {
+          throw lastError;
+        }
+        if (attempt < maxRetries) {
+          console.warn(`[CopilotService] Attempt ${attempt} failed, retrying in ${delayMs}ms...`);
+          await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+          delayMs *= 2;
+        }
+      }
+    }
+    throw lastError;
+  }
+  /**
+   * Get available tools for a session type
+   */
+  getAvailableTools(type) {
+    if (type === "devops") {
+      return devopsTools.map((t) => ({ name: t.name, description: t.description }));
+    }
+    return [];
+  }
+  /**
+   * Execute a tool directly (for testing or standalone use)
+   */
+  async executeTool(toolName, params) {
+    const tool = getToolByName(toolName);
+    if (!tool) {
+      return { success: false, error: `Unknown tool: ${toolName}` };
+    }
+    try {
+      const result = await tool.handler(params);
+      return { success: true, result };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async abortRequest(sessionId) {
+    const copilotSession = this.sessions.get(sessionId);
+    if (copilotSession?.session && !this.mockMode) {
+      await copilotSession.session.abort();
+    }
+  }
+  async destroySession(sessionId) {
+    const copilotSession = this.sessions.get(sessionId);
+    if (copilotSession?.session && !this.mockMode) {
+      try {
+        await copilotSession.session.abort().catch(() => {
+        });
+        await copilotSession.session.destroy();
+        console.log(`[CopilotService] Session ${sessionId} destroyed successfully`);
+      } catch (error) {
+        console.error(`[CopilotService] Error destroying session ${sessionId}:`, error);
+      }
+    }
+    if (this.client && !this.mockMode) {
+      try {
+        await this.client.deleteSession(sessionId);
+        console.log(`[CopilotService] Session ${sessionId} files deleted from disk`);
+      } catch (error) {
+        console.log(`[CopilotService] Could not delete session files (may not exist): ${sessionId}`);
+      }
+    }
+    this.sessions.delete(sessionId);
+    console.log(`[CopilotService] Session ${sessionId} removed from memory`);
+  }
+  async shutdown() {
+    for (const [sessionId, copilotSession] of this.sessions) {
+      try {
+        if (copilotSession.session && !this.mockMode) {
+          await copilotSession.session.destroy();
+        }
+      } catch (error) {
+        console.error(`[CopilotService] Failed to destroy session ${sessionId}:`, error);
+      }
+    }
+    this.sessions.clear();
+    if (this.client && !this.mockMode) {
+      try {
+        await this.client.stop();
+      } catch (error) {
+        console.error("[CopilotService] Failed to stop client:", error);
+      }
+    }
+    this.initialized = false;
+  }
+  // Mock implementations for development without Copilot CLI
+  generateMockResponse(prompt, context) {
+    const action = context?.action;
+    if (action === "explain") {
+      return `**Explanation:**
+
+This appears to be ${context?.selectedText?.slice(0, 50)}...
+
+In essence, this code/text demonstrates a common pattern used in software development. The key points are:
+
+1. It handles a specific use case
+2. It follows best practices
+3. It can be extended for additional functionality`;
+    }
+    if (action === "translate") {
+      return `**Translation:**
+
+${context?.selectedText || "No text provided"}`;
+    }
+    if (action === "rewrite") {
+      return `**Rewritten:**
+
+${context?.selectedText || prompt}`;
+    }
+    if (action === "fix_grammar") {
+      return `**Corrected:**
+
+${context?.selectedText || prompt}`;
+    }
+    return `**Mock Response:**
+
+I understand you're asking about: "${prompt.slice(0, 100)}..."
+
+This is a mock response because the Copilot SDK is not available. In production, you would receive intelligent responses powered by GitHub Copilot.
+
+To enable real responses:
+1. Install GitHub Copilot CLI
+2. Authenticate with your GitHub account
+3. Restart the DevMentorAI backend`;
+  }
+  async streamMockResponse(prompt, context, onEvent) {
+    const response = this.generateMockResponse(prompt, context);
+    const words = response.split(" ");
+    for (let i = 0; i < words.length; i++) {
+      await new Promise((resolve2) => setTimeout(resolve2, 50));
+      onEvent?.({
+        type: "assistant.message_delta",
+        data: { deltaContent: words[i] + (i < words.length - 1 ? " " : "") }
+      });
+    }
+    onEvent?.({
+      type: "assistant.message",
+      data: { content: response }
+    });
+    onEvent?.({
+      type: "session.idle",
+      data: {}
+    });
+  }
+};
+
+// src/services/session.service.ts
+var SessionService = class {
+  constructor(db) {
+    this.db = db;
+  }
+  // Sessions
+  listSessions(page = 1, pageSize = 50) {
+    const offset = (page - 1) * pageSize;
+    const countStmt = this.db.prepare("SELECT COUNT(*) as count FROM sessions");
+    const count = countStmt.get().count;
+    const stmt = this.db.prepare(`
+      SELECT * FROM sessions 
+      ORDER BY updated_at DESC 
+      LIMIT ? OFFSET ?
+    `);
+    const rows = stmt.all(pageSize, offset);
+    return {
+      items: rows.map(this.mapDbSession),
+      total: count,
+      page,
+      pageSize,
+      hasMore: offset + rows.length < count
+    };
+  }
+  getSession(id) {
+    const stmt = this.db.prepare("SELECT * FROM sessions WHERE id = ?");
+    const row = stmt.get(id);
+    return row ? this.mapDbSession(row) : null;
+  }
+  createSession(request) {
+    const id = generateSessionId();
+    const now = formatDate();
+    const agentConfig = getAgentConfig(request.type);
+    const model = request.model || getDefaultModel(request.type);
+    const stmt = this.db.prepare(`
+      INSERT INTO sessions (id, name, type, model, system_prompt, custom_agent, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      id,
+      request.name,
+      request.type,
+      model,
+      request.systemPrompt || agentConfig?.prompt || null,
+      agentConfig?.name || null,
+      now,
+      now
+    );
+    return this.getSession(id);
+  }
+  updateSession(id, request) {
+    const session = this.getSession(id);
+    if (!session) return null;
+    const updates = [];
+    const values = [];
+    if (request.name !== void 0) {
+      updates.push("name = ?");
+      values.push(request.name);
+    }
+    if (request.status !== void 0) {
+      updates.push("status = ?");
+      values.push(request.status);
+    }
+    if (updates.length === 0) return session;
+    updates.push("updated_at = ?");
+    values.push(formatDate());
+    values.push(id);
+    const stmt = this.db.prepare(`
+      UPDATE sessions SET ${updates.join(", ")} WHERE id = ?
+    `);
+    stmt.run(...values);
+    return this.getSession(id);
+  }
+  deleteSession(id) {
+    const stmt = this.db.prepare("DELETE FROM sessions WHERE id = ?");
+    const result = stmt.run(id);
+    return result.changes > 0;
+  }
+  incrementMessageCount(sessionId) {
+    const stmt = this.db.prepare(`
+      UPDATE sessions 
+      SET message_count = message_count + 1, updated_at = ?
+      WHERE id = ?
+    `);
+    stmt.run(formatDate(), sessionId);
+  }
+  // Messages
+  listMessages(sessionId, page = 1, pageSize = 100) {
+    const offset = (page - 1) * pageSize;
+    const countStmt = this.db.prepare("SELECT COUNT(*) as count FROM messages WHERE session_id = ?");
+    const count = countStmt.get(sessionId).count;
+    const stmt = this.db.prepare(`
+      SELECT * FROM messages 
+      WHERE session_id = ?
+      ORDER BY timestamp ASC
+      LIMIT ? OFFSET ?
+    `);
+    const rows = stmt.all(sessionId, pageSize, offset);
+    return {
+      items: rows.map((row) => this.mapDbMessage(row)),
+      total: count,
+      page,
+      pageSize,
+      hasMore: offset + rows.length < count
+    };
+  }
+  addMessage(sessionId, role, content, metadata) {
+    const id = generateMessageId();
+    const timestamp = formatDate();
+    const stmt = this.db.prepare(`
+      INSERT INTO messages (id, session_id, role, content, timestamp, metadata)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      id,
+      sessionId,
+      role,
+      content,
+      timestamp,
+      metadata ? JSON.stringify(metadata) : null
+    );
+    this.incrementMessageCount(sessionId);
+    return {
+      id,
+      sessionId,
+      role,
+      content,
+      timestamp,
+      metadata
+    };
+  }
+  updateMessageContent(messageId, content) {
+    const stmt = this.db.prepare("UPDATE messages SET content = ? WHERE id = ?");
+    stmt.run(content, messageId);
+  }
+  updateMessageMetadata(messageId, metadata) {
+    const stmt = this.db.prepare("UPDATE messages SET metadata = ? WHERE id = ?");
+    stmt.run(JSON.stringify(metadata), messageId);
+  }
+  // ============================================================================
+  // Context Persistence (Phase 5)
+  // ============================================================================
+  /**
+   * 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 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)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(id, sessionId, messageId || null, contextJson, pageUrl || null, pageTitle || null, platform || null, now);
+    return id;
+  }
+  /**
+   * Get the most recent context for a session
+   */
+  getLatestContext(sessionId) {
+    const stmt = this.db.prepare(`
+      SELECT id, context_json, page_url, platform, extracted_at
+      FROM session_contexts
+      WHERE session_id = ?
+      ORDER BY extracted_at DESC
+      LIMIT 1
+    `);
+    const row = stmt.get(sessionId);
+    if (!row) return null;
+    return {
+      id: row.id,
+      contextJson: row.context_json,
+      pageUrl: row.page_url || void 0,
+      platform: row.platform || void 0,
+      extractedAt: row.extracted_at
+    };
+  }
+  /**
+   * Get context history for a session
+   */
+  getContextHistory(sessionId, limit = 10) {
+    const stmt = this.db.prepare(`
+      SELECT id, message_id, page_url, page_title, platform, extracted_at
+      FROM session_contexts
+      WHERE session_id = ?
+      ORDER BY extracted_at DESC
+      LIMIT ?
+    `);
+    const rows = stmt.all(sessionId, limit);
+    return rows.map((row) => ({
+      id: row.id,
+      messageId: row.message_id || void 0,
+      pageUrl: row.page_url || void 0,
+      pageTitle: row.page_title || void 0,
+      platform: row.platform || void 0,
+      extractedAt: row.extracted_at
+    }));
+  }
+  /**
+   * Get a specific context by ID
+   */
+  getContext(contextId) {
+    const stmt = this.db.prepare(`
+      SELECT id, session_id, context_json, extracted_at
+      FROM session_contexts
+      WHERE id = ?
+    `);
+    const row = stmt.get(contextId);
+    if (!row) return null;
+    return {
+      id: row.id,
+      sessionId: row.session_id,
+      contextJson: row.context_json,
+      extractedAt: row.extracted_at
+    };
+  }
+  /**
+   * Clean up old contexts for a session (keep only last N)
+   */
+  cleanupOldContexts(sessionId, keepCount = 20) {
+    const keepStmt = this.db.prepare(`
+      SELECT id FROM session_contexts
+      WHERE session_id = ?
+      ORDER BY extracted_at DESC
+      LIMIT ?
+    `);
+    const idsToKeep = keepStmt.all(sessionId, keepCount).map((r) => r.id);
+    if (idsToKeep.length === 0) return 0;
+    const deleteStmt = this.db.prepare(`
+      DELETE FROM session_contexts
+      WHERE session_id = ?
+      AND id NOT IN (${idsToKeep.map(() => "?").join(",")})
+    `);
+    const result = deleteStmt.run(sessionId, ...idsToKeep);
+    return result.changes;
+  }
+  /**
+   * Get context count for a session
+   */
+  getContextCount(sessionId) {
+    const stmt = this.db.prepare("SELECT COUNT(*) as count FROM session_contexts WHERE session_id = ?");
+    const result = stmt.get(sessionId);
+    return result.count;
+  }
+  mapDbSession(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      type: row.type,
+      status: row.status,
+      model: row.model,
+      systemPrompt: row.system_prompt || void 0,
+      customAgent: row.custom_agent || void 0,
+      messageCount: row.message_count,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  mapDbMessage(row) {
+    let metadata = row.metadata ? JSON.parse(row.metadata) : void 0;
+    if (metadata?.images) {
+      metadata.images = metadata.images.map((img) => ({
+        ...img,
+        thumbnailUrl: this.fixImageUrl(img.thumbnailUrl),
+        fullImageUrl: this.fixImageUrl(img.fullImageUrl)
+      }));
+    }
+    return {
+      id: row.id,
+      sessionId: row.session_id,
+      role: row.role,
+      content: row.content,
+      timestamp: row.timestamp,
+      metadata
+    };
+  }
+  /**
+   * Fix legacy image URLs that have incorrect format
+   * - Adds missing port (localhost -> localhost:3847)
+   * - Removes duplicate "images/images/" path
+   */
+  fixImageUrl(url) {
+    if (!url) return url;
+    let fixed = url;
+    if (fixed.includes("http://localhost/api")) {
+      fixed = fixed.replace("http://localhost/api", "http://localhost:3847/api");
+    }
+    if (fixed.includes("/api/images/images/")) {
+      fixed = fixed.replace("/api/images/images/", "/api/images/");
+    }
+    return fixed;
+  }
+};
+
+// src/db/index.ts
+import Database from "better-sqlite3";
+import path4 from "path";
+import os from "os";
+import fs4 from "fs";
+var DB_DIR = path4.join(os.homedir(), ".devmentorai");
+var DB_PATH = path4.join(DB_DIR, "devmentorai.db");
+console.log(`Database path: ${DB_PATH}`);
+function initDatabase() {
+  if (!fs4.existsSync(DB_DIR)) {
+    fs4.mkdirSync(DB_DIR, { recursive: true });
+  }
+  const db = new Database(DB_PATH);
+  db.pragma("journal_mode = WAL");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      type TEXT NOT NULL CHECK (type IN ('devops', 'writing', 'development', 'general')),
+      status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'paused', 'closed')),
+      model TEXT NOT NULL DEFAULT 'gpt-4.1',
+      system_prompt TEXT,
+      custom_agent TEXT,
+      message_count INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS messages (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      role TEXT NOT NULL CHECK (role IN ('user', 'assistant', 'system')),
+      content TEXT NOT NULL,
+      timestamp TEXT NOT NULL DEFAULT (datetime('now')),
+      metadata TEXT,
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+    );
+
+    -- New table for session context persistence (Phase 5)
+    CREATE TABLE IF NOT EXISTS session_contexts (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      message_id TEXT,
+      context_json TEXT NOT NULL,
+      page_url TEXT,
+      page_title TEXT,
+      platform TEXT,
+      extracted_at TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE,
+      FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE SET NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_messages_session_id ON messages(session_id);
+    CREATE INDEX IF NOT EXISTS idx_messages_timestamp ON messages(timestamp);
+    CREATE INDEX IF NOT EXISTS idx_session_contexts_session_id ON session_contexts(session_id);
+    CREATE INDEX IF NOT EXISTS idx_session_contexts_extracted_at ON session_contexts(extracted_at);
+  `);
+  return db;
+}
+
+// src/server.ts
+var PORT = 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) {
+  if (!str) return "";
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen) + `... [truncated ${str.length - maxLen} chars]`;
+}
+async function createServer() {
+  const fastify = Fastify({
+    logger: {
+      level: DEBUG_MODE ? "debug" : "info",
+      transport: {
+        target: "pino-pretty",
+        options: {
+          colorize: true,
+          translateTime: "HH:MM:ss Z",
+          ignore: "pid,hostname"
+        }
+      }
+    }
+  });
+  if (DEBUG_MODE) {
+    fastify.log.info("\u{1F50D} Debug mode enabled - logging all requests and responses");
+    fastify.addHook("preHandler", async (request) => {
+      const body = request.body ? truncate(JSON.stringify(request.body)) : null;
+      fastify.log.debug({
+        type: "\u2192 REQUEST",
+        method: request.method,
+        url: request.url,
+        headers: {
+          "content-type": request.headers["content-type"],
+          "user-agent": request.headers["user-agent"]
+        },
+        body
+      });
+    });
+    fastify.addHook("onSend", async (request, reply, payload) => {
+      const statusCode = reply.statusCode;
+      let responseBody = null;
+      if (reply.getHeader("content-type") === "text/event-stream") {
+        responseBody = "[SSE Stream]";
+      } else if (typeof payload === "string") {
+        responseBody = truncate(payload);
+      } else if (Buffer.isBuffer(payload)) {
+        responseBody = truncate(payload.toString());
+      }
+      fastify.log.debug({
+        type: "\u2190 RESPONSE",
+        method: request.method,
+        url: request.url,
+        statusCode,
+        body: responseBody
+      });
+      return payload;
+    });
+    fastify.addHook("onError", async (request, reply, error) => {
+      fastify.log.error({
+        type: "\u2717 ERROR",
+        method: request.method,
+        url: request.url,
+        error: error.message,
+        stack: error.stack
+      });
+    });
+  }
+  const db = initDatabase();
+  fastify.log.info("Database initialized");
+  const sessionService = new SessionService(db);
+  const copilotService = new CopilotService(sessionService);
+  try {
+    await copilotService.initialize();
+    fastify.log.info("CopilotService initialized");
+  } catch (err) {
+    fastify.log.error({ err }, "Failed to initialize CopilotService");
+    fastify.log.warn("Running in mock mode - Copilot features will be simulated");
+  }
+  fastify.decorate("sessionService", sessionService);
+  fastify.decorate("copilotService", copilotService);
+  await fastify.register(cors, {
+    origin: true,
+    // Allow all origins in development
+    methods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
+    allowedHeaders: ["Content-Type", "Authorization"]
+  });
+  await fastify.register(healthRoutes, { prefix: "/api" });
+  await fastify.register(sessionRoutes, { prefix: "/api" });
+  await fastify.register(chatRoutes, { prefix: "/api" });
+  await fastify.register(modelsRoutes, { prefix: "/api" });
+  await fastify.register(imagesRoutes, { prefix: "/api/images" });
+  registerToolsRoutes(fastify, copilotService);
+  return fastify;
+}
+async function main() {
+  const fastify = await createServer();
+  const shutdown = async () => {
+    fastify.log.info("Shutting down...");
+    try {
+      await fastify.copilotService.shutdown();
+      await fastify.close();
+      process.exit(0);
+    } catch (err) {
+      fastify.log.error({ err }, "Error during shutdown");
+      process.exit(1);
+    }
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  try {
+    await fastify.listen({ port: PORT, host: HOST });
+    fastify.log.info(`\u{1F680} DevMentorAI backend running at http://${HOST}:${PORT}`);
+  } catch (error) {
+    fastify.log.error(error);
+    process.exit(1);
+  }
+}
+main();
+export {
+  createServer
+};
+//# sourceMappingURL=server.js.map