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

package/dist/lib/auth/auth-manager.d.ts

@@ -2,7 +2,11 @@ import { AuthConfig, LocalAuthUser, AuthSession, ApiKey, UserRole } from '@lovel
 export declare class AuthManager {
     private authConfigPath;
     private authConfig;
-    constructor(dataPath: string);
+    /**
+     * Create an AuthManager instance.
+     * @param configPath - Optional custom path to auth.json. If not provided, uses OS app data directory.
+     */
+    constructor(configPath?: string);
     /**
      * Check if auth is enabled
      */
@@ -119,4 +123,8 @@ export declare class AuthManager {
      */
     clearCache(): void;
 }
-export declare function getAuthManager(dataPath?: string): AuthManager;
+/**
+ * Get the singleton AuthManager instance.
+ * @param configPath - Optional custom path to auth.json. If not provided, uses OS app data directory.
+ */
+export declare function getAuthManager(configPath?: string): AuthManager;

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

@@ -3,14 +3,19 @@ import path from 'path';
 import bcrypt from 'bcrypt';
 import jwt from 'jsonwebtoken';
 import crypto from 'crypto';
+import { getAuthConfigPath } from '@lovelybunch/core';
 const SALT_ROUNDS = 10;
 const DEFAULT_SESSION_EXPIRY = '7d';
 const DEFAULT_COOKIE_NAME = 'nut-session';
 export class AuthManager {
     authConfigPath;
     authConfig = null;
-    constructor(dataPath) {
-        this.authConfigPath = path.join(dataPath, '.nut', 'auth.json');
+    /**
+     * Create an AuthManager instance.
+     * @param configPath - Optional custom path to auth.json. If not provided, uses OS app data directory.
+     */
+    constructor(configPath) {
+        this.authConfigPath = configPath ?? getAuthConfigPath();
     }
     /**
      * Check if auth is enabled
@@ -45,6 +50,9 @@ export class AuthManager {
      * Save auth config to file
      */
     async saveAuthConfig(config) {
+        // Ensure the directory exists
+        const dir = path.dirname(this.authConfigPath);
+        await fs.mkdir(dir, { recursive: true });
         await fs.writeFile(this.authConfigPath, JSON.stringify(config, null, 2), 'utf-8');
         this.authConfig = config;
     }
@@ -402,10 +410,13 @@ export class AuthManager {
 }
 // Singleton instance
 let authManagerInstance = null;
-export function getAuthManager(dataPath) {
+/**
+ * Get the singleton AuthManager instance.
+ * @param configPath - Optional custom path to auth.json. If not provided, uses OS app data directory.
+ */
+export function getAuthManager(configPath) {
     if (!authManagerInstance) {
-        const path = dataPath || process.env.GAIT_DATA_PATH || process.cwd();
-        authManagerInstance = new AuthManager(path);
+        authManagerInstance = new AuthManager(configPath);
     }
     return authManagerInstance;
 }

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/git.d.ts

@@ -44,6 +44,7 @@ export declare function getCredentialConfig(): Promise<{
     origin?: string;
 }>;
 export declare function setRemoteUrl(remoteUrl: string): Promise<void>;
+export declare function removeRemote(): Promise<void>;
 export declare function storeCredentials(username: string, password: string, remoteUrl?: string): Promise<void>;
 export interface WorktreeInfo {
     name: string;

package/dist/lib/git.js

@@ -158,7 +158,8 @@ export async function pushCurrent() {
         console.error('[git] Error reading GitHub token:', tokenError);
     }
     console.log('[git] Executing git push...');
-    const { stdout } = await runGit(['push'], { timeout: 30000 }); // 30 second timeout for push
+    // Use -u to set upstream tracking if not already set (harmless if already configured)
+    const { stdout } = await runGit(['push', '-u', 'origin', 'HEAD'], { timeout: 30000 }); // 30 second timeout for push
     console.log('[git] Push completed successfully');
     return stdout;
 }
@@ -257,6 +258,18 @@ export async function setRemoteUrl(remoteUrl) {
         await runGit(['remote', 'add', 'origin', trimmed]);
     }
 }
+export async function removeRemote() {
+    // Check if origin exists
+    try {
+        await runGit(['config', '--get', 'remote.origin.url']);
+        // If we get here, origin exists, so remove it
+        await runGit(['remote', 'remove', 'origin']);
+    }
+    catch {
+        // Origin doesn't exist, nothing to do
+        throw new Error('No remote configured');
+    }
+}
 export async function storeCredentials(username, password, remoteUrl) {
     // If a remote URL is provided, set it first
     if (remoteUrl && remoteUrl.trim()) {

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,15 @@ function buildCommand(agent, instruction, config) {
                 : baseCmd;
             break;
         }
+        case 'droid': {
+            // For Factory Droid, use exec mode with --auto high for non-interactive scheduled jobs
+            // See: https://docs.factory.ai/reference/cli-reference#autonomy-levels
+            const mcpFlags = config.mcpServers && config.mcpServers.length > 0
+                ? config.mcpServers.map(server => `--mcp ${shellQuote(server)}`).join(' ')
+                : '';
+            mainCommand = `droid exec --auto high ${mcpFlags} ${quotedInstruction}`.trim();
+            break;
+        }
         case 'claude':
         default: {
             // Claude uses .mcp.json for MCP server configuration (no --mcp flag)
@@ -55,12 +67,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 +237,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/events/status/route.d.ts

@@ -7,8 +7,6 @@ import { Context } from "hono";
  * Get logging system status and configuration
  */
 export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
-    error: string;
-}, 404, "json">) | (Response & import("hono").TypedResponse<{
     currentFile: string;
     sizeBytes: number;
     lastSeq: number;

package/dist/routes/api/v1/events/status/route.js

@@ -2,28 +2,16 @@
  * Events status endpoint
  */
 import { getLogger } from "@lovelybunch/core/logging";
+import { getLogsDir } from "@lovelybunch/core";
 import { promises as fs } from "fs";
 import path from "path";
-import { findGaitDirectory } from "../../../../../lib/gait-path.js";
-/**
- * Get the events directory path
- */
-async function getEventsDir() {
-    const gaitDir = await findGaitDirectory();
-    if (!gaitDir)
-        return null;
-    return path.join(gaitDir, "logs");
-}
 /**
  * GET /api/v1/events/status
  * Get logging system status and configuration
  */
 export async function GET(c) {
     try {
-        const eventsDir = await getEventsDir();
-        if (!eventsDir) {
-            return c.json({ error: "Events directory not found" }, 404);
-        }
+        const eventsDir = getLogsDir();
         const logger = getLogger();
         const currentFile = path.join(eventsDir, "events-current.jsonl");
         let sizeBytes = 0;

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

@@ -111,6 +111,17 @@ app.put('/remote', async (c) => {
         return c.json({ success: false, error: { message: e.message } }, 500);
     }
 });
+// Delete Remote URL
+app.delete('/remote', async (c) => {
+    try {
+        const { removeRemote } = await import('../../../../lib/git.js');
+        await removeRemote();
+        return c.json({ success: true, data: { message: 'Remote URL removed successfully' } });
+    }
+    catch (e) {
+        return c.json({ success: false, error: { message: e.message } }, 500);
+    }
+});
 // Store Credentials
 app.post('/credentials', async (c) => {
     try {
@@ -402,13 +413,19 @@ app.post('/discard', async (c) => {
         const statusCode = fileChange.status.trim();
         // Handle different file statuses
         if (statusCode === '??' || statusCode.includes('U')) {
-            // Untracked file - remove it
-            const { unlink } = await import('fs/promises');
+            // Untracked file or directory - remove it
+            const { rm, stat } = await import('fs/promises');
             const { getRepoRoot } = await import('../../../../lib/git.js');
             const repoRoot = await getRepoRoot();
             const { join } = await import('path');
             const fullPath = join(repoRoot, filePath);
-            await unlink(fullPath);
+            const stats = await stat(fullPath);
+            if (stats.isDirectory()) {
+                await rm(fullPath, { recursive: true });
+            }
+            else {
+                await rm(fullPath);
+            }
         }
         else if (statusCode.includes('D')) {
             // Deleted file - restore it

package/dist/routes/api/v1/jobs/[id]/run/route.d.ts

@@ -12,8 +12,8 @@ export declare function POST(c: Context): Promise<(Response & import("hono").Typ
         run: {
             id: string;
             jobId: string;
-            trigger: import("@lovelybunch/types").ScheduledJobTrigger;
-            status: import("@lovelybunch/types").ScheduledJobRunStatus;
+            trigger: import("@lovelybunch/core").ScheduledJobTrigger;
+            status: import("@lovelybunch/core").ScheduledJobRunStatus;
             startedAt: string;
             finishedAt?: string;
             outputPath?: string;

package/dist/routes/api/v1/jobs/status/route.d.ts

@@ -7,7 +7,7 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
         runningCount: number;
         jobs: {
             id: string;
-            status: import("@lovelybunch/types").ScheduledJobStatus;
+            status: import("@lovelybunch/core").ScheduledJobStatus;
             nextRunAt?: string;
             lastRunAt?: string;
             timerActive: boolean;

package/dist/routes/api/v1/proposals/[id]/route.d.ts

@@ -12,7 +12,7 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
         intent: string;
         content?: string;
         author: {
-            type: import("@lovelybunch/types").AuthorType;
+            type: import("@lovelybunch/core").AuthorType;
             id: string;
             name: string;
             email?: string;
@@ -47,7 +47,7 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
             version: string;
             name: string;
             description: string;
-            type: import("@lovelybunch/types").FeatureFlagType;
+            type: import("@lovelybunch/core").FeatureFlagType;
             defaultValue: any;
             scopes: string[];
             targets: {
@@ -95,7 +95,7 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
                 minimumSampleSize: number;
                 testType: "two-tailed" | "one-tailed";
             };
-            status: import("@lovelybunch/types").ExperimentStatus;
+            status: import("@lovelybunch/core").ExperimentStatus;
             startedAt?: string;
             endedAt?: string;
         }[];
@@ -133,7 +133,7 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
             schedule?: string;
             rollbackPlan?: string;
         };
-        status: import("@lovelybunch/types").CPStatus;
+        status: import("@lovelybunch/core").CPStatus;
         metadata: {
             createdAt: string;
             updatedAt: string;
@@ -169,7 +169,7 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
         intent: string;
         content?: string;
         author: {
-            type: import("@lovelybunch/types").AuthorType;
+            type: import("@lovelybunch/core").AuthorType;
             id: string;
             name: string;
             email?: string;
@@ -204,7 +204,7 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
             version: string;
             name: string;
             description: string;
-            type: import("@lovelybunch/types").FeatureFlagType;
+            type: import("@lovelybunch/core").FeatureFlagType;
             defaultValue: any;
             scopes: string[];
             targets: {
@@ -252,7 +252,7 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
                 minimumSampleSize: number;
                 testType: "two-tailed" | "one-tailed";
             };
-            status: import("@lovelybunch/types").ExperimentStatus;
+            status: import("@lovelybunch/core").ExperimentStatus;
             startedAt?: string;
             endedAt?: string;
         }[];
@@ -290,7 +290,7 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
             schedule?: string;
             rollbackPlan?: string;
         };
-        status: import("@lovelybunch/types").CPStatus;
+        status: import("@lovelybunch/core").CPStatus;
         metadata: {
             createdAt: string;
             updatedAt: string;