luang-cli 0.3.0 → 0.3.2

package/lib/commands.js

@@ -3,6 +3,7 @@
 // lib/commands.js — implementasi semua command luang-cli.
 
 const os = require('os');
+const fs = require('fs');
 const readline = require('readline');
 
 const core = require('./core');
@@ -14,6 +15,8 @@ const {
   saveConfig,
   collectProviders,
   heartbeatProviders,
+  resolveWorkspace,
+  modelsForProvider,
   detectProviders,
   PROVIDER_TYPES,
   DISPLAY_NAMES,
@@ -149,6 +152,74 @@ async function cmdTelemetry(rt, args) {
   return 0;
 }
 
+// ── Workspace folder (folder kerja provider; sinkron dashboard ↔ CLI) ──────
+// Server adalah sumber kebenaran (dashboard mengatur); CLI menyimpan salinan
+// lokal + MEMAKAI sebagai cwd saat --exec. Endpoint CLI: POST /agent/workspace
+// (X-CLI-Key, milik key sendiri) — dashboard memakai PUT /keys/:id/workspace (JWT).
+async function workspaceShow(rt, serverVal) {
+  const local = typeof rt.cfg.workspace === 'string' ? rt.cfg.workspace.trim() : '';
+  const server = typeof serverVal === 'string' ? serverVal.trim() : '';
+  const effective = server || local;
+  const resolved = resolveWorkspace(effective);
+  let exists = null;
+  if (resolved) {
+    try {
+      exists = fs.statSync(resolved).isDirectory();
+    } catch (e) {
+      exists = false;
+    }
+  }
+  console.log('');
+  console.log('📁 Workspace folder — folder kerja provider agent (opencode, claude, …)');
+  console.log(`   Server : ${server ? server : '(belum diset — atur di dashboard Agents atau: luang-cli workspace <path>)'}`);
+  console.log(`   Lokal  : ${local ? local : '(mengikuti server)'}`);
+  if (resolved) {
+    console.log(`   Efektif: ${resolved}${exists === true ? '' : ' ⚠️  tidak ada/bukan folder → exec pakai folder saat ini'}`);
+  } else {
+    console.log(`   Efektif: folder saat ini (${process.cwd()})`);
+  }
+  console.log('   Atur   : luang-cli workspace <path> · reset: luang-cli workspace --reset');
+  return 0;
+}
+
+async function cmdWorkspace(rt, args) {
+  const raw = String(args.pos[1] || '').trim();
+  if (!rt.key) return errExit('Belum login — jalankan `luang-cli login` atau set LUANG_KEY.');
+  const flagReset = args.flags && (args.flags.reset === true || args.flags.reset === 'true' || args.flags.reset === '');
+  const reset = raw === 'reset' || raw === '-' || raw === '--reset' || flagReset;
+  if ((!raw || raw === 'status' || raw === 'show') && !reset) {
+    let serverVal = null;
+    try {
+      const me = await apiRequest(rt, 'GET', '/api/v1/agent/me');
+      serverVal = me && me.data ? me.data.workspace : null;
+    } catch (e) {
+      console.log(`   ⚠️  /me gagal: ${e.message} — tampilkan nilai lokal saja.`);
+    }
+    return workspaceShow(rt, serverVal);
+  }
+  const value = reset ? '' : raw;
+  if (!reset) {
+    const resolved = resolveWorkspace(value);
+    if (!resolved) return errExit(`Path tidak valid: ${value}`);
+    try {
+      if (!fs.statSync(resolved).isDirectory()) {
+        return errExit(`Bukan folder: ${resolved}`, 'Buat dulu foldernya, atau cek penulisannya.');
+      }
+    } catch (e) {
+      return errExit(`Folder tidak ada: ${resolved}`, 'Buat dulu foldernya, atau cek penulisannya.');
+    }
+  }
+  try {
+    await apiRequest(rt, 'POST', '/api/v1/agent/workspace', { body: { workspace: value } });
+  } catch (e) {
+    return errExit(`Gagal menyimpan ke server: ${e.message}`);
+  }
+  rt.cfg.workspace = value;
+  saveConfig(rt.cfg);
+  console.log(reset ? '📁 Workspace direset — exec memakai folder saat ini.' : `📁 Workspace disimpan: ${resolveWorkspace(value)} (server + lokal sinkron)`);
+  return 0;
+}
+
 // ── login (device flow) ──────────────────────────────────────────────────────
 
 async function cmdLogin(rt, args) {
@@ -266,6 +337,12 @@ async function cmdWhoami(rt) {
     return authFailMessage(e);
   }
   const d = (me && me.data) || {};
+  // Sinkron default provider dari dashboard bila diset di sana.
+  const sdp = typeof d.default_provider === 'string' ? d.default_provider.trim() : '';
+  if (sdp && rt.cfg.default_provider !== sdp) {
+    rt.cfg.default_provider = sdp;
+    saveConfig(rt.cfg);
+  }
   console.log('👤 Sesi Agent');
   console.log(`   Nama         : ${d.name || '-'}`);
   console.log(`   Status       : ${d.status || '-'}`);
@@ -281,6 +358,7 @@ async function cmdWhoami(rt) {
   console.log('   (ubah lokal: luang-cli telemetry on|off · flag server: dashboard Agents)');
   console.log('');
   console.log(`🛠  Provider terdaftar (server): ${providersLabel(d.providers)}`);
+  console.log(`⭐ Default provider: ${rt.cfg.default_provider || '(belum di-set)'}${sdp ? ' (disetel dashboard)' : ''}`);
   return 0;
 }
 
@@ -400,4 +478,82 @@ async function cmdProvider(rt, args) {
   return errExit(`Sub-command provider tidak dikenal: ${sub}`, 'Gunakan: list | add | remove | default');
 }
 
-module.exports = { cmdLogin, cmdLogout, cmdWhoami, cmdTelemetry, cmdProvider, errExit, authFailMessage, taskIdOf, statusInputNorm, normalizeTaskList, ask, providersLabel, syncIfKey, permLine, telemetryConsentLabel };
+// ── models (daftar model per provider) ───────────────────────────────────────
+
+// Lebar kolom daftar model & maks baris wrap (spec: maks 6 baris + "…+n lagi").
+const MODELS_LIST_WIDTH = 44;
+const MODELS_MAX_LINES = 6;
+
+function wrapModelList(models, width, maxLines) {
+  const rows = [];
+  let cur = '';
+  let cnt = 0;
+  for (const m of models) {
+    const cand = cur ? `${cur}, ${m}` : m;
+    if (cur && cand.length > width) {
+      rows.push({ text: cur, cnt });
+      cur = m;
+      cnt = 1;
+    } else {
+      cur = cand;
+      cnt += 1;
+    }
+  }
+  if (cur) rows.push({ text: cur, cnt });
+  if (rows.length <= maxLines) return { lines: rows.map((r) => r.text), remaining: 0 };
+  const keep = rows.slice(0, maxLines);
+  const shown = keep.reduce((a, r) => a + r.cnt, 0);
+  return { lines: keep.map((r) => r.text).concat([`…+${models.length - shown} lagi`]), remaining: models.length - shown };
+}
+
+async function cmdModels(rt, args) {
+  const arg = args.pos[1] && !String(args.pos[1]).startsWith('-') ? String(args.pos[1]) : null;
+  const allTypes = Object.keys(core.MODEL_REGISTRY);
+  if (arg && !allTypes.includes(arg)) {
+    return errExit(`Provider tidak dikenal: ${arg}`, `Pilihan: ${allTypes.join(', ')}`);
+  }
+  const types = arg ? [arg] : allTypes;
+  const detected = new Map(collectProviders(rt.cfg).map((p) => [p.provider_type, p]));
+
+  const result = {};
+  for (const t of types) {
+    const p = detected.get(t);
+    // refresh: true → deteksi dijalankan ulang (bypass cache) saat user minta.
+    result[t] = modelsForProvider(t, { path: p && p.path, refresh: true });
+  }
+
+  if (args.flags.json === true) {
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  }
+
+  if (!types.length) {
+    console.log('📭 Tidak ada provider.');
+    return 0;
+  }
+
+  const wProv = Math.max('Provider'.length, ...types.map((t) => t.length));
+  const counts = types.map((t) => String(result[t].models.length));
+  const wCnt = Math.max('Jumlah'.length, ...counts.map((s) => s.length));
+  const pad = (s, w) => String(s).padEnd(w, ' ');
+  const padL = (s, w) => String(s).padStart(w, ' ');
+
+  console.log(`${pad('Provider', wProv)}  ${padL('Jumlah', wCnt)}  Models`);
+  console.log(`${'─'.repeat(wProv)}  ${'─'.repeat(wCnt)}  ${'─'.repeat(Math.min(MODELS_LIST_WIDTH, 20))}`);
+  types.forEach((t, i) => {
+    const r = result[t];
+    const w = wrapModelList(r.models, MODELS_LIST_WIDTH, MODELS_MAX_LINES);
+    const head = `${pad(t, wProv)}  ${padL(r.models.length, wCnt)}  ${w.lines[0] || '-'}`;
+    console.log(head);
+    for (const line of w.lines.slice(1)) {
+      console.log(`${' '.repeat(wProv)}  ${' '.repeat(wCnt)}  ${line}`);
+    }
+  });
+  console.log('');
+  console.log('Sumber: static = registry saran lokal · binary = perintah `opencode models` · config = ~/.config/opencode');
+  console.log('Daftar ini saran/datalist — model bisa diketik manual; `claude`/`codex`/`gemini` tidak pernah dieksekusi.');
+  console.log('JSON: luang-cli models [provider] --json');
+  return 0;
+}
+
+module.exports = { cmdLogin, cmdLogout, cmdWhoami, cmdTelemetry, cmdWorkspace, cmdProvider, cmdModels, errExit, authFailMessage, taskIdOf, statusInputNorm, normalizeTaskList, ask, providersLabel, syncIfKey, permLine, telemetryConsentLabel };

package/lib/core.js

@@ -8,6 +8,25 @@ const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
 
+const { modelsForProvider, sanitizeModels, MODEL_REGISTRY } = require('./models');
+
+/**
+ * Resolve workspace folder mentah (dari server / config / arg CLI) menjadi
+ * path absolut, atau null bila kosong. Aturan:
+ *  - "" / null → null (pakai cwd proses)
+ *  - "~" / "~/x" → home dir user
+ *  - relatif → resolve terhadap cwd proses saat dipanggil
+ *  - absolut → apa adanya (dinormalisasi)
+ * Tidak menyentuh filesystem (cek eksistensi di pemanggil agar bisa warning).
+ */
+function resolveWorkspace(raw) {
+  const s = typeof raw === 'string' ? raw.trim() : '';
+  if (!s) return null;
+  if (s === '~' || s.startsWith('~/')) return path.normalize(path.join(os.homedir(), s.slice(s === '~' ? 1 : 2)));
+  if (path.isAbsolute(s)) return path.normalize(s);
+  return path.resolve(process.cwd(), s);
+}
+
 // ── Lokasi file ──────────────────────────────────────────────────────────────
 
 const CONFIG_DIR = path.join(os.homedir(), '.luang-cli');
@@ -28,6 +47,10 @@ const DEFAULT_CONFIG = {
   // ikut dikirim bila consent aktif; selain itu biarkan null.
   tokens_in: null,
   tokens_out: null,
+  // Mode auto agent (`luang-cli agent start`): true = eksekusi tugas To-Do
+  // tanpa konfirmasi y/N (agent berjalan di background / tanpa terminal).
+  // Ditulis oleh `agent start` (default true, `--no-auto` menulis false).
+  auto_exec: false,
 };
 
 // ── Config ───────────────────────────────────────────────────────────────────
@@ -398,6 +421,9 @@ function heartbeatProviders(list) {
     path: p.path || null,
     exec_template: p.exec_template || null,
     version: probeVersion(p.path),
+    // Kontrak baru (opsional): daftar model per provider — maks 50 item,
+    // tiap item ≤120 karakter (lihat lib/models.js).
+    models: modelsForProvider(p.provider_type, { path: p.path }).models,
   }));
 }
 
@@ -446,5 +472,9 @@ module.exports = {
   probeVersion,
   collectProviders,
   heartbeatProviders,
+  resolveWorkspace,
+  modelsForProvider,
+  sanitizeModels,
+  MODEL_REGISTRY,
   openBrowser,
 };

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,
+};

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "luang-cli",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "CLI Agent Orchestration Luang — login device flow, sinkronisasi provider AI, daemon tugas, dan manajemen task dari terminal. Zero-dependency, Node >= 18.",
   "license": "MIT",
   "bin": {
     "luang-cli": "bin/luang-cli.js"
   },
   "scripts": {
-    "test": "node test/e2e-realtime-stub.js"
+    "test": "node test/run-e2e.js"
   },
   "engines": {
     "node": ">=18"

package/test/bin/opencode

@@ -1,5 +1,10 @@
 #!/usr/bin/env bash
 # Stub provider untuk E2E offline luang-cli.
 # Ganti binary `opencode` di PATH uji — TIDAK memanggil opencode/claude/gemini asli.
+if [ "$1" = "models" ]; then
+  # Dipakai skenario `luang-cli models` (deteksi dinamis opencode).
+  printf '%s\n' '["stub-model-a","stub-model-b","stub-model-c"]'
+  exit 0
+fi
 printf 'PROVIDER-RUN %s\n' "$*"
 exit 0

package/test/http-stub.js

@@ -9,11 +9,19 @@
 const http = require('http');
 
 let telemetryEnabled = false;
+let lastHeartbeat = null;
+let workspace = '';
 
 process.on('message', (msg) => {
   if (msg && typeof msg === 'object' && 'telemetry_enabled' in msg) {
     telemetryEnabled = msg.telemetry_enabled === true;
   }
+  if (msg && typeof msg === 'object' && 'workspace' in msg) {
+    workspace = String(msg.workspace || '');
+  }
+  if (msg && msg.cmd === 'get_heartbeat') {
+    if (typeof process.send === 'function') process.send({ cmd: 'heartbeat', body: lastHeartbeat });
+  }
   if (msg && msg.cmd === 'exit') {
     process.exit(0);
   }
@@ -24,10 +32,40 @@ const server = http.createServer((req, res) => {
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify({
       success: true,
-      data: { name: 'Sesi Uji', key_id: 'k3', telemetry_enabled: telemetryEnabled, can_update_tasks: true },
+      data: { name: 'Sesi Uji', key_id: 'k3', telemetry_enabled: telemetryEnabled, workspace, can_update_tasks: true },
     }));
     return;
   }
+  if (req.url.startsWith('/api/v1/agent/workspace') && req.method === 'POST') {
+    let raw = '';
+    req.on('data', (d) => { raw += d; });
+    req.on('end', () => {
+      try {
+        const b = JSON.parse(raw);
+        workspace = typeof b.workspace === 'string' ? b.workspace : workspace;
+      } catch (e) { /* abaikan */ }
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ success: true, message: 'Workspace disimpan', data: { workspace } }));
+    });
+    return;
+  }
+  if (req.url.startsWith('/api/v1/agent/heartbeat') && req.method === 'POST') {
+    let raw = '';
+    req.on('data', (d) => { raw += d; });
+    req.on('end', () => {
+      try {
+        lastHeartbeat = JSON.parse(raw);
+      } catch (e) {
+        lastHeartbeat = null;
+      }
+      // Kirim payload ke induk supaya E2E bisa memeriksa kontrak `providers[].models`.
+      if (typeof process.send === 'function') process.send({ cmd: 'heartbeat', body: lastHeartbeat });
+      const n = (lastHeartbeat && Array.isArray(lastHeartbeat.providers) ? lastHeartbeat.providers : []).length;
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ success: true, data: { providers_count: n } }));
+    });
+    return;
+  }
   res.writeHead(404, { 'Content-Type': 'application/json' });
   res.end(JSON.stringify({ success: false, message: 'not found' }));
 });