bosun 0.27.3 → 0.27.5

package/.env.example

@@ -105,6 +105,14 @@ TELEGRAM_MINIAPP_ENABLED=false
 # Tunnel mode control: auto | cloudflared | disabled
 # TELEGRAM_UI_TUNNEL=auto
 
+# ─── Desktop Portal ────────────────────────────────────────────────────────
+# Auto-start bosun daemon when the desktop portal launches (default: true)
+# BOSUN_DESKTOP_AUTO_START_DAEMON=true
+# Enable auto-updates for packaged desktop builds (default: false)
+# BOSUN_DESKTOP_AUTO_UPDATE=false
+# Optional auto-update feed URL override
+# BOSUN_DESKTOP_UPDATE_URL=https://updates.example.com/bosun
+
 # ─── Telegram Sentinel (independent watchdog) ──────────────────────────────
 # Keep Telegram command availability even when bosun is down.
 # Sentinel can auto-restart monitor, detect crash loops, and run repair-agent.

package/autofix.mjs

@@ -328,6 +328,39 @@ async function readSourceContext(filePath, errorLine, contextLines = 30) {
  */
 let _devModeCache = null;
 
+function detectBosunRepo(startDir, maxDepth = 6) {
+  let cursor = resolve(startDir);
+  for (let i = 0; i < maxDepth; i += 1) {
+    const pkgPath = resolve(cursor, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        if (pkg?.name === "bosun" && existsSync(resolve(cursor, "monitor.mjs"))) {
+          return true;
+        }
+      } catch {
+        /* ignore */
+      }
+    }
+    const monoPkg = resolve(cursor, "scripts", "bosun", "package.json");
+    if (existsSync(monoPkg)) {
+      try {
+        const pkg = JSON.parse(readFileSync(monoPkg, "utf8"));
+        if (
+          pkg?.name === "bosun" &&
+          existsSync(resolve(cursor, "scripts", "bosun", "monitor.mjs"))
+        ) {
+          return true;
+        }
+      } catch {
+        /* ignore */
+      }
+    }
+    cursor = resolve(cursor, "..");
+  }
+  return false;
+}
+
 export function isDevMode() {
   if (_devModeCache !== null) return _devModeCache;
 
@@ -341,9 +374,21 @@ export function isDevMode() {
     return false;
   }
 
-  // Check if we're inside node_modules (npm install)
+  // Check if we're inside node_modules (npm install). Ignore Vite/Vitest
+  // cache paths so local tests that bundle via node_modules/.vite still
+  // fall back to repo detection.
   const normalized = __dirname.replace(/\\/g, "/").toLowerCase();
-  if (normalized.includes("/node_modules/")) {
+  const inNodeModules = normalized.includes("/node_modules/");
+  const inViteCache =
+    normalized.includes("/node_modules/.vite/") ||
+    normalized.includes("/node_modules/.vitest/") ||
+    normalized.includes("/node_modules/.cache/");
+  if (inNodeModules) {
+    if (inViteCache) {
+      const fromCwd = detectBosunRepo(process.cwd());
+      _devModeCache = fromCwd;
+      return fromCwd;
+    }
     _devModeCache = false;
     return false;
   }

package/cli.mjs

@@ -70,6 +70,9 @@ function showHelp() {
     --help                      Show this help
     --version                   Show version
     --portal, --desktop         Launch the Bosun desktop portal (Electron)
+    --desktop-shortcut          Create a desktop shortcut for the portal
+    --desktop-shortcut-remove   Remove the desktop shortcut
+    --desktop-shortcut-status   Show desktop shortcut status
     --update                    Check for and install latest version
     --no-update-check           Skip automatic update check on startup
     --no-auto-update            Disable background auto-update polling
@@ -423,9 +426,11 @@ function startDaemon() {
     /* ok */
   }
 
+  const runAsNode = process.versions?.electron ? ["--run-as-node"] : [];
   const child = spawn(
     process.execPath,
     [
+      ...runAsNode,
       "--max-old-space-size=4096",
       fileURLToPath(new URL("./cli.mjs", import.meta.url)),
       ...process.argv.slice(2).filter((a) => a !== "--daemon" && a !== "-d"),
@@ -536,6 +541,47 @@ async function main() {
     process.exit(0);
   }
 
+  // Handle desktop shortcut controls
+  if (args.includes("--desktop-shortcut")) {
+    const { installDesktopShortcut, getDesktopShortcutMethodName } =
+      await import("./desktop-shortcut.mjs");
+    const result = installDesktopShortcut();
+    if (result.success) {
+      console.log(`  ✅ Desktop shortcut installed (${result.method})`);
+      if (result.path) console.log(`     Path: ${result.path}`);
+      if (result.name) console.log(`     Name: ${result.name}`);
+    } else {
+      const method = getDesktopShortcutMethodName();
+      console.error(
+        `  ❌ Failed to install desktop shortcut (${method}): ${result.error}`,
+      );
+    }
+    process.exit(result.success ? 0 : 1);
+  }
+  if (args.includes("--desktop-shortcut-remove")) {
+    const { removeDesktopShortcut } = await import("./desktop-shortcut.mjs");
+    const result = removeDesktopShortcut();
+    if (result.success) {
+      console.log(`  ✅ Desktop shortcut removed`);
+    } else {
+      console.error(
+        `  ❌ Failed to remove desktop shortcut: ${result.error}`,
+      );
+    }
+    process.exit(result.success ? 0 : 1);
+  }
+  if (args.includes("--desktop-shortcut-status")) {
+    const { getDesktopShortcutStatus } = await import("./desktop-shortcut.mjs");
+    const status = getDesktopShortcutStatus();
+    if (status.installed) {
+      console.log(`  Desktop shortcut: installed (${status.method})`);
+      if (status.path) console.log(`  Path: ${status.path}`);
+    } else {
+      console.log(`  Desktop shortcut: not installed`);
+    }
+    process.exit(0);
+  }
+
   // Handle --portal / --desktop
   if (args.includes("--portal") || args.includes("--desktop")) {
     const launcher = resolve(__dirname, "desktop", "launch.mjs");

package/config.mjs

@@ -703,6 +703,48 @@ function loadRepoConfig(configDir, configData = {}, options = {}) {
   ];
 }
 
+function loadWorkspaceRepoConfig(configDir, configData = {}, activeWorkspace = "") {
+  const workspaces = Array.isArray(configData.workspaces)
+    ? configData.workspaces
+    : [];
+  if (workspaces.length === 0) return [];
+
+  const targetWorkspaceId = normalizeKey(activeWorkspace || configData.activeWorkspace || "");
+  const targetWorkspace =
+    (targetWorkspaceId
+      ? workspaces.find((workspace) => normalizeKey(workspace?.id) === targetWorkspaceId)
+      : null) ||
+    workspaces[0];
+
+  if (!targetWorkspace || !Array.isArray(targetWorkspace.repos)) {
+    return [];
+  }
+
+  const workspacePath = resolve(configDir, "workspaces", targetWorkspace.id);
+  const activeRepoName = normalizeKey(targetWorkspace.activeRepo || "");
+
+  return targetWorkspace.repos
+    .map((repo, index) => {
+      if (!repo || typeof repo !== "object") return null;
+      const name = String(repo.name || repo.id || "").trim();
+      if (!name) return null;
+      const repoPath = resolve(workspacePath, name);
+      return {
+        name,
+        id: normalizeKey(name),
+        path: repoPath,
+        slug: String(repo.slug || "").trim(),
+        url: String(repo.url || "").trim(),
+        workspace: String(targetWorkspace.id || "").trim(),
+        primary:
+          repo.primary === true ||
+          (activeRepoName && normalizeKey(name) === activeRepoName) ||
+          (!activeRepoName && index === 0),
+      };
+    })
+    .filter(Boolean);
+}
+
 function loadAgentPrompts(configDir, repoRoot, configData) {
   const resolved = resolveAgentPrompts(configDir, repoRoot, configData);
   return { ...resolved.prompts, _sources: resolved.sources };
@@ -741,9 +783,16 @@ export function loadConfig(argv = process.argv, options = {}) {
     configData.defaultWorkspace ||
     "";
 
-  let repositories = loadRepoConfig(configDir, configData, {
-    repoRootOverride,
-  });
+  let repositories = loadWorkspaceRepoConfig(
+    configDir,
+    configData,
+    activeWorkspace,
+  );
+  if (!repositories.length) {
+    repositories = loadRepoConfig(configDir, configData, {
+      repoRootOverride,
+    });
+  }
 
   const repoSelection =
     cli["repo-name"] ||
@@ -798,7 +847,14 @@ export function loadConfig(argv = process.argv, options = {}) {
 
   // Apply profile overrides (executors, repos, etc.)
   configData = applyProfileOverrides(configData, profile);
-  repositories = loadRepoConfig(configDir, configData, { repoRootOverride });
+  repositories = loadWorkspaceRepoConfig(
+    configDir,
+    configData,
+    activeWorkspace,
+  );
+  if (!repositories.length) {
+    repositories = loadRepoConfig(configDir, configData, { repoRootOverride });
+  }
   selectedRepository =
     resolveRepoSelection(
       repositories,

package/desktop/AGENTS.md

@@ -0,0 +1,62 @@
+# Bosun Desktop — AGENTS Guide
+
+## Module Overview
+- Purpose: Native desktop shell for the Bosun control center, bundling the UI server and opening it in a desktop window.
+- Use when: Updating desktop packaging, launch flow, auto-update, or native window behavior.
+- Key entry points: `scripts/bosun/desktop/main.mjs:1`, `scripts/bosun/desktop/launch.mjs:1`, `scripts/bosun/ui-server.mjs:1`.
+
+## Architecture
+- The desktop app dynamically imports Bosun’s UI server and runs it locally, then loads the UI with a session token.
+- Packaged builds copy the `scripts/bosun/` runtime into app resources and start from there.
+- Entry points:
+  - `main.mjs` starts the UI server and creates the BrowserWindow.
+  - `launch.mjs` installs Electron (if needed) and runs the desktop app in dev.
+
+```mermaid
+flowchart TD
+  Desktop[desktop/main.mjs] --> UiServer[ui-server.mjs]
+  UiServer --> UI[ui/index.html]
+  Desktop --> Window[BrowserWindow]
+```
+
+## Core Concepts
+- Local UI server: desktop app embeds the same UI server used by the Telegram Mini App.
+- Session token: desktop loads `/?token=...` so the UI server sets a session cookie.
+- Packaged runtime: `extraResources` copies the Bosun runtime into app resources.
+
+## Usage Examples
+
+### Launch in dev
+```bash
+node scripts/bosun/desktop/launch.mjs
+```
+
+### Build installers
+```bash
+cd scripts/bosun/desktop
+npm install
+npm run dist
+```
+
+## Implementation Patterns
+- Always resolve the Bosun runtime root with `resolveBosunRoot()` when packaged.
+- Use dynamic import to load `ui-server.mjs` so packaged resources are used.
+- Keep auto-update behind `BOSUN_DESKTOP_AUTO_UPDATE=1` to avoid noisy failures in dev.
+
+## Configuration
+- Desktop packaging config lives in `scripts/bosun/desktop/package.json:20`.
+- Auto-update is opt-in via `BOSUN_DESKTOP_AUTO_UPDATE=1`.
+- Optional update feed override: `BOSUN_DESKTOP_UPDATE_URL`.
+- To skip Electron auto-install in dev, set `BOSUN_DESKTOP_SKIP_INSTALL=1`.
+
+## Testing
+- Bosun tests: `cd scripts/bosun && npm test`
+- Desktop smoke: `node scripts/bosun/desktop/launch.mjs`
+
+## Troubleshooting
+- Electron missing
+  - Cause: Desktop dependencies not installed.
+  - Fix: `npm -C scripts/bosun/desktop install` or set `BOSUN_DESKTOP_SKIP_INSTALL=1` to avoid auto-install.
+- UI server fails to start
+  - Cause: Port conflict or missing runtime files.
+  - Fix: Ensure the packaged `bosun/` runtime exists and retry with a clean start.

package/desktop/README.md

@@ -0,0 +1,41 @@
+# Bosun Desktop
+
+Bosun Desktop is an Electron shell that launches the Bosun UI server locally
+and opens the portal in a native window.
+
+## Development
+```bash
+cd scripts/bosun/desktop
+npm install
+npm run start
+```
+
+## Launch via Bosun CLI
+```bash
+cd scripts/bosun
+node cli.mjs --desktop
+```
+
+## Desktop shortcut
+```bash
+cd scripts/bosun
+node cli.mjs --desktop-shortcut
+```
+
+The shortcut launches the desktop portal and will auto-start the bosun daemon
+if it is not already running.
+
+## Build installers
+```bash
+cd scripts/bosun/desktop
+npm run dist
+```
+
+## Auto-update
+- Enable with `BOSUN_DESKTOP_AUTO_UPDATE=1`.
+- Optional feed URL override: `BOSUN_DESKTOP_UPDATE_URL=https://.../`.
+
+## Notes
+- Packaged apps bundle the Bosun runtime under `resources/bosun/`.
+- The UI server runs locally; the desktop app loads `/?token=...` to set the
+  session cookie.

package/desktop/main.mjs

@@ -1,12 +1,9 @@
 import { app, BrowserWindow } from "electron";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import {
-  getSessionToken,
-  getTelegramUiUrl,
-  startTelegramUiServer,
-  stopTelegramUiServer,
-} from "../ui-server.mjs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { existsSync, readFileSync } from "node:fs";
+import { execFileSync, spawn } from "node:child_process";
+import { homedir } from "node:os";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -14,24 +11,151 @@ let mainWindow = null;
 let shuttingDown = false;
 let uiServerStarted = false;
 let uiOrigin = null;
+let uiApi = null;
+
+const DAEMON_PID_FILE = resolve(homedir(), ".cache", "bosun", "daemon.pid");
+
+function parseBoolEnv(value, fallback) {
+  if (value === undefined || value === null) return fallback;
+  const normalized = String(value).trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  return fallback;
+}
+
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getDaemonPid() {
+  try {
+    if (!existsSync(DAEMON_PID_FILE)) return null;
+    const pid = parseInt(readFileSync(DAEMON_PID_FILE, "utf8").trim(), 10);
+    if (!Number.isFinite(pid)) return null;
+    return isProcessAlive(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+function findGhostDaemonPids() {
+  if (process.platform === "win32") return [];
+  try {
+    const out = execFileSync(
+      "pgrep",
+      ["-f", "bosun.*--daemon-child|cli\\.mjs.*--daemon-child"],
+      { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], timeout: 3000 },
+    ).trim();
+    return out
+      .split("\n")
+      .map((s) => parseInt(s.trim(), 10))
+      .filter((n) => Number.isFinite(n) && n > 0 && n !== process.pid);
+  } catch {
+    return [];
+  }
+}
+
+async function waitForDaemon(timeoutMs = 5000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const pid = getDaemonPid();
+    if (pid) return pid;
+    await new Promise((resolve) => setTimeout(resolve, 200));
+  }
+  return null;
+}
+
+function resolveBosunRoot() {
+  if (app.isPackaged) {
+    return resolve(process.resourcesPath, "bosun");
+  }
+  return resolve(__dirname, "..");
+}
+
+function resolveBosunRuntimePath(file) {
+  return resolve(resolveBosunRoot(), file);
+}
+
+async function loadBosunModule(file) {
+  const modulePath = resolveBosunRuntimePath(file);
+  return import(pathToFileURL(modulePath).href);
+}
+
+async function loadUiServerModule() {
+  if (uiApi) return uiApi;
+  uiApi = await loadBosunModule("ui-server.mjs");
+  return uiApi;
+}
+
+async function ensureDaemonRunning() {
+  const autoStart = parseBoolEnv(
+    process.env.BOSUN_DESKTOP_AUTO_START_DAEMON,
+    true,
+  );
+  if (!autoStart) return;
+
+  const existing = getDaemonPid();
+  if (existing) return;
+
+  const ghosts = findGhostDaemonPids();
+  if (ghosts.length > 0) return;
+
+  const cliPath = resolveBosunRuntimePath("cli.mjs");
+  if (!existsSync(cliPath)) {
+    console.warn("[desktop] bosun CLI not found; daemon auto-start skipped");
+    return;
+  }
+
+  try {
+    const setupModule = await loadBosunModule("setup.mjs");
+    if (setupModule?.shouldRunSetup?.()) {
+      console.warn(
+        "[desktop] setup required before daemon start; run: bosun --setup",
+      );
+      return;
+    }
+  } catch (err) {
+    console.warn(
+      "[desktop] unable to verify setup state; starting daemon anyway",
+    );
+  }
+
+  const child = spawn(process.execPath, ["--run-as-node", cliPath, "--daemon"], {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env, BOSUN_DESKTOP: "1" },
+    cwd: resolveBosunRoot(),
+    windowsHide: true,
+  });
+  child.unref();
+
+  await waitForDaemon(4000);
+}
 
 async function startUiServer() {
   if (uiServerStarted) return;
-  const server = await startTelegramUiServer({});
+  const api = await loadUiServerModule();
+  const server = await api.startTelegramUiServer({});
   if (!server) {
     throw new Error("Failed to start Telegram UI server.");
   }
   uiServerStarted = true;
 }
 
-function buildUiUrl() {
-  const uiServerUrl = getTelegramUiUrl();
+async function buildUiUrl() {
+  const api = await loadUiServerModule();
+  const uiServerUrl = api.getTelegramUiUrl();
   if (!uiServerUrl) {
     throw new Error("Telegram UI server URL is unavailable.");
   }
   const targetUrl = new URL(uiServerUrl);
   uiOrigin = targetUrl.origin;
-  const sessionToken = getSessionToken();
+  const sessionToken = api.getSessionToken();
   if (sessionToken) {
     targetUrl.searchParams.set("token", sessionToken);
   }
@@ -64,20 +188,40 @@ async function createMainWindow() {
     mainWindow?.show();
   });
 
-  const uiUrl = buildUiUrl();
+  const uiUrl = await buildUiUrl();
   await mainWindow.loadURL(uiUrl);
 }
 
 async function bootstrap() {
   try {
+    app.setAppUserModelId("com.virtengine.bosun");
+    process.chdir(resolveBosunRoot());
+    await ensureDaemonRunning();
     await startUiServer();
     await createMainWindow();
+    await maybeAutoUpdate();
   } catch (error) {
     console.error("[desktop] startup failed", error);
     await shutdown("startup_failed");
   }
 }
 
+async function maybeAutoUpdate() {
+  if (!app.isPackaged) return;
+  if (process.env.BOSUN_DESKTOP_AUTO_UPDATE !== "1") return;
+  try {
+    const { autoUpdater } = await import("electron-updater");
+    const feedUrl = process.env.BOSUN_DESKTOP_UPDATE_URL;
+    if (feedUrl) {
+      autoUpdater.setFeedURL({ url: feedUrl });
+    }
+    autoUpdater.autoDownload = true;
+    autoUpdater.checkForUpdatesAndNotify().catch(() => {});
+  } catch (err) {
+    console.warn("[desktop] auto-update unavailable", err?.message || err);
+  }
+}
+
 async function shutdown(reason) {
   if (shuttingDown) return;
   shuttingDown = true;
@@ -87,7 +231,8 @@ async function shutdown(reason) {
   }
 
   try {
-    stopTelegramUiServer();
+    const api = await loadUiServerModule();
+    api.stopTelegramUiServer();
   } catch (error) {
     console.error("[desktop] failed to stop ui-server", error);
   }
@@ -98,7 +243,9 @@ async function shutdown(reason) {
 app.on("before-quit", () => {
   shuttingDown = true;
   try {
-    stopTelegramUiServer();
+    if (uiApi?.stopTelegramUiServer) {
+      uiApi.stopTelegramUiServer();
+    }
   } catch (error) {
     console.error("[desktop] failed to stop ui-server", error);
   }