@lovelybunch/api 1.0.69-alpha.12 → 1.0.69-alpha.15

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

@@ -0,0 +1,205 @@
+import Replicate from 'replicate';
+import { promises as fs } from 'fs';
+import path from 'path';
+const REPLICATE_API_TOKEN = 'r8_6IsX89og0JuK6Ay8RXADjp8RjnEOpfK3BpNXu';
+const replicate = new Replicate({
+    auth: REPLICATE_API_TOKEN,
+});
+function getResourcesPath() {
+    let basePath;
+    if (process.env.NODE_ENV === 'development' && process.env.GAIT_DEV_ROOT) {
+        basePath = process.env.GAIT_DEV_ROOT;
+    }
+    else if (process.env.GAIT_DATA_PATH) {
+        basePath = path.resolve(process.env.GAIT_DATA_PATH, '.nut');
+    }
+    else {
+        basePath = path.resolve(process.cwd(), '.nut');
+    }
+    return path.join(basePath, 'resources');
+}
+const RESOURCES_DIR = getResourcesPath();
+const FILES_DIR = path.join(RESOURCES_DIR, 'files');
+const METADATA_DIR = path.join(RESOURCES_DIR, 'metadata');
+const THUMBNAILS_DIR = path.join(RESOURCES_DIR, 'thumbnails');
+async function getResourceMetadata(id) {
+    try {
+        const metadataPath = path.join(METADATA_DIR, `${id}.json`);
+        const content = await fs.readFile(metadataPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+function extractResourceId(imageRef) {
+    if (typeof imageRef !== 'string')
+        return null;
+    // Allow direct resource IDs or URLs containing the ID
+    const directMatch = imageRef.match(/^(res-[A-Za-z0-9-]+)/);
+    if (directMatch && directMatch[1]) {
+        return directMatch[1];
+    }
+    const urlMatch = imageRef.match(/\/resources\/([^/?]+)/);
+    if (urlMatch && urlMatch[1]) {
+        return urlMatch[1];
+    }
+    return null;
+}
+// Map dimensions to aspect ratios
+function getAspectRatio(dimensions) {
+    if (!dimensions)
+        return '1:1';
+    // Legacy support for previous values
+    const legacyMapping = {
+        '1x1': '1:1',
+        '3x2': '3:2',
+        '2x3': '2:3',
+        '6x9': '2:3',
+    };
+    if (legacyMapping[dimensions]) {
+        return legacyMapping[dimensions];
+    }
+    if (dimensions === 'match_input_image') {
+        return null;
+    }
+    return dimensions;
+}
+export async function POST(c) {
+    try {
+        const body = await c.req.json();
+        const { prompt, inspiration, dimensions, resolution, model, image_input } = body;
+        if (!prompt) {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'MISSING_PROMPT',
+                    message: 'Prompt is required'
+                }
+            }, 400);
+        }
+        // Build the full prompt with inspiration if provided
+        let fullPrompt = prompt;
+        if (inspiration) {
+            fullPrompt = `${inspiration}: ${prompt}`;
+        }
+        // Get aspect ratio from dimensions
+        const mappedAspectRatio = getAspectRatio(dimensions || '4:3');
+        // Process image_input: upload files to Replicate and get URLs
+        // image_input can contain resource IDs or URLs (or be empty if none selected)
+        const imageInputArray = [];
+        const imageInputs = Array.isArray(image_input)
+            ? image_input
+            : typeof image_input === 'string' && image_input
+                ? [image_input]
+                : [];
+        for (const imageRef of imageInputs) {
+            try {
+                const resourceId = extractResourceId(imageRef);
+                if (!resourceId) {
+                    console.warn(`Unable to resolve resource id from image reference: ${imageRef}`);
+                    continue;
+                }
+                const resource = await getResourceMetadata(resourceId);
+                if (!resource) {
+                    console.warn(`Resource metadata not found for id ${resourceId}`);
+                    continue;
+                }
+                const candidatePaths = [];
+                if (resource.path) {
+                    candidatePaths.push(path.join(FILES_DIR, resource.path));
+                }
+                if (resource.thumbnailPath) {
+                    candidatePaths.push(path.join(THUMBNAILS_DIR, resource.thumbnailPath));
+                }
+                let filePath = null;
+                for (const candidate of candidatePaths) {
+                    try {
+                        await fs.access(candidate);
+                        filePath = candidate;
+                        break;
+                    }
+                    catch {
+                        // Try next candidate
+                    }
+                }
+                if (!filePath) {
+                    console.warn(`No accessible file found for resource ${resourceId}`);
+                    continue;
+                }
+                const fileBuffer = await fs.readFile(filePath);
+                const uploadedFile = await replicate.files.create(fileBuffer, {
+                    resourceId,
+                    originalName: resource.name,
+                });
+                const fileUrl = uploadedFile?.urls?.get;
+                if (fileUrl) {
+                    imageInputArray.push(fileUrl);
+                }
+                else {
+                    console.warn(`Replicate file upload did not return a URL for resource ${resourceId}`);
+                }
+            }
+            catch (error) {
+                console.error(`Error processing image input ${imageRef}:`, error);
+            }
+        }
+        const input = {
+            prompt: fullPrompt,
+            resolution: resolution || '1K',
+            output_format: 'png',
+            safety_filter_level: 'block_only_high'
+        };
+        if (mappedAspectRatio) {
+            input.aspect_ratio = mappedAspectRatio;
+        }
+        if (imageInputArray.length > 0) {
+            input.image_input = imageInputArray;
+        }
+        // Run the model (defaulting to nano-banana-pro)
+        const modelId = model === 'Nano Banana Pro' ? 'google/nano-banana-pro' : 'google/nano-banana-pro';
+        const output = await replicate.run(modelId, { input });
+        // Extract URL from output
+        // Replicate output can be: string URL, array of URLs, or FileOutput object with url() method
+        let imageUrl;
+        if (typeof output === 'string') {
+            imageUrl = output;
+        }
+        else if (Array.isArray(output) && output.length > 0) {
+            imageUrl = output[0];
+        }
+        else if (output && typeof output === 'object') {
+            // Check for url() method (FileOutput object)
+            if (typeof output.url === 'function') {
+                imageUrl = output.url();
+            }
+            else if ('url' in output) {
+                imageUrl = output.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: {
+                imageUrl
+            }
+        });
+    }
+    catch (error) {
+        console.error('Error generating image:', error);
+        return c.json({
+            success: false,
+            error: {
+                code: 'GENERATION_ERROR',
+                message: error.message || 'Failed to generate image'
+            }
+        }, 500);
+    }
+}

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

@@ -1,6 +1,8 @@
 import { Hono } from 'hono';
 import { GET, POST } from './route.js';
+import generate from './generate/index.js';
 const app = new Hono();
 app.get('/', GET);
 app.post('/', POST);
+app.route('/generate', generate);
 export default app;

package/dist/routes/api/v1/version/index.d.ts

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

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

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

package/dist/routes/api/v1/version/route.d.ts

@@ -0,0 +1,32 @@
+import { Context } from 'hono';
+/**
+ * GET /api/v1/version
+ * Returns the current version of Coconut from the root package.json
+ * Requires authentication
+ */
+export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        version: any;
+        name: any;
+        description: any;
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 401, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: string;
+    };
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;

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

@@ -0,0 +1,61 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { requireAuth } from '../../../../middleware/auth.js';
+/**
+ * GET /api/v1/version
+ * Returns the current version of Coconut from the root package.json
+ * Requires authentication
+ */
+export async function GET(c) {
+    try {
+        // Require authentication
+        requireAuth(c);
+        // Find the root package.json
+        // Get the directory of this file
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        // Navigate up to the root: route.ts -> version -> v1 -> api -> routes -> src -> api -> packages -> root
+        const rootDir = path.resolve(__dirname, '..', '..', '..', '..', '..', '..');
+        const packageJsonPath = path.join(rootDir, 'package.json');
+        // Read package.json
+        const content = await fs.readFile(packageJsonPath, 'utf-8');
+        const packageJson = JSON.parse(content);
+        return c.json({
+            success: true,
+            data: {
+                version: packageJson.version,
+                name: packageJson.name,
+                description: packageJson.description
+            }
+        });
+    }
+    catch (error) {
+        console.error('Error reading version:', error);
+        if (error.message === 'Authentication required' || error.message === 'Admin access required') {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'UNAUTHORIZED',
+                    message: error.message
+                }
+            }, 401);
+        }
+        if (error.code === 'ENOENT') {
+            return c.json({
+                success: false,
+                error: {
+                    code: 'VERSION_NOT_FOUND',
+                    message: 'Could not find package.json'
+                }
+            }, 404);
+        }
+        return c.json({
+            success: false,
+            error: {
+                code: 'VERSION_ERROR',
+                message: error.message
+            }
+        }, 500);
+    }
+}

package/dist/server-with-static.js

@@ -163,6 +163,7 @@ import git from './routes/api/v1/git/index.js';
 import mcp from './routes/api/v1/mcp/index.js';
 import jobs from './routes/api/v1/jobs/index.js';
 import events from './routes/api/v1/events/index.js';
+import version from './routes/api/v1/version/index.js';
 // Register API routes FIRST
 console.log('🔗 Registering API routes...');
 app.route('/api/v1/auth', auth);
@@ -189,6 +190,7 @@ app.route('/api/v1/git', git);
 app.route('/api/v1/mcp', mcp);
 app.route('/api/v1/jobs', jobs);
 app.route('/api/v1/events', events);
+app.route('/api/v1/version', version);
 console.log('✅ API routes registered');
 app.get(PUBLIC_AGENT_CARD_PATH, authMiddleware, async (c) => {
     try {

package/dist/server.js

@@ -163,6 +163,7 @@ import mcp from './routes/api/v1/mcp/index.js';
 import symlinks from './routes/api/v1/symlinks/index.js';
 import jobs from './routes/api/v1/jobs/index.js';
 import events from './routes/api/v1/events/index.js';
+import version from './routes/api/v1/version/index.js';
 // Register API routes
 app.route('/api/v1/auth', auth);
 app.route('/api/v1/auth-settings', authSettings);
@@ -189,6 +190,7 @@ app.route('/api/v1/mcp', mcp);
 app.route('/api/v1/symlinks', symlinks);
 app.route('/api/v1/jobs', jobs);
 app.route('/api/v1/events', events);
+app.route('/api/v1/version', version);
 app.get(PUBLIC_AGENT_CARD_PATH, authMiddleware, async (c) => {
     try {
         const document = await readAgentCard();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovelybunch/api",
-  "version": "1.0.69-alpha.12",
+  "version": "1.0.69-alpha.15",
   "type": "module",
   "main": "dist/server-with-static.js",
   "exports": {
@@ -36,9 +36,9 @@
   "dependencies": {
     "@hono/node-server": "^1.13.7",
     "@hono/node-ws": "^1.0.6",
-    "@lovelybunch/core": "^1.0.69-alpha.12",
-    "@lovelybunch/mcp": "^1.0.69-alpha.12",
-    "@lovelybunch/types": "^1.0.69-alpha.12",
+    "@lovelybunch/core": "^1.0.69-alpha.15",
+    "@lovelybunch/mcp": "^1.0.69-alpha.15",
+    "@lovelybunch/types": "^1.0.69-alpha.15",
     "arctic": "^1.9.2",
     "bcrypt": "^5.1.1",
     "cookie": "^0.6.0",
@@ -48,6 +48,7 @@
     "hono": "^4.9.5",
     "jsonwebtoken": "^9.0.2",
     "node-pty": "^1.0.0",
+    "replicate": "^0.34.1",
     "ws": "^8.18.0"
   },
   "devDependencies": {