@omnixal/openclaw-nats-plugin 0.2.7 → 0.2.8

package/dashboard/src/App.svelte

@@ -1,14 +1,15 @@
 <script lang="ts">
   import { onMount } from 'svelte';
   import {
-    getHealth, getPending, getRoutes, getCronJobs, getMetrics,
-    type HealthStatus, type PendingEvent, type EventRoute, type CronJob, type SubjectMetric,
+    getHealth, getPending, getRoutes, getCronJobs, getTimers, getMetrics,
+    type HealthStatus, type PendingEvent, type EventRoute, type CronJob, type TimerJob, type SubjectMetric,
   } from '$lib/api';
   import HealthCards from '$lib/HealthCards.svelte';
   import PendingTable from '$lib/PendingTable.svelte';
   import ConfigPanel from '$lib/ConfigPanel.svelte';
   import RoutesPanel from '$lib/RoutesPanel.svelte';
   import CronPanel from '$lib/CronPanel.svelte';
+  import TimerPanel from '$lib/TimerPanel.svelte';
   import MetricsPanel from '$lib/MetricsPanel.svelte';
   import ThemeToggle from '$lib/ThemeToggle.svelte';
   import RefreshCw from '@lucide/svelte/icons/refresh-cw';
@@ -17,31 +18,35 @@
   let pending: PendingEvent[] = $state([]);
   let routes: EventRoute[] = $state([]);
   let cronJobs: CronJob[] = $state([]);
+  let timers: TimerJob[] = $state([]);
   let metrics: SubjectMetric[] = $state([]);
   let error: string | null = $state(null);
-  let activeTab: 'pending' | 'routes' | 'cron' | 'metrics' = $state('pending');
+  let activeTab: 'pending' | 'routes' | 'cron' | 'timers' | 'metrics' = $state('pending');
 
   const tabs = [
     { id: 'pending' as const, label: 'Pending' },
     { id: 'routes' as const, label: 'Routes' },
     { id: 'cron' as const, label: 'Cron Jobs' },
+    { id: 'timers' as const, label: 'Timers' },
     { id: 'metrics' as const, label: 'Metrics' },
   ];
 
   async function refresh() {
     try {
       error = null;
-      const [h, p, r, c, m] = await Promise.all([
+      const [h, p, r, c, t, m] = await Promise.all([
         getHealth(),
         getPending('default'),
         getRoutes(),
         getCronJobs(),
+        getTimers(),
         getMetrics(),
       ]);
       health = h;
       pending = p;
       routes = r;
       cronJobs = c;
+      timers = t;
       metrics = m;
     } catch (e: any) {
       error = e.message;
@@ -91,6 +96,12 @@
           {#if tab.id === 'pending' && pending.length > 0}
             <span class="ml-1.5 inline-flex items-center justify-center rounded-full bg-destructive/15 text-destructive text-xs font-semibold min-w-5 h-5 px-1.5">{pending.length}</span>
           {/if}
+          {#if tab.id === 'timers'}
+            {@const pendingTimers = timers.filter(t => !t.fired).length}
+            {#if pendingTimers > 0}
+              <span class="ml-1.5 inline-flex items-center justify-center rounded-full bg-primary/15 text-primary text-xs font-semibold min-w-5 h-5 px-1.5">{pendingTimers}</span>
+            {/if}
+          {/if}
         </button>
       {/each}
     </div>
@@ -101,6 +112,8 @@
       <RoutesPanel {routes} onRefresh={refresh} />
     {:else if activeTab === 'cron'}
       <CronPanel jobs={cronJobs} onRefresh={refresh} />
+    {:else if activeTab === 'timers'}
+      <TimerPanel {timers} onRefresh={refresh} />
     {:else if activeTab === 'metrics'}
       <MetricsPanel {metrics} />
     {/if}

package/dashboard/src/lib/TimerPanel.svelte

@@ -0,0 +1,327 @@
+<script lang="ts">
+  import * as Card from '$lib/components/ui/card';
+  import * as Table from '$lib/components/ui/table';
+  import { Badge } from '$lib/components/ui/badge';
+  import { Button } from '$lib/components/ui/button';
+  import { Modal } from '$lib/components/ui/modal';
+  import LogsPanel from '$lib/LogsPanel.svelte';
+  import { type TimerJob, createTimer, cancelTimer } from '$lib/api';
+  import { relativeAge, formatDuration, isValidAgentSubject } from '$lib/utils';
+
+  interface Props {
+    timers: TimerJob[];
+    onRefresh: () => void;
+  }
+
+  let { timers, onRefresh }: Props = $props();
+
+  // Create form
+  let showForm = $state(false);
+  let formName = $state('');
+  let formDelay = $state('300000');
+  let formSubject = $state('agent.events.timer.');
+  let formPayload = $state('{}');
+  let formError: string | null = $state(null);
+  let actionError: string | null = $state(null);
+  let loading = $state(false);
+
+  // Modal state
+  let selectedTimer: TimerJob | null = $state(null);
+  let activeTab: 'details' | 'logs' = $state('details');
+  let showDeleteConfirm = $state(false);
+
+  // Delay presets
+  const presets = [
+    { label: '1m', ms: 60_000 },
+    { label: '5m', ms: 300_000 },
+    { label: '15m', ms: 900_000 },
+    { label: '30m', ms: 1_800_000 },
+    { label: '1h', ms: 3_600_000 },
+    { label: '6h', ms: 21_600_000 },
+  ];
+
+  function resetForm() {
+    showForm = false;
+    formName = '';
+    formDelay = '300000';
+    formSubject = 'agent.events.timer.';
+    formPayload = '{}';
+    formError = null;
+  }
+
+  async function handleCreate() {
+    formError = null;
+
+    if (!formName.trim()) {
+      formError = 'Name is required';
+      return;
+    }
+
+    const delayMs = parseInt(formDelay);
+    if (isNaN(delayMs) || delayMs <= 0) {
+      formError = 'Delay must be a positive number (ms)';
+      return;
+    }
+
+    if (!isValidAgentSubject(formSubject)) {
+      formError = 'Subject must start with "agent.events." followed by at least one token and must not end with "."';
+      return;
+    }
+
+    let parsedPayload: unknown;
+    try {
+      parsedPayload = JSON.parse(formPayload);
+    } catch {
+      formError = 'Invalid JSON payload';
+      return;
+    }
+
+    loading = true;
+    try {
+      await createTimer({
+        name: formName.trim(),
+        delayMs,
+        subject: formSubject.trim(),
+        payload: parsedPayload,
+      });
+      resetForm();
+      onRefresh();
+    } catch (e: any) {
+      formError = e.message;
+    } finally {
+      loading = false;
+    }
+  }
+
+  function openTimerModal(timer: TimerJob) {
+    selectedTimer = timer;
+    activeTab = 'details';
+    showDeleteConfirm = false;
+  }
+
+  function closeModal() {
+    selectedTimer = null;
+    showDeleteConfirm = false;
+  }
+
+  async function handleCancel() {
+    if (!selectedTimer) return;
+    try {
+      loading = true;
+      await cancelTimer(selectedTimer.name);
+      closeModal();
+      onRefresh();
+    } catch (e: any) {
+      actionError = e.message;
+    } finally {
+      loading = false;
+    }
+  }
+
+  function statusVariant(timer: TimerJob): 'default' | 'secondary' | 'destructive' {
+    if (timer.fired) return 'secondary';
+    if (timer.remainingMs <= 0) return 'destructive';
+    return 'default';
+  }
+
+  function statusLabel(timer: TimerJob): string {
+    if (timer.fired) return 'Fired';
+    if (timer.remainingMs <= 0) return 'Overdue';
+    return 'Pending';
+  }
+</script>
+
+{#if selectedTimer}
+  <Modal
+    open={true}
+    title="Timer: {selectedTimer.name}"
+    onClose={closeModal}
+  >
+    {#snippet children()}
+      <div class="flex gap-1 border-b mb-4">
+        <button
+          class="px-3 py-1.5 text-sm font-medium border-b-2 transition-colors {activeTab === 'details' ? 'border-primary text-foreground' : 'border-transparent text-muted-foreground hover:text-foreground'}"
+          onclick={() => (activeTab = 'details')}
+        >Details</button>
+        <button
+          class="px-3 py-1.5 text-sm font-medium border-b-2 transition-colors {activeTab === 'logs' ? 'border-primary text-foreground' : 'border-transparent text-muted-foreground hover:text-foreground'}"
+          onclick={() => (activeTab = 'logs')}
+        >Logs</button>
+      </div>
+
+      {#if activeTab === 'details'}
+        {#if showDeleteConfirm}
+          <div class="rounded-md border border-destructive/50 bg-destructive/5 p-4 space-y-3">
+            <p class="text-sm">Cancel timer <span class="font-mono font-semibold">{selectedTimer.name}</span>?</p>
+            <p class="text-xs text-muted-foreground">The timer will be removed and will not fire.</p>
+            <div class="flex gap-2">
+              <Button variant="destructive" size="sm" onclick={handleCancel} disabled={loading}>
+                {loading ? 'Cancelling...' : 'Confirm Cancel'}
+              </Button>
+              <Button variant="outline" size="sm" onclick={() => (showDeleteConfirm = false)}>Back</Button>
+            </div>
+          </div>
+        {:else}
+          <div class="space-y-3">
+            <div class="grid grid-cols-2 gap-3">
+              <div class="space-y-1">
+                <span class="text-xs text-muted-foreground">Status</span>
+                <div>
+                  <Badge variant={statusVariant(selectedTimer)}>{statusLabel(selectedTimer)}</Badge>
+                </div>
+              </div>
+              <div class="space-y-1">
+                <span class="text-xs text-muted-foreground">Delay</span>
+                <div class="text-sm font-medium">{formatDuration(selectedTimer.delayMs)}</div>
+              </div>
+            </div>
+            <div class="space-y-1">
+              <span class="text-xs text-muted-foreground">Subject</span>
+              <div class="text-sm font-mono">{selectedTimer.subject}</div>
+            </div>
+            <div class="space-y-1">
+              <span class="text-xs text-muted-foreground">Payload</span>
+              <pre class="text-xs font-mono bg-muted/50 rounded-md p-2 overflow-x-auto">{JSON.stringify(selectedTimer.payload, null, 2)}</pre>
+            </div>
+            <div class="text-xs text-muted-foreground pt-2 space-y-1">
+              <div>Created: <span class="font-medium text-foreground">{relativeAge(selectedTimer.createdAt)}</span></div>
+              <div>Fire at: <span class="font-medium text-foreground">{new Date(selectedTimer.fireAt).toLocaleString()}</span></div>
+              {#if !selectedTimer.fired}
+                <div>Remaining: <span class="font-medium text-foreground">{formatDuration(selectedTimer.remainingMs)}</span></div>
+              {/if}
+            </div>
+          </div>
+        {/if}
+      {:else}
+        <LogsPanel entityType="timer" entityId={selectedTimer.id} />
+      {/if}
+    {/snippet}
+
+    {#snippet actions()}
+      {#if activeTab === 'details' && !showDeleteConfirm && !selectedTimer.fired}
+        <div class="flex w-full justify-between">
+          <Button variant="ghost" size="sm" class="text-destructive" onclick={() => (showDeleteConfirm = true)}>
+            Cancel Timer
+          </Button>
+          <Button variant="outline" size="sm" onclick={closeModal}>Close</Button>
+        </div>
+      {:else if activeTab === 'details' && !showDeleteConfirm}
+        <div class="flex w-full justify-end">
+          <Button variant="outline" size="sm" onclick={closeModal}>Close</Button>
+        </div>
+      {/if}
+    {/snippet}
+  </Modal>
+{/if}
+
+<Card.Root>
+  <Card.Header class="pb-2">
+    <div class="flex items-center justify-between">
+      <Card.Title class="text-sm font-medium">Timers</Card.Title>
+      {#if !showForm}
+        <Button variant="outline" size="sm" onclick={() => (showForm = true)}>Set Timer</Button>
+      {/if}
+    </div>
+  </Card.Header>
+  <Card.Content>
+    {#if actionError}
+      <div class="rounded-md bg-destructive/10 p-2 text-xs text-destructive mb-2">{actionError}</div>
+    {/if}
+
+    {#if showForm}
+      <div class="mb-4 space-y-3 rounded-md border p-4">
+        {#if formError}
+          <div class="rounded-md bg-destructive/10 p-2 text-xs text-destructive">{formError}</div>
+        {/if}
+        <div>
+          <label for="timer-name" class="text-xs text-muted-foreground">Name</label>
+          <input
+            id="timer-name"
+            type="text"
+            bind:value={formName}
+            placeholder="check-deploy"
+            class="w-full rounded-md border border-input bg-background px-3 py-1.5 text-sm"
+          />
+        </div>
+        <div>
+          <label for="timer-delay" class="text-xs text-muted-foreground">Delay (ms)</label>
+          <input
+            id="timer-delay"
+            type="number"
+            min="1000"
+            bind:value={formDelay}
+            class="w-full rounded-md border border-input bg-background px-3 py-1.5 text-sm"
+          />
+          <div class="flex gap-1.5 mt-1.5">
+            {#each presets as preset}
+              <button
+                class="rounded px-2 py-0.5 text-xs border border-input hover:bg-accent transition-colors {formDelay === String(preset.ms) ? 'bg-accent text-foreground' : 'text-muted-foreground'}"
+                onclick={() => (formDelay = String(preset.ms))}
+              >{preset.label}</button>
+            {/each}
+          </div>
+        </div>
+        <div>
+          <label for="timer-subject" class="text-xs text-muted-foreground">Subject</label>
+          <input
+            id="timer-subject"
+            type="text"
+            bind:value={formSubject}
+            placeholder="agent.events.timer.my-event"
+            class="w-full rounded-md border border-input bg-background px-3 py-1.5 text-sm"
+          />
+        </div>
+        <div>
+          <label for="timer-payload" class="text-xs text-muted-foreground">Payload (JSON)</label>
+          <textarea
+            id="timer-payload"
+            bind:value={formPayload}
+            rows="3"
+            class="w-full rounded-md border border-input bg-background px-3 py-1.5 text-sm"
+          ></textarea>
+        </div>
+        <div class="flex gap-2">
+          <Button size="sm" onclick={handleCreate} disabled={loading}>
+            {loading ? 'Creating...' : 'Set Timer'}
+          </Button>
+          <Button variant="ghost" size="sm" onclick={resetForm}>Cancel</Button>
+        </div>
+      </div>
+    {/if}
+
+    {#if timers.length === 0}
+      <p class="text-sm text-muted-foreground py-4">No timers</p>
+    {:else}
+      <Table.Root>
+        <Table.Header>
+          <Table.Row>
+            <Table.Head>Name</Table.Head>
+            <Table.Head>Subject</Table.Head>
+            <Table.Head>Delay</Table.Head>
+            <Table.Head>Status</Table.Head>
+            <Table.Head>Remaining</Table.Head>
+            <Table.Head>Fire At</Table.Head>
+          </Table.Row>
+        </Table.Header>
+        <Table.Body>
+          {#each timers as timer}
+            <Table.Row class="cursor-pointer hover:bg-muted/50" onclick={() => openTimerModal(timer)}>
+              <Table.Cell class="font-mono text-xs">{timer.name}</Table.Cell>
+              <Table.Cell class="font-mono text-xs">{timer.subject}</Table.Cell>
+              <Table.Cell class="text-xs">{formatDuration(timer.delayMs)}</Table.Cell>
+              <Table.Cell>
+                <Badge variant={statusVariant(timer)}>{statusLabel(timer)}</Badge>
+              </Table.Cell>
+              <Table.Cell class="text-xs text-muted-foreground">
+                {timer.fired ? '\u2014' : formatDuration(timer.remainingMs)}
+              </Table.Cell>
+              <Table.Cell class="text-xs text-muted-foreground">
+                {new Date(timer.fireAt).toLocaleString()}
+              </Table.Cell>
+            </Table.Row>
+          {/each}
+        </Table.Body>
+      </Table.Root>
+    {/if}
+  </Card.Content>
+</Card.Root>

package/dashboard/src/lib/api.ts

@@ -156,6 +156,41 @@ export async function runCronJobNow(name: string): Promise<void> {
   await fetchJSON(`/cron/${encodeURIComponent(name)}/run`, { method: 'POST' });
 }
 
+// ── Timers ──────────────────────────────────────────────────────────
+
+export interface TimerJob {
+  id: string;
+  name: string;
+  subject: string;
+  payload: unknown;
+  delayMs: number;
+  fireAt: number;
+  fired: boolean;
+  createdAt: number;
+  remainingMs: number;
+}
+
+export async function getTimers(): Promise<TimerJob[]> {
+  return fetchJSON('/cron/timer');
+}
+
+export async function createTimer(body: {
+  name: string;
+  delayMs: number;
+  subject: string;
+  payload?: unknown;
+}): Promise<TimerJob> {
+  return fetchJSON('/cron/timer', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+}
+
+export async function cancelTimer(name: string): Promise<void> {
+  await fetchJSON(`/cron/timer/${encodeURIComponent(name)}`, { method: 'DELETE' });
+}
+
 // ── Metrics ─────────────────────────────────────────────────────────
 
 export interface SubjectMetric {

package/dashboard/src/lib/utils.ts

@@ -22,6 +22,7 @@ export function relativeAge(ts: number | null): string {
 
 export function formatDuration(ms: number | null): string {
   if (ms === null) return '\u2014';
+  if (ms < 1000) return `${ms}ms`;
   const seconds = Math.floor(ms / 1000);
   if (seconds < 60) return `${seconds}s`;
   if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnixal/openclaw-nats-plugin",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "NATS JetStream event-driven plugin for OpenClaw",
   "license": "MIT",
   "type": "module",

package/plugins/nats-context-engine/index.ts

@@ -231,6 +231,149 @@ export default function (api: any) {
     },
   });
 
+  api.registerTool({
+    name: 'nats_cron_update',
+    description: 'Update an existing cron job. Can change schedule, subject, payload, timezone, or enabled status.',
+    parameters: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Job name to update' },
+        cron: { type: 'string', description: 'New cron expression' },
+        subject: { type: 'string', description: 'New NATS subject' },
+        payload: { type: 'object', description: 'New event payload' },
+        timezone: { type: 'string', description: 'New timezone' },
+        enabled: { type: 'boolean', description: 'Enable or disable the job' },
+      },
+      required: ['name'],
+    },
+    async execute(_id: string, params: any) {
+      const { name, ...fields } = params;
+      const result = await sidecarFetch(`/api/cron/${encodeURIComponent(name)}`, {
+        method: 'PATCH',
+        body: JSON.stringify(fields),
+      });
+      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    },
+  });
+
+  api.registerTool({
+    name: 'nats_cron_toggle',
+    description: 'Toggle a cron job on/off.',
+    parameters: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Job name to toggle' },
+      },
+      required: ['name'],
+    },
+    async execute(_id: string, params: any) {
+      const result = await sidecarFetch(`/api/cron/${encodeURIComponent(params.name)}/toggle`, {
+        method: 'PATCH',
+      });
+      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    },
+  });
+
+  api.registerTool({
+    name: 'nats_cron_run',
+    description: 'Manually fire a cron job right now (does not affect its schedule).',
+    parameters: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Job name to fire' },
+      },
+      required: ['name'],
+    },
+    async execute(_id: string, params: any) {
+      const result = await sidecarFetch(`/api/cron/${encodeURIComponent(params.name)}/run`, {
+        method: 'POST',
+      });
+      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    },
+  });
+
+  // ── Route Management Tools ────────────────────────────────────────
+
+  api.registerTool({
+    name: 'nats_route_update',
+    description: 'Update an existing route subscription. Can change target session, priority, or enabled status.',
+    parameters: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Route ID (from nats_subscriptions)' },
+        target: { type: 'string', description: 'New target session' },
+        priority: { type: 'number', description: 'New priority (1-10)' },
+        enabled: { type: 'boolean', description: 'Enable or disable the route' },
+      },
+      required: ['id'],
+    },
+    async execute(_id: string, params: any) {
+      const { id, ...fields } = params;
+      const result = await sidecarFetch(`/api/routes/${encodeURIComponent(id)}`, {
+        method: 'PATCH',
+        body: JSON.stringify(fields),
+      });
+      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    },
+  });
+
+  // ── Timer (One-Shot Delayed) Tools ────────────────────────────────
+
+  api.registerTool({
+    name: 'nats_timer_set',
+    description: 'Set a one-shot timer that publishes a NATS event after a delay. Use for delayed self-pings, reminders, or deferred tasks. Survives sidecar restarts.',
+    parameters: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Unique timer name (e.g., check-deploy-status, reminder-followup)' },
+        delayMs: { type: 'number', description: 'Delay in milliseconds before firing (e.g., 300000 for 5 minutes)' },
+        subject: { type: 'string', description: 'NATS subject to publish (must start with agent.events.)' },
+        payload: { type: 'object', description: 'Event payload data' },
+      },
+      required: ['name', 'delayMs', 'subject'],
+    },
+    async execute(_id: string, params: any) {
+      const result = await sidecarFetch('/api/cron/timer', {
+        method: 'POST',
+        body: JSON.stringify({
+          name: params.name,
+          delayMs: params.delayMs,
+          subject: params.subject,
+          payload: params.payload ?? {},
+        }),
+      });
+      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    },
+  });
+
+  api.registerTool({
+    name: 'nats_timer_cancel',
+    description: 'Cancel a pending timer by name.',
+    parameters: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Timer name to cancel' },
+      },
+      required: ['name'],
+    },
+    async execute(_id: string, params: any) {
+      const result = await sidecarFetch(`/api/cron/timer/${encodeURIComponent(params.name)}`, {
+        method: 'DELETE',
+      });
+      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    },
+  });
+
+  api.registerTool({
+    name: 'nats_timer_list',
+    description: 'List all timers (pending and fired) with remaining time.',
+    parameters: { type: 'object', properties: {} },
+    async execute() {
+      const result = await sidecarFetch('/api/cron/timer');
+      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    },
+  });
+
   // ── Dashboard UI ─────────────────────────────────────────────────
 
   api.registerHttpRoute({

package/sidecar/src/consumer/consumer.controller.ts

@@ -56,6 +56,7 @@ export class ConsumerController extends BaseController {
       if (this.gatewayClient.isAlive()) {
         for (const route of routes) {
           try {
+            const injectStart = performance.now();
             await this.gatewayClient.inject({
               target: route.target,
               message: this.formatMessage(envelope),
@@ -66,7 +67,8 @@ export class ConsumerController extends BaseController {
                 priority: (ctx.enrichments['priority'] as number) ?? envelope.meta?.priority ?? 5,
               },
             });
-            await this.routerService.recordDelivery(route.id, envelope.subject);
+            const lagMs = Math.round(performance.now() - injectStart);
+            await this.routerService.recordDelivery(route.id, envelope.subject, lagMs);
             this.metrics.recordConsume(envelope.subject);
             await this.logService.logDelivery(route.id, envelope.subject, JSON.stringify({ eventId: envelope.id, target: route.target }));
           } catch (routeErr) {

package/sidecar/src/db/migrations/0006_cooing_ultimatum.sql

@@ -0,0 +1 @@
+ALTER TABLE `event_routes` ADD `last_delivery_lag_ms` integer;

package/sidecar/src/db/migrations/0007_dizzy_komodo.sql

@@ -0,0 +1,14 @@
+CREATE TABLE `timer_jobs` (
+	`id` text PRIMARY KEY NOT NULL,
+	`name` text NOT NULL,
+	`subject` text NOT NULL,
+	`payload` text,
+	`delay_ms` integer NOT NULL,
+	`fire_at` integer NOT NULL,
+	`fired` integer DEFAULT false NOT NULL,
+	`created_at` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `timer_jobs_name_unique` ON `timer_jobs` (`name`);--> statement-breakpoint
+CREATE INDEX `timer_jobs_name_idx` ON `timer_jobs` (`name`);--> statement-breakpoint
+CREATE INDEX `timer_jobs_fire_at_idx` ON `timer_jobs` (`fire_at`);