@astrale-os/adapter-cloudflare 0.5.0-beta.2 → 0.5.0-beta.21

package/src/build/wrangler-cli.ts

@@ -1,362 +0,0 @@
-/**
- * Thin wrapper around the `wrangler` binary — the only place the adapter shells
- * out. `watch` runs `wrangler dev` (local workerd) and resolves once the worker
- * reports its local URL; `deploy` runs `wrangler deploy` and parses the
- * authoritative public URL from the output; secrets go through `wrangler secret
- * bulk`. The wrangler binary is resolved from the project's `node_modules/.bin`,
- * falling back to `npx wrangler`.
- */
-
-import type { ChildProcess } from 'node:child_process'
-
-import { spawn } from 'node:child_process'
-import { existsSync, readdirSync } from 'node:fs'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { createServer } from 'node:net'
-import { tmpdir } from 'node:os'
-import { dirname, join } from 'node:path'
-
-import { parseDeployUrl, parseDeployVersionId, parseDevReadyUrl } from './parse-output.js'
-
-function wranglerCommand(projectDir: string): { cmd: string; prefix: string[] } {
-  const local = join(projectDir, 'node_modules', '.bin', 'wrangler')
-  if (existsSync(local)) return { cmd: local, prefix: [] }
-  return { cmd: 'npx', prefix: ['--yes', 'wrangler'] }
-}
-
-export interface DevHandle {
-  url: string
-  stop(): Promise<void>
-}
-
-/**
- * True when `port` is free on `host`. A taken port previously made `wrangler
- * dev` either die ("Address already in use") or — worse — a FIRST probe hit a
- * DIFFERENT project's dev server on the same port (observed in agent runs:
- * every reader of the docs converges on 8787/8899).
- */
-function portFree(port: number, host: string): Promise<boolean> {
-  return new Promise((resolve) => {
-    const srv = createServer()
-    srv.once('error', () => resolve(false))
-    srv.once('listening', () => srv.close(() => resolve(true)))
-    srv.listen(port, host)
-  })
-}
-
-/** An OS-assigned free port. */
-function ephemeralPort(host: string): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const srv = createServer()
-    srv.once('error', reject)
-    srv.listen(0, host, () => {
-      const addr = srv.address()
-      const port = typeof addr === 'object' && addr ? addr.port : 0
-      srv.close(() => resolve(port))
-    })
-  })
-}
-
-export async function runWranglerDev(args: {
-  projectDir: string
-  configPath: string
-  port: number
-  remote: boolean
-  /** Bind address — '0.0.0.0' for tunneled/proxied dev (`--host`). Default loopback. */
-  ip?: string
-  /** When the port was NOT explicitly chosen, dodge a taken one automatically. */
-  autoPickPort?: boolean
-  onReload: () => void
-  onLog?: (line: string) => void
-}): Promise<DevHandle> {
-  await runWranglerTypes(args)
-  const { cmd, prefix } = wranglerCommand(args.projectDir)
-  const bindHost = args.ip ?? '127.0.0.1'
-  if (args.autoPickPort && !(await portFree(args.port, bindHost))) {
-    const picked = await ephemeralPort(bindHost)
-    args.onLog?.(`port ${args.port} is taken — using ${picked} instead (pass --port to pin one)`)
-    args = { ...args, port: picked }
-  }
-  const wranglerArgs = [
-    ...prefix,
-    'dev',
-    '--config',
-    args.configPath,
-    '--port',
-    String(args.port),
-    '--local-protocol',
-    'http',
-    '--ip',
-    args.ip ?? '127.0.0.1',
-    ...(args.remote ? ['--remote'] : []),
-  ]
-
-  const child = spawn(cmd, wranglerArgs, {
-    cwd: args.projectDir,
-    stdio: ['ignore', 'pipe', 'pipe'],
-    env: { ...process.env, WRANGLER_SEND_METRICS: 'false' },
-  })
-
-  const fallbackUrl = `http://localhost:${args.port}`
-  // (args.port may have been re-picked above — everything below reads args.port)
-  let resolved = false
-  // Wrangler's watch mode STAYS ALIVE on a build failure (listener up, worker
-  // never answers) — the classic silent hang. Track build errors so the
-  // safety net can fail LOUD instead of resolving a dead URL.
-  let buildErrorTail = ''
-  let outputTail = ''
-
-  const url = await new Promise<string>((resolve, reject) => {
-    const onData = (buf: Buffer) => {
-      const text = buf.toString()
-      outputTail = (outputTail + text).slice(-3000)
-      for (const line of text.split('\n')) {
-        if (line.trim()) args.onLog?.(line)
-      }
-      if (/✘ \[ERROR\]|Build failed|Could not resolve "/.test(text)) {
-        buildErrorTail = (buildErrorTail + text).slice(-2000)
-      }
-      if (!resolved) {
-        const ready = parseDevReadyUrl(text, args.port)
-        if (ready) {
-          resolved = true
-          resolve(ready)
-        }
-      } else if (/Reloading|Detected changes|Updated/i.test(text)) {
-        args.onReload()
-      }
-    }
-    child.stdout?.on('data', onData)
-    child.stderr?.on('data', onData)
-    child.on('exit', (code) => {
-      if (!resolved) {
-        resolved = true
-        reject(
-          new Error(
-            `wrangler dev exited before becoming ready (code ${code ?? 'null'}).\n${outputTail}`,
-          ),
-        )
-      }
-    })
-    child.on('error', (err) => {
-      if (!resolved) {
-        resolved = true
-        reject(err)
-      }
-    })
-    // Safety net: if we never matched a URL but the process is alive, assume the
-    // conventional localhost URL after a grace period — UNLESS the build
-    // failed, in which case a listener may be up but the worker will never
-    // answer: fail loud with the build output instead of handing back a dead
-    // URL.
-    setTimeout(() => {
-      if (!resolved && child.exitCode === null) {
-        resolved = true
-        if (buildErrorTail) {
-          void stopChild(child)
-          reject(
-            new Error(
-              `worker build failed — the dev server would hang silently.\n${buildErrorTail}`,
-            ),
-          )
-        } else {
-          resolve(fallbackUrl)
-        }
-      }
-    }, 15_000).unref?.()
-  })
-
-  return { url, stop: () => stopChild(child) }
-}
-
-export interface DeployArgs {
-  configPath: string
-  /** SELF-less config for the first-deploy two-pass (see `deployWithSelfFallback`). */
-  fallbackConfigPath?: string
-  /** The worker's own name, to scope the self-binding-missing detection. */
-  workerName?: string
-  route?: string
-  onLog?: (line: string) => void
-}
-
-export async function runWranglerDeploy(
-  args: DeployArgs & { projectDir: string },
-): Promise<{ url: string; raw: string; deploymentVersion?: string }> {
-  await runWranglerTypes(args)
-  const { cmd, prefix } = wranglerCommand(args.projectDir)
-  const deploy = (configPath: string) =>
-    runCapture(cmd, [...prefix, 'deploy', '--config', configPath], args.projectDir, args.onLog)
-  return deployWithSelfFallback(deploy, args)
-}
-
-/**
- * Deploy with a one-time SELF-binding first-deploy recovery. A fresh worker that
- * declares a `services: SELF` binding can't deploy (its own script doesn't exist
- * yet); on THAT specific failure we deploy the SELF-less fallback to create the
- * script, then redeploy WITH SELF so autobinding works. Steady state (every
- * deploy after the first) is a single pass. The `deploy` runner is injected so
- * the orchestration is unit-testable without shelling out.
- */
-export async function deployWithSelfFallback(
-  deploy: (configPath: string) => Promise<{ code: number; out: string }>,
-  args: DeployArgs,
-): Promise<{ url: string; raw: string; deploymentVersion?: string }> {
-  let { code, out } = await deploy(args.configPath)
-
-  if (code !== 0 && args.fallbackConfigPath && isSelfBindingMissing(out, args.workerName)) {
-    args.onLog?.(
-      'SELF service binding not resolvable yet (first deploy) — creating the worker, then re-binding SELF',
-    )
-    const first = await deploy(args.fallbackConfigPath)
-    if (first.code !== 0) {
-      throw new Error(
-        `wrangler deploy (no-self pass) failed (code ${first.code}):\n${first.out.slice(-2000)}`,
-      )
-    }
-    ;({ code, out } = await deploy(args.configPath))
-  }
-
-  if (code !== 0) {
-    throw new Error(`wrangler deploy failed (code ${code}):\n${out.slice(-2000)}`)
-  }
-  const url = parseDeployUrl(out, args.route)
-  if (!url) {
-    throw new Error(`could not determine deployed URL from wrangler output:\n${out.slice(-2000)}`)
-  }
-  const deploymentVersion = parseDeployVersionId(out)
-  return { url, raw: out, ...(deploymentVersion === undefined ? {} : { deploymentVersion }) }
-}
-
-/**
- * True when wrangler failed specifically because the worker's OWN `SELF` service
- * binding can't resolve yet (first deploy of a fresh script). Requires the
- * worker name so an unrelated missing-service error doesn't trigger the two-pass.
- */
-export function isSelfBindingMissing(out: string, workerName?: string): boolean {
-  const bindingError =
-    /could not resolve binding/i.test(out) ||
-    /service\b[^\n]*\bnot found/i.test(out) ||
-    /script\b[^\n]*\bnot found/i.test(out)
-  if (!bindingError || !/\bSELF\b/.test(out)) return false
-  return workerName ? out.includes(workerName) : true
-}
-
-export async function bulkPutSecrets(args: {
-  projectDir: string
-  configPath: string
-  secrets: Record<string, string>
-  onLog?: (line: string) => void
-}): Promise<void> {
-  const names = Object.keys(args.secrets)
-  if (names.length === 0) return
-  const { cmd, prefix } = wranglerCommand(args.projectDir)
-  const dir = await mkdtemp(join(tmpdir(), 'astrale-secrets-'))
-  const file = join(dir, 'secrets.json')
-  try {
-    await writeFile(file, JSON.stringify(args.secrets))
-    const { code, out } = await runCapture(
-      cmd,
-      [...prefix, 'secret', 'bulk', file, '--config', args.configPath],
-      args.projectDir,
-      args.onLog,
-    )
-    if (code !== 0) {
-      throw new Error(`wrangler secret bulk failed (code ${code}):\n${out.slice(-1500)}`)
-    }
-  } finally {
-    await rm(dir, { recursive: true, force: true })
-  }
-}
-
-// ── internals ──────────────────────────────────────────────────────────────
-
-function runCapture(
-  cmd: string,
-  args: string[],
-  cwd: string,
-  onLog?: (line: string) => void,
-): Promise<{ code: number; out: string }> {
-  return new Promise((resolve, reject) => {
-    const child = spawn(cmd, args, {
-      cwd,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      env: { ...process.env, WRANGLER_SEND_METRICS: 'false' },
-    })
-    let out = ''
-    const onData = (buf: Buffer) => {
-      const text = buf.toString()
-      out += text
-      for (const line of text.split('\n')) if (line.trim()) onLog?.(line)
-    }
-    child.stdout?.on('data', onData)
-    child.stderr?.on('data', onData)
-    child.on('exit', (code) => resolve({ code: code ?? 1, out }))
-    child.on('error', reject)
-  })
-}
-
-async function stopChild(child: ChildProcess): Promise<void> {
-  if (child.exitCode !== null) return
-  await new Promise<void>((resolve) => {
-    child.on('exit', () => resolve())
-    child.kill('SIGTERM')
-    setTimeout(() => {
-      if (child.exitCode === null) child.kill('SIGKILL')
-      resolve()
-    }, 4000).unref?.()
-  })
-}
-
-/**
- * Build the single-module worker bundle WITHOUT deploying — `wrangler deploy
- * --dry-run --outdir` (no Cloudflare auth required). Returns the path of the
- * bundled .js module (the managed adapter publishes its bytes).
- */
-export async function runWranglerBundle(args: {
-  projectDir: string
-  configPath: string
-  outDir: string
-  onLog?: (line: string) => void
-}): Promise<string> {
-  await runWranglerTypes(args)
-  const { cmd, prefix } = wranglerCommand(args.projectDir)
-  const { code, out } = await runCapture(
-    cmd,
-    [...prefix, 'deploy', '--dry-run', '--outdir', args.outDir, '--config', args.configPath],
-    args.projectDir,
-    args.onLog,
-  )
-  if (code !== 0) throw new Error(`wrangler bundle failed (exit ${code}): ${out.slice(-400)}`)
-  const js = readdirSync(args.outDir).filter((f) => f.endsWith('.js'))
-  if (js.length === 0) throw new Error(`wrangler bundle produced no .js in ${args.outDir}`)
-  const preferred = js.find((f) => f.startsWith('worker')) ?? js[0]!
-  return join(args.outDir, preferred)
-}
-
-/** Generate the exact binding and runtime types selected by the generated config. */
-export async function runWranglerTypes(args: {
-  readonly projectDir: string
-  readonly configPath: string
-  readonly onLog?: (line: string) => void
-}): Promise<string> {
-  const { cmd, prefix } = wranglerCommand(args.projectDir)
-  const outputPath = join(dirname(args.configPath), 'worker-configuration.d.ts')
-  const { code, out } = await runCapture(
-    cmd,
-    [
-      ...prefix,
-      'types',
-      outputPath,
-      '--env-interface',
-      'CloudflareEnv',
-      '--config',
-      args.configPath,
-    ],
-    args.projectDir,
-    args.onLog,
-  )
-  if (code !== 0) {
-    throw new Error(`wrangler types failed (code ${code}):\n${out.slice(-2000)}`)
-  }
-  return outputPath
-}

package/src/cloudflare.ts

@@ -1,251 +0,0 @@
-/**
- * `cloudflare(envs)` — the Cloudflare deployment adapter.
- *
- * Owns everything target-specific: it codegens the Worker entry + wrangler
- * config (the dev never sees a `wrangler.jsonc`), materializes the optional frontend
- * SPA, and shells out to `wrangler`. `watch` → `wrangler dev` (local URL);
- * `deploy` → `wrangler deploy` (workers.dev or a custom-domain URL); secrets →
- * `wrangler secret bulk`. Both `watch` and `deploy` return the URL the CLI
- * prints and `astrale domain install <url>` consumes.
- */
-
-import type { DomainAdapter } from '@astrale-os/sdk'
-
-import { defineAdapter } from '@astrale-os/sdk'
-
-import type { CloudflareParams } from './params.js'
-
-import {
-  bulkPutSecrets,
-  buildCloudflareWorker,
-  buildFrontend,
-  logTo,
-  prepare,
-  runWranglerDeploy,
-  runWranglerDev,
-  runWranglerTypes,
-  watchFrontend,
-} from './build/index.js'
-
-export function cloudflare(
-  envs: Record<string, CloudflareParams>,
-): DomainAdapter<CloudflareParams> {
-  return cloudflareWithDependencies(envs, {
-    bulkPutSecrets,
-    buildCloudflareWorker,
-    buildFrontend,
-    logTo,
-    prepare,
-    runWranglerDeploy,
-    runWranglerDev,
-    runWranglerTypes,
-    watchFrontend,
-    waitUntilLive,
-  })
-}
-
-interface CloudflareAdapterDependencies {
-  readonly bulkPutSecrets: typeof bulkPutSecrets
-  readonly buildCloudflareWorker: typeof buildCloudflareWorker
-  readonly buildFrontend: typeof buildFrontend
-  readonly logTo: typeof logTo
-  readonly prepare: typeof prepare
-  readonly runWranglerDeploy: typeof runWranglerDeploy
-  readonly runWranglerDev: typeof runWranglerDev
-  readonly runWranglerTypes: typeof runWranglerTypes
-  readonly watchFrontend: typeof watchFrontend
-  readonly waitUntilLive: typeof waitUntilLive
-}
-
-/** Exact orchestration seam used by adapter-level deployment qualification. */
-export function cloudflareWithDependencies(
-  envs: Record<string, CloudflareParams>,
-  dependencies: CloudflareAdapterDependencies,
-): DomainAdapter<CloudflareParams> {
-  return defineAdapter<CloudflareParams>({
-    name: 'cloudflare',
-    envs,
-
-    async build(params, ctx) {
-      await dependencies.buildCloudflareWorker({
-        params,
-        context: ctx,
-        onLog: dependencies.logTo(),
-      })
-    },
-
-    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>
-      try {
-        frontendWatch = dependencies.watchFrontend({
-          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,
-        })
-      } catch (error) {
-        try {
-          await handle.stop()
-        } catch (cleanupError) {
-          throw new AggregateError(
-            [error, cleanupError],
-            'cloudflare frontend watcher startup failed and Wrangler cleanup also failed',
-          )
-        }
-        throw error
-      }
-      // 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,
-        async stop() {
-          const errors: unknown[] = []
-          try {
-            await frontendWatch?.stop()
-          } catch (error) {
-            errors.push(error)
-          }
-          try {
-            await handle.stop()
-          } catch (error) {
-            errors.push(error)
-          }
-          if (errors.length === 1) throw errors[0]
-          if (errors.length > 1) {
-            throw new AggregateError(errors, 'cloudflare development cleanup failed')
-          }
-        },
-      }
-    },
-
-    // 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.
-    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)
-      await dependencies.runWranglerTypes({
-        projectDir: ctx.projectDir,
-        configPath,
-        onLog: dependencies.logTo(),
-      })
-    },
-
-    async deploy(params, ctx) {
-      const frontend = await dependencies.buildFrontend({
-        definition: ctx.definition,
-        projectDir: ctx.projectDir,
-        onLog: dependencies.logTo(),
-      })
-      const {
-        configPath,
-        fallbackConfigPath,
-        workerName: name,
-      } = await dependencies.prepare(params, ctx, 'deploy', frontend)
-      const { url, deploymentVersion } = await dependencies.runWranglerDeploy({
-        projectDir: ctx.projectDir,
-        configPath,
-        workerName: name,
-        ...(fallbackConfigPath ? { fallbackConfigPath } : {}),
-        ...(params.route ? { route: params.route } : {}),
-        onLog: dependencies.logTo(),
-      })
-      if (Object.keys(ctx.secrets).length > 0) {
-        await dependencies.bulkPutSecrets({
-          projectDir: ctx.projectDir,
-          configPath,
-          secrets: ctx.secrets,
-          onLog: dependencies.logTo(),
-        })
-      }
-      // A first deploy on a fresh `*.workers.dev` host can take ~30-60s to
-      // 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)
-      return { url }
-    },
-
-    secretsFile(params) {
-      return params.secrets
-    },
-  })
-}
-
-/**
- * Poll until the deployed Worker health endpoint returns exactly 200.
- */
-async function waitUntilLive(
-  url: string,
-  onLog: (line: string) => void,
-  expectedDeploymentVersion?: string,
-  timeoutMs = 90_000,
-): Promise<void> {
-  const probe = new URL('/health', url)
-  const metadata = new URL('/meta', url)
-  const deadline = Date.now() + timeoutMs
-  let waited = false
-  let lastStatus: number | undefined
-  let lastDeploymentVersion: string | undefined
-  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()
-        }
-      }
-    } catch {
-      // Network hiccup — treat like "not live yet" and keep polling.
-    }
-    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)}`),
-      )
-    }
-    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))
-  }
-}

package/src/index.ts

@@ -1,21 +0,0 @@
-/**
- * `@astrale-os/adapter-cloudflare` — deploy an Astrale domain as a standalone
- * Cloudflare Worker on YOUR OWN Cloudflare account.
- *
- *   import { cloudflare } from '@astrale-os/adapter-cloudflare'
- *
- *   adapter: cloudflare({
- *     dev:  { secrets: '.env.dev' },
- *     prod: { route: 'crm.acme.dev', secrets: '.env.prod' },
- *   })
- *
- * `dev` runs `wrangler dev` locally; an env with no `route` ships to
- * `*.workers.dev`; an env with a `route` ships to that custom domain.
- *
- * Prefer a managed deploy (no Cloudflare account)? Use
- * `@astrale-os/adapter-astrale`, which builds the same bundle via this package's
- * `/build` toolkit and ships it through the Astrale platform.
- */
-
-export { cloudflare } from './cloudflare.js'
-export type { CloudflareParams } from './params.js'