9router 0.2.84 → 0.2.87

package/src/cli/menus/cliTools.js

@@ -1,6 +1,3 @@
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
 const api = require("../api/client");
 const { pause } = require("../utils/input");
 const { showStatus } = require("../utils/display");
@@ -8,13 +5,6 @@ const { selectModelFromList } = require("../utils/modelSelector");
 const { showMenuWithBack } = require("../utils/menuHelper");
 const { getEndpoint } = require("../utils/endpoint");
 
-// Claude model types with their env keys and default values (matching Web UI)
-const CLAUDE_MODEL_TYPES = [
-  { id: "sonnet", name: "Sonnet", envKey: "ANTHROPIC_DEFAULT_SONNET_MODEL", defaultValue: "cc/claude-sonnet-4-5-20250929" },
-  { id: "opus", name: "Opus", envKey: "ANTHROPIC_DEFAULT_OPUS_MODEL", defaultValue: "cc/claude-opus-4-5-20251101" },
-  { id: "haiku", name: "Haiku", envKey: "ANTHROPIC_DEFAULT_HAIKU_MODEL", defaultValue: "cc/claude-haiku-4-5-20251001" },
-];
-
 const COLORS = {
   reset: "\x1b[0m",
   green: "\x1b[32m",
@@ -23,266 +13,424 @@ const COLORS = {
   cyan: "\x1b[36m"
 };
 
+// Claude model types with defaults (matching Web UI)
+const CLAUDE_MODEL_TYPES = [
+  { id: "sonnet", name: "Sonnet", envKey: "ANTHROPIC_DEFAULT_SONNET_MODEL", defaultValue: "cc/claude-sonnet-4-5-20250929" },
+  { id: "opus",   name: "Opus",   envKey: "ANTHROPIC_DEFAULT_OPUS_MODEL",   defaultValue: "cc/claude-opus-4-5-20251101" },
+  { id: "haiku",  name: "Haiku",  envKey: "ANTHROPIC_DEFAULT_HAIKU_MODEL",  defaultValue: "cc/claude-haiku-4-5-20251001" },
+];
+
+// ─── Shared helpers ───────────────────────────────────────────────────────────
+
 /**
- * Get Claude settings file path
- * @returns {string} Full path to settings.json
+ * Get first available API key from server
+ * @returns {Promise<string|null>}
  */
-function getClaudeSettingsPath() {
-  return path.join(os.homedir(), ".claude", "settings.json");
+async function getFirstApiKey() {
+  const result = await api.getApiKeys();
+  const keys = result.success ? (result.data.keys || []) : [];
+  return keys.length > 0 ? keys[0].key : null;
 }
 
+// ─── Claude Code ──────────────────────────────────────────────────────────────
+
 /**
- * Read Claude settings
- * @returns {Object|null}
+ * Build header showing current Claude config status
+ * @returns {Promise<string>}
  */
-function readClaudeSettings() {
-  try {
-    const settingsPath = getClaudeSettingsPath();
-    const content = fs.readFileSync(settingsPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
+async function buildClaudeHeader() {
+  const result = await api.getCliToolSettings("claude");
+  if (!result.success) return `  ${COLORS.red}Failed to load settings${COLORS.reset}`;
+
+  const settings = result.data.settings;
+  const currentUrl = settings?.env?.ANTHROPIC_BASE_URL;
+  const currentKey = settings?.env?.ANTHROPIC_AUTH_TOKEN;
+  const lines = [];
+
+  if (currentUrl) {
+    lines.push(`Status:   ${COLORS.green}✓ Configured${COLORS.reset}`);
+    lines.push(`Endpoint: ${COLORS.cyan}${currentUrl}${COLORS.reset}`);
+    if (currentKey) {
+      lines.push(`API Key:  ${COLORS.dim}${currentKey.substring(0, 10)}...${COLORS.reset}`);
+    }
+  } else {
+    lines.push(`Status:   ${COLORS.red}✗ Not configured${COLORS.reset}`);
+    lines.push(`${COLORS.dim}Run "Quick Setup" to configure${COLORS.reset}`);
   }
+
+  return lines.join("\n");
 }
 
 /**
- * Write Claude settings
- * @param {Object} settings - Settings object
+ * Get current Claude model from settings
+ * @param {string} envKey
+ * @returns {Promise<string>}
  */
-function writeClaudeSettings(settings) {
-  const settingsPath = getClaudeSettingsPath();
-  const claudeDir = path.dirname(settingsPath);
-  
-  if (!fs.existsSync(claudeDir)) {
-    fs.mkdirSync(claudeDir, { recursive: true });
-  }
-  
-  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+async function getClaudeModel(envKey) {
+  const result = await api.getCliToolSettings("claude");
+  return result.success ? (result.data.settings?.env?.[envKey] || "Not set") : "Not set";
 }
 
 /**
- * Get current model mapping from settings
- * @param {string} envKey - Environment key
- * @returns {string} Current model or "Not set"
+ * Quick setup for Claude Code — sets endpoint, key, and all default models
+ * @param {number} port
  */
-function getCurrentModel(envKey) {
-  const settings = readClaudeSettings();
-  return settings?.env?.[envKey] || "Not set";
+async function claudeQuickSetup(port) {
+  const { endpoint } = await getEndpoint(port);
+  const apiKey = await getFirstApiKey();
+
+  if (!apiKey) {
+    showStatus("No API keys found. Create one in API Keys menu first.", "error");
+    await pause();
+    return;
+  }
+
+  const env = { ANTHROPIC_BASE_URL: endpoint, ANTHROPIC_AUTH_TOKEN: apiKey, API_TIMEOUT_MS: "600000" };
+  CLAUDE_MODEL_TYPES.forEach(t => { env[t.envKey] = t.defaultValue; });
+
+  const result = await api.applyCliToolSettings("claude", { env });
+  showStatus(result.success ? "Quick Setup completed!" : `Failed: ${result.error}`, result.success ? "success" : "error");
+  await pause();
 }
 
 /**
- * Select a model for a specific type
- * @param {Object} modelType - Model type config
- * @param {number} port - Server port
+ * Select and save a specific Claude model type
+ * @param {Object} modelType
+ * @param {number} port
  */
-async function selectModelForType(modelType, port) {
-  const currentValue = getCurrentModel(modelType.envKey);
-  const selectedModel = await selectModelFromList(`Select ${modelType.name} Model`, currentValue);
-  
-  if (!selectedModel) {
-    return;
-  }
-  
-  const { endpoint } = await getEndpoint(port);
-  
-  // Save immediately
-  let settings = readClaudeSettings() || {};
-  settings.env = settings.env || {};
-  settings.env[modelType.envKey] = selectedModel;
-  
-  // Also set base URL if not set
-  if (!settings.env.ANTHROPIC_BASE_URL) {
-    settings.env.ANTHROPIC_BASE_URL = endpoint;
-    settings.env.API_TIMEOUT_MS = "600000";
-    
-    // Get first API key for auth
-    const keysResult = await api.getApiKeys();
-    const keys = keysResult.success ? (keysResult.data.keys || []) : [];
-    if (keys.length > 0) {
-      settings.env.ANTHROPIC_AUTH_TOKEN = keys[0].key;
-    }
-  }
-  
-  try {
-    writeClaudeSettings(settings);
-    showStatus(`${modelType.name} → ${selectedModel} saved!`, "success");
-  } catch (error) {
-    showStatus(`Failed to save: ${error.message}`, "error");
+async function claudeSelectModel(modelType, port) {
+  const current = await getClaudeModel(modelType.envKey);
+  const selected = await selectModelFromList(`Select ${modelType.name} Model`, current);
+  if (!selected) return;
+
+  const env = { [modelType.envKey]: selected };
+
+  // Also set base URL if not configured yet
+  const settingsResult = await api.getCliToolSettings("claude");
+  if (!settingsResult.data?.settings?.env?.ANTHROPIC_BASE_URL) {
+    const { endpoint } = await getEndpoint(port);
+    const apiKey = await getFirstApiKey();
+    env.ANTHROPIC_BASE_URL = endpoint;
+    env.API_TIMEOUT_MS = "600000";
+    if (apiKey) env.ANTHROPIC_AUTH_TOKEN = apiKey;
   }
-  
+
+  const result = await api.applyCliToolSettings("claude", { env });
+  showStatus(result.success ? `${modelType.name} → ${selected} saved!` : `Failed: ${result.error}`, result.success ? "success" : "error");
+  await pause();
+}
+
+/**
+ * Reset Claude Code settings
+ */
+async function claudeReset() {
+  const result = await api.resetCliToolSettings("claude");
+  showStatus(result.success ? "Settings reset successfully!" : `Failed: ${result.error}`, result.success ? "success" : "error");
   await pause();
 }
 
 /**
- * Quick setup - set endpoint, key and all default models
- * @param {number} port - Server port
+ * Claude Code submenu
+ * @param {number} port
+ * @param {Array<string>} breadcrumb
  */
-async function quickSetup(port) {
+async function showClaudeCodeMenu(port, breadcrumb = []) {
+  await showMenuWithBack({
+    title: "🔧 Claude Code Settings",
+    breadcrumb,
+    headerContent: buildClaudeHeader,
+    refresh: async () => ({
+      sonnet: await getClaudeModel("ANTHROPIC_DEFAULT_SONNET_MODEL"),
+      opus:   await getClaudeModel("ANTHROPIC_DEFAULT_OPUS_MODEL"),
+      haiku:  await getClaudeModel("ANTHROPIC_DEFAULT_HAIKU_MODEL"),
+    }),
+    items: [
+      {
+        label: "⚡ Quick Setup (recommended)",
+        action: async () => { await claudeQuickSetup(port); return true; }
+      },
+      {
+        label: (d) => `Sonnet → ${d.sonnet}`,
+        action: async () => { await claudeSelectModel(CLAUDE_MODEL_TYPES[0], port); return true; }
+      },
+      {
+        label: (d) => `Opus → ${d.opus}`,
+        action: async () => { await claudeSelectModel(CLAUDE_MODEL_TYPES[1], port); return true; }
+      },
+      {
+        label: (d) => `Haiku → ${d.haiku}`,
+        action: async () => { await claudeSelectModel(CLAUDE_MODEL_TYPES[2], port); return true; }
+      },
+      {
+        label: "Reset to Default",
+        action: async () => { await claudeReset(); return true; }
+      }
+    ]
+  });
+}
+
+// ─── Codex CLI ────────────────────────────────────────────────────────────────
+
+/**
+ * Build header showing current Codex config status
+ * @returns {Promise<string>}
+ */
+async function buildCodexHeader() {
+  const result = await api.getCliToolSettings("codex");
+  if (!result.success) return `  ${COLORS.red}Failed to load settings${COLORS.reset}`;
+
+  const { installed, has9Router, config } = result.data;
+  if (!installed) return `Status:   ${COLORS.red}✗ Codex CLI not installed${COLORS.reset}`;
+
+  if (!has9Router) {
+    return [
+      `Status:   ${COLORS.red}✗ Not configured${COLORS.reset}`,
+      `${COLORS.dim}Run "Quick Setup" to configure${COLORS.reset}`
+    ].join("\n");
+  }
+
+  // Parse base_url and model from raw TOML string
+  const baseUrlMatch = config && config.match(/base_url\s*=\s*"([^"]+)"/);
+  const modelMatch = config && config.match(/^model\s*=\s*"([^"]+)"/m);
+  const baseUrl = baseUrlMatch ? baseUrlMatch[1] : "";
+  const model = modelMatch ? modelMatch[1] : "";
+
+  const lines = [`Status:   ${COLORS.green}✓ Configured${COLORS.reset}`];
+  if (baseUrl) lines.push(`Endpoint: ${COLORS.cyan}${baseUrl}${COLORS.reset}`);
+  if (model)   lines.push(`Model:    ${COLORS.dim}${model}${COLORS.reset}`);
+  return lines.join("\n");
+}
+
+/**
+ * Quick setup for Codex CLI
+ * @param {number} port
+ */
+async function codexQuickSetup(port) {
   const { endpoint } = await getEndpoint(port);
-  
-  // Get first API key
-  const keysResult = await api.getApiKeys();
-  const keys = keysResult.success ? (keysResult.data.keys || []) : [];
-  
-  if (keys.length === 0) {
-    showStatus("No API keys found. Please create one in API Keys menu first.", "error");
+  const apiKey = await getFirstApiKey();
+
+  if (!apiKey) {
+    showStatus("No API keys found. Create one in API Keys menu first.", "error");
     await pause();
     return;
   }
-  
-  let settings = readClaudeSettings() || {};
-  settings.env = settings.env || {};
-  
-  // Set endpoint and key
-  settings.env.ANTHROPIC_BASE_URL = endpoint;
-  settings.env.ANTHROPIC_AUTH_TOKEN = keys[0].key;
-  settings.env.API_TIMEOUT_MS = "600000";
-  
-  // Set default models
-  CLAUDE_MODEL_TYPES.forEach(modelType => {
-    settings.env[modelType.envKey] = modelType.defaultValue;
-  });
-  
-  try {
-    writeClaudeSettings(settings);
-    showStatus("Quick Setup completed! All settings configured.", "success");
-  } catch (error) {
-    showStatus(`Failed to save: ${error.message}`, "error");
-  }
-  
+
+  // Get model selection
+  const model = await selectModelFromList("Select Codex Model", "cx/claude-sonnet-4-5-20250929");
+  if (!model) return;
+
+  const result = await api.applyCliToolSettings("codex", { baseUrl: endpoint, apiKey, model });
+  showStatus(result.success ? "Codex setup completed!" : `Failed: ${result.error}`, result.success ? "success" : "error");
   await pause();
 }
 
 /**
- * Build header content showing current config status
- * @param {number} port - Server port
+ * Reset Codex CLI settings
+ */
+async function codexReset() {
+  const result = await api.resetCliToolSettings("codex");
+  showStatus(result.success ? "Codex settings reset!" : `Failed: ${result.error}`, result.success ? "success" : "error");
+  await pause();
+}
+
+/**
+ * Codex CLI submenu
+ * @param {number} port
+ * @param {Array<string>} breadcrumb
+ */
+async function showCodexMenu(port, breadcrumb = []) {
+  await showMenuWithBack({
+    title: "🤖 Codex CLI Settings",
+    breadcrumb,
+    headerContent: buildCodexHeader,
+    refresh: async () => ({}),
+    items: [
+      {
+        label: "⚡ Quick Setup",
+        action: async () => { await codexQuickSetup(port); return true; }
+      },
+      {
+        label: "Reset to Default",
+        action: async () => { await codexReset(); return true; }
+      }
+    ]
+  });
+}
+
+// ─── Factory Droid ────────────────────────────────────────────────────────────
+
+/**
+ * Build header showing current Droid config status
  * @returns {Promise<string>}
  */
-async function buildClaudeHeaderContent(port) {
-  const settings = readClaudeSettings();
-  const { endpoint } = await getEndpoint(port);
-  
-  const currentUrl = settings?.env?.ANTHROPIC_BASE_URL;
-  const currentKey = settings?.env?.ANTHROPIC_AUTH_TOKEN;
-  const isConfigured = !!currentUrl;
-  
-  const lines = [];
-  
-  if (isConfigured) {
-    lines.push(`Status:   ${COLORS.green}✓ Configured${COLORS.reset}`);
-    lines.push(`Endpoint: ${COLORS.cyan}${currentUrl}${COLORS.reset}`);
-    if (currentKey) {
-      const masked = currentKey.substring(0, 10) + "...";
-      lines.push(`API Key:  ${COLORS.dim}${masked}${COLORS.reset}`);
-    }
-  } else {
-    lines.push(`Status:   ${COLORS.red}✗ Not configured${COLORS.reset}`);
-    lines.push(`${COLORS.dim}Run "Quick Setup" to configure${COLORS.reset}`);
+async function buildDroidHeader() {
+  const result = await api.getCliToolSettings("droid");
+  if (!result.success) return `  ${COLORS.red}Failed to load settings${COLORS.reset}`;
+
+  const { installed, has9Router, settings } = result.data;
+  if (!installed) return `Status:   ${COLORS.red}✗ Factory Droid not installed${COLORS.reset}`;
+
+  if (!has9Router) {
+    return [
+      `Status:   ${COLORS.red}✗ Not configured${COLORS.reset}`,
+      `${COLORS.dim}Run "Quick Setup" to configure${COLORS.reset}`
+    ].join("\n");
   }
-  
+
+  // Extract 9Router custom model config
+  const custom = settings?.customModels?.find(m => m.id === "custom:9Router-0");
+  const lines = [`Status:   ${COLORS.green}✓ Configured${COLORS.reset}`];
+  if (custom?.baseUrl) lines.push(`Endpoint: ${COLORS.cyan}${custom.baseUrl}${COLORS.reset}`);
+  if (custom?.model)   lines.push(`Model:    ${COLORS.dim}${custom.model}${COLORS.reset}`);
   return lines.join("\n");
 }
 
 /**
- * Reset Claude settings
+ * Quick setup for Factory Droid
+ * @param {number} port
  */
-async function resetClaudeSettings() {
-  const settings = readClaudeSettings();
-  
-  if (!settings) {
-    showStatus("No settings file to reset", "info");
+async function droidQuickSetup(port) {
+  const { endpoint } = await getEndpoint(port);
+  const apiKey = await getFirstApiKey();
+
+  if (!apiKey) {
+    showStatus("No API keys found. Create one in API Keys menu first.", "error");
     await pause();
     return;
   }
-  
-  const keysToRemove = [
-    "ANTHROPIC_BASE_URL",
-    "ANTHROPIC_AUTH_TOKEN",
-    "ANTHROPIC_DEFAULT_OPUS_MODEL",
-    "ANTHROPIC_DEFAULT_SONNET_MODEL",
-    "ANTHROPIC_DEFAULT_HAIKU_MODEL",
-    "API_TIMEOUT_MS",
-  ];
-  
-  if (settings.env) {
-    keysToRemove.forEach(key => {
-      delete settings.env[key];
-    });
-    
-    if (Object.keys(settings.env).length === 0) {
-      delete settings.env;
-    }
-  }
-  
-  try {
-    writeClaudeSettings(settings);
-    showStatus("Settings reset successfully!", "success");
-  } catch (error) {
-    showStatus(`Failed to reset: ${error.message}`, "error");
-  }
-  
+
+  const model = await selectModelFromList("Select Droid Model", "cc/claude-sonnet-4-5-20250929");
+  if (!model) return;
+
+  const result = await api.applyCliToolSettings("droid", { baseUrl: endpoint, apiKey, model });
+  showStatus(result.success ? "Factory Droid setup completed!" : `Failed: ${result.error}`, result.success ? "success" : "error");
   await pause();
 }
 
 /**
- * Claude Code settings submenu
- * @param {number} port - Server port
- * @param {Array<string>} breadcrumb - Breadcrumb path
+ * Reset Factory Droid settings
  */
-async function showClaudeCodeMenu(port, breadcrumb = []) {
+async function droidReset() {
+  const result = await api.resetCliToolSettings("droid");
+  showStatus(result.success ? "Factory Droid settings reset!" : `Failed: ${result.error}`, result.success ? "success" : "error");
+  await pause();
+}
+
+/**
+ * Factory Droid submenu
+ * @param {number} port
+ * @param {Array<string>} breadcrumb
+ */
+async function showDroidMenu(port, breadcrumb = []) {
   await showMenuWithBack({
-    title: "🔧 Claude Code Settings",
+    title: "🤖 Factory Droid Settings",
     breadcrumb,
-    headerContent: async () => await buildClaudeHeaderContent(port),
-    refresh: async () => ({
-      sonnet: getCurrentModel("ANTHROPIC_DEFAULT_SONNET_MODEL"),
-      opus: getCurrentModel("ANTHROPIC_DEFAULT_OPUS_MODEL"),
-      haiku: getCurrentModel("ANTHROPIC_DEFAULT_HAIKU_MODEL")
-    }),
+    headerContent: buildDroidHeader,
+    refresh: async () => ({}),
     items: [
       {
-        label: "⚡ Quick Setup (recommended)",
-        action: async () => {
-          await quickSetup(port);
-          return true;
-        }
-      },
-      {
-        label: (data) => `Sonnet → ${data.sonnet}`,
-        action: async () => {
-          await selectModelForType(CLAUDE_MODEL_TYPES[0], port);
-          return true;
-        }
+        label: "⚡ Quick Setup",
+        action: async () => { await droidQuickSetup(port); return true; }
       },
       {
-        label: (data) => `Opus → ${data.opus}`,
-        action: async () => {
-          await selectModelForType(CLAUDE_MODEL_TYPES[1], port);
-          return true;
-        }
-      },
+        label: "Reset to Default",
+        action: async () => { await droidReset(); return true; }
+      }
+    ]
+  });
+}
+
+// ─── Open Claw ────────────────────────────────────────────────────────────────
+
+/**
+ * Build header showing current OpenClaw config status
+ * @returns {Promise<string>}
+ */
+async function buildOpenClawHeader() {
+  const result = await api.getCliToolSettings("openclaw");
+  if (!result.success) return `  ${COLORS.red}Failed to load settings${COLORS.reset}`;
+
+  const { installed, has9Router, settings } = result.data;
+  if (!installed) return `Status:   ${COLORS.red}✗ Open Claw not installed${COLORS.reset}`;
+
+  if (!has9Router) {
+    return [
+      `Status:   ${COLORS.red}✗ Not configured${COLORS.reset}`,
+      `${COLORS.dim}Run "Quick Setup" to configure${COLORS.reset}`
+    ].join("\n");
+  }
+
+  // Extract 9Router provider config
+  const provider = settings?.models?.providers?.["9router"];
+  const primary = settings?.agents?.defaults?.model?.primary || "";
+  const model = primary.startsWith("9router/") ? primary.replace("9router/", "") : (provider?.models?.[0]?.id || "");
+  const lines = [`Status:   ${COLORS.green}✓ Configured${COLORS.reset}`];
+  if (provider?.baseUrl) lines.push(`Endpoint: ${COLORS.cyan}${provider.baseUrl}${COLORS.reset}`);
+  if (model)             lines.push(`Model:    ${COLORS.dim}${model}${COLORS.reset}`);
+  return lines.join("\n");
+}
+
+/**
+ * Quick setup for Open Claw
+ * @param {number} port
+ */
+async function openClawQuickSetup(port) {
+  const { endpoint } = await getEndpoint(port);
+  const apiKey = await getFirstApiKey();
+
+  if (!apiKey) {
+    showStatus("No API keys found. Create one in API Keys menu first.", "error");
+    await pause();
+    return;
+  }
+
+  const model = await selectModelFromList("Select OpenClaw Model", "cc/claude-sonnet-4-5-20250929");
+  if (!model) return;
+
+  const result = await api.applyCliToolSettings("openclaw", { baseUrl: endpoint, apiKey, model });
+  showStatus(result.success ? "Open Claw setup completed!" : `Failed: ${result.error}`, result.success ? "success" : "error");
+  await pause();
+}
+
+/**
+ * Reset Open Claw settings
+ */
+async function openClawReset() {
+  const result = await api.resetCliToolSettings("openclaw");
+  showStatus(result.success ? "Open Claw settings reset!" : `Failed: ${result.error}`, result.success ? "success" : "error");
+  await pause();
+}
+
+/**
+ * Open Claw submenu
+ * @param {number} port
+ * @param {Array<string>} breadcrumb
+ */
+async function showOpenClawMenu(port, breadcrumb = []) {
+  await showMenuWithBack({
+    title: "🦞 Open Claw Settings",
+    breadcrumb,
+    headerContent: buildOpenClawHeader,
+    refresh: async () => ({}),
+    items: [
       {
-        label: (data) => `Haiku → ${data.haiku}`,
-        action: async () => {
-          await selectModelForType(CLAUDE_MODEL_TYPES[2], port);
-          return true;
-        }
+        label: "⚡ Quick Setup",
+        action: async () => { await openClawQuickSetup(port); return true; }
       },
       {
         label: "Reset to Default",
-        action: async () => {
-          await resetClaudeSettings();
-          return true;
-        }
+        action: async () => { await openClawReset(); return true; }
       }
     ]
   });
 }
 
+// ─── Main CLI Tools Menu ──────────────────────────────────────────────────────
+
 /**
- * Main CLI Tools menu - list all CLI tools
- * @param {number} port - Server port
- * @param {Array<string>} breadcrumb - Breadcrumb path
+ * Main CLI Tools menu
+ * @param {number} port
+ * @param {Array<string>} breadcrumb
  */
 async function showCliToolsMenu(port, breadcrumb = []) {
   const { endpoint } = await getEndpoint(port);
@@ -293,18 +441,22 @@ async function showCliToolsMenu(port, breadcrumb = []) {
     items: [
       {
         label: "Claude Code",
-        action: async () => {
-          await showClaudeCodeMenu(port, [...breadcrumb, "Claude Code"]);
-          return true;
-        }
+        action: async () => { await showClaudeCodeMenu(port, [...breadcrumb, "Claude Code"]); return true; }
+      },
+      {
+        label: "Codex CLI",
+        action: async () => { await showCodexMenu(port, [...breadcrumb, "Codex CLI"]); return true; }
+      },
+      {
+        label: "Factory Droid",
+        action: async () => { await showDroidMenu(port, [...breadcrumb, "Factory Droid"]); return true; }
+      },
+      {
+        label: "Open Claw",
+        action: async () => { await showOpenClawMenu(port, [...breadcrumb, "Open Claw"]); return true; }
       }
-      // { label: "Codex CLI" },
-      // { label: "Cursor" },
-      // { label: "Cline" }
     ]
   });
 }
 
-module.exports = {
-  showCliToolsMenu
-};
+module.exports = { showCliToolsMenu };

package/src/cli/tray/tray.js

@@ -60,7 +60,8 @@ function initTray(options) {
 
     const menu = {
       icon: getIconBase64(),
-      title: "",
+      // Windows uses title as the tray icon tooltip
+      title: `9Router - Port ${port}`,
       tooltip: `9Router - Port ${port}`,
       items: [
         {