@astrale-os/adapter-cloudflare 0.3.1 → 0.4.0

package/template/core/monitor/keys.ts

@@ -1,41 +0,0 @@
-/**
- * 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/edge paths. */
-export const MONITOR_CLASS = D.Monitor.path.class.raw
-export const STATUS_PAGE_CLASS = D.StatusPage.path.class.raw
-export const WATCHES_EDGE = D.watches.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
-
-/** Qualified storage key for the StatusPage's rolled-up status. */
-export const PAGE_KEYS = {
-  status: D.StatusPage.status.key,
-} as const
-
-/** Qualified key for the `watches` edge's `critical` prop. Edge-prop accessors
- *  aren't typed yet (an SDK gap), so this casts to read the key. */
-export const WATCHES_KEYS = {
-  critical: (D.watches as unknown as { critical: { key: string } }).critical.key,
-} as const

package/template/core/monitor/node.ts

@@ -1,63 +0,0 @@
-/**
- * Node identity — PURE domain constants + slug logic (no I/O): where monitors and
- * status pages live in the graph, how a new node's slug is formed, and the seed
- * set. `runtime/` consumes these; the IMPURE bits (the slug's entropy suffix, the
- * node writes) stay in `runtime/`, so this file is deterministic and testable.
- */
-
-/** Where monitoring nodes live in the graph (domain layout; `seed` creates the folders). */
-export const MONITORING_PARENT = '/monitoring'
-export const MONITORS_PARENT = `${MONITORING_PARENT}/monitors`
-export const STATUS_PAGES_PARENT = `${MONITORING_PARENT}/pages`
-
-/** Deterministic URL-/name-safe stem (lowercased, non-alnum → `-`, clamped). Pure. */
-export function slugify(text: string): string {
-  return (
-    text
-      .replace(/^https?:\/\//i, '')
-      .toLowerCase()
-      .replace(/[^a-z0-9]+/g, '-')
-      .replace(/^-|-$/g, '')
-      .slice(0, 40) || 'node'
-  )
-}
-
-/**
- * Slug for a NEW node: the stem + a caller-supplied `suffix`. Pure — `runtime/`
- * injects the `suffix` (clock/RNG entropy for collision safety) so core stays
- * deterministic. `seed` uses fixed slugs (not this) for idempotency.
- */
-export function uniqueSlug(text: string, suffix: string): string {
-  return `${slugify(text)}-${suffix}`
-}
-
-export interface StarterMonitor {
-  slug: string
-  name: string
-  url: string
-  /** Whether the seeded status page treats this monitor as critical. */
-  critical: boolean
-}
-
-/**
- * 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 homepage',
-    url: 'https://astrale.ai',
-    critical: true,
-  },
-  {
-    slug: 'httpbin-200',
-    name: 'HTTP 200 smoke check',
-    url: 'https://httpbin.org/status/200',
-    critical: false,
-  },
-]
-
-/** The status page `seed` creates, watching every starter monitor. */
-export const STARTER_PAGE = { slug: 'status', name: 'Public status' } as const

package/template/integrations/prober/http.ts

@@ -1,32 +0,0 @@
-/**
- * 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

@@ -1,18 +0,0 @@
-/**
- * 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

@@ -1,26 +0,0 @@
-/**
- * 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

@@ -1,65 +0,0 @@
-/**
- * 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
-}