@siftd/connect-agent 0.2.38 → 0.2.40

package/README.md

@@ -18,7 +18,7 @@ Connect Agent runs on your machine and bridges the Connect web app to Claude Cod
 ```bash
 # 1. Go to https://connect.siftd.app and get a pairing code
 
-# 2. Pair your machine (with API key for full orchestrator mode)
+# 2. Pair your machine (with API key)
 npx @siftd/connect-agent pair <CODE> --api-key <YOUR_ANTHROPIC_API_KEY>
 
 # 3. Start the agent
@@ -33,17 +33,13 @@ On first start, the agent creates `~/Lia-Hub/` with:
 
 ## Modes
 
-### Orchestrator Mode (Recommended)
-When you provide an Anthropic API key, the agent runs as a **master orchestrator**:
+The agent runs as a **master orchestrator** (requires an Anthropic API key):
 - Uses Claude API directly for the orchestration layer
 - Maintains persistent memory about you and your projects
 - Delegates file/code work to Claude Code CLI workers
 - Schedules future tasks
 - Reads hub files for context on every startup
 
-### Simple Relay Mode
-Without an API key, the agent acts as a simple relay to `claude -p --continue`.
-
 ## Commands
 
 ```bash
@@ -66,7 +62,7 @@ connect-agent logout
 ## Special Commands (via web chat)
 
 - `/reset` or `/clear` - Clear conversation history
-- `/mode` - Check current mode (orchestrator vs simple)
+- `/mode` - Show runtime details
 - `/memory` - Show memory statistics
 - `/verbose` - Toggle verbose tool output
 

package/dist/agent.js

@@ -12,10 +12,6 @@ import { startHeartbeat, stopHeartbeat, getHeartbeatState } from './heartbeat.js
 import { loadHubContext, readScratchpad } from './core/hub.js';
 import { PRODUCT_FULL_NAME } from './branding.js';
 import { startPreviewWorker, stopPreviewWorker } from './core/preview-worker.js';
-// Strip ANSI escape codes for clean output
-function stripAnsi(str) {
-    return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
-}
 function parseAttachments(content) {
     const marker = '📎 Attached files:';
     const index = content.indexOf(marker);
@@ -162,13 +158,10 @@ function initOrchestrator() {
     const instanceMode = getInstanceMode();
     const userOrgIds = getUserOrgIds();
     if (!apiKey) {
-        console.log('[AGENT] No API key - using simple relay mode');
-        console.log('[AGENT] To enable orchestrator: pair with --api-key flag');
-        return null;
+        throw new Error('Missing Anthropic API key. Set ANTHROPIC_API_KEY or run `lia-agent set-key <key>`.');
     }
     if (!userId) {
-        console.log('[AGENT] No userId configured - using simple relay mode');
-        return null;
+        throw new Error('Missing userId configuration. Re-pair the agent.');
     }
     console.log(`[AGENT] Initializing Master Orchestrator (mode: ${instanceMode})...`);
     if (instanceMode === 'personal' && userOrgIds.length > 0) {
@@ -187,59 +180,11 @@ function initOrchestrator() {
         userOrgIds: instanceMode === 'personal' ? userOrgIds : undefined,
     });
 }
-/**
- * Simple relay mode - just pipes to Claude Code CLI
- */
-async function sendToClaudeSimple(input) {
-    return new Promise((resolve) => {
-        console.log(`\n[CLAUDE] Sending: ${input.substring(0, 80)}...`);
-        const claude = spawn('claude', ['-p', '--continue'], {
-            cwd: process.env.HOME,
-            env: process.env,
-            shell: true,
-        });
-        let output = '';
-        let errorOutput = '';
-        claude.stdout?.on('data', (data) => {
-            const text = data.toString();
-            output += text;
-            process.stdout.write(text);
-        });
-        claude.stderr?.on('data', (data) => {
-            const text = data.toString();
-            errorOutput += text;
-            if (!text.includes('Checking') && !text.includes('Connected')) {
-                process.stderr.write(text);
-            }
-        });
-        claude.on('close', (code) => {
-            if (code === 0) {
-                const response = stripAnsi(output).trim();
-                console.log(`\n[CLAUDE] Response: ${response.substring(0, 80)}...`);
-                resolve(response || 'No response from Claude');
-            }
-            else {
-                const error = errorOutput || `Claude exited with code ${code}`;
-                console.error(`\n[CLAUDE] Error: ${error}`);
-                resolve(`Error: ${stripAnsi(error).trim()}`);
-            }
-        });
-        claude.on('error', (err) => {
-            console.error(`\n[CLAUDE] Failed to start: ${err.message}`);
-            resolve(`Error: Failed to start Claude - ${err.message}`);
-        });
-        if (claude.stdin) {
-            claude.stdin.write(input);
-            claude.stdin.end();
-        }
-    });
-}
 /**
  * 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, messageId, apiKey) {
+async function sendToOrchestrator(input, orch, messageId) {
     console.log(`\n[ORCHESTRATOR] Processing: ${input.substring(0, 80)}...`);
     // Send typing indicator via WebSocket
     if (wsClient?.connected()) {
@@ -263,8 +208,7 @@ async function sendToOrchestrator(input, orch, messageId, apiKey) {
             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 });
@@ -307,14 +251,11 @@ export async function processMessage(message) {
         const wsStatus = wsClient?.connected() ? 'WebSocket' : 'Polling';
         const hbState = getHeartbeatState();
         const runnerInfo = hbState.runnerId ? ` [${hbState.runnerId}]` : '';
-        return orchestrator
-            ? `Running in ORCHESTRATOR mode (${wsStatus})${runnerInfo} with memory and delegation`
-            : `Running in SIMPLE mode (${wsStatus})${runnerInfo} - direct Claude Code relay`;
+        return `Running in ORCHESTRATOR mode (${wsStatus})${runnerInfo} with memory and delegation`;
     }
     if (content === '/memory' && orchestrator) {
         // Trigger memory stats
-        const response = await orchestrator.processMessage('Show me my memory stats', [], undefined, message.apiKey // Use per-message API key if provided
-        );
+        const response = await orchestrator.processMessage('Show me my memory stats', [], undefined);
         return response;
     }
     // System command: force update (sent by webapp banner)
@@ -359,12 +300,7 @@ export async function processMessage(message) {
         };
     }
     try {
-        if (orchestrator) {
-            return await sendToOrchestrator(message.content, orchestrator, message.id, message.apiKey);
-        }
-        else {
-            return await sendToClaudeSimple(message.content);
-        }
+        return await sendToOrchestrator(message.content, orchestrator, message.id);
     }
     catch (error) {
         console.error('Error:', error);
@@ -372,9 +308,15 @@ export async function processMessage(message) {
     }
 }
 export async function runAgent(pollInterval = 2000) {
-    // Initialize orchestrator
-    orchestrator = initOrchestrator();
-    const mode = orchestrator ? 'ORCHESTRATOR' : 'SIMPLE RELAY';
+    try {
+        orchestrator = initOrchestrator();
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`[AGENT] ${msg}`);
+        process.exit(1);
+    }
+    const mode = 'ORCHESTRATOR';
     const deployment = getDeploymentInfo();
     console.log('╔══════════════════════════════════════════════════╗');
     console.log(`║  ${PRODUCT_FULL_NAME.padEnd(47)}║`);
@@ -385,29 +327,27 @@ export async function runAgent(pollInterval = 2000) {
         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();
-        // Load hub context on startup
-        const hubContext = loadHubContext();
-        if (hubContext.agentIdentity) {
-            console.log('[AGENT] Hub: AGENTS.md loaded');
-        }
-        if (hubContext.claudeMd) {
-            console.log('[AGENT] Hub: CLAUDE.md loaded');
-        }
-        if (hubContext.landmarks) {
-            console.log('[AGENT] Hub: LANDMARKS.md loaded');
-        }
-        // Check scratchpad for pending plans
-        const scratchpad = readScratchpad();
-        if (scratchpad && scratchpad.length > 100) {
-            console.log(`[AGENT] Scratchpad: ${scratchpad.length} chars of pending notes`);
-        }
+    console.log('[AGENT] Features: Memory, Scheduling, Worker Delegation');
+    // Initialize orchestrator (indexes filesystem into memory)
+    await orchestrator.initialize();
+    // Load hub context on startup
+    const hubContext = loadHubContext();
+    if (hubContext.agentIdentity) {
+        console.log('[AGENT] Hub: AGENTS.md loaded');
+    }
+    if (hubContext.claudeMd) {
+        console.log('[AGENT] Hub: CLAUDE.md loaded');
+    }
+    if (hubContext.landmarks) {
+        console.log('[AGENT] Hub: LANDMARKS.md loaded');
+    }
+    // Check scratchpad for pending plans
+    const scratchpad = readScratchpad();
+    if (scratchpad && scratchpad.length > 100) {
+        console.log(`[AGENT] Scratchpad: ${scratchpad.length} chars of pending notes`);
     }
     // Start preview worker for fast-path asset previews (no LLM)
-    const previewWorker = startPreviewWorker({
+    startPreviewWorker({
         verbose: true,
         onAsset: (manifest) => {
             console.log(`[PREVIEW] New asset: ${manifest.name} (${manifest.id})`);
@@ -425,7 +365,7 @@ export async function runAgent(pollInterval = 2000) {
     const runnerType = isCloudMode() ? 'vm' : 'local';
     startHeartbeat({
         runnerType,
-        capabilities: orchestrator ? ['orchestrator', 'memory'] : [],
+        capabilities: ['orchestrator', 'memory'],
         onError: (error) => {
             // Log only significant errors
             if (error.message.includes('401') || error.message.includes('403')) {
@@ -449,35 +389,38 @@ export async function runAgent(pollInterval = 2000) {
     // Try WebSocket first
     wsClient = new AgentWebSocket();
     const wsConnected = await wsClient.connect();
-    // Set up worker callbacks
-    if (orchestrator) {
-        // Progress bars
-        orchestrator.setWorkerStatusCallback((workers) => {
-            if (wsClient?.connected()) {
-                wsClient.sendWorkersUpdate(workers);
-            }
-            const running = workers.filter(w => w.status === 'running');
-            if (running.length > 0) {
-                console.log(`[WORKERS] ${running.length} running`);
-            }
-        });
-        // Gallery updates - send worker assets for UI gallery view
-        orchestrator.setGalleryCallback((galleryWorkers) => {
-            if (wsClient?.connected()) {
-                wsClient.sendGalleryWorkers(galleryWorkers);
-                const totalAssets = galleryWorkers.reduce((sum, w) => sum + w.assets.length, 0);
-                console.log(`[GALLERY] ${galleryWorkers.length} workers, ${totalAssets} assets`);
-            }
-        });
-        // Worker results - send to user when workers complete
-        orchestrator.setWorkerResultCallback((workerId, result) => {
-            console.log(`[WORKER DONE] ${workerId}: ${result.slice(0, 100)}...`);
-            if (wsClient?.connected()) {
-                // Send as response with worker ID as message ID
-                wsClient.sendResponse(workerId, `**Worker completed:**\n\n${result}`);
-            }
-        });
-    }
+    // Progress bars
+    orchestrator.setWorkerStatusCallback((workers) => {
+        if (wsClient?.connected()) {
+            wsClient.sendWorkersUpdate(workers);
+        }
+        const running = workers.filter(w => w.status === 'running');
+        if (running.length > 0) {
+            console.log(`[WORKERS] ${running.length} running`);
+        }
+    });
+    // Todo updates - send to user for inline display in chat
+    orchestrator.setTodoUpdateCallback((todos) => {
+        if (wsClient?.connected()) {
+            wsClient.sendTodoUpdate(todos);
+        }
+    });
+    // Gallery updates - send worker assets for UI gallery view
+    orchestrator.setGalleryCallback((galleryWorkers) => {
+        if (wsClient?.connected()) {
+            wsClient.sendGalleryWorkers(galleryWorkers);
+            const totalAssets = galleryWorkers.reduce((sum, w) => sum + w.assets.length, 0);
+            console.log(`[GALLERY] ${galleryWorkers.length} workers, ${totalAssets} assets`);
+        }
+    });
+    // Worker results - send to user when workers complete
+    orchestrator.setWorkerResultCallback((workerId, result) => {
+        console.log(`[WORKER DONE] ${workerId}: ${result.slice(0, 100)}...`);
+        if (wsClient?.connected()) {
+            // Send as response with worker ID as message ID
+            wsClient.sendResponse(workerId, `**Worker completed:**\n\n${result}`);
+        }
+    });
     if (wsConnected) {
         console.log('[AGENT] Using WebSocket for real-time communication\n');
         // Handle messages via WebSocket
@@ -486,8 +429,7 @@ export async function runAgent(pollInterval = 2000) {
                 const message = {
                     id: wsMsg.id,
                     content: wsMsg.content,
-                    timestamp: wsMsg.timestamp || Date.now(),
-                    apiKey: wsMsg.apiKey // Pass through per-request API key
+                    timestamp: wsMsg.timestamp || Date.now()
                 };
                 const response = await processMessage(message);
                 // Send response via WebSocket

package/dist/api.d.ts

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

package/dist/cli.js

@@ -84,7 +84,7 @@ program
     console.log(`Config file: ${getConfigPath()}`);
     console.log(`Server URL: ${getServerUrl()}`);
     console.log(`Configured: ${isConfigured() ? 'Yes' : 'No'}`);
-    console.log(`Orchestrator mode: ${getAnthropicApiKey() ? 'Yes (API key saved)' : 'No (simple relay)'}`);
+    console.log(`Anthropic API key: ${getAnthropicApiKey() ? 'Configured' : 'Missing'}`);
     if (isConfigured()) {
         const spinner = ora('Checking connection...').start();
         const connected = await checkConnection();

package/dist/core/task-queue.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Lia's Internal Task Queue
+ *
+ * This manages Lia's own todo list - separate from user /todos.
+ * Allows async message processing where users can keep sending
+ * while Lia works through her queue.
+ */
+export type TaskPriority = 'urgent' | 'high' | 'normal' | 'low';
+export type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled';
+export interface LiaTask {
+    id: string;
+    type: 'user_message' | 'follow_up' | 'scheduled' | 'background';
+    content: string;
+    priority: TaskPriority;
+    status: TaskStatus;
+    createdAt: Date;
+    startedAt?: Date;
+    completedAt?: Date;
+    result?: string;
+    error?: string;
+    metadata?: {
+        userId?: string;
+        messageId?: string;
+        parentTaskId?: string;
+        context?: 'personal' | 'team';
+        orgId?: string;
+    };
+}
+export interface LiaPlan {
+    id: string;
+    goal: string;
+    steps: LiaPlanStep[];
+    status: 'planning' | 'executing' | 'completed' | 'failed';
+    createdAt: Date;
+    completedAt?: Date;
+}
+export interface LiaPlanStep {
+    id: string;
+    description: string;
+    status: TaskStatus;
+    taskId?: string;
+    notes?: string;
+}
+export type TaskQueueCallback = (task: LiaTask) => void;
+export type PlanCallback = (plan: LiaPlan) => void;
+/**
+ * Lia's task queue - manages her internal todo list
+ */
+export declare class LiaTaskQueue {
+    private tasks;
+    private plans;
+    private queue;
+    private currentTask;
+    private isProcessing;
+    private onTaskUpdate?;
+    private onPlanUpdate?;
+    private processTask?;
+    constructor(options?: {
+        onTaskUpdate?: TaskQueueCallback;
+        onPlanUpdate?: PlanCallback;
+        processTask?: (task: LiaTask) => Promise<string>;
+    });
+    /**
+     * Add a new task to the queue
+     */
+    addTask(task: Omit<LiaTask, 'id' | 'status' | 'createdAt'>): LiaTask;
+    /**
+     * Insert task ID into queue based on priority
+     */
+    private insertByPriority;
+    /**
+     * Start processing the queue
+     */
+    startProcessing(): Promise<void>;
+    /**
+     * Get the current task being processed
+     */
+    getCurrentTask(): LiaTask | null;
+    /**
+     * Get all pending tasks
+     */
+    getPendingTasks(): LiaTask[];
+    /**
+     * Get recent tasks (last N)
+     */
+    getRecentTasks(limit?: number): LiaTask[];
+    /**
+     * Get task by ID
+     */
+    getTask(taskId: string): LiaTask | null;
+    /**
+     * Cancel a pending task
+     */
+    cancelTask(taskId: string): boolean;
+    /**
+     * Create a plan (breaks down a goal into steps)
+     */
+    createPlan(goal: string, steps: string[]): LiaPlan;
+    /**
+     * Update a plan step
+     */
+    updatePlanStep(planId: string, stepId: string, update: Partial<LiaPlanStep>): boolean;
+    /**
+     * Get current plan
+     */
+    getCurrentPlan(): LiaPlan | null;
+    /**
+     * Get all plans
+     */
+    getPlans(): LiaPlan[];
+    /**
+     * Get queue status for display
+     */
+    getStatus(): {
+        isProcessing: boolean;
+        currentTask: LiaTask | null;
+        pendingCount: number;
+        queuePreview: string[];
+    };
+    /**
+     * Format tasks as readable todo list (for LLM context)
+     */
+    formatAsTodoList(): string;
+}