tuna-agent 0.1.0 → 0.1.2

package/dist/daemon/index.js

@@ -2,15 +2,17 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import { AgentWebSocketClient } from './ws-client.js';
-import { removePid } from '../config/store.js';
-import { validatePath } from '../utils/validate-path.js';
+import { removePid, loadConfig, saveConfig } from '../config/store.js';
 import { validateMessage } from '../utils/message-schemas.js';
 import { createAgentAdapter } from '../agents/factory.js';
 import { loadPMState, savePMState, clearPMState } from './pm-state.js';
 import { chatWithPM } from '../pm/planner.js';
 import { executePlanAndReport, simplifyMarkdown, waitForInput } from '../utils/execution-helpers.js';
 import { runClaude } from '../utils/claude-cli.js';
+import { handleGetHistory, handleRetryVideo, handleGenerateIdeas, handleGenerateScript, handleGenerateScene, handleGenerateScenes, handleRenderVideo, handleListCharacters, handleCreateCharacter, handleSaveCharacterSelection, } from './extension-handlers.js';
 import { downloadAttachments, cleanupAttachments } from '../utils/image-download.js';
+import { scanSkills } from '../utils/skill-scanner.js';
+import { setupMcpConfig } from '../mcp/setup.js';
 /**
  * Start the agent daemon.
  * Connects to API via WebSocket, receives tasks, delegates to agent adapter.
@@ -21,7 +23,14 @@ export async function startDaemon(config) {
         type: config.agentType || 'claude-code',
         ...config.agentConfig,
     };
-    const adapter = createAgentAdapter(agentConfig);
+    const adapter = createAgentAdapter(agentConfig, config);
+    // Setup MCP config for Knowledge server
+    try {
+        setupMcpConfig(config);
+    }
+    catch (err) {
+        console.warn(`[Daemon] MCP config setup failed (non-fatal):`, err);
+    }
     // Health check on startup
     const health = await adapter.checkHealth();
     if (!health.ok) {
@@ -58,8 +67,8 @@ export async function startDaemon(config) {
         switch (type) {
             case 'connected':
                 console.log(`[Daemon] Connected as "${msg.name}" (${msg.agentId})`);
-                // Recover any tasks orphaned by previous daemon crash/restart
-                ws.send({ action: 'recover_orphaned_tasks' });
+                // Recover orphaned tasks — pass activeTaskId so API won't fail a task we're still running
+                ws.send({ action: 'recover_orphaned_tasks', activeTaskId: currentTaskId ?? undefined });
                 break;
             case 'task_assigned': {
                 const task = msg.task;
@@ -67,6 +76,10 @@ export async function startDaemon(config) {
                     console.error('[Daemon] Received task_assigned without task data');
                     break;
                 }
+                // Resolve tilde in repoPath (e.g. ~/agents/co-founder → /Users/admin/agents/co-founder)
+                if (task.repoPath?.startsWith('~/')) {
+                    task.repoPath = path.join(os.homedir(), task.repoPath.slice(2));
+                }
                 if (activeTasks >= MAX_CONCURRENT) {
                     console.log(`[Daemon] Busy — rejecting task ${task.id}`);
                     ws.send({ action: 'task_rejected', taskId: task.id, reason: 'agent_busy' });
@@ -76,6 +89,15 @@ export async function startDaemon(config) {
                 currentTaskId = task.id;
                 currentTaskAbort = new AbortController();
                 console.log(`[Daemon] Received task: ${task.id} — ${task.description.slice(0, 80)} (attachments: ${task.attachments?.length ?? 0})`);
+                // Update MCP config with the task's agent ID so knowledge server uses correct attribution
+                if (task.agentId) {
+                    try {
+                        setupMcpConfig({ ...config, agentId: task.agentId });
+                    }
+                    catch (err) {
+                        console.warn(`[Daemon] MCP config update for task failed (non-fatal):`, err);
+                    }
+                }
                 try {
                     await adapter.handleTask(task, ws, pendingInputResolvers, currentTaskAbort.signal, pendingPermissionResolvers);
                 }
@@ -117,42 +139,21 @@ export async function startDaemon(config) {
             }
             case 'command': {
                 const command = msg.command;
-                if (command === 'scan_workspace') {
-                    const rawPath = msg.workspace_path || '~/tuna-workspace';
-                    const wsPath = rawPath.startsWith('~')
-                        ? path.join(os.homedir(), rawPath.slice(1))
-                        : rawPath;
-                    try {
-                        validatePath(wsPath, os.homedir());
-                    }
-                    catch (err) {
-                        const errMsg = err instanceof Error ? err.message : String(err);
-                        console.error(`[Daemon] Workspace path validation failed: ${errMsg}`);
-                        ws.send({ action: 'workspace_scanned', projects: [] });
-                        break;
-                    }
-                    // Resolve agent folder paths (sent by API)
-                    const rawFolders = msg.agent_folders || [];
-                    const agentFolders = rawFolders.map(f => f.startsWith('~') ? path.join(os.homedir(), f.slice(1)) : f);
-                    console.log(`[Daemon] Scanning workspace: ${wsPath}, agent folders: ${agentFolders.length}`);
-                    ws.setWorkspacePath(wsPath);
-                    ws.setAgentFolders(agentFolders);
-                    try {
-                        const entries = fs.readdirSync(wsPath, { withFileTypes: true });
-                        const projects = entries
-                            .filter(e => e.isDirectory() && !e.name.startsWith('.'))
-                            .map(e => ({
-                            name: e.name,
-                            path: path.join(wsPath, e.name),
-                        }));
-                        ws.send({ action: 'workspace_scanned', projects });
-                        console.log(`[Daemon] Found ${projects.length} projects in workspace`);
-                    }
-                    catch (err) {
-                        const errMsg = err instanceof Error ? err.message : String(err);
-                        console.error(`[Daemon] Workspace scan failed: ${errMsg}`);
-                        ws.send({ action: 'workspace_scanned', projects: [] });
-                    }
+                if (command === 'rescan_agent_skills') {
+                    const agentId = msg.agent_id;
+                    const rawFolder = msg.folder_path || '';
+                    const rawWsPath = msg.workspace_path || '~/tuna-workspace';
+                    const wsPath = rawWsPath.startsWith('~')
+                        ? path.join(os.homedir(), rawWsPath.slice(1))
+                        : rawWsPath;
+                    const folder = rawFolder.startsWith('~')
+                        ? path.join(os.homedir(), rawFolder.slice(1))
+                        : rawFolder;
+                    console.log(`[Daemon] Rescan skills for agent ${agentId}, folder: ${folder || '(none)'}`);
+                    const folders = folder ? [folder] : [];
+                    const skills = scanSkills(wsPath, folders);
+                    ws.send({ action: 'agent_skills_scanned', agent_id: agentId, skills });
+                    console.log(`[Daemon] Scanned ${skills.length} skill(s) for agent ${agentId}`);
                 }
                 else if (command === 'analyze_skill') {
                     const skillId = msg.skill_id;
@@ -180,12 +181,15 @@ export async function startDaemon(config) {
                             const analyzePrompt = `You are analyzing a Claude Code skill file (markdown prompt template). Extract the following structured information from the content below:
 
 1. **description**: A short summary of what this skill does in under 80 characters. Be very concise — like a subtitle, not a full sentence.
-2. **actions**: Sub-commands or modes available in this skill. Look for sections, headings, or conditional logic that indicate different actions/modes the user can invoke. Each action has a "name" (short, lowercase, no spaces — use hyphens) and "description" (what it does, max 100 chars).
-3. **parameters**: Input parameters the skill accepts. Look for {{param_name}} placeholders, $ARGUMENTS references, or documented inputs. Each parameter has "key", "label", "type" (text/number/select/multiline), "required" (boolean), "default_value", "options" (for select type), "placeholder".
+2. **actions**: Sub-commands or modes available in this skill. Look for sections, headings, or conditional logic that indicate different actions/modes the user can invoke. Each action has:
+   - "name" (short, lowercase, no spaces — use hyphens)
+   - "description" (what it does, max 100 chars)
+   - "params" (array of parameter KEY strings that are relevant to THIS specific action — only include params that this action actually uses)
+3. **parameters**: ALL input parameters the skill accepts (the full definitions). Look for {{param_name}} placeholders, $ARGUMENTS references, or documented inputs. Each parameter has "key", "label", "type" (text/number/select/multiline), "required" (boolean), "default_value", "options" (for select type), "placeholder".
    - IMPORTANT: If a parameter has a finite set of known values (e.g. listed in config files, enums, documented choices), use type "select" and populate the "options" array with ALL known values. Only use type "text" when the input is truly free-form.
 
 Respond with ONLY valid JSON, no markdown, no explanation:
-{"description":"...","actions":[{"name":"...","description":"..."}],"parameters":[{"key":"...","label":"...","type":"select","required":false,"options":["opt1","opt2"]}]}
+{"description":"...","actions":[{"name":"...","description":"...","params":["param_key1","param_key2"]}],"parameters":[{"key":"...","label":"...","type":"select","required":false,"options":["opt1","opt2"]}]}
 
 If no actions are found, return an empty array. If no parameters found, return an empty array.
 
@@ -287,8 +291,133 @@ ${skillContent.slice(0, 15000)}`;
                 }
                 break;
             }
+            case 'extension_task': {
+                const extCode = msg.code;
+                const extTaskId = msg.taskId;
+                const extTask = msg.task;
+                const extStream = msg.stream;
+                if (!extCode || !extTaskId || !extTask) {
+                    console.warn('[Daemon] extension_task missing required fields');
+                    break;
+                }
+                console.log(`[Daemon] Extension task ${extTaskId}: ${extTask.substring(0, 80)}`);
+                // ── Specialized handlers (no Claude needed) ──────────────────────────
+                if (extTask === 'get_history') {
+                    handleGetHistory(ws, extCode, extTaskId);
+                    break;
+                }
+                if (extTask === 'generate_ideas') {
+                    (async () => {
+                        await handleGenerateIdeas(ws, extCode, extTaskId, msg.topic);
+                    })();
+                    break;
+                }
+                if (extTask === 'generate_script') {
+                    (async () => {
+                        await handleGenerateScript(ws, extCode, extTaskId, msg.idea, msg.topic, msg.style);
+                    })();
+                    break;
+                }
+                if (extTask === 'retry_video') {
+                    const videoId = msg.videoId;
+                    handleRetryVideo(ws, extCode, extTaskId, videoId);
+                    break;
+                }
+                if (extTask === 'generate_scene') {
+                    (async () => {
+                        await handleGenerateScene(ws, extCode, extTaskId, msg.sceneIdx, msg.prompt, msg.aspectRatio || 'portrait');
+                    })();
+                    break;
+                }
+                if (extTask === 'generate_scenes') {
+                    (async () => {
+                        await handleGenerateScenes(ws, extCode, extTaskId, msg.scenes, msg.aspectRatio || 'portrait');
+                    })();
+                    break;
+                }
+                if (extTask === 'render_video') {
+                    (async () => {
+                        await handleRenderVideo(ws, extCode, extTaskId, {
+                            scenes: msg.scenes,
+                            script: msg.script,
+                            title: msg.title,
+                            aspectRatio: msg.aspectRatio || 'portrait',
+                            voiceId: msg.voiceId || '',
+                            subtitleStyle: msg.subtitleStyle || 'karaoke',
+                        });
+                    })();
+                    break;
+                }
+                if (extTask === 'list_characters') {
+                    handleListCharacters(ws, extCode, extTaskId);
+                    break;
+                }
+                if (extTask === 'create_character') {
+                    (async () => {
+                        await handleCreateCharacter(ws, extCode, extTaskId, msg.name, msg.displayName, msg.prompt, msg.outputCount || 2, msg.orientation || 'portrait');
+                    })();
+                    break;
+                }
+                if (extTask === 'save_character_selection') {
+                    handleSaveCharacterSelection(ws, extCode, extTaskId, msg.characterId, msg.selectedImages || []);
+                    break;
+                }
+                // ── Claude-powered tasks (ideas, script, etc.) ────────────────────────
+                (async () => {
+                    try {
+                        const result = await runClaude({
+                            prompt: extTask,
+                            cwd: os.homedir(),
+                            maxTurns: 10,
+                            outputFormat: extStream ? 'stream-json' : 'json',
+                            lightweight: true,
+                            timeoutMs: 120000,
+                            onStreamLine: extStream ? (data) => {
+                                if (data.type === 'stream_event') {
+                                    const event = data.event;
+                                    if (event?.type === 'content_block_delta') {
+                                        const delta = event.delta;
+                                        if (delta?.type === 'text_delta' && delta.text) {
+                                            ws.sendExtensionStream(extCode, extTaskId, delta.text);
+                                        }
+                                    }
+                                }
+                            } : undefined,
+                        });
+                        ws.sendExtensionDone(extCode, extTaskId, { script: result.result, text: result.result });
+                        console.log(`[Daemon] Extension task ${extTaskId} done`);
+                    }
+                    catch (err) {
+                        const errMsg = err instanceof Error ? err.message : String(err);
+                        console.error(`[Daemon] Extension task ${extTaskId} error: ${errMsg}`);
+                        ws.sendExtensionDone(extCode, extTaskId, { error: errMsg });
+                    }
+                })();
+                break;
+            }
             case 'pong':
                 break;
+            case 'flow_command_result': {
+                const fcId = msg.id;
+                const fcResult = msg.result;
+                if (fcId) {
+                    ws.resolveFlowCommand(fcId, fcResult || {});
+                }
+                break;
+            }
+            case 'extension_unpaired': {
+                // Extension signed out — remove this code from local config so it's not restored on reconnect
+                const unpairCode = msg.code;
+                if (unpairCode) {
+                    const cfg = loadConfig();
+                    if (cfg?.extensionCodes) {
+                        const newCodes = cfg.extensionCodes.filter(c => c !== unpairCode);
+                        saveConfig({ ...cfg, extensionCodes: newCodes });
+                        console.log(`[Daemon] Extension unpaired: ${unpairCode}`);
+                    }
+                }
+                break;
+            }
             case 'error':
                 console.error(`[Daemon] Server error: ${msg.message}`);
                 break;

package/dist/daemon/ws-client.d.ts

@@ -10,9 +10,8 @@ export declare class AgentWebSocketClient {
     private running;
     private onMessage;
     private onAuthFailed?;
-    private heartbeatCount;
-    private _workspacePath;
-    private _agentFolders;
+    /** Pending flow command callbacks keyed by request ID */
+    private _flowCallbacks;
     constructor(config: AgentConfig, onMessage: MessageHandler, onAuthFailed?: (code: number, reason: string) => void);
     connect(): void;
     disconnect(): void;
@@ -94,14 +93,35 @@ export declare class AgentWebSocketClient {
         context?: string;
         startedAt?: string;
     }): boolean;
+    /**
+     * Stream a text chunk back to the Chrome extension for an extension task.
+     */
+    sendExtensionStream(code: string, taskId: string, text: string): boolean;
+    /**
+     * Signal that an extension task is complete.
+     */
+    sendExtensionDone(code: string, taskId: string, result: Record<string, unknown>): boolean;
+    /**
+     * Send progress update for an extension task.
+     */
+    sendExtensionProgress(code: string, taskId: string, progress: number): boolean;
+    /**
+     * Send a custom-typed event to the extension (generic forwarder via extension_event action).
+     */
+    sendExtensionEvent(code: string, event: Record<string, unknown>): boolean;
+    /**
+     * Send a flow command to the extension and wait for the result.
+     * Returns a Promise that resolves with the command result.
+     */
+    sendFlowCommand(code: string, command: Record<string, unknown>, timeout?: number): Promise<Record<string, unknown>>;
+    /**
+     * Resolve a pending flow command callback (called from message handler).
+     * Returns true if the callback was found and resolved.
+     */
+    resolveFlowCommand(id: string, result: Record<string, unknown>): boolean;
     get isConnected(): boolean;
     private _connect;
     private _startHeartbeat;
-    /** Set workspace path (called when scan_workspace command is received) */
-    setWorkspacePath(wsPath: string): void;
-    /** Set agent folder paths for skill scanning */
-    setAgentFolders(folders: string[]): void;
-    private _scanWorkspace;
     private _stopHeartbeat;
     private _scheduleReconnect;
 }

package/dist/daemon/ws-client.js

@@ -1,9 +1,5 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
 import WebSocket from 'ws';
 import { getSystemLoad, detectCapabilities } from '../system/info.js';
-import { scanSkills } from '../utils/skill-scanner.js';
 /** Close codes that indicate a permanent error — do NOT reconnect. */
 const PERMANENT_CLOSE_CODES = new Set([
     4001, // Authentication failed (invalid token)
@@ -19,9 +15,8 @@ export class AgentWebSocketClient {
     running = false;
     onMessage;
     onAuthFailed;
-    heartbeatCount = 0;
-    _workspacePath = null;
-    _agentFolders = [];
+    /** Pending flow command callbacks keyed by request ID */
+    _flowCallbacks = new Map();
     constructor(config, onMessage, onAuthFailed) {
         this.config = config;
         this.onMessage = onMessage;
@@ -159,6 +154,67 @@ export class AgentWebSocketClient {
             timestamp: message.startedAt || new Date().toISOString(),
         });
     }
+    /**
+     * Stream a text chunk back to the Chrome extension for an extension task.
+     */
+    sendExtensionStream(code, taskId, text) {
+        return this.send({ action: 'extension_task_stream', code, taskId, text });
+    }
+    /**
+     * Signal that an extension task is complete.
+     */
+    sendExtensionDone(code, taskId, result) {
+        return this.send({ action: 'extension_task_done', code, taskId, result });
+    }
+    /**
+     * Send progress update for an extension task.
+     */
+    sendExtensionProgress(code, taskId, progress) {
+        return this.send({ action: 'extension_task_progress', code, taskId, progress });
+    }
+    /**
+     * Send a custom-typed event to the extension (generic forwarder via extension_event action).
+     */
+    sendExtensionEvent(code, event) {
+        return this.send({ action: 'extension_event', code, event });
+    }
+    /**
+     * Send a flow command to the extension and wait for the result.
+     * Returns a Promise that resolves with the command result.
+     */
+    sendFlowCommand(code, command, timeout = 60000) {
+        return new Promise((resolve, reject) => {
+            const id = `fc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const timer = setTimeout(() => {
+                this._flowCallbacks.delete(id);
+                reject(new Error(`Flow command timed out after ${timeout}ms: ${command.type}`));
+            }, timeout);
+            this._flowCallbacks.set(id, { resolve, reject, timer });
+            const sent = this.sendExtensionEvent(code, {
+                type: 'flow_command',
+                id,
+                command,
+            });
+            if (!sent) {
+                clearTimeout(timer);
+                this._flowCallbacks.delete(id);
+                reject(new Error('WebSocket not connected — cannot send flow command'));
+            }
+        });
+    }
+    /**
+     * Resolve a pending flow command callback (called from message handler).
+     * Returns true if the callback was found and resolved.
+     */
+    resolveFlowCommand(id, result) {
+        const cb = this._flowCallbacks.get(id);
+        if (!cb)
+            return false;
+        clearTimeout(cb.timer);
+        this._flowCallbacks.delete(id);
+        cb.resolve(result);
+        return true;
+    }
     get isConnected() {
         return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
     }
@@ -177,6 +233,11 @@ export class AgentWebSocketClient {
             this.reconnectAttempts = 0;
             console.log('[WS] Connected to API server');
             this._startHeartbeat();
+            // Restore extension pairings so server can send agent_connected to already-connected extensions
+            const codes = this.config.extensionCodes;
+            if (codes && codes.length > 0) {
+                this.send({ action: 'restore_extensions', codes });
+            }
         });
         this.ws.on('message', (raw) => {
             try {
@@ -210,70 +271,15 @@ export class AgentWebSocketClient {
     }
     _startHeartbeat() {
         this._stopHeartbeat();
-        this.heartbeatCount = 0;
-        // Scan workspace once on connect (delayed 3s to let connection stabilize)
-        setTimeout(() => this._scanWorkspace(), 3000);
         this.heartbeatTimer = setInterval(() => {
-            this.heartbeatCount++;
             const agentType = this.config.agentType || 'claude-code';
             this.send({
                 action: 'heartbeat',
                 system_load: getSystemLoad(),
                 capabilities: detectCapabilities(agentType),
             });
-            // Scan workspace every 20th heartbeat (~10 min)
-            if (this.heartbeatCount % 20 === 0) {
-                this._scanWorkspace();
-            }
         }, 30000);
     }
-    /** Set workspace path (called when scan_workspace command is received) */
-    setWorkspacePath(wsPath) {
-        this._workspacePath = wsPath;
-    }
-    /** Set agent folder paths for skill scanning */
-    setAgentFolders(folders) {
-        this._agentFolders = folders;
-    }
-    _scanWorkspace() {
-        const wsPath = this._workspacePath || path.join(os.homedir(), 'tuna-workspace');
-        try {
-            if (!fs.existsSync(wsPath))
-                return;
-            const entries = fs.readdirSync(wsPath, { withFileTypes: true });
-            const projects = entries
-                .filter(e => e.isDirectory() && !e.name.startsWith('.'))
-                .map(e => ({ name: e.name, path: path.join(wsPath, e.name) }));
-            this.send({ action: 'workspace_scanned', projects });
-        }
-        catch {
-            // Silent fail — non-critical
-        }
-        // Scan skills from .claude/commands/ directories
-        // Merge API-provided folders with local config scan_paths
-        try {
-            let folders = [...this._agentFolders];
-            if (folders.length === 0) {
-                // Fallback: read scan_paths from local config
-                const configPath = path.join(os.homedir(), '.tuna-agent', 'config.json');
-                try {
-                    const cfg = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-                    if (Array.isArray(cfg.scan_paths)) {
-                        folders = cfg.scan_paths;
-                    }
-                }
-                catch { /* no config or parse error */ }
-            }
-            const skills = scanSkills(wsPath, folders);
-            if (skills.length > 0) {
-                this.send({ action: 'skills_scanned', skills });
-                console.log(`[WS] Scanned ${skills.length} skill(s) from ${folders.length} folder(s)`);
-            }
-        }
-        catch {
-            // Silent fail — non-critical
-        }
-    }
     _stopHeartbeat() {
         if (this.heartbeatTimer) {
             clearInterval(this.heartbeatTimer);

package/dist/mcp/browser-server.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * Browser MCP Server for Tuna Agent
+ *
+ * Stdio-based MCP server that exposes browser automation tools to Claude Code.
+ * Uses browserclaw (vendored from OpenClaw) for snapshot+ref browser control.
+ *
+ * Usage:
+ *   node browser-server.js [--headless] [--user-data-dir /path/to/chrome/profile] [--cdp-port 9222]
+ */
+export {};