runlater-js 0.1.0

package/README.md

@@ -0,0 +1,206 @@
+# runlater
+
+Delayed tasks, cron jobs, and reliable webhooks for any Node.js app. No Redis. No infrastructure. Just HTTP.
+
+[Documentation](https://runlater.eu/docs) | [Dashboard](https://runlater.eu)
+
+## Install
+
+```bash
+npm install runlater
+```
+
+## Quick start
+
+```js
+import { Runlater } from "runlater"
+
+const rl = new Runlater({ apiKey: process.env.RUNLATER_KEY })
+
+// Fire-and-forget with retries
+await rl.send("https://myapp.com/api/process-order", {
+  body: { orderId: 123 },
+  retries: 5,
+})
+
+// Run in 10 minutes
+await rl.delay("https://myapp.com/api/send-reminder", {
+  delay: "10m",
+  body: { userId: 456 },
+})
+
+// Run at a specific time
+await rl.schedule("https://myapp.com/api/trial-expired", {
+  at: "2026-03-15T09:00:00Z",
+  body: { userId: 789 },
+})
+
+// Recurring cron job
+await rl.cron("daily-report", {
+  url: "https://myapp.com/api/report",
+  schedule: "0 9 * * *",
+})
+```
+
+## Why Runlater?
+
+- **No infrastructure** — no Redis, no SQS, no cron containers
+- **Works everywhere** — Vercel, Netlify, Cloudflare Workers, Express, any Node.js app
+- **EU-hosted** — GDPR-native, data never leaves Europe
+- **Reliable** — automatic retries with exponential backoff
+- **Observable** — execution history, status codes, and error logs in the dashboard
+
+## API
+
+### `rl.send(url, options?)`
+
+Execute a request immediately with reliable delivery.
+
+```js
+const result = await rl.send("https://myapp.com/api/webhook", {
+  method: "POST",         // default: "POST"
+  headers: { "X-Custom": "value" },
+  body: { key: "value" }, // automatically JSON-serialized
+  retries: 5,             // default: server default
+  timeout: 30000,         // ms, default: 30000
+  queue: "emails",        // optional: serialize execution within a queue
+  callback: "https://myapp.com/api/on-complete", // optional: receive result
+})
+// => { task_id, execution_id, status, scheduled_for }
+```
+
+### `rl.delay(url, options)`
+
+Execute a request after a delay.
+
+```js
+await rl.delay("https://myapp.com/api/remind", {
+  delay: "10m",           // "30s", "5m", "2h", "1d", or seconds as number
+  body: { userId: 123 },
+})
+```
+
+### `rl.schedule(url, options)`
+
+Execute a request at a specific time.
+
+```js
+await rl.schedule("https://myapp.com/api/expire", {
+  at: new Date("2026-03-15T09:00:00Z"), // Date object or ISO string
+  body: { subscriptionId: "sub_123" },
+})
+```
+
+### `rl.cron(name, options)`
+
+Create or update a recurring cron task.
+
+```js
+await rl.cron("weekly-digest", {
+  url: "https://myapp.com/api/digest",
+  schedule: "0 9 * * MON",  // every Monday at 9am
+  method: "POST",
+  enabled: true,
+})
+```
+
+### Task management
+
+```js
+// List all tasks
+const { data, has_more } = await rl.tasks.list({ limit: 20 })
+
+// Get a specific task
+const task = await rl.tasks.get("task-id")
+
+// Trigger a task manually
+await rl.tasks.trigger("task-id")
+
+// View execution history
+const executions = await rl.tasks.executions("task-id")
+
+// Delete a task
+await rl.tasks.delete("task-id")
+```
+
+### Monitors (dead man's switch)
+
+```js
+// Create a monitor — alerts you if a ping is missed
+const monitor = await rl.monitors.create({
+  name: "nightly-backup",
+  schedule: "0 2 * * *",
+  grace: 600,  // 10 min grace period
+})
+
+// Ping it from your cron job
+await fetch(monitor.ping_url)
+```
+
+### Declarative sync
+
+Push your task configuration from code. Matched by name.
+
+```js
+await rl.sync({
+  tasks: [
+    {
+      url: "https://myapp.com/api/report",
+      schedule: "0 9 * * *",
+    },
+  ],
+  deleteRemoved: true, // remove tasks not in this list
+})
+```
+
+## Frameworks
+
+### Next.js (App Router)
+
+```js
+// app/api/orders/route.ts
+import { Runlater } from "runlater"
+
+const rl = new Runlater({ apiKey: process.env.RUNLATER_KEY })
+
+export async function POST(req: Request) {
+  const order = await req.json()
+
+  // Process immediately, return fast
+  await rl.send("https://myapp.com/api/fulfill-order", {
+    body: order,
+    retries: 5,
+  })
+
+  return Response.json({ status: "queued" })
+}
+```
+
+### Express
+
+```js
+import express from "express"
+import { Runlater } from "runlater"
+
+const app = express()
+const rl = new Runlater({ apiKey: process.env.RUNLATER_KEY })
+
+app.post("/orders", async (req, res) => {
+  // Send confirmation email in 5 minutes
+  await rl.delay("https://myapp.com/api/send-confirmation", {
+    delay: "5m",
+    body: { orderId: req.body.id },
+  })
+
+  res.json({ status: "ok" })
+})
+```
+
+## Requirements
+
+- Node.js 18+ (uses native `fetch`)
+- [Runlater account](https://runlater.eu) (free tier: 10k requests/month)
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,239 @@
+interface RunlaterOptions {
+    apiKey: string;
+    baseUrl?: string;
+}
+interface SendOptions {
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    headers?: Record<string, string>;
+    body?: unknown;
+    retries?: number;
+    timeout?: number;
+    queue?: string;
+    callback?: string;
+    idempotencyKey?: string;
+}
+interface DelayOptions extends SendOptions {
+    delay: string | number;
+}
+interface ScheduleOptions extends SendOptions {
+    at: string | Date;
+}
+interface CronOptions {
+    url: string;
+    schedule: string;
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    headers?: Record<string, string>;
+    body?: unknown;
+    timeout?: number;
+    retries?: number;
+    queue?: string;
+    callback?: string;
+    enabled?: boolean;
+}
+interface TaskResponse {
+    task_id: string;
+    execution_id: string;
+    status: string;
+    scheduled_for: string;
+}
+interface CronResponse {
+    id: string;
+    name: string;
+    url: string;
+    method: string;
+    cron_expression: string;
+    enabled: boolean;
+    next_run_at: string | null;
+    inserted_at: string;
+    updated_at: string;
+}
+interface Task {
+    id: string;
+    name: string;
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body: string | null;
+    schedule_type: string;
+    cron_expression: string | null;
+    scheduled_at: string | null;
+    enabled: boolean;
+    muted: boolean;
+    timeout_ms: number;
+    retry_attempts: number;
+    callback_url: string | null;
+    queue: string | null;
+    next_run_at: string | null;
+    inserted_at: string;
+    updated_at: string;
+}
+interface Execution {
+    id: string;
+    status: "pending" | "running" | "success" | "failed" | "timeout";
+    scheduled_for: string;
+    started_at: string | null;
+    finished_at: string | null;
+    status_code: number | null;
+    duration_ms: number | null;
+    error_message: string | null;
+    attempt: number;
+}
+interface ListOptions {
+    queue?: string;
+    limit?: number;
+    offset?: number;
+}
+interface ListResponse<T> {
+    data: T[];
+    has_more: boolean;
+    limit: number;
+    offset: number;
+}
+interface TriggerResponse {
+    execution_id: string;
+    status: string;
+    scheduled_for: string;
+}
+interface Monitor {
+    id: string;
+    name: string;
+    ping_token: string;
+    ping_url: string;
+    schedule_type: "cron" | "interval";
+    cron_expression: string | null;
+    interval_seconds: number | null;
+    grace_period_seconds: number;
+    status: "new" | "up" | "down" | "paused";
+    enabled: boolean;
+    muted: boolean;
+    last_ping_at: string | null;
+    next_expected_at: string | null;
+    inserted_at: string;
+    updated_at: string;
+}
+interface CreateMonitorOptions {
+    name: string;
+    schedule: string;
+    interval?: number;
+    grace?: number;
+    enabled?: boolean;
+}
+interface SyncOptions {
+    tasks?: CronOptions[];
+    monitors?: CreateMonitorOptions[];
+    deleteRemoved?: boolean;
+}
+interface SyncResponse {
+    tasks: {
+        created: string[];
+        updated: string[];
+        deleted: string[];
+    };
+    monitors: {
+        created: string[];
+        updated: string[];
+        deleted: string[];
+    };
+    created_count: number;
+    updated_count: number;
+    deleted_count: number;
+}
+declare class RunlaterError extends Error {
+    status: number;
+    code: string;
+    constructor(status: number, code: string, message: string);
+}
+
+declare class Runlater {
+    private apiKey;
+    private baseUrl;
+    tasks: Tasks;
+    monitors: Monitors;
+    constructor(options: RunlaterOptions | string);
+    /**
+     * Send a request immediately with reliable delivery and retries.
+     *
+     * ```js
+     * await rl.send("https://myapp.com/api/process", {
+     *   body: { orderId: 123 },
+     *   retries: 5
+     * })
+     * ```
+     */
+    send(url: string, options?: SendOptions): Promise<TaskResponse>;
+    /**
+     * Execute a request after a delay.
+     *
+     * ```js
+     * await rl.delay("https://myapp.com/api/remind", {
+     *   delay: "10m",
+     *   body: { userId: 456 }
+     * })
+     * ```
+     *
+     * Delay accepts:
+     * - Strings: "30s", "5m", "2h", "1d"
+     * - Numbers: seconds (e.g. 3600 for 1 hour)
+     */
+    delay(url: string, options: DelayOptions): Promise<TaskResponse>;
+    /**
+     * Execute a request at a specific time.
+     *
+     * ```js
+     * await rl.schedule("https://myapp.com/api/expire", {
+     *   at: "2026-03-15T09:00:00Z",
+     *   body: { trialId: 789 }
+     * })
+     * ```
+     */
+    schedule(url: string, options: ScheduleOptions): Promise<TaskResponse>;
+    /**
+     * Create or update a recurring cron task.
+     *
+     * ```js
+     * await rl.cron("daily-report", {
+     *   url: "https://myapp.com/api/report",
+     *   schedule: "0 9 * * *"
+     * })
+     * ```
+     */
+    cron(name: string, options: CronOptions): Promise<CronResponse>;
+    /**
+     * Declaratively sync tasks and monitors. Matched by name.
+     *
+     * ```js
+     * await rl.sync({
+     *   tasks: [
+     *     { name: "daily-report", url: "https://...", schedule: "0 9 * * *" }
+     *   ],
+     *   deleteRemoved: true
+     * })
+     * ```
+     */
+    sync(options: SyncOptions): Promise<SyncResponse>;
+    private buildTaskBody;
+    /** @internal */
+    request<T>(method: string, path: string, options?: {
+        body?: unknown;
+        idempotencyKey?: string;
+    }): Promise<T>;
+}
+declare class Tasks {
+    private client;
+    constructor(client: Runlater);
+    list(options?: ListOptions): Promise<ListResponse<Task>>;
+    get(id: string): Promise<Task>;
+    delete(id: string): Promise<void>;
+    trigger(id: string): Promise<TriggerResponse>;
+    executions(id: string, limit?: number): Promise<Execution[]>;
+}
+declare class Monitors {
+    private client;
+    constructor(client: Runlater);
+    list(): Promise<Monitor[]>;
+    get(id: string): Promise<Monitor>;
+    create(options: CreateMonitorOptions): Promise<Monitor>;
+    delete(id: string): Promise<void>;
+}
+
+export { type CreateMonitorOptions, type CronOptions, type CronResponse, type DelayOptions, type Execution, type ListOptions, type ListResponse, type Monitor, Runlater, RunlaterError, type RunlaterOptions, type ScheduleOptions, type SendOptions, type SyncOptions, type SyncResponse, type Task, type TaskResponse, type TriggerResponse };

package/dist/index.d.ts

@@ -0,0 +1,239 @@
+interface RunlaterOptions {
+    apiKey: string;
+    baseUrl?: string;
+}
+interface SendOptions {
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    headers?: Record<string, string>;
+    body?: unknown;
+    retries?: number;
+    timeout?: number;
+    queue?: string;
+    callback?: string;
+    idempotencyKey?: string;
+}
+interface DelayOptions extends SendOptions {
+    delay: string | number;
+}
+interface ScheduleOptions extends SendOptions {
+    at: string | Date;
+}
+interface CronOptions {
+    url: string;
+    schedule: string;
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    headers?: Record<string, string>;
+    body?: unknown;
+    timeout?: number;
+    retries?: number;
+    queue?: string;
+    callback?: string;
+    enabled?: boolean;
+}
+interface TaskResponse {
+    task_id: string;
+    execution_id: string;
+    status: string;
+    scheduled_for: string;
+}
+interface CronResponse {
+    id: string;
+    name: string;
+    url: string;
+    method: string;
+    cron_expression: string;
+    enabled: boolean;
+    next_run_at: string | null;
+    inserted_at: string;
+    updated_at: string;
+}
+interface Task {
+    id: string;
+    name: string;
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body: string | null;
+    schedule_type: string;
+    cron_expression: string | null;
+    scheduled_at: string | null;
+    enabled: boolean;
+    muted: boolean;
+    timeout_ms: number;
+    retry_attempts: number;
+    callback_url: string | null;
+    queue: string | null;
+    next_run_at: string | null;
+    inserted_at: string;
+    updated_at: string;
+}
+interface Execution {
+    id: string;
+    status: "pending" | "running" | "success" | "failed" | "timeout";
+    scheduled_for: string;
+    started_at: string | null;
+    finished_at: string | null;
+    status_code: number | null;
+    duration_ms: number | null;
+    error_message: string | null;
+    attempt: number;
+}
+interface ListOptions {
+    queue?: string;
+    limit?: number;
+    offset?: number;
+}
+interface ListResponse<T> {
+    data: T[];
+    has_more: boolean;
+    limit: number;
+    offset: number;
+}
+interface TriggerResponse {
+    execution_id: string;
+    status: string;
+    scheduled_for: string;
+}
+interface Monitor {
+    id: string;
+    name: string;
+    ping_token: string;
+    ping_url: string;
+    schedule_type: "cron" | "interval";
+    cron_expression: string | null;
+    interval_seconds: number | null;
+    grace_period_seconds: number;
+    status: "new" | "up" | "down" | "paused";
+    enabled: boolean;
+    muted: boolean;
+    last_ping_at: string | null;
+    next_expected_at: string | null;
+    inserted_at: string;
+    updated_at: string;
+}
+interface CreateMonitorOptions {
+    name: string;
+    schedule: string;
+    interval?: number;
+    grace?: number;
+    enabled?: boolean;
+}
+interface SyncOptions {
+    tasks?: CronOptions[];
+    monitors?: CreateMonitorOptions[];
+    deleteRemoved?: boolean;
+}
+interface SyncResponse {
+    tasks: {
+        created: string[];
+        updated: string[];
+        deleted: string[];
+    };
+    monitors: {
+        created: string[];
+        updated: string[];
+        deleted: string[];
+    };
+    created_count: number;
+    updated_count: number;
+    deleted_count: number;
+}
+declare class RunlaterError extends Error {
+    status: number;
+    code: string;
+    constructor(status: number, code: string, message: string);
+}
+
+declare class Runlater {
+    private apiKey;
+    private baseUrl;
+    tasks: Tasks;
+    monitors: Monitors;
+    constructor(options: RunlaterOptions | string);
+    /**
+     * Send a request immediately with reliable delivery and retries.
+     *
+     * ```js
+     * await rl.send("https://myapp.com/api/process", {
+     *   body: { orderId: 123 },
+     *   retries: 5
+     * })
+     * ```
+     */
+    send(url: string, options?: SendOptions): Promise<TaskResponse>;
+    /**
+     * Execute a request after a delay.
+     *
+     * ```js
+     * await rl.delay("https://myapp.com/api/remind", {
+     *   delay: "10m",
+     *   body: { userId: 456 }
+     * })
+     * ```
+     *
+     * Delay accepts:
+     * - Strings: "30s", "5m", "2h", "1d"
+     * - Numbers: seconds (e.g. 3600 for 1 hour)
+     */
+    delay(url: string, options: DelayOptions): Promise<TaskResponse>;
+    /**
+     * Execute a request at a specific time.
+     *
+     * ```js
+     * await rl.schedule("https://myapp.com/api/expire", {
+     *   at: "2026-03-15T09:00:00Z",
+     *   body: { trialId: 789 }
+     * })
+     * ```
+     */
+    schedule(url: string, options: ScheduleOptions): Promise<TaskResponse>;
+    /**
+     * Create or update a recurring cron task.
+     *
+     * ```js
+     * await rl.cron("daily-report", {
+     *   url: "https://myapp.com/api/report",
+     *   schedule: "0 9 * * *"
+     * })
+     * ```
+     */
+    cron(name: string, options: CronOptions): Promise<CronResponse>;
+    /**
+     * Declaratively sync tasks and monitors. Matched by name.
+     *
+     * ```js
+     * await rl.sync({
+     *   tasks: [
+     *     { name: "daily-report", url: "https://...", schedule: "0 9 * * *" }
+     *   ],
+     *   deleteRemoved: true
+     * })
+     * ```
+     */
+    sync(options: SyncOptions): Promise<SyncResponse>;
+    private buildTaskBody;
+    /** @internal */
+    request<T>(method: string, path: string, options?: {
+        body?: unknown;
+        idempotencyKey?: string;
+    }): Promise<T>;
+}
+declare class Tasks {
+    private client;
+    constructor(client: Runlater);
+    list(options?: ListOptions): Promise<ListResponse<Task>>;
+    get(id: string): Promise<Task>;
+    delete(id: string): Promise<void>;
+    trigger(id: string): Promise<TriggerResponse>;
+    executions(id: string, limit?: number): Promise<Execution[]>;
+}
+declare class Monitors {
+    private client;
+    constructor(client: Runlater);
+    list(): Promise<Monitor[]>;
+    get(id: string): Promise<Monitor>;
+    create(options: CreateMonitorOptions): Promise<Monitor>;
+    delete(id: string): Promise<void>;
+}
+
+export { type CreateMonitorOptions, type CronOptions, type CronResponse, type DelayOptions, type Execution, type ListOptions, type ListResponse, type Monitor, Runlater, RunlaterError, type RunlaterOptions, type ScheduleOptions, type SendOptions, type SyncOptions, type SyncResponse, type Task, type TaskResponse, type TriggerResponse };

package/dist/index.js

@@ -0,0 +1,309 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Runlater: () => Runlater,
+  RunlaterError: () => RunlaterError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var RunlaterError = class extends Error {
+  status;
+  code;
+  constructor(status, code, message) {
+    super(message);
+    this.name = "RunlaterError";
+    this.status = status;
+    this.code = code;
+  }
+};
+
+// src/index.ts
+var DEFAULT_BASE_URL = "https://runlater.eu";
+var Runlater = class {
+  apiKey;
+  baseUrl;
+  tasks;
+  monitors;
+  constructor(options) {
+    if (typeof options === "string") {
+      this.apiKey = options;
+      this.baseUrl = DEFAULT_BASE_URL;
+    } else {
+      this.apiKey = options.apiKey;
+      this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    }
+    this.tasks = new Tasks(this);
+    this.monitors = new Monitors(this);
+  }
+  /**
+   * Send a request immediately with reliable delivery and retries.
+   *
+   * ```js
+   * await rl.send("https://myapp.com/api/process", {
+   *   body: { orderId: 123 },
+   *   retries: 5
+   * })
+   * ```
+   */
+  async send(url, options = {}) {
+    const res = await this.request("POST", "/tasks", {
+      body: this.buildTaskBody(url, options),
+      idempotencyKey: options.idempotencyKey
+    });
+    return res.data;
+  }
+  /**
+   * Execute a request after a delay.
+   *
+   * ```js
+   * await rl.delay("https://myapp.com/api/remind", {
+   *   delay: "10m",
+   *   body: { userId: 456 }
+   * })
+   * ```
+   *
+   * Delay accepts:
+   * - Strings: "30s", "5m", "2h", "1d"
+   * - Numbers: seconds (e.g. 3600 for 1 hour)
+   */
+  async delay(url, options) {
+    const res = await this.request("POST", "/tasks", {
+      body: {
+        ...this.buildTaskBody(url, options),
+        delay: formatDelay(options.delay)
+      },
+      idempotencyKey: options.idempotencyKey
+    });
+    return res.data;
+  }
+  /**
+   * Execute a request at a specific time.
+   *
+   * ```js
+   * await rl.schedule("https://myapp.com/api/expire", {
+   *   at: "2026-03-15T09:00:00Z",
+   *   body: { trialId: 789 }
+   * })
+   * ```
+   */
+  async schedule(url, options) {
+    const at = options.at instanceof Date ? options.at.toISOString() : options.at;
+    const res = await this.request("POST", "/tasks", {
+      body: {
+        ...this.buildTaskBody(url, options),
+        run_at: at
+      },
+      idempotencyKey: options.idempotencyKey
+    });
+    return res.data;
+  }
+  /**
+   * Create or update a recurring cron task.
+   *
+   * ```js
+   * await rl.cron("daily-report", {
+   *   url: "https://myapp.com/api/report",
+   *   schedule: "0 9 * * *"
+   * })
+   * ```
+   */
+  async cron(name, options) {
+    const res = await this.request("POST", "/tasks", {
+      body: {
+        name,
+        url: options.url,
+        method: options.method ?? "GET",
+        cron: options.schedule,
+        headers: options.headers,
+        body: options.body != null ? JSON.stringify(options.body) : void 0,
+        timeout_ms: options.timeout,
+        retry_attempts: options.retries,
+        queue: options.queue,
+        callback_url: options.callback,
+        enabled: options.enabled
+      }
+    });
+    return res.data;
+  }
+  /**
+   * Declaratively sync tasks and monitors. Matched by name.
+   *
+   * ```js
+   * await rl.sync({
+   *   tasks: [
+   *     { name: "daily-report", url: "https://...", schedule: "0 9 * * *" }
+   *   ],
+   *   deleteRemoved: true
+   * })
+   * ```
+   */
+  async sync(options) {
+    const body = {};
+    if (options.tasks) {
+      body.tasks = options.tasks.map((t) => ({
+        name: t.url,
+        // name defaults to url if not in CronOptions
+        url: t.url,
+        method: t.method ?? "GET",
+        schedule_type: "cron",
+        cron_expression: t.schedule,
+        headers: t.headers,
+        body: t.body != null ? JSON.stringify(t.body) : void 0,
+        timeout_ms: t.timeout,
+        retry_attempts: t.retries,
+        queue: t.queue,
+        callback_url: t.callback,
+        enabled: t.enabled
+      }));
+    }
+    if (options.monitors) {
+      body.monitors = options.monitors.map((m) => ({
+        name: m.name,
+        schedule_type: m.interval ? "interval" : "cron",
+        cron_expression: m.schedule,
+        interval_seconds: m.interval,
+        grace_period_seconds: m.grace,
+        enabled: m.enabled
+      }));
+    }
+    if (options.deleteRemoved) {
+      body.delete_removed = true;
+    }
+    const res = await this.request("PUT", "/sync", { body });
+    return res.data;
+  }
+  // --- Internal ---
+  buildTaskBody(url, options) {
+    return {
+      url,
+      method: options.method ?? "POST",
+      headers: options.headers,
+      body: options.body != null ? JSON.stringify(options.body) : void 0,
+      timeout_ms: options.timeout,
+      retry_attempts: options.retries,
+      queue: options.queue,
+      callback_url: options.callback
+    };
+  }
+  /** @internal */
+  async request(method, path, options = {}) {
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      "User-Agent": "runlater-node/0.1.0"
+    };
+    if (options.idempotencyKey) {
+      headers["Idempotency-Key"] = options.idempotencyKey;
+    }
+    const response = await fetch(`${this.baseUrl}/api/v1${path}`, {
+      method,
+      headers,
+      body: options.body != null ? JSON.stringify(options.body) : void 0
+    });
+    if (!response.ok) {
+      const errorBody = await response.json().catch(() => ({}));
+      const error = errorBody.error;
+      throw new RunlaterError(
+        response.status,
+        error?.code ?? "unknown_error",
+        error?.message ?? `HTTP ${response.status}`
+      );
+    }
+    if (response.status === 204) {
+      return {};
+    }
+    return await response.json();
+  }
+};
+var Tasks = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.queue != null) params.set("queue", options.queue);
+    if (options.limit != null) params.set("limit", String(options.limit));
+    if (options.offset != null) params.set("offset", String(options.offset));
+    const query = params.toString();
+    return this.client.request("GET", `/tasks${query ? `?${query}` : ""}`);
+  }
+  async get(id) {
+    const res = await this.client.request("GET", `/tasks/${id}`);
+    return res.data;
+  }
+  async delete(id) {
+    await this.client.request("DELETE", `/tasks/${id}`);
+  }
+  async trigger(id) {
+    const res = await this.client.request(
+      "POST",
+      `/tasks/${id}/trigger`
+    );
+    return res.data;
+  }
+  async executions(id, limit = 50) {
+    const res = await this.client.request(
+      "GET",
+      `/tasks/${id}/executions?limit=${limit}`
+    );
+    return res.data;
+  }
+};
+var Monitors = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    const res = await this.client.request("GET", "/monitors");
+    return res.data;
+  }
+  async get(id) {
+    const res = await this.client.request("GET", `/monitors/${id}`);
+    return res.data;
+  }
+  async create(options) {
+    const res = await this.client.request("POST", "/monitors", {
+      body: {
+        name: options.name,
+        schedule_type: options.interval ? "interval" : "cron",
+        cron_expression: options.schedule,
+        interval_seconds: options.interval,
+        grace_period_seconds: options.grace,
+        enabled: options.enabled
+      }
+    });
+    return res.data;
+  }
+  async delete(id) {
+    await this.client.request("DELETE", `/monitors/${id}`);
+  }
+};
+function formatDelay(delay) {
+  if (typeof delay === "number") return `${delay}s`;
+  return delay;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Runlater,
+  RunlaterError
+});

package/dist/index.mjs

@@ -0,0 +1,281 @@
+// src/types.ts
+var RunlaterError = class extends Error {
+  status;
+  code;
+  constructor(status, code, message) {
+    super(message);
+    this.name = "RunlaterError";
+    this.status = status;
+    this.code = code;
+  }
+};
+
+// src/index.ts
+var DEFAULT_BASE_URL = "https://runlater.eu";
+var Runlater = class {
+  apiKey;
+  baseUrl;
+  tasks;
+  monitors;
+  constructor(options) {
+    if (typeof options === "string") {
+      this.apiKey = options;
+      this.baseUrl = DEFAULT_BASE_URL;
+    } else {
+      this.apiKey = options.apiKey;
+      this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    }
+    this.tasks = new Tasks(this);
+    this.monitors = new Monitors(this);
+  }
+  /**
+   * Send a request immediately with reliable delivery and retries.
+   *
+   * ```js
+   * await rl.send("https://myapp.com/api/process", {
+   *   body: { orderId: 123 },
+   *   retries: 5
+   * })
+   * ```
+   */
+  async send(url, options = {}) {
+    const res = await this.request("POST", "/tasks", {
+      body: this.buildTaskBody(url, options),
+      idempotencyKey: options.idempotencyKey
+    });
+    return res.data;
+  }
+  /**
+   * Execute a request after a delay.
+   *
+   * ```js
+   * await rl.delay("https://myapp.com/api/remind", {
+   *   delay: "10m",
+   *   body: { userId: 456 }
+   * })
+   * ```
+   *
+   * Delay accepts:
+   * - Strings: "30s", "5m", "2h", "1d"
+   * - Numbers: seconds (e.g. 3600 for 1 hour)
+   */
+  async delay(url, options) {
+    const res = await this.request("POST", "/tasks", {
+      body: {
+        ...this.buildTaskBody(url, options),
+        delay: formatDelay(options.delay)
+      },
+      idempotencyKey: options.idempotencyKey
+    });
+    return res.data;
+  }
+  /**
+   * Execute a request at a specific time.
+   *
+   * ```js
+   * await rl.schedule("https://myapp.com/api/expire", {
+   *   at: "2026-03-15T09:00:00Z",
+   *   body: { trialId: 789 }
+   * })
+   * ```
+   */
+  async schedule(url, options) {
+    const at = options.at instanceof Date ? options.at.toISOString() : options.at;
+    const res = await this.request("POST", "/tasks", {
+      body: {
+        ...this.buildTaskBody(url, options),
+        run_at: at
+      },
+      idempotencyKey: options.idempotencyKey
+    });
+    return res.data;
+  }
+  /**
+   * Create or update a recurring cron task.
+   *
+   * ```js
+   * await rl.cron("daily-report", {
+   *   url: "https://myapp.com/api/report",
+   *   schedule: "0 9 * * *"
+   * })
+   * ```
+   */
+  async cron(name, options) {
+    const res = await this.request("POST", "/tasks", {
+      body: {
+        name,
+        url: options.url,
+        method: options.method ?? "GET",
+        cron: options.schedule,
+        headers: options.headers,
+        body: options.body != null ? JSON.stringify(options.body) : void 0,
+        timeout_ms: options.timeout,
+        retry_attempts: options.retries,
+        queue: options.queue,
+        callback_url: options.callback,
+        enabled: options.enabled
+      }
+    });
+    return res.data;
+  }
+  /**
+   * Declaratively sync tasks and monitors. Matched by name.
+   *
+   * ```js
+   * await rl.sync({
+   *   tasks: [
+   *     { name: "daily-report", url: "https://...", schedule: "0 9 * * *" }
+   *   ],
+   *   deleteRemoved: true
+   * })
+   * ```
+   */
+  async sync(options) {
+    const body = {};
+    if (options.tasks) {
+      body.tasks = options.tasks.map((t) => ({
+        name: t.url,
+        // name defaults to url if not in CronOptions
+        url: t.url,
+        method: t.method ?? "GET",
+        schedule_type: "cron",
+        cron_expression: t.schedule,
+        headers: t.headers,
+        body: t.body != null ? JSON.stringify(t.body) : void 0,
+        timeout_ms: t.timeout,
+        retry_attempts: t.retries,
+        queue: t.queue,
+        callback_url: t.callback,
+        enabled: t.enabled
+      }));
+    }
+    if (options.monitors) {
+      body.monitors = options.monitors.map((m) => ({
+        name: m.name,
+        schedule_type: m.interval ? "interval" : "cron",
+        cron_expression: m.schedule,
+        interval_seconds: m.interval,
+        grace_period_seconds: m.grace,
+        enabled: m.enabled
+      }));
+    }
+    if (options.deleteRemoved) {
+      body.delete_removed = true;
+    }
+    const res = await this.request("PUT", "/sync", { body });
+    return res.data;
+  }
+  // --- Internal ---
+  buildTaskBody(url, options) {
+    return {
+      url,
+      method: options.method ?? "POST",
+      headers: options.headers,
+      body: options.body != null ? JSON.stringify(options.body) : void 0,
+      timeout_ms: options.timeout,
+      retry_attempts: options.retries,
+      queue: options.queue,
+      callback_url: options.callback
+    };
+  }
+  /** @internal */
+  async request(method, path, options = {}) {
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      "User-Agent": "runlater-node/0.1.0"
+    };
+    if (options.idempotencyKey) {
+      headers["Idempotency-Key"] = options.idempotencyKey;
+    }
+    const response = await fetch(`${this.baseUrl}/api/v1${path}`, {
+      method,
+      headers,
+      body: options.body != null ? JSON.stringify(options.body) : void 0
+    });
+    if (!response.ok) {
+      const errorBody = await response.json().catch(() => ({}));
+      const error = errorBody.error;
+      throw new RunlaterError(
+        response.status,
+        error?.code ?? "unknown_error",
+        error?.message ?? `HTTP ${response.status}`
+      );
+    }
+    if (response.status === 204) {
+      return {};
+    }
+    return await response.json();
+  }
+};
+var Tasks = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.queue != null) params.set("queue", options.queue);
+    if (options.limit != null) params.set("limit", String(options.limit));
+    if (options.offset != null) params.set("offset", String(options.offset));
+    const query = params.toString();
+    return this.client.request("GET", `/tasks${query ? `?${query}` : ""}`);
+  }
+  async get(id) {
+    const res = await this.client.request("GET", `/tasks/${id}`);
+    return res.data;
+  }
+  async delete(id) {
+    await this.client.request("DELETE", `/tasks/${id}`);
+  }
+  async trigger(id) {
+    const res = await this.client.request(
+      "POST",
+      `/tasks/${id}/trigger`
+    );
+    return res.data;
+  }
+  async executions(id, limit = 50) {
+    const res = await this.client.request(
+      "GET",
+      `/tasks/${id}/executions?limit=${limit}`
+    );
+    return res.data;
+  }
+};
+var Monitors = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    const res = await this.client.request("GET", "/monitors");
+    return res.data;
+  }
+  async get(id) {
+    const res = await this.client.request("GET", `/monitors/${id}`);
+    return res.data;
+  }
+  async create(options) {
+    const res = await this.client.request("POST", "/monitors", {
+      body: {
+        name: options.name,
+        schedule_type: options.interval ? "interval" : "cron",
+        cron_expression: options.schedule,
+        interval_seconds: options.interval,
+        grace_period_seconds: options.grace,
+        enabled: options.enabled
+      }
+    });
+    return res.data;
+  }
+  async delete(id) {
+    await this.client.request("DELETE", `/monitors/${id}`);
+  }
+};
+function formatDelay(delay) {
+  if (typeof delay === "number") return `${delay}s`;
+  return delay;
+}
+export {
+  Runlater,
+  RunlaterError
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "runlater-js",
+  "version": "0.1.0",
+  "description": "Delayed tasks, cron jobs, and reliable webhooks. No infrastructure required.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  },
+  "keywords": [
+    "cron",
+    "queue",
+    "task",
+    "webhook",
+    "delay",
+    "scheduler",
+    "background-jobs",
+    "serverless"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/runlater-eu/runlater-js"
+  },
+  "homepage": "https://runlater.eu",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}