botrun-horse 2.29.2 → 2.30.0

package/botrun-c/.claude/skills/GoogleDrive/346/212/200/350/203/275/scripts/gdrive-read.mjs

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+
+/**
+ * gdrive-read.mjs - 讀取已同步的 Google Drive 檔案
+ *
+ * 使用方式：
+ *   node gdrive-read.mjs --userId "user123" --file "path/to/file.md"
+ *   node gdrive-read.mjs --userId "user123" --fileId "file-id" --folderId "folder-id"
+ *
+ * 輸出：
+ *   檔案內容（純文字）
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+// 解析命令列參數
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = {
+    userId: 'anonymous',
+    file: null,
+    fileId: null,
+    folderId: null,
+    maxLines: 0, // 0 = 無限制
+    startLine: 0
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--userId' && args[i + 1]) {
+      result.userId = args[i + 1];
+      i++;
+    } else if (args[i] === '--file' && args[i + 1]) {
+      result.file = args[i + 1];
+      i++;
+    } else if (args[i] === '--fileId' && args[i + 1]) {
+      result.fileId = args[i + 1];
+      i++;
+    } else if (args[i] === '--folderId' && args[i + 1]) {
+      result.folderId = args[i + 1];
+      i++;
+    } else if (args[i] === '--maxLines' && args[i + 1]) {
+      result.maxLines = parseInt(args[i + 1], 10);
+      i++;
+    } else if (args[i] === '--startLine' && args[i + 1]) {
+      result.startLine = parseInt(args[i + 1], 10);
+      i++;
+    }
+  }
+
+  return result;
+}
+
+// 取得快取根目錄（使用 /tmp SSD，速度極快）
+function getCacheRoot(userId) {
+  // 驗證 userId 格式（防止路徑遍歷攻擊）
+  if (!userId || typeof userId !== 'string' || !/^[a-zA-Z0-9]+$/.test(userId)) {
+    throw new Error(`Invalid userId format: ${userId}`);
+  }
+  return `/tmp/${userId}/gdrive`;
+}
+
+// 取得索引路徑
+function getIndexPath(userId) {
+  return path.join(getCacheRoot(userId), 'index.json');
+}
+
+// 讀取索引
+function readIndex(userId) {
+  const indexPath = getIndexPath(userId);
+
+  if (!fs.existsSync(indexPath)) {
+    return { folders: [], files: [] };
+  }
+
+  try {
+    const content = fs.readFileSync(indexPath, 'utf-8');
+    return JSON.parse(content);
+  } catch (error) {
+    return { folders: [], files: [] };
+  }
+}
+
+// 根據 fileId 找到檔案路徑
+function findFileById(userId, fileId, folderId) {
+  const cacheRoot = getCacheRoot(userId);
+  const index = readIndex(userId);
+
+  // 在 files 索引中搜尋
+  const fileEntry = index.files?.find(f => f.id === fileId);
+
+  if (fileEntry) {
+    // 嘗試讀取轉換後的檔案
+    const convertedPath = path.join(cacheRoot, fileEntry.folderId, 'converted', fileEntry.path);
+    if (fs.existsSync(convertedPath)) {
+      return convertedPath;
+    }
+
+    // 嘗試讀取原始檔案
+    const originalPath = path.join(cacheRoot, fileEntry.folderId, 'original', fileEntry.originalName);
+    if (fs.existsSync(originalPath)) {
+      return originalPath;
+    }
+  }
+
+  // 如果提供了 folderId，在該資料夾中搜尋
+  if (folderId) {
+    const folderPath = path.join(cacheRoot, folderId);
+    if (fs.existsSync(folderPath)) {
+      // 搜尋 converted 目錄
+      const convertedDir = path.join(folderPath, 'converted');
+      if (fs.existsSync(convertedDir)) {
+        const files = fs.readdirSync(convertedDir);
+        const found = files.find(f => f.includes(fileId));
+        if (found) {
+          return path.join(convertedDir, found);
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+// 解析檔案路徑
+function resolveFilePath(userId, filePath) {
+  // 如果是絕對路徑且存在，直接使用
+  if (path.isAbsolute(filePath) && fs.existsSync(filePath)) {
+    return filePath;
+  }
+
+  const cacheRoot = getCacheRoot(userId);
+
+  // 嘗試相對於 cache root 的路徑
+  const relativePath = path.join(cacheRoot, filePath);
+  if (fs.existsSync(relativePath)) {
+    return relativePath;
+  }
+
+  // 搜尋所有資料夾的 converted 目錄
+  const index = readIndex(userId);
+
+  for (const folder of index.folders) {
+    const convertedPath = path.join(cacheRoot, folder.id, 'converted', filePath);
+    if (fs.existsSync(convertedPath)) {
+      return convertedPath;
+    }
+
+    // 嘗試匹配檔名
+    const convertedDir = path.join(cacheRoot, folder.id, 'converted');
+    if (fs.existsSync(convertedDir)) {
+      const files = fs.readdirSync(convertedDir);
+      const found = files.find(f => f === filePath || f.includes(path.basename(filePath, path.extname(filePath))));
+      if (found) {
+        return path.join(convertedDir, found);
+      }
+    }
+  }
+
+  return null;
+}
+
+// 主函數
+async function main() {
+  const { userId, file, fileId, folderId, maxLines, startLine } = parseArgs();
+
+  if (!file && !fileId) {
+    console.error('Error: Either --file or --fileId is required.');
+    console.error('Usage: node gdrive-read.mjs --userId "user" --file "path/to/file"');
+    console.error('       node gdrive-read.mjs --userId "user" --fileId "id" --folderId "folder"');
+    process.exit(1);
+  }
+
+  try {
+    let filePath;
+
+    if (fileId) {
+      filePath = findFileById(userId, fileId, folderId);
+    } else {
+      filePath = resolveFilePath(userId, file);
+    }
+
+    if (!filePath || !fs.existsSync(filePath)) {
+      console.error(`Error: File not found.`);
+      console.error(`Searched for: ${file || fileId}`);
+      console.error(`User: ${userId}`);
+      console.error(`Cache root: ${getCacheRoot(userId)}`);
+      process.exit(1);
+    }
+
+    // 讀取檔案
+    let content = fs.readFileSync(filePath, 'utf-8');
+
+    // 處理行數限制
+    if (maxLines > 0 || startLine > 0) {
+      const lines = content.split('\n');
+      const start = startLine;
+      const end = maxLines > 0 ? start + maxLines : lines.length;
+      content = lines.slice(start, end).join('\n');
+    }
+
+    // 輸出檔案資訊（作為註解）
+    console.log(`# File: ${path.basename(filePath)}`);
+    console.log(`# Path: ${filePath}`);
+    console.log(`# Size: ${fs.statSync(filePath).size} bytes`);
+    console.log('---');
+    console.log(content);
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/botrun-c/.claude/skills/GoogleDrive/346/212/200/350/203/275/scripts/gdrive-restore.mjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+/**
+ * gdrive-restore.mjs - 還原 Google Drive 檔案到特定版本
+ *
+ * 使用方式：
+ *   node gdrive-restore.mjs --userId "user123" --fileId "abc123" --revisionId "r1"
+ *
+ * 輸出 JSON：
+ *   {
+ *     "success": true,
+ *     "message": "已還原到版本 r1",
+ *     "newRevisionId": "r4"
+ *   }
+ */
+
+import { parseArgs } from 'node:util';
+
+const API_URL = process.env.API_URL || 'http://localhost:8080';
+const INTERNAL_API_KEY = process.env.INTERNAL_API_KEY || '';
+
+async function main() {
+  const { values } = parseArgs({
+    options: {
+      userId: { type: 'string' },
+      fileId: { type: 'string' },
+      revisionId: { type: 'string' },
+    },
+  });
+
+  const { userId, fileId, revisionId } = values;
+
+  if (!userId || !fileId || !revisionId) {
+    console.error(JSON.stringify({
+      error: 'userId, fileId, and revisionId are required',
+      usage: 'node gdrive-restore.mjs --userId "user123" --fileId "abc123" --revisionId "r1"',
+    }));
+    process.exit(1);
+  }
+
+  try {
+    const response = await fetch(`${API_URL}/api/gdrive/files/${fileId}/restore`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-User-Id': userId,
+        'X-Internal-Key': INTERNAL_API_KEY,
+      },
+      body: JSON.stringify({ revisionId }),
+    });
+
+    const data = await response.json();
+
+    if (!data.success) {
+      throw new Error(data.error || data.message || 'Failed to restore revision');
+    }
+
+    console.log(JSON.stringify({
+      success: true,
+      restoredTo: revisionId,
+      newRevisionId: data.newRevisionId,
+      modifiedTime: data.modifiedTime,
+      message: data.message || `已還原到版本 ${revisionId}`,
+    }, null, 2));
+
+  } catch (error) {
+    console.error(JSON.stringify({
+      success: false,
+      error: error.message,
+    }));
+    process.exit(1);
+  }
+}
+
+main();

package/botrun-c/.claude/skills/GoogleDrive/346/212/200/350/203/275/scripts/gdrive-search.mjs

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+
+/**
+ * gdrive-search.mjs - 在已同步的 Google Drive 資料夾中搜尋
+ *
+ * 使用方式：
+ *   node gdrive-search.mjs --userId "user123" --query "關鍵字"
+ *   node gdrive-search.mjs --userId "user123" --query "關鍵字" --folder "folderId"
+ *
+ * 輸出 JSON：
+ *   {
+ *     "query": "關鍵字",
+ *     "results": [
+ *       { "path": "file.md", "name": "file.md", "matches": 3, "preview": "..." }
+ *     ]
+ *   }
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+
+// 解析命令列參數
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = {
+    userId: 'anonymous',
+    query: '',
+    folderId: null,
+    maxResults: 20,
+    contextLines: 2
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--userId' && args[i + 1]) {
+      result.userId = args[i + 1];
+      i++;
+    } else if (args[i] === '--query' && args[i + 1]) {
+      result.query = args[i + 1];
+      i++;
+    } else if (args[i] === '--folder' && args[i + 1]) {
+      result.folderId = args[i + 1];
+      i++;
+    } else if (args[i] === '--max' && args[i + 1]) {
+      result.maxResults = parseInt(args[i + 1], 10);
+      i++;
+    }
+  }
+
+  return result;
+}
+
+// 取得快取根目錄（使用 /tmp SSD，速度極快）
+function getCacheRoot(userId) {
+  // 驗證 userId 格式（防止路徑遍歷攻擊）
+  if (!userId || typeof userId !== 'string' || !/^[a-zA-Z0-9]+$/.test(userId)) {
+    throw new Error(`Invalid userId format: ${userId}`);
+  }
+  return `/tmp/${userId}/gdrive`;
+}
+
+// 取得索引路徑（注意：backend 使用 .index.json 隱藏檔）
+function getIndexPath(userId) {
+  return path.join(getCacheRoot(userId), '.index.json');
+}
+
+// 讀取索引
+function readIndex(userId) {
+  const indexPath = getIndexPath(userId);
+
+  if (!fs.existsSync(indexPath)) {
+    return { folders: [], files: [] };
+  }
+
+  try {
+    const content = fs.readFileSync(indexPath, 'utf-8');
+    return JSON.parse(content);
+  } catch (error) {
+    return { folders: [], files: [] };
+  }
+}
+
+// 使用 ripgrep 搜尋
+function searchWithRipgrep(searchPath, query, contextLines = 2) {
+  try {
+    // 使用 rg 進行搜尋，輸出 JSON 格式
+    const cmd = `rg --json -i -C ${contextLines} ${JSON.stringify(query)} ${JSON.stringify(searchPath)} 2>/dev/null || true`;
+    const output = execSync(cmd, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+
+    if (!output.trim()) {
+      return [];
+    }
+
+    // 解析 ripgrep JSON 輸出
+    const results = new Map();
+
+    output.split('\n').filter(line => line.trim()).forEach(line => {
+      try {
+        const data = JSON.parse(line);
+
+        if (data.type === 'match') {
+          const filePath = data.data.path.text;
+          const lineNum = data.data.line_number;
+          const lineText = data.data.lines.text.trim();
+
+          if (!results.has(filePath)) {
+            results.set(filePath, {
+              path: filePath,
+              name: path.basename(filePath),
+              matches: 0,
+              lines: []
+            });
+          }
+
+          const result = results.get(filePath);
+          result.matches++;
+          if (result.lines.length < 5) {
+            result.lines.push({
+              lineNumber: lineNum,
+              text: lineText.substring(0, 200)
+            });
+          }
+        }
+      } catch (e) {
+        // 忽略解析錯誤
+      }
+    });
+
+    return Array.from(results.values());
+  } catch (error) {
+    console.error(`Search error: ${error.message}`);
+    return [];
+  }
+}
+
+// 使用 grep 作為備選方案
+function searchWithGrep(searchPath, query) {
+  try {
+    const cmd = `grep -ril ${JSON.stringify(query)} ${JSON.stringify(searchPath)} 2>/dev/null | head -20`;
+    const output = execSync(cmd, { encoding: 'utf-8' });
+
+    if (!output.trim()) {
+      return [];
+    }
+
+    const files = output.trim().split('\n').filter(f => f);
+
+    return files.map(filePath => {
+      // 計算匹配次數
+      let matches = 0;
+      try {
+        const countCmd = `grep -ci ${JSON.stringify(query)} ${JSON.stringify(filePath)} 2>/dev/null || echo "0"`;
+        matches = parseInt(execSync(countCmd, { encoding: 'utf-8' }).trim(), 10);
+      } catch (e) {
+        matches = 1;
+      }
+
+      // 取得預覽
+      let preview = '';
+      try {
+        const previewCmd = `grep -i -m 3 ${JSON.stringify(query)} ${JSON.stringify(filePath)} 2>/dev/null | head -3`;
+        preview = execSync(previewCmd, { encoding: 'utf-8' }).trim();
+      } catch (e) {
+        // ignore
+      }
+
+      return {
+        path: filePath,
+        name: path.basename(filePath),
+        matches,
+        preview: preview.substring(0, 300)
+      };
+    });
+  } catch (error) {
+    return [];
+  }
+}
+
+// 主函數
+async function main() {
+  const { userId, query, folderId, maxResults, contextLines } = parseArgs();
+
+  if (!query) {
+    console.error(JSON.stringify({
+      error: true,
+      message: 'Query is required. Use --query "keyword"'
+    }, null, 2));
+    process.exit(1);
+  }
+
+  try {
+    const cacheRoot = getCacheRoot(userId);
+    const index = readIndex(userId);
+
+    // 決定搜尋路徑
+    let searchPaths = [];
+
+    if (folderId) {
+      // 搜尋指定資料夾（檔案直接在 folderId 目錄下，無 converted 子目錄）
+      const folderPath = path.join(cacheRoot, folderId);
+      if (fs.existsSync(folderPath)) {
+        searchPaths.push(folderPath);
+      }
+    } else {
+      // 搜尋所有選中的資料夾
+      for (const folder of index.folders) {
+        if (folder.selected !== false) {
+          const folderPath = path.join(cacheRoot, folder.id);
+          if (fs.existsSync(folderPath)) {
+            searchPaths.push(folderPath);
+          }
+        }
+      }
+    }
+
+    if (searchPaths.length === 0) {
+      console.log(JSON.stringify({
+        query,
+        message: 'No synced folders found or no folders selected.',
+        results: []
+      }, null, 2));
+      return;
+    }
+
+    // 執行搜尋
+    let allResults = [];
+
+    for (const searchPath of searchPaths) {
+      // 優先使用 ripgrep
+      let results = searchWithRipgrep(searchPath, query, contextLines);
+
+      // 如果 ripgrep 失敗，使用 grep
+      if (results.length === 0) {
+        results = searchWithGrep(searchPath, query);
+      }
+
+      allResults = allResults.concat(results);
+    }
+
+    // 排序：匹配次數多的在前
+    allResults.sort((a, b) => b.matches - a.matches);
+
+    // 限制結果數量
+    allResults = allResults.slice(0, maxResults);
+
+    // 格式化輸出
+    const output = {
+      query,
+      userId,
+      searchPaths,
+      totalResults: allResults.length,
+      results: allResults.map(r => ({
+        path: r.path,
+        name: r.name,
+        matches: r.matches,
+        preview: r.preview || (r.lines ? r.lines.map(l => l.text).join('\n') : '')
+      }))
+    };
+
+    console.log(JSON.stringify(output, null, 2));
+  } catch (error) {
+    console.error(JSON.stringify({
+      error: true,
+      message: error.message
+    }, null, 2));
+    process.exit(1);
+  }
+}
+
+main();

package/botrun-c/.claude/skills/GoogleDrive/346/212/200/350/203/275/scripts/gdrive-sync-back.mjs

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+
+/**
+ * gdrive-sync-back.mjs - 將本地編輯的檔案同步回 Google Drive
+ *
+ * 使用方式：
+ *   node gdrive-sync-back.mjs --userId "user123" --file "/tmp/user123/gdrive/folder/file.md"
+ *
+ * 輸出 JSON：
+ *   {
+ *     "success": true,
+ *     "file": { "id": "xxx", "name": "file.md" },
+ *     "message": "檔案已同步回 Google Drive"
+ *   }
+ */
+
+import { parseArgs } from 'node:util';
+import { readFileSync, existsSync } from 'fs';
+import path from 'path';
+
+const API_URL = process.env.API_URL || 'http://localhost:8080';
+const INTERNAL_API_KEY = process.env.INTERNAL_API_KEY || '';
+
+async function main() {
+  const { values } = parseArgs({
+    options: {
+      userId: { type: 'string' },
+      file: { type: 'string' },
+      fileId: { type: 'string' },
+    },
+  });
+
+  const { userId, file, fileId } = values;
+
+  if (!userId) {
+    console.error(JSON.stringify({
+      error: 'userId is required',
+      usage: 'node gdrive-sync-back.mjs --userId "user123" --file "/path/to/file" [--fileId "abc123"]',
+    }));
+    process.exit(1);
+  }
+
+  if (!file && !fileId) {
+    console.error(JSON.stringify({
+      error: '必須提供 --file 或 --fileId 參數',
+    }));
+    process.exit(1);
+  }
+
+  try {
+    let targetFileId = fileId;
+    let content;
+
+    if (file) {
+      // 檢查檔案存在
+      if (!existsSync(file)) {
+        throw new Error(`檔案不存在: ${file}`);
+      }
+
+      // 讀取檔案內容
+      content = readFileSync(file, 'utf-8');
+
+      // 如果沒有提供 fileId，嘗試從路徑解析
+      // 路徑格式: /tmp/{userId}/gdrive/{folderId}/{fileName}
+      if (!targetFileId) {
+        const cacheRoot = `/tmp/${userId}/gdrive/`;
+        if (!file.startsWith(cacheRoot)) {
+          throw new Error('檔案路徑不在 GDrive 快取目錄內，請提供 --fileId');
+        }
+
+        // 嘗試從索引中找到 fileId
+        const indexPath = path.join(cacheRoot, '.index.json');
+        if (existsSync(indexPath)) {
+          const index = JSON.parse(readFileSync(indexPath, 'utf-8'));
+          const relativePath = file.replace(cacheRoot, '');
+          const fileName = path.basename(file);
+
+          // 在索引中搜尋
+          const fileEntry = index.files?.find(f =>
+            f.path === relativePath || f.name === fileName
+          );
+
+          if (fileEntry) {
+            targetFileId = fileEntry.id;
+          }
+        }
+
+        if (!targetFileId) {
+          throw new Error('無法從快取索引找到對應的 fileId，請提供 --fileId');
+        }
+      }
+    }
+
+    // 如果只有 fileId，需要從快取中讀取最新內容
+    if (!content && targetFileId) {
+      throw new Error('使用 --fileId 時必須同時提供 --file 參數');
+    }
+
+    // 更新檔案
+    const response = await fetch(`${API_URL}/api/gdrive/files/${targetFileId}`, {
+      method: 'PUT',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-User-Id': userId,
+        'X-Internal-Key': INTERNAL_API_KEY,
+      },
+      body: JSON.stringify({
+        content,
+        mimeType: detectMimeType(file || ''),
+      }),
+    });
+
+    const data = await response.json();
+
+    if (!data.success) {
+      throw new Error(data.error || data.message || 'Failed to sync file');
+    }
+
+    console.log(JSON.stringify({
+      success: true,
+      file: data.file,
+      message: '檔案已同步回 Google Drive',
+    }, null, 2));
+
+  } catch (error) {
+    console.error(JSON.stringify({
+      success: false,
+      error: error.message,
+    }));
+    process.exit(1);
+  }
+}
+
+/**
+ * 根據檔名偵測 MIME 類型
+ */
+function detectMimeType(fileName) {
+  const ext = fileName.split('.').pop()?.toLowerCase();
+  const mimeTypes = {
+    'txt': 'text/plain',
+    'md': 'text/markdown',
+    'json': 'application/json',
+    'csv': 'text/csv',
+    'html': 'text/html',
+    'css': 'text/css',
+    'js': 'text/javascript',
+    'ts': 'text/typescript',
+    'xml': 'text/xml',
+    'yaml': 'text/yaml',
+    'yml': 'text/yaml',
+  };
+  return mimeTypes[ext] || 'text/plain';
+}
+
+main();