@ryuu-reinzz/ryuu-cli 0.4.3 → 0.5.1

package/plugins/google-drive/backup.js

@@ -0,0 +1,282 @@
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { RyuuError } from '../../src/utils/errors.js';
+import { ZipWriter } from './zip-writer.js';
+import { extractZip, listZipEntries } from './zip-reader.js';
+
+/**
+ * Backup and restore engine for the Google Drive plugin.
+ *
+ * Backups are streamed into a temporary ZIP (never fully buffered), uploaded
+ * with a resumable request, and the temporary file is always removed. Restore
+ * downloads to a temporary file, validates the archive, then extracts with Zip
+ * Slip protection.
+ */
+
+const BACKUP_ERROR = 'DRIVE_BACKUP';
+
+/** Patterns that must never be archived silently. */
+export const HARD_EXCLUDES = Object.freeze([
+  '.env',
+  '.env.*',
+  '*.pem',
+  '*.key',
+  '*.p12',
+  '*.pfx',
+  'id_rsa*',
+  'id_ed25519*',
+  'credentials.json',
+  'service-account*.json',
+  'credentials.enc',
+]);
+
+/** Turn a pattern list into matchers; supports `*`, `?`, `**` and bare names. */
+export function compilePatterns(patterns = []) {
+  return patterns
+    .map((pattern) => String(pattern || '').trim())
+    .filter(Boolean)
+    .map((pattern) => {
+      const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+      const body = escaped.replace(/\*\*/g, '\u0000').replace(/\*/g, '[^/]*').replace(/\?/g, '[^/]').replace(/\u0000/g, '.*');
+      return { pattern, regex: new RegExp(`^${body}$`) };
+    });
+}
+
+/** True when `relPath` (posix style) or any of its segments matches a pattern. */
+export function isExcluded(relPath, matchers) {
+  const candidates = [relPath, ...relPath.split('/')];
+  return matchers.some(({ regex }) => candidates.some((candidate) => regex.test(candidate)));
+}
+
+/**
+ * Walk `root` and return the files that may be archived, with their sizes.
+ * Symlinks are not followed: a backup must not silently pull in /etc.
+ */
+export async function collectFiles({ root, includePatterns = [], excludePatterns = [], maxFiles = 20000, signal = null, onProgress = null }) {
+  const matchers = compilePatterns([...excludePatterns, ...HARD_EXCLUDES]);
+  const includes = includePatterns.length > 0 ? compilePatterns(includePatterns) : null;
+  const files = [];
+  let totalBytes = 0;
+  let skipped = 0;
+
+  const walk = async (dir) => {
+    if (signal?.aborted) throw new RyuuError('Backup dibatalkan.', { code: 'CANCELLED' });
+    const entries = await fsp.readdir(dir, { withFileTypes: true });
+    entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    for (const entry of entries) {
+      if (files.length >= maxFiles) {
+        throw new RyuuError(
+          `Backup dibatasi ${maxFiles} file. Persempit sourcePath atau tambah excludePatterns.`,
+          { code: BACKUP_ERROR },
+        );
+      }
+      const absPath = path.join(dir, entry.name);
+      const relPath = path.relative(root, absPath).split(path.sep).join('/');
+      if (entry.isSymbolicLink()) {
+        skipped += 1;
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (isExcluded(`${relPath}/`, matchers) || isExcluded(relPath, matchers)) {
+          skipped += 1;
+          continue;
+        }
+        await walk(absPath);
+        continue;
+      }
+      if (!entry.isFile()) {
+        skipped += 1;
+        continue;
+      }
+      if (isExcluded(relPath, matchers)) {
+        skipped += 1;
+        continue;
+      }
+      if (includes && !includes.some(({ regex }) => regex.test(relPath))) {
+        skipped += 1;
+        continue;
+      }
+      const stat = await fsp.stat(absPath);
+      files.push({ absPath, relPath, size: stat.size, mtime: stat.mtime });
+      totalBytes += stat.size;
+      if (onProgress) onProgress({ files: files.length, bytes: totalBytes, current: relPath });
+    }
+  };
+
+  const stat = await fsp.stat(root).catch((error) => {
+    if (error.code === 'ENOENT') throw new RyuuError(`Direktori sumber tidak ditemukan: ${root}`, { code: 'DRIVE_LOCAL' });
+    throw new RyuuError(`Direktori sumber tidak dapat dibaca: ${root} (${error.message})`, { code: 'DRIVE_LOCAL' });
+  });
+  if (!stat.isDirectory()) throw new RyuuError(`Sumber backup bukan direktori: ${root}`, { code: 'DRIVE_LOCAL' });
+  await walk(root);
+  return { root, files, totalBytes, skipped, excludedPatterns: [...excludePatterns, ...HARD_EXCLUDES] };
+}
+
+/** Default archive name: `<name>-backup-YYYYMMDD-HHmmss.zip`. */
+export function defaultArchiveName(baseName = 'project', date = new Date()) {
+  const pad = (value) => String(value).padStart(2, '0');
+  const stamp =
+    `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}` +
+    `-${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
+  const safe = String(baseName || 'project').replace(/[^A-Za-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '') || 'project';
+  return `${safe}-backup-${stamp}.zip`;
+}
+
+/** Create the ZIP in a temporary directory and return its path and stats. */
+export async function createArchive({ files, archivePath, compressionLevel = 6, signal = null }) {
+  const writer = new ZipWriter({ file: archivePath, compressionLevel });
+  await writer.open();
+  try {
+    for (const file of files) {
+      await writer.addFile(file.relPath, file.absPath, { signal });
+    }
+    return await writer.close();
+  } catch (error) {
+    await fsp.rm(archivePath, { force: true }).catch(() => {});
+    throw error instanceof RyuuError
+      ? error
+      : new RyuuError(`Gagal membuat arsip backup: ${error.message}`, { code: BACKUP_ERROR });
+  }
+}
+
+/** Temporary scratch directory owned by the plugin. */
+export async function makeTempDir(label = 'drive') {
+  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), `ryuu-${label}-`));
+  return dir;
+}
+
+function formatBackupName(name) {
+  return String(name || '').trim();
+}
+
+/**
+ * Full backup: collect → archive → upload → cleanup.
+ * Nothing is deleted from the source directory, and old backups are kept.
+ */
+export async function backupToDrive({
+  drive,
+  sourceRoot,
+  destinationFolderId,
+  archiveName = null,
+  excludePatterns = [],
+  includePatterns = [],
+  compressionLevel = 6,
+  maxUploadSize = 0,
+  signal = null,
+  onProgress = null,
+  logger = null,
+}) {
+  const collected = await collectFiles({ root: sourceRoot, includePatterns, excludePatterns, signal, onProgress });
+  if (collected.files.length === 0) {
+    throw new RyuuError('Tidak ada file yang bisa dibackup setelah exclusion diterapkan.', { code: BACKUP_ERROR });
+  }
+  if (maxUploadSize > 0 && collected.totalBytes > maxUploadSize) {
+    throw new RyuuError(
+      `Ukuran backup ${collected.totalBytes} byte melebihi maxUploadSize ${maxUploadSize} byte. Tambah excludePatterns atau naikkan maxUploadSize.`,
+      { code: BACKUP_ERROR },
+    );
+  }
+  const folder = await drive.assertFolder({ folderId: destinationFolderId, label: 'Folder tujuan backup' });
+  const name = formatBackupName(archiveName) || defaultArchiveName(path.basename(sourceRoot));
+  const tempDir = await makeTempDir('backup');
+  const archivePath = path.join(tempDir, name.endsWith('.zip') ? name : `${name}.zip`);
+  try {
+    const archive = await createArchive({ files: collected.files, archivePath, compressionLevel, signal });
+    onProgress?.({ stage: 'uploading', archive: path.basename(archivePath) });
+    const uploaded = await drive.uploadFile({
+      filePath: archivePath,
+      fileName: path.basename(archivePath),
+      folderId: folder.id,
+      mimeType: 'application/zip',
+      onProgress: (event) => onProgress?.({ stage: 'upload', ...event }),
+    });
+    logger?.info('drive backup uploaded', { fileId: uploaded.id, bytes: uploaded.size });
+    return {
+      archiveName: path.basename(archivePath),
+      fileId: uploaded.id,
+      size: uploaded.size ?? archive.bytes,
+      sourcePath: sourceRoot,
+      destinationFolderId: folder.id,
+      destinationFolderName: folder.name || null,
+      webViewLink: uploaded.webViewLink,
+      fileCount: collected.files.length,
+      excludedPatterns: collected.excludedPatterns,
+      skipped: collected.skipped,
+      createdAt: new Date().toISOString(),
+      status: 'berhasil',
+    };
+  } finally {
+    await fsp.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+/** List ZIP archives that look like Ryuu backups inside a folder. */
+export async function listBackups({ drive, folderId = 'root', pageSize = 50, pageToken = null }) {
+  const result = await drive.search({
+    query: "mimeType = 'application/zip'",
+    folderId,
+    pageSize,
+    pageToken,
+    orderBy: 'modifiedTime desc',
+  });
+  return { ...result, backups: result.files.filter((file) => /\.zip$/i.test(file.name)) };
+}
+
+/**
+ * Restore: download → validate → extract. The archive is inspected before any
+ * file is written, and an existing target file is only replaced with overwrite.
+ */
+export async function restoreFromDrive({
+  drive,
+  fileId,
+  destinationRoot,
+  overwrite = false,
+  signal = null,
+  onProgress = null,
+  logger = null,
+}) {
+  const tempDir = await makeTempDir('restore');
+  const archivePath = path.join(tempDir, `restore-${randomBytes(4).toString('hex')}.zip`);
+  try {
+    const downloaded = await drive.downloadFile({
+      fileId,
+      destination: archivePath,
+      onProgress: (event) => onProgress?.({ stage: 'download', ...event }),
+    });
+    const entries = await listZipEntries(archivePath);
+    if (entries.length === 0) {
+      throw new RyuuError('Arsip backup kosong atau tidak valid.', { code: 'ZIP_INVALID' });
+    }
+    onProgress?.({ stage: 'extract', entries: entries.length });
+    const extracted = await extractZip({ zipPath: archivePath, destination: destinationRoot, overwrite, signal, onProgress });
+    logger?.info('drive restore extracted', { fileId, files: extracted.fileCount });
+    return {
+      fileId,
+      archiveName: downloaded.name,
+      destinationPath: extracted.destination,
+      overwritten: Boolean(overwrite),
+      fileCount: extracted.fileCount,
+      bytes: extracted.bytes,
+      archiveEntries: entries.length,
+      files: extracted.files.slice(0, 200),
+      restoredAt: new Date().toISOString(),
+      status: 'berhasil',
+    };
+  } finally {
+    await fsp.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
+/** Remove one backup archive after an explicit confirmation upstream. */
+export async function deleteBackup({ drive, fileId }) {
+  const meta = await drive.getMetadata({ fileId });
+  if (!/\.zip$/i.test(meta.name || '')) {
+    throw new RyuuError(`File ${meta.name || fileId} bukan arsip backup (.zip), penghapusan dibatalkan.`, {
+      code: BACKUP_ERROR,
+    });
+  }
+  await drive.remove({ fileId });
+  return { fileId, name: meta.name, size: meta.size, deleted: true, deletedAt: new Date().toISOString() };
+}

package/plugins/google-drive/command.js

@@ -0,0 +1,266 @@
+import { formatBytes } from './tool-helpers.js';
+import { syncPluginTools, unregisterPluginTools } from '../index.js';
+
+/**
+ * `/drive` command handler.
+ *
+ * It is wired into the existing command parser through `define()` in
+ * cli/commands.js; this module only formats output and calls the manager.
+ * Every message is Indonesian, and no token is ever printed.
+ */
+
+const USAGE = [
+  'Google Drive Integration',
+  '',
+  'Autentikasi:',
+  '  /drive login',
+  '  /drive logout',
+  '  /drive account',
+  '',
+  'Integrasi:',
+  '  /drive enable',
+  '  /drive disable',
+  '  /drive status',
+  '',
+  'Konfigurasi:',
+  '  /drive config',
+  '  /drive config show',
+  '  /drive config set <key> <value>',
+  '',
+  'Diagnostik:',
+  '  /drive test',
+].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);
+}
+
+export function createDriveCommand({ plugin, registry, confirm = null, openBrowser = true, showCode = null }) {
+  /**
+   * @param {string} args raw argument string after `/drive`
+   * @param {(text: string) => void} print
+   */
+  return async function driveCommand(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') {
+      try {
+        await plugin.login({
+          print,
+          showCode,
+          openBrowser,
+          confirmReplace: confirm ? (question) => confirm(question) : null,
+        });
+      } catch (error) {
+        print(`Login gagal: ${error.message}`);
+      }
+      return;
+    }
+
+    if (sub === 'logout') {
+      const authenticated = await plugin.isAuthenticated().catch(() => false);
+      if (!authenticated) {
+        print('Belum ada akun Google yang terhubung. Tidak ada yang perlu diputus.');
+        return;
+      }
+      if (confirm && !(await confirm('Putuskan koneksi Google Drive 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 Google Drive diaktifkan. ${count} tool terdaftar untuk AI Agent:`);
+        print(`  ${result.tools.join(', ')}`);
+      } catch (error) {
+        print(error.message);
+        if (error.code === 'DRIVE_UNAUTHORIZED') print('Jalankan /drive login untuk menghubungkan akun Google.');
+      }
+      return;
+    }
+
+    if (sub === 'disable') {
+      const removed = unregisterPluginTools(plugin, registry);
+      await plugin.disable();
+      print(
+        `Integrasi Google Drive dinonaktifkan (${removed} tool dilepas dari AI Agent). ` +
+          'Token dan konfigurasi tetap disimpan; backup tidak dihapus.',
+      );
+      return;
+    }
+
+    if (sub === 'status') {
+      print(await formatStatus(plugin, registry));
+      return;
+    }
+
+    if (sub === 'account') {
+      const info = await plugin.authInfo().catch((error) => ({ connected: false, error: error.message }));
+      if (!info.connected) {
+        print('Belum ada akun Google yang terhubung. Jalankan /drive login.');
+        return;
+      }
+      let quota = null;
+      try {
+        const client = await plugin.getClient();
+        const about = await client.getAbout();
+        quota = about.storageQuota;
+        print(
+          [
+            'AKUN GOOGLE DRIVE',
+            `  Nama       : ${about.name || '(tidak tersedia)'}`,
+            `  Email      : ${about.email || '(tidak tersedia)'}`,
+            `  Permission : ${info.scope || '(tidak tercatat)'}`,
+            `  Token      : ${info.hasRefreshToken ? 'izin refresh tersedia (grant)' : 'hanya access token'}`,
+            `  Kadaluarsa : ${stamp(info.expiresAt)}`,
+            `  Tersimpan  : ${stamp(info.savedAt)}`,
+            quota?.limit
+              ? `  Storage    : ${formatBytes(quota.usage)} / ${formatBytes(quota.limit)}`
+              : '  Storage    : tidak tersedia dari API',
+          ].join('\n'),
+        );
+      } catch (error) {
+        print(`Akun tersimpan: ${info.email || '(tanpa email)'} — tetapi API menolak: ${error.message}`);
+      }
+      return;
+    }
+
+    if (sub === 'config') {
+      const action = (rest[0] || 'show').toLowerCase();
+      if (action === 'show') {
+        const { lines } = await plugin.configView();
+        const width = Math.max(...Object.keys(lines).map((key) => key.length));
+        print(
+          [
+            'KONFIGURASI GOOGLE DRIVE',
+            ...Object.entries(lines).map(([key, value]) => `  ${key.padEnd(width)}  ${value}`),
+            '',
+            'Ubah dengan: /drive config set <key> <value>',
+            'Key: enabled, defaultBackupFolder, backupDirectory, maxUploadSize, confirmDestructive, autoRefresh, excludePatterns',
+          ].join('\n'),
+        );
+        return;
+      }
+      if (action === 'set') {
+        const key = rest[1];
+        const value = rest.slice(2).join(' ');
+        if (!key || rest.length < 3) {
+          print('Usage: /drive config set <key> <value>');
+          return;
+        }
+        try {
+          const parsed = await plugin.setConfig(key, value);
+          const shown = Array.isArray(parsed) ? parsed.join(', ') || '(kosong)' : String(parsed);
+          print(`Konfigurasi diperbarui: ${key} = ${shown}`);
+          if (key === 'enabled') {
+            if (parsed === true) await syncPluginTools(plugin, registry);
+            else unregisterPluginTools(plugin, registry);
+          }
+        } catch (error) {
+          print(error.message);
+        }
+        return;
+      }
+      print('Usage: /drive config [show] | /drive config set <key> <value>');
+      return;
+    }
+
+    if (sub === 'test') {
+      print('Menjalankan pemeriksaan Google Drive…');
+      const result = await plugin.diagnose();
+      const rows = result.report.map((row) => `  ${row.ok ? '[✓]' : '[!]'} ${row.label.padEnd(24)} ${row.detail}`);
+      print(['DIAGNOSTIK GOOGLE DRIVE', ...rows, '', result.ok ? 'Semua pemeriksaan berhasil.' : 'Ada pemeriksaan yang gagal.'].join('\n'));
+      return;
+    }
+
+    if (sub === 'tools') {
+      const registered = registry?.plugins?.get?.(plugin.name);
+      print(
+        registered
+          ? `Tool Google Drive terdaftar (${registered.toolNames.length}): ${registered.toolNames.join(', ')}`
+          : 'Tool Google Drive sedang tidak terdaftar untuk AI Agent (nonaktif atau belum login).',
+      );
+      return;
+    }
+
+    print(`Subcommand tidak dikenal: /drive ${sub}`);
+    print(USAGE);
+  };
+}
+
+export async function formatStatus(plugin, registry) {
+  const status = await plugin.status();
+  const registered = registry?.plugins?.get?.(plugin.name);
+  const integration = status.enabled ? 'aktif' : 'nonaktif';
+  const auth = status.authenticated ? 'terhubung' : 'belum login';
+  const lines = [
+    'STATUS GOOGLE DRIVE',
+    `  Integrasi       : ${integration}`,
+    `  Autentikasi     : ${auth}`,
+  ];
+  if (status.configError) lines.push(`  Konfigurasi     : error — ${status.configError}`);
+  if (status.authError) lines.push(`  Credential      : error — ${status.authError}`);
+  if (status.authenticated) {
+    lines.push(`  Akun            : ${status.auth.email || status.account?.email || '(tanpa email)'}`);
+    if (status.auth.name || status.account?.name) lines.push(`  Nama            : ${status.auth.name || status.account.name}`);
+    lines.push(`  Scope OAuth     : ${status.auth.scope || (status.settings?.scopes || []).join(', ')}`);
+    lines.push(
+      `  Token           : ${status.auth.hasRefreshToken ? 'izin refresh tersedia (grant)' : 'hanya access token'} · kadaluarsa ${stamp(status.auth.expiresAt)}`,
+    );
+    if (status.quota?.limit) {
+      lines.push(`  Storage         : ${formatBytes(status.quota.usage)} / ${formatBytes(status.quota.limit)}`);
+    }
+  }
+  lines.push(
+    `  Tool aktif      : ${registered ? registered.toolNames.length : 0} dari ${status.toolCount}`,
+    `  Folder backup   : ${status.settings?.defaultBackupFolder || '(My Drive root / belum diatur)'}`,
+    `  Folder arsip    : ${status.settings?.backupDirectory || 'Backups'}`,
+    `  Cek terakhir    : ${stamp(status.lastCheck)}${status.lastCheck === null ? '' : status.lastCheckOk ? ' (berhasil)' : ' (gagal)'}`,
+    `  Config file     : ${status.paths.configFile}`,
+    `  Credential file : ${status.paths.credentialFile}`,
+  );
+  if (status.enabled && !status.authenticated) lines.push('', 'Jalankan /drive login untuk menghubungkan akun Google.');
+  if (status.registered === false) lines.push('', 'Integrasi aktif tetapi tool belum terdaftar: jalankan /drive enable.');
+  return lines.join('\n');
+}