luang-cli 0.0.0-stage → 0.1.0

package/lib/core.js

@@ -0,0 +1,442 @@
+'use strict';
+
+// lib/core.js — konfigurasi lokal, state, HTTP helper, util format,
+// banner ASCII, dan deteksi provider. Tanpa dependensi npm (Node >= 18).
+
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+// ── Lokasi file ──────────────────────────────────────────────────────────────
+
+const CONFIG_DIR = path.join(os.homedir(), '.luang-cli');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const STATE_FILE = path.join(CONFIG_DIR, 'state.json');
+
+const DEFAULT_CONFIG = {
+  api_url: 'https://api.luang.id',
+  app_url: 'https://app.luang.id',
+  key: null,
+  default_provider: null,
+  providers: {},
+};
+
+// ── Config ───────────────────────────────────────────────────────────────────
+
+function loadConfig() {
+  const cfg = JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      const raw = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+      if (raw && typeof raw === 'object') {
+        for (const k of Object.keys(DEFAULT_CONFIG)) {
+          if (raw[k] !== undefined) cfg[k] = raw[k];
+        }
+        if (!cfg.providers || typeof cfg.providers !== 'object') cfg.providers = {};
+      }
+    }
+  } catch (e) {
+    // config rusak → pakai default, jangan crash
+  }
+  return cfg;
+}
+
+function saveConfig(cfg) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  const clean = { ...DEFAULT_CONFIG, ...cfg };
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(clean, null, 2) + '\n');
+}
+
+// ── State daemon ─────────────────────────────────────────────────────────────
+
+function loadState() {
+  const st = { tasks: {}, executed: {} };
+  try {
+    if (fs.existsSync(STATE_FILE)) {
+      const raw = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+      if (raw && typeof raw === 'object') {
+        if (raw.tasks && typeof raw.tasks === 'object') st.tasks = raw.tasks;
+        if (raw.executed && typeof raw.executed === 'object') st.executed = raw.executed;
+      }
+    }
+  } catch (e) {
+    // state rusak → mulai kosong
+  }
+  return st;
+}
+
+function saveState(st) {
+  const s = st && typeof st === 'object' && !Array.isArray(st) ? st : { tasks: {} , executed: {} };
+  if (!s.tasks || typeof s.tasks !== 'object') s.tasks = {};
+  if (!s.executed || typeof s.executed !== 'object') s.executed = {};
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(STATE_FILE, JSON.stringify(s, null, 2) + '\n');
+}
+
+// ── Resolusi runtime (flag --api / env / config) ─────────────────────────────
+
+function resolveRuntime(cfg, flags) {
+  const f = flags || {};
+  const apiUrl = (f.api && String(f.api)) || process.env.LUANG_API_URL || cfg.api_url || DEFAULT_CONFIG.api_url;
+  const appUrl = process.env.LUANG_APP_URL || cfg.app_url || DEFAULT_CONFIG.app_url;
+  const key = process.env.LUANG_KEY || cfg.key || null;
+  return { cfg, apiUrl, appUrl, key };
+}
+
+// ── HTTP helper ──────────────────────────────────────────────────────────────
+
+class ApiError extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.name = 'ApiError';
+    this.status = status || 0;
+    this.body = body || null;
+  }
+}
+
+function shortBase(url) {
+  try {
+    return new URL(url).origin;
+  } catch (e) {
+    return url;
+  }
+}
+
+function extractErr(body, status, rawText) {
+  let msg = null;
+  if (body && typeof body === 'object') {
+    // error | message dari envelope; title utk badan error ala Cloudflare
+    msg = body.error || body.message || body.title || null;
+    if (msg && body.detail && typeof body.detail === 'string' && !String(msg).includes(body.detail)) {
+      msg += ` (${String(body.detail).replace(/\s+/g, ' ').trim().slice(0, 200)})`;
+    } else if (!msg && Array.isArray(body.detail)) {
+      msg = 'Data tidak valid (validation error)';
+    }
+  }
+  if (!msg) msg = status ? `Permintaan gagal (HTTP ${status})` : 'Permintaan gagal';
+  // Jangan bungkam bocor server: bila body non-JSON, tampilkan sebagian isi aslinya.
+  if (!body && rawText && typeof rawText === 'string') {
+    const snippet = rawText.replace(/\s+/g, ' ').trim().slice(0, 160);
+    if (snippet) msg += ` — ${snippet}`;
+  }
+  return msg;
+}
+
+async function httpJson(url, { method = 'GET', body, key, timeoutMs = 15000 } = {}) {
+  const headers = { Accept: 'application/json' };
+  if (key) headers['X-CLI-Key'] = key;
+  if (body !== undefined) headers['Content-Type'] = 'application/json';
+
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  let res;
+  let text;
+  try {
+    const opts = { method, headers, signal: ctrl.signal };
+    if (body !== undefined) opts.body = JSON.stringify(body);
+    res = await fetch(url, opts);
+    text = await res.text();
+  } catch (e) {
+    const aborted = e && (e.name === 'AbortError' || String(e.message || '').includes('aborted'));
+    if (aborted) throw new ApiError(`Waktu habis (timeout ${timeoutMs / 1000} s) menghubungi ${shortBase(url)}`, 0, null);
+    throw new ApiError(`Tidak bisa terhubung ke ${shortBase(url)} → ${e.message}`, 0, null);
+  } finally {
+    clearTimeout(timer);
+  }
+
+  let parsed = null;
+  try {
+    parsed = text ? JSON.parse(text) : null;
+  } catch (e) {
+    parsed = null;
+  }
+
+  const status = res.status;
+  if (!res.ok) throw new ApiError(extractErr(parsed, status, text), status, parsed);
+  if (parsed && parsed.success === false) throw new ApiError(extractErr(parsed, status, text), status, parsed);
+  if (parsed === null && status === 204) parsed = { success: true, data: null };
+  if (parsed === null && text && status >= 200 && status < 300) parsed = { success: true, data: text };
+  return parsed;
+}
+
+function buildApiUrl(apiBaseUrl, pathUrl, query) {
+  const base = String(apiBaseUrl || '').replace(/\/+$/, '');
+  const p = pathUrl.startsWith('/') ? pathUrl : '/' + pathUrl;
+  let url = base + p;
+  if (query) {
+    const qs = Object.entries(query)
+      .filter(([, v]) => v !== undefined && v !== null && v !== '')
+      .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`)
+      .join('&');
+    if (qs) url += `?${qs}`;
+  }
+  return url;
+}
+
+async function apiRequest(rt, method, pathUrl, { body, query } = {}) {
+  return httpJson(buildApiUrl(rt.apiUrl, pathUrl, query), { method, body, key: rt.key || undefined });
+}
+
+// ── Util tampilan ────────────────────────────────────────────────────────────
+
+function trunc(s, n) {
+  s = String(s === null || s === undefined ? '' : s);
+  return s.length > n ? s.slice(0, Math.max(1, n - 1)) + '…' : s;
+}
+
+function keyPrefix(key) {
+  if (!key) return '(tidak ada)';
+  return key.length > 9 ? key.slice(0, 9) + '…' : key;
+}
+
+function fmtWhen(iso) {
+  if (!iso) return '-';
+  const d = new Date(iso);
+  if (isNaN(d.getTime())) return String(iso);
+  const diff = Date.now() - d.getTime();
+  if (diff < 45e3) return 'baru saja';
+  const m = Math.round(diff / 60e3);
+  if (m < 60) return `${m}m lalu`;
+  const h = Math.round(m / 60);
+  if (h < 24) return `${h}j lalu`;
+  const dd = Math.round(h / 24);
+  if (dd < 30) return `${dd}d lalu`;
+  return d.toISOString().slice(0, 10);
+}
+
+function printTable(headers, rows) {
+  const widths = headers.map((h, i) =>
+    Math.max(String(h).length, ...rows.map((r) => String(r[i] === null || r[i] === undefined ? '' : r[i]).length))
+  );
+  const fmt = (r) =>
+    r
+      .map((c, i) => String(c === null || c === undefined ? '' : c).padEnd(widths[i], ' '))
+      .join('  ')
+      .replace(/\s+$/, '');
+  console.log(fmt(headers));
+  console.log(fmt(widths.map((w) => '─'.repeat(w))));
+  for (const r of rows) console.log(fmt(r));
+}
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// ── Banner ASCII (font blok sederhana 4×5, 1 = blok) ─────────────────────────
+
+const BIG_FONT = {
+  A: '0110 1001 1111 1001 1001',
+  B: '1110 1001 1110 1001 1110',
+  C: '0111 1000 1000 1000 0111',
+  D: '1110 1001 1001 1001 1110',
+  E: '1111 1000 1110 1000 1111',
+  F: '1111 1000 1110 1000 1000',
+  G: '0111 1000 1011 1001 0111',
+  H: '1001 1001 1111 1001 1001',
+  I: '0111 0010 0010 0010 0111',
+  J: '0011 0001 0001 1001 0110',
+  K: '1001 1010 1100 1010 1001',
+  L: '1000 1000 1000 1000 1111',
+  M: '1001 1111 1111 1001 1001',
+  N: '1001 1101 1011 1001 1001',
+  O: '0110 1001 1001 1001 0110',
+  P: '1110 1001 1110 1000 1000',
+  Q: '0110 1001 1001 0110 0001',
+  R: '1110 1001 1110 1010 1001',
+  S: '0111 1000 0110 0001 1110',
+  T: '1111 0010 0010 0010 0010',
+  U: '1001 1001 1001 1001 0110',
+  V: '1001 1001 1001 0110 0110',
+  W: '1001 1001 1111 1111 1001',
+  X: '1001 1001 0110 1001 1001',
+  Y: '1001 1001 0110 0010 0010',
+  Z: '1111 0001 0110 0100 1111',
+  0: '0110 1011 1101 1001 0110',
+  1: '0010 0110 0010 0010 0111',
+  2: '0111 0001 0110 1000 1111',
+  3: '0111 0001 0110 0001 0111',
+  4: '1001 1001 1111 0001 0001',
+  5: '1111 1000 1110 0001 1110',
+  6: '0111 1000 1110 1001 0111',
+  7: '1111 0001 0010 0100 0100',
+  8: '0110 1001 0110 1001 0110',
+  9: '0110 1001 0111 0001 1110',
+  '-': '0000 0000 0111 0000 0000',
+  ' ': '0000 0000 0000 0000 0000',
+};
+
+function bigBanner(text) {
+  const rows = ['', '', '', '', ''];
+  for (const ch of String(text).toUpperCase()) {
+    const glyph = BIG_FONT[ch] || BIG_FONT[' '];
+    glyph.split(' ').forEach((row, i) => {
+      rows[i] += row.replace(/1/g, '█').replace(/0/g, ' ');
+    });
+    rows.forEach((v, i) => {
+      rows[i] = v + '  ';
+    });
+  }
+  return rows.map((r) => '  ' + r.replace(/\s+$/, '')).join('\n');
+}
+
+function printBigCode(code) {
+  const art = bigBanner(code).split('\n');
+  const w = Math.max(...art.map((l) => l.length));
+  const bar = '  ' + '─'.repeat(w - 2);
+  console.log('');
+  console.log(bar);
+  console.log(art.join('\n'));
+  console.log(bar);
+  console.log('');
+}
+
+// ── Provider CLI: deteksi otomatis, config, heartbeat ────────────────────────
+
+const PROVIDER_TYPES = ['claude_code', 'codex', 'opencode', 'gemini_cli'];
+
+const DISPLAY_NAMES = {
+  claude_code: 'Claude Code',
+  codex: 'Codex',
+  opencode: 'OpenCode',
+  gemini_cli: 'Gemini CLI',
+};
+
+const DEFAULT_TEMPLATES = {
+  claude_code: 'claude -p "{task}"',
+  codex: 'codex exec "{task}"',
+  opencode: 'opencode run "{task}"',
+  gemini_cli: 'gemini -p "{task}"',
+};
+
+const PROVIDER_DETECTORS = [
+  { type: 'claude_code', dirs: ['.claude'], bin: 'claude' },
+  { type: 'codex', dirs: ['.codex'], bin: 'codex' },
+  { type: 'opencode', dirs: ['.config/opencode', '.opencode'], bin: 'opencode' },
+  { type: 'gemini_cli', dirs: ['.gemini'], bin: 'gemini' },
+];
+
+function whichBin(bin) {
+  const isWin = process.platform === 'win32';
+  try {
+    const r = spawnSync(isWin ? 'where' : 'which', [bin], { encoding: 'utf8', timeout: 4000 });
+    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;
+}
+
+function detectProviders() {
+  const home = os.homedir();
+  const found = [];
+  for (const d of PROVIDER_DETECTORS) {
+    const cfgDir = d.dirs.map((x) => path.join(home, x)).find((p) => fs.existsSync(p));
+    const binPath = whichBin(d.bin);
+    if (!cfgDir && !binPath) continue;
+    const p = {
+      provider_type: d.type,
+      display_name: DISPLAY_NAMES[d.type],
+      path: binPath || cfgDir,
+      exec_template: DEFAULT_TEMPLATES[d.type],
+      detected: true,
+    };
+    if (binPath && cfgDir) p.config_dir = cfgDir;
+    found.push(p);
+  }
+  return found;
+}
+
+// Cache in-process: jangan jalankan `--version` berulang di tiap heartbeat (murah & sesuai spec).
+const _versionCache = new Map();
+
+function probeVersion(execPath) {
+  if (!execPath) return null;
+  if (_versionCache.has(execPath)) return _versionCache.get(execPath);
+  let out = null;
+  try {
+    const r = spawnSync(execPath, ['--version'], { encoding: 'utf8', timeout: 3000 });
+    const line = String((r.stdout || r.stderr || '')).trim().split(/\r?\n/)[0];
+    out = (r.status === 0 && line) ? line.slice(0, 32) : null;
+  } catch (e) {
+    out = null;
+  }
+  _versionCache.set(execPath, out);
+  return out;
+}
+
+// Gabung deteksi lokal + config tersimpan (config menang).
+function collectProviders(cfg) {
+  const map = new Map();
+  for (const p of detectProviders()) map.set(p.provider_type, { ...p });
+  for (const [type, p] of Object.entries(cfg.providers || {})) {
+    const base = map.get(type) || {
+      provider_type: type,
+      display_name: DISPLAY_NAMES[type] || type,
+      path: null,
+      exec_template: DEFAULT_TEMPLATES[type] || null,
+    };
+    map.set(type, { ...base, ...p, provider_type: type });
+  }
+  for (const p of map.values()) p.is_default = p.provider_type === cfg.default_provider;
+  return [...map.values()];
+}
+
+function heartbeatProviders(list) {
+  return list.map((p) => ({
+    provider_type: p.provider_type,
+    display_name: p.display_name || p.provider_type,
+    path: p.path || null,
+    exec_template: p.exec_template || null,
+    version: probeVersion(p.path),
+  }));
+}
+
+// ── Buka browser (fail aman) ─────────────────────────────────────────────────
+
+function openBrowser(url) {
+  if (process.env.LUANG_NO_OPEN) return false; // seam uji/otomasi: jangan buka browser, cukup cetak URL
+  try {
+    const { spawn } = require('child_process');
+    const plat = process.platform;
+    const cmd = plat === 'darwin' ? 'open' : plat === 'win32' ? 'cmd' : 'xdg-open';
+    const args = plat === 'win32' ? ['/c', 'start', '', url] : [url];
+    spawn(cmd, args, { detached: true, stdio: 'ignore', shell: plat === 'win32' }).unref();
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+module.exports = {
+  CONFIG_DIR,
+  CONFIG_FILE,
+  STATE_FILE,
+  DEFAULT_CONFIG,
+  PROVIDER_TYPES,
+  DISPLAY_NAMES,
+  DEFAULT_TEMPLATES,
+  loadConfig,
+  saveConfig,
+  loadState,
+  saveState,
+  resolveRuntime,
+  ApiError,
+  httpJson,
+  buildApiUrl,
+  apiRequest,
+  trunc,
+  keyPrefix,
+  fmtWhen,
+  printTable,
+  sleep,
+  bigBanner,
+  printBigCode,
+  whichBin,
+  detectProviders,
+  probeVersion,
+  collectProviders,
+  heartbeatProviders,
+  openBrowser,
+};

package/package.json

@@ -1,6 +1,19 @@
 {
   "name": "luang-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "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"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "luang",
+    "agent",
+    "orchestration",
+    "task",
+    "cli"
+  ]
+}