@lovelybunch/api 1.0.71-alpha.4 → 1.0.71-alpha.6

package/dist/routes/api/v1/context/images/index.d.ts

@@ -0,0 +1,2 @@
+import images from './route.js';
+export default images;

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

@@ -0,0 +1,2 @@
+import images from './route.js';
+export default images;

package/dist/routes/api/v1/context/images/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;

package/dist/routes/api/v1/context/images/route.js

@@ -0,0 +1,253 @@
+import { Hono } from 'hono';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { getLogger } from '@lovelybunch/core/logging';
+import { requireAuth } from '../../../../../middleware/auth.js';
+const app = new Hono();
+// Supported image MIME types
+const IMAGE_MIME_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.bmp': 'image/bmp',
+};
+const ALLOWED_EXTENSIONS = Object.keys(IMAGE_MIME_TYPES);
+function getImagesPath() {
+    let basePath;
+    if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
+        // Dev mode: use project root .nut directory
+        basePath = process.env.GAIT_DEV_ROOT;
+    }
+    else if (process.env.GAIT_DATA_PATH) {
+        // Production mode: use GAIT_DATA_PATH (set by CLI)
+        basePath = path.resolve(process.env.GAIT_DATA_PATH, '.nut');
+    }
+    else {
+        // Fallback: use current directory .nut
+        basePath = path.resolve(process.cwd(), '.nut');
+    }
+    return path.join(basePath, 'context', 'images');
+}
+function getMimeType(filename) {
+    const ext = path.extname(filename).toLowerCase();
+    return IMAGE_MIME_TYPES[ext] || null;
+}
+function isValidImageFilename(filename) {
+    const ext = path.extname(filename).toLowerCase();
+    return ALLOWED_EXTENSIONS.includes(ext);
+}
+function sanitizeFilename(filename) {
+    // Remove path traversal attempts and invalid characters
+    return filename
+        .replace(/\.\./g, '')
+        .replace(/[/\\]/g, '')
+        .replace(/[^a-zA-Z0-9._-]/g, '-');
+}
+/**
+ * GET /api/v1/context/images
+ * List all images
+ */
+app.get('/', async (c) => {
+    try {
+        const imagesPath = getImagesPath();
+        // Ensure directory exists
+        await fs.mkdir(imagesPath, { recursive: true });
+        const files = await fs.readdir(imagesPath);
+        const images = await Promise.all(files
+            .filter(file => isValidImageFilename(file))
+            .map(async (file) => {
+            try {
+                const filePath = path.join(imagesPath, file);
+                const stats = await fs.stat(filePath);
+                const mimeType = getMimeType(file);
+                if (!mimeType)
+                    return null;
+                return {
+                    filename: file,
+                    size: stats.size,
+                    mimeType,
+                    uploadedAt: stats.mtime.toISOString(),
+                };
+            }
+            catch {
+                return null;
+            }
+        }));
+        const validImages = images.filter((img) => img !== null);
+        return c.json({
+            success: true,
+            images: validImages.sort((a, b) => a.filename.localeCompare(b.filename))
+        });
+    }
+    catch (error) {
+        console.error('Error listing images:', error);
+        return c.json({ success: false, error: 'Failed to list images' }, 500);
+    }
+});
+/**
+ * GET /api/v1/context/images/:filename
+ * Serve a specific image
+ */
+app.get('/:filename', async (c) => {
+    try {
+        const filename = c.req.param('filename');
+        const imagesPath = getImagesPath();
+        // Sanitize filename to prevent path traversal
+        const safeFilename = sanitizeFilename(filename);
+        if (!isValidImageFilename(safeFilename)) {
+            return c.json({ success: false, error: 'Invalid image file type' }, 400);
+        }
+        const filePath = path.join(imagesPath, safeFilename);
+        const mimeType = getMimeType(safeFilename);
+        if (!mimeType) {
+            return c.json({ success: false, error: 'Unsupported image format' }, 400);
+        }
+        try {
+            const fileBuffer = await fs.readFile(filePath);
+            const stats = await fs.stat(filePath);
+            return new Response(fileBuffer, {
+                headers: {
+                    'Content-Type': mimeType,
+                    'Content-Length': stats.size.toString(),
+                    'Cache-Control': 'public, max-age=31536000',
+                }
+            });
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return c.json({ success: false, error: 'Image not found' }, 404);
+            }
+            throw error;
+        }
+    }
+    catch (error) {
+        console.error('Error serving image:', error);
+        return c.json({ success: false, error: 'Failed to serve image' }, 500);
+    }
+});
+/**
+ * POST /api/v1/context/images
+ * Upload a new image (multipart/form-data)
+ */
+app.post('/', async (c) => {
+    try {
+        const imagesPath = getImagesPath();
+        // Ensure directory exists
+        await fs.mkdir(imagesPath, { recursive: true });
+        // Parse multipart form data
+        const formData = await c.req.formData();
+        const file = formData.get('file');
+        if (!file || !(file instanceof File)) {
+            return c.json({ success: false, error: 'No file provided. Use multipart/form-data with a "file" field.' }, 400);
+        }
+        // Get filename from form data or use original
+        let filename = formData.get('filename')?.toString() || file.name;
+        filename = sanitizeFilename(filename);
+        if (!isValidImageFilename(filename)) {
+            return c.json({ success: false, error: `Invalid file type. Supported types: ${ALLOWED_EXTENSIONS.join(', ')}` }, 400);
+        }
+        const filePath = path.join(imagesPath, filename);
+        // Check if file already exists
+        try {
+            await fs.access(filePath);
+            return c.json({ success: false, error: 'An image with this filename already exists' }, 409);
+        }
+        catch {
+            // File doesn't exist, which is what we want
+        }
+        // Write file
+        const arrayBuffer = await file.arrayBuffer();
+        await fs.writeFile(filePath, Buffer.from(arrayBuffer));
+        const stats = await fs.stat(filePath);
+        const mimeType = getMimeType(filename);
+        // Log image upload event
+        try {
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : 'human:unknown';
+            const logger = getLogger();
+            logger.log({
+                kind: 'image.upload',
+                actor,
+                subject: `image:${filename}`,
+                tags: ['image', 'upload'],
+                payload: {
+                    filename,
+                    size: stats.size,
+                    mimeType,
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging image upload:', logError);
+        }
+        return c.json({
+            success: true,
+            image: {
+                filename,
+                size: stats.size,
+                mimeType,
+                uploadedAt: stats.mtime.toISOString(),
+            }
+        }, 201);
+    }
+    catch (error) {
+        console.error('Error uploading image:', error);
+        return c.json({ success: false, error: 'Failed to upload image' }, 500);
+    }
+});
+/**
+ * DELETE /api/v1/context/images/:filename
+ * Delete an image
+ */
+app.delete('/:filename', async (c) => {
+    try {
+        const filename = c.req.param('filename');
+        const imagesPath = getImagesPath();
+        // Sanitize filename to prevent path traversal
+        const safeFilename = sanitizeFilename(filename);
+        if (!isValidImageFilename(safeFilename)) {
+            return c.json({ success: false, error: 'Invalid image file type' }, 400);
+        }
+        const filePath = path.join(imagesPath, safeFilename);
+        // Check if file exists
+        try {
+            await fs.access(filePath);
+        }
+        catch {
+            return c.json({ success: false, error: 'Image not found' }, 404);
+        }
+        // Delete the file
+        await fs.unlink(filePath);
+        // Log image deletion event
+        try {
+            const session = await requireAuth(c);
+            const actor = session ? `human:${session.email}` : 'human:unknown';
+            const logger = getLogger();
+            logger.log({
+                kind: 'image.delete',
+                actor,
+                subject: `image:${safeFilename}`,
+                tags: ['image', 'delete'],
+                payload: {
+                    filename: safeFilename,
+                }
+            });
+        }
+        catch (logError) {
+            console.error('Error logging image deletion:', logError);
+        }
+        return c.json({
+            success: true,
+            message: 'Image deleted successfully'
+        });
+    }
+    catch (error) {
+        console.error('Error deleting image:', error);
+        return c.json({ success: false, error: 'Failed to delete image' }, 500);
+    }
+});
+export default app;

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

@@ -2,8 +2,10 @@ import { Hono } from 'hono';
 import project from './project/route.js';
 import architecture from './architecture/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('/knowledge', knowledge);
+context.route('/images', images);
 export default context;

package/dist/routes/api/v1/resources/generate-audio/index.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;

package/dist/routes/api/v1/resources/generate-audio/index.js

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import { POST } from './route.js';
+const app = new Hono();
+app.post('/', POST);
+export default app;

package/dist/routes/api/v1/resources/generate-audio/route.d.ts

@@ -0,0 +1,19 @@
+import { Context } from 'hono';
+export declare function POST(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: string;
+    };
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        audioUrl: string;
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: string;
+    };
+}, 500, "json">)>;

package/dist/routes/api/v1/resources/generate-audio/route.js

@@ -0,0 +1,129 @@
+import Replicate from 'replicate';
+import path from 'path';
+import { homedir } from 'os';
+import { existsSync, readFileSync } from 'fs';
+/**
+ * Get Replicate API token from global config or environment variable
+ */
+function getReplicateApiToken() {
+    // First try global config
+    try {
+        const platform = process.platform;
+        let configDir;
+        if (platform === 'win32') {
+            configDir = path.join(process.env.APPDATA || homedir(), 'coconuts');
+        }
+        else if (platform === 'darwin') {
+            configDir = path.join(homedir(), 'Library', 'Application Support', 'coconuts');
+        }
+        else {
+            configDir = path.join(process.env.XDG_CONFIG_HOME || path.join(homedir(), '.config'), 'coconuts');
+        }
+        const configPath = path.join(configDir, 'config.json');
+        if (existsSync(configPath)) {
+            const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+            if (config.apiKeys?.replicate) {
+                return config.apiKeys.replicate;
+            }
+        }
+    }
+    catch (error) {
+        console.warn('Failed to load Replicate token from config:', error);
+    }
+    // Fallback to environment variable
+    return process.env.REPLICATE_API_TOKEN || null;
+}
+// Initialize Replicate client lazily to ensure token is loaded at request time
+function getReplicateClient() {
+    const token = getReplicateApiToken();
+    if (!token) {
+        throw new Error('Replicate API token not configured');
+    }
+    return new Replicate({
+        auth: token,
+    });
+}
+export async function POST(c) {
+    try {
+        // Check if Replicate API token is configured
+        const replicateToken = getReplicateApiToken();
+        if (!replicateToken) {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'MISSING_API_TOKEN',
+                    message: 'Replicate API token not configured. Please add it in Settings → Integrations.'
+                }
+            }, 400);
+        }
+        const body = await c.req.json();
+        const { text, voice_id = 'English_Trustworth_Man', speed = 1, pitch = 0, emotion = 'auto', language_boost = 'English', audio_format = 'mp3' } = body;
+        if (!text || !text.trim()) {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'MISSING_TEXT',
+                    message: 'Text is required for audio generation'
+                }
+            }, 400);
+        }
+        // Build input for minimax/speech-02-turbo
+        const input = {
+            text: text.trim(),
+            pitch,
+            speed,
+            volume: 1,
+            bitrate: 128000,
+            channel: 'mono',
+            emotion,
+            voice_id,
+            sample_rate: 32000,
+            audio_format,
+            language_boost,
+            subtitle_enable: false,
+            english_normalization: true
+        };
+        // Run the model
+        const replicateClient = getReplicateClient();
+        const output = await replicateClient.run('minimax/speech-02-turbo', { input });
+        // Extract URL from output
+        // Replicate output can be: FileOutput object with url() method
+        let audioUrl;
+        if (typeof output === 'string') {
+            audioUrl = output;
+        }
+        else if (output && typeof output === 'object') {
+            // Check for url() method (FileOutput object)
+            const outputObj = output;
+            if (typeof outputObj.url === 'function') {
+                audioUrl = outputObj.url();
+            }
+            else if ('url' in outputObj && typeof outputObj.url === 'string') {
+                audioUrl = outputObj.url;
+            }
+            else {
+                throw new Error('Unexpected output format from Replicate');
+            }
+        }
+        else {
+            throw new Error('Unexpected output format from Replicate');
+        }
+        return c.json({
+            success: true,
+            data: {
+                audioUrl
+            }
+        });
+    }
+    catch (error) {
+        console.error('Error generating audio:', error);
+        const message = error instanceof Error ? error.message : 'Failed to generate audio';
+        return c.json({
+            success: false,
+            error: {
+                code: 'GENERATION_ERROR',
+                message
+            }
+        }, 500);
+    }
+}

package/dist/routes/api/v1/resources/generate-video/index.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;

package/dist/routes/api/v1/resources/generate-video/index.js

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import { POST } from './route.js';
+const app = new Hono();
+app.post('/', POST);
+export default app;

package/dist/routes/api/v1/resources/generate-video/route.d.ts

@@ -0,0 +1,19 @@
+import { Context } from 'hono';
+export declare function POST(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: string;
+    };
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        videoUrl: string;
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: string;
+    };
+}, 500, "json">)>;