@siftd/connect-agent 0.2.0 → 0.2.3

package/dist/websocket.d.ts

@@ -0,0 +1,73 @@
+/**
+ * WebSocket Client for Real-Time Communication
+ *
+ * Provides bidirectional streaming between agent and server.
+ * - Receives messages instantly (no polling delay)
+ * - Streams responses as they're generated
+ * - Supports interruption and progress updates
+ */
+export type MessageHandler = (message: WebSocketMessage) => Promise<void>;
+export type StreamHandler = (chunk: string) => void;
+export interface WebSocketMessage {
+    type: 'message' | 'interrupt' | 'ping' | 'pong' | 'connected';
+    id?: string;
+    content?: string;
+    timestamp?: number;
+    apiKey?: string;
+}
+export interface StreamingResponse {
+    send: (chunk: string) => void;
+    done: () => void;
+    error: (message: string) => void;
+}
+export declare class AgentWebSocket {
+    private ws;
+    private serverUrl;
+    private token;
+    private messageHandler;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    private pingInterval;
+    private isConnected;
+    private pendingResponses;
+    private cloudflareBlocked;
+    constructor();
+    /**
+     * Connect to the WebSocket server
+     */
+    connect(): Promise<boolean>;
+    /**
+     * Set handler for incoming messages
+     */
+    onMessage(handler: MessageHandler): void;
+    /**
+     * Send a streaming response for a message
+     */
+    createStreamingResponse(messageId: string): StreamingResponse;
+    /**
+     * Send a complete response (non-streaming)
+     */
+    sendResponse(messageId: string, content: string): void;
+    /**
+     * Send progress update
+     */
+    sendProgress(messageId: string, status: string): void;
+    /**
+     * Send typing indicator
+     */
+    sendTyping(isTyping: boolean): void;
+    /**
+     * Check if connected
+     */
+    connected(): boolean;
+    /**
+     * Close the connection
+     */
+    close(): void;
+    private handleMessage;
+    private sendToServer;
+    private startPingInterval;
+    private stopPingInterval;
+    private attemptReconnect;
+}

package/dist/websocket.js

@@ -0,0 +1,243 @@
+/**
+ * WebSocket Client for Real-Time Communication
+ *
+ * Provides bidirectional streaming between agent and server.
+ * - Receives messages instantly (no polling delay)
+ * - Streams responses as they're generated
+ * - Supports interruption and progress updates
+ */
+import WebSocket from 'ws';
+import { getServerUrl, getAgentToken } from './config.js';
+export class AgentWebSocket {
+    ws = null;
+    serverUrl;
+    token;
+    messageHandler = null;
+    reconnectAttempts = 0;
+    maxReconnectAttempts = 3; // Reduced - don't spam retries, polling works fine
+    reconnectDelay = 1000;
+    pingInterval = null;
+    isConnected = false;
+    pendingResponses = new Map();
+    cloudflareBlocked = false; // Track if Cloudflare is blocking WebSockets
+    constructor() {
+        const httpUrl = getServerUrl();
+        // Check for WebSocket-specific URL (bypasses Cloudflare)
+        const wsOverride = process.env.CONNECT_WS_URL;
+        if (wsOverride) {
+            this.serverUrl = wsOverride;
+        }
+        else {
+            // Convert http(s) to ws(s)
+            this.serverUrl = httpUrl.replace(/^http/, 'ws') + '/api/agent/ws';
+        }
+        this.token = getAgentToken() || '';
+    }
+    /**
+     * Connect to the WebSocket server
+     */
+    async connect() {
+        return new Promise((resolve) => {
+            try {
+                console.log('[WS] Connecting to', this.serverUrl);
+                this.ws = new WebSocket(this.serverUrl, {
+                    headers: {
+                        'Authorization': `Bearer ${this.token}`
+                    }
+                });
+                this.ws.on('open', () => {
+                    console.log('[WS] Connected');
+                    this.isConnected = true;
+                    this.reconnectAttempts = 0;
+                    this.startPingInterval();
+                    resolve(true);
+                });
+                this.ws.on('message', (data) => {
+                    this.handleMessage(data.toString());
+                });
+                this.ws.on('close', (code, reason) => {
+                    // Don't log disconnects if Cloudflare is blocking (polling is working)
+                    if (!this.cloudflareBlocked) {
+                        console.log(`[WS] Disconnected (${code}): ${reason}`);
+                    }
+                    this.isConnected = false;
+                    this.stopPingInterval();
+                    this.attemptReconnect();
+                });
+                this.ws.on('error', (error) => {
+                    // Check for Cloudflare 524 timeout - don't spam logs
+                    if (error.message.includes('524') || error.message.includes('Unexpected server response')) {
+                        if (!this.cloudflareBlocked) {
+                            this.cloudflareBlocked = true;
+                            // Only log once, not every retry
+                        }
+                    }
+                    else {
+                        console.error('[WS] Error:', error.message);
+                    }
+                    if (!this.isConnected) {
+                        resolve(false);
+                    }
+                });
+                // Timeout for initial connection
+                setTimeout(() => {
+                    if (!this.isConnected) {
+                        console.log('[WS] Connection timeout');
+                        resolve(false);
+                    }
+                }, 10000);
+            }
+            catch (error) {
+                console.error('[WS] Connection failed:', error);
+                resolve(false);
+            }
+        });
+    }
+    /**
+     * Set handler for incoming messages
+     */
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    /**
+     * Send a streaming response for a message
+     */
+    createStreamingResponse(messageId) {
+        const response = {
+            send: (chunk) => {
+                this.sendToServer({
+                    type: 'stream',
+                    messageId,
+                    chunk
+                });
+            },
+            done: () => {
+                this.sendToServer({
+                    type: 'stream_end',
+                    messageId
+                });
+                this.pendingResponses.delete(messageId);
+            },
+            error: (message) => {
+                this.sendToServer({
+                    type: 'stream_error',
+                    messageId,
+                    error: message
+                });
+                this.pendingResponses.delete(messageId);
+            }
+        };
+        this.pendingResponses.set(messageId, response);
+        return response;
+    }
+    /**
+     * Send a complete response (non-streaming)
+     */
+    sendResponse(messageId, content) {
+        this.sendToServer({
+            type: 'response',
+            messageId,
+            content
+        });
+    }
+    /**
+     * Send progress update
+     */
+    sendProgress(messageId, status) {
+        this.sendToServer({
+            type: 'progress',
+            messageId,
+            status
+        });
+    }
+    /**
+     * Send typing indicator
+     */
+    sendTyping(isTyping) {
+        this.sendToServer({
+            type: 'typing',
+            isTyping
+        });
+    }
+    /**
+     * Check if connected
+     */
+    connected() {
+        return this.isConnected && this.ws?.readyState === WebSocket.OPEN;
+    }
+    /**
+     * Close the connection
+     */
+    close() {
+        this.stopPingInterval();
+        this.maxReconnectAttempts = 0; // Prevent reconnection
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.isConnected = false;
+    }
+    handleMessage(data) {
+        try {
+            const message = JSON.parse(data);
+            switch (message.type) {
+                case 'ping':
+                    this.sendToServer({ type: 'pong' });
+                    break;
+                case 'pong':
+                    // Expected response to our ping, ignore silently
+                    break;
+                case 'connected':
+                    console.log('[WS] Server confirmed connection');
+                    break;
+                case 'interrupt':
+                    console.log('[WS] Received interrupt for message:', message.id);
+                    // TODO: Cancel ongoing work for this message
+                    break;
+                case 'message':
+                    if (this.messageHandler && message.content) {
+                        this.messageHandler(message);
+                    }
+                    break;
+                default:
+                    console.log('[WS] Unknown message type:', message.type);
+            }
+        }
+        catch (error) {
+            console.error('[WS] Failed to parse message:', error);
+        }
+    }
+    sendToServer(data) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(data));
+        }
+    }
+    startPingInterval() {
+        this.pingInterval = setInterval(() => {
+            if (this.connected()) {
+                this.sendToServer({ type: 'ping' });
+            }
+        }, 30000);
+    }
+    stopPingInterval() {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
+    }
+    attemptReconnect() {
+        // Don't retry if Cloudflare is blocking WebSockets
+        if (this.cloudflareBlocked) {
+            return;
+        }
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            // Silent - polling is working fine
+            return;
+        }
+        this.reconnectAttempts++;
+        const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+        setTimeout(() => {
+            this.connect();
+        }, delay);
+    }
+}

package/dist/workers/manager.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Claude Code Worker Manager
+ * Spawns and manages Claude Code CLI instances for parallel task execution
+ */
+import { WorkerJob, SpawnOptions, WorkerConfig } from './types.js';
+export declare class WorkerManager {
+    private config;
+    private activeWorkers;
+    constructor(workspaceDir: string, configOverrides?: Partial<WorkerConfig>);
+    /**
+     * Generate a unique job ID
+     */
+    private generateJobId;
+    /**
+     * Get job file path
+     */
+    private getJobPath;
+    /**
+     * Save job state
+     */
+    private saveJob;
+    /**
+     * Count currently running workers
+     */
+    private countRunning;
+    /**
+     * Spawn a new Claude Code worker
+     */
+    spawn(task: string, options?: SpawnOptions): Promise<string>;
+    /**
+     * Get job status
+     */
+    get(jobId: string): WorkerJob | null;
+    /**
+     * Wait for a job to complete
+     */
+    wait(jobId: string, maxWait?: number): Promise<WorkerJob>;
+    /**
+     * List jobs with optional filter
+     */
+    list(filter?: {
+        status?: string;
+    }): WorkerJob[];
+    /**
+     * Cancel a running job
+     */
+    cancel(jobId: string): boolean;
+    /**
+     * Clean up old completed/failed jobs
+     */
+    cleanup(olderThanMs?: number): number;
+    /**
+     * Get summary of all jobs
+     */
+    summary(): {
+        total: number;
+        running: number;
+        completed: number;
+        failed: number;
+        pending: number;
+    };
+}

package/dist/workers/manager.js

@@ -0,0 +1,270 @@
+/**
+ * Claude Code Worker Manager
+ * Spawns and manages Claude Code CLI instances for parallel task execution
+ */
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { DEFAULT_WORKER_CONFIG } from './types.js';
+export class WorkerManager {
+    config;
+    activeWorkers = new Map();
+    constructor(workspaceDir, configOverrides) {
+        this.config = {
+            ...DEFAULT_WORKER_CONFIG,
+            ...configOverrides,
+            jobsDir: path.join(workspaceDir, 'jobs')
+        };
+        // Ensure jobs directory exists
+        if (!fs.existsSync(this.config.jobsDir)) {
+            fs.mkdirSync(this.config.jobsDir, { recursive: true });
+        }
+    }
+    /**
+     * Generate a unique job ID
+     */
+    generateJobId() {
+        return `job_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    }
+    /**
+     * Get job file path
+     */
+    getJobPath(jobId) {
+        return path.join(this.config.jobsDir, `${jobId}.json`);
+    }
+    /**
+     * Save job state
+     */
+    saveJob(job) {
+        fs.writeFileSync(this.getJobPath(job.id), JSON.stringify(job, null, 2));
+    }
+    /**
+     * Count currently running workers
+     */
+    countRunning() {
+        const jobs = this.list({ status: 'running' });
+        return jobs.length;
+    }
+    /**
+     * Spawn a new Claude Code worker
+     */
+    async spawn(task, options = {}) {
+        const { workspace = process.cwd(), timeout = this.config.defaultTimeout, priority = 'normal' } = options;
+        // Check parallel limit
+        const runningCount = this.countRunning();
+        if (runningCount >= this.config.maxParallel) {
+            throw new Error(`Maximum parallel workers (${this.config.maxParallel}) reached. ${runningCount} workers running.`);
+        }
+        // Validate timeout
+        const effectiveTimeout = Math.min(timeout, this.config.maxTimeout);
+        const jobId = this.generateJobId();
+        const job = {
+            id: jobId,
+            task,
+            workspace,
+            status: 'pending',
+            priority,
+            created: new Date().toISOString(),
+            timeout: effectiveTimeout
+        };
+        this.saveJob(job);
+        // Spawn Claude CLI process
+        try {
+            // Escape single quotes in task for shell safety
+            const escapedTask = task.replace(/'/g, "'\\''");
+            // Spawn using bash -l -c to ensure proper PATH resolution (NVM, etc.)
+            // This is more reliable than shell: true which has quote escaping issues
+            const child = spawn('bash', ['-l', '-c', `claude -p '${escapedTask}' --output-format text --dangerously-skip-permissions`], {
+                cwd: workspace,
+                detached: true,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                env: {
+                    ...process.env,
+                    ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
+                    GH_TOKEN: process.env.GH_TOKEN,
+                    GITHUB_TOKEN: process.env.GITHUB_TOKEN
+                }
+            });
+            job.status = 'running';
+            job.started = new Date().toISOString();
+            job.pid = child.pid;
+            this.saveJob(job);
+            this.activeWorkers.set(jobId, child);
+            let stdout = '';
+            let stderr = '';
+            child.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            child.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            // Set up timeout
+            const timeoutHandle = setTimeout(() => {
+                if (child.pid && !child.killed) {
+                    child.kill('SIGTERM');
+                    job.status = 'timeout';
+                    job.error = `Job timed out after ${effectiveTimeout}ms`;
+                    job.completed = new Date().toISOString();
+                    job.result = stdout || stderr;
+                    this.saveJob(job);
+                    this.activeWorkers.delete(jobId);
+                }
+            }, effectiveTimeout);
+            child.on('close', (code) => {
+                clearTimeout(timeoutHandle);
+                this.activeWorkers.delete(jobId);
+                // Reload job in case it was updated (e.g., cancelled)
+                const currentJob = this.get(jobId);
+                if (currentJob && currentJob.status === 'running') {
+                    currentJob.status = code === 0 ? 'completed' : 'failed';
+                    currentJob.completed = new Date().toISOString();
+                    currentJob.exitCode = code ?? undefined;
+                    currentJob.result = stdout.trim();
+                    if (stderr && code !== 0) {
+                        currentJob.error = stderr.trim();
+                    }
+                    this.saveJob(currentJob);
+                }
+            });
+            child.on('error', (err) => {
+                clearTimeout(timeoutHandle);
+                this.activeWorkers.delete(jobId);
+                job.status = 'failed';
+                job.error = err.message;
+                job.completed = new Date().toISOString();
+                this.saveJob(job);
+            });
+            // Detach the child process
+            child.unref();
+        }
+        catch (error) {
+            job.status = 'failed';
+            job.error = error instanceof Error ? error.message : String(error);
+            job.completed = new Date().toISOString();
+            this.saveJob(job);
+        }
+        return jobId;
+    }
+    /**
+     * Get job status
+     */
+    get(jobId) {
+        const jobPath = this.getJobPath(jobId);
+        if (!fs.existsSync(jobPath)) {
+            return null;
+        }
+        try {
+            return JSON.parse(fs.readFileSync(jobPath, 'utf8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Wait for a job to complete
+     */
+    async wait(jobId, maxWait = 300000) {
+        const pollInterval = 1000;
+        const start = Date.now();
+        while (Date.now() - start < maxWait) {
+            const job = this.get(jobId);
+            if (!job) {
+                throw new Error(`Job ${jobId} not found`);
+            }
+            if (job.status !== 'running' && job.status !== 'pending') {
+                return job;
+            }
+            await new Promise(resolve => setTimeout(resolve, pollInterval));
+        }
+        throw new Error(`Job ${jobId} did not complete within ${maxWait}ms`);
+    }
+    /**
+     * List jobs with optional filter
+     */
+    list(filter) {
+        if (!fs.existsSync(this.config.jobsDir)) {
+            return [];
+        }
+        const files = fs.readdirSync(this.config.jobsDir).filter(f => f.endsWith('.json'));
+        const jobs = [];
+        for (const file of files) {
+            try {
+                const job = JSON.parse(fs.readFileSync(path.join(this.config.jobsDir, file), 'utf8'));
+                if (!filter?.status || job.status === filter.status) {
+                    jobs.push(job);
+                }
+            }
+            catch {
+                // Skip invalid job files
+            }
+        }
+        // Sort by created date, newest first
+        return jobs.sort((a, b) => new Date(b.created).getTime() - new Date(a.created).getTime());
+    }
+    /**
+     * Cancel a running job
+     */
+    cancel(jobId) {
+        const job = this.get(jobId);
+        if (!job) {
+            return false;
+        }
+        if (job.status !== 'running') {
+            return false;
+        }
+        // Try to kill the process
+        const child = this.activeWorkers.get(jobId);
+        if (child && !child.killed) {
+            child.kill('SIGTERM');
+        }
+        else if (job.pid) {
+            try {
+                process.kill(job.pid, 'SIGTERM');
+            }
+            catch {
+                // Process may already be dead
+            }
+        }
+        job.status = 'cancelled';
+        job.completed = new Date().toISOString();
+        this.saveJob(job);
+        this.activeWorkers.delete(jobId);
+        return true;
+    }
+    /**
+     * Clean up old completed/failed jobs
+     */
+    cleanup(olderThanMs = this.config.jobRetention) {
+        const jobs = this.list();
+        let cleaned = 0;
+        for (const job of jobs) {
+            if (job.status === 'running' || job.status === 'pending') {
+                continue;
+            }
+            const completedTime = job.completed ? new Date(job.completed).getTime() : new Date(job.created).getTime();
+            if (Date.now() - completedTime > olderThanMs) {
+                try {
+                    fs.unlinkSync(this.getJobPath(job.id));
+                    cleaned++;
+                }
+                catch {
+                    // Ignore deletion errors
+                }
+            }
+        }
+        return cleaned;
+    }
+    /**
+     * Get summary of all jobs
+     */
+    summary() {
+        const jobs = this.list();
+        return {
+            total: jobs.length,
+            running: jobs.filter(j => j.status === 'running').length,
+            completed: jobs.filter(j => j.status === 'completed').length,
+            failed: jobs.filter(j => j.status === 'failed' || j.status === 'timeout').length,
+            pending: jobs.filter(j => j.status === 'pending').length
+        };
+    }
+}

package/dist/workers/types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Worker System Types
+ */
+export interface WorkerJob {
+    id: string;
+    task: string;
+    workspace: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'timeout' | 'cancelled';
+    priority: 'low' | 'normal' | 'high' | 'critical';
+    created: string;
+    started?: string;
+    completed?: string;
+    result?: string;
+    error?: string;
+    pid?: number;
+    timeout: number;
+    exitCode?: number;
+}
+export interface SpawnOptions {
+    workspace?: string;
+    timeout?: number;
+    priority?: 'low' | 'normal' | 'high' | 'critical';
+}
+export interface WorkerConfig {
+    maxParallel: number;
+    defaultTimeout: number;
+    maxTimeout: number;
+    jobRetention: number;
+    jobsDir: string;
+}
+export declare const DEFAULT_WORKER_CONFIG: WorkerConfig;

package/dist/workers/types.js

@@ -0,0 +1,10 @@
+/**
+ * Worker System Types
+ */
+export const DEFAULT_WORKER_CONFIG = {
+    maxParallel: 3,
+    defaultTimeout: 300000, // 5 minutes
+    maxTimeout: 1800000, // 30 minutes
+    jobRetention: 3600000, // 1 hour
+    jobsDir: '' // Set at runtime
+};