neondeck 1.0.0-beta.4

package/src/modules/scheduled-tasks/triggers.ts

@@ -0,0 +1,87 @@
+import { Cron } from 'croner';
+import * as v from 'valibot';
+import { automationTriggerSchema, type AutomationTrigger } from './schemas';
+
+export function validateAutomationTrigger(input: unknown) {
+  const parsed = v.safeParse(automationTriggerSchema, input);
+  if (!parsed.success) {
+    return { ok: false as const, message: v.summarize(parsed.issues) };
+  }
+  const trigger = parsed.output;
+  if (trigger.kind === 'once') {
+    if (!isIsoDate(trigger.at)) {
+      return {
+        ok: false as const,
+        message: 'One-shot scheduled tasks require an ISO timestamp.',
+      };
+    }
+  }
+  if (trigger.kind === 'cron') {
+    if (!isIanaTimezone(trigger.timezone)) {
+      return {
+        ok: false as const,
+        message: `"${trigger.timezone}" is not a supported IANA timezone.`,
+      };
+    }
+    try {
+      new Cron(trigger.expression, {
+        timezone: trigger.timezone,
+        paused: true,
+      });
+    } catch (error) {
+      return {
+        ok: false as const,
+        message: `Invalid cron expression: ${errorMessage(error)}.`,
+      };
+    }
+  }
+  return { ok: true as const, trigger };
+}
+
+export function nextOccurrence(
+  trigger: AutomationTrigger,
+  from = new Date(),
+): string | null {
+  if (trigger.kind === 'interval') {
+    return new Date(
+      from.getTime() + trigger.everySeconds * 1_000,
+    ).toISOString();
+  }
+  if (trigger.kind === 'once') {
+    const at = new Date(trigger.at);
+    return at.getTime() > from.getTime() ? at.toISOString() : null;
+  }
+  return (
+    new Cron(trigger.expression, {
+      timezone: trigger.timezone,
+      paused: true,
+    })
+      .nextRun(from)
+      ?.toISOString() ?? null
+  );
+}
+
+export function describeTrigger(trigger: AutomationTrigger) {
+  if (trigger.kind === 'interval') {
+    return `every ${trigger.everySeconds} seconds`;
+  }
+  if (trigger.kind === 'once') return `once at ${trigger.at}`;
+  return `${trigger.expression} (${trigger.timezone})`;
+}
+
+function isIsoDate(value: string) {
+  return !Number.isNaN(Date.parse(value));
+}
+
+function isIanaTimezone(value: string) {
+  try {
+    new Intl.DateTimeFormat('en-US', { timeZone: value });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function errorMessage(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/modules/scheduler/actions.ts

@@ -0,0 +1,37 @@
+import { defineAction } from '@flue/runtime';
+import * as v from 'valibot';
+import { runtimePaths } from '../../runtime-home';
+import { runSchedulerTick } from './service';
+import { schedulerActionOutputSchema } from './schemas';
+
+export const schedulerTickAction = defineAction({
+  name: 'neondeck_scheduler_tick',
+  description:
+    'Claim due canonical scheduled tasks and run their bounded executions.',
+  input: v.object({ runtimeHome: v.optional(v.string()) }),
+  output: schedulerActionOutputSchema,
+  async run({ input, log }) {
+    log.info('Scheduler tick requested');
+
+    const result = await runSchedulerTick(
+      input.runtimeHome ? runtimePaths(input.runtimeHome) : runtimePaths(),
+    );
+    const payload = {
+      ok: result.ok,
+      outcome: result.outcome ?? null,
+      changed: result.changed,
+      message: result.message,
+      tasks: result.tasks?.length ?? 0,
+      notifications: result.notifications?.length ?? 0,
+    };
+    if (result.ok) {
+      log.info('Scheduler tick completed', payload);
+    } else {
+      log.warn('Scheduler tick failed', payload);
+    }
+
+    return result;
+  },
+});
+
+export const neondeckSchedulerActions = [];

package/src/modules/scheduler/dispatch.ts

@@ -0,0 +1,126 @@
+import type { JsonValue } from '@flue/runtime';
+import type { NotificationLevel } from '../app-state';
+import type { RuntimePaths } from '../../runtime-home';
+import { refreshPrWatch } from '../watches';
+import type { SchedulerDependencies } from './schemas';
+import {
+  pendingEventResultsFromJobResult,
+  refreshWatchJobEvents,
+} from './pr-watch-events';
+
+export { invokeScheduledWorkflow } from './workflow-invocation';
+
+export async function refreshWatchTask(
+  watchId: string,
+  previousResult: JsonValue | null,
+  paths: RuntimePaths,
+  dependencies: SchedulerDependencies = {},
+) {
+  const refreshWatch = dependencies.refreshPrWatch ?? refreshPrWatch;
+  const result = await refreshWatch({ id: watchId }, paths);
+  if (!result.ok) {
+    const pendingEventResults = pendingEventResultsFromJobResult(previousResult);
+    return {
+      outcome: 'failed' as const,
+      message: `Failed to refresh PR watch "${watchId}".`,
+      result: {
+        results: [result],
+        ...(pendingEventResults.length > 0
+          ? { eventResults: pendingEventResults }
+          : {}),
+      },
+      notifications: [
+        {
+          level: 'attention' as const,
+          title: 'PR watch refresh failed',
+          message: result.message,
+          source: 'watch-pr',
+          sourceId: watchId,
+          data: result,
+        },
+      ],
+    };
+  }
+
+  const eventResults = await refreshWatchJobEvents(
+    [result],
+    paths,
+    dependencies,
+    previousResult,
+  );
+  const eventFailures = eventResults.filter((item) => !item.ok);
+  const eventChanges = eventResults.filter((item) => item.ok && item.changed);
+  const notifications = [
+    ...(result.changed ? [notificationFromWatchResult(result, watchId)] : []),
+    ...eventResults.flatMap((item) => item.notifications ?? []),
+  ];
+  return {
+    outcome:
+      eventFailures.length > 0
+        ? ('failed' as const)
+        : result.changed || eventChanges.length > 0
+          ? ('updated' as const)
+          : ('silent' as const),
+    message: watchRefreshMessage(
+      result.changed ? 1 : 0,
+      eventChanges.length,
+      eventFailures.length,
+    ),
+    result: {
+      results: [result],
+      ...(eventResults.length > 0 ? { eventResults } : {}),
+    },
+    notifications,
+  };
+}
+
+function notificationFromWatchResult(
+  result: Awaited<ReturnType<typeof refreshPrWatch>>,
+  watchId: string,
+) {
+  const watch = result.watch as { id?: string; status?: string } | undefined;
+  const level: NotificationLevel =
+    watch?.status === 'closed' || watch?.status === 'attention-needed'
+      ? 'attention'
+      : watch?.status === 'merged' || watch?.status === 'green'
+        ? 'ready'
+        : 'info';
+  const title =
+    watch?.status === 'green'
+      ? 'PR watch green'
+      : watch?.status === 'attention-needed'
+        ? 'PR watch needs attention'
+        : watch?.status === 'merged'
+          ? 'PR watch merged'
+          : watch?.status === 'closed'
+            ? 'PR watch closed'
+            : 'PR watch changed';
+  return {
+    level,
+    title,
+    message: result.message,
+    source: 'watch-pr',
+    sourceId: watch?.id ?? watchId,
+    data: result.watch,
+  };
+}
+
+function watchRefreshMessage(
+  watchChanges: number,
+  eventChanges: number,
+  eventFailures: number,
+) {
+  if (eventFailures > 0) {
+    return `Failed to refresh ${eventFailures} PR event watch${eventFailures === 1 ? '' : 'es'}.`;
+  }
+  if (watchChanges > 0 && eventChanges > 0) {
+    return `Updated ${watchChanges} PR watch${watchChanges === 1 ? '' : 'es'} and ${eventChanges} PR event watch${eventChanges === 1 ? '' : 'es'}.`;
+  }
+  if (watchChanges > 0) {
+    return `Updated ${watchChanges} PR watch${watchChanges === 1 ? '' : 'es'}.`;
+  }
+  if (eventChanges > 0) {
+    return `Updated ${eventChanges} PR event watch${eventChanges === 1 ? '' : 'es'}.`;
+  }
+  return 'PR watch refresh had no changes.';
+}

package/src/modules/scheduler/index.ts

@@ -0,0 +1,4 @@
+export * from './actions';
+export * from './lease';
+export * from './schemas';
+export * from './service';

package/src/modules/scheduler/lease.ts

@@ -0,0 +1,247 @@
+import { randomUUID } from 'node:crypto';
+import { DatabaseSync } from 'node:sqlite';
+import type { RuntimePaths } from '../../runtime-home';
+import type {
+  SchedulerTickLease,
+  SchedulerTickLeaseRenewResult,
+  SchedulerTickLeaseResult,
+} from './schemas';
+import { schedulerTickLeaseKey } from './schemas';
+import { errorMessage } from './utils';
+
+export function acquireSchedulerTickLease(
+  paths: RuntimePaths,
+  now: Date,
+  ttlMs: number,
+): SchedulerTickLeaseResult {
+  const database = new DatabaseSync(paths.neondeckDatabase);
+
+  try {
+    database.exec('BEGIN IMMEDIATE;');
+    const existing = database
+      .prepare('SELECT value FROM app_metadata WHERE key = ?;')
+      .get(schedulerTickLeaseKey);
+    const existingLease = parseSchedulerTickLease(readMetadataValue(existing));
+    if (existingLease && Date.parse(existingLease.expiresAt) > now.getTime()) {
+      database.exec('COMMIT;');
+      return { acquired: false, reason: 'active' };
+    }
+
+    const acquiredAt = now.toISOString();
+    const lease: SchedulerTickLease = {
+      owner: `pid-${process.pid}-${randomUUID()}`,
+      acquiredAt,
+      expiresAt: new Date(now.getTime() + ttlMs).toISOString(),
+    };
+    database
+      .prepare(
+        `
+        INSERT INTO app_metadata (key, value, updated_at)
+        VALUES (?, ?, ?)
+        ON CONFLICT(key) DO UPDATE SET
+          value = excluded.value,
+          updated_at = excluded.updated_at;
+      `,
+      )
+      .run(schedulerTickLeaseKey, JSON.stringify(lease), acquiredAt);
+    database.exec('COMMIT;');
+
+    return { acquired: true, owner: lease.owner };
+  } catch (error) {
+    rollbackQuietly(database);
+    if (isSqliteBusy(error)) return { acquired: false, reason: 'busy' };
+    throw error;
+  } finally {
+    database.close();
+  }
+}
+
+export function startSchedulerTickLeaseHeartbeat(
+  paths: RuntimePaths,
+  owner: string,
+  ttlMs: number,
+) {
+  const intervalMs = Math.max(10, Math.floor(ttlMs / 3));
+  const timer = setInterval(() => {
+    try {
+      const result = renewSchedulerTickLease(paths, owner, new Date(), ttlMs);
+      if (result === 'lost') {
+        clearInterval(timer);
+      }
+    } catch (error) {
+      console.warn(
+        `[neondeck] scheduler tick lease heartbeat failed: ${errorMessage(error)}`,
+      );
+    }
+  }, intervalMs);
+
+  timer.unref?.();
+  return () => clearInterval(timer);
+}
+
+export function renewSchedulerTickLease(
+  paths: RuntimePaths,
+  owner: string,
+  now: Date,
+  ttlMs: number,
+): SchedulerTickLeaseRenewResult {
+  const database = new DatabaseSync(paths.neondeckDatabase);
+
+  try {
+    database.exec('BEGIN IMMEDIATE;');
+    const existing = database
+      .prepare('SELECT value FROM app_metadata WHERE key = ?;')
+      .get(schedulerTickLeaseKey);
+    const existingLease = parseSchedulerTickLease(readMetadataValue(existing));
+    if (existingLease?.owner !== owner) {
+      database.exec('COMMIT;');
+      return 'lost';
+    }
+
+    const renewedLease = {
+      ...existingLease,
+      expiresAt: new Date(now.getTime() + ttlMs).toISOString(),
+    };
+    database
+      .prepare(
+        `
+        UPDATE app_metadata
+        SET value = ?, updated_at = ?
+        WHERE key = ?;
+      `,
+      )
+      .run(
+        JSON.stringify(renewedLease),
+        now.toISOString(),
+        schedulerTickLeaseKey,
+      );
+    database.exec('COMMIT;');
+    return 'renewed';
+  } catch (error) {
+    rollbackQuietly(database);
+    if (isSqliteBusy(error)) return 'busy';
+    throw error;
+  } finally {
+    database.close();
+  }
+}
+
+export function isSchedulerTickLeaseOwned(
+  paths: RuntimePaths,
+  owner: string,
+  now: Date,
+) {
+  const database = new DatabaseSync(paths.neondeckDatabase);
+
+  try {
+    const existing = database
+      .prepare('SELECT value FROM app_metadata WHERE key = ?;')
+      .get(schedulerTickLeaseKey);
+    const existingLease = parseSchedulerTickLease(readMetadataValue(existing));
+    return (
+      existingLease?.owner === owner &&
+      Date.parse(existingLease.expiresAt) > now.getTime()
+    );
+  } catch (error) {
+    if (isSqliteBusy(error)) return false;
+    throw error;
+  } finally {
+    database.close();
+  }
+}
+
+export async function releaseSchedulerTickLease(
+  paths: RuntimePaths,
+  owner: string,
+) {
+  const maxAttempts = 5;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    const released = releaseSchedulerTickLeaseOnce(paths, owner);
+    if (released) return;
+    if (attempt < maxAttempts) {
+      await sleep(25 * attempt);
+    }
+  }
+
+  console.warn(
+    '[neondeck] scheduler tick lease release was blocked by SQLite; lease will expire automatically.',
+  );
+}
+
+export function releaseSchedulerTickLeaseOnce(
+  paths: RuntimePaths,
+  owner: string,
+) {
+  const database = new DatabaseSync(paths.neondeckDatabase);
+
+  try {
+    database.exec('BEGIN IMMEDIATE;');
+    const existing = database
+      .prepare('SELECT value FROM app_metadata WHERE key = ?;')
+      .get(schedulerTickLeaseKey);
+    const existingLease = parseSchedulerTickLease(readMetadataValue(existing));
+    if (existingLease?.owner === owner) {
+      database
+        .prepare('DELETE FROM app_metadata WHERE key = ?;')
+        .run(schedulerTickLeaseKey);
+    }
+    database.exec('COMMIT;');
+    return true;
+  } catch (error) {
+    rollbackQuietly(database);
+    if (isSqliteBusy(error)) return false;
+    throw error;
+  } finally {
+    database.close();
+  }
+}
+
+export function parseSchedulerTickLease(value: string | undefined) {
+  if (!value) return;
+
+  try {
+    const parsed = JSON.parse(value) as Partial<SchedulerTickLease>;
+    if (
+      typeof parsed.owner === 'string' &&
+      typeof parsed.acquiredAt === 'string' &&
+      typeof parsed.expiresAt === 'string'
+    ) {
+      return {
+        owner: parsed.owner,
+        acquiredAt: parsed.acquiredAt,
+        expiresAt: parsed.expiresAt,
+      };
+    }
+  } catch {
+    return;
+  }
+}
+
+export function readMetadataValue(row: unknown) {
+  if (row && typeof row === 'object' && 'value' in row) {
+    const value = row.value;
+    return typeof value === 'string' ? value : undefined;
+  }
+}
+
+export function rollbackQuietly(database: DatabaseSync) {
+  try {
+    database.exec('ROLLBACK;');
+  } catch {
+    // The transaction may already be closed.
+  }
+}
+
+export function isSqliteBusy(error: unknown) {
+  const message = error instanceof Error ? error.message : String(error);
+  return (
+    message.includes('SQLITE_BUSY') ||
+    message.includes('SQLITE_LOCKED') ||
+    message.includes('database is locked')
+  );
+}
+
+export function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}