@astrale-os/adapter-cloudflare 0.1.9 → 0.1.10

package/template/core/monitor/index.ts

@@ -0,0 +1,9 @@
+/**
+ * The monitor bounded context's PURE core, in one place: schema accessors
+ * (`keys`), the health status rule (`health`), and node identity/layout/seed
+ * data (`node`). No I/O, no clock/RNG — all deterministic + testable.
+ * `runtime/monitor/` imports the operations' logic from here.
+ */
+export * from './keys'
+export * from './health'
+export * from './node'

package/template/core/monitor/keys.ts

@@ -0,0 +1,29 @@
+/**
+ * Compiled-schema accessors for the monitor context — the ONE place class paths,
+ * method paths, and qualified prop keys come from. Pure (schema-derived); never
+ * hand-write key strings. `D` (the compiled domain) comes from `schema/index`,
+ * re-exported here so the rest of the context reads it from one place.
+ */
+import { K } from '@astrale-os/kernel-core'
+
+import { D } from '../../schema'
+
+export { D, K }
+
+/** Kernel ops/classes the logic addresses. */
+export const NODE_CREATE = K.Node.createNode.path.method.raw
+export const FOLDER_CLASS = K.Folder.path.class.raw
+export const NAME_KEY = K.Named.name.key
+
+/** Domain class paths. */
+export const MONITOR_CLASS = D.Monitor.path.class.raw
+export const DEPENDS_ON_EDGE = D.depends_on.path.class.raw
+
+/** Qualified storage keys for Monitor node props. */
+export const MONITOR_KEYS = {
+  url: D.Monitor.url.key,
+  status: D.Monitor.status.key,
+  statusCode: D.Monitor.statusCode.key,
+  latencyMs: D.Monitor.latencyMs.key,
+  lastCheckedAt: D.Monitor.lastCheckedAt.key,
+} as const

package/template/core/monitor/node.ts

@@ -0,0 +1,51 @@
+/**
+ * Monitor node identity — PURE domain constants + slug logic (no I/O): where
+ * monitors live in the graph, how a new node's slug is formed, and the seed set.
+ * `runtime/monitor/` consumes these. The IMPURE bits (the slug's entropy suffix,
+ * the actual node writes) stay in `runtime/`, so this file is deterministic and
+ * trivially testable.
+ */
+
+/** Where Monitor nodes live in the graph — a domain layout choice (`seed` creates the folder). */
+export const MONITORS_PARENT = '/monitors'
+
+/**
+ * Deterministic URL-safe stem for a monitor's node slug (host + path, lowercased,
+ * non-alnum → `-`). Pure.
+ */
+export function slugForUrl(url: string): string {
+  return (
+    url
+      .replace(/^https?:\/\//i, '')
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-|-$/g, '')
+      .slice(0, 40) || 'monitor'
+  )
+}
+
+/**
+ * Slug for a NEW monitor node: the url stem + a caller-supplied `suffix`. Pure —
+ * `runtime/monitor/watch` injects the `suffix` (clock/RNG entropy for collision
+ * safety) so core stays deterministic. `seed` doesn't use this (it pins fixed
+ * slugs for idempotency); `watch` does.
+ */
+export function monitorSlug(url: string, suffix: string): string {
+  return `${slugForUrl(url)}-${suffix}`
+}
+
+export interface StarterMonitor {
+  slug: string
+  name: string
+  url: string
+}
+
+/**
+ * Monitors laid down by `seed` (postInstall). httpbin returns a deterministic
+ * status code, so the second starter is a stable demo target; the first points at
+ * a real site. Fixed slugs keep `seed` idempotent across reinstalls.
+ */
+export const STARTERS: readonly StarterMonitor[] = [
+  { slug: 'astrale', name: 'Astrale', url: 'https://astrale.ai' },
+  { slug: 'httpbin-200', name: 'httpbin (200)', url: 'https://httpbin.org/status/200' },
+]

package/template/deps.ts

@@ -5,21 +5,21 @@
  * it's where ports/clients are wired once instead of being re-derived in every
  * handler.
  *
- * The summarizer port is resolved ON-REQUEST (lazy `summarizer()` via the
- * registry), not here — so this stays a cheap synchronous wiring step and a
- * worker never validates a provider's env until a handler actually uses it.
+ * The prober port is resolved PER-REQUEST and PER-NODE (each `prober(target)`
+ * call), not here — so this stays a cheap synchronous wiring step and the backend
+ * can be chosen from the monitor being probed, not just the env.
  *
  * Omit the `deps` field in `domain.ts` for the trivial case (handlers then get
- * raw `Env`). Transform here the moment a handler should depend on a PORT
- * instead of raw config — that's the whole point of this seam.
+ * raw `Env`). Transform here the moment a handler should depend on a PORT instead
+ * of raw config — that's the whole point of this seam.
  */
-import { buildSummarizerRegistry, type SummarizerRegistry } from './integrations/summary/registry'
+import { buildProberRegistry, type ProberRegistry } from './integrations/prober/registry'
 import type { Env } from './env'
 
 /** Typed dependency container handed to every method as `ctx.deps`. */
-export interface Deps extends SummarizerRegistry {}
+export interface Deps extends ProberRegistry {}
 
 /** Map the worker env to the handler deps (the seam `defineDomain({ deps })` mounts). */
 export function deps(env: Env): Deps {
-  return buildSummarizerRegistry(env)
+  return buildProberRegistry(env)
 }

package/template/domain.ts

@@ -28,6 +28,6 @@ export const domain = defineDomain({
   views,
   functions,
   client: { dir: 'client' },
-  postInstall: `/:${schema.domain}:class.Note:seed`,
+  postInstall: `/:${schema.domain}:class.Monitor:seed`,
   requires: [],
 })

package/template/env.ts

@@ -19,15 +19,8 @@ export interface Env {
   /** Dev-only: forward /ui/* to a running Vite dev server. */
   VIEW_DEV_URL?: string
 
-  // ── Summarizer (the example external-API integration) ─────────────
-  /** Which summarizer adapter to bind: `heuristic` (default, no secret) | `http`. */
-  NOTE_SUMMARIZER?: string
-  /** `http` only — bearer token for the OpenAI-compatible upstream (a secret). */
-  SUMMARIZER_API_KEY?: string
-  /** `http` only — OpenAI-compatible base URL (e.g. https://api.openai.com/v1). */
-  SUMMARIZER_BASE_URL?: string
-  /** `http` only — model id (default gpt-4o-mini). */
-  SUMMARIZER_MODEL?: string
+  /** `http` only — per-probe timeout in ms (default 10000). */
+  PROBE_TIMEOUT_MS?: string
 
   [key: string]: unknown
 }

package/template/integrations/prober/http.ts

@@ -0,0 +1,43 @@
+/**
+ * HTTP prober — the REAL external adapter: a single keyless `fetch` to the
+ * target, timing the round-trip. This is the shape your domain's external calls
+ * take — a timeout via `AbortSignal`, failures mapped to a domain result rather
+ * than thrown. NO API key: a fresh scaffold makes a true external call out of
+ * the box (it's the registry default).
+ */
+import type { Prober, ProbeResult } from './port'
+
+export interface HttpProberConfig {
+  /** Probe verb — `GET` (default) or the lighter `HEAD`. */
+  method?: 'GET' | 'HEAD'
+  /** Per-probe timeout in ms (default 10000). */
+  timeoutMs?: number
+}
+
+const DEFAULT_TIMEOUT_MS = 10_000
+
+/** Build the keyless HTTP prober. */
+export function createHttpProber(config: HttpProberConfig = {}): Prober {
+  const method = config.method ?? 'GET'
+  const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  return {
+    async probe(url): Promise<ProbeResult> {
+      const start = Date.now()
+      try {
+        const res = await fetch(url, {
+          method,
+          redirect: 'follow',
+          signal: AbortSignal.timeout(timeoutMs),
+        })
+        return {
+          statusCode: res.status,
+          latencyMs: Date.now() - start,
+          ok: res.status >= 200 && res.status < 400,
+        }
+      } catch {
+        // Unreachable / timeout / DNS failure — a `down` result, not an error.
+        return { statusCode: 0, latencyMs: Date.now() - start, ok: false }
+      }
+    },
+  }
+}

package/template/integrations/prober/mock.ts

@@ -0,0 +1,22 @@
+/**
+ * Mock prober — offline + deterministic, no network. Used by tests (construct it
+ * directly with the status you want) and by `PROBER=mock` for an offline dev
+ * loop. Returns a fixed result regardless of URL.
+ */
+import type { Prober, ProbeResult } from './port'
+
+/** Build an offline prober that always returns `opts` (default: a healthy 200). */
+export function createMockProber(opts: { statusCode?: number; latencyMs?: number } = {}): Prober {
+  const statusCode = opts.statusCode ?? 200
+  const latencyMs = opts.latencyMs ?? 1
+  const result: ProbeResult = {
+    statusCode,
+    latencyMs,
+    ok: statusCode >= 200 && statusCode < 400,
+  }
+  return {
+    probe() {
+      return Promise.resolve(result)
+    },
+  }
+}

package/template/integrations/prober/port.ts

@@ -0,0 +1,28 @@
+/**
+ * Prober — the PORT between the domain's logic and whatever performs the actual
+ * uptime probe. This is the external-API seam every real domain has, reduced to
+ * the narrowest interface the logic needs.
+ *
+ * `runtime/` logic depends on THIS interface only — never on `fetch`, an SDK, or
+ * `env`. Adapters in this folder implement it: `http.ts` (a real, keyless HTTP
+ * request) and `mock.ts` (offline + deterministic, for tests). The registry
+ * picks one from `env`; the handler logic only ever sees the resolved port. Swap
+ * or add a backend = one adapter + one arm in `registry.ts`.
+ */
+export interface ProbeResult {
+  /** Observed HTTP status code, or `0` if the host was unreachable. */
+  statusCode: number
+  /** Round-trip time in ms. */
+  latencyMs: number
+  /** Convenience flag — `statusCode` in `[200, 400)`. */
+  ok: boolean
+}
+
+export interface Prober {
+  /**
+   * Probe a URL once. MUST resolve, never reject: an unreachable host or a
+   * timeout is a `down` RESULT (`statusCode: 0`), not an error — a probe failing
+   * is the normal case a monitor exists to observe.
+   */
+  probe(url: string): Promise<ProbeResult>
+}

package/template/integrations/prober/registry.ts

@@ -0,0 +1,66 @@
+/**
+ * Prober registry — the ONE place the worker env (and the probed node) become the
+ * live `Prober` port. Adding a backend = one more arm in `selectProber`; handler
+ * logic only ever sees the resolved port.
+ *
+ * Resolution is PER-REQUEST and PER-NODE: each `prober(target)` call selects +
+ * builds the port from env AND the monitor being probed — nothing is built at
+ * `deps()` / isolate setup. A per-node choice can't be memoized at the isolate
+ * level, which is exactly why `deps` exposes `prober()` as a FUNCTION, not a
+ * value. The default is the keyless `http` prober (so the scaffold makes a real
+ * probe out of the box); `PROBER=mock` forces the offline prober.
+ */
+import type { Env } from '../../env'
+import type { Prober } from './port'
+
+import { createHttpProber } from './http'
+import { createMockProber } from './mock'
+
+/**
+ * The node a probe is for — what the registry may branch on. Mirrors how the
+ * `services` domain picks a provider from a node's class; here we also look at
+ * the target url. The handler passes this from `self.node()`; omit it for
+ * node-less callers (e.g. `seed`, which just wants the env default).
+ */
+export interface ProbeTarget {
+  /** The monitor node's class path (`node.class.raw`). */
+  class: string
+  /** The url this monitor probes (`node.props[MONITOR_KEYS.url]`). */
+  url: string
+}
+
+export interface ProberRegistry {
+  /** Resolve the prober for a probe — built per call from env + the target node. */
+  prober(target?: ProbeTarget): Prober
+}
+
+/** Build the registry from the worker env. The port is resolved per request. */
+export function buildProberRegistry(env: Env): ProberRegistry {
+  return {
+    prober(target) {
+      return selectProber(env, target)
+    },
+  }
+}
+
+const DEFAULT_TIMEOUT_MS = 10_000
+
+/** Bind the abstract prober port to the concrete adapter for this env + target. */
+function selectProber(env: Env, target?: ProbeTarget): Prober {
+  if (target && isLocalTarget(target.url)) {
+    return createMockProber()
+  }
+  // Default: the real, keyless HTTP prober.
+  return createHttpProber({ timeoutMs: parseIntOr(env.PROBE_TIMEOUT_MS, DEFAULT_TIMEOUT_MS) })
+}
+
+/** A loopback / unspecified host the public edge can't reach. */
+function isLocalTarget(url: string): boolean {
+  return /^https?:\/\/(localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\])(:|\/|$)/i.test(url)
+}
+
+function parseIntOr(value: string | undefined, fallback: number): number {
+  if (!value) return fallback
+  const n = Number.parseInt(value, 10)
+  return Number.isFinite(n) && n > 0 ? n : fallback
+}

package/template/package.json

@@ -14,7 +14,7 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@astrale-os/adapter-cloudflare": ">=0.1.9 <1.0.0",
+    "@astrale-os/adapter-cloudflare": ">=0.1.10 <1.0.0",
     "@astrale-os/kernel-core": ">=0.4.3 <1.0.0",
     "@astrale-os/kernel-dsl": ">=0.1.2 <1.0.0",
     "@astrale-os/sdk": ">=0.1.7 <1.0.0",