@siftd/connect-agent 0.2.0 → 0.2.3

package/dist/tools/bash.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Bash Tool
+ * Execute shell commands with safety controls
+ */
+export interface ToolResult {
+    success: boolean;
+    output: string;
+    error?: string;
+}
+export declare class BashTool {
+    private workspaceDir;
+    private shellInit;
+    constructor(workspaceDir: string);
+    /**
+     * Execute a bash command
+     */
+    execute(command: string, timeout?: number): Promise<ToolResult>;
+}

package/dist/tools/bash.js

@@ -0,0 +1,85 @@
+/**
+ * Bash Tool
+ * Execute shell commands with safety controls
+ */
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+const MAX_OUTPUT_LENGTH = 10000;
+const DEFAULT_TIMEOUT = 30000;
+const MAX_TIMEOUT = 120000;
+export class BashTool {
+    workspaceDir;
+    shellInit;
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+        // Shell initialization for proper environment
+        this.shellInit = 'source ~/.zshrc 2>/dev/null || source ~/.bashrc 2>/dev/null || true; ';
+    }
+    /**
+     * Execute a bash command
+     */
+    async execute(command, timeout) {
+        // Clamp timeout
+        const effectiveTimeout = Math.min(Math.max(timeout || DEFAULT_TIMEOUT, 1000), MAX_TIMEOUT);
+        try {
+            const effectiveCommand = `${this.shellInit}${command}`;
+            const { stdout, stderr } = await execAsync(effectiveCommand, {
+                cwd: this.workspaceDir,
+                timeout: effectiveTimeout,
+                maxBuffer: 1024 * 1024 * 10, // 10MB
+                shell: '/bin/zsh',
+                env: { ...process.env }
+            });
+            let output = '';
+            if (stdout) {
+                output += stdout;
+            }
+            if (stderr) {
+                output += (output ? '\n\n' : '') + `[stderr]\n${stderr}`;
+            }
+            if (!output) {
+                output = '(command completed with no output)';
+            }
+            // Truncate long output
+            if (output.length > MAX_OUTPUT_LENGTH) {
+                output = output.slice(0, MAX_OUTPUT_LENGTH) +
+                    `\n\n[... truncated, ${output.length - MAX_OUTPUT_LENGTH} more characters]`;
+            }
+            return { success: true, output };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                // Handle timeout
+                if (error.message.includes('TIMEOUT')) {
+                    return {
+                        success: false,
+                        output: '',
+                        error: `Command timed out after ${effectiveTimeout}ms`
+                    };
+                }
+                // Handle exec errors (non-zero exit codes)
+                const execError = error;
+                let output = '';
+                if (execError.stdout)
+                    output += execError.stdout;
+                if (execError.stderr)
+                    output += (output ? '\n\n' : '') + `[stderr]\n${execError.stderr}`;
+                // Truncate
+                if (output.length > MAX_OUTPUT_LENGTH) {
+                    output = output.slice(0, MAX_OUTPUT_LENGTH) + `\n\n[... truncated]`;
+                }
+                return {
+                    success: false,
+                    output,
+                    error: `Exit code ${execError.code || 'unknown'}: ${error.message.slice(0, 200)}`
+                };
+            }
+            return {
+                success: false,
+                output: '',
+                error: String(error)
+            };
+        }
+    }
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tools Index
+ * Central registry for all available tools
+ */
+export { BashTool } from './bash.js';
+export type { ToolResult } from './bash.js';
+export { WebTools } from './web.js';
+export { WorkerTools } from './worker.js';

package/dist/tools/index.js

@@ -0,0 +1,7 @@
+/**
+ * Tools Index
+ * Central registry for all available tools
+ */
+export { BashTool } from './bash.js';
+export { WebTools } from './web.js';
+export { WorkerTools } from './worker.js';

package/dist/tools/web.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Web Access Tools
+ * Fetch URLs and search the web
+ */
+import type { ToolResult } from './bash.js';
+interface FetchOptions {
+    selector?: string;
+    format?: 'text' | 'html' | 'json';
+    timeout?: number;
+    maxSize?: number;
+}
+export declare class WebTools {
+    private maxResponseSize;
+    private defaultTimeout;
+    constructor(options?: {
+        maxResponseSize?: number;
+        defaultTimeout?: number;
+    });
+    /**
+     * Check rate limit
+     */
+    private checkRateLimit;
+    /**
+     * Record a request for rate limiting
+     */
+    private recordRequest;
+    /**
+     * Fetch and parse a URL
+     */
+    fetchUrl(url: string, options?: FetchOptions): Promise<ToolResult>;
+    /**
+     * Search the web using DuckDuckGo HTML (no API key needed)
+     */
+    webSearch(query: string, options?: {
+        numResults?: number;
+    }): Promise<ToolResult>;
+}
+export {};

package/dist/tools/web.js

@@ -0,0 +1,284 @@
+/**
+ * Web Access Tools
+ * Fetch URLs and search the web
+ */
+// Rate limiting
+const requestTimes = [];
+const RATE_LIMIT_WINDOW = 60000; // 1 minute
+const MAX_REQUESTS = 10;
+export class WebTools {
+    maxResponseSize;
+    defaultTimeout;
+    constructor(options) {
+        this.maxResponseSize = options?.maxResponseSize || 1024 * 1024; // 1MB
+        this.defaultTimeout = options?.defaultTimeout || 10000; // 10s
+    }
+    /**
+     * Check rate limit
+     */
+    checkRateLimit() {
+        const now = Date.now();
+        // Remove old requests
+        while (requestTimes.length > 0 && requestTimes[0] < now - RATE_LIMIT_WINDOW) {
+            requestTimes.shift();
+        }
+        return requestTimes.length < MAX_REQUESTS;
+    }
+    /**
+     * Record a request for rate limiting
+     */
+    recordRequest() {
+        requestTimes.push(Date.now());
+    }
+    /**
+     * Fetch and parse a URL
+     */
+    async fetchUrl(url, options = {}) {
+        // Validate URL
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(url);
+            if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
+                return {
+                    success: false,
+                    output: '',
+                    error: 'Only HTTP and HTTPS URLs are supported'
+                };
+            }
+        }
+        catch {
+            return {
+                success: false,
+                output: '',
+                error: 'Invalid URL format'
+            };
+        }
+        // Check rate limit
+        if (!this.checkRateLimit()) {
+            return {
+                success: false,
+                output: '',
+                error: `Rate limit exceeded. Max ${MAX_REQUESTS} requests per minute.`
+            };
+        }
+        const timeout = Math.min(options.timeout || this.defaultTimeout, 30000);
+        const format = options.format || 'text';
+        try {
+            this.recordRequest();
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+            const response = await fetch(url, {
+                signal: controller.signal,
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (compatible; ConnectAgent/1.0)',
+                    'Accept': format === 'json' ? 'application/json' : 'text/html,text/plain,*/*'
+                }
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                return {
+                    success: false,
+                    output: '',
+                    error: `HTTP ${response.status}: ${response.statusText}`
+                };
+            }
+            // Check content length
+            const contentLength = response.headers.get('content-length');
+            if (contentLength && parseInt(contentLength) > this.maxResponseSize) {
+                return {
+                    success: false,
+                    output: '',
+                    error: `Response too large: ${contentLength} bytes (max: ${this.maxResponseSize})`
+                };
+            }
+            // Get content type
+            const contentType = response.headers.get('content-type') || '';
+            // Handle JSON
+            if (format === 'json' || contentType.includes('application/json')) {
+                const json = await response.json();
+                return {
+                    success: true,
+                    output: JSON.stringify(json, null, 2)
+                };
+            }
+            // Get text content
+            const text = await response.text();
+            // Check size after fetch (for streaming responses)
+            if (text.length > this.maxResponseSize) {
+                return {
+                    success: true,
+                    output: text.slice(0, this.maxResponseSize) + '\n\n[Content truncated...]'
+                };
+            }
+            // Parse HTML if needed - basic extraction without cheerio dependency
+            if (contentType.includes('text/html')) {
+                // Extract text content from HTML
+                let mainContent = text
+                    // Remove script and style tags
+                    .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+                    .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+                    // Remove HTML tags
+                    .replace(/<[^>]+>/g, ' ')
+                    // Decode HTML entities
+                    .replace(/&nbsp;/g, ' ')
+                    .replace(/&amp;/g, '&')
+                    .replace(/&lt;/g, '<')
+                    .replace(/&gt;/g, '>')
+                    .replace(/&quot;/g, '"')
+                    // Clean up whitespace
+                    .replace(/\s+/g, ' ')
+                    .trim();
+                // Extract title
+                const titleMatch = text.match(/<title[^>]*>([^<]+)<\/title>/i);
+                const title = titleMatch ? titleMatch[1].trim() : '';
+                let output = '';
+                if (title) {
+                    output += `Title: ${title}\n\n`;
+                }
+                output += mainContent;
+                // Truncate if too long
+                if (output.length > 10000) {
+                    output = output.slice(0, 10000) + '\n\n[Content truncated...]';
+                }
+                return {
+                    success: true,
+                    output
+                };
+            }
+            // Plain text
+            return {
+                success: true,
+                output: text
+            };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.name === 'AbortError') {
+                    return {
+                        success: false,
+                        output: '',
+                        error: `Request timed out after ${timeout}ms`
+                    };
+                }
+                return {
+                    success: false,
+                    output: '',
+                    error: error.message
+                };
+            }
+            return {
+                success: false,
+                output: '',
+                error: String(error)
+            };
+        }
+    }
+    /**
+     * Search the web using DuckDuckGo HTML (no API key needed)
+     */
+    async webSearch(query, options) {
+        const numResults = Math.min(options?.numResults || 5, 10);
+        // Check rate limit
+        if (!this.checkRateLimit()) {
+            return {
+                success: false,
+                output: '',
+                error: `Rate limit exceeded. Max ${MAX_REQUESTS} requests per minute.`
+            };
+        }
+        try {
+            this.recordRequest();
+            // Use DuckDuckGo HTML
+            const searchUrl = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 15000);
+            const response = await fetch(searchUrl, {
+                signal: controller.signal,
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                    'Accept': 'text/html'
+                }
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                return {
+                    success: false,
+                    output: '',
+                    error: `Search failed: HTTP ${response.status}`
+                };
+            }
+            const html = await response.text();
+            // Parse results with regex (no cheerio)
+            const results = [];
+            // Match result divs - DuckDuckGo structure
+            const resultPattern = /<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>([^<]*)<\/a>[\s\S]*?<a[^>]*class="result__snippet"[^>]*>([^<]*)<\/a>/gi;
+            let match;
+            while ((match = resultPattern.exec(html)) !== null && results.length < numResults) {
+                let url = match[1];
+                const title = match[2].trim();
+                const snippet = match[3].trim();
+                // DuckDuckGo uses redirect URLs, extract the actual URL
+                if (url.includes('uddg=')) {
+                    const uddgMatch = url.match(/uddg=([^&]+)/);
+                    if (uddgMatch) {
+                        url = decodeURIComponent(uddgMatch[1]);
+                    }
+                }
+                if (title && url) {
+                    results.push({ title, url, snippet });
+                }
+            }
+            // Fallback: simpler pattern
+            if (results.length === 0) {
+                const simplePattern = /<a[^>]*href="(https?:\/\/[^"]+)"[^>]*>([^<]+)<\/a>/gi;
+                while ((match = simplePattern.exec(html)) !== null && results.length < numResults) {
+                    const url = match[1];
+                    const title = match[2].trim();
+                    if (title && url && !url.includes('duckduckgo.com')) {
+                        results.push({ title, url, snippet: '' });
+                    }
+                }
+            }
+            if (results.length === 0) {
+                return {
+                    success: true,
+                    output: 'No results found for this query.'
+                };
+            }
+            let output = `Search results for: "${query}"\n\n`;
+            results.forEach((result, i) => {
+                output += `${i + 1}. ${result.title}\n`;
+                output += `   URL: ${result.url}\n`;
+                if (result.snippet) {
+                    output += `   ${result.snippet}\n`;
+                }
+                output += '\n';
+            });
+            return {
+                success: true,
+                output
+            };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.name === 'AbortError') {
+                    return {
+                        success: false,
+                        output: '',
+                        error: 'Search timed out'
+                    };
+                }
+                return {
+                    success: false,
+                    output: '',
+                    error: error.message
+                };
+            }
+            return {
+                success: false,
+                output: '',
+                error: String(error)
+            };
+        }
+    }
+}

package/dist/tools/worker.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Worker Tools
+ * Tools for spawning and managing Claude Code workers
+ */
+import type { ToolResult } from './bash.js';
+export declare class WorkerTools {
+    private manager;
+    constructor(workspaceDir: string);
+    /**
+     * Spawn a new Claude Code worker
+     */
+    spawnWorker(task: string, options?: {
+        timeout?: number;
+        priority?: 'low' | 'normal' | 'high' | 'critical';
+    }): Promise<ToolResult>;
+    /**
+     * Check worker status
+     */
+    checkWorker(jobId: string): Promise<ToolResult>;
+    /**
+     * Wait for worker to complete
+     */
+    waitWorker(jobId: string, maxWait?: number): Promise<ToolResult>;
+    /**
+     * List all workers
+     */
+    listWorkers(status?: string): Promise<ToolResult>;
+    /**
+     * Cancel a running worker
+     */
+    cancelWorker(jobId: string): Promise<ToolResult>;
+    /**
+     * Clean up old jobs
+     */
+    cleanupWorkers(): Promise<ToolResult>;
+}

package/dist/tools/worker.js

@@ -0,0 +1,149 @@
+/**
+ * Worker Tools
+ * Tools for spawning and managing Claude Code workers
+ */
+import { WorkerManager } from '../workers/manager.js';
+export class WorkerTools {
+    manager;
+    constructor(workspaceDir) {
+        this.manager = new WorkerManager(workspaceDir);
+    }
+    /**
+     * Spawn a new Claude Code worker
+     */
+    async spawnWorker(task, options) {
+        try {
+            const jobId = await this.manager.spawn(task, {
+                timeout: options?.timeout,
+                priority: options?.priority
+            });
+            const job = this.manager.get(jobId);
+            return {
+                success: true,
+                output: `Worker spawned successfully.\nJob ID: ${jobId}\nStatus: ${job?.status || 'pending'}\nTask: ${task}\n\nUse check_worker("${jobId}") to check status, or wait_worker("${jobId}") to wait for completion.`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                output: '',
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    /**
+     * Check worker status
+     */
+    async checkWorker(jobId) {
+        const job = this.manager.get(jobId);
+        if (!job) {
+            return {
+                success: false,
+                output: '',
+                error: `Job ${jobId} not found`
+            };
+        }
+        let output = `Job: ${job.id}\nStatus: ${job.status}\nTask: ${job.task}\nCreated: ${job.created}`;
+        if (job.started) {
+            output += `\nStarted: ${job.started}`;
+        }
+        if (job.completed) {
+            output += `\nCompleted: ${job.completed}`;
+        }
+        if (job.result) {
+            output += `\n\nResult:\n${job.result}`;
+        }
+        if (job.error) {
+            output += `\n\nError: ${job.error}`;
+        }
+        return {
+            success: true,
+            output
+        };
+    }
+    /**
+     * Wait for worker to complete
+     */
+    async waitWorker(jobId, maxWait) {
+        try {
+            const job = await this.manager.wait(jobId, maxWait);
+            let output = `Job ${job.id} ${job.status}.\n`;
+            if (job.result) {
+                output += `\nResult:\n${job.result}`;
+            }
+            if (job.error) {
+                output += `\nError: ${job.error}`;
+            }
+            return {
+                success: job.status === 'completed',
+                output,
+                error: job.status !== 'completed' ? `Job ${job.status}` : undefined
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                output: '',
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    /**
+     * List all workers
+     */
+    async listWorkers(status) {
+        const jobs = this.manager.list(status ? { status } : undefined);
+        const summary = this.manager.summary();
+        if (jobs.length === 0) {
+            return {
+                success: true,
+                output: 'No jobs found.'
+            };
+        }
+        let output = `Jobs Summary: ${summary.total} total (${summary.running} running, ${summary.completed} completed, ${summary.failed} failed)\n\n`;
+        for (const job of jobs.slice(0, 20)) { // Limit to 20 most recent
+            output += `[${job.status.toUpperCase()}] ${job.id}\n`;
+            output += `  Task: ${job.task.slice(0, 80)}${job.task.length > 80 ? '...' : ''}\n`;
+            output += `  Created: ${job.created}\n`;
+            if (job.result && job.status === 'completed') {
+                const preview = job.result.slice(0, 100);
+                output += `  Result: ${preview}${job.result.length > 100 ? '...' : ''}\n`;
+            }
+            output += '\n';
+        }
+        if (jobs.length > 20) {
+            output += `... and ${jobs.length - 20} more jobs`;
+        }
+        return {
+            success: true,
+            output
+        };
+    }
+    /**
+     * Cancel a running worker
+     */
+    async cancelWorker(jobId) {
+        const cancelled = this.manager.cancel(jobId);
+        if (cancelled) {
+            return {
+                success: true,
+                output: `Job ${jobId} cancelled successfully.`
+            };
+        }
+        return {
+            success: false,
+            output: '',
+            error: `Could not cancel job ${jobId}. It may not exist or is not running.`
+        };
+    }
+    /**
+     * Clean up old jobs
+     */
+    async cleanupWorkers() {
+        const cleaned = this.manager.cleanup();
+        return {
+            success: true,
+            output: `Cleaned up ${cleaned} old job(s).`
+        };
+    }
+}