@astrale-os/adapter-cloudflare 0.5.0-beta.7 → 0.5.0-beta.70

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}`
-  }
-}

package/src/build/prepare.ts

@@ -1,161 +0,0 @@
-import type {
-  BuildCtx,
-  CompiledFrontendArtifact,
-  DeployCtx,
-  FrontendRoute,
-  WatchCtx,
-} from '@astrale-os/sdk'
-
-import { mkdir, rename, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
-
-import type { CloudflareParams } from '../index.js'
-
-import { ensureIdentity } from './codegen/identity.js'
-import { generateWorkerEntry } from './codegen/worker.js'
-import { generateWranglerConfig } from './codegen/wrangler.js'
-
-const DEFAULT_PORT = 8787
-const DEPLOYMENT_VERSION_BINDING = 'ASTRALE_DEPLOYMENT_VERSION'
-const WORKER_NAME_RE = /^[a-z0-9][a-z0-9-]*$/
-
-/** Prepare immutable generated Worker sources and Wrangler configuration. */
-export async function prepare(
-  params: CloudflareParams,
-  ctx: WatchCtx | DeployCtx | BuildCtx,
-  mode: 'build' | 'dev' | 'deploy',
-  frontend?: CompiledFrontendArtifact,
-): Promise<{ configPath: string; fallbackConfigPath?: string; port: number; workerName: string }> {
-  if (Object.hasOwn(params.vars ?? {}, DEPLOYMENT_VERSION_BINDING)) {
-    throw new Error(
-      `cloudflare adapter: \`${DEPLOYMENT_VERSION_BINDING}\` is adapter-managed and cannot be set in \`vars\`.`,
-    )
-  }
-  const astraleDir = join(ctx.projectDir, '.astrale')
-  await mkdir(astraleDir, { recursive: true })
-  await ensureIdentity(astraleDir, ctx.definition.schema.origin)
-
-  const name = workerName(params, ctx.definition.schema.origin)
-  const router = resolveRouter(params.router)
-  const localFrontend =
-    ctx.definition.frontend !== undefined && ctx.definition.frontend.source.kind !== 'external'
-  if (localFrontend !== (frontend !== undefined && frontend.artifact.source.kind !== 'external')) {
-    throw new TypeError('cloudflare adapter: materialized frontend must match definition.frontend.')
-  }
-
-  await writeFileAtomic(
-    join(astraleDir, 'worker.gen.ts'),
-    generateWorkerEntry({
-      origin: ctx.definition.schema.origin,
-      ...(router
-        ? {
-            router: {
-              binding: router.binding,
-              hostSuffix: router.hostSuffix,
-              minLabels: router.minLabels,
-            },
-          }
-        : {}),
-    }),
-  )
-
-  const workerUrl =
-    mode === 'deploy' && params.route
-      ? `https://${params.route}`
-      : mode === 'dev' && params.host
-        ? params.host
-        : undefined
-  const vars = {
-    ...(workerUrl ? { WORKER_URL: workerUrl } : {}),
-    ...(mode === 'dev'
-      ? { ...params.vars, ...('secrets' in ctx ? ctx.secrets : {}) }
-      : { ...params.vars }),
-  }
-  const baseConfig = {
-    workerName: name,
-    ...(mode === 'deploy' && params.route ? { route: params.route } : {}),
-    ...(localFrontend
-      ? {
-          frontend: {
-            directory: './frontend',
-            routes: localFrontendRoutes(ctx.definition),
-          },
-        }
-      : {}),
-    vars,
-    ...(router ? { router: { binding: router.binding, service: router.service } } : {}),
-    ...(params.wrangler ? { wrangler: params.wrangler } : {}),
-  }
-
-  const configPath = join(astraleDir, 'wrangler.gen.jsonc')
-  await writeFileAtomic(configPath, generateWranglerConfig({ ...baseConfig, selfBinding: true }))
-
-  let fallbackConfigPath: string | undefined
-  if (mode === 'deploy') {
-    fallbackConfigPath = join(astraleDir, 'wrangler.no-self.gen.jsonc')
-    await writeFileAtomic(
-      fallbackConfigPath,
-      generateWranglerConfig({ ...baseConfig, selfBinding: false }),
-    )
-  }
-
-  return {
-    configPath,
-    ...(fallbackConfigPath ? { fallbackConfigPath } : {}),
-    port: params.port ?? DEFAULT_PORT,
-    workerName: name,
-  }
-}
-
-function localFrontendRoutes(
-  definition: BuildCtx['definition'] | DeployCtx['definition'] | WatchCtx['definition'],
-): readonly string[] {
-  const frontend = definition.frontend
-  if (frontend === undefined || frontend.source.kind === 'external') return Object.freeze([])
-  return Object.freeze(
-    Object.values(frontend.routes as Readonly<Record<string, FrontendRoute>>)
-      .flatMap((route) => (route.path === undefined ? [] : [route.path]))
-      .sort(),
-  )
-}
-
-async function writeFileAtomic(path: string, content: string): Promise<void> {
-  const tmp = `${path}.tmp`
-  await writeFile(tmp, content)
-  await rename(tmp, path)
-}
-
-export function workerName(params: CloudflareParams, origin: string): string {
-  if (params.workerName !== undefined) {
-    if (!WORKER_NAME_RE.test(params.workerName) || params.workerName.length > 63) {
-      throw new Error(
-        `cloudflare adapter: invalid \`workerName\` "${params.workerName}". A Cloudflare worker ` +
-          'name must be lowercase, start with a letter or digit, contain only letters, digits and ' +
-          'dashes, and be at most 63 chars.',
-      )
-    }
-    return params.workerName
-  }
-  return origin
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .slice(0, 54)
-    .replace(/^-+|-+$/g, '')
-}
-
-export function resolveRouter(
-  ir: CloudflareParams['router'],
-): { binding: string; service: string; hostSuffix: string; minLabels: number } | undefined {
-  if (ir === false) return undefined
-  const cfg = ir ?? {}
-  return {
-    binding: cfg.binding ?? 'ROUTER',
-    service: cfg.service ?? 'admin-router',
-    hostSuffix: cfg.hostSuffix ?? '.astrale.ai',
-    minLabels: cfg.minLabels ?? 4,
-  }
-}
-
-export function logTo(): (line: string) => void {
-  return (line: string) => process.stderr.write(`\x1b[2m  ${line}\x1b[0m\n`)
-}

package/src/build/worker.ts

@@ -1,37 +0,0 @@
-import type { BuildCtx, CompiledFrontendArtifact } from '@astrale-os/sdk'
-
-import { join } from 'node:path'
-
-import type { CloudflareParams } from '../params.js'
-
-import { buildFrontend } from './frontend.js'
-import { prepare } from './prepare.js'
-import { runWranglerBundle } from './wrangler-cli.js'
-
-export interface CloudflareWorkerBuild {
-  readonly frontend: CompiledFrontendArtifact | undefined
-  readonly configPath: string
-  readonly bundlePath: string
-}
-
-/** One shared frontend/config/Worker qualification lifecycle for Cloudflare-based adapters. */
-export async function buildCloudflareWorker(input: {
-  readonly params: CloudflareParams
-  readonly context: BuildCtx
-  readonly outDir?: string
-  readonly onLog?: (line: string) => void
-}): Promise<CloudflareWorkerBuild> {
-  const frontend = await buildFrontend({
-    definition: input.context.definition,
-    projectDir: input.context.projectDir,
-    onLog: input.onLog,
-  })
-  const { configPath } = await prepare(input.params, input.context, 'build', frontend)
-  const bundlePath = await runWranglerBundle({
-    projectDir: input.context.projectDir,
-    configPath,
-    outDir: input.outDir ?? join(input.context.projectDir, '.astrale', 'dist-build'),
-    onLog: input.onLog,
-  })
-  return Object.freeze({ frontend, configPath, bundlePath })
-}

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
-}