@lovelybunch/api 1.0.57 → 1.0.59

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

@@ -0,0 +1,309 @@
+import { randomUUID } from 'crypto';
+import { JobStore } from './job-store.js';
+import { JobRunner } from './job-runner.js';
+const DAY_TO_INDEX = {
+    sunday: 0,
+    monday: 1,
+    tuesday: 2,
+    wednesday: 3,
+    thursday: 4,
+    friday: 5,
+    saturday: 6
+};
+export class JobScheduler {
+    store;
+    runner;
+    jobs = new Map();
+    runningJobs = new Set();
+    initialized = false;
+    constructor(store = new JobStore(), runner = new JobRunner()) {
+        this.store = store;
+        this.runner = runner;
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        const jobs = await this.store.listJobs();
+        for (const job of jobs) {
+            await this.register(job);
+        }
+        this.initialized = true;
+    }
+    async register(job) {
+        this.clearTimer(job.id);
+        this.jobs.set(job.id, { job });
+        if (job.status !== 'active') {
+            await this.updateJobMetadata(job, undefined);
+            return;
+        }
+        const nextRun = this.calculateNextRun(job);
+        await this.updateJobMetadata(job, nextRun);
+        if (!nextRun) {
+            console.warn(`No upcoming execution found for job ${job.id}`);
+            return;
+        }
+        const timeUntil = nextRun.getTime() - Date.now();
+        if (timeUntil <= 0) {
+            // Missed window – run immediately to catch up
+            setTimeout(() => {
+                this.execute(job.id, 'scheduled').catch((err) => {
+                    console.error(`Failed to execute scheduled job ${job.id}:`, err);
+                });
+            }, 10);
+            this.jobs.set(job.id, { job: { ...job }, nextRun });
+            return;
+        }
+        const delay = Math.max(0, timeUntil);
+        const timer = setTimeout(() => {
+            this.execute(job.id, 'scheduled').catch((err) => {
+                console.error(`Failed to execute scheduled job ${job.id}:`, err);
+            });
+        }, delay);
+        this.jobs.set(job.id, { job: { ...job, metadata: { ...job.metadata } }, timer, nextRun });
+    }
+    async unregister(jobId) {
+        this.clearTimer(jobId);
+        this.jobs.delete(jobId);
+    }
+    async refresh(jobId) {
+        const job = await this.store.getJob(jobId);
+        if (!job) {
+            this.unregister(jobId);
+            return;
+        }
+        await this.register(job);
+    }
+    async runNow(jobId, trigger = 'manual') {
+        await this.initialize();
+        return this.execute(jobId, trigger);
+    }
+    clearTimer(jobId) {
+        const managed = this.jobs.get(jobId);
+        if (managed?.timer) {
+            clearTimeout(managed.timer);
+        }
+    }
+    async execute(jobId, trigger) {
+        if (this.runningJobs.has(jobId)) {
+            console.warn(`Job ${jobId} is already running; skipping concurrent execution`);
+            return null;
+        }
+        const job = await this.store.getJob(jobId);
+        if (!job) {
+            console.warn(`Attempted to run missing job ${jobId}`);
+            return null;
+        }
+        this.runningJobs.add(jobId);
+        const runId = `run-${randomUUID()}`;
+        const start = new Date();
+        const runRecord = {
+            id: runId,
+            jobId: job.id,
+            trigger,
+            status: 'running',
+            startedAt: start,
+            cliCommand: ''
+        };
+        const existingRuns = [runRecord, ...job.runs];
+        job.runs = existingRuns.slice(0, 50);
+        job.metadata.lastRunAt = start;
+        job.metadata.updatedAt = new Date();
+        await this.store.saveJob(job);
+        let outcome = null;
+        try {
+            const result = await this.runner.run(job, runId);
+            runRecord.status = result.status;
+            runRecord.finishedAt = new Date();
+            runRecord.summary = result.summary;
+            runRecord.outputPath = result.outputPath;
+            runRecord.error = result.error;
+            runRecord.cliCommand = result.cliCommand;
+            outcome = { ...runRecord };
+        }
+        catch (error) {
+            runRecord.status = 'failed';
+            runRecord.finishedAt = new Date();
+            runRecord.error = error?.message || 'Unknown error executing scheduled job';
+            runRecord.summary = runRecord.error;
+            outcome = { ...runRecord };
+        }
+        try {
+            await this.store.saveJob(job);
+        }
+        catch (error) {
+            console.error(`Failed to persist run state for job ${job.id}:`, error);
+        }
+        this.runningJobs.delete(jobId);
+        // Refresh schedule for next execution
+        await this.register(job);
+        return outcome;
+    }
+    async updateJobMetadata(job, nextRun) {
+        const managed = this.jobs.get(job.id);
+        const updated = {
+            ...job,
+            metadata: {
+                ...job.metadata,
+                nextRunAt: nextRun
+            }
+        };
+        try {
+            await this.store.saveJob(updated);
+            this.jobs.set(job.id, { job: updated, timer: managed?.timer, nextRun });
+        }
+        catch (error) {
+            console.error(`Failed to update next run for job ${job.id}:`, error);
+        }
+    }
+    calculateNextRun(job, from = new Date()) {
+        const schedule = job.schedule;
+        if (schedule.type === 'interval') {
+            return this.calculateNextInterval(schedule, from);
+        }
+        if (schedule.type === 'cron') {
+            return this.calculateNextCron(schedule.expression, from);
+        }
+        return undefined;
+    }
+    calculateNextInterval(schedule, from) {
+        const hours = Math.max(1, schedule.hours || 1);
+        const allowedDays = Array.isArray(schedule.daysOfWeek) && schedule.daysOfWeek.length > 0
+            ? new Set(schedule.daysOfWeek.map((day) => DAY_TO_INDEX[day.toLowerCase()] ?? -1))
+            : new Set([0, 1, 2, 3, 4, 5, 6]);
+        let next = new Date(from.getTime());
+        next.setSeconds(0, 0);
+        next.setMinutes(0);
+        // Move forward by one interval window
+        next = new Date(next.getTime() + hours * 60 * 60 * 1000);
+        next.setMinutes(0, 0, 0);
+        let guard = 0;
+        while (!allowedDays.has(next.getDay())) {
+            next = new Date(next.getTime() + 60 * 60 * 1000);
+            next.setMinutes(0, 0, 0);
+            guard += 1;
+            if (guard > 24 * 14) {
+                return undefined;
+            }
+        }
+        if (typeof schedule.anchorHour === 'number') {
+            next.setHours(schedule.anchorHour, 0, 0, 0);
+            if (next <= from) {
+                next = new Date(next.getTime() + hours * 60 * 60 * 1000);
+                next.setMinutes(0, 0, 0);
+            }
+        }
+        return next;
+    }
+    calculateNextCron(expression, from) {
+        const fields = expression.trim().split(/\s+/);
+        if (fields.length !== 5) {
+            console.warn(`Invalid cron expression "${expression}". Expected 5 fields.`);
+            return undefined;
+        }
+        const minuteField = this.parseCronField(fields[0], 0, 59);
+        const hourField = this.parseCronField(fields[1], 0, 23);
+        const domField = this.parseCronField(fields[2], 1, 31);
+        const monthField = this.parseCronField(fields[3], 1, 12);
+        const dowField = this.parseCronField(fields[4], 0, 6, true);
+        let cursor = new Date(from.getTime());
+        cursor.setSeconds(0, 0);
+        cursor.setMinutes(cursor.getMinutes() + 1);
+        const limit = from.getTime() + 1000 * 60 * 60 * 24 * 366; // search up to 1 year ahead
+        while (cursor.getTime() <= limit) {
+            const minuteMatch = minuteField.isWildcard || minuteField.values.has(cursor.getMinutes());
+            const hourMatch = hourField.isWildcard || hourField.values.has(cursor.getHours());
+            const monthMatch = monthField.isWildcard || monthField.values.has(cursor.getMonth() + 1);
+            const domMatch = domField.isWildcard || domField.values.has(cursor.getDate());
+            const dowMatch = dowField.isWildcard || dowField.values.has(cursor.getDay());
+            const dayMatch = this.resolveDayMatch(domField.isWildcard, dowField.isWildcard, domMatch, dowMatch);
+            if (minuteMatch && hourMatch && monthMatch && dayMatch) {
+                return new Date(cursor.getTime());
+            }
+            cursor = new Date(cursor.getTime() + 60 * 1000);
+        }
+        return undefined;
+    }
+    resolveDayMatch(domWildcard, dowWildcard, domMatch, dowMatch) {
+        if (domWildcard && dowWildcard)
+            return true;
+        if (domWildcard)
+            return dowMatch;
+        if (dowWildcard)
+            return domMatch;
+        return domMatch || dowMatch;
+    }
+    parseCronField(field, min, max, isDayOfWeek = false) {
+        const values = new Set();
+        const normalized = field.trim();
+        if (!normalized || normalized === '*' || normalized === '?') {
+            for (let i = min; i <= max; i++) {
+                values.add(isDayOfWeek && i === 7 ? 0 : i);
+            }
+            return { values, isWildcard: true };
+        }
+        const segments = normalized.split(',');
+        for (const segment of segments) {
+            this.expandCronSegment(segment.trim(), min, max, values, isDayOfWeek);
+        }
+        if (values.size === (max - min + 1)) {
+            return { values, isWildcard: true };
+        }
+        return { values, isWildcard: false };
+    }
+    expandCronSegment(segment, min, max, bucket, isDayOfWeek) {
+        if (!segment)
+            return;
+        let step = 1;
+        let rangePart = segment;
+        if (segment.includes('/')) {
+            const [base, stepPart] = segment.split('/');
+            rangePart = base;
+            step = Math.max(1, parseInt(stepPart, 10) || 1);
+        }
+        if (rangePart === '*' || rangePart === '?') {
+            for (let value = min; value <= max; value += step) {
+                this.storeCronValue(value, bucket, isDayOfWeek);
+            }
+            return;
+        }
+        if (rangePart.includes('-')) {
+            const [startRaw, endRaw] = rangePart.split('-');
+            const start = Math.max(min, parseInt(startRaw, 10));
+            const end = Math.min(max, parseInt(endRaw, 10));
+            for (let value = start; value <= end; value += step) {
+                this.storeCronValue(value, bucket, isDayOfWeek);
+            }
+            return;
+        }
+        const parsed = parseInt(rangePart, 10);
+        if (!Number.isNaN(parsed)) {
+            this.storeCronValue(parsed, bucket, isDayOfWeek);
+        }
+    }
+    storeCronValue(value, bucket, isDayOfWeek) {
+        if (isDayOfWeek && value === 7) {
+            bucket.add(0);
+            return;
+        }
+        bucket.add(value);
+    }
+    getStatus() {
+        const jobs = [];
+        for (const [id, managed] of this.jobs.entries()) {
+            jobs.push({
+                id,
+                status: managed.job.status,
+                nextRunAt: managed.job.metadata.nextRunAt,
+                lastRunAt: managed.job.metadata.lastRunAt,
+                timerActive: Boolean(managed.timer),
+                running: this.runningJobs.has(id)
+            });
+        }
+        return {
+            initialized: this.initialized,
+            jobCount: this.jobs.size,
+            runningCount: this.runningJobs.size,
+            jobs
+        };
+    }
+}

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

@@ -0,0 +1,16 @@
+import { ScheduledJob, ScheduledJobRun } from '@lovelybunch/types';
+export declare class JobStore {
+    private jobsDirPromise;
+    constructor();
+    private sanitizeForYAML;
+    private resolveJobsDir;
+    private normalizeSchedule;
+    private getJobFilePath;
+    listJobs(): Promise<ScheduledJob[]>;
+    getJob(id: string): Promise<ScheduledJob | null>;
+    saveJob(job: ScheduledJob, bodyContent?: string): Promise<void>;
+    deleteJob(id: string): Promise<boolean>;
+    appendRun(jobId: string, run: ScheduledJobRun): Promise<ScheduledJob>;
+    private fromFrontmatter;
+    private toFrontmatter;
+}

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

@@ -0,0 +1,211 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+import { randomUUID } from 'crypto';
+import { getProjectRoot } from '../project-paths.js';
+function toDate(value) {
+    if (!value)
+        return undefined;
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+}
+function prepareDate(value) {
+    if (!value)
+        return undefined;
+    return value.toISOString();
+}
+export class JobStore {
+    jobsDirPromise;
+    constructor() {
+        this.jobsDirPromise = this.resolveJobsDir();
+    }
+    sanitizeForYAML(value) {
+        if (value === undefined)
+            return undefined;
+        if (value === null)
+            return null;
+        if (Array.isArray(value)) {
+            const sanitizedArray = value
+                .map((item) => this.sanitizeForYAML(item))
+                .filter((item) => item !== undefined);
+            return sanitizedArray;
+        }
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        if (typeof value === 'object') {
+            const out = {};
+            for (const [key, val] of Object.entries(value)) {
+                const sanitized = this.sanitizeForYAML(val);
+                if (sanitized !== undefined) {
+                    out[key] = sanitized;
+                }
+            }
+            return out;
+        }
+        return value;
+    }
+    async resolveJobsDir() {
+        const projectRoot = await getProjectRoot();
+        const dir = path.join(projectRoot, '.nut', 'jobs');
+        await fs.mkdir(dir, { recursive: true });
+        return dir;
+    }
+    normalizeSchedule(schedule) {
+        if (schedule.type === 'interval') {
+            const order = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday'];
+            const uniqueDays = Array.from(new Set(schedule.daysOfWeek))
+                .filter((day) => order.includes(day))
+                .sort((a, b) => order.indexOf(a) - order.indexOf(b));
+            return {
+                ...schedule,
+                daysOfWeek: uniqueDays
+            };
+        }
+        return schedule;
+    }
+    async getJobFilePath(id) {
+        const dir = await this.jobsDirPromise;
+        return path.join(dir, `${id}.md`);
+    }
+    async listJobs() {
+        const dir = await this.jobsDirPromise;
+        const entries = await fs.readdir(dir).catch(() => []);
+        const jobs = [];
+        for (const entry of entries) {
+            if (!entry.endsWith('.md'))
+                continue;
+            const id = entry.replace(/\.md$/, '');
+            const job = await this.getJob(id);
+            if (job)
+                jobs.push(job);
+        }
+        return jobs.sort((a, b) => {
+            const aTime = a.metadata.updatedAt?.getTime?.() ?? 0;
+            const bTime = b.metadata.updatedAt?.getTime?.() ?? 0;
+            return bTime - aTime;
+        });
+    }
+    async getJob(id) {
+        try {
+            const filePath = await this.getJobFilePath(id);
+            const content = await fs.readFile(filePath, 'utf-8');
+            const { data, content: body } = matter(content);
+            return this.fromFrontmatter(data, body);
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT')
+                return null;
+            throw error;
+        }
+    }
+    async saveJob(job, bodyContent = '') {
+        const filePath = await this.getJobFilePath(job.id);
+        const normalizedJob = {
+            ...job,
+            schedule: this.normalizeSchedule(job.schedule)
+        };
+        const payload = this.sanitizeForYAML(this.toFrontmatter(normalizedJob));
+        const markdown = matter.stringify(bodyContent || job.prompt || '', payload);
+        await fs.writeFile(filePath, `${markdown.trim()}\n`, 'utf-8');
+    }
+    async deleteJob(id) {
+        try {
+            const filePath = await this.getJobFilePath(id);
+            await fs.unlink(filePath);
+            return true;
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT')
+                return false;
+            throw error;
+        }
+    }
+    async appendRun(jobId, run) {
+        const job = await this.getJob(jobId);
+        if (!job) {
+            throw new Error(`Job ${jobId} not found`);
+        }
+        const updatedRuns = [run, ...job.runs];
+        const trimmedRuns = updatedRuns.slice(0, 50);
+        job.runs = trimmedRuns;
+        job.metadata.updatedAt = new Date();
+        job.metadata.lastRunAt = run.startedAt;
+        await this.saveJob(job);
+        return job;
+    }
+    fromFrontmatter(data, body) {
+        if (!data?.id) {
+            throw new Error('Scheduled job is missing required id field');
+        }
+        const createdAt = toDate(data.metadata?.createdAt) ?? new Date();
+        const updatedAt = toDate(data.metadata?.updatedAt) ?? createdAt;
+        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,
+            }))
+            : [];
+        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']
+            },
+            metadata: {
+                createdAt,
+                updatedAt,
+                lastRunAt: toDate(data.metadata?.lastRunAt),
+                nextRunAt: toDate(data.metadata?.nextRunAt),
+            },
+            runs,
+            tags: data.tags ?? [],
+            contextPaths: data.contextPaths ?? [],
+        };
+    }
+    toFrontmatter(job) {
+        return {
+            id: job.id,
+            name: job.name,
+            description: job.description,
+            prompt: job.prompt,
+            model: job.model,
+            status: job.status,
+            schedule: job.schedule,
+            metadata: {
+                createdAt: prepareDate(job.metadata.createdAt),
+                updatedAt: prepareDate(job.metadata.updatedAt),
+                lastRunAt: prepareDate(job.metadata.lastRunAt),
+                nextRunAt: prepareDate(job.metadata.nextRunAt),
+            },
+            runs: job.runs.map((run) => ({
+                id: run.id,
+                jobId: run.jobId,
+                trigger: run.trigger,
+                status: run.status,
+                startedAt: prepareDate(run.startedAt),
+                finishedAt: prepareDate(run.finishedAt),
+                outputPath: run.outputPath,
+                summary: run.summary,
+                error: run.error,
+                cliCommand: run.cliCommand,
+            })),
+            tags: job.tags ?? [],
+            contextPaths: job.contextPaths ?? [],
+        };
+    }
+}

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

@@ -49,7 +49,7 @@ export class FileStorageAdapter {
         }
     }
     async ensureDirectories() {
-        const dirs = ['proposals', 'specs', 'flags', 'experiments', 'templates'];
+        const dirs = ['proposals', 'specs', 'flags', 'experiments', 'templates', 'jobs'];
         for (const dir of dirs) {
             await fs.mkdir(path.join(this.basePath, dir), { recursive: true });
         }
@@ -119,19 +119,21 @@ export class FileStorageAdapter {
         const existing = await this.getCP(id);
         if (!existing)
             throw new Error(`CP ${id} not found`);
+        // 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 = {
             ...existing,
-            ...updates,
+            ...safeUpdates,
             metadata: {
                 ...existing.metadata,
-                ...updates.metadata,
+                ...safeUpdates.metadata,
                 updatedAt: new Date()
             }
         };
         // If comments are being updated, store them at the root level for the file format
-        if (updates.comments) {
-            updated.comments = updates.comments;
+        if (safeUpdates.comments) {
+            updated.comments = safeUpdates.comments;
         }
         await this.createCP(updated);
     }

package/dist/lib/terminal/terminal-manager.d.ts

@@ -13,6 +13,8 @@ export interface TerminalSession {
     previewSockets?: Set<WebSocket>;
     previewBuffer?: string;
     previewFlushTimer?: NodeJS.Timeout | null;
+    pingInterval?: NodeJS.Timeout;
+    previewPingIntervals?: Map<WebSocket, NodeJS.Timeout>;
 }
 export declare class TerminalManager {
     private sessions;