zelai-cli 1.1.0

package/src/cli.js

@@ -0,0 +1,563 @@
+/**
+ * Zelai CLI — main loop.
+ * Interactive REPL untuk Zelapi Agent API.
+ */
+'use strict';
+
+const readline = require('readline');
+const ora = require('ora');
+
+const config = require('./config');
+const { makeClient, LimitExceededError } = require('./client');
+const commands = require('./commands');
+const session = require('./session');
+const ui = require('./ui');
+
+const VERSION = require('../package.json').version;
+
+function parseArgv(argv) {
+  const out = { _: [], flags: {} };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--help' || a === '-h') out.flags.help = true;
+    else if (a === '--version' || a === '-v') out.flags.version = true;
+    else if (a === '--key' || a === '-k') out.flags.key = argv[++i];
+    else if (a === '--model' || a === '-m') out.flags.model = argv[++i];
+    else if (a === '--endpoint' || a === '-e') out.flags.endpoint = argv[++i];
+    else if (a === '--system' || a === '-s') out.flags.system = argv[++i];
+    else if (a === '--session') out.flags.session = argv[++i];
+    else if (a === '--no-banner') out.flags.noBanner = true;
+    else if (a === '--prompt' || a === '-p') out.flags.prompt = argv[++i];
+    else if (a === 'login') out._.push('login');
+    else if (a === 'status') out._.push('status');
+    else if (a === 'usage') out._.push('usage');
+    else if (a === 'activity' || a === 'logs') out._.push('activity');
+    else if (a === 'config') out._.push('config');
+    else if (a === 'sessions') out._.push('sessions');
+    else if (a === 'resume' || a === 'continue') {
+      out._.push('resume');
+      // optional positional arg: zelai resume <id|nomor>
+      if (argv[i + 1] && !argv[i + 1].startsWith('-')) {
+        out.flags.resumeRef = argv[++i];
+      }
+    }
+    else if (a.startsWith('-')) {
+      // unknown flag — abaikan biar friendly
+    } else out._.push(a);
+  }
+  return out;
+}
+
+function printHelp() {
+  const c = ui.chalk;
+  console.log(`
+${c.magentaBright.bold('zelai')} ${c.gray('v' + VERSION)} ${c.gray('—')} official CLI buat ${c.magenta.bold('Zelapi')} Agent API
+
+${c.bold('Usage:')}
+  ${c.cyan('zelai')}                          masuk ke chat interaktif
+  ${c.cyan('zelai -p')} ${c.gray('"<pesan>"')}            kirim satu pesan terus exit (one-shot)
+  ${c.cyan('zelai login')} ${c.gray('[zel_…]')}          set / ganti API key
+  ${c.cyan('zelai status')}                   cek status server
+  ${c.cyan('zelai usage')}                    tampilin pemakaian API key
+  ${c.cyan('zelai activity')}                 tampilin activity logs
+  ${c.cyan('zelai sessions')}                 list sesi tersimpan di ./session
+  ${c.cyan('zelai resume')} ${c.gray('[id|nomor]')}        lanjutin sesi (default: paling baru)
+  ${c.cyan('zelai config')}                   tampilin konfigurasi tersimpan
+
+${c.bold('Options:')}
+  ${c.gray('-k, --key <key>')}           pakai API key tertentu sekali jalan
+  ${c.gray('-m, --model <name>')}        opus | sonnet | haiku
+  ${c.gray('-e, --endpoint <path>')}     AI endpoint (default /ai/claila)
+  ${c.gray('-s, --system <prompt>')}     custom system prompt
+  ${c.gray('    --session <id>')}        lanjutin sesi lama
+  ${c.gray('    --no-banner')}           sembunyiin banner
+  ${c.gray('-p, --prompt <msg>')}        kirim satu pesan langsung
+  ${c.gray('-h, --help')}                tampilin pesan ini
+  ${c.gray('-v, --version')}             tampilin versi
+
+${c.bold('Inside chat:')}
+  ketik ${c.yellow('/help')} buat lihat semua slash command (${c.yellow('/status')}, ${c.yellow('/usage')}, ${c.yellow('/activity')}, ${c.yellow('/sessions')}, ${c.yellow('/load')}, …)
+
+${c.gray('Docs: https://zelapioffciall.dpdns.org')}
+`);
+}
+
+async function main(argv) {
+  const args = parseArgv(argv);
+
+  if (args.flags.help) {
+    printHelp();
+    return;
+  }
+  if (args.flags.version) {
+    console.log(`zelai v${VERSION}`);
+    return;
+  }
+
+  // Make sure session folder is ready first thing — user-requested behavior.
+  session.ensureDir();
+
+  // Load config + apply flags / env overrides.
+  let cfg = config.load();
+  if (process.env.ZELAPI_KEY && !cfg.apiKey) cfg.apiKey = process.env.ZELAPI_KEY;
+  if (args.flags.key) cfg.apiKey = args.flags.key;
+  if (args.flags.model) cfg.model = args.flags.model;
+  if (args.flags.endpoint) cfg.endpoint = args.flags.endpoint;
+  if (args.flags.system) cfg.system = args.flags.system;
+
+  const sub = args._[0];
+
+  if (sub === 'login') {
+    await runLogin(cfg, args._[1]);
+    return;
+  }
+  if (sub === 'status') {
+    const client = makeClient(cfg);
+    await runOneShot(() => commandStatus(client));
+    return;
+  }
+  if (sub === 'usage') {
+    if (!cfg.apiKey) return errorExit('Belum login. Jalanin `zelai login` dulu.');
+    const client = makeClient(cfg);
+    await runOneShot(() => commandUsage(client, cfg.apiKey));
+    return;
+  }
+  if (sub === 'activity') {
+    if (!cfg.apiKey) return errorExit('Belum login. Jalanin `zelai login` dulu.');
+    const client = makeClient(cfg);
+    await runOneShot(() => commandActivity(client, cfg.apiKey));
+    return;
+  }
+  if (sub === 'sessions') {
+    listSessions();
+    return;
+  }
+  if (sub === 'resume') {
+    // Resolve sesi yang mau di-resume:
+    //   zelai resume <id>        → load id-nya
+    //   zelai resume <nomor>     → load index dari `zelai sessions` (1-based)
+    //   zelai resume             → load sesi yang paling baru
+    const ref = args.flags.resumeRef;
+    const rows = session.list();
+    let target = null;
+    if (!ref) {
+      target = rows[0]; // paling baru
+    } else if (/^\d+$/.test(ref)) {
+      target = rows[parseInt(ref, 10) - 1];
+    } else {
+      const rec = session.load(ref);
+      target = rec ? { id: rec.id, turns: (rec.history || []).length } : null;
+    }
+    if (!target) {
+      console.log(`${ui.errorTag()} sesi "${ref || '(none)'}" gak ketemu. Coba ${ui.chalk.cyan('zelai sessions')} dulu.`);
+      process.exit(1);
+    }
+    const rec = session.load(target.id);
+    if (rec) {
+      if (rec.model) cfg.model = rec.model;
+      if (rec.endpoint) cfg.endpoint = rec.endpoint;
+      if (rec.system) cfg.system = rec.system;
+      config.update({
+        lastSession: target.id,
+        model: cfg.model,
+        endpoint: cfg.endpoint,
+        system: cfg.system,
+      });
+    }
+    args.flags.session = target.id;
+    if (!args.flags.noBanner) console.log(ui.banner());
+    console.log(`${ui.okTag()} resume sesi ${ui.chalk.cyan(target.id)} ` +
+      ui.chalk.gray(`(${(rec && rec.history && rec.history.length) || 0} pesan dimuat)`));
+    if (!cfg.apiKey) {
+      console.log(`${ui.systemTag()} login dulu yuk biar bisa lanjut chatting.`);
+      await runLogin(cfg, null);
+      cfg = config.load();
+    }
+    // skip banner di runInteractive karena udah di-print
+    const interactiveArgs = { ...args, flags: { ...args.flags, noBanner: true } };
+    await runInteractive(cfg, interactiveArgs);
+    return;
+  }
+  if (sub === 'config') {
+    const ctx = { config: cfg, sessionId: args.flags.session || cfg.lastSession || null };
+    await commands.dispatch(ctx, '/config', {});
+    return;
+  }
+
+  // Kalau belum punya API key — jalanin login interaktif dulu.
+  if (!cfg.apiKey) {
+    if (!args.flags.noBanner) console.log(ui.banner());
+    console.log(`${ui.systemTag()} kayaknya kamu belum login. Yuk masukin API key dulu.`);
+    await runLogin(cfg, null);
+    cfg = config.load();
+  }
+
+  // One-shot mode lewat -p.
+  if (args.flags.prompt) {
+    const client = makeClient(cfg);
+    const sessionId = args.flags.session || null;
+    await runPrompt(cfg, client, args.flags.prompt, sessionId);
+    return;
+  }
+
+  await runInteractive(cfg, args);
+}
+
+async function runLogin(cfg, maybeKey) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    let key = maybeKey;
+    if (!key) {
+      key = await askMasked(rl, `${ui.systemTag()} masukin API key (zel_…): `, { mask: true });
+    }
+    key = (key || '').trim();
+    if (!key) {
+      console.log(`${ui.errorTag()} API key kosong, dibatalin.`);
+      return;
+    }
+    config.update({ apiKey: key });
+    console.log(`${ui.okTag()} tersimpan di ${ui.chalk.gray(config.configPath())}`);
+  } finally {
+    rl.close();
+  }
+}
+
+async function runOneShot(fn) {
+  try {
+    await fn();
+  } catch (err) {
+    handleError(err);
+    process.exit(1);
+  }
+}
+
+async function commandStatus(client) {
+  const spinner = ora({ text: 'ngecek status…', color: 'cyan' }).start();
+  try {
+    const data = await client.getStatus();
+    spinner.stop();
+    console.log(ui.pretty(data));
+  } catch (err) {
+    spinner.stop();
+    throw err;
+  }
+}
+
+async function commandUsage(client, key) {
+  const spinner = ora({ text: 'narik usage…', color: 'cyan' }).start();
+  try {
+    const data = await client.getUsage(key);
+    spinner.stop();
+    console.log(ui.pretty(data));
+  } catch (err) {
+    spinner.stop();
+    throw err;
+  }
+}
+
+async function commandActivity(client, key) {
+  const spinner = ora({ text: 'narik activity logs…', color: 'cyan' }).start();
+  try {
+    const data = await client.getActivityLogs(key);
+    spinner.stop();
+    console.log(ui.pretty(data));
+  } catch (err) {
+    spinner.stop();
+    throw err;
+  }
+}
+
+function listSessions() {
+  const rows = session.list();
+  console.log(ui.hr());
+  console.log(ui.chalk.bold('Sessions tersimpan'));
+  console.log(ui.chalk.gray('dir: ' + session.sessionDir()));
+  if (rows.length === 0) {
+    console.log(ui.chalk.gray('(belum ada sesi)'));
+    console.log(ui.hr());
+    return;
+  }
+  rows.forEach((r, i) => {
+    const when = r.updatedAt ? new Date(r.updatedAt).toISOString().replace('T', ' ').slice(0, 19) : '—';
+    console.log(
+      ui.chalk.gray(`#${String(i + 1).padStart(2)} `) +
+      ui.chalk.cyan(r.id.padEnd(28)) +
+      ui.chalk.gray(' · ') +
+      ui.chalk.gray(`${String(r.turns).padStart(3)} turns`) +
+      ui.chalk.gray(' · ') +
+      ui.chalk.gray(when) +
+      (r.preview ? ui.chalk.gray('  — ' + r.preview) : '')
+    );
+  });
+  console.log(ui.hr());
+}
+
+async function runPrompt(cfg, client, prompt, sessionId) {
+  const spinner = ora({ text: ' mikir…', color: 'magenta' }).start();
+  try {
+    const res = await client.sendAgent({
+      messages: [{ role: 'user', content: prompt }],
+      model: cfg.model,
+      endpoint: cfg.endpoint,
+      system: cfg.system,
+      sessionId: sessionId || null,
+    });
+    spinner.stop();
+    console.log(ui.renderMarkdown(res.reply || '(gak ada balasan)'));
+
+    const sid = res.sessionId || sessionId || session.localId();
+    session.append(sid, { role: 'user', content: prompt }, {
+      model: cfg.model, endpoint: cfg.endpoint, system: cfg.system,
+    });
+    session.append(sid, { role: 'assistant', content: res.reply || '' });
+    if (sessionId && res.sessionId && sessionId !== res.sessionId) {
+      session.rename(sessionId, res.sessionId);
+    }
+    config.update({ lastSession: sid });
+    console.log(ui.chalk.gray(`\nsession: ${sid}`));
+  } catch (err) {
+    spinner.stop();
+    handleError(err);
+    process.exit(1);
+  }
+}
+
+async function runInteractive(cfg, args) {
+  if (!args.flags.noBanner) {
+    console.log(ui.banner());
+  }
+
+  const client = makeClient(cfg);
+  const ctx = {
+    config: cfg,
+    client,
+    history: [],
+    sessionId: args.flags.session || cfg.lastSession || null,
+    rl: null,
+  };
+
+  // Auto-reload history dari file sesi sebelumnya kalau ada.
+  if (ctx.sessionId) {
+    const rec = session.load(ctx.sessionId);
+    if (rec && Array.isArray(rec.history) && rec.history.length > 0) {
+      ctx.history = rec.history.map(({ role, content }) => ({ role, content }));
+      console.log(`${ui.infoTag()} lanjutin sesi ${ui.chalk.cyan(ctx.sessionId)} ` +
+        ui.chalk.gray(`(${rec.history.length} pesan dimuat dari ./session)`));
+    } else {
+      console.log(`${ui.infoTag()} pakai session id ${ui.chalk.cyan(ctx.sessionId)} ${ui.chalk.gray('(belum ada history lokal)')}`);
+    }
+  }
+
+  // Optional: warn early kalau quota deket habis (best-effort, gak nge-block).
+  warnQuotaSoft(client, cfg.apiKey).catch(() => {});
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    historySize: 200,
+    terminal: true,
+  });
+  ctx.rl = rl;
+
+  const helpers = {
+    ask: (q, opts) => askMasked(rl, q, opts),
+  };
+
+  const promptFn = () => {
+    rl.setPrompt(ui.userPrompt(ctx.config.model));
+    rl.prompt();
+  };
+
+  rl.on('SIGINT', () => {
+    console.log(`\n${ui.infoTag()} pakai ${ui.chalk.yellow('/exit')} buat keluar, atau Ctrl+D.`);
+    promptFn();
+  });
+
+  rl.on('close', () => {
+    console.log(`\n${ui.infoTag()} bye! 👋`);
+    process.exit(0);
+  });
+
+  promptFn();
+
+  rl.on('line', async (raw) => {
+    const line = raw.replace(/\r$/, '').trim();
+    if (!line) {
+      promptFn();
+      return;
+    }
+
+    if (line.startsWith('/')) {
+      try {
+        const handled = await commands.dispatch(ctx, line, helpers);
+        if (!handled) {
+          await handleChat(ctx, line);
+        }
+      } catch (err) {
+        handleError(err);
+      }
+      promptFn();
+      return;
+    }
+
+    try {
+      await handleChat(ctx, line);
+    } catch (err) {
+      handleError(err);
+    }
+    promptFn();
+  });
+}
+
+async function handleChat(ctx, content) {
+  ctx.history.push({ role: 'user', content });
+
+  // Strategi: kalau ada session id, kirim cuma user message terbaru — server
+  // yang ngurus history. Kalau belum, sertain tail history terakhir biar AI
+  // tetap punya konteks.
+  let messages;
+  if (ctx.sessionId) {
+    messages = [{ role: 'user', content }];
+  } else {
+    messages = ctx.history.slice(-12);
+  }
+
+  const spinner = ora({ text: ' mikir…', color: 'magenta' }).start();
+  let res;
+  try {
+    res = await ctx.client.sendAgent({
+      messages,
+      model: ctx.config.model,
+      endpoint: ctx.config.endpoint,
+      system: ctx.config.system,
+      sessionId: ctx.sessionId,
+    });
+  } catch (err) {
+    spinner.stop();
+    ctx.history.pop();
+    throw err;
+  }
+  spinner.stop();
+
+  const reply = res.reply || '(gak ada balasan)';
+  ctx.history.push({ role: 'assistant', content: reply });
+
+  // Persist ke ./session/<id>.json
+  const previousId = ctx.sessionId;
+  const newId = res.sessionId || ctx.sessionId || session.localId();
+  if (previousId && res.sessionId && previousId !== res.sessionId) {
+    session.rename(previousId, res.sessionId);
+  }
+  ctx.sessionId = newId;
+  session.append(newId, { role: 'user', content }, {
+    model: ctx.config.model,
+    endpoint: ctx.config.endpoint,
+    system: ctx.config.system,
+  });
+  session.append(newId, { role: 'assistant', content: reply });
+  config.update({ lastSession: newId });
+
+  console.log(`${ui.assistantTag(ctx.config.model)}`);
+  console.log(ui.renderMarkdown(reply));
+}
+
+async function warnQuotaSoft(client, apiKey) {
+  if (!apiKey) return;
+  let usage;
+  try {
+    usage = await client.getUsage(apiKey);
+  } catch {
+    return; // soft check — diem aja kalau error
+  }
+  const info = extractQuotaInfo(usage);
+  if (!info) return;
+  if (info.exhausted) {
+    console.log(ui.limitWarning(info));
+    return;
+  }
+  if (info.used !== undefined && info.limit && info.limit > 0) {
+    const ratio = info.used / info.limit;
+    if (ratio >= 0.9) {
+      console.log(`${ui.warnTag()} pemakaian udah ${(ratio * 100).toFixed(0)}% (${info.used}/${info.limit}). Hati-hati ya.`);
+    }
+  }
+}
+
+function extractQuotaInfo(data) {
+  if (!data || typeof data !== 'object') return null;
+  const root = data.data && typeof data.data === 'object' ? data.data : data;
+  const used = num(root.used) ?? num(root.usage) ?? num(root.count) ?? num(root.requests);
+  const limit = num(root.limit) ?? num(root.quota) ?? num(root.max);
+  const plan = root.plan || root.tier;
+  const resetAt = root.reset || root.resetAt || root.resets_at;
+  const exhausted = root.exhausted === true
+    || (used !== undefined && limit !== undefined && used >= limit && limit > 0);
+  if (used === undefined && limit === undefined && !exhausted) return null;
+  return { used, limit, plan, resetAt, exhausted };
+}
+
+function num(v) {
+  if (v === undefined || v === null || v === '') return undefined;
+  const n = typeof v === 'number' ? v : parseFloat(v);
+  return Number.isFinite(n) ? n : undefined;
+}
+
+function handleError(err) {
+  if (err instanceof LimitExceededError) {
+    console.log(ui.limitWarning(err.info || {}));
+    return;
+  }
+  console.log(`${ui.errorTag()} ${err.message}`);
+  if (process.env.ZELAI_DEBUG && err.stack) {
+    console.log(ui.chalk.gray(err.stack));
+  }
+}
+
+/**
+ * readline `question` dengan optional masking buat API key.
+ */
+function askMasked(rl, prompt, opts = {}) {
+  return new Promise((resolve) => {
+    if (!opts.mask) {
+      rl.question(prompt, (ans) => resolve(ans));
+      return;
+    }
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    stdout.write(prompt);
+    let buf = '';
+    const onData = (chunk) => {
+      const s = chunk.toString('utf8');
+      for (const ch of s) {
+        if (ch === '\n' || ch === '\r') {
+          stdin.removeListener('data', onData);
+          stdout.write('\n');
+          resolve(buf);
+          return;
+        }
+        if (ch === '') { // Ctrl+C
+          stdin.removeListener('data', onData);
+          stdout.write('\n');
+          process.exit(130);
+        }
+        if (ch === '' || ch === '\b') {
+          if (buf.length > 0) {
+            buf = buf.slice(0, -1);
+            stdout.write('\b \b');
+          }
+          continue;
+        }
+        buf += ch;
+        stdout.write('•');
+      }
+    };
+    stdin.on('data', onData);
+  });
+}
+
+function errorExit(msg) {
+  console.log(`${ui.errorTag()} ${msg}`);
+  process.exit(1);
+}
+
+module.exports = { main };