@agenticmail/enterprise 0.5.326 → 0.5.328

package/src/agent-tools/tools/local/file-edit.ts

@@ -1,31 +0,0 @@
-/**
- * file_edit — Edit a file by replacing exact text.
- */
-import { readFile, writeFile } from 'node:fs/promises';
-import { resolvePath } from './resolve-path.js';
-import type { ToolDefinition } from '../../types.js';
-
-export function createFileEditTool(sandbox?: string): ToolDefinition {
-  return {
-    name: 'file_edit',
-    description: 'Edit a file by replacing exact text match.',
-    input_schema: {
-      type: 'object' as const,
-      properties: {
-        path: { type: 'string' },
-        old_text: { type: 'string', description: 'Exact text to find' },
-        new_text: { type: 'string', description: 'Replacement text' },
-      },
-      required: ['path', 'old_text', 'new_text'],
-    },
-    execute: async (input: any) => {
-      var filePath = resolvePath(input.path, sandbox);
-      var content = await readFile(filePath, 'utf-8');
-      if (!content.includes(input.old_text)) {
-        return { error: 'old_text not found in file. Must match exactly including whitespace.' };
-      }
-      await writeFile(filePath, content.replace(input.old_text, input.new_text), 'utf-8');
-      return { ok: true, path: filePath };
-    },
-  };
-}

package/src/agent-tools/tools/local/file-list.ts

@@ -1,39 +0,0 @@
-/**
- * file_list — List files/directories at a path.
- */
-import { readdir, stat } from 'node:fs/promises';
-import { join } from 'node:path';
-import { resolvePath } from './resolve-path.js';
-import type { ToolDefinition } from '../../types.js';
-
-export function createFileListTool(sandbox?: string): ToolDefinition {
-  return {
-    name: 'file_list',
-    description: 'List files and directories at a path.',
-    input_schema: {
-      type: 'object' as const,
-      properties: {
-        path: { type: 'string' },
-      },
-      required: ['path'],
-    },
-    execute: async (input: any) => {
-      var dirPath = resolvePath(input.path, sandbox);
-      var entries = await readdir(dirPath, { withFileTypes: true });
-      var results: any[] = [];
-
-      for (var entry of entries) {
-        var info: any = { name: entry.name, type: entry.isDirectory() ? 'directory' : 'file' };
-        try {
-          var s = await stat(join(dirPath, entry.name));
-          info.size = s.size;
-          info.modified = s.mtime.toISOString();
-        } catch {}
-        results.push(info);
-        if (results.length >= 500) break;
-      }
-
-      return { path: dirPath, entries: results, count: results.length };
-    },
-  };
-}

package/src/agent-tools/tools/local/file-ops.ts

@@ -1,48 +0,0 @@
-/**
- * file_move + file_delete — File management operations.
- */
-import { rename, unlink, mkdir } from 'node:fs/promises';
-import { dirname } from 'node:path';
-import { resolvePath } from './resolve-path.js';
-import type { ToolDefinition } from '../../types.js';
-
-export function createFileMoveTool(sandbox?: string): ToolDefinition {
-  return {
-    name: 'file_move',
-    description: 'Move or rename a file.',
-    input_schema: {
-      type: 'object' as const,
-      properties: {
-        from: { type: 'string' },
-        to: { type: 'string' },
-      },
-      required: ['from', 'to'],
-    },
-    execute: async (input: any) => {
-      var fromPath = resolvePath(input.from, sandbox);
-      var toPath = resolvePath(input.to, sandbox);
-      await mkdir(dirname(toPath), { recursive: true });
-      await rename(fromPath, toPath);
-      return { ok: true, from: fromPath, to: toPath };
-    },
-  };
-}
-
-export function createFileDeleteTool(sandbox?: string): ToolDefinition {
-  return {
-    name: 'file_delete',
-    description: 'Delete a file. Use with caution.',
-    input_schema: {
-      type: 'object' as const,
-      properties: {
-        path: { type: 'string' },
-      },
-      required: ['path'],
-    },
-    execute: async (input: any) => {
-      var filePath = resolvePath(input.path, sandbox);
-      await unlink(filePath);
-      return { ok: true, deleted: filePath };
-    },
-  };
-}

package/src/agent-tools/tools/local/file-read.ts

@@ -1,39 +0,0 @@
-/**
- * file_read — Read file contents with optional offset/limit.
- */
-import { readFile } from 'node:fs/promises';
-import { resolvePath } from './resolve-path.js';
-import type { ToolDefinition } from '../../types.js';
-
-export function createFileReadTool(sandbox?: string): ToolDefinition {
-  return {
-    name: 'file_read',
-    description: 'Read file contents. Use offset/limit for large files.',
-    input_schema: {
-      type: 'object' as const,
-      properties: {
-        path: { type: 'string' },
-        offset: { type: 'number', description: 'Start line (1-indexed)' },
-        limit: { type: 'number', description: 'Max lines' },
-      },
-      required: ['path'],
-    },
-    execute: async (input: any) => {
-      var filePath = resolvePath(input.path, sandbox);
-      var content = await readFile(filePath, 'utf-8');
-
-      if (input.offset || input.limit) {
-        var lines = content.split('\n');
-        var start = Math.max(0, (input.offset || 1) - 1);
-        var end = input.limit ? start + input.limit : lines.length;
-        content = lines.slice(start, end).join('\n');
-      }
-
-      if (content.length > 50000) {
-        content = content.slice(0, 50000) + '\n\n[...truncated at 50KB]';
-      }
-
-      return { content, path: filePath, size: content.length };
-    },
-  };
-}

package/src/agent-tools/tools/local/file-search.ts

@@ -1,46 +0,0 @@
-/**
- * file_search — Search for files by name pattern.
- */
-import { readdir } from 'node:fs/promises';
-import { join, relative } from 'node:path';
-import { resolvePath } from './resolve-path.js';
-import type { ToolDefinition } from '../../types.js';
-
-export function createFileSearchTool(sandbox?: string): ToolDefinition {
-  return {
-    name: 'file_search',
-    description: 'Search for files by name pattern (* wildcard supported).',
-    input_schema: {
-      type: 'object' as const,
-      properties: {
-        path: { type: 'string' },
-        pattern: { type: 'string', description: 'Filename pattern (e.g. *.ts)' },
-        maxResults: { type: 'number' },
-      },
-      required: ['path', 'pattern'],
-    },
-    execute: async (input: any) => {
-      var dirPath = resolvePath(input.path, sandbox);
-      var max = input.maxResults || 50;
-      var regex = new RegExp('^' + input.pattern.replace(/\*/g, '.*').replace(/\?/g, '.') + '$', 'i');
-      var results: string[] = [];
-
-      async function walk(dir: string, depth: number) {
-        if (depth > 10 || results.length >= max) return;
-        try {
-          var entries = await readdir(dir, { withFileTypes: true });
-          for (var entry of entries) {
-            if (results.length >= max) break;
-            if (regex.test(entry.name)) results.push(relative(dirPath, join(dir, entry.name)));
-            if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
-              await walk(join(dir, entry.name), depth + 1);
-            }
-          }
-        } catch {}
-      }
-
-      await walk(dirPath, 0);
-      return { path: dirPath, matches: results, count: results.length };
-    },
-  };
-}

package/src/agent-tools/tools/local/file-write.ts

@@ -1,28 +0,0 @@
-/**
- * file_write — Write content to a file. Creates dirs automatically.
- */
-import { writeFile, mkdir } from 'node:fs/promises';
-import { dirname } from 'node:path';
-import { resolvePath } from './resolve-path.js';
-import type { ToolDefinition } from '../../types.js';
-
-export function createFileWriteTool(sandbox?: string): ToolDefinition {
-  return {
-    name: 'file_write',
-    description: 'Write content to a file. Creates parent directories. Overwrites if exists.',
-    input_schema: {
-      type: 'object' as const,
-      properties: {
-        path: { type: 'string' },
-        content: { type: 'string' },
-      },
-      required: ['path', 'content'],
-    },
-    execute: async (input: any) => {
-      var filePath = resolvePath(input.path, sandbox);
-      await mkdir(dirname(filePath), { recursive: true });
-      await writeFile(filePath, input.content, 'utf-8');
-      return { ok: true, path: filePath, bytesWritten: Buffer.byteLength(input.content, 'utf-8') };
-    },
-  };
-}

package/src/agent-tools/tools/local/filesystem.ts

@@ -1,5 +0,0 @@
-/**
- * @deprecated — Use individual tool files or the barrel (./index.ts) instead.
- * This file is kept for backward compatibility only.
- */
-export { createLocalSystemTools } from './index.js';

package/src/agent-tools/tools/local/index.ts

@@ -1,55 +0,0 @@
-/**
- * Local System Tools — barrel export.
- * 
- * Provides filesystem, shell, and system info tools.
- * Must be enabled via Settings > Platform Capabilities.
- */
-import { createFileReadTool } from './file-read.js';
-import { createFileWriteTool } from './file-write.js';
-import { createFileEditTool } from './file-edit.js';
-import { createFileListTool } from './file-list.js';
-import { createFileSearchTool } from './file-search.js';
-import { createFileMoveTool, createFileDeleteTool } from './file-ops.js';
-import { createShellTools } from './shell.js';
-import { createDependencyManagerTools } from './dependency-manager.js';
-import { createSystemInfoTool } from './system-info.js';
-import { createCodingTools } from './coding.js';
-import type { ToolDefinition } from '../../types.js';
-
-export interface LocalToolsConfig {
-  /** If set, filesystem tools are sandboxed to this directory. Null = full access. */
-  sandboxRoot?: string;
-  /** Working directory for shell commands. */
-  shellCwd?: string;
-  /** Shell command timeout in seconds (default 30). */
-  shellTimeout?: number;
-}
-
-export function createLocalSystemTools(config?: LocalToolsConfig): ToolDefinition[] {
-  var sandbox = config?.sandboxRoot;
-
-  return [
-    createFileReadTool(sandbox),
-    createFileWriteTool(sandbox),
-    createFileEditTool(sandbox),
-    createFileListTool(sandbox),
-    createFileSearchTool(sandbox),
-    createFileMoveTool(sandbox),
-    createFileDeleteTool(sandbox),
-    ...createShellTools({ cwd: config?.shellCwd, timeout: config?.shellTimeout }),
-    ...createDependencyManagerTools(),
-    createSystemInfoTool(),
-    ...createCodingTools({ cwd: config?.shellCwd, sandbox }),
-  ];
-}
-
-export { createFileReadTool } from './file-read.js';
-export { createFileWriteTool } from './file-write.js';
-export { createFileEditTool } from './file-edit.js';
-export { createFileListTool } from './file-list.js';
-export { createFileSearchTool } from './file-search.js';
-export { createFileMoveTool, createFileDeleteTool } from './file-ops.js';
-export { createShellTools, createShellExecTool } from './shell.js';
-export { createSystemInfoTool } from './system-info.js';
-export { createCodingTools } from './coding.js';
-export { createDependencyManagerTools } from './dependency-manager.js';

package/src/agent-tools/tools/local/resolve-path.ts

@@ -1,18 +0,0 @@
-/**
- * Shared path resolver with optional sandbox enforcement.
- */
-import { join, resolve } from 'node:path';
-import { homedir } from 'node:os';
-
-export function resolvePath(inputPath: string, sandbox?: string): string {
-  var expanded = inputPath.startsWith('~') ? join(homedir(), inputPath.slice(1)) : inputPath;
-  var resolved = resolve(expanded);
-
-  if (sandbox) {
-    var sandboxResolved = resolve(sandbox);
-    if (!resolved.startsWith(sandboxResolved)) {
-      throw new Error('Access denied: path is outside the allowed directory (' + sandbox + ')');
-    }
-  }
-  return resolved;
-}

package/src/agent-tools/tools/local/shell.ts

@@ -1,277 +0,0 @@
-/**
- * Shell tools — Execute commands on the host with full PTY support.
- * 
- * Supports:
- * - Regular commands (non-interactive, fast)
- * - Interactive commands via PTY (sudo, apt-get, installers, etc.)
- * - Password input for sudo/elevated permissions
- * - Long-running processes with background mode
- * - Cross-platform: macOS, Linux (all distros), Windows (PowerShell)
- * 
- * MUST be gated by platform capabilities in settings.
- */
-
-import { exec as cpExec, spawn } from 'node:child_process';
-import { promisify } from 'node:util';
-import { platform } from 'node:os';
-import type { ToolDefinition } from '../../types.js';
-
-var execAsync = promisify(cpExec);
-
-// Active PTY sessions for interactive/long-running commands
-var activeSessions = new Map<string, {
-  proc: any;
-  output: string;
-  exitCode: number | null;
-  startedAt: number;
-}>();
-
-// Auto-cleanup sessions older than 30 minutes
-setInterval(() => {
-  var now = Date.now();
-  for (var [id, s] of activeSessions) {
-    if (now - s.startedAt > 30 * 60 * 1000) {
-      try { s.proc?.kill(); } catch {}
-      activeSessions.delete(id);
-    }
-  }
-}, 60000);
-
-export function createShellTools(opts?: { cwd?: string; timeout?: number }): ToolDefinition[] {
-  return [
-    {
-      name: 'shell_exec',
-      description: 'Execute a shell command. For interactive commands (sudo, installers), use shell_interactive instead.',
-      input_schema: {
-        type: 'object' as const,
-        properties: {
-          command: { type: 'string' },
-          cwd: { type: 'string' },
-          timeout: { type: 'number', description: 'Seconds (default 30)' },
-        },
-        required: ['command'],
-      },
-      execute: async (input: any) => {
-        // Intercept package install commands → redirect to install_dependency
-        var _cmdLow = (input.command || '').trim().toLowerCase();
-        var _pkgPatterns = [
-          /^(sudo\s+)?brew\s+install\s/, /^(sudo\s+)?apt(-get)?\s+install\s/, /^(sudo\s+)?dnf\s+install\s/,
-          /^(sudo\s+)?pacman\s+-S\s/, /^(sudo\s+)?snap\s+install\s/, /^choco\s+install\s/, /^winget\s+install\s/,
-          /^scoop\s+install\s/, /^(sudo\s+)?pip3?\s+install\s(?!-r\s|--requirement)/, /^npm\s+install\s+-g\s/,
-        ];
-        if (_pkgPatterns.some(p => p.test(_cmdLow))) {
-          return { stdout: '', stderr: 'POLICY: Package installation via shell is not allowed. Use the install_dependency tool instead.\nExample: install_dependency({ command: "wget" })', exitCode: 1 };
-        }
-
-        var timeoutMs = (input.timeout || opts?.timeout || 30) * 1000;
-        var cwd = input.cwd || opts?.cwd || process.cwd();
-        try {
-          var r = await execAsync(input.command, {
-            cwd, timeout: timeoutMs, maxBuffer: 1024 * 1024,
-            env: { ...process.env, TERM: 'dumb', DEBIAN_FRONTEND: 'noninteractive' },
-          });
-          var stdout = r.stdout || '';
-          var stderr = r.stderr || '';
-          if (stdout.length > 50000) stdout = stdout.slice(0, 50000) + '\n[...truncated]';
-          if (stderr.length > 10000) stderr = stderr.slice(0, 10000) + '\n[...truncated]';
-          return { stdout, stderr, exitCode: 0 };
-        } catch (err: any) {
-          return { stdout: (err.stdout || '').slice(0, 50000), stderr: (err.stderr || err.message || '').slice(0, 10000), exitCode: err.code || 1 };
-        }
-      },
-    },
-    {
-      name: 'shell_interactive',
-      description: 'Run an interactive command with PTY (sudo, apt install, ssh, etc.). Can send input like passwords. Returns session ID for follow-up.',
-      input_schema: {
-        type: 'object' as const,
-        properties: {
-          command: { type: 'string', description: 'Command to run (e.g. "sudo apt install nginx")' },
-          input: { type: 'string', description: 'Text to send to stdin (e.g. password). Sent after command starts.' },
-          inputDelay: { type: 'number', description: 'ms to wait before sending input (default 500)' },
-          cwd: { type: 'string' },
-          timeout: { type: 'number', description: 'Seconds to wait for output (default 30)' },
-          sessionId: { type: 'string', description: 'Resume existing session instead of starting new command' },
-        },
-        required: [],
-      },
-      execute: async (input: any) => {
-        // Resume existing session
-        if (input.sessionId) {
-          var session = activeSessions.get(input.sessionId);
-          if (!session) return { error: 'Session not found or expired' };
-
-          // Send input if provided
-          if (input.input) {
-            try { session.proc.stdin.write(input.input + '\n'); } catch {}
-          }
-
-          // Wait a bit for output
-          await new Promise(r => setTimeout(r, (input.timeout || 3) * 1000));
-
-          var output = session.output;
-          session.output = ''; // Clear buffer
-          if (output.length > 50000) output = output.slice(-50000);
-          return { sessionId: input.sessionId, output, exitCode: session.exitCode, done: session.exitCode !== null };
-        }
-
-        // Start new interactive session
-        var sessionId = 'sh_' + Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
-        var shell = platform() === 'win32' ? 'powershell.exe' : '/bin/bash';
-        var args = platform() === 'win32' ? ['-Command', input.command || 'echo ready'] : ['-c', input.command || 'echo ready'];
-        var cwd = input.cwd || opts?.cwd || process.cwd();
-
-        var proc = spawn(shell, args, {
-          cwd,
-          env: { ...process.env, TERM: 'xterm-256color' },
-          stdio: ['pipe', 'pipe', 'pipe'],
-        });
-
-        var entry = { proc, output: '', exitCode: null as number | null, startedAt: Date.now() };
-        activeSessions.set(sessionId, entry);
-
-        proc.stdout?.on('data', (d: Buffer) => { entry.output += d.toString(); });
-        proc.stderr?.on('data', (d: Buffer) => { entry.output += d.toString(); });
-        proc.on('close', (code: number) => { entry.exitCode = code ?? 0; });
-        proc.on('error', (err: Error) => { entry.output += '\n[ERROR] ' + err.message; entry.exitCode = 1; });
-
-        // Send input after delay (for password prompts etc.)
-        if (input.input) {
-          var delay = input.inputDelay || 500;
-          setTimeout(() => {
-            try { proc.stdin.write(input.input + '\n'); } catch {}
-          }, delay);
-        }
-
-        // Wait for initial output
-        var waitMs = Math.min((input.timeout || 30) * 1000, 60000);
-        await new Promise<void>((resolve) => {
-          var timer = setTimeout(resolve, waitMs);
-          proc.on('close', () => { clearTimeout(timer); setTimeout(resolve, 200); });
-        });
-
-        var output = entry.output;
-        entry.output = '';
-        if (output.length > 50000) output = output.slice(-50000);
-        return { sessionId, output, exitCode: entry.exitCode, done: entry.exitCode !== null };
-      },
-    },
-    {
-      name: 'shell_sudo',
-      description: 'Run a command with sudo. Handles password prompt automatically.',
-      input_schema: {
-        type: 'object' as const,
-        properties: {
-          command: { type: 'string', description: 'Command to run (without sudo prefix)' },
-          password: { type: 'string', description: 'User password for sudo' },
-          cwd: { type: 'string' },
-          timeout: { type: 'number', description: 'Seconds (default 60)' },
-        },
-        required: ['command', 'password'],
-      },
-      execute: async (input: any) => {
-        if (platform() === 'win32') {
-          // Windows: Use RunAs or PowerShell elevation
-          return { error: 'Use shell_interactive with "Start-Process ... -Verb RunAs" for Windows elevation' };
-        }
-        var timeoutMs = (input.timeout || 60) * 1000;
-        var cwd = input.cwd || opts?.cwd || process.cwd();
-        var cmd = `echo '${input.password.replace(/'/g, "'\\''")}' | sudo -S ${input.command}`;
-        try {
-          var r = await execAsync(cmd, {
-            cwd, timeout: timeoutMs, maxBuffer: 2 * 1024 * 1024,
-            env: { ...process.env, TERM: 'dumb', DEBIAN_FRONTEND: 'noninteractive' },
-          });
-          var stdout = r.stdout || '';
-          var stderr = (r.stderr || '').replace(/\[sudo\].*\n?/g, ''); // Strip sudo prompt
-          if (stdout.length > 50000) stdout = stdout.slice(0, 50000) + '\n[...truncated]';
-          return { stdout, stderr, exitCode: 0 };
-        } catch (err: any) {
-          var stderrMsg = (err.stderr || err.message || '').replace(/\[sudo\].*\n?/g, '');
-          return { stdout: (err.stdout || '').slice(0, 50000), stderr: stderrMsg.slice(0, 10000), exitCode: err.code || 1 };
-        }
-      },
-    },
-    {
-      name: 'shell_install',
-      description: 'Install a package using the system package manager. Auto-detects apt/yum/dnf/pacman/brew/choco/winget.',
-      input_schema: {
-        type: 'object' as const,
-        properties: {
-          package: { type: 'string', description: 'Package name(s) to install' },
-          password: { type: 'string', description: 'Sudo password (not needed for brew/choco/winget)' },
-        },
-        required: ['package'],
-      },
-      execute: async (input: any) => {
-        var os = platform();
-        var pkg = input.package;
-        var cmd: string;
-        var needsSudo = true;
-
-        if (os === 'darwin') {
-          cmd = `brew install ${pkg}`; needsSudo = false;
-        } else if (os === 'win32') {
-          cmd = `winget install ${pkg}`; needsSudo = false;
-        } else {
-          // Linux — detect package manager
-          try { await execAsync('which apt-get'); cmd = `apt-get install -y ${pkg}`; }
-          catch { try { await execAsync('which dnf'); cmd = `dnf install -y ${pkg}`; }
-          catch { try { await execAsync('which yum'); cmd = `yum install -y ${pkg}`; }
-          catch { try { await execAsync('which pacman'); cmd = `pacman -S --noconfirm ${pkg}`; }
-          catch { try { await execAsync('which apk'); cmd = `apk add ${pkg}`; }
-          catch { return { error: 'No supported package manager found (apt/dnf/yum/pacman/apk)' }; }}}}}
-        }
-
-        if (needsSudo && input.password) {
-          cmd = `echo '${input.password.replace(/'/g, "'\\''")}' | sudo -S ${cmd}`;
-        } else if (needsSudo) {
-          cmd = `sudo ${cmd}`; // Try passwordless sudo (Docker, root user)
-        }
-
-        try {
-          var r = await execAsync(cmd, {
-            timeout: 300000, maxBuffer: 2 * 1024 * 1024,
-            env: { ...process.env, DEBIAN_FRONTEND: 'noninteractive', TERM: 'dumb' },
-          });
-          return { ok: true, stdout: (r.stdout || '').slice(-5000), stderr: (r.stderr || '').slice(-2000) };
-        } catch (err: any) {
-          return { error: (err.stderr || err.message || '').slice(0, 10000), exitCode: err.code || 1 };
-        }
-      },
-    },
-    {
-      name: 'shell_session_list',
-      description: 'List active interactive shell sessions.',
-      input_schema: { type: 'object' as const, properties: {}, required: [] },
-      execute: async () => ({
-        sessions: Array.from(activeSessions.entries()).map(([id, s]) => ({
-          id, done: s.exitCode !== null, exitCode: s.exitCode,
-          age: Math.round((Date.now() - s.startedAt) / 1000) + 's',
-          buffered: s.output.length + ' chars',
-        })),
-      }),
-    },
-    {
-      name: 'shell_session_kill',
-      description: 'Kill an interactive shell session.',
-      input_schema: {
-        type: 'object' as const,
-        properties: { sessionId: { type: 'string' } },
-        required: ['sessionId'],
-      },
-      execute: async (input: any) => {
-        var s = activeSessions.get(input.sessionId);
-        if (!s) return { error: 'Not found' };
-        try { s.proc.kill('SIGKILL'); } catch {}
-        activeSessions.delete(input.sessionId);
-        return { ok: true };
-      },
-    },
-  ];
-}
-
-// Backward compat
-export function createShellExecTool(opts?: { cwd?: string; timeout?: number }): ToolDefinition {
-  return createShellTools(opts)[0];
-}

package/src/agent-tools/tools/local/system-info.ts

@@ -1,29 +0,0 @@
-/**
- * system_info — Get host system information.
- */
-import { hostname, platform, arch, cpus, totalmem, freemem, uptime, homedir, userInfo } from 'node:os';
-import type { ToolDefinition } from '../../types.js';
-
-export function createSystemInfoTool(): ToolDefinition {
-  return {
-    name: 'system_info',
-    description: 'Get host system info (OS, CPU, memory, uptime).',
-    input_schema: { type: 'object' as const, properties: {} },
-    execute: async () => {
-      return {
-        hostname: hostname(),
-        platform: platform(),
-        arch: arch(),
-        cpuCount: cpus().length,
-        cpuModel: cpus()[0]?.model || 'unknown',
-        totalMemoryGB: +(totalmem() / 1073741824).toFixed(1),
-        freeMemoryGB: +(freemem() / 1073741824).toFixed(1),
-        uptimeHours: +(uptime() / 3600).toFixed(1),
-        homeDir: homedir(),
-        user: userInfo().username,
-        cwd: process.cwd(),
-        nodeVersion: process.version,
-      };
-    },
-  };
-}