@lovelybunch/api 1.0.69-alpha.16 → 1.0.69-alpha.17

package/dist/lib/env-injection.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Get environment variables to inject into spawned child processes
+ * These are the API keys that coding agents (Claude Code, Codex, Gemini CLI) will use
+ * Returns a full environment object with process.env merged with API keys
+ */
+export declare function getInjectedEnv(): Record<string, string>;

package/dist/lib/env-injection.js

@@ -0,0 +1,64 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, readFileSync } from 'fs';
+/**
+ * Get the path to the global config file
+ */
+function getGlobalConfigPath() {
+    const platform = process.platform;
+    let configDir;
+    if (platform === 'win32') {
+        configDir = join(process.env.APPDATA || homedir(), 'coconuts');
+    }
+    else if (platform === 'darwin') {
+        configDir = join(homedir(), 'Library', 'Application Support', 'coconuts');
+    }
+    else {
+        // Linux/Unix
+        configDir = join(process.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'coconuts');
+    }
+    return join(configDir, 'config.json');
+}
+/**
+ * Load global config from OS-specific location
+ */
+function loadGlobalConfig() {
+    const configPath = getGlobalConfigPath();
+    if (!existsSync(configPath)) {
+        return { apiKeys: {}, defaults: {} };
+    }
+    try {
+        const content = readFileSync(configPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        console.warn('Warning: Could not parse global config file, using defaults');
+        return { apiKeys: {}, defaults: {} };
+    }
+}
+/**
+ * Get environment variables to inject into spawned child processes
+ * These are the API keys that coding agents (Claude Code, Codex, Gemini CLI) will use
+ * Returns a full environment object with process.env merged with API keys
+ */
+export function getInjectedEnv() {
+    const config = loadGlobalConfig();
+    const env = { ...process.env };
+    // Only inject keys that are actually configured
+    if (config.apiKeys?.anthropic) {
+        env.ANTHROPIC_API_KEY = config.apiKeys.anthropic;
+    }
+    if (config.apiKeys?.openai) {
+        env.OPENAI_API_KEY = config.apiKeys.openai;
+    }
+    if (config.apiKeys?.gemini) {
+        env.GEMINI_API_KEY = config.apiKeys.gemini;
+    }
+    if (config.apiKeys?.replicate) {
+        env.REPLICATE_API_TOKEN = config.apiKeys.replicate;
+    }
+    if (config.apiKeys?.factorydroid) {
+        env.FACTORY_API_KEY = config.apiKeys.factorydroid;
+    }
+    return env;
+}

package/dist/lib/jobs/job-runner.js

@@ -3,6 +3,7 @@ import { createWriteStream } from 'fs';
 import { promises as fs } from 'fs';
 import path from 'path';
 import { getProjectRoot } from '../project-paths.js';
+import { getInjectedEnv } from '../env-injection.js';
 function shellQuote(value) {
     if (value === '')
         return "''";
@@ -16,6 +17,8 @@ function resolveAgent(model) {
         return 'gemini';
     if (lower.includes('codex') || lower.includes('gpt') || lower.includes('openai'))
         return 'codex';
+    if (lower.includes('droid') || lower.includes('factory'))
+        return 'droid';
     return 'claude';
 }
 function buildCommand(agent, instruction, config) {
@@ -42,6 +45,14 @@ function buildCommand(agent, instruction, config) {
                 : baseCmd;
             break;
         }
+        case 'droid': {
+            // For Factory Droid, use the --mcp flag approach if supported
+            const mcpFlags = config.mcpServers && config.mcpServers.length > 0
+                ? config.mcpServers.map(server => `--mcp ${shellQuote(server)}`).join(' ')
+                : '';
+            mainCommand = `droid ${quotedInstruction} --skip-permissions-unsafe ${mcpFlags}`.trim();
+            break;
+        }
         case 'claude':
         default: {
             // Claude uses .mcp.json for MCP server configuration (no --mcp flag)
@@ -55,12 +66,14 @@ function buildCommand(agent, instruction, config) {
 const CLI_AGENT_LABEL = {
     claude: 'Claude',
     gemini: 'Gemini',
-    codex: 'Code'
+    codex: 'Codex',
+    droid: 'Factory Droid'
 };
 const CLI_AGENT_BINARY = {
     claude: 'claude',
     gemini: 'gemini',
-    codex: 'codex'
+    codex: 'codex',
+    droid: 'droid'
 };
 const DEFAULT_MAX_RUNTIME_MS = 30 * 60 * 1000; // 30 minutes
 function getMaxRuntime() {
@@ -223,9 +236,14 @@ export class JobRunner {
                 });
                 return;
             }
+            // Inject API keys from global config into child process environment
+            const injectedEnv = getInjectedEnv();
             const child = spawn('bash', ['-lc', shellCommand], {
                 cwd: projectRoot,
-                env: process.env,
+                env: {
+                    ...process.env,
+                    ...injectedEnv
+                },
                 stdio: ['ignore', 'pipe', 'pipe'],
             });
             const maxRuntime = getMaxRuntime();

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

@@ -5,6 +5,7 @@ import fs from 'fs';
 import { createInitScript } from './context-helper.js';
 import { getShellPath, getShellArgs, prepareShellInit } from './shell-utils.js';
 import { getLogger, AgentKinds } from '@lovelybunch/core/logging';
+import { getInjectedEnv } from '../env-injection.js';
 export class TerminalManager {
     sessions = new Map();
     cleanupInterval;
@@ -82,9 +83,9 @@ export class TerminalManager {
         }
         // Get shell arguments
         const shellArgs = getShellArgs(shellPath, initScriptPath);
-        // Prepare environment variables
+        // Prepare environment variables with API keys injected
         const env = {
-            ...process.env,
+            ...getInjectedEnv(),
             COCONUT_PROPOSAL_ID: proposalId,
             COCONUT_CONTEXT_PATH: path.join(projectRoot, '.nut', 'context'),
             COCONUT_PROPOSAL_PATH: path.join(projectRoot, '.nut', 'proposals', `${proposalId}.md`),

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

@@ -1,8 +1,7 @@
 import { Hono } from 'hono';
-import { GET, PUT, TEST, EXPORT } from './route.js';
+import { GET, PUT, TEST } 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,14 +30,3 @@ 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

@@ -233,114 +233,30 @@ export async function TEST(c) {
                 return c.json({ success: false, message: err instanceof Error ? err.message : 'Network error' }, 200);
             }
         }
-        // Other providers not wired up yet
-        return c.json({ success: false, message: `Provider '${provider}' test not implemented yet` }, 501);
-    }
-    catch (error) {
-        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}`;
+        if (provider === 'replicate') {
+            try {
+                // Test Replicate API by listing models (lightweight endpoint)
+                const resp = await fetch('https://api.replicate.com/v1/models', {
+                    method: 'GET',
+                    headers: {
+                        'Authorization': `Bearer ${effectiveKey}`,
+                        'Content-Type': 'application/json',
+                    },
+                });
+                if (!resp.ok) {
+                    const text = await resp.text();
+                    return c.json({ success: false, message: `Replicate rejected token: ${text.slice(0, 200)}` }, 200);
+                }
+                return c.json({ success: true, message: 'Replicate token is valid' });
             }
-            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('');
+            catch (err) {
+                return c.json({ success: false, message: err instanceof Error ? err.message : 'Network error' }, 200);
             }
-            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
-        });
+        // Other providers not wired up yet
+        return c.json({ success: false, message: `Provider '${provider}' test not implemented yet` }, 501);
     }
     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);
+        return c.json({ success: false, message: 'Invalid request body' }, 400);
     }
 }

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

@@ -1,10 +1,49 @@
 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,
-});
+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) {
@@ -69,6 +108,17 @@ function getAspectRatio(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) {
@@ -130,7 +180,8 @@ export async function POST(c) {
                     continue;
                 }
                 const fileBuffer = await fs.readFile(filePath);
-                const uploadedFile = await replicate.files.create(fileBuffer, {
+                const replicateClient = getReplicateClient();
+                const uploadedFile = await replicateClient.files.create(fileBuffer, {
                     resourceId,
                     originalName: resource.name,
                 });
@@ -160,7 +211,8 @@ export async function POST(c) {
         }
         // 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 });
+        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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovelybunch/api",
-  "version": "1.0.69-alpha.16",
+  "version": "1.0.69-alpha.17",
   "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.16",
-    "@lovelybunch/mcp": "^1.0.69-alpha.16",
-    "@lovelybunch/types": "^1.0.69-alpha.16",
+    "@lovelybunch/core": "^1.0.69-alpha.17",
+    "@lovelybunch/mcp": "^1.0.69-alpha.17",
+    "@lovelybunch/types": "^1.0.69-alpha.17",
     "arctic": "^1.9.2",
     "bcrypt": "^5.1.1",
     "cookie": "^0.6.0",