@lovelybunch/api 1.0.69-alpha.1 → 1.0.69-alpha.3

package/dist/lib/jobs/job-runner.d.ts

@@ -11,6 +11,10 @@ export declare class JobRunner {
     constructor();
     private ensureCliAvailable;
     private ensureLogPath;
+    private loadAgentInstructions;
+    private loadMcpConfigs;
+    private writeMcpJson;
+    private cleanupMcpJson;
     private buildInstruction;
     run(job: ScheduledJob, runId: string): Promise<JobRunResult>;
 }

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

@@ -18,28 +18,39 @@ function resolveAgent(model) {
         return 'codex';
     return 'claude';
 }
-function buildCommand(agent, instruction, options) {
+function buildCommand(agent, instruction, config) {
     const quotedInstruction = shellQuote(instruction);
+    let mainCommand = '';
     switch (agent) {
         case 'gemini': {
-            const cmd = `gemini --yolo -i ${quotedInstruction}`;
-            return { command: 'gemini', shellCommand: cmd };
+            // For non-Claude agents, use the --mcp flag approach if supported
+            const mcpFlags = config.mcpServers && config.mcpServers.length > 0
+                ? config.mcpServers.map(server => `--mcp ${shellQuote(server)}`).join(' ')
+                : '';
+            mainCommand = `gemini --yolo ${mcpFlags} -i ${quotedInstruction}`;
+            break;
         }
         case 'codex': {
-            const baseCmd = `codex ${quotedInstruction} --dangerously-bypass-approvals-and-sandbox`;
-            const needsPseudoTty = options.runningAsRoot && process.platform !== 'win32';
-            const wrappedCmd = needsPseudoTty
+            // For non-Claude agents, use the --mcp flag approach if supported
+            const mcpFlags = config.mcpServers && config.mcpServers.length > 0
+                ? config.mcpServers.map(server => `--mcp ${shellQuote(server)}`).join(' ')
+                : '';
+            const baseCmd = `codex ${quotedInstruction} --dangerously-bypass-approvals-and-sandbox ${mcpFlags}`.trim();
+            const needsPseudoTty = config.runningAsRoot && process.platform !== 'win32';
+            mainCommand = needsPseudoTty
                 ? `script -q -e -c ${shellQuote(baseCmd)} /dev/null`
                 : baseCmd;
-            return { command: 'codex', shellCommand: wrappedCmd };
+            break;
         }
         case 'claude':
         default: {
-            const prefix = options.runningAsRoot ? 'IS_SANDBOX=1 ' : '';
-            const cmd = `${prefix}claude ${quotedInstruction} --dangerously-skip-permissions`;
-            return { command: 'claude', shellCommand: cmd };
+            // Claude uses .mcp.json for MCP server configuration (no --mcp flag)
+            const prefix = config.runningAsRoot ? 'IS_SANDBOX=1 ' : '';
+            mainCommand = `${prefix}claude ${quotedInstruction} --dangerously-skip-permissions`.trim();
+            break;
         }
     }
+    return { command: agent === 'claude' ? 'claude' : agent, shellCommand: mainCommand };
 }
 const CLI_AGENT_LABEL = {
     claude: 'Claude',
@@ -80,18 +91,103 @@ export class JobRunner {
         await fs.mkdir(logsDir, { recursive: true });
         return path.join(logsDir, `${runId}.log`);
     }
-    buildInstruction(job, agentLabel) {
-        const prompt = job.prompt.trim();
+    async loadAgentInstructions(agentId) {
+        try {
+            const projectRoot = await this.projectRootPromise;
+            const agentPath = path.join(projectRoot, '.nut', 'agents', agentId);
+            const content = await fs.readFile(agentPath, 'utf-8');
+            // Extract content after frontmatter
+            const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+            if (frontmatterMatch && frontmatterMatch[2]) {
+                return frontmatterMatch[2].trim();
+            }
+            return content.trim();
+        }
+        catch (error) {
+            console.warn(`Failed to load agent ${agentId}:`, error);
+            return null;
+        }
+    }
+    async loadMcpConfigs() {
+        try {
+            const projectRoot = await this.projectRootPromise;
+            const mcpConfigPath = path.join(projectRoot, '.nut', 'mcp', 'config.json');
+            const content = await fs.readFile(mcpConfigPath, 'utf-8');
+            const json = JSON.parse(content);
+            return json.mcpServers || {};
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                console.warn('Failed to load MCP config:', error);
+            }
+            return {};
+        }
+    }
+    async writeMcpJson(mcpServers, allMcpConfigs) {
+        const projectRoot = await this.projectRootPromise;
+        const mcpJsonPath = path.join(projectRoot, '.mcp.json');
+        // Filter to only include the requested servers that are enabled
+        const filteredConfigs = {};
+        for (const serverName of mcpServers) {
+            const config = allMcpConfigs[serverName];
+            if (config && config.enabled !== false) {
+                filteredConfigs[serverName] = config;
+            }
+        }
+        const mcpJson = {
+            mcpServers: filteredConfigs
+        };
+        await fs.writeFile(mcpJsonPath, JSON.stringify(mcpJson, null, 2), 'utf-8');
+    }
+    async cleanupMcpJson() {
+        try {
+            const projectRoot = await this.projectRootPromise;
+            const mcpJsonPath = path.join(projectRoot, '.mcp.json');
+            // Reset to empty mcpServers object
+            const emptyMcpJson = {
+                mcpServers: {}
+            };
+            await fs.writeFile(mcpJsonPath, JSON.stringify(emptyMcpJson, null, 2), 'utf-8');
+        }
+        catch (error) {
+            // Don't fail the job if cleanup fails
+            console.warn('Failed to cleanup .mcp.json:', error);
+        }
+    }
+    async buildInstruction(job, agentLabel) {
         const scheduleDescription = job.schedule.type === 'cron'
             ? `Cron: ${job.schedule.expression}`
             : `Interval: every ${job.schedule.hours}h on ${job.schedule.daysOfWeek.join(', ')}`;
-        return `Run this scheduled Coconut job (${job.id}).\nSchedule: ${scheduleDescription}.\nPreferred CLI agent: ${agentLabel}.\nInstruction:\n${prompt}`;
+        let instruction = `Run this scheduled Coconut job (${job.id}).\nSchedule: ${scheduleDescription}.\nPreferred CLI agent: ${agentLabel}.\n\n`;
+        // If an agent is specified, load and use its instructions
+        if (job.agentId) {
+            const agentInstructions = await this.loadAgentInstructions(job.agentId);
+            if (agentInstructions) {
+                instruction += `Agent Instructions (${job.agentId}):\n${agentInstructions}\n\n`;
+            }
+        }
+        // Add custom instructions (or main prompt if no agent)
+        const customInstructions = job.prompt.trim();
+        if (customInstructions) {
+            const label = job.agentId ? 'Additional Custom Instructions' : 'Instructions';
+            instruction += `${label}:\n${customInstructions}`;
+        }
+        return instruction;
     }
     async run(job, runId) {
         const agent = resolveAgent(job.model);
-        const instruction = this.buildInstruction(job, CLI_AGENT_LABEL[agent] || agent);
+        const instruction = await this.buildInstruction(job, CLI_AGENT_LABEL[agent] || agent);
         const runningAsRoot = typeof process.getuid === 'function' && process.getuid() === 0;
-        const { shellCommand } = buildCommand(agent, instruction, { runningAsRoot });
+        // Write .mcp.json if MCP servers are specified (Claude reads this from project root)
+        const mcpJsonWritten = job.mcpServers && job.mcpServers.length > 0 && agent === 'claude';
+        if (mcpJsonWritten) {
+            const allMcpConfigs = await this.loadMcpConfigs();
+            await this.writeMcpJson(job.mcpServers, allMcpConfigs);
+        }
+        const { shellCommand } = buildCommand(agent, instruction, {
+            runningAsRoot,
+            mcpServers: job.mcpServers
+        });
         const projectRoot = await this.projectRootPromise;
         const logPath = await this.ensureLogPath(job.id, runId);
         const logStream = createWriteStream(logPath, { flags: 'a' });
@@ -99,6 +195,9 @@ export class JobRunner {
         logStream.write(`[${new Date().toISOString()}] Starting job ${job.id} using ${agent} CLI\n`);
         logStream.write(`Instruction: ${instruction}\n`);
         logStream.write(`Command: ${shellCommand}\n`);
+        if (job.mcpServers && job.mcpServers.length > 0) {
+            logStream.write(`MCP Servers: ${job.mcpServers.join(', ')} (configured via .mcp.json)\n`);
+        }
         return new Promise((resolve) => {
             let cliMissingError = null;
             try {
@@ -111,6 +210,10 @@ export class JobRunner {
                 const message = cliMissingError.message;
                 logStream.write(`${message}\n`);
                 logStream.end();
+                // Cleanup .mcp.json if it was written
+                if (mcpJsonWritten) {
+                    this.cleanupMcpJson().catch(err => console.warn('Cleanup failed:', err));
+                }
                 resolve({
                     status: 'failed',
                     error: message,
@@ -146,6 +249,10 @@ export class JobRunner {
                 logStream.write(`${message}\n`);
                 logStream.end();
                 clearTimeout(abortTimeout);
+                // Cleanup .mcp.json if it was written
+                if (mcpJsonWritten) {
+                    this.cleanupMcpJson().catch(err => console.warn('Cleanup failed:', err));
+                }
                 resolve({
                     status: 'failed',
                     error: message,
@@ -159,6 +266,10 @@ export class JobRunner {
                 logStream.write(`\n[${new Date().toISOString()}] Job ${job.id} completed with exit code ${code}\n`);
                 logStream.end();
                 clearTimeout(abortTimeout);
+                // Cleanup .mcp.json if it was written
+                if (mcpJsonWritten) {
+                    this.cleanupMcpJson().catch(err => console.warn('Cleanup failed:', err));
+                }
                 const summary = summaryChunks.join('');
                 resolve({
                     status,

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

@@ -175,6 +175,8 @@ export class JobStore {
             runs,
             tags: data.tags ?? [],
             contextPaths: data.contextPaths ?? [],
+            agentId: data.agentId,
+            mcpServers: data.mcpServers,
         };
     }
     toFrontmatter(job) {
@@ -206,6 +208,8 @@ export class JobStore {
             })),
             tags: job.tags ?? [],
             contextPaths: job.contextPaths ?? [],
+            agentId: job.agentId,
+            mcpServers: job.mcpServers,
         };
     }
 }

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

@@ -47,6 +47,8 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
         }[];
         tags?: string[];
         contextPaths?: string[];
+        agentId?: string;
+        mcpServers?: string[];
     };
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;
@@ -108,6 +110,8 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
         }[];
         tags?: string[];
         contextPaths?: string[];
+        agentId?: string;
+        mcpServers?: string[];
     };
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;

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

@@ -82,6 +82,12 @@ export async function PATCH(c) {
             schedule,
             tags: Array.isArray(body.tags) ? body.tags : existing.tags,
             contextPaths: Array.isArray(body.contextPaths) ? body.contextPaths : existing.contextPaths,
+            agentId: body.agentId !== undefined
+                ? (typeof body.agentId === 'string' && body.agentId ? body.agentId : undefined)
+                : existing.agentId,
+            mcpServers: body.mcpServers !== undefined
+                ? (Array.isArray(body.mcpServers) ? body.mcpServers.filter((s) => typeof s === 'string') : undefined)
+                : existing.mcpServers,
             metadata: {
                 ...existing.metadata,
                 updatedAt: new Date()

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

@@ -43,6 +43,8 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
         }[];
         tags?: string[];
         contextPaths?: string[];
+        agentId?: string;
+        mcpServers?: string[];
     }[];
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;
@@ -98,6 +100,8 @@ export declare function POST(c: Context): Promise<(Response & import("hono").Typ
         }[];
         tags?: string[];
         contextPaths?: string[];
+        agentId?: string;
+        mcpServers?: string[];
     };
 }, 201, "json">) | (Response & import("hono").TypedResponse<{
     success: false;

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

@@ -122,6 +122,8 @@ export async function POST(c) {
             runs: [],
             tags: Array.isArray(body.tags) ? body.tags : [],
             contextPaths: Array.isArray(body.contextPaths) ? body.contextPaths : [],
+            agentId: body.agentId && typeof body.agentId === 'string' ? body.agentId : undefined,
+            mcpServers: Array.isArray(body.mcpServers) ? body.mcpServers.filter((s) => typeof s === 'string') : undefined,
         };
         await store.saveJob(job);
         await scheduler.refresh(job.id);

package/package.json

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