tuna-agent 0.1.3 → 0.1.5

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

@@ -27,7 +27,7 @@ export interface VideoRecord {
 }
 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): 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 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

@@ -11,7 +11,11 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { pipeline } from 'stream/promises';
 import { runClaude } from '../utils/claude-cli.js';
+const execFileAsync = promisify(execFile);
 // ─── Storage ──────────────────────────────────────────────────────────────────
 const VIDEOS_DIR = path.join(os.homedir(), '.tuna-content', 'videos');
 const VIDEOS_DB = path.join(VIDEOS_DIR, 'history.json');
@@ -146,7 +150,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) {
+export async function handleGenerateScript(ws, code, taskId, idea, topic, style, duration, language) {
     if (!hasContentCreator()) {
         const error = 'content-creator agent not found on this machine';
         console.error(`[generate_script] ${error}`);
@@ -165,9 +169,16 @@ export async function handleGenerateScript(ws, code, taskId, idea, topic, style)
         ws.sendExtensionDone(code, taskId, { error });
         return;
     }
-    const styleFlag = style ? `--style ${style} ` : '';
-    const args = `${styleFlag}${idea}`.trim();
-    const expandedTemplate = template.replace(/\$ARGUMENTS/g, args);
+    const resolvedStyle = style || 'short-form';
+    const resolvedDuration = duration || 60;
+    const resolvedLanguage = language || 'vi';
+    console.log(`[generate_script] Received: style=${style} duration=${duration} (resolved=${resolvedDuration}) language=${language}`);
+    const expandedTemplate = template
+        .replace(/\$ARGUMENTS/g, idea)
+        .replace(/\$IDEA/g, idea)
+        .replace(/\$STYLE/g, resolvedStyle)
+        .replace(/\$DURATION/g, String(resolvedDuration))
+        .replace(/\$LANGUAGE/g, resolvedLanguage);
     // Also read character profiles so Claude can match characters
     let characterContext = '';
     try {
@@ -192,7 +203,7 @@ export async function handleGenerateScript(ws, code, taskId, idea, topic, style)
         let streamChunks = 0;
         let sentTextLen = 0; // track how much text we've already streamed
         const result = await runClaude({
-            prompt: `Viết script video theo hướng dẫn trên. Arguments: ${args}`,
+            prompt: `Viết script video theo hướng dẫn trên.\n\nIdea: ${idea}\nStyle: ${resolvedStyle}\nDuration: ${resolvedDuration}s\nLanguage: ${resolvedLanguage}`,
             systemPrompt,
             cwd: CONTENT_CREATOR_DIR,
             maxTurns: 4,
@@ -320,19 +331,121 @@ async function _callVeo3(prompt, aspectRatio, onProgress) {
     const outFile = path.join(VIDEOS_DIR, `scene-${Date.now()}.mp4`);
     return 'file://' + outFile;
 }
-// ─── Internal: Render ─────────────────────────────────────────────────────────
+// ─── Internal: Render (ffmpeg concat) ─────────────────────────────────────────
 async function _doRender(ws, code, taskId, record, payload) {
+    const tmpDir = path.join(os.tmpdir(), `tuna-render-${record.id}`);
     try {
-        // Progress: 0 → 100
-        for (let p = 10; p <= 90; p += 10) {
-            await _sleep(600);
-            record.progress = p;
-            upsertVideo(record);
-            ws.sendExtensionEvent(code, { type: 'render_progress', progress: p });
+        fs.mkdirSync(tmpDir, { recursive: true });
+        ensureDir();
+        const scenes = payload?.scenes || record.scenes || [];
+        // ── Step 1: Collect scene video files (0% → 30%) ─────────────────────
+        _emitProgress(ws, code, record, 5, 'Collecting scene videos...');
+        const videoFiles = [];
+        for (let i = 0; i < scenes.length; i++) {
+            const scene = scenes[i];
+            if (!scene.videoUrl) {
+                console.warn(`[render] Scene ${scene.idx} has no videoUrl, skipping`);
+                continue;
+            }
+            let localPath;
+            const destFile = path.join(tmpDir, `scene_${String(scene.idx).padStart(2, '0')}.mp4`);
+            if (scene.videoUrl.startsWith('file://')) {
+                localPath = scene.videoUrl.replace('file://', '');
+            }
+            else if (scene.videoUrl.startsWith('/')) {
+                localPath = scene.videoUrl;
+            }
+            else if (scene.videoUrl.startsWith('data:')) {
+                // Base64 data URL — decode and save
+                const match = scene.videoUrl.match(/^data:video\/\w+;base64,(.+)$/);
+                if (!match)
+                    throw new Error(`Invalid data URL for scene ${scene.idx}`);
+                fs.writeFileSync(destFile, Buffer.from(match[1], 'base64'));
+                localPath = destFile;
+            }
+            else if (scene.videoUrl.startsWith('http://') || scene.videoUrl.startsWith('https://')) {
+                // HTTP(S) URL — download directly
+                await _downloadFile(scene.videoUrl, destFile);
+                localPath = destFile;
+            }
+            else if (scene.videoUrl.startsWith('blob:')) {
+                // Blob URL — ask extension to extract via flow command
+                try {
+                    const result = await flowCmd(ws, code, {
+                        type: 'getVideoBlob',
+                        videoUrl: scene.videoUrl,
+                    }, 60000);
+                    const base64 = result.base64;
+                    if (!base64)
+                        throw new Error('No base64 data returned');
+                    fs.writeFileSync(destFile, Buffer.from(base64, 'base64'));
+                    localPath = destFile;
+                }
+                catch (err) {
+                    throw new Error(`Failed to extract blob video for scene ${scene.idx}: ${err instanceof Error ? err.message : err}`);
+                }
+            }
+            else {
+                throw new Error(`Unsupported videoUrl format for scene ${scene.idx}: ${scene.videoUrl.substring(0, 30)}...`);
+            }
+            if (!fs.existsSync(localPath)) {
+                throw new Error(`Video file not found for scene ${scene.idx}: ${localPath}`);
+            }
+            videoFiles.push(localPath);
+            const pct = 5 + Math.round(((i + 1) / scenes.length) * 25);
+            _emitProgress(ws, code, record, pct, `Collected ${i + 1}/${scenes.length} videos`);
         }
-        // TODO: integrate real Remotion render
-        // Real impl: call /render skill or Remotion CLI with scene clips + voiceover
+        if (videoFiles.length === 0) {
+            throw new Error('No scene videos available to render');
+        }
+        console.log(`[render] Collected ${videoFiles.length} video files`);
+        // ── Step 2: Create ffmpeg concat list (30%) ──────────────────────────
+        _emitProgress(ws, code, record, 30, 'Preparing video merge...');
+        const concatList = path.join(tmpDir, 'concat.txt');
+        const concatContent = videoFiles
+            .map(f => `file '${f.replace(/'/g, "'\\''")}'`)
+            .join('\n');
+        fs.writeFileSync(concatList, concatContent);
+        // ── Step 3: Run ffmpeg concat (35% → 80%) ───────────────────────────
         const outFile = path.join(VIDEOS_DIR, `${record.id}.mp4`);
+        _emitProgress(ws, code, record, 35, 'Merging videos with ffmpeg...');
+        // Try stream-copy first (fast, no re-encoding)
+        try {
+            await _runFfmpeg([
+                '-y', '-f', 'concat', '-safe', '0',
+                '-i', concatList,
+                '-c', 'copy',
+                '-movflags', '+faststart',
+                outFile,
+            ]);
+        }
+        catch (copyErr) {
+            // If copy fails (codec mismatch), re-encode
+            console.warn(`[render] -c copy failed, re-encoding: ${copyErr instanceof Error ? copyErr.message : copyErr}`);
+            _emitProgress(ws, code, record, 40, 'Re-encoding (codec mismatch)...');
+            await _runFfmpeg([
+                '-y', '-f', 'concat', '-safe', '0',
+                '-i', concatList,
+                '-c:v', 'libx264', '-preset', 'fast', '-crf', '23',
+                '-c:a', 'aac', '-b:a', '128k',
+                '-movflags', '+faststart',
+                outFile,
+            ]);
+        }
+        _emitProgress(ws, code, record, 85, 'Video merged');
+        // ── Step 4: Get output metadata ─────────────────────────────────────
+        let duration = '0:00';
+        let resolution = '1080×1920';
+        try {
+            const probe = await _runFfprobe(outFile);
+            duration = probe.duration;
+            resolution = probe.resolution;
+        }
+        catch (e) {
+            console.warn(`[render] ffprobe failed (non-fatal):`, e);
+        }
+        _emitProgress(ws, code, record, 95, 'Finalizing...');
+        // ── Step 5: Update record and notify ─────────────────────────────────
         record.status = 'rendered';
         record.progress = 100;
         record.outputPath = outFile;
@@ -341,18 +454,83 @@ async function _doRender(ws, code, taskId, record, payload) {
             type: 'render_done',
             outputPath: outFile,
             title: record.title,
+            duration,
+            resolution,
             video: record,
         });
-        ws.sendExtensionDone(code, taskId, { ok: true, videoId: record.id });
+        ws.sendExtensionDone(code, taskId, {
+            ok: true,
+            videoId: record.id,
+            outputPath: outFile,
+            duration,
+            resolution,
+        });
+        console.log(`[render] Done: ${outFile} (${duration}, ${resolution})`);
     }
     catch (err) {
         const error = err instanceof Error ? err.message : String(err);
+        console.error(`[render] Failed:`, error);
         record.status = 'failed';
         record.error = error;
         upsertVideo(record);
         ws.sendExtensionEvent(code, { type: 'render_failed', error });
         ws.sendExtensionDone(code, taskId, { error });
     }
+    finally {
+        // Cleanup temp directory
+        try {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { /* ignore cleanup errors */ }
+    }
+}
+/** Emit render progress and persist to history */
+function _emitProgress(ws, code, record, progress, phase) {
+    record.progress = progress;
+    upsertVideo(record);
+    ws.sendExtensionEvent(code, { type: 'render_progress', progress, phase });
+}
+/** Download a file from HTTP(S) URL to a local path */
+async function _downloadFile(url, dest) {
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`Download failed: ${res.status} ${res.statusText}`);
+    if (!res.body)
+        throw new Error('No response body');
+    const fileStream = fs.createWriteStream(dest);
+    // @ts-ignore — Node ReadableStream → pipeline
+    await pipeline(res.body, fileStream);
+}
+/** Run ffmpeg with the given arguments */
+async function _runFfmpeg(args) {
+    const { stdout, stderr } = await execFileAsync('ffmpeg', args, {
+        timeout: 300000, // 5 minutes
+        maxBuffer: 10 * 1024 * 1024, // 10MB
+    });
+    return stdout || stderr;
+}
+/** Probe a video file for duration and resolution */
+async function _runFfprobe(filePath) {
+    const { stdout } = await execFileAsync('ffprobe', [
+        '-v', 'quiet',
+        '-print_format', 'json',
+        '-show_format', '-show_streams',
+        filePath,
+    ], { timeout: 10000 });
+    const info = JSON.parse(stdout);
+    const videoStream = info.streams?.find((s) => s.codec_type === 'video');
+    let duration = '0:00';
+    const totalSec = parseFloat(info.format?.duration || '0');
+    if (totalSec > 0) {
+        const min = Math.floor(totalSec / 60);
+        const sec = Math.round(totalSec % 60);
+        duration = `${min}:${String(sec).padStart(2, '0')}`;
+    }
+    let resolution = '1080×1920';
+    if (videoStream) {
+        resolution = `${videoStream.width}×${videoStream.height}`;
+    }
+    return { duration, resolution };
 }
 // ─── Character profile interface ─────────────────────────────────────────────
 const CHARACTERS_DIR = path.join(os.homedir(), '.tuna', 'characters');

package/dist/daemon/index.js

@@ -155,6 +155,43 @@ export async function startDaemon(config) {
                     ws.send({ action: 'agent_skills_scanned', agent_id: agentId, skills });
                     console.log(`[Daemon] Scanned ${skills.length} skill(s) for agent ${agentId}`);
                 }
+                else if (command === 'create_agent') {
+                    const agentId = msg.agent_id;
+                    const agentName = msg.agent_name || 'agent';
+                    const rawFolder = msg.folder_path || '';
+                    const roleDesc = msg.role_description || '';
+                    if (!rawFolder) {
+                        console.error('[Daemon] create_agent: missing folder_path');
+                        ws.send({ action: 'agent_folder_created', agent_id: agentId, success: false, error: 'Missing folder_path' });
+                        break;
+                    }
+                    const folderPath = rawFolder.startsWith('~')
+                        ? path.join(os.homedir(), rawFolder.slice(1))
+                        : rawFolder;
+                    console.log(`[Daemon] Creating agent folder: ${folderPath} for "${agentName}"`);
+                    try {
+                        // Create folder structure
+                        fs.mkdirSync(path.join(folderPath, '.claude', 'commands'), { recursive: true });
+                        fs.mkdirSync(path.join(folderPath, 'knowledge'), { recursive: true });
+                        // Write CLAUDE.md only if it doesn't exist
+                        const claudeMdPath = path.join(folderPath, 'CLAUDE.md');
+                        if (!fs.existsSync(claudeMdPath)) {
+                            const claudeContent = `# ${agentName}\n\n${roleDesc || `You are ${agentName}, an AI agent.`}\n`;
+                            fs.writeFileSync(claudeMdPath, claudeContent, 'utf-8');
+                            console.log(`[Daemon] Created CLAUDE.md for "${agentName}"`);
+                        }
+                        else {
+                            console.log(`[Daemon] CLAUDE.md already exists, skipping`);
+                        }
+                        ws.send({ action: 'agent_folder_created', agent_id: agentId, success: true });
+                        console.log(`[Daemon] Agent folder created: ${folderPath}`);
+                    }
+                    catch (err) {
+                        const errMsg = err instanceof Error ? err.message : String(err);
+                        console.error(`[Daemon] Failed to create agent folder: ${errMsg}`);
+                        ws.send({ action: 'agent_folder_created', agent_id: agentId, success: false, error: errMsg });
+                    }
+                }
                 else if (command === 'analyze_skill') {
                     const skillId = msg.skill_id;
                     const sourcePath = msg.source_path;
@@ -314,7 +351,7 @@ ${skillContent.slice(0, 15000)}`;
                 }
                 if (extTask === 'generate_script') {
                     (async () => {
-                        await handleGenerateScript(ws, extCode, extTaskId, msg.idea, msg.topic, msg.style);
+                        await handleGenerateScript(ws, extCode, extTaskId, msg.idea, msg.topic, msg.style, msg.duration, msg.language);
                     })();
                     break;
                 }

package/dist/mcp/setup.js

@@ -5,6 +5,36 @@ const __filename = fileURLToPath(import.meta.url);
 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"
+const MEM0_SSH_PORT = process.env.MEM0_SSH_PORT || '22';
+const MEM0_SSH_KEY = process.env.MEM0_SSH_KEY; // optional: path to SSH key
+/**
+ * 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.
+ */
+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 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`);
+    return { command: 'ssh', args };
+}
 /**
  * Generate MCP server config file for Claude Code.
  * This file is auto-detected by runClaude and passed via --mcp-config.
@@ -12,23 +42,26 @@ const MCP_CONFIG_PATH = path.join(MCP_CONFIG_DIR, 'mcp-config.json');
 export function setupMcpConfig(config) {
     const knowledgeServerPath = path.join(__dirname, 'knowledge-server.js');
     const browserServerPath = path.join(__dirname, 'browser-server.js');
-    const mcpConfig = {
-        mcpServers: {
-            'tuna-knowledge': {
-                command: process.execPath, // full path to current node binary
-                args: [
-                    knowledgeServerPath,
-                    '--api-url', config.apiUrl,
-                    '--token', config.agentToken,
-                    '--agent-id', config.agentId,
-                ],
-            },
-            'tuna-browser': {
-                command: process.execPath,
-                args: [browserServerPath, '--user-data-dir', path.join(process.env.HOME || '', '.config', 'tuna-browser', 'chrome-profile')],
-            },
+    const mcpServers = {
+        'tuna-knowledge': {
+            command: process.execPath, // full path to current node binary
+            args: [
+                knowledgeServerPath,
+                '--api-url', config.apiUrl,
+                '--token', config.agentToken,
+                '--agent-id', config.agentId,
+            ],
+        },
+        'tuna-browser': {
+            command: process.execPath,
+            args: [browserServerPath, '--user-data-dir', path.join(process.env.HOME || '', '.config', 'tuna-browser', 'chrome-profile')],
         },
     };
+    const mem0Config = buildMem0McpConfig(config.name);
+    if (mem0Config) {
+        mcpServers['mem0'] = mem0Config;
+    }
+    const mcpConfig = { mcpServers };
     if (!fs.existsSync(MCP_CONFIG_DIR)) {
         fs.mkdirSync(MCP_CONFIG_DIR, { recursive: true });
     }
@@ -61,7 +94,7 @@ export function writeAgentFolderMcpConfig(agentFolderPath, config) {
             existing = JSON.parse(fs.readFileSync(mcpJsonPath, 'utf-8'));
         }
         const existingServers = existing.mcpServers ?? {};
-        existing.mcpServers = {
+        const newServers = {
             ...existingServers,
             'tuna-knowledge': {
                 command: process.execPath,
@@ -77,6 +110,11 @@ export function writeAgentFolderMcpConfig(agentFolderPath, config) {
                 args: [browserServerPath, '--user-data-dir', path.join(process.env.HOME || '', '.config', 'tuna-browser', 'chrome-profile')],
             },
         };
+        const mem0Config = buildMem0McpConfig(config.name);
+        if (mem0Config) {
+            newServers['mem0'] = mem0Config;
+        }
+        existing.mcpServers = newServers;
         fs.writeFileSync(mcpJsonPath, JSON.stringify(existing, null, 2));
         console.log(`[MCP] Agent folder .mcp.json written to ${mcpJsonPath}`);
     }

package/dist/utils/message-schemas.d.ts

@@ -32,6 +32,8 @@ export declare const CommandMessageSchema: z.ZodObject<{
     agent_folders: z.ZodOptional<z.ZodArray<z.ZodString>>;
     agent_id: z.ZodOptional<z.ZodString>;
     folder_path: z.ZodOptional<z.ZodString>;
+    agent_name: z.ZodOptional<z.ZodString>;
+    role_description: z.ZodOptional<z.ZodString>;
     skill_id: z.ZodOptional<z.ZodString>;
     source_path: z.ZodOptional<z.ZodString>;
     skill_name: z.ZodOptional<z.ZodString>;

package/dist/utils/message-schemas.js

@@ -26,6 +26,9 @@ export const CommandMessageSchema = z.object({
     // For rescan_agent_skills command
     agent_id: z.string().optional(),
     folder_path: z.string().optional(),
+    // For create_agent command
+    agent_name: z.string().optional(),
+    role_description: z.string().optional(),
     // For analyze_skill command
     skill_id: z.string().optional(),
     source_path: z.string().optional(),

package/package.json

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