npm - free-coding-models - Versions diffs - 0.5.6 → 0.5.8 - Mend

free-coding-models 0.5.6 → 0.5.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (48) hide show

package/README.md +14 -9
package/changelog/v0.5.7.md +20 -0
package/package.json +1 -1
package/src/core/endpoint-installer.js +3 -3
package/src/core/tool-launchers.js +2 -2
package/web/dist/assets/index-DKmmiDip.css +1 -0
package/web/dist/assets/index-DzVt42Nf.js +39 -0
package/web/dist/index.html +2 -2
package/web/server.js +386 -1
package/web/src/App.jsx +145 -26
package/web/src/components/analytics/AnalyticsView.jsx +4 -0
package/web/src/components/analytics/TokenUsagePanel.jsx +105 -0
package/web/src/components/analytics/TokenUsagePanel.module.css +126 -0
package/web/src/components/atoms/TierBadge.module.css +3 -3
package/web/src/components/dashboard/DetailPanel.jsx +29 -4
package/web/src/components/dashboard/DetailPanel.module.css +26 -0
package/web/src/components/dashboard/FilterBar.jsx +17 -2
package/web/src/components/dashboard/FilterBar.module.css +17 -0
package/web/src/components/dashboard/ModelTable.jsx +17 -5
package/web/src/components/dashboard/ModelTable.module.css +14 -1
package/web/src/components/help/HelpView.jsx +1 -1
package/web/src/components/install/InstallEndpointsView.jsx +278 -0
package/web/src/components/install/InstallEndpointsView.module.css +351 -0
package/web/src/components/installed/InstalledModelsView.jsx +89 -0
package/web/src/components/installed/InstalledModelsView.module.css +200 -0
package/web/src/components/launch/IncompatibleFallbackModal.jsx +69 -0
package/web/src/components/launch/LaunchButton.jsx +30 -0
package/web/src/components/launch/LaunchButton.module.css +35 -0
package/web/src/components/launch/LaunchModal.module.css +125 -0
package/web/src/components/layout/Header.jsx +70 -11
package/web/src/components/layout/Header.module.css +62 -2
package/web/src/components/recommend/RecommendView.jsx +121 -0
package/web/src/components/recommend/RecommendView.module.css +55 -0
package/web/src/components/router/RouterView.jsx +286 -0
package/web/src/components/router/RouterView.module.css +357 -0
package/web/src/components/tools/ToolPicker.jsx +86 -0
package/web/src/components/tools/ToolPicker.module.css +84 -0
package/web/src/global.css +23 -0
package/web/src/hooks/urlState.constants.js +3 -0
package/web/src/hooks/useInstalledModels.js +42 -0
package/web/src/hooks/useRecommend.js +67 -0
package/web/src/hooks/useRouterDashboard.js +133 -0
package/web/src/hooks/useTokenUsage.js +103 -0
package/web/src/hooks/useToolMode.js +77 -0
package/web/src/hooks/useUrlState.js +4 -3
package/web/src/utils/m3.js +55 -0
package/web/dist/assets/index-Blp9QJev.js +0 -39
package/web/dist/assets/index-Cz_aCLTR.css +0 -1

package/web/dist/index.html CHANGED Viewed

@@ -48,8 +48,8 @@
   <link rel="preconnect" href="https://fonts.googleapis.com">
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
   <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800;900&family=JetBrains+Mono:wght@400;500;600&display=swap" rel="stylesheet">
-  <script type="module" crossorigin src="/assets/index-Blp9QJev.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-Cz_aCLTR.css">
+  <script type="module" crossorigin src="/assets/index-DzVt42Nf.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-DKmmiDip.css">
 </head>
 <body>
   <div id="root"></div>

package/web/server.js CHANGED Viewed

@@ -46,6 +46,17 @@ import {
   getStabilityScore,
 } from '../src/core/utils.js'
 import { benchmarkModel, BENCHMARK_TIMEOUT_MS } from '../src/core/benchmark.js'
+import { getInstallTargetModes, installProviderEndpoints, getConfiguredInstallableProviders, getProviderCatalogModels } from '../src/core/endpoint-installer.js'
+import { isModelCompatibleWithTool } from '../src/core/tool-metadata.js'
+import { sendUsageTelemetry } from '../src/core/telemetry.js'
+import { getRouterDaemonStatus, startRouterDaemonBackground, stopRouterDaemon, ROUTER_TOKENS_PATH } from '../src/core/router-daemon.js'
+import { scanAllToolConfigs, softDeleteModel } from '../src/core/installed-models-manager.js'
+import {
+  TASK_TYPES,
+  PRIORITY_TYPES,
+  CONTEXT_BUDGETS,
+  getTopRecommendations,
+} from '../src/core/utils.js'
 import {
   PING_MODE_INTERVALS,
   PING_MODE_CYCLE,
@@ -511,6 +522,108 @@ function runWithConcurrency(tasks, concurrency) {
   })
 }
+const TOOL_MODE_ORDER = getInstallTargetModes()
+const TOOL_MODES = new Set(TOOL_MODE_ORDER)
+const DAEMON_PROXY_TIMEOUT_MS = 5000
+// ─── Router daemon proxy helper ────────────────────────────────────────────
+async function proxyToDaemon(path, options = {}) {
+  const port = await readDaemonPort()
+  if (!port) return null
+  try {
+    const url = `http://127.0.0.1:${port}${path}`
+    const resp = await fetch(url, { ...options, signal: AbortSignal.timeout(DAEMON_PROXY_TIMEOUT_MS) })
+    return { ok: resp.ok, status: resp.status, data: await resp.json().catch(() => null) }
+  } catch { return null }
+}
+function readTokenFile() {
+  try {
+    if (!existsSync(ROUTER_TOKENS_PATH)) return null
+    return JSON.parse(readFileSync(ROUTER_TOKENS_PATH, 'utf8'))
+  } catch { return null }
+}
+function normalizeToolMode(mode) {
+  return typeof mode === 'string' && TOOL_MODES.has(mode) ? mode : 'opencode'
+}
+function getPreferredToolMode() {
+  return normalizeToolMode(config.settings?.preferredToolMode)
+}
+function persistPreferredToolMode(mode) {
+  const normalized = normalizeToolMode(mode)
+  if (!config.settings || typeof config.settings !== 'object') config.settings = {}
+  config.settings.preferredToolMode = normalized
+  const saveResult = saveConfig(config)
+  return { mode: normalized, saveResult }
+}
+function getEndpointModel(providerKey, modelId) {
+  const result = getResult(providerKey, modelId)
+  if (!result) return null
+  return {
+    providerKey: result.providerKey,
+    modelId: result.modelId,
+    label: result.label,
+    tier: result.tier,
+    sweScore: result.sweScore,
+    ctx: result.ctx,
+    status: result.status,
+  }
+}
+async function readDaemonPort() {
+  try {
+    const raw = readFileSync(`${process.env.HOME}/.free-coding-models-daemon.port`, 'utf8').trim()
+    if (/^\d+$/.test(raw)) return Number(raw)
+  } catch {}
+  return null
+}
+async function syncFavoritesToRouter(selected) {
+  if (config?.router?.enabled !== true) return
+  const selKey = `${selected.providerKey}/${selected.modelId}`
+  const favorites = Array.isArray(config.favorites) ? config.favorites : []
+  const chain = [selKey, ...favorites.filter((entry) => entry !== selKey)]
+  const models = chain.map((entry, index) => {
+    const slashIdx = entry.indexOf('/')
+    const provider = slashIdx >= 0 ? entry.slice(0, slashIdx) : '?'
+    const model = slashIdx >= 0 ? entry.slice(slashIdx + 1) : entry
+    return { provider, model, priority: index + 1 }
+  })
+  try {
+    const port = await readDaemonPort()
+    if (!port) return
+    const baseUrl = `http://127.0.0.1:${port}`
+    const setPayload = { name: 'fast-coding', models, created: new Date().toISOString() }
+    await fetch(`${baseUrl}/sets/fast-coding`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(setPayload),
+    })
+    await fetch(`${baseUrl}/sets/fast-coding/activate`, { method: 'POST' })
+  } catch {}
+}
+async function installEndpointForMode(mode, model) {
+  return installProviderEndpoints(config, model.providerKey, mode, {
+    scope: 'selected',
+    modelIds: [model.modelId],
+  })
+}
+function buildRecommendReason(result, answers) {
+  const bits = []
+  if (result.tier) bits.push(`${result.tier} tier`)
+  if (result.sweScore && result.sweScore !== '—') bits.push(`${result.sweScore} SWE`)
+  if (result.ctx) bits.push(`${result.ctx} context`)
+  if (result.status === 'up') bits.push('currently up')
+  const priority = PRIORITY_TYPES[answers.priority]?.label || 'balanced'
+  return `${bits.join(' · ') || 'Strong catalog fit'} for ${priority.toLowerCase()} priority.`
+}
 async function handleRequest(req, res) {
   res.setHeader('X-FCM-Server', SERVER_SIGNATURE)
   res.setHeader('Access-Control-Allow-Origin', '*')
@@ -628,6 +741,110 @@ async function handleRequest(req, res) {
         sendJson(res, 200, getConfigPayload())
         return
+      // ── M3: shared tool mode — same preferredToolMode setting as the TUI Z cycle ──
+      case '/api/tool-mode': {
+        if (req.method === 'GET') {
+          sendJson(res, 200, { mode: getPreferredToolMode(), tools: TOOL_MODE_ORDER })
+          return
+        }
+        if (req.method !== 'POST') { res.writeHead(405); res.end('Method Not Allowed'); return }
+        const body = await readJsonBody(req)
+        if (!TOOL_MODES.has(body?.mode)) { sendJson(res, 422, { error: 'Invalid tool mode' }); return }
+        const { mode, saveResult } = persistPreferredToolMode(body.mode)
+        if (!saveResult.success) { sendJson(res, 500, { error: saveResult.error || 'Failed to save tool mode' }); return }
+        noteUserActivity()
+        sendJson(res, 200, { mode })
+        return
+      }
+      // ── M3: install selected model endpoint into a tool config, no process spawn ──
+      case '/api/install-endpoint':
+      case '/api/launch': {
+        if (req.method !== 'POST') { res.writeHead(405); res.end('Method Not Allowed'); return }
+        const body = await readJsonBody(req)
+        const mode = normalizeToolMode(body?.toolMode || body?.mode || getPreferredToolMode())
+        const model = getEndpointModel(body?.providerKey, body?.modelId)
+        if (!model) { sendJson(res, 404, { error: 'Model not found' }); return }
+        if (!isModelCompatibleWithTool(model.providerKey, mode)) {
+          sendJson(res, 422, { error: 'Model is incompatible with selected tool', code: 'incompatible_model', mode, model })
+          return
+        }
+        const { saveResult } = persistPreferredToolMode(mode)
+        if (!saveResult.success) { sendJson(res, 500, { error: saveResult.error || 'Failed to persist tool mode' }); return }
+        noteUserActivity()
+        try {
+          const installResult = await installEndpointForMode(mode, model)
+          void syncFavoritesToRouter(model)
+          void sendUsageTelemetry(config, { noTelemetry: false }, {
+            event: 'app_action',
+            mode,
+            properties: {
+              source: 'web',
+              action_type: 'install_endpoint',
+              tool_mode: mode,
+              provider: model.providerKey,
+              model_id: model.modelId,
+              model_label: model.label,
+              model_tier: model.tier,
+            },
+          })
+          sendJson(res, 200, { configured: true, mode, model, installResult })
+        } catch (err) {
+          sendJson(res, 422, {
+            error: err?.message || 'Failed to install endpoint',
+            code: 'endpoint_install_failed',
+            mode,
+            model,
+          })
+        }
+        return
+      }
+      // ── M3: Smart Recommend — wraps the same core scoring engine as the TUI ──
+      case '/api/recommend': {
+        if (req.method !== 'POST') { res.writeHead(405); res.end('Method Not Allowed'); return }
+        const body = await readJsonBody(req)
+        const answers = body?.answers || {}
+        const taskType = answers.taskType
+        const priority = answers.priority
+        const contextBudget = answers.contextBudget
+        if (!TASK_TYPES[taskType] || !PRIORITY_TYPES[priority] || !CONTEXT_BUDGETS[contextBudget]) {
+          sendJson(res, 422, { error: 'Invalid recommendation answers' })
+          return
+        }
+        const top3 = getTopRecommendations(results, taskType, priority, contextBudget, 3)
+          .map(({ result, score }) => ({
+            result: serializeModel(result),
+            score,
+            reason: buildRecommendReason(result, answers),
+          }))
+        void sendUsageTelemetry(config, { noTelemetry: false }, {
+          event: 'app_action',
+          mode: getPreferredToolMode(),
+          properties: { source: 'web', action_type: 'smart_recommend', taskType, priority, contextBudget },
+        })
+        sendJson(res, 200, { top3, answers: { taskType, priority, contextBudget } })
+        return
+      }
+      // ── M3: web telemetry mirror — never blocks UX and never exposes secrets ──
+      case '/api/telemetry/event': {
+        if (req.method !== 'POST') { res.writeHead(405); res.end('Method Not Allowed'); return }
+        const body = await readJsonBody(req)
+        const event = typeof body?.event === 'string' && body.event.trim() ? body.event.trim() : 'app_action'
+        const properties = body?.properties && typeof body.properties === 'object' && !Array.isArray(body.properties)
+          ? body.properties
+          : {}
+        void sendUsageTelemetry(config, { noTelemetry: false }, {
+          event,
+          mode: getPreferredToolMode(),
+          properties: { ...properties, source: 'web' },
+        })
+        sendJson(res, 200, { ok: true })
+        return
+      }
       case '/api/events':
         res.writeHead(200, {
           'Content-Type': 'text/event-stream',
@@ -900,7 +1117,175 @@ async function handleRequest(req, res) {
         return
       }
-      default:
+      // ── M4: Router dashboard endpoints ────────────────────────────────────
+      case '/api/router/status': {
+        try {
+          const status = await getRouterDaemonStatus()
+          sendJson(res, 200, status)
+        } catch (err) {
+          sendJson(res, 200, { ok: false, running: false, error: err.message })
+        }
+        return
+      }
+      case '/api/router/stats': {
+        const proxy = await proxyToDaemon('/stats')
+        if (proxy?.ok) { sendJson(res, 200, proxy.data); return }
+        sendJson(res, 200, { ok: false, running: false, error: 'Daemon not reachable' })
+        return
+      }
+      case '/api/router/tokens': {
+        // 📖 Try daemon first (live data), fall back to reading the token file
+        const proxy = await proxyToDaemon('/stats/tokens')
+        if (proxy?.ok) { sendJson(res, 200, proxy.data); return }
+        const fileData = readTokenFile()
+        if (fileData) { sendJson(res, 200, fileData); return }
+        sendJson(res, 200, { daily: {}, all_time: { total_tokens: 0, prompt_tokens: 0, completion_tokens: 0, requests: 0 } })
+        return
+      }
+      case '/api/router/start': {
+        if (req.method !== 'POST') { res.writeHead(405); res.end('Method Not Allowed'); return }
+        try {
+          const result = await startRouterDaemonBackground()
+          noteUserActivity()
+          sendJson(res, 200, result)
+        } catch (err) {
+          sendJson(res, 500, { ok: false, error: err.message })
+        }
+        return
+      }
+      case '/api/router/stop': {
+        if (req.method !== 'POST') { res.writeHead(405); res.end('Method Not Allowed'); return }
+        try {
+          const result = await stopRouterDaemon()
+          sendJson(res, 200, result)
+        } catch (err) {
+          sendJson(res, 500, { ok: false, error: err.message })
+        }
+        return
+      }
+      case '/api/router/sets': {
+        // 📖 Proxy set operations to the daemon
+        if (req.method === 'GET') {
+          const proxy = await proxyToDaemon('/sets')
+          if (proxy?.ok) { sendJson(res, 200, proxy.data); return }
+          // 📖 Fallback: read sets from config directly
+          const routerConfig = config.router || {}
+          sendJson(res, 200, { activeSet: routerConfig.activeSet || 'fast-coding', sets: routerConfig.sets || {} })
+          return
+        }
+        if (req.method === 'POST') {
+          const proxy = await proxyToDaemon('/sets', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(await readJsonBody(req)) })
+          if (proxy?.ok) { sendJson(res, 200, proxy.data); return }
+          if (proxy?.status === 201) { sendJson(res, 201, proxy.data); return }
+          sendJson(res, proxy?.status || 502, proxy?.data || { error: 'Daemon not reachable' })
+          return
+        }
+        res.writeHead(405); res.end('Method Not Allowed')
+        return
+      }
+      case '/api/router/probe-mode': {
+        if (req.method !== 'POST') { res.writeHead(405); res.end('Method Not Allowed'); return }
+        const body = await readJsonBody(req)
+        const proxy = await proxyToDaemon('/daemon/probe-mode', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) })
+        if (proxy?.ok) { sendJson(res, 200, proxy.data); return }
+        sendJson(res, proxy?.status || 502, proxy?.data || { error: 'Daemon not reachable' })
+        return
+      }
+      case '/api/router/quick-setup': {
+        // 📖 Return router connection info for quick clipboard copy
+        const port = await readDaemonPort()
+        const routerConfig = config.router || {}
+        const activeSetName = routerConfig.activeSet || 'fast-coding'
+        const baseUrl = port ? `http://127.0.0.1:${port}/v1` : null
+        sendJson(res, 200, {
+          running: !!port,
+          port: port || null,
+          baseUrl,
+          model: 'fcm',
+          activeSet: activeSetName,
+          apiKey: 'not-needed',
+        })
+        return
+      }
+      // ── M4: Installed Models — scan tool configs + soft-delete ────────────
+      case '/api/installed-models': {
+        if (req.method !== 'GET') { res.writeHead(405); res.end('Method Not Allowed'); return }
+        const results = scanAllToolConfigs()
+        sendJson(res, 200, { results })
+        return
+      }
+      // ── M4: Install Endpoints wizard — full provider install into tool ────
+      case '/api/install-endpoints/providers': {
+        if (req.method !== 'GET') { res.writeHead(405); res.end('Method Not Allowed'); return }
+        const providers = getConfiguredInstallableProviders(config)
+        sendJson(res, 200, { providers })
+        return
+      }
+      case '/api/install-endpoints/catalog': {
+        const catProvider = url.searchParams.get('provider')
+        if (!catProvider) { sendJson(res, 400, { error: 'Missing ?provider= parameter' }); return }
+        const models = getProviderCatalogModels(catProvider)
+        sendJson(res, 200, { provider: catProvider, models })
+        return
+      }
+      case '/api/install-endpoints/wizard': {
+        if (req.method !== 'POST') { res.writeHead(405); res.end('Method Not Allowed'); return }
+        const body = await readJsonBody(req)
+        const wizProvider = body?.providerKey
+        const wizTool = body?.toolMode
+        const wizScope = body?.scope || 'all'
+        const wizModelIds = body?.modelIds || []
+        if (!wizProvider || !wizTool) {
+          sendJson(res, 400, { error: 'Missing providerKey or toolMode' }); return
+        }
+        noteUserActivity()
+        try {
+          const installResult = installProviderEndpoints(config, wizProvider, wizTool, {
+            scope: wizScope,
+            modelIds: wizModelIds,
+          })
+          void sendUsageTelemetry(config, { noTelemetry: false }, {
+            event: 'app_action',
+            mode: wizTool,
+            properties: {
+              source: 'web',
+              action_type: 'install_endpoints_wizard',
+              provider: wizProvider,
+              tool_mode: wizTool,
+              scope: wizScope,
+              model_count: installResult.modelCount || 0,
+            },
+          })
+          sendJson(res, 200, { success: true, ...installResult })
+        } catch (err) {
+          sendJson(res, 422, { error: err.message, code: 'install_failed' })
+        }
+        return
+      }
+      // 📖 M4: soft-delete an installed model (pattern match — must be before default:)
+      // 📖 Path: /api/installed-models/:tool/:model/disable
+      default: {
+        const disableMatch = url.pathname.match(/^\/api\/installed-models\/([^/]+)\/([^/]+)\/disable$/)
+        if (disableMatch && req.method === 'POST') {
+          const toolMode = decodeURIComponent(disableMatch[1])
+          const modelId = decodeURIComponent(disableMatch[2])
+          const result = softDeleteModel(toolMode, modelId)
+          sendJson(res, result.success ? 200 : 422, result)
+          return
+        }
+      }
         // 📖 Serve Vite's /assets/* bundle, and our static favicon set that
         // 📖 Vite copies verbatim from web/public/ into web/dist/. The legacy
         // 📖 /favicon.ico lives at web/public/favicon.ico (root of public/).