bleam 0.0.9 → 0.0.11

package/templates/text-generation/app.config.ts

@@ -0,0 +1,5 @@
+import { appConfig } from 'bleam'
+
+export default appConfig({
+  name: 'Bleam Basic',
+})

package/templates/updates/README.md

@@ -0,0 +1,116 @@
+# Bleam OTA Update Service
+
+This local-only Worker publishes and resolves OTA releases from an R2 simulation
+and serves their artifacts through opaque Bleam download URLs. It has no
+deployment command, Cloudflare account ID, remote binding, authentication, or
+remote publisher endpoint. Running it cannot mutate remote resources.
+
+## Local Development
+
+`bleam dev` normally starts the packaged Worker at `http://127.0.0.1:8787`,
+waits for `/v1/health`, and stops it with the owning dev session. Local state and
+logs persist at:
+
+```text
+~/Library/Caches/bleam/updates/state
+~/Library/Caches/bleam/updates/worker.log
+```
+
+Use Wrangler directly only while developing this service. Wrangler 4.110.0 or
+newer is required:
+
+```sh
+wrangler dev --config services/updates/wrangler.jsonc --local \
+  --persist-to services/updates/.wrangler/state
+```
+
+Run the seeded R2 resolver and download smoke test with:
+
+```sh
+sh services/updates/scripts/smoke.sh
+```
+
+Run the real `bleam publish ota` publication and download loop with:
+
+```sh
+sh services/updates/scripts/ota-e2e.sh
+```
+
+With a configured Apple development team, the installed-app harness validates
+next-launch OTA activation, successful startup confirmation, rejection of a
+hash-valid broken bundle, and fallback to the embedded bundle:
+
+```sh
+sh services/updates/scripts/ota-installed-e2e.sh
+```
+
+The installed-app harness builds and launches an isolated signed app. It is not
+part of the normal service test suite and should only be run when native testing
+is intended.
+
+## API
+
+```text
+GET /v1/health
+GET /v1/apps/:bundleIdentifier/ota/:runtimeVersion
+GET /v1/downloads/:downloadId
+POST /v1/local/releases/ota
+```
+
+The POST route accepts only `localhost` requests. It validates the manifest,
+artifact byte size, and SHA-256 before writing the immutable artifact and
+activating its runtime-specific resolver record.
+
+Resolver responses use `Cache-Control: no-store`. Opaque download IDs are
+immutable, so artifact responses use one-year immutable caching. R2 object keys
+remain private in internal download records.
+
+## Manifest Contract
+
+An OTA release replaces JavaScript and ordinary application assets without
+replacing the installed app. Its `runtimeVersion` is the exact native runtime it
+requires.
+
+```json
+{
+  "schemaVersion": 1,
+  "kind": "ota",
+  "bundleIdentifier": "com.example.notes",
+  "teamIdentifier": "ABCDE12345",
+  "channel": "stable",
+  "releaseId": "ota_release_01",
+  "bundleVersion": "1.2.0+4",
+  "runtimeVersion": "0.0.11",
+  "artifact": {
+    "format": "bleam-ota-zip-v1",
+    "downloadId": "ota_release_01",
+    "url": "http://127.0.0.1:8787/v1/downloads/ota_release_01",
+    "sizeBytes": 1843921,
+    "sha256": "b6d25f9f844da5e5d810501774e5949760a5a45f32e4d8f449905c61d6a8d58d"
+  },
+  "publishedAt": "2026-07-12T16:00:00Z"
+}
+```
+
+The stored manifest omits only the resolver-provided artifact URL. The internal
+R2 layout is:
+
+```text
+releases/<bundleIdentifier>/ota/<runtimeVersion>.json
+downloads/<downloadId>.json
+artifacts/ota/<downloadId>.zip
+```
+
+## Verification And Recovery
+
+Publication verifies the declared artifact size and SHA-256 before activating a
+resolver record. The app repeats both checks after download and requires exact
+bundle identifier, Apple team identifier, and runtime version compatibility.
+
+OTA bundles are cached under
+`~/Library/Caches/Bleam/OTA/<bundleIdentifier>/<releaseId>/`. A verified release
+is selected only on a later cold launch and marked attempted before React Native
+starts. After startup confirmation, the attempted state is cleared. If startup
+fails first, the following launch rejects the release, clears its active state,
+and loads the embedded bundle. A rejected release is not selected again while
+it remains active in the resolver.

package/templates/updates/src/index.ts

@@ -0,0 +1,292 @@
+import {
+  type DownloadRecord,
+  isBundleIdentifier,
+  isDownloadId,
+  isRuntimeVersion,
+  parseDownloadRecord,
+  parseStoredRelease,
+  resolveRelease,
+  type StoredRelease,
+} from './schema'
+
+interface StoredObject {
+  body: ReadableStream<Uint8Array>
+  httpEtag: string
+  size: number
+  text(): Promise<string>
+}
+
+interface UpdatesBucket {
+  get(key: string): Promise<StoredObject | null>
+  put(
+    key: string,
+    value: string | ArrayBuffer,
+    options?: { httpMetadata?: { contentType: string } },
+  ): Promise<unknown>
+}
+
+interface Env {
+  UPDATES: UpdatesBucket
+}
+
+const jsonHeaders = {
+  'content-type': 'application/json; charset=utf-8',
+  'cache-control': 'no-store',
+}
+
+function json(value: unknown, status = 200, method = 'GET') {
+  return new Response(method === 'HEAD' ? null : JSON.stringify(value), {
+    status,
+    headers: jsonHeaders,
+  })
+}
+
+function error(code: string, status: number, method: string) {
+  return json({ error: { code } }, status, method)
+}
+
+function notFound(method: string) {
+  return error('not_found', 404, method)
+}
+
+function unavailable(method: string) {
+  return error('invalid_release', 500, method)
+}
+
+function methodNotAllowed() {
+  return new Response(null, {
+    status: 405,
+    headers: { allow: 'GET, HEAD' },
+  })
+}
+
+function isLocalRequest(request: Request) {
+  const hostname = new URL(request.url).hostname
+  return hostname === '127.0.0.1' || hostname === 'localhost'
+}
+
+function base64Bytes(value: string) {
+  const binary = atob(value)
+  const bytes = new Uint8Array(binary.length)
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index)
+  }
+  return bytes
+}
+
+async function sha256(bytes: Uint8Array) {
+  const digest = await crypto.subtle.digest(
+    'SHA-256',
+    bytes.buffer.slice(
+      bytes.byteOffset,
+      bytes.byteOffset + bytes.byteLength,
+    ) as ArrayBuffer,
+  )
+  return Array.from(new Uint8Array(digest), (byte) =>
+    byte.toString(16).padStart(2, '0'),
+  ).join('')
+}
+
+async function publishLocalRelease(request: Request, bucket: UpdatesBucket) {
+  if (!isLocalRequest(request)) return notFound(request.method)
+
+  let input: Record<string, unknown>
+  try {
+    input = (await request.json()) as Record<string, unknown>
+  } catch {
+    return error('invalid_request', 400, request.method)
+  }
+
+  if (typeof input.artifactBase64 !== 'string') {
+    return error('invalid_request', 400, request.method)
+  }
+
+  try {
+    const release = parseStoredRelease(input.release)
+    const artifact = base64Bytes(input.artifactBase64)
+    if (artifact.byteLength !== release.artifact.sizeBytes) {
+      return error('invalid_request', 400, request.method)
+    }
+    if ((await sha256(artifact)) !== release.artifact.sha256) {
+      return error('invalid_request', 400, request.method)
+    }
+
+    const releaseKey = `releases/${release.bundleIdentifier}/ota/${release.runtimeVersion}.json`
+
+    const artifactKey = `artifacts/ota/${release.artifact.downloadId}.zip`
+    const download: DownloadRecord = {
+      schemaVersion: 1,
+      downloadId: release.artifact.downloadId,
+      artifactKey,
+      contentType: 'application/zip',
+    }
+    await bucket.put(artifactKey, artifact.buffer, {
+      httpMetadata: { contentType: 'application/zip' },
+    })
+    await bucket.put(
+      `downloads/${download.downloadId}.json`,
+      JSON.stringify(download),
+      { httpMetadata: { contentType: 'application/json' } },
+    )
+    await bucket.put(releaseKey, JSON.stringify(release), {
+      httpMetadata: { contentType: 'application/json' },
+    })
+    return json(
+      resolveRelease(
+        release,
+        new URL(`/v1/downloads/${download.downloadId}`, request.url).toString(),
+      ),
+      201,
+    )
+  } catch {
+    return error('invalid_request', 400, request.method)
+  }
+}
+
+function decodedSegment(value: string): string | undefined {
+  try {
+    return decodeURIComponent(value)
+  } catch {
+    return undefined
+  }
+}
+
+async function readStoredJson(bucket: UpdatesBucket, key: string) {
+  const object = await bucket.get(key)
+  if (!object) return undefined
+
+  try {
+    return JSON.parse(await object.text()) as unknown
+  } catch {
+    return undefined
+  }
+}
+
+function releaseResponse(
+  release: StoredRelease,
+  request: Request,
+  method: string,
+) {
+  const artifactUrl = new URL(
+    `/v1/downloads/${release.artifact.downloadId}`,
+    request.url,
+  ).toString()
+  return json(resolveRelease(release, artifactUrl), 200, method)
+}
+
+async function resolveOta(
+  bucket: UpdatesBucket,
+  request: Request,
+  bundleIdentifier: string,
+  runtimeVersion: string,
+  method: string,
+) {
+  if (
+    !isBundleIdentifier(bundleIdentifier) ||
+    !isRuntimeVersion(runtimeVersion)
+  ) {
+    return notFound(method)
+  }
+
+  const stored = await readStoredJson(
+    bucket,
+    `releases/${bundleIdentifier}/ota/${runtimeVersion}.json`,
+  )
+  if (!stored) return notFound(method)
+
+  try {
+    const release = parseStoredRelease(stored)
+    if (
+      release.kind !== 'ota' ||
+      release.bundleIdentifier !== bundleIdentifier ||
+      release.runtimeVersion !== runtimeVersion
+    ) {
+      return unavailable(method)
+    }
+    return releaseResponse(release, request, method)
+  } catch {
+    return unavailable(method)
+  }
+}
+
+async function downloadArtifact(
+  bucket: UpdatesBucket,
+  downloadId: string,
+  method: string,
+) {
+  if (!isDownloadId(downloadId)) return notFound(method)
+
+  const stored = await readStoredJson(bucket, `downloads/${downloadId}.json`)
+  if (!stored) return notFound(method)
+
+  let download: DownloadRecord
+  try {
+    download = parseDownloadRecord(stored)
+  } catch {
+    return unavailable(method)
+  }
+
+  if (download.downloadId !== downloadId) return unavailable(method)
+
+  const artifact = await bucket.get(download.artifactKey)
+  if (!artifact) return notFound(method)
+
+  const headers = new Headers({
+    'content-type': download.contentType,
+    'cache-control': 'public, max-age=31536000, immutable',
+    etag: artifact.httpEtag,
+    'content-length': String(artifact.size),
+  })
+  return new Response(method === 'HEAD' ? null : artifact.body, {
+    status: 200,
+    headers,
+  })
+}
+
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    const url = new URL(request.url)
+    if (request.method === 'GET' && url.pathname === '/v1/health') {
+      return json({ healthy: true })
+    }
+    if (
+      request.method === 'POST' &&
+      url.pathname === '/v1/local/releases/ota'
+    ) {
+      return publishLocalRelease(request, env.UPDATES)
+    }
+
+    if (request.method !== 'GET' && request.method !== 'HEAD') {
+      return methodNotAllowed()
+    }
+
+    const path = url.pathname.split('/').filter(Boolean)
+    const method = request.method
+
+    if (
+      path.length === 5 &&
+      path[0] === 'v1' &&
+      path[1] === 'apps' &&
+      path[3] === 'ota'
+    ) {
+      const bundleIdentifier = decodedSegment(path[2])
+      const runtimeVersion = decodedSegment(path[4])
+      if (!bundleIdentifier || !runtimeVersion) return notFound(method)
+      return resolveOta(
+        env.UPDATES,
+        request,
+        bundleIdentifier,
+        runtimeVersion,
+        method,
+      )
+    }
+
+    if (path.length === 3 && path[0] === 'v1' && path[1] === 'downloads') {
+      const downloadId = decodedSegment(path[2])
+      if (!downloadId) return notFound(method)
+      return downloadArtifact(env.UPDATES, downloadId, method)
+    }
+
+    return notFound(method)
+  },
+}

package/templates/updates/src/schema.ts

@@ -0,0 +1,230 @@
+export type ArtifactFormat = 'bleam-ota-zip-v1'
+
+export interface StoredArtifact {
+  format: ArtifactFormat
+  downloadId: string
+  sizeBytes: number
+  sha256: string
+}
+
+export interface ResolvedArtifact extends StoredArtifact {
+  url: string
+}
+
+export interface OtaRelease {
+  schemaVersion: 1
+  kind: 'ota'
+  bundleIdentifier: string
+  teamIdentifier: string
+  channel: 'stable'
+  releaseId: string
+  bundleVersion: string
+  runtimeVersion: string
+  artifact: StoredArtifact & { format: 'bleam-ota-zip-v1' }
+  publishedAt: string
+}
+
+export type StoredRelease = OtaRelease
+
+export type ResolvedRelease = Omit<OtaRelease, 'artifact'> & {
+  artifact: ResolvedArtifact
+}
+
+export interface DownloadRecord {
+  schemaVersion: 1
+  downloadId: string
+  artifactKey: string
+  contentType: string
+}
+
+export class ManifestValidationError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'ManifestValidationError'
+  }
+}
+
+function invalid(field: string, detail: string): never {
+  throw new ManifestValidationError(`${field} ${detail}`)
+}
+
+function record(value: unknown, field: string): Record<string, unknown> {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    return invalid(field, 'must be an object')
+  }
+  return value as Record<string, unknown>
+}
+
+function string(value: unknown, field: string): string {
+  if (typeof value !== 'string' || !value.trim()) {
+    return invalid(field, 'must be a non-empty string')
+  }
+  return value
+}
+
+function exactString(value: unknown, field: string, expected: string): string {
+  const result = string(value, field)
+  if (result !== expected) {
+    return invalid(field, `must be ${JSON.stringify(expected)}`)
+  }
+  return result
+}
+
+function positiveInteger(value: unknown, field: string): number {
+  if (!Number.isSafeInteger(value) || (value as number) <= 0) {
+    return invalid(field, 'must be a positive integer')
+  }
+  return value as number
+}
+
+function version(value: unknown, field: string): string {
+  const result = string(value, field)
+  if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(result)) {
+    return invalid(field, 'must be a semantic version')
+  }
+  return result
+}
+
+function publishedAt(value: unknown): string {
+  const result = string(value, 'publishedAt')
+  if (
+    !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/.test(result) ||
+    Number.isNaN(Date.parse(result))
+  ) {
+    return invalid('publishedAt', 'must be an RFC 3339 UTC timestamp')
+  }
+  return result
+}
+
+export function isBundleIdentifier(value: string): boolean {
+  return /^[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)*$/.test(value)
+}
+
+export function isRuntimeVersion(value: string): boolean {
+  return /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(value)
+}
+
+export function isDownloadId(value: string): boolean {
+  return /^[a-z][a-z0-9_-]{2,127}$/.test(value)
+}
+
+function releaseId(value: unknown): string {
+  const result = string(value, 'releaseId')
+  if (!isDownloadId(result)) {
+    return invalid(
+      'releaseId',
+      'must use lowercase letters, numbers, underscores, or hyphens',
+    )
+  }
+  return result
+}
+
+function bundleIdentifier(value: unknown): string {
+  const result = string(value, 'bundleIdentifier')
+  if (!isBundleIdentifier(result)) {
+    return invalid('bundleIdentifier', 'must be a bundle identifier')
+  }
+  return result
+}
+
+function teamIdentifier(value: unknown): string {
+  const result = string(value, 'teamIdentifier')
+  if (!/^[A-Z0-9]{10}$/.test(result)) {
+    return invalid('teamIdentifier', 'must be a 10-character Apple team ID')
+  }
+  return result
+}
+
+function artifact(value: unknown): StoredArtifact {
+  const input = record(value, 'artifact')
+  exactString(input.format, 'artifact.format', 'bleam-ota-zip-v1')
+
+  const downloadId = string(input.downloadId, 'artifact.downloadId')
+  if (!isDownloadId(downloadId)) {
+    return invalid(
+      'artifact.downloadId',
+      'must use lowercase letters, numbers, underscores, or hyphens',
+    )
+  }
+
+  const sha256 = string(input.sha256, 'artifact.sha256')
+  if (!/^[a-f0-9]{64}$/.test(sha256)) {
+    return invalid('artifact.sha256', 'must be a lowercase SHA-256 hex digest')
+  }
+
+  return {
+    format: 'bleam-ota-zip-v1',
+    downloadId,
+    sizeBytes: positiveInteger(input.sizeBytes, 'artifact.sizeBytes'),
+    sha256,
+  }
+}
+
+export function parseStoredRelease(value: unknown): StoredRelease {
+  const input = record(value, 'manifest')
+  if (input.schemaVersion !== 1) {
+    return invalid('schemaVersion', 'must be 1')
+  }
+  exactString(input.kind, 'kind', 'ota')
+  exactString(input.channel, 'channel', 'stable')
+  return {
+    schemaVersion: 1,
+    kind: 'ota',
+    bundleIdentifier: bundleIdentifier(input.bundleIdentifier),
+    teamIdentifier: teamIdentifier(input.teamIdentifier),
+    channel: 'stable',
+    releaseId: releaseId(input.releaseId),
+    bundleVersion: string(input.bundleVersion, 'bundleVersion'),
+    runtimeVersion: version(input.runtimeVersion, 'runtimeVersion'),
+    artifact: artifact(input.artifact),
+    publishedAt: publishedAt(input.publishedAt),
+  }
+}
+
+export function parseDownloadRecord(value: unknown): DownloadRecord {
+  const input = record(value, 'download record')
+  if (input.schemaVersion !== 1) {
+    return invalid('schemaVersion', 'must be 1')
+  }
+
+  const downloadId = string(input.downloadId, 'downloadId')
+  if (!isDownloadId(downloadId)) {
+    return invalid(
+      'downloadId',
+      'must use lowercase letters, numbers, underscores, or hyphens',
+    )
+  }
+
+  const artifactKey = string(input.artifactKey, 'artifactKey')
+  if (
+    !/^artifacts\/[A-Za-z0-9._/-]+$/.test(artifactKey) ||
+    artifactKey.split('/').includes('..')
+  ) {
+    return invalid('artifactKey', 'must be a private artifacts path')
+  }
+
+  const contentType = string(input.contentType, 'contentType')
+  if (!/^[^/\s]+\/[^/\s]+$/.test(contentType)) {
+    return invalid('contentType', 'must be a MIME type')
+  }
+
+  return {
+    schemaVersion: 1,
+    downloadId,
+    artifactKey,
+    contentType,
+  }
+}
+
+export function resolveRelease(
+  release: StoredRelease,
+  artifactUrl: string,
+): ResolvedRelease {
+  return {
+    ...release,
+    artifact: {
+      ...release.artifact,
+      url: artifactUrl,
+    },
+  }
+}

package/templates/updates/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022", "WebWorker"],
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}

package/templates/updates/wrangler.jsonc

@@ -0,0 +1,19 @@
+{
+  "name": "bleam-updates-local",
+  "main": "src/index.ts",
+  "compatibility_date": "2026-07-13",
+  "compatibility_flags": ["nodejs_compat"],
+  "workers_dev": false,
+  "send_metrics": false,
+  "dev": {
+    "ip": "127.0.0.1",
+    "port": 8787,
+    "local_protocol": "http"
+  },
+  "r2_buckets": [
+    {
+      "binding": "UPDATES",
+      "bucket_name": "bleam-updates-local"
+    }
+  ]
+}

package/templates/native/ios/PlatformHelper/Info.plist

@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>$(DEVELOPMENT_LANGUAGE)</string>
-	<key>CFBundleExecutable</key>
-	<string>$(EXECUTABLE_NAME)</string>
-	<key>CFBundleIdentifier</key>
-	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundleName</key>
-	<string>$(PRODUCT_NAME)</string>
-	<key>CFBundlePackageType</key>
-	<string>XPC!</string>
-	<key>CFBundleShortVersionString</key>
-	<string>$(MARKETING_VERSION)</string>
-	<key>CFBundleVersion</key>
-	<string>$(CURRENT_PROJECT_VERSION)</string>
-	<key>BleamPlatformVersion</key>
-	<string>0.0.9</string>
-	<key>XPCService</key>
-	<dict>
-		<key>ServiceType</key>
-		<string>Application</string>
-	</dict>
-</dict>
-</plist>