From 9cd0f8640a4a38c88bb6ff7be020731ffb764446 Mon Sep 17 00:00:00 2001
From: Tudor Golubenco <tudor@xata.io>
Date: Tue, 18 Feb 2025 18:23:56 +0100
Subject: [PATCH 01/12] Adding monitoring pages (wip)

---
 .../src/app/(main)/monitoring/page.tsx        |  17 ++
 .../(main)/monitoring/schedule/[id]/page.tsx  |   8 +
 .../src/components/monitoring/actions.ts      |  48 ++++++
 .../components/monitoring/conn-selector.tsx   |  37 +++++
 .../components/monitoring/schedule-form.tsx   | 150 ++++++++++++++++++
 .../components/monitoring/schedules-table.tsx |  70 ++++++++
 6 files changed, 330 insertions(+)
 create mode 100644 apps/dbagent/src/app/(main)/monitoring/page.tsx
 create mode 100644 apps/dbagent/src/app/(main)/monitoring/schedule/[id]/page.tsx
 create mode 100644 apps/dbagent/src/components/monitoring/actions.ts
 create mode 100644 apps/dbagent/src/components/monitoring/conn-selector.tsx
 create mode 100644 apps/dbagent/src/components/monitoring/schedule-form.tsx
 create mode 100644 apps/dbagent/src/components/monitoring/schedules-table.tsx

diff --git a/apps/dbagent/src/app/(main)/monitoring/page.tsx b/apps/dbagent/src/app/(main)/monitoring/page.tsx
new file mode 100644
index 00000000..c4b63f53
--- /dev/null
+++ b/apps/dbagent/src/app/(main)/monitoring/page.tsx
@@ -0,0 +1,17 @@
+import { MonitoringScheduleTable } from '~/components/monitoring/schedules-table';
+import { listConnections } from '~/lib/db/connections';
+
+async function getConnections() {
+  const connections = await listConnections();
+  return connections;
+}
+
+export default async function Page() {
+  const connections = await getConnections();
+
+  return (
+    <div className="container">
+      <MonitoringScheduleTable connections={connections} />
+    </div>
+  );
+}
diff --git a/apps/dbagent/src/app/(main)/monitoring/schedule/[id]/page.tsx b/apps/dbagent/src/app/(main)/monitoring/schedule/[id]/page.tsx
new file mode 100644
index 00000000..22d5d222
--- /dev/null
+++ b/apps/dbagent/src/app/(main)/monitoring/schedule/[id]/page.tsx
@@ -0,0 +1,8 @@
+import { ScheduleForm } from '~/components/monitoring/schedule-form';
+export default async function Page({ params }: { params: { id: string } }) {
+  return (
+    <div className="container">
+      <ScheduleForm action="edit" scheduleId={params.id} />
+    </div>
+  );
+}
diff --git a/apps/dbagent/src/components/monitoring/actions.ts b/apps/dbagent/src/components/monitoring/actions.ts
new file mode 100644
index 00000000..39b6ac09
--- /dev/null
+++ b/apps/dbagent/src/components/monitoring/actions.ts
@@ -0,0 +1,48 @@
+'use server';
+
+export type Schedule = {
+  id: string;
+  schedule: string;
+  playbook: string;
+  lastRun: string;
+  failures: number;
+  enabled: boolean;
+};
+
+export async function getSchedules(): Promise<Schedule[]> {
+  // TODO: Replace with actual database query
+  return [
+    {
+      id: '1',
+      schedule: 'Every hour',
+      playbook: 'Check API Status',
+      lastRun: '2023-05-01 14:30',
+      failures: 0,
+      enabled: true
+    },
+    {
+      id: '2',
+      schedule: 'Daily at 00:00',
+      playbook: 'Database Backup',
+      lastRun: '2023-05-01 00:00',
+      failures: 1,
+      enabled: true
+    },
+    {
+      id: '3',
+      schedule: 'Weekly on Sunday',
+      playbook: 'Generate Reports',
+      lastRun: '2023-04-30 01:00',
+      failures: 0,
+      enabled: false
+    },
+    {
+      id: '4',
+      schedule: 'Every 15 minutes',
+      playbook: 'Monitor Server Load',
+      lastRun: '2023-05-01 14:45',
+      failures: 2,
+      enabled: true
+    }
+  ];
+}
diff --git a/apps/dbagent/src/components/monitoring/conn-selector.tsx b/apps/dbagent/src/components/monitoring/conn-selector.tsx
new file mode 100644
index 00000000..f971d4b6
--- /dev/null
+++ b/apps/dbagent/src/components/monitoring/conn-selector.tsx
@@ -0,0 +1,37 @@
+'use client';
+
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@internal/components';
+import { DbConnection } from '~/lib/db/connections';
+
+interface DatabaseSelectorProps {
+  connections: DbConnection[];
+  value: DbConnection | null;
+  onChange: (value: DbConnection) => void;
+}
+
+export function ConnectionSelector({ connections, value, onChange }: DatabaseSelectorProps) {
+  return (
+    <div className="flex items-center space-x-2 pr-2">
+      <Select
+        value={value?.name || ''}
+        onValueChange={(name) => {
+          const selectedConnection = connections.find((db) => db.name === name);
+          if (selectedConnection) {
+            onChange(selectedConnection);
+          }
+        }}
+      >
+        <SelectTrigger id="database-select" className="w-[180px]">
+          <SelectValue>{value?.name || ''}</SelectValue>
+        </SelectTrigger>
+        <SelectContent>
+          {connections.map((db) => (
+            <SelectItem key={db.id} value={db.name}>
+              {db.name}
+            </SelectItem>
+          ))}
+        </SelectContent>
+      </Select>
+    </div>
+  );
+}
diff --git a/apps/dbagent/src/components/monitoring/schedule-form.tsx b/apps/dbagent/src/components/monitoring/schedule-form.tsx
new file mode 100644
index 00000000..d9dca320
--- /dev/null
+++ b/apps/dbagent/src/components/monitoring/schedule-form.tsx
@@ -0,0 +1,150 @@
+'use client';
+
+import { Button, Input, Label, Textarea } from '@internal/components';
+import { useRouter } from 'next/navigation';
+import { useEffect } from 'react';
+import { Controller, useForm } from 'react-hook-form';
+
+type FormData = {
+  name: string;
+  cronExpression: string;
+  playbook: string;
+  description: string;
+  database: string;
+  enabled: boolean;
+};
+
+export function ScheduleForm({ action, scheduleId }: { action: string; scheduleId: string }) {
+  const router = useRouter();
+  const isEditMode = action !== 'add';
+
+  const { control, handleSubmit, reset } = useForm<FormData>({
+    defaultValues: {
+      name: '',
+      cronExpression: '',
+      playbook: '',
+      description: '',
+      database: 'Prod',
+      enabled: true
+    }
+  });
+
+  useEffect(() => {
+    if (isEditMode) {
+      // TODO: Fetch schedule data from API or database
+      // For now, we'll just simulate fetching data
+      reset({
+        name: 'Example Schedule',
+        cronExpression: '0 * * * *',
+        playbook: 'Check API Status',
+        description: 'Hourly check of API endpoints',
+        database: 'Prod',
+        enabled: true
+      });
+    }
+  }, [isEditMode, reset]);
+
+  const onSubmit = async (data: FormData) => {
+    // TODO: Save schedule to API or database
+    console.log('Saving schedule:', data);
+    router.push('/monitoring');
+  };
+
+  return (
+    <div className="container mx-auto py-10">
+      <h1 className="mb-6 text-2xl font-bold">{isEditMode ? 'Edit Schedule' : 'Add New Schedule'}</h1>
+      <form onSubmit={handleSubmit(onSubmit)} className="max-w-2xl space-y-6">
+        <div className="space-y-2">
+          <Label htmlFor="name">Schedule Name</Label>
+          <Controller
+            name="name"
+            control={control}
+            rules={{ required: 'Schedule name is required' }}
+            render={({ field, fieldState: { error } }) => (
+              <>
+                <Input {...field} id="name" />
+                {error && <p className="mt-1 text-sm text-red-500">{error.message}</p>}
+              </>
+            )}
+          />
+        </div>
+        <div className="space-y-2">
+          <Label htmlFor="cronExpression">Cron Expression</Label>
+          <Controller
+            name="cronExpression"
+            control={control}
+            rules={{ required: 'Cron expression is required' }}
+            render={({ field, fieldState: { error } }) => (
+              <>
+                <Input {...field} id="cronExpression" />
+                {error && <p className="mt-1 text-sm text-red-500">{error.message}</p>}
+              </>
+            )}
+          />
+        </div>
+        <div className="space-y-2">
+          <Label htmlFor="playbook">Playbook</Label>
+          <Controller
+            name="playbook"
+            control={control}
+            rules={{ required: 'Playbook is required' }}
+            render={({ field, fieldState: { error } }) => (
+              <>
+                <Input {...field} id="playbook" />
+                {error && <p className="mt-1 text-sm text-red-500">{error.message}</p>}
+              </>
+            )}
+          />
+        </div>
+        <div className="space-y-2">
+          <Label htmlFor="description">Description</Label>
+          <Controller
+            name="description"
+            control={control}
+            render={({ field }) => <Textarea {...field} id="description" rows={3} />}
+          />
+        </div>
+        <div className="space-y-2">
+          <Label htmlFor="database">Database</Label>
+          <Controller
+            name="database"
+            control={control}
+            render={({ field }) => (
+              <select
+                {...field}
+                id="database"
+                className="w-full rounded-md border border-gray-300 px-3 py-2 shadow-sm focus:border-blue-500 focus:outline-none focus:ring-1 focus:ring-blue-500"
+              >
+                <option value="Prod">Prod</option>
+                <option value="Staging">Staging</option>
+                <option value="Test">Test</option>
+              </select>
+            )}
+          />
+        </div>
+        <div className="flex items-center space-x-2">
+          <Controller
+            name="enabled"
+            control={control}
+            render={({ field }) => (
+              <input
+                type="checkbox"
+                id="enabled"
+                checked={field.value}
+                onChange={(e) => field.onChange(e.target.checked)}
+                className="h-4 w-4 rounded border-gray-300 text-blue-600 focus:ring-blue-500"
+              />
+            )}
+          />
+          <Label htmlFor="enabled">Enabled</Label>
+        </div>
+        <div className="flex space-x-4">
+          <Button type="submit">{isEditMode ? 'Update Schedule' : 'Create Schedule'}</Button>
+          <Button type="button" variant="outline" onClick={() => router.push('/monitoring-schedule')}>
+            Cancel
+          </Button>
+        </div>
+      </form>
+    </div>
+  );
+}
diff --git a/apps/dbagent/src/components/monitoring/schedules-table.tsx b/apps/dbagent/src/components/monitoring/schedules-table.tsx
new file mode 100644
index 00000000..547a4582
--- /dev/null
+++ b/apps/dbagent/src/components/monitoring/schedules-table.tsx
@@ -0,0 +1,70 @@
+'use client';
+
+import { Button, Switch, Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@internal/components';
+import { PencilIcon, PlusIcon } from 'lucide-react';
+import Link from 'next/link';
+import { useEffect, useState } from 'react';
+import { DbConnection } from '~/lib/db/connections';
+import { getSchedules, Schedule } from './actions';
+import { ConnectionSelector } from './conn-selector';
+
+export function MonitoringScheduleTable({ connections }: { connections: DbConnection[] }) {
+  const [schedules, setSchedules] = useState<Schedule[]>([]);
+  const defaultConnection = connections.find((c) => c.is_default);
+  const [selectedDatabase, setSelectedDatabase] = useState<DbConnection | null>(defaultConnection || null);
+  useEffect(() => {
+    const loadSchedules = async () => {
+      const schedules = await getSchedules();
+      setSchedules(schedules);
+    };
+    void loadSchedules();
+  }, []);
+
+  return (
+    <div>
+      <div className="mb-4 flex items-center justify-between">
+        <h1 className="text-2xl font-bold">Monitoring Schedules</h1>
+        <div className="mb-6 flex items-center justify-between">
+          <ConnectionSelector connections={connections} value={selectedDatabase} onChange={setSelectedDatabase} />
+          <Button>
+            <PlusIcon className="mr-2 h-4 w-4" /> Add New Schedule
+          </Button>
+        </div>
+      </div>
+      <Table>
+        <TableHeader>
+          <TableRow>
+            <TableHead className="w-[150px]">Schedule</TableHead>
+            <TableHead>Playbook</TableHead>
+            <TableHead className="w-[150px]">Last Run</TableHead>
+            <TableHead className="w-[100px]">Failures</TableHead>
+            <TableHead className="w-[100px]">Status</TableHead>
+            <TableHead className="w-[100px]">Actions</TableHead>
+          </TableRow>
+        </TableHeader>
+        <TableBody>
+          {schedules.map((schedule) => (
+            <TableRow key={schedule.id}>
+              <TableCell className="font-medium">{schedule.schedule}</TableCell>
+              <TableCell>{schedule.playbook}</TableCell>
+              <TableCell>{schedule.lastRun}</TableCell>
+              <TableCell>{schedule.failures}</TableCell>
+              <TableCell>
+                <Switch checked={schedule.enabled} />
+              </TableCell>
+              <TableCell>
+                <div className="flex space-x-2">
+                  <Link href={`/monitoring/schedule/${schedule.id}`}>
+                    <Button variant="outline" size="icon" className="cursor-pointer">
+                      <PencilIcon className="h-4 w-4" />
+                    </Button>
+                  </Link>
+                </div>
+              </TableCell>
+            </TableRow>
+          ))}
+        </TableBody>
+      </Table>
+    </div>
+  );
+}

From 1377ca91c9b4811649877b151e61238be9d6aa57 Mon Sep 17 00:00:00 2001
From: Tudor Golubenco <tudor@xata.io>
Date: Wed, 19 Feb 2025 12:54:13 +0100
Subject: [PATCH 02/12] New form

---
 .../(main)/monitoring/schedule/[id]/page.tsx  |   5 +-
 .../src/components/monitoring/actions.ts      |  20 ++
 .../monitoring/cron-expression-modal.tsx      |  74 ++++
 .../components/monitoring/schedule-form.tsx   | 339 ++++++++++++------
 .../components/monitoring/schedules-table.tsx |   8 +-
 5 files changed, 327 insertions(+), 119 deletions(-)
 create mode 100644 apps/dbagent/src/components/monitoring/cron-expression-modal.tsx

diff --git a/apps/dbagent/src/app/(main)/monitoring/schedule/[id]/page.tsx b/apps/dbagent/src/app/(main)/monitoring/schedule/[id]/page.tsx
index 22d5d222..df03a818 100644
--- a/apps/dbagent/src/app/(main)/monitoring/schedule/[id]/page.tsx
+++ b/apps/dbagent/src/app/(main)/monitoring/schedule/[id]/page.tsx
@@ -1,8 +1,11 @@
+import { actionListPlaybooks } from '~/components/monitoring/actions';
 import { ScheduleForm } from '~/components/monitoring/schedule-form';
+
 export default async function Page({ params }: { params: { id: string } }) {
+  const playbooks = await actionListPlaybooks();
   return (
     <div className="container">
-      <ScheduleForm action="edit" scheduleId={params.id} />
+      <ScheduleForm scheduleId={params.id} playbooks={playbooks} />
     </div>
   );
 }
diff --git a/apps/dbagent/src/components/monitoring/actions.ts b/apps/dbagent/src/components/monitoring/actions.ts
index 39b6ac09..a0121951 100644
--- a/apps/dbagent/src/components/monitoring/actions.ts
+++ b/apps/dbagent/src/components/monitoring/actions.ts
@@ -1,5 +1,9 @@
 'use server';
 
+import { openai } from '@ai-sdk/openai';
+import { generateText } from 'ai';
+import { listPlaybooks } from '~/lib/tools/playbooks';
+
 export type Schedule = {
   id: string;
   schedule: string;
@@ -9,6 +13,18 @@ export type Schedule = {
   enabled: boolean;
 };
 
+export async function generateCronExpression(description: string): Promise<string> {
+  const prompt = `Generate a cron expression for the following schedule description: "${description}". 
+  Return strictly the cron expression, no quotes or anything else.`;
+
+  const { text } = await generateText({
+    model: openai('gpt-4o'),
+    prompt: prompt
+  });
+
+  return text.trim();
+}
+
 export async function getSchedules(): Promise<Schedule[]> {
   // TODO: Replace with actual database query
   return [
@@ -46,3 +62,7 @@ export async function getSchedules(): Promise<Schedule[]> {
     }
   ];
 }
+
+export async function actionListPlaybooks(): Promise<string[]> {
+  return listPlaybooks();
+}
diff --git a/apps/dbagent/src/components/monitoring/cron-expression-modal.tsx b/apps/dbagent/src/components/monitoring/cron-expression-modal.tsx
new file mode 100644
index 00000000..8144808b
--- /dev/null
+++ b/apps/dbagent/src/components/monitoring/cron-expression-modal.tsx
@@ -0,0 +1,74 @@
+'use client';
+
+import {
+  Button,
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+  Input,
+  Label
+} from '@internal/components';
+import { useState } from 'react';
+import { generateCronExpression } from './actions';
+
+interface CronExpressionModalProps {
+  isOpen: boolean;
+  onClose: () => void;
+  onGenerate: (expression: string) => void;
+}
+
+export function CronExpressionModal({ isOpen, onClose, onGenerate }: CronExpressionModalProps) {
+  const [input, setInput] = useState('');
+  const [generatedExpression, setGeneratedExpression] = useState('');
+
+  const handleGenerate = async () => {
+    const expression = await generateCronExpression(input);
+    setGeneratedExpression(expression);
+  };
+
+  return (
+    <Dialog open={isOpen} onOpenChange={onClose}>
+      <DialogContent className="sm:max-w-[425px]">
+        <DialogHeader>
+          <DialogTitle>Generate Cron Expression</DialogTitle>
+          <DialogDescription>
+            Enter a description of your desired schedule, and we&apos;ll generate a cron expression for you.
+          </DialogDescription>
+        </DialogHeader>
+        <div className="grid gap-4 py-4">
+          <div className="grid grid-cols-4 items-center gap-4">
+            <Label htmlFor="schedule-description" className="text-right">
+              Description
+            </Label>
+            <Input
+              id="schedule-description"
+              value={input}
+              onChange={(e) => setInput(e.target.value)}
+              className="col-span-3"
+              placeholder="e.g., Every Monday at 9 AM"
+            />
+          </div>
+          {generatedExpression && (
+            <div className="grid grid-cols-4 items-center gap-4">
+              <Label htmlFor="generated-expression" className="text-right">
+                Generated
+              </Label>
+              <Input id="generated-expression" value={generatedExpression} readOnly className="col-span-3" />
+            </div>
+          )}
+        </div>
+        <DialogFooter>
+          <Button type="button" onClick={handleGenerate}>
+            Generate
+          </Button>
+          <Button type="button" onClick={() => onGenerate(generatedExpression)} disabled={!generatedExpression}>
+            Use Expression
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/apps/dbagent/src/components/monitoring/schedule-form.tsx b/apps/dbagent/src/components/monitoring/schedule-form.tsx
index d9dca320..c69205f7 100644
--- a/apps/dbagent/src/components/monitoring/schedule-form.tsx
+++ b/apps/dbagent/src/components/monitoring/schedule-form.tsx
@@ -1,30 +1,77 @@
 'use client';
 
-import { Button, Input, Label, Textarea } from '@internal/components';
-import { useRouter } from 'next/navigation';
-import { useEffect } from 'react';
-import { Controller, useForm } from 'react-hook-form';
+import {
+  Button,
+  Card,
+  CardContent,
+  CardHeader,
+  CardTitle,
+  Form,
+  FormControl,
+  FormDescription,
+  FormField,
+  FormItem,
+  FormLabel,
+  Input,
+  RadioGroup,
+  RadioGroupItem,
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+  Switch,
+  Textarea,
+  zodResolver
+} from '@internal/components';
+import { useEffect, useState } from 'react';
+import { useForm } from 'react-hook-form';
+import * as z from 'zod';
+import { CronExpressionModal } from './cron-expression-modal';
 
 type FormData = {
-  name: string;
-  cronExpression: string;
   playbook: string;
-  description: string;
+  cronExpression: string;
+  additionalDetails: string;
   database: string;
+  description: string;
   enabled: boolean;
 };
 
-export function ScheduleForm({ action, scheduleId }: { action: string; scheduleId: string }) {
-  const router = useRouter();
-  const isEditMode = action !== 'add';
+const formSchema = z.object({
+  playbook: z.string().min(1, { message: 'Please select a playbook' }),
+  scheduleType: z.enum(['automatic', 'cron']),
+  minInterval: z.string().optional(),
+  maxInterval: z.string().optional(),
+  cronExpression: z.string().optional(),
+  additionalInstructions: z.string().optional(),
+  enabled: z.boolean()
+});
 
-  const { control, handleSubmit, reset } = useForm<FormData>({
+export function ScheduleForm({ scheduleId, playbooks }: { scheduleId: string; playbooks: string[] }) {
+  //const router = useRouter();
+  const [showCronModal, setShowCronModal] = useState(false);
+  const form = useForm<z.infer<typeof formSchema>>({
+    resolver: zodResolver(formSchema),
     defaultValues: {
-      name: '',
-      cronExpression: '',
       playbook: '',
-      description: '',
+      scheduleType: 'cron',
+      minInterval: '',
+      maxInterval: '',
+      cronExpression: '',
+      additionalInstructions: '',
+      enabled: true
+    }
+  });
+  const isEditMode = scheduleId !== 'add';
+
+  const { control, handleSubmit, reset } = useForm<FormData>({
+    defaultValues: {
+      cronExpression: '0 5 * * *',
+      playbook: playbooks[0] || '',
+      additionalDetails: '',
       database: 'Prod',
+      description: '',
       enabled: true
     }
   });
@@ -34,117 +81,179 @@ export function ScheduleForm({ action, scheduleId }: { action: string; scheduleI
       // TODO: Fetch schedule data from API or database
       // For now, we'll just simulate fetching data
       reset({
-        name: 'Example Schedule',
-        cronExpression: '0 * * * *',
-        playbook: 'Check API Status',
-        description: 'Hourly check of API endpoints',
+        cronExpression: '0 5 * * *',
+        playbook: playbooks[0] || '',
+        additionalDetails: '',
         database: 'Prod',
+        description: '',
         enabled: true
       });
     }
   }, [isEditMode, reset]);
 
-  const onSubmit = async (data: FormData) => {
-    // TODO: Save schedule to API or database
-    console.log('Saving schedule:', data);
-    router.push('/monitoring');
+  const onSubmit = async (data: z.infer<typeof formSchema>) => {
+    console.log(data);
+    // Here you would typically send the data to your backend
+    alert('Form submitted! Check console for data.');
   };
 
   return (
-    <div className="container mx-auto py-10">
-      <h1 className="mb-6 text-2xl font-bold">{isEditMode ? 'Edit Schedule' : 'Add New Schedule'}</h1>
-      <form onSubmit={handleSubmit(onSubmit)} className="max-w-2xl space-y-6">
-        <div className="space-y-2">
-          <Label htmlFor="name">Schedule Name</Label>
-          <Controller
-            name="name"
-            control={control}
-            rules={{ required: 'Schedule name is required' }}
-            render={({ field, fieldState: { error } }) => (
-              <>
-                <Input {...field} id="name" />
-                {error && <p className="mt-1 text-sm text-red-500">{error.message}</p>}
-              </>
-            )}
-          />
-        </div>
-        <div className="space-y-2">
-          <Label htmlFor="cronExpression">Cron Expression</Label>
-          <Controller
-            name="cronExpression"
-            control={control}
-            rules={{ required: 'Cron expression is required' }}
-            render={({ field, fieldState: { error } }) => (
-              <>
-                <Input {...field} id="cronExpression" />
-                {error && <p className="mt-1 text-sm text-red-500">{error.message}</p>}
-              </>
-            )}
-          />
-        </div>
-        <div className="space-y-2">
-          <Label htmlFor="playbook">Playbook</Label>
-          <Controller
-            name="playbook"
-            control={control}
-            rules={{ required: 'Playbook is required' }}
-            render={({ field, fieldState: { error } }) => (
-              <>
-                <Input {...field} id="playbook" />
-                {error && <p className="mt-1 text-sm text-red-500">{error.message}</p>}
-              </>
-            )}
-          />
-        </div>
-        <div className="space-y-2">
-          <Label htmlFor="description">Description</Label>
-          <Controller
-            name="description"
-            control={control}
-            render={({ field }) => <Textarea {...field} id="description" rows={3} />}
-          />
-        </div>
-        <div className="space-y-2">
-          <Label htmlFor="database">Database</Label>
-          <Controller
-            name="database"
-            control={control}
-            render={({ field }) => (
-              <select
-                {...field}
-                id="database"
-                className="w-full rounded-md border border-gray-300 px-3 py-2 shadow-sm focus:border-blue-500 focus:outline-none focus:ring-1 focus:ring-blue-500"
-              >
-                <option value="Prod">Prod</option>
-                <option value="Staging">Staging</option>
-                <option value="Test">Test</option>
-              </select>
-            )}
-          />
-        </div>
-        <div className="flex items-center space-x-2">
-          <Controller
-            name="enabled"
-            control={control}
-            render={({ field }) => (
-              <input
-                type="checkbox"
-                id="enabled"
-                checked={field.value}
-                onChange={(e) => field.onChange(e.target.checked)}
-                className="h-4 w-4 rounded border-gray-300 text-blue-600 focus:ring-blue-500"
+    <div className="container mx-auto p-4">
+      <Card>
+        <CardHeader>
+          <CardTitle>{isEditMode ? 'Edit monitoring schedule' : 'Add new monitoring schedule'}</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <Form {...form}>
+            <form onSubmit={form.handleSubmit(onSubmit)} className="space-y-6">
+              <FormField
+                control={form.control}
+                name="playbook"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>Playbook</FormLabel>
+                    <Select onValueChange={field.onChange} defaultValue={field.value}>
+                      <FormControl>
+                        <SelectTrigger>
+                          <SelectValue placeholder="Select a playbook" />
+                        </SelectTrigger>
+                      </FormControl>
+                      <SelectContent>
+                        {playbooks.map((playbook) => (
+                          <SelectItem key={playbook} value={playbook}>
+                            {playbook}
+                          </SelectItem>
+                        ))}
+                      </SelectContent>
+                    </Select>
+                  </FormItem>
+                )}
+              />
+
+              <FormField
+                control={form.control}
+                name="scheduleType"
+                render={({ field }) => (
+                  <FormItem className="space-y-3">
+                    <FormLabel>Schedule Type</FormLabel>
+                    <FormControl>
+                      <RadioGroup
+                        onValueChange={field.onChange}
+                        defaultValue={field.value}
+                        className="flex flex-col space-y-1"
+                      >
+                        <FormItem className="flex items-center space-x-3 space-y-0">
+                          <FormItem className="flex items-center space-x-3 space-y-0">
+                            <FormControl>
+                              <RadioGroupItem value="cron" />
+                            </FormControl>
+                            <FormLabel className="font-normal">Cron Expression</FormLabel>
+                          </FormItem>
+                          <FormControl>
+                            <RadioGroupItem value="automatic" />
+                          </FormControl>
+                          <FormLabel className="font-normal">
+                            Automatic/Dynamic (let the agent decide the next run)
+                          </FormLabel>
+                        </FormItem>
+                      </RadioGroup>
+                    </FormControl>
+                  </FormItem>
+                )}
+              />
+
+              {form.watch('scheduleType') === 'automatic' && (
+                <div className="grid grid-cols-2 gap-4">
+                  <FormField
+                    control={form.control}
+                    name="minInterval"
+                    render={({ field }) => (
+                      <FormItem>
+                        <FormLabel>Minimum Interval (minutes)</FormLabel>
+                        <FormControl>
+                          <Input type="number" {...field} />
+                        </FormControl>
+                      </FormItem>
+                    )}
+                  />
+                  <FormField
+                    control={form.control}
+                    name="maxInterval"
+                    render={({ field }) => (
+                      <FormItem>
+                        <FormLabel>Maximum Interval (minutes)</FormLabel>
+                        <FormControl>
+                          <Input type="number" {...field} />
+                        </FormControl>
+                      </FormItem>
+                    )}
+                  />
+                </div>
+              )}
+
+              {form.watch('scheduleType') === 'cron' && (
+                <FormField
+                  control={form.control}
+                  name="cronExpression"
+                  render={({ field }) => (
+                    <FormItem>
+                      <FormLabel>Cron Expression</FormLabel>
+                      <FormControl>
+                        <div className="flex space-x-2">
+                          <Input {...field} />
+                          <Button type="button" variant="outline" onClick={() => setShowCronModal(true)}>
+                            Generate with AI
+                          </Button>
+                        </div>
+                      </FormControl>
+                    </FormItem>
+                  )}
+                />
+              )}
+
+              <FormField
+                control={form.control}
+                name="additionalInstructions"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>Additional Instructions</FormLabel>
+                    <FormControl>
+                      <Textarea placeholder="Enter any additional instructions here..." {...field} />
+                    </FormControl>
+                  </FormItem>
+                )}
+              />
+
+              <FormField
+                control={form.control}
+                name="enabled"
+                render={({ field }) => (
+                  <FormItem className="flex flex-row items-center justify-between rounded-lg border p-4">
+                    <div className="space-y-0.5">
+                      <FormLabel className="text-base">Enabled</FormLabel>
+                      <FormDescription>Turn on or off the monitoring job schedule</FormDescription>
+                    </div>
+                    <FormControl>
+                      <Switch checked={field.value} onCheckedChange={field.onChange} />
+                    </FormControl>
+                  </FormItem>
+                )}
               />
-            )}
-          />
-          <Label htmlFor="enabled">Enabled</Label>
-        </div>
-        <div className="flex space-x-4">
-          <Button type="submit">{isEditMode ? 'Update Schedule' : 'Create Schedule'}</Button>
-          <Button type="button" variant="outline" onClick={() => router.push('/monitoring-schedule')}>
-            Cancel
-          </Button>
-        </div>
-      </form>
+
+              <Button type="submit">Create Schedule</Button>
+            </form>
+
+            <CronExpressionModal
+              isOpen={showCronModal}
+              onClose={() => setShowCronModal(false)}
+              onGenerate={(expression) => {
+                form.setValue('cronExpression', expression);
+                setShowCronModal(false);
+              }}
+            />
+          </Form>
+        </CardContent>
+      </Card>
     </div>
   );
 }
diff --git a/apps/dbagent/src/components/monitoring/schedules-table.tsx b/apps/dbagent/src/components/monitoring/schedules-table.tsx
index 547a4582..e40a2372 100644
--- a/apps/dbagent/src/components/monitoring/schedules-table.tsx
+++ b/apps/dbagent/src/components/monitoring/schedules-table.tsx
@@ -26,9 +26,11 @@ export function MonitoringScheduleTable({ connections }: { connections: DbConnec
         <h1 className="text-2xl font-bold">Monitoring Schedules</h1>
         <div className="mb-6 flex items-center justify-between">
           <ConnectionSelector connections={connections} value={selectedDatabase} onChange={setSelectedDatabase} />
-          <Button>
-            <PlusIcon className="mr-2 h-4 w-4" /> Add New Schedule
-          </Button>
+          <Link href="/monitoring/schedule/add">
+            <Button>
+              <PlusIcon className="mr-2 h-4 w-4" /> Add New Schedule
+            </Button>
+          </Link>
         </div>
       </div>
       <Table>

From 2e66e40b9d1e0c49a10d3d1f5cae946c4bca3ef9 Mon Sep 17 00:00:00 2001
From: Tudor Golubenco <tudor@xata.io>
Date: Wed, 19 Feb 2025 18:49:16 +0100
Subject: [PATCH 03/12] Small visual fixes

---
 .../monitoring/cron-expression-modal.tsx      | 20 +++++----
 .../components/monitoring/schedule-form.tsx   | 45 ++++++-------------
 2 files changed, 26 insertions(+), 39 deletions(-)

diff --git a/apps/dbagent/src/components/monitoring/cron-expression-modal.tsx b/apps/dbagent/src/components/monitoring/cron-expression-modal.tsx
index 8144808b..52f495f6 100644
--- a/apps/dbagent/src/components/monitoring/cron-expression-modal.tsx
+++ b/apps/dbagent/src/components/monitoring/cron-expression-modal.tsx
@@ -43,20 +43,24 @@ export function CronExpressionModal({ isOpen, onClose, onGenerate }: CronExpress
             <Label htmlFor="schedule-description" className="text-right">
               Description
             </Label>
-            <Input
-              id="schedule-description"
-              value={input}
-              onChange={(e) => setInput(e.target.value)}
-              className="col-span-3"
-              placeholder="e.g., Every Monday at 9 AM"
-            />
+            <div className="col-span-3">
+              <Input
+                id="schedule-description"
+                value={input}
+                onChange={(e) => setInput(e.target.value)}
+                className="w-full"
+                placeholder="e.g., Every Monday at 9 AM"
+              />
+            </div>
           </div>
           {generatedExpression && (
             <div className="grid grid-cols-4 items-center gap-4">
               <Label htmlFor="generated-expression" className="text-right">
                 Generated
               </Label>
-              <Input id="generated-expression" value={generatedExpression} readOnly className="col-span-3" />
+              <div className="col-span-3">
+                <Input id="generated-expression" value={generatedExpression} readOnly />
+              </div>
             </div>
           )}
         </div>
diff --git a/apps/dbagent/src/components/monitoring/schedule-form.tsx b/apps/dbagent/src/components/monitoring/schedule-form.tsx
index c69205f7..0d76961d 100644
--- a/apps/dbagent/src/components/monitoring/schedule-form.tsx
+++ b/apps/dbagent/src/components/monitoring/schedule-form.tsx
@@ -29,15 +29,6 @@ import { useForm } from 'react-hook-form';
 import * as z from 'zod';
 import { CronExpressionModal } from './cron-expression-modal';
 
-type FormData = {
-  playbook: string;
-  cronExpression: string;
-  additionalDetails: string;
-  database: string;
-  description: string;
-  enabled: boolean;
-};
-
 const formSchema = z.object({
   playbook: z.string().min(1, { message: 'Please select a playbook' }),
   scheduleType: z.enum(['automatic', 'cron']),
@@ -54,42 +45,32 @@ export function ScheduleForm({ scheduleId, playbooks }: { scheduleId: string; pl
   const form = useForm<z.infer<typeof formSchema>>({
     resolver: zodResolver(formSchema),
     defaultValues: {
-      playbook: '',
+      playbook: playbooks[0] || '',
       scheduleType: 'cron',
-      minInterval: '',
-      maxInterval: '',
-      cronExpression: '',
+      minInterval: '5',
+      maxInterval: '1440',
+      cronExpression: '0 * * * *',
       additionalInstructions: '',
       enabled: true
     }
   });
   const isEditMode = scheduleId !== 'add';
 
-  const { control, handleSubmit, reset } = useForm<FormData>({
-    defaultValues: {
-      cronExpression: '0 5 * * *',
-      playbook: playbooks[0] || '',
-      additionalDetails: '',
-      database: 'Prod',
-      description: '',
-      enabled: true
-    }
-  });
-
   useEffect(() => {
     if (isEditMode) {
       // TODO: Fetch schedule data from API or database
       // For now, we'll just simulate fetching data
-      reset({
-        cronExpression: '0 5 * * *',
+      form.reset({
+        cronExpression: '0 * * * *',
+        scheduleType: 'cron',
+        minInterval: '5',
+        maxInterval: '60',
         playbook: playbooks[0] || '',
-        additionalDetails: '',
-        database: 'Prod',
-        description: '',
+        additionalInstructions: '',
         enabled: true
       });
     }
-  }, [isEditMode, reset]);
+  }, [isEditMode, form.reset]);
 
   const onSubmit = async (data: z.infer<typeof formSchema>) => {
     console.log(data);
@@ -200,7 +181,9 @@ export function ScheduleForm({ scheduleId, playbooks }: { scheduleId: string; pl
                       <FormLabel>Cron Expression</FormLabel>
                       <FormControl>
                         <div className="flex space-x-2">
-                          <Input {...field} />
+                          <div className="w-full">
+                            <Input {...field} />
+                          </div>
                           <Button type="button" variant="outline" onClick={() => setShowCronModal(true)}>
                             Generate with AI
                           </Button>

From e024efbcfb6cc5558e75783a3419eb965bcb1ce7 Mon Sep 17 00:00:00 2001
From: Tudor Golubenco <tudor@xata.io>
Date: Fri, 21 Feb 2025 10:54:08 +0100
Subject: [PATCH 04/12] Save schedules to the DB

---
 apps/dbagent/migrations/0005_schedules.sql    |  11 ++
 .../src/components/monitoring/actions.ts      |  64 +++-----
 .../components/monitoring/schedule-form.tsx   |  70 +++++---
 .../components/monitoring/schedules-table.tsx |   8 +-
 apps/dbagent/src/lib/db/monitoring.ts         | 151 ++++++++++++++++++
 5 files changed, 243 insertions(+), 61 deletions(-)
 create mode 100644 apps/dbagent/migrations/0005_schedules.sql
 create mode 100644 apps/dbagent/src/lib/db/monitoring.ts

diff --git a/apps/dbagent/migrations/0005_schedules.sql b/apps/dbagent/migrations/0005_schedules.sql
new file mode 100644
index 00000000..dfc1dba7
--- /dev/null
+++ b/apps/dbagent/migrations/0005_schedules.sql
@@ -0,0 +1,11 @@
+CREATE TABLE schedules (
+  id SERIAL PRIMARY KEY,
+  connection_id INT NOT NULL REFERENCES connections(id),
+  playbook VARCHAR(255) NOT NULL,
+  schedule_type VARCHAR(255) NOT NULL,
+  cron_expression VARCHAR(255),
+  additional_instructions TEXT,
+  min_interval INT,
+  max_interval INT,
+  enabled BOOLEAN NOT NULL
+);
diff --git a/apps/dbagent/src/components/monitoring/actions.ts b/apps/dbagent/src/components/monitoring/actions.ts
index a0121951..ba9c2a07 100644
--- a/apps/dbagent/src/components/monitoring/actions.ts
+++ b/apps/dbagent/src/components/monitoring/actions.ts
@@ -2,14 +2,20 @@
 
 import { openai } from '@ai-sdk/openai';
 import { generateText } from 'ai';
+import { getSchedule, getSchedules, insertSchedule, updateSchedule } from '~/lib/db/monitoring';
 import { listPlaybooks } from '~/lib/tools/playbooks';
 
 export type Schedule = {
   id: string;
-  schedule: string;
+  connectionId: string;
   playbook: string;
-  lastRun: string;
-  failures: number;
+  scheduleType: string;
+  cronExpression?: string;
+  additionalInstructions?: string;
+  minInterval?: number;
+  maxInterval?: number;
+  lastRun?: string;
+  failures?: number;
   enabled: boolean;
 };
 
@@ -25,42 +31,22 @@ export async function generateCronExpression(description: string): Promise<strin
   return text.trim();
 }
 
-export async function getSchedules(): Promise<Schedule[]> {
-  // TODO: Replace with actual database query
-  return [
-    {
-      id: '1',
-      schedule: 'Every hour',
-      playbook: 'Check API Status',
-      lastRun: '2023-05-01 14:30',
-      failures: 0,
-      enabled: true
-    },
-    {
-      id: '2',
-      schedule: 'Daily at 00:00',
-      playbook: 'Database Backup',
-      lastRun: '2023-05-01 00:00',
-      failures: 1,
-      enabled: true
-    },
-    {
-      id: '3',
-      schedule: 'Weekly on Sunday',
-      playbook: 'Generate Reports',
-      lastRun: '2023-04-30 01:00',
-      failures: 0,
-      enabled: false
-    },
-    {
-      id: '4',
-      schedule: 'Every 15 minutes',
-      playbook: 'Monitor Server Load',
-      lastRun: '2023-05-01 14:45',
-      failures: 2,
-      enabled: true
-    }
-  ];
+export async function actionCreateSchedule(schedule: Schedule): Promise<Schedule> {
+  return insertSchedule(schedule);
+}
+
+export async function actionUpdateSchedule(schedule: Schedule): Promise<Schedule> {
+  return updateSchedule(schedule);
+}
+
+export async function actionGetSchedules(): Promise<Schedule[]> {
+  const schedules = await getSchedules();
+  console.log(schedules);
+  return schedules;
+}
+
+export async function actionGetSchedule(id: string): Promise<Schedule> {
+  return getSchedule(id);
 }
 
 export async function actionListPlaybooks(): Promise<string[]> {
diff --git a/apps/dbagent/src/components/monitoring/schedule-form.tsx b/apps/dbagent/src/components/monitoring/schedule-form.tsx
index 0d76961d..369ea7a4 100644
--- a/apps/dbagent/src/components/monitoring/schedule-form.tsx
+++ b/apps/dbagent/src/components/monitoring/schedule-form.tsx
@@ -24,9 +24,12 @@ import {
   Textarea,
   zodResolver
 } from '@internal/components';
+import Link from 'next/link';
+import { useRouter } from 'next/navigation';
 import { useEffect, useState } from 'react';
 import { useForm } from 'react-hook-form';
 import * as z from 'zod';
+import { actionCreateSchedule, actionGetSchedule, actionUpdateSchedule, Schedule } from './actions';
 import { CronExpressionModal } from './cron-expression-modal';
 
 const formSchema = z.object({
@@ -39,8 +42,16 @@ const formSchema = z.object({
   enabled: z.boolean()
 });
 
-export function ScheduleForm({ scheduleId, playbooks }: { scheduleId: string; playbooks: string[] }) {
-  //const router = useRouter();
+export function ScheduleForm({
+  scheduleId,
+  playbooks,
+  connectionId
+}: {
+  scheduleId: string;
+  playbooks: string[];
+  connectionId: string;
+}) {
+  const router = useRouter();
   const [showCronModal, setShowCronModal] = useState(false);
   const form = useForm<z.infer<typeof formSchema>>({
     resolver: zodResolver(formSchema),
@@ -58,24 +69,41 @@ export function ScheduleForm({ scheduleId, playbooks }: { scheduleId: string; pl
 
   useEffect(() => {
     if (isEditMode) {
-      // TODO: Fetch schedule data from API or database
-      // For now, we'll just simulate fetching data
-      form.reset({
-        cronExpression: '0 * * * *',
-        scheduleType: 'cron',
-        minInterval: '5',
-        maxInterval: '60',
-        playbook: playbooks[0] || '',
-        additionalInstructions: '',
-        enabled: true
-      });
+      const fetchSchedule = async () => {
+        const schedule = await actionGetSchedule(scheduleId);
+        form.reset({
+          playbook: schedule.playbook,
+          scheduleType: schedule.scheduleType as 'automatic' | 'cron',
+          cronExpression: schedule.cronExpression,
+          minInterval: schedule.minInterval?.toString(),
+          maxInterval: schedule.maxInterval?.toString(),
+          additionalInstructions: schedule.additionalInstructions,
+          enabled: schedule.enabled
+        });
+      };
+      void fetchSchedule();
     }
-  }, [isEditMode, form.reset]);
+  }, [isEditMode, form.reset, scheduleId]);
 
   const onSubmit = async (data: z.infer<typeof formSchema>) => {
+    const schedule: Schedule = {
+      id: scheduleId,
+      connectionId: connectionId,
+      playbook: data.playbook,
+      scheduleType: data.scheduleType,
+      cronExpression: data.cronExpression,
+      additionalInstructions: data.additionalInstructions,
+      minInterval: Number(data.minInterval),
+      maxInterval: Number(data.maxInterval),
+      enabled: data.enabled
+    };
+    if (isEditMode) {
+      await actionUpdateSchedule(schedule);
+    } else {
+      await actionCreateSchedule(schedule);
+    }
     console.log(data);
-    // Here you would typically send the data to your backend
-    alert('Form submitted! Check console for data.');
+    router.push('/monitoring');
   };
 
   return (
@@ -110,7 +138,6 @@ export function ScheduleForm({ scheduleId, playbooks }: { scheduleId: string; pl
                   </FormItem>
                 )}
               />
-
               <FormField
                 control={form.control}
                 name="scheduleType"
@@ -120,7 +147,7 @@ export function ScheduleForm({ scheduleId, playbooks }: { scheduleId: string; pl
                     <FormControl>
                       <RadioGroup
                         onValueChange={field.onChange}
-                        defaultValue={field.value}
+                        value={field.value}
                         className="flex flex-col space-y-1"
                       >
                         <FormItem className="flex items-center space-x-3 space-y-0">
@@ -223,7 +250,12 @@ export function ScheduleForm({ scheduleId, playbooks }: { scheduleId: string; pl
                 )}
               />
 
-              <Button type="submit">Create Schedule</Button>
+              <Button type="submit" className="mr-2">
+                {isEditMode ? 'Update Schedule' : 'Create Schedule'}
+              </Button>
+              <Link href="/monitoring">
+                <Button variant="outline">Cancel</Button>
+              </Link>
             </form>
 
             <CronExpressionModal
diff --git a/apps/dbagent/src/components/monitoring/schedules-table.tsx b/apps/dbagent/src/components/monitoring/schedules-table.tsx
index e40a2372..6b3ff48c 100644
--- a/apps/dbagent/src/components/monitoring/schedules-table.tsx
+++ b/apps/dbagent/src/components/monitoring/schedules-table.tsx
@@ -5,7 +5,7 @@ import { PencilIcon, PlusIcon } from 'lucide-react';
 import Link from 'next/link';
 import { useEffect, useState } from 'react';
 import { DbConnection } from '~/lib/db/connections';
-import { getSchedules, Schedule } from './actions';
+import { actionGetSchedules, Schedule } from './actions';
 import { ConnectionSelector } from './conn-selector';
 
 export function MonitoringScheduleTable({ connections }: { connections: DbConnection[] }) {
@@ -14,7 +14,7 @@ export function MonitoringScheduleTable({ connections }: { connections: DbConnec
   const [selectedDatabase, setSelectedDatabase] = useState<DbConnection | null>(defaultConnection || null);
   useEffect(() => {
     const loadSchedules = async () => {
-      const schedules = await getSchedules();
+      const schedules = await actionGetSchedules();
       setSchedules(schedules);
     };
     void loadSchedules();
@@ -47,7 +47,9 @@ export function MonitoringScheduleTable({ connections }: { connections: DbConnec
         <TableBody>
           {schedules.map((schedule) => (
             <TableRow key={schedule.id}>
-              <TableCell className="font-medium">{schedule.schedule}</TableCell>
+              <TableCell className="font-medium">
+                {schedule.scheduleType === 'cron' ? schedule.cronExpression : 'Automatic'}
+              </TableCell>
               <TableCell>{schedule.playbook}</TableCell>
               <TableCell>{schedule.lastRun}</TableCell>
               <TableCell>{schedule.failures}</TableCell>
diff --git a/apps/dbagent/src/lib/db/monitoring.ts b/apps/dbagent/src/lib/db/monitoring.ts
new file mode 100644
index 00000000..82860f00
--- /dev/null
+++ b/apps/dbagent/src/lib/db/monitoring.ts
@@ -0,0 +1,151 @@
+import { Schedule } from '~/components/monitoring/actions';
+import { pool } from './db';
+
+export async function insertSchedule(schedule: Schedule): Promise<Schedule> {
+  const client = await pool.connect();
+
+  try {
+    const result = await client.query(
+      `
+    INSERT INTO schedules (
+      connection_id,
+      playbook,
+      schedule_type, 
+      cron_expression,
+      additional_instructions,
+      min_interval,
+      max_interval,
+      enabled
+    ) VALUES (
+      $1, $2, $3, $4, $5, $6, $7, $8
+    ) RETURNING *
+  `,
+      [
+        schedule.connectionId,
+        schedule.playbook,
+        schedule.scheduleType,
+        schedule.cronExpression,
+        schedule.additionalInstructions,
+        schedule.minInterval,
+        schedule.maxInterval,
+        schedule.enabled
+      ]
+    );
+
+    const savedSchedule = result.rows[0];
+
+    return {
+      id: savedSchedule.id,
+      connectionId: savedSchedule.connection_id,
+      playbook: savedSchedule.playbook,
+      scheduleType: savedSchedule.schedule_type,
+      cronExpression: savedSchedule.cron_expression,
+      additionalInstructions: savedSchedule.additional_instructions,
+      minInterval: savedSchedule.min_interval,
+      maxInterval: savedSchedule.max_interval,
+      enabled: savedSchedule.enabled
+    };
+  } finally {
+    client.release();
+  }
+}
+
+export async function updateSchedule(schedule: Schedule): Promise<Schedule> {
+  const client = await pool.connect();
+
+  try {
+    const result = await client.query(
+      `
+    UPDATE schedules 
+    SET
+      connection_id = $1,
+      playbook = $2,
+      schedule_type = $3,
+      cron_expression = $4,
+      additional_instructions = $5,
+      min_interval = $6,
+      max_interval = $7,
+      enabled = $8
+    WHERE id = $9
+    RETURNING *
+    `,
+      [
+        schedule.connectionId,
+        schedule.playbook,
+        schedule.scheduleType,
+        schedule.cronExpression,
+        schedule.additionalInstructions,
+        schedule.minInterval,
+        schedule.maxInterval,
+        schedule.enabled,
+        schedule.id
+      ]
+    );
+
+    if (result.rows.length === 0) {
+      throw new Error(`Schedule with id ${schedule.id} not found`);
+    }
+
+    const savedSchedule = result.rows[0];
+
+    return {
+      id: savedSchedule.id,
+      connectionId: savedSchedule.connection_id,
+      playbook: savedSchedule.playbook,
+      scheduleType: savedSchedule.schedule_type,
+      cronExpression: savedSchedule.cron_expression,
+      additionalInstructions: savedSchedule.additional_instructions,
+      minInterval: savedSchedule.min_interval,
+      maxInterval: savedSchedule.max_interval,
+      enabled: savedSchedule.enabled
+    };
+  } finally {
+    client.release();
+  }
+}
+
+export async function getSchedules(): Promise<Schedule[]> {
+  const client = await pool.connect();
+  try {
+    const result = await client.query('SELECT * FROM schedules');
+    return result.rows.map((row) => ({
+      id: row.id,
+      connectionId: row.connection_id,
+      playbook: row.playbook,
+      scheduleType: row.schedule_type,
+      cronExpression: row.cron_expression,
+      additionalInstructions: row.additional_instructions,
+      minInterval: row.min_interval,
+      maxInterval: row.max_interval,
+      enabled: row.enabled
+    }));
+  } finally {
+    client.release();
+  }
+}
+
+export async function getSchedule(id: string): Promise<Schedule> {
+  const client = await pool.connect();
+  try {
+    const result = await client.query('SELECT * FROM schedules WHERE id = $1', [id]);
+
+    if (result.rows.length === 0) {
+      throw new Error(`Schedule with id ${id} not found`);
+    }
+
+    const row = result.rows[0];
+    return {
+      id: row.id,
+      connectionId: row.connection_id,
+      playbook: row.playbook,
+      scheduleType: row.schedule_type,
+      cronExpression: row.cron_expression,
+      additionalInstructions: row.additional_instructions,
+      minInterval: row.min_interval,
+      maxInterval: row.max_interval,
+      enabled: row.enabled
+    };
+  } finally {
+    client.release();
+  }
+}

From 33739f6cc1ac8279839cf1e3467dcaf16f2a4532 Mon Sep 17 00:00:00 2001
From: Tudor Golubenco <tudor@xata.io>
Date: Fri, 21 Feb 2025 10:59:38 +0100
Subject: [PATCH 05/12] Add a way to delete a schedule

---
 .../src/components/monitoring/actions.ts      |  6 ++-
 .../components/monitoring/schedule-form.tsx   | 42 ++++++++++++++++++-
 apps/dbagent/src/lib/db/monitoring.ts         |  9 ++++
 3 files changed, 55 insertions(+), 2 deletions(-)

diff --git a/apps/dbagent/src/components/monitoring/actions.ts b/apps/dbagent/src/components/monitoring/actions.ts
index ba9c2a07..6a9fc56d 100644
--- a/apps/dbagent/src/components/monitoring/actions.ts
+++ b/apps/dbagent/src/components/monitoring/actions.ts
@@ -2,7 +2,7 @@
 
 import { openai } from '@ai-sdk/openai';
 import { generateText } from 'ai';
-import { getSchedule, getSchedules, insertSchedule, updateSchedule } from '~/lib/db/monitoring';
+import { deleteSchedule, getSchedule, getSchedules, insertSchedule, updateSchedule } from '~/lib/db/monitoring';
 import { listPlaybooks } from '~/lib/tools/playbooks';
 
 export type Schedule = {
@@ -49,6 +49,10 @@ export async function actionGetSchedule(id: string): Promise<Schedule> {
   return getSchedule(id);
 }
 
+export async function actionDeleteSchedule(id: string): Promise<void> {
+  return deleteSchedule(id);
+}
+
 export async function actionListPlaybooks(): Promise<string[]> {
   return listPlaybooks();
 }
diff --git a/apps/dbagent/src/components/monitoring/schedule-form.tsx b/apps/dbagent/src/components/monitoring/schedule-form.tsx
index 369ea7a4..7c2de878 100644
--- a/apps/dbagent/src/components/monitoring/schedule-form.tsx
+++ b/apps/dbagent/src/components/monitoring/schedule-form.tsx
@@ -29,7 +29,13 @@ import { useRouter } from 'next/navigation';
 import { useEffect, useState } from 'react';
 import { useForm } from 'react-hook-form';
 import * as z from 'zod';
-import { actionCreateSchedule, actionGetSchedule, actionUpdateSchedule, Schedule } from './actions';
+import {
+  actionCreateSchedule,
+  actionDeleteSchedule,
+  actionGetSchedule,
+  actionUpdateSchedule,
+  Schedule
+} from './actions';
 import { CronExpressionModal } from './cron-expression-modal';
 
 const formSchema = z.object({
@@ -53,6 +59,7 @@ export function ScheduleForm({
 }) {
   const router = useRouter();
   const [showCronModal, setShowCronModal] = useState(false);
+  const [showDeleteConfirm, setShowDeleteConfirm] = useState(false);
   const form = useForm<z.infer<typeof formSchema>>({
     resolver: zodResolver(formSchema),
     defaultValues: {
@@ -106,6 +113,11 @@ export function ScheduleForm({
     router.push('/monitoring');
   };
 
+  const handleDelete = async () => {
+    await actionDeleteSchedule(scheduleId);
+    router.push('/monitoring');
+  };
+
   return (
     <div className="container mx-auto p-4">
       <Card>
@@ -253,6 +265,34 @@ export function ScheduleForm({
               <Button type="submit" className="mr-2">
                 {isEditMode ? 'Update Schedule' : 'Create Schedule'}
               </Button>
+              {isEditMode && (
+                <>
+                  {!showDeleteConfirm ? (
+                    <Button
+                      type="button"
+                      variant="destructive"
+                      className="mr-2"
+                      onClick={() => setShowDeleteConfirm(true)}
+                    >
+                      Delete
+                    </Button>
+                  ) : (
+                    <>
+                      <Button type="button" variant="destructive" className="mr-2" onClick={handleDelete}>
+                        Confirm Delete
+                      </Button>
+                      <Button
+                        type="button"
+                        variant="outline"
+                        className="mr-2"
+                        onClick={() => setShowDeleteConfirm(false)}
+                      >
+                        Cancel Delete
+                      </Button>
+                    </>
+                  )}
+                </>
+              )}
               <Link href="/monitoring">
                 <Button variant="outline">Cancel</Button>
               </Link>
diff --git a/apps/dbagent/src/lib/db/monitoring.ts b/apps/dbagent/src/lib/db/monitoring.ts
index 82860f00..fb6e01af 100644
--- a/apps/dbagent/src/lib/db/monitoring.ts
+++ b/apps/dbagent/src/lib/db/monitoring.ts
@@ -149,3 +149,12 @@ export async function getSchedule(id: string): Promise<Schedule> {
     client.release();
   }
 }
+
+export async function deleteSchedule(id: string): Promise<void> {
+  const client = await pool.connect();
+  try {
+    await client.query('DELETE FROM schedules WHERE id = $1', [id]);
+  } finally {
+    client.release();
+  }
+}

From 11d446fe37d7edc6776878a82a6e64368ded2540 Mon Sep 17 00:00:00 2001
From: Tudor Golubenco <tudor@xata.io>
Date: Fri, 21 Feb 2025 11:34:56 +0100
Subject: [PATCH 06/12] Tie a schedule to a connection

---
 .../(main)/monitoring/schedule/[id]/page.tsx  | 11 ++-
 .../components/monitoring/conn-selector.tsx   | 37 ----------
 .../components/monitoring/schedule-form.tsx   | 34 +++++++++-
 .../components/monitoring/schedules-table.tsx | 68 ++++++++++++-------
 4 files changed, 82 insertions(+), 68 deletions(-)
 delete mode 100644 apps/dbagent/src/components/monitoring/conn-selector.tsx

diff --git a/apps/dbagent/src/app/(main)/monitoring/schedule/[id]/page.tsx b/apps/dbagent/src/app/(main)/monitoring/schedule/[id]/page.tsx
index df03a818..2b4a1fbe 100644
--- a/apps/dbagent/src/app/(main)/monitoring/schedule/[id]/page.tsx
+++ b/apps/dbagent/src/app/(main)/monitoring/schedule/[id]/page.tsx
@@ -1,11 +1,18 @@
+import { actionListConnections } from '~/components/connections/actions';
 import { actionListPlaybooks } from '~/components/monitoring/actions';
 import { ScheduleForm } from '~/components/monitoring/schedule-form';
 
-export default async function Page({ params }: { params: { id: string } }) {
+export default async function Page({ params }: { params: { id: string; connection?: string } }) {
   const playbooks = await actionListPlaybooks();
+  const connections = await actionListConnections();
   return (
     <div className="container">
-      <ScheduleForm scheduleId={params.id} playbooks={playbooks} />
+      <ScheduleForm
+        scheduleId={params.id}
+        playbooks={playbooks}
+        connections={connections}
+        connection={params.connection}
+      />
     </div>
   );
 }
diff --git a/apps/dbagent/src/components/monitoring/conn-selector.tsx b/apps/dbagent/src/components/monitoring/conn-selector.tsx
deleted file mode 100644
index f971d4b6..00000000
--- a/apps/dbagent/src/components/monitoring/conn-selector.tsx
+++ /dev/null
@@ -1,37 +0,0 @@
-'use client';
-
-import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@internal/components';
-import { DbConnection } from '~/lib/db/connections';
-
-interface DatabaseSelectorProps {
-  connections: DbConnection[];
-  value: DbConnection | null;
-  onChange: (value: DbConnection) => void;
-}
-
-export function ConnectionSelector({ connections, value, onChange }: DatabaseSelectorProps) {
-  return (
-    <div className="flex items-center space-x-2 pr-2">
-      <Select
-        value={value?.name || ''}
-        onValueChange={(name) => {
-          const selectedConnection = connections.find((db) => db.name === name);
-          if (selectedConnection) {
-            onChange(selectedConnection);
-          }
-        }}
-      >
-        <SelectTrigger id="database-select" className="w-[180px]">
-          <SelectValue>{value?.name || ''}</SelectValue>
-        </SelectTrigger>
-        <SelectContent>
-          {connections.map((db) => (
-            <SelectItem key={db.id} value={db.name}>
-              {db.name}
-            </SelectItem>
-          ))}
-        </SelectContent>
-      </Select>
-    </div>
-  );
-}
diff --git a/apps/dbagent/src/components/monitoring/schedule-form.tsx b/apps/dbagent/src/components/monitoring/schedule-form.tsx
index 7c2de878..75c8d4e1 100644
--- a/apps/dbagent/src/components/monitoring/schedule-form.tsx
+++ b/apps/dbagent/src/components/monitoring/schedule-form.tsx
@@ -29,6 +29,7 @@ import { useRouter } from 'next/navigation';
 import { useEffect, useState } from 'react';
 import { useForm } from 'react-hook-form';
 import * as z from 'zod';
+import { DbConnection } from '~/lib/db/connections';
 import {
   actionCreateSchedule,
   actionDeleteSchedule,
@@ -40,6 +41,7 @@ import { CronExpressionModal } from './cron-expression-modal';
 
 const formSchema = z.object({
   playbook: z.string().min(1, { message: 'Please select a playbook' }),
+  connection: z.string().min(1, { message: 'Please select a connection' }),
   scheduleType: z.enum(['automatic', 'cron']),
   minInterval: z.string().optional(),
   maxInterval: z.string().optional(),
@@ -51,11 +53,12 @@ const formSchema = z.object({
 export function ScheduleForm({
   scheduleId,
   playbooks,
-  connectionId
+  connections
 }: {
   scheduleId: string;
   playbooks: string[];
-  connectionId: string;
+  connections: DbConnection[];
+  connection?: string;
 }) {
   const router = useRouter();
   const [showCronModal, setShowCronModal] = useState(false);
@@ -64,6 +67,7 @@ export function ScheduleForm({
     resolver: zodResolver(formSchema),
     defaultValues: {
       playbook: playbooks[0] || '',
+      connection: connections.find((c) => c.is_default)?.name || '',
       scheduleType: 'cron',
       minInterval: '5',
       maxInterval: '1440',
@@ -80,6 +84,7 @@ export function ScheduleForm({
         const schedule = await actionGetSchedule(scheduleId);
         form.reset({
           playbook: schedule.playbook,
+          connection: connections.find((c) => c.id === Number(schedule.connectionId))?.name || '',
           scheduleType: schedule.scheduleType as 'automatic' | 'cron',
           cronExpression: schedule.cronExpression,
           minInterval: schedule.minInterval?.toString(),
@@ -95,7 +100,7 @@ export function ScheduleForm({
   const onSubmit = async (data: z.infer<typeof formSchema>) => {
     const schedule: Schedule = {
       id: scheduleId,
-      connectionId: connectionId,
+      connectionId: connections.find((c) => c.name === data.connection)?.id.toString() || '',
       playbook: data.playbook,
       scheduleType: data.scheduleType,
       cronExpression: data.cronExpression,
@@ -127,6 +132,29 @@ export function ScheduleForm({
         <CardContent>
           <Form {...form}>
             <form onSubmit={form.handleSubmit(onSubmit)} className="space-y-6">
+              <FormField
+                control={form.control}
+                name="connection"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>Database</FormLabel>
+                    <Select onValueChange={field.onChange} defaultValue={field.value}>
+                      <FormControl>
+                        <SelectTrigger>
+                          <SelectValue placeholder="Select a database" />
+                        </SelectTrigger>
+                      </FormControl>
+                      <SelectContent>
+                        {connections.map((connection) => (
+                          <SelectItem key={connection.name} value={connection.name}>
+                            {connection.name}
+                          </SelectItem>
+                        ))}
+                      </SelectContent>
+                    </Select>
+                  </FormItem>
+                )}
+              />
               <FormField
                 control={form.control}
                 name="playbook"
diff --git a/apps/dbagent/src/components/monitoring/schedules-table.tsx b/apps/dbagent/src/components/monitoring/schedules-table.tsx
index 6b3ff48c..99004428 100644
--- a/apps/dbagent/src/components/monitoring/schedules-table.tsx
+++ b/apps/dbagent/src/components/monitoring/schedules-table.tsx
@@ -6,12 +6,9 @@ import Link from 'next/link';
 import { useEffect, useState } from 'react';
 import { DbConnection } from '~/lib/db/connections';
 import { actionGetSchedules, Schedule } from './actions';
-import { ConnectionSelector } from './conn-selector';
 
 export function MonitoringScheduleTable({ connections }: { connections: DbConnection[] }) {
   const [schedules, setSchedules] = useState<Schedule[]>([]);
-  const defaultConnection = connections.find((c) => c.is_default);
-  const [selectedDatabase, setSelectedDatabase] = useState<DbConnection | null>(defaultConnection || null);
   useEffect(() => {
     const loadSchedules = async () => {
       const schedules = await actionGetSchedules();
@@ -25,7 +22,6 @@ export function MonitoringScheduleTable({ connections }: { connections: DbConnec
       <div className="mb-4 flex items-center justify-between">
         <h1 className="text-2xl font-bold">Monitoring Schedules</h1>
         <div className="mb-6 flex items-center justify-between">
-          <ConnectionSelector connections={connections} value={selectedDatabase} onChange={setSelectedDatabase} />
           <Link href="/monitoring/schedule/add">
             <Button>
               <PlusIcon className="mr-2 h-4 w-4" /> Add New Schedule
@@ -36,8 +32,9 @@ export function MonitoringScheduleTable({ connections }: { connections: DbConnec
       <Table>
         <TableHeader>
           <TableRow>
+            <TableHead className="w-[150px]">Playbook</TableHead>
+            <TableHead className="w-[150px]">Database</TableHead>
             <TableHead className="w-[150px]">Schedule</TableHead>
-            <TableHead>Playbook</TableHead>
             <TableHead className="w-[150px]">Last Run</TableHead>
             <TableHead className="w-[100px]">Failures</TableHead>
             <TableHead className="w-[100px]">Status</TableHead>
@@ -45,28 +42,47 @@ export function MonitoringScheduleTable({ connections }: { connections: DbConnec
           </TableRow>
         </TableHeader>
         <TableBody>
-          {schedules.map((schedule) => (
-            <TableRow key={schedule.id}>
-              <TableCell className="font-medium">
-                {schedule.scheduleType === 'cron' ? schedule.cronExpression : 'Automatic'}
-              </TableCell>
-              <TableCell>{schedule.playbook}</TableCell>
-              <TableCell>{schedule.lastRun}</TableCell>
-              <TableCell>{schedule.failures}</TableCell>
-              <TableCell>
-                <Switch checked={schedule.enabled} />
-              </TableCell>
-              <TableCell>
-                <div className="flex space-x-2">
-                  <Link href={`/monitoring/schedule/${schedule.id}`}>
-                    <Button variant="outline" size="icon" className="cursor-pointer">
-                      <PencilIcon className="h-4 w-4" />
-                    </Button>
+          {schedules.length === 0 ? (
+            <>
+              <TableRow>
+                <TableCell colSpan={6} className="text-muted-foreground py-8 text-center">
+                  Monitoring schedules make the agent execute a playbook periodically in order to proactively identify
+                  issues.
+                </TableCell>
+              </TableRow>
+              <TableRow>
+                <TableCell colSpan={6} className="text-center">
+                  <Link href="/monitoring/schedule/add">
+                    <Button>Add Schedule</Button>
                   </Link>
-                </div>
-              </TableCell>
-            </TableRow>
-          ))}
+                </TableCell>
+              </TableRow>
+            </>
+          ) : (
+            schedules.map((schedule) => (
+              <TableRow key={schedule.id}>
+                <TableCell>{connections.find((c) => c.id === Number(schedule.connectionId))?.name}</TableCell>
+                <TableCell>{schedule.playbook}</TableCell>
+                <TableCell className="font-medium">
+                  {schedule.scheduleType === 'cron' ? schedule.cronExpression : 'Automatic'}
+                </TableCell>
+                <TableCell>{schedule.lastRun}</TableCell>
+                <TableCell>{schedule.failures}</TableCell>
+                <TableCell>
+                  <Switch checked={schedule.enabled} />
+                </TableCell>
+                <TableCell>
+                  <div className="flex space-x-2">
+                    <Link href={`/monitoring/schedule/${schedule.id}`}>
+                      <Button variant="outline" size="icon" className="cursor-pointer">
+                        <PencilIcon className="h-4 w-4" />
+                      </Button>
+                    </Link>
+                  </div>
+                </TableCell>
+              </TableRow>
+            ))
+          )}
         </TableBody>
       </Table>
     </div>

From ed320cf2e33f42191cea5257ab5584f41a693bbc Mon Sep 17 00:00:00 2001
From: Tudor Golubenco <tudor@xata.io>
Date: Fri, 21 Feb 2025 14:04:34 +0100
Subject: [PATCH 07/12] Toggle enabled state from the main table

---
 apps/dbagent/src/components/monitoring/actions.ts  | 13 ++++++++++++-
 .../src/components/monitoring/schedules-table.tsx  | 14 ++++++++++++--
 apps/dbagent/src/lib/db/monitoring.ts              |  9 +++++++++
 3 files changed, 33 insertions(+), 3 deletions(-)

diff --git a/apps/dbagent/src/components/monitoring/actions.ts b/apps/dbagent/src/components/monitoring/actions.ts
index 6a9fc56d..8dc43600 100644
--- a/apps/dbagent/src/components/monitoring/actions.ts
+++ b/apps/dbagent/src/components/monitoring/actions.ts
@@ -2,7 +2,14 @@
 
 import { openai } from '@ai-sdk/openai';
 import { generateText } from 'ai';
-import { deleteSchedule, getSchedule, getSchedules, insertSchedule, updateSchedule } from '~/lib/db/monitoring';
+import {
+  deleteSchedule,
+  getSchedule,
+  getSchedules,
+  insertSchedule,
+  updateSchedule,
+  updateScheduleEnabled
+} from '~/lib/db/monitoring';
 import { listPlaybooks } from '~/lib/tools/playbooks';
 
 export type Schedule = {
@@ -56,3 +63,7 @@ export async function actionDeleteSchedule(id: string): Promise<void> {
 export async function actionListPlaybooks(): Promise<string[]> {
   return listPlaybooks();
 }
+
+export async function actionUpdateScheduleEnabled(scheduleId: string, enabled: boolean) {
+  return updateScheduleEnabled(scheduleId, enabled);
+}
diff --git a/apps/dbagent/src/components/monitoring/schedules-table.tsx b/apps/dbagent/src/components/monitoring/schedules-table.tsx
index 99004428..c7e2012f 100644
--- a/apps/dbagent/src/components/monitoring/schedules-table.tsx
+++ b/apps/dbagent/src/components/monitoring/schedules-table.tsx
@@ -5,7 +5,7 @@ import { PencilIcon, PlusIcon } from 'lucide-react';
 import Link from 'next/link';
 import { useEffect, useState } from 'react';
 import { DbConnection } from '~/lib/db/connections';
-import { actionGetSchedules, Schedule } from './actions';
+import { actionGetSchedules, actionUpdateScheduleEnabled, Schedule } from './actions';
 
 export function MonitoringScheduleTable({ connections }: { connections: DbConnection[] }) {
   const [schedules, setSchedules] = useState<Schedule[]>([]);
@@ -17,6 +17,13 @@ export function MonitoringScheduleTable({ connections }: { connections: DbConnec
     void loadSchedules();
   }, []);
 
+  const handleToggleEnabled = async (scheduleId: string, enabled: boolean) => {
+    await actionUpdateScheduleEnabled(scheduleId, enabled);
+    // Refresh the schedules list
+    const updatedSchedules = await actionGetSchedules();
+    setSchedules(updatedSchedules);
+  };
+
   return (
     <div>
       <div className="mb-4 flex items-center justify-between">
@@ -69,7 +76,10 @@ export function MonitoringScheduleTable({ connections }: { connections: DbConnec
                 <TableCell>{schedule.lastRun}</TableCell>
                 <TableCell>{schedule.failures}</TableCell>
                 <TableCell>
-                  <Switch checked={schedule.enabled} />
+                  <Switch
+                    checked={schedule.enabled}
+                    onCheckedChange={(checked) => handleToggleEnabled(schedule.id, checked)}
+                  />
                 </TableCell>
                 <TableCell>
                   <div className="flex space-x-2">
diff --git a/apps/dbagent/src/lib/db/monitoring.ts b/apps/dbagent/src/lib/db/monitoring.ts
index fb6e01af..1fb9b916 100644
--- a/apps/dbagent/src/lib/db/monitoring.ts
+++ b/apps/dbagent/src/lib/db/monitoring.ts
@@ -158,3 +158,12 @@ export async function deleteSchedule(id: string): Promise<void> {
     client.release();
   }
 }
+
+export async function updateScheduleEnabled(id: string, enabled: boolean): Promise<void> {
+  const client = await pool.connect();
+  try {
+    await client.query('UPDATE schedules SET enabled = $1 WHERE id = $2', [enabled, id]);
+  } finally {
+    client.release();
+  }
+}

From e078a8ef367772eae720301f7deb1d3512ef231c Mon Sep 17 00:00:00 2001
From: Tudor Golubenco <tudor@xata.io>
Date: Fri, 21 Feb 2025 14:06:11 +0100
Subject: [PATCH 08/12] Added skeleton

---
 .../components/monitoring/schedules-table.tsx | 44 +++++++++++++++++--
 1 file changed, 41 insertions(+), 3 deletions(-)

diff --git a/apps/dbagent/src/components/monitoring/schedules-table.tsx b/apps/dbagent/src/components/monitoring/schedules-table.tsx
index c7e2012f..af227a01 100644
--- a/apps/dbagent/src/components/monitoring/schedules-table.tsx
+++ b/apps/dbagent/src/components/monitoring/schedules-table.tsx
@@ -9,10 +9,16 @@ import { actionGetSchedules, actionUpdateScheduleEnabled, Schedule } from './act
 
 export function MonitoringScheduleTable({ connections }: { connections: DbConnection[] }) {
   const [schedules, setSchedules] = useState<Schedule[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+
   useEffect(() => {
     const loadSchedules = async () => {
-      const schedules = await actionGetSchedules();
-      setSchedules(schedules);
+      try {
+        const schedules = await actionGetSchedules();
+        setSchedules(schedules);
+      } finally {
+        setIsLoading(false);
+      }
     };
     void loadSchedules();
   }, []);
@@ -24,6 +30,32 @@ export function MonitoringScheduleTable({ connections }: { connections: DbConnec
     setSchedules(updatedSchedules);
   };
 
+  const SkeletonRow = () => (
+    <TableRow>
+      <TableCell>
+        <div className="bg-muted h-4 w-24 animate-pulse rounded" />
+      </TableCell>
+      <TableCell>
+        <div className="bg-muted h-4 w-32 animate-pulse rounded" />
+      </TableCell>
+      <TableCell>
+        <div className="bg-muted h-4 w-28 animate-pulse rounded" />
+      </TableCell>
+      <TableCell>
+        <div className="bg-muted h-4 w-24 animate-pulse rounded" />
+      </TableCell>
+      <TableCell>
+        <div className="bg-muted h-4 w-16 animate-pulse rounded" />
+      </TableCell>
+      <TableCell>
+        <div className="bg-muted h-6 w-10 animate-pulse rounded" />
+      </TableCell>
+      <TableCell>
+        <div className="bg-muted h-8 w-8 animate-pulse rounded" />
+      </TableCell>
+    </TableRow>
+  );
+
   return (
     <div>
       <div className="mb-4 flex items-center justify-between">
@@ -49,7 +81,13 @@ export function MonitoringScheduleTable({ connections }: { connections: DbConnec
           </TableRow>
         </TableHeader>
         <TableBody>
-          {schedules.length === 0 ? (
+          {isLoading ? (
+            <>
+              <SkeletonRow />
+              <SkeletonRow />
+              <SkeletonRow />
+            </>
+          ) : schedules.length === 0 ? (
             <>
               <TableRow>
                 <TableCell colSpan={6} className="text-muted-foreground py-8 text-center">

From 4faca9b5516ef0375b96b0752fd1deb41520a39f Mon Sep 17 00:00:00 2001
From: Tudor Golubenco <tudor@xata.io>
Date: Sat, 22 Feb 2025 20:36:31 +0100
Subject: [PATCH 09/12] Run the schedule jobs

---
 .../migrations/0006_schedules_last_run.sql    |   6 +
 apps/dbagent/package.json                     |   4 +-
 apps/dbagent/scripts/scheduler.ts             |  24 ++
 .../src/app/api/priv/schedule-tick/route.ts   |   7 +
 apps/dbagent/src/app/layout.tsx               |   1 +
 .../src/components/monitoring/actions.ts      |  49 +--
 .../src/components/monitoring/schedule.ts     |  35 +++
 .../components/monitoring/schedules-table.tsx |  74 ++++-
 apps/dbagent/src/lib/db/monitoring.ts         | 169 ----------
 apps/dbagent/src/lib/db/schedules.ts          | 297 ++++++++++++++++++
 apps/dbagent/src/lib/services/scheduler.ts    | 110 +++++++
 pnpm-lock.yaml                                |  17 +
 12 files changed, 591 insertions(+), 202 deletions(-)
 create mode 100644 apps/dbagent/migrations/0006_schedules_last_run.sql
 create mode 100644 apps/dbagent/scripts/scheduler.ts
 create mode 100644 apps/dbagent/src/app/api/priv/schedule-tick/route.ts
 create mode 100644 apps/dbagent/src/components/monitoring/schedule.ts
 delete mode 100644 apps/dbagent/src/lib/db/monitoring.ts
 create mode 100644 apps/dbagent/src/lib/db/schedules.ts
 create mode 100644 apps/dbagent/src/lib/services/scheduler.ts

diff --git a/apps/dbagent/migrations/0006_schedules_last_run.sql b/apps/dbagent/migrations/0006_schedules_last_run.sql
new file mode 100644
index 00000000..ce03f4d2
--- /dev/null
+++ b/apps/dbagent/migrations/0006_schedules_last_run.sql
@@ -0,0 +1,6 @@
+CREATE TYPE schedule_status AS ENUM ('disabled', 'scheduled', 'running');
+
+ALTER TABLE schedules ADD COLUMN last_run TIMESTAMP;
+ALTER TABLE schedules ADD COLUMN next_run TIMESTAMP;
+ALTER TABLE schedules ADD COLUMN status schedule_status DEFAULT 'disabled';
+ALTER TABLE schedules ADD COLUMN failures INTEGER DEFAULT 0;
diff --git a/apps/dbagent/package.json b/apps/dbagent/package.json
index fb7c9fe6..cc0bcdf2 100644
--- a/apps/dbagent/package.json
+++ b/apps/dbagent/package.json
@@ -11,7 +11,8 @@
     "tsc": "tsc --noEmit",
     "test": "vitest --passWithNoTests",
     "dbmigrate": "tsx scripts/dbmigrate.ts",
-    "load-test": "tsx scripts/load-testing/musicbrainz-loader.ts"
+    "load-test": "tsx scripts/load-testing/musicbrainz-loader.ts",
+    "dev-scheduler": "tsx scripts/scheduler.ts"
   },
   "dependencies": {
     "@ai-sdk/anthropic": "^1.1.8",
@@ -29,6 +30,7 @@
     "bytes": "^3.1.2",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
+    "cron-parser": "^5.0.3",
     "framer-motion": "^12.4.3",
     "kysely": "^0.27.5",
     "lucide-react": "^0.475.0",
diff --git a/apps/dbagent/scripts/scheduler.ts b/apps/dbagent/scripts/scheduler.ts
new file mode 100644
index 00000000..f8cd68ac
--- /dev/null
+++ b/apps/dbagent/scripts/scheduler.ts
@@ -0,0 +1,24 @@
+async function tick() {
+  try {
+    const response = await fetch('http://localhost:4001/api/priv/schedule-tick', {
+      method: 'POST'
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    console.log('Scheduler tick completed successfully');
+  } catch (error) {
+    console.error('Error in scheduler tick:', error);
+  }
+}
+
+// Run tick every 10 seconds
+const INTERVAL_MS = 10000;
+console.log(`Starting scheduler with ${INTERVAL_MS}ms interval`);
+
+setInterval(tick, INTERVAL_MS);
+
+// Run immediately on start
+void tick();
diff --git a/apps/dbagent/src/app/api/priv/schedule-tick/route.ts b/apps/dbagent/src/app/api/priv/schedule-tick/route.ts
new file mode 100644
index 00000000..ce06bfdb
--- /dev/null
+++ b/apps/dbagent/src/app/api/priv/schedule-tick/route.ts
@@ -0,0 +1,7 @@
+import { SchedulerService } from '~/lib/services/scheduler';
+
+export async function POST() {
+  const scheduler = new SchedulerService();
+  await scheduler.checkAndRunJobs();
+  return new Response('OK', { status: 200 });
+}
diff --git a/apps/dbagent/src/app/layout.tsx b/apps/dbagent/src/app/layout.tsx
index 1b64a278..5424d7a3 100644
--- a/apps/dbagent/src/app/layout.tsx
+++ b/apps/dbagent/src/app/layout.tsx
@@ -2,6 +2,7 @@ import '@internal/theme';
 import { Metadata } from 'next';
 import { Inter, JetBrains_Mono } from 'next/font/google';
 import { Providers } from '~/components/providers';
+//import '~/lib/services/local-scheduler'; // This starts the local scheduler
 
 const inter = Inter({
   subsets: ['latin'],
diff --git a/apps/dbagent/src/components/monitoring/actions.ts b/apps/dbagent/src/components/monitoring/actions.ts
index 8dc43600..309927db 100644
--- a/apps/dbagent/src/components/monitoring/actions.ts
+++ b/apps/dbagent/src/components/monitoring/actions.ts
@@ -7,25 +7,13 @@ import {
   getSchedule,
   getSchedules,
   insertSchedule,
+  Schedule,
+  scheduleGetNextRun,
   updateSchedule,
-  updateScheduleEnabled
-} from '~/lib/db/monitoring';
+  updateScheduleRunData
+} from '~/lib/db/schedules';
 import { listPlaybooks } from '~/lib/tools/playbooks';
 
-export type Schedule = {
-  id: string;
-  connectionId: string;
-  playbook: string;
-  scheduleType: string;
-  cronExpression?: string;
-  additionalInstructions?: string;
-  minInterval?: number;
-  maxInterval?: number;
-  lastRun?: string;
-  failures?: number;
-  enabled: boolean;
-};
-
 export async function generateCronExpression(description: string): Promise<string> {
   const prompt = `Generate a cron expression for the following schedule description: "${description}". 
   Return strictly the cron expression, no quotes or anything else.`;
@@ -39,6 +27,10 @@ export async function generateCronExpression(description: string): Promise<strin
 }
 
 export async function actionCreateSchedule(schedule: Schedule): Promise<Schedule> {
+  if (schedule.enabled) {
+    schedule.status = 'scheduled';
+    schedule.nextRun = scheduleGetNextRun(schedule, new Date()).toISOString();
+  }
   return insertSchedule(schedule);
 }
 
@@ -48,7 +40,15 @@ export async function actionUpdateSchedule(schedule: Schedule): Promise<Schedule
 
 export async function actionGetSchedules(): Promise<Schedule[]> {
   const schedules = await getSchedules();
-  console.log(schedules);
+  // Ensure last_run is serialized as string
+  schedules.forEach((schedule) => {
+    if (schedule.lastRun) {
+      schedule.lastRun = schedule.lastRun.toString();
+    }
+    if (schedule.nextRun) {
+      schedule.nextRun = schedule.nextRun.toString();
+    }
+  });
   return schedules;
 }
 
@@ -65,5 +65,18 @@ export async function actionListPlaybooks(): Promise<string[]> {
 }
 
 export async function actionUpdateScheduleEnabled(scheduleId: string, enabled: boolean) {
-  return updateScheduleEnabled(scheduleId, enabled);
+  if (enabled) {
+    const schedule = await getSchedule(scheduleId);
+    schedule.enabled = true;
+    schedule.status = 'scheduled';
+    schedule.nextRun = scheduleGetNextRun(schedule, new Date()).toUTCString();
+    console.log('nextRun', schedule.nextRun);
+    await updateScheduleRunData(schedule);
+  } else {
+    const schedule = await getSchedule(scheduleId);
+    schedule.enabled = false;
+    schedule.status = 'disabled';
+    schedule.nextRun = undefined;
+    await updateScheduleRunData(schedule);
+  }
 }
diff --git a/apps/dbagent/src/components/monitoring/schedule.ts b/apps/dbagent/src/components/monitoring/schedule.ts
new file mode 100644
index 00000000..91c7a8be
--- /dev/null
+++ b/apps/dbagent/src/components/monitoring/schedule.ts
@@ -0,0 +1,35 @@
+import { CronExpressionParser } from 'cron-parser';
+
+export type Schedule = {
+  id: string;
+  connectionId: string;
+  playbook: string;
+  scheduleType: string;
+  cronExpression?: string;
+  additionalInstructions?: string;
+  minInterval?: number;
+  maxInterval?: number;
+  lastRun?: string;
+  nextRun?: string;
+  failures?: number;
+  status: 'disabled' | 'scheduled' | 'running';
+  enabled: boolean;
+};
+
+export function shouldRunSchedule(schedule: Schedule, now: Date): boolean {
+  if (schedule.enabled === false || schedule.nextRun === undefined) return false;
+  return now >= new Date(schedule.nextRun);
+}
+
+export function scheduleGetNextRun(schedule: Schedule, now: Date): Date {
+  if (schedule.scheduleType === 'cron' && schedule.cronExpression) {
+    const interval = CronExpressionParser.parse(schedule.cronExpression);
+    return interval.next().toDate();
+  }
+  if (schedule.scheduleType === 'automatic' && schedule.minInterval) {
+    // TODO ask the model to get the interval
+    const nextRun = new Date(now.getTime() + schedule.minInterval * 1000);
+    return nextRun;
+  }
+  return now;
+}
diff --git a/apps/dbagent/src/components/monitoring/schedules-table.tsx b/apps/dbagent/src/components/monitoring/schedules-table.tsx
index af227a01..84a9afd0 100644
--- a/apps/dbagent/src/components/monitoring/schedules-table.tsx
+++ b/apps/dbagent/src/components/monitoring/schedules-table.tsx
@@ -1,25 +1,45 @@
 'use client';
 
 import { Button, Switch, Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@internal/components';
-import { PencilIcon, PlusIcon } from 'lucide-react';
+import { PencilIcon, PlusIcon, RefreshCwIcon } from 'lucide-react';
 import Link from 'next/link';
 import { useEffect, useState } from 'react';
 import { DbConnection } from '~/lib/db/connections';
-import { actionGetSchedules, actionUpdateScheduleEnabled, Schedule } from './actions';
+import { Schedule } from '~/lib/db/schedules';
+import { actionGetSchedules, actionUpdateScheduleEnabled } from './actions';
+
+function displayRelativeTime(date1: Date, date2: Date): string {
+  const diff = date2.getTime() - date1.getTime();
+  const diffSeconds = Math.floor(diff / 1000);
+  if (diffSeconds < 60) {
+    return `${diffSeconds}s`;
+  }
+  const diffMinutes = Math.floor(diff / (1000 * 60));
+  if (diffMinutes < 60) {
+    return `${diffMinutes}m`;
+  }
+  if (diffMinutes < 1440) {
+    return `${Math.floor(diffMinutes / 60)}h`;
+  }
+  return `${Math.floor(diffMinutes / 1440)}d`;
+}
 
 export function MonitoringScheduleTable({ connections }: { connections: DbConnection[] }) {
   const [schedules, setSchedules] = useState<Schedule[]>([]);
   const [isLoading, setIsLoading] = useState(true);
 
+  const loadSchedules = async () => {
+    setIsLoading(true);
+    try {
+      const schedules = await actionGetSchedules();
+      // Sort schedules by ID to maintain stable order
+      setSchedules(schedules.sort((a, b) => String(a.id || '').localeCompare(String(b.id || ''))));
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
   useEffect(() => {
-    const loadSchedules = async () => {
-      try {
-        const schedules = await actionGetSchedules();
-        setSchedules(schedules);
-      } finally {
-        setIsLoading(false);
-      }
-    };
     void loadSchedules();
   }, []);
 
@@ -27,7 +47,8 @@ export function MonitoringScheduleTable({ connections }: { connections: DbConnec
     await actionUpdateScheduleEnabled(scheduleId, enabled);
     // Refresh the schedules list
     const updatedSchedules = await actionGetSchedules();
-    setSchedules(updatedSchedules);
+    // Sort schedules by ID to maintain stable order
+    setSchedules(updatedSchedules.sort((a, b) => String(a.id || '').localeCompare(String(b.id || ''))));
   };
 
   const SkeletonRow = () => (
@@ -60,7 +81,10 @@ export function MonitoringScheduleTable({ connections }: { connections: DbConnec
     <div>
       <div className="mb-4 flex items-center justify-between">
         <h1 className="text-2xl font-bold">Monitoring Schedules</h1>
-        <div className="mb-6 flex items-center justify-between">
+        <div className="mb-6 flex items-center gap-2">
+          <Button variant="outline" onClick={() => loadSchedules()}>
+            <RefreshCwIcon className="mr-2 h-4 w-4" />
+          </Button>
           <Link href="/monitoring/schedule/add">
             <Button>
               <PlusIcon className="mr-2 h-4 w-4" /> Add New Schedule
@@ -74,9 +98,11 @@ export function MonitoringScheduleTable({ connections }: { connections: DbConnec
             <TableHead className="w-[150px]">Playbook</TableHead>
             <TableHead className="w-[150px]">Database</TableHead>
             <TableHead className="w-[150px]">Schedule</TableHead>
+            <TableHead className="w-[150px]">Status</TableHead>
             <TableHead className="w-[150px]">Last Run</TableHead>
+            <TableHead className="w-[150px]">Next Run</TableHead>
             <TableHead className="w-[100px]">Failures</TableHead>
-            <TableHead className="w-[100px]">Status</TableHead>
+            <TableHead className="w-[100px]">Enabled</TableHead>
             <TableHead className="w-[100px]">Actions</TableHead>
           </TableRow>
         </TableHeader>
@@ -111,7 +137,27 @@ export function MonitoringScheduleTable({ connections }: { connections: DbConnec
                 <TableCell className="font-medium">
                   {schedule.scheduleType === 'cron' ? schedule.cronExpression : 'Automatic'}
                 </TableCell>
-                <TableCell>{schedule.lastRun}</TableCell>
+                <TableCell>{schedule.status}</TableCell>
+                <TableCell>
+                  {schedule.lastRun ? (
+                    <span title={schedule.lastRun}>
+                      {displayRelativeTime(new Date(Date.parse(schedule.lastRun)), new Date())} ago
+                    </span>
+                  ) : (
+                    '-'
+                  )}
+                </TableCell>
+                <TableCell>
+                  {schedule.nextRun ? (
+                    <span title={schedule.nextRun}>
+                      {new Date(schedule.nextRun) <= new Date()
+                        ? 'now'
+                        : `in ${displayRelativeTime(new Date(), new Date(schedule.nextRun))}`}
+                    </span>
+                  ) : (
+                    '-'
+                  )}
+                </TableCell>
                 <TableCell>{schedule.failures}</TableCell>
                 <TableCell>
                   <Switch
diff --git a/apps/dbagent/src/lib/db/monitoring.ts b/apps/dbagent/src/lib/db/monitoring.ts
deleted file mode 100644
index 1fb9b916..00000000
--- a/apps/dbagent/src/lib/db/monitoring.ts
+++ /dev/null
@@ -1,169 +0,0 @@
-import { Schedule } from '~/components/monitoring/actions';
-import { pool } from './db';
-
-export async function insertSchedule(schedule: Schedule): Promise<Schedule> {
-  const client = await pool.connect();
-
-  try {
-    const result = await client.query(
-      `
-    INSERT INTO schedules (
-      connection_id,
-      playbook,
-      schedule_type, 
-      cron_expression,
-      additional_instructions,
-      min_interval,
-      max_interval,
-      enabled
-    ) VALUES (
-      $1, $2, $3, $4, $5, $6, $7, $8
-    ) RETURNING *
-  `,
-      [
-        schedule.connectionId,
-        schedule.playbook,
-        schedule.scheduleType,
-        schedule.cronExpression,
-        schedule.additionalInstructions,
-        schedule.minInterval,
-        schedule.maxInterval,
-        schedule.enabled
-      ]
-    );
-
-    const savedSchedule = result.rows[0];
-
-    return {
-      id: savedSchedule.id,
-      connectionId: savedSchedule.connection_id,
-      playbook: savedSchedule.playbook,
-      scheduleType: savedSchedule.schedule_type,
-      cronExpression: savedSchedule.cron_expression,
-      additionalInstructions: savedSchedule.additional_instructions,
-      minInterval: savedSchedule.min_interval,
-      maxInterval: savedSchedule.max_interval,
-      enabled: savedSchedule.enabled
-    };
-  } finally {
-    client.release();
-  }
-}
-
-export async function updateSchedule(schedule: Schedule): Promise<Schedule> {
-  const client = await pool.connect();
-
-  try {
-    const result = await client.query(
-      `
-    UPDATE schedules 
-    SET
-      connection_id = $1,
-      playbook = $2,
-      schedule_type = $3,
-      cron_expression = $4,
-      additional_instructions = $5,
-      min_interval = $6,
-      max_interval = $7,
-      enabled = $8
-    WHERE id = $9
-    RETURNING *
-    `,
-      [
-        schedule.connectionId,
-        schedule.playbook,
-        schedule.scheduleType,
-        schedule.cronExpression,
-        schedule.additionalInstructions,
-        schedule.minInterval,
-        schedule.maxInterval,
-        schedule.enabled,
-        schedule.id
-      ]
-    );
-
-    if (result.rows.length === 0) {
-      throw new Error(`Schedule with id ${schedule.id} not found`);
-    }
-
-    const savedSchedule = result.rows[0];
-
-    return {
-      id: savedSchedule.id,
-      connectionId: savedSchedule.connection_id,
-      playbook: savedSchedule.playbook,
-      scheduleType: savedSchedule.schedule_type,
-      cronExpression: savedSchedule.cron_expression,
-      additionalInstructions: savedSchedule.additional_instructions,
-      minInterval: savedSchedule.min_interval,
-      maxInterval: savedSchedule.max_interval,
-      enabled: savedSchedule.enabled
-    };
-  } finally {
-    client.release();
-  }
-}
-
-export async function getSchedules(): Promise<Schedule[]> {
-  const client = await pool.connect();
-  try {
-    const result = await client.query('SELECT * FROM schedules');
-    return result.rows.map((row) => ({
-      id: row.id,
-      connectionId: row.connection_id,
-      playbook: row.playbook,
-      scheduleType: row.schedule_type,
-      cronExpression: row.cron_expression,
-      additionalInstructions: row.additional_instructions,
-      minInterval: row.min_interval,
-      maxInterval: row.max_interval,
-      enabled: row.enabled
-    }));
-  } finally {
-    client.release();
-  }
-}
-
-export async function getSchedule(id: string): Promise<Schedule> {
-  const client = await pool.connect();
-  try {
-    const result = await client.query('SELECT * FROM schedules WHERE id = $1', [id]);
-
-    if (result.rows.length === 0) {
-      throw new Error(`Schedule with id ${id} not found`);
-    }
-
-    const row = result.rows[0];
-    return {
-      id: row.id,
-      connectionId: row.connection_id,
-      playbook: row.playbook,
-      scheduleType: row.schedule_type,
-      cronExpression: row.cron_expression,
-      additionalInstructions: row.additional_instructions,
-      minInterval: row.min_interval,
-      maxInterval: row.max_interval,
-      enabled: row.enabled
-    };
-  } finally {
-    client.release();
-  }
-}
-
-export async function deleteSchedule(id: string): Promise<void> {
-  const client = await pool.connect();
-  try {
-    await client.query('DELETE FROM schedules WHERE id = $1', [id]);
-  } finally {
-    client.release();
-  }
-}
-
-export async function updateScheduleEnabled(id: string, enabled: boolean): Promise<void> {
-  const client = await pool.connect();
-  try {
-    await client.query('UPDATE schedules SET enabled = $1 WHERE id = $2', [enabled, id]);
-  } finally {
-    client.release();
-  }
-}
diff --git a/apps/dbagent/src/lib/db/schedules.ts b/apps/dbagent/src/lib/db/schedules.ts
new file mode 100644
index 00000000..e08b2519
--- /dev/null
+++ b/apps/dbagent/src/lib/db/schedules.ts
@@ -0,0 +1,297 @@
+import { pool } from './db';
+
+import { CronExpressionParser } from 'cron-parser';
+
+export type Schedule = {
+  id: string;
+  connectionId: string;
+  playbook: string;
+  scheduleType: string;
+  cronExpression?: string;
+  additionalInstructions?: string;
+  minInterval?: number;
+  maxInterval?: number;
+  lastRun?: string;
+  nextRun?: string;
+  failures?: number;
+  status: 'disabled' | 'scheduled' | 'running';
+  enabled: boolean;
+};
+
+export function shouldRunSchedule(schedule: Schedule, now: Date): boolean {
+  console.log('shouldRunSchedule', schedule, now);
+  if (schedule.enabled === false || schedule.nextRun === undefined) return false;
+  return now >= new Date(schedule.nextRun);
+}
+
+export function scheduleGetNextRun(schedule: Schedule, now: Date): Date {
+  if (schedule.scheduleType === 'cron' && schedule.cronExpression) {
+    const interval = CronExpressionParser.parse(schedule.cronExpression);
+    return interval.next().toDate();
+  }
+  if (schedule.scheduleType === 'automatic' && schedule.minInterval) {
+    // TODO ask the model to get the interval, for now use the minInterval
+    const nextRun = new Date(now.getTime() + schedule.minInterval * 1000);
+    return nextRun;
+  }
+  return now;
+}
+
+export async function insertSchedule(schedule: Schedule): Promise<Schedule> {
+  const client = await pool.connect();
+
+  try {
+    const result = await client.query(
+      `
+    INSERT INTO schedules (
+      connection_id,
+      playbook,
+      schedule_type, 
+      cron_expression,
+      additional_instructions,
+      min_interval,
+      max_interval,
+      enabled,
+      status,
+      next_run
+    ) VALUES (
+      $1, $2, $3, $4, $5, $6, $7, $8, $9, $10
+    ) RETURNING *
+  `,
+      [
+        schedule.connectionId,
+        schedule.playbook,
+        schedule.scheduleType,
+        schedule.cronExpression,
+        schedule.additionalInstructions,
+        schedule.minInterval,
+        schedule.maxInterval,
+        schedule.enabled,
+        schedule.status,
+        schedule.nextRun
+      ]
+    );
+
+    const savedSchedule = result.rows[0];
+
+    return {
+      id: savedSchedule.id,
+      connectionId: savedSchedule.connection_id,
+      playbook: savedSchedule.playbook,
+      scheduleType: savedSchedule.schedule_type,
+      cronExpression: savedSchedule.cron_expression,
+      additionalInstructions: savedSchedule.additional_instructions,
+      minInterval: savedSchedule.min_interval,
+      maxInterval: savedSchedule.max_interval,
+      enabled: savedSchedule.enabled,
+      status: savedSchedule.status,
+      nextRun: savedSchedule.next_run
+    };
+  } finally {
+    client.release();
+  }
+}
+
+export async function updateSchedule(schedule: Schedule): Promise<Schedule> {
+  const client = await pool.connect();
+
+  try {
+    const result = await client.query(
+      `
+    UPDATE schedules 
+    SET
+      connection_id = $1,
+      playbook = $2,
+      schedule_type = $3,
+      cron_expression = $4,
+      additional_instructions = $5,
+      min_interval = $6,
+      max_interval = $7,
+      enabled = $8,
+      next_run = $9,
+      failures = $10,
+      last_run = $11,
+      status = $12
+    WHERE id = $13
+    RETURNING *
+    `,
+      [
+        schedule.connectionId,
+        schedule.playbook,
+        schedule.scheduleType,
+        schedule.cronExpression,
+        schedule.additionalInstructions,
+        schedule.minInterval,
+        schedule.maxInterval,
+        schedule.enabled,
+        schedule.nextRun,
+        schedule.failures,
+        schedule.lastRun,
+        schedule.status,
+        schedule.id
+      ]
+    );
+
+    if (result.rows.length === 0) {
+      throw new Error(`Schedule with id ${schedule.id} not found`);
+    }
+
+    const savedSchedule = result.rows[0];
+
+    return {
+      id: savedSchedule.id,
+      connectionId: savedSchedule.connection_id,
+      playbook: savedSchedule.playbook,
+      scheduleType: savedSchedule.schedule_type,
+      cronExpression: savedSchedule.cron_expression,
+      additionalInstructions: savedSchedule.additional_instructions,
+      minInterval: savedSchedule.min_interval,
+      maxInterval: savedSchedule.max_interval,
+      enabled: savedSchedule.enabled,
+      nextRun: savedSchedule.next_run,
+      failures: savedSchedule.failures,
+      lastRun: savedSchedule.last_run,
+      status: savedSchedule.status
+    };
+  } finally {
+    client.release();
+  }
+}
+
+export async function getSchedules(): Promise<Schedule[]> {
+  const client = await pool.connect();
+  try {
+    const result = await client.query(`SELECT id,
+      connection_id,
+      playbook,
+      schedule_type,
+      cron_expression,
+      additional_instructions,
+      min_interval,
+      max_interval,
+      enabled,
+      COALESCE(to_char(next_run, 'YYYY-MM-DD HH24:MI:SSZ'), '') as next_run,
+      COALESCE(to_char(last_run, 'YYYY-MM-DD HH24:MI:SSZ'), '') as last_run,
+      failures,
+      status FROM schedules`);
+    return result.rows.map((row) => ({
+      id: row.id,
+      connectionId: row.connection_id,
+      playbook: row.playbook,
+      scheduleType: row.schedule_type,
+      cronExpression: row.cron_expression,
+      additionalInstructions: row.additional_instructions,
+      minInterval: row.min_interval,
+      maxInterval: row.max_interval,
+      lastRun: row.last_run,
+      nextRun: row.next_run,
+      failures: row.failures,
+      enabled: row.enabled,
+      status: row.status
+    }));
+  } finally {
+    client.release();
+  }
+}
+
+export async function getSchedule(id: string): Promise<Schedule> {
+  const client = await pool.connect();
+  try {
+    const result = await client.query(
+      `SELECT id,
+             connection_id,
+             playbook,
+             schedule_type,
+             cron_expression,
+             additional_instructions,
+             min_interval,
+             max_interval,
+             enabled,
+             COALESCE(to_char(next_run, 'YYYY-MM-DD HH24:MI:SSZ'), '') as next_run,
+             COALESCE(to_char(last_run, 'YYYY-MM-DD HH24:MI:SSZ'), '') as last_run,
+             failures,
+             status
+      FROM schedules
+      WHERE id = $1`,
+      [id]
+    );
+
+    if (result.rows.length === 0) {
+      throw new Error(`Schedule with id ${id} not found`);
+    }
+
+    const row = result.rows[0];
+    return {
+      id: row.id,
+      connectionId: row.connection_id,
+      playbook: row.playbook,
+      scheduleType: row.schedule_type,
+      cronExpression: row.cron_expression,
+      additionalInstructions: row.additional_instructions,
+      minInterval: row.min_interval,
+      maxInterval: row.max_interval,
+      enabled: row.enabled,
+      nextRun: row.next_run,
+      failures: row.failures,
+      lastRun: row.last_run,
+      status: row.status
+    };
+  } finally {
+    client.release();
+  }
+}
+
+export async function deleteSchedule(id: string): Promise<void> {
+  const client = await pool.connect();
+  try {
+    await client.query('DELETE FROM schedules WHERE id = $1', [id]);
+  } finally {
+    client.release();
+  }
+}
+
+export async function incrementScheduleFailures(id: string): Promise<void> {
+  const client = await pool.connect();
+  try {
+    await client.query('UPDATE schedules SET failures = failures + 1 WHERE id = $1', [id]);
+  } finally {
+    client.release();
+  }
+}
+
+export async function setScheduleStatusRunning(id: string): Promise<void> {
+  const client = await pool.connect();
+  try {
+    await client.query('BEGIN');
+
+    const result = await client.query('SELECT status FROM schedules WHERE id = $1 FOR UPDATE', [id]);
+
+    if (result.rows[0]?.status === 'running') {
+      throw new Error(`Schedule ${id} is already running`);
+    }
+
+    await client.query('UPDATE schedules SET status = $1 WHERE id = $2', ['running', id]);
+
+    await client.query('COMMIT');
+  } catch (error) {
+    await client.query('ROLLBACK');
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+
+export async function updateScheduleRunData(schedule: Schedule): Promise<void> {
+  const client = await pool.connect();
+  try {
+    await client.query('UPDATE schedules SET next_run = $1, last_run = $2, status = $3, enabled = $4  WHERE id = $5', [
+      schedule.nextRun,
+      schedule.lastRun,
+      schedule.status,
+      schedule.enabled,
+      schedule.id
+    ]);
+  } finally {
+    client.release();
+  }
+}
diff --git a/apps/dbagent/src/lib/services/scheduler.ts b/apps/dbagent/src/lib/services/scheduler.ts
new file mode 100644
index 00000000..b3c42ee4
--- /dev/null
+++ b/apps/dbagent/src/lib/services/scheduler.ts
@@ -0,0 +1,110 @@
+import {
+  getSchedules,
+  incrementScheduleFailures,
+  Schedule,
+  scheduleGetNextRun,
+  setScheduleStatusRunning,
+  updateScheduleRunData
+} from '~/lib/db/schedules';
+
+const MAX_PARALLEL_JOBS = 20;
+
+export class SchedulerService {
+  private intervalId?: NodeJS.Timeout;
+  private checkIntervalMs: number;
+
+  constructor(checkIntervalMs: number = 60000) {
+    // default 1 minute
+    this.checkIntervalMs = checkIntervalMs;
+  }
+
+  async start() {
+    if (this.intervalId) {
+      console.warn('Scheduler already running');
+      return;
+    }
+
+    console.log(`Starting scheduler with ${this.checkIntervalMs}ms interval`);
+    this.intervalId = setInterval(() => this.checkAndRunJobs(), this.checkIntervalMs);
+
+    // Run immediately on start
+    await this.checkAndRunJobs();
+  }
+
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = undefined;
+      console.log('Scheduler stopped');
+    }
+  }
+
+  async checkAndRunJobs() {
+    console.log('Checking and running jobs');
+    try {
+      const schedules = await getSchedules();
+      const now = new Date();
+
+      // Filter schedules that should run
+      const schedulesToRun = [];
+      for (const schedule of schedules) {
+        if (!schedule.enabled) continue;
+        const shouldRun = await this.shouldRunSchedule(schedule, now);
+        if (shouldRun) {
+          schedulesToRun.push(schedule);
+        }
+      }
+
+      // Take only up to MAX_PARALLEL_JOBS
+      // Randomly shuffle the array and take first MAX_PARALLEL_JOBS items
+      const shuffled = [...schedulesToRun].sort(() => Math.random() - 0.5);
+      const schedulesToRunNow = shuffled.slice(0, MAX_PARALLEL_JOBS);
+      if (schedulesToRun.length > MAX_PARALLEL_JOBS) {
+        console.log(`Deferring ${schedulesToRun.length - MAX_PARALLEL_JOBS} jobs until next wake up`);
+      }
+
+      // Run selected jobs in parallel
+      await Promise.all(schedulesToRunNow.map((schedule) => this.runJob(schedule, now)));
+    } catch (error) {
+      console.error('Error in scheduler:', error);
+    }
+  }
+
+  private async shouldRunSchedule(schedule: Schedule, now: Date): Promise<boolean> {
+    if (schedule.status !== 'scheduled' || schedule.enabled === false || schedule.nextRun === undefined) return false;
+    return now >= new Date(schedule.nextRun);
+  }
+
+  private async runJob(schedule: Schedule, now: Date) {
+    try {
+      await setScheduleStatusRunning(schedule.id);
+    } catch (error) {
+      // I'm going to assume that some other worker has just picked this up
+      // and will do the job
+      console.error(`Someone else is running schedule ${schedule.id}:`, error);
+      return;
+    }
+
+    try {
+      console.log(`Running playbook ${schedule.playbook} for schedule ${schedule.id}`);
+
+      // TODO: Implement playbook execution
+      //await executePlaybook(schedule.playbook, {
+      //  connectionId: schedule.connectionId,
+      //  additionalInstructions: schedule.additionalInstructions
+      //});
+      // Simulate job execution with 5 second delay
+      await new Promise((resolve) => setTimeout(resolve, 5000));
+    } catch (error) {
+      console.error(`Error running playbook ${schedule.playbook}:`, error);
+      await incrementScheduleFailures(schedule.id);
+    }
+
+    // Schedule the next run (also in case of errors)
+    schedule.status = 'scheduled';
+    schedule.lastRun = now.toUTCString();
+    schedule.nextRun = scheduleGetNextRun(schedule, now).toUTCString();
+    await updateScheduleRunData(schedule);
+    console.log(`Wrote back ${JSON.stringify(schedule)} to the DB`);
+  }
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index a246b1cd..780efc36 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -92,6 +92,9 @@ importers:
       clsx:
         specifier: ^2.1.1
         version: 2.1.1
+      cron-parser:
+        specifier: ^5.0.3
+        version: 5.0.3
       framer-motion:
         specifier: ^12.4.3
         version: 12.4.3(react-dom@19.0.0(react@19.0.0))(react@19.0.0)
@@ -2800,6 +2803,10 @@ packages:
   concat-map@0.0.1:
     resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
 
+  cron-parser@5.0.3:
+    resolution: {integrity: sha512-PWP8fZGP1QuLm7X/jT6kDNcJpoV7/XqT5Z8tQLgmX3El8RLscn2zc/TPQFo2TiMIZ2k4UNVNMGZmBI2B+YU7og==}
+    engines: {node: '>=18'}
+
   cross-spawn@7.0.6:
     resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==}
     engines: {node: '>= 8'}
@@ -3777,6 +3784,10 @@ packages:
     peerDependencies:
       react: ^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0
 
+  luxon@3.5.0:
+    resolution: {integrity: sha512-rh+Zjr6DNfUYR3bPwJEnuwDdqMbxZW7LOQfUN4B54+Cl+0o5zaU9RJ6bcidfDtC1cWCZXQ+nvX8bf6bAji37QQ==}
+    engines: {node: '>=12'}
+
   magic-string@0.30.17:
     resolution: {integrity: sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==}
 
@@ -7788,6 +7799,10 @@ snapshots:
 
   concat-map@0.0.1: {}
 
+  cron-parser@5.0.3:
+    dependencies:
+      luxon: 3.5.0
+
   cross-spawn@7.0.6:
     dependencies:
       path-key: 3.1.1
@@ -8944,6 +8959,8 @@ snapshots:
     dependencies:
       react: 19.0.0
 
+  luxon@3.5.0: {}
+
   magic-string@0.30.17:
     dependencies:
       '@jridgewell/sourcemap-codec': 1.5.0

From e91efdd95ef60044a98bb8eb44f3116bb184bba1 Mon Sep 17 00:00:00 2001
From: Tudor Golubenco <tudor@xata.io>
Date: Sat, 22 Feb 2025 22:31:13 +0100
Subject: [PATCH 10/12] Simplify by removing the class, not really needed

---
 .../src/app/api/priv/schedule-tick/route.ts   |   5 +-
 apps/dbagent/src/lib/db/schedules.ts          |   1 -
 apps/dbagent/src/lib/services/scheduler.ts    | 143 +++++++-----------
 3 files changed, 56 insertions(+), 93 deletions(-)

diff --git a/apps/dbagent/src/app/api/priv/schedule-tick/route.ts b/apps/dbagent/src/app/api/priv/schedule-tick/route.ts
index ce06bfdb..7efca0c2 100644
--- a/apps/dbagent/src/app/api/priv/schedule-tick/route.ts
+++ b/apps/dbagent/src/app/api/priv/schedule-tick/route.ts
@@ -1,7 +1,6 @@
-import { SchedulerService } from '~/lib/services/scheduler';
+import { checkAndRunJobs } from '~/lib/services/scheduler';
 
 export async function POST() {
-  const scheduler = new SchedulerService();
-  await scheduler.checkAndRunJobs();
+  await checkAndRunJobs();
   return new Response('OK', { status: 200 });
 }
diff --git a/apps/dbagent/src/lib/db/schedules.ts b/apps/dbagent/src/lib/db/schedules.ts
index e08b2519..3d836c3c 100644
--- a/apps/dbagent/src/lib/db/schedules.ts
+++ b/apps/dbagent/src/lib/db/schedules.ts
@@ -19,7 +19,6 @@ export type Schedule = {
 };
 
 export function shouldRunSchedule(schedule: Schedule, now: Date): boolean {
-  console.log('shouldRunSchedule', schedule, now);
   if (schedule.enabled === false || schedule.nextRun === undefined) return false;
   return now >= new Date(schedule.nextRun);
 }
diff --git a/apps/dbagent/src/lib/services/scheduler.ts b/apps/dbagent/src/lib/services/scheduler.ts
index b3c42ee4..d33b770d 100644
--- a/apps/dbagent/src/lib/services/scheduler.ts
+++ b/apps/dbagent/src/lib/services/scheduler.ts
@@ -4,107 +4,72 @@ import {
   Schedule,
   scheduleGetNextRun,
   setScheduleStatusRunning,
+  shouldRunSchedule,
   updateScheduleRunData
 } from '~/lib/db/schedules';
 
 const MAX_PARALLEL_JOBS = 20;
 
-export class SchedulerService {
-  private intervalId?: NodeJS.Timeout;
-  private checkIntervalMs: number;
-
-  constructor(checkIntervalMs: number = 60000) {
-    // default 1 minute
-    this.checkIntervalMs = checkIntervalMs;
-  }
-
-  async start() {
-    if (this.intervalId) {
-      console.warn('Scheduler already running');
-      return;
+export async function checkAndRunJobs() {
+  console.log('Checking and running jobs');
+  try {
+    const schedules = await getSchedules();
+    const now = new Date();
+
+    // Filter schedules that should run
+    const schedulesToRun = [];
+    for (const schedule of schedules) {
+      if (!schedule.enabled) continue;
+      const shouldRun = shouldRunSchedule(schedule, now);
+      if (shouldRun) {
+        schedulesToRun.push(schedule);
+      }
     }
 
-    console.log(`Starting scheduler with ${this.checkIntervalMs}ms interval`);
-    this.intervalId = setInterval(() => this.checkAndRunJobs(), this.checkIntervalMs);
-
-    // Run immediately on start
-    await this.checkAndRunJobs();
-  }
-
-  stop() {
-    if (this.intervalId) {
-      clearInterval(this.intervalId);
-      this.intervalId = undefined;
-      console.log('Scheduler stopped');
+    // Take only up to MAX_PARALLEL_JOBS
+    // Randomly shuffle the array and take first MAX_PARALLEL_JOBS items
+    const shuffled = [...schedulesToRun].sort(() => Math.random() - 0.5);
+    const schedulesToRunNow = shuffled.slice(0, MAX_PARALLEL_JOBS);
+    if (schedulesToRun.length > MAX_PARALLEL_JOBS) {
+      console.log(`Deferring ${schedulesToRun.length - MAX_PARALLEL_JOBS} jobs until next wake up`);
     }
-  }
-
-  async checkAndRunJobs() {
-    console.log('Checking and running jobs');
-    try {
-      const schedules = await getSchedules();
-      const now = new Date();
-
-      // Filter schedules that should run
-      const schedulesToRun = [];
-      for (const schedule of schedules) {
-        if (!schedule.enabled) continue;
-        const shouldRun = await this.shouldRunSchedule(schedule, now);
-        if (shouldRun) {
-          schedulesToRun.push(schedule);
-        }
-      }
 
-      // Take only up to MAX_PARALLEL_JOBS
-      // Randomly shuffle the array and take first MAX_PARALLEL_JOBS items
-      const shuffled = [...schedulesToRun].sort(() => Math.random() - 0.5);
-      const schedulesToRunNow = shuffled.slice(0, MAX_PARALLEL_JOBS);
-      if (schedulesToRun.length > MAX_PARALLEL_JOBS) {
-        console.log(`Deferring ${schedulesToRun.length - MAX_PARALLEL_JOBS} jobs until next wake up`);
-      }
-
-      // Run selected jobs in parallel
-      await Promise.all(schedulesToRunNow.map((schedule) => this.runJob(schedule, now)));
-    } catch (error) {
-      console.error('Error in scheduler:', error);
-    }
+    // Run selected jobs in parallel
+    await Promise.all(schedulesToRunNow.map((schedule) => runJob(schedule, now)));
+  } catch (error) {
+    console.error('Error in scheduler:', error);
   }
+}
 
-  private async shouldRunSchedule(schedule: Schedule, now: Date): Promise<boolean> {
-    if (schedule.status !== 'scheduled' || schedule.enabled === false || schedule.nextRun === undefined) return false;
-    return now >= new Date(schedule.nextRun);
+async function runJob(schedule: Schedule, now: Date) {
+  try {
+    await setScheduleStatusRunning(schedule.id);
+  } catch (error) {
+    // I'm going to assume that some other worker has just picked this up
+    // and will do the job
+    console.error(`Someone else is running schedule ${schedule.id}:`, error);
+    return;
   }
 
-  private async runJob(schedule: Schedule, now: Date) {
-    try {
-      await setScheduleStatusRunning(schedule.id);
-    } catch (error) {
-      // I'm going to assume that some other worker has just picked this up
-      // and will do the job
-      console.error(`Someone else is running schedule ${schedule.id}:`, error);
-      return;
-    }
-
-    try {
-      console.log(`Running playbook ${schedule.playbook} for schedule ${schedule.id}`);
-
-      // TODO: Implement playbook execution
-      //await executePlaybook(schedule.playbook, {
-      //  connectionId: schedule.connectionId,
-      //  additionalInstructions: schedule.additionalInstructions
-      //});
-      // Simulate job execution with 5 second delay
-      await new Promise((resolve) => setTimeout(resolve, 5000));
-    } catch (error) {
-      console.error(`Error running playbook ${schedule.playbook}:`, error);
-      await incrementScheduleFailures(schedule.id);
-    }
-
-    // Schedule the next run (also in case of errors)
-    schedule.status = 'scheduled';
-    schedule.lastRun = now.toUTCString();
-    schedule.nextRun = scheduleGetNextRun(schedule, now).toUTCString();
-    await updateScheduleRunData(schedule);
-    console.log(`Wrote back ${JSON.stringify(schedule)} to the DB`);
+  try {
+    console.log(`Running playbook ${schedule.playbook} for schedule ${schedule.id}`);
+
+    // TODO: Implement playbook execution
+    //await executePlaybook(schedule.playbook, {
+    //  connectionId: schedule.connectionId,
+    //  additionalInstructions: schedule.additionalInstructions
+    //});
+    // Simulate job execution with 5 second delay
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+  } catch (error) {
+    console.error(`Error running playbook ${schedule.playbook}:`, error);
+    await incrementScheduleFailures(schedule.id);
   }
+
+  // Schedule the next run (also in case of errors)
+  schedule.status = 'scheduled';
+  schedule.lastRun = now.toUTCString();
+  schedule.nextRun = scheduleGetNextRun(schedule, now).toUTCString();
+  await updateScheduleRunData(schedule);
+  console.log(`Wrote back ${JSON.stringify(schedule)} to the DB`);
 }

From f20998861167ff4a2b139326457bc7aaeb11a961 Mon Sep 17 00:00:00 2001
From: Tudor Golubenco <tudor@xata.io>
Date: Sat, 22 Feb 2025 23:05:59 +0100
Subject: [PATCH 11/12] Recover schedules in case they time out

---
 .../components/monitoring/schedules-table.tsx |  7 ++-
 apps/dbagent/src/lib/db/schedules.ts          |  5 --
 apps/dbagent/src/lib/env/scheduler.ts         | 16 +++++++
 apps/dbagent/src/lib/services/scheduler.ts    | 48 +++++++++++++------
 4 files changed, 56 insertions(+), 20 deletions(-)
 create mode 100644 apps/dbagent/src/lib/env/scheduler.ts

diff --git a/apps/dbagent/src/components/monitoring/schedules-table.tsx b/apps/dbagent/src/components/monitoring/schedules-table.tsx
index 84a9afd0..6304eab0 100644
--- a/apps/dbagent/src/components/monitoring/schedules-table.tsx
+++ b/apps/dbagent/src/components/monitoring/schedules-table.tsx
@@ -39,6 +39,11 @@ export function MonitoringScheduleTable({ connections }: { connections: DbConnec
     }
   };
 
+  const refreshSchedules = async () => {
+    const schedules = await actionGetSchedules();
+    setSchedules(schedules.sort((a, b) => String(a.id || '').localeCompare(String(b.id || ''))));
+  };
+
   useEffect(() => {
     void loadSchedules();
   }, []);
@@ -82,7 +87,7 @@ export function MonitoringScheduleTable({ connections }: { connections: DbConnec
       <div className="mb-4 flex items-center justify-between">
         <h1 className="text-2xl font-bold">Monitoring Schedules</h1>
         <div className="mb-6 flex items-center gap-2">
-          <Button variant="outline" onClick={() => loadSchedules()}>
+          <Button variant="outline" onClick={() => refreshSchedules()}>
             <RefreshCwIcon className="mr-2 h-4 w-4" />
           </Button>
           <Link href="/monitoring/schedule/add">
diff --git a/apps/dbagent/src/lib/db/schedules.ts b/apps/dbagent/src/lib/db/schedules.ts
index 3d836c3c..e4f50208 100644
--- a/apps/dbagent/src/lib/db/schedules.ts
+++ b/apps/dbagent/src/lib/db/schedules.ts
@@ -18,11 +18,6 @@ export type Schedule = {
   enabled: boolean;
 };
 
-export function shouldRunSchedule(schedule: Schedule, now: Date): boolean {
-  if (schedule.enabled === false || schedule.nextRun === undefined) return false;
-  return now >= new Date(schedule.nextRun);
-}
-
 export function scheduleGetNextRun(schedule: Schedule, now: Date): Date {
   if (schedule.scheduleType === 'cron' && schedule.cronExpression) {
     const interval = CronExpressionParser.parse(schedule.cronExpression);
diff --git a/apps/dbagent/src/lib/env/scheduler.ts b/apps/dbagent/src/lib/env/scheduler.ts
new file mode 100644
index 00000000..c25395af
--- /dev/null
+++ b/apps/dbagent/src/lib/env/scheduler.ts
@@ -0,0 +1,16 @@
+/* eslint-disable no-process-env */
+
+import { z } from 'zod';
+
+const schema = z.object({
+  // How many schedules can run in parallel
+  MAX_PARALLEL_RUNS: z.number().default(20),
+
+  // How long to wait for a schedule to finish before assuming it's dead and running it again
+  TIMEOUT_FOR_RUNNING_SCHEDULE_SECS: z.number().default(15 * 60)
+});
+
+export const env = schema.parse({
+  TIMEOUT_FOR_RUNNING_SCHEDULE_SECS: process.env.TIMEOUT_FOR_RUNNING_SCHEDULE_SECS,
+  MAX_PARALLEL_RUNS: process.env.MAX_PARALLEL_RUNS
+});
diff --git a/apps/dbagent/src/lib/services/scheduler.ts b/apps/dbagent/src/lib/services/scheduler.ts
index d33b770d..43f067c1 100644
--- a/apps/dbagent/src/lib/services/scheduler.ts
+++ b/apps/dbagent/src/lib/services/scheduler.ts
@@ -4,11 +4,29 @@ import {
   Schedule,
   scheduleGetNextRun,
   setScheduleStatusRunning,
-  shouldRunSchedule,
   updateScheduleRunData
 } from '~/lib/db/schedules';
+import { env } from '../env/scheduler';
 
-const MAX_PARALLEL_JOBS = 20;
+export function shouldRunSchedule(schedule: Schedule, now: Date): boolean {
+  if (schedule.enabled === false || schedule.nextRun === undefined) return false;
+  const nextRun = new Date(schedule.nextRun);
+
+  if (schedule.status !== 'scheduled') {
+    if (
+      schedule.status === 'running' &&
+      nextRun.getTime() + env.TIMEOUT_FOR_RUNNING_SCHEDULE_SECS * 1000 < now.getTime()
+    ) {
+      console.log(`Schedule ${schedule.id} is running but timeout has expired, restarting`);
+      // The process might have crashed while the schedule was running.
+      // We should restart it.
+      return true;
+    }
+    return false;
+  }
+
+  return now >= nextRun;
+}
 
 export async function checkAndRunJobs() {
   console.log('Checking and running jobs');
@@ -29,9 +47,9 @@ export async function checkAndRunJobs() {
     // Take only up to MAX_PARALLEL_JOBS
     // Randomly shuffle the array and take first MAX_PARALLEL_JOBS items
     const shuffled = [...schedulesToRun].sort(() => Math.random() - 0.5);
-    const schedulesToRunNow = shuffled.slice(0, MAX_PARALLEL_JOBS);
-    if (schedulesToRun.length > MAX_PARALLEL_JOBS) {
-      console.log(`Deferring ${schedulesToRun.length - MAX_PARALLEL_JOBS} jobs until next wake up`);
+    const schedulesToRunNow = shuffled.slice(0, env.MAX_PARALLEL_RUNS);
+    if (schedulesToRun.length > env.MAX_PARALLEL_RUNS) {
+      console.log(`Deferring ${schedulesToRun.length - env.MAX_PARALLEL_RUNS} jobs until next wake up`);
     }
 
     // Run selected jobs in parallel
@@ -42,18 +60,20 @@ export async function checkAndRunJobs() {
 }
 
 async function runJob(schedule: Schedule, now: Date) {
-  try {
-    await setScheduleStatusRunning(schedule.id);
-  } catch (error) {
-    // I'm going to assume that some other worker has just picked this up
-    // and will do the job
-    console.error(`Someone else is running schedule ${schedule.id}:`, error);
-    return;
+  console.log(`Running playbook ${schedule.playbook} for schedule ${schedule.id}`);
+
+  if (schedule.status === 'scheduled') {
+    try {
+      await setScheduleStatusRunning(schedule.id);
+    } catch (error) {
+      // I'm going to assume that some other worker has just picked this up
+      // and will do the job
+      console.error(`Someone else is running schedule ${schedule.id}:`, error);
+      return;
+    }
   }
 
   try {
-    console.log(`Running playbook ${schedule.playbook} for schedule ${schedule.id}`);
-
     // TODO: Implement playbook execution
     //await executePlaybook(schedule.playbook, {
     //  connectionId: schedule.connectionId,

From bcb3731c42b66d1a2e383f8eb680eae700068831 Mon Sep 17 00:00:00 2001
From: Tudor Golubenco <tudor@xata.io>
Date: Sun, 23 Feb 2025 10:40:40 +0100
Subject: [PATCH 12/12] Fix tsc error

---
 apps/dbagent/src/app/layout.tsx                      |  1 -
 .../src/components/monitoring/schedule-form.tsx      | 12 ++++--------
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/apps/dbagent/src/app/layout.tsx b/apps/dbagent/src/app/layout.tsx
index 5424d7a3..1b64a278 100644
--- a/apps/dbagent/src/app/layout.tsx
+++ b/apps/dbagent/src/app/layout.tsx
@@ -2,7 +2,6 @@ import '@internal/theme';
 import { Metadata } from 'next';
 import { Inter, JetBrains_Mono } from 'next/font/google';
 import { Providers } from '~/components/providers';
-//import '~/lib/services/local-scheduler'; // This starts the local scheduler
 
 const inter = Inter({
   subsets: ['latin'],
diff --git a/apps/dbagent/src/components/monitoring/schedule-form.tsx b/apps/dbagent/src/components/monitoring/schedule-form.tsx
index 75c8d4e1..4bc84893 100644
--- a/apps/dbagent/src/components/monitoring/schedule-form.tsx
+++ b/apps/dbagent/src/components/monitoring/schedule-form.tsx
@@ -30,13 +30,8 @@ import { useEffect, useState } from 'react';
 import { useForm } from 'react-hook-form';
 import * as z from 'zod';
 import { DbConnection } from '~/lib/db/connections';
-import {
-  actionCreateSchedule,
-  actionDeleteSchedule,
-  actionGetSchedule,
-  actionUpdateSchedule,
-  Schedule
-} from './actions';
+import { Schedule } from '~/lib/db/schedules';
+import { actionCreateSchedule, actionDeleteSchedule, actionGetSchedule, actionUpdateSchedule } from './actions';
 import { CronExpressionModal } from './cron-expression-modal';
 
 const formSchema = z.object({
@@ -107,7 +102,8 @@ export function ScheduleForm({
       additionalInstructions: data.additionalInstructions,
       minInterval: Number(data.minInterval),
       maxInterval: Number(data.maxInterval),
-      enabled: data.enabled
+      enabled: data.enabled,
+      status: data.enabled ? 'scheduled' : 'disabled'
     };
     if (isEditMode) {
       await actionUpdateSchedule(schedule);