tuna-agent 0.1.1 → 0.1.2

package/dist/daemon/index.js

@@ -9,6 +9,7 @@ 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';
@@ -75,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' });
@@ -287,7 +292,6 @@ ${skillContent.slice(0, 15000)}`;
                 break;
             }
             case 'extension_task': {
-                // Task sent from Chrome extension — run Claude and stream results back
                 const extCode = msg.code;
                 const extTaskId = msg.taskId;
                 const extTask = msg.task;
@@ -297,11 +301,70 @@ ${skillContent.slice(0, 15000)}`;
                     break;
                 }
                 console.log(`[Daemon] Extension task ${extTaskId}: ${extTask.substring(0, 80)}`);
-                // Run in background — don't block message handling
+                // ── 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 {
-                        let accumulated = '';
-                        let progress = 0;
                         const result = await runClaude({
                             prompt: extTask,
                             cwd: os.homedir(),
@@ -315,37 +378,33 @@ ${skillContent.slice(0, 15000)}`;
                                     if (event?.type === 'content_block_delta') {
                                         const delta = event.delta;
                                         if (delta?.type === 'text_delta' && delta.text) {
-                                            const chunk = delta.text;
-                                            accumulated += chunk;
-                                            ws.send({ action: 'extension_task_stream', code: extCode, taskId: extTaskId, text: chunk });
+                                            ws.sendExtensionStream(extCode, extTaskId, delta.text);
                                         }
                                     }
                                 }
                             } : undefined,
                         });
-                        ws.send({
-                            action: 'extension_task_done',
-                            code: extCode,
-                            taskId: extTaskId,
-                            result: { script: result.result, text: result.result },
-                        });
+                        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.send({
-                            action: 'extension_task_done',
-                            code: extCode,
-                            taskId: extTaskId,
-                            result: { 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;

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

@@ -10,6 +10,8 @@ export declare class AgentWebSocketClient {
     private running;
     private onMessage;
     private onAuthFailed?;
+    /** 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;
@@ -103,6 +105,20 @@ export declare class AgentWebSocketClient {
      * 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;

package/dist/daemon/ws-client.js

@@ -15,6 +15,8 @@ export class AgentWebSocketClient {
     running = false;
     onMessage;
     onAuthFailed;
+    /** Pending flow command callbacks keyed by request ID */
+    _flowCallbacks = new Map();
     constructor(config, onMessage, onAuthFailed) {
         this.config = config;
         this.onMessage = onMessage;
@@ -170,6 +172,49 @@ export class AgentWebSocketClient {
     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;
     }

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 {};