@ryuu-reinzz/ryuu-cli 0.5.0 → 0.5.1

package/plugins/github/api.js

@@ -0,0 +1,78 @@
+import { GitHubPluginError, GITHUB_CODES } from './errors.js';
+
+/**
+ * Klien GitHub API sisi plugin.
+ *
+ * CLI tidak memegang access token, jadi setiap panggilan diteruskan ke backend
+ * (Integration Gateway) yang memasang token pengguna. Antarmuka sengaja dibuat
+ * mirip REST GitHub agar tools mudah dibaca.
+ */
+export class GitHubApi {
+  constructor({ backend, logger = null } = {}) {
+    if (!backend) throw new Error('GitHubApi membutuhkan backend client.');
+    this.backend = backend;
+    this.logger = logger;
+  }
+
+  async request(method, path, { query = null, body = undefined } = {}) {
+    const { data } = await this.backend.proxy(method, path, { query, body });
+    return data;
+  }
+
+  get(path, query = null) {
+    return this.request('GET', path, { query });
+  }
+
+  post(path, body = undefined, query = null) {
+    return this.request('POST', path, { body, query });
+  }
+
+  patch(path, body = undefined) {
+    return this.request('PATCH', path, { body });
+  }
+
+  put(path, body = undefined) {
+    return this.request('PUT', path, { body });
+  }
+
+  delete(path, body = undefined) {
+    return this.request('DELETE', path, { body });
+  }
+
+  /**
+   * Ambil beberapa halaman berturut-turut. Backend meneruskan header `Link`
+   * GitHub lewat `x-github-link`, sehingga CLI tahu kapan harus berhenti.
+   */
+  async paginate(path, { query = {}, perPage = 30, maxPages = 5, maxItems = 100 } = {}) {
+    const items = [];
+    let page = 1;
+    let pages = 0;
+    while (items.length < maxItems && pages < maxPages) {
+      pages += 1;
+      const { data, nextPage } = await this.backend.proxy('GET', path, {
+        query: { ...query, per_page: perPage, page },
+      });
+      if (!Array.isArray(data)) break;
+      items.push(...data.slice(0, Math.max(0, maxItems - items.length)));
+      if (!nextPage) break;
+      page += 1;
+    }
+    return items;
+  }
+
+  /** Cek kuota GitHub. */
+  async rateLimit() {
+    return this.get('/rate_limit');
+  }
+}
+
+/** Bungkus error jaringan/HTTP agar pesan ke pengguna konsisten. */
+export function describeApiError(error) {
+  if (error instanceof GitHubPluginError) return error;
+  const status = Number(error?.status || 0);
+  return new GitHubPluginError(error?.message || 'Permintaan GitHub gagal.', {
+    code: status === 429 ? GITHUB_CODES.RATE_LIMIT : GITHUB_CODES.API,
+    status,
+    retryable: status === 429 || status >= 500,
+  });
+}

package/plugins/github/auth.js

@@ -0,0 +1,45 @@
+import { spawn } from 'node:child_process';
+
+/**
+ * Pembantu autentikasi sisi CLI. Tidak ada kredensial di sini: OAuth,
+ * penukaran kode, refresh, dan revoke seluruhnya dikerjakan backend.
+ */
+
+/** Buka browser default; `false` bila tidak ada opener yang tersedia. */
+export function openBrowser(url) {
+  const target = String(url);
+  const attempts =
+    process.platform === 'darwin'
+      ? [['open', [target]]]
+      : process.platform === 'win32'
+        ? [['cmd', ['/c', 'start', '', target]]]
+        : [
+            ['xdg-open', [target]],
+            ['sensible-browser', [target]],
+            ['gio', ['open', target]],
+          ];
+  for (const [command, args] of attempts) {
+    try {
+      const child = spawn(command, args, { stdio: 'ignore', detached: true });
+      child.on('error', () => {});
+      child.unref();
+      return true;
+    } catch {
+      // Coba opener berikutnya.
+    }
+  }
+  return false;
+}
+
+/** Pesan kegagalan login yang ramah dan tidak membocorkan apa pun. */
+export function describeLoginFailure(error) {
+  const status = Number(error?.status || 0);
+  const code = String(error?.code || '');
+  if (code === 'GITHUB_LOGIN_TIMEOUT' || code === 'GITHUB_SESSION') return error.message;
+  if (status === 401) return 'Backend menolak sesi login. Jalankan /github login lagi.';
+  if (status === 403) return 'Otorisasi ditolak atau dibatasi oleh GitHub.';
+  if (status === 410 || code === 'GITHUB_SESSION') return 'Sesi login sudah kedaluwarsa. Jalankan /github login lagi.';
+  if (status >= 500) return 'Backend integrasi GitHub sedang bermasalah. Coba lagi nanti.';
+  if (status === 0) return 'Tidak dapat menghubungi backend integrasi GitHub. Periksa koneksi internet.';
+  return error?.message || 'Login GitHub gagal.';
+}

package/plugins/github/backend.js

@@ -0,0 +1,191 @@
+import { GitHubPluginError, GITHUB_CODES } from './errors.js';
+import { GITHUB_BACKEND_URL } from './config.js';
+
+/**
+ * Klien backend integrasi GitHub.
+ *
+ * Backend adalah satu-satunya pemegang Client Secret, Private Key, dan token
+ * pengguna. CLI hanya memegang `cliToken` (per akun, diterbitkan setelah OAuth
+ * berhasil) yang dikirim sebagai Bearer pada endpoint terautentikasi.
+ */
+export const GITHUB_API_PREFIX = '/integrations/github';
+
+const RETRYABLE_STATUS = new Set([429, 500, 502, 503, 504]);
+
+export class GitHubBackendClient {
+  constructor({
+    baseUrl = GITHUB_BACKEND_URL,
+    getToken = () => null,
+    fetchImpl = null,
+    logger = null,
+    timeoutMs = 20_000,
+  } = {}) {
+    this.baseUrl = String(baseUrl || GITHUB_BACKEND_URL).replace(/\/+$/, '');
+    this.getToken = getToken;
+    this.fetchImpl = fetchImpl || fetch;
+    this.logger = logger;
+    this.timeoutMs = timeoutMs;
+  }
+
+  endpoint(path) {
+    return `${this.baseUrl}${GITHUB_API_PREFIX}${path}`;
+  }
+
+  async request(path, { method = 'GET', body = undefined, auth = true, headers = {}, timeoutMs = null } = {}) {
+    const token = auth ? this.getToken() : null;
+    if (auth && !token) {
+      throw new GitHubPluginError('Belum login ke GitHub. Jalankan /github login.', {
+        code: GITHUB_CODES.UNAUTHORIZED,
+        status: 401,
+        reconnect: true,
+      });
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs || this.timeoutMs);
+    timer.unref?.();
+    let response;
+    try {
+      response = await this.fetchImpl(this.endpoint(path), {
+        method,
+        headers: {
+          accept: 'application/json',
+          ...(body !== undefined ? { 'content-type': 'application/json' } : {}),
+          ...(token ? { authorization: `Bearer ${token}` } : {}),
+          ...headers,
+        },
+        ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+        signal: controller.signal,
+      });
+    } catch (error) {
+      throw new GitHubPluginError(
+        typeof error?.code === 'string' && error.code.startsWith('E')
+          ? 'Tidak dapat menghubungi backend integrasi GitHub (masalah jaringan).'
+          : 'Backend integrasi GitHub tidak merespons. Coba lagi.',
+        {
+          code: GITHUB_CODES.BACKEND_UNREACHABLE,
+          status: 0,
+          retryable: true,
+          details: error instanceof Error ? error.message : null,
+        },
+      );
+    } finally {
+      clearTimeout(timer);
+    }
+
+    const text = await response.text();
+    let parsed = null;
+    try {
+      parsed = text ? JSON.parse(text) : null;
+    } catch {
+      parsed = null;
+    }
+    const result = parsed && typeof parsed === 'object' && 'result' in parsed ? parsed.result : parsed;
+    if (!response.ok || parsed?.success === false) {
+      const message =
+        (result && typeof result === 'object' && (result.message || result.error)) ||
+        (typeof result === 'string' ? result : '') ||
+        `Backend menjawab HTTP ${response.status}`;
+      throw new GitHubPluginError(message, {
+        code:
+          (result && typeof result === 'object' && result.code) ||
+          (response.status === 429 ? GITHUB_CODES.RATE_LIMIT : GITHUB_CODES.BACKEND),
+        status: response.status,
+        retryable: RETRYABLE_STATUS.has(response.status),
+        reconnect: Boolean(result && typeof result === 'object' && result.reconnect),
+        details: result && typeof result === 'object' ? result.details || result.missing || null : null,
+      });
+    }
+    return { result: result ?? {}, headers: response.headers, status: response.status };
+  }
+
+  async startSession({ label = null, loginHint = null } = {}) {
+    const { result } = await this.request('/connect', {
+      method: 'POST',
+      auth: false,
+      body: { ...(label ? { label } : {}), ...(loginHint ? { loginHint } : {}) },
+    });
+    if (!result.sessionId || !result.pairingSecret || !result.url) {
+      throw new GitHubPluginError('Backend tidak mengembalikan sesi login yang valid.', {
+        code: GITHUB_CODES.SESSION,
+        status: 502,
+      });
+    }
+    return result;
+  }
+
+  async pollSession({ sessionId, pairingSecret }) {
+    const { result } = await this.request(`/session/${encodeURIComponent(sessionId)}`, {
+      auth: false,
+      headers: { 'x-ryuu-pairing': pairingSecret },
+      timeoutMs: 15_000,
+    });
+    return result;
+  }
+
+  async startDevice() {
+    const { result } = await this.request('/device/start', { method: 'POST', auth: false });
+    if (!result.sessionId || !result.pairingSecret || !result.userCode) {
+      throw new GitHubPluginError('Backend tidak mengembalikan kode device flow yang valid.', {
+        code: GITHUB_CODES.SESSION,
+        status: 502,
+      });
+    }
+    return result;
+  }
+
+  async pollDevice({ sessionId, pairingSecret }) {
+    const { result } = await this.request('/device/poll', {
+      method: 'POST',
+      auth: false,
+      body: { sessionId, pairingSecret },
+      timeoutMs: 20_000,
+    });
+    return result;
+  }
+
+  async status() {
+    return (await this.request('/status')).result;
+  }
+
+  async account() {
+    return (await this.request('/account')).result;
+  }
+
+  async test() {
+    return (await this.request('/test', { method: 'POST' })).result;
+  }
+
+  async refresh() {
+    return (await this.request('/refresh', { method: 'POST' })).result;
+  }
+
+  async disconnect() {
+    return (await this.request('/disconnect', { method: 'POST' })).result;
+  }
+
+  async setEnabled(enabled) {
+    return (await this.request(enabled ? '/enable' : '/disable', { method: 'POST' })).result;
+  }
+
+  /**
+   * Proxy ke GitHub REST. Backend memasang token pengguna; CLI tidak pernah
+   * melihat token tersebut. `nextPage` berasal dari header Link yang diteruskan
+   * backend sebagai `x-github-link`.
+   */
+  async proxy(method, apiPath, { query = null, body = undefined } = {}) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(query || {})) {
+      if (value === undefined || value === null || value === '') continue;
+      if (Array.isArray(value)) {
+        for (const item of value) search.append(key, String(item));
+      } else {
+        search.set(key, String(value));
+      }
+    }
+    const suffix = search.toString() ? `?${search.toString()}` : '';
+    const path = `/api${String(apiPath || '').startsWith('/') ? apiPath : `/${apiPath}`}${suffix}`;
+    const response = await this.request(path, { method, body: body !== undefined ? body : undefined });
+    const link = response.headers?.get?.('x-github-link') || '';
+    return { data: response.result, nextPage: /rel="next"/.test(link) };
+  }
+}

package/plugins/github/command.js

@@ -0,0 +1,307 @@
+import { syncPluginTools, unregisterPluginTools } from '../index.js';
+
+/**
+ * Handler `/github`.
+ *
+ * Command memakai parser Ryuu yang sudah ada (`define` di cli/commands.js);
+ * modul ini hanya memformat keluaran dan memanggil manager. Tidak ada token
+ * yang pernah dicetak.
+ */
+
+const USAGE = [
+  'GitHub Integration',
+  '',
+  'Autentikasi:',
+  '  /github login              login lewat browser (utama)',
+  '  /github login --device     login device flow (headless)',
+  '  /github logout             putuskan akun GitHub',
+  '',
+  'Status:',
+  '  /github status',
+  '  /github account',
+  '  /github test',
+  '',
+  'Integrasi:',
+  '  /github enable',
+  '  /github disable',
+  '',
+  'Konfigurasi:',
+  '  /github config',
+  '  /github config set <key> <value>',
+].join('\n');
+
+function tokenize(args) {
+  const out = [];
+  let current = '';
+  let quote = null;
+  for (const char of String(args ?? '')) {
+    if (quote) {
+      if (char === quote) quote = null;
+      else current += char;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current) out.push(current);
+      current = '';
+      continue;
+    }
+    current += char;
+  }
+  if (current) out.push(current);
+  return out;
+}
+
+function stamp(value) {
+  if (!value) return 'belum pernah';
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return String(value);
+  return date.toISOString().replace('T', ' ').slice(0, 19);
+}
+
+function redirectNote(plugin) {
+  return [
+    `  Backend         : ${plugin.pathsInfo.configFile.replace(/\/config\.json$/, '')}`,
+    '  Client Secret / Private Key / Webhook Secret: hanya di backend, tidak ada di CLI.',
+  ].join('\n');
+}
+
+export function createGitHubCommand({ plugin, registry, confirm = null, openBrowser = true, showCode = null }) {
+  return async function githubCommand(args, print) {
+    const parts = tokenize(args);
+    const sub = (parts[0] || '').toLowerCase();
+    const rest = parts.slice(1);
+
+    if (!sub || sub === 'help' || sub === '?') {
+      print(USAGE);
+      return;
+    }
+
+    if (sub === 'login') {
+      const device = rest.includes('--device');
+      const noBrowser = rest.includes('--no-browser');
+      try {
+        await plugin.login({
+          print,
+          showCode,
+          device,
+          openBrowser: openBrowser && !noBrowser,
+          confirmReplace: confirm ? (question) => confirm(question) : null,
+        });
+        // Setelah login, plugin otomatis enabled; daftarkan tool agar sesi ini
+        // langsung bisa memakainya tanpa restart.
+        if (await plugin.isEnabled()) await syncPluginTools(plugin, registry);
+      } catch (error) {
+        print(`Login GitHub gagal: ${error.message}`);
+      }
+      return;
+    }
+
+    if (sub === 'logout') {
+      // Sesi yang kedaluwarsa tetap punya kredensial lokal yang harus dihapus,
+      // jadi pemeriksaannya memakai `authInfo().connected`, bukan isAuthenticated.
+      const info = await plugin.authInfo().catch(() => ({ connected: false }));
+      if (!info.connected) {
+        print('Belum ada akun GitHub yang terhubung. Tidak ada yang perlu diputus.');
+        return;
+      }
+      if (confirm && !(await confirm('Putuskan koneksi GitHub dan hapus kredensial lokal? [y/N] '))) {
+        print('Logout dibatalkan. Kredensial tidak diubah.');
+        return;
+      }
+      unregisterPluginTools(plugin, registry);
+      await plugin.logout({ print });
+      return;
+    }
+
+    if (sub === 'enable') {
+      try {
+        const result = await plugin.enable();
+        const count = await syncPluginTools(plugin, registry);
+        print(`Integrasi GitHub diaktifkan. ${count} tool terdaftar untuk AI Agent:`);
+        print(`  ${result.tools.join(', ')}`);
+        print('Operasi yang mengubah data tetap meminta approval Ryuu.');
+      } catch (error) {
+        print(error.message);
+        if (error.code === 'GITHUB_UNAUTHORIZED') print('Jalankan /github login untuk menghubungkan akun GitHub.');
+      }
+      return;
+    }
+
+    if (sub === 'disable') {
+      const removed = unregisterPluginTools(plugin, registry);
+      await plugin.disable();
+      print(
+        `Integrasi GitHub dinonaktifkan (${removed} tool dilepas dari AI Agent). ` +
+          'Akun dan token tetap tersimpan; instalasi GitHub App tidak diputus.',
+      );
+      return;
+    }
+
+    if (sub === 'status') {
+      print(await formatStatus(plugin, registry));
+      return;
+    }
+
+    if (sub === 'account') {
+      try {
+        const account = await plugin.account();
+        print(
+          [
+            'AKUN GITHUB',
+            `  Username   : @${account.login || '(tidak tersedia)'}`,
+            `  Nama       : ${account.name || '(tidak tersedia)'}`,
+            `  Tipe akun  : ${account.type || '(tidak tersedia)'}`,
+            `  Profil     : ${account.htmlUrl || '(tidak tersedia)'}`,
+            `  Avatar     : ${account.avatarUrl || '(tidak tersedia)'}`,
+            `  Scope      : ${account.scope || '(tidak tercatat)'}`,
+            `  Status     : ${account.connected ? 'terhubung' : 'perlu login ulang'}`,
+            `  Integrasi  : ${(await plugin.isEnabled()) ? 'aktif' : 'nonaktif'}`,
+            `  Instalasi  : ${(account.installations || []).length} terlihat`,
+          ].join('\n'),
+        );
+        for (const installation of account.installations || []) {
+          print(`    · ${installation.account || '?'} (${installation.accountType || '?'}) · id ${installation.id}`);
+        }
+      } catch (error) {
+        print(`Tidak dapat membaca akun GitHub: ${error.message}`);
+        if (error.reconnect) print('Jalankan /github login untuk menghubungkan ulang.');
+      }
+      return;
+    }
+
+    if (sub === 'test') {
+      print('Menjalankan pemeriksaan GitHub…');
+      const result = await plugin.test();
+      const rows = (result.report || []).map(
+        (row) => `  ${row.ok ? '[✓]' : '[!]'} ${String(row.label).padEnd(26)} ${row.detail || ''}`,
+      );
+      print(
+        [
+          'DIAGNOSTIK GITHUB',
+          ...rows,
+          '',
+          result.ok ? 'Semua pemeriksaan berhasil.' : 'Ada pemeriksaan yang gagal.',
+          'Tidak ada repository yang dibuat, diubah, atau dihapus oleh test ini.',
+        ].join('\n'),
+      );
+      return;
+    }
+
+    if (sub === 'config') {
+      const action = (rest[0] || 'show').toLowerCase();
+      if (action === 'show') {
+        let view;
+        try {
+          view = await plugin.configView();
+        } catch (error) {
+          print(`Tidak dapat membaca konfigurasi GitHub: ${error.message}`);
+          return;
+        }
+        const width = Math.max(...Object.keys(view.lines).map((key) => key.length));
+        print(
+          [
+            'KONFIGURASI GITHUB (NON-RAHASIA)',
+            ...Object.entries(view.lines).map(([key, value]) => `  ${key.padEnd(width)}  ${value}`),
+            '',
+            redirectNote(plugin),
+            '',
+            'Ubah dengan: /github config set <key> <value>',
+            'Key: enabled, autoRefresh, confirmDestructive, defaultRepo',
+          ].join('\n'),
+        );
+        return;
+      }
+      if (action === 'set') {
+        const key = rest[1];
+        const value = rest.slice(2).join(' ');
+        if (!key || rest.length < 3) {
+          print('Usage: /github config set <key> <value>');
+          return;
+        }
+        try {
+          const parsed = await plugin.setConfig(key, value);
+          print(`Konfigurasi diperbarui: ${key} = ${parsed === null ? '(kosong)' : String(parsed)}`);
+          if (key === 'enabled') {
+            if (parsed === true) {
+              const count = await syncPluginTools(plugin, registry);
+              print(`${count} tool GitHub ${count > 0 ? 'terdaftar' : 'belum dapat didaftarkan (pastikan sudah login)'}.`);
+            } else {
+              const removed = unregisterPluginTools(plugin, registry);
+              print(`${removed} tool GitHub dilepas dari AI Agent.`);
+            }
+          }
+          if (key === 'confirmDestructive' && parsed === false) {
+            print('Peringatan: penghapusan file dan merge pull request akan diblokir sampai opsi ini diaktifkan lagi.');
+          }
+        } catch (error) {
+          print(error.message);
+        }
+        return;
+      }
+      print('Usage: /github config [show] | /github config set <key> <value>');
+      return;
+    }
+
+    print(`Subcommand tidak dikenal: /github ${sub}`);
+    print(USAGE);
+  };
+}
+
+export async function formatStatus(plugin, registry) {
+  const status = await plugin.status();
+  const registered = registry?.plugins?.get?.(plugin.name);
+  const remote = status.remote;
+  const lines = [
+    'STATUS GITHUB',
+    `  Integrasi       : ${status.enabled ? 'aktif' : 'nonaktif'}`,
+    `  Autentikasi     : ${status.authenticated ? 'terhubung' : 'belum login'}`,
+  ];
+  if (status.configError) lines.push(`  Konfigurasi     : error — ${status.configError}`);
+  if (status.authError) lines.push(`  Kredensial      : error — ${status.authError}`);
+  if (status.sessionExpired) lines.push('  Sesi lokal      : kedaluwarsa — jalankan /github login');
+
+  if (status.authenticated) {
+    const account = remote?.github || status.auth;
+    lines.push(`  Akun            : @${account.login || status.auth.login || '(tidak tersedia)'}`);
+    if (account.name || status.auth.name) lines.push(`  Nama            : ${account.name || status.auth.name}`);
+    if (remote?.token) {
+      lines.push(
+        `  Access token    : ${
+          remote.token.accessExpiresAt
+            ? `berlaku sampai ${stamp(remote.token.accessExpiresAt)}`
+            : 'tanpa masa berlaku (expiration off)'
+        }`,
+      );
+      lines.push(
+        `  Refresh token   : ${remote.token.hasRefreshToken ? 'tersedia di backend' : 'tidak tersedia'}`,
+      );
+      if (remote.token.needsReconnect) lines.push('  Perlu login ulang: ya (otorisasi dicabut/kedaluwarsa)');
+    }
+    lines.push(
+      `  Instalasi       : ${Array.isArray(remote?.installations) ? remote.installations.length : (status.auth.installations || 0)} terlihat`,
+    );
+    lines.push(`  Sesi lokal      : ${status.auth.cliTokenExpiresAt ? `berlaku sampai ${stamp(status.auth.cliTokenExpiresAt)}` : 'tanpa masa berlaku tercatat'}`);
+  }
+
+  lines.push(
+    `  Backend         : ${remote ? 'terhubung (respons aplikasi)' : status.remoteError ? `gagal — ${status.remoteError}` : status.settings?.backend || 'tidak diketahui'}`,
+    `  Tool aktif      : ${registered ? registered.toolNames.length : 0} dari ${status.toolCount}`,
+    `  Cek terakhir    : ${stamp(status.lastCheck)}${status.lastCheck === null ? '' : status.lastCheckOk ? ' (berhasil)' : ' (gagal)'}`,
+    `  Config file     : ${status.paths.configFile}`,
+    `  Credential file : ${status.paths.credentialFile}`,
+    '  Rahasia         : Client Secret, Private Key, dan token GitHub tidak disimpan di CLI',
+  );
+
+  if (status.enabled && !status.authenticated) lines.push('', 'Jalankan /github login untuk menghubungkan akun GitHub.');
+  if (status.enabled && status.authenticated && !registered) {
+    lines.push('', 'Integrasi aktif tetapi tool belum terdaftar: jalankan /github enable.');
+  }
+  if (remote?.config && !remote.config.ok) {
+    lines.push('', `Konfigurasi backend belum lengkap: ${(remote.config.missing || []).join(', ') || 'tidak diketahui'}.`);
+  }
+  return lines.join('\n');
+}