luang-cli 0.3.0 → 0.3.2

package/test/run-e2e.js

@@ -117,7 +117,7 @@ function homeConfig(home) {
 // ── Skenario 1: sintaks ──
 function scenarioSyntax() {
   console.log('\n[1] node --check semua file JS + guard PATH uji (kebijakan provider opencode)');
-  const files = ['bin/luang-cli.js', 'lib/core.js', 'lib/commands.js', 'lib/agent.js', 'lib/ws.js', 'test/run-e2e.js', 'test/ws-stub.js'];
+  const files = ['bin/luang-cli.js', 'lib/core.js', 'lib/commands.js', 'lib/agent.js', 'lib/models.js', 'lib/ws.js', 'test/run-e2e.js', 'test/ws-stub.js', 'test/http-stub.js'];
   for (const f of files) {
     const r = spawnSync(process.execPath, ['--check', path.join(ROOT, f)], { encoding: 'utf8' });
     assert(r.status === 0, `${f} lolos --check${r.stderr ? ' — ' + r.stderr.slice(0, 200) : ''}`);
@@ -183,6 +183,9 @@ async function scenarioRealtime() {
       assert(typeof m.data.version === 'string' && m.data.version.length > 0, 'hello menyertakan version');
       assert(Array.isArray(m.data.providers) && m.data.providers.some((p) => p.type === 'opencode'), 'hello menyertakan provider opencode');
       assert(m.data.providers.find((p) => p.type === 'opencode').exec_template.includes('{task}'), 'hello menyertakan exec_template berisi {task}');
+      const helloOpc = m.data.providers.find((p) => p.type === 'opencode');
+      assert(Array.isArray(helloOpc.models) && helloOpc.models.length <= 50, 'hello menyertakan field models (≤50 item)');
+      assert(helloOpc.models.every((x) => typeof x === 'string' && x.length <= 120), 'tiap model di hello ≤120 karakter');
       gotHello = true;
       // Langsung perintah server: set_model SEBELUM tugas dikirim (agar exec pakai model)
       phase = 1;
@@ -387,6 +390,13 @@ async function scenarioConsentAndModel() {
   });
   const setServerTelemetry = (v) => stub.send({ telemetry_enabled: v });
 
+  // Kumpulkan payload heartbeat (IPC) — daftar sebelum runCli karena pesan
+  // IPC yang tiba tanpa listener akan hilang.
+  const heartbeats = [];
+  stub.on('message', (m) => {
+    if (m && m.cmd === 'heartbeat' && m.body) heartbeats.push(m.body);
+  });
+
   const envA = { ...daemonEnv(home), LUANG_HEARTBEAT_SEC: undefined };
   writeJson(path.join(home, '.luang-cli', 'config.json'), {
     api_url: `http://127.0.0.1:${port}`,
@@ -429,6 +439,17 @@ async function scenarioConsentAndModel() {
     assert(homeConfig(home).providers.opencode.model === 'sonnet-test-9', 'config providers.opencode.model');
     r = runCli(envA, ['provider', 'list']);
     assert(r.stdout.includes('Model') && r.stdout.includes('opencode'), 'provider list menunjukkan kolom Model');
+
+    // Kontrak baru: payload heartbeat menyertakan providers[].models (≤50 × 120 char)
+    // Catatan: pesan IPC datang async setelah spawnSync runCli selesai → tunggu.
+    await until(() => heartbeats.length >= 1, 8000, 'heartbeat HTTP terkirim saat provider list');
+    const hb = heartbeats[heartbeats.length - 1];
+    assert(hb && Array.isArray(hb.providers) && hb.providers.length > 0, 'heartbeat payload memuat providers[]');
+    const hbOpc = hb.providers.find((p) => p.provider_type === 'opencode');
+    assert(!!hbOpc, 'heartbeat providers memuat opencode');
+    assert(Array.isArray(hbOpc.models) && hbOpc.models.length <= 50, 'heartbeat providers[].models array (≤50)');
+    assert(hbOpc.models.every((m) => typeof m === 'string' && m.length <= 120), 'tiap model di heartbeat ≤120 karakter');
+    assert(hbOpc.models.includes('stub-model-a'), 'models heartbeat datang dari deteksi dinamis (stub opencode)');
   } finally {
     try { stub.send({ cmd: 'exit' }); } catch (e) { /* abaikan */ }
     stub.kill();
@@ -437,6 +458,329 @@ async function scenarioConsentAndModel() {
   console.log('    ✅ Skenario konsent + model selesai');
 }
 
+// ── Skenario 5: pesan eksekusi jujur (tanpa --exec TIDAK menyalahkan template) ──
+async function scenarioExecMessages() {
+  console.log('\n[5] Pesan eksekusi: doExec=false → "eksekusi nonaktif"; --exec tanpa template → exec_template');
+  const home = mkFakeHome('execmsg');
+  const port = 18501 + Math.floor(Math.random() * 400);
+  const config = {
+    api_url: `http://127.0.0.1:${port}`,
+    app_url: 'http://127.0.0.1',
+    key: 'lk_test_e2e_execmsg',
+    default_provider: 'opencode',
+    providers: {
+      opencode: {
+        provider_type: 'opencode',
+        display_name: 'OpenCode',
+        path: 'stub-opencode',
+        exec_template: 'opencode run "{task}"',
+      },
+    },
+    telemetry: false,
+  };
+  writeJson(path.join(home, '.luang-cli', 'config.json'), config);
+  const env = daemonEnv(home);
+  const stub = new StubWsServer({ port, expectedKey: config.key });
+  await stub.start();
+  const task = { id: 't-m1', task_code: 'TGS-201', title: 'Tugas tanpa eksekusi', description: 'pesan harus jujur', status: 'todo' };
+  const send = (type, data) => stub.broadcastText(JSON.stringify({ type, ts: Date.now(), data }));
+  stub.onMsg = (f) => {
+    const m = f.obj;
+    if (!m) return;
+    if (m.type === 'hello') {
+      send('hello.ok', { key_id: 'kx', user_id: 'ux', tenant_id: 'tx', telemetry_enabled: false, server_time: new Date().toISOString() });
+      send('task.snapshot', { tasks: [task] });
+    }
+  };
+
+  try {
+    // A) foreground TANPA --exec → notice "eksekusi nonaktif" (bukan salahkan template)
+    const a = spawnDaemon(env, ['agent']);
+    try {
+      await until(() => a.cap.out.includes('eksekusi nonaktif'), 15000, 'notice "eksekusi nonaktif" tanpa --exec');
+      assert(a.cap.out.includes('Eksekusi  : nonaktif'), 'banner: Eksekusi : nonaktif');
+      assert(a.cap.out.includes('luang-cli agent --exec'), 'notice menyebut cara menyalakan: luang-cli agent --exec');
+      assert(a.cap.out.includes('agent start'), 'notice menyebut mode otomatis: agent start');
+      assert(!a.cap.out.includes('default provider belum punya exec_template'), 'TANPA --exec: TIDAK menyalahkan exec_template');
+      assert(!a.cap.out.includes('Jalankan sekarang?'), 'TANPA --exec: tidak ada prompt y/N');
+      await a.proc.finish('SIGTERM');
+    } finally {
+      await a.proc.finish();
+    }
+    const st = JSON.parse(fs.readFileSync(path.join(home, '.luang-cli', 'state.json'), 'utf8'));
+    assert(!st.executed || !st.executed['TGS-201'], 'tugas TIDAK ditandai executed saat eksekusi nonaktif');
+
+    // B) --exec tapi exec_template kosong → BARU menyalahkan exec_template
+    config.providers.opencode.exec_template = null;
+    writeJson(path.join(home, '.luang-cli', 'config.json'), config);
+    const b = spawnDaemon(env, ['agent', '--exec']);
+    try {
+      await until(() => b.cap.out.includes('default provider belum punya exec_template'), 15000, 'notice exec_template saat --exec tanpa template');
+      assert(b.cap.out.includes('diminta tapi nonaktif'), 'banner: diminta tapi nonaktif (exec_template kosong)');
+      assert(!b.cap.out.includes('eksekusi nonaktif (jalankan'), '--exec: pesan tetap soal exec_template');
+      await b.proc.finish('SIGTERM');
+    } finally {
+      await b.proc.finish();
+    }
+  } finally {
+    await stub.stop();
+  }
+  passCount += 1;
+  console.log('    ✅ Skenario pesan eksekusi selesai');
+}
+
+// ── Skenario 6: agent start/stop/status/logs (fake HOME) + eksekusi auto ──
+async function scenarioAgentLifecycle() {
+  console.log('\n[6] agent start/stop/status/logs (background, fake HOME) + eksekusi auto tanpa y/N');
+  const home = mkFakeHome('lifecycle');
+  const port = 18701 + Math.floor(Math.random() * 400);
+  const config = {
+    api_url: `http://127.0.0.1:${port}`,
+    app_url: 'http://127.0.0.1',
+    key: 'lk_test_e2e_lifecycle',
+    default_provider: 'opencode',
+    providers: {
+      opencode: {
+        provider_type: 'opencode',
+        display_name: 'OpenCode',
+        path: 'stub-opencode',
+        exec_template: 'opencode run "{task}"',
+      },
+    },
+    telemetry: false,
+  };
+  writeJson(path.join(home, '.luang-cli', 'config.json'), config);
+  const env = daemonEnv(home);
+  const stub = new StubWsServer({ port, expectedKey: config.key });
+  await stub.start();
+  const task = { id: 't-l1', task_code: 'TGS-301', title: 'Tugas background', description: 'jalan tanpa terminal', status: 'todo' };
+  const send = (type, data) => stub.broadcastText(JSON.stringify({ type, ts: Date.now(), data }));
+  stub.onMsg = (f) => {
+    const m = f.obj;
+    if (!m) return;
+    if (m.type === 'hello') {
+      send('hello.ok', { key_id: 'kl', user_id: 'ul', tenant_id: 'tl', telemetry_enabled: false, server_time: new Date().toISOString() });
+      send('task.snapshot', { tasks: [task] });
+    }
+  };
+
+  const pidFile = path.join(home, '.luang-cli', 'agent.pid');
+  const logFile = path.join(home, '.luang-cli', 'agent.log');
+  const readPid = () => JSON.parse(fs.readFileSync(pidFile, 'utf8'));
+
+  try {
+    let r = runCli(env, ['agent', 'start']);
+    assert(r.code === 0, `agent start exit 0 (dapat ${r.code}) — ${r.stderr || r.stdout}`);
+    assert(r.stdout.includes('berjalan di background (pid'), 'start mencetak "berjalan di background (pid …"');
+    assert(r.stdout.includes('log:'), 'start mencetak path log');
+    const info = readPid();
+    assert(Number.isInteger(info.pid) && info.pid > 0, `agent.pid memuat pid (dapat ${info.pid})`);
+    assert(info.auto === true && info.mode === 'auto', 'agent.pid: auto=true, mode="auto" (default agent start)');
+    assert(typeof info.started_at === 'string' && info.started_at.length > 10, 'agent.pid: started_at ISO');
+    assert(homeConfig(home).auto_exec === true, 'config.auto_exec = true ditulis oleh agent start');
+
+    // Eksekusi AUTO: tidak ada tulisan "y" ke stdin — tugas langsung dijalankan.
+    await until(() => fs.existsSync(logFile) && fs.readFileSync(logFile, 'utf8').includes('PROVIDER-RUN'), 25000, 'exec auto berjalan dari background (stub provider)');
+    const logTxt = fs.readFileSync(logFile, 'utf8');
+    assert(logTxt.includes('Realtime aktif'), 'child: mode realtime aktif (terlihat di log)');
+    assert(logTxt.includes('otomatis tanpa konfirmasi'), 'banner child: mode auto (tanpa konfirmasi)');
+    assert(!logTxt.includes('Jalankan sekarang?'), 'mode auto: TANPA prompt y/N');
+    assert(logTxt.includes('Konfirmasi: otomatis'), 'log mencatat konfirmasi otomatis');
+    await until(
+      () => stub.frames.some((f) => f.obj && f.obj.type === 'task.status' && f.obj.data && f.obj.data.ref === 'TGS-301' && f.obj.data.status === 'done'),
+      15000,
+      'task.status done dari daemon background',
+    );
+
+    // status: pid, uptime, mode, auto_exec, 3 baris log terakhir
+    r = runCli(env, ['agent', 'status']);
+    assert(r.code === 0, 'agent status exit 0');
+    assert(r.stdout.includes(String(info.pid)) && r.stdout.includes('hidup'), 'status: pid + hidup');
+    assert(/Uptime\s+:/.test(r.stdout), 'status: uptime tampil');
+    assert(r.stdout.includes('auto (otomatis tanpa konfirmasi)'), 'status: mode auto tampil');
+    assert(r.stdout.includes('auto_exec = true'), 'status: config auto_exec tampil');
+    const marker = '── log (3 terakhir) ──';
+    assert(r.stdout.includes(marker), 'status: 3 baris log terakhir ditampilkan');
+    const tail = r.stdout.split(marker)[1].split('\n').map((s) => s.trim()).filter(Boolean);
+    assert(tail.length === 3, `status menampilkan tepat 3 baris log (dapat ${tail.length})`);
+    const logNow = fs.readFileSync(logFile, 'utf8');
+    assert(tail.every((l) => logNow.includes(l)), 'baris yang ditampilkan benar-benar isi agent.log');
+
+    // logs [--tail N] (default 30)
+    r = runCli(env, ['agent', 'logs', '--tail', '5']);
+    assert(r.code === 0, 'agent logs --tail 5 exit 0');
+    const logLines = r.stdout.split('\n').filter((l) => l.trim() !== '');
+    assert(logLines.length <= 5, `logs --tail 5 maksimal 5 baris (dapat ${logLines.length})`);
+    r = runCli(env, ['agent', 'logs']);
+    assert(r.code === 0 && r.stdout.includes('TGS-301 selesai'), 'logs (default) memuat hasil eksekusi TGS-301');
+
+    // stop → SIGTERM graceful, pid file hilang, proses benar-benar mati
+    r = runCli(env, ['agent', 'stop']);
+    assert(r.code === 0 && r.stdout.includes('dihentikan'), 'agent stop: sukses (SIGTERM graceful)');
+    assert(!fs.existsSync(pidFile), 'agent.pid dihapus setelah stop');
+    let alive = true;
+    try {
+      process.kill(info.pid, 0);
+    } catch (e) {
+      alive = false;
+    }
+    assert(!alive, 'proses background mati setelah stop');
+
+    r = runCli(env, ['agent', 'status']);
+    assert(r.stdout.includes('tidak berjalan'), 'status setelah stop: tidak berjalan');
+    r = runCli(env, ['agent', 'stop']);
+    assert(r.code === 0 && r.stdout.includes('tidak berjalan'), 'stop kedua (pid file sudah hilang) tetap exit 0');
+
+    // --no-auto → mode manual + config auto_exec false
+    r = runCli(env, ['agent', 'start', '--no-auto']);
+    assert(r.code === 0, `agent start --no-auto exit 0 (dapat ${r.code})`);
+    const info2 = readPid();
+    assert(info2.auto === false && info2.mode === 'manual', 'agent.pid (--no-auto): auto=false, mode="manual"');
+    assert(homeConfig(home).auto_exec === false, 'config.auto_exec = false ditulis oleh --no-auto');
+    r = runCli(env, ['agent', 'stop']);
+    assert(r.code === 0, 'stop setelah --no-auto');
+  } finally {
+    // bersihkan bila skenario gagal di tengah (jangan biarkan proses liar)
+    try {
+      const info = fs.existsSync(pidFile) ? JSON.parse(fs.readFileSync(pidFile, 'utf8')) : null;
+      if (info) {
+        try {
+          process.kill(info.pid, 'SIGKILL');
+        } catch (e) { /* abaikan */ }
+        fs.rmSync(pidFile, { force: true });
+      }
+    } catch (e) { /* abaikan */ }
+    await stub.stop();
+  }
+  passCount += 1;
+  console.log('    ✅ Skenario lifecycle agent start/stop/status/logs selesai');
+}
+
+// ── Skenario 7: models (registry + opencode dinamis + guard binary lain) ──
+async function scenarioModels() {
+  console.log('\n[7] models: registry statis + opencode dinamis (stub) + honeypot claude/gemini/codex');
+  const home = mkFakeHome('models');
+  const marker = path.join(home, 'honeypot-executed.log');
+  const binDir = mkdirp(path.join(home, 'bin'));
+  // Honeypot: bila binary ini dieksekusi → menulis marker. Harus TIDAK pernah terjadi.
+  for (const b of ['claude', 'gemini', 'codex']) {
+    const p = path.join(binDir, b);
+    fs.writeFileSync(p, '#!/usr/bin/env bash\necho "$0 $*" >> "$HONEYPOT_MARKER"\nexit 0\n');
+    fs.chmodSync(p, 0o755);
+  }
+  const env = {
+    ...process.env,
+    HOME: home,
+    LUANG_NO_OPEN: '1',
+    HONEYPOT_MARKER: marker,
+    PATH: `${binDir}:${path.join(__dirname, 'bin')}:/usr/bin:/bin`,
+  };
+
+  // --json: struktur benar untuk SEMUA provider
+  let r = runCli(env, ['models', '--json']);
+  assert(r.code === 0, `models --json exit 0 (dapat ${r.code}) ${r.stderr || ''}`);
+  let j = null;
+  try {
+    j = JSON.parse(r.stdout);
+  } catch (e) {
+    j = null;
+  }
+  assert(j !== null && typeof j === 'object', 'models --json menghasilkan JSON valid');
+  const types = ['claude_code', 'codex', 'opencode', 'gemini_cli', 'custom'];
+  assert(types.every((t) => j && j[t]), `json memuat semua provider (${types.join(', ')})`);
+  for (const t of types) {
+    const e = j[t];
+    assert(!!e && e.provider === t, `${t}: field provider benar`);
+    assert(!!e && ['static', 'binary', 'config'].includes(e.source), `${t}: source valid (${e && e.source})`);
+    assert(!!e && Array.isArray(e.models), `${t}: models berupa array`);
+    assert(!!e && e.models.length <= 50, `${t}: maksimal 50 item`);
+    assert(!!e && e.models.every((m) => typeof m === 'string' && m.length <= 120), `${t}: tiap model ≤120 karakter`);
+  }
+  assert(j.claude_code.source === 'static', 'claude_code: statis (binary tidak dieksekusi)');
+  assert(j.codex.source === 'static' && j.gemini_cli.source === 'static', 'codex & gemini_cli: statis');
+  assert(j.opencode.source === 'binary', `opencode: deteksi dinamis via stub (dapat ${j.opencode.source})`);
+  assert(j.opencode.models.includes('stub-model-a'), 'opencode: model dari `opencode models` (stub)');
+
+  // provider tunggal
+  r = runCli(env, ['models', 'opencode', '--json']);
+  j = JSON.parse(r.stdout);
+  assert(Object.keys(j).length === 1 && Array.isArray(j.opencode.models), 'models <provider> --json: hanya provider itu');
+
+  // provider tak dikenal → error + daftar pilihan
+  r = runCli(env, ['models', 'bogus_provider']);
+  assert(r.code === 1 && /tidak dikenal/i.test(r.stderr), 'models bogus → exit 1 + pesan pilihan');
+
+  // tampilan tabel
+  r = runCli(env, ['models']);
+  assert(r.code === 0, 'models (tabel) exit 0');
+  assert(r.stdout.includes('Provider') && r.stdout.includes('Jumlah'), 'tabel: header Provider | Jumlah');
+  assert(r.stdout.includes('claude_code') && r.stdout.includes('gemini_cli'), 'tabel: semua provider tampil');
+  assert(r.stdout.includes('…+'), 'tabel: wrap maks 6 baris + "…+n lagi" untuk daftar panjang');
+
+  // Guard kebijakan: claude/gemini/codex TIDAK PERNAH dieksekusi
+  assert(!fs.existsSync(marker), 'KEBIJAKAN: binary claude/gemini/codex tidak pernah dieksekusi (honeypot bersih)');
+
+  passCount += 1;
+  console.log('    ✅ Skenario models selesai');
+}
+
+// ── Skenario 8: workspace folder (set/status/reset + dipakai exec) ──
+async function scenarioWorkspace() {
+  console.log('\n[8] workspace: set via CLI → server+lokal sinkron, status tampil, reset bersih');
+  const home = mkFakeHome('workspace');
+  const stub = fork(path.join(__dirname, 'http-stub.js'), [], { stdio: ['ignore', 'ignore', 'ignore', 'ipc'] });
+  const port = await new Promise((resolve, reject) => {
+    stub.once('message', (m) => { if (m && m.cmd === 'listening') resolve(m.port); else reject(new Error('pesan stub tak dikenal')); });
+    stub.once('error', reject);
+    setTimeout(() => reject(new Error('stub http tidak siap dalam 5s')), 5000);
+  });
+
+  const envA = { ...daemonEnv(home), LUANG_HEARTBEAT_SEC: undefined };
+  writeJson(path.join(home, '.luang-cli', 'config.json'), {
+    api_url: `http://127.0.0.1:${port}`,
+    app_url: 'http://127.0.0.1',
+    key: 'lk_test_e2e_workspace',
+    default_provider: null,
+    providers: {},
+  });
+  // Folder kerja valid di dalam HOME palsu.
+  const workdir = path.join(home, 'projek');
+  fs.mkdirSync(workdir, { recursive: true });
+
+  try {
+    // status awal: server kosong → efektif folder saat ini
+    let r = runCli(envA, ['workspace']);
+    assert(r.code === 0, 'workspace (status) exit 0');
+    assert(r.stdout.includes('folder saat ini'), 'status awal: efektif folder saat ini');
+
+    // set ke folder yang ada → server + lokal sinkron
+    r = runCli(envA, ['workspace', workdir]);
+    assert(r.code === 0 && r.stdout.includes('Workspace disimpan'), 'workspace set → tersimpan');
+    assert(homeConfig(home).workspace === workdir, 'config.workspace tersimpan lokal');
+
+    // status lagi → server menampilkan path yang sama (bukti POST /agent/workspace masuk stub)
+    r = runCli(envA, ['workspace']);
+    assert(r.code === 0 && r.stdout.includes(workdir), 'status: server menampilkan path yang diset');
+
+    // set ke folder tak ada → ditolak, config tidak berubah
+    r = runCli(envA, ['workspace', path.join(home, 'tidak-ada')]);
+    assert(r.code === 1, 'workspace path tak ada → exit 1');
+    assert(homeConfig(home).workspace === workdir, 'config.workspace tidak berubah saat gagal');
+
+    // reset → kosong kembali
+    r = runCli(envA, ['workspace', '--reset']);
+    assert(r.code === 0 && r.stdout.includes('direset'), 'workspace --reset → direset');
+    assert(!homeConfig(home).workspace, 'config.workspace kosong setelah reset');
+    r = runCli(envA, ['workspace']);
+    assert(r.code === 0 && r.stdout.includes('folder saat ini'), 'status setelah reset: folder saat ini');
+  } finally {
+    try { stub.send({ cmd: 'exit' }); } catch (e) { /* abaikan */ }
+    stub.kill();
+  }
+  passCount += 1;
+  console.log('    ✅ Skenario workspace selesai');
+}
+
 // ── main ──
 async function main() {
   console.log(`E2E luang-cli — fakir HOME: ${baseTmp}`);
@@ -444,6 +788,10 @@ async function main() {
   await scenarioRealtime();
   await scenarioFallback();
   await scenarioConsentAndModel();
+  await scenarioExecMessages();
+  await scenarioAgentLifecycle();
+  await scenarioModels();
+  await scenarioWorkspace();
   console.log(`\nSEMIUA PASS ✅ (${passCount} assertion)`);
 }