bingocode 1.1.199 → 1.1.200-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bingocode",
-  "version": "1.1.199",
+  "version": "1.1.200-beta.1",
   "type": "module",
   "bin": {
     "claude": "bin/claude-win.cjs",

package/src/cli/ProviderPanel.tsx

@@ -51,8 +51,7 @@ type Stage =
   | 'editing'
   | 'slot_config'
   | 'slot_loading'
-  | 'slot_select_model'
-  | 'slot_input_label';
+  | 'slot_select_model';
 
 export const ProviderPanel: React.FC<{
   apiUrl: string;
@@ -97,9 +96,8 @@ export const ProviderPanel: React.FC<{
   const [slotProviderModels, setSlotProviderModels] = useState<Record<string, string[]>>({});
   const [currentSlotName, setCurrentSlotName] = useState<string>('main');
   const [slotLoadingMsg, setSlotLoadingMsg] = useState<string>('');
-  const [tempSlotProviderId, setTempSlotProviderId] = useState<string>('');
-  const [tempSlotModelId, setTempSlotModelId] = useState<string>('');
-  const [slotLabelInput, setSlotLabelInput] = useState<string>('');
+
+
 
   const base = apiUrl.replace(/\/+$/, '');
 
@@ -348,7 +346,7 @@ export const ProviderPanel: React.FC<{
                 setStage('slot_config');
                 setListOffset(0);
                 break;
-              case 'test':
+                            case 'test':
                 setStage('test_select');
                 setListOffset(0);
                 break;
@@ -780,10 +778,25 @@ export const ProviderPanel: React.FC<{
                 const sepIdx = val.indexOf('::');
                 const providerId = val.slice(0, sepIdx);
                 const modelId = val.slice(sepIdx + 2);
-                setTempSlotProviderId(providerId);
-                setTempSlotModelId(modelId);
-                setSlotLabelInput(modelId);
-                setStage('slot_input_label');
+                axios.put(`${base}/api/providers/slots/${currentSlotName}`, {
+                  providerId,
+                  modelId,
+                  label: null,
+                })
+                .then(() => {
+                  setSlotTable(prev => ({
+                    ...prev,
+                    [currentSlotName]: { providerId, modelId, label: null }
+                  }));
+                  setOpMsg(`Configured [${currentSlotName}] -> ${modelId}`);
+                  setErr(null);
+                  setListOffset(0);
+                  setStage('slot_config');
+                })
+                .catch(e => {
+                  setErr((e as any)?.response?.data?.message || (e as any)?.message || 'Save failed');
+                  setStage('slot_config');
+                });
               }}
             />
           </Box>
@@ -794,47 +807,6 @@ export const ProviderPanel: React.FC<{
     );
   }
 
-  if (stage === 'slot_input_label') {
-    return (
-      <Box flexDirection="column" flexGrow={1}>
-        <Title color="cyan">Configure Slot [{currentSlotName}] — Set Display Name</Title>
-        <Text>
-          Model: {providers.find(p => p.id === tempSlotProviderId)?.name || tempSlotProviderId} / {tempSlotModelId}
-        </Text>
-        <Box marginTop={1}>
-          <Text>Display Name (Label): </Text>
-          <TextInput
-            value={slotLabelInput}
-            onChange={setSlotLabelInput}
-            onSubmit={() => {
-              const label = slotLabelInput.trim() || tempSlotModelId;
-              axios.put(`${base}/api/providers/slots/${currentSlotName}`, {
-                providerId: tempSlotProviderId,
-                modelId: tempSlotModelId,
-                label,
-              })
-              .then(() => {
-                setSlotTable(prev => ({
-                  ...prev,
-                  [currentSlotName]: { providerId: tempSlotProviderId, modelId: tempSlotModelId, label }
-                }));
-                setOpMsg(`Configured [${currentSlotName}] -> ${label}`);
-                setErr(null);
-                setListOffset(0);
-                setStage('slot_config');
-              })
-              .catch(e => {
-                setErr((e as any)?.response?.data?.message || (e as any)?.message || 'Save failed');
-                setStage('slot_config');
-              });
-            }}
-          />
-        </Box>
-        <Hint>Enter: Save (Display name in UI) · ESC: Back to Models</Hint>
-      </Box>
-    );
-  }
-
   return null;
 };
 

package/src/manager/CliMenuManager.tsx

@@ -229,6 +229,9 @@ const i18nMap = {
     bypassPermsLabel: 'Bypass',
     bypassPermsOn: '已开启',
     bypassPermsOff: '已关闭',
+    vscodeLabel: 'Connect to VS Code',
+    vscodeOn: '已连接',
+    vscodeOff: '未连接',
   },
   en: {
     menu: {
@@ -268,6 +271,9 @@ const i18nMap = {
     bypassPermsLabel: 'Bypass',
     bypassPermsOn: 'Enabled',
     bypassPermsOff: 'Disabled',
+    vscodeLabel: 'Connect to VS Code',
+    vscodeOn: 'Connected',
+    vscodeOff: 'Disconnected',
   },
   ja: {
     menu: {
@@ -307,6 +313,9 @@ const i18nMap = {
     bypassPermsLabel: 'Bypass',
     bypassPermsOn: '有効',
     bypassPermsOff: '無効',
+    vscodeLabel: 'Connect to VS Code',
+    vscodeOn: '接続済',
+    vscodeOff: '未接続',
   },
 };
 
@@ -429,6 +438,9 @@ export const CliMenuManager: React.FC = () => {
       if (typeof bSettings.bypassPermsEnabled === 'boolean') {
         setBypassPermsEnabled(bSettings.bypassPermsEnabled);
       }
+      if (typeof bSettings.vscodeLinked === 'boolean') {
+        setVscodeLinked(bSettings.vscodeLinked);
+      }
     } catch {}
   }, []);
 
@@ -488,6 +500,7 @@ export const CliMenuManager: React.FC = () => {
   const [settingsCursor, setSettingsCursor] = useState(0);
   const [autoModeEnabled, setAutoModeEnabled] = useState(false);
   const [bypassPermsEnabled, setBypassPermsEnabled] = useState(false);
+  const [vscodeLinked, setVscodeLinked] = useState(false);
 
   // Top toolbar state
   const [animEnabled, setAnimEnabled] = useState(true);
@@ -875,7 +888,7 @@ export const CliMenuManager: React.FC = () => {
     if (!showHelp && page === 'settings') {
       if (settingsStage === 'list') {
         // +1 for the fixed Language row prepended before settingData entries
-        const totalRows = 3 + (settingData && typeof settingData === 'object' ? Object.keys(settingData).length : 0);
+        const totalRows = 4 + (settingData && typeof settingData === 'object' ? Object.keys(settingData).length : 0);
         const visible = Math.max(1, MID_H - 2);
         if (key.downArrow || input === 'j') {
           setSettingsCursor(c => Math.min(totalRows - 1, c + 1));
@@ -923,12 +936,33 @@ export const CliMenuManager: React.FC = () => {
               }
               return next;
             });
+          } else if (settingsCursor === 3) {
+            // Row 3: toggle VS Code link
+            const port = (process.env.BINGO_PORT ? parseInt(process.env.BINGO_PORT) : 3456) || 3456;
+            const apiBase = process.env.BASE_API_URL || `http://127.0.0.1:${port}`;
+            setVscodeLinked(prev => {
+              const next = !prev;
+              try {
+                writeBingoSettings({ vscodeLinked: next });
+              } catch {
+                return prev;
+              }
+              const http = require('http');
+              if (next) {
+                http.request(`${apiBase}/api/providers/link-vscode`, { method: 'POST' })
+                  .on('error', () => {}).end();
+              } else {
+                http.request(`${apiBase}/api/providers/link-vscode`, { method: 'DELETE' })
+                  .on('error', () => {}).end();
+              }
+              return next;
+            });
           }
         }
       }
       // langPicker stage: ESC handled above; selection via SelectInput onSelect
     }
-  }, [menuItems, page, historyMenuStage, historyList, historyHasMore, navIndex, sessionMessages, settingData, MID_H, MSGS_PAGE_SIZE, showHelp, theme, settingsStage, settingsCursor, autoModeEnabled, bypassPermsEnabled]);
+  }, [menuItems, page, historyMenuStage, historyList, historyHasMore, navIndex, sessionMessages, settingData, MID_H, MSGS_PAGE_SIZE, showHelp, theme, settingsStage, settingsCursor, autoModeEnabled, bypassPermsEnabled, vscodeLinked]);
 
   function cleanText(text: string): string {
     return String(text ?? '').replace(/[\n\r]+/g, ' ').replace(/\u001b\[[0-9;]*m/g, '').trim();
@@ -1412,6 +1446,7 @@ export const CliMenuManager: React.FC = () => {
         { key: '__lang', label: tS.langLabel, value: currentLangLabel, interactive: true },
         { key: '__autoMode', label: tS.autoModeLabel, value: autoModeEnabled ? tS.autoModeOn : tS.autoModeOff, interactive: true },
         { key: '__bypassPerms', label: tS.bypassPermsLabel, value: bypassPermsEnabled ? tS.bypassPermsOn : tS.bypassPermsOff, interactive: true },
+        { key: '__vscode', label: tS.vscodeLabel, value: vscodeLinked ? tS.vscodeOn : tS.vscodeOff, interactive: true },
       ];
       const dataEntries = settingData && typeof settingData === 'object' ? Object.entries(settingData) : [];
       const dataRows: SettingRow[] = dataEntries.map(([k, v]) => ({

package/src/server/api/providers.ts

@@ -26,6 +26,9 @@ import type { SlotName } from '../types/provider.js'
 import { ApiError, errorResponse } from '../middleware/errorHandler.js'
 
 const providerService = new ProviderService()
+providerService.init().catch((err) =>
+  console.error('[ProviderService] init failed:', err),
+)
 
 function maskApiKey(key: string): string {
   if (key.length <= 8) return '****'
@@ -76,6 +79,23 @@ export async function handleProvidersApi(
       return Response.json(slots)
     }
 
+    // /api/providers/link-vscode — manage VS Code linking
+    if (id === 'link-vscode' && !action) {
+      if (req.method === 'GET') {
+        const status = await providerService.getVscodeStatus()
+        return Response.json(status)
+      }
+      if (req.method === 'POST') {
+        const result = await providerService.linkVscode()
+        return Response.json(result)
+      }
+      if (req.method === 'DELETE') {
+        const result = await providerService.unlinkVscode()
+        return Response.json(result)
+      }
+      throw methodNotAllowed(req.method)
+    }
+
     // PUT /api/providers/slots/:slotName  — set one slot
     if (id === 'slots' && action && req.method === 'PUT') {
       const parsed = SlotNameSchema.safeParse(action)

package/src/server/services/providerService.ts

@@ -41,6 +41,44 @@ const MANAGED_ENV_KEYS = [
   'ANTHROPIC_DEFAULT_OPUS_MODEL',
 ] as const
 
+const CLAUDE_DEFAULT_LABELS: Record<SlotName, string> = {
+  main: 'claude-sonnet-4-5',
+  haiku: 'claude-haiku-4-5',
+  sonnet: 'claude-sonnet-4-5',
+  opus: 'claude-opus-4-7',
+}
+
+const VSCODE_EDITOR_NAMES = ['Code', 'Code - Insiders', 'Cursor'] as const
+
+/**
+ * Return candidate VS Code settings.json paths for the current platform.
+ * These are checked for existence (editor directory must exist) before writing.
+ */
+function getVscodeSettingsPaths(): string[] {
+  const home = os.homedir()
+  const paths: string[] = []
+
+  if (process.platform === 'win32') {
+    const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming')
+    for (const name of VSCODE_EDITOR_NAMES) {
+      paths.push(path.join(appData, name, 'User', 'settings.json'))
+    }
+  } else if (process.platform === 'darwin') {
+    const lib = path.join(home, 'Library', 'Application Support')
+    for (const name of VSCODE_EDITOR_NAMES) {
+      paths.push(path.join(lib, name, 'User', 'settings.json'))
+    }
+  } else {
+    // Linux / other Unix
+    const config = path.join(home, '.config')
+    for (const name of VSCODE_EDITOR_NAMES) {
+      paths.push(path.join(config, name, 'User', 'settings.json'))
+    }
+  }
+
+  return paths
+}
+
 const DEFAULT_INDEX: ProvidersIndex = { activeId: null, providers: [] }
 
 export class ProviderService {
@@ -476,12 +514,172 @@ export class ProviderService {
     const index = await this.readIndex()
     const provider = index.providers.find((p) => p.id === entry.providerId)
     if (!provider) return null
+
+    // Auto-fill Claude model names as label when user hasn't set one.
+    // This lets closed-source clients (e.g. VS Code extension) see Claude
+    // model names while the CLI continues to show the real upstream modelId
+    // (syncSettingsForSlots reads raw entry.label, which stays null).
     return {
       baseUrl: provider.baseUrl,
       apiKey: provider.apiKey,
       apiFormat: provider.apiFormat ?? 'anthropic',
       modelId: entry.modelId,
-      label: entry.label,
+      label: entry.label || CLAUDE_DEFAULT_LABELS[slotName],
+    }
+  }
+
+  // --- VS Code linking ---
+
+  /**
+   * Build the environmentVariables array for VS Code claudeCode settings
+   * based on current slot configuration. Uses user-set labels or falls back
+   * to Claude default model names so the VS Code extension shows the right labels.
+   */
+  private async buildVscodeEnvVars(): Promise<Array<{ name: string; value: string }>> {
+    const slots = await this.readSlots()
+    const index = await this.readIndex()
+
+    function getSlotLabel(slotName: SlotName): string | null {
+      const entry = slots[slotName]
+      if (!entry) return null
+      const provider = index.providers.find((p) => p.id === entry.providerId)
+      if (!provider) return null
+      return entry.label || CLAUDE_DEFAULT_LABELS[slotName]
+    }
+
+    const envVars: Array<{ name: string; value: string }> = [
+      { name: 'ANTHROPIC_BASE_URL', value: `http://127.0.0.1:${ProviderService.serverPort}/proxy` },
+      { name: 'ANTHROPIC_AUTH_TOKEN', value: 'proxy-managed' },
+    ]
+
+    const mainLabel = getSlotLabel("main")
+    if (mainLabel) {
+      envVars.push({ name: "ANTHROPIC_MODEL", value: mainLabel })
+    }
+    const haikuLabel = getSlotLabel("haiku")
+    if (haikuLabel) {
+      envVars.push({ name: "ANTHROPIC_DEFAULT_HAIKU_MODEL", value: haikuLabel })
+    }
+    const sonnetLabel = getSlotLabel("sonnet")
+    if (sonnetLabel) {
+      envVars.push({ name: "ANTHROPIC_DEFAULT_SONNET_MODEL", value: sonnetLabel })
+    }
+    const opusLabel = getSlotLabel("opus")
+    if (opusLabel) {
+      envVars.push({ name: "ANTHROPIC_DEFAULT_OPUS_MODEL", value: opusLabel })
+    }
+
+    return envVars
+  }
+
+  /**
+   * Write claudeCode settings into ALL detected VS Code editor instances
+   * (stable, Insiders, Cursor). Persists linked state in bingo settings so
+   * it survives restarts.
+   */
+  async linkVscode(): Promise<{ paths: string[]; linked: boolean }> {
+    const envVars = await this.buildVscodeEnvVars()
+    const candidatePaths = getVscodeSettingsPaths()
+    const writtenPaths: string[] = []
+
+    for (const settingsPath of candidatePaths) {
+      // Only write if the editor config directory exists (editor is installed)
+      const editorDir = path.dirname(path.dirname(settingsPath))
+      try {
+        await fs.access(editorDir)
+      } catch {
+        continue
+      }
+
+      let settings: Record<string, unknown> = {}
+      try {
+        const raw = await fs.readFile(settingsPath, "utf-8")
+        settings = JSON.parse(raw)
+      } catch {
+        // File does not exist yet — start fresh
+      }
+
+      settings.claudeCode = {
+        ...(settings.claudeCode as Record<string, unknown> || {}),
+        preferredLocation: "panel",
+        disableLoginPrompt: true,
+        environmentVariables: envVars,
+      }
+
+      await fs.mkdir(path.dirname(settingsPath), { recursive: true })
+      await fs.writeFile(settingsPath, JSON.stringify(settings, null, 4) + '\n')
+      writtenPaths.push(settingsPath)
+    }
+
+    if (writtenPaths.length === 0) {
+      throw ApiError.badRequest(
+        'No VS Code installation detected. Please install VS Code (stable, Insiders, or Cursor) first.',
+      )
+    }
+
+    // Persist so re-sync on restart and unlink work correctly
+    const bingoSettings = await this.readSettings()
+    bingoSettings.vscodeLinked = true
+    bingoSettings.vscodeLinkedPaths = writtenPaths
+    await this.writeSettings(bingoSettings)
+
+    return { paths: writtenPaths, linked: true }
+  }
+
+  /**
+   * Remove claudeCode keys from all previously-linked VS Code settings files.
+   * Does NOT delete the entire file — it only removes the claudeCode key.
+   */
+  async unlinkVscode(): Promise<{ paths: string[]; linked: boolean }> {
+    const bingoSettings = await this.readSettings()
+    const linkedPaths = (bingoSettings.vscodeLinkedPaths as string[]) || []
+
+    for (const settingsPath of linkedPaths) {
+      try {
+        const raw = await fs.readFile(settingsPath, "utf-8")
+        const settings = JSON.parse(raw)
+        delete settings.claudeCode
+        await fs.writeFile(settingsPath, JSON.stringify(settings, null, 4) + '\n')
+      } catch {
+        // File may have been moved or deleted since linking — harmless
+      }
+    }
+
+    bingoSettings.vscodeLinked = false
+    delete bingoSettings.vscodeLinkedPaths
+    await this.writeSettings(bingoSettings)
+
+    return { paths: linkedPaths, linked: false }
+  }
+
+  /**
+   * Return current VS Code link status from persisted bingo settings.
+   */
+  async getVscodeStatus(): Promise<{ linked: boolean; paths: string[] }> {
+    const bingoSettings = await this.readSettings()
+    return {
+      linked: Boolean(bingoSettings.vscodeLinked),
+      paths: (bingoSettings.vscodeLinkedPaths as string[]) || [],
+    }
+  }
+
+  /**
+   * Initialise the service. If vscodeLinked is true in bingo settings,
+   * re-sync VS Code settings so they stay current with the slot config.
+   * Should be called once after server startup.
+   */
+  async init(): Promise<void> {
+    const status = await this.getVscodeStatus()
+    if (status.linked) {
+      try {
+        await this.linkVscode()
+      } catch {
+        // VS Code may have been uninstalled — clear stale state
+        const bingoSettings = await this.readSettings()
+        bingoSettings.vscodeLinked = false
+        delete bingoSettings.vscodeLinkedPaths
+        await this.writeSettings(bingoSettings)
+      }
     }
   }