@siftd/connect-agent 0.2.0 → 0.2.2

package/dist/agent.js

@@ -1,7 +1,9 @@
 import { spawn } from 'child_process';
 import { pollMessages, sendResponse } from './api.js';
-import { getUserId, getAnthropicApiKey } from './config.js';
+import { getUserId, getAnthropicApiKey, isCloudMode, getDeploymentInfo } from './config.js';
 import { MasterOrchestrator } from './orchestrator.js';
+import { AgentWebSocket } from './websocket.js';
+import { startHeartbeat, stopHeartbeat, getHeartbeatState } from './heartbeat.js';
 // Strip ANSI escape codes for clean output
 function stripAnsi(str) {
     return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
@@ -9,6 +11,7 @@ function stripAnsi(str) {
 // Conversation history for orchestrator mode
 let conversationHistory = [];
 let orchestrator = null;
+let wsClient = null;
 /**
  * Initialize the orchestrator if API key is available
  */
@@ -82,26 +85,48 @@ async function sendToClaudeSimple(input) {
 }
 /**
  * Orchestrator mode - uses the master orchestrator with memory
+ * Supports WebSocket streaming for real-time progress updates
+ * @param apiKey Optional per-request API key from user
  */
-async function sendToOrchestrator(input, orch) {
+async function sendToOrchestrator(input, orch, messageId, apiKey) {
     console.log(`\n[ORCHESTRATOR] Processing: ${input.substring(0, 80)}...`);
+    // Send typing indicator via WebSocket
+    if (wsClient?.connected()) {
+        wsClient.sendTyping(true);
+    }
     try {
         const response = await orch.processMessage(input, conversationHistory, async (msg) => {
-            // Progress callback - log to console
+            // Progress callback - log to console and send via WebSocket
             console.log(`[ORCHESTRATOR] ${msg}`);
-        });
-        // Update conversation history
-        conversationHistory.push({ role: 'user', content: input });
-        conversationHistory.push({ role: 'assistant', content: response });
-        // Keep history manageable (last 20 exchanges)
-        if (conversationHistory.length > 40) {
-            conversationHistory = conversationHistory.slice(-40);
+            if (wsClient?.connected() && messageId) {
+                wsClient.sendProgress(messageId, msg);
+            }
+        }, apiKey // Pass per-request API key
+        );
+        // Update conversation history (only if response is non-empty)
+        if (response && response.trim()) {
+            conversationHistory.push({ role: 'user', content: input });
+            conversationHistory.push({ role: 'assistant', content: response });
+            // Keep history manageable (last 20 exchanges)
+            if (conversationHistory.length > 40) {
+                conversationHistory = conversationHistory.slice(-40);
+            }
+        }
+        else {
+            console.log('[ORCHESTRATOR] Empty response - not adding to conversation history');
         }
         console.log(`\n[ORCHESTRATOR] Response: ${response.substring(0, 80)}...`);
+        // Stop typing indicator
+        if (wsClient?.connected()) {
+            wsClient.sendTyping(false);
+        }
         return response;
     }
     catch (error) {
         console.error('[ORCHESTRATOR] Error:', error);
+        if (wsClient?.connected()) {
+            wsClient.sendTyping(false);
+        }
         return `Error: ${error instanceof Error ? error.message : 'Unknown error'}`;
     }
 }
@@ -114,18 +139,22 @@ export async function processMessage(message) {
         return 'Conversation history cleared.';
     }
     if (content === '/mode') {
+        const wsStatus = wsClient?.connected() ? 'WebSocket' : 'Polling';
+        const hbState = getHeartbeatState();
+        const runnerInfo = hbState.runnerId ? ` [${hbState.runnerId}]` : '';
         return orchestrator
-            ? 'Running in ORCHESTRATOR mode (with memory and delegation)'
-            : 'Running in SIMPLE mode (direct Claude Code relay)';
+            ? `Running in ORCHESTRATOR mode (${wsStatus})${runnerInfo} with memory and delegation`
+            : `Running in SIMPLE mode (${wsStatus})${runnerInfo} - direct Claude Code relay`;
     }
     if (content === '/memory' && orchestrator) {
         // Trigger memory stats
-        const response = await orchestrator.processMessage('Show me my memory stats', [], undefined);
+        const response = await orchestrator.processMessage('Show me my memory stats', [], undefined, message.apiKey // Use per-message API key if provided
+        );
         return response;
     }
     try {
         if (orchestrator) {
-            return await sendToOrchestrator(message.content, orchestrator);
+            return await sendToOrchestrator(message.content, orchestrator, message.id, message.apiKey);
         }
         else {
             return await sendToClaudeSimple(message.content);
@@ -140,36 +169,101 @@ export async function runAgent(pollInterval = 2000) {
     // Initialize orchestrator
     orchestrator = initOrchestrator();
     const mode = orchestrator ? 'ORCHESTRATOR' : 'SIMPLE RELAY';
+    const deployment = getDeploymentInfo();
     console.log('╔══════════════════════════════════════════════════╗');
     console.log('║  Connect Agent - Master Orchestrator              ║');
     console.log(`║  Mode: ${mode.padEnd(41)}║`);
+    console.log(`║  Deployment: ${deployment.mode.toUpperCase().padEnd(35)}║`);
     console.log('╚══════════════════════════════════════════════════╝\n');
+    if (isCloudMode()) {
+        console.log(`[AGENT] Running in CLOUD mode`);
+        console.log(`[AGENT] Server: ${deployment.server}`);
+    }
     if (orchestrator) {
         console.log('[AGENT] Features: Memory, Scheduling, Worker Delegation');
+        // Initialize orchestrator (indexes filesystem into memory)
+        await orchestrator.initialize();
     }
-    console.log('[AGENT] Polling for web messages...\n');
+    // Start heartbeat to maintain presence in runner registry
+    const runnerType = isCloudMode() ? 'vm' : 'local';
+    startHeartbeat({
+        runnerType,
+        capabilities: orchestrator ? ['orchestrator', 'memory'] : [],
+        onError: (error) => {
+            // Log only significant errors
+            if (error.message.includes('401') || error.message.includes('403')) {
+                console.error('[AGENT] Heartbeat auth failed - may need to re-pair');
+            }
+        },
+    });
     // Graceful shutdown
     process.on('SIGINT', () => {
         console.log('\n[AGENT] Shutting down...');
+        stopHeartbeat();
+        if (wsClient) {
+            wsClient.close();
+        }
         if (orchestrator) {
             orchestrator.shutdown();
         }
         process.exit(0);
     });
-    while (true) {
-        try {
-            const { messages } = await pollMessages();
-            for (const msg of messages) {
-                const response = await processMessage(msg);
-                await sendResponse(msg.id, response);
-                console.log(`[AGENT] Response sent (${response.length} chars)`);
+    // Try WebSocket first
+    wsClient = new AgentWebSocket();
+    const wsConnected = await wsClient.connect();
+    if (wsConnected) {
+        console.log('[AGENT] Using WebSocket for real-time communication\n');
+        // Handle messages via WebSocket
+        wsClient.onMessage(async (wsMsg) => {
+            if (wsMsg.type === 'message' && wsMsg.content && wsMsg.id) {
+                const message = {
+                    id: wsMsg.id,
+                    content: wsMsg.content,
+                    timestamp: wsMsg.timestamp || Date.now(),
+                    apiKey: wsMsg.apiKey // Pass through per-request API key
+                };
+                const response = await processMessage(message);
+                // Send response via WebSocket
+                wsClient.sendResponse(wsMsg.id, response);
+                console.log(`[AGENT] Response sent via WebSocket (${response.length} chars)`);
             }
-        }
-        catch (error) {
-            if (error instanceof Error && !error.message.includes('ECONNREFUSED')) {
+        });
+        // Keep process alive - WebSocket handles messages
+        console.log('[AGENT] Listening for WebSocket messages...\n');
+        // Always poll for messages (socket-store.ts stores messages that WebSocket doesn't see)
+        while (true) {
+            await new Promise(resolve => setTimeout(resolve, pollInterval));
+            try {
+                const { messages } = await pollMessages();
+                for (const msg of messages) {
+                    const response = await processMessage(msg);
+                    await sendResponse(msg.id, response);
+                    console.log(`[AGENT] Response sent (${response.length} chars)`);
+                }
+            }
+            catch (error) {
                 console.error('[AGENT] Poll error:', error.message);
             }
         }
-        await new Promise(resolve => setTimeout(resolve, pollInterval));
+    }
+    else {
+        // Fall back to polling
+        console.log('[AGENT] WebSocket unavailable, using HTTP polling\n');
+        while (true) {
+            try {
+                const { messages } = await pollMessages();
+                for (const msg of messages) {
+                    const response = await processMessage(msg);
+                    await sendResponse(msg.id, response);
+                    console.log(`[AGENT] Response sent (${response.length} chars)`);
+                }
+            }
+            catch (error) {
+                if (error instanceof Error && !error.message.includes('ECONNREFUSED')) {
+                    console.error('[AGENT] Poll error:', error.message);
+                }
+            }
+            await new Promise(resolve => setTimeout(resolve, pollInterval));
+        }
     }
 }

package/dist/api.d.ts

@@ -2,6 +2,7 @@ export interface Message {
     id: string;
     content: string;
     timestamp: number;
+    apiKey?: string;
 }
 export interface ConnectResponse {
     success: boolean;

package/dist/cli.js

@@ -36,7 +36,9 @@ program
         if (options.apiKey) {
             console.log('Orchestrator mode enabled (API key saved)');
         }
-        console.log('Run "connect-agent start" to begin processing messages.');
+        console.log('\nTo start the agent, run one of:');
+        console.log('  npx @siftd/connect-agent start');
+        console.log('  (or install globally: npm install -g @siftd/connect-agent)');
     }
     catch (error) {
         spinner.fail(`Connection failed: ${error instanceof Error ? error.message : 'Unknown error'}`);

package/dist/config.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Check if running in cloud mode (environment variables take precedence)
+ */
+export declare function isCloudMode(): boolean;
 export declare function getServerUrl(): string;
 export declare function setServerUrl(url: string): void;
 export declare function getAgentToken(): string | null;
@@ -9,3 +13,11 @@ export declare function setAnthropicApiKey(key: string | null): void;
 export declare function isConfigured(): boolean;
 export declare function clearConfig(): void;
 export declare function getConfigPath(): string;
+/**
+ * Get deployment mode info for logging
+ */
+export declare function getDeploymentInfo(): {
+    mode: string;
+    server: string;
+    userId: string | null;
+};

package/dist/config.js

@@ -5,14 +5,22 @@ const config = new Conf({
         serverUrl: 'https://connect.siftd.app',
     },
 });
+/**
+ * Check if running in cloud mode (environment variables take precedence)
+ */
+export function isCloudMode() {
+    return !!(process.env.CONNECT_SERVER_URL && process.env.CONNECT_AGENT_TOKEN && process.env.CONNECT_USER_ID);
+}
 export function getServerUrl() {
-    return config.get('serverUrl');
+    // Environment variable takes precedence (cloud mode)
+    return process.env.CONNECT_SERVER_URL || config.get('serverUrl');
 }
 export function setServerUrl(url) {
     config.set('serverUrl', url);
 }
 export function getAgentToken() {
-    return config.get('agentToken') ?? null;
+    // Environment variable takes precedence (cloud mode)
+    return process.env.CONNECT_AGENT_TOKEN || config.get('agentToken') || null;
 }
 export function setAgentToken(token) {
     if (token === null) {
@@ -23,7 +31,8 @@ export function setAgentToken(token) {
     }
 }
 export function getUserId() {
-    return config.get('userId') ?? null;
+    // Environment variable takes precedence (cloud mode)
+    return process.env.CONNECT_USER_ID || config.get('userId') || null;
 }
 export function setUserId(id) {
     if (id === null) {
@@ -34,7 +43,9 @@ export function setUserId(id) {
     }
 }
 export function getAnthropicApiKey() {
-    return config.get('anthropicApiKey') ?? null;
+    // Environment variable takes precedence (cloud mode)
+    // Note: ANTHROPIC_API_KEY is also checked in orchestrator.ts
+    return process.env.ANTHROPIC_API_KEY || config.get('anthropicApiKey') || null;
 }
 export function setAnthropicApiKey(key) {
     if (key === null) {
@@ -55,3 +66,13 @@ export function clearConfig() {
 export function getConfigPath() {
     return config.path;
 }
+/**
+ * Get deployment mode info for logging
+ */
+export function getDeploymentInfo() {
+    return {
+        mode: isCloudMode() ? 'cloud' : 'local',
+        server: getServerUrl(),
+        userId: getUserId(),
+    };
+}

package/dist/core/system-indexer.d.ts

@@ -0,0 +1,65 @@
+/**
+ * System Indexer
+ *
+ * Indexes the user's filesystem INTO the memory system.
+ * When user says "that project" or "save in downloads",
+ * semantic search finds the relevant paths.
+ *
+ * No MCP. No new protocols. Just smart memory use.
+ */
+import { AdvancedMemoryStore } from './memory-advanced.js';
+export declare class SystemIndexer {
+    private memory;
+    private home;
+    private indexed;
+    constructor(memory: AdvancedMemoryStore);
+    /**
+     * Index the user's home directory structure into memory
+     */
+    indexHome(): Promise<{
+        projects: number;
+        directories: number;
+        total: number;
+    }>;
+    /**
+     * Index a directory and its subdirectories
+     */
+    private indexDirectory;
+    /**
+     * Find and index git repositories as projects
+     */
+    private indexGitRepos;
+    /**
+     * Get detailed info about a git project
+     */
+    private getProjectInfo;
+    /**
+     * Detect project type by looking at files
+     */
+    private detectProjectType;
+    /**
+     * Remember a key directory (Downloads, Documents, Desktop, etc.)
+     * These get high importance and multiple aliases for better search
+     */
+    private rememberKeyDirectory;
+    /**
+     * Store a project in memory
+     */
+    private rememberProject;
+    /**
+     * Generate a description for a directory
+     */
+    private describeDirectory;
+    /**
+     * Extract relevant tags from directory contents
+     */
+    private extractTags;
+    /**
+     * Re-index (clear old filesystem memories and re-scan)
+     */
+    reindex(): Promise<{
+        projects: number;
+        directories: number;
+        total: number;
+    }>;
+}