@astrale-os/adapter-cloudflare 0.3.1 → 0.4.0

package/template/runtime/monitoring/index.ts

@@ -1,8 +0,0 @@
-/**
- * Monitoring runtime context — method implementations grouped by the domain
- * slice they serve. `runtime/index.ts` wires these into SDK method handlers.
- */
-import * as monitor from './monitor'
-import * as page from './page'
-
-export { monitor, page }

package/template/runtime/monitoring/monitor/check.ts

@@ -1,29 +0,0 @@
-import type { Prober } from '../../../integrations/prober/port'
-import type { CallableKernel } from '../../shared'
-
-/**
- * `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'
-
-export async function check(
-  kernel: CallableKernel,
-  prober: Prober,
-  selfPathRaw: string,
-  url: string,
-): Promise<{ status: string }> {
-  const result = await prober.probe(url)
-  const status = classify(result.statusCode)
-  await kernel.call(`${selfPathRaw}::update`, {
-    props: {
-      [MONITOR_KEYS.status]: status,
-      [MONITOR_KEYS.statusCode]: result.statusCode,
-      [MONITOR_KEYS.latencyMs]: result.latencyMs,
-      [MONITOR_KEYS.lastCheckedAt]: new Date().toISOString(),
-    },
-  })
-  return { status }
-}

package/template/runtime/monitoring/monitor/index.ts

@@ -1,10 +0,0 @@
-/**
- * Monitor operations inside the monitoring bounded context — 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 { seed } from './seed'
-export { watch } from './watch'

package/template/runtime/monitoring/monitor/seed.ts

@@ -1,104 +0,0 @@
-import type { Prober } from '../../../integrations/prober/port'
-
-/**
- * The domain's post-install bootstrap — exposed as the standalone `seed` function
- * (`functions/`) and wired as `postInstall` in `domain.ts`. The kernel calls it
- * ONCE after install, as __SYSTEM__, so the
- * domain comes up demonstrable: a `/monitoring` folder, `/monitoring/monitors`
- * starter Monitors (each probed once), and `/monitoring/pages/status`, a
- * 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,
-  FOLDER_CLASS,
-  MONITOR_CLASS,
-  MONITOR_KEYS,
-  MONITORING_PARENT,
-  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 CallableKernel, isPathConflict } from '../../shared'
-
-/** 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, 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: MONITORING_PARENT,
-    props: { [NAME_KEY]: 'monitoring' },
-  })
-
-  await ensure(kernel, {
-    class: FOLDER_CLASS,
-    path: MONITORS_PARENT,
-    props: { [NAME_KEY]: 'monitors' },
-  })
-
-  // 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) {
-    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++
-  }
-
-  // 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]: '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/monitoring/monitor/watch.ts

@@ -1,31 +0,0 @@
-/**
- * `Monitor.watch` (static) — create a Monitor node under `/monitoring/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,
-  NAME_KEY,
-  NODE_CREATE,
-  uniqueSlug,
-} from '../../../core/monitor'
-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}/${uniqueSlug(params.url, randomSuffix())}`
-  const created = (await kernel.call(NODE_CREATE, {
-    class: MONITOR_CLASS,
-    path,
-    props: {
-      [NAME_KEY]: params.name ?? params.url,
-      [MONITOR_KEYS.url]: params.url,
-      [MONITOR_KEYS.status]: 'unknown',
-    },
-  })) as { id: string }
-  return { id: created.id, path }
-}

package/template/runtime/monitoring/page/add.ts

@@ -1,21 +0,0 @@
-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/monitoring/page/check.ts

@@ -1,50 +0,0 @@
-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/monitoring/page/create.ts

@@ -1,24 +0,0 @@
-/**
- * `StatusPage.create` (static) — create a StatusPage node under `/monitoring/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/monitoring/page/index.ts

@@ -1,9 +0,0 @@
-/**
- * StatusPage operations inside the monitoring bounded context — 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/runtime/shared.ts

@@ -1,21 +0,0 @@
-/**
- * Runtime-internal helpers shared across the context's operations. Not exported
- * from the domain — just the seam the operation files agree on.
- */
-
-/**
- * The minimal kernel surface the operations need — kept narrow so each is
- * unit-testable with a fake `{ call }`. The SDK hands the real client at the
- * `runtime/index.ts` seam.
- */
-export type CallableKernel = { call(path: string, params: unknown): Promise<unknown> }
-
-/** True for the kernel's create-collision error — lets `seed` stay idempotent. */
-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/schema/monitor.ts

@@ -1,92 +0,0 @@
-/**
- * Monitoring context — the domain's single bounded slice: a `Checkable` contract
- * implemented by two classes, plus the edge that binds them.
- *
- *   - 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. (The demo set is laid down by
- *                             the standalone `seed` function — see `functions/`.)
- *   - 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, 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 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 `check()` reports — the subject's current health verdict. */
-export const CheckResult = z.object({ status: z.string() })
-
-export const Checkable = nodeInterface({
-  methods: {
-    // `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: [Checkable],
-  props: {
-    /** The target URL this monitor probes. */
-    url: z.string(),
-    // Live status, written by `check`. PLAIN STRING, not `z.enum()`: `::update`
-    // 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(),
-    /** Last observed round-trip latency, in ms. */
-    latencyMs: z.number().int().optional(),
-    /** ISO timestamp of the last check. */
-    lastCheckedAt: z.string().optional(),
-  },
-  methods: {
-    // 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/monitoring/monitor/check.ts`.
-    check: fn({ returns: CheckResult }),
-    /** Create a Monitor under `/monitoring/monitors`. */
-    watch: fn({
-      static: true,
-      params: { url: z.string(), name: z.string().optional() },
-      returns: NodeRef,
-    }),
-  },
-})
-
-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/monitoring/page/check.ts`.
-    check: fn({ returns: CheckResult }),
-    /** Create a StatusPage under `/monitoring/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/status-page.ts

@@ -1,16 +0,0 @@
-/**
- * `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/views/welcome.ts

@@ -1,35 +0,0 @@
-/**
- * `welcome` — a lightweight inline-HTML View, rendered straight from the worker
- * (no SPA, no client bundle, no shell handshake). Because it has a `render`, the
- * SDK mounts a worker route and the View node's iframe points at
- * `<publicUrl>/views/welcome`. Add a rich, shell-connected view by dropping a
- * `client/` SPA in and binding a View to `/ui/<route>` instead.
- */
-import { defineView } from '@astrale-os/sdk'
-
-export const welcome = defineView({
-  auth: 'public',
-  render: ({ c }) =>
-    c.html(
-      `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>astrale domain</title>
-    <style>
-      body { font: 14px/1.6 system-ui, sans-serif; margin: 2rem; color: #111; max-width: 40rem; }
-      code { background: #f4f4f5; padding: 0.1rem 0.35rem; border-radius: 4px; }
-      h1 { font-size: 1.25rem; }
-    </style>
-  </head>
-  <body>
-    <h1>Your Astrale domain is live</h1>
-    <p>This inline-HTML view is rendered by the worker. The RPC surface and the
-       <code>seed</code> post-install hook run alongside it.</p>
-    <p>Edit <code>views/welcome.ts</code> to change this page — it hot-reloads at
-       the same URL.</p>
-  </body>
-</html>`,
-    ),
-})