luang-cli 0.2.0 → 0.3.2

package/test/run-e2e.js

@@ -0,0 +1,806 @@
+'use strict';
+
+// test/run-e2e.js — E2E offline luang-cli dengan stub WS + stub HTTP.
+// TIDAK pernah menjalankan harness provider asli (opencode/claude/gemini):
+// binary `opencode` di PATH uji adalah stub (test/bin/opencode).
+// HOME selalu fake (~/.luang-cli milik user tidak tersentuh).
+//
+// Pakai: node test/run-e2e.js
+
+const { spawn, spawnSync, fork } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+
+const { StubWsServer } = require('./ws-stub');
+
+const ROOT = path.join(__dirname, '..');
+const BIN = path.join(ROOT, 'bin', 'luang-cli.js');
+
+// ── util ──
+const baseTmp = process.env.E2E_TMP || path.join(os.tmpdir(), 'opencode');
+let passCount = 0;
+let failCount = 0;
+
+function assert(cond, msg) {
+  if (cond) {
+    passCount += 1;
+    console.log(`    ✅ ${msg}`);
+  } else {
+    failCount += 1;
+    console.error(`    ❌ ${msg}`);
+    throw new Error(`ASSERT: ${msg}`);
+  }
+}
+
+function mkdirp(p) {
+  fs.mkdirSync(p, { recursive: true });
+  return p;
+}
+
+function writeJson(p, obj) {
+  fs.writeFileSync(p, JSON.stringify(obj, null, 2) + '\n');
+}
+
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+function until(fn, ms, label) {
+  const t0 = Date.now();
+  return new Promise((resolve, reject) => {
+    const tick = () => {
+      let v;
+      try { v = fn(); } catch (e) { return reject(e); }
+      if (v) return resolve(v);
+      if (Date.now() - t0 > ms) return reject(new Error(`Timeout menunggu: ${label}`));
+      setTimeout(tick, 100);
+    };
+    tick();
+  });
+}
+
+function mkFakeHome(name) {
+  const home = mkdtempUnder(baseTmp, `luang-e2e-${name}-`);
+  mkdirp(path.join(home, '.luang-cli'));
+  return home;
+}
+
+function mkdtempUnder(base, prefix) {
+  mkdirp(base);
+  return fs.mkdtempSync(path.join(base, prefix));
+}
+
+function daemonEnv(home) {
+  return {
+    ...process.env,
+    HOME: home,
+    LUANG_NO_OPEN: '1',
+    // ── Kebijakan pengujian provider ───────────────────────────────────────
+    // PATH uji DIKUNCI ke stub test/bin + util dasar: `which claude` /
+    // `which gemini` HARUS NOT_FOUND di sini, sehingga deteksi provider
+    // (which(1)) dan probe versi (→ `<bin> --version`) tidak pernah
+    // mengeksekusi binary claude/gemini. Provider uji: opencode (stub).
+    PATH: `${path.join(__dirname, 'bin')}:/usr/bin:/bin`,
+    // heartbeat cepat supaya E2E melihat frame heartbeat tanpa nunggu 30s
+    LUANG_HEARTBEAT_SEC: '3',
+  };
+}
+
+function spawnDaemon(env, args, stdinData) {
+  const p = spawn(process.execPath, [BIN, ...args], { env, cwd: ROOT });
+  const cap = { out: '', err: '' };
+  p.stdout.on('data', (d) => { cap.out += d.toString(); });
+  p.stderr.on('data', (d) => { cap.err += d.toString(); });
+  if (stdinData !== undefined) p.stdin.write(stdinData);
+  p.killedCleanly = false;
+  p.finish = async (sig = 'SIGTERM') => {
+    if (!p.killedCleanly) {
+      p.killedCleanly = true;
+      try { p.kill(sig); } catch (e) { /* abaikan */ }
+    }
+    await until(() => p.exitCode !== null || p.signalCode !== null, 6000, 'daemon keluar');
+  };
+  return { proc: p, cap };
+}
+
+function runCli(env, args) {
+  const r = spawnSync(process.execPath, [BIN, ...args], { env, cwd: ROOT, encoding: 'utf8', timeout: 20000 });
+  return { code: r.status, stdout: String(r.stdout || ''), stderr: String(r.stderr || '') };
+}
+
+function homeConfig(home) {
+  return JSON.parse(fs.readFileSync(path.join(home, '.luang-cli', 'config.json'), 'utf8'));
+}
+
+// ── 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/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) : ''}`);
+  }
+  // Guard kebijakan: PATH yang dipakai daemon TIDAK BOLEH menemukan claude/gemini,
+  // dan `opencode` harus resolve ke stub di test/bin (bukan binary asli).
+  const guardEnv = { ...process.env, PATH: `${path.join(__dirname, 'bin')}:/usr/bin:/bin` };
+  for (const bin of ['claude', 'gemini', 'codex']) {
+    const which = spawnSync('/usr/bin/which', [bin], { env: guardEnv, encoding: 'utf8' });
+    assert(which.status !== 0, `PATH uji TIDAK menemukan ${bin} (tidak akan dieksekusi) — dapat: ${String(which.stdout || '').trim() || 'tidak ada'}`);
+  }
+  const whichOpen = spawnSync('/usr/bin/which', ['opencode'], { env: guardEnv, encoding: 'utf8' });
+  const openPath = String(whichOpen.stdout || '').trim();
+  assert(openPath.startsWith(path.join(__dirname, 'bin')), `PATH uji resolve opencode → stub (${openPath || 'tidak ada'})`);
+  // HOME uji tidak boleh menyentuh host ~/.claude dst — daemonEnv memakai HOME fake.
+}
+
+// ── Skenario 2: realtime WS hello → command → snapshot → assigned → exec → telemetry → ack → heartbeat ──
+async function scenarioRealtime() {
+  console.log('\n[2] E2E realtime WS: hello→ack→snapshot→assigned→exec→telemetry→pause/resume→heartbeat');
+  const home = mkFakeHome('realtime');
+  const port = 18101 + 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_realtime',
+    default_provider: 'opencode',
+    providers: {
+      opencode: {
+        provider_type: 'opencode',
+        display_name: 'OpenCode',
+        path: 'stub-opencode',
+        exec_template: 'opencode run --model "{model}" "{task}"',
+      },
+    },
+    telemetry: true,
+  };
+  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 state = { done: false };
+  const task101 = { id: 't-1', task_code: 'TGS-101', title: 'Refactor auth CLI', description: 'Bersihkan modul core', status: 'todo' };
+  const task102 = { id: 't-2', task_code: 'TGS-102', title: 'Deploy stub test', description: 'Cek pipeline offline', status: 'todo' };
+
+  const send = (type, data) => stub.broadcastText(JSON.stringify({ type, ts: Date.now(), data }));
+
+  stub.onHandshake = () => {
+    assert(true, 'handshake 101 diterima stub (upgrade sukses)');
+    send('hello.ok', { key_id: 'k9', user_id: 'u1', tenant_id: 'tn1', telemetry_enabled: true, server_time: new Date().toISOString() });
+  };
+
+  let phase = 0;
+  let gotHello = false;
+  stub.onMsg = (f) => {
+    const m = f.obj;
+    if (!m) return;
+    if (m.type === 'hello') {
+      assert(stub.frames.filter((x) => x.obj && x.obj.type !== 'hello').every((x) => x.ts >= f.ts), 'hello = pesan pertama klien dalam koneksi');
+      assert(m.data && m.data.mode === 'cli', 'hello {mode:"cli"} sesuai kontrak');
+      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;
+      send('agent.command', { command_id: 'c1', command: 'set_model', provider: 'opencode', model: 'sonnet-test-9' });
+    } else if (m.type === 'command.ack') {
+      assert(Object.prototype.hasOwnProperty.call(m.data, 'command_id'), 'command.ack memakai command_id');
+      if (m.data.command_id === 'c1') {
+        assert(m.data.ok === true, 'ack c1 (set_model) ok:true');
+        const cfg = homeConfig(home);
+        assert(cfg.providers && cfg.providers.opencode && cfg.providers.opencode.model === 'sonnet-test-9', 'model tersimpan ke config providers.opencode.model');
+        phase = 2;
+        send('task.snapshot', { tasks: [task101] });
+      } else if (m.data.command_id === 'c2') {
+        assert(m.data.ok === true, 'ack c2 (pause) ok:true');
+        send('agent.command', { command_id: 'c3', command: 'resume' });
+      } else if (m.data.command_id === 'c3') {
+        assert(m.data.ok === true, 'ack c3 (resume) ok:true');
+        phase = 4;
+        stub.pingAll(); // protocol ping server → CLI balas pong
+      }
+    } else if (m.type === 'task.status') {
+      assert(m.data && m.data.ref, 'task.status menyertakan ref');
+      if (m.data.ref === 'TGS-101' && m.data.status === 'in_progress') {
+        assert(phase >= 2, 'setelah snapshot → in_progress terkirim via WS');
+      }
+      if (m.data.ref === 'TGS-101' && m.data.status === 'done') {
+        phase = 3;
+        send('task.assigned', { task: task102 });
+      }
+    }
+  };
+
+  const { proc, cap } = spawnDaemon(env, ['agent', '--exec']);
+  proc.stdin.write('y\n'); // jawab konfirmasi exec pertama (TGS-101); exec kedua dijawab belakangan
+  const dbg = (e) => {
+    console.error('---- daemon stdout ----\n' + cap.out);
+    console.error('---- daemon stderr ----\n' + cap.err);
+    console.error('---- ts client terakhir ----');
+    for (const f of stub.frames.slice(-20)) {
+      console.error(`  op=${f.opcode} ${f.obj ? f.obj.type + ' ' + JSON.stringify(f.obj.data || f.obj).slice(0, 120) : ''}`);
+    }
+    throw e;
+  };
+  try {
+    // telemetry run TGS-101: started → completed
+    await until(() => {
+      const xs = stub.frames.filter((f) => f.obj && f.obj.type === 'telemetry.run' && f.obj.data && f.obj.data.task_ref === 'TGS-101');
+      const started = xs.find((f) => f.obj.data.status === 'started');
+      const done = xs.find((f) => f.obj.data.status === 'completed');
+      return started && done ? { started, done } : null;
+    }, 15000, 'telemetry.run started+completed (TGS-101)');
+    const xs = stub.frames.filter((f) => f.obj && f.obj.type === 'telemetry.run' && f.obj.data && f.obj.data.task_ref === 'TGS-101');
+    const started = xs.find((f) => f.obj.data.status === 'started');
+    const done = xs.find((f) => f.obj.data.status === 'completed');
+    assert(started.obj.data.provider === 'opencode', 'telemetry started: provider opencode');
+    assert(started.obj.data.model === 'sonnet-test-9', 'telemetry started: model dari set_model');
+    assert(!('duration_ms' in started.obj.data), 'started tanpa duration_ms');
+    assert(done.obj.data.exit_code === 0, 'telemetry completed: exit_code 0');
+    assert(typeof done.obj.data.duration_ms === 'number' && done.obj.data.duration_ms >= 0, 'telemetry completed: duration_ms ada');
+
+    // exec kedua (TGS-102 via task.assigned) sedang menunggu konfirmasi — jawab y
+    proc.stdin.write('y\n');
+
+    // exec TGS-101 sukses: PROVIDER-RUN dari stub binary (bukan opencode asli)
+    await until(() => cap.out.includes('PROVIDER-RUN'), 15000, 'exec TGS-101 dijalankan (stub binary)');
+    assert(cap.out.includes('--model sonnet-test-9'), `{model} di exec_template diganti 'sonnet-test-9'`);
+
+    // TGS-102 via task.assigned → exec kedua
+    await until(() => {
+      const ys = stub.frames.filter((f) => f.obj && f.obj.type === 'telemetry.run' && f.obj.data && f.obj.data.task_ref === 'TGS-102');
+      return ys.some((f) => f.obj.data.status === 'started') && ys.some((f) => f.obj.data.status === 'completed') ? true : null;
+    }, 20000, 'telemetry.started+completed (TGS-102)');
+
+    const zs = stub.frames.filter((f) => f.obj && f.obj.type === 'task.status' && f.obj.data && f.obj.data.ref === 'TGS-102');
+    assert(zs.some((f) => f.obj.data.status === 'in_progress'), 'TGS-102: task.status in_progress via WS');
+    assert(zs.some((f) => f.obj.data.status === 'done'), 'TGS-102: task.status done via WS');
+
+    // pause + resume + heartbeat (frame) + pong
+    send('agent.command', { command_id: 'c2', command: 'pause' });
+    await until(() => stub.frames.some((f) => f.obj && f.obj.type === 'command.ack' && f.obj.data && f.obj.data.command_id === 'c3'), 8000, 'ack resume');
+    await until(() => stub.frames.some((f) => f.obj && f.obj.type === 'command.ack' && f.obj.data && f.obj.data.command_id === 'c3'), 8000, 'ack resume (dup cek)');
+    await until(() => stub.frames.some((f) => f.obj && f.obj.type === 'heartbeat'), 15000, 'frame heartbeat telah dikirim CLI');
+    await until(() => stub.frames.some((f) => f.opcode === 0xa), 10000, 'CLI membalas protocol ping dengan pong');
+
+    assert(cap.out.includes('set_model → opencode = sonnet-test-9'), 'stdout menampilkan persetujuan perintah set_model');
+    assert(cap.out.includes('PAUSE'), 'stdout menampilkan PAUSE');
+    assert(cap.out.includes('RESUME'), 'stdout menampilkan RESUME');
+    assert(cap.out.includes('di-assign'), 'stdout menandai tugas di-assign realtime');
+    assert(!cap.out.includes('fallback polling HTTP'), 'mode realtime aktif (tanpa fallback)');
+
+    state.done = true;
+    await proc.finish('SIGTERM');
+    assert(gotHello, 'hello pernah dikirim CLI');
+  } catch (e) {
+    await proc.finish();
+    dbg(e);
+  } finally {
+    await proc.finish();
+    await stub.stop();
+  }
+  if (!state.done) throw new Error('skenario realtime belum selesai');
+  passCount += 1;
+  console.log('    ✅ Skenario realtime selesai');
+}
+
+// ── Skenario 3: fallback polling HTTP ──
+async function scenarioFallback() {
+  console.log('\n[3] Fallback: WS gagal (port mati) → polling HTTP tetap jalan');
+  const home = mkFakeHome('fallback');
+  // Kebijakan: provider default uji = opencode (template offline walau tidak dieksekusi).
+  writeJson(path.join(home, '.luang-cli', 'config.json'), {
+    api_url: 'http://127.0.0.1:3', // port mati
+    app_url: 'http://127.0.0.1',
+    key: 'lk_test_e2e_fallback',
+    default_provider: 'opencode',
+    providers: {
+      opencode: {
+        provider_type: 'opencode',
+        display_name: 'OpenCode',
+        path: 'stub-opencode',
+        exec_template: 'opencode run "{task}"',
+      },
+    },
+    telemetry: false,
+  });
+  const env = daemonEnv(home);
+  const { proc, cap } = spawnDaemon(env, ['agent']);
+  try {
+    await until(() => cap.out.includes('fallback polling HTTP'), 20000, 'notice fallback muncul');
+    await until(() => cap.out.includes('Poll gagal'), 12000, 'message polling gagal mencoba (perilaku lama tetap hidup)');
+    assert(!cap.out.includes('Realtime aktif'), 'tidak mengaku realtime ketika WS gagal');
+  } finally {
+    await proc.finish();
+  }
+  passCount += 1;
+  console.log('    ✅ Skenario fallback selesai');
+}
+
+// ── Skenario reconnect ──
+async function scenarioReconnect() {
+  console.log('\n[4] Reconnect: koneksi WS diputus server → hello dikirim ulang, tanpa fallback');
+  const home = mkFakeHome('reconnect');
+  const port = 18301 + Math.floor(Math.random() * 400);
+  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_reconnect',
+    default_provider: 'opencode',
+    providers: {
+      opencode: {
+        provider_type: 'opencode',
+        display_name: 'OpenCode',
+        path: 'stub-opencode',
+        exec_template: 'opencode run "{task}"',
+      },
+    },
+    telemetry: false,
+  });
+  const env = daemonEnv(home);
+  const stub = new StubWsServer({ port, expectedKey: 'lk_test_e2e_reconnect' });
+  await stub.start();
+  let handshakes = 0;
+  stub.onHandshake = () => { handshakes += 1; };
+  stub.onMsg = (f) => {
+    const m = f.obj;
+    if (m && m.type === 'hello') {
+      // jawab hello.ok agar CLI menganggap setiap koneksi siap
+      stub.broadcastText(JSON.stringify({ type: 'hello.ok', ts: Date.now(), data: { key_id: 'kr', user_id: 'ur', tenant_id: 't1', telemetry_enabled: false, server_time: Date.now() } }));
+    }
+  };
+  const { proc, cap } = spawnDaemon(env, ['agent']);
+  try {
+    await until(() => handshakes >= 1, 10000, 'handshake pertama');
+    await until(() => cap.out.includes('Realtime aktif'), 5000, 'realtime aktif pertama');
+    await sleep(400);
+    stub.killAll(); // putus tanpa close frame
+    await until(() => handshakes >= 2, 12000, 'handshake kedua (reconnect)');
+    await until(() => (cap.out.match(/WS terhubung ulang/g) || []).length >= 1, 6000, 'daemon mencetak reconnect');
+    const allOut = cap.out + cap.err;
+    assert(!allOut.includes('fallback polling HTTP'), 'tanpa fallback saat reconnect sukses');
+  } finally {
+    try { await proc.finish(); } catch (e) { try { proc.kill('SIGKILL'); } catch (e2) {} }
+    await stub.stop();
+  }
+  passCount += 1;
+  console.log('    ✅ Skenario reconnect selesai');
+}
+
+// ── Skenario 4: telemetry konsent + provider add --model ──
+async function scenarioConsentAndModel() {
+  console.log('\n[4] telemetry on/off/status + provider add --model');
+  const home = mkFakeHome('consent');
+
+  // Stub HTTP di-fork jadi proses TERPISAH supaya event loop induk tetap
+  // bebas melayani saat runCli (spawnSync) memblokir — kalau in-process,
+  // request /agent/me dari CLI selalu timeout (tidak pernah dilayani).
+  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 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}`,
+    app_url: 'http://127.0.0.1',
+    key: 'lk_test_e2e_consent',
+    default_provider: null,
+    providers: {},
+  });
+
+  try {
+    setServerTelemetry(false);
+    // status: lokal false default, server false
+    let r = runCli(envA, ['telemetry', 'status']);
+    assert(r.code === 0, 'telemetry status exit 0');
+    assert(r.stdout.includes('config.telemetry = false'), 'status: lokal default OFF');
+    assert(r.stdout.includes('telemetry_enabled = false'), 'status: server flag OFF');
+    assert(r.stdout.includes('❌ tidak dikirim'), 'status: efektif tidak dikirim');
+
+    // on → config true
+    r = runCli(envA, ['telemetry', 'on']);
+    assert(r.code === 0 && r.stdout.includes('Telemetry lokal: ON'), 'telemetry on → lokalis ON');
+    assert(homeConfig(home).telemetry === true, 'config.telemetry === true tersimpan');
+
+    // server flag ON → efektif ✅
+    setServerTelemetry(true);
+    r = runCli(envA, ['telemetry', 'status']);
+    assert(r.stdout.includes('lokal ✅ · server ✅'), 'status: lokal+server ON');
+    assert(r.stdout.includes('✅ DIKIRIM'), 'status: efektif DIKIRIM');
+
+    // off → config false lagi
+    r = runCli(envA, ['telemetry', 'off']);
+    assert(r.code === 0 && r.stdout.includes('Telemetry lokal: OFF'), 'telemetry off → lokal OFF');
+    assert(homeConfig(home).telemetry === false, 'config.telemetry === false kembali');
+    r = runCli(envA, ['telemetry', 'status']);
+    assert(r.stdout.includes('❌ tidak dikirim'), 'status: efektif drei OFF lagi (server still tidak terkirim)');
+
+    // provider add --model
+    r = runCli(envA, ['provider', 'add', 'opencode', '--model', 'sonnet-test-9']);
+    assert(r.code === 0 && r.stdout.includes('Model         : sonnet-test-9'), 'provider add --model tersimpan & tampil');
+    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();
+  }
+  passCount += 1;
+  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}`);
+  scenarioSyntax();
+  await scenarioRealtime();
+  await scenarioFallback();
+  await scenarioConsentAndModel();
+  await scenarioExecMessages();
+  await scenarioAgentLifecycle();
+  await scenarioModels();
+  await scenarioWorkspace();
+  console.log(`\nSEMIUA PASS ✅ (${passCount} assertion)`);
+}
+
+main()
+  .then(() => {
+    process.exit(failCount ? 1 : 0);
+  })
+  .catch((e) => {
+    console.error(`\nE2E GAGAL ❌: ${e.message}`);
+    console.error(e.stack);
+    process.exit(1);
+  });