@astrale-os/adapter-cloudflare 0.3.1 → 0.3.2

package/template/client/__tests__/seam.test.tsx

@@ -1,115 +0,0 @@
-/**
- * What the presentation/logic seam unlocks:
- *
- *  1. PRESENTATION components (`@/ui`) test with ZERO infrastructure — no fake
- *     shell, no fake kernel, no session. Just props in, DOM out. (Contrast
- *     app.test.tsx, which stands up a handshake + kernel stub to reach the same
- *     markup.)
- *  2. FEATURE hooks (`@/status`) test against a bare `KernelClient` (the fake
- *     kernel fetch stub) with no handshake — the write lifecycle and the
- *     reload signal are verified once, in isolation.
- */
-import { act, cleanup, render, renderHook, screen, waitFor } from '@testing-library/react'
-import { afterEach, describe, expect, it } from 'vitest'
-
-import { useCheck, useCheckable } from '@/status'
-import { StatusBadge } from '@/ui'
-
-import { checkableNode, fakeKernelSession, installFakeKernel, ok } from './harness'
-
-afterEach(cleanup)
-
-describe('presentation is pure (no kernel, no session, no shell)', () => {
-  it('StatusBadge renders the label and tone class for each status', () => {
-    const { rerender } = render(<StatusBadge status="up" />)
-    expect(screen.getByText('UP').className).toContain('status-up')
-
-    rerender(<StatusBadge status="degraded" />)
-    expect(screen.getByText('DEGRADED').className).toContain('status-degraded')
-
-    rerender(<StatusBadge status="down" />)
-    expect(screen.getByText('DOWN').className).toContain('status-down')
-
-    rerender(<StatusBadge status="weird" />)
-    expect(screen.getByText('UNKNOWN').className).toContain('status-unknown')
-  })
-})
-
-describe('useCheckable — query + reload signal', () => {
-  it('loads the record, then exposes reloading across a reload()', async () => {
-    const session = fakeKernelSession()
-    let status = 'down'
-    const kernel = installFakeKernel(() => ok(checkableNode({ id: 'page-1', name: 'API', status })))
-
-    try {
-      const { result } = renderHook(() => useCheckable(session, 'page-1'))
-      await waitFor(() => expect(result.current.state).toBe('ok'))
-      expect(result.current.record?.status).toBe('down')
-      expect(result.current.reloading).toBe(false)
-
-      // Server-side status flips; a reload picks it up and flags `reloading`.
-      status = 'up'
-      act(() => {
-        result.current.reload()
-      })
-      expect(result.current.reloading).toBe(true)
-
-      await waitFor(() => expect(result.current.reloading).toBe(false))
-      expect(result.current.record?.status).toBe('up')
-    } finally {
-      kernel.restore()
-    }
-  })
-
-  it('surfaces a node-load error', async () => {
-    const session = fakeKernelSession()
-    const kernel = installFakeKernel(() => ({ error: { code: 3002, message: 'Path not found' } }))
-    try {
-      const { result } = renderHook(() => useCheckable(session, 'missing'))
-      await waitFor(() => expect(result.current.state).toBe('error'))
-      expect(result.current.message).toMatch(/Path not found/)
-    } finally {
-      kernel.restore()
-    }
-  })
-})
-
-describe('useCheck — the shared write-lifecycle', () => {
-  it('idle → running → done, then resolves true', async () => {
-    const session = fakeKernelSession()
-    const kernel = installFakeKernel(() => ok(null))
-    try {
-      const { result } = renderHook(() => useCheck(session, 'page-1'))
-      expect(result.current.phase).toBe('idle')
-
-      let returned: boolean | undefined
-      await act(async () => {
-        returned = await result.current.run()
-      })
-      expect(returned).toBe(true)
-      expect(result.current.phase).toBe('done')
-      expect(result.current.error).toBeNull()
-    } finally {
-      kernel.restore()
-    }
-  })
-
-  it('captures a failure: phase failed, error set, resolves false', async () => {
-    const session = fakeKernelSession()
-    const kernel = installFakeKernel(() => ({
-      error: { code: 2004, message: 'Permission denied' },
-    }))
-    try {
-      const { result } = renderHook(() => useCheck(session, 'page-1'))
-      let returned: boolean | undefined
-      await act(async () => {
-        returned = await result.current.run()
-      })
-      expect(returned).toBe(false)
-      expect(result.current.phase).toBe('failed')
-      expect(result.current.error).toMatch(/Permission denied/)
-    } finally {
-      kernel.restore()
-    }
-  })
-})

package/template/client/src/status/components/StatusCard.tsx

@@ -1,160 +0,0 @@
-/**
- * StatusCard — the status feature's one container. It owns the data/logic: loads
- * the node (`useCheckable`), wires the `check` write (`useCheck`), and composes
- * the presentation. Handles the query's loading/error/ok states; on `ok` it
- * renders a `Panel` with the check-error banner (if any) + the StatusBadge.
- * "Check now" runs the check then reloads the node so the fresh status renders.
- *
- * The generic surfaces come from the `@/ui` design system; the only domain-shaped
- * primitive is the shared `StatusBadge`.
- */
-import type { KernelClient } from '@/shell'
-
-import {
-  EmptyState,
-  ErrorBanner,
-  ExternalLink,
-  Mono,
-  Panel,
-  relativeTime,
-  Spinner,
-  StatusBadge,
-} from '@/ui'
-
-import type { WatchedMonitorRecord } from '../status.types'
-
-import { useCheck, useCheckable } from '../hooks'
-
-function latestCheckedAt(monitors: WatchedMonitorRecord[]): string | undefined {
-  let latest = 0
-  let latestIso: string | undefined
-  for (const monitor of monitors) {
-    if (!monitor.lastCheckedAt) continue
-    const time = Date.parse(monitor.lastCheckedAt)
-    if (!Number.isNaN(time) && time > latest) {
-      latest = time
-      latestIso = monitor.lastCheckedAt
-    }
-  }
-  return latestIso
-}
-
-export function StatusCard({ session, nodeId }: { session: KernelClient; nodeId: string }) {
-  const checkable = useCheckable(session, nodeId)
-  const check = useCheck(session, nodeId)
-
-  async function checkNow() {
-    if (await check.run()) checkable.reload()
-  }
-
-  if (checkable.state === 'idle' || checkable.state === 'loading') {
-    return <Spinner label="Loading…" />
-  }
-  if (checkable.state === 'error') {
-    return <ErrorBanner>Failed to load: {checkable.message}</ErrorBanner>
-  }
-
-  const record = checkable.record!
-  const checking = check.phase === 'running'
-  const busy = checking || checkable.reloading
-  const monitors = record.monitors
-  const criticalCount = monitors.filter((monitor) => monitor.critical).length
-  const downCount = monitors.filter((monitor) => monitor.status === 'down').length
-  const lastChecked = latestCheckedAt(monitors)
-  const checkButton = (
-    <button type="button" className="check-btn" onClick={checkNow} disabled={busy}>
-      {checking ? 'Checking...' : checkable.reloading ? 'Refreshing...' : 'Check now'}
-    </button>
-  )
-
-  return (
-    <Panel title={record.name} actions={checkButton}>
-      {check.phase === 'failed' && check.error && (
-        <ErrorBanner>Check failed: {check.error}</ErrorBanner>
-      )}
-      <div className="status-dashboard">
-        <div className="status-overview">
-          <div>
-            <p className="status-label">Overall health</p>
-            <StatusBadge status={record.status} />
-          </div>
-          <div className="summary-grid" aria-label="Monitoring summary">
-            <div className="summary-cell">
-              <span className="summary-value">{monitors.length}</span>
-              <span className="summary-label">monitors</span>
-            </div>
-            <div className="summary-cell">
-              <span className="summary-value">{criticalCount}</span>
-              <span className="summary-label">critical</span>
-            </div>
-            <div className="summary-cell">
-              <span className="summary-value">{downCount}</span>
-              <span className="summary-label">down</span>
-            </div>
-          </div>
-        </div>
-
-        <div className="status-meta">
-          <span>Page path</span>
-          <Mono value={record.path} />
-          <span>Last checked</span>
-          <span className="mono" title={lastChecked}>
-            {relativeTime(lastChecked)}
-          </span>
-        </div>
-
-        <section className="monitor-section" aria-label="Watched monitors">
-          <div className="monitor-section-head">
-            <h3>Watched monitors</h3>
-            {checkable.reloading && <span className="refreshing">Refreshing</span>}
-          </div>
-
-          {monitors.length === 0 ? (
-            <EmptyState hint="StatusPage.add({ monitor, critical })">
-              This page is not watching any monitors yet.
-            </EmptyState>
-          ) : (
-            <div className="monitor-list">
-              {monitors.map((monitor) => (
-                <MonitorRow key={`${monitor.path}:${monitor.critical}`} monitor={monitor} />
-              ))}
-            </div>
-          )}
-        </section>
-      </div>
-    </Panel>
-  )
-}
-
-function MonitorRow({ monitor }: { monitor: WatchedMonitorRecord }) {
-  return (
-    <article className="monitor-row">
-      <div className="monitor-status">
-        <StatusBadge status={monitor.status} />
-        <span className={monitor.critical ? 'weight weight-critical' : 'weight'}>
-          {monitor.critical ? 'Critical' : 'Standard'}
-        </span>
-      </div>
-
-      <div className="monitor-main">
-        <h4>{monitor.name}</h4>
-        <ExternalLink url={monitor.url} />
-      </div>
-
-      <dl className="monitor-metrics">
-        <div>
-          <dt>HTTP</dt>
-          <dd>{monitor.statusCode ?? '-'}</dd>
-        </div>
-        <div>
-          <dt>Latency</dt>
-          <dd>{monitor.latencyMs === undefined ? '-' : `${monitor.latencyMs}ms`}</dd>
-        </div>
-        <div>
-          <dt>Checked</dt>
-          <dd title={monitor.lastCheckedAt}>{relativeTime(monitor.lastCheckedAt)}</dd>
-        </div>
-      </dl>
-    </article>
-  )
-}

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

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

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

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

package/template/client/src/status/hooks/useCheck.mutation.ts

@@ -1,16 +0,0 @@
-/** Run a checkable node's `check` — the feature's one write capability. */
-import { type Capability, type KernelClient, useCapability } from '@/shell'
-
-import { check } from '../status.api'
-
-/**
- * Wrap `@<id>::check` in the shared `useCapability` lifecycle (idle → running →
- * done/failed). The view runs it and, on success, reloads the node so the fresh
- * status renders:
- *
- *   const probe = useCheck(session, nodeId)
- *   if (await probe.run()) reload()
- */
-export function useCheck(session: KernelClient, nodeId: string): Capability {
-  return useCapability(() => check(session, nodeId))
-}

package/template/client/src/status/hooks/useCheckable.query.ts

@@ -1,72 +0,0 @@
-/** Load a status page with its watched monitors, with reload for post-check refresh. */
-
-import { type KernelClient, type KernelNode, useAsync } from '@/shell'
-
-import type { StatusPanelRecord, WatchedMonitorRecord } from '../status.types'
-
-import { getCheckable, getLinks, getNodeRef } from '../status.api'
-import { checkableFromNode, monitorFromRef, watchedMonitorRefs } from '../status.mappers'
-
-export type CheckableQuery = {
-  /** Lifecycle of the underlying page + monitor graph read. */
-  state: 'idle' | 'loading' | 'error' | 'ok'
-  /** The projected record once `ok`. */
-  record?: StatusPanelRecord
-  /** Failure message once `error`. */
-  message?: string
-  /** Re-fetch the page and watched monitors after `check` mutates them. */
-  reload(): void
-  /** True while a `reload()`-triggered re-fetch is in flight. */
-  reloading: boolean
-}
-
-async function loadMonitor(
-  session: KernelClient,
-  ref: ReturnType<typeof watchedMonitorRefs>[number],
-): Promise<WatchedMonitorRecord> {
-  try {
-    const node = (await getNodeRef(session, ref.target)) as KernelNode
-    return { ...checkableFromNode(node), critical: ref.critical }
-  } catch {
-    return monitorFromRef(ref)
-  }
-}
-
-async function loadStatusPanel(session: KernelClient, nodeId: string): Promise<StatusPanelRecord> {
-  const page = checkableFromNode((await getCheckable(session, nodeId)) as KernelNode)
-  if (page.className !== 'StatusPage') return { ...page, monitors: [] }
-
-  const refs = watchedMonitorRefs(await getLinks(session, nodeId))
-  const monitors = await Promise.all(refs.map((ref) => loadMonitor(session, ref)))
-  return { ...page, monitors }
-}
-
-/**
- * Load the status page `nodeId`, then its outgoing `watches` targets. The view
- * calls `reload()` after `::check`, so the rolled-up page status and all monitor
- * rows refresh together.
- */
-export function useCheckable(session: KernelClient, nodeId: string): CheckableQuery {
-  const resource = useAsync(() => loadStatusPanel(session, nodeId), [session, nodeId])
-
-  switch (resource.state.status) {
-    case 'ok':
-      return {
-        state: 'ok',
-        record: resource.state.data,
-        reload: resource.reload,
-        reloading: resource.reloading,
-      }
-    case 'error':
-      return {
-        state: 'error',
-        message: resource.state.message,
-        reload: resource.reload,
-        reloading: resource.reloading,
-      }
-    case 'loading':
-      return { state: 'loading', reload: resource.reload, reloading: resource.reloading }
-    default:
-      return { state: 'idle', reload: resource.reload, reloading: resource.reloading }
-  }
-}

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

@@ -1,7 +0,0 @@
-/** The status feature — its api, types, mappers, hooks and components. One card,
- * polymorphic over any `Checkable` node (Monitor or StatusPage). */
-export * from './components'
-export * from './hooks'
-export { check } from './status.api'
-export { checkableFromNode, watchedMonitorRefs } from './status.mappers'
-export type { CheckableRecord, StatusPanelRecord, WatchedMonitorRecord } from './status.types'

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

@@ -1,29 +0,0 @@
-/** Raw kernel calls for the status feature — node instance methods. */
-import { callMethod, invokeNode, type KernelClient } from '@/shell'
-
-/**
- * Run a checkable node's `check` instance method (`@<id>::check`). The single
- * write both classes share: a Monitor probes its target URL, a StatusPage rolls
- * its watched monitors up — each updates its own `status` prop server-side; the
- * caller reloads the node to render the fresh value.
- */
-export function check(session: KernelClient, nodeId: string): Promise<unknown> {
-  return invokeNode(session, nodeId, 'check', {})
-}
-
-export function getCheckable(session: KernelClient, nodeId: string): Promise<unknown> {
-  return invokeNode(session, nodeId, 'get', {})
-}
-
-export function getLinks(session: KernelClient, nodeId: string): Promise<unknown> {
-  return invokeNode(session, nodeId, 'getLinks', { direction: 'out' })
-}
-
-function getRefMethod(ref: string): string {
-  if (ref.startsWith('/') || ref.startsWith('@')) return `${ref}::get`
-  return `@${ref}::get`
-}
-
-export function getNodeRef(session: KernelClient, ref: string): Promise<unknown> {
-  return callMethod(session, getRefMethod(ref), {})
-}

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

@@ -1,102 +0,0 @@
-/** Kernel graph payloads -> typed records for the status feature. */
-import {
-  classShortName,
-  type KernelNode,
-  PROP,
-  qualifiedProp,
-  qualifiedString,
-  readProp,
-} from '@/shell'
-
-import type { CheckableRecord, WatchedMonitorRecord } from './status.types'
-
-const lastSegment = (path: string): string => path.split('/').filter(Boolean).pop() ?? path
-
-function numericProp(props: Record<string, unknown>, name: string): number | undefined {
-  const value = qualifiedProp(props, name)
-  if (typeof value === 'number' && Number.isFinite(value)) return value
-  if (typeof value === 'string' && value.trim() !== '') {
-    const parsed = Number(value)
-    if (Number.isFinite(parsed)) return parsed
-  }
-  return undefined
-}
-
-/**
- * Project a `Checkable` `KernelNode` into a `CheckableRecord`: the name from the
- * kernel `Named.name` key, plus any monitor details the node carries.
- */
-export function checkableFromNode(node: KernelNode): CheckableRecord {
-  const p = node.props ?? {}
-  return {
-    id: node.id,
-    path: node.path ?? `@${node.id}`,
-    className: classShortName(node),
-    name: readProp(p, PROP.named.name) ?? lastSegment(node.path ?? '') ?? node.id,
-    status: qualifiedString(p, 'status') ?? 'unknown',
-    url: qualifiedString(p, 'url'),
-    statusCode: numericProp(p, 'statusCode'),
-    latencyMs: numericProp(p, 'latencyMs'),
-    lastCheckedAt: qualifiedString(p, 'lastCheckedAt'),
-  }
-}
-
-type RawLink = {
-  class?: unknown
-  edgeClass?: unknown
-  target?: unknown
-  to?: unknown
-  props?: Record<string, unknown>
-}
-
-function rawString(value: unknown): string | undefined {
-  if (typeof value === 'string' && value !== '') return value
-  if (value && typeof value === 'object') {
-    const raw = (value as { raw?: unknown }).raw
-    if (typeof raw === 'string' && raw !== '') return raw
-  }
-  return undefined
-}
-
-function rawLinks(raw: unknown): RawLink[] {
-  if (Array.isArray(raw)) return raw as RawLink[]
-  const obj = raw as { links?: RawLink[]; edges?: RawLink[] } | null
-  return obj?.links ?? obj?.edges ?? []
-}
-
-function booleanProp(props: Record<string, unknown> | undefined, name: string): boolean {
-  if (!props) return false
-  const direct = props[name]
-  if (typeof direct === 'boolean') return direct
-  return qualifiedProp(props, name) === true
-}
-
-export type WatchedMonitorRef = {
-  target: string
-  critical: boolean
-}
-
-/** Parse outgoing StatusPage `watches` edges into target refs and roll-up weight. */
-export function watchedMonitorRefs(raw: unknown): WatchedMonitorRef[] {
-  const out: WatchedMonitorRef[] = []
-  for (const link of rawLinks(raw)) {
-    const cls = rawString(link.class) ?? rawString(link.edgeClass) ?? ''
-    if (cls && !cls.endsWith('class.watches') && !cls.endsWith('.watches')) continue
-    const target = rawString(link.target) ?? rawString(link.to)
-    if (!target) continue
-    out.push({ target, critical: booleanProp(link.props, 'critical') })
-  }
-  return out
-}
-
-/** Fallback row when a linked monitor ref exists but the target cannot be loaded. */
-export function monitorFromRef(ref: WatchedMonitorRef): WatchedMonitorRecord {
-  return {
-    id: ref.target,
-    path: ref.target,
-    className: 'Monitor',
-    name: lastSegment(ref.target.replace(/^@/, '')),
-    status: 'unknown',
-    critical: ref.critical,
-  }
-}

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

@@ -1,26 +0,0 @@
-/** The status feature's client types — what graph nodes project to. */
-
-/**
- * Client-side projection of the `Checkable` node the view renders (a StatusPage).
- * `status` stays a plain string — the subject's verdict
- * (up/degraded/down/unknown), which `StatusBadge` renders.
- */
-export type CheckableRecord = {
-  id: string
-  path: string
-  className: string
-  name: string
-  status: string
-  url?: string
-  statusCode?: number
-  latencyMs?: number
-  lastCheckedAt?: string
-}
-
-export type WatchedMonitorRecord = CheckableRecord & {
-  critical: boolean
-}
-
-export type StatusPanelRecord = CheckableRecord & {
-  monitors: WatchedMonitorRecord[]
-}

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

@@ -1,31 +0,0 @@
-/** Health status chip — pure presentational; styling lives in `styles.css`. */
-
-/** The health vocabulary the badge styles, shared across checkable nodes. */
-export type HealthStatus = 'up' | 'down' | 'degraded' | 'unknown'
-
-/** Map any raw status string to the four styled states (unrecognized → unknown). */
-function normalize(status: string): HealthStatus {
-  return status === 'up' || status === 'down' || status === 'degraded' ? status : 'unknown'
-}
-
-/**
- * Color-coded status pill: up = green, degraded = amber, down = red, unknown =
- * muted. The label is the uppercased status (`UP` / `DEGRADED` / `DOWN` /
- * `UNKNOWN`). Takes any raw status string — the vocabulary depends on the node
- * type (up/down for a Monitor, up/degraded/down for a StatusPage) — and styles
- * the four known states, falling back to `unknown` for anything else. Both
- * checkable node types render through it, so it lives in the feature-agnostic
- * `@/ui`, not a feature's own folder.
- */
-export function StatusBadge({ status }: { status: string }) {
-  const known = normalize(status)
-  const label =
-    known === 'up'
-      ? 'UP'
-      : known === 'degraded'
-        ? 'DEGRADED'
-        : known === 'down'
-          ? 'DOWN'
-          : 'UNKNOWN'
-  return <span className={`status-badge status-${known}`}>{label}</span>
-}

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

@@ -1,28 +0,0 @@
-/**
- * The status view — the SPA's one view: the StatusPage panel at `/ui/status-page`.
- * 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 `StatusCard`, the feature container that
- * loads the node, renders its rolled-up status, and exposes a "Check now" action.
- *
- * Pure composition — no data/transport logic lives here (that's `@/status` +
- * `@/shell`).
- */
-import { type ShellState, ViewFrame } from '@/shell'
-import { StatusCard } from '@/status'
-
-export function StatusView(shell: ShellState) {
-  return (
-    <ViewFrame shell={shell} title="Status page" subline="monitoring view">
-      {(session, nodeId) =>
-        nodeId ? (
-          // Keyed by node id so a target hot-swap remounts with fresh state.
-          <StatusCard key={nodeId} session={session} nodeId={nodeId} />
-        ) : (
-          <div className="banner">No target node — open this view from a StatusPage.</div>
-        )
-      }
-    </ViewFrame>
-  )
-}

package/template/core/monitor/health.ts

@@ -1,34 +0,0 @@
-/**
- * Health logic — PURE status rules, no I/O. `classify` maps one probe's HTTP code
- * to a monitor verdict; `rollup` aggregates a status page's watched monitors into
- * a page verdict. (Node identity/layout/seed data lives in `./node`; the kernel
- * reads/writes live in `runtime/`; the network probe behind the `Prober` port.)
- */
-
-/** A monitor's health verdict. `unknown` is the pre-first-check state. */
-export type HealthStatus = 'up' | 'down' | 'unknown'
-
-/**
- * Map an observed HTTP status code to a verdict. `0` means the host was
- * unreachable (DNS/timeout/refused) — that's `down`. 2xx/3xx is `up`; anything
- * else (4xx/5xx) is `down`. Pure.
- */
-export function classify(statusCode: number): HealthStatus {
-  if (statusCode >= 200 && statusCode < 400) return 'up'
-  return 'down'
-}
-
-/** A status page's rolled-up verdict — `degraded` = only non-critical checks down. */
-export type PageStatus = 'up' | 'degraded' | 'down' | 'unknown'
-
-/**
- * Roll up a page's watched monitors into a page verdict: a CRITICAL monitor down
- * ⇒ `down`; any other monitor down ⇒ `degraded`; all up ⇒ `up`; none ⇒ `unknown`.
- * Pure.
- */
-export function rollup(members: readonly { status: string; critical: boolean }[]): PageStatus {
-  if (members.length === 0) return 'unknown'
-  const down = members.filter((m) => m.status === 'down')
-  if (down.some((m) => m.critical)) return 'down'
-  return down.length > 0 ? 'degraded' : 'up'
-}

package/template/core/monitor/index.ts

@@ -1,9 +0,0 @@
-/**
- * The monitoring 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/monitoring/` imports the operations' logic from here.
- */
-export * from './keys'
-export * from './health'
-export * from './node'