bosun 0.36.2 → 0.36.4

package/desktop/preload.mjs

@@ -1,5 +1,58 @@
-import { contextBridge } from "electron";
+import { contextBridge, ipcRenderer } from "electron";
 
 contextBridge.exposeInMainWorld("veDesktop", {
   platform: process.platform,
+
+  follow: {
+    open: async (detail = {}) => {
+      return ipcRenderer.invoke("bosun:desktop:follow:open", detail || {});
+    },
+    hide: async () => {
+      return ipcRenderer.invoke("bosun:desktop:follow:hide");
+    },
+    restore: async () => {
+      return ipcRenderer.invoke("bosun:desktop:follow:restore");
+    },
+  },
+
+  /**
+   * Keyboard shortcuts API.
+   * Available in the renderer via `window.veDesktop.shortcuts.*`
+   */
+  shortcuts: {
+    /**
+     * Returns the full shortcuts catalog with current effective accelerators.
+     * @returns {Promise<ShortcutEntry[]>}
+     */
+    list: () => ipcRenderer.invoke("bosun:shortcuts:list"),
+
+    /**
+     * Set a custom accelerator for a shortcut.
+     * Pass `null` as accelerator to disable the shortcut.
+     * @param {string} id
+     * @param {string|null} accelerator  Electron accelerator string or null.
+     * @returns {Promise<{ ok: boolean, error?: string }>}
+     */
+    set: (id, accelerator) =>
+      ipcRenderer.invoke("bosun:shortcuts:set", { id, accelerator }),
+
+    /**
+     * Reset a single shortcut to its default accelerator.
+     * @param {string} id
+     * @returns {Promise<{ ok: boolean, error?: string }>}
+     */
+    reset: (id) => ipcRenderer.invoke("bosun:shortcuts:reset", { id }),
+
+    /**
+     * Reset all shortcuts to their defaults.
+     * @returns {Promise<{ ok: boolean }>}
+     */
+    resetAll: () => ipcRenderer.invoke("bosun:shortcuts:resetAll"),
+
+    /**
+     * Show the native keyboard shortcuts reference dialog.
+     * @returns {Promise<{ ok: boolean }>}
+     */
+    showDialog: () => ipcRenderer.invoke("bosun:shortcuts:showDialog"),
+  },
 });

package/desktop-shortcut.mjs

@@ -47,10 +47,91 @@ function getCliPath() {
   return resolve(__dirname, "cli.mjs");
 }
 
+function getDesktopMainPath() {
+  return resolve(__dirname, "desktop", "main.mjs");
+}
+
 function getWorkingDirectory() {
   return __dirname;
 }
 
+/**
+ * Attempt to locate the Electron binary that should be used to launch the
+ * Bosun desktop app.
+ *
+ * Search order:
+ *  1. BOSUN_ELECTRON_PATH env var — explicit override
+ *  2. <bosun-dir>/node_modules/.bin/electron(.cmd)
+ *  3. <bosun-dir>/../node_modules/.bin/electron(.cmd)  (repo root)
+ *  4. electron(.cmd) anywhere on $PATH
+ *
+ * Returns the resolved absolute path to the electron binary, or null when
+ * none could be located (falls back to node + cli.mjs --desktop).
+ */
+function findElectronBinary() {
+  // 1. Explicit env override
+  const envPath = process.env.BOSUN_ELECTRON_PATH;
+  if (envPath) {
+    const resolved = resolve(envPath);
+    if (existsSync(resolved)) return resolved;
+  }
+
+  const isWin = process.platform === "win32";
+  const candidates = isWin
+    ? [
+        resolve(__dirname, "node_modules", ".bin", "electron.cmd"),
+        resolve(__dirname, "..", "node_modules", ".bin", "electron.cmd"),
+        resolve(__dirname, "node_modules", ".bin", "electron.exe"),
+        resolve(__dirname, "..", "node_modules", ".bin", "electron.exe"),
+      ]
+    : [
+        resolve(__dirname, "node_modules", ".bin", "electron"),
+        resolve(__dirname, "..", "node_modules", ".bin", "electron"),
+      ];
+
+  for (const c of candidates) {
+    if (existsSync(c)) return c;
+  }
+
+  // 4. Search $PATH
+  try {
+    const cmd = isWin ? "where electron.cmd 2>nul" : "which electron 2>/dev/null";
+    const found = execSync(cmd, { encoding: "utf8", stdio: "pipe", timeout: 2000 })
+      .trim()
+      .split("\n")[0]
+      .trim();
+    if (found && existsSync(found)) return found;
+  } catch {
+    /* not found on PATH */
+  }
+
+  return null;
+}
+
+/**
+ * Return `{ executable, args }` for launching the Bosun desktop app.
+ *
+ * - If an Electron binary is found: launches `electron desktop/main.mjs`
+ * - Otherwise: falls back to `node cli.mjs --desktop`
+ */
+export function resolveElectronLauncher() {
+  const electronPath = findElectronBinary();
+  if (electronPath) {
+    return { executable: electronPath, args: [getDesktopMainPath()] };
+  }
+  return { executable: getNodePath(), args: [getCliPath(), "--desktop"] };
+}
+
+/**
+ * Build a quoted shell command string for the launcher.
+ * Used by macOS .command fallback and Linux .desktop Exec= field.
+ */
+function buildShellCommand() {
+  const { executable, args } = resolveElectronLauncher();
+  const quotedArgs = args.map((a) => `"${a}"`).join(" ");
+  return `"${executable}" ${quotedArgs}`;
+}
+
 function parseLinuxDesktopDir() {
   try {
     const configPath = resolve(homedir(), ".config", "user-dirs.dirs");
@@ -93,12 +174,6 @@ function ensureDesktopDir(dir) {
   }
 }
 
-function buildShellCommand() {
-  const nodePath = getNodePath();
-  const cliPath = getCliPath();
-  return `"${nodePath}" "${cliPath}" --desktop`;
-}
-
 function escapePowerShell(value) {
   return String(value).replace(/'/g, "''");
 }
@@ -109,17 +184,21 @@ function escapeAppleScript(value) {
 
 function installWindowsShortcut(desktopDir) {
   const shortcutPath = resolve(desktopDir, `${APP_NAME}.lnk`);
-  const nodePath = getNodePath();
-  const cliPath = getCliPath();
-  const args = `"${cliPath}" --desktop`;
+  const { executable, args } = resolveElectronLauncher();
+  const quotedArgs = args.map((a) => `"${a}"`).join(" ");
   const workingDir = getWorkingDirectory();
+  const iconPath = resolve(__dirname, "logo.png");
+  const iconLine = existsSync(iconPath)
+    ? `$Shortcut.IconLocation = '${escapePowerShell(iconPath)}'`
+    : "";
   const psScript = `
 $WshShell = New-Object -ComObject WScript.Shell
 $Shortcut = $WshShell.CreateShortcut('${escapePowerShell(shortcutPath)}')
-$Shortcut.TargetPath = '${escapePowerShell(nodePath)}'
-$Shortcut.Arguments = '${escapePowerShell(args)}'
+$Shortcut.TargetPath = '${escapePowerShell(executable)}'
+$Shortcut.Arguments = '${escapePowerShell(quotedArgs)}'
 $Shortcut.WorkingDirectory = '${escapePowerShell(workingDir)}'
 $Shortcut.Description = 'Bosun Desktop Portal'
+${iconLine}
 $Shortcut.Save()
 `.trim();
 

package/git-editor-fix.mjs

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+/**
+ * git-editor-fix.mjs — Prevent agents from opening interactive editors
+ *
+ * Problem: Agents inherit user's git config which uses VSCode (`code --wait`)
+ * Result: Git operations block waiting for editor, freezing agents
+ *
+ * Solution: Set GIT_EDITOR=true (or GIT_EDITOR=:) for non-interactive mode
+ *
+ * This script ensures all agent workspaces have non-blocking git config.
+ * Covers: main repo, tmpclaude-* workspaces, git worktrees (ve/*),
+ *         and VK task worktrees under $TEMP/vibe-kanban/worktrees/.
+ */
+
+import { execSync } from "child_process";
+import { existsSync, readdirSync } from "fs";
+import { resolve, basename } from "path";
+import { tmpdir } from "os";
+import { fileURLToPath } from "url";
+import { resolveRepoRoot } from "./repo-root.mjs";
+
+const __dirname = resolve(fileURLToPath(new URL(".", import.meta.url)));
+const REPO_ROOT = resolveRepoRoot();
+
+/**
+ * Configure git to never open interactive editors
+ * @param {string} workspacePath - Path to workspace directory
+ * @returns {boolean} true if configured successfully
+ */
+function configureNonInteractiveGit(workspacePath) {
+  const gitDir = resolve(workspacePath, ".git");
+
+  // .git can be a file (worktree link) or a directory — both are valid
+  if (!existsSync(gitDir)) {
+    console.warn(`[git-editor-fix] No .git entry at ${workspacePath}`);
+    return false;
+  }
+
+  try {
+    // Set local git config for this workspace
+    // Use ':' (colon) as no-op editor — POSIX standard that always succeeds
+    execSync("git config --local core.editor :", {
+      cwd: workspacePath,
+      stdio: "pipe",
+    });
+
+    // Also disable merge commit editor prompts
+    execSync("git config --local merge.commit.autoEdit no", {
+      cwd: workspacePath,
+      stdio: "pipe",
+    });
+
+    console.log(
+      `[git-editor-fix] ✓ Configured ${workspacePath} for non-interactive git`,
+    );
+    return true;
+  } catch (err) {
+    console.error(
+      `[git-editor-fix] Failed to configure ${workspacePath}:`,
+      err.message,
+    );
+    return false;
+  }
+}
+
+// ── Workspace discovery helpers ──────────────────────────────────────────────
+
+/**
+ * Collect tmpclaude-* directories under REPO_ROOT
+ * @returns {string[]}
+ */
+function findTmpclaudeWorkspaces() {
+  /** @type {string[]} */
+  const results = [];
+  try {
+    const entries = readdirSync(REPO_ROOT, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && entry.name.startsWith("tmpclaude-")) {
+        results.push(resolve(REPO_ROOT, entry.name));
+      }
+    }
+  } catch (err) {
+    console.error(
+      "[git-editor-fix] Failed to scan tmpclaude workspaces:",
+      err.message,
+    );
+  }
+  return results;
+}
+
+/**
+ * Parse `git worktree list --porcelain` and return paths of ve/* worktrees
+ * @returns {string[]}
+ */
+function findGitWorktrees() {
+  /** @type {string[]} */
+  const results = [];
+  try {
+    const raw = execSync("git worktree list --porcelain", {
+      cwd: REPO_ROOT,
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf-8",
+    });
+
+    // Porcelain output has blocks separated by blank lines.
+    // Each block starts with "worktree <path>".
+    // We also look for "branch refs/heads/ve/..." to identify VK worktrees,
+    // but we include ALL worktrees — they all need the fix.
+    for (const line of raw.split("\n")) {
+      const match = line.match(/^worktree\s+(.+)$/);
+      if (match) {
+        const wtPath = match[1].trim();
+        // Skip the bare repo entry if present
+        if (existsSync(resolve(wtPath, ".git"))) {
+          results.push(wtPath);
+        }
+      }
+    }
+  } catch (err) {
+    // git worktree list fails if the repo has no worktrees — that's fine
+    if (!String(err.message).includes("is not a git repository")) {
+      console.warn(
+        "[git-editor-fix] Could not enumerate git worktrees:",
+        err.message,
+      );
+    }
+  }
+  return results;
+}
+
+/**
+ * Scan $TEMP/vibe-kanban/worktrees/ for VK task worktree directories
+ * @returns {string[]}
+ */
+function findVKWorktrees() {
+  /** @type {string[]} */
+  const results = [];
+  const vkBase = resolve(tmpdir(), "vibe-kanban", "worktrees");
+
+  if (!existsSync(vkBase)) {
+    return results;
+  }
+
+  try {
+    const entries = readdirSync(vkBase, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const candidate = resolve(vkBase, entry.name);
+        if (existsSync(resolve(candidate, ".git"))) {
+          results.push(candidate);
+        }
+      }
+    }
+  } catch (err) {
+    console.error("[git-editor-fix] Failed to scan VK worktrees:", err.message);
+  }
+  return results;
+}
+
+// ── Main functions ───────────────────────────────────────────────────────────
+
+/**
+ * Scan for all agent workspaces and fix git config.
+ * Sources:
+ *   1. Main repo root (REPO_ROOT)
+ *   2. tmpclaude-* directories
+ *   3. git worktrees (parsed from `git worktree list --porcelain`)
+ *   4. VK task worktrees under $TEMP/vibe-kanban/worktrees/
+ *
+ * Paths are deduplicated before configuration.
+ */
+function fixAllWorkspaces() {
+  console.log("[git-editor-fix] Scanning for agent workspaces...");
+
+  /** @type {Set<string>} */
+  const seen = new Set();
+
+  /** @param {string} p */
+  const add = (p) => {
+    const normalized = resolve(p);
+    seen.add(normalized);
+  };
+
+  // 1. Main repo root
+  add(REPO_ROOT);
+
+  // 2. tmpclaude-* directories
+  for (const ws of findTmpclaudeWorkspaces()) {
+    add(ws);
+  }
+
+  // 3. Git worktrees (includes ve/* branches)
+  for (const ws of findGitWorktrees()) {
+    add(ws);
+  }
+
+  // 4. VK worktrees under $TEMP
+  for (const ws of findVKWorktrees()) {
+    add(ws);
+  }
+
+  const workspaces = [...seen];
+  console.log(
+    `[git-editor-fix] Found ${workspaces.length} workspace(s) to configure`,
+  );
+
+  let fixed = 0;
+  for (const ws of workspaces) {
+    if (configureNonInteractiveGit(ws)) {
+      fixed++;
+    }
+  }
+
+  console.log(
+    `[git-editor-fix] ✓ Fixed ${fixed}/${workspaces.length} workspaces`,
+  );
+}
+
+/**
+ * Convenience wrapper: configure the main repo and all discoverable worktrees
+ * in a single call. Suitable for use from other modules.
+ * @returns {{ fixed: number, total: number }}
+ */
+function configureRepoAndWorktrees() {
+  console.log("[git-editor-fix] Configuring repo and all worktrees...");
+
+  /** @type {Set<string>} */
+  const seen = new Set();
+
+  const add = (/** @type {string} */ p) => seen.add(resolve(p));
+
+  add(REPO_ROOT);
+  findTmpclaudeWorkspaces().forEach(add);
+  findGitWorktrees().forEach(add);
+  findVKWorktrees().forEach(add);
+
+  const workspaces = [...seen];
+  let fixed = 0;
+  for (const ws of workspaces) {
+    if (configureNonInteractiveGit(ws)) {
+      fixed++;
+    }
+  }
+
+  console.log(
+    `[git-editor-fix] ✓ Configured ${fixed}/${workspaces.length} workspace(s)`,
+  );
+  return { fixed, total: workspaces.length };
+}
+
+// ── CLI Entry Point ──────────────────────────────────────────────────────────
+
+const isMainModule = () => {
+  try {
+    const modulePath = fileURLToPath(import.meta.url);
+    return process.argv[1] === modulePath;
+  } catch {
+    return false;
+  }
+};
+
+if (isMainModule()) {
+  fixAllWorkspaces();
+}
+
+export {
+  configureNonInteractiveGit,
+  fixAllWorkspaces,
+  configureRepoAndWorktrees,
+  findGitWorktrees,
+  findVKWorktrees,
+  findTmpclaudeWorkspaces,
+};