@lovelybunch/api 1.0.69-alpha.2 → 1.0.69-alpha.4

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

@@ -12,6 +12,9 @@ export declare class JobRunner {
     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

@@ -20,29 +20,37 @@ function resolveAgent(model) {
 }
 function buildCommand(agent, instruction, config) {
     const quotedInstruction = shellQuote(instruction);
-    const mcpFlags = config.mcpServers && config.mcpServers.length > 0
-        ? config.mcpServers.map(server => `--mcp ${shellQuote(server)}`).join(' ')
-        : '';
+    let mainCommand = '';
     switch (agent) {
         case 'gemini': {
-            const cmd = `gemini --yolo ${mcpFlags} -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': {
+            // 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';
-            const wrappedCmd = needsPseudoTty
+            mainCommand = needsPseudoTty
                 ? `script -q -e -c ${shellQuote(baseCmd)} /dev/null`
                 : baseCmd;
-            return { command: 'codex', shellCommand: wrappedCmd };
+            break;
         }
         case 'claude':
         default: {
+            // Claude uses .mcp.json for MCP server configuration (no --mcp flag)
             const prefix = config.runningAsRoot ? 'IS_SANDBOX=1 ' : '';
-            const cmd = `${prefix}claude ${quotedInstruction} --dangerously-skip-permissions ${mcpFlags}`.trim();
-            return { command: 'claude', shellCommand: cmd };
+            mainCommand = `${prefix}claude ${quotedInstruction} --dangerously-skip-permissions`.trim();
+            break;
         }
     }
+    return { command: agent === 'claude' ? 'claude' : agent, shellCommand: mainCommand };
 }
 const CLI_AGENT_LABEL = {
     claude: 'Claude',
@@ -100,6 +108,52 @@ export class JobRunner {
             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}`
@@ -124,6 +178,12 @@ export class JobRunner {
         const agent = resolveAgent(job.model);
         const instruction = await this.buildInstruction(job, CLI_AGENT_LABEL[agent] || agent);
         const runningAsRoot = typeof process.getuid === 'function' && process.getuid() === 0;
+        // 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
@@ -135,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 {
@@ -147,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,
@@ -182,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,
@@ -195,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

@@ -176,6 +176,7 @@ export class JobStore {
             tags: data.tags ?? [],
             contextPaths: data.contextPaths ?? [],
             agentId: data.agentId,
+            agentIds: data.agentIds,
             mcpServers: data.mcpServers,
         };
     }
@@ -209,6 +210,7 @@ export class JobStore {
             tags: job.tags ?? [],
             contextPaths: job.contextPaths ?? [],
             agentId: job.agentId,
+            agentIds: job.agentIds,
             mcpServers: job.mcpServers,
         };
     }

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

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

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

@@ -85,6 +85,9 @@ export async function PATCH(c) {
             agentId: body.agentId !== undefined
                 ? (typeof body.agentId === 'string' && body.agentId ? body.agentId : undefined)
                 : existing.agentId,
+            agentIds: body.agentIds !== undefined
+                ? (Array.isArray(body.agentIds) ? body.agentIds.filter((s) => typeof s === 'string') : undefined)
+                : existing.agentIds,
             mcpServers: body.mcpServers !== undefined
                 ? (Array.isArray(body.mcpServers) ? body.mcpServers.filter((s) => typeof s === 'string') : undefined)
                 : existing.mcpServers,

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

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

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

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

package/package.json

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