@astrale-os/adapter-cloudflare 0.5.0-beta.11 → 0.5.0-beta.13

package/src/cloudflare.ts

@@ -10,8 +10,11 @@
  */
 
 import type { DomainAdapter } from '@astrale-os/sdk'
+import type { DeployFetch } from '@astrale-os/sdk/deployment'
 
 import { defineAdapter } from '@astrale-os/sdk'
+import { deployCheck } from '@astrale-os/sdk/deployment'
+import { resolve } from 'node:path'
 
 import type { CloudflareParams } from './params.js'
 
@@ -24,7 +27,7 @@ import {
   runWranglerDeploy,
   runWranglerDev,
   runWranglerTypes,
-  watchFrontend,
+  startFrontendDev,
 } from './build/index.js'
 
 export function cloudflare(
@@ -39,7 +42,7 @@ export function cloudflare(
     runWranglerDeploy,
     runWranglerDev,
     runWranglerTypes,
-    watchFrontend,
+    startFrontendDev,
     waitUntilLive,
   })
 }
@@ -53,7 +56,7 @@ interface CloudflareAdapterDependencies {
   readonly runWranglerDeploy: typeof runWranglerDeploy
   readonly runWranglerDev: typeof runWranglerDev
   readonly runWranglerTypes: typeof runWranglerTypes
-  readonly watchFrontend: typeof watchFrontend
+  readonly startFrontendDev: typeof startFrontendDev
   readonly waitUntilLive: typeof waitUntilLive
 }
 
@@ -62,6 +65,7 @@ export function cloudflareWithDependencies(
   envs: Record<string, CloudflareParams>,
   dependencies: CloudflareAdapterDependencies,
 ): DomainAdapter<CloudflareParams> {
+  const frontendDevUrls = new Map<string, string>()
   return defineAdapter<CloudflareParams>({
     name: 'cloudflare',
     envs,
@@ -76,52 +80,56 @@ export function cloudflareWithDependencies(
 
     async watch(params, ctx) {
       const onLog = dependencies.logTo()
-      const frontend = await dependencies.buildFrontend({
-        definition: ctx.definition,
-        projectDir: ctx.projectDir,
-        onLog,
-      })
-      const { configPath, port } = await dependencies.prepare(params, ctx, 'dev', frontend)
-      const handle = await dependencies.runWranglerDev({
-        projectDir: ctx.projectDir,
-        configPath,
-        port,
-        remote: Boolean(params.remote),
-        autoPickPort: params.port === undefined,
-        ...(params.host ? { ip: '0.0.0.0' } : {}),
-        onReload: ctx.onReload,
-        onLog,
-      })
-      let frontendWatch: ReturnType<typeof watchFrontend>
+      const projectKey = resolve(ctx.projectDir)
+      let frontendDev: Awaited<ReturnType<typeof startFrontendDev>>
+      let handle: Awaited<ReturnType<typeof runWranglerDev>> | undefined
       try {
-        frontendWatch = dependencies.watchFrontend({
+        frontendDev = await dependencies.startFrontendDev({
           definition: ctx.definition,
           projectDir: ctx.projectDir,
           onLog,
-          // Routes and source recipes are immutable for this watch generation.
-          // Wrangler already observes the atomically swapped asset stage, so a
-          // source rebuild needs no config regeneration.
-          onRebuild: ctx.onReload,
+        })
+        if (frontendDev !== undefined) frontendDevUrls.set(projectKey, frontendDev.url)
+        const { configPath, port } = await dependencies.prepare(
+          params,
+          ctx,
+          'dev',
+          undefined,
+          frontendDev?.url,
+        )
+        handle = await dependencies.runWranglerDev({
+          projectDir: ctx.projectDir,
+          configPath,
+          port,
+          remote: Boolean(params.remote),
+          autoPickPort: params.port === undefined,
+          ...(params.host ? { ip: '0.0.0.0' } : {}),
+          onReload: ctx.onReload,
+          onLog,
         })
       } catch (error) {
+        frontendDevUrls.delete(projectKey)
         try {
-          await handle.stop()
+          await frontendDev?.stop()
         } catch (cleanupError) {
           throw new AggregateError(
             [error, cleanupError],
-            'cloudflare frontend watcher startup failed and Wrangler cleanup also failed',
+            'cloudflare development startup failed and Vite cleanup also failed',
           )
         }
         throw error
       }
+      if (handle === undefined) throw new Error('cloudflare local Worker failed to start')
       // With --host the actionable URL is the PUBLIC one (the tunnel/proxy
       // front), not the local bind — print and spec-stamp that.
       return {
         url: params.host ?? handle.url,
+        localUrl: handle.url,
         async stop() {
           const errors: unknown[] = []
+          frontendDevUrls.delete(projectKey)
           try {
-            await frontendWatch?.stop()
+            await frontendDev?.stop()
           } catch (error) {
             errors.push(error)
           }
@@ -138,17 +146,16 @@ export function cloudflareWithDependencies(
       }
     },
 
-    // Config hot-regen: rewrite the generated files only — the running
-    // `wrangler dev` watches its `--config` (and the worker entry) and reloads
-    // them itself, so a `astrale.config.ts` edit lands without a restart.
-    // Mirrors `watch`'s prep exactly (codegen + frontend build), minus the spawn.
+    // Config hot-regen rewrites generated files only. Wrangler reloads its config and entry;
+    // the author-owned Vite process keeps its own source/config watch lifecycle.
     async regenerate(params, ctx) {
-      const frontend = await dependencies.buildFrontend({
-        definition: ctx.definition,
-        projectDir: ctx.projectDir,
-        onLog: dependencies.logTo(),
-      })
-      const { configPath } = await dependencies.prepare(params, ctx, 'dev', frontend)
+      const { configPath } = await dependencies.prepare(
+        params,
+        ctx,
+        'dev',
+        undefined,
+        frontendDevUrls.get(resolve(ctx.projectDir)),
+      )
       await dependencies.runWranglerTypes({
         projectDir: ctx.projectDir,
         configPath,
@@ -187,7 +194,13 @@ export function cloudflareWithDependencies(
       // propagate; an `astrale domain install <url>` issued right away would
       // 404 (Cloudflare 1042). Block until the URL actually serves so the
       // install line we print is immediately actionable.
-      await dependencies.waitUntilLive(url, dependencies.logTo(), deploymentVersion)
+      await dependencies.waitUntilLive(url, dependencies.logTo(), {
+        expectedOrigin: ctx.definition.schema.origin,
+        expectedRevision: ctx.definition.domain.$.revision,
+        ...(deploymentVersion === undefined
+          ? {}
+          : { expectedDeploymentVersion: deploymentVersion }),
+      })
       return { url }
     },
 
@@ -198,54 +211,65 @@ export function cloudflareWithDependencies(
 }
 
 /**
- * Poll until the deployed Worker health endpoint returns exactly 200.
+ * Poll until the deployed Worker exposes one complete canonical deployment chain.
  */
-async function waitUntilLive(
+export async function waitUntilLive(
   url: string,
   onLog: (line: string) => void,
-  expectedDeploymentVersion?: string,
-  timeoutMs = 90_000,
+  expectations: {
+    readonly expectedOrigin: Parameters<typeof deployCheck>[0]['expectedOrigin']
+    readonly expectedRevision: Parameters<typeof deployCheck>[0]['expectedRevision']
+    readonly expectedDeploymentVersion?: string
+    readonly fetch?: DeployFetch
+    readonly timeoutMs?: number
+    readonly fetchTimeoutMs?: number
+    readonly retryMs?: number
+    readonly sleep?: (ms: number) => Promise<void>
+  },
 ): Promise<void> {
-  const probe = new URL('/health', url)
-  const metadata = new URL('/meta', url)
+  const timeoutMs = expectations.timeoutMs ?? 90_000
+  const fetchTimeoutMs = expectations.fetchTimeoutMs ?? 5_000
+  const retryMs = expectations.retryMs ?? 3_000
+  const sleep =
+    expectations.sleep ?? ((ms: number) => new Promise((resolve) => setTimeout(resolve, ms)))
   const deadline = Date.now() + timeoutMs
   let waited = false
-  let lastStatus: number | undefined
-  let lastDeploymentVersion: string | undefined
+  let lastReason = 'not checked'
   for (;;) {
     try {
-      const res = await fetch(probe, { redirect: 'manual' })
-      lastStatus = res.status
-      await res.body?.cancel()
-      if (res.status === 200) {
-        if (expectedDeploymentVersion === undefined) return
-        const meta = await fetch(metadata, { redirect: 'manual' })
-        if (meta.status === 200) {
-          const body = (await meta.json()) as { deploymentVersion?: unknown }
-          lastDeploymentVersion =
-            typeof body.deploymentVersion === 'string' ? body.deploymentVersion : undefined
-          if (lastDeploymentVersion === expectedDeploymentVersion) return
-        } else {
-          await meta.body?.cancel()
-        }
+      const deployed = await deployCheck({
+        url,
+        expectedOrigin: expectations.expectedOrigin,
+        expectedRevision: expectations.expectedRevision,
+        signal: AbortSignal.timeout(fetchTimeoutMs),
+        ...(expectations.fetch === undefined ? {} : { fetch: expectations.fetch }),
+        log: () => undefined,
+      })
+      const actualDeploymentVersion = new URL(deployed.schema.bundle.href).searchParams.get(
+        'deployment',
+      )
+      if (
+        expectations.expectedDeploymentVersion === undefined ||
+        actualDeploymentVersion === expectations.expectedDeploymentVersion
+      ) {
+        return
       }
-    } catch {
-      // Network hiccup — treat like "not live yet" and keep polling.
+      lastReason =
+        `bundle deployment=${JSON.stringify(actualDeploymentVersion)} ` +
+        `expected=${JSON.stringify(expectations.expectedDeploymentVersion)}`
+    } catch (error) {
+      lastReason = error instanceof Error ? error.message : String(error)
     }
     if (Date.now() >= deadline) {
       throw new Error(
-        `deployed Worker health did not reach HTTP 200 within ${Math.round(timeoutMs / 1000)}s` +
-          (lastStatus === undefined ? '' : ` (last status ${lastStatus})`) +
-          (expectedDeploymentVersion === undefined
-            ? ''
-            : `; deployment version ${JSON.stringify(lastDeploymentVersion)} ` +
-              `did not reach ${JSON.stringify(expectedDeploymentVersion)}`),
+        `deployed Worker did not expose a valid Publication chain within ` +
+          `${Math.round(timeoutMs / 1000)}s; last check: ${lastReason}`,
       )
     }
     if (!waited) {
       waited = true
       onLog('waiting for the URL to go live (first deploys can take ~30-60s)…')
     }
-    await new Promise((r) => setTimeout(r, 3000))
+    await sleep(Math.min(retryMs, Math.max(0, deadline - Date.now())))
   }
 }

package/src/worker/index.ts

@@ -158,14 +158,6 @@ export function cloudflareWorkerEntry<
       const deploymentQuery = `deployment=${encodeURIComponent(version)}`
       const issuerId = issuer.accept(url)
       const host = new HonoApplication()
-      host.get('/meta', (context) =>
-        context.json({
-          origin: definition.schema.origin,
-          issuer: issuerId,
-          schemaRevision: definition.domain.$.revision,
-          deploymentVersion: version,
-        }),
-      )
       const serving: Application<Hono> = createRemoteApplication({
         definition,
         environment,
@@ -267,20 +259,35 @@ async function frontendAsset<S extends schema.DomainSchema>(
 ): Promise<Response | undefined> {
   const frontend = definition.frontend
   if (frontend === undefined || frontend.source.kind === 'external') return undefined
+  if (isReservedServicePath(url.pathname)) return undefined
+  if (request.method !== 'GET' && request.method !== 'HEAD') return undefined
+  const dev = environment.FRONTEND_DEV_URL?.replace(/\/+$/u, '')
+  if (dev !== undefined && dev.length > 0) {
+    return fetch(new Request(new URL(`${url.pathname}${url.search}`, `${dev}/`), request))
+  }
   const routes = frontend.routes as Readonly<Record<string, FrontendRoute>>
-  const route = Object.values(routes).find((candidate) => candidate.path === url.pathname)
+  const spa = frontend.source.kind === 'vite' && frontend.source.spa
+  const route = Object.values(routes)
+    .filter(
+      (candidate) =>
+        candidate.path === url.pathname ||
+        (spa && (candidate.path === '/' || url.pathname.startsWith(`${candidate.path}/`))),
+    )
+    .sort((left, right) => right.path.length - left.path.length)[0]
   const staticAsset = url.pathname.startsWith('/assets/')
   if (route === undefined && !staticAsset) return undefined
-  if (request.method !== 'GET' && request.method !== 'HEAD') return undefined
   const binding = environment.ASSETS
   if (binding === undefined) return undefined
-  const dev = environment.FRONTEND_DEV_URL?.replace(/\/+$/u, '')
-  if (dev !== undefined && dev.length > 0) {
-    return fetch(new Request(`${dev}${url.pathname}${url.search}`, request))
-  }
-  const path =
-    route === undefined ? `${url.pathname}${url.search}` : `/${route.document}${url.search}`
-  return binding.fetch(new Request(new URL(path, url.origin), request))
+  const asset = await binding.fetch(request)
+  if (asset.status !== 404 || route === undefined) return asset
+  await asset.body?.cancel()
+  return binding.fetch(new Request(new URL(`/${route.document}${url.search}`, url.origin), request))
+}
+
+function isReservedServicePath(path: string): boolean {
+  return ['/invoke', '/install', '/health', '/meta', '/.well-known'].some(
+    (reserved) => path === reserved || path.startsWith(`${reserved}/`),
+  )
 }
 
 function requestOrigin(url: URL, request: Request): string {