@pellux/goodvibes-sdk 0.18.13 → 0.18.15

package/dist/_internal/platform/automation/manager-runtime.js

@@ -0,0 +1,573 @@
+import { PersistentStore } from '@pellux/goodvibes-sdk/platform/state/persistent-store';
+import { ConfigManager } from '../config/manager.js';
+import { createDomainDispatch } from '../runtime/store/index.js';
+import { AgentMessageBus } from '../agents/message-bus.js';
+import { migrateLegacySchedules } from '@pellux/goodvibes-sdk/platform/automation/migration';
+import { AutomationJobStore } from '@pellux/goodvibes-sdk/platform/automation/store/jobs';
+import { AutomationRunStore } from '@pellux/goodvibes-sdk/platform/automation/store/runs';
+import { resolveAutomationStorePath } from '@pellux/goodvibes-sdk/platform/automation/store/paths';
+import { AutomationDeliveryManager } from './delivery-manager.js';
+import { RouteBindingManager } from '../channels/index.js';
+import { SharedSessionBroker } from '../control-plane/index.js';
+import { applyFailureToJob as applyAutomationFailureToJob, executeAutomationJob, resolveAutomationExecution, resolveRouteForTarget as resolveAutomationRouteForTarget, resolveSharedSessionExecution as resolveAutomationSharedSessionExecution, syncExecutionRoute as syncAutomationExecutionRoute, toResolvedExecution as toAutomationResolvedExecution, } from './manager-runtime-execution.js';
+import { formatExternalContentSource, normalizeExternalTelemetry, normalizeJobRecord, normalizeRunRecord, normalizeRunTelemetry, normalizeSourceRecord, sortJobs, sortRuns, } from './manager-runtime-helpers.js';
+import { advanceScheduledHeartbeatAutomationJob, cancelAutomationTimer, queueDueHeartbeatAutomationJobs, queueHeartbeatWake, scheduleAutomationJob, } from './manager-runtime-scheduling.js';
+import { maybeDeliverAutomationFailureNotice, maybeDeliverAutomationRun, scheduleAutomationFailureFollowUp, } from './manager-runtime-delivery.js';
+import { emitAutomationManagerJobAutoDisabled, emitAutomationManagerJobCreated, emitAutomationManagerJobUpdated, emitAutomationManagerRunCompleted, emitAutomationManagerRunFailed, emitAutomationManagerRunQueued, emitAutomationManagerRunStarted, } from './manager-runtime-events.js';
+import { collectAutomationSources, syncAutomationJobToRuntime, syncAutomationRunToRuntime, syncAutomationRuntimeSnapshot, } from './manager-runtime-sync.js';
+import { reconcileAutomationActiveRuns } from './manager-runtime-reconcile.js';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+import { createAutomationJobRecord, toggleAutomationJobEnabled, updateAutomationJobRecord, } from './manager-runtime-job-mutations.js';
+export class AutomationManager {
+    jobStore;
+    runStore;
+    legacyStore;
+    spawnTask;
+    cancelTask;
+    agentStatusProvider;
+    configManager;
+    routeBindings;
+    sessionBroker;
+    jobs = new Map();
+    runs = new Map();
+    timers = new Map();
+    retryTimers = new Map();
+    heartbeatWakes = new Map();
+    deliveryManager;
+    deliveryInFlight = new Set();
+    runtimeDispatch = null;
+    runtimeBus = null;
+    loaded = false;
+    running = false;
+    startPromise = null;
+    reconcileTimer = null;
+    constructor(config) {
+        this.configManager = config.configManager;
+        this.jobStore = config.jobStore ?? new AutomationJobStore({ configManager: this.configManager });
+        this.runStore = config.runStore ?? new AutomationRunStore({ configManager: this.configManager });
+        this.legacyStore = config.legacyStore ?? new PersistentStore(resolveAutomationStorePath('schedules.json', this.configManager));
+        this.routeBindings = config.routeBindings;
+        this.sessionBroker = config.sessionBroker;
+        this.agentStatusProvider = config.agentStatusProvider;
+        this.spawnTask = config.spawnTask;
+        this.cancelTask = config.cancelTask;
+        if (config.runtimeStore) {
+            this.runtimeDispatch = createDomainDispatch(config.runtimeStore);
+        }
+        this.runtimeBus = config.runtimeBus ?? null;
+        this.deliveryManager = config.deliveryManager ?? null;
+    }
+    requireSpawnTask() {
+        if (!this.spawnTask) {
+            throw new Error('AutomationManager requires an explicit spawnTask callback.');
+        }
+        return this.spawnTask;
+    }
+    requireCancelTask() {
+        if (!this.cancelTask) {
+            throw new Error('AutomationManager requires an explicit cancelTask callback.');
+        }
+        return this.cancelTask;
+    }
+    runtimeExecutionContext() {
+        return {
+            configManager: this.configManager,
+            routeBindings: this.routeBindings,
+            sessionBroker: this.sessionBroker,
+            spawnTask: (input) => this.requireSpawnTask()(input),
+            saveJobs: () => this.saveJobs(),
+            saveRuns: () => this.saveRuns(),
+            pruneRunHistory: (jobId) => this.pruneRunHistory(jobId),
+            activeRunCount: () => this.activeRunCount(),
+            maxConcurrentRuns: () => this.maxConcurrentRuns(),
+            syncExecutionRoute: (job, run) => this.syncExecutionRoute(job, run),
+            syncRunToRuntime: (run, source) => this.syncRunToRuntime(run, source),
+            syncJobToRuntime: (job, source) => this.syncJobToRuntime(job, source),
+            emitRunQueued: (job, run) => this.emitRunQueued(job, run),
+            emitRunStarted: (job, run) => this.emitRunStarted(job, run),
+            emitRunCompleted: (job, run, outcome) => this.emitRunCompleted(job, run, outcome),
+            emitRunFailed: (job, run, error, retryable) => this.emitRunFailed(job, run, error, retryable),
+            maybeDeliverRun: (job, run) => this.maybeDeliverRun(job, run),
+            scheduleFailureFollowUp: (job, run) => this.scheduleFailureFollowUp(job, run),
+            applyFailureToJob: (job, timestamp, countRun = true) => this.applyFailureToJob(job, timestamp, countRun),
+            jobs: this.jobs,
+            runs: this.runs,
+        };
+    }
+    jobMutationContext() {
+        return {
+            configManager: this.configManager,
+            jobs: this.jobs,
+            saveJobs: () => this.saveJobs(),
+            scheduleJob: (job) => this.scheduleJob(job),
+            syncJobToRuntime: (job, source) => this.syncJobToRuntime(job, source),
+            emitJobCreated: (job) => this.emitJobCreated(job),
+            emitJobUpdated: (job, changedFields) => this.emitJobUpdated(job, changedFields),
+        };
+    }
+    async start() {
+        if (this.running)
+            return;
+        if (this.startPromise)
+            return await this.startPromise;
+        this.startPromise = this.load()
+            .then(() => {
+            this.running = true;
+            this.reconcileActiveRuns();
+            this.reconcileTimer = setInterval(() => {
+                this.reconcileActiveRuns();
+            }, 2_000);
+            for (const job of this.jobs.values()) {
+                this.scheduleJob(job);
+            }
+        })
+            .finally(() => {
+            this.startPromise = null;
+        });
+        return await this.startPromise;
+    }
+    stop() {
+        for (const timer of this.timers.values()) {
+            clearTimeout(timer);
+        }
+        this.timers.clear();
+        for (const timer of this.retryTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.retryTimers.clear();
+        if (this.reconcileTimer !== null) {
+            clearInterval(this.reconcileTimer);
+            this.reconcileTimer = null;
+        }
+        this.running = false;
+    }
+    attachRuntime(config) {
+        if (config.runtimeStore) {
+            this.runtimeDispatch = createDomainDispatch(config.runtimeStore);
+            this.syncRuntimeSnapshot();
+        }
+        if (config.runtimeBus) {
+            this.runtimeBus = config.runtimeBus;
+        }
+        if (config.deliveryManager) {
+            this.deliveryManager = config.deliveryManager;
+            this.deliveryManager.attachRuntime({
+                runtimeStore: config.runtimeStore,
+                runtimeBus: config.runtimeBus,
+            });
+        }
+    }
+    listJobs() {
+        this.reconcileActiveRuns();
+        return sortJobs(this.jobs.values());
+    }
+    listRuns(jobId) {
+        this.reconcileActiveRuns();
+        const runs = jobId
+            ? [...this.runs.values()].filter((run) => run.jobId === jobId)
+            : this.runs.values();
+        return sortRuns(runs);
+    }
+    listHeartbeatWakes() {
+        this.queueDueHeartbeatJobs('inspect');
+        return [...this.heartbeatWakes.values()].sort((a, b) => a.queuedAt - b.queuedAt || a.jobId.localeCompare(b.jobId));
+    }
+    getRun(runId) {
+        this.reconcileActiveRuns();
+        return this.runs.get(runId);
+    }
+    getJob(jobId) {
+        this.reconcileActiveRuns();
+        return this.jobs.get(jobId);
+    }
+    async createJob(input) {
+        await this.start();
+        return await createAutomationJobRecord(this.jobMutationContext(), input);
+    }
+    async removeJob(jobId) {
+        await this.start();
+        this.cancelTimer(jobId);
+        const removed = this.jobs.delete(jobId);
+        if (!removed)
+            return false;
+        await this.saveJobs();
+        return true;
+    }
+    async setEnabled(jobId, enabled) {
+        await this.start();
+        const updated = await toggleAutomationJobEnabled(this.jobMutationContext(), jobId, enabled);
+        if (!enabled)
+            this.cancelTimer(jobId);
+        return updated;
+    }
+    async updateJob(jobId, patch) {
+        await this.start();
+        return await updateAutomationJobRecord(this.jobMutationContext(), jobId, patch);
+    }
+    async runNow(jobId) {
+        await this.start();
+        const job = this.jobs.get(jobId);
+        if (!job)
+            throw new Error(`Automation job not found: ${jobId}`);
+        if (this.activeRunCount() >= this.maxConcurrentRuns()) {
+            throw new Error(`Automation concurrency limit reached (${this.maxConcurrentRuns()})`);
+        }
+        return await this.executeJob(job, 'manual', false);
+    }
+    async triggerHeartbeat(_input = {}) {
+        await this.start();
+        this.queueDueHeartbeatJobs('heartbeat');
+        const queued = this.listHeartbeatWakes();
+        const processed = [];
+        const failed = [];
+        for (const wake of queued) {
+            if (this.activeRunCount() >= this.maxConcurrentRuns())
+                break;
+            const job = this.jobs.get(wake.jobId);
+            this.heartbeatWakes.delete(wake.jobId);
+            if (!job?.enabled)
+                continue;
+            try {
+                const run = await this.executeJob(job, wake.trigger, wake.dueRun, wake.attempt);
+                processed.push(run);
+                this.advanceScheduledHeartbeatJob(job.id);
+            }
+            catch (error) {
+                failed.push({
+                    jobId: wake.jobId,
+                    error: summarizeError(error),
+                });
+            }
+        }
+        return {
+            processed,
+            failed,
+            pending: this.listHeartbeatWakes(),
+            checkedAt: Date.now(),
+        };
+    }
+    async retryRun(runId) {
+        await this.start();
+        const run = this.runs.get(runId);
+        if (!run)
+            throw new Error(`Automation run not found: ${runId}`);
+        const job = this.jobs.get(run.jobId);
+        if (!job)
+            throw new Error(`Automation job not found: ${run.jobId}`);
+        if (this.activeRunCount() >= this.maxConcurrentRuns()) {
+            throw new Error(`Automation concurrency limit reached (${this.maxConcurrentRuns()})`);
+        }
+        return await this.executeJob(job, 'manual', false, run.attempt + 1);
+    }
+    async cancelRun(runId, reason = 'operator-cancelled') {
+        await this.start();
+        const run = this.runs.get(runId);
+        if (!run)
+            return null;
+        if (run.status !== 'running')
+            return run;
+        if (run.agentId) {
+            this.requireCancelTask()(run.agentId);
+        }
+        const endedAt = Date.now();
+        const updatedRun = {
+            ...run,
+            status: 'cancelled',
+            endedAt,
+            durationMs: Math.max(0, endedAt - (run.startedAt ?? run.queuedAt)),
+            cancelledReason: reason,
+            updatedAt: endedAt,
+        };
+        this.runs.set(run.id, updatedRun);
+        this.syncRunToRuntime(updatedRun, 'automation.cancel');
+        const job = this.jobs.get(run.jobId);
+        if (job) {
+            const updatedJob = {
+                ...job,
+                lastRunAt: endedAt,
+                updatedAt: endedAt,
+            };
+            this.jobs.set(job.id, updatedJob);
+            await this.syncExecutionRoute(updatedJob, updatedRun);
+            if (updatedRun.sessionId && updatedRun.continuationMode !== 'continued-live') {
+                await this.sessionBroker.completeAgent(updatedRun.sessionId, updatedRun.agentId ?? run.id, reason, {
+                    status: 'cancelled',
+                    automationJobId: updatedJob.id,
+                    automationRunId: updatedRun.id,
+                });
+            }
+            this.syncJobToRuntime(updatedJob, 'automation.cancel');
+            this.emitRunCompleted(updatedJob, updatedRun, 'cancelled');
+            this.maybeDeliverRun(updatedJob, updatedRun);
+        }
+        await this.saveRuns();
+        await this.saveJobs();
+        return updatedRun;
+    }
+    async recordExternalRunResult(runId, input) {
+        await this.start();
+        const run = this.runs.get(runId);
+        if (!run)
+            return null;
+        if (run.status !== 'running')
+            return run;
+        const endedAt = Date.now();
+        const updatedRun = {
+            ...run,
+            status: input.status,
+            endedAt,
+            durationMs: Math.max(0, endedAt - (run.startedAt ?? run.queuedAt)),
+            updatedAt: endedAt,
+            ...(input.status === 'completed'
+                ? { result: input.result }
+                : input.status === 'failed'
+                    ? { error: input.error ?? 'Remote work failed' }
+                    : { cancelledReason: input.error ?? 'Remote work cancelled' }),
+            ...(input.telemetry ? { telemetry: normalizeExternalTelemetry(input.telemetry, run, input.metadata) } : {}),
+        };
+        this.runs.set(run.id, updatedRun);
+        this.syncRunToRuntime(updatedRun, 'automation.external');
+        const job = this.jobs.get(run.jobId);
+        if (!job) {
+            await this.saveRuns();
+            return updatedRun;
+        }
+        const wasEnabled = job.enabled;
+        const updatedJob = input.status === 'completed'
+            ? {
+                ...job,
+                successCount: job.successCount + 1,
+                failureCount: 0,
+                updatedAt: endedAt,
+            }
+            : input.status === 'failed'
+                ? this.applyFailureToJob(job, endedAt, false)
+                : {
+                    ...job,
+                    updatedAt: endedAt,
+                };
+        this.jobs.set(job.id, updatedJob);
+        await this.syncExecutionRoute(updatedJob, updatedRun);
+        this.syncJobToRuntime(updatedJob, 'automation.external');
+        if (input.status === 'completed') {
+            this.emitRunCompleted(updatedJob, updatedRun, 'success');
+        }
+        else if (input.status === 'failed') {
+            this.emitRunFailed(updatedJob, updatedRun, updatedRun.error ?? 'Remote work failed', false);
+        }
+        else {
+            this.emitRunCompleted(updatedJob, updatedRun, 'cancelled');
+        }
+        this.maybeDeliverRun(updatedJob, updatedRun);
+        if (input.status === 'completed' && updatedJob.deleteAfterRun) {
+            this.cancelTimer(updatedJob.id);
+            this.jobs.delete(updatedJob.id);
+        }
+        else if (input.status === 'failed') {
+            this.scheduleFailureFollowUp(updatedJob, updatedRun);
+        }
+        if (!updatedJob.enabled && wasEnabled && input.status === 'failed') {
+            this.emitJobAutoDisabled(updatedJob, updatedJob.pausedReason ?? 'failure-threshold-reached');
+        }
+        await this.saveRuns();
+        await this.saveJobs();
+        return updatedRun;
+    }
+    async load() {
+        if (this.loaded)
+            return;
+        const [jobSnapshot, runSnapshot] = await Promise.all([
+            this.jobStore.load(),
+            this.runStore.load(),
+        ]);
+        for (const job of jobSnapshot.jobs) {
+            const normalizedJob = normalizeJobRecord(job, this.configManager);
+            this.jobs.set(normalizedJob.id, normalizedJob);
+        }
+        for (const run of runSnapshot.runs) {
+            const normalizedRun = normalizeRunRecord(run, this.jobs.get(run.jobId));
+            this.runs.set(normalizedRun.id, normalizedRun);
+        }
+        if (this.jobs.size === 0) {
+            await this.importLegacySchedules();
+        }
+        this.loaded = true;
+        this.pruneRunHistory();
+        this.syncRuntimeSnapshot();
+    }
+    async importLegacySchedules() {
+        const snapshot = await this.legacyStore.load();
+        if (!snapshot)
+            return;
+        const migrated = migrateLegacySchedules(snapshot);
+        if (migrated.jobs.length === 0 && migrated.runs.length === 0)
+            return;
+        for (const job of migrated.jobs) {
+            this.jobs.set(job.id, job);
+        }
+        for (const run of migrated.runs) {
+            this.runs.set(run.id, run);
+        }
+        await Promise.all([this.saveJobs(), this.saveRuns()]);
+        this.syncRuntimeSnapshot();
+    }
+    scheduleJob(job) {
+        scheduleAutomationJob({
+            configManager: this.configManager,
+            jobs: this.jobs,
+            timers: this.timers,
+            heartbeatWakes: this.heartbeatWakes,
+            running: () => this.running,
+            saveJobs: () => this.saveJobs(),
+            activeRunCount: () => this.activeRunCount(),
+            maxConcurrentRuns: () => this.maxConcurrentRuns(),
+            executeJob: (scheduledJob, trigger, dueRun, attempt) => this.executeJob(scheduledJob, trigger, dueRun, attempt),
+        }, job);
+    }
+    cancelTimer(jobId) {
+        cancelAutomationTimer(this.timers, jobId);
+    }
+    queueDueHeartbeatJobs(reason) {
+        queueDueHeartbeatAutomationJobs(this.jobs.values(), this.heartbeatWakes, reason);
+    }
+    advanceScheduledHeartbeatJob(jobId) {
+        advanceScheduledHeartbeatAutomationJob({
+            jobs: this.jobs,
+            saveJobs: () => this.saveJobs(),
+        }, this.timers, jobId, (job) => this.scheduleJob(job));
+    }
+    async executeJob(job, trigger, dueRun, attempt = 1) {
+        return await executeAutomationJob(this.runtimeExecutionContext(), job, trigger, dueRun, attempt);
+    }
+    async syncExecutionRoute(job, run) {
+        await syncAutomationExecutionRoute(this.runtimeExecutionContext(), job, run);
+    }
+    applyFailureToJob(job, timestamp, countRun = true) {
+        return applyAutomationFailureToJob(job, timestamp, countRun);
+    }
+    reconcileActiveRuns() {
+        if (!this.agentStatusProvider) {
+            return;
+        }
+        reconcileAutomationActiveRuns({
+            configManager: this.configManager,
+            sessionBroker: this.sessionBroker,
+            agentStatusProvider: this.agentStatusProvider,
+            jobs: this.jobs,
+            runs: this.runs,
+            saveJobs: () => this.saveJobs(),
+            saveRuns: () => this.saveRuns(),
+            syncExecutionRoute: (job, run) => this.syncExecutionRoute(job, run),
+            syncRunToRuntime: (run, source) => this.syncRunToRuntime(run, source),
+            syncJobToRuntime: (job, source) => this.syncJobToRuntime(job, source),
+            emitRunCompleted: (job, run, outcome) => this.emitRunCompleted(job, run, outcome),
+            emitRunFailed: (job, run, error, retryable) => this.emitRunFailed(job, run, error, retryable),
+            emitJobAutoDisabled: (job, reason) => this.emitJobAutoDisabled(job, reason),
+            maybeDeliverRun: (job, run) => this.maybeDeliverRun(job, run),
+            scheduleFailureFollowUp: (job, run) => this.scheduleFailureFollowUp(job, run),
+            applyFailureToJob: (job, timestamp, countRun) => this.applyFailureToJob(job, timestamp, countRun),
+            pruneRunHistory: () => this.pruneRunHistory(),
+            cancelTimer: (jobId) => this.cancelTimer(jobId),
+        });
+    }
+    async saveJobs() {
+        await this.jobStore.save(sortJobs(this.jobs.values()));
+    }
+    async saveRuns() {
+        this.pruneRunHistory();
+        await this.runStore.save(sortRuns(this.runs.values()));
+    }
+    maxConcurrentRuns() {
+        return Math.max(1, Number(this.configManager.get('automation.maxConcurrentRuns') ?? 4));
+    }
+    activeRunCount() {
+        let total = 0;
+        for (const run of this.runs.values()) {
+            if (run.status === 'running')
+                total += 1;
+        }
+        return total;
+    }
+    pruneRunHistory(jobId) {
+        const limit = Math.max(1, Number(this.configManager.get('automation.runHistoryLimit') ?? 100));
+        const runs = sortRuns(this.runs.values());
+        const keep = new Set();
+        if (jobId) {
+            const scoped = runs.filter((run) => run.jobId === jobId).slice(0, limit);
+            for (const run of scoped)
+                keep.add(run.id);
+            for (const run of runs) {
+                if (run.jobId !== jobId)
+                    keep.add(run.id);
+            }
+        }
+        else {
+            const grouped = new Map();
+            for (const run of runs) {
+                const count = grouped.get(run.jobId) ?? 0;
+                if (count < limit) {
+                    grouped.set(run.jobId, count + 1);
+                    keep.add(run.id);
+                }
+            }
+        }
+        for (const runId of [...this.runs.keys()]) {
+            if (!keep.has(runId))
+                this.runs.delete(runId);
+        }
+    }
+    scheduleFailureFollowUp(job, run) {
+        scheduleAutomationFailureFollowUp({
+            jobs: this.jobs,
+            retryTimers: this.retryTimers,
+            deliveryManager: this.deliveryManager,
+            activeRunCount: () => this.activeRunCount(),
+            maxConcurrentRuns: () => this.maxConcurrentRuns(),
+            executeJob: (scheduledJob, trigger, dueRun, attempt) => this.executeJob(scheduledJob, trigger, dueRun, attempt),
+            saveJobs: () => this.saveJobs(),
+            scheduleJob: (scheduledJob) => this.scheduleJob(scheduledJob),
+        }, (failureJob, failureRun) => this.maybeDeliverFailureNotice(failureJob, failureRun), job, run);
+    }
+    maybeDeliverFailureNotice(job, run) {
+        maybeDeliverAutomationFailureNotice(this.deliveryManager, job, run);
+    }
+    syncRuntimeSnapshot() {
+        syncAutomationRuntimeSnapshot(this.runtimeDispatch, this.jobs.values(), this.runs.values());
+    }
+    syncJobToRuntime(job, source) {
+        syncAutomationJobToRuntime(this.runtimeDispatch, job, source);
+    }
+    syncRunToRuntime(run, source) {
+        syncAutomationRunToRuntime(this.runtimeDispatch, run, source);
+    }
+    emitJobCreated(job) {
+        emitAutomationManagerJobCreated(this.runtimeBus, job);
+    }
+    emitJobUpdated(job, changedFields) {
+        emitAutomationManagerJobUpdated(this.runtimeBus, job, changedFields);
+    }
+    emitJobAutoDisabled(job, reason) {
+        emitAutomationManagerJobAutoDisabled(this.runtimeBus, job, reason);
+    }
+    emitRunQueued(job, run) {
+        emitAutomationManagerRunQueued(this.runtimeBus, job, run);
+    }
+    emitRunStarted(job, run) {
+        emitAutomationManagerRunStarted(this.runtimeBus, job, run);
+    }
+    emitRunCompleted(job, run, outcome) {
+        emitAutomationManagerRunCompleted(this.runtimeBus, job, run, outcome);
+    }
+    emitRunFailed(job, run, error, retryable) {
+        emitAutomationManagerRunFailed(this.runtimeBus, job, run, error, retryable);
+    }
+    maybeDeliverRun(job, run) {
+        maybeDeliverAutomationRun({
+            runs: this.runs,
+            deliveryInFlight: this.deliveryInFlight,
+            deliveryManager: this.deliveryManager,
+            syncRunToRuntime: (nextRun, source) => this.syncRunToRuntime(nextRun, source),
+            saveRuns: () => this.saveRuns(),
+        }, job, run);
+    }
+}

package/dist/_internal/platform/automation/manager.d.ts

@@ -0,0 +1,3 @@
+export { AutomationManager, } from './manager-runtime.js';
+export type { CreateAutomationJobInput, UpdateAutomationJobInput, AutomationHeartbeatResult, AutomationHeartbeatWake, } from './manager-runtime.js';
+//# sourceMappingURL=manager.d.ts.map

package/dist/_internal/platform/automation/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/automation/manager.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,GAClB,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EACV,wBAAwB,EACxB,wBAAwB,EACxB,yBAAyB,EACzB,uBAAuB,GACxB,MAAM,sBAAsB,CAAC"}

package/dist/_internal/platform/automation/manager.js

@@ -0,0 +1 @@
+export { AutomationManager, } from './manager-runtime.js';

package/dist/_internal/platform/automation/schedules.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { TaskScheduler } from '../scheduler/scheduler.js';
 const EVERY_PATTERN = /^(\d+(?:\.\d+)?)(ms|s|m|h|d)$/;
-const CRON_HELPER_STATE_PATH = '.goodvibes/tui/.automation-cron-helper.json';
+const CRON_HELPER_STATE_PATH = '.goodvibes/goodvibes/.automation-cron-helper.json';
 export const DEFAULT_TOP_OF_HOUR_STAGGER_MS = 5 * 60 * 1_000;
 function createCronHelper() {
     return new TaskScheduler(CRON_HELPER_STATE_PATH);

package/dist/_internal/platform/automation/service.d.ts

@@ -0,0 +1,61 @@
+import { PersistentStore } from '@pellux/goodvibes-sdk/platform/state/persistent-store';
+import { ConfigManager } from '../config/manager.js';
+import { AutomationManager } from './manager.js';
+import { type LegacySchedulerSnapshot } from '@pellux/goodvibes-sdk/platform/automation/migration';
+import type { AutomationJob } from '@pellux/goodvibes-sdk/platform/automation/jobs';
+import type { AutomationRouteBinding } from '@pellux/goodvibes-sdk/platform/automation/routes';
+import type { AutomationRun } from '@pellux/goodvibes-sdk/platform/automation/runs';
+import type { AutomationSourceRecord } from '@pellux/goodvibes-sdk/platform/automation/sources';
+import { AutomationJobStore } from '@pellux/goodvibes-sdk/platform/automation/store/jobs';
+import { AutomationRouteStore } from '@pellux/goodvibes-sdk/platform/automation/store/routes';
+import { AutomationRunStore } from '@pellux/goodvibes-sdk/platform/automation/store/runs';
+import { AutomationSourceStore } from '@pellux/goodvibes-sdk/platform/automation/store/sources';
+export interface AutomationServiceConfig {
+    readonly configManager: ConfigManager;
+    readonly jobs?: AutomationJobStore;
+    readonly runs?: AutomationRunStore;
+    readonly routes?: AutomationRouteStore;
+    readonly sources?: AutomationSourceStore;
+    readonly legacyStore?: PersistentStore<LegacySchedulerSnapshot>;
+    readonly manager?: AutomationManager;
+}
+export declare class AutomationService {
+    private readonly jobStore;
+    private readonly runStore;
+    private readonly routeStore;
+    private readonly sourceStore;
+    private readonly legacyStore;
+    private readonly manager;
+    private readonly jobs;
+    private readonly runs;
+    private readonly routes;
+    private readonly sources;
+    private loaded;
+    constructor(config: AutomationServiceConfig);
+    start(): Promise<void>;
+    stop(): void;
+    load(): Promise<void>;
+    listJobs(): AutomationJob[];
+    listRuns(jobId?: string): AutomationRun[];
+    listRoutes(): AutomationRouteBinding[];
+    listSources(): AutomationSourceRecord[];
+    getJob(jobId: string): AutomationJob | undefined;
+    getRoute(routeId: string): AutomationRouteBinding | undefined;
+    getSource(sourceId: string): AutomationSourceRecord | undefined;
+    upsertJob(job: AutomationJob): Promise<AutomationJob>;
+    upsertRun(run: AutomationRun): Promise<AutomationRun>;
+    appendRun(run: Omit<AutomationRun, 'id'> & {
+        readonly id?: string;
+    }): Promise<AutomationRun>;
+    upsertRoute(route: AutomationRouteBinding): Promise<AutomationRouteBinding>;
+    upsertSource(source: AutomationSourceRecord): Promise<AutomationSourceRecord>;
+    removeJob(jobId: string): Promise<boolean>;
+    removeRoute(routeId: string): Promise<boolean>;
+    removeSource(sourceId: string): Promise<boolean>;
+    seedFromLegacyScheduler(snapshot?: LegacySchedulerSnapshot): Promise<void>;
+    private saveJobs;
+    private saveRuns;
+    private saveRoutes;
+    private saveSources;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/_internal/platform/automation/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/automation/service.ts"],"names":[],"mappings":"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"}