bingocode 1.1.199 → 1.1.200-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bingocode",
-  "version": "1.1.199",
+  "version": "1.1.200-beta.0",
   "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,11 @@ 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>('');
+
+  // VS Code link status
+  const [vscodeLinked, setVscodeLinked] = useState(false);
+  const [vscodeLinkedPaths, setVscodeLinkedPaths] = useState<string[]>([]);
+
 
   const base = apiUrl.replace(/\/+$/, '');
 
@@ -146,6 +147,16 @@ export const ProviderPanel: React.FC<{
     loadPresets();
   }, [loadProviders, loadPresets]);
 
+  // Fetch VS Code link status on mount
+  useEffect(() => {
+    axios.get(`${base}/api/providers/link-vscode`)
+      .then(r => {
+        setVscodeLinked(r.data.linked);
+        setVscodeLinkedPaths(r.data.paths || []);
+      })
+      .catch(() => {});
+  }, [base]);
+
   // Key processing for Page Up/Down and Arrow keys in scrolling lists
   useEffect(() => {
     const handler = (buf: Buffer) => {
@@ -320,6 +331,7 @@ export const ProviderPanel: React.FC<{
             { label: 'Add Provider', value: 'add' },
             { label: 'Edit Provider (Name/Key)', value: 'edit' },
             { label: 'Configure Slots', value: 'slots' },
+            { label: vscodeLinked ? `Disconnect from VS Code (${vscodeLinkedPaths.length} editor(s))` : 'Connect to VS Code', value: 'link_vscode' },
             { label: 'Connectivity Test', value: 'test' },
             { label: 'Delete Provider', value: 'delete' },
             { label: 'Refresh', value: 'refresh' },
@@ -348,6 +360,33 @@ export const ProviderPanel: React.FC<{
                 setStage('slot_config');
                 setListOffset(0);
                 break;
+              case 'link_vscode':
+                setOpMsg(null);
+                setErr(null);
+                if (vscodeLinked) {
+                  // Unlink
+                  axios.delete(`${base}/api/providers/link-vscode`)
+                    .then(() => {
+                      setVscodeLinked(false);
+                      setVscodeLinkedPaths([]);
+                      setOpMsg('Disconnected from VS Code.');
+                    })
+                    .catch(e => {
+                      setErr((e as any)?.response?.data?.message || (e as any)?.message || 'Failed to disconnect VS Code');
+                    });
+                } else {
+                  // Link
+                  axios.post(`${base}/api/providers/link-vscode`)
+                    .then(r => {
+                      setVscodeLinked(true);
+                      setVscodeLinkedPaths(r.data.paths || []);
+                      setOpMsg(`Connected to VS Code (${(r.data.paths || []).length} editor(s)).`);
+                    })
+                    .catch(e => {
+                      setErr((e as any)?.response?.data?.message || (e as any)?.message || 'Failed to connect VS Code');
+                    });
+                }
+                break;
               case 'test':
                 setStage('test_select');
                 setListOffset(0);
@@ -780,10 +819,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 +848,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/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)
+      }
     }
   }