@lovelybunch/api 1.0.76-alpha.9 → 1.0.76

package/dist/lib/git.d.ts

@@ -1,3 +1,4 @@
+import type { InstructionFileKind, InstructionFiles } from '@lovelybunch/types';
 export declare function getRepoRoot(): Promise<string>;
 export declare function getWorktreesBase(): Promise<string>;
 export declare function sanitizeBranchName(name: string): string;
@@ -9,6 +10,8 @@ export declare function runGit(args: string[], opts?: {
     stdout: string;
     stderr: string;
 }>;
+export declare function lsTree(ref?: string): Promise<string[]>;
+export declare function getInstructionFiles(filter?: InstructionFileKind | 'all'): Promise<InstructionFiles>;
 export declare function getRepoStatus(): Promise<{
     branch: string;
     ahead: number;

package/dist/lib/git.js

@@ -5,6 +5,7 @@ import { promises as fs } from 'fs';
 import { readGithubToken, isGithubTokenValid } from './github-token.js';
 import { findGaitDirectory } from './gait-path.js';
 import { loadGitSettings } from './git-settings.js';
+import { INSTRUCTION_FILE_KINDS } from '@lovelybunch/types';
 const execFile = promisify(_execFile);
 // Base directory for worktrees under the repository root
 export async function getRepoRoot() {
@@ -52,6 +53,40 @@ export async function runGit(args, opts) {
     };
     return execFile('git', args, { cwd, maxBuffer: 10 * 1024 * 1024, timeout, env });
 }
+// --- ls-tree ---
+export async function lsTree(ref = 'HEAD') {
+    const { stdout } = await runGit(['ls-tree', '-r', '--name-only', ref]);
+    return stdout.trim().split('\n').filter(l => l && !l.startsWith('.nut/'));
+}
+// --- Instruction files ---
+const FILENAME_TO_KIND = new Map(INSTRUCTION_FILE_KINDS.map(k => [`${k}.md`, k]));
+const KIND_TO_FILENAME = new Map(INSTRUCTION_FILE_KINDS.map(k => [k, `${k}.md`]));
+export async function getInstructionFiles(filter) {
+    const filterFilename = filter && filter !== 'all' ? KIND_TO_FILENAME.get(filter) : undefined;
+    const allPaths = await lsTree();
+    const wanted = allPaths.filter(p => {
+        const name = path.basename(p);
+        if (!FILENAME_TO_KIND.has(name))
+            return false;
+        if (filterFilename)
+            return name === filterFilename;
+        return true;
+    });
+    const entries = await Promise.all(wanted.map(async (filePath) => {
+        const { stdout } = await runGit(['show', `HEAD:${filePath}`]);
+        return { filePath, content: stdout };
+    }));
+    const result = {};
+    for (const { filePath, content } of entries) {
+        const dir = path.dirname(filePath);
+        const key = dir === '.' ? '.' : dir;
+        const kind = FILENAME_TO_KIND.get(path.basename(filePath));
+        if (!result[key])
+            result[key] = {};
+        result[key][kind] = content;
+    }
+    return result;
+}
 // --- Status ---
 export async function getRepoStatus() {
     const { stdout } = await runGit(['status', '--porcelain=v1', '-b']);

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

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { homedir } from 'os';
 import { join, resolve as pathResolve, basename } from 'path';
 import { existsSync, readFileSync, promises as fs, createReadStream } from 'fs';
@@ -7,7 +8,7 @@ import { ZodError } from 'zod';
 import { streamText, tool, jsonSchema, stepCountIs } from 'ai';
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { getLogsDir, listTasks, getTask, createTask, updateTask, deleteTask, } from '@lovelybunch/core';
-import { tasksFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool, roleContextTool, resourcesTool } from '@lovelybunch/mcp';
+import { tasksFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, roleContextTool, agentsContextTool, teamContextTool, memoryContextTool, resourcesTool, listConnectorsTool, connectorRequestTool, resolveConnectorUrl } from '@lovelybunch/mcp';
 import matter from 'gray-matter';
 import Fuse from 'fuse.js';
 import { FileStorageAdapter } from '../../../../lib/storage/file-storage.js';
@@ -59,6 +60,10 @@ export async function POST(c) {
         const systemPrompt = persona
             ? `${baseSystem}\n\nThe following persona is authoritative and overrides general guidance above. You must strictly follow it.\n\n${persona}`
             : baseSystem;
+        if (process.env.NODE_ENV === 'development') {
+            const sha256Prefix = createHash('sha256').update(systemPrompt).digest('hex').slice(0, 16);
+            console.log('AI system prompt debug:', { length: systemPrompt.length, sha256Prefix });
+        }
         // Build context messages from attached files
         const contextMessages = [];
         if (Array.isArray(attachedContextFiles)) {
@@ -120,27 +125,35 @@ export async function POST(c) {
                     return JSON.stringify(result);
                 },
             }),
-            project_context: tool({
-                description: projectContextTool.description,
-                inputSchema: jsonSchema(projectContextTool.parameters),
+            role_context: tool({
+                description: roleContextTool.description,
+                inputSchema: jsonSchema(roleContextTool.parameters),
                 execute: async (args) => {
-                    const result = await executeProjectContextToolDirect(args);
+                    const result = await executeRoleContextToolDirect(args);
                     return JSON.stringify(result);
                 },
             }),
-            architecture_context: tool({
-                description: architectureContextTool.description,
-                inputSchema: jsonSchema(architectureContextTool.parameters),
+            agents_context: tool({
+                description: agentsContextTool.description,
+                inputSchema: jsonSchema(agentsContextTool.parameters),
                 execute: async (args) => {
-                    const result = await executeArchitectureContextToolDirect(args);
+                    const result = await executeAgentsContextToolDirect(args);
                     return JSON.stringify(result);
                 },
             }),
-            role_context: tool({
-                description: roleContextTool.description,
-                inputSchema: jsonSchema(roleContextTool.parameters),
+            team_context: tool({
+                description: teamContextTool.description,
+                inputSchema: jsonSchema(teamContextTool.parameters),
                 execute: async (args) => {
-                    const result = await executeRoleContextToolDirect(args);
+                    const result = await executeTeamContextToolDirect(args);
+                    return JSON.stringify(result);
+                },
+            }),
+            memory_context: tool({
+                description: memoryContextTool.description,
+                inputSchema: jsonSchema(memoryContextTool.parameters),
+                execute: async (args) => {
+                    const result = await executeMemoryContextToolDirect(args);
                     return JSON.stringify(result);
                 },
             }),
@@ -152,6 +165,22 @@ export async function POST(c) {
                     return JSON.stringify(result);
                 },
             }),
+            list_connectors: tool({
+                description: listConnectorsTool.description,
+                inputSchema: jsonSchema(listConnectorsTool.parameters),
+                execute: async () => {
+                    const result = await executeListConnectorsToolDirect();
+                    return JSON.stringify(result);
+                },
+            }),
+            connector_request: tool({
+                description: connectorRequestTool.description,
+                inputSchema: jsonSchema(connectorRequestTool.parameters),
+                execute: async (args) => {
+                    const result = await executeConnectorRequestToolDirect(args);
+                    return JSON.stringify(result);
+                },
+            }),
         };
         // Debug logging
         console.log('AI Request Debug:', {
@@ -521,12 +550,12 @@ async function executeEventsToolDirect(args) {
         return { success: false, error: error.message || 'Events tool execution failed' };
     }
 }
-// Project context tool - read/write the project definition document
-async function executeProjectContextToolDirect(args) {
+// Role context tool - read/write the role definition document
+async function executeRoleContextToolDirect(args) {
     const { operation, content, old_text, new_text } = args;
     try {
         const contextPath = getContextBasePath();
-        const filePath = join(contextPath, 'project.md');
+        const filePath = join(contextPath, 'role.md');
         switch (operation) {
             case 'get': {
                 try {
@@ -539,7 +568,7 @@ async function executeProjectContextToolDirect(args) {
                             frontmatter: parsed.data,
                             raw: fileContent
                         },
-                        message: 'Retrieved project context'
+                        message: 'Retrieved role context'
                     };
                 }
                 catch (err) {
@@ -547,7 +576,7 @@ async function executeProjectContextToolDirect(args) {
                         return {
                             success: true,
                             data: { content: '', frontmatter: {}, raw: '' },
-                            message: 'Project context document does not exist yet. You can create it with an update operation.'
+                            message: 'Role context document does not exist yet. You can create it with an update operation.'
                         };
                     }
                     throw err;
@@ -574,7 +603,7 @@ async function executeProjectContextToolDirect(args) {
                 await fs.writeFile(filePath, newContent, 'utf-8');
                 return {
                     success: true,
-                    message: 'Appended content to project context document'
+                    message: 'Appended content to role context document'
                 };
             }
             case 'replace_section': {
@@ -588,7 +617,7 @@ async function executeProjectContextToolDirect(args) {
                 }
                 catch (err) {
                     if (err.code === 'ENOENT') {
-                        return { success: false, error: 'Project context document does not exist. Use append or update to create it first.' };
+                        return { success: false, error: 'Role context document does not exist. Use append or update to create it first.' };
                     }
                     throw err;
                 }
@@ -598,7 +627,7 @@ async function executeProjectContextToolDirect(args) {
                         success: false,
                         error: 'Could not find the specified text in the document. The text may have been paraphrased or changed.',
                         fallback_markdown: new_text,
-                        suggestion: 'Here is the replacement text. You can copy it and manually edit the document at /context/project'
+                        suggestion: 'Here is the replacement text. You can copy it and manually edit the document at /context/role'
                     };
                 }
                 // Replace the text
@@ -606,7 +635,7 @@ async function executeProjectContextToolDirect(args) {
                 await fs.writeFile(filePath, updatedContent, 'utf-8');
                 return {
                     success: true,
-                    message: 'Replaced section in project context document'
+                    message: 'Replaced section in role context document'
                 };
             }
             case 'update': {
@@ -617,7 +646,7 @@ async function executeProjectContextToolDirect(args) {
                 await fs.writeFile(filePath, content, 'utf-8');
                 return {
                     success: true,
-                    message: 'Updated project context document'
+                    message: 'Updated role context document'
                 };
             }
             default:
@@ -625,124 +654,28 @@ async function executeProjectContextToolDirect(args) {
         }
     }
     catch (error) {
-        console.error('Error executing project context tool:', error);
-        return { success: false, error: error.message || 'Project context tool execution failed' };
+        console.error('Error executing role context tool:', error);
+        return { success: false, error: error.message || 'Role context tool execution failed' };
     }
 }
-// Architecture context tool - read/write the architecture document
-async function executeArchitectureContextToolDirect(args) {
-    const { operation, content, old_text, new_text } = args;
-    try {
-        const contextPath = getContextBasePath();
-        const filePath = join(contextPath, 'architecture.md');
-        switch (operation) {
-            case 'get': {
-                try {
-                    const fileContent = await fs.readFile(filePath, 'utf-8');
-                    const parsed = matter(fileContent);
-                    return {
-                        success: true,
-                        data: {
-                            content: parsed.content,
-                            frontmatter: parsed.data,
-                            raw: fileContent
-                        },
-                        message: 'Retrieved architecture context'
-                    };
-                }
-                catch (err) {
-                    if (err.code === 'ENOENT') {
-                        return {
-                            success: true,
-                            data: { content: '', frontmatter: {}, raw: '' },
-                            message: 'Architecture context document does not exist yet. You can create it with an update operation.'
-                        };
-                    }
-                    throw err;
-                }
-            }
-            case 'append': {
-                if (!content) {
-                    return { success: false, error: 'Content is required for append operation' };
-                }
-                await fs.mkdir(contextPath, { recursive: true });
-                // Read existing content if file exists
-                let existingContent = '';
-                try {
-                    existingContent = await fs.readFile(filePath, 'utf-8');
-                }
-                catch (err) {
-                    if (err.code !== 'ENOENT')
-                        throw err;
-                }
-                // Append new content with a newline separator
-                const newContent = existingContent
-                    ? existingContent.trimEnd() + '\n\n' + content
-                    : content;
-                await fs.writeFile(filePath, newContent, 'utf-8');
-                return {
-                    success: true,
-                    message: 'Appended content to architecture context document'
-                };
-            }
-            case 'replace_section': {
-                if (!old_text || !new_text) {
-                    return { success: false, error: 'Both old_text and new_text are required for replace_section operation' };
-                }
-                // Read existing content
-                let existingContent = '';
-                try {
-                    existingContent = await fs.readFile(filePath, 'utf-8');
-                }
-                catch (err) {
-                    if (err.code === 'ENOENT') {
-                        return { success: false, error: 'Architecture context document does not exist. Use append or update to create it first.' };
-                    }
-                    throw err;
-                }
-                // Check if old_text exists in the document
-                if (!existingContent.includes(old_text)) {
-                    return {
-                        success: false,
-                        error: 'Could not find the specified text in the document. The text may have been paraphrased or changed.',
-                        fallback_markdown: new_text,
-                        suggestion: 'Here is the replacement text. You can copy it and manually edit the document at /context/architecture'
-                    };
-                }
-                // Replace the text
-                const updatedContent = existingContent.replace(old_text, new_text);
-                await fs.writeFile(filePath, updatedContent, 'utf-8');
-                return {
-                    success: true,
-                    message: 'Replaced section in architecture context document'
-                };
-            }
-            case 'update': {
-                if (!content) {
-                    return { success: false, error: 'Content is required for update operation' };
-                }
-                await fs.mkdir(contextPath, { recursive: true });
-                await fs.writeFile(filePath, content, 'utf-8');
-                return {
-                    success: true,
-                    message: 'Updated architecture context document'
-                };
-            }
-            default:
-                return { success: false, error: `Unknown operation: ${operation}. Use 'get', 'append', 'replace_section', or 'update'.` };
-        }
-    }
-    catch (error) {
-        console.error('Error executing architecture context tool:', error);
-        return { success: false, error: error.message || 'Architecture context tool execution failed' };
-    }
+// Agents context tool - read/write the agents definition document
+async function executeAgentsContextToolDirect(args) {
+    return executeGenericContextToolDirect('agents', args);
 }
-// Role context tool - read/write the role definition document
-async function executeRoleContextToolDirect(args) {
+// Team context tool - read/write the team definition document
+async function executeTeamContextToolDirect(args) {
+    return executeGenericContextToolDirect('team', args);
+}
+// Memory context tool - read/write the memory document
+async function executeMemoryContextToolDirect(args) {
+    return executeGenericContextToolDirect('memory', args);
+}
+async function executeGenericContextToolDirect(contextType, args) {
     const { operation, content, old_text, new_text } = args;
+    const label = contextType.charAt(0).toUpperCase() + contextType.slice(1);
     try {
         const contextPath = getContextBasePath();
-        const filePath = join(contextPath, 'role.md');
+        const filePath = join(contextPath, `${contextType}.md`);
         switch (operation) {
             case 'get': {
                 try {
@@ -755,7 +688,7 @@ async function executeRoleContextToolDirect(args) {
                             frontmatter: parsed.data,
                             raw: fileContent
                         },
-                        message: 'Retrieved role context'
+                        message: `Retrieved ${contextType} context`
                     };
                 }
                 catch (err) {
@@ -763,7 +696,7 @@ async function executeRoleContextToolDirect(args) {
                         return {
                             success: true,
                             data: { content: '', frontmatter: {}, raw: '' },
-                            message: 'Role context document does not exist yet. You can create it with an update operation.'
+                            message: `${label} context document does not exist yet. You can create it with an update operation.`
                         };
                     }
                     throw err;
@@ -774,7 +707,6 @@ async function executeRoleContextToolDirect(args) {
                     return { success: false, error: 'Content is required for append operation' };
                 }
                 await fs.mkdir(contextPath, { recursive: true });
-                // Read existing content if file exists
                 let existingContent = '';
                 try {
                     existingContent = await fs.readFile(filePath, 'utf-8');
@@ -783,46 +715,42 @@ async function executeRoleContextToolDirect(args) {
                     if (err.code !== 'ENOENT')
                         throw err;
                 }
-                // Append new content with a newline separator
                 const newContent = existingContent
                     ? existingContent.trimEnd() + '\n\n' + content
                     : content;
                 await fs.writeFile(filePath, newContent, 'utf-8');
                 return {
                     success: true,
-                    message: 'Appended content to role context document'
+                    message: `Appended content to ${contextType} context document`
                 };
             }
             case 'replace_section': {
                 if (!old_text || !new_text) {
                     return { success: false, error: 'Both old_text and new_text are required for replace_section operation' };
                 }
-                // Read existing content
                 let existingContent = '';
                 try {
                     existingContent = await fs.readFile(filePath, 'utf-8');
                 }
                 catch (err) {
                     if (err.code === 'ENOENT') {
-                        return { success: false, error: 'Role context document does not exist. Use append or update to create it first.' };
+                        return { success: false, error: `${label} context document does not exist. Use append or update to create it first.` };
                     }
                     throw err;
                 }
-                // Check if old_text exists in the document
                 if (!existingContent.includes(old_text)) {
                     return {
                         success: false,
                         error: 'Could not find the specified text in the document. The text may have been paraphrased or changed.',
                         fallback_markdown: new_text,
-                        suggestion: 'Here is the replacement text. You can copy it and manually edit the document at /context/role'
+                        suggestion: `Here is the replacement text. You can copy it and manually edit the document at /context/${contextType}`
                     };
                 }
-                // Replace the text
                 const updatedContent = existingContent.replace(old_text, new_text);
                 await fs.writeFile(filePath, updatedContent, 'utf-8');
                 return {
                     success: true,
-                    message: 'Replaced section in role context document'
+                    message: `Replaced section in ${contextType} context document`
                 };
             }
             case 'update': {
@@ -833,7 +761,7 @@ async function executeRoleContextToolDirect(args) {
                 await fs.writeFile(filePath, content, 'utf-8');
                 return {
                     success: true,
-                    message: 'Updated role context document'
+                    message: `Updated ${contextType} context document`
                 };
             }
             default:
@@ -841,8 +769,8 @@ async function executeRoleContextToolDirect(args) {
         }
     }
     catch (error) {
-        console.error('Error executing role context tool:', error);
-        return { success: false, error: error.message || 'Role context tool execution failed' };
+        console.error(`Error executing ${contextType} context tool:`, error);
+        return { success: false, error: error.message || `${label} context tool execution failed` };
     }
 }
 // ─── Resources Tool ─────────────────────────────────────────────────────────
@@ -1352,13 +1280,147 @@ function readRoleContext() {
     catch { }
     return null;
 }
+function readMemoryContext() {
+    try {
+        const contextPath = getContextBasePath();
+        const memoryPath = join(contextPath, 'memory.md');
+        if (existsSync(memoryPath)) {
+            return readFileSync(memoryPath, 'utf-8');
+        }
+    }
+    catch { }
+    return null;
+}
 function getSystemPrompt() {
     const basePrompt = readSharedPrompt('coconut-assistant') ||
         `You are the Coconut 🥥 AI assistant for agent-native development workflows. You help developers with proposals, architecture decisions, planning, and execution.`;
-    // Add role context if it exists
     const roleContent = readRoleContext();
+    const memoryContent = readMemoryContext();
+    let result = basePrompt;
     if (roleContent) {
-        return `${basePrompt}\n\n## Your Role for This Instance\n\n${roleContent}`;
+        result = `${result}\n\n## Your Role for This Instance\n\n${roleContent}`;
+    }
+    if (memoryContent) {
+        result = `${result}\n\n## Memory for This Instance\n\n${memoryContent}`;
+    }
+    return result;
+}
+const COCONUT_HOST = 'https://app.coconut.dev';
+async function executeListConnectorsToolDirect() {
+    const token = getGlobalApiKey('callbackToken');
+    if (!token) {
+        return {
+            success: false,
+            error: 'Callback token not configured. Set it via Settings > API Keys or PUT /api/v1/config?type=global with { "apiKeys": { "callbackToken": "cpt_xxx" } }'
+        };
+    }
+    try {
+        const res = await fetch(`${COCONUT_HOST}/api/connectors/accounts`, {
+            headers: { 'X-Callback-Token': token }
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            return { success: false, error: `Control plane returned ${res.status}: ${body || res.statusText}` };
+        }
+        const data = await res.json();
+        const accounts = Array.isArray(data) ? data : (data.accounts ?? data.data ?? []);
+        return {
+            success: true,
+            data: accounts,
+            count: accounts.length,
+            message: `Found ${accounts.length} connected service${accounts.length === 1 ? '' : 's'}`
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message || 'Failed to list connectors' };
+    }
+}
+async function executeConnectorRequestToolDirect(args) {
+    const { app: appSlug, method, path: apiPath, body, headers: extraHeaders } = args;
+    if (!appSlug || !method || !apiPath) {
+        return { success: false, error: 'app, method, and path are required' };
+    }
+    const token = getGlobalApiKey('callbackToken');
+    if (!token) {
+        return {
+            success: false,
+            error: 'Callback token not configured. Set it via Settings > API Keys or PUT /api/v1/config?type=global with { "apiKeys": { "callbackToken": "cpt_xxx" } }'
+        };
+    }
+    try {
+        const accountsRes = await fetch(`${COCONUT_HOST}/api/connectors/accounts`, {
+            headers: { 'X-Callback-Token': token }
+        });
+        if (!accountsRes.ok) {
+            const errBody = await accountsRes.text().catch(() => '');
+            return { success: false, error: `Failed to fetch accounts (${accountsRes.status}): ${errBody || accountsRes.statusText}` };
+        }
+        const accountsData = await accountsRes.json();
+        const accounts = Array.isArray(accountsData) ? accountsData : (accountsData.accounts ?? accountsData.data ?? []);
+        const account = accounts.find((a) => a.appSlug === appSlug || a.appName?.toLowerCase() === appSlug.toLowerCase());
+        if (!account) {
+            return {
+                success: false,
+                error: `No connected account found for "${appSlug}"`,
+                available: accounts.map((a) => a.appSlug || a.appName)
+            };
+        }
+        const url = resolveConnectorUrl(appSlug, apiPath);
+        if (!url) {
+            return {
+                success: false,
+                error: `Unknown app "${appSlug}" and path is not a full URL. Use a full URL (https://...) or a known app slug.`
+            };
+        }
+        let parsedBody = undefined;
+        if (body) {
+            try {
+                parsedBody = typeof body === 'string' ? JSON.parse(body) : body;
+            }
+            catch {
+                return { success: false, error: 'Invalid JSON in body parameter' };
+            }
+        }
+        let parsedHeaders = {};
+        if (extraHeaders) {
+            try {
+                parsedHeaders = typeof extraHeaders === 'string' ? JSON.parse(extraHeaders) : extraHeaders;
+            }
+            catch {
+                return { success: false, error: 'Invalid JSON in headers parameter' };
+            }
+        }
+        const proxyPayload = {
+            accountId: account.accountId,
+            url,
+            method: method.toUpperCase()
+        };
+        if (parsedBody !== undefined)
+            proxyPayload.body = parsedBody;
+        if (Object.keys(parsedHeaders).length > 0)
+            proxyPayload.headers = parsedHeaders;
+        const proxyRes = await fetch(`${COCONUT_HOST}/api/connectors/proxy`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Callback-Token': token
+            },
+            body: JSON.stringify(proxyPayload)
+        });
+        if (!proxyRes.ok) {
+            const errBody = await proxyRes.text().catch(() => '');
+            return { success: false, error: `Proxy request failed (${proxyRes.status}): ${errBody || proxyRes.statusText}` };
+        }
+        const responseData = await proxyRes.json().catch(async () => {
+            return await proxyRes.text().catch(() => null);
+        });
+        return {
+            success: true,
+            data: responseData,
+            message: `${method.toUpperCase()} ${apiPath} via ${appSlug}`
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message || 'Connector request failed' };
     }
-    return basePrompt;
 }

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

@@ -124,12 +124,12 @@ export async function PUT(c) {
         }
     }
     else {
-        // Update project config (coconut object)
+        // Update project config
         try {
             const body = await c.req.json();
-            const { coconut } = body;
-            if (!coconut) {
-                return c.json({ error: 'Missing coconut object in request body' }, 400);
+            const { coconut, scripts } = body;
+            if (!coconut && scripts === undefined) {
+                return c.json({ error: 'Missing coconut or scripts in request body' }, 400);
             }
             const configPath = await getConfigPath();
             if (!configPath) {
@@ -152,11 +152,15 @@ export async function PUT(c) {
             // Ensure .nut directory exists
             const configDir = path.dirname(configPath);
             await fs.mkdir(configDir, { recursive: true });
-            // Merge coconut object with existing config
-            config.coconut = {
-                ...config.coconut,
-                ...coconut,
-            };
+            if (coconut) {
+                config.coconut = {
+                    ...config.coconut,
+                    ...coconut,
+                };
+            }
+            if (scripts !== undefined) {
+                config.scripts = scripts;
+            }
             // Save config
             await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
             return c.json({

package/dist/routes/api/v1/context/agents/route.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;