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

package/src/build/codegen/worker.ts

@@ -1,53 +0,0 @@
-/** Codegen for the Cloudflare module entry owned by the adapter. */
-
-export interface WorkerCodegenOptions {
-  readonly origin: string
-  /** Optional same-zone routing service selected by the adapter environment. */
-  readonly router?: {
-    readonly binding: string
-    readonly hostSuffix: string
-    readonly minLabels: number
-  }
-}
-
-export function generateWorkerEntry(options: WorkerCodegenOptions): string {
-  const router = options.router
-  const routerPredicate =
-    router === undefined
-      ? ''
-      : `
-function isInstanceHost(host: string): boolean {
-  return host.endsWith('${router.hostSuffix}') && host.split('.').length >= ${router.minLabels}
-}
-`
-  const routeSubrequest =
-    router === undefined
-      ? ''
-      : `
-  routeSubrequest: (url, env) => {
-    const labels = url.hostname.split('.')
-    if (env.DISPATCHER && labels[1] === 'svc') return env.DISPATCHER.get(labels[0]!)
-    if (env.${router.binding} && isInstanceHost(url.hostname)) return env.${router.binding}
-    return null
-  },`
-
-  return `// AUTO-GENERATED by @astrale-os/adapter-cloudflare — do not edit.
-// Regenerated by every Astrale Domain build, dev, and deploy operation.
-// Domain origin: ${options.origin}
-import type { CloudflareAdapterBindings } from '@astrale-os/adapter-cloudflare/worker'
-import type { ApplicationEnvironment } from '../implementation.js'
-
-import { cloudflareWorkerEntry } from '@astrale-os/adapter-cloudflare/worker'
-import { domain } from '../implementation.js'
-import { PRIVATE_JWK } from './identity.js'
-
-type WorkerEnv = CloudflareEnv & ApplicationEnvironment & CloudflareAdapterBindings
-${routerPredicate}
-export default cloudflareWorkerEntry<WorkerEnv>()({
-  definition: domain,
-  privateKey: PRIVATE_JWK,
-  resolveUrl: (env, requestOrigin) => env.WORKER_URL ?? requestOrigin,
-  selfBinding: (env) => env.SELF,${routeSubrequest}
-})
-`
-}

package/src/build/codegen/wrangler.ts

@@ -1,128 +0,0 @@
-/**
- * Codegen for the Worker config (`.astrale/wrangler.gen.jsonc`). This is the
- * `wrangler.jsonc` that used to be hand-copied into every domain — now an
- * internal adapter detail the dev never sees.
- *
- * `main` is `./worker.gen.ts` (same dir). `assets.directory` points at the
- * adapter's materialized frontend stage. A `SELF` service binding enables autobinding
- * (a handler calling back into its own domain). Custom-domain deploys attach a
- * `custom_domain` route; otherwise the Worker ships to `*.workers.dev`.
- *
- * A dev's `params.wrangler` escape hatch is deep-merged on top of this base
- * (extra bindings: KV, R2, D1, queues, …) — see `mergeUserConfig`.
- */
-
-import { deepMergeConfig } from './merge.js'
-
-export interface WranglerCodegenOptions {
-  workerName: string
-  /** Full custom hostname for a routed deploy (e.g. 'crm.acme.dev'). */
-  route?: string
-  /** Exact materialized local frontend; absence means no ASSETS binding. */
-  frontend?: {
-    readonly directory: string
-    readonly routes: readonly string[]
-    readonly dev: boolean
-  }
-  /** Plain (non-secret) vars to bake in. */
-  vars?: Record<string, string>
-  /** Add the SELF service binding (autobinding). */
-  selfBinding: boolean
-  /**
-   * Add a service binding to a router Worker for instance-host subrequest
-   * routing (see `CloudflareParams.router`). Pairs with the worker
-   * entry's `routeSubrequest`.
-   */
-  router?: { binding: string; service: string }
-  /**
-   * Raw wrangler config to deep-merge over the generated base — the escape
-   * hatch for extra bindings (KV, R2, D1, queues, service bindings, extra
-   * `compatibility_flags`, cron `triggers`, …). Arrays concat; new keys are
-   * added as-is. The adapter-owned keys `name`, `main`, `assets`, `routes` are
-   * rejected (throws) — use `workerName` / `route` instead.
-   */
-  wrangler?: Record<string, unknown>
-}
-
-// Wrangler 4.121.0's pinned workerd accepts dates through 2026-08-11.
-const COMPATIBILITY_DATE = '2026-08-11'
-
-export function generateWranglerConfig(opts: WranglerCodegenOptions): string {
-  const config: Record<string, unknown> = {
-    name: opts.workerName,
-    main: './worker.gen.ts',
-    compatibility_date: COMPATIBILITY_DATE,
-    compatibility_flags: ['nodejs_compat'],
-    workers_dev: true,
-    version_metadata: { binding: 'ASTRALE_VERSION_METADATA' },
-    observability: { enabled: true },
-  }
-
-  if (opts.route) {
-    config.routes = [{ pattern: opts.route, custom_domain: true }]
-  }
-
-  if (opts.frontend !== undefined) {
-    config.assets = {
-      directory: opts.frontend.directory,
-      binding: 'ASSETS',
-      run_worker_first: opts.frontend.dev
-        ? true
-        : [
-            '/invoke',
-            '/invoke/*',
-            '/install',
-            '/install/*',
-            '/health',
-            '/health/*',
-            '/.well-known',
-            '/.well-known/*',
-            ...opts.frontend.routes,
-          ],
-    }
-  }
-
-  const services: Array<{ binding: string; service: string }> = []
-  if (opts.selfBinding) services.push({ binding: 'SELF', service: opts.workerName })
-  if (opts.router) {
-    services.push({ binding: opts.router.binding, service: opts.router.service })
-  }
-  if (services.length > 0) config.services = services
-
-  if (opts.vars && Object.keys(opts.vars).length > 0) {
-    config.vars = opts.vars
-  }
-
-  const merged = opts.wrangler ? mergeUserConfig(config, opts.wrangler) : config
-  return JSON.stringify(merged, null, 2) + '\n'
-}
-
-/** Keys the adapter owns and won't let `params.wrangler` clobber. */
-const ADAPTER_OWNED_KEYS = [
-  'name',
-  'main',
-  'assets',
-  'routes',
-  'compatibility_date',
-  'version_metadata',
-]
-
-/**
- * Deep-merge the dev's raw wrangler overlay over the generated config, after
- * refusing any attempt to override an adapter-owned key. Throwing (rather than
- * silently dropping) keeps a stray `main` from breaking the Worker unnoticed.
- */
-function mergeUserConfig(
-  base: Record<string, unknown>,
-  user: Record<string, unknown>,
-): Record<string, unknown> {
-  const collisions = ADAPTER_OWNED_KEYS.filter((k) => k in user)
-  if (collisions.length > 0) {
-    throw new Error(
-      `wrangler: cannot override adapter-managed key(s): ${collisions.join(', ')}. ` +
-        'Use `workerName` for the worker name and `route` for routing; ' +
-        '`main` and `assets` are generated by the adapter.',
-    )
-  }
-  return deepMergeConfig(base, user)
-}

package/src/build/frontend.ts

@@ -1,298 +0,0 @@
-import type { CompiledFrontendArtifact, DomainDefinition, FrontendFile } from '@astrale-os/sdk'
-import type { ChildProcess } from 'node:child_process'
-
-import { compileFrontend } from '@astrale-os/sdk'
-import { spawn } from 'node:child_process'
-import { existsSync } from 'node:fs'
-import { mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises'
-import { createServer } from 'node:net'
-import { dirname, join, resolve, sep } from 'node:path'
-
-export const FRONTEND_STAGE_DIR = '.astrale/frontend'
-const FRONTEND_BUILD_DIR = '.astrale/frontend-build'
-let stageGeneration = 0
-const buildQueues = new Map<string, Promise<void>>()
-
-export interface ViteBuildInput {
-  readonly projectDir: string
-  readonly output: string
-  readonly config?: string
-  readonly onLog?: (line: string) => void
-}
-
-export type ViteBuild = (input: ViteBuildInput) => Promise<void>
-
-/** Materialize one Domain-owned frontend recipe into an immutable adapter artifact. */
-export async function buildFrontend(input: {
-  readonly definition: DomainDefinition
-  readonly projectDir: string
-  readonly onLog?: (line: string) => void
-  readonly buildVite?: ViteBuild
-}): Promise<CompiledFrontendArtifact | undefined> {
-  const key = resolve(input.projectDir)
-  const previous = buildQueues.get(key) ?? Promise.resolve()
-  let release = (): void => {}
-  const current = new Promise<void>((resolveBuild) => {
-    release = resolveBuild
-  })
-  const tail = previous.then(() => current)
-  buildQueues.set(key, tail)
-  await previous
-  try {
-    return await buildFrontendUnlocked(input)
-  } finally {
-    release()
-    if (buildQueues.get(key) === tail) buildQueues.delete(key)
-  }
-}
-
-async function buildFrontendUnlocked(input: {
-  readonly definition: DomainDefinition
-  readonly projectDir: string
-  readonly onLog?: (line: string) => void
-  readonly buildVite?: ViteBuild
-}): Promise<CompiledFrontendArtifact | undefined> {
-  const artifact = input.definition.frontend
-  if (artifact === undefined) return undefined
-  if (artifact.source.kind === 'external') {
-    return compileFrontend({
-      artifact,
-      files: [],
-      provenance: { adapter: 'cloudflare', source: 'external' },
-    })
-  }
-  const output = contained(input.projectDir, FRONTEND_BUILD_DIR, 'Vite frontend staging output')
-  await rm(output, { recursive: true, force: true })
-  await (input.buildVite ?? runViteBuild)({
-    projectDir: input.projectDir,
-    output,
-    ...(artifact.source.config === undefined ? {} : { config: artifact.source.config }),
-    ...(input.onLog === undefined ? {} : { onLog: input.onLog }),
-  })
-  const files = await readFiles(output)
-  const compiled = await compileFrontend({
-    artifact,
-    baseHref: 'https://frontend.invalid/',
-    files,
-    provenance: { adapter: 'cloudflare', source: artifact.source.kind },
-  })
-  await replaceStage(input.projectDir, compiled.files)
-  return compiled
-}
-
-export interface FrontendDevHandle {
-  readonly url: string
-  stop(): Promise<void>
-}
-
-/** Start the Domain project's own Vite server; the Worker remains the browser-facing origin. */
-export async function startFrontendDev(input: {
-  readonly definition: DomainDefinition
-  readonly projectDir: string
-  readonly onLog?: (line: string) => void
-}): Promise<FrontendDevHandle | undefined> {
-  const artifact = input.definition.frontend
-  if (artifact === undefined || artifact.source.kind !== 'vite') return undefined
-  const command = viteCommand(input.projectDir)
-  const port = await ephemeralPort('127.0.0.1')
-  const args = [
-    ...command.prefix,
-    '--host',
-    '127.0.0.1',
-    '--port',
-    String(port),
-    '--strictPort',
-    ...(artifact.source.config === undefined ? [] : ['--config', artifact.source.config]),
-  ]
-  const child = spawn(command.command, args, {
-    cwd: input.projectDir,
-    stdio: ['ignore', 'pipe', 'pipe'],
-  })
-  const output: string[] = []
-  const collect = (buffer: Buffer) => {
-    for (const line of buffer.toString().split('\n')) {
-      if (line.trim() === '') continue
-      output.push(line)
-      if (output.length > 40) output.shift()
-      input.onLog?.(line)
-    }
-  }
-  child.stdout?.on('data', collect)
-  child.stderr?.on('data', collect)
-  const url = `http://127.0.0.1:${port}`
-  try {
-    await waitUntilReady(url, child, output)
-  } catch (error) {
-    await stopChild(child)
-    throw error
-  }
-  return Object.freeze({ url, stop: () => stopChild(child) })
-}
-
-async function readFiles(root: string, current = ''): Promise<readonly FrontendFile[]> {
-  const directory = join(root, current)
-  const entries = await readdir(directory, { withFileTypes: true })
-  const files: FrontendFile[] = []
-  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
-    const path = current === '' ? entry.name : `${current}/${entry.name}`
-    if (entry.isDirectory()) files.push(...(await readFiles(root, path)))
-    else if (entry.isFile())
-      files.push({ path, content: new Uint8Array(await readFile(join(root, path))) })
-  }
-  return files
-}
-
-async function replaceStage(projectDir: string, files: readonly FrontendFile[]): Promise<void> {
-  const stage = contained(projectDir, FRONTEND_STAGE_DIR, 'frontend stage')
-  const generation = `${process.pid}-${++stageGeneration}`
-  const next = `${stage}.next-${generation}`
-  const previous = `${stage}.previous-${generation}`
-  await rm(next, { recursive: true, force: true })
-  await mkdir(next, { recursive: true })
-  try {
-    for (const file of files) {
-      const path = contained(next, file.path, 'staged frontend file')
-      await mkdir(dirname(path), { recursive: true })
-      await writeFile(path, file.content)
-    }
-    await rm(previous, { recursive: true, force: true })
-    let retainedPrevious = false
-    try {
-      await rename(stage, previous)
-      retainedPrevious = true
-    } catch (error) {
-      if (!isMissing(error)) throw error
-    }
-    try {
-      await rename(next, stage)
-    } catch (error) {
-      if (retainedPrevious) await rename(previous, stage)
-      throw error
-    }
-    if (retainedPrevious) await rm(previous, { recursive: true, force: true })
-  } finally {
-    await rm(next, { recursive: true, force: true })
-  }
-}
-
-function isMissing(error: unknown): boolean {
-  return error instanceof Error && 'code' in error && error.code === 'ENOENT'
-}
-
-function contained(root: string, input: string, label: string): string {
-  const base = resolve(root)
-  const target = resolve(base, input)
-  if (target !== base && !target.startsWith(`${base}${sep}`)) {
-    throw new TypeError(`${label} must remain within the Domain project root.`)
-  }
-  return target
-}
-
-function viteCommand(projectDir: string): { command: string; prefix: readonly string[] } {
-  const command = join(projectDir, 'node_modules', '.bin', 'vite')
-  if (!existsSync(command)) {
-    throw new TypeError(
-      'Vite frontend requires the Domain project to install vite as a development dependency.',
-    )
-  }
-  return { command, prefix: [] }
-}
-
-async function runViteBuild(input: ViteBuildInput): Promise<void> {
-  const command = viteCommand(input.projectDir)
-  await runProcess(
-    command.command,
-    [
-      ...command.prefix,
-      'build',
-      '--outDir',
-      input.output,
-      '--emptyOutDir',
-      ...(input.config === undefined ? [] : ['--config', input.config]),
-    ],
-    input.projectDir,
-    input.onLog,
-  )
-}
-
-function runProcess(
-  command: string,
-  args: readonly string[],
-  cwd: string,
-  onLog?: (line: string) => void,
-): Promise<void> {
-  return new Promise((resolveBuild, reject) => {
-    const child = spawn(command, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] })
-    let output = ''
-    const collect = (buffer: Buffer) => {
-      const value = buffer.toString()
-      output += value
-      for (const line of value.split('\n')) if (line.trim() !== '') onLog?.(line)
-    }
-    child.stdout?.on('data', collect)
-    child.stderr?.on('data', collect)
-    child.on('error', reject)
-    child.on('exit', (code) =>
-      code === 0
-        ? resolveBuild()
-        : reject(
-            new Error(`Vite frontend build failed (code ${code ?? 1}):\n${output.slice(-1500)}`),
-          ),
-    )
-  })
-}
-
-function ephemeralPort(host: string): Promise<number> {
-  return new Promise((resolvePort, reject) => {
-    const server = createServer()
-    server.once('error', reject)
-    server.listen(0, host, () => {
-      const address = server.address()
-      const port = typeof address === 'object' && address !== null ? address.port : 0
-      server.close((error) => (error === undefined ? resolvePort(port) : reject(error)))
-    })
-  })
-}
-
-async function waitUntilReady(
-  url: string,
-  child: ChildProcess,
-  output: readonly string[],
-): Promise<void> {
-  const deadline = Date.now() + 15_000
-  while (Date.now() < deadline) {
-    if (child.exitCode !== null) {
-      throw new Error(
-        `Vite frontend dev server exited before becoming ready (code ${child.exitCode}).\n${output.join('\n')}`,
-      )
-    }
-    try {
-      const response = await fetch(url, { signal: AbortSignal.timeout(500) })
-      await response.body?.cancel()
-      return
-    } catch {
-      await new Promise((resolveDelay) => setTimeout(resolveDelay, 50))
-    }
-  }
-  throw new Error(`Vite frontend dev server did not become ready at ${url}.\n${output.join('\n')}`)
-}
-
-function stopChild(child: ChildProcess): Promise<void> {
-  if (child.exitCode !== null || child.killed) return Promise.resolve()
-  return new Promise((resolveStop) => {
-    let settled = false
-    const finish = () => {
-      if (settled) return
-      settled = true
-      clearTimeout(timer)
-      resolveStop()
-    }
-    const timer = setTimeout(() => {
-      if (child.exitCode === null) child.kill('SIGKILL')
-      finish()
-    }, 2_000)
-    timer.unref?.()
-    child.once('exit', finish)
-    child.kill('SIGTERM')
-  })
-}

package/src/build/index.ts

@@ -1,29 +0,0 @@
-/**
- * `@astrale-os/adapter-cloudflare/build` — the shared Cloudflare-Workers build
- * toolkit, exposed for sibling deploy adapters (e.g.
- * `@astrale-os/adapter-astrale`).
- *
- * This is the "compile a `defineDomain` into a Cloudflare Workers bundle + run
- * local dev" surface that every Cloudflare-Workers deploy strategy shares,
- * regardless of WHERE the bundle ultimately ships. It is NOT part of the public
- * adapter API (`@astrale-os/adapter-cloudflare`) — it's the seam two adapters
- * build on so the codegen/bundling/dev logic lives in exactly one place.
- */
-
-export {
-  buildFrontend,
-  FRONTEND_STAGE_DIR,
-  startFrontendDev,
-  type FrontendDevHandle,
-  type ViteBuild,
-  type ViteBuildInput,
-} from './frontend.js'
-export { logTo, prepare } from './prepare.js'
-export { buildCloudflareWorker, type CloudflareWorkerBuild } from './worker.js'
-export {
-  bulkPutSecrets,
-  runWranglerBundle,
-  runWranglerDeploy,
-  runWranglerDev,
-  runWranglerTypes,
-} from './wrangler-cli.js'

package/src/build/parse-output.ts

@@ -1,60 +0,0 @@
-/**
- * Pure parsers for `wrangler` stdout. Kept separate from the process-spawning in
- * `wrangler-cli.ts` so the brittle bit — scraping wrangler's human output — is
- * unit-testable against captured fixtures without shelling out.
- */
-
-const READY_RE = /(?:Ready on|Listening on|⎔.*?at)\s+(https?:\/\/[^\s]+)/i
-const WORKERS_DEV_RE = /(https:\/\/[^\s]+\.workers\.dev)/i
-const VERSION_ID_RE = /(?:Current\s+)?Version ID:\s*([a-z0-9_-]+)/i
-
-/**
- * Local dev URL from `wrangler dev` output, normalized to an origin on the given
- * port. Returns `undefined` when the output hasn't reported readiness yet.
- *
- * The fallback (when no explicit "Ready on" line) only accepts a localhost URL
- * on the EXPECTED port — wrangler may print unrelated localhost URLs (e.g. an
- * inspector/devtools endpoint on a different port) before readiness, and taking
- * one of those would point `astrale domain install <url>` at a dead endpoint.
- */
-export function parseDevReadyUrl(text: string, port: number): string | undefined {
-  const ready = READY_RE.exec(text)
-  if (ready) return normalizeLocal(ready[1]!, port)
-  // `port` is a number, so it's safe to interpolate into the pattern. The
-  // negative lookahead stops `:8787` from matching inside `:87870`.
-  const localhostOnPort = new RegExp(
-    `(https?://(?:localhost|127\\.0\\.0\\.1):${port})(?![0-9])`,
-    'i',
-  )
-  const m = localhostOnPort.exec(text)
-  return m ? normalizeLocal(m[1]!, port) : undefined
-}
-
-/**
- * Authoritative public URL from `wrangler deploy` output. A custom-domain
- * `route` wins (the deploy attaches it); otherwise the printed `*.workers.dev`
- * URL. Returns `undefined` when neither is available (caller surfaces the raw
- * output).
- */
-export function parseDeployUrl(text: string, route?: string): string | undefined {
-  if (route) return `https://${route.replace(/\/.*$/, '')}`
-  const m = WORKERS_DEV_RE.exec(text)
-  return m ? m[1] : undefined
-}
-
-/** Cloudflare version published by the final Wrangler deploy pass. */
-export function parseDeployVersionId(text: string): string | undefined {
-  return VERSION_ID_RE.exec(text)?.[1]
-}
-
-/** Normalize a local dev URL to an origin: `0.0.0.0` → `localhost`, fill the port. */
-export function normalizeLocal(url: string, port: number): string {
-  try {
-    const u = new URL(url)
-    if (u.hostname === '0.0.0.0') u.hostname = 'localhost'
-    if (!u.port) u.port = String(port)
-    return u.origin
-  } catch {
-    return `http://localhost:${port}`
-  }
-}