free-coding-models 0.3.9 → 0.3.12

package/src/log-reader.js

@@ -1,195 +0,0 @@
-/**
- * @file lib/log-reader.js
- * @description Pure functions to load recent request-log entries from
- *   ~/.free-coding-models/request-log.jsonl, newest-first, bounded by a
- *   configurable row limit.
- *
- * Design principles:
- *   - Bounded reads only — never slurp the entire log for every TUI repaint.
- *   - Tolerates malformed / partially-written JSONL lines by skipping them.
- *   - No shared mutable state (pure functions, injectable file path for tests).
- *   - No new npm dependencies — uses only Node.js built-ins.
- *
- * Default path:
- *   ~/.free-coding-models/request-log.jsonl
- *
- * Row object shape returned from loadRecentLogs():
- *   {
- *     time:     string   // ISO timestamp string  (from entry.timestamp)
- *     requestType: string // e.g. "chat.completions"
- *     model:    string   // e.g. "llama-3.3-70b-instruct"
- *     requestedModel: string // public proxy model originally requested by the client
- *     provider: string   // e.g. "nvidia"
- *     status:   string   // e.g. "200" | "429" | "error"
- *     tokens:   number   // promptTokens + completionTokens (0 if unknown)
- *     latency:  number   // ms (0 if unknown)
- *     switched: boolean  // true when the router retried on a fallback provider/model
- *     switchReason: string|null // short reason label shown in the log UI
- *   }
- *
- * @exports loadRecentLogs
- * @exports parseLogLine
- */
-
-import { existsSync, statSync, openSync, readSync, closeSync } from 'node:fs'
-import { join } from 'node:path'
-import { homedir } from 'node:os'
-
-const DEFAULT_LOG_FILE = join(homedir(), '.free-coding-models', 'request-log.jsonl')
-
-/** Maximum bytes to read from the tail of the file to avoid OOM on large logs. */
-const MAX_READ_BYTES = 128 * 1024 // 128 KB
-
-function normalizeTimestamp(raw) {
-  if (typeof raw === 'number' && Number.isFinite(raw)) {
-    return new Date(raw).toISOString()
-  }
-  if (typeof raw === 'string') {
-    const numeric = Number(raw)
-    if (Number.isFinite(numeric)) return new Date(numeric).toISOString()
-    const parsed = new Date(raw)
-    if (!Number.isNaN(parsed.getTime())) return parsed.toISOString()
-  }
-  return null
-}
-
-function inferProvider(entry) {
-  if (entry.providerKey || entry.provider) {
-    return String(entry.providerKey ?? entry.provider)
-  }
-  if (typeof entry.accountId === 'string' && entry.accountId.includes('/')) {
-    return entry.accountId.split('/')[0] || 'unknown'
-  }
-  return 'unknown'
-}
-
-function inferStatus(entry) {
-  if (entry.statusCode !== undefined || entry.status !== undefined) {
-    return String(entry.statusCode ?? entry.status)
-  }
-  if (typeof entry.success === 'boolean') {
-    return entry.success ? '200' : 'error'
-  }
-  return 'unknown'
-}
-
-function inferRequestType(entry) {
-  if (entry.requestType !== undefined || entry.type !== undefined) {
-    return String(entry.requestType ?? entry.type)
-  }
-  if (typeof entry.url === 'string') {
-    if (entry.url.includes('/chat/completions')) return 'chat.completions'
-    if (entry.url.includes('/models')) return 'models'
-  }
-  return 'chat.completions'
-}
-
-/**
- * Parse a single JSONL line into a normalised log row object.
- *
- * Returns `null` for any line that is blank, not valid JSON, or missing
- * the required `timestamp` field.
- *
- * @param {string} line - A single text line from the JSONL file.
- * @returns {{ time: string, requestType: string, model: string, requestedModel: string, provider: string, status: string, tokens: number, latency: number, switched: boolean, switchReason: string|null, switchedFromProvider: string|null, switchedFromModel: string|null } | null}
- */
-export function parseLogLine(line) {
-  const trimmed = line.trim()
-  if (!trimmed) return null
-  let entry
-  try {
-    entry = JSON.parse(trimmed)
-  } catch {
-    return null
-  }
-  if (!entry || typeof entry !== 'object') return null
-  if (!entry.timestamp) return null
-
-  const normalizedTime = normalizeTimestamp(entry.timestamp)
-  if (!normalizedTime) return null
-
-  const model    = String(entry.modelId    ?? entry.model    ?? 'unknown')
-  const requestedModel = typeof entry.requestedModelId === 'string'
-    ? entry.requestedModelId
-    : (typeof entry.requestedModel === 'string' ? entry.requestedModel : '')
-  const provider = inferProvider(entry)
-  const status   = inferStatus(entry)
-  const requestType = inferRequestType(entry)
-  const tokens   = (Number(entry.usage?.prompt_tokens ?? entry.promptTokens ?? 0) +
-                    Number(entry.usage?.completion_tokens ?? entry.completionTokens ?? 0)) || 0
-  const latency  = Number(entry.latencyMs ?? entry.latency ?? 0) || 0
-  const switched = entry.switched === true
-  const switchReason = typeof entry.switchReason === 'string' && entry.switchReason.trim().length > 0
-    ? entry.switchReason.trim()
-    : null
-  const switchedFromProvider = typeof entry.switchedFromProviderKey === 'string' && entry.switchedFromProviderKey.trim().length > 0
-    ? entry.switchedFromProviderKey.trim()
-    : null
-  const switchedFromModel = typeof entry.switchedFromModelId === 'string' && entry.switchedFromModelId.trim().length > 0
-    ? entry.switchedFromModelId.trim()
-    : null
-
-  return {
-    time: normalizedTime,
-    requestType,
-    model,
-    requestedModel,
-    provider,
-    status,
-    tokens,
-    latency,
-    switched,
-    switchReason,
-    switchedFromProvider,
-    switchedFromModel,
-  }
-}
-
-/**
- * Load the N most-recent log entries from the JSONL file, newest-first.
- *
- * Only reads up to MAX_READ_BYTES from the end of the file to avoid
- * loading the entire log history.  Malformed lines are silently skipped.
- *
- * @param {object}  [opts]
- * @param {string}  [opts.logFile]  - Path to request-log.jsonl (injectable for tests)
- * @param {number}  [opts.limit]    - Maximum rows to return (default 200)
- * @returns {Array<{ time: string, requestType: string, model: string, requestedModel: string, provider: string, status: string, tokens: number, latency: number, switched: boolean, switchReason: string|null, switchedFromProvider: string|null, switchedFromModel: string|null }>}
- */
-export function loadRecentLogs({ logFile = DEFAULT_LOG_FILE, limit = 200 } = {}) {
-  try {
-    if (!existsSync(logFile)) return []
-
-    const fileSize = statSync(logFile).size
-    if (fileSize === 0) return []
-
-    // 📖 Read only the tail of the file (bounded by MAX_READ_BYTES) to avoid
-    // 📖 reading multi-megabyte logs on every TUI repaint.
-    const readBytes = Math.min(fileSize, MAX_READ_BYTES)
-    const fileOffset = fileSize - readBytes
-
-    const buf = Buffer.allocUnsafe(readBytes)
-    const fd = openSync(logFile, 'r')
-    try {
-      readSync(fd, buf, 0, readBytes, fileOffset)
-    } finally {
-      closeSync(fd)
-    }
-
-    const text = buf.toString('utf8')
-
-    // 📖 Split on newlines; if we started mid-line (fileOffset > 0), drop
-    // 📖 the first (potentially incomplete) line to avoid corrupt JSON.
-    const rawLines = text.split('\n')
-    const lines = fileOffset > 0 ? rawLines.slice(1) : rawLines
-
-    const rows = []
-    for (let i = lines.length - 1; i >= 0 && rows.length < limit; i--) {
-      const row = parseLogLine(lines[i])
-      if (row) rows.push(row)
-    }
-    return rows
-  } catch {
-    return []
-  }
-}

package/src/opencode-sync.js

@@ -1,200 +0,0 @@
-import { readFileSync, writeFileSync, copyFileSync, existsSync, mkdirSync } from 'node:fs'
-import { join } from 'node:path'
-import { homedir } from 'node:os'
-import { randomBytes } from 'node:crypto'
-
-const OC_CONFIG_DIR = join(homedir(), '.config', 'opencode')
-const OC_CONFIG_PATH = join(OC_CONFIG_DIR, 'opencode.json')
-const OC_BACKUP_PATH = join(OC_CONFIG_DIR, 'opencode.json.bak')
-const FCM_PROVIDER_ID = 'fcm-proxy'
-const DEFAULT_PROXY_BASE_URL = 'http://127.0.0.1:8045/v1'
-
-function generateProxyToken() {
-  return `fcm_${randomBytes(24).toString('hex')}`
-}
-
-function ensureV1BaseUrl(baseURL) {
-  if (typeof baseURL !== 'string' || baseURL.length === 0) {
-    return DEFAULT_PROXY_BASE_URL
-  }
-  const trimmed = baseURL.replace(/\/+$/, '')
-  return trimmed.endsWith('/v1') ? trimmed : `${trimmed}/v1`
-}
-
-/**
- * Load existing OpenCode config, or return empty object.
- */
-export function loadOpenCodeConfig() {
-  try {
-    if (existsSync(OC_CONFIG_PATH)) {
-      return JSON.parse(readFileSync(OC_CONFIG_PATH, 'utf8'))
-    }
-  } catch {}
-  return {}
-}
-
-/**
- * Save OpenCode config with automatic backup.
- * Creates backup of current config before overwriting.
- */
-export function saveOpenCodeConfig(config) {
-  mkdirSync(OC_CONFIG_DIR, { recursive: true })
-  // Backup existing config before saving
-  if (existsSync(OC_CONFIG_PATH)) {
-    copyFileSync(OC_CONFIG_PATH, OC_BACKUP_PATH)
-  }
-  writeFileSync(OC_CONFIG_PATH, JSON.stringify(config, null, 2) + '\n')
-}
-
-/**
- * Restore OpenCode config from backup.
- * @returns {boolean} true if restored, false if no backup exists
- */
-export function restoreOpenCodeBackup() {
-  if (!existsSync(OC_BACKUP_PATH)) return false
-  copyFileSync(OC_BACKUP_PATH, OC_CONFIG_PATH)
-  return true
-}
-
-/**
- * Pure merge: apply FCM provider entry into an existing OpenCode config object.
- *
- * This function contains the merge logic without any filesystem I/O so it can
- * be unit-tested in isolation. It is exported for tests and used internally by
- * syncToOpenCode.
- *
- * CRITICAL: This function ONLY adds/updates the fcm-proxy provider entry.
- * It PRESERVES all existing providers (antigravity-manager, openai, iflow, etc.)
- * and all other top-level keys ($schema, mcp, plugin, command, model).
- *
- * proxyInfo should only carry runtime port/token when the proxy is actively
- * running (running === true). Callers MUST NOT pass stale values from a stopped
- * proxy — use undefined/omit the fields instead so we fall back to the existing
- * persisted provider options cleanly.
- *
- * @param {Object} ocConfig - Existing OpenCode config object (will be mutated in-place)
- * @param {Array} mergedModels - Output of buildMergedModels()
- * @param {{ proxyPort?: number, proxyToken?: string, availableModelSlugs?: Set<string>|string[] }} proxyInfo
- *   availableModelSlugs: when provided, only models whose slug is in this set are written
- *   to the OpenCode catalog. Use this to prevent "ghost" entries for models with no API keys.
- * @returns {Object} The mutated ocConfig
- */
-export function mergeOcConfig(ocConfig, mergedModels, proxyInfo = {}) {
-  ocConfig.provider = ocConfig.provider || {}
-
-  const existingProvider = ocConfig.provider[FCM_PROVIDER_ID] || {}
-  const existingOptions = existingProvider.options || {}
-
-  // Only use the runtime proxyPort if it is a valid positive integer.
-  // A null/undefined/0 port means the proxy is not running — fall back to
-  // the existing persisted baseURL so we don't write a broken URL.
-  const hasValidPort = Number.isInteger(proxyInfo.proxyPort) && proxyInfo.proxyPort > 0
-  const baseURL = ensureV1BaseUrl(
-    hasValidPort
-      ? `http://127.0.0.1:${proxyInfo.proxyPort}`
-      : existingOptions.baseURL
-  )
-
-  // Keep token stable unless caller provides a runtime token.
-  // A non-string or empty proxyToken is treated as absent.
-  const hasValidToken = typeof proxyInfo.proxyToken === 'string' && proxyInfo.proxyToken.length > 0
-  const hasExistingToken =
-    typeof existingOptions.apiKey === 'string' &&
-    existingOptions.apiKey.length > 0 &&
-    existingOptions.apiKey !== 'fcm-proxy-token'
-  const apiKey = hasValidToken ? proxyInfo.proxyToken : (hasExistingToken ? existingOptions.apiKey : generateProxyToken())
-
-  const slugFilter = proxyInfo.availableModelSlugs
-    ? new Set(proxyInfo.availableModelSlugs)
-    : null
-
-  const models = {}
-  for (const m of mergedModels) {
-    if (slugFilter && !slugFilter.has(m.slug)) continue
-    models[m.slug] = { name: m.label }
-  }
-
-  ocConfig.provider[FCM_PROVIDER_ID] = {
-    npm: '@ai-sdk/openai-compatible',
-    name: 'FCM Rotation Proxy',
-    options: {
-      ...existingOptions,
-      baseURL,
-      apiKey,
-    },
-    models,
-  }
-
-  return ocConfig
-}
-
-/**
- * Pure cleanup: remove only the persisted FCM proxy provider and any default
- * model that still points at it. Other OpenCode providers stay untouched.
- *
- * @param {Object} ocConfig - Existing OpenCode config object (will be mutated in-place)
- * @returns {{ removedProvider: boolean, removedModel: boolean, config: Object }}
- */
-export function removeFcmProxyFromConfig(ocConfig) {
-  if (!ocConfig || typeof ocConfig !== 'object') {
-    return { removedProvider: false, removedModel: false, config: {} }
-  }
-
-  const hadProvider = Boolean(ocConfig.provider?.[FCM_PROVIDER_ID])
-  if (hadProvider) {
-    delete ocConfig.provider[FCM_PROVIDER_ID]
-    if (Object.keys(ocConfig.provider).length === 0) delete ocConfig.provider
-  }
-
-  const hadModel = typeof ocConfig.model === 'string' && ocConfig.model.startsWith(`${FCM_PROVIDER_ID}/`)
-  if (hadModel) delete ocConfig.model
-
-  return { removedProvider: hadProvider, removedModel: hadModel, config: ocConfig }
-}
-
-/**
- * MERGE the single FCM proxy provider into OpenCode config.
- *
- * CRITICAL: This function ONLY adds/updates the fcm-proxy provider entry.
- * It PRESERVES all existing providers (antigravity-manager, openai, iflow, etc.)
- * and all other top-level keys ($schema, mcp, plugin, command, model).
- *
- * proxyInfo should only carry runtime port/token when the proxy is actively
- * running (running === true). Callers MUST NOT pass stale values from a stopped
- * proxy — use undefined/omit the fields instead so we fall back to the existing
- * persisted provider options cleanly.
- *
- * @param {Object} fcmConfig - FCM config (from loadConfig())
- * @param {Object} _sources - PROVIDERS object from sources.js (unused, kept for signature compatibility)
- * @param {Array} mergedModels - Output of buildMergedModels()
- * @param {{ proxyPort?: number, proxyToken?: string, availableModelSlugs?: Set<string>|string[] }} proxyInfo
- *   availableModelSlugs: slugs of models that have real API key accounts. When provided,
- *   only those models appear in the OpenCode catalog, preventing ghost entries.
- */
-export function syncToOpenCode(fcmConfig, _sources, mergedModels, proxyInfo = {}) {
-  const oc = loadOpenCodeConfig()
-  const merged = mergeOcConfig(oc, mergedModels, proxyInfo)
-  saveOpenCodeConfig(merged)
-  return {
-    providerKey: FCM_PROVIDER_ID,
-    modelCount: Object.keys(merged.provider[FCM_PROVIDER_ID].models).length,
-    path: OC_CONFIG_PATH,
-  }
-}
-
-/**
- * Remove the persisted FCM proxy provider from OpenCode's config on disk.
- * This is the user-facing cleanup operation for "proxy uninstall".
- *
- * @returns {{ removedProvider: boolean, removedModel: boolean, path: string }}
- */
-export function cleanupOpenCodeProxyConfig() {
-  const oc = loadOpenCodeConfig()
-  const result = removeFcmProxyFromConfig(oc)
-  saveOpenCodeConfig(result.config)
-  return {
-    removedProvider: result.removedProvider,
-    removedModel: result.removedModel,
-    path: OC_CONFIG_PATH,
-  }
-}