@astrale-os/adapter-cloudflare 0.1.10 → 0.2.0

package/template/runtime/index.ts

@@ -1,62 +1,47 @@
 /**
  * Runtime composition root — the ONLY place request context (kernel/self/params/
- * auth) and `deps` meet the per-feature logic. Each `execute` resolves the port
- * it needs (`deps.prober()`, on-request) and delegates to the per-operation I/O
- * functions in `runtime/monitor/` (`watch`/`check`/`dependsOn`/`seed`), which in
- * turn call `core/` for pure decisions. No business logic lives here.
+ * auth) and `deps` meet the per-feature logic. Each `execute` resolves what it
+ * needs (the `Prober` port, the self node) and delegates to the per-operation I/O
+ * functions in `runtime/monitor/` and `runtime/status-page/`. No business logic
+ * lives here.
  *
- *   - `watch`      is interface-hosted (static) → `remoteInterfaceMethods`.
- *   - `check`      is class-hosted (instance)   → `remoteMethod` + `remoteClassMethods`.
- *   - `dependsOn`  is class-hosted (instance).
- *   - `seed`       is class-hosted (static)     — the `postInstall` bootstrap.
+ * `check` is the `Checkable` interface method, declared `abstract`, so it is
+ * implemented PER CLASS (Monitor probes; StatusPage rolls up) — wired under
+ * `class.Monitor` / `class.StatusPage`, NOT a shared `interface` block. The
+ * kernel dispatches `@<node>::check` to the impl for that node's class.
  *
  * SDK-level `authorize` is an additive throw-to-deny check (returns void). For
  * finer worker checks see `assertPerm` / `requireOwnership` from `@astrale-os/sdk`.
- *
- * Exports the `methods` map the domain definition (`domain.ts`) wires in.
  */
-import {
-  remoteClassMethods,
-  remoteInterfaceMethods,
-  remoteMethod,
-  type SchemaMethodsImpl,
-} from '@astrale-os/sdk'
+import { remoteClassMethods, remoteMethod, type SchemaMethodsImpl } from '@astrale-os/sdk'
 
 import type { Deps } from '../deps'
 
 import { MONITOR_KEYS } from '../core/monitor'
 import { schema } from '../schema'
-import { check, dependsOn, seed, watch } from './monitor'
+import { check as monitorCheck, seed, watch } from './monitor'
+import { add, check as pageCheck, create } from './status-page'
 
 const method = remoteMethod<Deps>()
-const interfaceMethods = remoteInterfaceMethods<Deps>()
 const classMethods = remoteClassMethods<Deps>()
 
-const MonitorOpsMethods = interfaceMethods(schema, 'MonitorOps', {
-  watch: {
-    authorize: async () => undefined,
-    execute: ({ kernel, params }) => {
-      return watch(kernel, params)
-    },
-  },
-})
+// ── Monitor ─────────────────────────────────────────────────────────
 
-const checkMethod = method(schema, 'Monitor', 'check', {
+const monitorCheckMethod = method(schema, 'Monitor', 'check', {
   authorize: async () => undefined,
   execute: async ({ kernel, self, deps }) => {
-    if (!kernel) throw new Error('check requires a kernel credential')
     const node = await self.node()
     const url = node.props[MONITOR_KEYS.url]
     if (typeof url !== 'string') throw new Error('Monitor node is missing its url property')
-    const prober = deps.prober({ class: node.class.raw, url })
-    return check(kernel, prober, self.path.raw, url)
+    // Pass the node to the picker — the prober is chosen FOR this monitor.
+    return monitorCheck(kernel, deps.prober({ class: node.class.raw, url }), self.path.raw, url)
   },
 })
 
-const dependsOnMethod = method(schema, 'Monitor', 'dependsOn', {
+const watchMethod = method(schema, 'Monitor', 'watch', {
   authorize: async () => undefined,
-  execute: ({ kernel, self, params }) => {
-    return dependsOn(kernel, self.path.raw, params)
+  execute: ({ kernel, params }) => {
+    return watch(kernel, params)
   },
 })
 
@@ -67,13 +52,40 @@ const seedMethod = method(schema, 'Monitor', 'seed', {
   },
 })
 
-const MonitorMethods = classMethods(schema, 'Monitor', {
-  check: checkMethod,
-  dependsOn: dependsOnMethod,
-  seed: seedMethod,
+// ── StatusPage ──────────────────────────────────────────────────────
+
+const pageCheckMethod = method(schema, 'StatusPage', 'check', {
+  authorize: async () => undefined,
+  execute: ({ kernel, self }) => {
+    return pageCheck(kernel, self.path.raw)
+  },
+})
+
+const createMethod = method(schema, 'StatusPage', 'create', {
+  authorize: async () => undefined,
+  execute: ({ kernel, params }) => {
+    return create(kernel, params)
+  },
+})
+
+const addMethod = method(schema, 'StatusPage', 'add', {
+  authorize: async () => undefined,
+  execute: ({ kernel, self, params }) => {
+    return add(kernel, self.path.raw, params)
+  },
 })
 
 export const methods: SchemaMethodsImpl<typeof schema, Deps> = {
-  interface: { MonitorOps: MonitorOpsMethods },
-  class: { Monitor: MonitorMethods },
+  class: {
+    Monitor: classMethods(schema, 'Monitor', {
+      check: monitorCheckMethod,
+      watch: watchMethod,
+      seed: seedMethod,
+    }),
+    StatusPage: classMethods(schema, 'StatusPage', {
+      check: pageCheckMethod,
+      create: createMethod,
+      add: addMethod,
+    }),
+  },
 }

package/template/runtime/monitor/check.ts

@@ -1,20 +1,20 @@
+import type { Prober } from '../../integrations/prober/port'
+import type { CallableKernel } from '../shared'
+
 /**
- * `Monitor.check` (instance) — probe the target via the resolved `Prober` port,
- * classify the result (pure, `core/health`), and record status/latency back onto
- * the node. `url` is the monitor's target and `prober` is already selected FOR
- * this node (both resolved by the wiring in `runtime/index.ts` from `self.node()`).
+ * `Monitor.check` (instance) — implements `Checkable.check` for a single endpoint:
+ * probe the target via the resolved `Prober` port, classify (pure, `core/monitor`),
+ * record status/latency on the node, and return the verdict. `url` + `prober` are
+ * resolved by the wiring (`runtime/index.ts`) from `self.node()`.
  */
 import { classify, MONITOR_KEYS } from '../../core/monitor'
-import type { Prober } from '../../integrations/prober/port'
-
-import type { CallableKernel } from './shared'
 
 export async function check(
   kernel: CallableKernel,
   prober: Prober,
   selfPathRaw: string,
   url: string,
-): Promise<{ status: string; statusCode: number; latencyMs: number }> {
+): Promise<{ status: string }> {
   const result = await prober.probe(url)
   const status = classify(result.statusCode)
   await kernel.call(`${selfPathRaw}::update`, {
@@ -25,5 +25,5 @@ export async function check(
       [MONITOR_KEYS.lastCheckedAt]: new Date().toISOString(),
     },
   })
-  return { status, statusCode: result.statusCode, latencyMs: result.latencyMs }
+  return { status }
 }

package/template/runtime/monitor/index.ts

@@ -1,12 +1,9 @@
 /**
- * Monitor runtime operations — one file per method, assembled here. The
- * composition root (`runtime/index.ts`) imports these and wires them into the
- * methods map. Each is transport-agnostic logic over a `CallableKernel` (+ the
- * `Prober` port where it probes), delegating pure decisions to `core/` — so all
- * are unit-testable with fakes.
+ * Monitor operations — one file per method, assembled here for the composition
+ * root (`runtime/index.ts`). Each is transport-agnostic logic over a
+ * `CallableKernel` (+ the `Prober` port where it probes), delegating pure
+ * decisions to `core/monitor` — so all are unit-testable with fakes.
  */
 export { check } from './check'
-export { dependsOn } from './dependsOn'
 export { seed } from './seed'
 export { watch } from './watch'
-export type { CallableKernel } from './shared'

package/template/runtime/monitor/seed.ts

@@ -1,73 +1,94 @@
+import type { Prober } from '../../integrations/prober/port'
+
 /**
  * `Monitor.seed` (static) — the domain's post-install bootstrap. The kernel calls
  * it ONCE after install, as __SYSTEM__ (see `postInstall` in `domain.ts`), so the
- * domain can lay down its initial state: the `/monitors` folder, a couple of
- * starter Monitors (each probed once so they show real status immediately), and a
- * `depends_on` edge between them. Idempotent: a re-run swallows `PATH_CONFLICT`
- * per node (the starters use fixed slugs).
+ * domain comes up demonstrable: a `/monitors` folder + starter Monitors (each
+ * probed once), and a `/status-pages` folder + one StatusPage that `watches` them
+ * (its initial status rolled up from the probes). Idempotent: node creates swallow
+ * `PATH_CONFLICT` (fixed paths) and re-linking a `watches` edge is a graph no-op.
+ * It grants nothing — the installing owner reaches these nodes via root-propagated
+ * perms; grant explicitly here for non-owner access.
  */
 import {
   classify,
-  DEPENDS_ON_EDGE,
   FOLDER_CLASS,
   MONITOR_CLASS,
   MONITOR_KEYS,
   MONITORS_PARENT,
   NAME_KEY,
   NODE_CREATE,
+  rollup,
+  STARTER_PAGE,
   STARTERS,
+  STATUS_PAGE_CLASS,
+  STATUS_PAGES_PARENT,
+  PAGE_KEYS,
+  WATCHES_EDGE,
+  WATCHES_KEYS,
 } from '../../core/monitor'
-import type { Prober } from '../../integrations/prober/port'
+import { type CallableKernel, isPathConflict } from '../shared'
 
-import { type CallableKernel, isPathConflict } from './shared'
-
-export async function seed(kernel: CallableKernel, prober: Prober): Promise<{ seeded: number }> {
-  // 1. The `/monitors` folder at the graph root.
+/** Create a node, swallowing a re-seed's `PATH_CONFLICT`. Returns true if newly created. */
+async function ensure(kernel: CallableKernel, params: unknown): Promise<boolean> {
   try {
-    await kernel.call(NODE_CREATE, {
-      class: FOLDER_CLASS,
-      path: MONITORS_PARENT,
-      props: { [NAME_KEY]: 'monitors' },
-    })
+    await kernel.call(NODE_CREATE, params)
+    return true
   } catch (e) {
     if (!isPathConflict(e)) throw e
+    return false
   }
+}
+
+export async function seed(kernel: CallableKernel, prober: Prober): Promise<{ seeded: number }> {
+  await ensure(kernel, {
+    class: FOLDER_CLASS,
+    path: MONITORS_PARENT,
+    props: { [NAME_KEY]: 'monitors' },
+  })
 
-  // 2. A couple of starter Monitors, each probed once for an initial status.
-  const ids: Record<string, string> = {}
+  // Probe + create each starter Monitor; collect the verdict for the page roll-up.
+  const members: { status: string; critical: boolean }[] = []
   let seeded = 0
   for (const s of STARTERS) {
-    try {
-      const result = await prober.probe(s.url)
-      const created = (await kernel.call(NODE_CREATE, {
-        class: MONITOR_CLASS,
-        path: `${MONITORS_PARENT}/${s.slug}`,
-        props: {
-          [NAME_KEY]: s.name,
-          [MONITOR_KEYS.url]: s.url,
-          [MONITOR_KEYS.status]: classify(result.statusCode),
-          [MONITOR_KEYS.statusCode]: result.statusCode,
-          [MONITOR_KEYS.latencyMs]: result.latencyMs,
-          [MONITOR_KEYS.lastCheckedAt]: new Date().toISOString(),
-        },
-      })) as { id: string }
-      ids[s.slug] = created.id
-      seeded++
-    } catch (e) {
-      if (!isPathConflict(e)) throw e
-    }
+    const result = await prober.probe(s.url)
+    const status = classify(result.statusCode)
+    members.push({ status, critical: s.critical })
+    const created = await ensure(kernel, {
+      class: MONITOR_CLASS,
+      path: `${MONITORS_PARENT}/${s.slug}`,
+      props: {
+        [NAME_KEY]: s.name,
+        [MONITOR_KEYS.url]: s.url,
+        [MONITOR_KEYS.status]: status,
+        [MONITOR_KEYS.statusCode]: result.statusCode,
+        [MONITOR_KEYS.latencyMs]: result.latencyMs,
+        [MONITOR_KEYS.lastCheckedAt]: new Date().toISOString(),
+      },
+    })
+    if (created) seeded++
   }
 
-  // 3. Link the first starter as depending on the second (id-form on both sides
-  //    — layout-independent). Best-effort.
-  const from = ids[STARTERS[0]?.slug ?? '']
-  const to = ids[STARTERS[1]?.slug ?? '']
-  if (from && to) {
-    try {
-      await kernel.call(`@${from}::link`, { edgeClass: DEPENDS_ON_EDGE, target: `@${to}` })
-    } catch (e) {
-      if (!isPathConflict(e)) throw e
-    }
+  // A StatusPage watching every starter, its status rolled up from the probes.
+  await ensure(kernel, {
+    class: FOLDER_CLASS,
+    path: STATUS_PAGES_PARENT,
+    props: { [NAME_KEY]: 'status-pages' },
+  })
+  const pagePath = `${STATUS_PAGES_PARENT}/${STARTER_PAGE.slug}`
+  await ensure(kernel, {
+    class: STATUS_PAGE_CLASS,
+    path: pagePath,
+    props: { [NAME_KEY]: STARTER_PAGE.name, [PAGE_KEYS.status]: rollup(members) },
+  })
+  // Re-linking the same (page, monitor) `watches` edge is a graph no-op, so this
+  // needs no conflict guard.
+  for (const s of STARTERS) {
+    await kernel.call(`${pagePath}::link`, {
+      edgeClass: WATCHES_EDGE,
+      target: `${MONITORS_PARENT}/${s.slug}`,
+      props: { [WATCHES_KEYS.critical]: s.critical },
+    })
   }
 
   return { seeded }

package/template/runtime/monitor/watch.ts

@@ -1,29 +1,23 @@
-import type { CallableKernel } from './shared'
-
 /**
- * `MonitorOps.watch` (static) — create a Monitor node under `/monitors`. The slug
- * FORMAT is pure (`core/monitor`'s `monitorSlug`); the entropy suffix (impure,
- * clock/RNG) is generated HERE, keeping core deterministic.
+ * `Monitor.watch` (static) — create a Monitor node under `/monitors`. The slug
+ * format is pure (`core/monitor`'s `uniqueSlug`); the entropy suffix (impure,
+ * clock/RNG) comes from `runtime/shared`, keeping core deterministic.
  */
 import {
   MONITOR_CLASS,
   MONITOR_KEYS,
   MONITORS_PARENT,
-  monitorSlug,
   NAME_KEY,
   NODE_CREATE,
+  uniqueSlug,
 } from '../../core/monitor'
-
-/** Short clock+RNG entropy to dodge same-ms / same-host slug collisions. */
-function randomSuffix(): string {
-  return `${Date.now().toString(36).slice(-4)}${Math.random().toString(36).slice(2, 6)}`
-}
+import { type CallableKernel, randomSuffix } from '../shared'
 
 export async function watch(
   kernel: CallableKernel,
   params: { url: string; name?: string },
 ): Promise<{ id: string; path: string }> {
-  const path = `${MONITORS_PARENT}/${monitorSlug(params.url, randomSuffix())}`
+  const path = `${MONITORS_PARENT}/${uniqueSlug(params.url, randomSuffix())}`
   const created = (await kernel.call(NODE_CREATE, {
     class: MONITOR_CLASS,
     path,

package/template/runtime/{monitor/shared.ts → shared.ts}

@@ -1,7 +1,6 @@
 /**
- * Runtime-internal helpers shared across the Monitor operations (`watch`,
- * `check`, `dependsOn`, `seed`). Not exported from the domain — just the seam the
- * operation files agree on.
+ * Runtime-internal helpers shared across the context's operations. Not exported
+ * from the domain — just the seam the operation files agree on.
  */
 
 /**
@@ -15,3 +14,8 @@ export type CallableKernel = { call(path: string, params: unknown): Promise<unkn
 export function isPathConflict(e: unknown): boolean {
   return e instanceof Error && e.message.includes('PATH_CONFLICT')
 }
+
+/** Short clock+RNG entropy to dodge same-ms / same-stem slug collisions (impure). */
+export function randomSuffix(): string {
+  return `${Date.now().toString(36).slice(-4)}${Math.random().toString(36).slice(2, 6)}`
+}

package/template/runtime/status-page/add.ts

@@ -0,0 +1,21 @@
+import type { CallableKernel } from '../shared'
+
+/**
+ * `StatusPage.add` (instance) — watch a Monitor: create a `watches` edge from
+ * this page to `monitor`, tagged `critical` (default false). `monitor` is any
+ * node address (a tree path or `@<id>`).
+ */
+import { WATCHES_EDGE, WATCHES_KEYS } from '../../core/monitor'
+
+export async function add(
+  kernel: CallableKernel,
+  selfPathRaw: string,
+  params: { monitor: string; critical?: boolean },
+): Promise<{ watched: string }> {
+  await kernel.call(`${selfPathRaw}::link`, {
+    edgeClass: WATCHES_EDGE,
+    target: params.monitor,
+    props: { [WATCHES_KEYS.critical]: params.critical ?? false },
+  })
+  return { watched: params.monitor }
+}

package/template/runtime/status-page/check.ts

@@ -0,0 +1,50 @@
+import type { CallableKernel } from '../shared'
+
+/**
+ * `StatusPage.check` (instance) — implements `Checkable.check` for a page: walk
+ * the `watches` edges, re-check each monitor (a cross-node `@<id>::check` call),
+ * roll the verdicts up (pure, `core/monitor`), record the page status, return it.
+ *
+ * `getLinks` returns raw `Edge`s whose endpoint/prop accessors aren't typed yet
+ * (an SDK gap) — `parseWatches` is the small cast that bridges it.
+ */
+import { PAGE_KEYS, rollup, WATCHES_EDGE, WATCHES_KEYS } from '../../core/monitor'
+
+/** A raw `watches` edge as `getLinks` returns it (endpoints are string-or-`{raw}`). */
+type RawEdge = {
+  class?: string | { raw: string }
+  target?: string | { raw: string }
+  props?: Record<string, unknown>
+}
+
+function rawOf(p: RawEdge['target']): string | undefined {
+  if (typeof p === 'string') return p
+  return typeof p?.raw === 'string' ? p.raw : undefined
+}
+
+/** The monitors this page watches: each target ref + its `critical` flag. */
+function parseWatches(raw: unknown): { monitor: string; critical: boolean }[] {
+  const edges = (Array.isArray(raw) ? raw : []) as RawEdge[]
+  const out: { monitor: string; critical: boolean }[] = []
+  for (const e of edges) {
+    if (rawOf(e.class) !== WATCHES_EDGE) continue
+    const monitor = rawOf(e.target)
+    if (monitor) out.push({ monitor, critical: e.props?.[WATCHES_KEYS.critical] === true })
+  }
+  return out
+}
+
+export async function check(
+  kernel: CallableKernel,
+  selfPathRaw: string,
+): Promise<{ status: string }> {
+  const links = await kernel.call(`${selfPathRaw}::getLinks`, { direction: 'out' })
+  const members = []
+  for (const w of parseWatches(links)) {
+    const { status } = (await kernel.call(`${w.monitor}::check`, {})) as { status: string }
+    members.push({ status, critical: w.critical })
+  }
+  const status = rollup(members)
+  await kernel.call(`${selfPathRaw}::update`, { props: { [PAGE_KEYS.status]: status } })
+  return { status }
+}

package/template/runtime/status-page/create.ts

@@ -0,0 +1,24 @@
+/**
+ * `StatusPage.create` (static) — create a StatusPage node under `/status-pages`.
+ */
+import {
+  NAME_KEY,
+  NODE_CREATE,
+  STATUS_PAGE_CLASS,
+  STATUS_PAGES_PARENT,
+  uniqueSlug,
+} from '../../core/monitor'
+import { type CallableKernel, randomSuffix } from '../shared'
+
+export async function create(
+  kernel: CallableKernel,
+  params: { name: string },
+): Promise<{ id: string; path: string }> {
+  const path = `${STATUS_PAGES_PARENT}/${uniqueSlug(params.name, randomSuffix())}`
+  const created = (await kernel.call(NODE_CREATE, {
+    class: STATUS_PAGE_CLASS,
+    path,
+    props: { [NAME_KEY]: params.name },
+  })) as { id: string }
+  return { id: created.id, path }
+}

package/template/runtime/status-page/index.ts

@@ -0,0 +1,8 @@
+/**
+ * StatusPage operations — one file per method, assembled here for the
+ * composition root (`runtime/index.ts`). Transport-agnostic logic over a
+ * `CallableKernel`, delegating the roll-up decision to `core/monitor`.
+ */
+export { add } from './add'
+export { check } from './check'
+export { create } from './create'

package/template/schema/index.ts

@@ -11,19 +11,19 @@
 import { defineSchema, KernelSchema } from '@astrale-os/kernel-core'
 import { compileDomain, type Domain } from '@astrale-os/kernel-core/domain'
 
-import { depends_on, Monitor, MonitorOps } from './monitor'
+import { Checkable, Monitor, StatusPage, watches } from './monitor'
 
 export const schema = defineSchema('astrale-domain.example.dev', {
-  interfaces: { MonitorOps },
-  classes: { Monitor, depends_on },
+  interfaces: { Checkable },
+  classes: { Monitor, StatusPage, watches },
   imports: [KernelSchema],
 })
 
 /**
  * The compiled domain — resolved class/interface paths + qualified prop keys.
  * `compileDomain` is pure (no env), so this is safe to import from the worker
- * and from build tooling alike. `core/keys.ts` re-exports it as the single source
- * of graph-facing strings (class paths, prop keys) — never hand-write those.
+ * and from build tooling alike. `core/monitor/keys.ts` re-exports it as the single
+ * source of graph-facing strings (class paths, prop keys) — never hand-write those.
  */
 export const D: Domain<typeof schema> = compileDomain(schema)