tuna-agent 0.1.5 → 0.1.7

package/dist/agents/claude-code-adapter.js

@@ -51,6 +51,7 @@ export class ClaudeCodeAdapter {
         if (task.mode === 'agent_team') {
             console.log(`[ClaudeCode] Agent Team mode — direct chat with Claude CLI`);
             ws.sendProgress(task.id, 'executing', { startedAt: new Date().toISOString() });
+            ws.sendSubtaskStart(task.id, { id: 'agent-team', role: 'agent', description: task.description });
             const MAX_ROUNDS = 50;
             let sessionId;
             let totalDurationMs = 0;
@@ -202,6 +203,11 @@ export class ClaudeCodeAdapter {
                         durationMs: totalDurationMs,
                         sessionId,
                     });
+                    // Workflow tasks: no follow-up needed — workflow engine handles next step
+                    if (task.source === 'workflow') {
+                        console.log(`[ClaudeCode] Workflow task done — skipping follow-up wait`);
+                        return;
+                    }
                     // Save state for resume after potential timeout or daemon restart
                     savePMState({
                         taskId: task.id,

package/dist/daemon/extension-handlers.d.ts

@@ -26,8 +26,8 @@ export interface VideoRecord {
     aspectRatio?: string;
 }
 export declare function handleGetHistory(ws: AgentWebSocketClient, code: string, taskId: string): void;
-export declare function handleGenerateIdeas(ws: AgentWebSocketClient, code: string, taskId: string, topic: string): Promise<void>;
-export declare function handleGenerateScript(ws: AgentWebSocketClient, code: string, taskId: string, idea: string, topic: string, style?: string, duration?: number, language?: string): Promise<void>;
+export declare function handleGenerateIdeas(ws: AgentWebSocketClient, code: string, taskId: string, topic: string, styleName?: string, styleDesc?: string, language?: string): Promise<void>;
+export declare function handleGenerateScript(ws: AgentWebSocketClient, code: string, taskId: string, idea: string, topic: string, style?: string, duration?: number, language?: string, styleName?: string, styleGuidance?: string): Promise<void>;
 export declare function handleRetryVideo(ws: AgentWebSocketClient, code: string, taskId: string, videoId: string): void;
 export declare function handleGenerateScene(ws: AgentWebSocketClient, code: string, taskId: string, sceneIdx: number, prompt: string, aspectRatio: string): Promise<void>;
 export declare function handleGenerateScenes(ws: AgentWebSocketClient, code: string, taskId: string, scenes: Array<{

package/dist/daemon/extension-handlers.js

@@ -64,7 +64,7 @@ function hasContentCreator() {
     }
 }
 // ─── Handler: generate_ideas ──────────────────────────────────────────────────
-export async function handleGenerateIdeas(ws, code, taskId, topic) {
+export async function handleGenerateIdeas(ws, code, taskId, topic, styleName, styleDesc, language) {
     if (!hasContentCreator()) {
         const error = 'content-creator agent not found on this machine';
         console.error(`[generate_ideas] ${error}`);
@@ -72,20 +72,33 @@ export async function handleGenerateIdeas(ws, code, taskId, topic) {
         ws.sendExtensionDone(code, taskId, { error });
         return;
     }
-    const systemPrompt = [
+    const resolvedLang = language || 'vi';
+    const langInstruction = resolvedLang === 'vi'
+        ? `You always write titles in Vietnamese that feel native, not translated.`
+        : `You always write titles in English that feel natural and engaging.`;
+    const systemParts = [
         `You are a top-tier content strategist and viral video expert specializing in YouTube Shorts and TikTok.`,
         `You deeply understand viral hooks, storytelling patterns, and audience psychology.`,
         `You know what makes people stop scrolling: curiosity gaps, emotional triggers, POV format, plot twists, listicles, and controversial takes.`,
-        `You always write titles in Vietnamese that feel native, not translated.`,
-    ].join(' ');
+        langInstruction,
+    ];
+    if (styleName) {
+        systemParts.push(`The video style is "${styleName}"${styleDesc ? `: ${styleDesc}` : ''}.`);
+        systemParts.push(`Generate ideas that are specifically suited for this style.`);
+    }
+    const systemPrompt = systemParts.join(' ');
+    const langReq = resolvedLang === 'vi'
+        ? `- Titles must be in Vietnamese, natural and engaging`
+        : `- Titles must be in English, natural and engaging`;
     const prompt = [
         `Generate exactly 5 viral YouTube Shorts video ideas for the topic: "${topic}".`,
         ``,
         `Requirements:`,
         `- Each idea is a catchy, scroll-stopping video title`,
         `- Use proven viral patterns: POV, "X điều...", plot twist, emotional hook, controversial take`,
-        `- Titles must be in Vietnamese, natural and engaging`,
+        langReq,
         `- Mix different angles/formats for variety`,
+        ...(styleName ? [`- Ideas must fit the "${styleName}" video style${styleDesc ? ` (${styleDesc})` : ''}`] : []),
         ``,
         `Respond with ONLY a JSON array of 5 strings. No explanation, no markdown, no wrapping.`,
         `Example format: ["title 1","title 2","title 3","title 4","title 5"]`,
@@ -150,7 +163,7 @@ export async function handleGenerateIdeas(ws, code, taskId, topic) {
 //   2. Run `claude -p <prompt> --append-system-prompt <template>` in lightweight mode
 //   3. Stream text deltas back to extension
 //   4. Return full script on completion
-export async function handleGenerateScript(ws, code, taskId, idea, topic, style, duration, language) {
+export async function handleGenerateScript(ws, code, taskId, idea, topic, style, duration, language, styleName, styleGuidance) {
     if (!hasContentCreator()) {
         const error = 'content-creator agent not found on this machine';
         console.error(`[generate_script] ${error}`);
@@ -196,7 +209,12 @@ export async function handleGenerateScript(ws, code, taskId, idea, topic, style,
     catch {
         // Non-fatal — Claude will use N/A for characters
     }
-    const systemPrompt = expandedTemplate + (characterContext
+    // Build style guidance section
+    let styleContext = '';
+    if (styleGuidance && styleGuidance.trim()) {
+        styleContext = `\n\n## VIDEO STYLE GUIDANCE (${styleName || resolvedStyle})\n\nFollow these style-specific instructions for tone, pacing, camera work, and visual direction. The output format MUST remain exactly as specified above — only the CONTENT within each section should reflect this guidance.\n\n${styleGuidance.trim()}`;
+    }
+    const systemPrompt = expandedTemplate + styleContext + (characterContext
         ? `\n\n## AVAILABLE CHARACTERS\n${characterContext}`
         : '');
     try {
@@ -364,9 +382,28 @@ async function _doRender(ws, code, taskId, record, payload) {
                 localPath = destFile;
             }
             else if (scene.videoUrl.startsWith('http://') || scene.videoUrl.startsWith('https://')) {
-                // HTTP(S) URL — download directly
-                await _downloadFile(scene.videoUrl, destFile);
-                localPath = destFile;
+                // HTTP(S) URL — ask extension to fetch (needs auth cookies for Google Flow)
+                try {
+                    const result = await flowCmd(ws, code, {
+                        type: 'fetchVideoAsBase64',
+                        videoUrl: scene.videoUrl,
+                    }, 120000);
+                    const base64 = result.base64;
+                    if (!base64)
+                        throw new Error('No base64 data returned from extension');
+                    fs.writeFileSync(destFile, Buffer.from(base64, 'base64'));
+                    localPath = destFile;
+                }
+                catch (err) {
+                    // Fallback: try direct download (works for non-auth URLs)
+                    try {
+                        await _downloadFile(scene.videoUrl, destFile);
+                        localPath = destFile;
+                    }
+                    catch (dlErr) {
+                        throw new Error(`Failed to download video for scene ${scene.idx}: ${dlErr instanceof Error ? dlErr.message : dlErr}`);
+                    }
+                }
             }
             else if (scene.videoUrl.startsWith('blob:')) {
                 // Blob URL — ask extension to extract via flow command
@@ -445,27 +482,40 @@ async function _doRender(ws, code, taskId, record, payload) {
             console.warn(`[render] ffprobe failed (non-fatal):`, e);
         }
         _emitProgress(ws, code, record, 95, 'Finalizing...');
-        // ── Step 5: Update record and notify ─────────────────────────────────
+        // ── Step 5: Read video file as base64 for extension playback ─────────
+        let videoBase64;
+        try {
+            const buf = fs.readFileSync(outFile);
+            videoBase64 = buf.toString('base64');
+            console.log(`[render] Video base64 size: ${(videoBase64.length / 1024 / 1024).toFixed(1)}MB`);
+        }
+        catch (e) {
+            console.warn(`[render] Could not read video for base64 (non-fatal):`, e);
+        }
+        // ── Step 6: Update record and notify ─────────────────────────────────
         record.status = 'rendered';
         record.progress = 100;
         record.outputPath = outFile;
         upsertVideo(record);
         ws.sendExtensionEvent(code, {
             type: 'render_done',
-            outputPath: outFile,
+            videoBase64,
             title: record.title,
             duration,
             resolution,
-            video: record,
         });
         ws.sendExtensionDone(code, taskId, {
             ok: true,
             videoId: record.id,
-            outputPath: outFile,
             duration,
             resolution,
         });
         console.log(`[render] Done: ${outFile} (${duration}, ${resolution})`);
+        // Clean up rendered video file — extension has the base64 data
+        try {
+            fs.unlinkSync(outFile);
+        }
+        catch { /* ignore */ }
     }
     catch (err) {
         const error = err instanceof Error ? err.message : String(err);

package/dist/daemon/index.js

@@ -345,13 +345,13 @@ ${skillContent.slice(0, 15000)}`;
                 }
                 if (extTask === 'generate_ideas') {
                     (async () => {
-                        await handleGenerateIdeas(ws, extCode, extTaskId, msg.topic);
+                        await handleGenerateIdeas(ws, extCode, extTaskId, msg.topic, msg.styleName, msg.styleDesc, msg.language);
                     })();
                     break;
                 }
                 if (extTask === 'generate_script') {
                     (async () => {
-                        await handleGenerateScript(ws, extCode, extTaskId, msg.idea, msg.topic, msg.style, msg.duration, msg.language);
+                        await handleGenerateScript(ws, extCode, extTaskId, msg.idea, msg.topic, msg.style, msg.duration, msg.language, msg.styleName, msg.styleGuidance);
                     })();
                     break;
                 }

package/dist/mcp/setup.js

@@ -6,33 +6,43 @@ const __dirname = path.dirname(__filename);
 const MCP_CONFIG_DIR = path.join(process.env.HOME || '', '.tuna-agent');
 const MCP_CONFIG_PATH = path.join(MCP_CONFIG_DIR, 'mcp-config.json');
 // Mem0 config from environment variables
-const MEM0_SSH_HOST = process.env.MEM0_SSH_HOST; // e.g. "root@redrop.ddns.net"
+// MEM0_SSH_HOST: "local" = run mem0-mcp directly, "user@host" = run via SSH, unset = disabled
+const MEM0_SSH_HOST = process.env.MEM0_SSH_HOST;
 const MEM0_SSH_PORT = process.env.MEM0_SSH_PORT || '22';
-const MEM0_SSH_KEY = process.env.MEM0_SSH_KEY; // optional: path to SSH key
+const MEM0_SSH_KEY = process.env.MEM0_SSH_KEY;
+const MEM0_ENV_VARS = {
+    MEM0_API_BASE: 'http://127.0.0.1:8765',
+    MEM0_QDRANT_URL: 'http://127.0.0.1:6333',
+    MEM0_OLLAMA_URL: 'http://127.0.0.1:11434',
+    MEM0_EMBED_MODEL: 'mxbai-embed-large:latest',
+    MEM0_COLLECTION: 'openmemory',
+    MEM0_NEO4J_URL: 'bolt://127.0.0.1:7687',
+    MEM0_NEO4J_USER: 'neo4j',
+    MEM0_NEO4J_PASSWORD: 'mem0graph',
+};
 /**
  * Build Mem0 MCP server config for an agent.
- * Runs mem0-mcp on the Mem0 infra machine via SSH stdio.
- * Returns null if MEM0_SSH_HOST is not configured.
+ * - MEM0_SSH_HOST="local": run mem0-mcp directly (Mem0 infra on same machine)
+ * - MEM0_SSH_HOST="user@host": run mem0-mcp via SSH stdio
+ * - MEM0_SSH_HOST unset: disabled
  */
 function buildMem0McpConfig(agentName) {
     if (!MEM0_SSH_HOST)
         return null;
-    const envVars = [
-        'MEM0_API_BASE=http://127.0.0.1:8765',
-        'MEM0_QDRANT_URL=http://127.0.0.1:6333',
-        'MEM0_OLLAMA_URL=http://127.0.0.1:11434',
-        'MEM0_EMBED_MODEL=mxbai-embed-large:latest',
-        'MEM0_COLLECTION=openmemory',
-        `MEM0_USER_ID=${agentName}`,
-        'MEM0_NEO4J_URL=bolt://127.0.0.1:7687',
-        'MEM0_NEO4J_USER=neo4j',
-        'MEM0_NEO4J_PASSWORD=mem0graph',
-    ].join(' ');
+    const envWithUser = { ...MEM0_ENV_VARS, MEM0_USER_ID: agentName };
+    if (MEM0_SSH_HOST === 'local') {
+        return {
+            command: 'mem0-mcp',
+            args: [],
+            env: envWithUser,
+        };
+    }
+    const envString = Object.entries(envWithUser).map(([k, v]) => `${k}=${v}`).join(' ');
     const args = ['-p', MEM0_SSH_PORT, '-o', 'StrictHostKeyChecking=no'];
     if (MEM0_SSH_KEY) {
         args.push('-i', MEM0_SSH_KEY);
     }
-    args.push(MEM0_SSH_HOST, `${envVars} mem0-mcp`);
+    args.push(MEM0_SSH_HOST, `${envString} mem0-mcp`);
     return { command: 'ssh', args };
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuna-agent",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Tuna Agent - Run AI coding tasks on your machine",
   "bin": {
     "tuna-agent": "dist/cli/index.js"