@lovelybunch/api 1.0.75-alpha.8 → 1.0.75-alpha.9

package/dist/lib/terminal/terminal-manager.d.ts

@@ -7,8 +7,6 @@ export interface TerminalSession {
     websocket?: WebSocket;
     createdAt: Date;
     lastActivity: Date;
-    enableLogging?: boolean;
-    logFilePath?: string;
     backlog: string;
     previewSockets?: Set<WebSocket>;
     previewBuffer?: string;
@@ -21,7 +19,7 @@ export declare class TerminalManager {
     private cleanupInterval;
     private static readonly MAX_BACKLOG_BYTES;
     constructor();
-    createSession(proposalId: string, enableLogging?: boolean, shellPreference?: ShellType, startupCommand?: string): Promise<TerminalSession>;
+    createSession(proposalId: string, shellPreference?: ShellType, startupCommand?: string): Promise<TerminalSession>;
     getSession(sessionId: string): TerminalSession | undefined;
     getSessionsByProposal(proposalId: string): TerminalSession[];
     attachWebSocket(sessionId: string, ws: WebSocket): boolean;

package/dist/lib/terminal/terminal-manager.js

@@ -16,7 +16,7 @@ export class TerminalManager {
             this.cleanupInactiveSessions();
         }, 5 * 60 * 1000);
     }
-    async createSession(proposalId, enableLogging = false, shellPreference = 'bash', startupCommand) {
+    async createSession(proposalId, shellPreference = 'bash', startupCommand) {
         const sessionId = `${proposalId}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
         // Get the project root directory
         let projectRoot;
@@ -65,22 +65,6 @@ export class TerminalManager {
         catch (error) {
             console.error('Error creating init script:', error);
         }
-        // Set up logging if enabled
-        let logFilePath;
-        if (enableLogging) {
-            const sessionsDir = path.join(projectRoot, '.nut', 'sessions');
-            try {
-                fs.mkdirSync(sessionsDir, { recursive: true });
-                logFilePath = path.join(sessionsDir, `${sessionId}.log`);
-                // Create log file with session header
-                const logHeader = `# Terminal Session Log\n# Session ID: ${sessionId}\n# Proposal ID: ${proposalId}\n# Created: ${new Date().toISOString()}\n\n`;
-                fs.writeFileSync(logFilePath, logHeader);
-            }
-            catch (error) {
-                console.error('Error setting up session logging:', error);
-                logFilePath = undefined;
-            }
-        }
         // Get shell arguments
         const shellArgs = getShellArgs(shellPath, initScriptPath);
         // Prepare environment variables with API keys injected.
@@ -120,8 +104,6 @@ export class TerminalManager {
             pty: ptyProcess,
             createdAt: new Date(),
             lastActivity: new Date(),
-            enableLogging,
-            logFilePath,
             backlog: '',
             previewSockets: new Set(),
             previewBuffer: '',
@@ -153,17 +135,6 @@ export class TerminalManager {
         // Set up PTY event handlers
         ptyProcess.onData((data) => {
             session.lastActivity = new Date();
-            // Log data if logging is enabled
-            if (session.enableLogging && session.logFilePath) {
-                try {
-                    const timestamp = new Date().toISOString();
-                    const logEntry = `[${timestamp}] OUTPUT: ${data}`;
-                    fs.appendFileSync(session.logFilePath, logEntry);
-                }
-                catch (error) {
-                    console.error('Error writing to session log:', error);
-                }
-            }
             // Maintain in-memory backlog (trim to last MAX_BACKLOG_BYTES)
             try {
                 // Append and trim to max size
@@ -187,17 +158,6 @@ export class TerminalManager {
         ptyProcess.onExit((e) => {
             const endTime = new Date();
             const duration = endTime.getTime() - session.createdAt.getTime();
-            // Log session end if logging is enabled
-            if (session.enableLogging && session.logFilePath) {
-                try {
-                    const timestamp = endTime.toISOString();
-                    const logEntry = `\n[${timestamp}] SESSION ENDED: Exit code ${e.exitCode}\n`;
-                    fs.appendFileSync(session.logFilePath, logEntry);
-                }
-                catch (error) {
-                    console.error('Error writing session end to log:', error);
-                }
-            }
             // Log session end to activity log
             try {
                 const logger = getLogger();
@@ -289,17 +249,6 @@ export class TerminalManager {
                 const data = JSON.parse(message.toString());
                 switch (data.type) {
                     case 'input':
-                        // Log input if logging is enabled
-                        if (session.enableLogging && session.logFilePath) {
-                            try {
-                                const timestamp = new Date().toISOString();
-                                const logEntry = `[${timestamp}] INPUT: ${data.data}`;
-                                fs.appendFileSync(session.logFilePath, logEntry);
-                            }
-                            catch (error) {
-                                console.error('Error writing input to session log:', error);
-                            }
-                        }
                         session.pty.write(data.data);
                         session.lastActivity = new Date();
                         break;

package/dist/routes/api/v1/ai/route.js

@@ -7,7 +7,7 @@ import { ZodError } from 'zod';
 import { streamText, tool, jsonSchema, stepCountIs } from 'ai';
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { getLogsDir, listProposals, getProposal, createProposal, updateProposal, deleteProposal, } from '@lovelybunch/core';
-import { proposalsFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool, roleContextTool } from '@lovelybunch/mcp';
+import { proposalsFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool, roleContextTool, resourcesTool } from '@lovelybunch/mcp';
 import matter from 'gray-matter';
 import Fuse from 'fuse.js';
 import { FileStorageAdapter } from '../../../../lib/storage/file-storage.js';
@@ -144,6 +144,14 @@ export async function POST(c) {
                     return JSON.stringify(result);
                 },
             }),
+            resources: tool({
+                description: resourcesTool.description,
+                inputSchema: jsonSchema(resourcesTool.parameters),
+                execute: async (args) => {
+                    const result = await executeResourcesToolDirect(args);
+                    return JSON.stringify(result);
+                },
+            }),
         };
         // Debug logging
         console.log('AI Request Debug:', {
@@ -817,6 +825,319 @@ async function executeRoleContextToolDirect(args) {
         return { success: false, error: error.message || 'Role context tool execution failed' };
     }
 }
+// ─── Resources Tool ─────────────────────────────────────────────────────────
+// Uses internal HTTP calls to the same server's resource endpoints so that all
+// existing validation, thumbnail generation, and error handling is reused.
+function getInternalApiBase() {
+    const port = process.env.PORT ? parseInt(process.env.PORT) : 3001;
+    return `http://127.0.0.1:${port}`;
+}
+async function executeResourcesToolDirect(args) {
+    const { operation, query, type_filter, resource_id, prompt, model, aspect_ratio, text, voice, duration, resolution, url, tags, description } = args;
+    const apiBase = getInternalApiBase();
+    try {
+        switch (operation) {
+            case 'list': {
+                const response = await fetch(`${apiBase}/api/v1/resources`);
+                const result = await response.json();
+                if (!result.success || !result.data) {
+                    return { success: false, error: 'Failed to list resources' };
+                }
+                let resources = result.data;
+                // Apply type filter
+                if (type_filter) {
+                    const prefix = type_filter.toLowerCase();
+                    resources = resources.filter((r) => r.type?.toLowerCase().startsWith(prefix));
+                }
+                // Apply search filter
+                if (query) {
+                    const q = query.toLowerCase();
+                    resources = resources.filter((r) => r.name?.toLowerCase().includes(q) ||
+                        r.metadata?.description?.toLowerCase().includes(q) ||
+                        r.metadata?.tags?.some((tag) => tag.toLowerCase().includes(q)));
+                }
+                // Return a concise summary to keep token usage reasonable
+                const summary = resources.map((r) => ({
+                    id: r.id,
+                    name: r.name,
+                    type: r.type,
+                    size: r.size,
+                    tags: r.metadata?.tags,
+                    description: r.metadata?.description
+                        ? (r.metadata.description.length > 100
+                            ? r.metadata.description.slice(0, 100) + '...'
+                            : r.metadata.description)
+                        : undefined,
+                }));
+                return {
+                    success: true,
+                    data: summary,
+                    count: summary.length,
+                    message: query
+                        ? `Found ${summary.length} resources matching "${query}"`
+                        : `Found ${summary.length} resources`
+                };
+            }
+            case 'get': {
+                if (!resource_id) {
+                    return { success: false, error: 'resource_id is required for get operation' };
+                }
+                const response = await fetch(`${apiBase}/api/v1/resources`);
+                const result = await response.json();
+                if (!result.success || !result.data) {
+                    return { success: false, error: 'Failed to fetch resources' };
+                }
+                const resource = result.data.find((r) => r.id === resource_id);
+                if (!resource) {
+                    return { success: false, error: `Resource '${resource_id}' not found` };
+                }
+                return {
+                    success: true,
+                    data: resource,
+                    message: `Retrieved resource ${resource.name} (${resource.id})`
+                };
+            }
+            case 'generate_image': {
+                if (!prompt) {
+                    return { success: false, error: 'prompt is required for generate_image operation' };
+                }
+                // Step 1: Generate the image via Replicate
+                const genBody = {
+                    prompt,
+                    model: model || 'nano-banana-pro',
+                    dimensions: aspect_ratio || '16:9',
+                    output_format: 'png',
+                };
+                const genResponse = await fetch(`${apiBase}/api/v1/resources/generate`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(genBody),
+                    signal: AbortSignal.timeout(300_000), // 5 min
+                });
+                const genResult = await genResponse.json();
+                if (!genResult.success || !genResult.data?.imageUrl) {
+                    const msg = genResult.error?.message || 'Image generation failed';
+                    return { success: false, error: msg };
+                }
+                // Step 2: Download and save to resources
+                const saved = await downloadAndSaveToResources(genResult.data.imageUrl, apiBase, { type: 'image', prompt, model: model || 'nano-banana-pro', tags, description });
+                return {
+                    success: true,
+                    data: saved,
+                    message: `Generated and saved image "${saved.name}" (${saved.id}). It is now available in the Resources section.`
+                };
+            }
+            case 'generate_audio': {
+                if (!text) {
+                    return { success: false, error: 'text is required for generate_audio operation' };
+                }
+                const audioBody = {
+                    text,
+                    voice_id: voice || 'English_Trustworth_Man',
+                    speed: 1,
+                    pitch: 0,
+                    emotion: 'auto',
+                    language_boost: 'English',
+                    audio_format: 'mp3',
+                };
+                const audioResponse = await fetch(`${apiBase}/api/v1/resources/generate-audio`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(audioBody),
+                    signal: AbortSignal.timeout(300_000),
+                });
+                const audioResult = await audioResponse.json();
+                if (!audioResult.success || !audioResult.data?.audioUrl) {
+                    const msg = audioResult.error?.message || 'Audio generation failed';
+                    return { success: false, error: msg };
+                }
+                const savedAudio = await downloadAndSaveToResources(audioResult.data.audioUrl, apiBase, { type: 'audio', prompt: text, model: 'minimax/speech-02-turbo', tags, description });
+                return {
+                    success: true,
+                    data: savedAudio,
+                    message: `Generated and saved audio "${savedAudio.name}" (${savedAudio.id}). It is now available in the Resources section.`
+                };
+            }
+            case 'generate_video': {
+                if (!prompt) {
+                    return { success: false, error: 'prompt is required for generate_video operation' };
+                }
+                const videoBody = {
+                    prompt,
+                    duration: duration || 8,
+                    resolution: resolution || '720p',
+                    aspect_ratio: aspect_ratio || '16:9',
+                    generate_audio: true,
+                };
+                const videoResponse = await fetch(`${apiBase}/api/v1/resources/generate-video`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(videoBody),
+                    signal: AbortSignal.timeout(300_000),
+                });
+                const videoResult = await videoResponse.json();
+                if (!videoResult.success || !videoResult.data?.videoUrl) {
+                    const msg = videoResult.error?.message || 'Video generation failed';
+                    return { success: false, error: msg };
+                }
+                const savedVideo = await downloadAndSaveToResources(videoResult.data.videoUrl, apiBase, { type: 'video', prompt, model: 'google/veo-3.1-fast', tags, description });
+                return {
+                    success: true,
+                    data: savedVideo,
+                    message: `Generated and saved video "${savedVideo.name}" (${savedVideo.id}). It is now available in the Resources section.`
+                };
+            }
+            case 'add_from_url': {
+                if (!url) {
+                    return { success: false, error: 'url is required for add_from_url operation' };
+                }
+                // Download the URL
+                const dlResponse = await fetch(url);
+                if (!dlResponse.ok) {
+                    return { success: false, error: `Failed to download URL: ${dlResponse.statusText}` };
+                }
+                const buffer = Buffer.from(await dlResponse.arrayBuffer());
+                const contentType = dlResponse.headers.get('content-type') || 'application/octet-stream';
+                // Derive filename from URL path
+                let fileName;
+                try {
+                    const urlPath = new URL(url).pathname;
+                    fileName = basename(urlPath);
+                    if (!fileName || fileName === '/') {
+                        fileName = `downloaded-${Date.now()}`;
+                    }
+                }
+                catch {
+                    fileName = `downloaded-${Date.now()}`;
+                }
+                // Add extension from content-type if missing
+                if (!fileName.includes('.')) {
+                    const extMap = {
+                        'image/png': '.png', 'image/jpeg': '.jpg', 'image/webp': '.webp',
+                        'image/gif': '.gif', 'image/svg+xml': '.svg',
+                        'audio/mpeg': '.mp3', 'audio/wav': '.wav', 'audio/ogg': '.ogg',
+                        'video/mp4': '.mp4', 'video/webm': '.webm',
+                        'application/pdf': '.pdf', 'application/json': '.json',
+                    };
+                    const ext = Object.entries(extMap).find(([ct]) => contentType.includes(ct))?.[1] || '.bin';
+                    fileName += ext;
+                }
+                const mimeType = contentType.split(';')[0].trim();
+                // Upload to resources via FormData
+                const formData = new FormData();
+                const blob = new Blob([buffer], { type: mimeType });
+                formData.set('file', blob, fileName);
+                if (tags)
+                    formData.set('tags', tags);
+                if (description)
+                    formData.set('description', description);
+                const uploadResponse = await fetch(`${apiBase}/api/v1/resources`, {
+                    method: 'POST',
+                    body: formData,
+                });
+                const uploadResult = await uploadResponse.json();
+                if (!uploadResult.success || !uploadResult.data) {
+                    return { success: false, error: uploadResult.error?.message || 'Upload failed' };
+                }
+                return {
+                    success: true,
+                    data: uploadResult.data,
+                    message: `Downloaded and saved "${uploadResult.data.name}" (${uploadResult.data.id}) from URL. It is now available in the Resources section.`
+                };
+            }
+            default:
+                return {
+                    success: false,
+                    error: `Unknown operation: ${operation}. Supported: list, get, generate_image, generate_audio, generate_video, add_from_url`
+                };
+        }
+    }
+    catch (error) {
+        console.error('Error executing resources tool:', error);
+        return { success: false, error: error.message || 'Resources tool execution failed' };
+    }
+}
+/**
+ * Download media from a URL and upload it to the resources API.
+ * Used by generation operations to auto-save generated content.
+ */
+async function downloadAndSaveToResources(mediaUrl, apiBase, meta) {
+    const response = await fetch(mediaUrl);
+    if (!response.ok) {
+        throw new Error(`Failed to download generated ${meta.type}`);
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const contentType = response.headers.get('content-type') || '';
+    // Determine extension from content-type
+    let extension = 'bin';
+    let mimeType = contentType.split(';')[0].trim();
+    if (meta.type === 'image') {
+        if (contentType.includes('png'))
+            extension = 'png';
+        else if (contentType.includes('jpeg') || contentType.includes('jpg'))
+            extension = 'jpg';
+        else if (contentType.includes('webp'))
+            extension = 'webp';
+        else
+            extension = 'png';
+        mimeType = mimeType || `image/${extension}`;
+    }
+    else if (meta.type === 'audio') {
+        if (contentType.includes('mp3') || contentType.includes('mpeg'))
+            extension = 'mp3';
+        else if (contentType.includes('wav'))
+            extension = 'wav';
+        else if (contentType.includes('ogg'))
+            extension = 'ogg';
+        else
+            extension = 'mp3';
+        mimeType = mimeType || `audio/${extension}`;
+    }
+    else if (meta.type === 'video') {
+        if (contentType.includes('mp4'))
+            extension = 'mp4';
+        else if (contentType.includes('webm'))
+            extension = 'webm';
+        else
+            extension = 'mp4';
+        mimeType = mimeType || `video/${extension}`;
+    }
+    const fileName = `generated-${meta.type}-${Date.now()}.${extension}`;
+    // Upload via FormData to the resources endpoint (triggers thumbnail generation, etc.)
+    const formData = new FormData();
+    const blob = new Blob([buffer], { type: mimeType });
+    formData.set('file', blob, fileName);
+    // Build description with generation metadata
+    const descParts = [];
+    if (meta.description)
+        descParts.push(meta.description);
+    if (meta.prompt)
+        descParts.push(`Generated with: "${meta.prompt}"`);
+    if (meta.model)
+        descParts.push(`Model: ${meta.model}`);
+    const fullDesc = descParts.join(' | ');
+    if (fullDesc)
+        formData.set('description', fullDesc);
+    // Build tags
+    const tagParts = [];
+    if (meta.tags)
+        tagParts.push(meta.tags);
+    tagParts.push('ai-generated', meta.type);
+    formData.set('tags', tagParts.join(', '));
+    if (meta.prompt)
+        formData.set('generationPrompt', meta.prompt);
+    if (meta.model)
+        formData.set('generationModel', meta.model);
+    const uploadResponse = await fetch(`${apiBase}/api/v1/resources`, {
+        method: 'POST',
+        body: formData,
+    });
+    const result = await uploadResponse.json();
+    if (!result.success || !result.data) {
+        throw new Error('Failed to save generated media to resources');
+    }
+    return result.data;
+}
 // ─── Helper Functions ────────────────────────────────────────────────────────
 function getContextBasePath() {
     let basePath;
@@ -842,7 +1163,7 @@ function getKnowledgeBasePath() {
     else {
         basePath = pathResolve(process.cwd(), '.nut');
     }
-    return join(basePath, 'context', 'knowledge');
+    return join(basePath, 'knowledge');
 }
 function slugify(value) {
     const slug = value

package/dist/routes/api/v1/chats/[id]/index.js

@@ -1,6 +1,7 @@
 import { Hono } from 'hono';
-import { GET, DELETE } from './route.js';
+import { GET, PUT, DELETE } from './route.js';
 const app = new Hono();
 app.get('/', GET);
+app.put('/', PUT);
 app.delete('/', DELETE);
 export default app;

package/dist/routes/api/v1/chats/[id]/route.d.ts

@@ -4,6 +4,13 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     error: string;
 }, 404, "json">)>;
+export declare function PUT(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+    chatId: string;
+    message: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;
 export declare function DELETE(c: Context): Promise<(Response & import("hono").TypedResponse<{
     success: true;
     message: string;

package/dist/routes/api/v1/chats/[id]/route.js

@@ -1,4 +1,4 @@
-import { readFile, unlink } from "fs/promises";
+import { readFile, writeFile, unlink } from "fs/promises";
 import { join, resolve } from "path";
 function getChatsPath() {
     let basePath;
@@ -30,6 +30,35 @@ export async function GET(c) {
         return c.json({ error: "Chat not found" }, 404);
     }
 }
+export async function PUT(c) {
+    try {
+        const id = c.req.param('id');
+        const filePath = join(CHATS_DIR, `${id}.json`);
+        // Read existing chat
+        const existing = JSON.parse(await readFile(filePath, 'utf8'));
+        const body = await c.req.json();
+        const { messages, model, context, title } = body;
+        const now = new Date().toISOString();
+        const updated = {
+            ...existing,
+            messages: messages ?? existing.messages,
+            model: model ?? existing.model,
+            context: context ?? existing.context,
+            title: title ?? existing.title,
+            updatedAt: now,
+        };
+        await writeFile(filePath, JSON.stringify(updated, null, 2));
+        return c.json({
+            success: true,
+            chatId: id,
+            message: "Chat updated successfully"
+        });
+    }
+    catch (error) {
+        console.error("Error updating chat:", error);
+        return c.json({ error: "Failed to update chat" }, 500);
+    }
+}
 export async function DELETE(c) {
     try {
         const id = c.req.param('id');

package/dist/routes/api/v1/context/index.js

@@ -2,12 +2,10 @@ import { Hono } from 'hono';
 import project from './project/route.js';
 import architecture from './architecture/route.js';
 import role from './role/route.js';
-import knowledge from './knowledge/index.js';
 import images from './images/index.js';
 const context = new Hono();
 context.route('/project', project);
 context.route('/architecture', architecture);
 context.route('/role', role);
-context.route('/knowledge', knowledge);
 context.route('/images', images);
 export default context;

package/dist/routes/api/v1/knowledge/[filename]/index.d.ts

@@ -0,0 +1 @@
+export { default } from './route.js';

package/dist/routes/api/v1/knowledge/[filename]/index.js

@@ -0,0 +1 @@
+export { default } from './route.js';

package/dist/routes/api/v1/knowledge/[filename]/route.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default app;