bosun 0.36.0 → 0.36.2

package/setup-web-server.mjs

@@ -36,8 +36,8 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 //   2. Node module resolution via createRequire — handles global install hoisting
 //   3. CDN redirect — last resort
 const _require = createRequire(import.meta.url);
-const uiRootPreferred = resolve(__dirname, "site", "ui");
-const uiRootFallback = resolve(__dirname, "ui");
+const uiRootPreferred = resolve(__dirname, "ui");
+const uiRootFallback = resolve(__dirname, "site", "ui");
 const uiRoot = existsSync(uiRootPreferred) ? uiRootPreferred : uiRootFallback;
 const BUNDLED_VENDOR_DIR = resolve(uiRoot, "vendor");
 
@@ -134,12 +134,27 @@ const MODELS = {
     { value: "claude-sonnet-4", label: "claude-sonnet-4" },
     { value: "claude-haiku-4.5", label: "claude-haiku-4.5" },
   ],
+  gemini: [
+    { value: "gemini-2.5-pro", label: "gemini-2.5-pro", recommended: true },
+    { value: "gemini-2.5-flash", label: "gemini-2.5-flash" },
+    { value: "gemini-2.0-flash", label: "gemini-2.0-flash" },
+    { value: "gemini-1.5-pro", label: "gemini-1.5-pro" },
+    { value: "gemini-1.5-flash", label: "gemini-1.5-flash" },
+  ],
+  opencode: [
+    { value: "gpt-5.3-codex", label: "gpt-5.3-codex", recommended: true },
+    { value: "gpt-5.2-codex", label: "gpt-5.2-codex" },
+    { value: "claude-opus-4.6", label: "claude-opus-4.6" },
+    { value: "gemini-2.5-pro", label: "gemini-2.5-pro" },
+  ],
 };
 
 const EXECUTOR_TYPES = [
   { value: "COPILOT", label: "GitHub Copilot (recommended)", recommended: true },
   { value: "CODEX", label: "OpenAI Codex CLI" },
   { value: "CLAUDE_CODE", label: "Claude Code" },
+  { value: "GEMINI", label: "Google Gemini" },
+  { value: "OPENCODE", label: "OpenCode (local server)" },
 ];
 
 const KANBAN_BACKENDS = [
@@ -178,6 +193,195 @@ function normalizeWorkflowTemplateIds(rawValue, fallback = []) {
   return Array.isArray(fallback) ? [...fallback] : [];
 }
 
+function normalizeWorkspaceId(value, fallback = "workspace") {
+  const normalized = String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+  return normalized || fallback;
+}
+
+function extractRepoNameFromText(text) {
+  const raw = String(text || "").trim();
+  if (!raw) return "";
+  if (/^[a-z0-9_.-]+\/[a-z0-9_.-]+$/i.test(raw)) {
+    return raw.split("/").pop() || "";
+  }
+  try {
+    const parsed = new URL(raw);
+    const pathname = String(parsed.pathname || "")
+      .replace(/\.git$/i, "")
+      .replace(/^\/+|\/+$/g, "");
+    return pathname.split("/").pop() || "";
+  } catch {
+    const cleaned = raw
+      .replace(/\\/g, "/")
+      .replace(/\.git$/i, "")
+      .replace(/^\/+|\/+$/g, "");
+    return cleaned.split("/").pop() || "";
+  }
+}
+
+function normalizeRepoSlug(text) {
+  const raw = String(text || "").trim();
+  if (!raw) return "";
+  if (/^[a-z0-9_.-]+\/[a-z0-9_.-]+$/i.test(raw)) return raw;
+  const fromUrl = raw.match(/github\.com[:/]([a-z0-9_.-]+\/[a-z0-9_.-]+)(?:\.git)?/i);
+  if (fromUrl?.[1]) return fromUrl[1];
+  return "";
+}
+
+function normalizeRepoConfigEntry(repo, index = 0) {
+  const raw = typeof repo === "string" ? { slug: repo } : (repo && typeof repo === "object" ? repo : null);
+  if (!raw) return null;
+  const slug = normalizeRepoSlug(raw.slug || raw.url || raw.path || raw.name || "");
+  const url =
+    String(raw.url || "").trim() ||
+    (slug ? `https://github.com/${slug}.git` : "");
+  const name = String(raw.name || raw.id || "").trim() || extractRepoNameFromText(slug || url || raw.path || "");
+  if (!name && !slug && !url) return null;
+  return {
+    name: name || extractRepoNameFromText(url || slug) || `repo-${index + 1}`,
+    slug,
+    url,
+    primary: Boolean(raw.primary) || index === 0,
+  };
+}
+
+function normalizeWorkspaceConfigEntry(workspace, index = 0) {
+  if (!workspace || typeof workspace !== "object") return null;
+  const fallbackId = `workspace-${index + 1}`;
+  const id = normalizeWorkspaceId(
+    workspace.id || workspace.name || fallbackId,
+    fallbackId,
+  );
+  const name = String(workspace.name || workspace.id || id).trim() || id;
+  const repos = Array.isArray(workspace.repos)
+    ? workspace.repos
+        .map((repo, repoIndex) => normalizeRepoConfigEntry(repo, repoIndex))
+        .filter(Boolean)
+    : [];
+  let activeRepo = String(workspace.activeRepo || "").trim();
+  if (!activeRepo && repos[0]?.name) activeRepo = repos[0].name;
+  if (activeRepo && !repos.some((repo) => repo.name === activeRepo)) {
+    activeRepo = repos[0]?.name || "";
+  }
+  return {
+    id,
+    name,
+    repos,
+    createdAt: workspace.createdAt || new Date().toISOString(),
+    activeRepo: activeRepo || null,
+  };
+}
+
+function normalizeWorkspaceConfigList(workspaces) {
+  if (!Array.isArray(workspaces)) return [];
+  const byId = new Map();
+  for (let i = 0; i < workspaces.length; i += 1) {
+    const normalized = normalizeWorkspaceConfigEntry(workspaces[i], i);
+    if (!normalized) continue;
+    const existing = byId.get(normalized.id);
+    if (!existing) {
+      byId.set(normalized.id, normalized);
+      continue;
+    }
+    // Merge with precedence to latest entry while preserving earlier repo order.
+    const repoMap = new Map();
+    for (const repo of existing.repos || []) repoMap.set(repo.name, repo);
+    for (const repo of normalized.repos || []) repoMap.set(repo.name, repo);
+    byId.set(normalized.id, {
+      ...existing,
+      ...normalized,
+      repos: [...repoMap.values()],
+      activeRepo:
+        normalized.activeRepo ||
+        existing.activeRepo ||
+        [...repoMap.values()][0]?.name ||
+        null,
+    });
+  }
+  return [...byId.values()];
+}
+
+function readExistingBosunConfig(bosunHome) {
+  const configPath = resolve(bosunHome, "bosun.config.json");
+  if (!existsSync(configPath)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(configPath, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function resolveSetupWorkspaceAndRepoConfig(existingConfig = {}, configJson = {}, env = {}) {
+  const normalizedIncomingRepos = Array.isArray(configJson.repos)
+    ? configJson.repos
+        .map((repo, idx) => normalizeRepoConfigEntry(repo, idx))
+        .filter(Boolean)
+    : [];
+  const normalizedExistingRepos = Array.isArray(existingConfig.repos)
+    ? existingConfig.repos
+        .map((repo, idx) => normalizeRepoConfigEntry(repo, idx))
+        .filter(Boolean)
+    : [];
+  const repos =
+    normalizedIncomingRepos.length > 0
+      ? normalizedIncomingRepos
+      : normalizedExistingRepos;
+
+  const normalizedIncomingWorkspaces = normalizeWorkspaceConfigList(configJson.workspaces);
+  const normalizedExistingWorkspaces = normalizeWorkspaceConfigList(existingConfig.workspaces);
+  let workspaces = normalizedIncomingWorkspaces.length > 0
+    ? normalizedIncomingWorkspaces
+    : normalizedExistingWorkspaces;
+
+  // Bootstrap a single default workspace when repos exist but no workspace
+  // layout was provided, so the UI and workspace APIs stay consistent.
+  if (workspaces.length === 0 && repos.length > 0) {
+    const defaultWorkspaceId = normalizeWorkspaceId(
+      configJson.projectName || env.projectName || existingConfig.projectName || "default",
+      "default",
+    );
+    workspaces = [
+      {
+        id: defaultWorkspaceId,
+        name:
+          configJson.projectName ||
+          env.projectName ||
+          existingConfig.projectName ||
+          "Default Workspace",
+        repos: repos.map((repo, idx) => ({
+          ...repo,
+          primary: repo.primary === true || idx === 0,
+        })),
+        createdAt: new Date().toISOString(),
+        activeRepo: repos[0]?.name || null,
+      },
+    ];
+  }
+
+  let activeWorkspace = "";
+  if (workspaces.length > 0) {
+    const requestedActiveWorkspace = normalizeWorkspaceId(
+      configJson.activeWorkspace || existingConfig.activeWorkspace || workspaces[0]?.id,
+      workspaces[0]?.id || "default",
+    );
+    activeWorkspace = workspaces.some((ws) => ws.id === requestedActiveWorkspace)
+      ? requestedActiveWorkspace
+      : workspaces[0].id;
+  }
+
+  return {
+    repos,
+    workspaces,
+    activeWorkspace,
+  };
+}
+
 function buildStableSetupDefaults({
   projectName,
   slug,
@@ -230,6 +434,18 @@ function buildStableSetupDefaults({
     workflowRunStuckThresholdMs: 300000,
     workflowMaxPersistedRuns: 200,
     workflowMaxConcurrentBranches: 8,
+    voiceEnabled: true,
+    voiceProvider: "auto",
+    voiceModel: "gpt-4o-realtime-preview-2024-12-17",
+    voiceVisionModel: "gpt-4.1-mini",
+    voiceId: "alloy",
+    voiceTurnDetection: "server_vad",
+    voiceFallbackMode: "browser",
+    voiceDelegateExecutor: "codex-sdk",
+    openaiRealtimeApiKey: "",
+    azureOpenaiRealtimeEndpoint: "",
+    azureOpenaiRealtimeApiKey: "",
+    azureOpenaiRealtimeDeployment: "gpt-4o-realtime-preview",
     copilotEnableAllMcpTools: false,
     // Backward-compatible fields consumed by older setup UI revisions.
     distribution: "primary-only",
@@ -330,8 +546,33 @@ function applyTelegramMiniAppSetupEnv(envMap, env, sourceEnv = process.env) {
     env?.telegramUiTunnel ||
     env?.TELEGRAM_UI_TUNNEL ||
     sourceEnv.TELEGRAM_UI_TUNNEL ||
-    "auto";
-  envMap.TELEGRAM_UI_TUNNEL = String(tunnelRaw).trim() || "auto";
+    "named";
+  envMap.TELEGRAM_UI_TUNNEL = String(tunnelRaw).trim() || "named";
+
+  const quickFallbackRaw =
+    env?.telegramUiAllowQuickTunnelFallback ??
+    env?.TELEGRAM_UI_ALLOW_QUICK_TUNNEL_FALLBACK ??
+    sourceEnv.TELEGRAM_UI_ALLOW_QUICK_TUNNEL_FALLBACK;
+  envMap.TELEGRAM_UI_ALLOW_QUICK_TUNNEL_FALLBACK = toBooleanEnvString(
+    quickFallbackRaw,
+    false,
+  );
+
+  const fallbackAuthRaw =
+    env?.telegramUiFallbackAuthEnabled ??
+    env?.TELEGRAM_UI_FALLBACK_AUTH_ENABLED ??
+    sourceEnv.TELEGRAM_UI_FALLBACK_AUTH_ENABLED;
+  envMap.TELEGRAM_UI_FALLBACK_AUTH_ENABLED = toBooleanEnvString(
+    fallbackAuthRaw,
+    true,
+  );
+
+  const hostnamePolicyRaw =
+    env?.cloudflareUsernameHostnamePolicy ||
+    env?.CLOUDFLARE_USERNAME_HOSTNAME_POLICY ||
+    sourceEnv.CLOUDFLARE_USERNAME_HOSTNAME_POLICY ||
+    "per-user-fixed";
+  envMap.CLOUDFLARE_USERNAME_HOSTNAME_POLICY = String(hostnamePolicyRaw).trim() || "per-user-fixed";
 
   const unsafeRaw =
     env?.telegramUiAllowUnsafe ??
@@ -589,6 +830,122 @@ function applyNonBlockingSetupEnvDefaults(envMap, env = {}, sourceEnv = process.
     ["workspace-write", "danger-full-access", "read-only"],
     "workspace-write",
   );
+  envMap.VOICE_ENABLED = toBooleanEnvString(
+    pickNonEmptyValue(
+      env.voiceEnabled,
+      env.VOICE_ENABLED,
+      envMap.VOICE_ENABLED,
+      sourceEnv.VOICE_ENABLED,
+    ),
+    true,
+  );
+  envMap.VOICE_PROVIDER = normalizeEnumValue(
+    pickNonEmptyValue(
+      env.voiceProvider,
+      env.VOICE_PROVIDER,
+      envMap.VOICE_PROVIDER,
+      sourceEnv.VOICE_PROVIDER,
+    ),
+    ["auto", "openai", "azure", "claude", "gemini", "fallback"],
+    "auto",
+  );
+  envMap.VOICE_MODEL = String(
+    pickNonEmptyValue(
+      env.voiceModel,
+      env.VOICE_MODEL,
+      envMap.VOICE_MODEL,
+      sourceEnv.VOICE_MODEL,
+    ) || "gpt-4o-realtime-preview-2024-12-17",
+  ).trim() || "gpt-4o-realtime-preview-2024-12-17";
+  envMap.VOICE_VISION_MODEL = String(
+    pickNonEmptyValue(
+      env.voiceVisionModel,
+      env.VOICE_VISION_MODEL,
+      envMap.VOICE_VISION_MODEL,
+      sourceEnv.VOICE_VISION_MODEL,
+    ) || "gpt-4.1-mini",
+  ).trim() || "gpt-4.1-mini";
+  envMap.VOICE_ID = normalizeEnumValue(
+    pickNonEmptyValue(
+      env.voiceId,
+      env.VOICE_ID,
+      envMap.VOICE_ID,
+      sourceEnv.VOICE_ID,
+    ),
+    ["alloy", "ash", "ballad", "coral", "echo", "fable", "onyx", "nova", "sage", "shimmer", "verse"],
+    "alloy",
+  );
+  envMap.VOICE_TURN_DETECTION = normalizeEnumValue(
+    pickNonEmptyValue(
+      env.voiceTurnDetection,
+      env.VOICE_TURN_DETECTION,
+      envMap.VOICE_TURN_DETECTION,
+      sourceEnv.VOICE_TURN_DETECTION,
+    ),
+    ["server_vad", "semantic_vad", "none"],
+    "server_vad",
+  );
+  envMap.VOICE_FALLBACK_MODE = normalizeEnumValue(
+    pickNonEmptyValue(
+      env.voiceFallbackMode,
+      env.VOICE_FALLBACK_MODE,
+      envMap.VOICE_FALLBACK_MODE,
+      sourceEnv.VOICE_FALLBACK_MODE,
+    ),
+    ["browser", "disabled"],
+    "browser",
+  );
+  envMap.VOICE_DELEGATE_EXECUTOR = normalizeEnumValue(
+    pickNonEmptyValue(
+      env.voiceDelegateExecutor,
+      env.VOICE_DELEGATE_EXECUTOR,
+      envMap.VOICE_DELEGATE_EXECUTOR,
+      sourceEnv.VOICE_DELEGATE_EXECUTOR,
+    ),
+    ["codex-sdk", "copilot-sdk", "claude-sdk", "gemini-sdk", "opencode-sdk"],
+    "codex-sdk",
+  );
+
+  const openaiRealtimeApiKey = pickNonEmptyValue(
+    env.openaiRealtimeApiKey,
+    env.OPENAI_REALTIME_API_KEY,
+    envMap.OPENAI_REALTIME_API_KEY,
+    sourceEnv.OPENAI_REALTIME_API_KEY,
+  );
+  if (openaiRealtimeApiKey !== undefined) {
+    envMap.OPENAI_REALTIME_API_KEY = String(openaiRealtimeApiKey).trim();
+  }
+
+  const azureRealtimeEndpoint = pickNonEmptyValue(
+    env.azureOpenaiRealtimeEndpoint,
+    env.AZURE_OPENAI_REALTIME_ENDPOINT,
+    envMap.AZURE_OPENAI_REALTIME_ENDPOINT,
+    sourceEnv.AZURE_OPENAI_REALTIME_ENDPOINT,
+    sourceEnv.AZURE_OPENAI_ENDPOINT,
+  );
+  if (azureRealtimeEndpoint !== undefined) {
+    envMap.AZURE_OPENAI_REALTIME_ENDPOINT = String(azureRealtimeEndpoint).trim();
+  }
+
+  const azureRealtimeApiKey = pickNonEmptyValue(
+    env.azureOpenaiRealtimeApiKey,
+    env.AZURE_OPENAI_REALTIME_API_KEY,
+    envMap.AZURE_OPENAI_REALTIME_API_KEY,
+    sourceEnv.AZURE_OPENAI_REALTIME_API_KEY,
+    sourceEnv.AZURE_OPENAI_API_KEY,
+  );
+  if (azureRealtimeApiKey !== undefined) {
+    envMap.AZURE_OPENAI_REALTIME_API_KEY = String(azureRealtimeApiKey).trim();
+  }
+
+  envMap.AZURE_OPENAI_REALTIME_DEPLOYMENT = String(
+    pickNonEmptyValue(
+      env.azureOpenaiRealtimeDeployment,
+      env.AZURE_OPENAI_REALTIME_DEPLOYMENT,
+      envMap.AZURE_OPENAI_REALTIME_DEPLOYMENT,
+      sourceEnv.AZURE_OPENAI_REALTIME_DEPLOYMENT,
+    ) || "gpt-4o-realtime-preview",
+  ).trim() || "gpt-4o-realtime-preview";
 
   envMap.CONTAINER_ENABLED = toBooleanEnvString(
     pickNonEmptyValue(env.containerEnabled, envMap.CONTAINER_ENABLED, sourceEnv.CONTAINER_ENABLED),
@@ -962,8 +1319,20 @@ async function handleModelsProbe(body) {
 
   // Copilot and Claude Code use OAuth — we can't probe their model lists from
   // the server side. Return the static list with a note.
-  if (executor === "COPILOT" || executor === "CLAUDE_CODE") {
-    const key = executor === "COPILOT" ? "copilot" : "claude";
+  if (
+    executor === "COPILOT" ||
+    executor === "CLAUDE_CODE" ||
+    executor === "GEMINI" ||
+    executor === "OPENCODE"
+  ) {
+    const key =
+      executor === "COPILOT"
+        ? "copilot"
+        : executor === "CLAUDE_CODE"
+          ? "claude"
+          : executor === "GEMINI"
+            ? "gemini"
+            : "opencode";
     return {
       ok: true,
       models: MODELS[key] || [],
@@ -1073,6 +1442,7 @@ function handleApply(body) {
     // Resolve home + workspaces dirs — prefer what the user chose in the wizard
     const bosunHome    = env.bosunHome    ? resolve(env.bosunHome)    : resolveConfigDir();
     const workspacesDir = env.workspacesDir ? resolve(env.workspacesDir) : resolveWorkspacesDir(bosunHome);
+    const existingConfig = readExistingBosunConfig(bosunHome);
 
     // ── Create directory scaffold ───────────────────────────────────────────
     mkdirSync(bosunHome, { recursive: true });
@@ -1264,6 +1634,13 @@ function handleApply(body) {
           if (ex.baseUrl) envMap.ANTHROPIC_BASE_URL = ex.baseUrl;
           // Note: Anthropic does not have a native multi-profile env-var system;
           // only a single key/endpoint is supported for this executor type.
+        } else if (type === "GEMINI" || type === "GOOGLE_GEMINI") {
+          if (ex.apiKey) {
+            envMap.GEMINI_API_KEY = ex.apiKey;
+          }
+          if (ex.baseUrl) {
+            envMap.GEMINI_BASE_URL = ex.baseUrl;
+          }
         }
         // COPILOT uses gh auth — no API key env vars needed.
       }
@@ -1280,17 +1657,28 @@ function handleApply(body) {
 
     // ── Build bosun.config.json ─────────────────────────────────────────────
     const config = {
+      ...existingConfig,
       projectName: configJson.projectName || env.projectName || "my-project",
       bosunHome,
       workspacesDir,
-      executors: configJson.executors || [],
+      executors:
+        Array.isArray(configJson.executors)
+          ? configJson.executors
+          : Array.isArray(existingConfig.executors)
+            ? existingConfig.executors
+            : [],
       failover: configJson.failover || {
+        ...(existingConfig.failover || {}),
         strategy: env.failoverStrategy || "next-in-line",
         maxRetries: Number(env.maxRetries) || 3,
         cooldownMinutes: Number(env.failoverCooldownMinutes) || 5,
         disableOnConsecutiveFailures: Number(env.failoverDisableOnConsecutive) || 3,
       },
-      distribution: configJson.distribution || env.executorDistribution || "primary-only",
+      distribution:
+        configJson.distribution ||
+        existingConfig.distribution ||
+        env.executorDistribution ||
+        "primary-only",
     };
 
     const workflowProfile = normalizeWorkflowProfile(
@@ -1345,16 +1733,33 @@ function handleApply(body) {
     if (configJson.primaryAgent)               config.primaryAgent               = configJson.primaryAgent;
     if (configJson.projectRequirementsProfile) config.projectRequirementsProfile = configJson.projectRequirementsProfile;
     if (configJson.internalReplenish)          config.internalReplenish          = configJson.internalReplenish;
-    if (configJson.repos?.length)              config.repos                      = configJson.repos;
     if (configJson.kanban)                     config.kanban                     = configJson.kanban;
-    if (configJson.workspaces?.length)         config.workspaces                 = configJson.workspaces;
+
+    const workspaceConfig = resolveSetupWorkspaceAndRepoConfig(
+      existingConfig,
+      configJson,
+      env,
+    );
+    if (workspaceConfig.repos.length > 0) {
+      config.repos = workspaceConfig.repos;
+    } else {
+      delete config.repos;
+    }
+
+    if (workspaceConfig.workspaces.length > 0) {
+      config.workspaces = workspaceConfig.workspaces;
+      config.activeWorkspace = workspaceConfig.activeWorkspace;
+    } else {
+      delete config.workspaces;
+      delete config.activeWorkspace;
+    }
 
     const configPath = resolve(bosunHome, "bosun.config.json");
     writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
 
     // ── Trust the BOSUN_HOME in every agent CLI ─────────────────────────────
     // Without this, running a codex agent from bosunHome is rejected with:
-    //   "⚠ Project config.toml files are disabled…"
+    //   ":alert: Project config.toml files are disabled…"
     // We also register bosunHome with Claude Code so it won't prompt for
     // permission when accessing the workspace directories.
 
@@ -1362,7 +1767,7 @@ function handleApply(body) {
     try {
       const trustedResult = ensureTrustedProjects([bosunHome, workspacesDir]);
       if (trustedResult.added.length > 0) {
-        console.log("  ✅ Codex: trusted bosun home directory:", trustedResult.added.join(", "));
+        console.log("  :check: Codex: trusted bosun home directory:", trustedResult.added.join(", "));
       }
     } catch (err) {
       console.warn("[setup] could not update codex trusted_projects:", err.message);
@@ -1373,7 +1778,7 @@ function handleApply(body) {
       const claudeResult = ensureClaudeAdditionalDirectory(bosunHome);
       const claudeWs = ensureClaudeAdditionalDirectory(workspacesDir);
       if (claudeResult.added || claudeWs.added) {
-        console.log("  ✅ Claude: added bosun directories to additionalDirectories");
+        console.log("  :check: Claude: added bosun directories to additionalDirectories");
       }
     } catch (err) {
       console.warn("[setup] could not update claude settings:", err.message);
@@ -1521,7 +1926,7 @@ async function handleRequest(req, res) {
           jsonResponse(res, 200, { ok: true, message: "Setup complete" });
           // Shut down server after response is sent
           setTimeout(() => {
-            console.log("\n  ✅ Setup complete — shutting down wizard server.\n");
+            console.log("\n  :check: Setup complete — shutting down wizard server.\n");
             if (callbackServer) callbackServer.close();
             server.close();
             process.exit(0);
@@ -1646,7 +2051,7 @@ async function startCallbackCatcher(setupPort) {
 </head>
 <body>
   <div class="card">
-    <div class="logo">🚀</div>
+    <div class="logo">:rocket:</div>
     <h1>Bosun GitHub App Setup</h1>
     <p>Bosun needs to be running on your machine before you complete the GitHub Marketplace installation.</p>
     <div class="step"><strong>Step 1:</strong> Open a terminal and run:<br><br><code>bosun --setup</code></div>
@@ -1677,7 +2082,7 @@ async function startCallbackCatcher(setupPort) {
 </head>
 <body>
   <div class="card">
-    <div class="icon">✅</div>
+    <div class="icon">:check:</div>
     <h1>GitHub App Authorized!</h1>
     <p>Redirecting you to the Bosun setup wizard…</p>
   </div>
@@ -1742,14 +2147,14 @@ async function startCallbackCatcher(setupPort) {
 
   try {
     await tryListen(callbackServer, CALLBACK_PORT);
-    console.log(`  📡 GitHub OAuth callback listener: http://127.0.0.1:${CALLBACK_PORT}/github/callback`);
+    console.log(`  :server: GitHub OAuth callback listener: http://127.0.0.1:${CALLBACK_PORT}/github/callback`);
     console.log(`     ↳ Keep this terminal open while installing from GitHub Marketplace.\n`);
   } catch (err) {
     if (err.code === "EADDRINUSE") {
       // Another Bosun instance (or the main UI server) is already on this port — that's fine.
-      console.log(`  ℹ️  Port ${CALLBACK_PORT} is already in use (main Bosun server may be running).\n`);
+      console.log(`  :help:  Port ${CALLBACK_PORT} is already in use (main Bosun server may be running).\n`);
     } else {
-      console.warn(`  ⚠️  Could not start OAuth callback listener on port ${CALLBACK_PORT}: ${err.message}`);
+      console.warn(`  :alert:  Could not start OAuth callback listener on port ${CALLBACK_PORT}: ${err.message}`);
     }
     callbackServer = null;
   }
@@ -1807,7 +2212,7 @@ export async function startSetupServer(options = {}) {
           actualPort = await tryListen(server, 0);
           break;
         } catch (e) {
-          console.error(`  ❌ Could not start setup server: ${e.message}`);
+          console.error(`  :close: Could not start setup server: ${e.message}`);
           process.exit(1);
         }
       }
@@ -1824,7 +2229,7 @@ export async function startSetupServer(options = {}) {
   console.log(`
   ┌──────────────────────────────────────────────────┐
   │                                                  │
-  │   🚀  Bosun Setup Wizard v${version.padEnd(25)}│
+  │   :rocket:  Bosun Setup Wizard v${version.padEnd(25)}│
   │                                                  │
   │   Open in your browser:                          │
   │   ${url.padEnd(45)}│
@@ -1855,6 +2260,9 @@ export {
   applyTelegramMiniAppSetupEnv,
   applyNonBlockingSetupEnvDefaults,
   normalizeTelegramUiPort,
+  normalizeRepoConfigEntry,
+  normalizeWorkspaceConfigList,
+  resolveSetupWorkspaceAndRepoConfig,
 };
 
 // Entry point when run directly