@ryuu-reinzz/ryuu-cli 0.4.3 → 0.5.0

package/plugins/google-drive/tools-files.js

@@ -0,0 +1,315 @@
+import fsp from 'node:fs/promises';
+import { defineTool } from '../../src/tools/registry.js';
+import { fileLine, formatBytes, resolveLocal } from './tool-helpers.js';
+
+/**
+ * File discovery and file management tools (search, list, metadata, download,
+ * upload, folder, move, rename, copy, delete).
+ *
+ * Destructive operations are declared destructive AND are re-checked against
+ * `confirmDestructive` at execution time, so a model cannot opt itself out of
+ * the safety check by sending an extra parameter.
+ */
+export function createFileTools(plugin) {
+  return [
+    defineTool({
+      name: 'drive_search',
+      description:
+        'Search Google Drive files by name, MIME type, parent folder id, or a raw Drive query string. Returns id, name, MIME type, size and timestamps for each match.',
+      risk: 'read',
+      schema: {
+        type: 'object',
+        properties: {
+          name: { type: 'string', description: 'Substring of the file name (case-insensitive on Drive side).' },
+          mimeType: {
+            type: 'string',
+            description: 'Exact MIME type, e.g. application/pdf or application/vnd.google-apps.folder.',
+          },
+          folderId: { type: 'string', description: 'Only search direct children of this folder id.' },
+          query: {
+            type: 'string',
+            description: "Raw Drive query fragment, e.g. \"fullText contains 'invoice'\".",
+          },
+          pageSize: { type: 'integer', minimum: 1, maximum: 100, description: 'Maximum results (default 25).' },
+          pageToken: { type: 'string', description: 'Token from a previous call for the next page.' },
+          orderBy: { type: 'string', description: 'Drive orderBy clause (default "modifiedTime desc").' },
+        },
+      },
+      async handler(args) {
+        const drive = await plugin.requireClient();
+        const result = await drive.search({
+          name: args.name || null,
+          mimeType: args.mimeType || null,
+          folderId: args.folderId || null,
+          query: args.query || null,
+          pageSize: args.pageSize ?? 25,
+          pageToken: args.pageToken || null,
+          orderBy: args.orderBy || 'modifiedTime desc',
+        });
+        return {
+          ok: true,
+          count: result.files.length,
+          files: result.files.map((file) => ({ ...file, sizeLabel: formatBytes(file.size) })),
+          nextPageToken: result.nextPageToken,
+        };
+      },
+    }),
+
+    defineTool({
+      name: 'drive_list',
+      description: 'List the immediate contents of a Google Drive folder (use "root" or omit the id for My Drive).',
+      risk: 'read',
+      schema: {
+        type: 'object',
+        properties: {
+          folderId: { type: 'string', description: 'Folder id to list; omit for My Drive root.' },
+          pageSize: { type: 'integer', minimum: 1, maximum: 200, description: 'Maximum entries (default 50).' },
+          pageToken: { type: 'string', description: 'Token from a previous call for the next page.' },
+          orderBy: { type: 'string', description: 'Drive orderBy clause (default "folder,name").' },
+        },
+      },
+      async handler(args) {
+        const drive = await plugin.requireClient();
+        const result = await drive.list({
+          folderId: args.folderId || 'root',
+          pageSize: args.pageSize ?? 50,
+          pageToken: args.pageToken || null,
+          orderBy: args.orderBy || 'folder,name',
+        });
+        return {
+          ok: true,
+          folderId: result.folderId,
+          count: result.files.length,
+          files: result.files.map((file) => ({ ...file, sizeLabel: formatBytes(file.size) })),
+          nextPageToken: result.nextPageToken,
+        };
+      },
+    }),
+
+    defineTool({
+      name: 'drive_get_metadata',
+      description:
+        'Get full metadata for one Drive file or folder: id, name, MIME type, size, created/modified time, parent folders and web view link.',
+      risk: 'read',
+      schema: {
+        type: 'object',
+        properties: { fileId: { type: 'string', description: 'Google Drive file or folder id.' } },
+        required: ['fileId'],
+      },
+      async handler(args) {
+        const drive = await plugin.requireClient();
+        const meta = await drive.getMetadata({ fileId: args.fileId });
+        return { ok: true, ...meta, sizeLabel: formatBytes(meta.size) };
+      },
+    }),
+
+    defineTool({
+      name: 'drive_download',
+      description:
+        'Download a Drive file to a local path inside the workspace. The destination must be relative to the workspace root; an existing file is not overwritten unless overwrite=true.',
+      risk: 'write',
+      requiresApproval: true,
+      schema: {
+        type: 'object',
+        properties: {
+          fileId: { type: 'string', description: 'Google Drive file id to download.' },
+          destinationPath: {
+            type: 'string',
+            description: 'Local destination file path relative to the workspace root, e.g. "downloads/report.pdf".',
+          },
+          overwrite: { type: 'boolean', description: 'Replace an existing local file. Default false.' },
+        },
+        required: ['fileId', 'destinationPath'],
+      },
+      async handler(args, ctx) {
+        const drive = await plugin.requireClient();
+        const target = resolveLocal(ctx, plugin, args.destinationPath);
+        if (!args.overwrite) {
+          const exists = await fsp.stat(target.realPath).then(() => true).catch(() => false);
+          if (exists) {
+            return {
+              ok: false,
+              error: {
+                code: 'DESTINATION_EXISTS',
+                message: `File lokal sudah ada: ${target.relPath}. Kirim overwrite=true bila memang ingin menggantinya.`,
+              },
+            };
+          }
+        }
+        const result = await drive.downloadFile({ fileId: args.fileId, destination: target.realPath });
+        return {
+          ok: true,
+          fileId: result.id,
+          name: result.name,
+          mimeType: result.mimeType,
+          destinationPath: target.relPath,
+          bytes: result.bytes,
+          sizeLabel: formatBytes(result.bytes),
+        };
+      },
+    }),
+
+    defineTool({
+      name: 'drive_upload',
+      description:
+        'Upload a local workspace file to Google Drive with streaming (the file is never buffered in memory). Large uploads are capped by maxUploadSize in the plugin config.',
+      risk: 'write',
+      requiresApproval: true,
+      schema: {
+        type: 'object',
+        properties: {
+          filePath: { type: 'string', description: 'Local file path relative to the workspace root.' },
+          fileName: { type: 'string', description: 'Name to use on Drive. Defaults to the local file name.' },
+          folderId: { type: 'string', description: 'Destination folder id. Omit for My Drive root.' },
+          mimeType: {
+            type: 'string',
+            description: 'Content type to store, e.g. application/zip, application/pdf, text/plain.',
+          },
+        },
+        required: ['filePath'],
+      },
+      async handler(args, ctx) {
+        const drive = await plugin.requireClient();
+        const settings = await plugin.loadConfig();
+        const source = resolveLocal(ctx, plugin, args.filePath, { mustExist: true });
+        const stat = await fsp.stat(source.realPath);
+        if (!stat.isFile()) {
+          return { ok: false, error: { code: 'NOT_A_FILE', message: `Bukan file biasa: ${source.relPath}` } };
+        }
+        if (settings.maxUploadSize && stat.size > settings.maxUploadSize) {
+          return {
+            ok: false,
+            error: {
+              code: 'UPLOAD_TOO_LARGE',
+              message: `Ukuran ${formatBytes(stat.size)} melebihi maxUploadSize ${formatBytes(settings.maxUploadSize)}. Naikkan lewat /drive config set maxUploadSize <byte>.`,
+            },
+          };
+        }
+        const uploaded = await drive.uploadFile({
+          filePath: source.realPath,
+          fileName: args.fileName || null,
+          folderId: args.folderId || 'root',
+          mimeType: args.mimeType || 'application/octet-stream',
+        });
+        return {
+          ok: true,
+          file: { ...uploaded, sizeLabel: formatBytes(uploaded.size) },
+          localPath: source.relPath,
+        };
+      },
+    }),
+
+    defineTool({
+      name: 'drive_create_folder',
+      description: 'Create a new Google Drive folder inside a parent folder.',
+      risk: 'write',
+      requiresApproval: true,
+      schema: {
+        type: 'object',
+        properties: {
+          name: { type: 'string', description: 'Folder name.' },
+          parentId: { type: 'string', description: 'Parent folder id. Omit for My Drive root.' },
+        },
+        required: ['name'],
+      },
+      async handler(args) {
+        const drive = await plugin.requireClient();
+        const folder = await drive.createFolder({ name: args.name, parentId: args.parentId || 'root' });
+        return { ok: true, folder };
+      },
+    }),
+
+    defineTool({
+      name: 'drive_move',
+      description: 'Move a Drive file or folder into another folder (the previous parents are removed).',
+      risk: 'write',
+      requiresApproval: true,
+      schema: {
+        type: 'object',
+        properties: {
+          fileId: { type: 'string', description: 'Item id to move.' },
+          toFolderId: { type: 'string', description: 'Destination folder id.' },
+        },
+        required: ['fileId', 'toFolderId'],
+      },
+      async handler(args) {
+        const drive = await plugin.requireClient();
+        await drive.assertFolder({ folderId: args.toFolderId });
+        return { ok: true, file: await drive.move({ fileId: args.fileId, toFolderId: args.toFolderId }) };
+      },
+    }),
+
+    defineTool({
+      name: 'drive_rename',
+      description: 'Rename a Google Drive file or folder without moving it.',
+      risk: 'write',
+      requiresApproval: true,
+      schema: {
+        type: 'object',
+        properties: {
+          fileId: { type: 'string', description: 'Item id to rename.' },
+          name: { type: 'string', description: 'New name.' },
+        },
+        required: ['fileId', 'name'],
+      },
+      async handler(args) {
+        const drive = await plugin.requireClient();
+        return { ok: true, file: await drive.rename({ fileId: args.fileId, name: args.name }) };
+      },
+    }),
+
+    defineTool({
+      name: 'drive_copy',
+      description: 'Copy a Google Drive file, optionally into another folder and under a new name.',
+      risk: 'write',
+      requiresApproval: true,
+      schema: {
+        type: 'object',
+        properties: {
+          fileId: { type: 'string', description: 'File id to copy (folders cannot be copied).' },
+          name: { type: 'string', description: 'Name for the copy. Defaults to Drive behaviour ("Copy of …").' },
+          folderId: { type: 'string', description: 'Destination folder id for the copy.' },
+        },
+        required: ['fileId'],
+      },
+      async handler(args) {
+        const drive = await plugin.requireClient();
+        return {
+          ok: true,
+          file: await drive.copy({ fileId: args.fileId, name: args.name || null, folderId: args.folderId || null }),
+        };
+      },
+    }),
+
+    defineTool({
+      name: 'drive_delete',
+      description:
+        'Permanently delete a Drive file or folder. This cannot be undone from Ryuu. Only call it after the user explicitly confirmed which file to delete.',
+      risk: 'destructive',
+      requiresApproval: true,
+      assess: (args) => (String(args?.fileId || '') ? 'critical' : 'normal'),
+      schema: {
+        type: 'object',
+        properties: {
+          fileId: { type: 'string', description: 'Drive file or folder id to delete.' },
+        },
+        required: ['fileId'],
+      },
+      preview: async (args) => {
+        try {
+          const drive = await plugin.getClient();
+          const meta = await drive.getMetadata({ fileId: args.fileId });
+          return `Hapus permanen: ${meta.name} (${meta.isFolder ? 'folder' : formatBytes(meta.size)})\nid: ${meta.id}\n${fileLine(meta)}`;
+        } catch (error) {
+          return `Hapus permanen id ${args.fileId} (metadata tidak terbaca: ${error.message})`;
+        }
+      },
+      async handler(args) {
+        const drive = await plugin.requireClient();
+        const meta = await drive.getMetadata({ fileId: args.fileId });
+        await drive.remove({ fileId: args.fileId });
+        return { ok: true, deleted: true, file: { id: meta.id, name: meta.name, isFolder: meta.isFolder } };
+      },
+    }),
+  ];
+}

package/plugins/google-drive/tools.js

@@ -0,0 +1,13 @@
+import { createFileTools } from './tools-files.js';
+import { createBackupTools } from './tools-backup.js';
+
+/**
+ * The complete AI tool set of the google-drive plugin.
+ *
+ * Every definition uses the registry's own `defineTool` contract (name,
+ * description, JSON schema, risk, handler), so the providers that already
+ * support Ryuu tool calling get these tools with no extra wiring.
+ */
+export function createDriveTools(plugin) {
+  return [...createFileTools(plugin), ...createBackupTools(plugin)];
+}

package/plugins/google-drive/zip-reader.js

@@ -0,0 +1,217 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import zlib from 'node:zlib';
+import { pipeline } from 'node:stream/promises';
+import { RyuuError } from '../../src/utils/errors.js';
+import { createCrc32 } from './zip-writer.js';
+
+/**
+ * Streaming ZIP reader with Zip Slip protection.
+ *
+ * The central directory is parsed once (it is small), then each entry is
+ * inflated straight from a bounded slice of the archive into its destination
+ * file. Every path is re-validated against the extraction root, and CRC32 is
+ * checked, so a corrupted or hostile archive fails before it can write outside
+ * the destination directory.
+ */
+
+const SIG_EOCD = 0x06054b50;
+const SIG_CENTRAL = 0x02014b50;
+const SIG_LOCAL = 0x04034b50;
+
+function zipError(message, extra = {}) {
+  return new RyuuError(message, { code: 'ZIP_INVALID', ...extra });
+}
+
+/** Reject absolute paths, `..` segments and drive letters (Zip Slip). */
+export function assertSafeEntryName(name) {
+  const raw = String(name).replace(/\\/g, '/');
+  if (!raw || raw.endsWith('/')) return null; // directory entry
+  if (raw.startsWith('/') || /^[A-Za-z]:/.test(raw)) {
+    throw zipError(`Arsip berisi path absolut dan ditolak: ${raw}`);
+  }
+  const segments = raw.split('/');
+  if (segments.some((segment) => segment === '..')) {
+    throw zipError(`Arsip berisi path traversal dan ditolak: ${raw}`);
+  }
+  const clean = segments.filter((segment) => segment && segment !== '.').join('/');
+  if (!clean) return null;
+  return clean;
+}
+
+/** Resolve an entry against the extraction root, refusing any escape. */
+export function resolveInside(root, entryName) {
+  const clean = assertSafeEntryName(entryName);
+  if (!clean) return null;
+  const target = path.resolve(root, clean);
+  const relative = path.relative(root, target);
+  if (relative.startsWith('..') || path.isAbsolute(relative)) {
+    throw zipError(`Entri arsip menulis di luar direktori tujuan: ${entryName}`);
+  }
+  return { relative: relative.split(path.sep).join('/'), target };
+}
+
+async function readEocd(handle, size) {
+  const tailLength = Math.min(size, 66 * 1024);
+  const buffer = Buffer.alloc(tailLength);
+  await handle.read(buffer, 0, tailLength, size - tailLength);
+  for (let i = buffer.length - 22; i >= 0; i -= 1) {
+    if (buffer.readUInt32LE(i) === SIG_EOCD) {
+      return {
+        entryCount: buffer.readUInt16LE(i + 10),
+        centralSize: buffer.readUInt32LE(i + 12),
+        centralOffset: buffer.readUInt32LE(i + 16),
+      };
+    }
+  }
+  throw zipError('Arsip bukan ZIP yang valid (end of central directory tidak ditemukan).');
+}
+
+async function readCentralDirectory(handle, eocd) {
+  if (eocd.centralSize === 0) return [];
+  const buffer = Buffer.alloc(eocd.centralSize);
+  await handle.read(buffer, 0, eocd.centralSize, eocd.centralOffset);
+  const entries = [];
+  let offset = 0;
+  while (offset + 46 <= buffer.length && buffer.readUInt32LE(offset) === SIG_CENTRAL) {
+    const flags = buffer.readUInt16LE(offset + 8);
+    const nameLength = buffer.readUInt16LE(offset + 28);
+    const extraLength = buffer.readUInt16LE(offset + 30);
+    const commentLength = buffer.readUInt16LE(offset + 32);
+    const name = buffer.subarray(offset + 46, offset + 46 + nameLength).toString('utf8');
+    entries.push({
+      name,
+      flags,
+      method: buffer.readUInt16LE(offset + 10),
+      crc32: buffer.readUInt32LE(offset + 16),
+      compressedSize: buffer.readUInt32LE(offset + 20),
+      uncompressedSize: buffer.readUInt32LE(offset + 24),
+      localOffset: buffer.readUInt32LE(offset + 42),
+    });
+    offset += 46 + nameLength + extraLength + commentLength;
+  }
+  return entries;
+}
+
+/** Read an archive's table of contents without extracting anything. */
+export async function listZipEntries(zipPath) {
+  let handle;
+  try {
+    handle = await fsp.open(zipPath, 'r');
+  } catch (error) {
+    throw zipError(`Arsip tidak dapat dibuka: ${zipPath} (${error.message})`);
+  }
+  try {
+    const { size } = await handle.stat();
+    if (size < 22) throw zipError('Arsip terlalu kecil untuk menjadi ZIP yang valid.');
+    const eocd = await readEocd(handle, size);
+    return await readCentralDirectory(handle, eocd);
+  } finally {
+    await handle.close().catch(() => {});
+  }
+}
+
+/**
+ * Extract `zipPath` into `destination`.
+ *
+ * `overwrite: false` refuses to replace an existing file instead of silently
+ * clobbering it. A symlink at the target path is always refused, even with
+ * overwrite, because writing through it would escape the destination.
+ */
+export async function extractZip({
+  zipPath,
+  destination,
+  overwrite = false,
+  entries: only = null,
+  maxTotalBytes = 8 * 1024 * 1024 * 1024,
+  onProgress = null,
+  signal = null,
+} = {}) {
+  const root = path.resolve(destination);
+  await fsp.mkdir(root, { recursive: true, mode: 0o700 });
+  const handle = await fsp.open(zipPath, 'r');
+  const written = [];
+  let totalBytes = 0;
+  try {
+    const { size } = await handle.stat();
+    const eocd = await readEocd(handle, size);
+    const entries = await readCentralDirectory(handle, eocd);
+    const wanted = only ? new Set(only) : null;
+    for (const entry of entries) {
+      if (signal?.aborted) throw new RyuuError('Restore dibatalkan.', { code: 'CANCELLED' });
+      if (entry.flags & 0x1) throw zipError('Arsip terenkripsi tidak didukung.');
+      if (entry.method !== 0 && entry.method !== 8) {
+        throw zipError(`Metode kompresi ${entry.method} tidak didukung pada entri ${entry.name}.`);
+      }
+      const resolved = resolveInside(root, entry.name);
+      if (!resolved) continue;
+      if (wanted && !wanted.has(resolved.relative)) continue;
+
+      // A symlink anywhere on the path would let the write escape the root.
+      const parent = path.dirname(resolved.target);
+      await fsp.mkdir(parent, { recursive: true, mode: 0o700 });
+      try {
+        const existing = await fsp.lstat(resolved.target);
+        if (existing.isSymbolicLink()) {
+          throw zipError(`Tujuan ekstraksi adalah symlink dan ditolak: ${resolved.relative}`);
+        }
+        if (existing.isDirectory()) {
+          throw zipError(`Tujuan ekstraksi adalah direktori, bukan file: ${resolved.relative}`);
+        }
+        if (!overwrite) {
+          throw new RyuuError(
+            `File sudah ada dan tidak ditimpa: ${resolved.relative}. Jalankan ulang dengan overwrite=true bila memang ingin menggantinya.`,
+            { code: 'RESTORE_EXISTS' },
+          );
+        }
+      } catch (error) {
+        if (error.code !== 'ENOENT') throw error;
+      }
+
+      const headerBuffer = Buffer.alloc(30);
+      await handle.read(headerBuffer, 0, 30, entry.localOffset);
+      if (headerBuffer.readUInt32LE(0) !== SIG_LOCAL) {
+        throw zipError(`Local header tidak valid pada entri ${entry.name}.`);
+      }
+      const nameLength = headerBuffer.readUInt16LE(26);
+      const extraLength = headerBuffer.readUInt16LE(28);
+      const dataStart = entry.localOffset + 30 + nameLength + extraLength;
+      if (entry.compressedSize === 0) {
+        await fsp.writeFile(resolved.target, Buffer.alloc(0), { mode: 0o600 });
+        written.push({ path: resolved.relative, bytes: 0 });
+        continue;
+      }
+      if (dataStart + entry.compressedSize > size) {
+        throw zipError(`Entri ${entry.name} melewati akhir arsip (arsip rusak).`);
+      }
+      const source = handle.createReadStream({ start: dataStart, end: dataStart + entry.compressedSize - 1, autoClose: false });
+      const crc = createCrc32();
+      const sink = fs.createWriteStream(resolved.target, { mode: 0o600 });
+      const meter = async function* meter(stream) {
+        for await (const chunk of stream) {
+          crc.update(chunk);
+          totalBytes += chunk.length;
+          if (totalBytes > maxTotalBytes) {
+            throw zipError('Ukuran hasil ekstraksi melebihi batas keamanan (8 GB).');
+          }
+          if (onProgress) onProgress({ path: resolved.relative, loaded: totalBytes });
+          yield chunk;
+        }
+      };
+      if (entry.method === 8) {
+        await pipeline(source, zlib.createInflateRaw(), meter, sink);
+      } else {
+        await pipeline(source, meter, sink);
+      }
+      if (crc.digest() !== entry.crc32) {
+        await fsp.rm(resolved.target, { force: true }).catch(() => {});
+        throw zipError(`CRC arsip tidak cocok pada entri ${entry.name} (arsip rusak).`);
+      }
+      written.push({ path: resolved.relative, bytes: entry.uncompressedSize });
+    }
+    return { destination: root, files: written, fileCount: written.length, bytes: totalBytes };
+  } finally {
+    await handle.close().catch(() => {});
+  }
+}