nothumanallowed 11.6.2 → 12.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nothumanallowed",
-  "version": "11.6.2",
-  "description": "NotHumanAllowed — 38 AI agents, 70 tools. Email, calendar, browser automation, screen capture, canvas, cron/heartbeat, Alexandria E2E messaging, GitHub, Notion, Slack, voice chat, free AI (Liara), 28 languages. Zero-dependency CLI.",
+  "version": "12.0.0",
+  "description": "NotHumanAllowed — 38 AI agents, 80 tools. Email, calendar, browser automation, screen capture, canvas, cron/heartbeat, Alexandria E2E messaging, GitHub, Notion, Slack, voice chat, free AI (Liara), 28 languages. Zero-dependency CLI.",
   "type": "module",
   "bin": {
     "nha": "./bin/nha.mjs",

package/src/commands/ui.mjs

@@ -800,6 +800,79 @@ export async function cmdUI(args) {
         return;
       }
 
+      // GET /api/drive/read/:fileId — read file as text
+      if (method === 'GET' && pathname.startsWith('/api/drive/read/')) {
+        const fileId = pathname.split('/api/drive/read/')[1];
+        try {
+          const gd = await import('../services/google-drive.mjs');
+          const content = await gd.readFileAsText(config, fileId);
+          sendJSON(res, 200, { content });
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // GET /api/drive/download/:fileId — download file as base64
+      if (method === 'GET' && pathname.startsWith('/api/drive/download/')) {
+        const fileId = pathname.split('/api/drive/download/')[1];
+        try {
+          const gd = await import('../services/google-drive.mjs');
+          const dl = await gd.downloadFileContent(config, fileId);
+          sendJSON(res, 200, dl);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // POST /api/drive/update/:fileId — update file content
+      if (method === 'POST' && pathname.startsWith('/api/drive/update/')) {
+        const fileId = pathname.split('/api/drive/update/')[1];
+        try {
+          const body = await readBody(req);
+          const gd = await import('../services/google-drive.mjs');
+          const result = await gd.updateFileContent(config, fileId, body.content || '');
+          sendJSON(res, 200, result);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // POST /api/drive/upload — upload new file
+      if (method === 'POST' && pathname === '/api/drive/upload') {
+        try {
+          const body = await readBody(req);
+          const gd = await import('../services/google-drive.mjs');
+          let content = body.content || '';
+          if (body.encoding === 'base64') content = Buffer.from(content, 'base64');
+          const result = await gd.uploadFile(config, body.name, content, body.mimeType || 'text/plain', body.folderId || 'root');
+          sendJSON(res, 200, result);
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
+      // POST /api/drive/delete/:fileId — trash file
+      if (method === 'POST' && pathname.startsWith('/api/drive/delete/')) {
+        const fileId = pathname.split('/api/drive/delete/')[1];
+        try {
+          const gd = await import('../services/google-drive.mjs');
+          await gd.trashFile(config, fileId);
+          sendJSON(res, 200, { ok: true });
+        } catch (e) {
+          sendJSON(res, 500, { error: e.message });
+        }
+        logRequest(method, pathname, 200, Date.now() - start);
+        return;
+      }
+
       // GET /api/emails?page=0&pageSize=25&filter=unread|all
       if (method === 'GET' && pathname === '/api/emails') {
         try {

package/src/constants.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const VERSION = '11.6.2';
+export const VERSION = '12.0.0';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/services/google-drive.mjs

@@ -165,6 +165,147 @@ export async function downloadFileContent(config, fileId) {
   };
 }
 
+/**
+ * Upload a file to Google Drive.
+ * @param {object} config
+ * @param {string} name — filename
+ * @param {string|Buffer} content — file content (string for text, Buffer for binary)
+ * @param {string} mimeType — e.g. 'text/plain', 'application/pdf'
+ * @param {string} folderId — parent folder ID (default: root)
+ * @returns {Promise<object>} uploaded file metadata
+ */
+export async function uploadFile(config, name, content, mimeType = 'text/plain', folderId = 'root') {
+  const token = await getAccessToken(config);
+  const metadata = {
+    name,
+    parents: [folderId],
+  };
+
+  // Multipart upload
+  const boundary = '===NHA_UPLOAD_BOUNDARY===';
+  const body = [
+    `--${boundary}`,
+    'Content-Type: application/json; charset=UTF-8',
+    '',
+    JSON.stringify(metadata),
+    `--${boundary}`,
+    `Content-Type: ${mimeType}`,
+    'Content-Transfer-Encoding: base64',
+    '',
+    Buffer.from(content).toString('base64'),
+    `--${boundary}--`,
+  ].join('\r\n');
+
+  const res = await fetch('https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart&fields=id,name,mimeType,size,webViewLink', {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${token}`,
+      'Content-Type': `multipart/related; boundary=${boundary}`,
+    },
+    body,
+  });
+
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Drive upload ${res.status}: ${err.slice(0, 200)}`);
+  }
+
+  return parseFile(await res.json());
+}
+
+/**
+ * Update (overwrite) file content on Drive.
+ */
+export async function updateFileContent(config, fileId, content, mimeType = 'text/plain') {
+  const token = await getAccessToken(config);
+  const res = await fetch(`https://www.googleapis.com/upload/drive/v3/files/${fileId}?uploadType=media&fields=id,name,mimeType,size,webViewLink`, {
+    method: 'PATCH',
+    headers: {
+      'Authorization': `Bearer ${token}`,
+      'Content-Type': mimeType,
+    },
+    body: content,
+  });
+
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Drive update ${res.status}: ${err.slice(0, 200)}`);
+  }
+
+  return parseFile(await res.json());
+}
+
+/**
+ * Delete a file (move to trash).
+ */
+export async function trashFile(config, fileId) {
+  const token = await getAccessToken(config);
+  const res = await fetch(`${DRIVE_BASE}/files/${fileId}`, {
+    method: 'PATCH',
+    headers: {
+      'Authorization': `Bearer ${token}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ trashed: true }),
+  });
+
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Drive trash ${res.status}: ${err.slice(0, 200)}`);
+  }
+
+  return { ok: true };
+}
+
+/**
+ * Read text content of a file directly (for text files, code, docs).
+ * For Google Docs, exports as plain text. For other text files, downloads raw.
+ * @returns {Promise<string>} file content as text
+ */
+export async function readFileAsText(config, fileId) {
+  const token = await getAccessToken(config);
+  const meta = await getFile(config, fileId);
+
+  let downloadUrl;
+
+  // Google Workspace files need export
+  if (meta.mimeType === 'application/vnd.google-apps.document') {
+    downloadUrl = `${DRIVE_BASE}/files/${fileId}/export?mimeType=text/plain`;
+  } else if (meta.mimeType === 'application/vnd.google-apps.spreadsheet') {
+    downloadUrl = `${DRIVE_BASE}/files/${fileId}/export?mimeType=text/csv`;
+  } else if (meta.mimeType.startsWith('application/vnd.google-apps.')) {
+    downloadUrl = `${DRIVE_BASE}/files/${fileId}/export?mimeType=text/plain`;
+  } else {
+    downloadUrl = `${DRIVE_BASE}/files/${fileId}?alt=media`;
+  }
+
+  const res = await fetch(downloadUrl, {
+    headers: { 'Authorization': `Bearer ${token}` },
+  });
+
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Drive read ${res.status}: ${err.slice(0, 200)}`);
+  }
+
+  return res.text();
+}
+
+/**
+ * Create a folder on Drive.
+ */
+export async function createFolder(config, name, parentId = 'root') {
+  return driveFetch(config, '/files', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      name,
+      mimeType: 'application/vnd.google-apps.folder',
+      parents: [parentId],
+    }),
+  });
+}
+
 // ── Helpers ─────────────────────────────────────────────────────────────
 
 function parseFile(raw) {

package/src/services/tool-executor.mjs

@@ -65,6 +65,10 @@ export const DESTRUCTIVE_ACTIONS = new Set([
   'notify_remind',
   'slack_send',
   'github_create_issue',
+  'file_write',
+  'drive_upload',
+  'drive_update',
+  'drive_delete',
 ]);
 
 // ── Tool Definitions (for system prompt) ─────────────────────────────────────
@@ -377,12 +381,74 @@ TOOLS:
     Use this when the user asks to check messages, read a conversation, or see what others wrote.
     If channel is not specified, reads from the active channel. Channel can be an ID or a name.
 
+--- FILE MANAGER ---
+
+68. file_list(path?: string, pattern?: string)
+    List files and folders in a directory. Default path is the current working directory.
+    pattern filters by glob (e.g. "*.js", "*.csv"). Shows: name, size, type (file/dir), modified date.
+    Use when the user asks "show files", "what's in this folder", "list files in ~/Downloads".
+
+69. file_read(path: string, lines?: number)
+    Read the content of a text file. Returns up to 500 lines by default (adjustable with lines parameter).
+    Supports: .txt, .md, .json, .csv, .js, .ts, .py, .html, .css, .xml, .yaml, .toml, .env, .log, .sh, and similar text formats.
+    Use when the user asks "read this file", "show me the contents of", "open file X".
+    For binary files (images, PDFs, etc.), returns file info instead of content.
+
+70. file_write(path: string, content: string, append?: boolean)
+    Write content to a file. Creates the file if it doesn't exist. Creates parent directories if needed.
+    append=true adds to the end instead of overwriting.
+    ALWAYS confirm with the user before writing. NEVER overwrite without permission.
+    Use when the user asks "create a file", "save this to", "write to".
+
+71. file_info(path: string)
+    Get detailed info about a file or folder: size, created date, modified date, permissions, type, extension.
+    For directories: also shows total items count and total size.
+    Use when the user asks "how big is this file", "when was this modified", "file details".
+
+72. file_search(query: string, path?: string, content?: boolean)
+    Search for files by name. Default path is current directory, searches recursively.
+    content=true also searches inside file contents (like grep). Max depth: 5 levels. Max results: 50.
+    Use when the user asks "find files named", "search for", "where is the file".
+
+--- GOOGLE DRIVE ---
+
+73. drive_list(filter?: "recent"|"starred"|"shared", query?: string, maxResults?: number)
+    List files from Google Drive. filter="recent" shows last 7 days, "starred" shows starred, "shared" shows shared with me.
+    query is a search term to find files by name. Default: all files, 20 results.
+
+74. drive_read(fileId: string)
+    Read the text content of a Drive file. Works with Google Docs (exported as plain text), Sheets (as CSV), and any text/code file.
+    Returns the content as text. For binary files (images, PDFs), use drive_download instead.
+
+75. drive_upload(name: string, content: string, mimeType?: string, folderId?: string)
+    Upload a new file to Google Drive. content is the file text content.
+    mimeType defaults to "text/plain". folderId defaults to root.
+    ALWAYS confirm before uploading. Use for creating new files on Drive.
+
+76. drive_update(fileId: string, content: string)
+    Update (overwrite) the content of an existing Drive file.
+    ALWAYS confirm before updating. Use for saving edits to existing files.
+
+77. drive_delete(fileId: string)
+    Move a Drive file to trash. ALWAYS confirm before deleting.
+
+78. drive_info(fileId: string)
+    Get detailed metadata of a Drive file: size, type, owner, dates, sharing status, link.
+
+79. drive_folder(folderId?: string)
+    List files inside a specific Drive folder. Default: root folder.
+    Returns files with their IDs, names, types, sizes.
+
+80. drive_download(fileId: string)
+    Download a file from Drive. For Google Docs/Sheets/Slides, exports as PDF.
+    Returns the file as base64-encoded content. Use for binary files, PDFs, images.
+
 RULES:
 - ABSOLUTE RULE: NEVER LIE. NEVER fabricate, invent, or guess information. If you do not know, say "I don't know." If a tool fails, say it failed. If you cannot see something, say so. Honesty is MORE important than being helpful.
 - CRITICAL: For web searches, ALWAYS use web_search — NEVER open Google/Bing/DuckDuckGo in the browser.
 - CRITICAL: For web searches ("search for X", "find X online", "look up X"), ALWAYS use web_search — NEVER open Google/Bing/DuckDuckGo in the browser. web_search is faster, more reliable, and doesn't get blocked by CAPTCHAs. Only use browser_open for interacting with specific websites (filling forms, clicking buttons, taking screenshots of specific pages).
 - For search/read operations, execute immediately and present results conversationally.
-- For write/send/delete operations (gmail_send, gmail_reply, gmail_delete, calendar_create, calendar_move, calendar_update, contact_delete, task_done, notify_remind), DESCRIBE what you're about to do and include the JSON block so the system can ask the user for confirmation.
+- For write/send/delete operations (gmail_send, gmail_reply, gmail_delete, calendar_create, calendar_move, calendar_update, contact_delete, task_done, notify_remind, file_write), DESCRIBE what you're about to do and include the JSON block so the system can ask the user for confirmation.
 - For schedule_meeting and schedule_draft_email, execute immediately — these are read operations that suggest slots.
 - When presenting email results, show From, Subject, Date, and a brief snippet. Never dump raw JSON.
 - When presenting calendar events, show Time, Title, Location/Link. Format times in a human-readable way.
@@ -530,11 +596,24 @@ export function describeAction(action, params) {
       return `Send Slack message to #${params.channel}`;
     case 'github_create_issue':
       return `Create GitHub issue on ${params.repo}: "${params.title}"`;
+    case 'file_write':
+      return `${params.append ? 'Append to' : 'Write'} file: ${params.path} (${params.content?.length || 0} chars)`;
+    case 'drive_upload':
+      return `Upload to Drive: ${params.name}`;
+    case 'drive_update':
+      return `Update Drive file: ${params.fileId}`;
+    case 'drive_delete':
+      return `Delete from Drive: ${params.fileId}`;
     default:
       return `Execute ${action}`;
   }
 }
 
+function driveIcon(type) {
+  const icons = { folder: '📁', doc: '📄', sheet: '📊', slides: '🎬', pdf: '📕', image: '🖼️', video: '🎥', audio: '🎵', archive: '📦', text: '📝', file: '📄' };
+  return icons[type] || icons.file;
+}
+
 /**
  * Build the system prompt with TOOL_DEFINITIONS + persona + profile + context.
  * @param {string} persona — e.g. "NHA Chat", "NHA Voice"
@@ -1576,7 +1655,294 @@ export async function executeTool(action, params, config) {
       }
     }
 
+    // ── Google Drive ──────────────────────────────────────────────────────
+    case 'drive_list': {
+      const drv = await import('./google-drive.mjs');
+      let files;
+      if (params.query) {
+        files = await drv.searchFiles(config, params.query, params.maxResults || 20);
+      } else if (params.filter === 'recent') {
+        files = await drv.getRecentFiles(config, params.maxResults || 20);
+      } else if (params.filter === 'starred') {
+        files = await drv.getStarredFiles(config, params.maxResults || 20);
+      } else if (params.filter === 'shared') {
+        files = await drv.getSharedFiles(config, params.maxResults || 20);
+      } else {
+        files = await drv.listFiles(config, params.maxResults || 20);
+      }
+      if (files.length === 0) return 'No files found on Drive.';
+      return files.map((f, i) =>
+        `${i + 1}. [${f.id}] ${driveIcon(f.type)} ${f.name}${f.size ? ' (' + f.size + ')' : ''} — ${f.modifiedTime ? new Date(f.modifiedTime).toLocaleDateString() : ''}${f.shared ? ' [shared]' : ''}${f.starred ? ' ★' : ''}`
+      ).join('\n');
+    }
+
+    case 'drive_read': {
+      if (!params.fileId) return 'Error: fileId required. Use drive_list first to get file IDs.';
+      const drv = await import('./google-drive.mjs');
+      const text = await drv.readFileAsText(config, params.fileId);
+      if (text.length > 10000) return text.slice(0, 10000) + '\n\n[... truncated at 10000 chars]';
+      return text;
+    }
+
+    case 'drive_upload': {
+      if (!params.name || !params.content) return 'Error: name and content required.';
+      const drv = await import('./google-drive.mjs');
+      const uploaded = await drv.uploadFile(config, params.name, params.content, params.mimeType || 'text/plain', params.folderId || 'root');
+      return `Uploaded: ${uploaded.name} (${uploaded.size || ''}) — ${uploaded.webViewLink || uploaded.id}`;
+    }
+
+    case 'drive_update': {
+      if (!params.fileId || !params.content) return 'Error: fileId and content required.';
+      const drv = await import('./google-drive.mjs');
+      const updated = await drv.updateFileContent(config, params.fileId, params.content);
+      return `Updated: ${updated.name} — ${updated.webViewLink || updated.id}`;
+    }
+
+    case 'drive_delete': {
+      if (!params.fileId) return 'Error: fileId required.';
+      const drv = await import('./google-drive.mjs');
+      await drv.trashFile(config, params.fileId);
+      return `File ${params.fileId} moved to trash.`;
+    }
+
+    case 'drive_info': {
+      if (!params.fileId) return 'Error: fileId required.';
+      const drv = await import('./google-drive.mjs');
+      const f = await drv.getFile(config, params.fileId);
+      return [
+        `Name: ${f.name}`,
+        `Type: ${f.type} (${f.mimeType})`,
+        `Size: ${f.size || 'unknown'}`,
+        `Modified: ${f.modifiedTime}`,
+        `Created: ${f.createdTime || 'unknown'}`,
+        `Owner: ${f.owner}`,
+        `Shared: ${f.shared ? 'yes' : 'no'}`,
+        `Starred: ${f.starred ? 'yes' : 'no'}`,
+        `Link: ${f.webViewLink}`,
+        f.description ? `Description: ${f.description}` : '',
+      ].filter(Boolean).join('\n');
+    }
+
+    case 'drive_folder': {
+      const drv = await import('./google-drive.mjs');
+      const files = await drv.listFolder(config, params.folderId || 'root', 30);
+      if (files.length === 0) return 'Empty folder.';
+      return files.map((f, i) =>
+        `${i + 1}. [${f.id}] ${driveIcon(f.type)} ${f.name}${f.size ? ' (' + f.size + ')' : ''}`
+      ).join('\n');
+    }
+
+    case 'drive_download': {
+      if (!params.fileId) return 'Error: fileId required.';
+      const drv = await import('./google-drive.mjs');
+      const dl = await drv.downloadFileContent(config, params.fileId);
+      return `Downloaded: ${dl.name} (${formatFileSize(dl.size)}, ${dl.mimeType})\n[File content available as base64 — ${dl.base64.length} chars]`;
+    }
+
+    // ── File Manager (Local) ────────────────────────────────────────────
+    case 'file_list': {
+      const fsM = await import('fs');
+      const pathM = await import('path');
+      const osM = await import('os');
+      let dir = params.path || process.cwd();
+      dir = dir.replace(/^~/, osM.default.homedir());
+      dir = pathM.default.resolve(dir);
+
+      if (!fsM.default.existsSync(dir)) return `Directory not found: ${dir}`;
+      if (!fsM.default.statSync(dir).isDirectory()) return `Not a directory: ${dir}`;
+
+      // Security: block sensitive paths
+      const blocked = ['/etc/shadow', '/etc/passwd', '.ssh/id_', '.gnupg/', 'Keychain'];
+      if (blocked.some(b => dir.includes(b))) return 'Access denied — sensitive path.';
+
+      let entries = fsM.default.readdirSync(dir, { withFileTypes: true });
+
+      // Pattern filter
+      if (params.pattern) {
+        const pat = params.pattern.replace(/\./g, '\\.').replace(/\*/g, '.*').replace(/\?/g, '.');
+        const re = new RegExp(`^${pat}$`, 'i');
+        entries = entries.filter(e => re.test(e.name));
+      }
+
+      if (entries.length === 0) return `Empty directory: ${dir}`;
+
+      const lines = entries.slice(0, 100).map(e => {
+        const full = pathM.default.join(dir, e.name);
+        try {
+          const st = fsM.default.statSync(full);
+          const size = e.isDirectory() ? '<DIR>' : formatFileSize(st.size);
+          const mod = st.mtime.toISOString().split('T')[0];
+          return `${e.isDirectory() ? 'd' : '-'} ${size.padStart(10)}  ${mod}  ${e.name}`;
+        } catch {
+          return `?          ?           ${e.name}`;
+        }
+      });
+
+      return `${dir}/ (${entries.length} items${entries.length > 100 ? ', showing first 100' : ''})\n\n${lines.join('\n')}`;
+    }
+
+    case 'file_read': {
+      const fsR = await import('fs');
+      const pathR = await import('path');
+      const osR = await import('os');
+      let filePath = params.path;
+      filePath = filePath.replace(/^~/, osR.default.homedir());
+      filePath = pathR.default.resolve(filePath);
+
+      if (!fsR.default.existsSync(filePath)) return `File not found: ${filePath}`;
+      const stat = fsR.default.statSync(filePath);
+
+      if (stat.isDirectory()) return `"${filePath}" is a directory. Use file_list to browse it.`;
+
+      // Block sensitive files
+      const sensitivePatterns = ['.ssh/id_', '.gnupg/', 'Keychain', '.env', 'credentials', 'secret', '.npmrc', '.pypirc'];
+      if (sensitivePatterns.some(p => filePath.includes(p))) return 'Access denied — sensitive file.';
+
+      // Binary check
+      const ext = pathR.default.extname(filePath).toLowerCase();
+      const binaryExts = new Set(['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp', '.mp3', '.mp4', '.avi', '.mov', '.zip', '.tar', '.gz', '.rar', '.7z', '.exe', '.dll', '.so', '.dylib', '.bin', '.dat', '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx', '.woff', '.woff2', '.ttf', '.otf', '.eot']);
+      if (binaryExts.has(ext)) {
+        return `Binary file: ${pathR.default.basename(filePath)} (${formatFileSize(stat.size)}, ${ext} format). Cannot display content.`;
+      }
+
+      // Size check
+      if (stat.size > 1024 * 1024) return `File too large to display: ${formatFileSize(stat.size)}. Use file_info for details.`;
+
+      const maxLines = params.lines || 500;
+      const content = fsR.default.readFileSync(filePath, 'utf-8');
+      const lines = content.split('\n');
+      const truncated = lines.length > maxLines;
+      const display = lines.slice(0, maxLines).join('\n');
+
+      return `${pathR.default.basename(filePath)} (${formatFileSize(stat.size)}, ${lines.length} lines)${truncated ? ` [showing first ${maxLines}]` : ''}\n\n${display}`;
+    }
+
+    case 'file_write': {
+      const fsW = await import('fs');
+      const pathW = await import('path');
+      const osW = await import('os');
+      let writePath = params.path;
+      writePath = writePath.replace(/^~/, osW.default.homedir());
+      writePath = pathW.default.resolve(writePath);
+
+      // Block writing to sensitive locations
+      const blockedWrite = ['/etc/', '/usr/', '/bin/', '/sbin/', '/System/', '/Library/', '.ssh/', '.gnupg/', 'node_modules/'];
+      if (blockedWrite.some(b => writePath.includes(b))) return 'Access denied — cannot write to system/sensitive paths.';
+
+      // Create parent directories
+      const dir = pathW.default.dirname(writePath);
+      if (!fsW.default.existsSync(dir)) {
+        fsW.default.mkdirSync(dir, { recursive: true });
+      }
+
+      if (params.append) {
+        fsW.default.appendFileSync(writePath, params.content, 'utf-8');
+        return `Appended ${params.content.length} chars to ${writePath}`;
+      } else {
+        fsW.default.writeFileSync(writePath, params.content, 'utf-8');
+        return `Written ${params.content.length} chars to ${writePath}`;
+      }
+    }
+
+    case 'file_info': {
+      const fsI = await import('fs');
+      const pathI = await import('path');
+      const osI = await import('os');
+      let infoPath = params.path;
+      infoPath = infoPath.replace(/^~/, osI.default.homedir());
+      infoPath = pathI.default.resolve(infoPath);
+
+      if (!fsI.default.existsSync(infoPath)) return `Not found: ${infoPath}`;
+      const st = fsI.default.statSync(infoPath);
+
+      const info = [
+        `Path: ${infoPath}`,
+        `Type: ${st.isDirectory() ? 'directory' : 'file'}`,
+        `Size: ${formatFileSize(st.size)}`,
+        `Created: ${st.birthtime.toISOString()}`,
+        `Modified: ${st.mtime.toISOString()}`,
+        `Permissions: ${(st.mode & 0o777).toString(8)}`,
+      ];
+
+      if (!st.isDirectory()) {
+        info.push(`Extension: ${pathI.default.extname(infoPath) || '(none)'}`);
+      } else {
+        try {
+          const items = fsI.default.readdirSync(infoPath);
+          info.push(`Items: ${items.length}`);
+        } catch { /* permission denied */ }
+      }
+
+      return info.join('\n');
+    }
+
+    case 'file_search': {
+      const fsS = await import('fs');
+      const pathS = await import('path');
+      const osS = await import('os');
+      let searchDir = params.path || process.cwd();
+      searchDir = searchDir.replace(/^~/, osS.default.homedir());
+      searchDir = pathS.default.resolve(searchDir);
+
+      if (!fsS.default.existsSync(searchDir)) return `Directory not found: ${searchDir}`;
+
+      const query = params.query.toLowerCase();
+      const searchContent = params.content || false;
+      const results = [];
+      const maxDepth = 5;
+      const maxResults = 50;
+
+      function searchRecursive(dir, depth) {
+        if (depth > maxDepth || results.length >= maxResults) return;
+        try {
+          const entries = fsS.default.readdirSync(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            if (results.length >= maxResults) break;
+            if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+
+            const full = pathS.default.join(dir, entry.name);
+
+            // Name match
+            if (entry.name.toLowerCase().includes(query)) {
+              const st = fsS.default.statSync(full);
+              results.push(`${entry.isDirectory() ? 'd' : '-'} ${formatFileSize(st.size).padStart(10)}  ${full}`);
+            }
+
+            // Content search
+            if (searchContent && entry.isFile() && !entry.name.match(/\.(png|jpg|gif|mp4|zip|tar|gz|exe|bin|pdf|woff|ttf)$/i)) {
+              try {
+                const st = fsS.default.statSync(full);
+                if (st.size < 512 * 1024) { // Max 512KB per file
+                  const content = fsS.default.readFileSync(full, 'utf-8');
+                  if (content.toLowerCase().includes(query)) {
+                    const lineNum = content.split('\n').findIndex(l => l.toLowerCase().includes(query)) + 1;
+                    if (!results.some(r => r.includes(full))) {
+                      results.push(`- ${formatFileSize(st.size).padStart(10)}  ${full}:${lineNum} (content match)`);
+                    }
+                  }
+                }
+              } catch { /* skip unreadable */ }
+            }
+
+            if (entry.isDirectory()) searchRecursive(full, depth + 1);
+          }
+        } catch { /* permission denied */ }
+      }
+
+      searchRecursive(searchDir, 0);
+
+      if (results.length === 0) return `No files matching "${params.query}" in ${searchDir}`;
+      return `Found ${results.length} match${results.length > 1 ? 'es' : ''} for "${params.query}":\n\n${results.join('\n')}`;
+    }
+
     default:
       return `Unknown action: ${action}`;
   }
 }
+
+function formatFileSize(bytes) {
+  if (bytes === 0) return '0 B';
+  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return `${(bytes / Math.pow(1024, i)).toFixed(i > 0 ? 1 : 0)} ${units[i]}`;
+}

package/src/services/web-ui.mjs

@@ -1365,9 +1365,12 @@ var AGENT_ICONS = {
   prometheus:'\\u{1F525}',cassandra:'\\u26A0',athena:'\\u{1F9E0}',sauron:'\\u{1F441}',conductor:'\\u{1F3BC}',
   navi:'\\u{1F9ED}',edi:'\\u{1F4C8}',tempest:'\\u26C8',epicure:'\\u{1F37D}'
 };
-// ---- DRIVE ----
+// ---- DRIVE (Full File Manager) ----
 var driveData=null;
 var driveFilter='';
+var driveEditorFile=null; // {id,name,content,mimeType} when editing
+var driveViewerFile=null; // {id,name,base64,mimeType} when viewing image/pdf
+
 function renderDrive(el){
   if(!driveData){
     el.innerHTML='<div style="text-align:center;padding:40px"><div class="spinner"></div><div style="color:var(--dim)">Loading Drive...</div></div>';
@@ -1376,27 +1379,37 @@ function renderDrive(el){
     });
     return;
   }
+
+  // If editor is open, render editor instead
+  if(driveEditorFile){renderDriveEditor(el);return;}
+  // If viewer is open, render viewer
+  if(driveViewerFile){renderDriveViewer(el);return;}
+
   var files=driveData.files||[];
   var quota=driveData.quota;
-
   var h='';
 
   // Quota bar
   if(quota){
     h+='<div class="card" style="margin-bottom:12px;padding:12px"><div style="display:flex;justify-content:space-between;margin-bottom:6px"><span style="color:var(--bright);font-size:12px">'+esc(quota.usage)+' of '+esc(quota.limit)+' used</span><span style="color:var(--dim);font-size:11px">'+quota.percentUsed+'%</span></div>';
-    h+='<div style="height:6px;background:var(--bg);border-radius:3px;overflow:hidden"><div style="height:100%;width:'+Math.min(quota.percentUsed,100)+'%;background:'+( quota.percentUsed>90?'var(--red)':quota.percentUsed>70?'var(--amber)':'var(--green)')+';border-radius:3px"></div></div></div>';
+    h+='<div style="height:6px;background:var(--bg);border-radius:3px;overflow:hidden"><div style="height:100%;width:'+Math.min(quota.percentUsed,100)+'%;background:'+(quota.percentUsed>90?'var(--red)':quota.percentUsed>70?'var(--amber)':'var(--green)')+';border-radius:3px"></div></div></div>';
   }
 
-  // Filter bar
+  // Action bar
   h+='<div style="display:flex;gap:6px;margin-bottom:12px;flex-wrap:wrap">';
   ['','recent','starred','shared'].forEach(function(f){
     var label=f||'All Files';
     var active=driveFilter===f;
-    h+='<button onclick="filterDrive(\\x27'+f+'\\x27)" style="padding:6px 14px;border-radius:6px;font-size:11px;background:'+(active?'var(--green3)':'var(--bg3)')+';color:'+(active?'var(--bg)':'var(--dim)')+';border:1px solid '+(active?'var(--green)':'var(--border)')+'">'+esc(label.charAt(0).toUpperCase()+label.slice(1))+'</button>';
+    h+='<button onclick="filterDrive(\\x27'+f+'\\x27)" style="padding:6px 14px;border-radius:6px;font-size:11px;background:'+(active?'var(--green3)':'var(--bg3)')+';color:'+(active?'var(--bg)':'var(--dim)')+';border:1px solid '+(active?'var(--green)':'var(--border)')+';cursor:pointer">'+esc(label.charAt(0).toUpperCase()+label.slice(1))+'</button>';
   });
-  h+='<input type="text" id="driveSearch" placeholder="Search files..." style="flex:1;min-width:120px;font-size:11px;padding:6px 10px" onkeydown="if(event.key===\\x27Enter\\x27)searchDrive()">';
+  h+='<div style="flex:1"></div>';
+  h+='<button onclick="driveNewFile()" style="padding:6px 14px;border-radius:6px;font-size:11px;background:var(--green3);color:var(--bg);border:1px solid var(--green);cursor:pointer">+ New File</button>';
+  h+='<button onclick="driveUploadFile()" style="padding:6px 14px;border-radius:6px;font-size:11px;background:var(--amberdim);color:var(--amber);border:1px solid var(--amber3);cursor:pointer">Upload</button>';
   h+='</div>';
 
+  // Search bar
+  h+='<div style="margin-bottom:12px"><input type="text" id="driveSearch" placeholder="Search files..." style="width:100%;font-size:11px;padding:8px 12px" onkeydown="if(event.key===\\x27Enter\\x27)searchDrive()"></div>';
+
   // File list
   if(files.length===0){
     h+='<div class="card" style="text-align:center;color:var(--dim);padding:30px">No files found</div>';
@@ -1404,14 +1417,31 @@ function renderDrive(el){
     files.forEach(function(f){
       var icon=driveTypeIcon(f.type);
       var date=f.modifiedTime?new Date(f.modifiedTime).toLocaleDateString():'';
-      h+='<div class="card" style="margin-bottom:6px;padding:10px;cursor:pointer" onclick="window.open(\\x27'+esc(f.webViewLink)+'\\x27,\\x27_blank\\x27)">';
+      var isText=f.type==='text'||f.type==='doc'||f.mimeType.includes('text')||f.mimeType.includes('json')||f.mimeType.includes('javascript')||f.mimeType.includes('xml')||f.mimeType.includes('csv')||f.mimeType.includes('yaml')||f.mimeType.includes('markdown')||f.mimeType.includes('html')||f.mimeType.includes('css')||f.mimeType.includes('python')||f.mimeType.includes('php')||f.mimeType.includes('vnd.google-apps.document');
+      var isImage=f.type==='image';
+      var isPdf=f.type==='pdf'||f.mimeType.includes('pdf');
+
+      h+='<div class="card" style="margin-bottom:4px;padding:10px">';
       h+='<div style="display:flex;align-items:center;gap:10px">';
-      h+='<span style="font-size:20px">'+icon+'</span>';
+      h+='<span style="font-size:18px">'+icon+'</span>';
       h+='<div style="flex:1;min-width:0">';
-      h+='<div style="color:var(--bright);font-size:13px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis">'+esc(f.name)+'</div>';
+      h+='<div style="color:var(--bright);font-size:12px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis">'+esc(f.name)+'</div>';
       h+='<div style="color:var(--dim);font-size:10px">'+esc(date)+(f.size?' &middot; '+esc(f.size):'')+(f.shared?' &middot; Shared':'')+(f.starred?' &#9733;':'')+'</div>';
       h+='</div>';
-      h+='<span style="color:var(--dim);font-size:10px">'+esc(f.type)+'</span>';
+      // Action buttons
+      h+='<div style="display:flex;gap:4px;flex-shrink:0">';
+      if(isText){
+        h+='<button onclick="event.stopPropagation();driveOpenEditor(\\x27'+f.id+'\\x27,\\x27'+esc(f.name).replace(/'/g,'\\x27')+'\\x27)" style="padding:3px 8px;font-size:10px;background:var(--bg3);border:1px solid var(--border2);border-radius:4px;color:var(--cyan);cursor:pointer" title="Open in editor">Edit</button>';
+      }
+      if(isImage){
+        h+='<button onclick="event.stopPropagation();driveViewImage(\\x27'+f.id+'\\x27,\\x27'+esc(f.name).replace(/'/g,'\\x27')+'\\x27)" style="padding:3px 8px;font-size:10px;background:var(--bg3);border:1px solid var(--border2);border-radius:4px;color:var(--green);cursor:pointer" title="View image">View</button>';
+      }
+      if(isPdf){
+        h+='<button onclick="event.stopPropagation();driveViewPdf(\\x27'+f.id+'\\x27,\\x27'+esc(f.name).replace(/'/g,'\\x27')+'\\x27)" style="padding:3px 8px;font-size:10px;background:var(--bg3);border:1px solid var(--border2);border-radius:4px;color:var(--amber);cursor:pointer" title="View PDF">PDF</button>';
+      }
+      h+='<button onclick="event.stopPropagation();window.open(\\x27'+esc(f.webViewLink)+'\\x27,\\x27_blank\\x27)" style="padding:3px 8px;font-size:10px;background:var(--bg3);border:1px solid var(--border2);border-radius:4px;color:var(--dim);cursor:pointer" title="Open in Google Drive">Open</button>';
+      h+='<button onclick="event.stopPropagation();driveDeleteFile(\\x27'+f.id+'\\x27,\\x27'+esc(f.name).replace(/'/g,'\\x27')+'\\x27)" style="padding:3px 8px;font-size:10px;background:var(--bg3);border:1px solid var(--border2);border-radius:4px;color:var(--red);cursor:pointer;opacity:0.6" title="Delete">Del</button>';
+      h+='</div>';
       h+='</div></div>';
     });
   }
@@ -1419,6 +1449,130 @@ function renderDrive(el){
   el.innerHTML=h;
 }
 
+// ---- Drive Editor (Notepad) ----
+function renderDriveEditor(el){
+  var f=driveEditorFile;
+  var h='<div style="max-width:900px;margin:0 auto">';
+  h+='<div style="display:flex;align-items:center;gap:8px;margin-bottom:12px">';
+  h+='<button onclick="driveCloseEditor()" style="padding:4px 10px;font-size:11px;background:var(--bg3);border:1px solid var(--border2);border-radius:4px;color:var(--dim);cursor:pointer">&larr; Back</button>';
+  h+='<span style="flex:1;font-size:14px;color:var(--bright);font-weight:bold">'+esc(f.name)+'</span>';
+  h+='<button onclick="driveSaveEditor()" style="padding:6px 16px;font-size:11px;background:var(--green3);border:1px solid var(--green);border-radius:6px;color:var(--bg);cursor:pointer;font-weight:bold">Save to Drive</button>';
+  h+='</div>';
+  h+='<textarea id="driveEditorContent" style="width:100%;min-height:500px;background:var(--bg);border:1px solid var(--border2);border-radius:8px;padding:14px;color:var(--fg);font-family:var(--mono);font-size:12px;line-height:1.6;resize:vertical;tab-size:2" spellcheck="false">'+esc(f.content||'')+'</textarea>';
+  h+='<div style="color:var(--dim);font-size:10px;margin-top:6px">File ID: '+esc(f.id)+' &middot; Use Tab for indentation &middot; Changes are NOT auto-saved</div>';
+  h+='</div>';
+  el.innerHTML=h;
+  // Enable Tab key in textarea
+  var ta=document.getElementById('driveEditorContent');
+  if(ta)ta.addEventListener('keydown',function(e){if(e.key==='Tab'){e.preventDefault();var s=this.selectionStart,end=this.selectionEnd;this.value=this.value.substring(0,s)+'  '+this.value.substring(end);this.selectionStart=this.selectionEnd=s+2;}});
+}
+
+function driveOpenEditor(fileId,fileName){
+  var el=document.getElementById('content');
+  el.innerHTML='<div style="text-align:center;padding:40px"><div class="spinner"></div><div style="color:var(--dim)">Loading file...</div></div>';
+  apiGet('/api/drive/read/'+fileId).then(function(r){
+    driveEditorFile={id:fileId,name:fileName,content:r.content||''};
+    renderDrive(el);
+  }).catch(function(e){
+    el.innerHTML='<div class="card" style="color:var(--red);padding:20px">Error reading file: '+esc(e.message||'unknown')+'</div>';
+  });
+}
+
+function driveSaveEditor(){
+  var ta=document.getElementById('driveEditorContent');
+  if(!ta||!driveEditorFile)return;
+  var content=ta.value;
+  if(!confirm('Save changes to "'+driveEditorFile.name+'" on Drive?'))return;
+  apiPost('/api/drive/update/'+driveEditorFile.id,{content:content}).then(function(){
+    driveEditorFile.content=content;
+    alert('Saved!');
+  }).catch(function(e){alert('Save failed: '+(e.message||'unknown'));});
+}
+
+function driveCloseEditor(){
+  driveEditorFile=null;
+  renderDrive(document.getElementById('content'));
+}
+
+// ---- Drive Image/PDF Viewer ----
+function renderDriveViewer(el){
+  var f=driveViewerFile;
+  var h='<div style="max-width:900px;margin:0 auto">';
+  h+='<div style="display:flex;align-items:center;gap:8px;margin-bottom:12px">';
+  h+='<button onclick="driveCloseViewer()" style="padding:4px 10px;font-size:11px;background:var(--bg3);border:1px solid var(--border2);border-radius:4px;color:var(--dim);cursor:pointer">&larr; Back</button>';
+  h+='<span style="flex:1;font-size:14px;color:var(--bright);font-weight:bold">'+esc(f.name)+'</span>';
+  h+='</div>';
+  if(f.mimeType&&f.mimeType.includes('image')){
+    h+='<img src="data:'+esc(f.mimeType)+';base64,'+f.base64+'" style="max-width:100%;border-radius:8px;border:1px solid var(--border)" alt="'+esc(f.name)+'">';
+  } else {
+    h+='<iframe src="data:application/pdf;base64,'+f.base64+'" style="width:100%;height:600px;border:1px solid var(--border);border-radius:8px" title="'+esc(f.name)+'"></iframe>';
+  }
+  h+='</div>';
+  el.innerHTML=h;
+}
+
+function driveViewImage(fileId,fileName){
+  var el=document.getElementById('content');
+  el.innerHTML='<div style="text-align:center;padding:40px"><div class="spinner"></div><div style="color:var(--dim)">Loading image...</div></div>';
+  apiGet('/api/drive/download/'+fileId).then(function(r){
+    driveViewerFile={id:fileId,name:fileName,base64:r.base64,mimeType:r.mimeType};
+    renderDrive(el);
+  }).catch(function(e){el.innerHTML='<div class="card" style="color:var(--red);padding:20px">Error: '+esc(e.message)+'</div>';});
+}
+
+function driveViewPdf(fileId,fileName){
+  var el=document.getElementById('content');
+  el.innerHTML='<div style="text-align:center;padding:40px"><div class="spinner"></div><div style="color:var(--dim)">Loading PDF...</div></div>';
+  apiGet('/api/drive/download/'+fileId).then(function(r){
+    driveViewerFile={id:fileId,name:fileName,base64:r.base64,mimeType:'application/pdf'};
+    renderDrive(el);
+  }).catch(function(e){el.innerHTML='<div class="card" style="color:var(--red);padding:20px">Error: '+esc(e.message)+'</div>';});
+}
+
+function driveCloseViewer(){
+  driveViewerFile=null;
+  renderDrive(document.getElementById('content'));
+}
+
+// ---- Drive Actions ----
+function driveNewFile(){
+  var name=prompt('File name (e.g. notes.txt, script.py):');
+  if(!name)return;
+  apiPost('/api/drive/upload',{name:name,content:'',mimeType:'text/plain'}).then(function(r){
+    driveData=null;
+    driveEditorFile={id:r.id,name:name,content:''};
+    renderDrive(document.getElementById('content'));
+  }).catch(function(e){alert('Error: '+(e.message||'unknown'));});
+}
+
+function driveUploadFile(){
+  var inp=document.createElement('input');
+  inp.type='file';
+  inp.accept='*/*';
+  inp.onchange=function(){
+    var file=inp.files[0];
+    if(!file)return;
+    var reader=new FileReader();
+    reader.onload=function(){
+      var base64=reader.result.split(',')[1]||'';
+      apiPost('/api/drive/upload',{name:file.name,content:base64,mimeType:file.type||'application/octet-stream',encoding:'base64'}).then(function(){
+        driveData=null;
+        renderDrive(document.getElementById('content'));
+      }).catch(function(e){alert('Upload error: '+(e.message||'unknown'));});
+    };
+    reader.readAsDataURL(file);
+  };
+  inp.click();
+}
+
+function driveDeleteFile(fileId,fileName){
+  if(!confirm('Delete "'+fileName+'" from Drive? (moved to trash)'))return;
+  apiPost('/api/drive/delete/'+fileId,{}).then(function(){
+    driveData=null;
+    renderDrive(document.getElementById('content'));
+  }).catch(function(e){alert('Delete error: '+(e.message||'unknown'));});
+}
+
 function driveTypeIcon(type){
   var icons={folder:'&#128193;',doc:'&#128196;',sheet:'&#128202;',slides:'&#127916;',pdf:'&#128213;',image:'&#127748;',video:'&#127910;',audio:'&#127925;',archive:'&#128230;',text:'&#128221;',file:'&#128196;'};
   return icons[type]||icons.file;