luang-cli 0.2.0 → 0.3.2

package/lib/models.js

@@ -0,0 +1,343 @@
+'use strict';
+
+// lib/models.js — daftar model AI per provider untuk `luang-cli models`
+// dan untuk sinkronisasi ke server (field `models` pada payload heartbeat
+// POST /api/v1/agent/heartbeat dan pada `providers` frame hello WS —
+// kontrak baru; backend menerima field opsional ini).
+//
+// Urutan sumber data:
+//   1. Dinamis (hanya whitelist AMAN): opencode → coba perintah
+//      `opencode models`, gagal/ kosong → parse config opencode di
+//      ~/.config/opencode/ atau ~/.opencode, gagal juga → statis.
+//   2. Registry statis = daftar saran per tipe provider (claude_code, codex,
+//      opencode, gemini_cli, custom). Ditulis apa adanya meski versi lama —
+//      ini datalist/saran, user tetap bebas mengetik model manual.
+//
+// KEBIJAKAN KETAT: binary `claude`, `gemini`, dan `codex` TIDAK PERNAH
+// dieksekusi di sini — apa pun alasannya. Cukup registry statis / parse file.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+// Batas payload ke server (kontrak heartbeat/hello).
+const MAX_MODELS = 50;
+const MAX_MODEL_LEN = 120;
+const BIN_TIMEOUT_MS = 3000;
+const CACHE_TTL_MS = 10 * 60 * 1000; // deteksi dinamis tidak dijalankan tiap heartbeat
+
+// ── Registry statis (saran / datalist per tipe provider) ─────────────────────
+
+const MODEL_REGISTRY = {
+  claude_code: [
+    'claude-opus-4-1',
+    'claude-sonnet-4-5',
+    'claude-haiku-4-5',
+    'claude-opus-4-1-20250805',
+    'claude-sonnet-4-5-20250929',
+    'claude-haiku-4-5-20251001',
+    'claude-sonnet-4-20250514',
+    'claude-opus-4-20250514',
+    'claude-3-7-sonnet-latest',
+    'claude-3-7-sonnet-20250219',
+    'claude-3-5-sonnet-latest',
+    'claude-3-5-sonnet-20241022',
+    'claude-3-5-haiku-latest',
+    'claude-3-5-haiku-20241022',
+    'claude-3-opus-latest',
+    'claude-3-sonnet-20240229',
+  ],
+  codex: [
+    'gpt-5-codex',
+    'gpt-5.1-codex',
+    'gpt-5-codex-spark',
+    'gpt-5-mini',
+    'gpt-5-nano',
+    'gpt-4.1',
+    'gpt-4.1-mini',
+    'gpt-4.1-nano',
+    'o3',
+    'o3-mini',
+    'o4-mini',
+    'codex-mini-latest',
+  ],
+  opencode: [
+    'anthropic/claude-sonnet-4-5',
+    'anthropic/claude-opus-4-1',
+    'anthropic/claude-haiku-4-5',
+    'openai/gpt-5-codex',
+    'openai/gpt-5.1-codex',
+    'openai/o4-mini',
+    'google/gemini-2.5-pro',
+    'google/gemini-2.5-flash',
+    'opencode/grok-code-fast-1',
+    'qwen/qwen3-coder',
+    'deepseek/deepseek-v3.1',
+    'mistral/codestral-latest',
+  ],
+  gemini_cli: [
+    'gemini-2.5-pro',
+    'gemini-2.5-flash',
+    'gemini-2.5-flash-lite',
+    'gemini-2.0-flash',
+    'gemini-2.0-flash-lite',
+    'gemini-1.5-pro',
+    'gemini-1.5-flash',
+    'gemini-1.0-pro',
+    'gemma-3-27b-it',
+    'gemma-3-12b-it',
+  ],
+  custom: [], // provider custom: tanpa saran — user ketik manual
+};
+
+// Whitelist binary yang BOLEH dijalankan untuk deteksi dinamis.
+// Kebijakan ketat: claude / gemini / codex tidak pernah ada di daftar ini.
+const DYNAMIC_OK = new Set(['opencode']);
+
+const MODEL_TOKEN_RE = /^[\w.:+/-]+$/;
+const PROVIDER_SLASH_RE = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
+// Kata umum yang bukan model (dipakai saat parse longgar).
+const NON_MODEL_WORDS = new Set([
+  'provider', 'providers', 'model', 'models', 'name', 'names', 'id', 'ids',
+  'type', 'types', 'label', 'description', 'path', 'version', 'default',
+  'baseurl', 'base_url', 'apikey', 'api_key',
+]);
+
+// ── Util ─────────────────────────────────────────────────────────────────────
+
+// Batas wire: maks 50 item, tiap item ≤120 karakter, unik, terpotong rapi.
+function sanitizeModels(list) {
+  const out = [];
+  const seen = new Set();
+  for (const m of Array.isArray(list) ? list : []) {
+    if (out.length >= MAX_MODELS) break;
+    const s = String(m === null || m === undefined ? '' : m).trim().slice(0, MAX_MODEL_LEN);
+    if (!s || seen.has(s)) continue;
+    seen.add(s);
+    out.push(s);
+  }
+  return out;
+}
+
+function makeCollector() {
+  const list = [];
+  const seen = new Set();
+  const add = (v) => {
+    if (typeof v !== 'string') return;
+    const s = v.trim().slice(0, MAX_MODEL_LEN);
+    if (!s || seen.has(s)) return;
+    if (!MODEL_TOKEN_RE.test(s)) return;
+    if (NON_MODEL_WORDS.has(s.toLowerCase())) return;
+    seen.add(s);
+    list.push(s);
+  };
+  return { list, add };
+}
+
+function whichBinLocal(bin) {
+  try {
+    const r = spawnSync(process.platform === 'win32' ? 'where' : 'which', [bin], {
+      encoding: 'utf8',
+      timeout: BIN_TIMEOUT_MS,
+    });
+    if (r.status === 0 && r.stdout) {
+      const first = String(r.stdout).split(/\r?\n/)[0].trim();
+      if (first) return first;
+    }
+  } catch (e) {
+    // abaikan
+  }
+  return null;
+}
+
+// Kebijakan ketat: hanya binary yang NAMANYA mengandung "opencode" yang boleh
+// dijalankan — pengaman ekstra agar path config yang aneh tidak pernah
+// mengeksekusi claude/gemini/codex.
+function resolveOpencodeBin(configuredPath) {
+  if (typeof configuredPath === 'string' && configuredPath.trim()) {
+    const p = configuredPath.trim();
+    if (path.basename(p).toLowerCase().includes('opencode') && fs.existsSync(p)) return p;
+  }
+  return whichBinLocal('opencode');
+}
+
+// ── Parse output / config ────────────────────────────────────────────────────
+
+// Walker JSON longgar: kunci "models"/"model_ids"/"modelIds", field
+// id/name/model, array berisi string, dan kunci berbentuk provider/model.
+function walkForModels(node, add, depth) {
+  if (depth > 8 || node === null || node === undefined) return;
+  if (Array.isArray(node)) {
+    for (const v of node) {
+      if (typeof v === 'string') add(v);
+      else walkForModels(v, add, depth + 1);
+    }
+    return;
+  }
+  if (typeof node !== 'object') return;
+  for (const [k, v] of Object.entries(node)) {
+    if (k === 'models' || k === 'model_ids' || k === 'modelIds') {
+      if (typeof v === 'string') add(v);
+      else if (Array.isArray(v)) {
+        for (const x of v) {
+          if (typeof x === 'string') add(x);
+          else if (x && typeof x === 'object') {
+            add(x.id || x.name || x.model);
+            walkForModels(x, add, depth + 1);
+          }
+        }
+      } else if (v && typeof v === 'object') {
+        for (const [mk, mv] of Object.entries(v)) {
+          add(mk);
+          if (typeof mv === 'string') add(mv);
+          else walkForModels(mv, add, depth + 1);
+        }
+      }
+      continue;
+    }
+    if (typeof v === 'string') {
+      if (k === 'id' || k === 'name' || k === 'model') add(v);
+      if (PROVIDER_SLASH_RE.test(k)) add(k);
+      continue;
+    }
+    if (PROVIDER_SLASH_RE.test(k)) add(k);
+    walkForModels(v, add, depth + 1);
+  }
+}
+
+// Ambil id model dari output perintah: JSON bila bisa, kalau tidak baris teks
+// (token pertama yang mengandung angka "/" — sengaja konservatif agar header
+// tabel/teks bebas tidak dianggap model).
+function extractModelIds(text) {
+  const col = makeCollector();
+  const raw = String(text || '').trim();
+  if (!raw) return col.list;
+  let parsed = null;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    parsed = null;
+  }
+  if (parsed !== null && typeof parsed === 'object') {
+    walkForModels(parsed, col.add, 0);
+  } else {
+    for (const line of raw.split(/\r?\n/)) {
+      const tok = line.trim().split(/\s+/)[0];
+      if (tok && /[0-9/]/.test(tok)) col.add(tok);
+    }
+  }
+  return col.list;
+}
+
+function stripJsonComments(s) {
+  return String(s).replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:"'\\])\/\/.*$/gm, '$1');
+}
+
+// Parse config opencode (bila ada): ~/.config/opencode/opencode[.jsonc] → ~/.opencode.
+function opencodeConfigModels() {
+  const home = os.homedir();
+  const candidates = [
+    path.join(home, '.config', 'opencode', 'opencode.json'),
+    path.join(home, '.config', 'opencode', 'opencode.jsonc'),
+    path.join(home, '.opencode', 'opencode.json'),
+  ];
+  for (const p of candidates) {
+    try {
+      if (!fs.existsSync(p)) continue;
+      const txt = fs.readFileSync(p, 'utf8');
+      let obj = null;
+      try {
+        obj = JSON.parse(txt);
+      } catch (e) {
+        try {
+          obj = JSON.parse(stripJsonComments(txt));
+        } catch (e2) {
+          obj = null;
+        }
+      }
+      if (obj && typeof obj === 'object') {
+        const col = makeCollector();
+        walkForModels(obj, col.add, 0);
+        if (col.list.length) return col.list;
+      }
+    } catch (e) {
+      // file tidak terbaca → coba kandidat berikutnya
+    }
+  }
+  return [];
+}
+
+function runOpencodeModels(bin) {
+  try {
+    const r = spawnSync(bin, ['models'], {
+      encoding: 'utf8',
+      timeout: BIN_TIMEOUT_MS,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true,
+    });
+    if (r.error) return '';
+    return String(r.stdout || r.stderr || '');
+  } catch (e) {
+    return '';
+  }
+}
+
+// ── API publik ───────────────────────────────────────────────────────────────
+
+const _cache = new Map(); // type → { at, result }
+
+function staticResult(type) {
+  const list = Array.isArray(MODEL_REGISTRY[type]) ? MODEL_REGISTRY[type] : [];
+  return { provider: String(type), source: 'static', models: sanitizeModels(list) };
+}
+
+/**
+ * Daftar model satu provider.
+ * @param {string} type  tipe provider (claude_code|codex|opencode|gemini_cli|custom|…)
+ * @param {{path?:string, refresh?:boolean}} opts  path = path provider dari config;
+ *   refresh = lewati cache (dipakai command `luang-cli models`).
+ * @returns {{provider:string, source:'static'|'binary'|'config', models:string[]}}
+ */
+function modelsForProvider(type, opts = {}) {
+  const t = String(type || '');
+  if (!opts.refresh) {
+    const hit = _cache.get(t);
+    if (hit && Date.now() - hit.at < CACHE_TTL_MS) return hit.result;
+  }
+  let result;
+  if (DYNAMIC_OK.has(t)) {
+    const bin = resolveOpencodeBin(opts.path);
+    const dynamic = bin ? extractModelIds(runOpencodeModels(bin)) : [];
+    if (dynamic.length) {
+      result = { provider: t, source: 'binary', models: sanitizeModels(dynamic) };
+    } else {
+      const fromCfg = sanitizeModels(opencodeConfigModels());
+      result = fromCfg.length
+        ? { provider: t, source: 'config', models: fromCfg }
+        : staticResult(t);
+    }
+  } else {
+    result = staticResult(t);
+  }
+  _cache.set(t, { at: Date.now(), result });
+  return result;
+}
+
+/** Semua tipe provider dalam registry (atau daftar tipe tertentu). */
+function listAllModels(types, opts = {}) {
+  const keys = Array.isArray(types) && types.length ? types : Object.keys(MODEL_REGISTRY);
+  const out = {};
+  for (const t of keys) out[t] = modelsForProvider(t, opts);
+  return out;
+}
+
+module.exports = {
+  MODEL_REGISTRY,
+  MAX_MODELS,
+  MAX_MODEL_LEN,
+  sanitizeModels,
+  extractModelIds,
+  modelsForProvider,
+  listAllModels,
+};