Create Upload Chat Session help feature (#48)

src/ipc/handlers/debug_handlers.ts

 import { ipcMain, app } from "electron";
 import { platform, arch } from "os";
-import { SystemDebugInfo } from "../ipc_types";
+import { SystemDebugInfo, ChatLogsData } from "../ipc_types";
 import { readSettings } from "../../main/settings";
 import { execSync } from "child_process";
 import log from "electron-log";
 import path from "path";
 import fs from "fs";
 import { runShellCommand } from "../utils/runShellCommand";
+import { extractCodebase } from "../../utils/codebase";
+import { db } from "../../db";
+import { chats, apps } from "../../db/schema";
+import { eq } from "drizzle-orm";
+import { getDyadAppPath } from "../../paths/paths";
 
-export function registerDebugHandlers() {
-  ipcMain.handle(
-    "get-system-debug-info",
-    async (): Promise<SystemDebugInfo> => {
-      console.log("IPC: get-system-debug-info called");
+// Shared function to get system debug info
+async function getSystemDebugInfo(): Promise<SystemDebugInfo> {
+  console.log("Getting system debug info");
 
   // Get Node.js and pnpm versions
   let nodeVersion: string | null = null;
@@ -41,17 +44,10 @@ export function registerDebugHandlers() {
   }
 
   // Get Dyad version from package.json
-      const packageJsonPath = path.resolve(
-        __dirname,
-        "..",
-        "..",
-        "package.json"
-      );
+  const packageJsonPath = path.resolve(__dirname, "..", "..", "package.json");
   let dyadVersion = "unknown";
   try {
-        const packageJson = JSON.parse(
-          fs.readFileSync(packageJsonPath, "utf8")
-        );
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
     dyadVersion = packageJson.version;
   } catch (err) {
     console.error("Failed to read package.json:", err);
@@ -87,6 +83,74 @@ export function registerDebugHandlers() {
     architecture: arch(),
     logs,
   };
+}
+
+export function registerDebugHandlers() {
+  ipcMain.handle(
+    "get-system-debug-info",
+    async (): Promise<SystemDebugInfo> => {
+      console.log("IPC: get-system-debug-info called");
+      return getSystemDebugInfo();
+    }
+  );
+
+  ipcMain.handle(
+    "get-chat-logs",
+    async (_, chatId: number): Promise<ChatLogsData> => {
+      console.log(`IPC: get-chat-logs called for chat ${chatId}`);
+
+      try {
+        // Get system debug info using the shared function
+        const debugInfo = await getSystemDebugInfo();
+
+        // Get chat data from database
+        const chatRecord = await db.query.chats.findFirst({
+          where: eq(chats.id, chatId),
+          with: {
+            messages: {
+              orderBy: (messages, { asc }) => [asc(messages.createdAt)],
+            },
+          },
+        });
+
+        if (!chatRecord) {
+          throw new Error(`Chat with ID ${chatId} not found`);
+        }
+
+        // Format the chat to match the Chat interface
+        const chat = {
+          id: chatRecord.id,
+          title: chatRecord.title || "Untitled Chat",
+          messages: chatRecord.messages.map((msg) => ({
+            id: msg.id,
+            role: msg.role,
+            content: msg.content,
+            approvalState: msg.approvalState,
+          })),
+        };
+
+        // Get app data from database
+        const app = await db.query.apps.findFirst({
+          where: eq(apps.id, chatRecord.appId),
+        });
+
+        if (!app) {
+          throw new Error(`App with ID ${chatRecord.appId} not found`);
+        }
+
+        // Extract codebase
+        const appPath = getDyadAppPath(app.path);
+        const codebase = await extractCodebase(appPath);
+
+        return {
+          debugInfo,
+          chat,
+          codebase,
+        };
+      } catch (error) {
+        console.error(`Error in get-chat-logs:`, error);
+        throw error;
+      }
     }
   );
 

src/ipc/handlers/upload_handlers.ts

+import { ipcMain } from "electron";
+import log from "electron-log";
+import fetch from "node-fetch";
+
+const logger = log.scope("upload_handlers");
+
+interface UploadToSignedUrlParams {
+  url: string;
+  contentType: string;
+  data: any;
+}
+
+export function registerUploadHandlers() {
+  ipcMain.handle(
+    "upload-to-signed-url",
+    async (_, params: UploadToSignedUrlParams) => {
+      const { url, contentType, data } = params;
+      logger.debug("IPC: upload-to-signed-url called");
+
+      try {
+        // Validate the signed URL
+        if (!url || typeof url !== "string" || !url.startsWith("https://")) {
+          throw new Error("Invalid signed URL provided");
+        }
+
+        // Validate content type
+        if (!contentType || typeof contentType !== "string") {
+          throw new Error("Invalid content type provided");
+        }
+
+        // Perform the upload to the signed URL
+        const response = await fetch(url, {
+          method: "PUT",
+          headers: {
+            "Content-Type": contentType,
+          },
+          body: JSON.stringify(data),
+        });
+
+        if (!response.ok) {
+          throw new Error(
+            `Upload failed with status ${response.status}: ${response.statusText}`
+          );
+        }
+
+        logger.debug("Successfully uploaded data to signed URL");
+        return { success: true };
+      } catch (error) {
+        logger.error("Failed to upload to signed URL:", error);
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+        };
+      }
+    }
+  );
+
+  logger.debug("Registered upload IPC handlers");
+}

src/ipc/ipc_client.ts

@@ -21,6 +21,7 @@ import type {
   LocalModelListResponse,
   TokenCountParams,
   TokenCountResult,
+  ChatLogsData,
 } from "./ipc_types";
 import type { CodeProposal, ProposalResult } from "@/lib/schemas";
 import { showError } from "@/lib/toast";
@@ -749,7 +750,35 @@ export class IpcClient {
   public async getSystemDebugInfo(): Promise<SystemDebugInfo> {
     try {
       const data = await this.ipcRenderer.invoke("get-system-debug-info");
-      return data;
+      return data as SystemDebugInfo;
+    } catch (error) {
+      showError(error);
+      throw error;
+    }
+  }
+
+  public async getChatLogs(chatId: number): Promise<ChatLogsData> {
+    try {
+      const data = await this.ipcRenderer.invoke("get-chat-logs", chatId);
+      return data as ChatLogsData;
+    } catch (error) {
+      showError(error);
+      throw error;
+    }
+  }
+
+  public async uploadToSignedUrl(
+    url: string,
+    contentType: string,
+    data: any
+  ): Promise<{ success: boolean; error?: string }> {
+    try {
+      const result = await this.ipcRenderer.invoke("upload-to-signed-url", {
+        url,
+        contentType,
+        data,
+      });
+      return result as { success: boolean; error?: string };
     } catch (error) {
       showError(error);
       throw error;

src/ipc/ipc_host.ts

@@ -12,6 +12,7 @@ import { registerSupabaseHandlers } from "./handlers/supabase_handlers";
 import { registerLocalModelHandlers } from "./handlers/local_model_handlers";
 import { registerTokenCountHandlers } from "./handlers/token_count_handlers";
 import { registerWindowHandlers } from "./handlers/window_handlers";
+import { registerUploadHandlers } from "./handlers/upload_handlers";
 
 export function registerIpcHandlers() {
   // Register all IPC handlers by category
@@ -29,4 +30,5 @@ export function registerIpcHandlers() {
   registerLocalModelHandlers();
   registerTokenCountHandlers();
   registerWindowHandlers();
+  registerUploadHandlers();
 }

src/ipc/ipc_types.ts

@@ -106,6 +106,7 @@ export interface TokenCountParams {
   chatId: number;
   input: string;
 }
+
 export interface TokenCountResult {
   totalTokens: number;
   messageHistoryTokens: number;
@@ -114,3 +115,9 @@ export interface TokenCountResult {
   systemPromptTokens: number;
   contextWindow: number;
 }
+
+export interface ChatLogsData {
+  debugInfo: SystemDebugInfo;
+  chat: Chat;
+  codebase: string;
+}

src/preload.ts

@@ -14,6 +14,7 @@ const validInvokeChannels = [
   "create-app",
   "get-chat",
   "get-chats",
+  "get-chat-logs",
   "list-apps",
   "get-app",
   "edit-app-file",
@@ -53,6 +54,7 @@ const validInvokeChannels = [
   "window:maximize",
   "window:close",
   "window:get-platform",
+  "upload-to-signed-url",
 ] as const;
 
 // Add valid receive channels