@projectservan8n/cnapse 0.2.0 → 0.4.0

package/src/tools/filesystem.ts

@@ -0,0 +1,272 @@
+/**
+ * File system tools
+ */
+
+import { promises as fs } from 'fs';
+import { join, dirname } from 'path';
+import { ToolResult, ok, err } from './index.js';
+
+/**
+ * Read file contents
+ */
+export async function readFile(path: string): Promise<ToolResult> {
+  try {
+    const content = await fs.readFile(path, 'utf-8');
+    return ok(content);
+  } catch (error: any) {
+    return err(`Failed to read file: ${error.message}`);
+  }
+}
+
+/**
+ * Write file contents
+ */
+export async function writeFile(path: string, content: string): Promise<ToolResult> {
+  try {
+    // Create parent directories if needed
+    const dir = dirname(path);
+    await fs.mkdir(dir, { recursive: true });
+
+    await fs.writeFile(path, content, 'utf-8');
+    return ok(`Written ${content.length} bytes to ${path}`);
+  } catch (error: any) {
+    return err(`Failed to write file: ${error.message}`);
+  }
+}
+
+/**
+ * List directory contents
+ */
+export async function listDir(path: string, recursive = false): Promise<ToolResult> {
+  try {
+    const stat = await fs.stat(path);
+    if (!stat.isDirectory()) {
+      return err(`Not a directory: ${path}`);
+    }
+
+    const entries: string[] = [];
+
+    async function walkDir(dir: string, prefix: string): Promise<void> {
+      const items = await fs.readdir(dir, { withFileTypes: true });
+      for (const item of items) {
+        const displayPath = prefix ? `${prefix}/${item.name}` : item.name;
+        if (item.isDirectory()) {
+          entries.push(`${displayPath}/`);
+          if (recursive) {
+            await walkDir(join(dir, item.name), displayPath);
+          }
+        } else {
+          entries.push(displayPath);
+        }
+      }
+    }
+
+    await walkDir(path, '');
+    entries.sort();
+    return ok(entries.join('\n'));
+  } catch (error: any) {
+    return err(`Failed to list directory: ${error.message}`);
+  }
+}
+
+/**
+ * Copy file
+ */
+export async function copyFile(src: string, dst: string): Promise<ToolResult> {
+  try {
+    const srcStat = await fs.stat(src);
+    if (!srcStat.isFile()) {
+      return err('Source is not a file');
+    }
+
+    // Create parent directories
+    const dir = dirname(dst);
+    await fs.mkdir(dir, { recursive: true });
+
+    await fs.copyFile(src, dst);
+    return ok(`Copied ${src} to ${dst}`);
+  } catch (error: any) {
+    return err(`Failed to copy: ${error.message}`);
+  }
+}
+
+/**
+ * Move/rename file or directory
+ */
+export async function movePath(src: string, dst: string): Promise<ToolResult> {
+  try {
+    await fs.rename(src, dst);
+    return ok(`Moved ${src} to ${dst}`);
+  } catch (error: any) {
+    return err(`Failed to move: ${error.message}`);
+  }
+}
+
+/**
+ * Delete file or directory
+ */
+export async function deletePath(path: string, force = false): Promise<ToolResult> {
+  try {
+    const stat = await fs.stat(path);
+
+    if (stat.isDirectory()) {
+      if (force) {
+        await fs.rm(path, { recursive: true, force: true });
+        return ok(`Deleted directory: ${path}`);
+      } else {
+        return err('Use force=true to delete directories');
+      }
+    } else {
+      await fs.unlink(path);
+      return ok(`Deleted file: ${path}`);
+    }
+  } catch (error: any) {
+    return err(`Failed to delete: ${error.message}`);
+  }
+}
+
+/**
+ * Get file metadata
+ */
+export async function fileInfo(path: string): Promise<ToolResult> {
+  try {
+    const stat = await fs.stat(path);
+
+    const fileType = stat.isDirectory() ? 'directory' : stat.isFile() ? 'file' : 'other';
+    const modified = stat.mtime.toISOString();
+
+    return ok(
+      `Type: ${fileType}\n` +
+      `Size: ${stat.size} bytes\n` +
+      `Modified: ${modified}\n` +
+      `Read-only: ${!(stat.mode & 0o200)}`
+    );
+  } catch (error: any) {
+    return err(`Failed to get file info: ${error.message}`);
+  }
+}
+
+/**
+ * Search for files by pattern
+ */
+export async function findFiles(
+  directory: string,
+  pattern: string,
+  maxResults = 100
+): Promise<ToolResult> {
+  try {
+    const { globby } = await import('globby');
+    const results = await globby(pattern, {
+      cwd: directory,
+      gitignore: true,
+    });
+
+    const limited = results.slice(0, maxResults);
+    if (results.length > maxResults) {
+      return ok(limited.join('\n') + `\n... and ${results.length - maxResults} more`);
+    }
+    return ok(limited.join('\n') || '(no matches)');
+  } catch (error: any) {
+    return err(`Failed to search: ${error.message}`);
+  }
+}
+
+/**
+ * File system tool definitions for agents
+ */
+export const filesystemTools = [
+  {
+    name: 'read_file',
+    description: 'Read file contents',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'File path' },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'write_file',
+    description: 'Write content to file',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'File path' },
+        content: { type: 'string', description: 'Content to write' },
+      },
+      required: ['path', 'content'],
+    },
+  },
+  {
+    name: 'list_dir',
+    description: 'List directory contents',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Directory path' },
+        recursive: { type: 'boolean', description: 'Include subdirectories' },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'copy_file',
+    description: 'Copy file',
+    parameters: {
+      type: 'object',
+      properties: {
+        src: { type: 'string', description: 'Source path' },
+        dst: { type: 'string', description: 'Destination path' },
+      },
+      required: ['src', 'dst'],
+    },
+  },
+  {
+    name: 'move_path',
+    description: 'Move or rename file/directory',
+    parameters: {
+      type: 'object',
+      properties: {
+        src: { type: 'string', description: 'Source path' },
+        dst: { type: 'string', description: 'Destination path' },
+      },
+      required: ['src', 'dst'],
+    },
+  },
+  {
+    name: 'delete_path',
+    description: 'Delete file or directory',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Path to delete' },
+        force: { type: 'boolean', description: 'Force delete directories' },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'file_info',
+    description: 'Get file metadata',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'File path' },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'find_files',
+    description: 'Search for files by glob pattern',
+    parameters: {
+      type: 'object',
+      properties: {
+        directory: { type: 'string', description: 'Search directory' },
+        pattern: { type: 'string', description: 'Glob pattern (e.g., "**/*.ts")' },
+      },
+      required: ['directory', 'pattern'],
+    },
+  },
+];

package/src/tools/index.ts

@@ -0,0 +1,35 @@
+/**
+ * Tool implementations for C-napse agents
+ */
+
+export * from './shell.js';
+export * from './filesystem.js';
+export * from './clipboard.js';
+export * from './network.js';
+export * from './process.js';
+export * from './computer.js';
+export * from './vision.js';
+
+export interface ToolResult {
+  success: boolean;
+  output: string;
+  error?: string;
+}
+
+export function ok(output: string): ToolResult {
+  return { success: true, output };
+}
+
+export function err(error: string): ToolResult {
+  return { success: false, output: '', error };
+}
+
+export interface ToolDefinition {
+  name: string;
+  description: string;
+  parameters: {
+    type: string;
+    properties: Record<string, unknown>;
+    required?: string[];
+  };
+}

package/src/tools/network.ts

@@ -0,0 +1,204 @@
+/**
+ * Network utilities
+ */
+
+import { createServer, Socket } from 'net';
+import { networkInterfaces } from 'os';
+import { ToolResult, ok, err } from './index.js';
+
+/**
+ * Check if a port is in use
+ */
+export function checkPort(port: number): Promise<ToolResult> {
+  return new Promise((resolve) => {
+    const server = createServer();
+
+    server.once('error', () => {
+      resolve(ok(`Port ${port} is in use`));
+    });
+
+    server.once('listening', () => {
+      server.close();
+      resolve(ok(`Port ${port} is available`));
+    });
+
+    server.listen(port, '127.0.0.1');
+  });
+}
+
+/**
+ * Find available port in range
+ */
+export async function findAvailablePort(start: number, end: number): Promise<ToolResult> {
+  for (let port = start; port <= end; port++) {
+    const result = await checkPort(port);
+    if (result.output.includes('available')) {
+      return ok(port.toString());
+    }
+  }
+  return err(`No available ports in range ${start}-${end}`);
+}
+
+/**
+ * Check if a host:port is reachable
+ */
+export function checkConnection(
+  host: string,
+  port: number,
+  timeoutMs = 5000
+): Promise<ToolResult> {
+  return new Promise((resolve) => {
+    const socket = new Socket();
+    let resolved = false;
+
+    const cleanup = () => {
+      if (!resolved) {
+        resolved = true;
+        socket.destroy();
+      }
+    };
+
+    socket.setTimeout(timeoutMs);
+
+    socket.on('connect', () => {
+      cleanup();
+      resolve(ok(`Connection to ${host}:${port} successful`));
+    });
+
+    socket.on('timeout', () => {
+      cleanup();
+      resolve(err(`Connection to ${host}:${port} timed out`));
+    });
+
+    socket.on('error', (error: any) => {
+      cleanup();
+      resolve(err(`Connection to ${host}:${port} failed: ${error.message}`));
+    });
+
+    socket.connect(port, host);
+  });
+}
+
+/**
+ * Get local IP addresses
+ */
+export function getLocalIp(): ToolResult {
+  const interfaces = networkInterfaces();
+  const addresses: string[] = [];
+
+  for (const [name, nets] of Object.entries(interfaces)) {
+    if (!nets) continue;
+    for (const net of nets) {
+      if (!net.internal && net.family === 'IPv4') {
+        addresses.push(`${name}: ${net.address}`);
+      }
+    }
+  }
+
+  if (addresses.length === 0) {
+    return err('No external IP addresses found');
+  }
+  return ok(addresses.join('\n'));
+}
+
+/**
+ * List all network interfaces
+ */
+export function listInterfaces(): ToolResult {
+  const interfaces = networkInterfaces();
+  const info: string[] = [];
+
+  for (const [name, nets] of Object.entries(interfaces)) {
+    if (!nets) continue;
+    for (const net of nets) {
+      info.push(`${name}: ${net.address} (${net.family}${net.internal ? ', internal' : ''})`);
+    }
+  }
+
+  return ok(info.join('\n'));
+}
+
+/**
+ * Fetch URL content
+ */
+export async function fetchUrl(url: string): Promise<ToolResult> {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      return err(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const text = await response.text();
+    return ok(text);
+  } catch (error: any) {
+    return err(`Failed to fetch: ${error.message}`);
+  }
+}
+
+/**
+ * Network tool definitions for agents
+ */
+export const networkTools = [
+  {
+    name: 'check_port',
+    description: 'Check if a port is in use',
+    parameters: {
+      type: 'object',
+      properties: {
+        port: { type: 'number', description: 'Port number' },
+      },
+      required: ['port'],
+    },
+  },
+  {
+    name: 'find_available_port',
+    description: 'Find available port in range',
+    parameters: {
+      type: 'object',
+      properties: {
+        start: { type: 'number', description: 'Start port' },
+        end: { type: 'number', description: 'End port' },
+      },
+      required: ['start', 'end'],
+    },
+  },
+  {
+    name: 'check_connection',
+    description: 'Check if host:port is reachable',
+    parameters: {
+      type: 'object',
+      properties: {
+        host: { type: 'string', description: 'Hostname' },
+        port: { type: 'number', description: 'Port number' },
+        timeout: { type: 'number', description: 'Timeout in ms' },
+      },
+      required: ['host', 'port'],
+    },
+  },
+  {
+    name: 'get_local_ip',
+    description: 'Get local IP addresses',
+    parameters: {
+      type: 'object',
+      properties: {},
+    },
+  },
+  {
+    name: 'list_interfaces',
+    description: 'List network interfaces',
+    parameters: {
+      type: 'object',
+      properties: {},
+    },
+  },
+  {
+    name: 'fetch_url',
+    description: 'Fetch content from URL',
+    parameters: {
+      type: 'object',
+      properties: {
+        url: { type: 'string', description: 'URL to fetch' },
+      },
+      required: ['url'],
+    },
+  },
+];

package/src/tools/process.ts

@@ -0,0 +1,194 @@
+/**
+ * Process management tools
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { platform, cpus, totalmem, freemem, hostname, version } from 'os';
+import { ToolResult, ok, err } from './index.js';
+
+const execAsync = promisify(exec);
+
+/**
+ * List running processes
+ */
+export async function listProcesses(): Promise<ToolResult> {
+  try {
+    const isWindows = process.platform === 'win32';
+
+    if (isWindows) {
+      const { stdout } = await execAsync(
+        'tasklist /FO CSV /NH',
+        { maxBuffer: 10 * 1024 * 1024 }
+      );
+
+      const lines = stdout.trim().split('\n').slice(0, 50);
+      const header = 'Name\tPID\tMemory';
+      const processes = lines.map(line => {
+        const parts = line.split('","').map(p => p.replace(/"/g, ''));
+        return `${parts[0]}\t${parts[1]}\t${parts[4]}`;
+      });
+
+      return ok(`${header}\n${processes.join('\n')}`);
+    } else {
+      const { stdout } = await execAsync(
+        'ps aux --sort=-%mem | head -50',
+        { maxBuffer: 10 * 1024 * 1024 }
+      );
+      return ok(stdout);
+    }
+  } catch (error: any) {
+    return err(`Failed to list processes: ${error.message}`);
+  }
+}
+
+/**
+ * Get information about a specific process
+ */
+export async function processInfo(pid: number): Promise<ToolResult> {
+  try {
+    const isWindows = process.platform === 'win32';
+
+    if (isWindows) {
+      const { stdout } = await execAsync(
+        `tasklist /FI "PID eq ${pid}" /FO LIST`
+      );
+      return ok(stdout || `No process found with PID ${pid}`);
+    } else {
+      const { stdout } = await execAsync(
+        `ps -p ${pid} -o pid,ppid,user,%cpu,%mem,stat,start,command`
+      );
+      return ok(stdout || `No process found with PID ${pid}`);
+    }
+  } catch (error: any) {
+    return err(`Failed to get process info: ${error.message}`);
+  }
+}
+
+/**
+ * Kill a process
+ */
+export async function killProcess(pid: number, force = false): Promise<ToolResult> {
+  try {
+    const isWindows = process.platform === 'win32';
+
+    if (isWindows) {
+      const flag = force ? '/F' : '';
+      await execAsync(`taskkill /PID ${pid} ${flag}`);
+    } else {
+      const signal = force ? '-9' : '-15';
+      await execAsync(`kill ${signal} ${pid}`);
+    }
+
+    return ok(`Killed process: ${pid}`);
+  } catch (error: any) {
+    return err(`Failed to kill process: ${error.message}`);
+  }
+}
+
+/**
+ * Find processes by name
+ */
+export async function findProcess(name: string): Promise<ToolResult> {
+  try {
+    const isWindows = process.platform === 'win32';
+
+    if (isWindows) {
+      const { stdout } = await execAsync(
+        `tasklist /FI "IMAGENAME eq *${name}*" /FO CSV /NH`
+      );
+      if (!stdout.trim() || stdout.includes('No tasks')) {
+        return err(`No processes found matching: ${name}`);
+      }
+      return ok(stdout);
+    } else {
+      const { stdout } = await execAsync(
+        `pgrep -l -i "${name}" || echo "No processes found"`
+      );
+      if (stdout.includes('No processes')) {
+        return err(`No processes found matching: ${name}`);
+      }
+      return ok(stdout);
+    }
+  } catch (error: any) {
+    return err(`No processes found matching: ${name}`);
+  }
+}
+
+/**
+ * Get system information
+ */
+export function systemInfo(): ToolResult {
+  const totalMemGB = (totalmem() / 1024 / 1024 / 1024).toFixed(1);
+  const freeMemGB = (freemem() / 1024 / 1024 / 1024).toFixed(1);
+  const usedMemGB = ((totalmem() - freemem()) / 1024 / 1024 / 1024).toFixed(1);
+
+  const info = [
+    `OS: ${platform()} ${version()}`,
+    `Hostname: ${hostname()}`,
+    `CPUs: ${cpus().length}`,
+    `CPU Model: ${cpus()[0]?.model || 'Unknown'}`,
+    `Total Memory: ${totalMemGB} GB`,
+    `Used Memory: ${usedMemGB} GB`,
+    `Free Memory: ${freeMemGB} GB`,
+    `Node Version: ${process.version}`,
+  ].join('\n');
+
+  return ok(info);
+}
+
+/**
+ * Process management tool definitions for agents
+ */
+export const processTools = [
+  {
+    name: 'list_processes',
+    description: 'List running processes',
+    parameters: {
+      type: 'object',
+      properties: {},
+    },
+  },
+  {
+    name: 'process_info',
+    description: 'Get info about specific process',
+    parameters: {
+      type: 'object',
+      properties: {
+        pid: { type: 'number', description: 'Process ID' },
+      },
+      required: ['pid'],
+    },
+  },
+  {
+    name: 'kill_process',
+    description: 'Kill a process',
+    parameters: {
+      type: 'object',
+      properties: {
+        pid: { type: 'number', description: 'Process ID' },
+        force: { type: 'boolean', description: 'Force kill' },
+      },
+      required: ['pid'],
+    },
+  },
+  {
+    name: 'find_process',
+    description: 'Find processes by name',
+    parameters: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Process name' },
+      },
+      required: ['name'],
+    },
+  },
+  {
+    name: 'system_info',
+    description: 'Get system information',
+    parameters: {
+      type: 'object',
+      properties: {},
+    },
+  },
+];