@siftd/connect-agent 0.2.0 → 0.2.3

package/dist/heartbeat.js

@@ -0,0 +1,166 @@
+/**
+ * Runner Heartbeat Module
+ *
+ * Sends periodic heartbeats to the Connect server to maintain presence.
+ * This is what makes a runner "connected" - NOT the pairing token.
+ *
+ * Both local and VM runners use this same module.
+ */
+import { hostname } from 'os';
+import { createHash } from 'crypto';
+import { getServerUrl, getAgentToken, getUserId, isCloudMode } from './config.js';
+const HEARTBEAT_INTERVAL = 10000; // 10 seconds
+const VERSION = '0.2.3'; // Should match package.json
+const state = {
+    intervalId: null,
+    runnerId: null,
+    isRunning: false,
+    lastSuccess: null,
+    consecutiveFailures: 0,
+};
+/**
+ * Generate a stable runner ID based on machine characteristics
+ * Format: local:<hash> or vm:<deploymentId>
+ */
+function generateRunnerId(runnerType) {
+    if (runnerType === 'vm') {
+        // For VM, use deployment ID from env or generate from container ID
+        const deploymentId = process.env.RAILWAY_DEPLOYMENT_ID
+            || process.env.FLY_ALLOC_ID
+            || process.env.CONTAINER_ID
+            || `vm-${createHash('sha256').update(hostname() + process.pid).digest('hex').substring(0, 8)}`;
+        return `vm:${deploymentId}`;
+    }
+    // For local, create a stable hash from machine characteristics
+    const machineId = createHash('sha256')
+        .update(hostname())
+        .update(process.env.USER || 'unknown')
+        .update(process.env.HOME || '/tmp')
+        .digest('hex')
+        .substring(0, 12);
+    return `local:${machineId}`;
+}
+/**
+ * Get the capabilities this runner supports
+ */
+function getCapabilities(customCapabilities) {
+    const capabilities = new Set();
+    // Base capabilities
+    capabilities.add('claude-cli');
+    capabilities.add('bash');
+    capabilities.add('filesystem');
+    // Check for common tools
+    if (process.env.ANTHROPIC_API_KEY) {
+        capabilities.add('orchestrator');
+    }
+    // Cloud mode has different capabilities
+    if (isCloudMode()) {
+        capabilities.add('cloud-persistent');
+    }
+    else {
+        capabilities.add('local-storage');
+    }
+    // Add custom capabilities
+    if (customCapabilities) {
+        customCapabilities.forEach(cap => capabilities.add(cap));
+    }
+    return Array.from(capabilities);
+}
+/**
+ * Send a single heartbeat to the server
+ */
+async function sendHeartbeat(config) {
+    const serverUrl = getServerUrl();
+    const agentToken = getAgentToken();
+    const userId = getUserId();
+    if (!agentToken || !userId) {
+        console.error('[HEARTBEAT] No agent token or userId configured');
+        return false;
+    }
+    if (!state.runnerId) {
+        state.runnerId = generateRunnerId(config.runnerType);
+    }
+    const payload = {
+        userId,
+        runnerId: state.runnerId,
+        runnerType: config.runnerType,
+        capabilities: getCapabilities(config.capabilities),
+        version: VERSION,
+        hostname: hostname(),
+        setActive: state.consecutiveFailures === 0 && !state.lastSuccess, // Set active on first successful heartbeat
+    };
+    try {
+        const response = await fetch(`${serverUrl}/api/agent/heartbeat`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${agentToken}`,
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+            throw new Error(error.error || `HTTP ${response.status}`);
+        }
+        // Success
+        state.lastSuccess = new Date();
+        state.consecutiveFailures = 0;
+        config.onSuccess?.();
+        return true;
+    }
+    catch (error) {
+        state.consecutiveFailures++;
+        const err = error instanceof Error ? error : new Error(String(error));
+        // Only log every 3rd failure to avoid spam
+        if (state.consecutiveFailures % 3 === 1) {
+            console.error(`[HEARTBEAT] Failed (${state.consecutiveFailures}x): ${err.message}`);
+        }
+        config.onError?.(err);
+        return false;
+    }
+}
+/**
+ * Start the heartbeat loop
+ */
+export function startHeartbeat(config) {
+    if (state.isRunning) {
+        console.log('[HEARTBEAT] Already running');
+        return;
+    }
+    state.runnerId = generateRunnerId(config.runnerType);
+    state.isRunning = true;
+    state.consecutiveFailures = 0;
+    console.log(`[HEARTBEAT] Starting (${config.runnerType} runner: ${state.runnerId})`);
+    // Send initial heartbeat immediately
+    sendHeartbeat(config).then(success => {
+        if (success) {
+            console.log('[HEARTBEAT] Initial heartbeat sent successfully');
+        }
+    });
+    // Then send every HEARTBEAT_INTERVAL
+    state.intervalId = setInterval(() => {
+        sendHeartbeat(config);
+    }, HEARTBEAT_INTERVAL);
+}
+/**
+ * Stop the heartbeat loop
+ */
+export function stopHeartbeat() {
+    if (state.intervalId) {
+        clearInterval(state.intervalId);
+        state.intervalId = null;
+    }
+    state.isRunning = false;
+    console.log('[HEARTBEAT] Stopped');
+}
+/**
+ * Get current heartbeat state (for diagnostics)
+ */
+export function getHeartbeatState() {
+    return {
+        isRunning: state.isRunning,
+        runnerId: state.runnerId,
+        lastSuccess: state.lastSuccess,
+        consecutiveFailures: state.consecutiveFailures,
+    };
+}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './config.js';
 export * from './api.js';
 export * from './agent.js';
+export * from './websocket.js';

package/dist/index.js

@@ -1,3 +1,4 @@
 export * from './config.js';
 export * from './api.js';
 export * from './agent.js';
+export * from './websocket.js';

package/dist/orchestrator.d.ts

@@ -12,10 +12,17 @@ export declare class MasterOrchestrator {
     private maxTokens;
     private memory;
     private scheduler;
+    private indexer;
     private jobs;
     private jobCounter;
     private userId;
     private workspaceDir;
+    private claudePath;
+    private initialized;
+    private bashTool;
+    private webTools;
+    private workerTools;
+    private verboseMode;
     constructor(options: {
         apiKey: string;
         userId: string;
@@ -24,10 +31,27 @@ export declare class MasterOrchestrator {
         maxTokens?: number;
         voyageApiKey?: string;
     });
+    /**
+     * Initialize the orchestrator - indexes filesystem on first call
+     */
+    initialize(): Promise<void>;
+    /**
+     * Find the claude binary path
+     */
+    private findClaudeBinary;
+    /**
+     * Handle slash commands
+     */
+    private handleSlashCommand;
+    /**
+     * Check if verbose mode is enabled
+     */
+    isVerbose(): boolean;
     /**
      * Process a user message
+     * @param apiKey Optional per-request API key (overrides default)
      */
-    processMessage(message: string, conversationHistory?: MessageParam[], sendMessage?: MessageSender): Promise<string>;
+    processMessage(message: string, conversationHistory?: MessageParam[], sendMessage?: MessageSender, apiKey?: string): Promise<string>;
     /**
      * Get relevant memory context for a message
      */
@@ -38,6 +62,7 @@ export declare class MasterOrchestrator {
     private autoRemember;
     /**
      * Run the agentic loop
+     * @param apiKey Optional per-request API key (creates temporary client)
      */
     private runAgentLoop;
     /**
@@ -49,7 +74,7 @@ export declare class MasterOrchestrator {
      */
     private processToolCalls;
     /**
-     * Delegate task to Claude Code CLI worker
+     * Delegate task to Claude Code CLI worker with retry logic
      */
     private delegateToWorker;
     /**
@@ -72,6 +97,18 @@ export declare class MasterOrchestrator {
      * Execute memory stats tool
      */
     private executeMemoryStats;
+    /**
+     * Open a URL in the user's default browser
+     */
+    private executeOpenBrowser;
+    /**
+     * Start a persistent HTTP server
+     */
+    private executeStartServer;
+    /**
+     * Stop a running server on a port
+     */
+    private executeStopServer;
     /**
      * Format tool preview for user
      */