bosun 0.36.2 → 0.36.3

package/ui-server.mjs

@@ -1253,6 +1253,85 @@ async function applySharedStateToTasks(tasks) {
   });
 }
 
+function normalizeCandidatePath(input) {
+  if (!input) return "";
+  const raw = String(input).trim();
+  if (!raw) return "";
+  try {
+    return resolve(raw);
+  } catch {
+    return "";
+  }
+}
+
+function pickWorkspaceRepoDir(workspace) {
+  if (!workspace || typeof workspace !== "object") return "";
+  const repos = Array.isArray(workspace.repos) ? workspace.repos : [];
+  const activeRepoName = String(workspace.activeRepo || "").trim();
+  const selectedRepo =
+    (activeRepoName
+      ? repos.find((repo) => String(repo?.name || "").trim() === activeRepoName)
+      : null) ||
+    repos.find((repo) => repo?.primary) ||
+    repos[0] ||
+    null;
+
+  const candidates = [];
+  const selectedRepoPath = normalizeCandidatePath(selectedRepo?.path);
+  if (selectedRepoPath) candidates.push(selectedRepoPath);
+  const workspacePath = normalizeCandidatePath(workspace.path);
+  if (workspacePath && selectedRepo?.name) {
+    const joined = normalizeCandidatePath(resolve(workspacePath, String(selectedRepo.name)));
+    if (joined) candidates.push(joined);
+  }
+  if (workspacePath) candidates.push(workspacePath);
+
+  for (const candidate of candidates) {
+    if (!candidate || !existsSync(candidate)) continue;
+    if (existsSync(resolve(candidate, ".git"))) return candidate;
+  }
+  for (const candidate of candidates) {
+    if (candidate && existsSync(candidate)) return candidate;
+  }
+  return "";
+}
+
+function resolveActiveWorkspaceExecutionContext() {
+  const fallback = { workspaceId: "", workspaceDir: repoRoot };
+  const configDir = resolveUiConfigDir();
+  if (!configDir) return fallback;
+
+  const listed = listManagedWorkspaces(configDir, { repoRoot });
+  const active = getActiveManagedWorkspace(configDir);
+  const activeId = String(active?.id || "").trim();
+  const workspace =
+    (activeId
+      ? listed.find((entry) => String(entry?.id || "") === activeId)
+      : null) ||
+    active ||
+    listed[0] ||
+    null;
+  if (!workspace) return fallback;
+
+  const workspaceId = String(workspace.id || "").trim();
+  const workspaceDir = pickWorkspaceRepoDir(workspace) || fallback.workspaceDir;
+  return {
+    workspaceId,
+    workspaceDir,
+  };
+}
+
+function resolveSessionWorkspaceDir(session = null) {
+  const metadata =
+    session && typeof session.metadata === "object" && session.metadata
+      ? session.metadata
+      : null;
+  const explicit = normalizeCandidatePath(metadata?.workspaceDir);
+  if (explicit && existsSync(explicit)) return explicit;
+  const context = resolveActiveWorkspaceExecutionContext();
+  return context.workspaceDir || repoRoot;
+}
+
 function normalizeWorktreePath(input) {
   if (!input) return "";
   try {
@@ -2359,7 +2438,11 @@ const SETTINGS_SENSITIVE_KEYS = new Set([
   "CLOUDFLARE_TUNNEL_CREDENTIALS", "CLOUDFLARE_API_TOKEN",
 ]);
 
-const SETTINGS_KNOWN_SET = new Set(SETTINGS_KNOWN_KEYS);
+const SETTINGS_SCHEMA_KEYS = SETTINGS_SCHEMA
+  .map((def) => String(def?.key || "").trim())
+  .filter((key) => key && !key.startsWith("_"));
+const SETTINGS_KNOWN_SET = new Set([...SETTINGS_KNOWN_KEYS, ...SETTINGS_SCHEMA_KEYS]);
+const SETTINGS_EFFECTIVE_KEYS = Array.from(SETTINGS_KNOWN_SET);
 let _settingsLastUpdateTime = 0;
 const ASYNC_UI_COMMAND_BASES = new Set(["/plan"]);
 
@@ -2411,7 +2494,7 @@ function buildSettingsResponseData() {
   );
   const { configData } = readConfigDocument();
 
-  for (const key of SETTINGS_KNOWN_KEYS) {
+  for (const key of SETTINGS_EFFECTIVE_KEYS) {
     const def = defsByKey.get(key);
     let rawValue = process.env[key];
     let source = hasSettingValue(rawValue) ? "env" : "unset";
@@ -2447,7 +2530,7 @@ function buildSettingsResponseData() {
     }
 
     const displayValue = toSettingsDisplayValue(def, rawValue);
-    if (SETTINGS_SENSITIVE_KEYS.has(key)) {
+    if (SETTINGS_SENSITIVE_KEYS.has(key) || def?.sensitive) {
       data[key] = displayValue ? "••••••" : "";
     } else {
       data[key] = displayValue;
@@ -8490,9 +8573,28 @@ async function handleApi(req, res, url) {
       }
       const args = (body?.args || "").trim();
       const adapter = (body?.adapter || "").trim() || undefined;
-      const result = await execSdkCommand(command, args, adapter);
+      const requestedSessionId = String(body?.sessionId || "").trim();
+      const tracker = getSessionTracker();
+      const commandSession = requestedSessionId
+        ? tracker.getSessionById(requestedSessionId)
+        : null;
+      const commandCwd = resolveSessionWorkspaceDir(commandSession);
+      const runSdkCommand =
+        typeof uiDeps.execSdkCommand === "function"
+          ? uiDeps.execSdkCommand
+          : execSdkCommand;
+      const result = await runSdkCommand(command, args, adapter, {
+        cwd: commandCwd,
+        sessionId: requestedSessionId || undefined,
+      });
       const parsed = typeof result === "string" ? result : JSON.stringify(result);
-      jsonResponse(res, 200, { ok: true, result: parsed, command, adapter: adapter || getPrimaryAgentName() });
+      jsonResponse(res, 200, {
+        ok: true,
+        result: parsed,
+        command,
+        adapter: adapter || getPrimaryAgentName(),
+        sessionId: requestedSessionId || null,
+      });
       broadcastUiEvent(["agents", "sessions"], "invalidate", {
         reason: "sdk-command-executed",
         command,
@@ -8659,6 +8761,13 @@ async function handleApi(req, res, url) {
       const body = await readJsonBody(req);
       const type = body?.type || "manual";
       const id = `${type}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      const workspaceContext = resolveActiveWorkspaceExecutionContext();
+      const requestedWorkspaceId = String(body?.workspaceId || "").trim();
+      const requestedWorkspaceDir = normalizeCandidatePath(body?.workspaceDir);
+      const resolvedWorkspaceId =
+        requestedWorkspaceId || workspaceContext.workspaceId;
+      const resolvedWorkspaceDir =
+        requestedWorkspaceDir || workspaceContext.workspaceDir || repoRoot;
       const tracker = getSessionTracker();
       const session = tracker.createSession({
         id,
@@ -8668,6 +8777,8 @@ async function handleApi(req, res, url) {
           agent: body?.agent || getPrimaryAgentName(),
           mode: body?.mode || getAgentMode(),
           model: body?.model || undefined,
+          ...(resolvedWorkspaceId ? { workspaceId: resolvedWorkspaceId } : {}),
+          ...(resolvedWorkspaceDir ? { workspaceDir: resolvedWorkspaceDir } : {}),
         },
       });
       jsonResponse(res, 200, { ok: true, session: { id: session.id, type: session.type, status: session.status, metadata: session.metadata } });
@@ -8813,6 +8924,7 @@ async function handleApi(req, res, url) {
           exec = await resolveExecPrimaryPrompt();
         }
         if (exec) {
+          const sessionWorkspaceDir = resolveSessionWorkspaceDir(session);
           // Don't record user event here — execPrimaryPrompt records it
           // Respond immediately so the UI doesn't block on agent execution
           jsonResponse(res, 200, { ok: true, messageId });
@@ -8853,6 +8965,7 @@ async function handleApi(req, res, url) {
             sessionType: "primary",
             mode: messageMode,
             model: messageModel,
+            cwd: sessionWorkspaceDir,
             persistent: true,
             sendRawEvents: true,
             attachments,
@@ -8893,6 +9006,44 @@ async function handleApi(req, res, url) {
       return;
     }
 
+    if (action === "message/edit" && req.method === "POST") {
+      try {
+        const tracker = getSessionTracker();
+        const session = tracker.getSessionById(sessionId);
+        if (!session) {
+          jsonResponse(res, 404, { ok: false, error: "Session not found" });
+          return;
+        }
+        const body = await readJsonBody(req);
+        const content = String(body?.content || "").trim();
+        if (!content) {
+          jsonResponse(res, 400, { ok: false, error: "content is required" });
+          return;
+        }
+
+        const edited = tracker.editUserMessage(sessionId, {
+          messageId: body?.messageId,
+          timestamp: body?.timestamp,
+          previousContent: body?.previousContent,
+          content,
+        });
+        if (!edited?.ok) {
+          const status = edited?.error === "Message not found" ? 404 : 400;
+          jsonResponse(res, status, { ok: false, error: edited?.error || "edit failed" });
+          return;
+        }
+
+        jsonResponse(res, 200, { ok: true, message: edited.message });
+        broadcastUiEvent(["sessions"], "invalidate", {
+          reason: "session-message-edited",
+          sessionId,
+        });
+      } catch (err) {
+        jsonResponse(res, 500, { ok: false, error: err.message });
+      }
+      return;
+    }
+
     if (action === "archive" && req.method === "POST") {
       try {
         const tracker = getSessionTracker();
@@ -9421,14 +9572,18 @@ export async function startTelegramUiServer(options = {}) {
     shouldReusePersistedPort
       ? persistedPort
       : configuredPort;
+  const hasExplicitEnvPort =
+    Number.isFinite(Number(process.env.TELEGRAM_UI_PORT || "")) &&
+    Number(process.env.TELEGRAM_UI_PORT || "") > 0;
   const portSource =
     shouldReusePersistedPort
       ? "cache.ui-last-port"
       : options.port != null
       ? "options.port"
-      : process.env.TELEGRAM_UI_PORT
+      : hasExplicitEnvPort
         ? "env.TELEGRAM_UI_PORT"
         : `default(${DEFAULT_TELEGRAM_UI_PORT})`;
+  const usingFallbackDefaultPort = portSource.startsWith("default(");
 
   if (!Number.isFinite(port) || port < 0) {
     console.warn(
@@ -9745,7 +9900,8 @@ export async function startTelegramUiServer(options = {}) {
     // Reuse a recent session token when possible so browser sessions survive restarts.
     ensureSessionToken();
 
-    const listenHost = options.host || DEFAULT_HOST;
+    const host = options.host || DEFAULT_HOST;
+    const maxPortFallbackAttempts = usingFallbackDefaultPort ? 20 : 0;
     const listenOnce = (targetPort) =>
       new Promise((resolveReady, rejectReady) => {
         const onError = (err) => {
@@ -9758,20 +9914,38 @@ export async function startTelegramUiServer(options = {}) {
         };
         uiServer.once("error", onError);
         uiServer.once("listening", onListening);
-        uiServer.listen(targetPort, listenHost);
+        uiServer.listen(targetPort, host);
       });
+    let listenPort = port;
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        await listenOnce(listenPort);
+        break;
+      } catch (err) {
+        const isAddrInUse = err?.code === "EADDRINUSE";
+        const canRetryPortIncrement =
+          isAddrInUse &&
+          attempt < maxPortFallbackAttempts &&
+          listenPort > 0;
+        if (canRetryPortIncrement) {
+          const nextPort = listenPort + 1;
+          console.warn(
+            `[telegram-ui] port ${listenPort} in use; retrying on ${nextPort} (attempt ${attempt + 1}/${maxPortFallbackAttempts})`,
+          );
+          listenPort = nextPort;
+          continue;
+        }
 
-    try {
-      await listenOnce(port);
-    } catch (err) {
-      const code = String(err?.code || "").toUpperCase();
-      const canRetryWithEphemeral =
-        allowEphemeralPort && port > 0 && (code === "EADDRINUSE" || code === "EACCES");
-      if (!canRetryWithEphemeral) throw err;
-      console.warn(
-        `[telegram-ui] failed to bind ${listenHost}:${port} (${code || "unknown"}); retrying with ephemeral port`,
-      );
-      await listenOnce(0);
+        const code = String(err?.code || "").toUpperCase();
+        const canRetryWithEphemeral =
+          allowEphemeralPort && listenPort > 0 && (code === "EADDRINUSE" || code === "EACCES");
+        if (!canRetryWithEphemeral) throw err;
+        console.warn(
+          `[telegram-ui] failed to bind ${host}:${listenPort} (${code || "unknown"}); retrying with ephemeral port`,
+        );
+        await listenOnce(0);
+        break;
+      }
     }
   } catch (err) {
     releaseUiInstanceLock();

package/update-check.mjs

@@ -529,6 +529,12 @@ let parentPid = null;
 let parentCheckInterval = null;
 let cleanupHandlersRegistered = false;
 
+function isSuppressedStreamNoiseError(err) {
+  const msg = String(err?.message || err || "");
+  if (!msg) return false;
+  return msg.includes("setRawMode EIO") || msg.includes("read EIO");
+}
+
 /**
  * Start a background polling loop that checks for updates every `intervalMs`
  * (default 10 min). When a newer version is found, it:
@@ -800,17 +806,17 @@ function registerCleanupHandlers() {
     stopAutoUpdateLoop();
   });
 
-  // Handle uncaught exceptions (last resort)
-  const originalUncaughtException = process.listeners("uncaughtException");
+  // Handle uncaught exceptions (last resort). Do not manually re-emit previous
+  // listeners: Node invokes all uncaughtException handlers automatically.
   process.on("uncaughtException", (err) => {
+    if (isSuppressedStreamNoiseError(err)) {
+      console.log(
+        `[auto-update] suppressed stream noise (uncaughtException): ${err?.message || err}`,
+      );
+      return;
+    }
     console.error(`[auto-update] Uncaught exception, cleaning up:`, err);
     stopAutoUpdateLoop();
-    // Re-emit for other handlers
-    if (originalUncaughtException.length > 0) {
-      for (const handler of originalUncaughtException) {
-        handler(err);
-      }
-    }
   });
 }
 
@@ -829,22 +835,44 @@ function printUpdateNotice(current, latest) {
 
 function promptConfirm(question) {
   return new Promise((res) => {
+    let settled = false;
+    const settle = (value) => {
+      if (settled) return;
+      settled = true;
+      res(Boolean(value));
+    };
     const rl = createInterface({
       input: process.stdin,
       output: process.stdout,
-      terminal: process.stdin.isTTY && process.stdout.isTTY,
+      // Keep readline out of raw-mode transitions; they can throw EIO during
+      // terminal teardown in daemonized/non-interactive contexts.
+      terminal: false,
+    });
+    rl.on("error", (err) => {
+      if (isSuppressedStreamNoiseError(err)) {
+        console.log(
+          `[auto-update] suppressed stream noise (readline): ${err?.message || err}`,
+        );
+        settle(false);
+        return;
+      }
+      console.warn(`[auto-update] prompt failed: ${err?.message || err}`);
+      settle(false);
     });
     rl.question(question, (answer) => {
       try {
         rl.close();
       } catch (err) {
-        const msg = err?.message || String(err || "");
-        if (!msg.includes("setRawMode EIO")) {
-          throw err;
+        if (isSuppressedStreamNoiseError(err)) {
+          console.log(
+            `[auto-update] suppressed stream noise (readline close): ${err?.message || err}`,
+          );
+        } else {
+          console.warn(`[auto-update] prompt close failed: ${err?.message || err}`);
         }
       }
       const a = answer.trim().toLowerCase();
-      res(!a || a === "y" || a === "yes");
+      settle(!a || a === "y" || a === "yes");
     });
   });
 }