@lovelybunch/api 1.0.69-alpha.11 → 1.0.69-alpha.14

package/dist/lib/git.js

@@ -138,21 +138,28 @@ export async function pushCurrent() {
     try {
         const tokenRecord = await readGithubToken();
         if (tokenRecord && isGithubTokenValid(tokenRecord)) {
+            console.log('[git] Found valid GitHub token, ensuring it\'s in credential helper');
             // Ensure token is stored in credential helper
             try {
                 await storeCredentials('x-access-token', tokenRecord.token);
+                console.log('[git] Successfully stored token in credential helper');
             }
             catch (credError) {
                 // Log but don't fail - credential helper might already have it
-                console.log('[git] Note: Could not update credential helper:', credError?.message);
+                console.error('[git] Failed to store token in credential helper:', credError?.message);
             }
         }
+        else {
+            console.log('[git] No valid GitHub token found');
+        }
     }
     catch (tokenError) {
         // Log but don't fail - might not be using GitHub auth
-        console.log('[git] Note: Could not read GitHub token:', tokenError);
+        console.error('[git] Error reading GitHub token:', tokenError);
     }
+    console.log('[git] Executing git push...');
     const { stdout } = await runGit(['push'], { timeout: 30000 }); // 30 second timeout for push
+    console.log('[git] Push completed successfully');
     return stdout;
 }
 export async function pullCurrent(strategy = 'rebase') {

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/routes/api/v1/jobs/[id]/runs/[runId]/log/route.d.ts

@@ -1,11 +1,11 @@
 import { Context } from 'hono';
-export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">) | (Response & import("hono").TypedResponse<{
+export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
     success: false;
     error: {
         code: string;
         message: string;
     };
-}, 404, "json">) | (Response & import("hono").TypedResponse<{
+}, 404, "json">) | (Response & import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "text">) | (Response & import("hono").TypedResponse<{
     success: false;
     error: {
         code: string;

package/package.json

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