@astrale-os/adapter-cloudflare 0.1.10 → 0.2.1

package/template/schema/monitor.ts

@@ -1,57 +1,43 @@
 /**
- * Monitor context — the domain's single bounded slice.
+ * Monitoring context — the domain's single bounded slice: a `Checkable` contract
+ * implemented by two classes, plus the edge that binds them.
  *
- * One file per context: a class (or a few tightly-related classes) plus the
- * edges that bind them. Here that is the `MonitorOps` interface, the `Monitor`
- * class that implements it, and the `depends_on` edge from one Monitor to
- * another. To grow the domain, add `schema/<context>.ts` and register its
- * members in `schema/index.ts`.
- *
- *   - Interface `MonitorOps`  one static op, `watch`. Static → the impl gets no
- *                             `self`; it creates a brand-new Monitor.
- *   - Class `Monitor`         implements `[MonitorOps, Container]`, inheriting
- *                             `watch` and adding instance methods `check`
- *                             (probe + record live status) and `dependsOn`
- *                             (links this Monitor to one it relies on).
- *   - Edge `depends_on`       Monitor → Monitor. A dependency graph of checks,
- *                             materialized by `dependsOn` (and by `seed`).
+ *   - Interface `Checkable`   one `abstract` method, `check()`. Abstract → each
+ *                             implementing class brings its OWN body, and the
+ *                             kernel dispatches by the node's class.
+ *   - Class `Monitor`         a single HTTP check. `check()` probes `url`;
+ *                             `watch` creates one; `seed` lays down the demo set.
+ *   - Class `StatusPage`      a roll-up. `check()` re-checks the monitors it
+ *                             `watches` and aggregates; `create` makes a page;
+ *                             `add` watches a monitor.
+ *   - Edge `watches`          StatusPage → Monitor, with a `critical` flag.
  */
-import { edgeClass, KernelSchema, nodeClass, nodeInterface } from '@astrale-os/kernel-core'
+import { edgeClass, nodeClass, nodeInterface } from '@astrale-os/kernel-core'
 import { fn } from '@astrale-os/kernel-dsl'
 import { z } from 'zod'
 
-/**
- * Thin ref to a created node — what node-creating ops return. A remote method
- * returns a plain `{ id, path }`, never `ref(SELF)` (whose full-Node value does
- * not round-trip over the worker wire).
- */
-export const MonitorRef = z.object({ id: z.string(), path: z.string() })
+/** Thin ref to a created node — what the static factories return (a full Node
+ *  value does not round-trip over the worker wire). */
+export const NodeRef = z.object({ id: z.string(), path: z.string() })
 
-/** What a single probe records — returned by `check`. */
-export const ProbeOutcome = z.object({
-  status: z.string(),
-  statusCode: z.number().int(),
-  latencyMs: z.number().int(),
-})
+/** What `check()` reports — the subject's current health verdict. */
+export const CheckResult = z.object({ status: z.string() })
 
-export const MonitorOps = nodeInterface({
+export const Checkable = nodeInterface({
   methods: {
-    watch: fn({
-      static: true,
-      params: { url: z.string(), name: z.string().optional() },
-      returns: MonitorRef,
-    }),
+    // `abstract` → no shared body; every implementer supplies its own `check`,
+    // wired per-class in `runtime/`. `@<node>::check` dispatches by the node's class.
+    check: fn({ inheritance: 'abstract', returns: CheckResult }),
   },
 })
 
 export const Monitor = nodeClass({
-  implements: [MonitorOps, KernelSchema.interfaces.Container],
+  implements: [Checkable],
   props: {
     /** The target URL this monitor probes. */
     url: z.string(),
     // Live status, written by `check`. PLAIN STRING, not `z.enum()`: `::update`
-    // currently drops `z.enum()` props silently, and `check` updates this.
-    // Values: 'up' | 'down' | 'unknown' (the initial value before the first check).
+    // silently drops `z.enum()` props. Values: 'up' | 'down' | 'unknown'.
     status: z.string().optional(),
     /** Last observed HTTP status code (0 = host unreachable). */
     statusCode: z.number().int().optional(),
@@ -61,20 +47,48 @@ export const Monitor = nodeClass({
     lastCheckedAt: z.string().optional(),
   },
   methods: {
-    // Instance: probe the target via the resolved `Prober` port (the external
-    // integration), then record status/latency back onto this node.
-    check: fn({ returns: ProbeOutcome }),
-    // Instance: link this Monitor to another it depends on (a `depends_on` edge).
-    dependsOn: fn({ params: { target: z.string() }, returns: z.object({ linked: z.string() }) }),
+    // Implements `Checkable.check` for a single endpoint (probe `url`). Redeclared
+    // here — a concrete class must declare each abstract method it implements, so
+    // the compiler materializes Monitor's OWN `check` node for per-class dispatch.
+    // The body lives in `runtime/monitor/check.ts`.
+    check: fn({ returns: CheckResult }),
+    /** Create a Monitor under `/monitors`. */
+    watch: fn({
+      static: true,
+      params: { url: z.string(), name: z.string().optional() },
+      returns: NodeRef,
+    }),
     // Post-install bootstrap (wired as `postInstall` in domain.ts). Static: the
-    // kernel calls it ONCE after install, as __SYSTEM__, with no `self`. Must
-    // stay idempotent — a re-install runs it again.
+    // kernel calls it ONCE after install, as __SYSTEM__. Must stay idempotent.
     seed: fn({ static: true, returns: z.object({ seeded: z.number().int() }) }),
   },
 })
 
-export const depends_on = edgeClass(
-  { as: 'dependent', types: [Monitor] },
-  { as: 'dependency', types: [Monitor] },
-  { props: { reason: z.string().optional() } },
+export const StatusPage = nodeClass({
+  implements: [Checkable],
+  props: {
+    /** Rolled-up status, written by `check`. 'up' | 'degraded' | 'down' | 'unknown'. */
+    status: z.string().optional(),
+  },
+  methods: {
+    // Implements `Checkable.check` for a page (roll up the watched monitors).
+    // Redeclared so StatusPage materializes its OWN `check` node. Body in
+    // `runtime/status-page/check.ts`.
+    check: fn({ returns: CheckResult }),
+    /** Create a StatusPage under `/status-pages`. */
+    create: fn({ static: true, params: { name: z.string() }, returns: NodeRef }),
+    /** Watch a monitor (a `watches` edge); `critical` decides the roll-up weight. */
+    add: fn({
+      params: { monitor: z.string(), critical: z.boolean().optional() },
+      returns: z.object({ watched: z.string() }),
+    }),
+  },
+})
+
+export const watches = edgeClass(
+  { as: 'page', types: [StatusPage] },
+  { as: 'monitor', types: [Monitor] },
+  // `critical` drives the roll-up: a critical monitor down ⇒ page `down`; a
+  // non-critical one down ⇒ `degraded`.
+  { props: { critical: z.boolean() } },
 )

package/template/views/index.ts

@@ -4,14 +4,13 @@
  * binding the SDK stamps with the worker's live serving URL when it builds the
  * install bundle.
  *
- * `welcome` is a worker-rendered inline-HTML view (no SPA). `ui-monitor` and
- * `ui-monitor-badge` are BOTH served by the one `client/` SPA — it routes on the
- * mount path (`/ui/monitor` vs `/ui/monitor-badge`) to pick which view to render.
+ * `welcome` is a worker-rendered inline-HTML view (no SPA). `ui-status-page` is
+ * the `client/` SPA (mounted at `/ui/status-page`, offered for any StatusPage).
  */
-import { monitor } from './monitor'
+import { statusPage } from './status-page'
 import { welcome } from './welcome'
 
 export const views = {
   welcome,
-  'ui-monitor': monitor,
+  'ui-status-page': statusPage,
 }

package/template/views/status-page.ts

@@ -0,0 +1,16 @@
+/**
+ * `ui-status-page` — the domain's SPA view, mounted at `/ui/status-page` and
+ * served from the `client/` bundle. `viewFor: selfOf(StatusPage)` attaches a
+ * `view_for` edge to the `StatusPage` class meta-node, so the GUI offers this
+ * view for any StatusPage instance.
+ */
+import { selfOf } from '@astrale-os/kernel-dsl'
+import { defineView } from '@astrale-os/sdk'
+
+import { StatusPage } from '../schema/monitor'
+
+export const statusPage = defineView({
+  auth: 'public',
+  mount: '/ui/status-page',
+  viewFor: selfOf(StatusPage),
+})

package/template/client/src/monitor/components/MonitorCard.tsx

@@ -1,50 +0,0 @@
-/**
- * MonitorCard — the Monitor feature's one container. It owns the data/logic:
- * loads the node (`useMonitor`), wires the `check` write (`useCheck`), and
- * composes the presentation. Handles the query's loading/error/ok states; on
- * `ok` it renders a `Panel` whose body is the check-error banner (if any) plus
- * the pure `MonitorDetails` view, with a "Check now" button that runs the probe
- * then reloads the node so the fresh values render.
- *
- * Thin by design: the record's layout lives in `monitor/ui` (`MonitorDetails`);
- * the generic surfaces come from the `@/ui` design system.
- */
-import type { KernelClient } from '@/shell'
-
-import { ErrorBanner, Panel, Spinner } from '@/ui'
-
-import { useCheck, useMonitor } from '../hooks'
-import { MonitorDetails } from '../ui'
-
-export function MonitorCard({ session, nodeId }: { session: KernelClient; nodeId: string }) {
-  const monitor = useMonitor(session, nodeId)
-  const probe = useCheck(session, nodeId)
-
-  async function checkNow() {
-    if (await probe.run()) monitor.reload()
-  }
-
-  if (monitor.state === 'idle' || monitor.state === 'loading') {
-    return <Spinner label="Loading the Monitor…" />
-  }
-  if (monitor.state === 'error') {
-    return <ErrorBanner>Failed to load the Monitor: {monitor.message}</ErrorBanner>
-  }
-
-  const record = monitor.record!
-  const checking = probe.phase === 'running'
-  const checkButton = (
-    <button type="button" className="check-btn" onClick={checkNow} disabled={checking}>
-      {checking ? 'Checking…' : 'Check now'}
-    </button>
-  )
-
-  return (
-    <Panel title={record.name} actions={checkButton}>
-      {probe.phase === 'failed' && probe.error && (
-        <ErrorBanner>Check failed: {probe.error}</ErrorBanner>
-      )}
-      <MonitorDetails record={record} />
-    </Panel>
-  )
-}

package/template/client/src/monitor/components/index.ts

@@ -1 +0,0 @@
-export { MonitorCard } from './MonitorCard'

package/template/client/src/monitor/hooks/index.ts

@@ -1,3 +0,0 @@
-export { useMonitor } from './useMonitor.query'
-export type { MonitorQuery } from './useMonitor.query'
-export { useCheck } from './useCheck.mutation'

package/template/client/src/monitor/index.ts

@@ -1,6 +0,0 @@
-/** The Monitor feature — its api, types, mappers, hooks and components. */
-export * from './components'
-export * from './hooks'
-export { check } from './monitor.api'
-export { monitorFromNode, normalizeStatus } from './monitor.mappers'
-export type { MonitorRecord } from './monitor.types'

package/template/client/src/monitor/monitor.api.ts

@@ -1,11 +0,0 @@
-/** Raw kernel calls for the Monitor feature — node instance methods. */
-import { invokeNode, type KernelClient } from '@/shell'
-
-/**
- * Run the Monitor's `check` instance method (`@<id>::check`). Probes the target
- * URL server-side and updates the node's `status`/`statusCode`/`latencyMs`/
- * `lastCheckedAt` props; the caller reloads the node to render the fresh values.
- */
-export function check(session: KernelClient, nodeId: string): Promise<unknown> {
-  return invokeNode(session, nodeId, 'check', {})
-}

package/template/client/src/monitor/monitor.mappers.ts

@@ -1,38 +0,0 @@
-/** Node → typed record transforms for the Monitor feature. */
-import { type KernelNode, PROP, readProp, readPropBySuffix } from '@/shell'
-
-import type { MonitorRecord, MonitorStatus } from './monitor.types'
-
-const lastSegment = (path: string): string => path.split('/').filter(Boolean).pop() ?? path
-
-/** Coerce a string prop to a finite number, or `undefined`. */
-function readNumberBySuffix(props: Record<string, unknown>, suffix: string): number | undefined {
-  const raw = readPropBySuffix(props, suffix)
-  if (raw === undefined) return undefined
-  const n = Number(raw)
-  return Number.isFinite(n) ? n : undefined
-}
-
-/** Normalize the node's `status` prop to the three known states. */
-export function normalizeStatus(raw: string | undefined): MonitorStatus {
-  return raw === 'up' || raw === 'down' ? raw : 'unknown'
-}
-
-/**
- * Project a Monitor `KernelNode` into a `MonitorRecord`. The name comes from the
- * kernel `Named.name` key; the domain props (`url`/`status`/`statusCode`/
- * `latencyMs`/`lastCheckedAt`) are domain-qualified, so read them by suffix.
- */
-export function monitorFromNode(node: KernelNode): MonitorRecord {
-  const p = node.props ?? {}
-  return {
-    id: node.id,
-    path: node.path ?? '',
-    name: readProp(p, PROP.named.name) ?? lastSegment(node.path ?? '') ?? node.id,
-    url: readPropBySuffix(p, '.property.url') ?? '',
-    status: normalizeStatus(readPropBySuffix(p, '.property.status')),
-    statusCode: readNumberBySuffix(p, '.property.statusCode'),
-    latencyMs: readNumberBySuffix(p, '.property.latencyMs'),
-    lastCheckedAt: readPropBySuffix(p, '.property.lastCheckedAt'),
-  }
-}

package/template/client/src/monitor/monitor.types.ts

@@ -1,23 +0,0 @@
-/** The Monitor feature's client types. */
-
-/** The three known states of a Monitor's normalized status. */
-export type MonitorStatus = 'up' | 'down' | 'unknown'
-
-/**
- * Client-side projection of a Monitor node. Domain props are read off the
- * kernel node by suffix (see `monitor.mappers.ts`); numeric props are coerced.
- */
-export type MonitorRecord = {
-  id: string
-  path: string
-  name: string
-  url: string
-  /** up | down | unknown — normalized from the node's `status` prop. */
-  status: MonitorStatus
-  /** HTTP status code from the last check, if any. */
-  statusCode?: number
-  /** Round-trip latency of the last check, in milliseconds. */
-  latencyMs?: number
-  /** ISO timestamp of the last check, if any. */
-  lastCheckedAt?: string
-}

package/template/client/src/monitor/ui/MonitorDetails.UI.tsx

@@ -1,38 +0,0 @@
-/**
- * MonitorDetails — the Monitor record's PRESENTATION, extracted pure. Given a
- * projected `MonitorRecord`, it lays out the StatusBadge + the url/latency/
- * statusCode/last-checked KV rows using the feature-agnostic `@/ui` primitives.
- *
- * Pure: no hooks, no kernel, no data loading — props in, DOM out. The container
- * (`MonitorCard`) owns loading the record and wiring the "Check now" write.
- */
-import { ExternalLink, KV, Mono, relativeTime } from '@/ui'
-
-import type { MonitorRecord } from '../monitor.types'
-
-import { StatusBadge } from './StatusBadge.UI'
-
-export function MonitorDetails({ record }: { record: MonitorRecord }) {
-  return (
-    <>
-      <div className="status-row">
-        <StatusBadge status={record.status} />
-      </div>
-
-      <div className="kv">
-        <KV label="url">
-          <ExternalLink url={record.url || undefined} />
-        </KV>
-        <KV label="latency">
-          <Mono value={record.latencyMs !== undefined ? `${record.latencyMs}ms` : undefined} />
-        </KV>
-        <KV label="status code">
-          <Mono value={record.statusCode !== undefined ? String(record.statusCode) : undefined} />
-        </KV>
-        <KV label="last checked">
-          <Mono value={relativeTime(record.lastCheckedAt)} title={record.lastCheckedAt} />
-        </KV>
-      </div>
-    </>
-  )
-}

package/template/client/src/monitor/ui/StatusBadge.UI.tsx

@@ -1,14 +0,0 @@
-/** Monitor status chip — pure presentational; styling lives in `styles.css`. */
-
-import type { MonitorStatus } from '../monitor.types'
-
-/**
- * Color-coded status pill: up = green, down = red, unknown = muted. The label is
- * the uppercased status (`UP` / `DOWN` / `UNKNOWN`). Monitor-specific — it knows
- * the feature's up/down/unknown vocabulary — so it lives in `monitor/ui`, not the
- * feature-agnostic `@/ui` design system.
- */
-export function StatusBadge({ status }: { status: MonitorStatus }) {
-  const label = status === 'up' ? 'UP' : status === 'down' ? 'DOWN' : 'UNKNOWN'
-  return <span className={`status-badge status-${status}`}>{label}</span>
-}

package/template/client/src/monitor/ui/index.ts

@@ -1,8 +0,0 @@
-/**
- * The Monitor feature's OWN presentation — monitor-specific, feature-aware UI
- * (it knows the up/down/unknown status vocabulary and the record shape). Pure
- * components, built on the feature-agnostic `@/ui` primitives. Import within the
- * feature: `import { StatusBadge, MonitorDetails } from '../ui'`.
- */
-export { StatusBadge } from './StatusBadge.UI'
-export { MonitorDetails } from './MonitorDetails.UI'

package/template/client/src/views/monitor.tsx

@@ -1,30 +0,0 @@
-/**
- * The `ui-monitor` view (mount path `/ui/monitor`) — the Monitor detail panel.
- *
- * Mounted by the Astrale shell as a sandboxed iframe; `@/shell` (built on the
- * real `@astrale-os/shell`) completes the handshake and hands over the kernel
- * session + the target node id. `ViewFrame` gates the handshake (loading /
- * standalone / ready); the `ready` body delegates to `MonitorCard`, the feature
- * container that loads the node, renders its status/url/latency, and exposes a
- * "Check now" probe.
- *
- * Pure composition — no data/transport logic lives here (that's `@/monitor` +
- * `@/shell`).
- */
-import { MonitorCard } from '@/monitor'
-import { type ShellState, ViewFrame } from '@/shell'
-
-export function MonitorView(shell: ShellState) {
-  return (
-    <ViewFrame shell={shell} title="Status monitor" subline="ui-monitor · Astrale view SPA">
-      {(session, nodeId) =>
-        nodeId ? (
-          // Keyed by node id so a target hot-swap remounts with fresh state.
-          <MonitorCard key={nodeId} session={session} nodeId={nodeId} />
-        ) : (
-          <div className="banner">No target Monitor — open this view from a Monitor node.</div>
-        )
-      }
-    </ViewFrame>
-  )
-}