bleam 0.0.9 → 0.0.10

package/templates/updates/src/schema.ts

@@ -0,0 +1,385 @@
+export type ArtifactFormat = 'bleam-ota-zip-v1' | 'bleam-macos-app-zip-v1'
+
+export interface StoredArtifact {
+  format: ArtifactFormat
+  downloadId: string
+  sizeBytes: number
+  sha256: string
+}
+
+export interface ResolvedArtifact extends StoredArtifact {
+  url: string
+}
+
+interface ReleaseFields {
+  schemaVersion: 1
+  bundleIdentifier: string
+  teamIdentifier: string
+  channel: 'stable'
+  releaseId: string
+  publishedAt: string
+}
+
+export interface OtaRelease extends ReleaseFields {
+  kind: 'ota'
+  bundleVersion: string
+  runtimeVersion: string
+  artifact: StoredArtifact & { format: 'bleam-ota-zip-v1' }
+}
+
+export interface PlatformRelease extends ReleaseFields {
+  kind: 'platform'
+  appVersion: string
+  buildNumber: string
+  bleamPlatformVersion: string
+  platformFingerprint?: string
+  redeploy: boolean
+  target: {
+    os: 'macos'
+    architecture: 'arm64'
+    installLocation: 'user-applications'
+    minimumMacOSVersion: string
+  }
+  artifact: StoredArtifact & { format: 'bleam-macos-app-zip-v1' }
+}
+
+export type StoredRelease = OtaRelease | PlatformRelease
+
+export type ResolvedRelease =
+  | (Omit<OtaRelease, 'artifact'> & { artifact: ResolvedArtifact })
+  | (Omit<PlatformRelease, '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 numericString(value: unknown, field: string): string {
+  const result = string(value, field)
+  if (!/^\d+$/.test(result)) {
+    return invalid(field, 'must contain only decimal digits')
+  }
+  return result
+}
+
+function optionalSha256(value: unknown, field: string): string | undefined {
+  if (value === undefined) return undefined
+  const result = string(value, field)
+  if (!/^[a-f0-9]{64}$/.test(result)) {
+    return invalid(field, 'must be a lowercase SHA-256 hex digest')
+  }
+  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 compareRuntimeVersions(left: string, right: string) {
+  const parse = (value: string) => {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([^+]+))?(?:\+.*)?$/.exec(value)
+    if (!match) return invalid('runtimeVersion', 'must be a semantic version')
+    return {
+      core: match.slice(1, 4).map(Number),
+      prerelease: match[4]?.split('.'),
+    }
+  }
+  const a = parse(left)
+  const b = parse(right)
+  for (let index = 0; index < a.core.length; index += 1) {
+    if (a.core[index] !== b.core[index]) {
+      return (a.core[index] ?? 0) < (b.core[index] ?? 0) ? -1 : 1
+    }
+  }
+  if (!a.prerelease && !b.prerelease) return 0
+  if (!a.prerelease) return 1
+  if (!b.prerelease) return -1
+  const length = Math.max(a.prerelease.length, b.prerelease.length)
+  for (let index = 0; index < length; index += 1) {
+    const aPart = a.prerelease[index]
+    const bPart = b.prerelease[index]
+    if (aPart === undefined) return -1
+    if (bPart === undefined) return 1
+    if (aPart === bPart) continue
+    const aNumber = /^\d+$/.test(aPart) ? Number(aPart) : undefined
+    const bNumber = /^\d+$/.test(bPart) ? Number(bPart) : undefined
+    if (aNumber !== undefined && bNumber !== undefined) {
+      return aNumber < bNumber ? -1 : 1
+    }
+    if (aNumber !== undefined) return -1
+    if (bNumber !== undefined) return 1
+    return aPart < bPart ? -1 : 1
+  }
+  return 0
+}
+
+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, kind: StoredRelease['kind']): StoredArtifact {
+  const input = record(value, 'artifact')
+  const expectedFormat =
+    kind === 'ota' ? 'bleam-ota-zip-v1' : 'bleam-macos-app-zip-v1'
+  exactString(input.format, 'artifact.format', expectedFormat)
+
+  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: expectedFormat,
+    downloadId,
+    sizeBytes: positiveInteger(input.sizeBytes, 'artifact.sizeBytes'),
+    sha256,
+  }
+}
+
+function releaseFields(input: Record<string, unknown>): ReleaseFields {
+  if (input.schemaVersion !== 1) {
+    return invalid('schemaVersion', 'must be 1')
+  }
+
+  exactString(input.channel, 'channel', 'stable')
+  return {
+    schemaVersion: 1,
+    bundleIdentifier: bundleIdentifier(input.bundleIdentifier),
+    teamIdentifier: teamIdentifier(input.teamIdentifier),
+    channel: 'stable',
+    releaseId: releaseId(input.releaseId),
+    publishedAt: publishedAt(input.publishedAt),
+  }
+}
+
+export function parseStoredRelease(value: unknown): StoredRelease {
+  const input = record(value, 'manifest')
+  const kind = string(input.kind, 'kind')
+  const fields = releaseFields(input)
+
+  if (kind === 'ota') {
+    const parsedArtifact = artifact(input.artifact, kind)
+    return {
+      ...fields,
+      kind,
+      bundleVersion: string(input.bundleVersion, 'bundleVersion'),
+      runtimeVersion: version(input.runtimeVersion, 'runtimeVersion'),
+      artifact: {
+        ...parsedArtifact,
+        format: 'bleam-ota-zip-v1',
+      },
+    }
+  }
+
+  if (kind === 'platform') {
+    const target = record(input.target, 'target')
+    exactString(target.os, 'target.os', 'macos')
+    exactString(target.architecture, 'target.architecture', 'arm64')
+    exactString(
+      target.installLocation,
+      'target.installLocation',
+      'user-applications',
+    )
+    const minimumMacOSVersion = string(
+      target.minimumMacOSVersion,
+      'target.minimumMacOSVersion',
+    )
+    if (!/^\d+(?:\.\d+){0,2}$/.test(minimumMacOSVersion)) {
+      return invalid(
+        'target.minimumMacOSVersion',
+        'must be a macOS version number',
+      )
+    }
+
+    const parsedArtifact = artifact(input.artifact, kind)
+    return {
+      ...fields,
+      kind,
+      appVersion: version(input.appVersion, 'appVersion'),
+      buildNumber: numericString(input.buildNumber, 'buildNumber'),
+      bleamPlatformVersion: version(
+        input.bleamPlatformVersion,
+        'bleamPlatformVersion',
+      ),
+      platformFingerprint: optionalSha256(
+        input.platformFingerprint,
+        'platformFingerprint',
+      ),
+      redeploy: input.redeploy === true,
+      target: {
+        os: 'macos',
+        architecture: 'arm64',
+        installLocation: 'user-applications',
+        minimumMacOSVersion,
+      },
+      artifact: {
+        ...parsedArtifact,
+        format: 'bleam-macos-app-zip-v1',
+      },
+    }
+  }
+
+  return invalid('kind', 'must be "ota" or "platform"')
+}
+
+export function parsePublishedRelease(value: unknown): StoredRelease {
+  const release = parseStoredRelease(value)
+  if (release.kind !== 'platform') return release
+
+  const input = record(value, 'manifest')
+  if (release.platformFingerprint === undefined) {
+    return invalid('platformFingerprint', 'is required')
+  }
+  if (typeof input.redeploy !== 'boolean') {
+    return invalid('redeploy', 'must be a boolean')
+  }
+  return release
+}
+
+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>