tuna-agent 0.1.0 → 0.1.2

package/dist/daemon/extension-handlers.js

@@ -0,0 +1,630 @@
+/**
+ * Extension Task Handlers
+ * Handles specialized tasks from the Chrome extension that don't need Claude:
+ * - get_history       — return local video history
+ * - retry_video       — re-queue a video for rendering
+ * - generate_scene(s) — call Veo3 to create clips
+ * - render_video      — compose final video via Remotion
+ * - list_characters   — return character profiles with thumbnails
+ * - create_character  — create new character profile directory
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { runClaude } from '../utils/claude-cli.js';
+// ─── Storage ──────────────────────────────────────────────────────────────────
+const VIDEOS_DIR = path.join(os.homedir(), '.tuna-content', 'videos');
+const VIDEOS_DB = path.join(VIDEOS_DIR, 'history.json');
+function ensureDir() {
+    fs.mkdirSync(VIDEOS_DIR, { recursive: true });
+}
+function loadHistory() {
+    try {
+        ensureDir();
+        if (!fs.existsSync(VIDEOS_DB))
+            return [];
+        return JSON.parse(fs.readFileSync(VIDEOS_DB, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+}
+function saveHistory(videos) {
+    ensureDir();
+    fs.writeFileSync(VIDEOS_DB, JSON.stringify(videos, null, 2));
+}
+function upsertVideo(record) {
+    const all = loadHistory();
+    const idx = all.findIndex(v => v.id === record.id);
+    if (idx >= 0)
+        all[idx] = record;
+    else
+        all.unshift(record);
+    saveHistory(all);
+}
+// ─── Handler: get_history ─────────────────────────────────────────────────────
+export function handleGetHistory(ws, code, taskId) {
+    const videos = loadHistory();
+    ws.sendExtensionEvent(code, { type: 'history_result', videos });
+    ws.sendExtensionDone(code, taskId, { ok: true });
+}
+// Fixed path to content-creator agent installed on this machine
+const CONTENT_CREATOR_DIR = path.join(os.homedir(), 'agents/content-creator');
+/** Returns true only when the content-creator agent is installed on this machine */
+function hasContentCreator() {
+    try {
+        return fs.existsSync(path.join(CONTENT_CREATOR_DIR, '.claude', 'commands', 'script.md'));
+    }
+    catch {
+        return false;
+    }
+}
+// ─── Handler: generate_ideas ──────────────────────────────────────────────────
+export async function handleGenerateIdeas(ws, code, taskId, topic) {
+    if (!hasContentCreator()) {
+        const error = 'content-creator agent not found on this machine';
+        console.error(`[generate_ideas] ${error}`);
+        ws.sendExtensionEvent(code, { type: 'ideas_result', ideas: [], error });
+        ws.sendExtensionDone(code, taskId, { error });
+        return;
+    }
+    const systemPrompt = [
+        `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(' ');
+    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`,
+        `- Mix different angles/formats for variety`,
+        ``,
+        `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"]`,
+    ].join('\n');
+    try {
+        const result = await runClaude({
+            prompt,
+            systemPrompt,
+            cwd: CONTENT_CREATOR_DIR,
+            maxTurns: 1,
+            outputFormat: 'json',
+            timeoutMs: 60000,
+        });
+        let ideas = [];
+        try {
+            // Try all JSON arrays in the response and pick the one with 5 items
+            const arrays = [];
+            const re = /\[(?:[^\[\]]*(?:"(?:[^"\\]|\\.)*"[^\[\]]*)*)\]/g;
+            let m;
+            while ((m = re.exec(result.result)) !== null) {
+                try {
+                    const parsed = JSON.parse(m[0]);
+                    if (Array.isArray(parsed) && parsed.every(i => typeof i === 'string')) {
+                        arrays.push(parsed);
+                    }
+                }
+                catch { /* skip non-JSON matches */ }
+            }
+            // Prefer the array closest to 5 items
+            if (arrays.length > 0) {
+                ideas = arrays.reduce((best, cur) => Math.abs(cur.length - 5) < Math.abs(best.length - 5) ? cur : best);
+            }
+        }
+        catch { /* fall through to fallback */ }
+        // Fallback: split numbered/bulleted lines
+        if (ideas.length === 0) {
+            ideas = result.result
+                .split('\n')
+                .map(l => l.replace(/^[\d\-\*\.\)\s]+/, '').replace(/^[""]|[""]$/g, '').trim())
+                .filter(l => l.length > 10 && !l.startsWith('[') && !l.toLowerCase().includes('json'))
+                .slice(0, 5);
+        }
+        // Clean up ideas: strip U+FFFD replacement chars and stray emoji that may not render
+        ideas = ideas.map(idea => idea.replace(/\uFFFD/g, '').trim());
+        ws.sendExtensionEvent(code, { type: 'ideas_result', ideas });
+        ws.sendExtensionDone(code, taskId, { ok: true });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        ws.sendExtensionEvent(code, { type: 'ideas_result', ideas: [], error });
+        ws.sendExtensionDone(code, taskId, { error });
+    }
+}
+// ─── Handler: generate_script ─────────────────────────────────────────────────
+//
+// Reads the /script command template, expands $ARGUMENTS, and runs Claude in
+// lightweight mode (no MCP servers, no tool loading). This avoids loading
+// Pencil MCP and other IDE-specific servers that hang in headless mode.
+//
+// Flow:
+//   1. Read .claude/commands/script.md, replace $ARGUMENTS with idea + style
+//   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) {
+    if (!hasContentCreator()) {
+        const error = 'content-creator agent not found on this machine';
+        console.error(`[generate_script] ${error}`);
+        ws.sendExtensionDone(code, taskId, { error });
+        return;
+    }
+    // Read and expand the /script command template
+    const templatePath = path.join(CONTENT_CREATOR_DIR, '.claude', 'commands', 'script.md');
+    let template;
+    try {
+        template = fs.readFileSync(templatePath, 'utf-8');
+    }
+    catch (err) {
+        const error = `Cannot read script template: ${err instanceof Error ? err.message : err}`;
+        console.error(`[generate_script] ${error}`);
+        ws.sendExtensionDone(code, taskId, { error });
+        return;
+    }
+    const styleFlag = style ? `--style ${style} ` : '';
+    const args = `${styleFlag}${idea}`.trim();
+    const expandedTemplate = template.replace(/\$ARGUMENTS/g, args);
+    // Also read character profiles so Claude can match characters
+    let characterContext = '';
+    try {
+        if (fs.existsSync(CHARACTERS_DIR)) {
+            const chars = fs.readdirSync(CHARACTERS_DIR).filter(d => fs.statSync(path.join(CHARACTERS_DIR, d)).isDirectory());
+            for (const charName of chars) {
+                const profilePath = path.join(CHARACTERS_DIR, charName, 'profile.md');
+                if (fs.existsSync(profilePath)) {
+                    const profile = fs.readFileSync(profilePath, 'utf-8');
+                    characterContext += `\n\n--- Character: ${charName} ---\n${profile}`;
+                }
+            }
+        }
+    }
+    catch {
+        // Non-fatal — Claude will use N/A for characters
+    }
+    const systemPrompt = expandedTemplate + (characterContext
+        ? `\n\n## AVAILABLE CHARACTERS\n${characterContext}`
+        : '');
+    try {
+        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}`,
+            systemPrompt,
+            cwd: CONTENT_CREATOR_DIR,
+            maxTurns: 4,
+            outputFormat: 'stream-json',
+            includePartialMessages: true,
+            timeoutMs: 180000,
+            onStreamLine: (data) => {
+                if (streamChunks < 5) {
+                    const sub = data.subtype || '';
+                    console.log(`[generate_script] stream #${streamChunks}: type=${data.type} sub=${sub}`);
+                }
+                streamChunks++;
+                // stream_event: raw API events (token-level deltas) — fast, smooth streaming
+                if (data.type === 'stream_event') {
+                    const evt = data.event;
+                    if (evt?.type === 'content_block_delta') {
+                        const delta = evt.delta;
+                        if (delta?.type === 'text_delta' && typeof delta.text === 'string') {
+                            sentTextLen += delta.text.length;
+                            ws.sendExtensionStream(code, taskId, delta.text);
+                        }
+                    }
+                    return;
+                }
+                // assistant: partial message snapshots (fallback for coarser updates)
+                if (data.type === 'assistant') {
+                    const msg = data.message;
+                    const content = (msg?.content ?? data.content);
+                    if (Array.isArray(content)) {
+                        let fullText = '';
+                        for (const block of content) {
+                            if (block.type === 'text' && typeof block.text === 'string') {
+                                fullText += block.text;
+                            }
+                        }
+                        if (fullText.length > sentTextLen) {
+                            const delta = fullText.slice(sentTextLen);
+                            sentTextLen = fullText.length;
+                            ws.sendExtensionStream(code, taskId, delta);
+                        }
+                    }
+                }
+            },
+        });
+        console.log(`[generate_script] Done: ${streamChunks} chunks, streamed=${sentTextLen} chars, result=${result.result?.length || 0} chars`);
+        const scriptText = result.result;
+        ws.sendExtensionDone(code, taskId, { script: scriptText, text: scriptText });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        console.error(`[generate_script] Error: ${error}`);
+        ws.sendExtensionDone(code, taskId, { error });
+    }
+}
+// ─── Handler: retry_video ─────────────────────────────────────────────────────
+export function handleRetryVideo(ws, code, taskId, videoId) {
+    const videos = loadHistory();
+    const v = videos.find(x => x.id === videoId);
+    if (!v) {
+        ws.sendExtensionDone(code, taskId, { error: 'Video not found' });
+        return;
+    }
+    // Reset status and re-queue
+    v.status = 'processing';
+    v.progress = 0;
+    v.error = undefined;
+    saveHistory(videos);
+    ws.sendExtensionEvent(code, { type: 'history_result', videos: loadHistory() });
+    ws.sendExtensionDone(code, taskId, { ok: true });
+    // Re-run the render in background
+    _doRender(ws, code, 'retry-' + taskId, v);
+}
+// ─── Handler: generate_scene ─────────────────────────────────────────────────
+export async function handleGenerateScene(ws, code, taskId, sceneIdx, prompt, aspectRatio) {
+    ws.sendExtensionEvent(code, { type: 'scene_progress', idx: sceneIdx, progress: 0 });
+    try {
+        const videoUrl = await _callVeo3(prompt, aspectRatio, (p) => {
+            ws.sendExtensionEvent(code, { type: 'scene_progress', idx: sceneIdx, progress: p });
+        });
+        ws.sendExtensionEvent(code, { type: 'scene_done', idx: sceneIdx, videoUrl });
+        ws.sendExtensionDone(code, taskId, { ok: true, idx: sceneIdx, videoUrl });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        ws.sendExtensionEvent(code, { type: 'scene_failed', idx: sceneIdx, error });
+        ws.sendExtensionDone(code, taskId, { error });
+    }
+}
+// ─── Handler: generate_scenes (batch) ────────────────────────────────────────
+export async function handleGenerateScenes(ws, code, taskId, scenes, aspectRatio) {
+    for (const scene of scenes) {
+        await handleGenerateScene(ws, code, taskId + '-' + scene.idx, scene.idx, scene.prompt, aspectRatio);
+    }
+    ws.sendExtensionDone(code, taskId, { ok: true });
+}
+// ─── Handler: render_video ────────────────────────────────────────────────────
+export async function handleRenderVideo(ws, code, taskId, payload) {
+    const videoId = 'v-' + Date.now();
+    const record = {
+        id: videoId,
+        title: payload.title || 'Untitled',
+        niche: '',
+        status: 'processing',
+        progress: 0,
+        createdAt: new Date().toISOString(),
+        scenes: payload.scenes,
+        aspectRatio: payload.aspectRatio,
+    };
+    upsertVideo(record);
+    ws.sendExtensionEvent(code, { type: 'render_progress', progress: 0 });
+    _doRender(ws, code, taskId, record, payload);
+}
+// ─── Internal: Veo3 call ──────────────────────────────────────────────────────
+async function _callVeo3(prompt, aspectRatio, onProgress) {
+    // TODO: integrate real Veo3 API
+    // Simulate progress for now
+    for (let p = 10; p <= 90; p += 20) {
+        await _sleep(800);
+        onProgress(p);
+    }
+    await _sleep(800);
+    onProgress(100);
+    // Placeholder: return a dummy local file path
+    // Real impl: call Google Veo3 API, download clip to VIDEOS_DIR, return file:// path
+    const outFile = path.join(VIDEOS_DIR, `scene-${Date.now()}.mp4`);
+    return 'file://' + outFile;
+}
+// ─── Internal: Render ─────────────────────────────────────────────────────────
+async function _doRender(ws, code, taskId, record, payload) {
+    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 });
+        }
+        // TODO: integrate real Remotion render
+        // Real impl: call /render skill or Remotion CLI with scene clips + voiceover
+        const outFile = path.join(VIDEOS_DIR, `${record.id}.mp4`);
+        record.status = 'rendered';
+        record.progress = 100;
+        record.outputPath = outFile;
+        upsertVideo(record);
+        ws.sendExtensionEvent(code, {
+            type: 'render_done',
+            outputPath: outFile,
+            title: record.title,
+            video: record,
+        });
+        ws.sendExtensionDone(code, taskId, { ok: true, videoId: record.id });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        record.status = 'failed';
+        record.error = error;
+        upsertVideo(record);
+        ws.sendExtensionEvent(code, { type: 'render_failed', error });
+        ws.sendExtensionDone(code, taskId, { error });
+    }
+}
+// ─── Character profile interface ─────────────────────────────────────────────
+const CHARACTERS_DIR = path.join(os.homedir(), '.tuna', 'characters');
+/** Parse profile.md key-value lines like `- **Key:** Value` */
+function _parseProfileMd(text) {
+    const result = {};
+    // Extract title (# Name)
+    const titleMatch = text.match(/^#\s+(.+)/m);
+    if (titleMatch)
+        result.name = titleMatch[1].trim();
+    // Extract key-value pairs
+    const kvRe = /- \*\*(.+?):\*\*\s*(.+)/g;
+    let m;
+    while ((m = kvRe.exec(text)) !== null) {
+        result[m[1].toLowerCase().replace(/\s+/g, '_')] = m[2].trim();
+    }
+    return result;
+}
+// ─── Handler: list_characters ────────────────────────────────────────────────
+export function handleListCharacters(ws, code, taskId) {
+    const charDir = CHARACTERS_DIR;
+    const characters = [];
+    try {
+        if (fs.existsSync(charDir)) {
+            const dirs = fs.readdirSync(charDir).filter(d => {
+                try {
+                    return fs.statSync(path.join(charDir, d)).isDirectory();
+                }
+                catch {
+                    return false;
+                }
+            });
+            for (const dirName of dirs) {
+                const profilePath = path.join(charDir, dirName, 'profile.md');
+                const profileText = fs.existsSync(profilePath)
+                    ? fs.readFileSync(profilePath, 'utf-8') : '';
+                const parsed = _parseProfileMd(profileText);
+                // Read main image as base64
+                let thumbnail = '';
+                const imgCandidates = ['main.jpg', 'main.jpeg', 'main.png'];
+                for (const fname of imgCandidates) {
+                    const imgPath = path.join(charDir, dirName, fname);
+                    if (fs.existsSync(imgPath)) {
+                        const imgBuf = fs.readFileSync(imgPath);
+                        const ext = path.extname(imgPath).slice(1);
+                        const mime = ext === 'png' ? 'image/png' : 'image/jpeg';
+                        thumbnail = `data:${mime};base64,${imgBuf.toString('base64')}`;
+                        break;
+                    }
+                }
+                // Count selected poses
+                const selectedDir = path.join(charDir, dirName, 'selected');
+                let poseCount = 0;
+                if (fs.existsSync(selectedDir)) {
+                    poseCount = fs.readdirSync(selectedDir).filter(f => /\.(jpe?g|png)$/i.test(f)).length;
+                }
+                characters.push({
+                    id: dirName,
+                    name: parsed.name || dirName,
+                    thumbnail,
+                    gender: parsed.gender || '',
+                    age: parsed.age || '',
+                    ethnicity: parsed.ethnicity || '',
+                    vibe: parsed.vibe || '',
+                    suitableFor: parsed.suitable_for || '',
+                    poseCount,
+                });
+            }
+        }
+    }
+    catch (err) {
+        console.error(`[list_characters] Error reading characters:`, err);
+    }
+    ws.sendExtensionEvent(code, { type: 'characters_result', characters });
+    ws.sendExtensionDone(code, taskId, { ok: true });
+}
+// ─── Helper: send a flow command and unwrap result ──────────────────────────
+async function flowCmd(ws, code, command, timeout = 60000) {
+    const result = await ws.sendFlowCommand(code, command, timeout);
+    if (result && !result.success) {
+        throw new Error(`Flow command failed: ${result.error || JSON.stringify(result)}`);
+    }
+    return result;
+}
+// ─── Handler: create_character ───────────────────────────────────────────────
+export async function handleCreateCharacter(ws, code, taskId, name, displayName, prompt, outputCount = 2, orientation = 'portrait') {
+    const charDir = path.join(CHARACTERS_DIR, name);
+    // Validate
+    if (!name || !/^[a-z0-9_]+$/.test(name)) {
+        ws.sendExtensionEvent(code, { type: 'char_create_failed', error: 'Invalid name — use lowercase letters, numbers, underscores only' });
+        ws.sendExtensionDone(code, taskId, { error: 'invalid name' });
+        return;
+    }
+    try {
+        // Create directory structure (allow re-creation for regeneration)
+        fs.mkdirSync(path.join(charDir, 'generated'), { recursive: true });
+        fs.mkdirSync(path.join(charDir, 'selected'), { recursive: true });
+        // Write profile.md
+        fs.writeFileSync(path.join(charDir, 'profile.md'), `# ${displayName}\n\n- **Orientation:** ${orientation}\n- **Output Count:** ${outputCount}\n\n${prompt}\n`);
+        // ── Step 1: Open Google Flow tab ──────────────────────────────────────
+        ws.sendExtensionEvent(code, {
+            type: 'char_create_progress',
+            phase: 'setup',
+            progress: 5,
+            current: 'Opening Google Flow...',
+        });
+        await flowCmd(ws, code, { type: 'openFlowTab' }, 15000);
+        await _sleep(2000); // Extra time for page to fully initialize
+        // ── Step 2: Ping content script to verify it's ready ──────────────────
+        ws.sendExtensionEvent(code, {
+            type: 'char_create_progress',
+            phase: 'setup',
+            progress: 10,
+            current: 'Waiting for Google Flow to load...',
+        });
+        // Poll until content script is responsive
+        let pingOk = false;
+        for (let attempt = 0; attempt < 10; attempt++) {
+            try {
+                await flowCmd(ws, code, { type: 'ping' }, 5000);
+                pingOk = true;
+                break;
+            }
+            catch {
+                await _sleep(2000);
+            }
+        }
+        if (!pingOk) {
+            throw new Error('Google Flow tab not responding — make sure Flow is open at labs.google/fx/tools/flow');
+        }
+        // ── Step 3: Configure settings (mode, orientation, count) ─────────────
+        ws.sendExtensionEvent(code, {
+            type: 'char_create_progress',
+            phase: 'configuring',
+            progress: 15,
+            current: 'Configuring image settings...',
+        });
+        // Map orientation to Flow aspect ratio names
+        const aspectRatio = orientation === 'landscape' ? 'landscape' : 'portrait';
+        await flowCmd(ws, code, {
+            type: 'configureSettings',
+            settings: {
+                mode: 'create image',
+                aspectRatio,
+                outputs: String(outputCount),
+            },
+        }, 15000);
+        await _sleep(1000);
+        // ── Step 4: Fill prompt and submit ────────────────────────────────────
+        ws.sendExtensionEvent(code, {
+            type: 'char_create_progress',
+            phase: 'submitting',
+            progress: 25,
+            current: 'Entering prompt...',
+        });
+        await flowCmd(ws, code, { type: 'fillTextbox', text: prompt }, 10000);
+        await _sleep(500);
+        await flowCmd(ws, code, { type: 'submitPrompt' }, 10000);
+        // ── Step 5: Wait for images to appear ────────────────────────────────
+        ws.sendExtensionEvent(code, {
+            type: 'char_create_progress',
+            phase: 'generating',
+            progress: 30,
+            current: 'Generating images (this may take 30-60s)...',
+        });
+        // Poll countGoogleImages until we have enough images
+        const maxWait = 120000; // 2 minutes max
+        const pollInterval = 3000;
+        const startTime = Date.now();
+        let imageCount = 0;
+        while (Date.now() - startTime < maxWait) {
+            await _sleep(pollInterval);
+            const countResult = await flowCmd(ws, code, { type: 'countImages' }, 10000);
+            imageCount = countResult.visible || 0;
+            const elapsed = Date.now() - startTime;
+            const progressPct = Math.min(30 + Math.round((elapsed / maxWait) * 60), 90);
+            ws.sendExtensionEvent(code, {
+                type: 'char_create_progress',
+                phase: 'generating',
+                progress: progressPct,
+                current: `Waiting for images... (${imageCount} found)`,
+            });
+            if (imageCount >= outputCount)
+                break;
+        }
+        if (imageCount === 0) {
+            throw new Error('No images generated after waiting 2 minutes. Please check Google Flow.');
+        }
+        // ── Step 6: Extract images as base64 ──────────────────────────────────
+        ws.sendExtensionEvent(code, {
+            type: 'char_create_progress',
+            phase: 'downloading',
+            progress: 92,
+            current: 'Downloading generated images...',
+        });
+        const imgResult = await flowCmd(ws, code, { type: 'getImageBase64', minSize: 100 }, 30000);
+        const base64Images = (imgResult.images || []);
+        // Save generated images to disk
+        const genDir = path.join(charDir, 'generated');
+        const images = [];
+        for (let i = 0; i < base64Images.length; i++) {
+            const dataUrl = base64Images[i];
+            images.push(dataUrl);
+            // Also save to file
+            const match = dataUrl.match(/^data:image\/(\w+);base64,(.+)$/);
+            if (match) {
+                const ext = match[1] === 'png' ? 'png' : 'jpg';
+                const fname = `gen_${String(i + 1).padStart(2, '0')}.${ext}`;
+                fs.writeFileSync(path.join(genDir, fname), Buffer.from(match[2], 'base64'));
+            }
+        }
+        // ── Step 7: Done ─────────────────────────────────────────────────────
+        ws.sendExtensionEvent(code, {
+            type: 'char_create_progress',
+            phase: 'done',
+            progress: 100,
+            current: 'Generation complete',
+        });
+        // Return the new character profile with images
+        const character = {
+            id: name,
+            name: displayName,
+            thumbnail: images.length > 0 ? images[0] : '',
+            gender: '',
+            age: '',
+            ethnicity: '',
+            vibe: '',
+            suitableFor: '',
+            poseCount: 0,
+            images,
+        };
+        ws.sendExtensionEvent(code, { type: 'char_created', character });
+        ws.sendExtensionDone(code, taskId, { ok: true });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        console.error(`[create_character] Error:`, error);
+        ws.sendExtensionEvent(code, { type: 'char_create_failed', error });
+        ws.sendExtensionDone(code, taskId, { error });
+    }
+}
+// ─── Handler: save_character_selection ────────────────────────────────────────
+export function handleSaveCharacterSelection(ws, code, taskId, characterId, selectedImages) {
+    const charDir = path.join(CHARACTERS_DIR, characterId);
+    try {
+        if (!fs.existsSync(charDir)) {
+            ws.sendExtensionDone(code, taskId, { error: 'Character not found' });
+            return;
+        }
+        const selectedDir = path.join(charDir, 'selected');
+        fs.mkdirSync(selectedDir, { recursive: true });
+        // Save first selected image as main.jpg if no main exists
+        if (selectedImages.length > 0) {
+            const mainPath = path.join(charDir, 'main.jpg');
+            if (!fs.existsSync(mainPath)) {
+                const first = selectedImages[0];
+                const match = first.match(/^data:image\/\w+;base64,(.+)$/);
+                if (match) {
+                    fs.writeFileSync(mainPath, Buffer.from(match[1], 'base64'));
+                }
+            }
+        }
+        // TODO: Copy selected generated images to selected/ directory
+        // For now, just acknowledge the selection
+        ws.sendExtensionDone(code, taskId, { ok: true, count: selectedImages.length });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        console.error(`[save_character_selection] Error:`, error);
+        ws.sendExtensionDone(code, taskId, { error });
+    }
+}
+function _sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}