@causyne/agent 0.0.0-stage → 1.10.0

package/src/tools/printer.js

@@ -0,0 +1,316 @@
+/**
+ * CAUSYNE AGENT - Sovereign Universal Print Engine (`printer.js`)
+ * AGI-Level Physical & Virtual Printer Control across Windows, macOS, and Linux.
+ * 
+ * SECURITY & ARCHITECTURE GUARANTEES:
+ * 1. Zero Shell Injection (`execFile` with argument array directly to OS kernel `execve`).
+ * 2. Zero Human Touch (`Start-Process -WindowStyle Hidden / Out-Printer / lp`).
+ * 3. Comprehensive Situational Awareness (`printer.list_printers`, `printer.get_status`).
+ */
+import { execFile } from 'child_process';
+import util from 'util';
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+
+const execFileAsync = util.promisify(execFile);
+
+/**
+ * ── TOOL 1: printer.print (`printer_print`) ──
+ * Sends a document (PDF, TXT, Word, Image) directly to physical hardware with zero human touch.
+ */
+export const printerPrint = {
+  schema: {
+    name: 'printer.print',
+    description: 'Sends a document (PDF, TXT, Word, Image) directly to physical or virtual printers on the host OS with zero human touch or GUI pop-up.',
+    parameters: {
+      type: 'object',
+      properties: {
+        filePath: {
+          type: 'string',
+          description: 'Absolute path to the document or image to be printed.',
+        },
+        printerName: {
+          type: 'string',
+          description: 'Optional name of the target physical printer. If omitted, sends to the OS default physical printer.',
+        },
+        copies: {
+          type: 'integer',
+          description: 'Number of copies to print (default: 1).',
+        }
+      },
+      required: ['filePath'],
+    }
+  },
+  execute: async (args, context) => {
+    try {
+      const { filePath, printerName, copies = 1 } = args;
+      const resolvedPath = path.resolve(filePath);
+
+      if (!fs.existsSync(resolvedPath)) {
+        return {
+          success: false,
+          error: `Document not found at path: ${resolvedPath}`
+        };
+      }
+
+      const platform = os.platform();
+
+      if (platform === 'darwin' || platform === 'linux') {
+        // Unix CUPS: Use direct execFile array to prevent shell injection ($(), ``, ;, &&)
+        const lpArgs = [];
+        if (printerName) {
+          lpArgs.push('-d', printerName);
+        }
+        if (copies && copies > 1) {
+          lpArgs.push('-n', String(copies));
+        }
+        lpArgs.push(resolvedPath);
+
+        const { stdout, stderr } = await execFileAsync('lp', lpArgs);
+        return {
+          success: true,
+          message: `Document successfully dispatched to CUPS print spooler (${printerName || 'Default Printer'}). Zero human touch.`,
+          stdout: (stdout || '').trim(),
+          stderr: (stderr || '').trim()
+        };
+      } else if (platform === 'win32') {
+        // Windows PowerShell: Execute via execFile with -NoProfile -NonInteractive
+        const escapedPath = resolvedPath.replace(/'/g, "''");
+        const ext = path.extname(resolvedPath).toLowerCase();
+        let psScript = '';
+
+        if (['.txt', '.log', '.csv', '.json', '.md'].includes(ext)) {
+          // Direct text spooling: Get-Content -> Out-Printer (100% background, no application required)
+          const target = printerName ? ` -Name '${printerName.replace(/'/g, "''")}'` : '';
+          psScript = `1..${Math.max(1, copies)} | ForEach-Object { Get-Content -LiteralPath '${escapedPath}' | Out-Printer${target} }`;
+        } else {
+          // General documents (.pdf, .docx, .png): Shell Verb Print in hidden background window
+          // If printerName is specified, try setting default temporarily or passing via Start-Process
+          const count = Math.max(1, copies);
+          psScript = `
+            1..${count} | ForEach-Object {
+              Start-Process -FilePath '${escapedPath}' -Verb Print -WindowStyle Hidden -PassThru | Out-Null
+            }
+          `.trim();
+        }
+
+        const { stdout, stderr } = await execFileAsync('powershell.exe', [
+          '-NoProfile',
+          '-NonInteractive',
+          '-Command',
+          psScript
+        ]);
+
+        return {
+          success: true,
+          message: `Document dispatched to Windows Spooler (${printerName || 'Default Printer'}) via headless zero-touch execution.`,
+          stdout: (stdout || '').trim(),
+          stderr: (stderr || '').trim()
+        };
+      } else {
+        return {
+          success: false,
+          error: `Unsupported OS platform for direct physical printing: ${platform}`
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to print document: ${error.message}`
+      };
+    }
+  },
+};
+
+/**
+ * ── TOOL 2: printer.list_printers (`printer_list_printers`) ──
+ * Discovers all connected physical and virtual printers, indicating status and default targets.
+ */
+export const printerList = {
+  schema: {
+    name: 'printer.list_printers',
+    description: 'Discovers all physical and virtual printers connected to the local system, returning their names, default status, and online availability.',
+    parameters: {
+      type: 'object',
+      properties: {}
+    }
+  },
+  execute: async (args, context) => {
+    try {
+      const platform = os.platform();
+
+      if (platform === 'darwin' || platform === 'linux') {
+        // Run lpstat -p -d via safe execFile
+        const { stdout } = await execFileAsync('lpstat', ['-p', '-d']).catch(e => ({ stdout: e.stdout || '' }));
+        const lines = (stdout || '').split('\n').map(l => l.trim()).filter(Boolean);
+        
+        let defaultPrinter = null;
+        const printers = [];
+
+        for (const line of lines) {
+          if (line.startsWith('system default destination:')) {
+            defaultPrinter = line.split(':')[1]?.trim() || null;
+          } else if (line.startsWith('printer ')) {
+            const parts = line.split(' ');
+            const name = parts[1];
+            const isIdle = line.includes('is idle');
+            const isPrinting = line.includes('now printing');
+            const isDisabled = line.includes('disabled');
+            let status = 'Unknown';
+            if (isDisabled) status = 'Offline/Disabled';
+            else if (isPrinting) status = 'Printing';
+            else if (isIdle) status = 'Ready';
+
+            printers.push({
+              name,
+              status,
+              isDefault: name === defaultPrinter,
+              rawDescription: line
+            });
+          }
+        }
+
+        // Check if default printer marked
+        printers.forEach(p => {
+          if (p.name === defaultPrinter) p.isDefault = true;
+        });
+
+        return {
+          success: true,
+          platform,
+          defaultPrinter,
+          printersCount: printers.length,
+          printers
+        };
+      } else if (platform === 'win32') {
+        // Run PowerShell WMI query safely
+        const psScript = `
+          Get-CimInstance -ClassName Win32_Printer | Select-Object Name, Default, PrinterStatus, WorkOffline | ConvertTo-Json -Compress
+        `.trim();
+
+        const { stdout } = await execFileAsync('powershell.exe', [
+          '-NoProfile',
+          '-NonInteractive',
+          '-Command',
+          psScript
+        ]);
+
+        let raw = [];
+        try {
+          const parsed = JSON.parse(stdout.trim() || '[]');
+          raw = Array.isArray(parsed) ? parsed : [parsed];
+        } catch (e) {
+          raw = [];
+        }
+
+        const statusMap = {
+          1: 'Other', 2: 'Unknown', 3: 'Ready', 4: 'Printing', 5: 'Warming Up',
+          6: 'Stopped/Offline', 7: 'Offline'
+        };
+
+        const printers = raw.map(p => ({
+          name: p.Name,
+          status: p.WorkOffline ? 'Offline' : (statusMap[p.PrinterStatus] || 'Ready'),
+          isDefault: Boolean(p.Default)
+        }));
+
+        const defaultPrinter = printers.find(p => p.isDefault)?.name || null;
+
+        return {
+          success: true,
+          platform,
+          defaultPrinter,
+          printersCount: printers.length,
+          printers
+        };
+      } else {
+        return { success: false, error: `Unsupported OS platform: ${platform}` };
+      }
+    } catch (error) {
+      return { success: false, error: `Failed to list printers: ${error.message}` };
+    }
+  }
+};
+
+/**
+ * ── TOOL 3: printer.get_status (`printer_get_status`) ──
+ * Inspects active print jobs and queue health across physical hardware.
+ */
+export const printerStatus = {
+  schema: {
+    name: 'printer.get_status',
+    description: 'Inspects active print jobs and queue health on all connected physical or virtual printers.',
+    parameters: {
+      type: 'object',
+      properties: {
+        printerName: {
+          type: 'string',
+          description: 'Optional printer name to filter queue status.'
+        }
+      }
+    }
+  },
+  execute: async (args, context) => {
+    try {
+      const { printerName } = args || {};
+      const platform = os.platform();
+
+      if (platform === 'darwin' || platform === 'linux') {
+        const lpArgs = printerName ? ['-o', printerName] : ['-o'];
+        const { stdout } = await execFileAsync('lpstat', lpArgs).catch(e => ({ stdout: e.stdout || '' }));
+        const lines = (stdout || '').split('\n').map(l => l.trim()).filter(Boolean);
+
+        const activeJobs = lines.map(line => {
+          const parts = line.split(' ');
+          return {
+            jobId: parts[0],
+            owner: parts[1] || 'Unknown',
+            sizeOrStatus: parts.slice(2).join(' ')
+          };
+        });
+
+        return {
+          success: true,
+          platform,
+          activeJobsCount: activeJobs.length,
+          activeJobs
+        };
+      } else if (platform === 'win32') {
+        const filter = printerName ? ` -Filter "Name LIKE '%${printerName.replace(/'/g, "''")}%'"` : '';
+        const psScript = `
+          Get-CimInstance -ClassName Win32_PrintJob${filter} | Select-Object JobId, Document, Owner, Status | ConvertTo-Json -Compress
+        `.trim();
+
+        const { stdout } = await execFileAsync('powershell.exe', [
+          '-NoProfile',
+          '-NonInteractive',
+          '-Command',
+          psScript
+        ]);
+
+        let raw = [];
+        try {
+          const parsed = JSON.parse(stdout.trim() || '[]');
+          raw = Array.isArray(parsed) ? parsed : [parsed];
+        } catch (e) {
+          raw = [];
+        }
+
+        return {
+          success: true,
+          platform,
+          activeJobsCount: raw.length,
+          activeJobs: raw
+        };
+      } else {
+        return { success: false, error: `Unsupported OS platform: ${platform}` };
+      }
+    } catch (error) {
+      return { success: false, error: `Failed to inspect printer status: ${error.message}` };
+    }
+  }
+};
+
+// Backwards compatibility alias for registry single imports
+export const printerTool = printerPrint;

package/src/tools/procTerm.js

@@ -0,0 +1,91 @@
+import { sendSignal } from '../procSignal.js';
+import { ensureCapability, loadCapabilityPackage } from '../provisioning/capabilityProvisioner.js';
+
+export const procTerm = {
+  schema: {
+    name: 'proc.term',
+    description: 'Gracefully terminate a running process via native POSIX signals without shell execution vulnerabilities.',
+    parameters: {
+      type: 'object',
+      properties: {
+        pid: { type: 'number' },
+        name: { type: 'string' },
+        port: { type: 'number' },
+        signal: { type: 'string', description: 'Signal name (e.g. SIGTERM, SIGKILL). Defaults to SIGTERM.' }
+      }
+    }
+  },
+  async execute(args) {
+    try {
+      const signal = args.signal || 'SIGTERM';
+      let targetPids = [];
+      
+      if (args.pid) {
+        targetPids.push(args.pid);
+      } 
+      else if (args.name || args.port) {
+        // D-2 resolved: `find-process` was referenced but was in neither
+        // dependencies nor node_modules, so this branch had never once worked.
+        // Adding it would have meant a new static dependency (ZM-06); instead
+        // the resolution reuses systeminformation, which the "system"
+        // capability group already provisions for process_list. One package,
+        // one consent prompt, two tools.
+        const capability = await ensureCapability('system');
+        if (!capability.ok) {
+          return {
+            success: false,
+            error: capability.reason + ' Until then, pass an explicit numeric pid.',
+            requiresConsent: capability.requiresConsent
+          };
+        }
+        const si = await loadCapabilityPackage('systeminformation');
+
+        let results = [];
+        if (args.name) {
+          const wanted = String(args.name).toLowerCase();
+          const data = await si.processes();
+          results = (data.list || []).filter(proc =>
+            String(proc.name || '').toLowerCase().includes(wanted) ||
+            String(proc.command || '').toLowerCase().includes(wanted)
+          );
+        } else if (args.port) {
+          // Port ownership is a separate table; map it back to the pid.
+          const connections = await si.networkConnections();
+          const wanted = String(args.port);
+          results = (connections || [])
+            .filter(conn => String(conn.localPort) === wanted && conn.pid)
+            .map(conn => ({ pid: Number(conn.pid) }));
+        }
+
+        if (results.length === 0) {
+          return { success: false, error: `No matching processes found for ${args.name || 'port ' + args.port}` };
+        }
+        targetPids = [...new Set(results.map(proc => proc.pid))].filter(Number.isInteger);
+      } 
+      else {
+        return { success: false, error: 'Must provide pid, name, or port' };
+      }
+      
+      // Phase 6 AGI Upgrade: Graceful Native POSIX Signal Delivery
+      let killedCount = 0;
+      let failedCount = 0;
+      
+      for (const pid of targetPids) {
+        try {
+          sendSignal(pid, signal);
+          killedCount++;
+        } catch (e) {
+          failedCount++;
+        }
+      }
+      
+      if (killedCount === 0 && failedCount > 0) {
+        return { success: false, error: `Failed to deliver ${signal} to ${failedCount} processes. They may be immune or require elevated privileges.` };
+      }
+      
+      return { success: true, output: `Successfully dispatched native ${signal} signal to ${killedCount} processes.` };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};

package/src/tools/processList.js

@@ -0,0 +1,52 @@
+import { ensureCapability, loadCapabilityPackage } from '../provisioning/capabilityProvisioner.js';
+export const processList = {
+  schema: {
+    name: 'process.list',
+    description: 'List running processes using native OS bindings. Automatically filters out OS noise to protect Context Window.',
+    parameters: {
+      type: 'object',
+      properties: {
+        filter: { type: 'string', description: 'Filter by name (e.g. "node")' }
+      }
+    }
+  },
+  async execute(args) {
+    try {
+      // Phase 2 AGI Upgrade: Native OS Bindings
+      const capability = await ensureCapability('system');
+      if (!capability.ok) return { success: false, error: capability.reason, requiresConsent: capability.requiresConsent };
+      const si = await loadCapabilityPackage('systeminformation');
+
+      const processData = await si.processes();
+      
+      let filtered = processData.list.filter(p => {
+        // AGI Optimization: Keep heavy applications (CPU > 5% or RAM > ~100MB depending on OS reporting)
+        if (p.cpu > 5 || p.mem > 1) return true;
+        
+        // Keep common dev tools
+        const name = p.name.toLowerCase();
+        if (name.includes('node') || name.includes('python') || name.includes('docker') || name.includes('java') || name.includes('git')) return true;
+        
+        // Keep Causyne processes
+        if (p.command && p.command.toLowerCase().includes('causyne')) return true;
+        
+        return false;
+      });
+      
+      if (args.filter) {
+        filtered = filtered.filter(p => p.name.toLowerCase().includes(args.filter.toLowerCase()));
+      }
+      
+      const formatted = filtered.map(p => ({
+        pid: p.pid,
+        name: p.name,
+        cpu_percent: Math.round(p.cpu),
+        ram_mb: Math.round(p.memRss / 1024)
+      }));
+      
+      return { success: true, output: JSON.stringify(formatted, null, 2) };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};

package/src/tools/readNativeSkill.js

@@ -0,0 +1,39 @@
+import { readCompiledSkill } from '../skillsManager.js';
+
+export default {
+  schema: {
+    name: "fs_read_skill",
+    description: "Read the full contents of a native AI skill from the bundled readable skill data. Use this to read the instructions for a specific skill.",
+    parameters: {
+      type: "object",
+      properties: {
+        skill_id: {
+          type: "string",
+          description: "The ID of the skill to read (e.g. 'devops/docker-best-practices' or 'python/python-env-isolation')"
+        }
+      },
+      required: ["skill_id"]
+    }
+  },
+  execute: async (args) => {
+    try {
+      const parts = args.skill_id.split('/');
+      if (parts.length !== 2) {
+        return { success: false, error: 'Invalid skill_id format. Expected "domain/skillName"' };
+      }
+      
+      const domain = parts[0];
+      const skillName = parts[1];
+      
+      const content = readCompiledSkill(domain, skillName);
+      
+      if (content.startsWith('Error:')) {
+        return { success: false, error: content };
+      }
+      
+      return { success: true, result: content };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};