claude-space 2.0.0

package/out/main/index.js

@@ -0,0 +1,3830 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+const electron = require("electron");
+const path = require("path");
+const fs = require("fs");
+const url = require("url");
+const utils = require("@electron-toolkit/utils");
+const yaml = require("js-yaml");
+const crypto = require("crypto");
+const uuid = require("uuid");
+const child_process = require("child_process");
+const icon = path.join(__dirname, "../../resources/icon.png");
+class AuthSettingsManager {
+  settingsPath;
+  settings = null;
+  constructor() {
+    this.settingsPath = path.join(electron.app.getPath("userData"), "auth-settings.json");
+  }
+  async loadSettings() {
+    if (this.settings) {
+      return this.settings;
+    }
+    try {
+      const content = await fs.promises.readFile(this.settingsPath, "utf-8");
+      this.settings = JSON.parse(content);
+      return this.settings;
+    } catch {
+      this.settings = {
+        preferredMethod: "cli",
+        autoFallback: true
+      };
+      return this.settings;
+    }
+  }
+  async saveSettings(settings) {
+    this.settings = settings;
+    await fs.promises.writeFile(this.settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+  }
+  async getPreferredMethod(projectPath) {
+    const settings = await this.loadSettings();
+    if (projectPath && settings.projectOverrides?.[projectPath]) {
+      return settings.projectOverrides[projectPath].preferredMethod;
+    }
+    return settings.preferredMethod;
+  }
+  async setPreferredMethod(method, projectPath) {
+    const settings = await this.loadSettings();
+    if (projectPath) {
+      if (!settings.projectOverrides) {
+        settings.projectOverrides = {};
+      }
+      settings.projectOverrides[projectPath] = { preferredMethod: method };
+    } else {
+      settings.preferredMethod = method;
+    }
+    await this.saveSettings(settings);
+  }
+  async getAutoFallback() {
+    const settings = await this.loadSettings();
+    return settings.autoFallback;
+  }
+  async setAutoFallback(enabled) {
+    const settings = await this.loadSettings();
+    settings.autoFallback = enabled;
+    await this.saveSettings(settings);
+  }
+  async getCustomCliCommand() {
+    const settings = await this.loadSettings();
+    const command = settings.customCliCommand;
+    return command && command.trim() ? command.trim() : null;
+  }
+  async setCustomCliCommand(command) {
+    const settings = await this.loadSettings();
+    settings.customCliCommand = command.trim();
+    await this.saveSettings(settings);
+  }
+  async clearCustomCliCommand() {
+    const settings = await this.loadSettings();
+    delete settings.customCliCommand;
+    await this.saveSettings(settings);
+  }
+}
+const authSettingsManager = new AuthSettingsManager();
+class AgentManager {
+  sessions = /* @__PURE__ */ new Map();
+  sdkModule = null;
+  /**
+   * Load the Claude SDK dynamically (ES module)
+   */
+  async loadSDK() {
+    if (!this.sdkModule) {
+      this.sdkModule = await import("@anthropic-ai/claude-agent-sdk");
+    }
+    return this.sdkModule;
+  }
+  /**
+   * Create a new agent session
+   * Returns a session ID for future message sending
+   */
+  async createSession(config) {
+    const sessionId = crypto.randomUUID();
+    const abortController = new AbortController();
+    this.sessions.set(sessionId, {
+      config,
+      abortController,
+      isActive: true,
+      sdkSessionId: config.sdkSessionId,
+      // Use provided SDK session ID if available
+      pendingApprovals: /* @__PURE__ */ new Map()
+      // Initialize empty approval map
+    });
+    return sessionId;
+  }
+  /**
+   * Send a message and stream the response
+   * Calls onChunk for each piece of content
+   */
+  async sendMessage(sessionId, message, onChunk) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    if (!session.isActive) {
+      throw new Error(`Session ${sessionId} is not active`);
+    }
+    try {
+      const sdk = await this.loadSDK();
+      const { query } = sdk;
+      const originalCwd = process.cwd();
+      let agentPath = session.config.projectPath;
+      if (session.config.agentFolderName) {
+        const candidate = `${session.config.projectPath}/${session.config.agentFolderName}`;
+        if (fs.existsSync(candidate)) {
+          agentPath = candidate;
+        }
+      }
+      process.chdir(agentPath);
+      let mcpServers;
+      const mcpConfigPath = path.join(session.config.projectPath, ".mcp.json");
+      console.log("[MCP] Looking for .mcp.json at:", mcpConfigPath);
+      if (fs.existsSync(mcpConfigPath)) {
+        try {
+          const mcpConfig = JSON.parse(fs.readFileSync(mcpConfigPath, "utf-8"));
+          if (mcpConfig.mcpServers) {
+            mcpServers = mcpConfig.mcpServers;
+            console.log("[MCP] Loaded MCP servers:", Object.keys(mcpServers || {}));
+          }
+        } catch (err) {
+          console.error("[MCP] Failed to load .mcp.json:", err);
+        }
+      } else {
+        console.log("[MCP] No .mcp.json found");
+      }
+      const customCliCommand = await authSettingsManager.getCustomCliCommand();
+      const queryOptions = {
+        // Only include apiKey if authMethod is 'apikey' and key is provided
+        // When omitted, SDK will use CLI authentication automatically
+        ...session.config.authMethod === "apikey" && session.config.apiKey ? { apiKey: session.config.apiKey } : {},
+        settingSources: ["project", "local"],
+        // Load settings.json (skills) and settings.local.json
+        systemPrompt: { type: "preset", preset: "claude_code" },
+        // Load CLAUDE.md
+        abortController: session.abortController,
+        permissionMode: session.config.permissionMode || "default",
+        // Use configured mode or default
+        ...mcpServers ? { mcpServers } : {},
+        // Include MCP servers if loaded
+        // Use custom CLI command if set, otherwise use default CLI path
+        ...customCliCommand ? {
+          pathToClaudeCodeExecutable: customCliCommand
+        } : electron.app.isPackaged ? {
+          // In production builds, explicitly point to the unpacked CLI
+          pathToClaudeCodeExecutable: path.join(
+            process.resourcesPath,
+            "app.asar.unpacked",
+            "node_modules",
+            "@anthropic-ai",
+            "claude-agent-sdk",
+            "cli.js"
+          )
+        } : {},
+        // Custom permission handler for human-in-the-loop approval
+        canUseTool: async (toolName, input, options) => {
+          console.log("🔐 [APPROVAL] canUseTool called for:", toolName);
+          console.log("🔐 [APPROVAL] Tool input:", JSON.stringify(input, null, 2));
+          console.log("🔐 [APPROVAL] Options:", options);
+          const requestId = crypto.randomUUID();
+          console.log("🔐 [APPROVAL] Generated requestId:", requestId);
+          const approvalPromise = new Promise((resolve, reject) => {
+            session.pendingApprovals.set(requestId, { requestId, resolve, reject });
+            console.log("🔐 [APPROVAL] Added to pending approvals, count:", session.pendingApprovals.size);
+          });
+          console.log("🔐 [APPROVAL] Sending approval request to frontend...");
+          onChunk({
+            type: "approval_request",
+            approvalRequest: {
+              requestId,
+              toolName,
+              parameters: input
+            }
+          });
+          console.log("🔐 [APPROVAL] Chunk sent, waiting for user response...");
+          const approved = await approvalPromise;
+          console.log("🔐 [APPROVAL] User response received:", approved ? "APPROVED" : "DENIED");
+          if (approved) {
+            console.log("🔐 [APPROVAL] Returning allow result");
+            const result2 = {
+              behavior: "allow",
+              updatedInput: input,
+              toolUseID: options.toolUseID
+            };
+            return result2;
+          } else {
+            console.log("🔐 [APPROVAL] Returning deny result");
+            const result2 = {
+              behavior: "deny",
+              message: "User denied tool execution",
+              interrupt: true,
+              toolUseID: options.toolUseID
+            };
+            return result2;
+          }
+        }
+      };
+      if (session.sdkSessionId) {
+        queryOptions.resume = session.sdkSessionId;
+      }
+      const result = query({
+        prompt: message,
+        options: queryOptions
+      });
+      for await (const msg of result) {
+        if (!session.isActive) {
+          break;
+        }
+        if (msg.type === "system" && msg.subtype === "init" && msg.session_id && !session.sdkSessionId) {
+          session.sdkSessionId = msg.session_id;
+          onChunk({
+            type: "session_id",
+            sdkSessionId: msg.session_id
+          });
+        }
+        switch (msg.type) {
+          case "assistant":
+            if (msg.message?.content) {
+              const content = Array.isArray(msg.message.content) ? msg.message.content : [msg.message.content];
+              let fullText = "";
+              for (const block of content) {
+                if (typeof block === "string") {
+                  onChunk({ type: "content", content: block });
+                  fullText += block;
+                } else if (block.type === "text") {
+                  onChunk({ type: "content", content: block.text });
+                  fullText += block.text;
+                } else if (block.type === "tool_use") {
+                  onChunk({
+                    type: "tool_use",
+                    tool: block.name,
+                    content: JSON.stringify(block.input, null, 2)
+                  });
+                  onChunk({
+                    type: "step",
+                    step: {
+                      type: "tool_call",
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                      title: `Tool: ${block.name}`,
+                      tool: block.name,
+                      input: block.input,
+                      status: "running"
+                    }
+                  });
+                }
+              }
+              if (fullText) {
+                onChunk({
+                  type: "step",
+                  step: {
+                    type: "llm_call",
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                    title: "LLM Call",
+                    messages: [{ role: "user", content: message }],
+                    response: fullText,
+                    duration: 0
+                  }
+                });
+              }
+            }
+            break;
+          case "result":
+            if (msg.subtype === "success") {
+              onChunk({
+                type: "step",
+                step: {
+                  type: "end",
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                  title: "End",
+                  totalCost: msg.total_cost_usd || 0,
+                  totalTokens: (msg.usage?.input_tokens || 0) + (msg.usage?.output_tokens || 0)
+                }
+              });
+              onChunk({
+                type: "metadata",
+                metadata: {
+                  cost: msg.total_cost_usd || 0,
+                  tokens: {
+                    input: msg.usage?.input_tokens || 0,
+                    output: msg.usage?.output_tokens || 0,
+                    total: (msg.usage?.input_tokens || 0) + (msg.usage?.output_tokens || 0)
+                  }
+                }
+              });
+            } else if (msg.subtype === "error") {
+              onChunk({
+                type: "error",
+                error: msg.error?.message || "Unknown error occurred"
+              });
+            }
+            break;
+          case "user":
+            break;
+          default:
+            console.log("Unhandled message type:", msg.type);
+        }
+      }
+      process.chdir(originalCwd);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      onChunk({
+        type: "error",
+        error: errorMessage
+      });
+    }
+  }
+  /**
+   * Update session configuration (e.g. permission mode)
+   */
+  updateSessionConfig(sessionId, updates) {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.config = { ...session.config, ...updates };
+    }
+  }
+  /**
+   * Stop an active session
+   */
+  stopSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.isActive = false;
+      session.abortController.abort();
+      this.sessions.delete(sessionId);
+    }
+  }
+  /**
+   * Stop all sessions
+   */
+  stopAllSessions() {
+    for (const [sessionId] of this.sessions) {
+      this.stopSession(sessionId);
+    }
+  }
+  /**
+   * Check if a session exists and is active
+   */
+  isSessionActive(sessionId) {
+    const session = this.sessions.get(sessionId);
+    return session?.isActive ?? false;
+  }
+  /**
+   * Get active session count
+   */
+  getActiveSessionCount() {
+    return Array.from(this.sessions.values()).filter((s) => s.isActive).length;
+  }
+  /**
+   * Respond to a pending approval request
+   */
+  respondToApproval(sessionId, requestId, approved) {
+    console.log("🔐 [APPROVAL] respondToApproval called:", { sessionId, requestId, approved });
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      console.error("🔐 [APPROVAL] Session not found:", sessionId);
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    console.log("🔐 [APPROVAL] Pending approvals count:", session.pendingApprovals.size);
+    console.log("🔐 [APPROVAL] Pending approval IDs:", Array.from(session.pendingApprovals.keys()));
+    const pendingApproval = session.pendingApprovals.get(requestId);
+    if (!pendingApproval) {
+      console.error("🔐 [APPROVAL] Request ID not found:", requestId);
+      throw new Error(`Approval request ${requestId} not found`);
+    }
+    console.log("🔐 [APPROVAL] Resolving approval promise with:", approved);
+    pendingApproval.resolve(approved);
+    session.pendingApprovals.delete(requestId);
+    console.log("🔐 [APPROVAL] Cleanup complete, remaining count:", session.pendingApprovals.size);
+  }
+}
+const agentManager = new AgentManager();
+class KeyManager {
+  keysPath;
+  keyStore = null;
+  constructor() {
+    this.keysPath = path.join(electron.app.getPath("userData"), "keys.json");
+  }
+  /**
+   * Load the key store from disk
+   */
+  async loadKeyStore() {
+    if (this.keyStore) {
+      return this.keyStore;
+    }
+    try {
+      const content = await fs.promises.readFile(this.keysPath, "utf-8");
+      this.keyStore = JSON.parse(content);
+      return this.keyStore;
+    } catch {
+      this.keyStore = { global: {}, projects: {} };
+      return this.keyStore;
+    }
+  }
+  /**
+   * Save the key store to disk
+   */
+  async saveKeyStore(store) {
+    this.keyStore = store;
+    await fs.promises.writeFile(this.keysPath, JSON.stringify(store, null, 2), "utf-8");
+  }
+  /**
+   * Encrypt a string using Electron's safeStorage
+   */
+  encrypt(plaintext) {
+    if (!electron.safeStorage.isEncryptionAvailable()) {
+      console.warn("Encryption not available, storing key as base64");
+      return Buffer.from(plaintext).toString("base64");
+    }
+    const buffer = electron.safeStorage.encryptString(plaintext);
+    return buffer.toString("base64");
+  }
+  /**
+   * Decrypt a string using Electron's safeStorage
+   */
+  decrypt(encrypted) {
+    if (!electron.safeStorage.isEncryptionAvailable()) {
+      console.warn("Encryption not available, decoding from base64");
+      return Buffer.from(encrypted, "base64").toString("utf-8");
+    }
+    const buffer = Buffer.from(encrypted, "base64");
+    return electron.safeStorage.decryptString(buffer);
+  }
+  /**
+   * Get Anthropic API key
+   * Checks project-specific key first, then falls back to global key
+   */
+  async getAnthropicKey(projectPath) {
+    const store = await this.loadKeyStore();
+    if (projectPath && store.projects?.[projectPath]?.anthropic) {
+      try {
+        return this.decrypt(store.projects[projectPath].anthropic);
+      } catch (error) {
+        console.error("Error decrypting project-specific key:", error);
+      }
+    }
+    if (store.global?.anthropic) {
+      try {
+        return this.decrypt(store.global.anthropic);
+      } catch (error) {
+        console.error("Error decrypting global key:", error);
+      }
+    }
+    return null;
+  }
+  /**
+   * Set Anthropic API key
+   * If projectPath is provided, stores as project-specific key
+   * Otherwise, stores as global key
+   */
+  async setAnthropicKey(key, projectPath) {
+    const store = await this.loadKeyStore();
+    const encrypted = this.encrypt(key);
+    if (projectPath) {
+      if (!store.projects) {
+        store.projects = {};
+      }
+      if (!store.projects[projectPath]) {
+        store.projects[projectPath] = {};
+      }
+      store.projects[projectPath].anthropic = encrypted;
+    } else {
+      if (!store.global) {
+        store.global = {};
+      }
+      store.global.anthropic = encrypted;
+    }
+    await this.saveKeyStore(store);
+  }
+  /**
+   * Check if any Anthropic API key exists
+   */
+  async hasAnthropicKey(projectPath) {
+    const key = await this.getAnthropicKey(projectPath);
+    return key !== null && key.length > 0;
+  }
+  /**
+   * Delete Anthropic API key
+   */
+  async deleteAnthropicKey(projectPath) {
+    const store = await this.loadKeyStore();
+    if (projectPath) {
+      if (store.projects?.[projectPath]?.anthropic) {
+        delete store.projects[projectPath].anthropic;
+        if (Object.keys(store.projects[projectPath]).length === 0) {
+          delete store.projects[projectPath];
+        }
+      }
+    } else {
+      if (store.global?.anthropic) {
+        delete store.global.anthropic;
+      }
+    }
+    await this.saveKeyStore(store);
+  }
+  /**
+   * Clear all stored keys (useful for debugging/testing)
+   */
+  async clearAllKeys() {
+    this.keyStore = { global: {}, projects: {} };
+    await this.saveKeyStore(this.keyStore);
+  }
+}
+const keyManager = new KeyManager();
+class LogManager {
+  /**
+   * Ensure the .logs folder exists in the project
+   */
+  async ensureLogsFolder(projectPath) {
+    const logsPath = path.join(projectPath, ".logs");
+    try {
+      await fs.promises.mkdir(logsPath, { recursive: true });
+      return logsPath;
+    } catch (error) {
+      console.error("Error creating logs folder:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get the path to the history.json file
+   */
+  async getHistoryFilePath(projectPath) {
+    const logsPath = await this.ensureLogsFolder(projectPath);
+    return path.join(logsPath, "history.json");
+  }
+  /**
+   * Load conversation logs from history.json
+   */
+  async loadLogs(projectPath) {
+    try {
+      const historyPath = await this.getHistoryFilePath(projectPath);
+      try {
+        const content = await fs.promises.readFile(historyPath, "utf-8");
+        return JSON.parse(content);
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          return [];
+        }
+        throw error;
+      }
+    } catch (error) {
+      console.error("Error loading logs:", error);
+      return [];
+    }
+  }
+  /**
+   * Save conversation logs to history.json
+   */
+  async saveLogs(projectPath, logs) {
+    try {
+      const historyPath = await this.getHistoryFilePath(projectPath);
+      await fs.promises.writeFile(historyPath, JSON.stringify(logs, null, 2), "utf-8");
+    } catch (error) {
+      console.error("Error saving logs:", error);
+      throw error;
+    }
+  }
+}
+const logManager = new LogManager();
+const getLibraryPath = () => path.join(electron.app.getPath("userData"), "node-library");
+const ensureLibraryExists = async () => {
+  const libraryPath = getLibraryPath();
+  await fs.promises.mkdir(libraryPath, { recursive: true });
+  await fs.promises.mkdir(path.join(libraryPath, "skills"), { recursive: true });
+  await fs.promises.mkdir(path.join(libraryPath, "memory"), { recursive: true });
+  return libraryPath;
+};
+const loadJsonFile = async (fileName) => {
+  const libraryPath = getLibraryPath();
+  const filePath = path.join(libraryPath, fileName);
+  try {
+    const content = await fs.promises.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { version: "1.0.0", items: [] };
+  }
+};
+const saveJsonFile = async (fileName, data) => {
+  const libraryPath = await ensureLibraryExists();
+  const filePath = path.join(libraryPath, fileName);
+  await fs.promises.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+};
+const createJsonCrudHandlers = (typeName, fileName, defaultColor) => {
+  electron.ipcMain.handle(`nodeLibrary:${typeName}:list`, async () => {
+    try {
+      const data = await loadJsonFile(fileName);
+      return { success: true, items: data.items };
+    } catch (error) {
+      console.error(`Error listing ${typeName}:`, error);
+      throw new Error(error.message || `Failed to list ${typeName}`);
+    }
+  });
+  electron.ipcMain.handle(`nodeLibrary:${typeName}:get`, async (_, id) => {
+    try {
+      const data = await loadJsonFile(fileName);
+      const item = data.items.find((i) => i.id === id);
+      if (!item) {
+        throw new Error(`${typeName} not found`);
+      }
+      return { success: true, item };
+    } catch (error) {
+      console.error(`Error getting ${typeName}:`, error);
+      throw new Error(error.message || `Failed to get ${typeName}`);
+    }
+  });
+  electron.ipcMain.handle(`nodeLibrary:${typeName}:create`, async (_, itemData) => {
+    try {
+      await ensureLibraryExists();
+      const data = await loadJsonFile(fileName);
+      const newItem = {
+        id: uuid.v4(),
+        color: defaultColor,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ...itemData
+      };
+      data.items.push(newItem);
+      await saveJsonFile(fileName, data);
+      return { success: true, item: newItem };
+    } catch (error) {
+      console.error(`Error creating ${typeName}:`, error);
+      throw new Error(error.message || `Failed to create ${typeName}`);
+    }
+  });
+  electron.ipcMain.handle(`nodeLibrary:${typeName}:update`, async (_, id, updates) => {
+    try {
+      const data = await loadJsonFile(fileName);
+      const index = data.items.findIndex((i) => i.id === id);
+      if (index === -1) {
+        throw new Error(`${typeName} not found`);
+      }
+      const { id: _id, ...editableUpdates } = updates;
+      updates = editableUpdates;
+      data.items[index] = {
+        ...data.items[index],
+        ...updates,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await saveJsonFile(fileName, data);
+      return { success: true, item: data.items[index] };
+    } catch (error) {
+      console.error(`Error updating ${typeName}:`, error);
+      throw new Error(error.message || `Failed to update ${typeName}`);
+    }
+  });
+  electron.ipcMain.handle(`nodeLibrary:${typeName}:delete`, async (_, id) => {
+    try {
+      const data = await loadJsonFile(fileName);
+      const item = data.items.find((i) => i.id === id);
+      if (!item) {
+        throw new Error(`${typeName} not found`);
+      }
+      data.items = data.items.filter((i) => i.id !== id);
+      await saveJsonFile(fileName, data);
+      return { success: true };
+    } catch (error) {
+      console.error(`Error deleting ${typeName}:`, error);
+      throw new Error(error.message || `Failed to delete ${typeName}`);
+    }
+  });
+};
+const registerSkillHandlers = () => {
+  const skillsFolder = () => path.join(getLibraryPath(), "skills");
+  electron.ipcMain.handle("nodeLibrary:skill:list", async () => {
+    try {
+      await ensureLibraryExists();
+      const skillsPath = skillsFolder();
+      let entries = [];
+      try {
+        entries = await fs.promises.readdir(skillsPath, { withFileTypes: true });
+      } catch {
+        return { success: true, items: [] };
+      }
+      const skills = [];
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const skillPath = path.join(skillsPath, entry.name);
+          const skillMdPath = path.join(skillPath, "SKILL.md");
+          let name = entry.name;
+          let description = "";
+          try {
+            const content = await fs.promises.readFile(skillMdPath, "utf-8");
+            const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+            if (frontmatterMatch) {
+              const lines = frontmatterMatch[1].split("\n");
+              for (const line of lines) {
+                const [key, ...valueParts] = line.split(":");
+                const value = valueParts.join(":").trim();
+                if (key.trim() === "name") name = value;
+                if (key.trim() === "description") description = value;
+              }
+            }
+          } catch {
+          }
+          const stats = await fs.promises.stat(skillPath);
+          skills.push({
+            id: entry.name,
+            // Use folder name as ID
+            name,
+            folderName: entry.name,
+            icon: "/Sk",
+            description,
+            color: "#ff5252",
+            createdAt: stats.birthtime.toISOString(),
+            updatedAt: stats.mtime.toISOString()
+          });
+        }
+      }
+      return { success: true, items: skills };
+    } catch (error) {
+      console.error("Error listing skills:", error);
+      throw new Error(error.message || "Failed to list skills");
+    }
+  });
+  electron.ipcMain.handle("nodeLibrary:skill:get", async (_, id) => {
+    try {
+      const skillPath = path.join(skillsFolder(), id);
+      const skillMdPath = path.join(skillPath, "SKILL.md");
+      await fs.promises.access(skillPath);
+      let skillMdContent = "";
+      let name = id;
+      let description = "";
+      try {
+        skillMdContent = await fs.promises.readFile(skillMdPath, "utf-8");
+        const frontmatterMatch = skillMdContent.match(/^---\s*\n([\s\S]*?)\n---/);
+        if (frontmatterMatch) {
+          const lines = frontmatterMatch[1].split("\n");
+          for (const line of lines) {
+            const [key, ...valueParts] = line.split(":");
+            const value = valueParts.join(":").trim();
+            if (key.trim() === "name") name = value;
+            if (key.trim() === "description") description = value;
+          }
+        }
+      } catch {
+        skillMdContent = `---
+name: ${id}
+description: Custom skill
+---
+
+# ${id}
+
+Describe your skill here.
+`;
+      }
+      const listFiles = async (subfolder) => {
+        try {
+          const files = await fs.promises.readdir(path.join(skillPath, subfolder));
+          return files;
+        } catch {
+          return [];
+        }
+      };
+      const scripts = await listFiles("scripts");
+      const references = await listFiles("references");
+      const assets = await listFiles("assets");
+      const stats = await fs.promises.stat(skillPath);
+      return {
+        success: true,
+        item: {
+          id,
+          name,
+          folderName: id,
+          icon: "/Sk",
+          description,
+          color: "#ff5252",
+          createdAt: stats.birthtime.toISOString(),
+          updatedAt: stats.mtime.toISOString(),
+          skillMdContent,
+          scripts,
+          references,
+          assets
+        }
+      };
+    } catch (error) {
+      console.error("Error getting skill:", error);
+      throw new Error(error.message || "Failed to get skill");
+    }
+  });
+  electron.ipcMain.handle(
+    "nodeLibrary:skill:create",
+    async (_, data) => {
+      try {
+        await ensureLibraryExists();
+        const folderName = data.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+        const skillPath = path.join(skillsFolder(), folderName);
+        try {
+          await fs.promises.access(skillPath);
+          throw new Error(`Skill "${data.name}" already exists`);
+        } catch (err) {
+          if (err.code !== "ENOENT") throw err;
+        }
+        await fs.promises.mkdir(skillPath, { recursive: true });
+        await fs.promises.mkdir(path.join(skillPath, "scripts"), { recursive: true });
+        await fs.promises.mkdir(path.join(skillPath, "references"), { recursive: true });
+        await fs.promises.mkdir(path.join(skillPath, "assets"), { recursive: true });
+        const skillMdContent = `---
+name: ${data.name}
+description: ${data.description || "Custom skill"}
+---
+
+# ${data.name}
+
+${data.description || "Describe your skill here."}
+
+## Instructions
+
+1. Step one
+2. Step two
+3. Step three
+`;
+        await fs.promises.writeFile(path.join(skillPath, "SKILL.md"), skillMdContent, "utf-8");
+        const stats = await fs.promises.stat(skillPath);
+        return {
+          success: true,
+          item: {
+            id: folderName,
+            name: data.name,
+            folderName,
+            icon: "/Sk",
+            description: data.description || "Custom skill",
+            color: "#ff5252",
+            createdAt: stats.birthtime.toISOString(),
+            updatedAt: stats.mtime.toISOString()
+          }
+        };
+      } catch (error) {
+        console.error("Error creating skill:", error);
+        throw new Error(error.message || "Failed to create skill");
+      }
+    }
+  );
+  electron.ipcMain.handle(
+    "nodeLibrary:skill:update",
+    async (_, id, updates) => {
+      try {
+        const skillPath = path.join(skillsFolder(), id);
+        const skillMdPath = path.join(skillPath, "SKILL.md");
+        await fs.promises.access(skillPath);
+        if (updates.skillMdContent !== void 0) {
+          await fs.promises.writeFile(skillMdPath, updates.skillMdContent, "utf-8");
+        } else if (updates.name !== void 0 || updates.description !== void 0) {
+          let currentContent = "";
+          try {
+            currentContent = await fs.promises.readFile(skillMdPath, "utf-8");
+          } catch {
+            currentContent = `---
+name: ${id}
+description: Custom skill
+---
+
+# ${id}
+
+Describe your skill here.
+`;
+          }
+          const frontmatterMatch = currentContent.match(/^---\s*\n([\s\S]*?)\n---/);
+          let frontmatter = {};
+          let bodyContent = currentContent;
+          if (frontmatterMatch) {
+            const lines = frontmatterMatch[1].split("\n");
+            for (const line of lines) {
+              const colonIndex = line.indexOf(":");
+              if (colonIndex > 0) {
+                const key = line.substring(0, colonIndex).trim();
+                const value = line.substring(colonIndex + 1).trim();
+                frontmatter[key] = value;
+              }
+            }
+            bodyContent = currentContent.substring(frontmatterMatch[0].length).trim();
+          }
+          if (updates.name !== void 0) {
+            frontmatter["name"] = updates.name;
+          }
+          if (updates.description !== void 0) {
+            frontmatter["description"] = updates.description;
+          }
+          const frontmatterLines = Object.entries(frontmatter).map(([key, value]) => `${key}: ${value}`).join("\n");
+          const newContent = `---
+${frontmatterLines}
+---
+
+${bodyContent}`;
+          await fs.promises.writeFile(skillMdPath, newContent, "utf-8");
+        }
+        return { success: true };
+      } catch (error) {
+        console.error("Error updating skill:", error);
+        throw new Error(error.message || "Failed to update skill");
+      }
+    }
+  );
+  electron.ipcMain.handle("nodeLibrary:skill:delete", async (_, id) => {
+    try {
+      const skillPath = path.join(skillsFolder(), id);
+      await fs.promises.rm(skillPath, { recursive: true, force: true });
+      return { success: true };
+    } catch (error) {
+      console.error("Error deleting skill:", error);
+      throw new Error(error.message || "Failed to delete skill");
+    }
+  });
+  electron.ipcMain.handle(
+    "nodeLibrary:skill:addFile",
+    async (_, id, fileType, sourcePath, fileName) => {
+      try {
+        const skillPath = path.join(skillsFolder(), id);
+        const subfolderMap = {
+          script: "scripts",
+          reference: "references",
+          asset: "assets"
+        };
+        const destFolder = path.join(skillPath, subfolderMap[fileType]);
+        const destPath = path.join(destFolder, fileName);
+        await fs.promises.mkdir(destFolder, { recursive: true });
+        await fs.promises.copyFile(sourcePath, destPath);
+        return { success: true };
+      } catch (error) {
+        console.error("Error adding skill file:", error);
+        throw new Error(error.message || "Failed to add file");
+      }
+    }
+  );
+  electron.ipcMain.handle(
+    "nodeLibrary:skill:deleteFile",
+    async (_, id, fileType, fileName) => {
+      try {
+        const skillPath = path.join(skillsFolder(), id);
+        const subfolderMap = {
+          script: "scripts",
+          reference: "references",
+          asset: "assets"
+        };
+        const filePath = path.join(skillPath, subfolderMap[fileType], fileName);
+        await fs.promises.unlink(filePath);
+        return { success: true };
+      } catch (error) {
+        console.error("Error deleting skill file:", error);
+        throw new Error(error.message || "Failed to delete file");
+      }
+    }
+  );
+  electron.ipcMain.handle(
+    "nodeLibrary:skill:copyToProject",
+    async (_, skillId, projectPath, forceSync, targetFolderName) => {
+      try {
+        const librarySkillPath = path.join(skillsFolder(), skillId);
+        const destFolderName = targetFolderName || skillId;
+        const projectSkillPath = path.join(projectPath, ".claude", "skills", destFolderName);
+        try {
+          await fs.promises.access(librarySkillPath);
+        } catch {
+          return { success: false, error: "Library skill not found" };
+        }
+        let alreadyExists = false;
+        try {
+          await fs.promises.access(projectSkillPath);
+          alreadyExists = true;
+          if (!forceSync) {
+            return { success: true, alreadyExists: true, folderName: destFolderName };
+          }
+        } catch {
+        }
+        await fs.promises.mkdir(path.join(projectPath, ".claude", "skills"), { recursive: true });
+        const copyDir = async (src, dest) => {
+          await fs.promises.mkdir(dest, { recursive: true });
+          const entries = await fs.promises.readdir(src, { withFileTypes: true });
+          for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            if (entry.isDirectory()) {
+              await copyDir(srcPath, destPath);
+            } else {
+              try {
+                await fs.promises.access(destPath);
+                continue;
+              } catch {
+                await fs.promises.copyFile(srcPath, destPath);
+              }
+            }
+          }
+        };
+        await copyDir(librarySkillPath, projectSkillPath);
+        return { success: true, alreadyExists, synced: forceSync, folderName: destFolderName };
+      } catch (error) {
+        console.error("Error copying skill to project:", error);
+        throw new Error(error.message || "Failed to copy skill to project");
+      }
+    }
+  );
+};
+const registerMemoryHandlers = () => {
+  const memoryFolder = () => path.join(getLibraryPath(), "memory");
+  electron.ipcMain.handle("nodeLibrary:memory:list", async () => {
+    try {
+      await ensureLibraryExists();
+      const memoryPath = memoryFolder();
+      let entries = [];
+      try {
+        entries = await fs.promises.readdir(memoryPath, { withFileTypes: true });
+      } catch {
+        return { success: true, items: [] };
+      }
+      const memories = [];
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const nodePath = path.join(memoryPath, entry.name);
+          const metadataPath = path.join(nodePath, "_metadata.json");
+          let name = entry.name;
+          let description = "";
+          let icon2 = "/Me";
+          let iconImage = "";
+          try {
+            const content = await fs.promises.readFile(metadataPath, "utf-8");
+            const metadata = JSON.parse(content);
+            if (metadata._node) {
+              name = metadata._node.name || entry.name;
+              description = metadata._node.description || "";
+              icon2 = metadata._node.icon || "/Me";
+              iconImage = metadata._node.iconImage || "";
+            }
+          } catch {
+          }
+          const files = await fs.promises.readdir(nodePath);
+          const fileCount = files.filter((f) => f !== "_metadata.json").length;
+          const stats = await fs.promises.stat(nodePath);
+          memories.push({
+            id: entry.name,
+            name,
+            folderName: entry.name,
+            icon: icon2,
+            iconImage,
+            description: description || `${fileCount} file(s)`,
+            color: "#4ade80",
+            createdAt: stats.birthtime.toISOString(),
+            updatedAt: stats.mtime.toISOString()
+          });
+        }
+      }
+      return { success: true, items: memories };
+    } catch (error) {
+      console.error("Error listing memory nodes:", error);
+      throw new Error(error.message || "Failed to list memory nodes");
+    }
+  });
+  electron.ipcMain.handle("nodeLibrary:memory:get", async (_, id) => {
+    try {
+      const nodePath = path.join(memoryFolder(), id);
+      const metadataPath = path.join(nodePath, "_metadata.json");
+      await fs.promises.access(nodePath);
+      let name = id;
+      let description = "";
+      let icon2 = "/Me";
+      let iconImage = "";
+      let fileMetadata = {};
+      try {
+        const content = await fs.promises.readFile(metadataPath, "utf-8");
+        const metadata = JSON.parse(content);
+        if (metadata._node) {
+          name = metadata._node.name || id;
+          description = metadata._node.description || "";
+          icon2 = metadata._node.icon || "/Me";
+          iconImage = metadata._node.iconImage || "";
+        }
+        const { _node, ...rest } = metadata;
+        fileMetadata = rest;
+      } catch {
+      }
+      const allFiles = await fs.promises.readdir(nodePath);
+      const files = allFiles.filter((f) => f !== "_metadata.json");
+      const fileInfos = await Promise.all(
+        files.map(async (fileName) => {
+          const filePath = path.join(nodePath, fileName);
+          const stats2 = await fs.promises.stat(filePath);
+          const meta = fileMetadata[fileName] || {};
+          return {
+            name: fileName,
+            title: meta.title || fileName,
+            description: meta.description || "",
+            size: stats2.size,
+            created: meta.created || stats2.birthtime.toISOString()
+          };
+        })
+      );
+      const stats = await fs.promises.stat(nodePath);
+      return {
+        success: true,
+        item: {
+          id,
+          name,
+          folderName: id,
+          icon: icon2,
+          iconImage,
+          description,
+          color: "#4ade80",
+          createdAt: stats.birthtime.toISOString(),
+          updatedAt: stats.mtime.toISOString(),
+          files: fileInfos
+        }
+      };
+    } catch (error) {
+      console.error("Error getting memory node:", error);
+      throw new Error(error.message || "Failed to get memory node");
+    }
+  });
+  electron.ipcMain.handle(
+    "nodeLibrary:memory:create",
+    async (_, data) => {
+      try {
+        await ensureLibraryExists();
+        const folderName = data.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+        const nodePath = path.join(memoryFolder(), folderName);
+        try {
+          await fs.promises.access(nodePath);
+          throw new Error(`Memory node "${data.name}" already exists`);
+        } catch (err) {
+          if (err.code !== "ENOENT") throw err;
+        }
+        await fs.promises.mkdir(nodePath, { recursive: true });
+        const metadata = {
+          _node: {
+            name: data.name,
+            description: data.description || "",
+            icon: data.icon || "/Me",
+            iconImage: data.iconImage || ""
+          }
+        };
+        await fs.promises.writeFile(path.join(nodePath, "_metadata.json"), JSON.stringify(metadata, null, 2), "utf-8");
+        const stats = await fs.promises.stat(nodePath);
+        return {
+          success: true,
+          item: {
+            id: folderName,
+            name: data.name,
+            folderName,
+            icon: data.icon || "/Me",
+            iconImage: data.iconImage || "",
+            description: data.description || "",
+            color: "#4ade80",
+            createdAt: stats.birthtime.toISOString(),
+            updatedAt: stats.mtime.toISOString()
+          }
+        };
+      } catch (error) {
+        console.error("Error creating memory node:", error);
+        throw new Error(error.message || "Failed to create memory node");
+      }
+    }
+  );
+  electron.ipcMain.handle(
+    "nodeLibrary:memory:update",
+    async (_, id, updates) => {
+      try {
+        const nodePath = path.join(memoryFolder(), id);
+        const metadataPath = path.join(nodePath, "_metadata.json");
+        await fs.promises.access(nodePath);
+        let metadata = {};
+        try {
+          const content = await fs.promises.readFile(metadataPath, "utf-8");
+          metadata = JSON.parse(content);
+        } catch {
+          metadata = {};
+        }
+        metadata._node = {
+          ...metadata._node || {},
+          ...updates
+        };
+        await fs.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+        return { success: true };
+      } catch (error) {
+        console.error("Error updating memory node:", error);
+        throw new Error(error.message || "Failed to update memory node");
+      }
+    }
+  );
+  electron.ipcMain.handle("nodeLibrary:memory:delete", async (_, id) => {
+    try {
+      const nodePath = path.join(memoryFolder(), id);
+      await fs.promises.rm(nodePath, { recursive: true, force: true });
+      return { success: true };
+    } catch (error) {
+      console.error("Error deleting memory node:", error);
+      throw new Error(error.message || "Failed to delete memory node");
+    }
+  });
+  electron.ipcMain.handle(
+    "nodeLibrary:memory:addFile",
+    async (_, id, sourcePath, fileName, title, description) => {
+      try {
+        const nodePath = path.join(memoryFolder(), id);
+        const destPath = path.join(nodePath, fileName);
+        const metadataPath = path.join(nodePath, "_metadata.json");
+        await fs.promises.copyFile(sourcePath, destPath);
+        let metadata = {};
+        try {
+          const content = await fs.promises.readFile(metadataPath, "utf-8");
+          metadata = JSON.parse(content);
+        } catch {
+          metadata = { _node: { name: id, description: "" } };
+        }
+        metadata[fileName] = {
+          title: title || fileName,
+          description: description || "",
+          created: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await fs.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+        return { success: true };
+      } catch (error) {
+        console.error("Error adding memory file:", error);
+        throw new Error(error.message || "Failed to add file");
+      }
+    }
+  );
+  electron.ipcMain.handle("nodeLibrary:memory:deleteFile", async (_, id, fileName) => {
+    try {
+      const nodePath = path.join(memoryFolder(), id);
+      const filePath = path.join(nodePath, fileName);
+      const metadataPath = path.join(nodePath, "_metadata.json");
+      await fs.promises.unlink(filePath);
+      try {
+        const content = await fs.promises.readFile(metadataPath, "utf-8");
+        const metadata = JSON.parse(content);
+        delete metadata[fileName];
+        await fs.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+      } catch {
+      }
+      return { success: true };
+    } catch (error) {
+      console.error("Error deleting memory file:", error);
+      throw new Error(error.message || "Failed to delete file");
+    }
+  });
+  electron.ipcMain.handle(
+    "nodeLibrary:memory:copyToProject",
+    async (_, memoryId, projectPath, forceSync, targetFolderName) => {
+      try {
+        const libraryMemoryPath = path.join(memoryFolder(), memoryId);
+        const destFolderName = targetFolderName || memoryId;
+        const projectMemoryPath = path.join(projectPath, ".claude", "memory", destFolderName);
+        try {
+          await fs.promises.access(libraryMemoryPath);
+        } catch {
+          return { success: false, error: "Library memory not found" };
+        }
+        let alreadyExists = false;
+        try {
+          await fs.promises.access(projectMemoryPath);
+          alreadyExists = true;
+          if (!forceSync) {
+            return { success: true, alreadyExists: true, folderName: destFolderName };
+          }
+        } catch {
+        }
+        await fs.promises.mkdir(path.join(projectPath, ".claude", "memory"), { recursive: true });
+        const copyDir = async (src, dest) => {
+          await fs.promises.mkdir(dest, { recursive: true });
+          const entries = await fs.promises.readdir(src, { withFileTypes: true });
+          for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            if (entry.isDirectory()) {
+              await copyDir(srcPath, destPath);
+            } else {
+              try {
+                await fs.promises.access(destPath);
+              } catch {
+                await fs.promises.copyFile(srcPath, destPath);
+              }
+            }
+          }
+        };
+        await copyDir(libraryMemoryPath, projectMemoryPath);
+        return { success: true, alreadyExists, synced: forceSync, folderName: destFolderName };
+      } catch (error) {
+        console.error("Error copying memory to project:", error);
+        throw new Error(error.message || "Failed to copy memory to project");
+      }
+    }
+  );
+};
+const registerMigrationHandler = () => {
+  electron.ipcMain.handle("nodeLibrary:migrate:fromNodeData", async () => {
+    try {
+      await ensureLibraryExists();
+      const defaultMCPs = [
+        {
+          id: "mcp-example",
+          name: "Example MCP",
+          icon: "E",
+          description: "Example MCP Server integration",
+          color: "#60a5fa",
+          command: "npx",
+          args: ["-y", "example-mcp", "--api-key", "YOUR_API_KEY"],
+          env: {},
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      ];
+      const defaultHooks = [
+        {
+          id: "hook-pretooluse",
+          name: "Pre Tool Use",
+          icon: "⚡",
+          description: "Execute before tool call is processed",
+          color: "#fcd34d",
+          eventType: "PreToolUse",
+          script: '#!/bin/bash\n# Pre-tool use hook\necho "Tool: $TOOL_NAME"',
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        {
+          id: "hook-posttooluse",
+          name: "Post Tool Use",
+          icon: "✓",
+          description: "Execute after tool completes successfully",
+          color: "#fcd34d",
+          eventType: "PostToolUse",
+          script: '#!/bin/bash\n# Post-tool use hook\necho "Tool completed: $TOOL_NAME"',
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        {
+          id: "hook-userpromptsubmit",
+          name: "User Prompt Submit",
+          icon: "💬",
+          description: "Execute when user submits a prompt",
+          color: "#fcd34d",
+          eventType: "UserPromptSubmit",
+          script: "#!/bin/bash\n# User prompt submit hook",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        {
+          id: "hook-notification",
+          name: "Notification",
+          icon: "🔔",
+          description: "Execute when notification is sent",
+          color: "#fcd34d",
+          eventType: "Notification",
+          script: "#!/bin/bash\n# Notification hook",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        {
+          id: "hook-stop",
+          name: "Stop",
+          icon: "⏹",
+          description: "Execute when agent finishes responding",
+          color: "#fcd34d",
+          eventType: "Stop",
+          script: "#!/bin/bash\n# Stop hook",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      ];
+      const defaultSubAgents = [
+        {
+          id: "subagent-manager",
+          name: "SubAgent Manager",
+          icon: "🤖",
+          description: "Manage specialized subagents for your workflow",
+          color: "#8b5cf6",
+          systemPrompt: "You are a SubAgent Manager. Your role is to coordinate and delegate tasks to specialized subagents to achieve complex goals efficiently.",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      ];
+      const defaultCommands = [
+        {
+          id: "default-command",
+          name: "Custom Command",
+          icon: "C",
+          description: "Define and manage custom commands for your workflow",
+          color: "hsl(294, 88%, 87%)",
+          promptTemplate: "# Custom Command\n\nDescribe your command here.",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      ];
+      const libraryPath = getLibraryPath();
+      const migrateIfNeeded = async (fileName, defaultItems) => {
+        const filePath = path.join(libraryPath, fileName);
+        try {
+          await fs.promises.access(filePath);
+          const content = await fs.promises.readFile(filePath, "utf-8");
+          const data = JSON.parse(content);
+          if (data.items && data.items.length > 0) {
+            return { migrated: false, count: data.items.length };
+          }
+        } catch {
+        }
+        await saveJsonFile(fileName, { version: "1.0.0", items: defaultItems });
+        return { migrated: true, count: defaultItems.length };
+      };
+      const results = {
+        mcps: await migrateIfNeeded("mcps.json", defaultMCPs),
+        hooks: await migrateIfNeeded("hooks.json", defaultHooks),
+        subagents: await migrateIfNeeded("subagents.json", defaultSubAgents),
+        commands: await migrateIfNeeded("commands.json", defaultCommands),
+        skills: { migrated: false, count: 0 }
+      };
+      const skillsPath = path.join(libraryPath, "skills");
+      const defaultSkills = [
+        {
+          folderName: "code-review",
+          name: "Code Review",
+          description: "Perform thorough code reviews with best practices",
+          content: `---
+name: Code Review
+description: Perform thorough code reviews with best practices
+---
+
+# Code Review Skill
+
+## Overview
+This skill helps you perform thorough code reviews focusing on code quality, security, and best practices.
+
+## Instructions
+
+1. **Analyze the code structure** - Check for proper organization and modularity
+2. **Review naming conventions** - Ensure variables, functions, and classes have descriptive names
+3. **Check for security issues** - Look for common vulnerabilities (injection, XSS, etc.)
+4. **Evaluate performance** - Identify potential bottlenecks or inefficient code
+5. **Verify error handling** - Ensure proper error handling and edge cases
+6. **Review documentation** - Check for adequate comments and documentation
+
+## Output Format
+Provide feedback in a structured format with:
+- Summary of findings
+- Critical issues (if any)
+- Suggestions for improvement
+- Positive observations
+`
+        },
+        {
+          folderName: "documentation-writer",
+          name: "Documentation Writer",
+          description: "Generate comprehensive documentation for code and APIs",
+          content: `---
+name: Documentation Writer
+description: Generate comprehensive documentation for code and APIs
+---
+
+# Documentation Writer Skill
+
+## Overview
+This skill helps you create clear, comprehensive documentation for code, APIs, and projects.
+
+## Instructions
+
+1. **Understand the context** - Review the code or API to document
+2. **Identify the audience** - Determine who will read the documentation
+3. **Structure the content** - Organize with clear headings and sections
+4. **Write clear explanations** - Use simple language and examples
+5. **Include code samples** - Provide working examples where applicable
+6. **Add troubleshooting tips** - Anticipate common issues
+
+## Documentation Types
+- README files
+- API documentation
+- Code comments
+- User guides
+- Technical specifications
+`
+        },
+        {
+          folderName: "test-generator",
+          name: "Test Generator",
+          description: "Generate unit tests and integration tests for your code",
+          content: `---
+name: Test Generator
+description: Generate unit tests and integration tests for your code
+---
+
+# Test Generator Skill
+
+## Overview
+This skill helps you generate comprehensive test suites including unit tests, integration tests, and edge cases.
+
+## Instructions
+
+1. **Analyze the code** - Understand what needs to be tested
+2. **Identify test cases** - List all scenarios to cover
+3. **Write unit tests** - Test individual functions and methods
+4. **Add edge cases** - Test boundary conditions and error scenarios
+5. **Include mocks** - Mock external dependencies when needed
+6. **Ensure coverage** - Aim for high code coverage
+
+## Test Patterns
+- Arrange-Act-Assert (AAA)
+- Given-When-Then (BDD)
+- Test doubles (mocks, stubs, spies)
+
+## Frameworks Support
+- Jest (JavaScript/TypeScript)
+- Pytest (Python)
+- JUnit (Java)
+- And more...
+`
+        }
+      ];
+      for (const skill of defaultSkills) {
+        const skillPath = path.join(skillsPath, skill.folderName);
+        try {
+          await fs.promises.access(skillPath);
+        } catch {
+          await fs.promises.mkdir(skillPath, { recursive: true });
+          await fs.promises.mkdir(path.join(skillPath, "scripts"), { recursive: true });
+          await fs.promises.mkdir(path.join(skillPath, "references"), { recursive: true });
+          await fs.promises.mkdir(path.join(skillPath, "assets"), { recursive: true });
+          await fs.promises.writeFile(path.join(skillPath, "SKILL.md"), skill.content, "utf-8");
+          results.skills.count++;
+          results.skills.migrated = true;
+        }
+      }
+      return { success: true, results };
+    } catch (error) {
+      console.error("Error migrating node data:", error);
+      throw new Error(error.message || "Failed to migrate node data");
+    }
+  });
+};
+function registerNodeLibraryHandlers() {
+  createJsonCrudHandlers("mcp", "mcps.json", "#60a5fa");
+  createJsonCrudHandlers("hook", "hooks.json", "#fcd34d");
+  createJsonCrudHandlers("hookconfig", "hookconfigs.json", "#fcd34d");
+  createJsonCrudHandlers("subagent", "subagents.json", "#8b5cf6");
+  createJsonCrudHandlers("command", "commands.json", "hsl(294, 88%, 87%)");
+  registerSkillHandlers();
+  registerMemoryHandlers();
+  registerMigrationHandler();
+  console.log("Node Library handlers registered");
+}
+let mainWindow = null;
+if (process.platform === "darwin" && electron.app.isPackaged) {
+  try {
+    const userShell = process.env.SHELL || "/bin/zsh";
+    const shellPath = child_process.execSync(`${userShell} -ilc 'echo $PATH'`, {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    }).trim();
+    if (shellPath) {
+      process.env.PATH = shellPath;
+    }
+  } catch (error) {
+    console.error("Failed to get shell PATH:", error);
+  }
+}
+const isDev = !electron.app.isPackaged;
+const SUPPORTED_AUDIO_EXTS = /* @__PURE__ */ new Set([".mp3", ".wav", ".m4a", ".ogg"]);
+function getDefaultMusicDir() {
+  if (isDev) return path.join(electron.app.getAppPath(), "resources", "music");
+  return path.join(process.resourcesPath, "app.asar.unpacked", "resources", "music");
+}
+function getWorkspaceMusicDir(workspacePath) {
+  return path.join(workspacePath, ".meta", "music");
+}
+function fileTitleFromPath(filePath) {
+  const base = path.basename(filePath);
+  const ext = path.extname(base);
+  return ext ? base.slice(0, -ext.length) : base;
+}
+async function listAudioFilesInDir(dirPath) {
+  try {
+    const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
+    const files = entries.filter((e) => e.isFile()).map((e) => path.join(dirPath, e.name)).filter((p) => SUPPORTED_AUDIO_EXTS.has(path.extname(p).toLowerCase()));
+    return files;
+  } catch {
+    return [];
+  }
+}
+function createWindow() {
+  mainWindow = new electron.BrowserWindow({
+    width: 1200,
+    height: 800,
+    minWidth: 1200,
+    minHeight: 800,
+    show: false,
+    autoHideMenuBar: true,
+    ...process.platform === "linux" ? { icon } : {},
+    webPreferences: {
+      preload: path.join(__dirname, "../preload/index.js"),
+      sandbox: false
+    }
+  });
+  mainWindow.on("ready-to-show", () => {
+    mainWindow?.show();
+  });
+  if (isDev) {
+    mainWindow.webContents.openDevTools();
+  }
+  mainWindow.webContents.setWindowOpenHandler((details) => {
+    electron.shell.openExternal(details.url);
+    return { action: "deny" };
+  });
+  if (isDev && process.env["ELECTRON_RENDERER_URL"]) {
+    mainWindow.loadURL(process.env["ELECTRON_RENDERER_URL"]);
+  } else {
+    mainWindow.loadFile(path.join(__dirname, "../renderer/index.html"));
+  }
+}
+function parseCliArguments(args) {
+  let projectPath = null;
+  let openCanvas = false;
+  const projectPathIndex = args.indexOf("--project-path");
+  if (projectPathIndex !== -1) {
+    for (let i = projectPathIndex + 1; i < args.length; i++) {
+      const arg = args[i];
+      if (!arg.startsWith("--")) {
+        projectPath = path.resolve(arg);
+        break;
+      }
+    }
+  }
+  const openCanvasIndex = args.indexOf("--open-canvas");
+  if (openCanvasIndex !== -1) {
+    openCanvas = true;
+  }
+  if (projectPath && !fs.existsSync(projectPath)) {
+    console.error(`Project path does not exist: ${projectPath}`);
+    projectPath = null;
+  }
+  return { projectPath, openCanvas };
+}
+const gotTheLock = electron.app.requestSingleInstanceLock();
+if (!gotTheLock) {
+  electron.app.quit();
+} else {
+  electron.app.on("second-instance", async (_, commandLine) => {
+    const { projectPath, openCanvas } = parseCliArguments(commandLine);
+    if (mainWindow) {
+      if (mainWindow.isMinimized()) mainWindow.restore();
+      mainWindow.focus();
+      if (mainWindow.webContents.isLoading()) {
+        await new Promise((resolve2) => {
+          mainWindow?.webContents.once("did-finish-load", resolve2);
+        });
+      }
+      if (projectPath) {
+        if (openCanvas) {
+          mainWindow.webContents.send("initial-open-canvas", true);
+        }
+        mainWindow.webContents.send("initial-project-path", projectPath);
+      }
+    }
+  });
+}
+electron.app.whenReady().then(() => {
+  utils.electronApp.setAppUserModelId("com.electron");
+  electron.app.on("browser-window-created", (_, window) => {
+    utils.optimizer.watchWindowShortcuts(window);
+  });
+  electron.ipcMain.on("ping", () => console.log("pong"));
+  registerNodeLibraryHandlers();
+  electron.ipcMain.handle("agent:start-session", async (_, projectPath2, apiKey, authMethod, sdkSessionId, permissionMode, agentFolderName) => {
+    try {
+      const sessionId = await agentManager.createSession({
+        projectPath: projectPath2,
+        apiKey,
+        authMethod,
+        sdkSessionId,
+        permissionMode,
+        agentFolderName
+      });
+      return { success: true, sessionId };
+    } catch (error) {
+      console.error("Error starting agent session:", error);
+      throw new Error(error.message || "Failed to start agent session");
+    }
+  });
+  electron.ipcMain.handle("agent:send-message", async (event, sessionId, message) => {
+    try {
+      const mainWindow2 = electron.BrowserWindow.fromWebContents(event.sender);
+      if (!mainWindow2) {
+        throw new Error("No active window found");
+      }
+      await agentManager.sendMessage(sessionId, message, (chunk) => {
+        if (chunk.type === "approval_request") {
+          console.log("📤 [IPC] Sending approval_request chunk to renderer:", chunk.approvalRequest?.requestId);
+        }
+        mainWindow2.webContents.send("agent:message-chunk", sessionId, chunk);
+      });
+      mainWindow2.webContents.send("agent:message-complete", sessionId);
+      return { success: true };
+    } catch (error) {
+      console.error("Error sending message to agent:", error);
+      throw new Error(error.message || "Failed to send message");
+    }
+  });
+  electron.ipcMain.handle("agent:stop-session", async (_, sessionId) => {
+    try {
+      agentManager.stopSession(sessionId);
+      return { success: true };
+    } catch (error) {
+      console.error("Error stopping agent session:", error);
+      throw new Error(error.message || "Failed to stop session");
+    }
+  });
+  electron.ipcMain.handle("agent:is-session-active", async (_, sessionId) => {
+    try {
+      const isActive = agentManager.isSessionActive(sessionId);
+      return { success: true, isActive };
+    } catch (error) {
+      console.error("Error checking session status:", error);
+      throw new Error(error.message || "Failed to check session status");
+    }
+  });
+  electron.ipcMain.handle("agent:set-permission-mode", async (_, sessionId, mode) => {
+    try {
+      agentManager.updateSessionConfig(sessionId, { permissionMode: mode });
+      return { success: true };
+    } catch (error) {
+      console.error("Error setting permission mode:", error);
+      throw new Error(error.message || "Failed to set permission mode");
+    }
+  });
+  electron.ipcMain.handle("agent:respond-to-approval", async (_, sessionId, requestId, approved) => {
+    try {
+      console.log("📥 [IPC] Received approval response from renderer:", { sessionId, requestId, approved });
+      agentManager.respondToApproval(sessionId, requestId, approved);
+      return { success: true };
+    } catch (error) {
+      console.error("Error responding to approval:", error);
+      throw new Error(error.message || "Failed to respond to approval");
+    }
+  });
+  electron.ipcMain.handle("keys:has-anthropic", async (_, projectPath2) => {
+    try {
+      const hasKey = await keyManager.hasAnthropicKey(projectPath2);
+      return { success: true, hasKey };
+    } catch (error) {
+      console.error("Error checking for API key:", error);
+      throw new Error(error.message || "Failed to check for API key");
+    }
+  });
+  electron.ipcMain.handle("keys:get-anthropic", async (_, projectPath2) => {
+    try {
+      const apiKey = await keyManager.getAnthropicKey(projectPath2);
+      return { success: true, apiKey };
+    } catch (error) {
+      console.error("Error getting API key:", error);
+      throw new Error(error.message || "Failed to get API key");
+    }
+  });
+  electron.ipcMain.handle("keys:set-anthropic", async (_, apiKey, projectPath2) => {
+    try {
+      await keyManager.setAnthropicKey(apiKey, projectPath2);
+      return { success: true };
+    } catch (error) {
+      console.error("Error setting API key:", error);
+      throw new Error(error.message || "Failed to set API key");
+    }
+  });
+  electron.ipcMain.handle("keys:delete-anthropic", async (_, projectPath2) => {
+    try {
+      await keyManager.deleteAnthropicKey(projectPath2);
+      return { success: true };
+    } catch (error) {
+      console.error("Error deleting API key:", error);
+      throw new Error(error.message || "Failed to delete API key");
+    }
+  });
+  electron.ipcMain.handle("auth:check-cli-status", async () => {
+    try {
+      const sdk = await import("@anthropic-ai/claude-agent-sdk");
+      const queryOptions = {
+        // Omit apiKey to use CLI auth
+        systemPrompt: { type: "preset", preset: "claude_code" }
+      };
+      const customCliCommand = await authSettingsManager.getCustomCliCommand();
+      console.log("[AUTH] Custom CLI command:", customCliCommand);
+      console.log("[AUTH] App isPackaged:", electron.app.isPackaged);
+      if (customCliCommand) {
+        console.log("[AUTH] Using custom CLI command:", customCliCommand);
+        queryOptions.pathToClaudeCodeExecutable = customCliCommand;
+      } else if (electron.app.isPackaged) {
+        const path2 = await import("path");
+        const cliPath = path2.join(
+          process.resourcesPath,
+          "app.asar.unpacked",
+          "node_modules",
+          "@anthropic-ai",
+          "claude-agent-sdk",
+          "cli.js"
+        );
+        console.log("[AUTH] Using packaged CLI path:", cliPath);
+        queryOptions.pathToClaudeCodeExecutable = cliPath;
+      } else {
+        console.log('[AUTH] Using default "claude" command from PATH');
+      }
+      const testQuery = sdk.query({
+        prompt: "",
+        options: queryOptions
+      });
+      const accountInfoPromise = testQuery.accountInfo();
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error("CLI authentication check timed out")), 1e4);
+      });
+      const accountInfo = await Promise.race([accountInfoPromise, timeoutPromise]);
+      return {
+        success: true,
+        isAuthenticated: true,
+        accountInfo: {
+          email: accountInfo?.email
+        }
+      };
+    } catch (error) {
+      return {
+        success: true,
+        isAuthenticated: false,
+        error: error.message
+      };
+    }
+  });
+  electron.ipcMain.handle("auth:get-preferred-method", async (_, projectPath2) => {
+    try {
+      const method = await authSettingsManager.getPreferredMethod(projectPath2);
+      return { success: true, method };
+    } catch (error) {
+      console.error("Error getting preferred auth method:", error);
+      throw new Error(error.message || "Failed to get auth preference");
+    }
+  });
+  electron.ipcMain.handle(
+    "auth:set-preferred-method",
+    async (_, method, projectPath2) => {
+      try {
+        await authSettingsManager.setPreferredMethod(method, projectPath2);
+        return { success: true };
+      } catch (error) {
+        console.error("Error setting preferred auth method:", error);
+        throw new Error(error.message || "Failed to set auth preference");
+      }
+    }
+  );
+  electron.ipcMain.handle("auth:get-auto-fallback", async () => {
+    try {
+      const enabled = await authSettingsManager.getAutoFallback();
+      return { success: true, enabled };
+    } catch (error) {
+      console.error("Error getting auto-fallback setting:", error);
+      throw new Error(error.message || "Failed to get auto-fallback setting");
+    }
+  });
+  electron.ipcMain.handle("auth:set-auto-fallback", async (_, enabled) => {
+    try {
+      await authSettingsManager.setAutoFallback(enabled);
+      return { success: true };
+    } catch (error) {
+      console.error("Error setting auto-fallback:", error);
+      throw new Error(error.message || "Failed to set auto-fallback");
+    }
+  });
+  electron.ipcMain.handle("auth:get-custom-cli-command", async () => {
+    try {
+      const command = await authSettingsManager.getCustomCliCommand();
+      return { success: true, command };
+    } catch (error) {
+      console.error("Error getting custom CLI command:", error);
+      throw new Error(error.message || "Failed to get custom CLI command");
+    }
+  });
+  electron.ipcMain.handle("auth:set-custom-cli-command", async (_, command) => {
+    try {
+      await authSettingsManager.setCustomCliCommand(command);
+      return { success: true };
+    } catch (error) {
+      console.error("Error setting custom CLI command:", error);
+      throw new Error(error.message || "Failed to set custom CLI command");
+    }
+  });
+  electron.ipcMain.handle("auth:clear-custom-cli-command", async () => {
+    try {
+      await authSettingsManager.clearCustomCliCommand();
+      return { success: true };
+    } catch (error) {
+      console.error("Error clearing custom CLI command:", error);
+      throw new Error(error.message || "Failed to clear custom CLI command");
+    }
+  });
+  electron.ipcMain.handle("logs:load", async (_, projectPath2) => {
+    try {
+      const logs = await logManager.loadLogs(projectPath2);
+      return { success: true, logs };
+    } catch (error) {
+      console.error("Error loading logs:", error);
+      return { success: false, logs: [] };
+    }
+  });
+  electron.ipcMain.handle("logs:save", async (_, projectPath2, logs) => {
+    try {
+      await logManager.saveLogs(projectPath2, logs);
+      return { success: true };
+    } catch (error) {
+      console.error("Error saving logs:", error);
+      throw new Error(error.message || "Failed to save logs");
+    }
+  });
+  const ensureMemoryFolder = async (folderPath) => {
+    const fullPath = path.join(electron.app.getPath("userData"), folderPath);
+    try {
+      await fs.promises.mkdir(fullPath, { recursive: true });
+      return fullPath;
+    } catch (error) {
+      console.error("Error creating memory folder:", error);
+      throw error;
+    }
+  };
+  electron.ipcMain.handle("list-markdown-files", async (_, folderPath) => {
+    try {
+      const fullPath = await ensureMemoryFolder(folderPath);
+      const files = await fs.promises.readdir(fullPath);
+      const mdFiles = files.filter((f) => f.endsWith(".md"));
+      const fileInfos = await Promise.all(
+        mdFiles.map(async (name) => {
+          const filePath = path.join(fullPath, name);
+          const stats = await fs.promises.stat(filePath);
+          return {
+            name,
+            path: filePath,
+            size: stats.size
+          };
+        })
+      );
+      return fileInfos;
+    } catch (error) {
+      console.error("Error listing markdown files:", error);
+      return [];
+    }
+  });
+  electron.ipcMain.handle(
+    "add-markdown-file",
+    async (_, folderPath, sourcePath, fileName) => {
+      try {
+        const fullPath = await ensureMemoryFolder(folderPath);
+        const destPath = path.join(fullPath, fileName);
+        try {
+          await fs.promises.access(destPath);
+          throw new Error(`File "${fileName}" already exists`);
+        } catch {
+        }
+        await fs.promises.copyFile(sourcePath, destPath);
+        return { success: true };
+      } catch (error) {
+        console.error("Error adding markdown file:", error);
+        throw new Error(error.message || "Failed to add file");
+      }
+    }
+  );
+  electron.ipcMain.handle("delete-markdown-file", async (_, filePath) => {
+    try {
+      await fs.promises.unlink(filePath);
+      return { success: true };
+    } catch (error) {
+      console.error("Error deleting markdown file:", error);
+      throw new Error("Failed to delete file");
+    }
+  });
+  const ensureContextFolder = async (projectPath2) => {
+    const contextPath = path.join(projectPath2, ".claude", "context");
+    try {
+      await fs.promises.mkdir(contextPath, { recursive: true });
+      return contextPath;
+    } catch (error) {
+      console.error("Error creating context folder:", error);
+      throw error;
+    }
+  };
+  const ensureMemoryNodeFolder = async (projectPath2, memoryFolderName) => {
+    const memoryPath = path.join(projectPath2, ".claude", "memory", memoryFolderName);
+    try {
+      await fs.promises.mkdir(memoryPath, { recursive: true });
+      return memoryPath;
+    } catch (error) {
+      console.error("Error creating memory node folder:", error);
+      throw error;
+    }
+  };
+  const getMetadataPath = async (projectPath2) => {
+    const contextPath = await ensureContextFolder(projectPath2);
+    return path.join(contextPath, "_metadata.json");
+  };
+  const getMemoryNodeMetadataPath = async (projectPath2, memoryFolderName) => {
+    const memoryPath = await ensureMemoryNodeFolder(projectPath2, memoryFolderName);
+    return path.join(memoryPath, "_metadata.json");
+  };
+  const loadMetadata = async (projectPath2) => {
+    try {
+      const metadataPath = await getMetadataPath(projectPath2);
+      const content = await fs.promises.readFile(metadataPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  };
+  const saveMetadata = async (projectPath2, metadata) => {
+    try {
+      const metadataPath = await getMetadataPath(projectPath2);
+      await fs.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+    } catch (error) {
+      console.error("Error saving metadata:", error);
+      throw error;
+    }
+  };
+  const getFileType = (fileName) => {
+    const ext = fileName.split(".").pop()?.toLowerCase() || "";
+    if (["jpg", "jpeg", "png", "gif", "webp", "svg", "bmp", "ico"].includes(ext)) {
+      return "image";
+    }
+    if (["md", "markdown", "txt"].includes(ext)) {
+      return "text";
+    }
+    if (["js", "ts", "jsx", "tsx", "py", "java", "cpp", "c", "h", "css", "html", "json", "xml", "yaml", "yml", "sh", "bash"].includes(ext)) {
+      return "code";
+    }
+    if (ext === "pdf") {
+      return "pdf";
+    }
+    if (["mp4", "avi", "mov", "wmv", "flv", "webm"].includes(ext)) {
+      return "video";
+    }
+    if (["mp3", "wav", "ogg", "flac", "m4a"].includes(ext)) {
+      return "audio";
+    }
+    if (["zip", "rar", "7z", "tar", "gz"].includes(ext)) {
+      return "archive";
+    }
+    return "other";
+  };
+  electron.ipcMain.handle("list-context-files", async (_, projectPath2) => {
+    try {
+      const contextPath = await ensureContextFolder(projectPath2);
+      const metadata = await loadMetadata(projectPath2);
+      const allFiles = await fs.promises.readdir(contextPath);
+      const files = allFiles.filter((f) => f !== "_metadata.json");
+      const fileInfos = await Promise.all(
+        files.map(async (name) => {
+          const filePath = path.join(contextPath, name);
+          const stats = await fs.promises.stat(filePath);
+          const ext = name.split(".").pop()?.toLowerCase() || "";
+          const type = getFileType(name);
+          const fileMeta = metadata[name] || {};
+          return {
+            name,
+            path: filePath,
+            size: stats.size,
+            type,
+            ext,
+            title: fileMeta.title || name,
+            description: fileMeta.description || "",
+            created: fileMeta.created || stats.birthtime.toISOString()
+          };
+        })
+      );
+      fileInfos.sort((a, b) => new Date(b.created).getTime() - new Date(a.created).getTime());
+      return fileInfos;
+    } catch (error) {
+      console.error("Error listing context files:", error);
+      return [];
+    }
+  });
+  const walkDirectory = async (dir, projectRoot, depth = 0, maxDepth = 10) => {
+    if (depth > maxDepth) return [];
+    const ignorePatterns = [
+      "node_modules",
+      ".git",
+      ".claude",
+      "dist",
+      "build",
+      "out",
+      "coverage",
+      ".next",
+      ".nuxt",
+      ".cache",
+      ".vscode",
+      ".idea",
+      ".DS_Store",
+      "thumbs.db",
+      "*.log",
+      ".env",
+      ".env.local",
+      "__pycache__",
+      "*.pyc",
+      ".pytest_cache",
+      "venv",
+      ".venv",
+      "target",
+      "pkg",
+      ".meta"
+    ];
+    const shouldIgnore = (name) => {
+      return ignorePatterns.some((pattern) => {
+        if (pattern.includes("*")) {
+          const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+          return regex.test(name);
+        }
+        return name === pattern || name.startsWith(pattern);
+      });
+    };
+    try {
+      const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+      const results = [];
+      for (const entry of entries) {
+        if (shouldIgnore(entry.name)) continue;
+        const fullPath = path.join(dir, entry.name);
+        const relativePath = fullPath.replace(projectRoot + path.sep, "").replace(/\\/g, "/");
+        if (entry.isDirectory()) {
+          const subResults = await walkDirectory(fullPath, projectRoot, depth + 1, maxDepth);
+          results.push(...subResults);
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name).toLowerCase();
+          const type = getFileType(entry.name);
+          const includeExtensions = [
+            ".js",
+            ".ts",
+            ".jsx",
+            ".tsx",
+            ".vue",
+            ".py",
+            ".java",
+            ".cpp",
+            ".c",
+            ".h",
+            ".cs",
+            ".go",
+            ".rs",
+            ".rb",
+            ".php",
+            ".swift",
+            ".kt",
+            ".scala",
+            ".sh",
+            ".html",
+            ".css",
+            ".scss",
+            ".sass",
+            ".json",
+            ".xml",
+            ".yaml",
+            ".yml",
+            ".md",
+            ".markdown",
+            ".txt"
+          ];
+          const shouldInclude = includeExtensions.includes(ext) || entry.name.match(/^(Dockerfile|Makefile|README|LICENSE|CHANGELOG)/);
+          if (shouldInclude) {
+            results.push({
+              name: entry.name,
+              path: relativePath,
+              type,
+              ext: ext.replace(".", "")
+            });
+          }
+        }
+      }
+      return results;
+    } catch (error) {
+      console.error(`Error walking directory ${dir}:`, error);
+      return [];
+    }
+  };
+  electron.ipcMain.handle("list-project-files", async (_, projectPath2) => {
+    try {
+      await fs.promises.access(projectPath2);
+      const files = await walkDirectory(projectPath2, projectPath2);
+      files.sort((a, b) => a.path.localeCompare(b.path));
+      const limitedFiles = files.slice(0, 500);
+      if (files.length > 500) {
+        console.warn(`Project has ${files.length} files, showing first 500`);
+      }
+      return limitedFiles;
+    } catch (error) {
+      console.error("Error listing project files:", error);
+      return [];
+    }
+  });
+  electron.ipcMain.handle("add-context-file", async (_, projectPath2, sourcePath, fileName, title, description) => {
+    try {
+      const contextPath = await ensureContextFolder(projectPath2);
+      const destPath = path.join(contextPath, fileName);
+      try {
+        await fs.promises.access(destPath);
+        throw new Error(`File "${fileName}" already exists`);
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          throw err;
+        }
+      }
+      await fs.promises.copyFile(sourcePath, destPath);
+      const metadata = await loadMetadata(projectPath2);
+      metadata[fileName] = {
+        title: title || fileName,
+        description: description || "",
+        created: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await saveMetadata(projectPath2, metadata);
+      return { success: true };
+    } catch (error) {
+      console.error("Error adding context file:", error);
+      throw new Error(error.message || "Failed to add file");
+    }
+  });
+  electron.ipcMain.handle("rename-context-file", async (_, projectPath2, oldName, newName) => {
+    try {
+      const contextPath = await ensureContextFolder(projectPath2);
+      const oldPath = path.join(contextPath, oldName);
+      const newPath = path.join(contextPath, newName);
+      try {
+        await fs.promises.access(newPath);
+        throw new Error(`File "${newName}" already exists`);
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          throw err;
+        }
+      }
+      await fs.promises.rename(oldPath, newPath);
+      const metadata = await loadMetadata(projectPath2);
+      if (metadata[oldName]) {
+        metadata[newName] = metadata[oldName];
+        delete metadata[oldName];
+        await saveMetadata(projectPath2, metadata);
+      }
+      return { success: true };
+    } catch (error) {
+      console.error("Error renaming context file:", error);
+      throw new Error(error.message || "Failed to rename file");
+    }
+  });
+  electron.ipcMain.handle("update-context-metadata", async (_, projectPath2, fileName, title, description) => {
+    try {
+      const metadata = await loadMetadata(projectPath2);
+      if (!metadata[fileName]) {
+        metadata[fileName] = { created: (/* @__PURE__ */ new Date()).toISOString() };
+      }
+      metadata[fileName].title = title;
+      metadata[fileName].description = description;
+      await saveMetadata(projectPath2, metadata);
+      return { success: true };
+    } catch (error) {
+      console.error("Error updating context metadata:", error);
+      throw new Error(error.message || "Failed to update metadata");
+    }
+  });
+  electron.ipcMain.handle("delete-context-file", async (_, projectPath2, fileName) => {
+    try {
+      const contextPath = await ensureContextFolder(projectPath2);
+      const filePath = path.join(contextPath, fileName);
+      await fs.promises.unlink(filePath);
+      const metadata = await loadMetadata(projectPath2);
+      if (metadata[fileName]) {
+        delete metadata[fileName];
+        await saveMetadata(projectPath2, metadata);
+      }
+      return { success: true };
+    } catch (error) {
+      console.error("Error deleting context file:", error);
+      throw new Error(error.message || "Failed to delete file");
+    }
+  });
+  electron.ipcMain.handle("read-context-file", async (_, projectPath2, fileName) => {
+    try {
+      const contextPath = await ensureContextFolder(projectPath2);
+      const filePath = path.join(contextPath, fileName);
+      const type = getFileType(fileName);
+      let content = null;
+      let dataUrl = null;
+      if (type === "image") {
+        const buffer = await fs.promises.readFile(filePath);
+        const ext = fileName.split(".").pop()?.toLowerCase() || "png";
+        const mimeType = ext === "svg" ? "image/svg+xml" : `image/${ext}`;
+        dataUrl = `data:${mimeType};base64,${buffer.toString("base64")}`;
+      } else if (type === "text" || type === "code") {
+        content = await fs.promises.readFile(filePath, "utf-8");
+      } else {
+        const stats = await fs.promises.stat(filePath);
+        content = `File size: ${(stats.size / 1024).toFixed(2)} KB`;
+      }
+      return {
+        success: true,
+        type,
+        content,
+        dataUrl
+      };
+    } catch (error) {
+      console.error("Error reading context file:", error);
+      throw new Error(error.message || "Failed to read file");
+    }
+  });
+  const loadMemoryNodeMetadata = async (projectPath2, memoryFolderName) => {
+    try {
+      const metadataPath = await getMemoryNodeMetadataPath(projectPath2, memoryFolderName);
+      const content = await fs.promises.readFile(metadataPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  };
+  const saveMemoryNodeMetadata = async (projectPath2, memoryFolderName, metadata) => {
+    try {
+      const metadataPath = await getMemoryNodeMetadataPath(projectPath2, memoryFolderName);
+      await fs.promises.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+    } catch (error) {
+      console.error("Error saving memory node metadata:", error);
+      throw error;
+    }
+  };
+  electron.ipcMain.handle("list-memory-node-files", async (_, projectPath2, memoryFolderName) => {
+    try {
+      const memoryPath = await ensureMemoryNodeFolder(projectPath2, memoryFolderName);
+      const metadata = await loadMemoryNodeMetadata(projectPath2, memoryFolderName);
+      const allFiles = await fs.promises.readdir(memoryPath);
+      const files = allFiles.filter((f) => f !== "_metadata.json");
+      const fileInfos = await Promise.all(
+        files.map(async (name) => {
+          const filePath = path.join(memoryPath, name);
+          const stats = await fs.promises.stat(filePath);
+          const ext = name.split(".").pop()?.toLowerCase() || "";
+          const type = getFileType(name);
+          const fileMeta = metadata[name] || {};
+          return {
+            name,
+            path: filePath,
+            size: stats.size,
+            type,
+            ext,
+            title: fileMeta.title || name,
+            description: fileMeta.description || "",
+            created: fileMeta.created || stats.birthtime.toISOString()
+          };
+        })
+      );
+      fileInfos.sort((a, b) => new Date(b.created).getTime() - new Date(a.created).getTime());
+      return fileInfos;
+    } catch (error) {
+      console.error("Error listing memory node files:", error);
+      return [];
+    }
+  });
+  electron.ipcMain.handle("add-memory-node-file", async (_, projectPath2, memoryFolderName, sourcePath, fileName, title, description) => {
+    try {
+      const memoryPath = await ensureMemoryNodeFolder(projectPath2, memoryFolderName);
+      const destPath = path.join(memoryPath, fileName);
+      try {
+        await fs.promises.access(destPath);
+        throw new Error(`File "${fileName}" already exists`);
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          throw err;
+        }
+      }
+      await fs.promises.copyFile(sourcePath, destPath);
+      const metadata = await loadMemoryNodeMetadata(projectPath2, memoryFolderName);
+      metadata[fileName] = {
+        title: title || fileName,
+        description: description || "",
+        created: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await saveMemoryNodeMetadata(projectPath2, memoryFolderName, metadata);
+      return { success: true };
+    } catch (error) {
+      console.error("Error adding memory node file:", error);
+      throw new Error(error.message || "Failed to add file");
+    }
+  });
+  electron.ipcMain.handle("rename-memory-node-file", async (_, projectPath2, memoryFolderName, oldName, newName) => {
+    try {
+      const memoryPath = await ensureMemoryNodeFolder(projectPath2, memoryFolderName);
+      const oldPath = path.join(memoryPath, oldName);
+      const newPath = path.join(memoryPath, newName);
+      try {
+        await fs.promises.access(newPath);
+        throw new Error(`File "${newName}" already exists`);
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          throw err;
+        }
+      }
+      await fs.promises.rename(oldPath, newPath);
+      const metadata = await loadMemoryNodeMetadata(projectPath2, memoryFolderName);
+      if (metadata[oldName]) {
+        metadata[newName] = metadata[oldName];
+        delete metadata[oldName];
+        await saveMemoryNodeMetadata(projectPath2, memoryFolderName, metadata);
+      }
+      return { success: true };
+    } catch (error) {
+      console.error("Error renaming memory node file:", error);
+      throw new Error(error.message || "Failed to rename file");
+    }
+  });
+  electron.ipcMain.handle("update-memory-node-metadata", async (_, projectPath2, memoryFolderName, fileName, title, description) => {
+    try {
+      const metadata = await loadMemoryNodeMetadata(projectPath2, memoryFolderName);
+      if (!metadata[fileName]) {
+        metadata[fileName] = { created: (/* @__PURE__ */ new Date()).toISOString() };
+      }
+      metadata[fileName].title = title;
+      metadata[fileName].description = description;
+      await saveMemoryNodeMetadata(projectPath2, memoryFolderName, metadata);
+      return { success: true };
+    } catch (error) {
+      console.error("Error updating memory node metadata:", error);
+      throw new Error(error.message || "Failed to update metadata");
+    }
+  });
+  electron.ipcMain.handle("delete-memory-node-file", async (_, projectPath2, memoryFolderName, fileName) => {
+    try {
+      const memoryPath = await ensureMemoryNodeFolder(projectPath2, memoryFolderName);
+      const filePath = path.join(memoryPath, fileName);
+      await fs.promises.unlink(filePath);
+      const metadata = await loadMemoryNodeMetadata(projectPath2, memoryFolderName);
+      if (metadata[fileName]) {
+        delete metadata[fileName];
+        await saveMemoryNodeMetadata(projectPath2, memoryFolderName, metadata);
+      }
+      return { success: true };
+    } catch (error) {
+      console.error("Error deleting memory node file:", error);
+      throw new Error(error.message || "Failed to delete file");
+    }
+  });
+  electron.ipcMain.handle("read-memory-node-file", async (_, projectPath2, memoryFolderName, fileName) => {
+    try {
+      const memoryPath = await ensureMemoryNodeFolder(projectPath2, memoryFolderName);
+      const filePath = path.join(memoryPath, fileName);
+      const type = getFileType(fileName);
+      let content = null;
+      let dataUrl = null;
+      if (type === "image") {
+        const buffer = await fs.promises.readFile(filePath);
+        const ext = fileName.split(".").pop()?.toLowerCase() || "png";
+        const mimeType = ext === "svg" ? "image/svg+xml" : `image/${ext}`;
+        dataUrl = `data:${mimeType};base64,${buffer.toString("base64")}`;
+      } else if (type === "text" || type === "code") {
+        content = await fs.promises.readFile(filePath, "utf-8");
+      } else {
+        const stats = await fs.promises.stat(filePath);
+        content = `File size: ${(stats.size / 1024).toFixed(2)} KB`;
+      }
+      return {
+        success: true,
+        type,
+        content,
+        dataUrl
+      };
+    } catch (error) {
+      console.error("Error reading memory node file:", error);
+      throw new Error(error.message || "Failed to read file");
+    }
+  });
+  electron.ipcMain.handle("delete-memory-node-folder", async (_, projectPath2, memoryFolderName) => {
+    try {
+      const memoryPath = path.join(projectPath2, ".claude", "memory", memoryFolderName);
+      try {
+        await fs.promises.access(memoryPath);
+      } catch {
+        return { success: true };
+      }
+      await fs.promises.rm(memoryPath, { recursive: true, force: true });
+      return { success: true };
+    } catch (error) {
+      console.error("Error deleting memory node folder:", error);
+      throw new Error(error.message || "Failed to delete memory node folder");
+    }
+  });
+  const ensureSkillFolder = async (projectPath2, skillName) => {
+    const skillFolder = path.join(projectPath2, ".claude", "skills", skillName);
+    try {
+      await fs.promises.mkdir(skillFolder, { recursive: true });
+      await fs.promises.mkdir(path.join(skillFolder, "scripts"), { recursive: true });
+      await fs.promises.mkdir(path.join(skillFolder, "references"), { recursive: true });
+      await fs.promises.mkdir(path.join(skillFolder, "assets"), { recursive: true });
+      return skillFolder;
+    } catch (error) {
+      console.error("Error creating skill folder:", error);
+      throw error;
+    }
+  };
+  electron.ipcMain.handle("initialize-skill", async (_, projectPath2, skillName) => {
+    try {
+      const skillFolder = await ensureSkillFolder(projectPath2, skillName);
+      const skillMdPath = path.join(skillFolder, "SKILL.md");
+      try {
+        await fs.promises.access(skillMdPath);
+      } catch {
+        const defaultContent = `---
+name: ${skillName}
+description: Custom skill for specialized tasks
+---
+
+# ${skillName}
+
+## Overview
+
+Describe what this skill does and when to use it.
+
+## Instructions
+
+1. Step one
+2. Step two
+3. Step three
+`;
+        await fs.promises.writeFile(skillMdPath, defaultContent, "utf-8");
+      }
+      return { success: true };
+    } catch (error) {
+      console.error("Error initializing skill:", error);
+      throw new Error("Failed to initialize skill");
+    }
+  });
+  electron.ipcMain.handle("load-skill", async (_, projectPath2, skillName) => {
+    try {
+      const skillFolder = await ensureSkillFolder(projectPath2, skillName);
+      const skillMdPath = path.join(skillFolder, "SKILL.md");
+      let skillMdContent = "";
+      try {
+        skillMdContent = await fs.promises.readFile(skillMdPath, "utf-8");
+      } catch {
+        skillMdContent = `---
+name: ${skillName}
+description: Custom skill for specialized tasks
+---
+
+# ${skillName}
+
+## Overview
+
+Describe what this skill does and when to use it.
+
+## Instructions
+
+1. Step one
+2. Step two
+3. Step three
+`;
+        await fs.promises.writeFile(skillMdPath, skillMdContent, "utf-8");
+      }
+      const listFilesInFolder = async (folderPath, type) => {
+        try {
+          const files = await fs.promises.readdir(folderPath);
+          return await Promise.all(
+            files.map(async (name) => {
+              const filePath = path.join(folderPath, name);
+              const stats = await fs.promises.stat(filePath);
+              if (stats.isFile()) {
+                let language = void 0;
+                if (name.endsWith(".py")) language = "python";
+                else if (name.endsWith(".sh") || name.endsWith(".bash")) language = "bash";
+                else if (name.endsWith(".md")) language = "markdown";
+                else if (name.endsWith(".json")) language = "json";
+                else if (name.endsWith(".csv")) language = "csv";
+                return {
+                  name,
+                  path: filePath,
+                  type,
+                  language,
+                  size: stats.size
+                };
+              }
+              return null;
+            })
+          ).then((results) => results.filter((r) => r !== null));
+        } catch {
+          return [];
+        }
+      };
+      const scripts = await listFilesInFolder(path.join(skillFolder, "scripts"), "script");
+      const references = await listFilesInFolder(path.join(skillFolder, "references"), "reference");
+      const assets = await listFilesInFolder(path.join(skillFolder, "assets"), "asset");
+      return {
+        skillMdContent,
+        scripts,
+        references,
+        assets
+      };
+    } catch (error) {
+      console.error("Error loading skill:", error);
+      throw new Error("Failed to load skill");
+    }
+  });
+  electron.ipcMain.handle("save-skill-md", async (_, projectPath2, skillName, content) => {
+    try {
+      const skillFolder = await ensureSkillFolder(projectPath2, skillName);
+      const skillMdPath = path.join(skillFolder, "SKILL.md");
+      await fs.promises.writeFile(skillMdPath, content, "utf-8");
+      return { success: true };
+    } catch (error) {
+      console.error("Error saving SKILL.md:", error);
+      throw new Error("Failed to save SKILL.md");
+    }
+  });
+  electron.ipcMain.handle("select-file", async () => {
+    try {
+      const result = await electron.dialog.showOpenDialog({
+        properties: ["openFile"],
+        title: "Select File",
+        buttonLabel: "Select"
+      });
+      if (result.canceled || result.filePaths.length === 0) {
+        return { canceled: true };
+      }
+      const filePath = result.filePaths[0];
+      const fileName = filePath.split(/[/\\]/).pop() || "file";
+      return {
+        canceled: false,
+        path: filePath,
+        name: fileName
+      };
+    } catch (error) {
+      console.error("Error selecting file:", error);
+      throw new Error("Failed to select file");
+    }
+  });
+  electron.ipcMain.handle("open-path", async (_, path2) => {
+    try {
+      const result = await electron.shell.openPath(path2);
+      if (result) {
+        throw new Error(result);
+      }
+      return { success: true };
+    } catch (error) {
+      console.error("Error opening path:", error);
+      throw new Error("Failed to open path");
+    }
+  });
+  electron.ipcMain.handle("app:clear-cache", async () => {
+    try {
+      const { session } = require("electron");
+      await session.defaultSession.clearStorageData();
+      await session.defaultSession.clearCache();
+      return { success: true };
+    } catch (error) {
+      console.error("Error clearing cache:", error);
+      throw new Error("Failed to clear cache");
+    }
+  });
+  electron.ipcMain.handle("app:restart", async () => {
+    electron.app.relaunch();
+    electron.app.exit(0);
+  });
+  electron.ipcMain.handle("music:ensure-workspace-music", async (_, workspacePath) => {
+    try {
+      if (!workspacePath) throw new Error("workspacePath is required");
+      const musicDir = getWorkspaceMusicDir(workspacePath);
+      await fs.promises.mkdir(musicDir, { recursive: true });
+      return { success: true, path: musicDir };
+    } catch (error) {
+      console.error("Error ensuring workspace music folder:", error);
+      throw new Error(error.message || "Failed to ensure music folder");
+    }
+  });
+  electron.ipcMain.handle("music:get-workspace-music-path", async (_, workspacePath) => {
+    if (!workspacePath) return "";
+    return getWorkspaceMusicDir(workspacePath);
+  });
+  electron.ipcMain.handle("music:select-tracks", async () => {
+    try {
+      const result = await electron.dialog.showOpenDialog({
+        properties: ["openFile", "multiSelections"],
+        title: "Select Music Files",
+        buttonLabel: "Add to Playlist",
+        filters: [
+          { name: "Audio", extensions: ["mp3", "wav", "m4a", "ogg"] },
+          { name: "All Files", extensions: ["*"] }
+        ]
+      });
+      if (result.canceled || result.filePaths.length === 0) {
+        return { canceled: true };
+      }
+      return { canceled: false, paths: result.filePaths };
+    } catch (error) {
+      console.error("Error selecting tracks:", error);
+      throw new Error("Failed to select tracks");
+    }
+  });
+  electron.ipcMain.handle("music:add-tracks", async (_, workspacePath, sourcePaths) => {
+    try {
+      if (!workspacePath) throw new Error("workspacePath is required");
+      if (!Array.isArray(sourcePaths) || sourcePaths.length === 0) return { success: true, added: 0 };
+      const musicDir = getWorkspaceMusicDir(workspacePath);
+      await fs.promises.mkdir(musicDir, { recursive: true });
+      let added = 0;
+      for (const sourcePath of sourcePaths) {
+        const ext = path.extname(sourcePath).toLowerCase();
+        if (!SUPPORTED_AUDIO_EXTS.has(ext)) continue;
+        const base = path.basename(sourcePath);
+        const nameNoExt = base.slice(0, -ext.length);
+        let destName = base;
+        let destPath = path.join(musicDir, destName);
+        let n = 1;
+        while (true) {
+          try {
+            await fs.promises.access(destPath);
+            destName = `${nameNoExt} (${n})${ext}`;
+            destPath = path.join(musicDir, destName);
+            n++;
+          } catch {
+            break;
+          }
+        }
+        await fs.promises.copyFile(sourcePath, destPath);
+        added++;
+      }
+      return { success: true, added };
+    } catch (error) {
+      console.error("Error adding tracks:", error);
+      throw new Error(error.message || "Failed to add tracks");
+    }
+  });
+  electron.ipcMain.handle("music:list-tracks", async (_, workspacePath) => {
+    try {
+      const defaultDir = getDefaultMusicDir();
+      const defaultFiles = await listAudioFilesInDir(defaultDir);
+      const workspaceDir = workspacePath ? getWorkspaceMusicDir(workspacePath) : "";
+      const workspaceFiles = workspaceDir ? await listAudioFilesInDir(workspaceDir) : [];
+      const tracks = [
+        ...defaultFiles.map((filePath) => ({
+          id: `default:${filePath}`,
+          title: fileTitleFromPath(filePath),
+          source: "default",
+          filePath,
+          url: url.pathToFileURL(filePath).toString()
+        })),
+        ...workspaceFiles.map((filePath) => ({
+          id: `workspace:${filePath}`,
+          title: fileTitleFromPath(filePath),
+          source: "workspace",
+          filePath,
+          url: url.pathToFileURL(filePath).toString()
+        }))
+      ];
+      return tracks;
+    } catch (error) {
+      console.error("Error listing tracks:", error);
+      return [];
+    }
+  });
+  electron.ipcMain.handle("music:read-track", async (_, filePath) => {
+    try {
+      if (!filePath) throw new Error("filePath is required");
+      const ext = path.extname(filePath).toLowerCase();
+      if (!SUPPORTED_AUDIO_EXTS.has(ext)) {
+        throw new Error(`Unsupported audio type: ${ext}`);
+      }
+      await fs.promises.access(filePath);
+      const bytes = await fs.promises.readFile(filePath);
+      const mime = ext === ".mp3" ? "audio/mpeg" : ext === ".wav" ? "audio/wav" : ext === ".m4a" ? "audio/mp4" : ext === ".ogg" ? "audio/ogg" : "application/octet-stream";
+      return { success: true, bytes, mime };
+    } catch (error) {
+      console.error("Error reading track:", error);
+      return { success: false, error: error.message || "Failed to read track" };
+    }
+  });
+  electron.ipcMain.handle(
+    "add-skill-file",
+    async (_, projectPath2, skillName, sourcePath, fileName, fileType) => {
+      try {
+        const skillFolder = await ensureSkillFolder(projectPath2, skillName);
+        let destFolder = skillFolder;
+        if (fileType === "script") destFolder = path.join(skillFolder, "scripts");
+        else if (fileType === "reference") destFolder = path.join(skillFolder, "references");
+        else if (fileType === "asset") destFolder = path.join(skillFolder, "assets");
+        const destPath = path.join(destFolder, fileName);
+        try {
+          await fs.promises.access(destPath);
+          throw new Error(`File "${fileName}" already exists`);
+        } catch {
+        }
+        await fs.promises.copyFile(sourcePath, destPath);
+        const stats = await fs.promises.stat(destPath);
+        let language = void 0;
+        if (fileName.endsWith(".py")) language = "python";
+        else if (fileName.endsWith(".sh") || fileName.endsWith(".bash")) language = "bash";
+        else if (fileName.endsWith(".md")) language = "markdown";
+        else if (fileName.endsWith(".json")) language = "json";
+        else if (fileName.endsWith(".csv")) language = "csv";
+        return {
+          success: true,
+          file: {
+            name: fileName,
+            path: destPath,
+            type: fileType,
+            language,
+            size: stats.size
+          }
+        };
+      } catch (error) {
+        console.error("Error adding skill file:", error);
+        throw new Error(error.message || "Failed to add file");
+      }
+    }
+  );
+  electron.ipcMain.handle("delete-skill-file", async (_, filePath) => {
+    try {
+      await fs.promises.unlink(filePath);
+      return { success: true };
+    } catch (error) {
+      console.error("Error deleting skill file:", error);
+      throw new Error("Failed to delete file");
+    }
+  });
+  electron.ipcMain.handle("delete-skill-folder", async (_, projectPath2, skillName) => {
+    try {
+      const skillFolder = path.join(projectPath2, ".claude", "skills", skillName);
+      await fs.promises.rm(skillFolder, { recursive: true, force: true });
+      return { success: true };
+    } catch (error) {
+      console.error("Error deleting skill folder:", error);
+      throw new Error("Failed to delete skill folder");
+    }
+  });
+  electron.ipcMain.handle("scan-skills-folder", async (_, projectPath2) => {
+    try {
+      const skillsFolder = path.join(projectPath2, ".claude", "skills");
+      try {
+        await fs.promises.access(skillsFolder);
+      } catch {
+        return { skills: [] };
+      }
+      const entries = await fs.promises.readdir(skillsFolder, { withFileTypes: true });
+      const skillFolders = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+      return { skills: skillFolders };
+    } catch (error) {
+      console.error("Error scanning skills folder:", error);
+      throw new Error("Failed to scan skills folder");
+    }
+  });
+  const ensureSubagentFolder = async (projectPath2) => {
+    const subagentPath = path.join(projectPath2, ".claude", "agents");
+    try {
+      await fs.promises.mkdir(subagentPath, { recursive: true });
+      return subagentPath;
+    } catch (error) {
+      console.error("Error creating subagent folder:", error);
+      throw error;
+    }
+  };
+  const parseSubagentFile = (content) => {
+    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (match) {
+      try {
+        const frontmatter = yaml.load(match[1]);
+        const markdown = match[2].trim();
+        return { frontmatter, markdown };
+      } catch (error) {
+        console.error("Error parsing YAML frontmatter:", error);
+        throw new Error("Invalid YAML frontmatter");
+      }
+    }
+    return { frontmatter: {}, markdown: content.trim() };
+  };
+  const generateSubagentFile = (frontmatter, markdown) => {
+    const yamlString = yaml.dump(frontmatter, { lineWidth: -1, noRefs: true });
+    return `---
+${yamlString}---
+
+${markdown}`;
+  };
+  electron.ipcMain.handle("list-subagent-files", async (_, projectPath2) => {
+    try {
+      const subagentPath = await ensureSubagentFolder(projectPath2);
+      const allFiles = await fs.promises.readdir(subagentPath);
+      const mdFiles = allFiles.filter((f) => f.endsWith(".md"));
+      const fileInfos = await Promise.all(
+        mdFiles.map(async (fileName) => {
+          const filePath = path.join(subagentPath, fileName);
+          const content = await fs.promises.readFile(filePath, "utf-8");
+          const stats = await fs.promises.stat(filePath);
+          const { frontmatter } = parseSubagentFile(content);
+          return {
+            fileName,
+            path: filePath,
+            name: frontmatter.name || fileName.replace(".md", ""),
+            description: frontmatter.description || "",
+            tools: frontmatter.tools || "",
+            model: frontmatter.model || "",
+            permissionMode: frontmatter.permissionMode || "",
+            skills: frontmatter.skills || "",
+            created: stats.birthtime.toISOString(),
+            modified: stats.mtime.toISOString()
+          };
+        })
+      );
+      fileInfos.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
+      return fileInfos;
+    } catch (error) {
+      console.error("Error listing subagent files:", error);
+      return [];
+    }
+  });
+  electron.ipcMain.handle("read-subagent-file", async (_, projectPath2, fileName) => {
+    try {
+      const subagentPath = await ensureSubagentFolder(projectPath2);
+      const filePath = path.join(subagentPath, fileName);
+      const content = await fs.promises.readFile(filePath, "utf-8");
+      const { frontmatter, markdown } = parseSubagentFile(content);
+      return {
+        success: true,
+        fileName,
+        frontmatter: {
+          name: frontmatter.name || "",
+          description: frontmatter.description || "",
+          tools: frontmatter.tools || "",
+          model: frontmatter.model || "",
+          permissionMode: frontmatter.permissionMode || "",
+          skills: frontmatter.skills || ""
+        },
+        markdown
+      };
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        console.error("Error reading subagent file:", error);
+      }
+      throw new Error(error.message || "Failed to read subagent file");
+    }
+  });
+  electron.ipcMain.handle("write-subagent-file", async (_, projectPath2, fileName, frontmatter, markdown) => {
+    try {
+      const subagentPath = await ensureSubagentFolder(projectPath2);
+      const filePath = path.join(subagentPath, fileName);
+      const cleanedFrontmatter = {
+        name: frontmatter.name,
+        description: frontmatter.description
+      };
+      if (frontmatter.tools && frontmatter.tools.trim()) {
+        cleanedFrontmatter["tools"] = frontmatter.tools;
+      }
+      if (frontmatter.model && frontmatter.model.trim()) {
+        cleanedFrontmatter["model"] = frontmatter.model;
+      }
+      if (frontmatter.permissionMode && frontmatter.permissionMode.trim()) {
+        cleanedFrontmatter["permissionMode"] = frontmatter.permissionMode;
+      }
+      if (frontmatter.skills && frontmatter.skills.trim()) {
+        cleanedFrontmatter["skills"] = frontmatter.skills;
+      }
+      const content = generateSubagentFile(cleanedFrontmatter, markdown);
+      await fs.promises.writeFile(filePath, content, "utf-8");
+      return { success: true };
+    } catch (error) {
+      console.error("Error writing subagent file:", error);
+      throw new Error(error.message || "Failed to write subagent file");
+    }
+  });
+  electron.ipcMain.handle("rename-subagent-file", async (_, projectPath2, oldFileName, newFileName) => {
+    try {
+      const subagentPath = await ensureSubagentFolder(projectPath2);
+      const oldFilePath = path.join(subagentPath, oldFileName);
+      const newFilePath = path.join(subagentPath, newFileName);
+      await fs.promises.rename(oldFilePath, newFilePath);
+      return { success: true };
+    } catch (error) {
+      console.error("Error renaming subagent file:", error);
+      throw new Error(error.message || "Failed to rename subagent file");
+    }
+  });
+  electron.ipcMain.handle("delete-subagent-file", async (_, projectPath2, fileName) => {
+    try {
+      const subagentPath = await ensureSubagentFolder(projectPath2);
+      const filePath = path.join(subagentPath, fileName);
+      await fs.promises.unlink(filePath);
+      return { success: true };
+    } catch (error) {
+      console.error("Error deleting subagent file:", error);
+      throw new Error(error.message || "Failed to delete subagent file");
+    }
+  });
+  electron.ipcMain.handle("scan-agents-folder", async (_, projectPath2) => {
+    try {
+      const agentsFolder = path.join(projectPath2, ".claude", "agents");
+      try {
+        await fs.promises.access(agentsFolder);
+      } catch {
+        return { agents: [] };
+      }
+      const files = await fs.promises.readdir(agentsFolder);
+      const mdFiles = files.filter((f) => f.endsWith(".md"));
+      return { agents: mdFiles };
+    } catch (error) {
+      console.error("Error scanning agents folder:", error);
+      throw new Error("Failed to scan agents folder");
+    }
+  });
+  const ensureCommandFolder = async (projectPath2) => {
+    const commandPath = path.join(projectPath2, ".claude", "commands");
+    try {
+      await fs.promises.mkdir(commandPath, { recursive: true });
+      return commandPath;
+    } catch (error) {
+      console.error("Error creating command folder:", error);
+      throw error;
+    }
+  };
+  const parseCommandFile = (content) => {
+    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (match) {
+      try {
+        const frontmatter = yaml.load(match[1]);
+        const markdown = match[2].trim();
+        return { frontmatter, markdown };
+      } catch (error) {
+        console.error("Error parsing YAML frontmatter:", error);
+        throw new Error("Invalid YAML frontmatter");
+      }
+    }
+    return { frontmatter: {}, markdown: content.trim() };
+  };
+  const generateCommandFile = (frontmatter, markdown) => {
+    const yamlString = yaml.dump(frontmatter, { lineWidth: -1, noRefs: true });
+    return `---
+${yamlString}---
+
+${markdown}`;
+  };
+  electron.ipcMain.handle("list-command-files", async (_, projectPath2) => {
+    try {
+      const commandPath = await ensureCommandFolder(projectPath2);
+      const allFiles = await fs.promises.readdir(commandPath);
+      const mdFiles = allFiles.filter((f) => f.endsWith(".md"));
+      const fileInfos = await Promise.all(
+        mdFiles.map(async (fileName) => {
+          const filePath = path.join(commandPath, fileName);
+          const content = await fs.promises.readFile(filePath, "utf-8");
+          const stats = await fs.promises.stat(filePath);
+          const { frontmatter } = parseCommandFile(content);
+          return {
+            fileName,
+            path: filePath,
+            name: frontmatter.name || fileName.replace(".md", ""),
+            description: frontmatter.description || "",
+            created: stats.birthtime.toISOString(),
+            modified: stats.mtime.toISOString()
+          };
+        })
+      );
+      fileInfos.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
+      return fileInfos;
+    } catch (error) {
+      console.error("Error listing command files:", error);
+      return [];
+    }
+  });
+  electron.ipcMain.handle("read-command-file", async (_, projectPath2, fileName) => {
+    try {
+      const commandPath = await ensureCommandFolder(projectPath2);
+      const filePath = path.join(commandPath, fileName);
+      const content = await fs.promises.readFile(filePath, "utf-8");
+      const { frontmatter, markdown } = parseCommandFile(content);
+      return {
+        success: true,
+        fileName,
+        frontmatter: {
+          name: frontmatter.name || "",
+          description: frontmatter.description || "",
+          // Command configuration fields (using kebab-case from YAML)
+          allowedTools: frontmatter["allowed-tools"] || "",
+          argumentHint: frontmatter["argument-hint"] || "",
+          model: frontmatter.model || ""
+        },
+        markdown
+      };
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        console.error("Error reading command file:", error);
+      }
+      throw new Error(error.message || "Failed to read command file");
+    }
+  });
+  electron.ipcMain.handle("write-command-file", async (_, projectPath2, fileName, frontmatter, markdown) => {
+    try {
+      const commandPath = await ensureCommandFolder(projectPath2);
+      const filePath = path.join(commandPath, fileName);
+      const cleanedFrontmatter = {};
+      if (frontmatter.name) cleanedFrontmatter.name = frontmatter.name;
+      if (frontmatter.description) cleanedFrontmatter.description = frontmatter.description;
+      if (frontmatter.allowedTools) cleanedFrontmatter["allowed-tools"] = frontmatter.allowedTools;
+      if (frontmatter.argumentHint) cleanedFrontmatter["argument-hint"] = frontmatter.argumentHint;
+      if (frontmatter.model) cleanedFrontmatter.model = frontmatter.model;
+      const content = generateCommandFile(cleanedFrontmatter, markdown);
+      await fs.promises.writeFile(filePath, content, "utf-8");
+      return { success: true };
+    } catch (error) {
+      console.error("Error writing command file:", error);
+      throw new Error(error.message || "Failed to write command file");
+    }
+  });
+  electron.ipcMain.handle("rename-command-file", async (_, projectPath2, oldFileName, newFileName) => {
+    try {
+      const commandPath = await ensureCommandFolder(projectPath2);
+      const oldFilePath = path.join(commandPath, oldFileName);
+      const newFilePath = path.join(commandPath, newFileName);
+      await fs.promises.rename(oldFilePath, newFilePath);
+      return { success: true };
+    } catch (error) {
+      console.error("Error renaming command file:", error);
+      throw new Error(error.message || "Failed to rename command file");
+    }
+  });
+  electron.ipcMain.handle("delete-command-file", async (_, projectPath2, fileName) => {
+    try {
+      const commandPath = await ensureCommandFolder(projectPath2);
+      const filePath = path.join(commandPath, fileName);
+      await fs.promises.unlink(filePath);
+      return { success: true };
+    } catch (error) {
+      console.error("Error deleting command file:", error);
+      throw new Error(error.message || "Failed to delete command file");
+    }
+  });
+  electron.ipcMain.handle("scan-commands-folder", async (_, projectPath2) => {
+    try {
+      const commandsFolder = path.join(projectPath2, ".claude", "commands");
+      try {
+        await fs.promises.access(commandsFolder);
+      } catch {
+        return { commands: [] };
+      }
+      const files = await fs.promises.readdir(commandsFolder);
+      const mdFiles = files.filter((f) => f.endsWith(".md"));
+      return { commands: mdFiles };
+    } catch (error) {
+      console.error("Error scanning commands folder:", error);
+      throw new Error("Failed to scan commands folder");
+    }
+  });
+  const ensureHooksFolder = async (projectPath2) => {
+    const hooksPath = path.join(projectPath2, ".claude", "hooks");
+    try {
+      await fs.promises.mkdir(hooksPath, { recursive: true });
+      return hooksPath;
+    } catch (error) {
+      console.error("Error creating hooks folder:", error);
+      throw error;
+    }
+  };
+  electron.ipcMain.handle("list-hook-files", async (_, projectPath2) => {
+    try {
+      const hooksPath = await ensureHooksFolder(projectPath2);
+      const allFiles = await fs.promises.readdir(hooksPath);
+      const shFiles = allFiles.filter((f) => f.endsWith(".sh"));
+      const fileInfos = await Promise.all(
+        shFiles.map(async (fileName) => {
+          const filePath = path.join(hooksPath, fileName);
+          const stats = await fs.promises.stat(filePath);
+          return {
+            fileName,
+            path: filePath,
+            created: stats.birthtime.toISOString(),
+            modified: stats.mtime.toISOString()
+          };
+        })
+      );
+      return fileInfos.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
+    } catch (error) {
+      console.error("Error listing hook files:", error);
+      return [];
+    }
+  });
+  electron.ipcMain.handle("read-hook-file", async (_, projectPath2, fileName) => {
+    try {
+      const hooksPath = await ensureHooksFolder(projectPath2);
+      const filePath = path.join(hooksPath, fileName);
+      const content = await fs.promises.readFile(filePath, "utf-8");
+      return {
+        success: true,
+        fileName,
+        content
+      };
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        console.error("Error reading hook file:", error);
+      }
+      throw new Error(error.message || "Failed to read hook file");
+    }
+  });
+  electron.ipcMain.handle("write-hook-file", async (_, projectPath2, fileName, content) => {
+    try {
+      const hooksPath = await ensureHooksFolder(projectPath2);
+      const filePath = path.join(hooksPath, fileName);
+      await fs.promises.writeFile(filePath, content, "utf-8");
+      if (process.platform !== "win32") {
+        await fs.promises.chmod(filePath, 493);
+      }
+      return { success: true };
+    } catch (error) {
+      console.error("Error writing hook file:", error);
+      throw new Error(error.message || "Failed to write hook file");
+    }
+  });
+  electron.ipcMain.handle("rename-hook-file", async (_, projectPath2, oldFileName, newFileName) => {
+    try {
+      const hooksPath = await ensureHooksFolder(projectPath2);
+      const oldFilePath = path.join(hooksPath, oldFileName);
+      const newFilePath = path.join(hooksPath, newFileName);
+      await fs.promises.rename(oldFilePath, newFilePath);
+      return { success: true };
+    } catch (error) {
+      console.error("Error renaming hook file:", error);
+      throw new Error(error.message || "Failed to rename hook file");
+    }
+  });
+  electron.ipcMain.handle("delete-hook-file", async (_, projectPath2, fileName) => {
+    try {
+      const hooksPath = await ensureHooksFolder(projectPath2);
+      const filePath = path.join(hooksPath, fileName);
+      await fs.promises.unlink(filePath);
+      return { success: true };
+    } catch (error) {
+      console.error("Error deleting hook file:", error);
+      throw new Error(error.message || "Failed to delete hook file");
+    }
+  });
+  electron.ipcMain.handle("scan-hooks-folder", async (_, projectPath2) => {
+    try {
+      const hooksFolder = path.join(projectPath2, ".claude", "hooks");
+      try {
+        await fs.promises.access(hooksFolder);
+      } catch {
+        return { hooks: [] };
+      }
+      const files = await fs.promises.readdir(hooksFolder);
+      const shFiles = files.filter((f) => f.endsWith(".sh"));
+      return { hooks: shFiles };
+    } catch (error) {
+      console.error("Error scanning hooks folder:", error);
+      throw new Error("Failed to scan hooks folder");
+    }
+  });
+  electron.ipcMain.handle("select-project-folder", async () => {
+    try {
+      const result = await electron.dialog.showOpenDialog({
+        properties: ["openDirectory"],
+        title: "Select Project Folder",
+        buttonLabel: "Select Project"
+      });
+      if (result.canceled || result.filePaths.length === 0) {
+        return { canceled: true };
+      }
+      return { canceled: false, path: result.filePaths[0] };
+    } catch (error) {
+      console.error("Error selecting project folder:", error);
+      throw new Error("Failed to select project folder");
+    }
+  });
+  electron.ipcMain.handle("validate-project", async (_, projectPath2) => {
+    try {
+      const workflowPath = path.join(projectPath2, ".claude", "workflow.json");
+      await fs.promises.access(workflowPath);
+      return { valid: true };
+    } catch {
+      return { valid: false };
+    }
+  });
+  electron.ipcMain.handle("check-claude-folder", async (_, projectPath2) => {
+    try {
+      console.log("[Main] check-claude-folder called with:", projectPath2);
+      const claudePath = path.join(projectPath2, ".claude");
+      const workflowPath = path.join(claudePath, "workflow.json");
+      console.log("[Main] Checking paths:", { claudePath, workflowPath });
+      let claudeFolderExists = false;
+      try {
+        const stats = await fs.promises.stat(claudePath);
+        claudeFolderExists = stats.isDirectory();
+        console.log("[Main] .claude folder exists:", claudeFolderExists);
+      } catch (err) {
+        claudeFolderExists = false;
+        console.log("[Main] .claude folder does not exist");
+      }
+      let workflowExists = false;
+      try {
+        await fs.promises.access(workflowPath);
+        workflowExists = true;
+        console.log("[Main] workflow.json exists:", workflowExists);
+      } catch (err) {
+        workflowExists = false;
+        console.log("[Main] workflow.json does not exist");
+      }
+      const result = {
+        success: true,
+        claudeFolderExists,
+        workflowExists
+      };
+      console.log("[Main] Returning result:", result);
+      return result;
+    } catch (error) {
+      console.error("[Main] Error checking claude folder:", error);
+      return {
+        success: false,
+        claudeFolderExists: false,
+        workflowExists: false,
+        error: error.message
+      };
+    }
+  });
+  electron.ipcMain.handle("list-projects", async (_, workspacePath) => {
+    try {
+      const entries = await fs.promises.readdir(workspacePath, { withFileTypes: true });
+      const projects = [];
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const projectPath2 = path.join(workspacePath, entry.name);
+          const claudeFolderPath = path.join(projectPath2, ".claude");
+          const workflowPath = path.join(claudeFolderPath, "workflow.json");
+          try {
+            await fs.promises.access(workflowPath);
+            let metadata = { name: entry.name, created: null, modified: null, iconImage: null, systemPrompt: null };
+            try {
+              const workflowContent = await fs.promises.readFile(workflowPath, "utf-8");
+              const workflow = JSON.parse(workflowContent);
+              let iconImage = null;
+              let systemPrompt = null;
+              let agentName = workflow.name || entry.name;
+              if (workflow.visual && workflow.visual.nodes) {
+                const mainCard = workflow.visual.nodes.find((node) => node.id === "main-card");
+                if (mainCard && mainCard.data) {
+                  iconImage = mainCard.data.iconImage || null;
+                  systemPrompt = mainCard.data.systemPrompt || mainCard.data.description || null;
+                  agentName = mainCard.data.name || workflow.name || entry.name;
+                }
+              }
+              metadata = {
+                name: agentName,
+                created: workflow.created,
+                modified: workflow.modified,
+                iconImage,
+                systemPrompt
+              };
+            } catch {
+            }
+            projects.push({
+              folderName: entry.name,
+              path: projectPath2,
+              ...metadata
+            });
+          } catch {
+          }
+        }
+      }
+      return projects;
+    } catch (error) {
+      console.error("Error listing projects:", error);
+      return [];
+    }
+  });
+  electron.ipcMain.handle("create-project-at", async (_, targetPath, projectName) => {
+    try {
+      const projectPath2 = path.join(targetPath, projectName);
+      const claudeFolder = path.join(projectPath2, ".claude");
+      try {
+        await fs.promises.access(projectPath2);
+        throw new Error("Project folder already exists");
+      } catch (err) {
+        if (err.code !== "ENOENT" && err.message !== "Project folder already exists") {
+          throw err;
+        }
+        if (err.message === "Project folder already exists") {
+          throw err;
+        }
+      }
+      await fs.promises.mkdir(claudeFolder, { recursive: true });
+      await fs.promises.mkdir(path.join(claudeFolder, "agents"), { recursive: true });
+      await fs.promises.mkdir(path.join(claudeFolder, "skills"), { recursive: true });
+      await fs.promises.mkdir(path.join(claudeFolder, "memory"), { recursive: true });
+      const initialWorkflow = {
+        version: "1.0",
+        name: projectName,
+        created: (/* @__PURE__ */ new Date()).toISOString(),
+        modified: (/* @__PURE__ */ new Date()).toISOString(),
+        visual: {
+          nodes: [],
+          edges: []
+        },
+        connections: {
+          interface: [],
+          memory: [],
+          skills: [],
+          mcp: [],
+          subagents: []
+        }
+      };
+      await fs.promises.writeFile(
+        path.join(claudeFolder, "workflow.json"),
+        JSON.stringify(initialWorkflow, null, 2),
+        "utf-8"
+      );
+      return { success: true, path: projectPath2 };
+    } catch (error) {
+      console.error("Error creating project:", error);
+      throw new Error(error.message || "Failed to create project");
+    }
+  });
+  electron.ipcMain.handle("save-project", async (_, projectPath2, workflowData) => {
+    try {
+      const claudeFolder = path.join(projectPath2, ".claude");
+      const workflowPath = path.join(claudeFolder, "workflow.json");
+      await fs.promises.mkdir(claudeFolder, { recursive: true });
+      const updatedWorkflow = {
+        ...workflowData,
+        modified: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await fs.promises.writeFile(workflowPath, JSON.stringify(updatedWorkflow, null, 2), "utf-8");
+      const mainCard = updatedWorkflow.visual?.nodes?.find((node) => node.id === "main-card");
+      if (mainCard && mainCard.data) {
+        const claudeMdPath = path.join(claudeFolder, "CLAUDE.md");
+        const systemPrompt = mainCard.data.systemPrompt || "";
+        await fs.promises.writeFile(claudeMdPath, systemPrompt, "utf-8");
+      }
+      return { success: true };
+    } catch (error) {
+      console.error("Error saving project:", error);
+      throw new Error(error.message || "Failed to save project");
+    }
+  });
+  electron.ipcMain.handle("load-project", async (_, projectPath2) => {
+    try {
+      const workflowPath = path.join(projectPath2, ".claude", "workflow.json");
+      const content = await fs.promises.readFile(workflowPath, "utf-8");
+      const workflow = JSON.parse(content);
+      return workflow;
+    } catch (error) {
+      console.error("Error loading project:", error);
+      throw new Error("Failed to load project");
+    }
+  });
+  electron.ipcMain.handle("delete-project", async (_, projectPath2) => {
+    try {
+      await fs.promises.rm(projectPath2, { recursive: true, force: true });
+      return { success: true };
+    } catch (error) {
+      console.error("Error deleting project:", error);
+      throw new Error("Failed to delete project");
+    }
+  });
+  electron.ipcMain.handle("select-export-location", async () => {
+    try {
+      const result = await electron.dialog.showOpenDialog({
+        properties: ["openDirectory", "createDirectory"],
+        title: "Select Export Location",
+        buttonLabel: "Export Here"
+      });
+      if (result.canceled || result.filePaths.length === 0) {
+        return { canceled: true };
+      }
+      return { canceled: false, path: result.filePaths[0] };
+    } catch (error) {
+      console.error("Error selecting export location:", error);
+      throw new Error("Failed to select export location");
+    }
+  });
+  electron.ipcMain.handle(
+    "export-claude-folder",
+    async (_, exportPath, projectName, exportData) => {
+      try {
+        const projectFolder = path.join(exportPath, projectName);
+        const claudeFolder = path.join(projectFolder, ".claude");
+        await fs.promises.mkdir(claudeFolder, { recursive: true });
+        await fs.promises.mkdir(path.join(claudeFolder, "agents"), { recursive: true });
+        await fs.promises.mkdir(path.join(claudeFolder, "skills"), { recursive: true });
+        await fs.promises.mkdir(path.join(claudeFolder, "memory"), { recursive: true });
+        await fs.promises.writeFile(
+          path.join(claudeFolder, "settings.json"),
+          JSON.stringify(exportData.settings, null, 2),
+          "utf-8"
+        );
+        if (exportData.settingsLocal) {
+          await fs.promises.writeFile(
+            path.join(claudeFolder, "settings.local.json"),
+            JSON.stringify(exportData.settingsLocal, null, 2),
+            "utf-8"
+          );
+        }
+        if (exportData.mcpJson) {
+          await fs.promises.writeFile(
+            path.join(projectFolder, ".mcp.json"),
+            JSON.stringify(exportData.mcpJson, null, 2),
+            "utf-8"
+          );
+        }
+        for (const [agentId, content] of Object.entries(exportData.agents)) {
+          const fileName = `${agentId}.md`;
+          await fs.promises.writeFile(path.join(claudeFolder, "agents", fileName), content, "utf-8");
+        }
+        for (const [fileName, content] of Object.entries(exportData.skills)) {
+          await fs.promises.writeFile(path.join(claudeFolder, "skills", fileName), content, "utf-8");
+        }
+        for (const [fileName, content] of Object.entries(exportData.memory)) {
+          await fs.promises.writeFile(path.join(claudeFolder, "memory", fileName), content, "utf-8");
+        }
+        return { success: true, path: projectFolder };
+      } catch (error) {
+        console.error("Error exporting Claude folder:", error);
+        throw new Error(error.message || "Failed to export project");
+      }
+    }
+  );
+  electron.ipcMain.handle("select-import-folder", async () => {
+    try {
+      const result = await electron.dialog.showOpenDialog({
+        properties: ["openDirectory"],
+        title: "Select .claude Folder to Import",
+        buttonLabel: "Import"
+      });
+      if (result.canceled || result.filePaths.length === 0) {
+        return { canceled: true };
+      }
+      return { canceled: false, path: result.filePaths[0] };
+    } catch (error) {
+      console.error("Error selecting import folder:", error);
+      throw new Error("Failed to select import folder");
+    }
+  });
+  electron.ipcMain.handle("import-claude-folder", async (_, claudeFolderPath) => {
+    try {
+      const settingsPath = path.join(claudeFolderPath, "settings.json");
+      const settingsContent = await fs.promises.readFile(settingsPath, "utf-8");
+      const settings = JSON.parse(settingsContent);
+      let settingsLocal = void 0;
+      try {
+        const settingsLocalPath = path.join(claudeFolderPath, "settings.local.json");
+        const settingsLocalContent = await fs.promises.readFile(settingsLocalPath, "utf-8");
+        settingsLocal = JSON.parse(settingsLocalContent);
+      } catch {
+      }
+      let mcpJson = void 0;
+      try {
+        const projectRoot = path.join(claudeFolderPath, "..");
+        const mcpJsonPath = path.join(projectRoot, ".mcp.json");
+        const mcpJsonContent = await fs.promises.readFile(mcpJsonPath, "utf-8");
+        mcpJson = JSON.parse(mcpJsonContent);
+      } catch {
+      }
+      const agentsFolder = path.join(claudeFolderPath, "agents");
+      const agentContents = {};
+      try {
+        const agentFiles = await fs.promises.readdir(agentsFolder);
+        for (const file of agentFiles) {
+          if (file.endsWith(".md")) {
+            const content = await fs.promises.readFile(path.join(agentsFolder, file), "utf-8");
+            agentContents[file] = content;
+          }
+        }
+      } catch {
+      }
+      const skillsFolder = path.join(claudeFolderPath, "skills");
+      const skillContents = {};
+      try {
+        const skillFiles = await fs.promises.readdir(skillsFolder);
+        for (const file of skillFiles) {
+          const content = await fs.promises.readFile(path.join(skillsFolder, file), "utf-8");
+          skillContents[file] = content;
+        }
+      } catch {
+      }
+      const memoryFolder = path.join(claudeFolderPath, "memory");
+      const memoryContents = {};
+      try {
+        const memoryFiles = await fs.promises.readdir(memoryFolder);
+        for (const file of memoryFiles) {
+          const content = await fs.promises.readFile(path.join(memoryFolder, file), "utf-8");
+          memoryContents[file] = content;
+        }
+      } catch {
+      }
+      return {
+        success: true,
+        data: {
+          settings,
+          settingsLocal,
+          mcpJson,
+          agentContents,
+          skillContents,
+          memoryContents
+        }
+      };
+    } catch (error) {
+      console.error("Error importing Claude folder:", error);
+      throw new Error(error.message || "Failed to import project");
+    }
+  });
+  electron.ipcMain.handle("load-settings-local", async (_, projectPath2) => {
+    try {
+      const claudeFolderPath = path.join(projectPath2, ".claude");
+      const settingsLocalPath = path.join(claudeFolderPath, "settings.local.json");
+      try {
+        await fs.promises.access(settingsLocalPath);
+      } catch {
+        return { success: true, settings: {} };
+      }
+      const content = await fs.promises.readFile(settingsLocalPath, "utf-8");
+      const settings = JSON.parse(content);
+      return {
+        success: true,
+        settings
+      };
+    } catch (error) {
+      console.error("Error loading settings.local.json:", error);
+      return { success: false, settings: {} };
+    }
+  });
+  electron.ipcMain.handle("save-settings-local", async (_, projectPath2, settings) => {
+    try {
+      const claudeFolderPath = path.join(projectPath2, ".claude");
+      const settingsLocalPath = path.join(claudeFolderPath, "settings.local.json");
+      await fs.promises.mkdir(claudeFolderPath, { recursive: true });
+      await fs.promises.writeFile(settingsLocalPath, JSON.stringify(settings, null, 2), "utf-8");
+      return { success: true };
+    } catch (error) {
+      console.error("Error saving settings.local.json:", error);
+      return { success: false };
+    }
+  });
+  electron.ipcMain.handle("load-mcp-json", async (_, projectPath2) => {
+    try {
+      const mcpJsonPath = path.join(projectPath2, ".mcp.json");
+      try {
+        await fs.promises.access(mcpJsonPath);
+      } catch {
+        return { success: true, mcpJson: null };
+      }
+      const content = await fs.promises.readFile(mcpJsonPath, "utf-8");
+      const mcpJson = JSON.parse(content);
+      return {
+        success: true,
+        mcpJson
+      };
+    } catch (error) {
+      console.error("Error loading .mcp.json:", error);
+      return { success: false, mcpJson: null };
+    }
+  });
+  electron.ipcMain.handle("save-mcp-json", async (_, projectPath2, mcpJson) => {
+    try {
+      const mcpJsonPath = path.join(projectPath2, ".mcp.json");
+      await fs.promises.writeFile(mcpJsonPath, JSON.stringify(mcpJson, null, 2), "utf-8");
+      return { success: true };
+    } catch (error) {
+      console.error("Error saving .mcp.json:", error);
+      return { success: false };
+    }
+  });
+  const getGlobalIconsPath = async () => {
+    const iconsPath = path.join(electron.app.getPath("userData"), "user-icons");
+    await fs.promises.mkdir(iconsPath, { recursive: true });
+    return iconsPath;
+  };
+  electron.ipcMain.handle("icons:list", async () => {
+    try {
+      const iconsPath = await getGlobalIconsPath();
+      const files = await fs.promises.readdir(iconsPath, { withFileTypes: true });
+      const iconFiles = await Promise.all(
+        files.filter((f) => f.isFile() && /\.(png|gif|svg)$/i.test(f.name)).map(async (file) => {
+          const filePath = path.join(iconsPath, file.name);
+          const stats = await fs.promises.stat(filePath);
+          const ext = path.extname(file.name).toLowerCase().slice(1);
+          return {
+            id: path.basename(file.name, path.extname(file.name)),
+            name: file.name,
+            path: filePath,
+            size: stats.size,
+            type: ext,
+            dateAdded: stats.birthtime.toISOString()
+          };
+        })
+      );
+      return iconFiles.sort((a, b) => a.name.localeCompare(b.name));
+    } catch (error) {
+      console.error("Error listing user icons:", error);
+      return [];
+    }
+  });
+  electron.ipcMain.handle("icons:add", async (_, sourcePath) => {
+    try {
+      const iconsPath = await getGlobalIconsPath();
+      const fileName = path.basename(sourcePath);
+      const ext = path.extname(fileName).toLowerCase();
+      if (![".png", ".gif", ".svg"].includes(ext)) {
+        throw new Error("Invalid file type. Only PNG, GIF, and SVG are supported.");
+      }
+      const stats = await fs.promises.stat(sourcePath);
+      const MAX_SIZE = 10 * 1024 * 1024;
+      if (stats.size > MAX_SIZE) {
+        throw new Error(`File too large. Maximum size is ${MAX_SIZE / 1024 / 1024}MB.`);
+      }
+      const destPath = path.join(iconsPath, fileName);
+      try {
+        await fs.promises.access(destPath);
+        throw new Error(`Icon "${fileName}" already exists`);
+      } catch (err) {
+        if (err.code !== "ENOENT") throw err;
+      }
+      await fs.promises.copyFile(sourcePath, destPath);
+      return {
+        success: true,
+        icon: {
+          id: path.basename(fileName, ext),
+          name: fileName,
+          path: destPath,
+          size: stats.size,
+          type: ext.slice(1),
+          dateAdded: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+    } catch (error) {
+      console.error("Error adding user icon:", error);
+      throw new Error(error.message || "Failed to add icon");
+    }
+  });
+  electron.ipcMain.handle("icons:delete", async (_, fileName) => {
+    try {
+      const iconsPath = await getGlobalIconsPath();
+      const filePath = path.join(iconsPath, fileName);
+      const resolvedPath = path.resolve(filePath);
+      const resolvedIconsPath = path.resolve(iconsPath);
+      if (!resolvedPath.startsWith(resolvedIconsPath)) {
+        throw new Error("Invalid file path");
+      }
+      await fs.promises.unlink(filePath);
+      return { success: true };
+    } catch (error) {
+      console.error("Error deleting user icon:", error);
+      throw new Error(error.message || "Failed to delete icon");
+    }
+  });
+  electron.ipcMain.handle("icons:select-files", async () => {
+    try {
+      const result = await electron.dialog.showOpenDialog({
+        properties: ["openFile", "multiSelections"],
+        title: "Select Icon Files",
+        buttonLabel: "Add Icons",
+        filters: [
+          { name: "Images", extensions: ["png", "gif", "svg"] }
+        ]
+      });
+      if (result.canceled || result.filePaths.length === 0) {
+        return { canceled: true };
+      }
+      return {
+        canceled: false,
+        filePaths: result.filePaths
+      };
+    } catch (error) {
+      console.error("Error selecting icon files:", error);
+      throw new Error("Failed to select files");
+    }
+  });
+  electron.ipcMain.handle("icons:read-file", async (_, filePath) => {
+    try {
+      const buffer = await fs.promises.readFile(filePath);
+      const base64 = buffer.toString("base64");
+      const ext = path.extname(filePath).toLowerCase().slice(1);
+      const mimeType = ext === "svg" ? "image/svg+xml" : `image/${ext}`;
+      return `data:${mimeType};base64,${base64}`;
+    } catch (error) {
+      console.error("Error reading icon file:", error);
+      throw new Error("Failed to read icon file");
+    }
+  });
+  const args = process.argv.slice(1);
+  const { projectPath, openCanvas } = parseCliArguments(args);
+  createWindow();
+  mainWindow?.webContents.once("did-finish-load", () => {
+    if (projectPath && mainWindow) {
+      mainWindow.webContents.send("initial-project-path", projectPath);
+      if (openCanvas) {
+        mainWindow.webContents.send("initial-open-canvas", true);
+      }
+    }
+    const cwd = process.env.CLAUDE_SPACE_CWD || electron.app.getPath("documents");
+    if (mainWindow) {
+      mainWindow.webContents.send("initial-cwd", cwd);
+    }
+  });
+  electron.app.on("activate", function() {
+    if (electron.BrowserWindow.getAllWindows().length === 0) createWindow();
+  });
+});
+electron.app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") {
+    electron.app.quit();
+  }
+});