@lovelybunch/api 1.0.69-alpha.12 → 1.0.69-alpha.15

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

@@ -26,7 +26,18 @@ export class JobScheduler {
             return;
         const jobs = await this.store.listJobs();
         for (const job of jobs) {
-            await this.register(job);
+            // Skip corrupted jobs (jobs with _error field)
+            if (job._error) {
+                console.warn(`Skipping corrupted job ${job.id}: ${job._error}`);
+                continue;
+            }
+            try {
+                await this.register(job);
+            }
+            catch (error) {
+                console.error(`Failed to register job ${job.id}:`, error);
+                // Continue with other jobs even if one fails
+            }
         }
         this.initialized = true;
     }

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

@@ -8,6 +8,7 @@ export declare class JobStore {
     private getJobFilePath;
     listJobs(): Promise<ScheduledJob[]>;
     getJob(id: string): Promise<ScheduledJob | null>;
+    private createErrorJob;
     saveJob(job: ScheduledJob, bodyContent?: string): Promise<void>;
     deleteJob(id: string): Promise<boolean>;
     appendRun(jobId: string, run: ScheduledJobRun): Promise<ScheduledJob>;

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

@@ -90,15 +90,53 @@ export class JobStore {
         try {
             const filePath = await this.getJobFilePath(id);
             const content = await fs.readFile(filePath, 'utf-8');
+            // Handle empty files
+            if (!content || content.trim().length === 0) {
+                return this.createErrorJob(id, 'Job file is empty');
+            }
             const { data, content: body } = matter(content);
+            // Validate that we have at least an id field
+            if (!data || typeof data !== 'object' || !data.id) {
+                return this.createErrorJob(id, 'Job file is missing required id field');
+            }
             return this.fromFrontmatter(data, body);
         }
         catch (error) {
             if (error?.code === 'ENOENT')
                 return null;
-            throw error;
+            // Handle parsing errors (e.g., invalid YAML, corrupted frontmatter)
+            const errorMessage = error?.message || 'Unknown error parsing job file';
+            return this.createErrorJob(id, errorMessage);
         }
     }
+    createErrorJob(id, errorMessage) {
+        const now = new Date();
+        return {
+            id,
+            name: id,
+            description: undefined,
+            prompt: '',
+            model: 'anthropic/claude-sonnet-4',
+            status: 'paused',
+            schedule: {
+                type: 'interval',
+                hours: 6,
+                daysOfWeek: ['monday', 'tuesday', 'wednesday', 'thursday', 'friday']
+            },
+            metadata: {
+                createdAt: now,
+                updatedAt: now,
+                lastRunAt: undefined,
+                nextRunAt: undefined,
+            },
+            runs: [],
+            tags: [],
+            contextPaths: [],
+            // Store error in a way that won't break serialization
+            // We'll use a special tag to mark error jobs
+            _error: errorMessage
+        };
+    }
     async saveJob(job, bodyContent = '') {
         const filePath = await this.getJobFilePath(job.id);
         const normalizedJob = {
@@ -138,34 +176,118 @@ export class JobStore {
         if (!data?.id) {
             throw new Error('Scheduled job is missing required id field');
         }
+        // Validate and sanitize fields to prevent issues with corrupted data
         const createdAt = toDate(data.metadata?.createdAt) ?? new Date();
         const updatedAt = toDate(data.metadata?.updatedAt) ?? createdAt;
+        // Validate schedule structure
+        let schedule;
+        if (data.schedule && typeof data.schedule === 'object') {
+            if (data.schedule.type === 'cron') {
+                const cronSchedule = data.schedule;
+                if (typeof cronSchedule.expression === 'string' && cronSchedule.expression.trim()) {
+                    schedule = {
+                        type: 'cron',
+                        expression: cronSchedule.expression.trim(),
+                        timezone: typeof cronSchedule.timezone === 'string' ? cronSchedule.timezone : undefined,
+                        description: typeof cronSchedule.description === 'string' ? cronSchedule.description : undefined,
+                    };
+                }
+                else {
+                    // Invalid cron schedule, fall back to default
+                    schedule = {
+                        type: 'interval',
+                        hours: 6,
+                        daysOfWeek: ['monday', 'tuesday', 'wednesday', 'thursday', 'friday']
+                    };
+                }
+            }
+            else {
+                const intervalSchedule = data.schedule;
+                const hours = typeof intervalSchedule.hours === 'number' && intervalSchedule.hours >= 1
+                    ? intervalSchedule.hours
+                    : 6;
+                const daysOfWeek = Array.isArray(intervalSchedule.daysOfWeek)
+                    ? intervalSchedule.daysOfWeek.filter((day) => typeof day === 'string' && ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday'].includes(day.toLowerCase()))
+                    : ['monday', 'tuesday', 'wednesday', 'thursday', 'friday'];
+                schedule = {
+                    type: 'interval',
+                    hours,
+                    daysOfWeek: daysOfWeek.length > 0 ? daysOfWeek : ['monday', 'tuesday', 'wednesday', 'thursday', 'friday'],
+                    anchorHour: typeof intervalSchedule.anchorHour === 'number' && intervalSchedule.anchorHour >= 0 && intervalSchedule.anchorHour <= 23
+                        ? intervalSchedule.anchorHour
+                        : undefined,
+                };
+            }
+        }
+        else {
+            schedule = {
+                type: 'interval',
+                hours: 6,
+                daysOfWeek: ['monday', 'tuesday', 'wednesday', 'thursday', 'friday']
+            };
+        }
+        // Validate and sanitize runs
         const runs = Array.isArray(data.runs)
-            ? data.runs.map((run) => ({
-                id: run.id ?? `run-${randomUUID()}`,
-                jobId: data.id,
-                trigger: run.trigger,
-                status: run.status,
-                startedAt: toDate(run.startedAt) ?? new Date(),
-                finishedAt: toDate(run.finishedAt),
-                outputPath: run.outputPath,
-                summary: run.summary,
-                error: run.error,
-                cliCommand: run.cliCommand,
-            }))
+            ? data.runs
+                .filter((run) => run && typeof run === 'object')
+                .map((run) => {
+                const startedAt = toDate(run.startedAt);
+                if (!startedAt) {
+                    // Skip runs with invalid dates
+                    return null;
+                }
+                return {
+                    id: typeof run.id === 'string' ? run.id : `run-${randomUUID()}`,
+                    jobId: data.id,
+                    trigger: (run.trigger === 'manual' || run.trigger === 'scheduled') ? run.trigger : 'manual',
+                    status: (['pending', 'running', 'succeeded', 'failed'].includes(run.status)) ? run.status : 'pending',
+                    startedAt,
+                    finishedAt: toDate(run.finishedAt),
+                    outputPath: typeof run.outputPath === 'string' ? run.outputPath : undefined,
+                    summary: typeof run.summary === 'string' ? run.summary : undefined,
+                    error: typeof run.error === 'string' ? run.error : undefined,
+                    cliCommand: typeof run.cliCommand === 'string' ? run.cliCommand : undefined,
+                };
+            })
+                .filter((run) => run !== null)
+            : [];
+        // Validate and sanitize string fields
+        const name = typeof data.name === 'string' && data.name.trim()
+            ? data.name.trim().slice(0, 500) // Limit length
+            : data.id;
+        const description = typeof data.description === 'string'
+            ? data.description.slice(0, 1000) // Limit length
+            : undefined;
+        const prompt = typeof data.prompt === 'string'
+            ? data.prompt.trim() || body.trim()
+            : body.trim();
+        const model = typeof data.model === 'string' && data.model.trim()
+            ? data.model.trim()
+            : 'anthropic/claude-sonnet-4';
+        const status = (data.status === 'active' || data.status === 'paused')
+            ? data.status
+            : 'paused';
+        // Validate arrays
+        const tags = Array.isArray(data.tags)
+            ? data.tags.filter((tag) => typeof tag === 'string').slice(0, 50)
+            : [];
+        const contextPaths = Array.isArray(data.contextPaths)
+            ? data.contextPaths.filter((path) => typeof path === 'string').slice(0, 100)
             : [];
+        const agentIds = Array.isArray(data.agentIds)
+            ? data.agentIds.filter((id) => typeof id === 'string').slice(0, 50)
+            : undefined;
+        const mcpServers = Array.isArray(data.mcpServers)
+            ? data.mcpServers.filter((server) => typeof server === 'string').slice(0, 50)
+            : undefined;
         return {
             id: data.id,
-            name: data.name || data.id,
-            description: data.description,
-            prompt: data.prompt || body.trim(),
-            model: data.model || 'anthropic/claude-sonnet-4',
-            status: data.status || 'paused',
-            schedule: data.schedule ?? {
-                type: 'interval',
-                hours: 6,
-                daysOfWeek: ['monday', 'tuesday', 'wednesday', 'thursday', 'friday']
-            },
+            name,
+            description,
+            prompt,
+            model,
+            status,
+            schedule,
             metadata: {
                 createdAt,
                 updatedAt,
@@ -173,11 +295,11 @@ export class JobStore {
                 nextRunAt: toDate(data.metadata?.nextRunAt),
             },
             runs,
-            tags: data.tags ?? [],
-            contextPaths: data.contextPaths ?? [],
-            agentId: data.agentId,
-            agentIds: data.agentIds,
-            mcpServers: data.mcpServers,
+            tags,
+            contextPaths,
+            agentId: typeof data.agentId === 'string' ? data.agentId : undefined,
+            agentIds,
+            mcpServers,
         };
     }
     toFrontmatter(job) {

package/dist/lib/storage/file-storage.js

@@ -122,19 +122,28 @@ export class FileStorageAdapter {
         // Never allow id to be updated to prevent overwriting other proposals
         const { id: _, ...safeUpdates } = updates;
         // Handle comments separately as they're stored at root level in file format
-        let updated = {
+        // Comments can come from either root level or metadata.comments
+        let commentsToStore = existing.metadata.comments || [];
+        if (safeUpdates.comments) {
+            // If comments are provided at root level, use them
+            commentsToStore = safeUpdates.comments;
+        }
+        else if (safeUpdates.metadata?.comments) {
+            // If comments are provided in metadata, use them
+            commentsToStore = safeUpdates.metadata.comments;
+        }
+        const updated = {
             ...existing,
             ...safeUpdates,
             metadata: {
                 ...existing.metadata,
                 ...safeUpdates.metadata,
-                updatedAt: new Date()
-            }
+                updatedAt: new Date(),
+                comments: commentsToStore
+            },
+            // Store comments at the root level for the file format
+            comments: commentsToStore
         };
-        // If comments are being updated, store them at the root level for the file format
-        if (safeUpdates.comments) {
-            updated.comments = safeUpdates.comments;
-        }
         await this.createCP(updated);
     }
     async deleteCP(id) {

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

@@ -1,7 +1,8 @@
 import { Hono } from 'hono';
-import { GET, PUT, TEST } from './route.js';
+import { GET, PUT, TEST, EXPORT } 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,3 +30,14 @@ 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

@@ -240,3 +240,107 @@ export async function TEST(c) {
         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}`;
+            }
+            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('');
+            }
+            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
+        });
+    }
+    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);
+    }
+}

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

@@ -52,10 +52,11 @@ export async function GET(c) {
         }
         const url = new URL(c.req.url);
         const download = url.searchParams.get('download');
+        // Return the actual file (either for download or inline display)
+        const filePath = path.join(FILES_DIR, resource.path);
+        const fileBuffer = await fs.readFile(filePath);
         if (download === 'true') {
-            // Return the actual file
-            const filePath = path.join(FILES_DIR, resource.path);
-            const fileBuffer = await fs.readFile(filePath);
+            // Force download with Content-Disposition: attachment
             return new Response(fileBuffer, {
                 headers: {
                     'Content-Type': resource.type,
@@ -64,10 +65,13 @@ export async function GET(c) {
                 }
             });
         }
-        // Return resource metadata
-        return c.json({
-            success: true,
-            data: resource
+        // Serve file inline (for preview in iframe, img, video, etc.)
+        return new Response(fileBuffer, {
+            headers: {
+                'Content-Type': resource.type,
+                'Content-Length': resource.size.toString(),
+                'Cache-Control': 'public, max-age=31536000'
+            }
         });
     }
     catch (error) {

package/dist/routes/api/v1/resources/generate/index.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;

package/dist/routes/api/v1/resources/generate/index.js

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import { POST } from './route.js';
+const app = new Hono();
+app.post('/', POST);
+export default app;

package/dist/routes/api/v1/resources/generate/route.d.ts

@@ -0,0 +1,19 @@
+import { Context } from 'hono';
+export declare function POST(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: string;
+    };
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        imageUrl: string;
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: {
+        code: string;
+        message: any;
+    };
+}, 500, "json">)>;