@lovelybunch/api 1.0.69-alpha.9 → 1.0.70

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

@@ -0,0 +1,257 @@
+import Replicate from 'replicate';
+import { promises as fs } from 'fs';
+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,
+    });
+}
+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 {
+        // 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 { 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 replicateClient = getReplicateClient();
+                const uploadedFile = await replicateClient.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 replicateClient = getReplicateClient();
+        const output = await replicateClient.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,24 @@
+import { Context } from 'hono';
+/**
+ * GET /api/v1/version
+ * Returns the current version of Coconut
+ * Requires authentication
+ */
+export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        version: 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: any;
+    };
+}, 500, "json">)>;

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

@@ -0,0 +1,51 @@
+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
+ * Requires authentication
+ */
+export async function GET(c) {
+    try {
+        // Require authentication
+        requireAuth(c);
+        // Read the API package's own package.json
+        // This works both in dev (from source) and production (from dist)
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        // Navigate up from dist/routes/api/v1/version to the package root
+        // In dev: src/routes/api/v1/version -> ../../../../..
+        // In prod: dist/routes/api/v1/version -> ../../../../..
+        let packageJsonPath = path.resolve(__dirname, '..', '..', '..', '..', '..', '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
+            }
+        });
+    }
+    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);
+        }
+        return c.json({
+            success: false,
+            error: {
+                code: 'VERSION_ERROR',
+                message: error.message || 'Failed to read version'
+            }
+        }, 500);
+    }
+}

package/dist/server-with-static.js

@@ -11,6 +11,7 @@ import { getGlobalTerminalManager } from './lib/terminal/global-manager.js';
 import { getGlobalJobScheduler } from './lib/jobs/global-job-scheduler.js';
 import { fileURLToPath } from 'url';
 import { getLogger } from '@lovelybunch/core/logging';
+import { getLogsDir } from '@lovelybunch/core';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // Load environment variables from .env file in project root
@@ -30,11 +31,15 @@ function findNutDirectorySync() {
     }
     return null;
 }
-// Initialize logger with config from .nut/config.json
+// Initialize logger with config from .nut/config.json or use OS app data directory
 // This must happen BEFORE importing route handlers (they call getLogger at module level)
 console.log('🔍 Initializing activity logging...');
 try {
     const nutDir = findNutDirectorySync();
+    let logsDir = getLogsDir(); // Default to OS app data directory
+    let coconutId = 'unknown.coconut';
+    let rotateBytes = 128 * 1024 * 1024;
+    let loggingEnabled = true; // Default to enabled
     if (nutDir) {
         const projectRoot = path.dirname(nutDir);
         const configPath = path.join(nutDir, 'config.json');
@@ -42,32 +47,42 @@ try {
         console.log('   Config path:', configPath);
         const configData = fs.readFileSync(configPath, 'utf-8');
         const config = JSON.parse(configData);
-        if (config.logging?.enabled) {
-            const logsDir = path.resolve(projectRoot, config.logging?.location || '.nut/logs');
-            const logger = getLogger({
-                coconutId: config.coconut?.id || 'unknown.coconut',
-                logsDir: logsDir,
-                rotateBytes: config.logging?.rotateBytes || 128 * 1024 * 1024
-            });
-            console.log('📝 Activity logging ENABLED');
-            console.log('   Logs directory:', logsDir);
-            console.log('   Coconut ID:', config.coconut?.id || 'unknown.coconut');
-            // Test log immediately
-            logger.log({
-                kind: 'system.startup',
-                actor: 'system',
-                subject: 'server',
-                tags: ['system', 'startup'],
-                payload: { message: 'Server starting with logging enabled' }
-            });
-            console.log('   ✓ Test event logged');
+        // Check if logging is explicitly disabled in config
+        if (config.logging?.enabled === false) {
+            loggingEnabled = false;
         }
-        else {
-            console.log('📝 Activity logging disabled in config');
+        // Allow config to override logs location (relative paths resolve from project root)
+        if (config.logging?.location) {
+            logsDir = path.resolve(projectRoot, config.logging.location);
         }
+        if (config.coconut?.id) {
+            coconutId = config.coconut.id;
+        }
+        if (config.logging?.rotateBytes) {
+            rotateBytes = config.logging.rotateBytes;
+        }
+    }
+    if (loggingEnabled) {
+        const logger = getLogger({
+            coconutId,
+            logsDir,
+            rotateBytes
+        });
+        console.log('📝 Activity logging ENABLED');
+        console.log('   Logs directory:', logsDir);
+        console.log('   Coconut ID:', coconutId);
+        // Test log immediately
+        logger.log({
+            kind: 'system.startup',
+            actor: 'system',
+            subject: 'server',
+            tags: ['system', 'startup'],
+            payload: { message: 'Server starting with logging enabled' }
+        });
+        console.log('   ✓ Test event logged');
     }
     else {
-        console.log('   ✗ .nut directory not found');
+        console.log('📝 Activity logging disabled in config');
     }
 }
 catch (error) {
@@ -163,6 +178,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 +205,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

@@ -10,6 +10,7 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import fs from 'fs';
 import { getLogger } from '@lovelybunch/core/logging';
+import { getLogsDir } from '@lovelybunch/core';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // Load environment variables from .env file in project root
@@ -29,11 +30,15 @@ function findNutDirectorySync() {
     }
     return null;
 }
-// Initialize logger with config from .nut/config.json
+// Initialize logger with config from .nut/config.json or use OS app data directory
 // This must happen BEFORE importing route handlers (they call getLogger at module level)
 console.log('🔍 Initializing activity logging...');
 try {
     const nutDir = findNutDirectorySync();
+    let logsDir = getLogsDir(); // Default to OS app data directory
+    let coconutId = 'unknown.coconut';
+    let rotateBytes = 128 * 1024 * 1024;
+    let loggingEnabled = true; // Default to enabled
     if (nutDir) {
         const projectRoot = path.dirname(nutDir);
         const configPath = path.join(nutDir, 'config.json');
@@ -41,32 +46,42 @@ try {
         console.log('   Config path:', configPath);
         const configData = fs.readFileSync(configPath, 'utf-8');
         const config = JSON.parse(configData);
-        if (config.logging?.enabled) {
-            const logsDir = path.resolve(projectRoot, config.logging?.location || '.nut/logs');
-            const logger = getLogger({
-                coconutId: config.coconut?.id || 'unknown.coconut',
-                logsDir: logsDir,
-                rotateBytes: config.logging?.rotateBytes || 128 * 1024 * 1024
-            });
-            console.log('📝 Activity logging ENABLED');
-            console.log('   Logs directory:', logsDir);
-            console.log('   Coconut ID:', config.coconut?.id || 'unknown.coconut');
-            // Test log immediately
-            logger.log({
-                kind: 'system.startup',
-                actor: 'system',
-                subject: 'server',
-                tags: ['system', 'startup'],
-                payload: { message: 'Server starting with logging enabled' }
-            });
-            console.log('   ✓ Test event logged');
+        // Check if logging is explicitly disabled in config
+        if (config.logging?.enabled === false) {
+            loggingEnabled = false;
         }
-        else {
-            console.log('📝 Activity logging disabled in config');
+        // Allow config to override logs location (relative paths resolve from project root)
+        if (config.logging?.location) {
+            logsDir = path.resolve(projectRoot, config.logging.location);
         }
+        if (config.coconut?.id) {
+            coconutId = config.coconut.id;
+        }
+        if (config.logging?.rotateBytes) {
+            rotateBytes = config.logging.rotateBytes;
+        }
+    }
+    if (loggingEnabled) {
+        const logger = getLogger({
+            coconutId,
+            logsDir,
+            rotateBytes
+        });
+        console.log('📝 Activity logging ENABLED');
+        console.log('   Logs directory:', logsDir);
+        console.log('   Coconut ID:', coconutId);
+        // Test log immediately
+        logger.log({
+            kind: 'system.startup',
+            actor: 'system',
+            subject: 'server',
+            tags: ['system', 'startup'],
+            payload: { message: 'Server starting with logging enabled' }
+        });
+        console.log('   ✓ Test event logged');
     }
     else {
-        console.log('   ✗ .nut directory not found');
+        console.log('📝 Activity logging disabled in config');
     }
 }
 catch (error) {
@@ -163,6 +178,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 +205,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.9",
+  "version": "1.0.70",
   "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.9",
-    "@lovelybunch/mcp": "^1.0.69-alpha.9",
-    "@lovelybunch/types": "^1.0.69-alpha.9",
+    "@lovelybunch/core": "^1.0.70",
+    "@lovelybunch/mcp": "^1.0.70",
+    "@lovelybunch/types": "^1.0.70",
     "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": {