@astrale-os/adapter-cloudflare 0.1.9 → 0.2.0

package/template/deps.ts

@@ -1,3 +1,5 @@
+import type { Env } from './env'
+
 /**
  * env → handler dependency container — the ONE place the worker env becomes the
  * typed `ctx.deps` every method reads. `defineDomain({ deps })` mounts it; the
@@ -5,21 +7,20 @@
  * 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 type { Env } from './env'
+import { buildProberRegistry, type ProberRegistry } from './integrations/prober/registry'
 
 /** 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,32 @@
+/**
+ * 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 {
+  /** Per-probe timeout in ms (default 10000). */
+  timeoutMs?: number
+}
+
+const DEFAULT_TIMEOUT_MS = 10_000
+
+/** Build the keyless HTTP prober (a `GET` with a timeout). */
+export function createHttpProber(config: HttpProberConfig = {}): Prober {
+  const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  return {
+    async probe(url): Promise<ProbeResult> {
+      const start = Date.now()
+      try {
+        const res = await fetch(url, { redirect: 'follow', signal: AbortSignal.timeout(timeoutMs) })
+        return { statusCode: res.status, latencyMs: Date.now() - start }
+      } catch {
+        // Unreachable / timeout / DNS failure — a `down` result, not an error.
+        return { statusCode: 0, latencyMs: Date.now() - start }
+      }
+    },
+  }
+}

package/template/integrations/prober/mock.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 }
+  return {
+    probe() {
+      return Promise.resolve(result)
+    },
+  }
+}

package/template/integrations/prober/port.ts

@@ -0,0 +1,26 @@
+/**
+ * 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
+}
+
+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,65 @@
+/**
+ * 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)
+    },
+  }
+}
+
+/** 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. Pass the env override (if any); the
+  // adapter owns the default timeout, so there's no second copy of it here.
+  return createHttpProber({ timeoutMs: parsePositiveInt(env.PROBE_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 parsePositiveInt(value: string | undefined): number | undefined {
+  if (!value) return undefined
+  const n = Number.parseInt(value, 10)
+  return Number.isFinite(n) && n > 0 ? n : undefined
+}

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.2.0 <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",