@lovelybunch/api 1.0.66 → 1.0.67

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

@@ -0,0 +1,158 @@
+import { Hono } from 'hono';
+import path from 'path';
+import { promises as fs } from 'fs';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { MarkdownStorageAdapter } from '@lovelybunch/core';
+import { getGlobalJobScheduler } from '../../../../lib/jobs/global-job-scheduler.js';
+const execFileAsync = promisify(execFile);
+const onboarding = new Hono();
+function isOnboardingActive() {
+    return process.env.COCONUT_ONBOARDING_MODE === '1';
+}
+function getProjectRoot() {
+    if (process.env.GAIT_DATA_PATH) {
+        return path.resolve(process.env.GAIT_DATA_PATH);
+    }
+    return process.cwd();
+}
+async function nutDirectoryExists(root) {
+    try {
+        await fs.access(path.join(root, '.nut'));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isGitRepository(root) {
+    try {
+        await execFileAsync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: root });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function sanitizeString(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+async function ensureSchedulerStarted() {
+    try {
+        const scheduler = getGlobalJobScheduler();
+        await scheduler.initialize();
+    }
+    catch (error) {
+        console.error('Failed to initialize job scheduler after onboarding:', error);
+    }
+}
+onboarding.get('/status', async (c) => {
+    const root = getProjectRoot();
+    const coconutInitialized = await nutDirectoryExists(root);
+    const gitInitialized = await isGitRepository(root);
+    return c.json({
+        success: true,
+        data: {
+            onboardingActive: isOnboardingActive() && !coconutInitialized,
+            coconutInitialized,
+            gitInitialized
+        }
+    });
+});
+onboarding.post('/start-empty', async (c) => {
+    const root = getProjectRoot();
+    const body = await c.req.json().catch(() => ({}));
+    const name = sanitizeString(body?.name);
+    const description = sanitizeString(body?.description);
+    if (!name) {
+        return c.json({ success: false, error: 'Repository name is required' }, 400);
+    }
+    if (!description) {
+        return c.json({ success: false, error: 'Repository description is required' }, 400);
+    }
+    if (await nutDirectoryExists(root)) {
+        return c.json({ success: false, error: 'Coconut is already initialized in this directory' }, 409);
+    }
+    try {
+        const storage = new MarkdownStorageAdapter(path.join(root, '.nut'));
+        await storage.init();
+        const config = (await storage.loadConfig()) ?? {
+            version: '1.0.0',
+            repository: {
+                name,
+                description
+            },
+            policies: {
+                requireApproval: true,
+                minApprovers: 1,
+                allowSelfApproval: false,
+                autoMerge: false
+            },
+            storage: {
+                type: 'file',
+                path: '.nut'
+            }
+        };
+        config.repository.name = name;
+        config.repository.description = description;
+        await storage.saveConfig(config);
+        const gitAlreadyInitialized = await isGitRepository(root);
+        if (!gitAlreadyInitialized) {
+            await execFileAsync('git', ['init'], { cwd: root });
+        }
+        await ensureSchedulerStarted();
+        return c.json({
+            success: true,
+            data: {
+                coconutInitialized: true,
+                gitInitialized: true
+            }
+        }, 201);
+    }
+    catch (error) {
+        console.error('Failed to initialize Coconut during onboarding:', error);
+        return c.json({
+            success: false,
+            error: error?.message || 'Failed to initialize Coconut'
+        }, 500);
+    }
+});
+onboarding.post('/clone', async (c) => {
+    const root = getProjectRoot();
+    const body = await c.req.json().catch(() => ({}));
+    const repositoryUrl = sanitizeString(body?.url);
+    if (!repositoryUrl) {
+        return c.json({ success: false, error: 'Repository URL is required' }, 400);
+    }
+    if (await nutDirectoryExists(root)) {
+        return c.json({ success: false, error: 'Coconut is already initialized in this directory' }, 409);
+    }
+    if (await isGitRepository(root)) {
+        return c.json({ success: false, error: 'Git repository already exists in this directory' }, 409);
+    }
+    try {
+        await execFileAsync('git', ['clone', repositoryUrl, '.'], { cwd: root });
+        const coconutInitialized = await nutDirectoryExists(root);
+        const gitInitialized = await isGitRepository(root);
+        if (coconutInitialized) {
+            await ensureSchedulerStarted();
+        }
+        return c.json({
+            success: true,
+            data: {
+                coconutInitialized,
+                gitInitialized
+            }
+        });
+    }
+    catch (error) {
+        console.error('Failed to clone repository during onboarding:', error);
+        const stderr = error?.stderr?.toString?.() || '';
+        const message = stderr.trim() || error?.message || 'Failed to clone repository';
+        return c.json({
+            success: false,
+            error: message
+        }, 400);
+    }
+});
+export default onboarding;

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

@@ -1,5 +1,7 @@
 import { FileStorageAdapter } from '../../../../../lib/storage/file-storage.js';
+import { getLogger } from '@lovelybunch/core/logging';
 const storage = new FileStorageAdapter();
+// Logger is lazily initialized inside handlers to use server config
 export async function GET(c) {
     try {
         const id = c.req.param('id');
@@ -52,6 +54,43 @@ export async function PATCH(c) {
         await storage.updateCP(id, finalUpdates);
         // Fetch the updated proposal
         const updatedProposal = await storage.getCP(id);
+        // Determine what changed
+        const changedFields = Object.keys(updates);
+        const oldStatus = existing.status;
+        const newStatus = updatedProposal?.status || existing.status;
+        // Log proposal.update event
+        const logger = getLogger();
+        logger.log({
+            kind: 'proposal.update',
+            actor: updatedProposal?.author.type === 'agent'
+                ? `agent:${updatedProposal.author.name}`
+                : `human:${updatedProposal?.author.email || 'unknown'}`,
+            subject: `proposal:${id}`,
+            tags: ['proposal'],
+            payload: {
+                id,
+                changes: changedFields,
+                oldStatus,
+                newStatus
+            }
+        });
+        // If status changed, also log a status.change event
+        if (oldStatus !== newStatus) {
+            logger.log({
+                kind: 'proposal.status.change',
+                actor: updatedProposal?.author.type === 'agent'
+                    ? `agent:${updatedProposal.author.name}`
+                    : `human:${updatedProposal?.author.email || 'unknown'}`,
+                subject: `proposal:${id}`,
+                tags: ['proposal', 'status'],
+                payload: {
+                    id,
+                    from: oldStatus,
+                    to: newStatus,
+                    reason: null
+                }
+            });
+        }
         return c.json({
             success: true,
             data: updatedProposal
@@ -80,7 +119,25 @@ export async function PATCH(c) {
 export async function DELETE(c) {
     try {
         const id = c.req.param('id');
+        // Get proposal info before deleting
+        const proposal = await storage.getCP(id);
         await storage.deleteCP(id);
+        // Log the deletion event
+        if (proposal) {
+            const logger = getLogger();
+            logger.log({
+                kind: 'proposal.delete',
+                actor: proposal.author.type === 'agent'
+                    ? `agent:${proposal.author.name}`
+                    : `human:${proposal.author.email || 'unknown'}`,
+                subject: `proposal:${id}`,
+                tags: ['proposal'],
+                payload: {
+                    id,
+                    intent: proposal.intent
+                }
+            });
+        }
         return c.json({
             success: true,
             message: `Proposal ${id} deleted successfully`

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

@@ -1,7 +1,9 @@
 import { FileStorageAdapter } from '../../../../lib/storage/file-storage.js';
 import { getAuthorInfo } from '../../../../lib/user-preferences.js';
 import Fuse from 'fuse.js';
+import { getLogger } from '@lovelybunch/core/logging';
 const storage = new FileStorageAdapter();
+// Logger is lazily initialized inside handlers to use server config
 export async function GET(c) {
     try {
         const url = new URL(c.req.url);
@@ -85,6 +87,22 @@ export async function POST(c) {
             productSpecRef: body.productSpecRef
         };
         await storage.createCP(proposal);
+        // Log the proposal creation event
+        const logger = getLogger();
+        logger.log({
+            kind: 'proposal.create',
+            actor: proposal.author.type === 'agent'
+                ? `agent:${proposal.author.name}`
+                : `human:${proposal.author.email}`,
+            subject: `proposal:${proposal.id}`,
+            tags: ['proposal'],
+            payload: {
+                id: proposal.id,
+                intent: proposal.intent,
+                priority: proposal.metadata.priority,
+                author: proposal.author
+            }
+        });
         return c.json({
             success: true,
             data: proposal

package/dist/server-with-static.js

@@ -10,10 +10,70 @@ import fs from 'fs';
 import { getGlobalTerminalManager } from './lib/terminal/global-manager.js';
 import { getGlobalJobScheduler } from './lib/jobs/global-job-scheduler.js';
 import { fileURLToPath } from 'url';
+import { getLogger } from '@lovelybunch/core/logging';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // Load environment variables from .env file in project root
 dotenvConfig({ path: path.resolve(__dirname, '../../../.env') });
+// Helper: Find .nut directory by traversing up from cwd
+// Only returns a .nut directory if it contains config.json
+function findNutDirectorySync() {
+    let currentDir = process.cwd();
+    while (currentDir !== path.parse(currentDir).root) {
+        const nutPath = path.join(currentDir, '.nut');
+        const configPath = path.join(nutPath, 'config.json');
+        // Check if .nut exists AND has config.json
+        if (fs.existsSync(nutPath) && fs.existsSync(configPath)) {
+            return nutPath;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+}
+// Initialize logger with config from .nut/config.json
+// This must happen BEFORE importing route handlers (they call getLogger at module level)
+console.log('🔍 Initializing activity logging...');
+try {
+    const nutDir = findNutDirectorySync();
+    if (nutDir) {
+        const projectRoot = path.dirname(nutDir);
+        const configPath = path.join(nutDir, 'config.json');
+        console.log('   Project root:', projectRoot);
+        console.log('   Config path:', configPath);
+        const configData = fs.readFileSync(configPath, 'utf-8');
+        const config = JSON.parse(configData);
+        if (config.logging?.enabled) {
+            const logsDir = path.resolve(projectRoot, config.logging?.location || '.nut/logs');
+            const logger = getLogger({
+                coconutId: config.coconut?.id || 'unknown.coconut',
+                logsDir: logsDir,
+                rotateBytes: config.logging?.rotateBytes || 128 * 1024 * 1024
+            });
+            console.log('📝 Activity logging ENABLED');
+            console.log('   Logs directory:', logsDir);
+            console.log('   Coconut ID:', config.coconut?.id || 'unknown.coconut');
+            // Test log immediately
+            logger.log({
+                kind: 'system.startup',
+                actor: 'system',
+                subject: 'server',
+                tags: ['system', 'startup'],
+                payload: { message: 'Server starting with logging enabled' }
+            });
+            console.log('   ✓ Test event logged');
+        }
+        else {
+            console.log('📝 Activity logging disabled in config');
+        }
+    }
+    else {
+        console.log('   ✗ .nut directory not found');
+    }
+}
+catch (error) {
+    console.error('⚠️  Failed to initialize logger:');
+    console.error(error);
+}
 const app = new Hono();
 // Enable CORS for development
 app.use('/api/*', cors({
@@ -101,6 +161,7 @@ import agentsById from './routes/api/v1/agents/[id]/index.js';
 import git from './routes/api/v1/git/index.js';
 import mcp from './routes/api/v1/mcp/index.js';
 import jobs from './routes/api/v1/jobs/index.js';
+import events from './routes/api/v1/events/index.js';
 // Register API routes FIRST
 console.log('🔗 Registering API routes...');
 app.route('/api/v1/auth', auth);
@@ -125,6 +186,7 @@ app.route('/api/v1/agents/:id', agentsById);
 app.route('/api/v1/git', git);
 app.route('/api/v1/mcp', mcp);
 app.route('/api/v1/jobs', jobs);
+app.route('/api/v1/events', events);
 console.log('✅ API routes registered');
 // Initialize background services
 getGlobalJobScheduler();

package/dist/server.js

@@ -8,10 +8,71 @@ import { getGlobalTerminalManager } from './lib/terminal/global-manager.js';
 import { getGlobalJobScheduler } from './lib/jobs/global-job-scheduler.js';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import fs from 'fs';
+import { getLogger } from '@lovelybunch/core/logging';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // Load environment variables from .env file in project root
 dotenvConfig({ path: path.resolve(__dirname, '../../../.env') });
+// Helper: Find .nut directory by traversing up from cwd
+// Only returns a .nut directory if it contains config.json
+function findNutDirectorySync() {
+    let currentDir = process.cwd();
+    while (currentDir !== path.parse(currentDir).root) {
+        const nutPath = path.join(currentDir, '.nut');
+        const configPath = path.join(nutPath, 'config.json');
+        // Check if .nut exists AND has config.json
+        if (fs.existsSync(nutPath) && fs.existsSync(configPath)) {
+            return nutPath;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+}
+// Initialize logger with config from .nut/config.json
+// This must happen BEFORE importing route handlers (they call getLogger at module level)
+console.log('🔍 Initializing activity logging...');
+try {
+    const nutDir = findNutDirectorySync();
+    if (nutDir) {
+        const projectRoot = path.dirname(nutDir);
+        const configPath = path.join(nutDir, 'config.json');
+        console.log('   Project root:', projectRoot);
+        console.log('   Config path:', configPath);
+        const configData = fs.readFileSync(configPath, 'utf-8');
+        const config = JSON.parse(configData);
+        if (config.logging?.enabled) {
+            const logsDir = path.resolve(projectRoot, config.logging?.location || '.nut/logs');
+            const logger = getLogger({
+                coconutId: config.coconut?.id || 'unknown.coconut',
+                logsDir: logsDir,
+                rotateBytes: config.logging?.rotateBytes || 128 * 1024 * 1024
+            });
+            console.log('📝 Activity logging ENABLED');
+            console.log('   Logs directory:', logsDir);
+            console.log('   Coconut ID:', config.coconut?.id || 'unknown.coconut');
+            // Test log immediately
+            logger.log({
+                kind: 'system.startup',
+                actor: 'system',
+                subject: 'server',
+                tags: ['system', 'startup'],
+                payload: { message: 'Server starting with logging enabled' }
+            });
+            console.log('   ✓ Test event logged');
+        }
+        else {
+            console.log('📝 Activity logging disabled in config');
+        }
+    }
+    else {
+        console.log('   ✗ .nut directory not found');
+    }
+}
+catch (error) {
+    console.error('⚠️  Failed to initialize logger:');
+    console.error(error);
+}
 const app = new Hono();
 // Enable CORS for frontend
 app.use('*', cors({
@@ -100,6 +161,7 @@ import git from './routes/api/v1/git/index.js';
 import mcp from './routes/api/v1/mcp/index.js';
 import symlinks from './routes/api/v1/symlinks/index.js';
 import jobs from './routes/api/v1/jobs/index.js';
+import events from './routes/api/v1/events/index.js';
 // Register API routes
 app.route('/api/v1/auth', auth);
 app.route('/api/v1/auth-settings', authSettings);
@@ -124,6 +186,7 @@ app.route('/api/v1/git', git);
 app.route('/api/v1/mcp', mcp);
 app.route('/api/v1/symlinks', symlinks);
 app.route('/api/v1/jobs', jobs);
+app.route('/api/v1/events', events);
 // Health check endpoint
 app.get('/health', (c) => {
     return c.json({ status: 'ok', timestamp: new Date().toISOString() });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovelybunch/api",
-  "version": "1.0.66",
+  "version": "1.0.67",
   "type": "module",
   "main": "dist/server-with-static.js",
   "exports": {
@@ -32,9 +32,9 @@
   "dependencies": {
     "@hono/node-server": "^1.13.7",
     "@hono/node-ws": "^1.0.6",
-    "@lovelybunch/core": "^1.0.66",
-    "@lovelybunch/mcp": "^1.0.66",
-    "@lovelybunch/types": "^1.0.66",
+    "@lovelybunch/core": "^1.0.67",
+    "@lovelybunch/mcp": "^1.0.67",
+    "@lovelybunch/types": "^1.0.67",
     "arctic": "^1.9.2",
     "bcrypt": "^5.1.1",
     "cookie": "^0.6.0",