background-agents 0.1.1 → 1.0.0

package/app/dist/main.js

@@ -0,0 +1,932 @@
+// src/main.ts
+import {
+  app as app5,
+  BrowserWindow as BrowserWindow5,
+  ipcMain as ipcMain3,
+  Notification as Notification2,
+  shell as shell2,
+  nativeTheme
+} from "electron";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/tray.ts
+import { app, Menu, nativeImage, Tray } from "electron";
+import path from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var tray = null;
+function createTray(mainWindow2) {
+  const iconPath = path.join(__dirname, "../assets/tray-icon.png");
+  let icon;
+  try {
+    icon = nativeImage.createFromPath(iconPath);
+    if (icon.isEmpty()) {
+      icon = nativeImage.createEmpty();
+    }
+  } catch {
+    icon = nativeImage.createEmpty();
+  }
+  if (process.platform === "darwin") {
+    icon.setTemplateImage(true);
+  }
+  tray = new Tray(icon);
+  tray.setToolTip("Background Agents");
+  const contextMenu = buildContextMenu(mainWindow2, false);
+  tray.setContextMenu(contextMenu);
+  tray.on("click", () => {
+    if (mainWindow2.isVisible() && mainWindow2.isFocused()) {
+      mainWindow2.hide();
+    } else {
+      mainWindow2.show();
+      mainWindow2.focus();
+    }
+  });
+  tray.on("double-click", () => {
+    mainWindow2.show();
+    mainWindow2.focus();
+  });
+  return tray;
+}
+function buildContextMenu(mainWindow2, isHidden) {
+  return Menu.buildFromTemplate([
+    {
+      label: isHidden ? "Show Background Agents" : "Hide Background Agents",
+      click: () => {
+        if (isHidden) {
+          mainWindow2.show();
+          mainWindow2.focus();
+        } else {
+          mainWindow2.hide();
+        }
+      }
+    },
+    { type: "separator" },
+    {
+      label: "New Chat",
+      accelerator: "CmdOrCtrl+N",
+      click: () => {
+        mainWindow2.show();
+        mainWindow2.focus();
+        mainWindow2.webContents.send("shortcut", "new-chat");
+      }
+    },
+    {
+      label: "Search",
+      accelerator: "CmdOrCtrl+K",
+      click: () => {
+        mainWindow2.show();
+        mainWindow2.focus();
+        mainWindow2.webContents.send("shortcut", "search");
+      }
+    },
+    { type: "separator" },
+    {
+      label: "Settings",
+      click: () => {
+        mainWindow2.show();
+        mainWindow2.focus();
+        mainWindow2.webContents.send("shortcut", "settings");
+      }
+    },
+    { type: "separator" },
+    {
+      label: "Quit Background Agents",
+      accelerator: "CmdOrCtrl+Q",
+      click: () => {
+        app.quit();
+      }
+    }
+  ]);
+}
+function updateTrayMenu(mainWindow2, isHidden) {
+  if (tray) {
+    const contextMenu = buildContextMenu(mainWindow2, isHidden);
+    tray.setContextMenu(contextMenu);
+  }
+}
+
+// src/shortcuts.ts
+import { globalShortcut } from "electron";
+var DEFAULT_SHORTCUTS = {
+  "toggle-window": "CmdOrCtrl+Shift+A",
+  "new-chat": "CmdOrCtrl+Shift+N",
+  search: "CmdOrCtrl+Shift+K"
+};
+var registeredShortcuts = [];
+var mainWindowRef = null;
+function registerShortcuts(mainWindow2) {
+  mainWindowRef = mainWindow2;
+  const toggleRet = globalShortcut.register(
+    DEFAULT_SHORTCUTS["toggle-window"],
+    () => {
+      if (mainWindow2.isVisible() && mainWindow2.isFocused()) {
+        mainWindow2.hide();
+      } else {
+        mainWindow2.show();
+        mainWindow2.focus();
+      }
+    }
+  );
+  if (toggleRet) {
+    registeredShortcuts.push(DEFAULT_SHORTCUTS["toggle-window"]);
+    console.log(
+      `Registered global shortcut: ${DEFAULT_SHORTCUTS["toggle-window"]} (toggle window)`
+    );
+  } else {
+    console.warn(
+      `Failed to register shortcut: ${DEFAULT_SHORTCUTS["toggle-window"]}`
+    );
+  }
+  const newChatRet = globalShortcut.register(
+    DEFAULT_SHORTCUTS["new-chat"],
+    () => {
+      mainWindow2.show();
+      mainWindow2.focus();
+      mainWindow2.webContents.send("shortcut", "new-chat");
+    }
+  );
+  if (newChatRet) {
+    registeredShortcuts.push(DEFAULT_SHORTCUTS["new-chat"]);
+    console.log(
+      `Registered global shortcut: ${DEFAULT_SHORTCUTS["new-chat"]} (new chat)`
+    );
+  } else {
+    console.warn(
+      `Failed to register shortcut: ${DEFAULT_SHORTCUTS["new-chat"]}`
+    );
+  }
+  const searchRet = globalShortcut.register(DEFAULT_SHORTCUTS["search"], () => {
+    mainWindow2.show();
+    mainWindow2.focus();
+    mainWindow2.webContents.send("shortcut", "search");
+  });
+  if (searchRet) {
+    registeredShortcuts.push(DEFAULT_SHORTCUTS["search"]);
+    console.log(
+      `Registered global shortcut: ${DEFAULT_SHORTCUTS["search"]} (search)`
+    );
+  } else {
+    console.warn(`Failed to register shortcut: ${DEFAULT_SHORTCUTS["search"]}`);
+  }
+}
+function unregisterShortcuts() {
+  for (const shortcut of registeredShortcuts) {
+    globalShortcut.unregister(shortcut);
+  }
+  registeredShortcuts = [];
+  mainWindowRef = null;
+}
+
+// src/deeplinks.ts
+import { app as app2 } from "electron";
+var PROTOCOL = "background-agents";
+function setupDeepLinks(handler) {
+  if (process.defaultApp) {
+    if (process.argv.length >= 2) {
+      app2.setAsDefaultProtocolClient(PROTOCOL, process.execPath, [
+        process.argv[1]
+      ]);
+    }
+  } else {
+    app2.setAsDefaultProtocolClient(PROTOCOL);
+  }
+  const deepLinkArg = process.argv.find(
+    (arg) => arg.startsWith(`${PROTOCOL}://`)
+  );
+  if (deepLinkArg) {
+    app2.whenReady().then(() => {
+      setTimeout(() => handler(deepLinkArg), 100);
+    });
+  }
+}
+
+// src/git-sync.ts
+import { ipcMain, Notification, app as app3, dialog, shell } from "electron";
+import git from "isomorphic-git";
+import http from "isomorphic-git/http/node";
+import path2 from "path";
+import fs from "fs";
+var SETTINGS_FILE = "git-sync-settings.json";
+function defaultRootDirectory() {
+  return path2.join(app3.getPath("home"), "Backgrounder");
+}
+function settingsPath() {
+  return path2.join(app3.getPath("userData"), SETTINGS_FILE);
+}
+var settings = { rootDirectory: defaultRootDirectory() };
+var opts = null;
+function loadSettings() {
+  try {
+    const raw = fs.readFileSync(settingsPath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.rootDirectory && typeof parsed.rootDirectory === "string") {
+      settings.rootDirectory = parsed.rootDirectory;
+    }
+  } catch {
+  }
+}
+function persistSettings() {
+  try {
+    fs.mkdirSync(app3.getPath("userData"), { recursive: true });
+    fs.writeFileSync(settingsPath(), JSON.stringify(settings, null, 2), "utf8");
+  } catch (error) {
+    console.error("[git-sync] Failed to persist settings:", error);
+  }
+}
+function emitStatus(repo, status, message) {
+  opts?.getWindow()?.webContents.send("sync-status", { repo, status, message });
+}
+function emitError(repo, branch, message) {
+  opts?.getWindow()?.webContents.send("sync-error", { repo, branch, message });
+  new Notification({ title: "Local sync error", body: message }).show();
+}
+var repoQueues = /* @__PURE__ */ new Map();
+function enqueue(repo, task) {
+  const prev = repoQueues.get(repo) ?? Promise.resolve();
+  const next = prev.then(task, task);
+  repoQueues.set(
+    repo,
+    next.then(
+      () => void 0,
+      () => void 0
+    )
+  );
+  return next;
+}
+function repoDir(repo) {
+  const name = repo.split("/").pop() || repo;
+  return path2.join(settings.rootDirectory, name);
+}
+function repoUrl(repo) {
+  return `https://github.com/${repo}.git`;
+}
+function isCloned(repo) {
+  return fs.existsSync(path2.join(repoDir(repo), ".git"));
+}
+var DivergenceError = class extends Error {
+  constructor(branch) {
+    super(
+      `Your local copy of "${branch}" has uncommitted changes that differ from the cloud. Sync was skipped to avoid overwriting your work.`
+    );
+    this.branch = branch;
+    this.name = "DivergenceError";
+  }
+  branch;
+};
+async function getToken() {
+  if (!opts) throw new Error("git-sync not initialized");
+  const win = opts.getWindow();
+  if (!win) throw new Error("No window available to fetch token");
+  const res = await win.webContents.session.fetch(
+    `${opts.backendUrl}/api/auth/github-sync-token`,
+    { method: "POST" }
+  );
+  if (!res.ok) {
+    throw new Error(`Could not get GitHub token (HTTP ${res.status})`);
+  }
+  const data = await res.json();
+  if (!data.token) throw new Error("No GitHub token returned");
+  return data.token;
+}
+function authCallback(token) {
+  return () => ({ username: token, password: "x-oauth-basic" });
+}
+async function isWorkingTreeClean(dir) {
+  const matrix = await git.statusMatrix({ fs, dir });
+  return !matrix.some(([, head, workdir]) => head === 1 && workdir !== 1);
+}
+async function currentBranch(dir) {
+  return await git.currentBranch({ fs, dir, fullname: false }) || void 0;
+}
+function isNotFound(error) {
+  return error?.code === "NotFoundError";
+}
+async function remoteOid(dir, branch) {
+  try {
+    return await git.resolveRef({ fs, dir, ref: `refs/remotes/origin/${branch}` });
+  } catch {
+    return null;
+  }
+}
+async function hasLocalBranch(dir, branch) {
+  try {
+    await git.resolveRef({ fs, dir, ref: `refs/heads/${branch}` });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function reconcileBranch(dir, branch, target, checkout) {
+  let local = null;
+  try {
+    local = await git.resolveRef({ fs, dir, ref: `refs/heads/${branch}` });
+  } catch {
+    local = null;
+  }
+  const checkedOut = await currentBranch(dir) === branch;
+  const touchesWorkingTree = checkout || checkedOut;
+  if (local === target) {
+    if (checkout && !checkedOut) await safeCheckout(dir, branch);
+    return;
+  }
+  if (touchesWorkingTree && !await isWorkingTreeClean(dir)) {
+    throw new DivergenceError(branch);
+  }
+  await git.writeRef({ fs, dir, ref: `refs/heads/${branch}`, value: target, force: true });
+  if (touchesWorkingTree) {
+    await git.checkout({ fs, dir, ref: branch, force: true });
+  }
+}
+async function fetchAndReconcile(dir, url, token, branch, checkout) {
+  let fetchHead = null;
+  try {
+    const res = await git.fetch({
+      fs,
+      http,
+      dir,
+      url,
+      ref: branch,
+      singleBranch: true,
+      tags: false,
+      onAuth: authCallback(token)
+    });
+    fetchHead = res.fetchHead ?? null;
+  } catch (error) {
+    if (isNotFound(error)) return false;
+    throw error;
+  }
+  if (!fetchHead) return false;
+  await reconcileBranch(dir, branch, fetchHead, checkout);
+  return true;
+}
+async function safeCheckout(dir, branch) {
+  if (await currentBranch(dir) === branch) return;
+  if (!await isWorkingTreeClean(dir)) {
+    throw new DivergenceError(branch);
+  }
+  await git.checkout({ fs, dir, ref: branch, force: true });
+}
+async function doOpenRepoFolder(repo, branches, activeBranch) {
+  const dir = repoDir(repo);
+  const url = repoUrl(repo);
+  fs.mkdirSync(settings.rootDirectory, { recursive: true });
+  if (isCloned(repo)) {
+    emitStatus(repo, "syncing");
+    try {
+      if (activeBranch && await hasLocalBranch(dir, activeBranch)) {
+        await safeCheckout(dir, activeBranch);
+      }
+    } catch (error) {
+      if (error instanceof DivergenceError) emitError(repo, activeBranch ?? "", error.message);
+      else throw error;
+    }
+    emitStatus(repo, "ready");
+    await shell.openPath(dir);
+    return;
+  }
+  const token = await getToken();
+  emitStatus(repo, "cloning");
+  fs.mkdirSync(dir, { recursive: true });
+  await git.clone({ fs, http, dir, url, singleBranch: false, onAuth: authCallback(token) });
+  emitStatus(repo, "syncing");
+  const wanted = Array.from(new Set(branches.filter(Boolean)));
+  for (const branch of wanted) {
+    const target = await remoteOid(dir, branch);
+    if (!target) continue;
+    try {
+      await reconcileBranch(dir, branch, target, branch === activeBranch);
+    } catch (error) {
+      if (error instanceof DivergenceError) {
+        emitError(repo, branch, error.message);
+      } else {
+        console.warn(`[git-sync] Could not update branch "${branch}" for ${repo}:`, error);
+      }
+    }
+  }
+  emitStatus(repo, "ready");
+  await shell.openPath(dir);
+}
+async function doSetActiveChat(repo, branch) {
+  if (!branch || !isCloned(repo)) return;
+  const dir = repoDir(repo);
+  const url = repoUrl(repo);
+  emitStatus(repo, "syncing");
+  try {
+    if (await hasLocalBranch(dir, branch)) {
+      await safeCheckout(dir, branch);
+    } else {
+      const token = await getToken();
+      await fetchAndReconcile(dir, url, token, branch, true);
+    }
+    emitStatus(repo, "ready");
+  } catch (error) {
+    handleOpError(repo, branch, error);
+  }
+}
+async function doSyncBranch(repo, branch) {
+  if (!branch || !isCloned(repo)) return;
+  const dir = repoDir(repo);
+  const url = repoUrl(repo);
+  emitStatus(repo, "syncing");
+  try {
+    const token = await getToken();
+    await fetchAndReconcile(dir, url, token, branch, false);
+    emitStatus(repo, "ready");
+  } catch (error) {
+    handleOpError(repo, branch, error);
+  }
+}
+function handleOpError(repo, branch, error) {
+  if (error instanceof DivergenceError) {
+    emitStatus(repo, "ready");
+    emitError(repo, branch, error.message);
+    return;
+  }
+  const message = error instanceof Error ? error.message : "Unknown error";
+  emitStatus(repo, "error", message);
+  emitError(repo, branch, `Failed to sync ${repo}: ${message}`);
+}
+function setupGitSync(setupOptions) {
+  opts = setupOptions;
+  loadSettings();
+  ipcMain.handle("git-sync:get-settings", () => settings);
+  ipcMain.handle(
+    "git-sync:set-settings",
+    (_event, next) => {
+      if (next.rootDirectory && typeof next.rootDirectory === "string") {
+        settings.rootDirectory = next.rootDirectory;
+      }
+      persistSettings();
+      return settings;
+    }
+  );
+  ipcMain.handle("git-sync:pick-directory", async () => {
+    const win = opts?.getWindow();
+    const result = win ? await dialog.showOpenDialog(win, {
+      title: "Choose Backgrounder folder",
+      defaultPath: settings.rootDirectory,
+      properties: ["openDirectory", "createDirectory"]
+    }) : await dialog.showOpenDialog({
+      properties: ["openDirectory", "createDirectory"]
+    });
+    if (result.canceled || result.filePaths.length === 0) return null;
+    settings.rootDirectory = result.filePaths[0];
+    persistSettings();
+    return settings.rootDirectory;
+  });
+  ipcMain.handle("git-sync:get-repo-state", (_event, repo) => {
+    return { cloned: isCloned(repo) };
+  });
+  ipcMain.handle(
+    "git-sync:open-repo-folder",
+    async (_event, data) => {
+      try {
+        await enqueue(
+          data.repo,
+          () => doOpenRepoFolder(data.repo, data.branches ?? [], data.activeBranch ?? null)
+        );
+        return { success: true };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        emitStatus(data.repo, "error", message);
+        emitError(data.repo, data.activeBranch ?? void 0, message);
+        return { success: false, error: message };
+      }
+    }
+  );
+  ipcMain.handle(
+    "git-sync:set-active-chat",
+    async (_event, data) => {
+      if (!isCloned(data.repo)) return { success: true };
+      await enqueue(data.repo, () => doSetActiveChat(data.repo, data.branch));
+      return { success: true };
+    }
+  );
+  ipcMain.handle(
+    "git-sync:sync-branch",
+    async (_event, data) => {
+      if (!isCloned(data.repo)) return { success: true };
+      await enqueue(data.repo, () => doSyncBranch(data.repo, data.branch));
+      return { success: true };
+    }
+  );
+}
+
+// src/autoupdate.ts
+import { dialog as dialog2 } from "electron";
+import pkg from "electron-updater";
+var { autoUpdater } = pkg;
+function setupAutoUpdater(mainWindow2) {
+  autoUpdater.autoDownload = false;
+  autoUpdater.autoInstallOnAppQuit = true;
+  setTimeout(() => {
+    autoUpdater.checkForUpdates().catch((err) => {
+      console.log("Auto-update check failed:", err.message);
+    });
+  }, 1e4);
+  setInterval(
+    () => {
+      autoUpdater.checkForUpdates().catch((err) => {
+        console.log("Auto-update check failed:", err.message);
+      });
+    },
+    60 * 60 * 1e3
+  );
+  autoUpdater.on("update-available", (info) => {
+    dialog2.showMessageBox(mainWindow2, {
+      type: "info",
+      title: "Update Available",
+      message: `A new version (${info.version}) is available. Would you like to download it now?`,
+      buttons: ["Download", "Later"],
+      defaultId: 0,
+      cancelId: 1
+    }).then((result) => {
+      if (result.response === 0) {
+        autoUpdater.downloadUpdate();
+      }
+    });
+  });
+  autoUpdater.on("update-not-available", () => {
+    console.log("No updates available");
+  });
+  autoUpdater.on("download-progress", (progress) => {
+    mainWindow2.webContents.send("update-progress", {
+      percent: progress.percent,
+      transferred: progress.transferred,
+      total: progress.total
+    });
+  });
+  autoUpdater.on("update-downloaded", (info) => {
+    dialog2.showMessageBox(mainWindow2, {
+      type: "info",
+      title: "Update Ready",
+      message: `Version ${info.version} has been downloaded. Restart now to install?`,
+      buttons: ["Restart Now", "Later"],
+      defaultId: 0,
+      cancelId: 1
+    }).then((result) => {
+      if (result.response === 0) {
+        autoUpdater.quitAndInstall(false, true);
+      }
+    });
+  });
+  autoUpdater.on("error", (err) => {
+    console.error("Auto-updater error:", err);
+  });
+}
+
+// src/license-detect.ts
+import { ipcMain as ipcMain2, app as app4 } from "electron";
+import fs2 from "fs";
+import path3 from "path";
+import { execSync } from "child_process";
+var settings2 = {
+  autoDetectEnabled: true
+};
+var getSettingsPath = () => path3.join(app4.getPath("userData"), "license-settings.json");
+function loadSettings2() {
+  try {
+    const settingsPath2 = getSettingsPath();
+    if (fs2.existsSync(settingsPath2)) {
+      const data = fs2.readFileSync(settingsPath2, "utf-8");
+      const loaded = JSON.parse(data);
+      settings2 = { ...settings2, ...loaded };
+    }
+  } catch (error) {
+    console.error("Failed to load license detection settings:", error);
+  }
+}
+function saveSettings() {
+  try {
+    const settingsPath2 = getSettingsPath();
+    fs2.writeFileSync(settingsPath2, JSON.stringify(settings2, null, 2), "utf-8");
+  } catch (error) {
+    console.error("Failed to save license detection settings:", error);
+  }
+}
+function getCredentialsFilePath() {
+  const homeDir = app4.getPath("home");
+  return path3.join(homeDir, ".claude", ".credentials.json");
+}
+function readFromKeychain() {
+  try {
+    const output = execSync(
+      'security find-generic-password -s "Claude Code-credentials" -w',
+      {
+        encoding: "utf-8",
+        timeout: 5e3,
+        stdio: ["pipe", "pipe", "pipe"]
+        // Suppress stderr
+      }
+    );
+    const credentials = output.trim();
+    if (credentials) {
+      try {
+        JSON.parse(credentials);
+        return {
+          found: true,
+          credentials,
+          source: "keychain"
+        };
+      } catch {
+        return {
+          found: false,
+          credentials: null,
+          source: null,
+          error: "Keychain contains invalid JSON"
+        };
+      }
+    }
+    return {
+      found: false,
+      credentials: null,
+      source: null,
+      error: "No credentials found in Keychain"
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown keychain error";
+    if (message.includes("could not be found") || message.includes("SecKeychainSearchCopyNext")) {
+      return {
+        found: false,
+        credentials: null,
+        source: null,
+        error: "Claude Code credentials not found in Keychain"
+      };
+    }
+    return {
+      found: false,
+      credentials: null,
+      source: null,
+      error: `Keychain access error: ${message}`
+    };
+  }
+}
+function readFromFile() {
+  try {
+    const credentialsPath = getCredentialsFilePath();
+    if (!fs2.existsSync(credentialsPath)) {
+      return {
+        found: false,
+        credentials: null,
+        source: null,
+        error: `Credentials file not found at ${credentialsPath}`
+      };
+    }
+    const content = fs2.readFileSync(credentialsPath, "utf-8");
+    try {
+      JSON.parse(content);
+      return {
+        found: true,
+        credentials: content.trim(),
+        source: "file"
+      };
+    } catch {
+      return {
+        found: false,
+        credentials: null,
+        source: null,
+        error: "Credentials file contains invalid JSON"
+      };
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown file read error";
+    return {
+      found: false,
+      credentials: null,
+      source: null,
+      error: `Failed to read credentials file: ${message}`
+    };
+  }
+}
+function detectClaudeCredentials() {
+  if (!settings2.autoDetectEnabled) {
+    return {
+      found: false,
+      credentials: null,
+      source: null,
+      error: "Auto-detection is disabled"
+    };
+  }
+  switch (process.platform) {
+    case "darwin":
+      return readFromKeychain();
+    case "linux":
+    case "win32":
+      return readFromFile();
+    default:
+      return {
+        found: false,
+        credentials: null,
+        source: null,
+        error: `Unsupported platform: ${process.platform}`
+      };
+  }
+}
+function setupLicenseDetect() {
+  loadSettings2();
+  ipcMain2.handle("get-claude-license-auto-detect", () => {
+    return detectClaudeCredentials();
+  });
+  ipcMain2.handle("get-license-detect-settings", () => {
+    return { autoDetectEnabled: settings2.autoDetectEnabled };
+  });
+  ipcMain2.handle(
+    "set-license-detect-settings",
+    (_event, newSettings) => {
+      settings2 = { ...settings2, ...newSettings };
+      saveSettings();
+      return true;
+    }
+  );
+}
+
+// src/main.ts
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path4.dirname(__filename2);
+var DEFAULT_BACKEND_URL = app5.isPackaged ? "https://backgrounder.dev" : "http://localhost:4000";
+var BACKEND_URL = process.env.BACKGROUND_AGENTS_URL || DEFAULT_BACKEND_URL;
+var mainWindow = null;
+var isQuitting = false;
+function createWindow() {
+  mainWindow = new BrowserWindow5({
+    width: 1400,
+    height: 900,
+    minWidth: 800,
+    minHeight: 600,
+    title: "Background Agents",
+    icon: path4.join(__dirname2, "../assets/icon.png"),
+    webPreferences: {
+      preload: path4.join(__dirname2, "preload.cjs"),
+      contextIsolation: true,
+      nodeIntegration: false,
+      sandbox: false
+    },
+    titleBarStyle: process.platform === "darwin" ? "hiddenInset" : "default",
+    trafficLightPosition: { x: 15, y: 15 },
+    backgroundColor: nativeTheme.shouldUseDarkColors ? "#0a0a0a" : "#ffffff",
+    show: false
+  });
+  mainWindow.loadURL(BACKEND_URL);
+  mainWindow.once("ready-to-show", () => {
+    mainWindow?.show();
+    console.log("background-agents:ready");
+  });
+  mainWindow.webContents.setWindowOpenHandler(({ url }) => {
+    shell2.openExternal(url);
+    return { action: "deny" };
+  });
+  mainWindow.webContents.on("will-navigate", (event, url) => {
+    if (url.includes("/api/auth/signin")) {
+      event.preventDefault();
+      const baseUrl = new URL(BACKEND_URL);
+      shell2.openExternal(`${baseUrl.origin}/auth/electron-start`);
+    }
+  });
+  mainWindow.on("close", (event) => {
+    if (!isQuitting) {
+      event.preventDefault();
+      mainWindow?.hide();
+    }
+  });
+  mainWindow.on("show", () => {
+    updateTrayMenu(mainWindow, false);
+  });
+  mainWindow.on("hide", () => {
+    updateTrayMenu(mainWindow, true);
+  });
+  return mainWindow;
+}
+var gotTheLock = app5.requestSingleInstanceLock();
+if (!gotTheLock) {
+  app5.quit();
+} else {
+  app5.on("second-instance", (_event, commandLine) => {
+    if (mainWindow) {
+      if (mainWindow.isMinimized()) mainWindow.restore();
+      mainWindow.show();
+      mainWindow.focus();
+    }
+    const deepLink = commandLine.find(
+      (arg) => arg.startsWith("background-agents://")
+    );
+    if (deepLink) {
+      handleDeepLink(deepLink);
+    }
+  });
+}
+async function handleDeepLink(url) {
+  if (!mainWindow) return;
+  try {
+    const parsed = new URL(url);
+    const action = parsed.hostname;
+    const params = Object.fromEntries(parsed.searchParams);
+    if (action === "auth" && params.token) {
+      console.log("Auth token received, setting session cookie...");
+      try {
+        const backendUrl = new URL(BACKEND_URL);
+        await mainWindow.webContents.session.cookies.set({
+          url: BACKEND_URL,
+          name: backendUrl.protocol === "https:" ? "__Secure-next-auth.session-token" : "next-auth.session-token",
+          value: params.token,
+          httpOnly: true,
+          secure: backendUrl.protocol === "https:",
+          sameSite: "lax",
+          // Expire in 30 days (NextAuth default)
+          expirationDate: Math.floor(Date.now() / 1e3) + 30 * 24 * 60 * 60
+        });
+        console.log("Session cookie set successfully");
+      } catch (cookieError) {
+        console.error("Failed to set session cookie:", cookieError);
+      }
+      mainWindow.loadURL(BACKEND_URL);
+      mainWindow.show();
+      mainWindow.focus();
+      return;
+    }
+    if (action === "auth-callback") {
+      console.log("Legacy auth callback received, reloading app...");
+      mainWindow.loadURL(BACKEND_URL);
+      mainWindow.show();
+      mainWindow.focus();
+      return;
+    }
+    mainWindow.webContents.send("deep-link", { action, params });
+    mainWindow.show();
+    mainWindow.focus();
+  } catch (error) {
+    console.error("Failed to parse deep link:", error);
+  }
+}
+app5.whenReady().then(async () => {
+  if (process.platform === "win32") {
+    app5.setAppUserModelId("com.background-agents.desktop");
+  }
+  const window = createWindow();
+  createTray(window);
+  registerShortcuts(window);
+  setupDeepLinks(handleDeepLink);
+  setupGitSync({ getWindow: () => mainWindow, backendUrl: BACKEND_URL });
+  if (app5.isPackaged) {
+    setupAutoUpdater(window);
+  }
+  setupLicenseDetect();
+  app5.on("activate", () => {
+    if (BrowserWindow5.getAllWindows().length === 0) {
+      createWindow();
+    } else {
+      mainWindow?.show();
+    }
+  });
+});
+app5.on("before-quit", () => {
+  isQuitting = true;
+});
+app5.on("will-quit", () => {
+  unregisterShortcuts();
+});
+app5.on("open-url", (event, url) => {
+  event.preventDefault();
+  handleDeepLink(url);
+});
+ipcMain3.on(
+  "show-notification",
+  (_event, { title, body, chatId }) => {
+    const notification = new Notification2({
+      title,
+      body,
+      icon: path4.join(__dirname2, "../assets/icon.png")
+    });
+    notification.on("click", () => {
+      mainWindow?.show();
+      mainWindow?.focus();
+      if (chatId) {
+        mainWindow?.webContents.send("navigate-to-chat", chatId);
+      }
+    });
+    notification.show();
+  }
+);
+ipcMain3.on("update-badge", (_event, count) => {
+  if (process.platform === "darwin") {
+    app5.dock?.setBadge(count > 0 ? count.toString() : "");
+  }
+});
+ipcMain3.on("toggle-window", () => {
+  if (mainWindow?.isVisible() && mainWindow?.isFocused()) {
+    mainWindow.hide();
+  } else {
+    mainWindow?.show();
+    mainWindow?.focus();
+  }
+});
+ipcMain3.handle("get-auth-token", async () => {
+  return null;
+});
+ipcMain3.handle("set-auth-token", async (_event, _token) => {
+  return true;
+});
+ipcMain3.on("open-external", (_event, url) => {
+  shell2.openExternal(url);
+});