@ouraihub/aether-worker 0.0.0-stage → 0.1.0

package/migrations/0001.sql

@@ -0,0 +1,22 @@
+-- Apply explicitly with the deployment's D1 migration command, never at request startup.
+CREATE TABLE aether_schema (
+  singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+  version INTEGER NOT NULL CHECK (version >= 1)
+);
+INSERT INTO aether_schema (singleton, version) VALUES (1, 1);
+CREATE TABLE aether_documents (
+  application_id TEXT NOT NULL,
+  tenant_key TEXT NOT NULL,
+  subject_id TEXT NOT NULL,
+  owner_key TEXT NOT NULL,
+  collection TEXT NOT NULL,
+  key TEXT NOT NULL,
+  revision INTEGER NOT NULL CHECK (revision >= 1),
+  value_json TEXT,
+  blob_key TEXT,
+  deleted INTEGER NOT NULL DEFAULT 0 CHECK (deleted IN (0, 1)),
+  updated_at INTEGER NOT NULL,
+  PRIMARY KEY (application_id, tenant_key, subject_id, collection, key),
+  CHECK ((deleted = 0 AND ((value_json IS NOT NULL AND json_valid(value_json) AND blob_key IS NULL) OR (value_json IS NULL AND blob_key IS NOT NULL))) OR (deleted = 1 AND value_json IS NULL AND blob_key IS NULL))
+) WITHOUT ROWID;
+CREATE INDEX aether_documents_list ON aether_documents (application_id, tenant_key, subject_id, collection, deleted, key);

package/package.json

@@ -1,6 +1,40 @@
 {
   "name": "@ouraihub/aether-worker",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "license": "LGPL-3.0-only",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ouraihub/Aether.git",
+    "directory": "packages/worker"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./providers": "./src/providers/index.ts",
+    "./search": "./src/search/index.ts",
+    "./images": "./src/images/index.ts",
+    "./skills": "./src/skills/index.ts",
+    "./mcp": "./src/mcp/index.ts",
+    "./conversations": "./src/conversations/index.ts",
+    "./*": "./src/*.ts"
+  },
+  "dependencies": {
+    "@ouraihub/aether-contracts": "0.1.0",
+    "@ouraihub/aether-core": "0.1.0"
+  },
+  "devDependencies": {},
+  "files": [
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.svelte",
+    "!src/**/__tests__",
+    "migrations"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "tsx --test \"src/**/*.test.ts\""
+  }
 }

package/src/app.ts

@@ -0,0 +1,327 @@
+import { isContract } from '@ouraihub/aether-contracts'
+import type { KitError, KitErrorCode } from '@ouraihub/aether-contracts'
+import { badRequest, KitFailure, safeError } from '@ouraihub/aether-core/error'
+import type { DurableObjectNamespace } from './cloudflare.ts'
+import { immutableActor, isActor } from './context.ts'
+import type { Actor, WorkerContext } from './context.ts'
+import type { IdentityPort } from './identity.ts'
+import type { Logger } from './logger.ts'
+
+export interface WorkerHandler {
+  handle(request: Request, context: WorkerContext): Promise<Response | null>
+}
+export interface PublicWorkerHandler {
+  handlePublic(request: Request): Promise<Response | null>
+}
+export interface WorkerAppOptions {
+  readonly applicationId: string
+  readonly origin: string
+  readonly identity: IdentityPort
+  readonly runs: DurableObjectNamespace
+  readonly handlers?: readonly WorkerHandler[]
+  readonly publicHandlers?: readonly PublicWorkerHandler[]
+  /** Authentication does not imply resource authorization or admission quota. */
+  readonly authorizeRoute: (actor: Actor, request: Request) => Promise<void>
+  readonly verifyCsrf: (request: Request, actor: Actor) => Promise<boolean>
+  readonly logger?: Logger
+  readonly maxBodyBytes?: number
+  readonly allowLoopbackHttp?: boolean
+}
+const statuses: Record<KitErrorCode, number> = {
+  bad_request: 400,
+  not_found: 404,
+  conflict: 409,
+  unsupported: 422,
+  cancelled: 409,
+  unauthorized: 401,
+  forbidden: 403,
+  rate_limited: 429,
+  upstream: 502,
+  timeout: 504,
+  network: 502,
+  needs_config: 422,
+  budget_exceeded: 413,
+  incompatible_db: 503,
+  internal: 500,
+}
+function failureResponse(error: unknown): Response {
+  let safe: KitError = safeError(error)
+  if (safe.code === 'internal')
+    safe = { code: 'internal', message: 'Internal request failure', details: { errorId: crypto.randomUUID() } }
+  return Response.json(safe, { status: statuses[safe.code] })
+}
+function loopback(url: URL): boolean {
+  return url.hostname === 'localhost' || url.hostname === '127.0.0.1' || url.hostname === '[::1]'
+}
+async function boundedRequest(request: Request, maximum: number): Promise<Request> {
+  if (request.method === 'GET' || request.method === 'HEAD' || request.body === null) return request
+  const declared = request.headers.get('content-length')
+  if (declared !== null && (!/^\d+$/u.test(declared) || Number(declared) > maximum))
+    throw badRequest('body', 'too_large', maximum)
+  const reader = request.body.getReader(),
+    chunks: Uint8Array[] = []
+  let size = 0,
+    completed = false
+  try {
+    while (true) {
+      const next = await reader.read()
+      if (next.done) {
+        completed = true
+        break
+      }
+      size += next.value.byteLength
+      if (size > maximum) throw badRequest('body', 'too_large', maximum)
+      chunks.push(next.value)
+    }
+  } finally {
+    if (!completed) await reader.cancel().catch(() => undefined)
+    reader.releaseLock()
+  }
+  const bytes = new Uint8Array(size)
+  let offset = 0
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset)
+    offset += chunk.byteLength
+  }
+  return new Request(request, { body: bytes })
+}
+function actorHeader(actor: Actor): string {
+  const bytes = new TextEncoder().encode(JSON.stringify(actor))
+  let binary = ''
+  for (const byte of bytes) binary += String.fromCharCode(byte)
+  return btoa(binary)
+}
+function secured(response: Response, origin: string | null, allowed: string): Response {
+  const headers = new Headers(response.headers)
+  headers.set('X-Content-Type-Options', 'nosniff')
+  headers.set('Referrer-Policy', 'no-referrer')
+  headers.set(
+    'Cache-Control',
+    headers.get('content-type')?.startsWith('text/event-stream') ? 'no-cache, no-transform' : 'no-store',
+  )
+  if (origin === allowed) {
+    headers.set('Access-Control-Allow-Origin', allowed)
+    headers.set('Access-Control-Allow-Credentials', 'true')
+    headers.append('Vary', 'Origin')
+  }
+  return new Response(response.body, { status: response.status, statusText: response.statusText, headers })
+}
+/** Product entrypoints compose this handler; this package never supplies product login or business tools. */
+export function createAetherWorkerApp(options: WorkerAppOptions): { fetch(request: Request): Promise<Response> } {
+  const publicOrigin = new URL(options.origin)
+  if (
+    !options.applicationId ||
+    publicOrigin.origin !== options.origin ||
+    (publicOrigin.protocol !== 'https:' &&
+      !(options.allowLoopbackHttp && publicOrigin.protocol === 'http:' && loopback(publicOrigin)))
+  )
+    throw new KitFailure('needs_config', 'Invalid Worker origin or application')
+  const maximum = options.maxBodyBytes ?? 24 * 1024 * 1024
+  if (!Number.isSafeInteger(maximum) || maximum <= 0 || maximum > 32 * 1024 * 1024)
+    throw badRequest('maxBodyBytes', 'invalid')
+  return {
+    async fetch(raw: Request): Promise<Response> {
+      const now = Date.now(),
+        requestId = crypto.randomUUID(),
+        url = new URL(raw.url),
+        origin = raw.headers.get('origin')
+      let response: Response
+      try {
+        if (url.protocol !== 'https:' && !(options.allowLoopbackHttp && url.protocol === 'http:' && loopback(url)))
+          throw new KitFailure('forbidden', 'Secure transport required')
+        if (origin !== null && origin !== options.origin) throw new KitFailure('forbidden', 'Origin rejected')
+        if (raw.method === 'OPTIONS') {
+          if (origin !== options.origin) throw new KitFailure('forbidden', 'Origin rejected')
+          return secured(
+            new Response(null, {
+              status: 204,
+              headers: {
+                'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, X-CSRF-Token',
+                'Access-Control-Max-Age': '600',
+              },
+            }),
+            origin,
+            options.origin,
+          )
+        }
+        const mutating = !['GET', 'HEAD'].includes(raw.method)
+        const publicRoute =
+          url.pathname === '/mcp' || url.pathname.startsWith('/oauth/') || url.pathname.startsWith('/.well-known/')
+        if (
+          mutating &&
+          raw.body !== null &&
+          !publicRoute &&
+          raw.headers.get('content-type')?.split(';')[0]?.trim().toLowerCase() !== 'application/json'
+        )
+          throw badRequest('contentType', 'json_required')
+        const request = await boundedRequest(raw, maximum)
+        if (publicRoute) {
+          let publicResponse: Response | null = null
+          for (const handler of options.publicHandlers ?? []) {
+            publicResponse = await handler.handlePublic(request)
+            if (publicResponse) break
+          }
+          if (!publicResponse) throw new KitFailure('not_found', 'Unknown route', { entity: 'route' })
+          response = publicResponse
+        } else {
+          const actor = await options.identity.resolve(request)
+          if (!isActor(actor) || actor.applicationId !== options.applicationId)
+            throw new KitFailure('unauthorized', 'Authentication required')
+          if (
+            mutating &&
+            actor.kind === 'user' &&
+            actor.sessionId !== null &&
+            (origin !== options.origin || !(await options.verifyCsrf(request, actor)))
+          )
+            throw new KitFailure('forbidden', 'Request authorization rejected')
+          await options.authorizeRoute(actor, request)
+          const context: WorkerContext = { actor: immutableActor(actor), requestId, now, signal: request.signal }
+          if (url.pathname === '/api/v1/runs' && request.method === 'POST') {
+            const input: unknown = await request.json()
+            if (!isContract('RunRequest', input)) throw badRequest('run', 'invalid')
+            const runId = crypto.randomUUID(),
+              stub = options.runs.get(options.runs.idFromName(`${options.applicationId}:${runId}`))
+            const accepted = await stub.fetch('https://aether.internal/accept', {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({ actor: context.actor, request: input, runId }),
+              signal: request.signal,
+            })
+            const value: unknown = await accepted.json()
+            if (accepted.status !== 202) {
+              if (isContract('KitError', value)) throw new KitFailure(value.code, value.message, value.details)
+              throw new KitFailure('internal', 'Invalid coordinator reply')
+            }
+            if (!isContract('RunAccepted', value)) throw new KitFailure('internal', 'Invalid coordinator acceptance')
+            response = Response.json(
+              { accepted: value, events: `/api/v1/runs/${encodeURIComponent(runId)}/events` },
+              { status: 202 },
+            )
+          } else {
+            const run = /^\/api\/v1\/runs\/([^/]+)(?:\/(events|cancel|approval))?$/u.exec(url.pathname)
+            if (run) {
+              const runId = decodeURIComponent(run[1] ?? ''),
+                action = run[2] ?? 'snapshot'
+              if (
+                !/^[A-Za-z0-9_-]{1,128}$/u.test(runId) ||
+                (['events', 'snapshot'].includes(action) ? request.method !== 'GET' : request.method !== 'POST')
+              )
+                throw badRequest('run', 'invalid')
+              const stub = options.runs.get(options.runs.idFromName(`${options.applicationId}:${runId}`)),
+                headers = new Headers({ 'x-aether-actor': actorHeader(context.actor) })
+              if (request.headers.has('Last-Event-ID'))
+                headers.set('Last-Event-ID', request.headers.get('Last-Event-ID') ?? '')
+              const body = request.method === 'POST' ? await request.text() : undefined
+              if (body !== undefined) headers.set('Content-Type', 'application/json')
+              response = await stub.fetch(`https://aether.internal/${action}`, {
+                method: request.method,
+                headers,
+                ...(body === undefined ? {} : { body }),
+                signal: request.signal,
+              })
+              if (
+                action === 'events' &&
+                response.status === 200 &&
+                response.body &&
+                response.headers.get('content-type')?.startsWith('text/event-stream')
+              ) {
+                const upstream = response.body.getReader()
+                const transport = new TransformStream<Uint8Array, Uint8Array>()
+                const writer = transport.writable.getWriter()
+                const heartbeat = new TextEncoder().encode(': keep-alive\n\n')
+                let finished = false,
+                  heartbeatPending = false
+                let cancellation: Promise<void> | null = null
+                const disconnected = (): Promise<void> => {
+                  if (finished) return Promise.resolve()
+                  if (cancellation) return cancellation
+                  clearInterval(timer)
+                  request.signal.removeEventListener('abort', aborted)
+                  // RPC response-body cancellation is not a reliable cross-isolate signal.
+                  // Explicitly notify the same authenticated run without the aborted client signal.
+                  cancellation = Promise.all([
+                    stub
+                      .fetch('https://aether.internal/cancel', {
+                        method: 'POST',
+                        headers: { 'x-aether-actor': actorHeader(context.actor), 'Content-Type': 'application/json' },
+                        body: '{}',
+                      })
+                      .then(async (reply) => {
+                        await reply.body?.cancel()
+                      }),
+                    upstream.cancel(),
+                    writer.abort(),
+                  ]).then(() => undefined)
+                  return cancellation
+                }
+                const aborted = (): void => {
+                  void disconnected().catch(() => undefined)
+                }
+                // A comment forces a real transport write even while the engine awaits approval.
+                const timer = setInterval(() => {
+                  if (finished || cancellation || heartbeatPending) return
+                  heartbeatPending = true
+                  void writer
+                    .write(heartbeat)
+                    .catch(disconnected)
+                    .finally(() => {
+                      heartbeatPending = false
+                    })
+                    .catch(() => undefined)
+                }, 1000)
+                request.signal.addEventListener('abort', aborted, { once: true })
+                void writer.closed.catch(disconnected).catch(() => undefined)
+                const pump = async (): Promise<void> => {
+                  try {
+                    while (!cancellation) {
+                      const next = await upstream.read()
+                      if (next.done) {
+                        clearInterval(timer)
+                        await writer.close()
+                        finished = true
+                        break
+                      }
+                      await writer.write(next.value)
+                    }
+                  } catch {
+                    await disconnected()
+                  } finally {
+                    clearInterval(timer)
+                    request.signal.removeEventListener('abort', aborted)
+                    upstream.releaseLock()
+                    writer.releaseLock()
+                  }
+                }
+                void pump().catch(() => undefined)
+                if (request.signal.aborted) aborted()
+                response = new Response(transport.readable, {
+                  status: response.status,
+                  statusText: response.statusText,
+                  headers: response.headers,
+                })
+              }
+            } else {
+              let handled: Response | null = null
+              for (const handler of options.handlers ?? []) {
+                handled = await handler.handle(request, context)
+                if (handled) break
+              }
+              if (!handled) throw new KitFailure('not_found', 'Unknown route', { entity: 'route' })
+              response = handled
+            }
+          }
+        }
+      } catch (error) {
+        response = failureResponse(error)
+      }
+      options.logger?.log('request.finished', {
+        requestId,
+        applicationId: options.applicationId,
+        status: response.status,
+        durationMs: Date.now() - now,
+      })
+      return secured(response, origin, options.origin)
+    },
+  }
+}

package/src/cloudflare.ts

@@ -0,0 +1,49 @@
+/** Structural subsets: the adapter needs no Cloudflare ambient globals. */
+export interface D1Statement {
+  bind(...values: (string | number | null)[]): D1Statement
+  first(): Promise<unknown>
+  all(): Promise<{ readonly results?: readonly unknown[]; readonly success: boolean }>
+}
+export interface D1Database {
+  prepare(sql: string): D1Statement
+}
+export interface R2Object {
+  readonly size: number
+  readonly httpMetadata?: { readonly contentType?: string }
+  arrayBuffer(): Promise<ArrayBuffer>
+}
+export interface R2Bucket {
+  put(
+    key: string,
+    value: ArrayBuffer | Uint8Array,
+    options?: {
+      readonly httpMetadata?: { readonly contentType?: string }
+      readonly onlyIf?: { readonly etagDoesNotMatch: string }
+    },
+  ): Promise<unknown>
+  get(key: string): Promise<R2Object | null>
+  delete(key: string): Promise<void>
+}
+export interface DurableObjectStorage {
+  get<T = unknown>(key: string): Promise<T | undefined>
+  put<T>(key: string, value: T): Promise<void>
+  delete(key: string): Promise<boolean>
+  setAlarm(scheduledTime: number | Date): Promise<void>
+  getAlarm(): Promise<number | null>
+  deleteAlarm(): Promise<void>
+}
+export interface DurableObjectState {
+  readonly storage: DurableObjectStorage
+  blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>
+  waitUntil(promise: Promise<unknown>): void
+}
+export interface DurableObjectStub {
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>
+}
+export interface DurableObjectNamespace {
+  idFromName(name: string): unknown
+  get(id: unknown): DurableObjectStub
+}
+export interface FetchBinding {
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>
+}

package/src/context.ts

@@ -0,0 +1,49 @@
+import { badRequest } from '@ouraihub/aether-core'
+
+export interface Actor {
+  readonly subjectId: string
+  readonly kind: 'user' | 'service' | 'mcp_client'
+  readonly applicationId: string
+  readonly tenantId: string | null
+  readonly sessionId: string | null
+  readonly scopes: readonly string[]
+}
+export interface WorkerContext {
+  readonly actor: Actor
+  readonly signal: AbortSignal
+  readonly requestId: string
+  readonly now: number
+}
+export function isActor(value: unknown): value is Actor {
+  if (typeof value !== 'object' || value === null) return false
+  return (
+    'subjectId' in value &&
+    typeof value.subjectId === 'string' &&
+    value.subjectId.length > 0 &&
+    value.subjectId.length <= 256 &&
+    'applicationId' in value &&
+    typeof value.applicationId === 'string' &&
+    value.applicationId.length > 0 &&
+    value.applicationId.length <= 256 &&
+    'kind' in value &&
+    (value.kind === 'user' || value.kind === 'service' || value.kind === 'mcp_client') &&
+    'tenantId' in value &&
+    (value.tenantId === null ||
+      (typeof value.tenantId === 'string' && value.tenantId.length > 0 && value.tenantId.length <= 256)) &&
+    'sessionId' in value &&
+    (value.sessionId === null ||
+      (typeof value.sessionId === 'string' && value.sessionId.length > 0 && value.sessionId.length <= 256)) &&
+    'scopes' in value &&
+    Array.isArray(value.scopes) &&
+    value.scopes.length <= 256 &&
+    value.scopes.every((scope: unknown) => typeof scope === 'string' && scope.length > 0 && scope.length <= 256)
+  )
+}
+export function immutableActor(actor: Actor): Actor {
+  if (!isActor(actor)) throw badRequest('actor', 'invalid')
+  return Object.freeze({ ...actor, scopes: Object.freeze([...actor.scopes]) })
+}
+export function ownerKey(actor: Actor): string {
+  if (!isActor(actor)) throw badRequest('actor', 'invalid')
+  return JSON.stringify([actor.applicationId, actor.tenantId, actor.subjectId])
+}