@tuzelko/opencode-delayed-message 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eugene Frost
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,127 @@
-# Temporary Holding Version
+<div align="center">
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# ⏰ opencode-delayed-message
+
+**Schedule a message that wakes the session later — without putting it in the prompt now.**
+
+[![npm](https://img.shields.io/npm/v/@tuzelko/opencode-delayed-message?style=flat-square&color=CB3837&logo=npm)](https://www.npmjs.com/package/@tuzelko/opencode-delayed-message)
+[![downloads](https://img.shields.io/npm/dm/@tuzelko/opencode-delayed-message?style=flat-square)](https://www.npmjs.com/package/@tuzelko/opencode-delayed-message)
+[![license](https://img.shields.io/github/license/TuzelKO/opencode-delayed-message?style=flat-square)](./LICENSE)
+[![OpenCode V2](https://img.shields.io/badge/OpenCode-V2-5B8DEF?style=flat-square)](https://opencode.ai)
+[![desktop UI](https://img.shields.io/badge/UI-desktop-8B5CF6?style=flat-square)](https://opencode.ai)
+
+</div>
+
+---
+
+`/delayed-message` schedules a message for a future time and delivers it as a normal user
+message. The trick: the text never enters the model context at scheduling time. The model
+sees it only when it arrives.
+
+Built for "remind me at 3:00" without trusting the model to remember — and without leaking
+the text into the conversation early.
+
+## ✨ Features
+
+- 🕰️ **Say it your way** — `HH:MM`, an absolute date, or a relative duration.
+- 🔒 **Private until delivery** — the text lives in plugin storage, not in the prompt.
+- 💾 **Durable** — jobs survive a service restart; timers re-arm from storage.
+- 🪟 **Desktop pill** — pending count and time above the composer, with a preview and a
+  cancel button.
+- 🤫 **Zero model turns on schedule** — a successful schedule does not wake the model.
+- 🌍 **Localized UI** — English, Russian, German, French, Chinese.
+
+## 📦 Install
+
+```sh
+opencode plugin add @tuzelko/opencode-delayed-message
+```
+
+Or straight from Git:
+
+```sh
+opencode plugin add github:TuzelKO/opencode-delayed-message
+```
+
+Requires OpenCode V2. The pill is part of the desktop app; the command itself works anywhere.
+
+## 🚀 Usage
+
+```text
+/delayed-message 03:00 call mom
+/delayed-message 2026-11-05 03:00 check the deploy
+/delayed-message +30m stretch
+```
+
+| Time | Meaning |
+| --- | --- |
+| `HH:MM` / `H:MM` | the next occurrence; if it already passed today, tomorrow |
+| `YYYY-MM-DD HH:MM` | absolute local time; a past time is refused |
+| `YYYY-MM-DDTHH:MM` | same, ISO form without the space |
+| `+30s`, `+30m`, `+2h`, `+1d` | relative to now |
+
+The first token is the time; everything after it is the message, taken verbatim.
+
+## 🔒 Privacy
+
+The command is a native plugin command: its executor receives the raw arguments and stores
+the message in OpenCode's plugin storage. It is not submitted as a prompt, so the model
+cannot read it at scheduling time.
+
+At the scheduled moment the plugin calls `session.prompt` with the stored text, and it
+arrives as a normal user message.
+
+The honest caveat: the text is stored on disk in OpenCode's database. The model does not get
+it through the prompt, but an agent with shell access to the machine could read the storage.
+Treat this as a prompt-level guarantee, not encryption.
+
+## 🪟 The desktop pill
+
+Above the composer, while a message is pending:
+
+```text
+⏰ Scheduled · 10:18
+```
+
+Click it for the list: time, relative countdown, a preview of the text, and `×` to cancel.
+The pill disappears when the message is delivered or cancelled. The terminal UI has no pill —
+there the transcript note is the only trace.
+
+The pill follows the app language: English, Russian, German, French, and Chinese are
+included. Transcript notes are English, because they are written for the model.
+
+## 💾 Durability
+
+Jobs are kept in the plugin's storage, not only in memory. After `opencode reload` or a
+service restart, timers are re-armed when the plugin loads for that directory. If the
+service is down at the scheduled moment, the message is delivered on the next start.
+
+## 🧠 How it works
+
+- `ctx.command.transform` registers `/delayed-message`; the executor gets the raw text
+  outside the prompt.
+- The job goes to `ctx.storage` (`pending/<uuid>`) and a `setTimeout` chain, split at the
+  24.8-day timer cap.
+- On fire: `ctx.session.prompt({ sessionID, text })` — a real user prompt, so the session
+  wakes.
+- The GUI talks to the server through an RPC: `pending`, `cancel`, and the events
+  `scheduled`, `fired`, `cancelled`.
+
+## 🛠 Development
+
+```sh
+npm install
+npm run build   # emits gui-experimental.cjs
+```
+
+Point OpenCode at the checkout while developing:
+
+```jsonc
+{
+  "plugins": ["/path/to/opencode-delayed-message"]
+}
+```
+
+## 📄 License
+
+MIT © Eugene Frost

package/gui-experimental.cjs

@@ -0,0 +1,11 @@
+Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}});let e=require("solid-js/web"),t=require("solid-js"),n=require("@opencode/plugin/gui");var r=require("@opencode/plugin/rpc").Rpc.define({id:`delayed-message`,methods:{pending:{input:{type:`object`,properties:{sessionID:{type:`string`}},required:[`sessionID`],additionalProperties:!1},output:{type:`object`,properties:{jobs:{type:`array`,items:{type:`object`,properties:{id:{type:`string`},fireAt:{type:`number`},preview:{type:`string`}},required:[`id`,`fireAt`,`preview`],additionalProperties:!1}}},required:[`jobs`],additionalProperties:!1}},cancel:{input:{type:`object`,properties:{sessionID:{type:`string`},id:{type:`string`}},required:[`sessionID`,`id`],additionalProperties:!1},output:{type:`object`,properties:{ok:{type:`boolean`}},required:[`ok`],additionalProperties:!1}}},events:{scheduled:{schema:{type:`object`,properties:{sessionID:{type:`string`},id:{type:`string`},fireAt:{type:`number`},preview:{type:`string`}},required:[`sessionID`,`id`,`fireAt`,`preview`],additionalProperties:!1}},fired:{schema:{type:`object`,properties:{sessionID:{type:`string`},id:{type:`string`}},required:[`sessionID`,`id`],additionalProperties:!1}},cancelled:{schema:{type:`object`,properties:{sessionID:{type:`string`},id:{type:`string`}},required:[`sessionID`,`id`],additionalProperties:!1}}}}),i=(0,e.template)(`<div class=dm>`),a=(0,e.template)(`<div class=dm-row><div class=dm-body><div class=dm-when><span></span><span class=dm-left></span></div><div class=dm-text></div></div><button class=dm-x>×`),o=`
+.dm { display: flex; flex-direction: column; min-width: 280px; max-width: 440px; }
+.dm-row { display: flex; align-items: center; gap: 8px; padding: 8px 2px; }
+.dm-row + .dm-row { border-top: 1px solid color-mix(in srgb, currentColor 12%, transparent); }
+.dm-body { flex: 1; min-width: 0; }
+.dm-when { display: flex; align-items: baseline; gap: 8px; font-variant-numeric: tabular-nums; }
+.dm-left { opacity: .55; font-size: 12px; white-space: nowrap; }
+.dm-text { opacity: .72; font-size: 12px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.dm-x { flex: none; width: 22px; height: 22px; border: 0; border-radius: 6px; background: transparent; color: inherit; opacity: .45; cursor: pointer; font: inherit; line-height: 1; }
+.dm-x:hover { opacity: 1; background: color-mix(in srgb, currentColor 14%, transparent); }
+`,s=n.Plugin.define({i18n:{en:{"pill.one":`Scheduled · {{time}}`,"pill.many":`Scheduled: {{count}}`,"menu.title":`Scheduled messages`,"row.cancel":`Cancel`,"left.now":`now`,"left.days":`in {{days}}d {{hours}}h`,"left.hours":`in {{hours}}h {{minutes}}m`,"left.minutes":`in {{minutes}}m`},ru:{"pill.one":`Отложенное · {{time}}`,"pill.many":`Отложенных: {{count}}`,"menu.title":`Отложенные сообщения`,"row.cancel":`Отменить`,"left.now":`сейчас`,"left.days":`через {{days}} д {{hours}} ч`,"left.hours":`через {{hours}} ч {{minutes}} мин`,"left.minutes":`через {{minutes}} мин`},de:{"pill.one":`Geplant · {{time}}`,"pill.many":`Geplant: {{count}}`,"menu.title":`Geplante Nachrichten`,"row.cancel":`Abbrechen`,"left.now":`jetzt`,"left.days":`in {{days}} T {{hours}} Std.`,"left.hours":`in {{hours}} Std. {{minutes}} Min.`,"left.minutes":`in {{minutes}} Min.`},fr:{"pill.one":`Programmé · {{time}}`,"pill.many":`Programmés : {{count}}`,"menu.title":`Messages programmés`,"row.cancel":`Annuler`,"left.now":`maintenant`,"left.days":`dans {{days}} j {{hours}} h`,"left.hours":`dans {{hours}} h {{minutes}} min`,"left.minutes":`dans {{minutes}} min`},zh:{"pill.one":`已安排 · {{time}}`,"pill.many":`已安排：{{count}}`,"menu.title":`已安排的消息`,"row.cancel":`取消`,"left.now":`现在`,"left.days":`还有 {{days}} 天 {{hours}} 小时`,"left.hours":`还有 {{hours}} 小时 {{minutes}} 分钟`,"left.minutes":`还有 {{minutes}} 分钟`}},setup(s){let[c,l]=(0,t.createSignal)({}),u=(e,t)=>l(n=>({...n,[e]:[...(n[e]??[]).filter(e=>e.id!==t.id),t].sort((e,t)=>e.fireAt-t.fireAt)})),d=(e,t)=>l(n=>({...n,[e]:(n[e]??[]).filter(e=>e.id!==t)})),f=e=>new Date(e).toLocaleTimeString(s.locale.locale(),{hour:`2-digit`,minute:`2-digit`}),p=e=>new Date(e).toLocaleDateString(s.locale.locale(),{day:`2-digit`,month:`2-digit`}),m=e=>{let t=new Date(e),n=new Date,r=f(e);return t.toDateString()===n.toDateString()?r:`${p(e)} ${r}`},h=e=>{let t=e-Date.now();if(t<=0)return s.t(`left.now`);let n=Math.ceil(t/6e4),r=Math.floor(n/60),i=Math.floor(r/24);return i>0?s.t(`left.days`,{days:i,hours:r%24}):r>0?s.t(`left.hours`,{hours:r,minutes:n%60}):s.t(`left.minutes`,{minutes:n})},g=s.client.rpc(r);g.events.on(`scheduled`,e=>{u(e.data.sessionID,{id:e.data.id,fireAt:e.data.fireAt,preview:e.data.preview})}),g.events.on(`fired`,e=>{d(e.data.sessionID,e.data.id)}),g.events.on(`cancelled`,e=>{d(e.data.sessionID,e.data.id)});let _=async(e,t)=>{try{let{ok:n}=await g.cancel({sessionID:e,id:t});n&&d(e,t)}catch{}};(0,n.createKeyed)(()=>s.sessions.current()?.id,e=>{g.pending({sessionID:e}).then(({jobs:t})=>l(n=>({...n,[e]:t}))).catch(()=>{})}),s.add(n.Style,o),s.add(n.ComposerPill,{id:`pending`,show(e){let t=c()[e.session.id]??[];if(t.length!==0)return{label:t.length===1?s.t(`pill.one`,{time:f(t[0].fireAt)}):s.t(`pill.many`,{count:t.length}),icon:`notifications`,title:s.t(`menu.title`)}},menu:n=>(()=>{var r=i();return(0,e.insert)(r,(0,e.createComponent)(t.For,{get each(){return c()[n.session.id]??[]},children:t=>(()=>{var r=a(),i=r.firstChild,o=i.firstChild,c=o.firstChild,l=c.nextSibling,u=o.nextSibling,d=i.nextSibling;return(0,e.insert)(c,()=>m(t.fireAt)),(0,e.insert)(l,()=>h(t.fireAt)),(0,e.insert)(u,()=>t.preview),d.$$click=()=>void _(n.session.id,t.id),(0,e.effect)(t=>{var n=s.t(`row.cancel`),r=s.t(`row.cancel`);return n!==t.e&&(0,e.setAttribute)(d,`title`,t.e=n),r!==t.t&&(0,e.setAttribute)(d,`aria-label`,t.t=r),t},{e:void 0,t:void 0}),r})()})),r})()})}});(0,e.delegateEvents)([`click`]),exports.default=s;

package/index.ts

@@ -0,0 +1,215 @@
+import { Plugin } from "@opencode/plugin"
+import { Delayed } from "./rpc"
+
+// /delayed-message <time> <message>
+//
+// The command is registered by the plugin, so the message never becomes a user
+// prompt at scheduling time: it stays inside `execute` and the model sees it
+// only when the timer delivers it as a real user prompt.
+
+type Job = {
+  id: string
+  sessionID: string
+  message: string
+  fireAt: number
+  directory: string
+}
+
+const MAX_TIMER = 2 ** 31 - 1
+const UNIT_MS: Record<string, number> = { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }
+
+// Setup can run more than once per directory; only the first timer may deliver.
+const claimed = new Set<string>()
+
+const key = (id: string) => `pending/${id}`
+
+const resolveTime = (raw: string, now: number): number | string => {
+  const relative = /^\+(\d+)([smhd])$/.exec(raw)
+  if (relative) return now + Number(relative[1]) * UNIT_MS[relative[2]]
+
+  const clock = /^(\d{1,2}):(\d{2})(?::(\d{2}))?$/.exec(raw)
+  if (clock) {
+    const hours = Number(clock[1])
+    const minutes = Number(clock[2])
+    const seconds = Number(clock[3] ?? 0)
+    if (hours > 23 || minutes > 59 || seconds > 59) return `invalid clock time: ${raw}`
+    const at = new Date(now)
+    at.setHours(hours, minutes, seconds, 0)
+    if (at.getTime() <= now) at.setDate(at.getDate() + 1)
+    return at.getTime()
+  }
+
+  const at = Date.parse(raw)
+  if (Number.isNaN(at)) return `cannot parse time: ${raw}`
+  if (at <= now) return `time is in the past: ${raw}`
+  return at
+}
+
+const stamp = (at: number) =>
+  `${new Date(at).toLocaleString("sv-SE", { hour12: false })} ${Intl.DateTimeFormat().resolvedOptions().timeZone}`
+
+const humanize = (ms: number) => {
+  const seconds = Math.max(0, Math.round(ms / 1000))
+  const days = Math.floor(seconds / 86_400)
+  const hours = Math.floor((seconds % 86_400) / 3_600)
+  const minutes = Math.floor((seconds % 3_600) / 60)
+  if (days > 0) return `${days}d ${hours}h`
+  if (hours > 0) return `${hours}h ${minutes}m`
+  return `${minutes}m`
+}
+
+const previewOf = (message: string) => message.replace(/\s+/g, " ").trim().slice(0, 120)
+
+export default Plugin.define({
+  id: "delayed-message",
+  async setup(ctx) {
+    const timers = new Map<string, ReturnType<typeof setTimeout>>()
+
+    const rpc = await ctx.rpc.register(Delayed, {
+      pending: async (input) => {
+        const { sessionID } = input as { sessionID: string }
+        const jobs: Array<{ id: string; fireAt: number; preview: string }> = []
+        let after: string | undefined
+        do {
+          const page = await ctx.storage.scan(after ? { prefix: "pending/", after } : { prefix: "pending/" })
+          for (const entry of page.entries) {
+            const job = entry.value as Job
+            if (job?.sessionID !== sessionID || !job.id || !job.fireAt) continue
+            jobs.push({ id: job.id, fireAt: job.fireAt, preview: previewOf(job.message) })
+          }
+          after = page.next
+        } while (after)
+        return { jobs }
+      },
+      cancel: async (input) => {
+        const { sessionID, id } = input as { sessionID: string; id: string }
+        if (claimed.has(id)) return { ok: false }
+        const stored = (await ctx.storage.get(key(id))) as Job | undefined
+        if (!stored || stored.sessionID !== sessionID) return { ok: false }
+        claimed.add(id)
+        const timer = timers.get(id)
+        if (timer) {
+          clearTimeout(timer)
+          timers.delete(id)
+        }
+        await ctx.storage.remove(key(id))
+        await rpc.events.emit("cancelled", { sessionID, id }).catch(() => {})
+        return { ok: true }
+      },
+    })
+
+    const deliver = async (job: Job) => {
+      timers.delete(job.id)
+      if (claimed.has(job.id)) return
+      claimed.add(job.id)
+      try {
+        if (!(await ctx.storage.get(key(job.id)))) return
+        await ctx.storage.remove(key(job.id))
+        await ctx.session.prompt({ sessionID: job.sessionID, text: job.message })
+      } catch (error) {
+        console.error(`[delayed-message] delivery failed for ${job.id}:`, error)
+      } finally {
+        await rpc.events.emit("fired", { sessionID: job.sessionID, id: job.id }).catch(() => {})
+      }
+    }
+
+    // setTimeout caps at MAX_TIMER, so long waits are split into hops.
+    const arm = (job: Job) => {
+      const delay = job.fireAt - Date.now()
+      if (delay <= 0) {
+        void deliver(job)
+        return
+      }
+      const timer = setTimeout(() => {
+        timers.delete(job.id)
+        arm(job)
+      }, Math.min(delay, MAX_TIMER - 1))
+      timers.set(job.id, timer)
+    }
+
+    // The GUI pill is the immediate feedback; the note is only a transcript
+    // record, so it waits for the next turn instead of waking the model.
+    const note = (sessionID: string, text: string) =>
+      ctx.session.synthetic({ sessionID, text, resume: false }).catch(() => {})
+
+    // Errors have no pill to lean on, so they drain at once.
+    const alert = (sessionID: string, text: string) =>
+      ctx.session.synthetic({ sessionID, text, resume: true }).catch(() => {})
+
+    await ctx.command.transform((editor) => {
+      editor.add({
+        name: "delayed-message",
+        description: "Wake this session later with a message",
+        execute: async ({ sessionID, prompt }) => {
+          try {
+            const raw = prompt.text.trim()
+            const first = /^(\S+)(?:\s+|$)/.exec(raw)
+            const when = first?.[1] ?? ""
+            let rest = raw.slice(first?.[0].length ?? 0)
+
+            let time = when
+            const second = /^(\S+)/.exec(rest)?.[1]
+            if (/^\d{4}-\d{2}-\d{2}$/.test(when) && second && /^\d{1,2}:\d{2}(:\d{2})?$/.test(second)) {
+              time = `${when}T${second}`
+              rest = rest.slice(second.length)
+            }
+
+            const message = rest.trim()
+            if (!time || !message) {
+              await alert(
+                sessionID,
+                "Usage: /delayed-message <time> <message>\n" +
+                  "Time: HH:MM, YYYY-MM-DDTHH:MM, or +30m / +2h / +1d.",
+              )
+              return
+            }
+
+            const now = Date.now()
+            const at = resolveTime(time, now)
+            if (typeof at === "string") {
+              await alert(sessionID, `Delayed message not scheduled: ${at}.`)
+              return
+            }
+
+            const job: Job = {
+              id: crypto.randomUUID(),
+              sessionID,
+              message,
+              fireAt: at,
+              directory: ctx.location.directory,
+            }
+            await ctx.storage.set(key(job.id), job)
+            arm(job)
+            await rpc.events.emit("scheduled", {
+              sessionID,
+              id: job.id,
+              fireAt: at,
+              preview: previewOf(message),
+            }).catch(() => {})
+            await note(sessionID, `Delayed message scheduled for ${stamp(at)} (in ${humanize(at - now)}).`)
+          } catch (error) {
+            console.error("[delayed-message] schedule failed:", error)
+            await alert(sessionID, `Delayed message failed: ${error instanceof Error ? error.message : String(error)}`)
+          }
+        },
+      })
+    })
+
+    let after: string | undefined
+    do {
+      const page = await ctx.storage.scan(after ? { prefix: "pending/", after } : { prefix: "pending/" })
+      for (const entry of page.entries) {
+        const job = entry.value as Job
+        if (!job?.id || !job.sessionID || !job.message || !job.fireAt) continue
+        if (job.directory !== ctx.location.directory) continue
+        arm(job)
+      }
+      after = page.next
+    } while (after)
+
+    return () => {
+      for (const timer of timers.values()) clearTimeout(timer)
+      timers.clear()
+    }
+  },
+})

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "@tuzelko/opencode-delayed-message",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Schedule a message that wakes an OpenCode session later, without showing it to the model first.",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "delayed",
+    "reminder",
+    "scheduler",
+    "timer",
+    "desktop"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./index.ts",
+    "./gui-experimental": "./gui-experimental.cjs"
+  },
+  "files": [
+    "index.ts",
+    "rpc.ts",
+    "gui-experimental.cjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "prepare": "npm run build",
+    "prepack": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TuzelKO/opencode-delayed-message.git"
+  },
+  "homepage": "https://github.com/TuzelKO/opencode-delayed-message#readme",
+  "bugs": {
+    "url": "https://github.com/TuzelKO/opencode-delayed-message/issues"
+  },
+  "dependencies": {
+    "@opencode/plugin": "^2.2.5"
+  },
+  "devDependencies": {
+    "solid-js": "^1.9.18",
+    "vite": "^8.3.5",
+    "vite-plugin-solid": "^2.11.15"
+  }
+}

package/rpc.ts

@@ -0,0 +1,91 @@
+import { Rpc } from "@opencode/plugin/rpc"
+
+// Bridge between the server plugin and its GUI part: the pill asks `pending`
+// on mount, follows `scheduled`/`fired`/`cancelled`, and cancels by id.
+
+const job = {
+  type: "object",
+  properties: {
+    id: { type: "string" },
+    fireAt: { type: "number" },
+    preview: { type: "string" },
+  },
+  required: ["id", "fireAt", "preview"],
+  additionalProperties: false,
+} as const
+
+export const Delayed = Rpc.define({
+  id: "delayed-message",
+  methods: {
+    pending: {
+      input: {
+        type: "object",
+        properties: { sessionID: { type: "string" } },
+        required: ["sessionID"],
+        additionalProperties: false,
+      },
+      output: {
+        type: "object",
+        properties: {
+          jobs: { type: "array", items: job },
+        },
+        required: ["jobs"],
+        additionalProperties: false,
+      },
+    },
+    cancel: {
+      input: {
+        type: "object",
+        properties: {
+          sessionID: { type: "string" },
+          id: { type: "string" },
+        },
+        required: ["sessionID", "id"],
+        additionalProperties: false,
+      },
+      output: {
+        type: "object",
+        properties: { ok: { type: "boolean" } },
+        required: ["ok"],
+        additionalProperties: false,
+      },
+    },
+  },
+  events: {
+    scheduled: {
+      schema: {
+        type: "object",
+        properties: {
+          sessionID: { type: "string" },
+          id: { type: "string" },
+          fireAt: { type: "number" },
+          preview: { type: "string" },
+        },
+        required: ["sessionID", "id", "fireAt", "preview"],
+        additionalProperties: false,
+      },
+    },
+    fired: {
+      schema: {
+        type: "object",
+        properties: {
+          sessionID: { type: "string" },
+          id: { type: "string" },
+        },
+        required: ["sessionID", "id"],
+        additionalProperties: false,
+      },
+    },
+    cancelled: {
+      schema: {
+        type: "object",
+        properties: {
+          sessionID: { type: "string" },
+          id: { type: "string" },
+        },
+        required: ["sessionID", "id"],
+        additionalProperties: false,
+      },
+    },
+  },
+})