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

package/dist/lib/storage/file-storage.js

@@ -122,19 +122,28 @@ export class FileStorageAdapter {
         // Never allow id to be updated to prevent overwriting other proposals
         const { id: _, ...safeUpdates } = updates;
         // Handle comments separately as they're stored at root level in file format
-        let updated = {
+        // Comments can come from either root level or metadata.comments
+        let commentsToStore = existing.metadata.comments || [];
+        if (safeUpdates.comments) {
+            // If comments are provided at root level, use them
+            commentsToStore = safeUpdates.comments;
+        }
+        else if (safeUpdates.metadata?.comments) {
+            // If comments are provided in metadata, use them
+            commentsToStore = safeUpdates.metadata.comments;
+        }
+        const updated = {
             ...existing,
             ...safeUpdates,
             metadata: {
                 ...existing.metadata,
                 ...safeUpdates.metadata,
-                updatedAt: new Date()
-            }
+                updatedAt: new Date(),
+                comments: commentsToStore
+            },
+            // Store comments at the root level for the file format
+            comments: commentsToStore
         };
-        // If comments are being updated, store them at the root level for the file format
-        if (safeUpdates.comments) {
-            updated.comments = safeUpdates.comments;
-        }
         await this.createCP(updated);
     }
     async deleteCP(id) {

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

@@ -1,7 +1,8 @@
 import { Hono } from 'hono';
-import { GET, PUT, TEST } from './route.js';
+import { GET, PUT, TEST, EXPORT } from './route.js';
 const config = new Hono();
 config.get('/', GET);
 config.put('/', PUT);
 config.post('/test', TEST);
+config.post('/export-to-env', EXPORT);
 export default config;

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

@@ -30,3 +30,14 @@ export declare function TEST(c: Context): Promise<(Response & import("hono").Typ
     success: false;
     message: string;
 }, 501, "json">)>;
+export declare function EXPORT(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    message: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    message: string;
+}, 500, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    message: string;
+    envPath: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;

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

@@ -240,3 +240,107 @@ export async function TEST(c) {
         return c.json({ success: false, message: 'Invalid request body' }, 400);
     }
 }
+// Provider to environment variable mapping
+const PROVIDER_ENV_VARS = {
+    openrouter: 'OPENROUTER_API_KEY',
+    anthropic: 'ANTHROPIC_API_KEY',
+    openai: 'OPENAI_API_KEY',
+    gemini: 'GEMINI_API_KEY',
+    factorydroid: 'FACTORY_DROID_API_KEY',
+    bedrock: 'AWS_BEDROCK_API_KEY',
+    baseten: 'BASETEN_API_KEY',
+    fireworks: 'FIREWORKS_API_KEY',
+    deepinfra: 'DEEPINFRA_API_KEY'
+};
+// Helper to find workspace root (where .env should be written)
+async function findWorkspaceRoot() {
+    // Try to find .nut directory first
+    let currentDir = process.cwd();
+    while (currentDir !== path.parse(currentDir).root) {
+        const nutPath = path.join(currentDir, '.nut');
+        try {
+            await fs.access(nutPath);
+            // Found .nut directory, return parent as workspace root
+            return currentDir;
+        }
+        catch {
+            currentDir = path.dirname(currentDir);
+        }
+    }
+    // Fallback to cwd if no .nut found
+    return process.cwd();
+}
+// POST /api/v1/config/export-to-env
+// Body: { provider: string }
+// Exports the saved API key for a provider to a .env file in workspace root
+export async function EXPORT(c) {
+    try {
+        const body = await c.req.json();
+        const provider = (body?.provider || '').toString();
+        if (!provider) {
+            return c.json({ success: false, message: 'Missing provider' }, 400);
+        }
+        const envVarName = PROVIDER_ENV_VARS[provider];
+        if (!envVarName) {
+            return c.json({ success: false, message: `Unknown provider: ${provider}` }, 400);
+        }
+        // Load the API key from global config
+        const configPath = await getGlobalConfigPath();
+        let config = { apiKeys: {}, defaults: {} };
+        try {
+            const content = await fs.readFile(configPath, 'utf-8');
+            config = JSON.parse(content);
+        }
+        catch {
+            // Config doesn't exist yet
+        }
+        const apiKey = config.apiKeys?.[provider];
+        if (!apiKey) {
+            return c.json({ success: false, message: `No API key configured for ${provider}` }, 400);
+        }
+        // Find workspace root
+        const workspaceRoot = await findWorkspaceRoot();
+        if (!workspaceRoot) {
+            return c.json({ success: false, message: 'Could not find workspace root' }, 500);
+        }
+        const envPath = path.join(workspaceRoot, '.env');
+        // Read existing .env file if it exists
+        let envContent = '';
+        try {
+            envContent = await fs.readFile(envPath, 'utf-8');
+        }
+        catch {
+            // File doesn't exist, will create new
+        }
+        // Parse existing env vars
+        const envLines = envContent.split('\n');
+        let found = false;
+        const updatedLines = envLines.map(line => {
+            const trimmed = line.trim();
+            if (trimmed.startsWith(envVarName + '=') || trimmed.startsWith(envVarName + ' =')) {
+                found = true;
+                return `${envVarName}=${apiKey}`;
+            }
+            return line;
+        });
+        // If not found, append to the end
+        if (!found) {
+            // Add a newline if the file doesn't end with one
+            if (updatedLines.length > 0 && updatedLines[updatedLines.length - 1] !== '') {
+                updatedLines.push('');
+            }
+            updatedLines.push(`${envVarName}=${apiKey}`);
+        }
+        // Write back to .env file
+        await fs.writeFile(envPath, updatedLines.join('\n'), 'utf-8');
+        return c.json({
+            success: true,
+            message: `${envVarName} saved to .env file`,
+            envPath
+        });
+    }
+    catch (error) {
+        console.error('Error exporting to env:', error);
+        return c.json({ success: false, message: error instanceof Error ? error.message : 'Failed to export to env' }, 500);
+    }
+}

package/dist/routes/api/v1/jobs/[id]/runs/[runId]/log/route.d.ts

@@ -1,11 +1,11 @@
 import { Context } from 'hono';
-export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
+export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">) | (Response & import("hono").TypedResponse<{
     success: false;
     error: {
         code: string;
         message: string;
     };
-}, 404, "json">) | (Response & import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">) | (Response & import("hono").TypedResponse<{
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
     success: false;
     error: {
         code: string;

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

@@ -52,10 +52,11 @@ export async function GET(c) {
         }
         const url = new URL(c.req.url);
         const download = url.searchParams.get('download');
+        // Return the actual file (either for download or inline display)
+        const filePath = path.join(FILES_DIR, resource.path);
+        const fileBuffer = await fs.readFile(filePath);
         if (download === 'true') {
-            // Return the actual file
-            const filePath = path.join(FILES_DIR, resource.path);
-            const fileBuffer = await fs.readFile(filePath);
+            // Force download with Content-Disposition: attachment
             return new Response(fileBuffer, {
                 headers: {
                     'Content-Type': resource.type,
@@ -64,10 +65,13 @@ export async function GET(c) {
                 }
             });
         }
-        // Return resource metadata
-        return c.json({
-            success: true,
-            data: resource
+        // Serve file inline (for preview in iframe, img, video, etc.)
+        return new Response(fileBuffer, {
+            headers: {
+                'Content-Type': resource.type,
+                'Content-Length': resource.size.toString(),
+                'Cache-Control': 'public, max-age=31536000'
+            }
         });
     }
     catch (error) {

package/dist/routes/api/v1/resources/generate/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/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/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: {
+        imageUrl: string;
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;

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.14",
+  "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.14",
-    "@lovelybunch/mcp": "^1.0.69-alpha.14",
-    "@lovelybunch/types": "^1.0.69-alpha.14",
+    "@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": {