chore: release v2.95.8

security: upgrade dompurify

.codespellrc

@@ -0,0 +1,4 @@
+[codespell]
+skip = .git,*.pdf,*.svg,package-lock.json,*.prisma,pnpm-lock.yaml
+ignore-words-list = afterall,vertx,notIn
+

.dockerignore

@@ -0,0 +1,8 @@
+Dockerfile
+.dockerignore
+node_modules
+npm-debug.log
+README.md
+**/.next
+.git
+**/node_modules

.env.dev-azure.example

@@ -0,0 +1,92 @@
+# When adding additional environment variables, the schema in "/src/env.mjs"
+# should be updated accordingly.
+
+# Prisma
+# https://www.prisma.io/docs/reference/database-reference/connection-urls#env
+DIRECT_URL="postgresql://postgres:postgres@localhost:5432/postgres"
+DATABASE_URL="postgresql://postgres:postgres@localhost:5432/postgres"
+
+# Clickhouse
+CLICKHOUSE_MIGRATION_URL="clickhouse://localhost:9000"
+CLICKHOUSE_URL="http://localhost:8123"
+CLICKHOUSE_USER="clickhouse"
+CLICKHOUSE_PASSWORD="clickhouse"
+CLICKHOUSE_MIGRATION_CLUSTER_DISABLED="true"
+
+# Next Auth
+# You can generate a new secret on the command line with:
+# openssl rand -base64 32
+# https://next-auth.js.org/configuration/options#secret
+# NEXTAUTH_SECRET=""
+NEXTAUTH_URL="http://localhost:3000"
+NEXTAUTH_SECRET="secret"
+
+# Langfuse Cloud Environment
+NEXT_PUBLIC_LANGFUSE_CLOUD_REGION="DEV"
+
+# Langfuse experimental features
+LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES="true"
+
+# Salt for API key hashing
+SALT="salt"
+
+# Email
+EMAIL_FROM_ADDRESS=""  # Defines the email address to use as the from address.
+SMTP_CONNECTION_URL=""  # Defines the connection url for smtp server.
+
+# DON'T PANIC: The Azurite Secrets are well-known and meant to be hard-coded
+# S3 storage
+S3_ENDPOINT=http://localhost:10000/devstoreaccount1
+S3_ACCESS_KEY_ID=devstoreaccount1
+S3_SECRET_ACCESS_KEY=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==
+S3_BUCKET_NAME=langfuse
+S3_REGION=auto
+## Necessary for minio compatibility
+S3_FORCE_PATH_STYLE=true
+
+# S3 Media Upload LOCAL
+LANGFUSE_S3_MEDIA_UPLOAD_ENABLED=true
+LANGFUSE_S3_MEDIA_UPLOAD_BUCKET=langfuse
+LANGFUSE_S3_MEDIA_UPLOAD_ACCESS_KEY_ID=devstoreaccount1
+LANGFUSE_S3_MEDIA_UPLOAD_SECRET_ACCESS_KEY=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==
+LANGFUSE_S3_MEDIA_UPLOAD_REGION=auto
+LANGFUSE_S3_MEDIA_UPLOAD_ENDPOINT=http://localhost:10000/devstoreaccount1
+## Necessary for minio compatibility
+LANGFUSE_S3_MEDIA_UPLOAD_FORCE_PATH_STYLE=true
+LANGFUSE_S3_MEDIA_UPLOAD_PREFIX=media/
+
+# S3 Event Bucket Upload
+## Set to true to test uploading all events to S3
+LANGFUSE_S3_EVENT_UPLOAD_ENABLED=true
+LANGFUSE_S3_EVENT_UPLOAD_BUCKET=langfuse
+LANGFUSE_S3_EVENT_UPLOAD_ACCESS_KEY_ID=devstoreaccount1
+LANGFUSE_S3_EVENT_UPLOAD_SECRET_ACCESS_KEY=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==
+LANGFUSE_S3_EVENT_UPLOAD_REGION=auto
+LANGFUSE_S3_EVENT_UPLOAD_ENDPOINT=http://localhost:10000/devstoreaccount1
+## Necessary for minio compatibility
+LANGFUSE_S3_EVENT_UPLOAD_FORCE_PATH_STYLE=true
+LANGFUSE_S3_EVENT_UPLOAD_PREFIX=events/
+
+LANGFUSE_USE_AZURE_BLOB=true
+
+# Set during docker build of application
+# Used to disable environment verification at build time
+# DOCKER_BUILD=1
+
+REDIS_HOST="127.0.0.1"
+REDIS_PORT=6379
+REDIS_AUTH="myredissecret"
+
+# openssl rand -hex 32 used only here
+ENCRYPTION_KEY=0000000000000000000000000000000000000000000000000000000000000000 
+
+# speeds up local development by not executing init scripts on server startup
+NEXT_PUBLIC_LANGFUSE_RUN_NEXT_INIT="false"
+
+LANGFUSE_READ_FROM_POSTGRES_ONLY=false
+LANGFUSE_RETURN_FROM_CLICKHOUSE=true
+LANGFUSE_READ_DASHBOARDS_FROM_CLICKHOUSE=true
+LANGFUSE_READ_FROM_CLICKHOUSE_ONLY=true
+
+LANGFUSE_ASYNC_INGESTION_PROCESSING="true"
+LANGFUSE_ASYNC_CLICKHOUSE_INGESTION_PROCESSING="true"

.env.dev.example

@@ -0,0 +1,89 @@
+# When adding additional environment variables, the schema in "/src/env.mjs"
+# should be updated accordingly.
+
+# Prisma
+# https://www.prisma.io/docs/reference/database-reference/connection-urls#env
+DIRECT_URL="postgresql://postgres:postgres@localhost:5432/postgres"
+DATABASE_URL="postgresql://postgres:postgres@localhost:5432/postgres"
+
+# Clickhouse
+CLICKHOUSE_MIGRATION_URL="clickhouse://localhost:9000"
+CLICKHOUSE_URL="http://localhost:8123"
+CLICKHOUSE_USER="clickhouse"
+CLICKHOUSE_PASSWORD="clickhouse"
+CLICKHOUSE_CLUSTER_DISABLED="true"
+
+# Next Auth
+# You can generate a new secret on the command line with:
+# openssl rand -base64 32
+# https://next-auth.js.org/configuration/options#secret
+# NEXTAUTH_SECRET=""
+NEXTAUTH_URL="http://localhost:3000"
+NEXTAUTH_SECRET="secret"
+
+# Langfuse Cloud Environment
+NEXT_PUBLIC_LANGFUSE_CLOUD_REGION="DEV"
+
+# Langfuse experimental features
+LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES="true"
+
+# Salt for API key hashing
+SALT="salt"
+
+# Email
+EMAIL_FROM_ADDRESS=""  # Defines the email address to use as the from address.
+SMTP_CONNECTION_URL=""  # Defines the connection url for smtp server.
+
+# S3 storage
+S3_ENDPOINT=http://localhost:9090
+S3_ACCESS_KEY_ID=minio
+S3_SECRET_ACCESS_KEY=miniosecret
+S3_BUCKET_NAME=langfuse
+S3_REGION=us-east-1
+## Necessary for minio compatibility
+S3_FORCE_PATH_STYLE=true
+
+# S3 Media Upload LOCAL
+LANGFUSE_S3_MEDIA_UPLOAD_ENABLED=true
+LANGFUSE_S3_MEDIA_UPLOAD_BUCKET=langfuse
+LANGFUSE_S3_MEDIA_UPLOAD_ACCESS_KEY_ID=minio
+LANGFUSE_S3_MEDIA_UPLOAD_SECRET_ACCESS_KEY=miniosecret
+LANGFUSE_S3_MEDIA_UPLOAD_REGION=us-east-1
+LANGFUSE_S3_MEDIA_UPLOAD_ENDPOINT=http://localhost:9090
+## Necessary for minio compatibility
+LANGFUSE_S3_MEDIA_UPLOAD_FORCE_PATH_STYLE=true
+LANGFUSE_S3_MEDIA_UPLOAD_PREFIX=media/
+
+# S3 Event Bucket Upload
+## Set to true to test uploading all events to S3
+LANGFUSE_S3_EVENT_UPLOAD_ENABLED=true
+LANGFUSE_S3_EVENT_UPLOAD_BUCKET=langfuse
+LANGFUSE_S3_EVENT_UPLOAD_ACCESS_KEY_ID=minio
+LANGFUSE_S3_EVENT_UPLOAD_SECRET_ACCESS_KEY=miniosecret
+LANGFUSE_S3_EVENT_UPLOAD_REGION=us-east-1
+LANGFUSE_S3_EVENT_UPLOAD_ENDPOINT=http://localhost:9090
+## Necessary for minio compatibility
+LANGFUSE_S3_EVENT_UPLOAD_FORCE_PATH_STYLE=true
+LANGFUSE_S3_EVENT_UPLOAD_PREFIX=events/
+
+# Set during docker build of application
+# Used to disable environment verification at build time
+# DOCKER_BUILD=1
+
+REDIS_HOST="127.0.0.1"
+REDIS_PORT=6379
+REDIS_AUTH="myredissecret"
+
+# openssl rand -hex 32 used only here
+ENCRYPTION_KEY=0000000000000000000000000000000000000000000000000000000000000000 
+
+# speeds up local development by not executing init scripts on server startup
+NEXT_PUBLIC_LANGFUSE_RUN_NEXT_INIT="false"
+
+LANGFUSE_READ_FROM_POSTGRES_ONLY=false
+LANGFUSE_RETURN_FROM_CLICKHOUSE=true
+LANGFUSE_READ_DASHBOARDS_FROM_CLICKHOUSE=true
+LANGFUSE_READ_FROM_CLICKHOUSE_ONLY=true
+
+LANGFUSE_ASYNC_INGESTION_PROCESSING="true"
+LANGFUSE_ASYNC_CLICKHOUSE_INGESTION_PROCESSING="true"

.env.dev.legacy.example

@@ -0,0 +1,81 @@
+# When adding additional environment variables, the schema in "/src/env.mjs"
+# should be updated accordingly.
+
+# Prisma
+# https://www.prisma.io/docs/reference/database-reference/connection-urls#env
+DIRECT_URL="postgresql://postgres:postgres@localhost:5432/postgres"
+DATABASE_URL="postgresql://postgres:postgres@localhost:5432/postgres"
+
+# Clickhouse
+CLICKHOUSE_MIGRATION_URL="clickhouse://localhost:9000"
+CLICKHOUSE_URL="http://localhost:8123"
+CLICKHOUSE_USER="clickhouse"
+CLICKHOUSE_PASSWORD="clickhouse"
+CLICKHOUSE_CLUSTER_ENABLED="false"
+
+# Next Auth
+# You can generate a new secret on the command line with:
+# openssl rand -base64 32
+# https://next-auth.js.org/configuration/options#secret
+# NEXTAUTH_SECRET=""
+NEXTAUTH_URL="http://localhost:3000"
+NEXTAUTH_SECRET="secret"
+
+# Langfuse Cloud Environment
+NEXT_PUBLIC_LANGFUSE_CLOUD_REGION="DEV"
+
+# Langfuse experimental features
+LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES="true"
+
+# Salt for API key hashing
+SALT="salt"
+
+# Email
+EMAIL_FROM_ADDRESS=""  # Defines the email address to use as the from address.
+SMTP_CONNECTION_URL=""  # Defines the connection url for smtp server.
+
+# S3 storage
+S3_ENDPOINT=http://localhost:9090
+S3_ACCESS_KEY_ID=minio
+S3_SECRET_ACCESS_KEY=miniosecret
+S3_BUCKET_NAME=langfuse
+S3_REGION=us-east-1
+## Necessary for minio compatibility
+S3_FORCE_PATH_STYLE=true
+
+# # S3 Media Upload LOCAL
+LANGFUSE_S3_MEDIA_UPLOAD_ENABLED=true
+LANGFUSE_S3_MEDIA_UPLOAD_BUCKET=langfuse
+LANGFUSE_S3_MEDIA_UPLOAD_ACCESS_KEY_ID=minio
+LANGFUSE_S3_MEDIA_UPLOAD_SECRET_ACCESS_KEY=miniosecret
+LANGFUSE_S3_MEDIA_UPLOAD_REGION=us-east-1
+LANGFUSE_S3_MEDIA_UPLOAD_ENDPOINT=http://localhost:9090
+## Necessary for minio compatibility
+LANGFUSE_S3_MEDIA_UPLOAD_FORCE_PATH_STYLE=true
+LANGFUSE_S3_MEDIA_UPLOAD_PREFIX=media/
+
+# S3 Event Bucket Upload
+## Set to true to test uploading all events to S3
+LANGFUSE_S3_EVENT_UPLOAD_ENABLED=true
+LANGFUSE_S3_EVENT_UPLOAD_BUCKET=langfuse
+LANGFUSE_S3_EVENT_UPLOAD_ACCESS_KEY_ID=minio
+LANGFUSE_S3_EVENT_UPLOAD_SECRET_ACCESS_KEY=miniosecret
+LANGFUSE_S3_EVENT_UPLOAD_REGION=us-east-1
+LANGFUSE_S3_EVENT_UPLOAD_ENDPOINT=http://localhost:9090
+## Necessary for minio compatibility
+LANGFUSE_S3_EVENT_UPLOAD_FORCE_PATH_STYLE=true
+LANGFUSE_S3_EVENT_UPLOAD_PREFIX=events/
+
+# Set during docker build of application
+# Used to disable environment verification at build time
+# DOCKER_BUILD=1
+
+REDIS_HOST="127.0.0.1"
+REDIS_PORT=6379
+REDIS_AUTH="myredissecret"
+
+# openssl rand -hex 32 used only here
+ENCRYPTION_KEY=0000000000000000000000000000000000000000000000000000000000000000 
+
+# speeds up local development by not executing init scripts on server startup
+NEXT_PUBLIC_LANGFUSE_RUN_NEXT_INIT="false"

.env.example

@@ -1,32 +0,0 @@
-# Hanzo Cloud Console — environment.
-# Copy to .env.local and adjust. All values are public (NEXT_PUBLIC_*) since the
-# console is a browser app that talks to the unified /v1 backend with cookies.
-
-# The ONE Hanzo API endpoint (the unified /v1 backend). There is no per-service
-# API host — never llm./kms./platform./cloud./console.hanzo.ai. Leave UNSET in
-# production: the browser then calls its own origin, so the session cookie stays
-# first-party and the edge route forwards /v1 through the gateway.
-# Local backend: http://localhost:14000
-NEXT_PUBLIC_CLOUD_URL=https://api.hanzo.ai
-
-# Hanzo PaaS FRONTEND (deep-links only — the Clusters/PaaS *API* is /v1/paas on
-# NEXT_PUBLIC_CLOUD_URL above, never a second API host).
-NEXT_PUBLIC_PLATFORM_URL=https://platform.hanzo.ai
-
-# hanzo.app builder — target of the Templates gallery "Open in builder" deep-link
-# (fork a starter → customize by prompt in the builder). Default: production.
-NEXT_PUBLIC_APP_URL=https://hanzo.app
-
-# Hanzo IAM (OIDC authority). Canonical issuer is https://hanzo.id — tokens are
-# minted with iss=https://hanzo.id, which the cloud /v1 backend validates against.
-# iam.hanzo.ai is the legacy zone (iss=https://iam.hanzo.ai) and MUST NOT be used
-# by the browser, or sign-in drops on iam.hanzo.ai with an issuer mismatch.
-NEXT_PUBLIC_IAM_URL=https://hanzo.id
-
-# IAM application console2 authenticates as. console2 is a front-end of the
-# shared Hanzo Cloud /v1 backend, which exchanges the OIDC code and validates the
-# token as app `hanzo-cloud` (aud=hanzo-cloud) — so the front-end presents the
-# same app/client_id. Must match the cloud-api binding, not a console-only app.
-NEXT_PUBLIC_IAM_APP_NAME=hanzo-cloud
-NEXT_PUBLIC_IAM_ORG_NAME=hanzo
-NEXT_PUBLIC_IAM_CLIENT_ID=hanzo-cloud

.env.local.example

@@ -0,0 +1,22 @@
+# When adding additional environment variables, the schema in "/src/env.mjs"
+# should be updated accordingly.
+
+# Prisma
+# https://www.prisma.io/docs/reference/database-reference/connection-urls#env
+DIRECT_URL="postgresql://postgres:postgres@db:5432/postgres"
+DATABASE_URL="postgresql://postgres:postgres@db:5432/postgres"
+# Next Auth
+NEXTAUTH_SECRET="secret"
+NEXTAUTH_URL="http://localhost:3000"
+
+# feature flag to enable experimental features locally
+LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES="false"
+SALT="salt"
+
+# Redis
+REDIS_HOST="127.0.0.1"
+REDIS_PORT=6379
+REDIS_AUTH="myredissecret"
+
+# openssl rand -hex 32 used only here
+ENCRYPTION_KEY=0000000000000000000000000000000000000000000000000000000000000000

.env.prod.example

@@ -0,0 +1,258 @@
+# More information: https://langfuse.com/docs/deployment/self-host
+
+# When adding additional environment variables, the schema in "/src/env.mjs"
+# should be updated accordingly.
+
+# Prisma
+# https://www.prisma.io/docs/reference/database-reference/connection-urls#env
+# DATABASE_URL supports pooled connections, but then you need to set DIRECT_URL
+DATABASE_URL="postgresql://postgres:postgres@db:5432/postgres"
+# DIRECT_URL="postgresql://postgres:postgres@db:5432/postgres"
+# SHADOW_DATABASE_URL=
+# optional, set to true to disable automated database migrations on Docker start
+# LANGFUSE_AUTO_POSTGRES_MIGRATION_DISABLED=
+
+# Next Auth
+# NEXTAUTH_URL does not need to be set when deploying on Vercel
+NEXTAUTH_URL="http://localhost:3000"
+
+# For each of these, you can generate a new secret on the command line with:
+# openssl rand -base64 32
+NEXTAUTH_SECRET="secret" # https://next-auth.js.org/configuration/options#secret
+SALT="salt" # salt used to hash api keys
+
+# API level encryption for sensitive data
+# Must be 256 bits, 64 string characters in hex format, generate via: openssl rand -hex 32
+ENCRYPTION_KEY="0000000000000000000000000000000000000000000000000000000000000000"
+
+# Use CSP headers to enforce HTTPS, optional
+# LANGFUSE_CSP_ENFORCE_HTTPS="true"
+
+# Configure base path for self-hosting, optional
+# Note: You need to build the docker image with the base path set and cannot use the pre-built docker image if you set this.
+# NEXT_PUBLIC_BASE_PATH="/app"
+
+# Docker only, optional
+# PORT=3000
+# HOSTNAME=localhost
+
+# Opentelemetry, optional
+OTEL_EXPORTER_OTLP_ENDPOINT="http://localhost:4318"
+OTEL_SERVICE_NAME="langfuse"
+
+# Default role for users who sign up, optional, can be org or org+project
+# LANGFUSE_DEFAULT_ORG_ID=
+# LANGFUSE_DEFAULT_ORG_ROLE=
+# LANGFUSE_DEFAULT_PROJECT_ID=
+# LANGFUSE_DEFAULT_PROJECT_ROLE=
+
+# Logging, optional
+# LANGFUSE_LOG_LEVEL=info
+# LANGFUSE_LOG_FORMAT=text
+
+# Enable experimental features, optional
+# LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES=true
+
+# Auth, optional configuration
+# AUTH_DOMAINS_WITH_SSO_ENFORCEMENT=domain1.com,domain2.com
+# AUTH_IGNORE_ACCOUNT_FIELDS=foo,bar
+# AUTH_DISABLE_USERNAME_PASSWORD=true
+# AUTH_DISABLE_SIGNUP=true
+# AUTH_SESSION_MAX_AGE=43200 # 30 days in minutes (default)
+
+# SSO, each group is optional
+# AUTH_GOOGLE_CLIENT_ID=
+# AUTH_GOOGLE_CLIENT_SECRET=
+# AUTH_GOOGLE_ALLOW_ACCOUNT_LINKING=false
+# AUTH_GOOGLE_ALLOWED_DOMAINS=langfuse.com,google.com # optional allowlist of workspace domains that can sign in via Google
+# AUTH_GITHUB_CLIENT_ID=
+# AUTH_GITHUB_CLIENT_SECRET=
+# AUTH_GITHUB_ALLOW_ACCOUNT_LINKING=false
+# AUTH_GITHUB_ENTERPRISE_CLIENT_ID=
+# AUTH_GITHUB_ENTERPRISE_CLIENT_SECRET=
+# AUTH_GITHUB_ENTERPRISE_BASE_URL=
+# AUTH_GITHUB_ENTERPRISE_ALLOW_ACCOUNT_LINKING=false
+# AUTH_GITLAB_CLIENT_ID=
+# AUTH_GITLAB_CLIENT_SECRET=
+# AUTH_GITLAB_ALLOW_ACCOUNT_LINKING=false
+# AUTH_GITLAB_ISSUER=
+# AUTH_AZURE_AD_CLIENT_ID=
+# AUTH_AZURE_AD_CLIENT_SECRET=
+# AUTH_AZURE_AD_TENANT_ID=
+# AUTH_AZURE_ALLOW_ACCOUNT_LINKING=false
+# AUTH_OKTA_CLIENT_ID=
+# AUTH_OKTA_CLIENT_SECRET=
+# AUTH_OKTA_ISSUER=
+# AUTH_OKTA_ALLOW_ACCOUNT_LINKING=false
+# AUTH_AUTH0_CLIENT_ID=
+# AUTH_AUTH0_CLIENT_SECRET=
+# AUTH_AUTH0_ISSUER=
+# AUTH_AUTH0_ALLOW_ACCOUNT_LINKING=false
+# AUTH_COGNITO_CLIENT_ID=
+# AUTH_COGNITO_CLIENT_SECRET=
+# AUTH_COGNITO_ISSUER=
+# AUTH_COGNITO_ALLOW_ACCOUNT_LINKING=false
+# AUTH_KEYCLOAK_CLIENT_ID=
+# AUTH_KEYCLOAK_CLIENT_SECRET=
+# AUTH_KEYCLOAK_ISSUER=
+# AUTH_KEYCLOAK_ALLOW_ACCOUNT_LINKING=false
+# AUTH_CUSTOM_CLIENT_ID=
+# AUTH_CUSTOM_CLIENT_SECRET=
+# AUTH_CUSTOM_ISSUER=
+# AUTH_CUSTOM_NAME=
+# AUTH_CUSTOM_SCOPE="openid email profile" # optional
+# AUTH_CUSTOM_ALLOW_ACCOUNT_LINKING=false
+# AUTH_CUSTOM_ID_TOKEN=false # optional, default is true
+
+# Transactional email, optional
+# Defines the email address to use as the from address.
+# EMAIL_FROM_ADDRESS=
+# Defines the connection url for smtp server. 
+# SMTP_CONNECTION_URL=
+
+# S3 storage, optional, used for exports from the UI
+# S3_ENDPOINT=
+# S3_ACCESS_KEY_ID=
+# S3_SECRET_ACCESS_KEY=
+# S3_BUCKET_NAME=
+# S3_REGION=
+# BATCH_EXPORT_DOWNLOAD_LINK_EXPIRATION_HOURS=
+
+# S3 storage for events, optional, used to persist all incoming events
+# LANGFUSE_S3_EVENT_UPLOAD_ENABLED="true"
+# LANGFUSE_S3_EVENT_UPLOAD_BUCKET=
+# Optional prefix to be used within the bucket. Must end with `/` if set
+# LANGFUSE_S3_EVENT_UPLOAD_PREFIX=events/
+# The following four options are optional and fallback to the normal SDK credential provider chain if omitted
+# See https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
+# LANGFUSE_S3_EVENT_UPLOAD_ENDPOINT=
+# LANGFUSE_S3_EVENT_UPLOAD_REGION=
+# LANGFUSE_S3_EVENT_UPLOAD_ACCESS_KEY_ID=
+# LANGFUSE_S3_EVENT_UPLOAD_SECRET_ACCESS_KEY=
+
+# Exports are streamed to S3 in pages to avoid memory issues
+# The page size can be adjusted if needed to optimize performance
+# DB_EXPORT_PAGE_SIZE=1000
+
+# Automated provisioning of default resources
+# LANGFUSE_INIT_ORG_ID=org-id
+# LANGFUSE_INIT_ORG_NAME=org-name
+# LANGFUSE_INIT_PROJECT_ID=project-id
+# LANGFUSE_INIT_PROJECT_NAME=project-name
+# LANGFUSE_INIT_PROJECT_PUBLIC_KEY=pk-1234567890
+# LANGFUSE_INIT_PROJECT_SECRET_KEY=sk-1234567890
+# LANGFUSE_INIT_USER_EMAIL=user@example.com
+# LANGFUSE_INIT_USER_NAME=User Name
+# LANGFUSE_INIT_USER_PASSWORD=password
+
+
+
+### START Enterprise Edition Configuration
+
+# Allowlisted users that can create new organizations, by default all users can create organizations
+# LANGFUSE_ALLOWED_ORGANIZATION_CREATORS=user1@langfuse.com,user2@langfuse.com
+
+# UI Customization Options
+# LANGFUSE_UI_API_HOST=https://api.example.com
+# LANGFUSE_UI_DOCUMENTATION_HREF=https://docs.example.com
+# LANGFUSE_UI_SUPPORT_HREF=https://support.example.com
+# LANGFUSE_UI_FEEDBACK_HREF=https://feedback.example.com
+# LANGFUSE_UI_LOGO_LIGHT_MODE_HREF=https://static.langfuse.com/langfuse-dev/example-logo-light-mode.png
+# LANGFUSE_UI_LOGO_DARK_MODE_HREF=https://static.langfuse.com/langfuse-dev/example-logo-dark-mode.png
+# LANGFUSE_UI_DEFAULT_MODEL_ADAPTER=Anthropic # OpenAI, Anthropic, Azure
+# LANGFUSE_UI_DEFAULT_BASE_URL_OPENAI=https://api.openai.com/v1
+# LANGFUSE_UI_DEFAULT_BASE_URL_ANTHROPIC=https://api.anthropic.com
+# LANGFUSE_UI_DEFAULT_BASE_URL_AZURE_OPENAI=https://{instanceName}.openai.azure.com/openai/deployments
+
+### END Enterprise Edition Configuration
+
+
+
+### START Envs to be deprecated in Langfuse v3.0
+
+# Disable the expensive analytics queries and related features
+# LANGFUSE_DISABLE_EXPENSIVE_POSTGRES_QUERIES="true"
+
+### END Envs to be deprecated in Langfuse v3.0
+
+
+
+
+### START Langfuse Cloud Config
+# Used for Langfuse Cloud deployments
+# Not recommended for self-hosted deployments as these are NOT COVERED BY SEMANTIC VERSIONING
+
+# NEXT_PUBLIC_LANGFUSE_CLOUD_REGION="US"
+# NEXTAUTH_COOKIE_DOMAIN=".langfuse.com"
+
+# LANGFUSE_TEAM_SLACK_WEBHOOK=
+# LANGFUSE_NEW_USER_SIGNUP_WEBHOOK=
+
+# Posthog (optional for analytics of web ui)
+# NEXT_PUBLIC_POSTHOG_HOST=
+# NEXT_PUBLIC_POSTHOG_KEY=
+
+# Sentry
+# NEXT_PUBLIC_LANGFUSE_TRACING_SAMPLE_RATE
+# NEXT_PUBLIC_SENTRY_DSN=
+# NEXT_SENTRY_ORG=
+# NEXT_SENTRY_PROJECT=
+# SENTRY_AUTH_TOKEN=
+# SENTRY_CSP_REPORT_URI=
+
+
+# Cloudflare Turnstile
+# NEXT_PUBLIC_TURNSTILE_SITE_KEY=
+# TURNSTILE_SECRET_KEY=
+
+# Demo project that users can use to try the platform
+# NEXT_PUBLIC_DEMO_ORG_ID=
+# NEXT_PUBLIC_DEMO_PROJECT_ID=
+
+# Crisp chat
+# NEXT_PUBLIC_CRISP_WEBSITE_ID=
+
+# Admin API
+# ADMIN_API_KEY=
+
+# Redis
+# REDIS_HOST=
+# REDIS_PORT=
+# REDIS_AUTH=
+# REDIS_CONNECTION_STRING=
+# REDIS_ENABLE_AUTO_PIPELINING=
+
+# Cache configuration
+# LANGFUSE_CACHE_API_KEY_ENABLED=
+# LANGFUSE_CACHE_API_KEY_TTL_SECONDS=
+# LANGFUSE_CACHE_PROMPT_ENABLED=
+# LANGFUSE_CACHE_PROMPT_TTL_SECONDS=
+
+# Rate limiting
+# LANGFUSE_RATE_LIMITS_ENABLED=
+
+# Stripe
+# STRIPE_SECRET_KEY=
+# STRIPE_WEBHOOK_SIGNING_SECRET=
+
+### END Langfuse Cloud Config
+
+
+## START Langfuse V3 Ingestion 
+
+# Clickhouse
+# CLICKHOUSE_MIGRATION_URL=
+# CLICKHOUSE_URL=
+# CLICKHOUSE_USER=
+# CLICKHOUSE_PASSWORD=
+
+# Ingestion
+# LANGFUSE_INGESTION_QUEUE_DELAY_MS=
+# LANGFUSE_INGESTION_CLICKHOUSE_WRITE_BATCH_SIZE=
+# LANGFUSE_INGESTION_CLICKHOUSE_WRITE_INTERVAL_MS= 
+# LANGFUSE_INGESTION_CLICKHOUSE_MAX_ATTEMPTS=
+# LANGFUSE_LEGACY_INGESTION_WORKER_CONCURRENCY=
+# LANGFUSE_ASYNC_INGESTION_PROCESSING="true"
+# QUEUE_CONSUMER_LEGACY_INGESTION_QUEUE_IS_ENABLED="true"
+
+## END Langfuse V3 Ingestion

.eslintignore

@@ -0,0 +1,4 @@
+node_modules
+**/node_modules
+build
+coverage

.github/CODEOWNERS

@@ -0,0 +1,2 @@
+# Currently inactive
+# * @langfuse/maintainers

.github/DISCUSSION_TEMPLATE/ideas.yml

@@ -0,0 +1,11 @@
+body:
+  - type: textarea
+    attributes:
+      label: Describe the feature or potential improvement
+      description: Please describe the change as clear and concise as possible. Remember to add context as to why you believe this is needed.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Additional information
+      description: Add any other information related to the change here. If your idea is related to any issues or discussions, link them here.

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,35 @@
+name: 🐞 Bug Report
+description: Create a bug report to help us improve
+title: "bug: "
+labels: ["🐞❔ unconfirmed bug"]
+body:
+  - type: textarea
+    attributes:
+      label: Describe the bug
+      description: A clear and concise description of the bug, as well as what you expected to happen when encountering it.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: To reproduce
+      description: Describe how to reproduce your bug. Please provide detailed steps, code snippets, reproduction repos etc.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: SDK and container versions
+      description: If you're experiencing an issue with an integration or SDK, please ensure you're using the latest version. If you're self-hosting Langfuse, check that you're running the most recent version. If updating isn't an option, please provide the specific versions you're currently using.
+  - type: textarea
+    attributes:
+      label: Additional information
+      description: Add any other information related to the bug here, screenshots if applicable.
+  - type: dropdown
+    id: contribute
+    attributes:
+      label: Are you interested to contribute a fix for this bug?
+      description: If this is a confirmed bug, the maintainers are happy to support with guidance and review.
+      options:
+        - "No"
+        - "Yes"
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,7 @@
+contact_links:
+  - name: 💡 Feature Request
+    url: https://github.com/orgs/langfuse/discussions/new?category=ideas
+    about: Suggest any ideas you have using our discussion forums.
+  - name: 🤗 Get Help
+    url: https://github.com/orgs/langfuse/discussions/new?category=support
+    about: If you can’t get something to work the way you expect, open a question in our discussion forums.

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,36 @@
+## What does this PR do?
+
+<!-- Please include a summary of the change and which issue is fixed. Please also include relevant motivation and context. List any dependencies that are required for this change. -->
+
+Fixes # (issue)
+
+<!-- Please provide a loom video for visual changes to speed up reviews
+ Loom Video: https://www.loom.com/
+-->
+
+## Type of change
+
+<!-- Please delete bullets that are not relevant. -->
+
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] Chore (refactoring code, technical debt, workflow improvements)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] Refactor (does not change functionality, e.g. code style improvements, linting)
+- [ ] This change requires a documentation update
+
+## Mandatory Tasks
+
+- [ ] Make sure you have self-reviewed the code. A decent size PR without self-review might be rejected.
+
+## Checklist
+
+<!-- Remove bullet points below that don't apply to you -->
+
+- I haven't read the [contributing guide](https://github.com/langfuse/langfuse/blob/main/CONTRIBUTING.md)
+- My code doesn't follow the style guidelines of this project (`npm run prettier`)
+- I haven't commented my code, particularly in hard-to-understand areas
+- I haven't checked if my PR needs changes to the documentation
+- I haven't checked if my changes generate no new warnings (`npm run lint`)
+- I haven't added tests that prove my fix is effective or that my feature works
+- I haven't checked if new and existing unit tests pass locally with my changes

.github/dependabot.yml

@@ -0,0 +1,48 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: npm
+    directory: "/" # Location of package manifests
+    rebase-strategy: "disabled" # use dependabot-rebase-stale
+    open-pull-requests-limit: 10
+    schedule:
+      interval: "daily"
+    versioning-strategy: "increase"
+    commit-message:
+      prefix: chore
+      prefix-development: chore
+      include: scope
+    ignore:
+      - dependency-name: "@types/node"
+      - dependency-name: "@trpc/*"
+    groups:
+      prisma:
+        patterns:
+          - "prisma"
+          - "@prisma/client"
+      next:
+        patterns:
+          - "eslint-config-next"
+          - "next"
+      lodash:
+        patterns:
+          - "lodash"
+          - "@types/lodash"
+      express:
+        patterns:
+          - "express"
+          - "@types/express"
+      observability:
+        patterns:
+          - "dd-trace"
+          - "@opentelemetry/*"
+          - "@appsignal/opentelemetry-instrumentation-bullmq"
+          - "@prisma/instrumentation"
+          - "@sentry/*"
+      radix-ui:
+        patterns:
+          - "@radix-ui/*"

.github/hero.svg

@@ -1,9 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="1280" height="640" viewBox="0 0 1280 640" role="img" aria-label="console2">
-<rect width="1280" height="640" fill="#0A0A0A"/>
-<svg x="96" y="215" width="210" height="210" viewBox="0 0 67 67"><path d="M22.21 67V44.6369H0V67H22.21Z" fill="#fff"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z" fill="#fff"/><path d="M22.21 0H0V22.3184H22.21V0Z" fill="#fff"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z" fill="#fff"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z" fill="#fff"/></svg>
-<text x="378" y="276" font-family="Inter,system-ui,-apple-system,sans-serif" font-size="78" font-weight="800" letter-spacing="-2" fill="#ffffff">console2</text>
-
-<rect x="378" y="338" width="806" height="3" rx="1.5" fill="#ffffff" opacity=".9"/>
-<text x="378" y="390" font-family="Inter,system-ui,sans-serif" font-size="24" font-weight="600" fill="#ffffff" opacity=".5">github.com/hanzoai</text>
-<text x="1184" y="390" text-anchor="end" font-family="Inter,system-ui,sans-serif" font-size="24" font-weight="600" fill="#ffffff" opacity=".5">hanzo.ai</text>
-</svg>

.github/workflows/_deploy_ecs_service.yml

@@ -0,0 +1,75 @@
+name: WorkflowCall - Deploy to ECS Service
+on:
+  workflow_call:
+    inputs:
+      environment:
+        type: string
+        description: Deployment environment
+        required: true
+      service:
+        type: string
+        description: Name of the service to be deployed, e.g. web-ingestion, web, or worker.
+        required: true
+jobs:
+  ecs-deploy:
+    runs-on: ubuntu-latest
+    environment: ${{ inputs.environment }}
+    steps:
+      - name: Get app name
+        uses: winterjung/split@v2
+        id: split
+        with:
+          msg: ${{ inputs.service }}
+          separator: "-"
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Authenticate with AWS
+        # GitHub/AWS recommend to use OIDC here: https://github.com/aws-actions/configure-aws-credentials?tab=readme-ov-file#oidc
+        # Probably more painful to configure, but would remove all long-lived credentials.
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ vars.AWS_REGION }}
+      - name: Login to AWS ECR
+        id: login-ecr
+        uses: aws-actions/amazon-ecr-login@v2
+      - name: Build, tag, and push Docker image
+        env:
+          REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          REPOSITORY: ${{ steps.split.outputs._0 }}
+          IMAGE_TAG: ${{ github.sha }}
+        run: |
+          docker build \
+            -t $REGISTRY/$REPOSITORY:$IMAGE_TAG \
+            -f ./${{ steps.split.outputs._0 }}/Dockerfile \
+            --build-arg NEXT_PUBLIC_LANGFUSE_CLOUD_REGION=${{ vars.NEXT_PUBLIC_LANGFUSE_CLOUD_REGION }} \
+            --build-arg NEXT_LANGFUSE_TRACING_SAMPLE_RATE=${{ vars.NEXT_LANGFUSE_TRACING_SAMPLE_RATE }} \
+            --build-arg NEXT_PUBLIC_SENTRY_ENVIRONMENT=${{ vars.NEXT_PUBLIC_SENTRY_ENVIRONMENT }} \
+            --build-arg NEXT_PUBLIC_DEMO_ORG_ID=${{ vars.NEXT_PUBLIC_DEMO_ORG_ID }} \
+            --build-arg NEXT_PUBLIC_DEMO_PROJECT_ID=${{ vars.NEXT_PUBLIC_DEMO_PROJECT_ID }} \
+            --build-arg NEXT_PUBLIC_SENTRY_DSN=${{ vars.NEXT_PUBLIC_SENTRY_DSN }} \
+            --build-arg NEXT_PUBLIC_BUILD_ID=${{ github.sha }} \
+            --build-arg NEXT_PUBLIC_POSTHOG_KEY=${{ vars.NEXT_PUBLIC_POSTHOG_KEY }} \
+            --build-arg NEXT_PUBLIC_POSTHOG_HOST=${{ vars.NEXT_PUBLIC_POSTHOG_HOST }} \
+            --build-arg NEXT_PUBLIC_CRISP_WEBSITE_ID=${{ vars.NEXT_PUBLIC_CRISP_WEBSITE_ID }} \
+            --build-arg SENTRY_AUTH_TOKEN=${{ secrets.SENTRY_AUTH_TOKEN }} \
+            --build-arg SENTRY_ORG=${{ vars.SENTRY_ORG }} \
+            --build-arg SENTRY_PROJECT=${{ vars.SENTRY_PROJECT }} \
+            .
+          docker push $REGISTRY/$REPOSITORY:$IMAGE_TAG
+
+      - name: Render AWS ECS Task Definition
+        id: render-task-definition
+        uses: aws-actions/amazon-ecs-render-task-definition@v1
+        with:
+          container-name: ${{ inputs.service }}
+          image: ${{ steps.login-ecr.outputs.registry }}/${{ steps.split.outputs._0 }}:${{ github.sha }}
+          task-definition-family: ${{ inputs.environment }}-${{ inputs.service }}
+      - name: Update AWS ECS Service
+        uses: aws-actions/amazon-ecs-deploy-task-definition@v2
+        with:
+          task-definition: ${{ steps.render-task-definition.outputs.task-definition }}
+          service: ${{ inputs.environment }}-${{ inputs.service }}
+          cluster: ${{ inputs.environment }}-cluster
+          wait-for-service-stability: true

.github/workflows/ci.yml.template

@@ -0,0 +1,69 @@
+name: CI
+
+on:
+  pull_request:
+    branches: ["*"]
+  push:
+    branches: ["main", "cloud"]
+
+# You can leverage Vercel Remote Caching with Turbo to speed up your builds
+# @link https://turborepo.org/docs/core-concepts/remote-caching#remote-caching-on-vercel-builds
+env:
+  TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
+  TURBO_TEAM: ${{ secrets.TURBO_TEAM }}
+
+jobs:
+  build-lint:
+    env:
+      DATABASE_URL: postgresql://postgres:postgres@localhost:5432/postgres
+      SHADOW_DATABASE_URL: postgresql://postgres:postgres@localhost:5432/postgres
+      DIRECT_URL: postgresql://postgres:postgres@localhost:5432/postgres
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v4
+
+      - name: Start containers
+        run: docker compose -f "docker-compose.yml" up -d --build
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v2.2.4
+
+      - name: Setup Node 18
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18
+
+      - name: Get pnpm store directory
+        id: pnpm-cache
+        run: |
+          echo "pnpm_cache_dir=$(pnpm store path)" >> $GITHUB_OUTPUT
+
+      - name: Setup pnpm cache
+        uses: actions/cache@v3
+        with:
+          path: ${{ steps.pnpm-cache.outputs.pnpm_cache_dir }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+
+      - name: Install deps (with cache)
+        run: pnpm install
+
+      # Normally, this would be done as part of the turbo pipeline - however since the Expo app doesn't depend on `@acme/db` it doesn't care.
+      # TODO: Free for all to find a better solution here.
+      - name: Deploy db
+        run: pnpm turbo db:deploy
+
+      - name: Generate Prisma Client
+        run: pnpm turbo db:generate
+
+      - name: Build, lint and type-check
+        run: pnpm turbo build lint type-check
+        env:
+          SKIP_ENV_VALIDATION: true
+
+      # FIXME: Add this back once we have an Expo SDK supporting React 18.2
+      # - name: Check workspaces
+      #   run: pnpm manypkg check

.github/workflows/codeql.yml

@@ -0,0 +1,92 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: ["main", "production", "v*"]
+  pull_request:
+    branches: ["main", "production", "v*"]
+  schedule:
+    - cron: "31 13 * * 0"
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    # Runner size impacts CodeQL analysis time. To learn more, please see:
+    #   - https://gh.io/recommended-hardware-resources-for-running-codeql
+    #   - https://gh.io/supported-runners-and-hardware-resources
+    #   - https://gh.io/using-larger-runners (GitHub.com only)
+    # Consider using larger runners or machines with greater resources for possible analysis time improvements.
+    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
+    permissions:
+      # required for all workflows
+      security-events: write
+
+      # required to fetch internal or private CodeQL packs
+      packages: read
+
+      # only required for workflows in private repositories
+      actions: read
+      contents: read
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - language: javascript-typescript
+            build-mode: none
+        # CodeQL supports the following values keywords for 'language': 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'swift'
+        # Use `c-cpp` to analyze code written in C, C++ or both
+        # Use 'java-kotlin' to analyze code written in Java, Kotlin or both
+        # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both
+        # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,
+        # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.
+        # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how
+        # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      # Initializes the CodeQL tools for scanning.
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v3
+        with:
+          languages: ${{ matrix.language }}
+          build-mode: ${{ matrix.build-mode }}
+          # If you wish to specify custom queries, you can do so here or in a config file.
+          # By default, queries listed here will override any specified in a config file.
+          # Prefix the list here with "+" to use these queries and those in the config file.
+
+          # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+          # queries: security-extended,security-and-quality
+
+      # If the analyze step fails for one of the languages you are analyzing with
+      # "We were unable to automatically build your code", modify the matrix above
+      # to set the build mode to "manual" for that language. Then modify this step
+      # to build your code.
+      # ℹ️ Command-line programs to run using the OS shell.
+      # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+      - if: matrix.build-mode == 'manual'
+        shell: bash
+        run: |
+          echo 'If you are using a "manual" build mode for one or more of the' \
+            'languages you are analyzing, replace this with the commands to build' \
+            'your code, for example:'
+          echo '  make bootstrap'
+          echo '  make release'
+          exit 1
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v3
+        with:
+          category: "/language:${{matrix.language}}"

.github/workflows/codespell.yml

@@ -0,0 +1,27 @@
+---
+name: Codespell
+
+on:
+  push:
+    branches:
+      - "main"
+    tags:
+      - "v*"
+  pull_request:
+    branches:
+      - "**"
+  merge_group:
+
+permissions:
+  contents: read
+
+jobs:
+  codespell:
+    name: Check for spelling errors
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Codespell
+        uses: codespell-project/actions-codespell@v2

.github/workflows/dependabot-rebase-stale.yml

@@ -0,0 +1,18 @@
+name: Rebase Dependabot stale PRs
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  rebase-dependabot:
+    runs-on: ubuntu-latest
+    environment: "protected branches"
+    steps:
+      - name: "Rebase open Dependabot PR"
+        uses: orange-buffalo/dependabot-auto-rebase@v1
+        with:
+          api-token: ${{ secrets.GH_ACCESS_TOKEN }}
+          repository: ${{ github.repository }}

.github/workflows/deploy.yml

@@ -0,0 +1,105 @@
+on:
+  push:
+    branches:
+      - main
+      - production
+  workflow_dispatch:
+    inputs:
+      service:
+        description: 'Service to be deployed'
+        type: choice
+        options:
+          - all
+          - web
+          - web-ingestion
+          - worker
+        required: true
+      environment:
+        description: 'Environment to deploy to'
+        type: choice
+        options:
+          - staging
+          - prod-eu
+          - prod-us
+        required: true
+
+concurrency:
+  # Support concurrent `push` and `workflow_dispatch`` actions
+  group: deploy-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: true
+
+name: Deploy to ECS
+jobs:
+  affected-services:
+    runs-on: ubuntu-latest
+    outputs:
+      services: ${{ steps.affected-services.outputs.result }}
+    steps:
+      - name: Get affected services
+        id: affected-services
+        uses: actions/github-script@v7
+        with:
+          script: |
+            if (context.eventName === "workflow_dispatch") {
+              if (context.payload.inputs.service === "all") {
+                return `["web", "web-ingestion", "worker"]`
+              }
+              return `["${context.payload.inputs.service}"]`
+            }
+            if (context.eventName === "push") {
+              return `["web", "web-ingestion", "worker"]`
+            }
+            return "[]"
+          result-encoding: string
+      - name: Print services to build
+        uses: actions/github-script@v7
+        env:
+          services: ${{ steps.affected-services.outputs.result }}
+        with:
+          result-encoding: string
+          script: |
+            console.log('Services', `${process.env.services}` ?? 'n/a');
+
+  affected-environments:
+    runs-on: ubuntu-latest
+    outputs:
+      environments: ${{ steps.affected-environments.outputs.result }}
+    steps:
+      - name: Get affected environments
+        id: affected-environments
+        uses: actions/github-script@v7
+        with:
+          script: |
+            if (context.eventName === "workflow_dispatch") {
+              return `["${context.payload.inputs.environment}"]`
+            }
+            if (context.eventName === "push") {
+              if (context.ref === "refs/heads/main") {
+                return `["staging"]`
+              }
+              if (context.ref === "refs/heads/production") {
+                return `["prod-eu", "prod-us"]`
+              }
+            }
+            return "[]"
+          result-encoding: string
+      - name: Print environments to build
+        uses: actions/github-script@v7
+        env:
+          environments: ${{ steps.affected-environments.outputs.result }}
+        with:
+          result-encoding: string
+          script: |
+            console.log('Environments', `${process.env.environments}` ?? 'n/a');
+
+  ecs-deploy:
+    uses: ./.github/workflows/_deploy_ecs_service.yml
+    needs: [affected-services, affected-environments]
+    secrets: inherit
+    strategy:
+      matrix:
+        service: ${{ fromJson(needs.affected-services.outputs.services) }}
+        environment: ${{ fromJson(needs.affected-environments.outputs.environments) }}
+    with:
+      service: ${{ matrix.service }}
+      environment: ${{ matrix.environment }}

.github/workflows/licencecheck.yml

@@ -0,0 +1,49 @@
+name: License Compliance Check
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - "main"
+  merge_group:
+  pull_request:
+    branches:
+      - "main"
+
+jobs:
+  license_check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18
+
+      - name: Install license-checker
+        run: npm install -g license-checker
+
+      - name: Install yui-lint
+        run: npm install yui-lint
+
+      - name: Generate license-checker CSV file
+        run: license-checker --production --csv > npm-license-checker.csv
+
+      - name: Check license-checker CSV file without headers
+        id: license_check_report
+        uses: pilosus/action-pip-license-checker@v2
+        with:
+          external: "npm-license-checker.csv"
+          external-format: "csv"
+          external-options: "{:skip-header true}"
+          fail: "WeakCopyleft,StrongCopyleft,NetworkCopyleft"
+          fails-only: true
+          totals: true
+          verbose: 1
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Echo error
+        if: failure()
+        run: echo "::error::${{ steps.license_check_report.outputs.report }}"
+      - name: Delete license-checker CSV file
+        run: rm npm-license-checker.csv

.github/workflows/pipeline.yml

@@ -0,0 +1,497 @@
+name: CI/CD
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - "main"
+    tags:
+      - "v*"
+  merge_group:
+  pull_request:
+    branches:
+      - "*"
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v3
+        with:
+          version: 9.5.0
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: "pnpm"
+          cache-dependency-path: "pnpm-lock.yaml"
+      - name: install dependencies
+        run: |
+          pnpm i
+      - name: Load default env
+        run: |
+          cp .env.dev.example .env
+      - name: lint web
+        run: pnpm run lint
+
+  test-docker-build:
+    timeout-minutes: 20
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME_READ }}
+          password: ${{ secrets.DOCKERHUB_TOKEN_READ }}
+      - name: Set NEXT_PUBLIC_BUILD_ID
+        run: echo "NEXT_PUBLIC_BUILD_ID=$(git rev-parse --short HEAD)" >> $GITHUB_ENV
+      - name: Build and run both images from compose
+        run: |
+          docker compose -f docker-compose.build.yml up -d
+          sleep 5 # Wait for PostgreSQL to accept connections
+      - name: Ensure no unhealthy status
+        run: |
+          if docker-compose ps | grep "(unhealthy)"; then
+            echo "One or more services are unhealthy"
+            exit 1
+          else
+            echo "All services are healthy"
+          fi
+      - name: Check worker health
+        run: |
+          timeout 10 bash -c 'until curl -f http://localhost:3030/api/health; do sleep 2; done'
+      - name: Check server health
+        run: |
+          timeout 10 bash -c 'until curl -f http://localhost:3000/api/public/health; do sleep 2; done'
+
+  tests-web-sync:
+    timeout-minutes: 20
+    runs-on: ubuntu-latest
+    name: tests-web-sync (node${{ matrix.node-version }}, pg${{ matrix.postgres-version }})
+    strategy:
+      matrix:
+        node-version: [20]
+        postgres-version: [12, 15]
+    steps:
+      - name: Set Swap Space
+        uses: pierotofy/set-swap-space@master
+        with:
+          swap-size-gb: 10
+      - uses: actions/checkout@v4
+      - name: Install golang-migrate for Clickhouse migrations
+        run: |
+          curl -L https://github.com/golang-migrate/migrate/releases/download/v4.18.2/migrate.linux-amd64.tar.gz | tar xvz
+          sudo mv migrate /usr/bin/migrate
+          which migrate
+      - uses: pnpm/action-setup@v3
+        with:
+          version: 9.5.0
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME_READ }}
+          password: ${{ secrets.DOCKERHUB_TOKEN_READ }}
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: "pnpm"
+          cache-dependency-path: "pnpm-lock.yaml"
+      - name: install dependencies
+        run: |
+          pnpm install
+      - name: Load default env
+        run: |
+          cp .env.dev.example .env
+          grep -v -e '^S3_BUCKET_NAME=' -e '^REDIS_HOST=' -e '^NEXT_PUBLIC_LANGFUSE_RUN_NEXT_INIT=' .env.dev.legacy.example > .env
+      - name: Run + migrate
+        run: |
+          docker compose -f docker-compose.dev.yml up -d
+          sleep 5 # Wait for PostgreSQL to accept connections
+          docker compose ps
+        env:
+          POSTGRES_VERSION: ${{ matrix.postgres-version }}
+      - name: Seed DB
+        run: |
+          pnpm run db:migrate
+          pnpm --filter=shared ch:up
+      - name: Build
+        run: pnpm run build
+      - name: Start Langfuse
+        run: (pnpm run start&)
+        env:
+          LANGFUSE_INIT_ORG_ID: "seed-org-id"
+          LANGFUSE_INIT_ORG_NAME: "Seed Org"
+          LANGFUSE_INIT_PROJECT_ID: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a"
+          LANGFUSE_INIT_PROJECT_NAME: "Seed Project"
+          LANGFUSE_INIT_PROJECT_PUBLIC_KEY: "pk-lf-1234567890"
+          LANGFUSE_INIT_PROJECT_SECRET_KEY: "sk-lf-1234567890"
+          LANGFUSE_INIT_USER_EMAIL: "demo@langfuse.com"
+          LANGFUSE_INIT_USER_NAME: "Demo User"
+          LANGFUSE_INIT_USER_PASSWORD: "password"
+      - name: run test-sync
+        run: pnpm --filter=web run test-sync
+
+  tests-web-async:
+    timeout-minutes: 20
+    runs-on: ubuntu-latest
+    name: tests-web-async (node${{ matrix.node-version }}, pg${{ matrix.postgres-version }}, mode${{ matrix.blob-provider }})
+    strategy:
+      matrix:
+        node-version: [20]
+        postgres-version: [12, 15]
+        blob-provider: ["", "-azure"]
+    steps:
+      - name: Set Swap Space
+        uses: pierotofy/set-swap-space@master
+        with:
+          swap-size-gb: 10
+      - uses: actions/checkout@v4
+      - name: Install golang-migrate for Clickhouse migrations
+        run: |
+          curl -L https://github.com/golang-migrate/migrate/releases/download/v4.18.2/migrate.linux-amd64.tar.gz | tar xvz
+          sudo mv migrate /usr/bin/migrate
+          which migrate
+      - uses: pnpm/action-setup@v3
+        with:
+          version: 9.5.0
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME_READ }}
+          password: ${{ secrets.DOCKERHUB_TOKEN_READ }}
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: "pnpm"
+          cache-dependency-path: "pnpm-lock.yaml"
+      - name: install dependencies
+        run: |
+          pnpm install
+      - name: Load default env
+        run: |
+          cp .env.dev${{ matrix.blob-provider }}.example .env
+          grep -v -e '^S3_BUCKET_NAME=' -e '^REDIS_HOST=' -e '^NEXT_PUBLIC_LANGFUSE_RUN_NEXT_INIT=' .env.dev${{ matrix.blob-provider }}.example > .env
+      - name: Run + migrate
+        run: |
+          docker compose -f docker-compose.dev${{ matrix.blob-provider }}.yml up -d
+          sleep 5 # Wait for PostgreSQL to accept connections
+          docker compose ps
+        env:
+          POSTGRES_VERSION: ${{ matrix.postgres-version }}
+      - name: Seed DB
+        run: |
+          pnpm run db:migrate
+          pnpm --filter=shared ch:up
+      - name: Build
+        run: pnpm run build
+      - name: Start Langfuse
+        run: (pnpm run start&)
+        env:
+          LANGFUSE_INIT_ORG_ID: "seed-org-id"
+          LANGFUSE_INIT_ORG_NAME: "Seed Org"
+          LANGFUSE_INIT_PROJECT_ID: "7a88fb47-b4e2-43b8-a06c-a5ce950dc53a"
+          LANGFUSE_INIT_PROJECT_NAME: "Seed Project"
+          LANGFUSE_INIT_PROJECT_PUBLIC_KEY: "pk-lf-1234567890"
+          LANGFUSE_INIT_PROJECT_SECRET_KEY: "sk-lf-1234567890"
+          LANGFUSE_INIT_USER_EMAIL: "demo@langfuse.com"
+          LANGFUSE_INIT_USER_NAME: "Demo User"
+          LANGFUSE_INIT_USER_PASSWORD: "password"
+      - name: run tests
+        run: pnpm --filter=web run test
+
+  tests-worker:
+    timeout-minutes: 20
+    runs-on: ubuntu-latest
+    name: tests-worker (node${{ matrix.node-version }}, pg${{ matrix.postgres-version }}, mode${{ matrix.blob-provider }})
+    strategy:
+      matrix:
+        node-version: [20]
+        postgres-version: [12, 15]
+        blob-provider: ["", "-azure"]
+    steps:
+      - name: Set Swap Space
+        uses: pierotofy/set-swap-space@master
+        with:
+          swap-size-gb: 10
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v3
+        with:
+          version: 9.5.0
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME_READ }}
+          password: ${{ secrets.DOCKERHUB_TOKEN_READ }}
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: "pnpm"
+          cache-dependency-path: "pnpm-lock.yaml"
+      - name: install dependencies
+        run: |
+          pnpm install
+      - name: Install golang-migrate for Clickhouse migrations
+        run: |
+          curl -L https://github.com/golang-migrate/migrate/releases/download/v4.18.2/migrate.linux-amd64.tar.gz | tar xvz
+          sudo mv migrate /usr/bin/migrate
+          which migrate
+      - name: Load default env
+        run: |
+          cp .env.dev${{ matrix.blob-provider }}.example .env
+          cp .env.dev${{ matrix.blob-provider }}.example web/.env
+          cp .env.dev${{ matrix.blob-provider }}.example worker/.env
+      - name: Run + migrate
+        run: |
+          docker compose -f docker-compose.dev${{ matrix.blob-provider }}.yml up -d
+          sleep 5 # Wait for PostgreSQL to accept connections
+          docker compose ps
+      - name: Ensure no unhealthy status
+        run: |
+          if docker compose ps | grep "(unhealthy)"; then
+            echo "One or more services are unhealthy"
+            exit 1
+          else
+            echo "All services are healthy"
+          fi
+      - name: Seed DB
+        run: |
+          pnpm run db:migrate
+          pnpm run db:seed
+          pnpm run --filter=shared ch:up
+      - name: Build
+        run: pnpm --filter=worker... run build
+      - name: run tests
+        run: pnpm --filter=worker run test
+
+  e2e-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v3
+        with:
+          version: 9.5.0
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: "pnpm"
+          cache-dependency-path: "pnpm-lock.yaml"
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME_READ }}
+          password: ${{ secrets.DOCKERHUB_TOKEN_READ }}
+      - name: install dependencies
+        run: |
+          pnpm install
+      - name: Load default env
+        run: |
+          cp .env.dev.example .env
+          cp .env.dev.example web/.env
+      - name: Run + migrate
+        run: |
+          docker compose -f docker-compose.dev.yml up -d
+          docker compose ps
+          sleep 5 # Wait for PostgreSQL to accept connections
+      - name: Seed DB
+        run: |
+          pnpm run db:migrate
+          pnpm run db:seed
+      - name: Build
+        run: pnpm run build
+      - name: Install playwright
+        run: pnpm --filter=web exec playwright install --with-deps
+      - name: Run e2e tests
+        run: pnpm --filter=web run test:e2e
+
+  e2e-server-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME_READ }}
+          password: ${{ secrets.DOCKERHUB_TOKEN_READ }}
+      - uses: pnpm/action-setup@v3
+        with:
+          version: 9.5.0
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: "pnpm"
+          cache-dependency-path: "pnpm-lock.yaml"
+      - name: install dependencies
+        run: |
+          pnpm install
+      - name: Install golang-migrate for Clickhouse migrations
+        run: |
+          curl -L https://github.com/golang-migrate/migrate/releases/download/v4.18.2/migrate.linux-amd64.tar.gz | tar xvz
+          sudo mv migrate /usr/bin/migrate
+          which migrate
+      - name: Load default env
+        run: |
+          cp .env.dev.example .env
+          echo "LANGFUSE_ASYNC_CLICKHOUSE_INGESTION_PROCESSING=true" >> .env
+          echo "LANGFUSE_ASYNC_INGESTION_PROCESSING=true" >> .env
+          echo "LANGFUSE_CACHE_API_KEY_ENABLED=true" >> .env
+          echo "LANGFUSE_CACHE_PROMPT_ENABLED=true" >> .env
+      - name: Run + migrate
+        run: |
+          docker compose -f docker-compose.dev.yml up -d
+          docker compose ps
+          sleep 5 # Wait for PostgreSQL to accept connections
+      - name: Ensure Docker dependencies are healthy
+        run: |
+          if docker-compose ps | grep "(unhealthy)"; then
+            echo "One or more services are unhealthy"
+            exit 1
+          else
+            echo "All services are healthy"
+          fi
+      - name: Seed DB
+        run: |
+          pnpm run db:migrate
+          pnpm --filter=shared run ch:up
+          pnpm run db:seed:examples
+      - name: Build
+        run: pnpm run build
+      - name: Run server
+        run: (pnpm run start&)
+      - name: Check worker health
+        run: |
+          timeout 10 bash -c 'until curl -f http://localhost:3030/api/health; do sleep 2; done'
+      - name: Check server health
+        run: |
+          timeout 10 bash -c 'until curl -f http://localhost:3000/api/public/health; do sleep 2; done'
+      - name: Run e2e tests
+        run: pnpm --filter=web run test:e2e:server
+
+  all-ci-passed:
+    # This allows us to have a branch protection rule for tests and deploys with matrix
+    runs-on: ubuntu-latest
+    needs:
+      [
+        lint,
+        tests-web-sync,
+        tests-worker,
+        e2e-tests,
+        test-docker-build,
+        e2e-server-tests,
+        tests-web-async,
+      ]
+    if: always()
+    steps:
+      - name: Successful deploy
+        if: ${{ !(contains(needs.*.result, 'failure')) }}
+        run: exit 0
+        working-directory: .
+      - name: Failing deploy
+        if: ${{ contains(needs.*.result, 'failure') }}
+        run: exit 1
+        working-directory: .
+
+  push-docker-image:
+    needs: all-ci-passed
+    if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/'))
+    environment: "protected branches"
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+
+    steps:
+      - uses: pnpm/action-setup@v3
+        with:
+          version: 9.5.0
+      - name: Setup node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache-dependency-path: "pnpm-lock.yaml"
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Set NEXT_PUBLIC_BUILD_ID
+        run: echo "NEXT_PUBLIC_BUILD_ID=$(git rev-parse --short HEAD)" >> $GITHUB_ENV
+      - name: Log in to the GitHub Container registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          driver-opts: network=host
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta-web
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            ghcr.io/langfuse/langfuse # GitHub
+            langfuse/langfuse # Docker Hub
+          flavor: |
+            latest=false
+          tags: |
+            type=ref,event=branch
+            type=ref,event=pr
+            type=sha
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=semver,pattern={{major}}
+            type=raw,value=latest,enable=${{ startsWith(github.ref, 'refs/tags/v3') }}
+      - name: Build and push Docker image (web)
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          file: ./web/Dockerfile
+          push: true
+          tags: ${{ steps.meta-web.outputs.tags }}
+          labels: ${{ steps.meta-web.outputs.labels }}
+          platforms: |
+            linux/amd64
+            ${{ startsWith(github.ref, 'refs/tags/') && 'linux/arm64' || '' }}
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta-worker
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            ghcr.io/langfuse/langfuse-worker # GitHub
+            langfuse/langfuse-worker # Docker Hub
+          tags: |
+            type=ref,event=branch
+            type=ref,event=pr
+            type=sha
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=semver,pattern={{major}}
+      - name: Build and push Docker image (worker)
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          file: ./worker/Dockerfile
+          push: true
+          tags: ${{ steps.meta-worker.outputs.tags }}
+          labels: ${{ steps.meta-worker.outputs.labels }}
+          platforms: |
+            linux/amd64
+            ${{ startsWith(github.ref, 'refs/tags/') && 'linux/arm64' || '' }}
+      - name: Notify Slack
+        uses: ravsamhq/notify-slack-action@v2
+        if: always()
+        with:
+          status: ${{ job.status }}
+          notify_when: "failure"
+        env:
+          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}

.github/workflows/release.yml

@@ -0,0 +1,19 @@
+on:
+  workflow_dispatch:
+  push:
+    # Pattern matched against refs/tags
+    tags:
+      - "v3.[0-9]+.[0-9]+" # Semantic version tags
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    environment: "protected branches"
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: main # Always checkout main even for tagged releases
+          fetch-depth: 0
+          token: ${{ secrets.GH_ACCESS_TOKEN }}
+      - name: Push to production
+        run: git push origin +main:production

.github/workflows/snyk.yml

@@ -0,0 +1,46 @@
+name: Snyk Container
+on:
+  pull_request:
+    branches:
+      - "**"
+  push:
+    branches:
+      - main
+
+jobs:
+  snyk:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Build a Docker image
+        run: docker compose -f docker-compose.build.yml up -d
+
+      - name: Run Snyk to check Docker image for vulnerabilities (langfuse-server)
+        continue-on-error: true
+        uses: snyk/actions/docker@master
+        env:
+          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
+        with:
+          image: langfuse-server
+          args: --file=web/Dockerfile
+
+      - name: Upload result to GitHub Code Scanning
+        uses: github/codeql-action/upload-sarif@v3
+        with:
+          sarif_file: snyk.sarif
+          category: web
+
+      - name: Run Snyk to check Docker image for vulnerabilities (langfuse-worker)
+        continue-on-error: true
+        uses: snyk/actions/docker@master
+        env:
+          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
+        with:
+          image: langfuse-worker
+          args: --file=worker/Dockerfile
+
+      - name: Upload result to GitHub Code Scanning
+        uses: github/codeql-action/upload-sarif@v3
+        with:
+          sarif_file: snyk.sarif
+          category: worker

.gitignore

@@ -1,32 +1,66 @@
-node_modules
-.next/
-out/
-dist/
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
 
-# pnpm is the one package manager here — pnpm-lock.yaml is the tracked lockfile and
-# `packageManager` in package.json pins the version corepack installs. A lockfile
-# from any other manager is a second source of truth that silently drifts.
-package-lock.json
-yarn.lock
-bun.lockb
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
 
-# build artifacts
-*.tsbuildinfo
+# testing
+/coverage
+
+# database
+/prisma/db.sqlite
+/prisma/db.sqlite-journal
+
+# next.js
+/.next/
+/out/
 next-env.d.ts
 
-# env
-.env*.local
+# production
+/build
 
-# editor / os
+# idea
+.idea
+
+# misc
 .DS_Store
-.vscode/
-.idea/
-*.log
-e2e/screenshots/
-e2e-shots/
-test-results/
-playwright-report/
-.claude/
+*.pem
 
-# blank-audit generated report
-e2e/blank-report.json
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# local env files
+# do not commit any .env files to git, except for the .env.example file. https://create.t3.gg/en/usage/env-variables#using-environment-variables
+.env*
+!.env.dev.example
+!.env.dev-azure.example
+!.env.local.example
+!.env.prod.example
+!.env.dev.legacy.example
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+
+/generated/typescript-server
+
+# openapi spec that is copied during build
+/public/openapi*.yml
+
+
+# vscode
+.devcontainer
+
+node_modules
+**/node_modules
+**/dist
+**/.next/*
+**/.turbo/*
+.yarn
+.turbo

.hanzo/workflows/cicd.yml

@@ -1,25 +0,0 @@
-# ~7-line canonical caller — all real config lives in /hanzo.yml.
-# Builds + pushes BOTH console images (the embed artifact cloud go:embeds, and
-# the Next.js server image admin.hanzo.ai runs); auto-mirrors to registry.hanzo.ai.
-#
-# It replaces `.hanzo/workflows/deploy.yml`, which built the server image a
-# SECOND time by hand and could not: `buildctl-daemonless.sh` is not in the image
-# this fleet serves for `hanzo-build-linux-amd64` (every label in that pool maps
-# to catthehacker/ubuntu:act-24.04 — universe:infra/k8s/git-runner/statefulset.yaml),
-# and its `secrets.GIT_CLONE_TOKEN` exists on neither the repo nor the org. Its
-# `kubectl patch app` was futile too: cd.hanzo.ai's selfHeal restores the CR from
-# the universe pin on the next poll. Rollout is a reviewed tag pin in
-# hanzoai/universe, never a CI side effect.
-name: CI/CD
-on:
-  workflow_dispatch:
-  push:
-    branches: [main]
-    # A hand-cut v* tag must produce its image, or the tag is a receipt for
-    # nothing — the exact drift the retired build-image.yml existed to prevent.
-    tags: ['v*']
-  pull_request:
-jobs:
-  cicd:
-    uses: hanzoai/ci/.hanzo/workflows/build.yml@v1
-    secrets: inherit

.husky/pre-commit

@@ -0,0 +1,22 @@
+#!/bin/sh
+
+# Get the current branch
+current_branch=$(git rev-parse --abbrev-ref HEAD)
+
+# Define the protected branch
+protected_branch="main"
+
+# Check if the current branch is the protected branch
+if [ "$current_branch" = "$protected_branch" ]; then
+    echo "🚨 You are about to commit to the $protected_branch branch. Are you sure? (y/n)"
+    read -r answer < /dev/tty
+    if [ "$answer" != "${answer#[Yy]}" ]; then
+        exit 0 # Commit will proceed
+    else
+        echo "Commit to $protected_branch branch has been canceled."
+        exit 1 # Commit will be blocked
+    fi
+fi
+
+# If not the protected branch, proceed with the commit
+exit 0

.husky/pre-push

@@ -0,0 +1,22 @@
+#!/bin/sh
+
+# Get the current branch
+current_branch=$(git rev-parse --abbrev-ref HEAD)
+
+# Define the protected branch
+protected_branch="main"
+
+# Check if the current branch is the protected branch
+if [ "$current_branch" = "$protected_branch" ]; then
+    echo "🚨 You are about to push to the $protected_branch branch. Are you sure? (y/n)"
+    read -r answer < /dev/tty
+    if [ "$answer" != "${answer#[Yy]}" ]; then
+        exit 0 # Push will proceed
+    else
+        echo "Push to $protected_branch branch has been canceled."
+        exit 1 # Push will be blocked
+    fi
+fi
+
+# If not the protected branch, proceed with the push
+exit 0

.npmrc

@@ -0,0 +1 @@
+public-hoist-pattern[]=*prisma*

.nvmrc

@@ -0,0 +1 @@
+v20

.vscode/extensions.json

@@ -0,0 +1,10 @@
+{
+  "recommendations": [
+    "esbenp.prettier-vscode",
+    "dbaeumer.vscode-eslint",
+    "bradlc.vscode-tailwindcss",
+    "unifiedjs.vscode-mdx",
+    "yoavbls.pretty-ts-errors",
+    "Prisma.prisma"
+  ]
+}

.vscode/launch.json

@@ -0,0 +1,28 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Web and Worker: server side",
+      "type": "node-terminal",
+      "request": "launch",
+      "command": "pnpm run dev"
+    },
+    {
+      "name": "Next.js: debug client-side",
+      "type": "chrome",
+      "request": "launch",
+      "url": "http://localhost:3000"
+    },
+    {
+      "name": "Next.js: debug full stack",
+      "type": "node-terminal",
+      "request": "launch",
+      "command": "npm run dev",
+      "serverReadyAction": {
+        "pattern": "- Local:.+(https?://.+)",
+        "uriFormat": "%s",
+        "action": "debugWithChrome"
+      }
+    }
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,32 @@
+{
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": "explicit"
+  },
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "editor.formatOnSave": true,
+  "editor.rulers": [100],
+  "editor.tabSize": 2,
+
+  "eslint.validate": [
+    "javascript",
+    "javascriptreact",
+    "astro",
+    "typescript",
+    "typescriptreact"
+  ],
+
+  "eslint.rules.customizations": [{ "rule": "*", "severity": "warn" }],
+  "typescript.tsdk": "node_modules/typescript/lib",
+  "prettier.documentSelectors": [
+    "**/*.{cjs,mjs,ts,tsx,astro,md,mdx,json,yaml,yml}"
+  ],
+  "prettier.trailingComma": "all",
+  "mdx.experimentalLanguageServer": true,
+  "typescript.preferences.importModuleSpecifier": "non-relative",
+  "docwriter.style": "JSDoc",
+  "[prisma]": {
+    "editor.defaultFormatter": "Prisma.prisma"
+  },
+  "eslint.lintTask.enable": true,
+  "eslint.workingDirectories": ["./web", "./worker"]
+}

AGENTS.md

@@ -1 +0,0 @@
-LLM.md

CLAUDE.md

@@ -1 +0,0 @@
-LLM.md

CONTRIBUTING.md

@@ -0,0 +1,453 @@
+![Langfuse GitHub Banner](https://github.com/langfuse/langfuse/assets/121163007/6035f0f3-d691-4963-b5d0-10cf506e9d42)
+
+# Contributing to Langfuse
+
+First off, thanks for taking the time to contribute! ❤️
+
+The best ways to contribute to Langfuse:
+
+- Submit and vote on [Ideas](https://github.com/orgs/langfuse/discussions/categories/ideas)
+- Create and comment on [Issues](https://github.com/langfuse/langfuse/issues)
+- Open a PR.
+
+We welcome contributions through GitHub pull requests. This document outlines our conventions regarding development workflow, commit message formatting, contact points, and other resources. Our goal is to simplify the process and ensure that your contributions are easily accepted.
+
+We gratefully welcome improvements to documentation ([docs repo](https://github.com/langfuse/langfuse-docs)), the core application (this repo) and the SDKs ([Python](https://github.com/langfuse/langfuse-python), [JS](https://github.com/langfuse/langfuse-js)).
+
+The maintainers are available on [Discord](https://langfuse.com/discord) in case you have any questions.
+
+> And if you like the project, but just don't have time to contribute code, that's fine. There are other easy ways to support the project and show your appreciation, which we would also be very happy about:
+>
+> - Star the project;
+> - Tweet about it;
+> - Refer to this project in your project's readme;
+> - Submit and vote on [Ideas](https://github.com/orgs/langfuse/discussions/categories/ideas);
+> - Create and comment on [Issues](https://github.com/langfuse/langfuse/issues);
+> - Mention the project at local meetups and tell your friends/colleagues.
+
+## Making a change
+
+_Before making any significant changes, please [open an issue](https://github.com/langfuse/langfuse/issues)._ Discussing your proposed changes ahead of time will make the contribution process smooth for everyone. Large changes that were not discussed in an issue may be rejected.
+
+Once we've discussed your changes and you've got your code ready, make sure that tests are passing and open your pull request.
+
+A good first step is to search for open [issues](https://github.com/langfuse/langfuse/issues). Issues are labeled, and some good issues to start with are labeled: [good first issue](https://github.com/langfuse/langfuse/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22).
+
+## Project Overview
+
+### Technologies we use
+
+- Application (this repository)
+  - NextJS 14, pages router
+  - NextAuth.js / Auth.js
+  - tRPC: Frontend APIs
+  - Prisma ORM
+  - Zod
+  - Tailwind CSS
+  - shadcn/ui tailwind components (using Radix and tanstack)
+  - Fern: generate OpenAPI spec and Pydantic models
+- JS SDK ([langfuse/langfuse-js](https://github.com/langfuse/langfuse-js))
+  - openapi-typescript to generated types based on OpenAPI spec
+- Python SDK ([langfuse/langfuse-python](https://github.com/langfuse/langfuse-python))
+  - Pydantic for input validation, models generated by fern
+
+### Architecture Overview
+
+**Langfuse v2**
+
+```mermaid
+flowchart TB
+    subgraph s4["Clients"]
+        subgraph s2["langfuse/langfuse-python"]
+            Python["Python low-level SDK"]
+            Decorator["observe() decorator"] -->|extends| Python
+            OAI["OpenAI drop-in replacement"] -->|extends| Python
+            Llamaindex["LlamaIndex Integration"] -->|extends| Python
+            LCPYTHON["Langchain Python Integration"] -->|extends| Python
+            Langflow -->|uses| LCPYTHON
+            LiteLLM -->|uses| Python
+        end
+        subgraph s3["langfuse/langfuse-js"]
+            JS["JS SDK"]
+            LCJS["Langchain JS Integration"]  -->|extends| JS
+            Flowise -->|uses| LCJS
+        end
+    end
+
+    DB[Postgres Database]
+    Redis[Redis]
+
+    subgraph s1["Application (langfuse/langfuse/web)"]
+        API[Public HTTP API]
+        G[TRPC API]
+        I[NextAuth]
+        H[React Frontend]
+        Prisma[Prisma ORM]
+        H --> G
+        H --> I
+        G --> I
+        G --- Prisma
+        API --- Prisma
+        I --- Prisma
+    end
+
+    Prisma --- DB
+    JS --- API
+    Python --- API
+```
+
+**Langfuse v3 (work in progress, not released yet)**
+
+> [!NOTE]
+> Infrastructure will change in Langfuse version 3.0. More in the [GitHub Discussions](https://github.com/orgs/langfuse/discussions/1902).
+> `langfuse/langfuse/worker` is under active development and not recommended for production use in Langfuse 2.x.
+
+```mermaid
+flowchart TB
+    subgraph s4["Clients"]
+        subgraph s2["langfuse/langfuse-python"]
+            Python["Python low-level SDK"]
+            Decorator["observe() decorator"] -->|extends| Python
+            OAI["OpenAI drop-in replacement"] -->|extends| Python
+            Llamaindex["LlamaIndex Integration"] -->|extends| Python
+            LCPYTHON["Langchain Python Integration"] -->|extends| Python
+            Langflow -->|uses| LCPYTHON
+            LiteLLM -->|uses| Python
+        end
+        subgraph s3["langfuse/langfuse-js"]
+            JS["JS SDK"]
+            LCJS["Langchain JS Integration"]  -->|extends| JS
+            Flowise -->|uses| LCJS
+        end
+    end
+
+    DB[Postgres Database]
+    Redis[Redis Cache/Queue]
+    Clickhouse[Clickhouse Database]
+
+    subgraph s1["Application (langfuse/langfuse/web)"]
+        API[Public HTTP API]
+        G[TRPC API]
+        I[NextAuth]
+        H[React Frontend]
+        ORM
+        H --> G
+        H --> I
+        G --> I
+        G --- ORM
+        API --- ORM
+        I --- ORM
+    end
+
+    subgraph s5["Application (langfuse/langfuse/worker)"]
+        Worker
+    end
+
+    Worker --- DB
+    Worker --- Redis
+    Worker --- Clickhouse
+
+    ORM --- DB
+    ORM --- Redis
+    ORM --- Clickhouse
+
+    JS --- API
+    Python --- API
+```
+
+### Network Overview
+
+> [!NOTE]
+> This will change in Langfuse version 3.0. More in the [GitHub Discussions](https://github.com/orgs/langfuse/discussions/1902).
+
+```mermaid
+flowchart LR
+   Browser ---|Web UI & TRPC API| App
+   Integrations/SDKs ---|Public HTTP API| App
+   subgraph i1["Application Network"]
+      App["Langfuse Application"]
+   end
+   subgraph i2["Database Network"]
+      DB["Postgres Database"]
+   end
+   App --- DB
+```
+
+### Database Overview
+
+The diagram below may not show all relationships if the foreign key is not defined in the database schema. For instance, `trace_id` in the `observation` table is not defined as a foreign key to the `trace` table to allow unordered ingestion of these objects, but it is still a foreign key in the application code.
+
+Full database schema: [packages/shared/prisma/schema.prisma](packages/shared/prisma/schema.prisma)
+
+<img src="./packages/shared/prisma/database.svg">
+
+## Repository Structure
+
+We built a monorepo using [pnpm](https://pnpm.io/motivation) and [turbo](https://turbo.build/repo/docs) to manage the dependencies and build process. The monorepo contains the following packages:
+
+- `web`: is the main application package providing Frontend and Backend APIs for Langfuse.
+- `worker` (no production yet): contains an application for asynchronous processing of tasks. This package is not yet used in production.
+- `packages`:
+  - `shared`: contains shared code between the above packages.
+  - `config-eslint`: contains eslint configurations which are shared between the above packages.
+  - `config-typescript`: contains typescript configurations which are shared between the above packages.
+- `ee`: contains all enterprise features. See [EE README](ee/README.md) for more details.
+
+## Development Setup
+
+Requirements
+
+- Node.js 20 as specified in the [.nvmrc](.nvmrc)
+- Pnpm v.9.5.0
+- Docker to run the database locally
+
+**Note:** You can also simply run Langfuse in a **GitHub Codespace** via the provided devcontainer. To do this, click on the green "Code" button in the top right corner of the repository and select "Open with Codespaces".
+
+**Steps**
+
+1. Fork the repository and clone it locally
+2. Run the development database
+
+   ```bash
+   pnpm run infra:dev:up
+   ```
+
+3. Create an env file
+
+   ```bash
+    cp .env.dev.example .env
+   ```
+
+4. Install dependencies
+
+   ```bash
+   pnpm install
+   ```
+
+5. Run the migrations
+
+   All database migrations and configs are in the `shared` package.
+
+   ```bash
+   pnpm --filter=shared run db:migrate
+
+   # Optional: seed the database
+   # pnpm run db:seed
+   # pnpm run db:seed:examples
+   # pnpm --filter=shared run db:seed:load
+   ```
+
+6. Start the development server
+
+   ```bash
+    pnpm run dev
+   ```
+
+7. Open the web app in the browser:
+
+   http://localhost:3000
+
+8. Log in as a test user (after you ran `db:seed` command):
+
+   Username: demo@langfuse.com
+
+   Password: password
+
+## Monorepo quickstart
+
+- Available packages and their dependencies
+
+  Packages are included in the monorepo according to the `pnpm-workspace.yaml` file. Each package maintains its own dependencies defined in the `package.json`. Internal dependencies can be added as well by adding them to the package dependencies: `"@langfuse/shared": "workspace:*"`.
+
+- Executing commands
+
+  You can run commands in all packages at once. For example, to install all dependencies in all packages, you can execute:
+
+  ```bash
+  pnpm install
+  pnpm run dev
+  pnpm --filter=web run dev # execute command only in one package
+  ```
+
+  In the root `package.json`, you can find scripts which are executed with turbo e.g. `turbo run dev`. These scripts are executed with the help of Turbo. Turbo executes the commands in all packages taking care of the correct order of execution. Task definitions can be found in the `turbo.config.js` file.
+
+- Run migrations
+
+  To run migrations, you can execute the following command.
+
+  ```bash
+  pnpm run db:migrate -- --name <name of the migration>
+  ```
+
+> [!NOTE]
+> If you frequently switch branches, use `pnpm run dx` instead of `pnpm run dev`. This command will install dependencies, reset the database (wipe and apply all migrations), and run the database seeder with example data before starting the development server.
+
+> [!NOTE]
+> If you find yourself stuck and want to clean the repo, execute `pnpm run nuke`. It will remove all node_modules and build files.
+
+## System behavior
+
+### Ingestion API `(/public/api/ingestion)`
+
+- the ingestion API takes different event types (creation and updates of traces, generations, spans, events)
+- The API loops through each event and:
+  - validates the event
+  - stores the event raw in the events table
+  - calculates tokens for `generations`
+  - matches models from the `models` table to model for `generations` events
+  - upserts the event in the `traces` or `observations` table
+- returns a `207` HTTP status code with a list of errors if any event failed to be ingested
+
+## Commit messages
+
+On the main branch, we adhere to the best practices of [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/). All pull requests and branches are squash-merged to maintain a clean and readable history. This approach ensures the addition of a conventional commit message when merging contributions.
+
+## Test the public API
+
+The API is tested using Jest. With the development server running, you can run the tests with:
+
+Run all
+
+```bash
+npm run test
+```
+
+Run interactively in watch mode
+
+```bash
+npm run test:watch
+```
+
+These tests are also run in CI.
+
+## CI/CD
+
+We use GitHub Actions for CI/CD, the configuration is in [`.github/workflows/pipeline.yml`](.github/workflows/pipeline.yml)
+
+CI on `main` and `pull_request`
+
+- Check Linting
+- E2E test of API using Jest
+- E2E tests of UI using Playwright
+
+CD on `main`
+
+- Publish Docker image to GitHub Packages if CI passes. Done on every push to `main` branch. Only released versions are tagged with `latest`.
+
+## Staging environment
+
+We run a staging environment at [https://staging.langfuse.com](https://staging.langfuse.com) that is automatically deployed on every push to `main` branch.
+
+The same environment is also used for preview deployments of pull requests. Limitations:
+
+- SSO is not available as dynamic domains are not supported by most SSO providers.
+- When making changes to the database, migrations to the staging database need to be applied manually by a maintainer. If you want to interactively test database changes in the staging environment, please reach out.
+
+You can use the staging environment end-to-end with the Langfuse integrations or SDKs (host: `https://staging.langfuse.com`). However, please note that the staging environment is not intended for production use and may be reset at any time.
+
+## Production environment
+
+When a new release is tagged on the `main` branch (excluding prereleases), it triggers a production deployment. The deployment process consists of two steps:
+
+1. The Docker image is published to GitHub Packages with the version number and `latest` tag.
+2. The deployment is carried out on Langfuse Cloud. This is done by force pushing the `main` branch to the `production` branch during every release, using the [`release.yml`](.github/workflows/release.yml) GitHub Action.
+
+## Theming
+
+At Langfuse, we utilize CSS variables to manage our theme settings across the platform.
+
+Our approach leverages separate CSS variables for backgrounds (--background) and foregrounds (--foreground), fully adhering to the [shadcn/ui](https://ui.shadcn.com/docs/theming) color conventions. The background suffix can be omitted if the variable is used for the background color of the component. We recommend using HSL values for these colors to enhance consistency and customization. There is no need to manually handle dark mode styling with "dark:" prefixes, as next-themes automatically manages the theme switching.
+
+Given the following CSS variables:
+
+```
+--primary: 222.2 47.4% 11.2%; // e.g. background-color
+--primary-foreground: 210 40% 98%; // e.g. text-color
+```
+
+The background color of the following component will be `hsl(var(--primary))` and the foreground color will be `hsl(var(--primary-foreground))`.
+
+```
+<div class="bg-primary text-primary-foreground">Hello</div>
+```
+
+### Color Variables
+
+| Variable                 | Description                                                        | Examples                         |
+| ------------------------ | ------------------------------------------------------------------ | -------------------------------- |
+| --background             | Background color                                                   | Default background color of body |
+| --foreground             | Foreground color                                                   | Default text color of body       |
+| --muted                  | Muted background color                                             | TabsList, Skeleton and Switch    |
+| --muted-foreground       | Muted foreground color                                             |                                  |
+| --popover                | Popover background color                                           | DropdownMenu, HoverCard, Popover |
+| --popover-foreground     | Popover foreground color                                           |                                  |
+| --card                   | Card background color                                              | Card                             |
+| --card-foreground        | Card foreground color                                              |                                  |
+| --border                 | Border color                                                       | Default border color             |
+| --input                  | Input field border color                                           | Input, Select, Textarea          |
+| --primary                | Primary button background colors                                   | Button variant="primary"         |
+| --primary-foreground     | Primary button foreground color                                    |                                  |
+| --secondary              | Secondary button background color                                  | Button variant="secondary"       |
+| --secondary-foreground   | Secondary button foreground color                                  |                                  |
+| --accent                 | Used for accents such as hover effects                             | DropdownMenuItem, SelectItem     |
+| --accent-foreground      | Used for texts on hover effects                                    | DropdownMenuItem, SelectItem     |
+| --destructive            | Destructive action color for background                            | Button variant="destructive"     |
+| --destructive-foreground | Destructive action color for text                                  |                                  |
+| --ring                   | Focus ring color                                                   | MultiSelect                      |
+| --primary-accent         | Primary accent color used for branding                             | Layout                           |
+| --hover-primary-accent   | Primary accent color used for hover effects for links              | SignIn and AuthCloudRegionSwitch |
+| --muted-green            | Muted green for Event label                                        | ObservationTree                  |
+| --muted-orange           | Muted orange for Generation label                                  | ObservationTree                  |
+| --muted-blue             | Muted blue for Span label                                          | ObservationTree                  |
+| --muted-gray             | Muted gray for disabled status badges                              | StatusBadge                      |
+| --accent-light-green     | Light green accent for background of output and assistant messages | IOPreview, Generations, Traces   |
+| --accent-dark-green      | Dark green accent for border of output and assistant messages      | CodeJsonViewer and IOPReview     |
+| --light-red              | Light red for error background                                     | level-color and StatusBadge      |
+| --dark-red               | Dark red for error text and error badge dot color                  | level-color and ErrorPage        |
+| --light-yellow           | Light yellow for warning background                                | LevelColor                       |
+| --dark-yellow            | Dark yellow for warning text                                       | LevelColor                       |
+| --light-green            | Light green for success status badge background                    | StatusBadge                      |
+| --dark-green             | Dark green for success status badge text and dot                   | StatusBadge                      |
+| --light-blue             | Light blue for background of Staging label                         | LangfuseLogo                     |
+| --dark-blue              | Dark blue for text and border of Staging label                     | LangfuseLogo                     |
+| --accent-light-blue      | Light blue accent for table link hover effect                      | TableLink                        |
+| --accent-dark-blue       | Dark blue accent for table link text                               | TableLink                        |
+
+### Adding New Colors
+
+1. Global Definitions: Add new CSS variable definitions in the global.css file.
+2. Tailwind Configuration: Reflect these new colors in the tailwind.config.js to maintain alignment with Tailwind's utility classes.
+
+By following these guidelines, you can ensure that any contributions to our theme are consistent, maintainable, and aligned with our design system.
+
+## Maintainers
+
+### Using secrets stored in 1Password
+
+When applying changes to non-local environments, you may need to use secrets stored in 1Password. We use the 1Password CLI for this purpose.
+
+Example:
+
+```bash
+op run --env-file="./.env" -- pnpm --filter=shared run db:deploy
+```
+
+### Editing default models and prices
+
+You can update the default AI models and prices by adding or updating an entry in `worker/src/constants/default-model-prices.json`.
+
+Please note that
+
+- prices are in USD
+- the list is ordered by ID, so make sure to keep this order
+- the `updated_at` field must be updated with the current date in ISO 8601 format. Otherwise, the change will be ignored.
+
+### Transition period until V3 release
+
+Until the V3 release, both the JSON record must be updated **and** a migration must be created to continue supporting self-hosted users. Note that the migration must updated both the `models` as well as the `prices` table accordingly.
+
+## License
+
+Langfuse is MIT licensed, except for `ee/` folder. See [LICENSE](LICENSE) and [docs](https://langfuse.com/docs/open-source) for more details.
+
+When contributing to the Langfuse codebase, you need to agree to the [Contributor License Agreement](https://cla-assistant.io/langfuse/langfuse). You only need to do this once and the CLA bot will remind you if you haven't signed it yet.

Dockerfile

@@ -1,48 +0,0 @@
-# console2 — Hanzo Cloud Console (Next.js 15 + @hanzo/gui). MIT OR Apache-2.0.
-# NEXT_PUBLIC_* are inlined at build time (browser config), so they are build args.
-FROM public.ecr.aws/docker/library/node:24-alpine AS build
-WORKDIR /app
-# Exact commit for a deterministic Next build id (next.config.mjs generateBuildId).
-# The alpine image has no git binary, so CI passes the SHA as a build arg -> ENV,
-# baked into .next/BUILD_ID so every replica of this image shares ONE build id.
-ARG SOURCE_COMMIT=""
-ENV SOURCE_COMMIT=$SOURCE_COMMIT
-# Copy ALL source FIRST, then install — order matters under Kaniko --single-snapshot:
-# a `COPY` that FOLLOWS the install in the same stage drops that RUN's freshly
-# created node_modules (the 'next not found' cause — the install's own `test -f next`
-# passed, then `COPY . .` wiped node_modules before the build RUN). Putting COPY
-# before install means node_modules is created by the LAST RUNs and nothing clobbers
-# it. (Layer-cache for deps is moot here — the on-cluster build runs --cache=false.)
-COPY . .
-# public/ may be empty (git doesn't track empty dirs) — ensure it exists for the runner COPY.
-RUN mkdir -p public
-# corepack installs the exact pnpm from package.json's `packageManager`, so the
-# builder and a laptop resolve identically. --frozen-lockfile is the whole reason
-# this repo is on pnpm: the old `npm install` here could not be `npm ci`, because
-# @hanzo/gui's react-native tree resolves its platform/optional packages differently
-# across npm versions and a lockfile written by one npm failed under another. pnpm
-# records every platform in the lockfile, so the build installs exactly what is
-# committed and fails loudly instead of quietly resolving something else.
-RUN corepack enable && pnpm install --frozen-lockfile
-# ONE brand-agnostic image: brand (IAM org/issuer/app + wordmark) is resolved at
-# RUNTIME from the request hostname (src/config/index.ts), and /v1 is same-origin
-# per host. Baking NEXT_PUBLIC_* here would inline a single brand and break that.
-# Next 15 + @hanzo/gui (large RN dep tree) overflows Node's default heap → OOMKill
-# (exit 137); cap the heap generously (chat uses 4096).
-ENV NEXT_TELEMETRY_DISABLED=1 NODE_OPTIONS=--max-old-space-size=6144
-RUN pnpm build
-
-FROM public.ecr.aws/docker/library/node:24-alpine AS runner
-WORKDIR /app
-ENV NODE_ENV=production NEXT_TELEMETRY_DISABLED=1 PORT=4000
-RUN addgroup -S app && adduser -S app -G app
-COPY --from=build /app/.next ./.next
-COPY --from=build /app/public ./public
-COPY --from=build /app/node_modules ./node_modules
-COPY --from=build /app/package.json ./package.json
-COPY --from=build /app/next.config.mjs ./next.config.mjs
-# next.config.mjs imports this at load time (build AND standalone runtime); copy it or the server ERR_MODULE_NOT_FOUND-crashes on boot.
-COPY --from=build /app/src/config/build-id.mjs ./src/config/build-id.mjs
-USER app
-EXPOSE 4000
-CMD ["node", "node_modules/next/dist/bin/next", "start", "-p", "4000"]

Dockerfile.embed

@@ -1,30 +0,0 @@
-# hanzoai/console — the EMBED artifact.
-#
-# Builds the console SPA static export (`pnpm build:embed` → out/) ONCE, as a
-# versioned immutable image whose rootfs is just the bundle at /dist. hanzoai/cloud
-# then does `FROM registry.hanzo.ai/hanzoai/console-embed:<ver> AS console` +
-# `COPY --from=console /dist/ webui/dist/` instead of re-running the install+Next export on
-# EVERY cloud release (the ~15-min cache-busted long pole). Console changes far less
-# often than cloud ships, so this moves the build to console's own cadence and turns
-# a cloud rebuild into a registry pull.
-#
-# The Next.js SERVER image (standalone/admin hosts) stays in build-image.yml — this
-# is a separate, additional artifact, not a replacement.
-FROM public.ecr.aws/docker/library/node:24-alpine AS build
-RUN apk add --no-cache git
-WORKDIR /console
-# Heap headroom so the full @hanzo/gui static export never OOMs into a stub; telemetry off.
-ENV NEXT_TELEMETRY_DISABLED=1 NODE_OPTIONS=--max-old-space-size=8192
-# Bake the console.hanzo.ai analytics property (public per-site id) — the SAME default
-# cloud baked at build:embed time, so the embedded console keeps tracking identically.
-# GA4/Pixel stay unset. Public id, not a KMS secret.
-ARG NEXT_PUBLIC_ANALYTICS_WEBSITE_ID=7dce54ee-41f6-4751-96bf-fe005067c7c7
-ENV NEXT_PUBLIC_ANALYTICS_WEBSITE_ID=$NEXT_PUBLIC_ANALYTICS_WEBSITE_ID
-COPY . .
-RUN corepack enable && pnpm install --frozen-lockfile
-# FAIL-HARD: the export MUST emit a real bundle (non-empty out/index.html + out/_next/),
-# never a placeholder shell — same invariant cloud's console stage enforced.
-RUN pnpm build:embed && [ -s out/index.html ] && [ -d out/_next ] \
-    && echo ">> embedded REAL console bundle: $(wc -c < out/index.html)-byte index.html, $(du -sh out/_next | cut -f1) _next/"
-FROM scratch
-COPY --from=build /console/out/ /dist/

LICENSE

@@ -1,14 +1,25 @@
-Licensed under either of
+Copyright (c) 2023--2024 Langfuse GmbH
 
-  * Apache License, Version 2.0 (LICENSE-APACHE or
-    https://www.apache.org/licenses/LICENSE-2.0)
-  * MIT license (LICENSE-MIT or https://opensource.org/licenses/MIT)
+Portions of this software are licensed as follows:
 
-at your option.
+- All content that resides under the "ee/" and/or "web/src/ee" directories of this repository, if these directories exist, is licensed under the license defined in "ee/LICENSE".
+- All third party components incorporated into the Finto Technologies Software are licensed under the original license provided by the owner of the applicable component.
+- Content outside of the above mentioned directories or restrictions above is available under the "MIT Expat" license as defined below.
 
-Unless you explicitly state otherwise, any contribution intentionally
-submitted for inclusion in the work by you, as defined in the Apache-2.0
-license, shall be dual licensed as above, without any additional terms or
-conditions.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-See HIP-0137 (hanzoai/hips) for the standard this follows.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE-APACHE

@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

LICENSE-MIT

@@ -1,33 +0,0 @@
-MIT License
-
-Copyright (c) 2026-present, Hanzo AI, Inc.
-
-Portions of this software are derived from upstream code originally licensed
-under the MIT License, with the following copyright notices retained per its
-terms:
-
-  Copyright (c) 2020 Nate Wienert
-  Copyright (c) 2015-present, Nicolas Gallagher.
-  Copyright (c) 2015-present, Facebook, Inc.
-  Copyright (c) 2021 Radix
-  Copyright (c) 2017 Carmelo Pullara
-  Copyright (c) 2018 Framer B.V.
-  Copyright (c) 2022 WorkOS
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

NOTICE

@@ -1,76 +0,0 @@
-Hanzo Cloud Console (console2)
-Copyright (c) Hanzo AI, Inc. Licensed MIT OR Apache-2.0 (see LICENSE) per HIP-0137.
-
-------------------------------------------------------------------------
-Third-party attribution
-------------------------------------------------------------------------
-
-Observe surface — Langfuse (MIT License)
-
-The console's Observe screens (Traces, Trace detail with the span-tree /
-latency-waterfall, Observations, Sessions, Scores, Score Configs, Datasets,
-Dataset Items, Dataset Runs / Experiments, and the observability Dashboards /
-Metrics) reproduce the SCREEN LAYOUT AND USER FLOWS of Langfuse's observability
-product.
-
-This is a clean-room reimplementation in our own code (React + @hanzo/gui),
-wired to the native Hanzo Cloud /v1/evals contract. No Langfuse source code is
-copied. Only the MIT-licensed layout/flow concepts inform the design; the
-Langfuse EE / commercial ("ee") code is neither used nor referenced.
-
-  Langfuse — https://github.com/langfuse/langfuse
-  Copyright (c) Langfuse GmbH
-  Licensed under the MIT License.
-
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be included in all
-  copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-  SOFTWARE.
-
-------------------------------------------------------------------------
-Vendored MIT-licensed code
-------------------------------------------------------------------------
-
-Portions of this software are derived from upstream MIT-licensed code. Those
-copyright notices are retained here per the MIT License's terms; they were
-previously carried in LICENSE, which is reserved for this project's own
-BSD-3-Clause grant.
-
-  Copyright (c) 2020 Nate Wienert            (Tamagui)
-  Copyright (c) 2015-present, Nicolas Gallagher.  (react-native-web)
-  Copyright (c) 2015-present, Facebook, Inc.      (react-native-web)
-  Copyright (c) 2021 Radix                    (Radix UI)
-  Copyright (c) 2017 Carmelo Pullara
-  Copyright (c) 2018 Framer B.V.              (Framer Motion)
-  Copyright (c) 2022 WorkOS
-
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be included in all
-  copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-  SOFTWARE.

README.md

@@ -1,53 +1,193 @@
-<p align="center"><img src=".github/hero.svg" alt="console2" width="880"></p>
+![Langfuse GitHub Banner](https://github.com/langfuse/langfuse/assets/121163007/6035f0f3-d691-4963-b5d0-10cf506e9d42)
 
-# Hanzo Cloud Console
+<div align="center"><h1>Langfuse: Open Source LLM Engineering Platform</h1></div>
+<div align="center"><h4>LLM Observability, Prompt Management, LLM Evaluations,<br/>Datasets, LLM Metrics, and Prompt Playground</h4></div>
 
-Unified admin console for **Hanzo Cloud** and all Hanzo cloud products. Built on
-[@hanzo/gui](https://gui.hanzo.ai) (cross-platform UI) over the unified `/v1`
-backend (`hanzoai/cloud`). Dark theme, OIDC sign-in via Hanzo IAM.
+<div align="center">
+   <div>
+      <h3>
+         <a href="https://cloud.langfuse.com">
+            <strong>Sign up</strong>
+         </a> · 
+         <a href="https://langfuse.com/docs/deployment/self-host">
+            <strong>Self Host</strong>
+         </a> · 
+         <a href="https://langfuse.com/demo">
+            <strong>Demo (live data)</strong>
+         </a>
+      </h3>
+   </div>
+   <div>
+      <a href="https://langfuse.com/docs"><strong>Docs</strong></a> ·
+      <a href="https://langfuse.com/issues"><strong>Report Bug</strong></a> ·
+      <a href="https://langfuse.com/ideas"><strong>Feature Request</strong></a> ·
+      <a href="https://langfuse.com/changelog"><strong>Changelog</strong></a> ·
+      <a href="https://langfuse.com/roadmap"><strong>Roadmap</strong></a> ·
+      <a href="https://langfuse.com/discord"><strong>Discord</strong></a> 
+   </div>
+   <span>Langfuse uses <a href="https://github.com/orgs/langfuse/discussions"><strong>Github Discussions</strong></a>  for Support and Feature Requests.</span>
+   <br/>
+   <span>We're hiring. <a href="https://langfuse.com/careers"><strong>Join us</strong></a> in Product Engineering and Developer Relations.</span>
+   <br/>
+   <br/>
+   <div>
+      <a href="https://github.com/langfuse/langfuse/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-MIT-red.svg?style=flat-square" alt="MIT License"></a>
+      <a href="https://www.ycombinator.com/companies/langfuse"><img src="https://img.shields.io/badge/Y%20Combinator-W23-orange?style=flat-square" alt="Y Combinator W23"></a>
+      <a href="https://github.com/langfuse/langfuse/pkgs/container/langfuse"><img alt="Docker Image" src="https://img.shields.io/badge/docker-langfuse-blue?logo=Docker&logoColor=white&style=flat-square"></a>
+      <a href="https://pypi.python.org/pypi/langfuse"><img src="https://img.shields.io/pypi/dm/langfuse?style=flat-square&logo=python&logoColor=white&label=pypi%20langfuse&color=blue" alt="langfuse Python package on PyPi"></a>
+      <a href="https://www.npmjs.com/package/langfuse"><img src="https://img.shields.io/npm/dm/langfuse?style=flat-square&logo=npm&logoColor=white&label=npm%20langfuse&color=blue" alt="langfuse npm package"></a>
+   </div>
+</div>
+</br>
 
-Manages: **Providers · Models · Applications · Stores · Chat** — with an
-extensible product-module registry so every cloud product can be added as a
-module.
+## Langfuse Overview
 
-## Quick start
+_Unmute video for voice-over_
+
+https://github.com/langfuse/langfuse/assets/2834609/a94062e9-c782-4ee9-af59-dee6370149a8
+
+### Develop
+
+- **LLM Observability:** Instrument your app and start ingesting traces to Langfuse ([Quickstart](https://langfuse.com/docs/get-started), [Integrations](https://langfuse.com/docs/integrations) [Tracing](https://langfuse.com/docs/tracing))
+- **Langfuse UI:** Inspect and debug complex logs ([Demo](https://langfuse.com/docs/demo), [Tracing](https://langfuse.com/docs/tracing))
+- **Prompt Management:** Manage, version and deploy prompts from within Langfuse ([Prompt Management](https://langfuse.com/docs/prompts/get-started))
+- **Prompt Engineering:** Test and iterate on your prompts with the [LLM Playground](https://langfuse.com/docs/playground)
+
+### Monitor
+
+- **LLM Analytics:** Track metrics (cost, latency, quality) and gain insights from dashboards & data exports ([Analytics](https://langfuse.com/docs/analytics))
+- **LLM Evaluations:** Collect and calculate scores for your LLM completions ([Scores & Evaluations](https://langfuse.com/docs/scores))
+  - Run ([Model-based evaluations](https://langfuse.com/docs/scores/model-based-evals)) and LLM-as-a-Judge within Langfuse
+  - Collect user feedback ([User Feedback](https://langfuse.com/docs/scores/user-feedback))
+  - Manually score LLM outputs in Langfuse ([Manual Scores](https://langfuse.com/docs/scores/manually))
+
+### Test
+
+- **Experiments:** Track and test app behaviour before deploying a new version
+  - Datasets let you test expected in and output pairs and benchmark performance before deploying ([Datasets](https://langfuse.com/docs/datasets))
+  - Track versions and releases in your application ([Experimentation](https://langfuse.com/docs/experimentation), [Prompt Management](https://langfuse.com/docs/prompts))
+
+## Get started
+
+### Langfuse Cloud
+
+Managed deployment by the Langfuse team, generous free-tier (hobby plan), no credit card required.
+
+**[» Langfuse Cloud](https://cloud.langfuse.com)**
+
+## Self-Hosting Open Source LLM Observability with Langfuse
+
+### Localhost (docker)
 
 ```bash
-npm install
-cp .env.example .env.local
-# set NEXT_PUBLIC_IAM_CLIENT_ID for live sign-in; defaults point at production.
-npm run dev          # http://localhost:4000
+# Clone repository
+git clone https://github.com/langfuse/langfuse.git
+cd langfuse
+
+# Run server and database
+docker compose up -d
 ```
 
-## Scripts
+[→ Learn more about deploying locally](https://langfuse.com/docs/deployment/local)
 
-| Script | What |
-| --- | --- |
-| `npm run dev` | Dev server on :4000 |
-| `npm run build` | Production build (type-checks; Gui CSS injected at runtime) |
-| `npm run start` | Serve the production build |
-| `npm run typecheck` | `tsc --noEmit` (strict) |
+### Self-host (docker)
 
-## Configuration
+Langfuse is simple to self-host and keep updated. It currently requires only a single docker container and a postgres database.
+[→ Self Hosting Instructions](https://langfuse.com/docs/deployment/self-host)
 
-All config is `NEXT_PUBLIC_*` (browser app, cookie auth). See `.env.example`.
+Templated deployments: [Railway, GCP, AWS, Azure, Kubernetes and others](https://langfuse.com/docs/deployment/self-host#platform-specific-information)
 
-| Var | Default | Meaning |
-| --- | --- | --- |
-| `NEXT_PUBLIC_CLOUD_URL` | same origin, else `https://api.hanzo.ai` | The ONE Hanzo API endpoint (unified `/v1` backend). Never a per-service API host. |
-| `NEXT_PUBLIC_IAM_URL` | `https://iam.hanzo.ai` | Hanzo IAM OIDC authority |
-| `NEXT_PUBLIC_IAM_APP_NAME` | `hanzo-console` | IAM application (`<org>-<app>`) |
-| `NEXT_PUBLIC_IAM_ORG_NAME` | `hanzo` | IAM organization |
-| `NEXT_PUBLIC_IAM_CLIENT_ID` | — | OAuth client id |
+## Get Started
 
-## Architecture
+### API Keys
 
-See [LLM.md](./LLM.md) for the full design (base choice, /v1 client, auth flow,
-the product-module registry, and the Providers surface). Endpoint reference in
-[docs/endpoints.md](./docs/endpoints.md).
+You need a Langfuse public and secret key to get started. Sign up [here](https://cloud.langfuse.com) and find them in your project settings.
+
+### Ingesting Data · Instrumenting Your Application · LLM Observability with Langfuse
+
+Note: We recommend using our fully async, typed [SDKs](https://langfuse.com/docs/sdk) that allow you to instrument any LLM application with any underlying model. They are available in [Python (Decorators)](https://langfuse.com/docs/sdk/python) & [JS/TS](https://langfuse.com/docs/sdk/typescript). The SDKs will always be the most fully featured and stable way to ingest data into Langfuse.
+
+See the [→ Quickstart](https://langfuse.com/docs/get-started) to integrate Langfuse.
+
+### LLM Observability Integrations
+
+| Integration                                                                  | Supports                   | Description                                                                                                                                      |
+| ---------------------------------------------------------------------------- | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| [SDK](https://langfuse.com/docs/sdk)                                         | Python, JS/TS              | Manual instrumentation using the SDKs for full flexibility.                                                                                      |
+| [OpenAI](https://langfuse.com/docs/integrations/openai)                      | Python, JS/TS              | Automated instrumentation using drop-in replacement of OpenAI SDK.                                                                               |
+| [Langchain](https://langfuse.com/docs/integrations/langchain)                | Python, JS/TS              | Automated instrumentation by passing callback handler to Langchain application.                                                                  |
+| [LlamaIndex](https://langfuse.com/docs/integrations/llama-index/get-started) | Python                     | Automated instrumentation via LlamaIndex callback system.                                                                                        |
+| [Haystack](https://langfuse.com/docs/integrations/haystack)                  | Python                     | Automated instrumentation via Haystack content tracing system.                                                                                   |
+| [LiteLLM](https://langfuse.com/docs/integrations/litellm)                    | Python, JS/TS (proxy only) | Use any LLM as a drop in replacement for GPT. Use Azure, OpenAI, Cohere, Anthropic, Ollama, VLLM, Sagemaker, HuggingFace, Replicate (100+ LLMs). |
+| [Vercel AI SDK](https://langfuse.com/docs/integrations/vercel-ai-sdk)        | JS/TS                      | TypeScript toolkit designed to help developers build AI-powered applications with React, Next.js, Vue, Svelte, Node.js.                          |
+| [API](https://langfuse.com/docs/api)                                         |                            | Directly call the public API. OpenAPI spec available.                                                                                            |
+
+Packages integrated with Langfuse:
+
+| Name                                                            | Description                                                                                                             |
+| --------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| [Instructor](https://langfuse.com/docs/integrations/instructor) | Library to get structured LLM outputs (JSON, Pydantic)                                                                  |
+| [Dify](https://langfuse.com/docs/integrations/dify)             | Open source LLM app development platform with no-code builder.                                                          |
+| [Ollama](https://langfuse.com/docs/integrations/ollama)         | Easily run open source LLMs on your own machine.                                                                        |
+| [Mirascope](https://langfuse.com/docs/integrations/mirascope)   | Python toolkit for building LLM applications.                                                                           |
+| [Flowise](https://langfuse.com/docs/integrations/flowise)       | JS/TS no-code builder for customized LLM flows.                                                                         |
+| [Langflow](https://langfuse.com/docs/integrations/langflow)     | Python-based UI for LangChain, designed with react-flow to provide an effortless way to experiment and prototype flows. |
+
+## Questions and feedback
+
+### Ideas and roadmap
+
+- [Roadmap](https://langfuse.com/roadmap)
+- [GitHub Discussions](https://github.com/orgs/langfuse/discussions)
+- [Feature Requests](https://langfuse.com/ideas)
+
+### Support and feedback
+
+In order of preference the best way to communicate with us:
+
+- [GitHub Discussions](https://github.com/orgs/langfuse/discussions) (preferred): Contribute [ideas](https://langfuse.com/ideas), [support requests](https://langfuse.com/gh-support) and [report bugs](https://langfuse.com/issues)
+- [Discord](https://langfuse.com/discord): community support
+- Privately: contact at langfuse dot com
+
+## Contributing to Langfuse
+
+- Vote on [Ideas](https://github.com/orgs/langfuse/discussions/categories/ideas)
+- Raise and comment on [Issues](https://github.com/langfuse/langfuse/issues)
+- Open a PR - see [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to setup a development environment.
 
 ## License
 
-`MIT OR Apache-2.0` at your option — see [LICENSE](./LICENSE),
-[LICENSE-MIT](./LICENSE-MIT), [LICENSE-APACHE](./LICENSE-APACHE).
-Copyright (c) 2026-present, Hanzo AI, Inc. Estate-wide licensing standard: HIP-0137 (`hanzoai/hips`).
+This repository is MIT licensed, except for the `ee` folders. See [LICENSE](LICENSE) and [docs](https://langfuse.com/docs/open-source) for more details.
+
+## Misc
+
+### GET API to export your data
+
+[**GET routes**](https://langfuse.com/docs/integrations/api) to use data in downstream applications (e.g. embedded analytics). You can also access them conveniently via the SDKs ([docs](https://langfuse.com/docs/query-traces)).
+
+### Security & Privacy
+
+We take data security and privacy seriously. Please refer to our [Security and Privacy](https://langfuse.com/security) page for more information.
+
+### Telemetry
+
+By default, Langfuse automatically reports basic usage statistics of self-hosted instances to a centralized server (PostHog).
+
+This helps us to:
+
+1. Understand how Langfuse is used and improve the most relevant features.
+2. Track overall usage for internal and external (e.g. fundraising) reporting.
+
+None of the data is shared with third parties and does not include any sensitive information. We want to be super transparent about this and you can find the exact data we collect [here](/web/src/features/telemetry/index.ts).
+
+You can opt-out by setting `TELEMETRY_ENABLED=false`.
+
+### Star History
+
+<a href="https://star-history.com/#langfuse/langfuse&Date">
+ <picture>
+   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=langfuse/langfuse&type=Date&theme=dark" />
+   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=langfuse/langfuse&type=Date" />
+   <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=langfuse/langfuse&type=Date" />
+ </picture>
+</a>

SECURITY.md

@@ -0,0 +1,4 @@
+## Security Policy
+We strongly recommend using the latest version of Langfuse to receive all security updates.
+
+For more information, please refer to the [Data Security & Privacy](https://langfuse.com/docs/data-security-privacy) page in the documentation or contact security@langfuse.com.

app/(dashboard)/[...slug]/page.tsx

@@ -1,20 +0,0 @@
-'use client'
-
-import { use } from 'react'
-
-import { ProductRoute } from '~/components/ProductRoute'
-
-/**
- * Catch-all product route. Resolves the module + route from the registry and
- * renders its component via the shared `ProductRoute` (the ONE renderer, also used
- * by the dashboard home for the static embed). Adding a product anywhere in the
- * registry makes its routes live here — no per-product page files.
- *
- * `ProductRoute` applies the two honest gates (sub-page stub, admin "managed by
- * Hanzo" notice), the external-product interstitial, and the per-route error
- * boundary. See that component.
- */
-export default function ProductPage({ params }: { params: Promise<{ slug: string[] }> }) {
-  const { slug } = use(params)
-  return <ProductRoute slug={slug} />
-}

app/(dashboard)/discover/[id]/page.tsx

@@ -1,15 +0,0 @@
-'use client'
-
-import { use } from 'react'
-
-import { ProductInterstitial } from '~/components/products/ProductInterstitial'
-
-/**
- * Product discover screen — `/discover/<id>` renders the interstitial for one
- * catalog entry (docs, OSS source, revenue share, open/get-started). A dedicated
- * route (more specific than the `[...slug]` product catch-all) so it's shareable.
- */
-export default function DiscoverPage({ params }: { params: Promise<{ id: string }> }) {
-  const { id } = use(params)
-  return <ProductInterstitial id={id} />
-}

app/(dashboard)/error.tsx

@@ -1,78 +0,0 @@
-'use client'
-
-/**
- * Dashboard route error backstop (Next App Router).
- *
- * `ProductErrorBoundary` catches throws inside a resolved product module; this
- * catches anything above it in the dashboard page tree (the resolver itself, a
- * non-catch-all dashboard page). It renders in the layout's content slot, so the
- * shell + nav stay mounted — never a white-screened "Application error". Next's
- * `reset()` re-renders the segment; `notFound()`/`redirect()` are control flow and
- * do not reach here.
- */
-import { useEffect } from 'react'
-import { Button, Card, Text, XStack, YStack } from '@hanzo/gui'
-import { RefreshCw, TriangleAlert } from '@hanzogui/lucide-icons-2'
-
-import { reportError } from '~/lib/event'
-import { isChunkLoadError, shouldReloadForChunk, CHUNK_RELOAD_AT_KEY } from '~/components/errors/boundary-logic'
-
-export default function DashboardError({ error, reset }: { error: Error & { digest?: string }; reset: () => void }) {
-  const chunk = isChunkLoadError(error)
-
-  useEffect(() => {
-    console.error('[console] dashboard route error:', error)
-    // A chunk skew self-heals: reload ONCE per window to pull the fresh HTML +
-    // current chunks (same recovery the product boundary does), so a stale-deploy
-    // crash at the segment level auto-recovers instead of stranding a manual card.
-    // A chunk skew is not an app bug, so report only a genuine crash to the ONE stream.
-    if (!chunk) {
-      reportError(error, { digest: error.digest, boundary: 'dashboard' })
-      return
-    }
-    if (typeof window === 'undefined') return
-    try {
-      const raw = window.sessionStorage.getItem(CHUNK_RELOAD_AT_KEY)
-      const last = raw ? Number(raw) : null
-      if (shouldReloadForChunk(Date.now(), last)) {
-        window.sessionStorage.setItem(CHUNK_RELOAD_AT_KEY, String(Date.now()))
-        window.location.reload()
-      }
-    } catch {
-      /* sessionStorage blocked (private mode) — fall through to the manual card */
-    }
-  }, [error, chunk])
-
-  return (
-    <YStack p="$4">
-      <Card borderWidth={1} borderColor="$borderColor" p="$4" gap="$3" maxWidth={640} bg="$color1">
-        <XStack gap="$2" items="center">
-          <TriangleAlert size={16} />
-          <Text fontSize="$4" fontWeight="700">
-            {chunk ? 'Updating to the latest version' : 'This page hit an unexpected error'}
-          </Text>
-        </XStack>
-        <Text fontSize="$3" color="$color11">
-          {chunk
-            ? 'A newer version of the console just shipped. Reload to load the latest.'
-            : 'The rest of the console still works. Try again, or reload the page.'}
-        </Text>
-        <XStack gap="$2">
-          {!chunk ? (
-            <Button size="$2" icon={<RefreshCw size={14} />} onPress={() => reset()}>
-              Try again
-            </Button>
-          ) : null}
-          <Button
-            size="$2"
-            chromeless={!chunk}
-            icon={<RefreshCw size={14} />}
-            onPress={() => { if (typeof window !== 'undefined') window.location.reload() }}
-          >
-            Reload
-          </Button>
-        </XStack>
-      </Card>
-    </YStack>
-  )
-}

app/(dashboard)/layout.tsx

@@ -1,27 +0,0 @@
-import type { ReactNode } from 'react'
-
-import { Preferences } from '~/lib/products/preferences'
-import { Toast } from '~/components/ui/Toast'
-import { Entry } from '~/entry/entry'
-import { Host } from '~/entry/host'
-
-/**
- * The console entry, decomplected (see src/entry/). `Preferences` + `Toast` are the
- * session-tier context: the stage RESOLVER reads the onboarding preference, and the
- * onboard wizard + every module report through Toast — so they sit above the switch.
- * `Host` answers the two effects `@hanzo/ui/product`'s state cards ask for (sign in,
- * add credits), so every card below renders its affordance without being handed one.
- * `Entry` computes ONE stage value from the session and renders EXACTLY one surface
- * (sign-in · waitlist · org · onboard · dashboard).
- */
-export default function DashboardLayout({ children }: { children: ReactNode }) {
-  return (
-    <Preferences>
-      <Toast>
-        <Host>
-          <Entry>{children}</Entry>
-        </Host>
-      </Toast>
-    </Preferences>
-  )
-}

app/(dashboard)/page.tsx

@@ -1,312 +0,0 @@
-'use client'
-
-/**
- * Product catalog — the unified console home. Every Hanzo product, grouped by the
- * ten canonical categories, with its Google Cloud equivalent. Every product is
- * open-for-all: each card opens straight into its native in-console surface and
- * carries a "Learn more" affordance to its docs — there is no enablement gate and
- * no external bounce. Each card can be pinned to the sidebar (persisted to the
- * account). Rendered entirely from the catalog registry.
- */
-import { useEffect, useState } from 'react'
-import { useRouter, usePathname } from 'next/navigation'
-import { Button, Card, Spinner, Text, XStack, YStack } from '@hanzo/gui'
-import { Star, Lock, ArrowRight, BookOpen, KeyRound, Boxes, HandCoins, ExternalLink } from '@hanzogui/lucide-icons-2'
-
-import { config } from '~/config'
-import { shellFor } from '~/lib/products/shell'
-import { visibleCatalogByCategory, categorySlug, type CatalogEntry } from '~/lib/products/registry'
-import { resolveView } from '~/lib/products/match'
-import { ProductRoute } from '~/components/ProductRoute'
-import { openProduct } from '~/lib/products/open'
-import { useFavorites } from '~/lib/products/favorites'
-import { useIsSuperAdmin } from '~/lib/auth/admin'
-import { ProductIcon } from '~/components/ui/ProductIcon'
-import { useProductColors } from '~/lib/products/pins'
-import { livingOverviewModule } from '~/components/products/overview/living/LivingOverviewModule'
-import { ResourceOverview } from '~/components/products/overview/ResourceOverview'
-import { ProductObservability } from '~/components/products/observability/ProductObservability'
-import { FadeIn, PageHeader, type IconLike } from '@hanzo/ui/product'
-
-// The home centerpiece is the reusable LivingOverview (count-up KPIs, live
-// sparklines, streaming activity) — the SAME component every product overview uses.
-const OverviewDashboard = livingOverviewModule('overview')
-
-function ProductCard({
-  entry,
-  pinned,
-  onOpen,
-  onToggle,
-  onLearnMore,
-}: {
-  entry: CatalogEntry
-  pinned: boolean
-  onOpen: () => void
-  onToggle: () => void
-  onLearnMore: () => void
-}) {
-  const Icon = entry.icon
-  return (
-    <Card borderWidth={1} borderColor="$borderColor" p="$4" gap="$3" width={272}>
-      <XStack justify="space-between" items="flex-start">
-        <XStack gap="$2" items="center" flex={1}>
-          <Icon size={20} />
-          <YStack flex={1}>
-            <Text fontSize="$5" fontWeight="700">
-              {entry.label}
-            </Text>
-            {entry.gcp ? (
-              <Text fontSize="$1" color="$color10">
-                {entry.gcp}
-              </Text>
-            ) : null}
-          </YStack>
-        </XStack>
-        <XStack gap="$1" items="center">
-          {entry.admin ? <Lock size={13} opacity={0.45} /> : null}
-          <Button
-            size="$2"
-            chromeless
-            opacity={pinned ? 1 : 0.3}
-            icon={<Star size={15} />}
-            onPress={onToggle}
-            aria-label={pinned ? `Unpin ${entry.label}` : `Pin ${entry.label}`}
-          />
-        </XStack>
-      </XStack>
-
-      <Text fontSize="$3" color="$color11" minH={40}>
-        {entry.description}
-      </Text>
-
-      <XStack justify="space-between" items="center">
-        <Button
-          size="$2"
-          chromeless
-          icon={<BookOpen size={14} />}
-          onPress={onLearnMore}
-          aria-label={`Learn more about ${entry.label}`}
-        >
-          Learn more
-        </Button>
-        <Button
-          size="$2"
-          bg="$color5"
-          borderWidth={1}
-          borderColor="$borderColor"
-          onPress={onOpen}
-          iconAfter={<ArrowRight size={14} />}
-        >
-          Open
-        </Button>
-      </XStack>
-    </Card>
-  )
-}
-
-/**
- * Primary action tile — the ONE presentational card for a top-of-home "first action"
- * (get an API key, deploy an OSS project, earn from your OSS). Prop-driven and pure: a
- * ProductIcon tile (the shared product-color system; omit `color` for the neutral chip),
- * a title, a one-line blurb, and a single CTA. Reused for EVERY primary action so the row
- * stays DRY — add an action by rendering one more tile, never a new card. `external` swaps
- * the CTA's trailing glyph to the new-tab mark; `dataTour` anchors the first-run tour (the
- * API-key tile keeps its `api-key` anchor). No data fetch — a tile is cheap on first paint;
- * anything heavy (e.g. the OSS catalog) lives behind the CTA, loaded only on press.
- */
-function PrimaryActionTile({
-  icon,
-  color,
-  title,
-  description,
-  ctaLabel,
-  external,
-  dataTour,
-  onPress,
-}: {
-  icon: IconLike
-  color?: string
-  title: string
-  description: string
-  ctaLabel: string
-  external?: boolean
-  dataTour?: string
-  onPress: () => void
-}) {
-  return (
-    <Card flex={1} minW={280} borderWidth={1} borderColor="$borderColor" bg="$color2" p="$4" gap="$3" data-tour={dataTour}>
-      <XStack items="center" gap="$3">
-        <ProductIcon icon={icon} color={color} size={40} />
-        <Text fontSize="$5" fontWeight="800" flex={1} numberOfLines={1}>
-          {title}
-        </Text>
-      </XStack>
-      <Text fontSize="$3" color="$color11" minH={40}>
-        {description}
-      </Text>
-      <XStack>
-        {/* Neutral, not filled. These three tiles are PEERS — a menu of things you can
-            do, not a call to action — so three white buttons side by side gave the
-            screen three primaries and therefore none. The one filled action on this
-            page is the getting-started card's active step: the thing to do NEXT. */}
-        <Button
-          size="$3"
-          borderWidth={1}
-          borderColor="$borderColor"
-          iconAfter={external ? <ExternalLink size={15} /> : <ArrowRight size={15} />}
-          onPress={onPress}
-        >
-          {ctaLabel}
-        </Button>
-      </XStack>
-    </Card>
-  )
-}
-
-export default function DashboardHome() {
-  const router = useRouter()
-  const pathname = usePathname()
-  const [mounted, setMounted] = useState(false)
-  const { toggle, isPinned } = useFavorites()
-  const { colorOf } = useProductColors()
-  const showAdmin = useIsSuperAdmin()
-  const push = (path: string) => router.push(path)
-  const groups = visibleCatalogByCategory(showAdmin)
-
-  useEffect(() => setMounted(true), [])
-
-  // Product-shell face (billing.<brand> / sentry.<brand> / an override): the default
-  // route IS the face's home — redirect the catalog home there so people who only ever
-  // see billing.hanzo.ai land on billing, and sentry.hanzo.ai on Issues. ONE redirect
-  // for every face, driven by the shell descriptor.
-  const shellHome = shellFor(config.shell).home
-  useEffect(() => {
-    if (shellHome) router.replace(`/${shellHome}`)
-  }, [router, shellHome])
-
-  // One-binary STATIC embed: cloud serves THIS page's index.html for EVERY deep
-  // link (a static export can't pre-generate arbitrary product slugs), so a direct
-  // load / refresh — or a client nav that hard-falls-back — of /models, /chat,
-  // /tracker … would otherwise render the home instead of the module. Resolve the
-  // LIVE path client-side and hand any real product route to the shared
-  // ProductRoute. Gated on `mounted` so the first client render matches the
-  // server-exported home ("/") — no hydration mismatch; it then swaps to the
-  // resolved module. On a real Next server this page only renders for "/", so
-  // `segments` is empty and the home always shows; an unknown/non-product deep path
-  // (e.g. /category/*, /discover/*) resolves to notfound here and falls through to
-  // the home rather than a hard 404 in the embed.
-  const segments =
-    mounted && pathname ? pathname.replace(/^\/+|\/+$/g, '').split('/').filter(Boolean) : []
-  if (segments.length > 0 && resolveView(segments).kind !== 'notfound') {
-    return <ProductRoute slug={segments} />
-  }
-
-  if (shellHome) {
-    return (
-      <XStack flex={1} justify="center" items="center" p="$8">
-        <Spinner size="large" color="$color11" />
-      </XStack>
-    )
-  }
-
-  return (
-    <YStack gap="$7">
-      {/* Primary actions — the first, most prominent things a signed-in user can do:
-          get an API key, deploy an open-source project (the platform template catalog),
-          and earn from their own OSS (the Authors revenue-share). ONE tile primitive,
-          three uses; wraps to stack on narrow viewports. The Deploy tile opens the
-          external OSS catalog on press — no eager fetch, so first paint stays cheap. */}
-      <XStack flexWrap="wrap" gap="$3">
-        <PrimaryActionTile
-          icon={KeyRound}
-          title="Get your API key"
-          description={`Call ${config.brandName} models from your apps, SDKs, and CLI with a personal key.`}
-          ctaLabel="Get API key"
-          dataTour="api-key"
-          onPress={() => push('/api-keys')}
-        />
-        <PrimaryActionTile
-          icon={Boxes}
-          color={colorOf('store')}
-          title="Deploy OSS"
-          description="Deploy Postgres, n8n, Grafana, Supabase and more — one-click open-source apps on Hanzo Cloud."
-          ctaLabel="Browse the App Store"
-          onPress={() => push('/store')}
-        />
-        <PrimaryActionTile
-          icon={HandCoins}
-          color={colorOf('authors')}
-          title="Earn from your OSS"
-          description="Earn 20% of the compute margin your open-source project drives when organizations run it on Hanzo Cloud — paid to your Hanzo wallet."
-          ctaLabel="Start earning"
-          onPress={() => push('/authors')}
-        />
-      </XStack>
-      <OverviewDashboard params={{}} />
-
-      {/* Observability, front-and-center — the platform's live LLM signals (RED
-          metrics · recent logs · recent traces) on the home, the way Langfuse put
-          its metrics dashboard up top. Reuses the ONE shared ProductObservability
-          panel over the `ai` inference service (honest-empty until o11y emits), and
-          deep-links to the full Observe surface. `data-tour` anchors the first-run
-          tour's Observability step. */}
-      <YStack gap="$3" data-tour="metrics">
-        <XStack
-          self="flex-start"
-          items="center"
-          gap="$2"
-          cursor="pointer"
-          hoverStyle={{ opacity: 0.75 }}
-          onPress={() => push('/o11y')}
-          aria-label="Open Observability"
-        >
-          <Text fontSize="$5" fontWeight="800" color="$color12">
-            Observability
-          </Text>
-          <ArrowRight size={16} opacity={0.5} />
-        </XStack>
-        <ProductObservability service="ai" label="AI inference" />
-      </YStack>
-
-      <ResourceOverview />
-      <YStack gap="$4">
-        <PageHeader
-          title="Explore products"
-          subtitle={`Open and manage every ${config.brandName} product from one place.`}
-        />
-        {groups.map((group, i) => (
-        <FadeIn key={group.category} index={i} style={{ width: '100%' }}>
-          <YStack gap="$3">
-            <XStack
-              self="flex-start"
-              items="center"
-              gap="$2"
-              cursor="pointer"
-              hoverStyle={{ opacity: 0.75 }}
-              onPress={() => push(`/category/${categorySlug(group.category)}`)}
-              aria-label={`${group.category} overview`}
-            >
-              <Text fontSize="$5" fontWeight="800" color="$color12">
-                {group.category}
-              </Text>
-              <ArrowRight size={16} opacity={0.5} />
-            </XStack>
-            <XStack flexWrap="wrap" gap="$3">
-              {group.entries.map((entry) => (
-                <ProductCard
-                  key={entry.id}
-                  entry={entry}
-                  pinned={isPinned(entry.id)}
-                  onOpen={() => openProduct(entry, push)}
-                  onToggle={() => toggle(entry.id)}
-                  onLearnMore={() => push(`/discover/${entry.id}`)}
-                />
-              ))}
-            </XStack>
-          </YStack>
-        </FadeIn>
-        ))}
-      </YStack>
-    </YStack>
-  )
-}

app/accept/page.tsx

@@ -1,232 +0,0 @@
-'use client'
-
-/**
- * /accept — the invitee's landing page for a team invite (PUBLIC, no session).
- *
- * The org admin shares this link (email/OTP delivery isn't wired on this
- * deployment). The invitee opens it, sees the org they've been invited to, sets a
- * password (IAM hashes it server-side — never plaintext), then signs in and lands
- * in that org with the role the admin assigned. Honest states throughout: an
- * invalid/expired link, an already-accepted link, and IAM errors are all truthful,
- * never a fake success.
- */
-import { Suspense, useCallback, useEffect, useState } from 'react'
-import { useRouter, useSearchParams } from 'next/navigation'
-import { Button, Card, Input, Spinner, Text, XStack, YStack } from '@hanzo/gui'
-import { CheckCircle2, ArrowRight, ShieldAlert, UserPlus } from '@hanzogui/lucide-icons-2'
-
-import { MIN_PASSWORD } from '~/lib/server/onboarding'
-
-type Info =
-  | { phase: 'loading' }
-  | { phase: 'error'; message: string }
-  | { phase: 'accepted'; org: string }
-  | { phase: 'form'; org: string; email: string; displayName: string; role: string }
-
-function Center({ children }: { children: React.ReactNode }) {
-  return (
-    <YStack flex={1} minH="100vh" items="center" justify="center" p="$4">
-      {children}
-    </YStack>
-  )
-}
-
-function AcceptFlow() {
-  const router = useRouter()
-  const params = useSearchParams()
-  const token = params?.get('t') ?? ''
-
-  const [info, setInfo] = useState<Info>({ phase: 'loading' })
-  const [password, setPassword] = useState('')
-  const [name, setName] = useState('')
-  const [busy, setBusy] = useState(false)
-  const [err, setErr] = useState<string | null>(null)
-  const [done, setDone] = useState<false | string>(false)
-
-  useEffect(() => {
-    if (!token) {
-      setInfo({ phase: 'error', message: 'This invitation link is missing its token.' })
-      return
-    }
-    let live = true
-    ;(async () => {
-      let res: Response
-      try {
-        res = await fetch(`/console/accept?t=${encodeURIComponent(token)}`, { credentials: 'include' })
-      } catch {
-        if (live) setInfo({ phase: 'error', message: 'Network error — please try again.' })
-        return
-      }
-      const j = (await res.json().catch(() => null)) as
-        | { org?: string; email?: string; displayName?: string; role?: string; accepted?: boolean; error?: string }
-        | null
-      if (!live) return
-      if (!res.ok || !j?.org) {
-        setInfo({ phase: 'error', message: j?.error || 'This invitation link is invalid or has expired.' })
-        return
-      }
-      if (j.accepted) {
-        setInfo({ phase: 'accepted', org: j.org })
-        return
-      }
-      setInfo({ phase: 'form', org: j.org, email: j.email || '', displayName: j.displayName || '', role: j.role || 'member' })
-      setName(j.displayName || '')
-    })()
-    return () => {
-      live = false
-    }
-  }, [token])
-
-  const submit = useCallback(async () => {
-    if (password.length < MIN_PASSWORD) {
-      setErr(`Use a password of at least ${MIN_PASSWORD} characters.`)
-      return
-    }
-    setBusy(true)
-    setErr(null)
-    let res: Response
-    try {
-      res = await fetch('/console/accept', {
-        method: 'POST',
-        credentials: 'include',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ t: token, password, displayName: name.trim() || undefined }),
-      })
-    } catch {
-      setErr('Network error — please try again.')
-      setBusy(false)
-      return
-    }
-    const j = (await res.json().catch(() => null)) as { ok?: boolean; org?: string; error?: string } | null
-    if (!res.ok || !j?.ok) {
-      setErr(j?.error || `Could not activate your account (HTTP ${res.status}).`)
-      setBusy(false)
-      return
-    }
-    setDone(j.org || (info.phase === 'form' ? info.org : ''))
-  }, [password, name, token, info])
-
-  if (done !== false) {
-    return (
-      <Center>
-        <Card p="$5" gap="$4" width={440} maxW="92vw" borderWidth={1} borderColor="$borderColor" bg="$color1" items="center">
-          <CheckCircle2 size={40} color="$green10" />
-          <YStack gap="$1" items="center">
-            <Text fontSize="$7" fontWeight="800">You're in</Text>
-            <Text fontSize="$3" color="$color11" text="center">
-              Your account for <Text color="$color12" fontWeight="700">{done}</Text> is ready. Sign in to continue.
-            </Text>
-          </YStack>
-          <Button
-            size="$4"
-            theme="light"
-            width="100%"
-            iconAfter={<ArrowRight size={16} />}
-            onPress={() => router.push('/signin')}
-          >
-            Sign in
-          </Button>
-        </Card>
-      </Center>
-    )
-  }
-
-  if (info.phase === 'loading') {
-    return (
-      <Center>
-        <Spinner size="large" color="$color11" />
-      </Center>
-    )
-  }
-
-  if (info.phase === 'error') {
-    return (
-      <Center>
-        <Card p="$5" gap="$3" width={440} maxW="92vw" borderWidth={1} borderColor="$borderColor" bg="$color1" items="center">
-          <ShieldAlert size={36} color="$red10" />
-          <Text fontSize="$6" fontWeight="800">Invitation unavailable</Text>
-          <Text fontSize="$3" color="$color11" text="center">{info.message}</Text>
-          <Button size="$3" onPress={() => router.push('/signin')}>Go to sign in</Button>
-        </Card>
-      </Center>
-    )
-  }
-
-  if (info.phase === 'accepted') {
-    return (
-      <Center>
-        <Card p="$5" gap="$3" width={440} maxW="92vw" borderWidth={1} borderColor="$borderColor" bg="$color1" items="center">
-          <CheckCircle2 size={36} color="$green10" />
-          <Text fontSize="$6" fontWeight="800">Already accepted</Text>
-          <Text fontSize="$3" color="$color11" text="center">
-            This invitation to <Text color="$color12" fontWeight="700">{info.org}</Text> was already used. Sign in to continue.
-          </Text>
-          <Button size="$4" theme="light" iconAfter={<ArrowRight size={16} />} onPress={() => router.push('/signin')}>
-            Sign in
-          </Button>
-        </Card>
-      </Center>
-    )
-  }
-
-  return (
-    <Center>
-      <Card p="$5" gap="$4" width={440} maxW="92vw" borderWidth={1} borderColor="$borderColor" bg="$color1">
-        <YStack gap="$2">
-          <XStack gap="$2" items="center">
-            <UserPlus size={20} />
-            <Text fontSize="$7" fontWeight="800">Join {info.org}</Text>
-          </XStack>
-          <Text fontSize="$3" color="$color11">
-            You've been invited to <Text color="$color12" fontWeight="700">{info.org}</Text> as a{' '}
-            <Text color="$color12" fontWeight="700">{info.role}</Text>. Set a password to activate{' '}
-            <Text color="$color12">{info.email}</Text> and sign in.
-          </Text>
-        </YStack>
-
-        <YStack gap="$2">
-          <Text fontSize="$2" color="$color11" fontWeight="600">Your name</Text>
-          <Input value={name} onChangeText={setName} placeholder="Your name" autoCapitalize="words" />
-        </YStack>
-
-        <YStack gap="$2">
-          <Text fontSize="$2" color="$color11" fontWeight="600">Password</Text>
-          <Input
-            value={password}
-            onChangeText={(v) => {
-              setPassword(v)
-              if (err) setErr(null)
-            }}
-            placeholder={`At least ${MIN_PASSWORD} characters`}
-            // secureTextEntry alone does not mask in this @hanzo/gui build; set the
-            // web input type explicitly (RNW passthrough) — same as SignInForm.
-            secureTextEntry
-            {...{ type: 'password' }}
-            autoComplete="new-password"
-            onSubmitEditing={() => void submit()}
-          />
-        </YStack>
-
-        {err ? <Text fontSize="$2" color="$red10">{err}</Text> : null}
-
-        <Button
-          size="$4"
-          theme="light"
-          disabled={busy || password.length < MIN_PASSWORD}
-          iconAfter={busy ? <Spinner color="$color1" /> : <ArrowRight size={16} />}
-          onPress={() => void submit()}
-        >
-          {busy ? 'Activating…' : 'Set password & join'}
-        </Button>
-      </Card>
-    </Center>
-  )
-}
-
-export default function AcceptPage() {
-  return (
-    <Suspense fallback={<Center><Spinner size="large" color="$color11" /></Center>}>
-      <AcceptFlow />
-    </Suspense>
-  )
-}

app/admin/aggregate/[...path]/route.ts

@@ -1,134 +0,0 @@
-/**
- * Server-gated GLOBAL admin aggregate proxy — the cross-tenant business/platform
- * reads (`/v1/admin/{overview,usage,orgs,audit,products,finance,compute,providers}`)
- * AND the few GLOBAL-admin mutations that ride the same god-view gate
- * (`POST /v1/admin/providers/{toggle,primary}` — flip shared-gateway provider
- * routing that affects every org).
- *
- * The admin business board is an ALL-ORGS god view (`?org=all`) over IAM + commerce
- * + o11y. So — unlike the per-tenant `/v1` proxy, which authorizes on the bearer
- * `owner` claim and is safe for any authenticated user — this MUST be gated to a
- * GLOBAL admin BEFORE anything is forwarded: a tenant customer (even one who is
- * `isAdmin` of their own org) must NOT read another org's revenue/spend/customers,
- * must NOT trigger the `org=all` aggregate at all, and must NOT flip a shared
- * provider's enabled/primary state.
- *
- * Defense in depth (RED H1 — the cloud-side gate for `/v1/admin/*` is a separate
- * backend contract we cannot see or test from this repo): `getAdminGate` enforces the
- * SAME policy the IAM/KMS admin proxies use — a VERIFIED `@<brand.adminDomain>` email
- * AND an IAM global-admin flag, fail-closed (→ 403) on any miss. Only then does the
- * shared `forwardWithUserBearer` mint a short-lived user bearer and forward to
- * cloud-api, applying the usual path-traversal + same-origin-CSRF hardening. On a
- * mutating method (POST), that CSRF gate (Sec-Fetch-Site ≠ cross-site AND Origin/
- * Referer host == Host, fail-closed 403 BEFORE resolving the user) means a
- * cross-site page can never flip a provider on the victim admin's behalf. The
- * browser holds no cloud credential and cannot reach this endpoint without passing
- * the gate; the client-side `admin: true` nav gate + `AdminManagedNotice` is UI-only
- * defense-in-depth, never the boundary.
- *
- * Least privilege: only the admin aggregate heads are reachable, NOT `iam`/`kms`
- * (those keep their own gated proxies with their own tenant-scoping semantics) — this
- * is not a general cloud-api tunnel. `allowAdminSurface` admits `v1/admin/<head>[/...]`
- * (the exact forwarded upstream shape), so `providers` covers the GET list and the
- * `providers/{toggle,primary}` POSTs and nothing else. `next.config.mjs` rewrites
- * `/v1/admin/<head>[/...]` here for BOTH GET and POST (dropping the `/v1/` into the
- * internal Next route path); this handler re-adds `v1/` for the upstream cloud call,
- * and the client calls the clean same-origin `/v1/admin/*` form (unchanged).
- */
-import { type NextRequest, NextResponse } from 'next/server'
-
-import { cloudAudience } from '~/config'
-import { getAdminGate } from '~/lib/server/identity'
-import { forwardWithUserBearer } from '~/lib/server/bearer-proxy'
-import { allowAdminSurface } from '~/lib/server/admin-aggregate'
-
-export const runtime = 'nodejs'
-
-const trim = (s: string) => s.replace(/\/+$/, '')
-/** The unified cloud backend (hanzoai/cloud). In-cluster ClusterIP — public egress is CF-403'd.
- *  `|| default` (not `??`) so an env reconciled to an EMPTY string still resolves the service. */
-const CLOUD_API_URL = trim(process.env.CLOUD_API_URL?.trim() || 'http://cloud-api.hanzo.svc.cluster.local:8000')
-
-const forbidden = () => NextResponse.json({ status: 'error', msg: 'forbidden' }, { status: 403 })
-
-type Ctx = { params: Promise<{ path: string[] }> }
-
-async function handle(req: NextRequest, ctx: Ctx): Promise<NextResponse> {
-  // AUTHORIZE FIRST — global-admin only, fail-closed. A non-global-admin (tenant
-  // customer, org-level isAdmin) gets a 403 and never triggers the org=all aggregate.
-  const gate = await getAdminGate(req)
-  if (!gate) return forbidden()
-
-  // The rewrite feeds the tail after `/v1/admin/` (e.g. `overview`, `audit`); rebuild
-  // the FULL cloud path, which is `/v1/admin/<head>` — cloud serves every admin route
-  // under `/v1/admin/*` (the beego `/v1/*` glob in hanzoai/ai + cloud's own
-  // `clients/admin` `app.Get("/v1/admin/…")`), and `forwardWithUserBearer` forwards to
-  // `target/path` VERBATIM (no `/v1` prepend), so the `v1/` MUST be part of the path
-  // here or the request lands on a non-existent bare `/admin/*` and 404s. The rewrite
-  // destination (`app/admin/aggregate/<head>`) is the internal Next route, not the
-  // upstream — it deliberately carries no `v1/`; this handler adds it.
-  // `forwardWithUserBearer` re-validates the exact forwarded path via `allow`
-  // (`allowAdminSurface`, keyed on the `v1/admin/<head>` shape) + `pathIsClean`.
-  const path = `v1/admin/${(await ctx.params).path.join('/')}`.replace(/\/+$/, '')
-  return forwardWithUserBearer(req, {
-    target: CLOUD_API_URL,
-    path,
-    allow: allowAdminSurface,
-    // Scope the minted user bearer to the brand's cloud audience (`<brand>-cloud`).
-    // The operator is a member of the reserved `admin` org, whose OWN app is
-    // `admin-console` — NOT in cloud's audience allowlist — so a default-audience
-    // bearer is rejected (anonymous → 403 on every /v1/admin/*). With the cloud
-    // audience, cloud validates the token and, seeing owner=admin + isAdmin=true,
-    // sets X-User-IsAdmin=true. Host-aware so a lux/zoo admin host scopes to its own
-    // brand cloud audience. (Tenant proxies are unchanged — they omit this.)
-    audience: cloudAudience(req.headers.get('host')),
-    // The AdminApi client unwraps the casibase `{status,msg,data}` envelope, so this
-    // proxy's own 401/404 must speak the same shape (an honest state, never a throw).
-    errorShape: 'casibase',
-    unauthorizedMessage: 'Sign in as an administrator.',
-  })
-}
-
-export async function GET(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-
-/**
- * POST — the GLOBAL-admin mutations that ride the same god-view gate
- * (`/v1/admin/providers/{toggle,primary}`, `/v1/admin/caps` create). Identical
- * path through `getAdminGate` (fail-closed 403) → `forwardWithUserBearer`, which applies
- * the same-origin CSRF check to this mutating method BEFORE resolving the user, streams
- * the JSON body through, and re-validates the path against `allowAdminSurface` (so a POST
- * can only ever reach an allowed head — never `iam`/`kms`, never a traversal).
- */
-export async function POST(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-
-/**
- * PUT — the GLOBAL-admin upserts on the same god-view gate (`PUT /v1/admin/enablement`
- * flip an item off|beta|ga + grant orgs; `PUT /v1/admin/promos` upsert the single
- * platform plan promo). Same gate + same CSRF/traversal hardening as POST;
- * `allowAdminSurface` admits only the declared heads, nothing else.
- */
-export async function PUT(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-
-/**
- * PATCH — the GLOBAL-admin partial edits (`PATCH /v1/admin/caps/:id?org=<slug>`,
- * override an org's usage cap). Same gate + same CSRF/traversal hardening; the `:id`
- * sub-path passes because `allowAdminSurface` admits `v1/admin/caps[/...]`.
- */
-export async function PATCH(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-
-/**
- * DELETE — the GLOBAL-admin removals (`DELETE /v1/admin/caps/:id?org=<slug>`,
- * remove an org's usage cap). Same gate + CSRF/traversal hardening as the other
- * mutating verbs; only an allow-listed head/sub-path is ever reached.
- */
-export async function DELETE(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}

app/admin/iam/[...path]/route.ts

@@ -1,127 +0,0 @@
-/**
- * Server-gated GLOBAL IAM admin proxy — cross-tenant IAM ops (any org).
- *
- * The browser holds no IAM credential. It calls this SAME-ORIGIN route with just
- * its session cookie; the handler enforces the GLOBAL admin gate (`getAdminGate`:
- * verified @<adminDomain> email AND a global-admin flag), then the shared
- * `forwardIam` applies the allow-list + tenant scoping (a global admin may act on
- * any org) and forwards to IAM as the user. A CUSTOMER managing their OWN org uses
- * `/org/iam` instead — this route is global-only.
- *
- * Least privilege: only an explicit allow-list of admin segments is reachable
- * (GET reads / POST mutations); every owner the request references — including
- * the mutation BODY owner — is validated by `forwardIam`.
- */
-import { type NextRequest, NextResponse } from 'next/server'
-
-import { getAdminGate } from '~/lib/server/identity'
-import { forwardIam } from '~/lib/server/iam-proxy'
-
-export const runtime = 'nodejs'
-
-/** Read segments — reachable via GET only. */
-const GET_SEGMENTS = new Set([
-  'get-organizations',
-  'get-organization',
-  'get-users',
-  'get-user',
-  'get-applications',
-  'get-application',
-  'get-providers',
-  'get-provider',
-  'get-roles',
-  'get-records',
-  // Waitlist approval queue (iam#104) — the Pending-Users board reads this. The
-  // /admin/iam gate is already global-admin-only, matching IAM's own
-  // GetPendingUsers auth (global admin or org admin). REUSED, not rebuilt.
-  'get-pending-users',
-])
-
-/**
- * Mutation segments — reachable via POST only (JSON body forwarded).
- *
- * The org-metadata WRITES (`add-organization`/`update-organization`/`delete-organization`)
- * are the DATA-DRIVEN white-label backbone: a tenant IS an org record, and its BRAND
- * (logo / favicon / themeData) is a real writable IAM field on that record. This is
- * how the Tenants board CREATES a tenant and WRITES its brand — no hardcoded brand map.
- * These are safe on THIS proxy because the gate is already GLOBAL-ADMIN-ONLY and
- * `forwardIam` pins the org NAME (`orgNameSegments` below) so the write is scoped
- * (a non-global caller — who can't reach this route anyway — could never retarget
- * another tenant's org via the id or the body `name`).
- */
-const POST_SEGMENTS = new Set([
-  'add-user',
-  'update-user',
-  'delete-user',
-  'add-application',
-  'update-application',
-  'delete-application',
-  'add-provider',
-  'update-provider',
-  'delete-provider',
-  'add-role',
-  'update-role',
-  'delete-role',
-  'add-organization',
-  'update-organization',
-  'delete-organization',
-  // Waitlist approval actions (iam#104) — approve/reject a pending user. Body is
-  // `{id:"owner/name"}`; the global-admin gate + forwardIam's owner scoping apply.
-  'approve-user',
-  'reject-user',
-])
-
-/**
- * Organization objects are owned by IAM's built-in `admin`, and the org
- * list/get endpoints scope results to the caller's org server-side — so `admin`
- * is an acceptable owner THERE (never for tenant data like users/roles). The
- * org-metadata WRITES join it: they operate on the `admin`-owned org record.
- */
-const ORG_ENDPOINTS = new Set([
-  'get-organizations',
-  'get-organization',
-  'add-organization',
-  'update-organization',
-  'delete-organization',
-])
-
-/**
- * Segments carrying an org NAME to guard — a non-global admin can't read/write
- * another org's settings via the `admin` metadata owner. (This route's gate is
- * already global-only, so this is defense-in-depth: it keeps the org-name scoping
- * identical to the `/org/iam` self-service proxy, one policy for both.)
- */
-const ORG_NAME_SEGMENTS = new Set([
-  'get-organization',
-  'update-organization',
-  'delete-organization',
-])
-
-const forbidden = () => NextResponse.json({ error: 'forbidden' }, { status: 403 })
-
-async function handle(req: NextRequest, path: string[], method: 'GET' | 'POST'): Promise<NextResponse> {
-  const gate = await getAdminGate(req)
-  if (!gate) return forbidden()
-  return forwardIam(
-    req,
-    { user: gate.user, isSuperAdmin: gate.user.isSuperAdmin, orgScope: gate.orgScope },
-    {
-      segment: path.join('/'),
-      method,
-      allowed: method === 'GET' ? GET_SEGMENTS : POST_SEGMENTS,
-      orgMetaSegments: ORG_ENDPOINTS,
-      orgNameSegments: ORG_NAME_SEGMENTS,
-      // The gate is already global-only; global admins may write to any org.
-      requireAdminForWrite: false,
-    },
-  )
-}
-
-type Ctx = { params: Promise<{ path: string[] }> }
-
-export async function GET(req: NextRequest, ctx: Ctx) {
-  return handle(req, (await ctx.params).path, 'GET')
-}
-export async function POST(req: NextRequest, ctx: Ctx) {
-  return handle(req, (await ctx.params).path, 'POST')
-}

app/admin/kms/[...path]/route.ts

@@ -1,149 +0,0 @@
-/**
- * Server-gated KMS admin proxy — the ONLY way the browser reaches Hanzo KMS.
- *
- * Same trust boundary as the IAM proxy: the browser sends only its session
- * cookie, this handler enforces the brand-admin gate, then forwards to kmsd as
- * the user (short-lived user-bound bearer) so KMS enforces org isolation from the
- * verified `owner` claim (`canActOnOrg`). Secrets are scoped to the brand org by
- * default; a global admin may target another org with `?org=`.
- *
- * Zero-knowledge discipline: this route NEVER logs a secret value or any request
- * body, and never derives or stores key material — it is a faithful pass-through
- * of kmsd's JSON + status code. One resource path (`/admin/kms/secrets`); the
- * verb + query select the operation:
- *   GET   ?path=&name=&env=   → reveal one value      → GET    .../secrets/<path>/<name>?env=
- *   GET   ?prefix=&env=       → list metadata          → GET    .../secrets?prefix=&env=
- *   POST  {path,name,env,value} → create/upsert        → POST   .../secrets
- *   PATCH ?path=&name= {value,version,env} → rotate    → PATCH  .../secrets/<path>/<name>
- *   DELETE ?path=&name=&env=  → delete                 → DELETE .../secrets/<path>/<name>?env=
- *
- * kmsd has no list endpoint yet — the list GET returns 404, which the KMS module
- * renders as an honest "listing requires kmsd ≥ next release" state.
- */
-import { type NextRequest, NextResponse } from 'next/server'
-
-import { getAdminGate, adminBearer, kmsBaseUrl, type AdminGate } from '~/lib/server/identity'
-import { orgFor as policyOrgFor } from '~/lib/server/admin-policy'
-import { csrfRefusal } from '~/lib/server/bearer-proxy'
-import { fetchWithTimeout } from '~/lib/server/fetch-timeout'
-
-export const runtime = 'nodejs'
-
-const forbidden = () => NextResponse.json({ error: 'forbidden' }, { status: 403 })
-const notFound = () => NextResponse.json({ error: 'not found' }, { status: 404 })
-
-/** `<path>/<name>` for the kmsd route, each segment encoded, slashes preserved. */
-function secretRest(path: string, name: string): string {
-  return [...path.split('/').filter(Boolean), name].map(encodeURIComponent).join('/')
-}
-
-/** Org the operator acts on — the brand org, unless a SuperAdmin passes ?org=
- *  (the pure `admin-policy` predicate, tested in admin-policy.test.ts). */
-function orgFor(gate: AdminGate, req: NextRequest): string {
-  return policyOrgFor(
-    { isSuperAdmin: gate.user.isSuperAdmin, orgScope: gate.orgScope },
-    req.nextUrl.searchParams.get('org'),
-  )
-}
-
-async function handle(req: NextRequest, segments: string[]): Promise<NextResponse> {
-  // CSRF: a cross-site page carrying the admin's auto-sent cookie must never be able
-  // to create / rotate / delete a KMS secret. Refuse a cross-origin MUTATION before
-  // the admin gate or any body read (safe GET reveals pass). Defense in depth on top
-  // of the session cookie's own SameSite attribute.
-  const csrf = csrfRefusal(req)
-  if (csrf) return csrf
-
-  const gate = await getAdminGate(req)
-  if (!gate) return forbidden()
-  if (segments.length !== 1 || segments[0] !== 'secrets') return notFound()
-
-  const org = orgFor(gate, req)
-  // The org travels on the IDENTITY channel, never the URL: cloud's KMS surface
-  // is /v1/kms/secrets and reads the acted-on org from the validated principal
-  // (X-Org-Id — for a SuperAdmin, the switched-into org; the same one-predicate
-  // switch every other subsystem honors). URL-addressed orgs were removed
-  // server-side because a path that names a tenant is caller-selectable.
-  const base = `${kmsBaseUrl()}/v1/kms/secrets`
-  const q = req.nextUrl.searchParams
-  const name = q.get('name') ?? ''
-  const path = q.get('path') ?? ''
-  const env = q.get('env') ?? ''
-
-  let target: string
-  let body: string | undefined
-  if (req.method === 'GET') {
-    if (name) {
-      const params = new URLSearchParams()
-      if (env) params.set('env', env)
-      target = `${base}/${secretRest(path, name)}${params.toString() ? `?${params}` : ''}`
-    } else {
-      const params = new URLSearchParams()
-      const prefix = q.get('prefix')
-      if (prefix) params.set('prefix', prefix)
-      if (env) params.set('env', env)
-      target = `${base}${params.toString() ? `?${params}` : ''}`
-    }
-  } else if (req.method === 'POST') {
-    target = base
-    body = await req.text() // {path,name,env,value} — forwarded verbatim, never logged
-  } else if (req.method === 'PATCH') {
-    if (!name) return notFound()
-    target = `${base}/${secretRest(path, name)}`
-    body = await req.text() // {value,version,env} — forwarded verbatim, never logged
-  } else if (req.method === 'DELETE') {
-    if (!name) return notFound()
-    const params = new URLSearchParams()
-    if (env) params.set('env', env)
-    target = `${base}/${secretRest(path, name)}${params.toString() ? `?${params}` : ''}`
-  } else {
-    return notFound()
-  }
-
-  let bearer: string
-  try {
-    bearer = await adminBearer(gate.user)
-  } catch (e) {
-    return NextResponse.json(
-      { message: `Could not authorize the request: ${e instanceof Error ? e.message : String(e)}` },
-      { status: 502 },
-    )
-  }
-
-  const headers: Record<string, string> = { Authorization: `Bearer ${bearer}`, Accept: 'application/json', 'X-Org-Id': org }
-  const init: RequestInit = { method: req.method, headers, cache: 'no-store' }
-  if (body !== undefined) {
-    headers['Content-Type'] = 'application/json'
-    init.body = body
-  }
-
-  try {
-    const res = await fetchWithTimeout(target, init)
-    const text = await res.text()
-    return new NextResponse(text, {
-      status: res.status,
-      headers: { 'Content-Type': res.headers.get('content-type') ?? 'application/json' },
-    })
-  } catch (e) {
-    // Surface only the transport failure — never the request body/value.
-    return NextResponse.json(
-      { message: `KMS unreachable: ${e instanceof Error ? e.message : String(e)}` },
-      { status: 502 },
-    )
-  }
-}
-
-type Ctx = { params: Promise<{ path: string[] }> }
-
-export async function GET(req: NextRequest, ctx: Ctx) {
-  return handle(req, (await ctx.params).path)
-}
-export async function POST(req: NextRequest, ctx: Ctx) {
-  return handle(req, (await ctx.params).path)
-}
-export async function PATCH(req: NextRequest, ctx: Ctx) {
-  return handle(req, (await ctx.params).path)
-}
-export async function DELETE(req: NextRequest, ctx: Ctx) {
-  return handle(req, (await ctx.params).path)
-}

app/admin/saas/route.ts

@@ -1,81 +0,0 @@
-/**
- * Server-gated GLOBAL-admin proxy for the commerce SaaS-operations god-view
- * (`GET /v1/metrics/saas`) — the cross-tenant revenue / subscription / customer
- * snapshot computed IN commerce (the money system of record). This is the exact
- * console→commerce pattern commerce's own `api/costs` gate documents: the console's
- * OWN global-admin gate runs FIRST, then it forwards with the `COMMERCE_SERVICE_TOKEN`
- * and NO user identity — commerce's `RequirePlatformAdmin` admits that trusted M2M
- * token (Admin bit, empty Subject) for the fleet god-view.
- *
- * Gated fail-closed BEFORE any cross-tenant row is read: `getAdminGate` requires a
- * VERIFIED `@<brand.adminDomain>` email AND an IAM global-admin flag (the SAME gate
- * the IAM/KMS/aggregate admin proxies use), → 403 on any miss. A tenant customer —
- * even one who is `isAdmin` of their OWN org — can never read another org's revenue.
- * The client-side `admin: true` nav gate + module `OperatorAccessRequired` are
- * UI-only defense-in-depth; this server gate is the boundary.
- *
- * The path is FIXED (`/v1/metrics/saas`) — there is no client-controlled path
- * segment, so no traversal surface. Only the allow-listed `window`/`limit` query
- * params are forwarded (validated here), never the raw query string. The commerce
- * SERVICE token comes from server-only env (never `NEXT_PUBLIC_`, never the browser
- * bundle); unset → honest 501 (the board shows "not configured", never a fabricated
- * MRR). The commerce raw JSON is wrapped in the casibase `{status,msg,data}`
- * envelope the admin client (`originGet`) unwraps.
- */
-import { type NextRequest, NextResponse } from 'next/server'
-
-import { getAdminGate } from '~/lib/server/identity'
-import { commerceBaseUrl, commerceServiceToken } from '~/lib/server/billing-proxy'
-import { fetchWithTimeout } from '~/lib/server/fetch-timeout'
-
-export const runtime = 'nodejs'
-
-/** The commerce SaaS god-view — the internal `/v1` bundle path (cloud/costs siblings
- *  live here too), reached directly at the in-cluster commerce address. */
-const METRICS_PATH = '/v1/metrics/saas'
-
-/** The windows commerce accepts; anything else is dropped (commerce defaults 30d). */
-const WINDOWS = new Set(['7d', '30d', '90d', 'mtd', 'all'])
-
-const NO_STORE = 'no-store, must-revalidate'
-const envelope = (msg: string, status: number) =>
-  NextResponse.json({ status: 'error', msg, data: null }, { status, headers: { 'Cache-Control': NO_STORE } })
-
-export async function GET(req: NextRequest): Promise<NextResponse> {
-  // AUTHORIZE FIRST — global-admin only, fail-closed. A non-global-admin never
-  // triggers the cross-tenant commerce walk.
-  const gate = await getAdminGate(req)
-  if (!gate) return envelope('forbidden', 403)
-
-  const token = commerceServiceToken()
-  if (!token) return envelope('SaaS metrics are not configured (COMMERCE_TOKEN missing).', 501)
-
-  // Forward ONLY the allow-listed, validated params — never the raw query string.
-  const q = new URLSearchParams()
-  const window = (req.nextUrl.searchParams.get('window') ?? '').trim()
-  if (WINDOWS.has(window)) q.set('window', window)
-  const limit = Number(req.nextUrl.searchParams.get('limit'))
-  if (Number.isInteger(limit) && limit > 0 && limit <= 200) q.set('limit', String(limit))
-
-  const url = `${commerceBaseUrl()}${METRICS_PATH}${q.toString() ? `?${q}` : ''}`
-  try {
-    const res = await fetchWithTimeout(url, {
-      method: 'GET',
-      headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' },
-      cache: 'no-store',
-      signal: req.signal,
-    })
-    if (!res.ok) {
-      // Forward commerce's status class as an honest error; the board shows the
-      // failure state (never a fabricated snapshot).
-      return envelope(`SaaS metrics upstream returned ${res.status}.`, res.status === 403 ? 403 : 502)
-    }
-    const data = await res.json()
-    return NextResponse.json({ status: 'ok', msg: '', data }, { headers: { 'Cache-Control': NO_STORE } })
-  } catch (e) {
-    // Redact the exception (it carries the internal commerce host/port) — log
-    // server-side only; return a generic client message.
-    console.error('saas-metrics proxy: upstream unreachable:', commerceBaseUrl(), e instanceof Error ? e.message : String(e))
-    return envelope('SaaS metrics upstream is unavailable.', 502)
-  }
-}

app/ai/[...path]/route.ts

@@ -1,145 +0,0 @@
-/**
- * Keyless AI proxy — the ONE path the console uses to reach the model gateway.
- *
- * `/v1/chat/completions` (and friends) REQUIRE an `Authorization: Bearer` token; a
- * browser session cookie alone is rejected. Rather than ship the user's durable
- * `sk-` key to the browser, the console calls its OWN origin at the canonical, prefix-free
- * `/v1/<aihead>` (the /v1-first law); `next.config.mjs` dispatches those heads to THIS `/ai`
- * proxy (re-rooting the upstream at `v1/` — invisible to the client). `forwardWithUserBearer`
- * resolves the user, mints a SHORT-LIVED, user-bound IAM token (shared per-user cache in
- * identity.ts), and forwards to the gateway with that token. No key in the browser, and
- * every call is billed to the user's own org. The response STREAMS through, so
- * `chat/completions` SSE (and the multi-model TTFT measurement) is preserved.
- *
- * Least privilege: only the read/inference AI endpoints are proxied (the ALLOWED
- * allow-list); anything else 404s, so this is not a general gateway tunnel. The RAG
- * retrieval switch (`X-Retrieval`/`X-Retrieval-Store`) is the ONE client-header
- * passthrough (allow-listed in `ai-proxy`).
- */
-import { type NextRequest } from 'next/server'
-
-import { forwardWithUserBearer } from '~/lib/server/bearer-proxy'
-import { retrievalHeaders } from '~/lib/server/ai-proxy'
-
-export const runtime = 'nodejs'
-
-const trim = (s: string) => s.replace(/\/+$/, '')
-/** Gateway the proxied AI calls are forwarded to (gated/priced api.hanzo.ai). */
-const AI_GATEWAY_URL = trim(process.env.AI_GATEWAY_URL ?? 'https://api.hanzo.ai')
-
-/** The exact `/v1/<...>` endpoints the console is allowed to reach. */
-const ALLOWED = new Set([
-  'v1/models',
-  'v1/pricing/models', // the rich model+provider catalog (context, pricing, specs, tier) for Models/Providers pages
-  'v1/plans', // the subscription tiers + entitlements (rpm/tpm/quota) for the catalog plan badges
-  'v1/chat',
-  'v1/chat/completions',
-  'v1/embeddings',
-  'v1/rerank',
-  'v1/audio/speech', // text-to-speech (JSON in → audio bytes out) for the Playground Audio tab
-  'v1/images/generations', // text-to-image (JSON in → image url/b64 out) for the Playground Image tab
-  'v1/videos/generations', // text-to-video CREATE — async: JSON in → a queued job object out (Sora-style)
-  'v1/ai/connections', // AI Login Manager (ai#79/#80): GET list + POST link a BYO provider key (KMS-sealed server-side)
-  'v1/training/clients', // Interactive Training: GET list clients + POST create a LoRA training client (engine plane)
-  'v1/router/policy', // Router: GET the caller's org policy + PUT upsert it (org-admin gated upstream, self-scoped)
-  'v1/router/stats', // Router: the caller org's routing observability aggregate (RequirePrincipal upstream, self-scoped)
-  'v1/get-training-contribution', // Router: the caller org's training opt-in flag (org-admin gated upstream)
-  'v1/update-training-contribution', // Router: set the caller org's training opt-in flag (org-admin gated upstream)
-  'v1/org/settings', // Routing admin: one org's settings row — GET read, PUT upsert (PATCH-merge), DELETE revert (super-admin gated upstream)
-  'v1/org/settings/list', // Routing admin: per-org settings rows (super-admin gated upstream)
-])
-
-/**
- * Async video poll/download sub-paths: GET `/v1/videos/{id}` and
- * `/v1/videos/{id}/content`. Video generation is async (create returns a job id
- * immediately; the client polls the job and then downloads the finished MP4), so
- * the Playground must reach these two dynamic paths in addition to the exact
- * CREATE above. The job id is an opaque `video_<uuid>`; the charset is kept
- * conservative and the pattern is anchored to `v1/videos/`, so this stays a
- * narrow allow-list (the create POST is still only the exact
- * `v1/videos/generations`), never a general gateway tunnel. Method is enforced
- * by the backend (these are GET-only there).
- */
-const VIDEO_JOB_PATH = /^v1\/videos\/[A-Za-z0-9._-]+(?:\/content)?$/
-
-/**
- * Per-provider AI-connection sub-path: `/v1/ai/connections/<provider>` — the
- * disconnect (the AI router maps POST here to the delete). Anchored to the
- * connections head with a conservative provider charset, so it stays a narrow
- * allow-list, never a general tunnel.
- */
-const AI_CONNECTION_PATH = /^v1\/ai\/connections\/[A-Za-z0-9_-]+$/
-
-/**
- * Provider-login OAuth start (ai#85): `/v1/ai/connections/<provider>/authorize`.
- * GET returns the provider consent URL (`?format=json` → `{ authorizeUrl }`) that
- * the console redirects the browser to; the OAuth callback is handled server-side
- * by the backend (KMS-sealed), never through this proxy. Anchored to the
- * connections head with a conservative provider charset — a narrow allow-list, not
- * a general tunnel.
- */
-const AI_CONNECTION_AUTHORIZE_PATH = /^v1\/ai\/connections\/[A-Za-z0-9_-]+\/authorize$/
-
-/**
- * Import a connected account's usage: `/v1/ai/connections/<provider>/usage`. GET only —
- * the org's key is unsealed SERVER-SIDE and the provider's usage/cost API is called there;
- * the browser only reads the normalized ProviderUsage. Anchored to the connections head
- * with a conservative provider charset — a narrow allow-list, not a general tunnel.
- */
-const AI_CONNECTION_USAGE_PATH = /^v1\/ai\/connections\/[A-Za-z0-9_-]+\/usage$/
-
-/**
- * Interactive-training per-client sub-path: `/v1/training/clients/<id>` and its four
- * drive actions — `/forward_backward`, `/optim_step`, `/sample`, `/save_weights`. GET
- * reads a client, DELETE drops it, POST drives the actions. Anchored to the clients
- * head with a conservative id charset (opaque `client_<...>`) and an exact action set,
- * so it stays a narrow allow-list, never a general tunnel. The bare `v1/training/clients`
- * (list/create) is the exact entry above.
- */
-const TRAINING_CLIENT_PATH = /^v1\/training\/clients\/[A-Za-z0-9._-]+(?:\/(?:forward_backward|optim_step|sample|save_weights))?$/
-
-/** Whether a resolved `/v1/<...>` path is reachable through this proxy. */
-function isAllowedAiPath(p: string): boolean {
-  return (
-    ALLOWED.has(p) ||
-    VIDEO_JOB_PATH.test(p) ||
-    AI_CONNECTION_PATH.test(p) ||
-    AI_CONNECTION_AUTHORIZE_PATH.test(p) ||
-    AI_CONNECTION_USAGE_PATH.test(p) ||
-    TRAINING_CLIENT_PATH.test(p)
-  )
-}
-
-type Ctx = { params: Promise<{ path: string[] }> }
-
-function handle(req: NextRequest, ctx: Ctx) {
-  return (async () => {
-    // The client builds a clean `/v1/<aihead>` and `next.config.mjs` dispatches it here
-    // WITHOUT a nested version (destination `/ai/<aihead>`), so the catch-all captures the
-    // sub-path after `/ai/`. Re-root the upstream at `v1/` — the exact path `isAllowedAiPath`
-    // and the gateway see (`v1/chat/completions`, `v1/images/generations`, `v1/ai/connections`).
-    const path = `v1/${(await ctx.params).path.join('/')}`
-    return forwardWithUserBearer(req, {
-      target: AI_GATEWAY_URL,
-      path,
-      allow: isAllowedAiPath,
-      // Forward the RAG retrieval switch when present; the store's org owner is still
-      // resolved server-side from the session (the bearer), never the browser.
-      extraHeaders: retrievalHeaders((h) => req.headers.get(h)),
-      errorShape: 'openai',
-      unauthorizedMessage: 'Sign in to use AI.',
-    })
-  })()
-}
-
-export async function GET(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function POST(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-// DELETE drops an interactive-training client (`/v1/training/clients/<id>`); the
-// same-origin CSRF guard in the bearer proxy gates it like every mutating verb.
-export async function DELETE(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}

app/auth/callback/page.tsx

@@ -1,18 +0,0 @@
-'use client'
-
-/**
- * IAM OAuth callback route. The exchange logic lives in <AuthCallback/> — the SPA fallback
- * also routes `/auth/callback` through <Auth/> (which renders the same component), so
- * both entry points share the ONE handler rather than duplicating the code→token flow.
- */
-import { Suspense } from 'react'
-
-import { AuthCallback } from '~/components/AuthCallback'
-
-export default function CallbackPage() {
-  return (
-    <Suspense fallback={null}>
-      <AuthCallback />
-    </Suspense>
-  )
-}

app/auth/session/route.ts

@@ -1,116 +0,0 @@
-/**
- * /auth/session — the console's OWN durable, refreshable OAuth session (BFF).
- *
- *   POST   establish the console session for the SIGNED-IN user (first-party
- *          confidential-client password grant WITH offline_access → access +
- *          rotating refresh token, sealed into the httpOnly cookies).
- *   GET    the current account resolved from that session (what the Auth reads
- *          FIRST — durable + silently refreshed, so it survives the casibase
- *          session's own lifetime and never bounces the user mid-task).
- *   DELETE sign out — best-effort revoke the refresh token + clear the cookies.
- *
- * SECURITY. POST is GATED: it mints a console session ONLY for a caller who is
- * ALREADY authenticated (a valid casibase/console session — the full login incl. any
- * MFA), AND only when the password grant resolves to the SAME principal — so it can
- * never be driven standalone with a stolen password, and never bypasses MFA (an MFA
- * account never reaches this call). Tokens live only inside the sealed httpOnly
- * cookies — never returned to the browser, never logged, never in a URL.
- */
-import { type NextRequest, NextResponse } from 'next/server'
-
-import { csrfRefusal } from '~/lib/server/bearer-proxy'
-import { resolveUser } from '~/lib/server/identity'
-import {
-  accountOf,
-  applyCookies,
-  clearCookies,
-  consoleSession,
-  passwordGrant,
-  readRefreshToken,
-  revokeRefreshToken,
-  sameSubject,
-  sealSession,
-  sessionConfigured,
-  setCookies,
-  SessionError,
-} from '~/lib/server/session'
-
-export const runtime = 'nodejs'
-
-/** GET — the account + remaining access lifetime from the live console session, or
- *  401 when there is none (the client then falls back to the casibase session). */
-export async function GET(req: NextRequest): Promise<NextResponse> {
-  const sess = consoleSession(req)
-  if (!sess || !sess.claims.name) {
-    return NextResponse.json({ error: 'no session' }, { status: 401 })
-  }
-  return NextResponse.json({ account: accountOf(sess.claims), expiresIn: sess.expiresInSec })
-}
-
-/** POST { username, password } — establish the console session for the signed-in user. */
-export async function POST(req: NextRequest): Promise<NextResponse> {
-  // CSRF: refuse a cross-origin login (login-CSRF fixes the victim into an attacker's
-  // session) before touching credentials.
-  const csrf = csrfRefusal(req)
-  if (csrf) return csrf
-
-  if (!sessionConfigured()) {
-    // No confidential client wired: the console still runs on the casibase session;
-    // report "not configured" so the client silently skips the console session.
-    return NextResponse.json({ error: 'session not configured' }, { status: 501 })
-  }
-
-  let body: { username?: unknown; password?: unknown }
-  try {
-    body = (await req.json()) as typeof body
-  } catch {
-    return NextResponse.json({ error: 'bad request' }, { status: 400 })
-  }
-  const username = typeof body.username === 'string' ? body.username.trim() : ''
-  const password = typeof body.password === 'string' ? body.password : ''
-  if (!username || !password) {
-    return NextResponse.json({ error: 'missing credentials' }, { status: 400 })
-  }
-
-  // GATE: the caller must already be authenticated (they just completed the casibase
-  // login incl. any MFA). This binds the console session to a real, MFA-cleared
-  // session and blocks standalone password abuse.
-  const authed = await resolveUser(req)
-  if (!authed) {
-    return NextResponse.json({ error: 'not authenticated' }, { status: 401 })
-  }
-
-  let tokens
-  try {
-    tokens = await passwordGrant(username, password)
-  } catch (e) {
-    const status = e instanceof SessionError ? e.status : 502
-    return NextResponse.json({ error: 'grant failed' }, { status })
-  }
-
-  const sealed = sealSession(tokens)
-  // The grant MUST resolve to the same principal as the established session — the
-  // console session is for the already-authenticated user, never a third party.
-  const grantId =
-    sealed && sealed.claims.owner && sealed.claims.name ? `${sealed.claims.owner}/${sealed.claims.name}` : ''
-  if (!sealed || !grantId || !sameSubject(grantId, authed.id)) {
-    return NextResponse.json({ error: 'identity mismatch' }, { status: 401 })
-  }
-
-  const res = NextResponse.json({
-    account: accountOf(sealed.claims),
-    expiresIn: Math.floor(sealed.expiresInMs / 1000),
-  })
-  return applyCookies(res, setCookies(sealed.identity, sealed.refresh))
-}
-
-/** DELETE — sign out: best-effort revoke the refresh token, then clear the cookies. */
-export async function DELETE(req: NextRequest): Promise<NextResponse> {
-  // CSRF: refuse a cross-origin forced sign-out.
-  const csrf = csrfRefusal(req)
-  if (csrf) return csrf
-
-  const rt = readRefreshToken(req)
-  if (rt) await revokeRefreshToken(rt)
-  return applyCookies(NextResponse.json({ ok: true }), clearCookies())
-}

app/auth/waitlist/route.ts

@@ -1,31 +0,0 @@
-/**
- * GET /auth/waitlist — the signed-in user's WAITLIST ACCESS + position (BFF).
- *
- * THE shared product-access check. The console shell (Waitlist) reads this to
- * decide whether to render the product or the waitlist status page; hanzo.chat and
- * hanzo.app gate on the SAME underlying `/v1/waitlist/status` for the same user, so
- * a user's access + position are identical across every surface.
- *
- * Resolves the caller's email from their established session (never trusts a
- * client-supplied email), then asks the waitlist plugin. FAIL-OPEN: when the waitlist
- * is unconfigured or unreachable, `waitlistAccess` grants access — the gate is
- * additive and never locks a signed-in user out of a paid product on a blip.
- */
-import { type NextRequest, NextResponse } from 'next/server'
-
-import { resolveUser } from '~/lib/server/identity'
-import { waitlistAccess } from '~/lib/server/waitlist'
-
-export const runtime = 'nodejs'
-
-export async function GET(req: NextRequest): Promise<NextResponse> {
-  const user = await resolveUser(req)
-  if (!user) return NextResponse.json({ error: 'not authenticated' }, { status: 401 })
-
-  // No email on the identity → cannot key a waitlist entry; fail OPEN (don't strand
-  // a valid session behind a gate it can never satisfy).
-  if (!user.email) return NextResponse.json({ hasAccess: true, status: null })
-
-  const { hasAccess, status } = await waitlistAccess(user.email, req.headers.get('host'))
-  return NextResponse.json({ hasAccess, status })
-}

app/console/accept/route.ts

@@ -1,90 +0,0 @@
-/**
- * /console/accept — the invitee's side of the team-invite flow (UNAUTHENTICATED).
- *
- *   GET  ?t=<token>  → validate the sealed invite; report whether the member is
- *                      still PENDING (no password) or already ACTIVATED, plus the
- *                      org + email to show. Never leaks anything a token-holder
- *                      shouldn't already know (the admin put them in the org).
- *   POST { t, password, displayName? } → set the pending member's INITIAL password
- *                      (IAM hashes it — never plaintext) and mark them activated.
- *
- * The sealed token IS the authorization (it names exactly one `org/name`), so this
- * needs no session — the invitee has none yet. It refuses once the member already
- * has a password, so a link can never reset an active member's credential.
- */
-import { type NextRequest, NextResponse } from 'next/server'
-
-import { brandFromHost } from '~/config'
-import { BRANDS } from '~/lib/branding/brands'
-import { csrfRefusal } from '~/lib/server/bearer-proxy'
-import { getMember, memberHasPassword, activateMember, mintConfigured } from '~/lib/server/identity'
-import { readInvite, inviteUserId } from '~/lib/server/invite'
-import { MIN_PASSWORD } from '~/lib/server/onboarding'
-
-export const runtime = 'nodejs'
-
-const bad = (error: string, status: number) => NextResponse.json({ error }, { status })
-
-export async function GET(req: NextRequest): Promise<NextResponse> {
-  const inv = readInvite(req.nextUrl.searchParams.get('t'))
-  if (!inv) return bad('This invitation link is invalid or has expired.', 400)
-
-  const member = await getMember(inviteUserId(inv))
-  if (!member || member.owner !== inv.org) {
-    return bad('This invitation is no longer valid — the member was removed.', 410)
-  }
-  return NextResponse.json({
-    ok: true,
-    org: inv.org,
-    email: member.email || inv.email,
-    displayName: member.displayName || member.name,
-    role: member.isAdmin ? 'admin' : 'member',
-    accepted: memberHasPassword(member),
-  })
-}
-
-export async function POST(req: NextRequest): Promise<NextResponse> {
-  const csrf = csrfRefusal(req)
-  if (csrf) return csrf
-
-  if (!mintConfigured()) {
-    return bad('Invite acceptance is not configured on this deployment.', 501)
-  }
-
-  let body: { t?: unknown; password?: unknown; displayName?: unknown }
-  try {
-    body = (await req.json()) as typeof body
-  } catch {
-    return bad('bad request', 400)
-  }
-  const inv = readInvite(typeof body.t === 'string' ? body.t : null)
-  if (!inv) return bad('This invitation link is invalid or has expired.', 400)
-
-  const password = typeof body.password === 'string' ? body.password : ''
-  if (password.length < MIN_PASSWORD) {
-    return bad(`Use a password of at least ${MIN_PASSWORD} characters.`, 400)
-  }
-  if (/\s/.test(password)) return bad('Password cannot contain spaces.', 400)
-  const displayName = typeof body.displayName === 'string' ? body.displayName.trim() : ''
-
-  const id = inviteUserId(inv)
-  const member = await getMember(id)
-  if (!member || member.owner !== inv.org) {
-    return bad('This invitation is no longer valid — the member was removed.', 410)
-  }
-  // Single-use for activation: refuse if the member already has a credential, so a
-  // stale/re-shared link can never reset an active member's password.
-  if (memberHasPassword(member)) {
-    return bad('This invitation was already accepted. Please sign in.', 409)
-  }
-
-  const brand = BRANDS[brandFromHost(req.headers.get('host'))]
-  const signupApplication = `${brand.id}-cloud`
-
-  try {
-    await activateMember(id, { password, displayName: displayName || undefined, signupApplication })
-  } catch (e) {
-    return bad(`Could not activate the account: ${e instanceof Error ? e.message : String(e)}`, 502)
-  }
-  return NextResponse.json({ ok: true, org: inv.org, email: member.email || inv.email })
-}

app/console/invite-link/route.ts

@@ -1,69 +0,0 @@
-/**
- * POST /console/invite-link — mint a shareable ACCEPT LINK for a pending member.
- *
- * The Team module creates the member row via the `/org/iam` proxy (Dave's own
- * user bearer, Casbin-scoped to his org) — that path is unchanged. This route then
- * mints the sealed, TTL-bound invite token so the invitee can set a password and
- * sign in, WITHOUT any email/OTP (delivery is a link hand-off; IAM `send-invitation`
- * is a documented stub on this deployment).
- *
- * Gate: any authenticated ORG ADMIN, pinned to a member of their OWN org (a global
- * admin may target any org — same policy as the `/org/iam` proxy). The member must
- * actually EXIST in that org (verified via the confidential client) — so an admin
- * can never mint an activation link for someone else's tenant or a phantom user.
- */
-import { type NextRequest, NextResponse } from 'next/server'
-
-import { getOrgGate, getMember } from '~/lib/server/identity'
-import { ownerAllowed, orgWriteAllowed } from '~/lib/server/admin-policy'
-import { csrfRefusal } from '~/lib/server/bearer-proxy'
-import { signInvite, acceptLink, type Invite } from '~/lib/server/invite'
-
-export const runtime = 'nodejs'
-
-const bad = (msg: string, status: number) => NextResponse.json({ error: msg }, { status })
-
-/** The public origin the invitee will open — from the ingress-set Host header. */
-function publicOrigin(req: NextRequest): string {
-  const host = req.headers.get('host') ?? req.nextUrl.host
-  const proto = req.headers.get('x-forwarded-proto') ?? (host.startsWith('localhost') ? 'http' : 'https')
-  return `${proto}://${host}`
-}
-
-export async function POST(req: NextRequest): Promise<NextResponse> {
-  const csrf = csrfRefusal(req)
-  if (csrf) return csrf
-
-  const gate = await getOrgGate(req)
-  if (!gate) return bad('forbidden', 403)
-  // Writes (an invite is one) require org admin — a member can view the roster only.
-  if (!orgWriteAllowed({ isSuperAdmin: gate.isSuperAdmin, isAdmin: gate.user.isAdmin })) {
-    return bad('forbidden', 403)
-  }
-
-  let body: { org?: unknown; name?: unknown; email?: unknown }
-  try {
-    body = (await req.json()) as typeof body
-  } catch {
-    return bad('bad request', 400)
-  }
-  const name = typeof body.name === 'string' ? body.name.trim() : ''
-  const email = typeof body.email === 'string' ? body.email.trim() : ''
-  // The org defaults to the caller's own scope; a SuperAdmin may pass another.
-  const reqOrg = typeof body.org === 'string' && body.org.trim() ? body.org.trim() : gate.orgScope
-  if (!name) return bad('missing member name', 400)
-
-  // Pin the org to the caller's scope (a non-SuperAdmin can only ever mint a link
-  // for their OWN org) — the SAME guard as the /org/iam proxy.
-  if (!ownerAllowed(reqOrg, { isSuperAdmin: gate.isSuperAdmin, orgScope: gate.orgScope, orgMetadataOk: false })) {
-    return bad('forbidden', 403)
-  }
-
-  const id = `${reqOrg}/${name}`
-  const member = await getMember(id)
-  if (!member || member.owner !== reqOrg) return bad('member not found', 404)
-
-  const inv: Invite = { org: reqOrg, name, email: email || member.email || '' }
-  const token = signInvite(inv)
-  return NextResponse.json({ ok: true, org: reqOrg, name, email: inv.email, link: acceptLink(publicOrigin(req), token) })
-}

app/console/mfa/[action]/route.ts

@@ -1,96 +0,0 @@
-/**
- * /console/mfa/<action> — console-native two-factor (TOTP) enrollment BFF.
- *
- * WHY console-native: the console delegated 2FA to hanzo.id's account page, but the
- * custom hanzo.id login worker doesn't establish an IAM account session, so a
- * user who signed in through it lands on an account page that can't manage MFA
- * (setup returns "Unauthorized operation"). This closes that gap: the user enrolls
- * 2FA IN the console. We forward each IAM MFA op as the caller's OWN user bearer
- * (the authz filter authenticates the JWT and Casbin authorizes self-service MFA),
- * with owner/name PINNED to the resolved session user — so a caller can only ever
- * manage THEIR OWN 2FA, never another account's.
- *
- * Actions (POST): initiate · verify · enable · disable — the standard TOTP flow.
- */
-import { type NextRequest, NextResponse } from 'next/server'
-
-import { resolveUser, adminBearer, iamBaseUrl } from '~/lib/server/identity'
-import { csrfRefusal } from '~/lib/server/bearer-proxy'
-import { fetchWithTimeout } from '~/lib/server/fetch-timeout'
-
-export const runtime = 'nodejs'
-
-const TOTP = 'app' // IAM TotpType
-
-/**
- * IAM endpoint + the params each action sends. owner/name are ALWAYS included and
- * pinned to the resolved session user for TWO reasons: (1) the handler targets that
- * user, and (2) the IAM authz filter derives the request OBJECT from `owner`/`name`
- * (query) and grants self-access when it equals the bearer subject — the SAME rule
- * that lets `get-users?owner=<me>` through. We send these as the QUERY STRING with an
- * EMPTY body: the authz filter's object-derivation reads a form body as JSON, so a
- * form-encoded body yields an empty object (→ no self-match → denied); with the
- * params in the query and no body it reads owner/name and the self grant applies.
- */
-const ACTIONS: Record<string, { path: string; params: (u: { owner: string; name: string }, b: Body) => Record<string, string> }> = {
-  initiate: {
-    path: '/v1/iam/mfa/setup/initiate',
-    params: (u) => ({ owner: u.owner, name: u.name, mfaType: TOTP }),
-  },
-  verify: {
-    path: '/v1/iam/mfa/setup/verify',
-    params: (u, b) => ({ owner: u.owner, name: u.name, mfaType: TOTP, passcode: b.passcode ?? '', secret: b.secret ?? '' }),
-  },
-  enable: {
-    path: '/v1/iam/mfa/setup/enable',
-    params: (u, b) => ({ owner: u.owner, name: u.name, mfaType: TOTP, secret: b.secret ?? '', recoveryCodes: b.recoveryCodes ?? '' }),
-  },
-  disable: {
-    path: '/v1/iam/delete-mfa',
-    params: (u) => ({ owner: u.owner, name: u.name }),
-  },
-}
-
-type Body = { passcode?: string; secret?: string; recoveryCodes?: string }
-
-export async function POST(req: NextRequest, ctx: { params: Promise<{ action: string }> }): Promise<NextResponse> {
-  const csrf = csrfRefusal(req)
-  if (csrf) return csrf
-
-  const { action } = await ctx.params
-  const spec = ACTIONS[action]
-  if (!spec) return NextResponse.json({ error: 'unknown action' }, { status: 404 })
-
-  const user = await resolveUser(req)
-  if (!user) return NextResponse.json({ error: 'not authenticated' }, { status: 401 })
-
-  const body = (await req.json().catch(() => ({}))) as Body
-
-  let bearer: string
-  try {
-    bearer = await adminBearer(user)
-  } catch {
-    return NextResponse.json({ status: 'error', msg: 'Could not authorize the request.' }, { status: 502 })
-  }
-
-  // Params ride the QUERY STRING (see ACTIONS doc) with an EMPTY body so the IAM
-  // authz filter derives owner/name for the self-access grant.
-  const qs = new URLSearchParams(spec.params({ owner: user.owner, name: user.name }, body)).toString()
-  try {
-    const res = await fetchWithTimeout(`${iamBaseUrl()}${spec.path}?${qs}`, {
-      method: 'POST',
-      headers: {
-        Authorization: `Bearer ${bearer}`,
-        Accept: 'application/json',
-      },
-      cache: 'no-store',
-    })
-    const text = await res.text()
-    return new NextResponse(text, {
-      status: res.status,
-      headers: { 'Content-Type': res.headers.get('content-type') ?? 'application/json' },
-    })
-  } catch {
-    return NextResponse.json({ status: 'error', msg: 'Identity service is unavailable.' }, { status: 502 })
-  }
-}

app/design/index.css

@@ -1,30 +0,0 @@
-/* ─────────────────────────────────────────────────────────────────────────────
-   Hanzo Design System tokens — the PUBLISHED @hanzo/design package.
-
-   These were vendored under app/design/ (synced 2026-07-24) only because the
-   package was not yet on npm. It is now (@hanzo/design ≥ 0.4.6), so the console
-   reads the real dependency and can no longer drift a border rework behind the
-   rest of the fleet. The token subpaths are named one by one rather than pulling
-   `@hanzo/design/styles.css`: that entry chains relative `@import url(...)`s that
-   Next's CSS pipeline resolves as modules, not sibling files, so the explicit
-   published subpaths are the resolvable form of the same import.
-
-   Fonts are deliberately NOT imported from the package: the console loads the
-   Geist faces via app/fonts.css, and the `:root` shim below lets the vendored
-   typography roles resolve without a second copy.
-   ───────────────────────────────────────────────────────────────────────────── */
-@import '@hanzo/design/tokens/colors.css';
-@import '@hanzo/design/tokens/typography.css';
-@import '@hanzo/design/tokens/spacing.css';
-@import '@hanzo/design/tokens/radius.css';
-@import '@hanzo/design/tokens/elevation.css';
-@import '@hanzo/design/tokens/motion.css';
-@import '@hanzo/design/tokens/z.css';
-
-/* Font families — the console loads the Geist faces via app/fonts.css; these vars
-   let the typography roles (--type-*) resolve without re-importing fonts. */
-:root {
-  --font-sans: 'Geist', 'Geist Sans', ui-sans-serif, system-ui, sans-serif;
-  --font-display: var(--font-sans);
-  --font-mono: 'Geist Mono', ui-monospace, SFMono-Regular, Menlo, monospace;
-}

app/docs/page.tsx

@@ -1,35 +0,0 @@
-'use client'
-
-/**
- * `/docs` → the brand documentation site (docs.hanzo.ai / docs.lux.network / …),
- * resolved CLIENT-side (task #41, "True 1-binary FE").
- *
- * Docs are an EXTERNAL product on their own domain, never an in-app route — so a
- * typed or bookmarked `<console-host>/docs` must land on the real docs, not the
- * catch-all not-found. The old app/docs/route.ts issued a server 308; in the
- * one-binary there is no Next runtime (the static export has no server, and a static
- * export cannot rewrite), so the redirect is resolved from the per-host brand
- * (`config.docsUrl`) in the browser — exactly what the sidebar "Docs" link and the
- * header "?" already open. One way, both topologies (embed + standalone).
- *
- * The target is set in an effect (not during render) so there is no SSR/CSR
- * hydration mismatch on the per-brand host between the build-time default and the
- * real browser host.
- */
-import { useEffect, useState } from 'react'
-
-import { config } from '~/config'
-
-export default function DocsRedirect() {
-  const [url, setUrl] = useState('')
-  useEffect(() => {
-    const target = config.docsUrl
-    setUrl(target)
-    window.location.replace(target)
-  }, [])
-  return (
-    <main style={{ padding: 24, fontFamily: 'system-ui, sans-serif' }}>
-      Opening documentation… {url ? <a href={url}>Continue</a> : null}
-    </main>
-  )
-}

app/fonts.css

@@ -1,30 +0,0 @@
-/* Canonical Hanzo faces — Geist Sans (UI/body/headings) + Geist Mono (code/data).
-   SELF-HOSTED, because a font we serve ourselves is the only kind that arrives.
-
-   These were `@import url('https://cdn.jsdelivr.net/npm/geist@1.3.1/...')`. The import
-   ORDER was fixed once already (an @import emitted after the reset rules is invalid and
-   dropped), but the fonts still never loaded in production: the browser refuses the
-   cross-origin stylesheet (ERR_BLOCKED_BY_ORB), so `document.fonts.size` was 0 on live
-   console.hanzo.ai and every customer read the whole product in system-ui while every
-   rule in the app asked for Geist. A third-party CDN on our own critical render path is
-   also a dependency we do not control.
-
-   One VARIABLE file per family (56K + 58K) spans weights 100-900, so eighteen static
-   cuts collapse to two requests and any weight the design reaches for already exists —
-   no second place to add a face. `font-display: swap` keeps text readable while they
-   load; `local()` lets an installed copy win with no download at all. */
-@font-face {
-  font-family: 'Geist';
-  font-style: normal;
-  font-weight: 100 900;
-  font-display: swap;
-  src: local('Geist'), url('/fonts/Geist-Variable.woff2') format('woff2');
-}
-
-@font-face {
-  font-family: 'Geist Mono';
-  font-style: normal;
-  font-weight: 100 900;
-  font-display: swap;
-  src: local('Geist Mono'), url('/fonts/GeistMono-Variable.woff2') format('woff2');
-}

app/global-error.tsx

@@ -1,107 +0,0 @@
-'use client'
-
-/**
- * Top-level recovery boundary (Next App Router `global-error`).
- *
- * This REPLACES Next's built-in root fallback — the one that renders the bare,
- * dead-ended "Application error: a client-side exception has occurred" and leaves
- * the SPA wedged (no router, so a later in-app nav back to `/` stays dead until a
- * full reload). It is the OUTERMOST boundary: it catches throws in the root layout
- * and anything that bubbles past the segment boundaries — including a chunk-load
- * failure during the very first hydration, which is exactly the "deep-link /
- * refresh a sub-route → crash" the audit hit (a stale-deploy chunk 404s, falls
- * through to the app-shell HTML, and the browser throws parsing HTML as JS).
- *
- * On a chunk skew it SELF-HEALS: one full reload per window pulls the fresh HTML +
- * current chunks. The reload is bounded by the SAME sessionStorage key every other
- * recovery site uses (`CHUNK_RELOAD_AT_KEY`), so a skew that trips several
- * boundaries at once reloads ONCE, never in a loop. For a genuine (non-chunk)
- * crash it shows a minimal, self-contained recovery card — it runs with the root
- * layout torn down, so it owns its own `<html>`/`<body>` and uses inline styles
- * (no GUI provider is mounted here).
- */
-import { useEffect } from 'react'
-
-import { reportError } from '~/lib/event'
-import { isChunkLoadError, shouldReloadForChunk, CHUNK_RELOAD_AT_KEY } from '~/components/errors/boundary-logic'
-
-export default function GlobalError({ error, reset }: { error: Error & { digest?: string }; reset: () => void }) {
-  const chunk = isChunkLoadError(error)
-
-  useEffect(() => {
-    console.error('[console] global error:', error)
-    // The root layout (and its AnalyticsProvider) is torn down here, so this boundary
-    // reports through the module-singleton `eventClient` — the reason it is shared. A
-    // chunk skew self-heals below and is not reported; only a genuine crash is.
-    if (!chunk) {
-      reportError(error, { digest: error.digest, boundary: 'global' })
-      return
-    }
-    if (typeof window === 'undefined') return
-    try {
-      const raw = window.sessionStorage.getItem(CHUNK_RELOAD_AT_KEY)
-      const last = raw ? Number(raw) : null
-      if (shouldReloadForChunk(Date.now(), last)) {
-        window.sessionStorage.setItem(CHUNK_RELOAD_AT_KEY, String(Date.now()))
-        window.location.reload()
-      }
-    } catch {
-      /* sessionStorage blocked (private mode) — fall through to the manual card */
-    }
-  }, [error, chunk])
-
-  return (
-    <html lang="en" style={{ backgroundColor: '#000', colorScheme: 'dark' }}>
-      <body style={{ margin: 0, fontFamily: 'ui-sans-serif, system-ui, -apple-system, sans-serif', color: '#fff', backgroundColor: '#000' }}>
-        <div style={{ minHeight: '100vh', display: 'flex', alignItems: 'center', justifyContent: 'center', padding: 24 }}>
-          <div style={{ maxWidth: 440, width: '100%', border: '1px solid #262626', borderRadius: 12, padding: 24, backgroundColor: '#0a0a0a' }}>
-            <h1 style={{ margin: '0 0 8px', fontSize: 18, fontWeight: 700 }}>
-              {chunk ? 'Updating to the latest version' : 'Something went wrong'}
-            </h1>
-            <p style={{ margin: '0 0 20px', fontSize: 14, lineHeight: 1.5, color: '#a3a3a3' }}>
-              {chunk
-                ? 'A newer version of the console just shipped. Reloading to load the latest…'
-                : 'The console hit an unexpected error. Reload to recover, or return home.'}
-            </p>
-            <div style={{ display: 'flex', gap: 8 }}>
-              {!chunk ? (
-                <button type="button" onClick={() => reset()} style={btn(true)}>
-                  Try again
-                </button>
-              ) : null}
-              <button
-                type="button"
-                onClick={() => { if (typeof window !== 'undefined') window.location.reload() }}
-                style={btn(chunk)}
-              >
-                Reload
-              </button>
-              <button
-                type="button"
-                onClick={() => { if (typeof window !== 'undefined') window.location.assign('/') }}
-                style={btn(false)}
-              >
-                Go home
-              </button>
-            </div>
-          </div>
-        </div>
-      </body>
-    </html>
-  )
-}
-
-/** Inline button style — primary (filled) vs chromeless (bordered). */
-function btn(primary: boolean): React.CSSProperties {
-  return {
-    appearance: 'none',
-    cursor: 'pointer',
-    fontSize: 13,
-    fontWeight: 600,
-    padding: '8px 14px',
-    borderRadius: 8,
-    border: primary ? '1px solid #fff' : '1px solid #333',
-    backgroundColor: primary ? '#fff' : 'transparent',
-    color: primary ? '#000' : '#e5e5e5',
-  }
-}

app/globals.css

@@ -1,635 +0,0 @@
-
-html,
-body,
-#__next {
-  height: 100%;
-}
-
-body {
-  margin: 0;
-  background-color: var(--background, #000000);
-  color: var(--color, #ededf1);
-  font-family: 'Geist', system-ui, -apple-system, sans-serif;
-  /* The base of the ONE type scale. Without this the body inherits the browser's
-     16px root, and every element that does not name a size token — a Gui <Button>
-     label, a bare <span>, anything the ladder does not reach — renders at a size
-     that belongs to no scale. That was the single largest source of type drift in
-     the console: hundreds of nodes painting the retired 16px base beside a 14px
-     one. `--text-base` is the same 14px the Gui `$3` token resolves to
-     (gui.config.ts), so the inherited size and the named size agree. */
-  font-size: var(--text-base, 0.875rem);
-  /* Calm type rendering — crisp, low-glare, comfortable rhythm for a full workday. */
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-  text-rendering: optimizeLegibility;
-  line-height: 1.5;
-  /* Geist ships a full real weight range, so a requested 500/600/700 resolves to a
-     genuine cut — never a browser-fabricated faux-bold/oblique. This bans synthesis
-     outright as a floor. Inherited by every element; the ONE place the product sets it. */
-  font-synthesis: none;
-}
-
-code,
-pre,
-kbd,
-samp {
-  font-family: 'Geist Mono', ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
-}
-
-/* Tabular numerals — metrics, prices, contexts and IDs align on a fixed advance
-   width so columns of numbers read cleanly (the dashboard-grade detail). */
-.hz-tnum {
-  font-variant-numeric: tabular-nums;
-  font-feature-settings: 'tnum' 1;
-}
-
-/* Display headline — a tight, UNITLESS line-height for large type.
-   A Gui font-size token ships a line-height tuned for ONE line, so a display
-   headline overprints itself the moment it wraps (which it always does on a
-   phone). This must live in CSS: React Native Web reads a bare numeric
-   `lineHeight` in a style object as PIXELS, so `lineHeight: 1.1` there crushes
-   the text instead of scaling it. Unitless in real CSS is relative to the
-   element's own font-size, so ONE rule holds at every size token and
-   breakpoint. `className` forwards to the DOM node on web, so a Gui <Text>
-   can wear it. */
-.hz-display {
-  line-height: 1.1;
-}
-
-/* Data/numeric face — Geist Mono + tabular figures for metric values, prices, IDs,
-   counts and code-like tokens. The dashboard-grade "numbers are typeset" detail
-   (Linear/Stripe): stat tiles, table numeric cells and monospace identifiers read
-   as precise, column-aligned data — distinct from Geist prose. One class, whole
-   product. `className` forwards to the DOM node on web, so a Gui <Text> can wear it. */
-.hz-mono {
-  font-family: 'Geist Mono', ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
-  font-variant-numeric: tabular-nums;
-  font-feature-settings: 'tnum' 1;
-  letter-spacing: -0.01em;
-}
-
-* {
-  box-sizing: border-box;
-}
-
-/* Ban faux-bold/oblique EVERYWHERE. Geist ships real weight cuts, so a requested
-   600/700/800/900 must map to a genuine face, never a browser-synthesized smear.
-   Tamagui/RNW inject runtime styles that reset the
-   inherited `font-synthesis` on Text nodes, so a body-level declaration loses —
-   this universal rule (with !important, a true global invariant) wins on every
-   element regardless of insertion order. One place, whole product. */
-*,
-*::before,
-*::after {
-  font-synthesis: none !important;
-}
-
-/* ── Console dark theme — TRUE-BLACK canvas + calm text/borders. The ONE place the
-   console's dark/light palette is set. Overrides the generated @hanzo/gui (Tamagui)
-   theme variables; the `html:root.t_*` selector is one step more specific than the
-   library's runtime `:root.t_*` block so it wins regardless of stylesheet insertion
-   order. DRY: every surface, border and text color in the app reads from these
-   tokens, so this one block sets the whole product.
-
-   Design intent (dark): a TRUE-BLACK #000 canvas (matches hanzo.ai marketing +
-   hanzo.chat OLED) with a Linear/Vercel-caliber surface-depth ladder above it —
-   resting panels #050505, the next surface #0a0a0a, interactive/elevated #171717 →
-   #1f1f1f — so cards read with real depth, never flat voids. Above the surface
-   ladder the CALM neutral scale (color5–12) gives premium, low-glare off-white text
-   and quiet hairline borders (never harsh pure #fff on pure #000). Neutral grey,
-   monochrome-first; text contrast stays WCAG-AA+ on every surface. */
-html:root.t_dark {
-  --background: #000000;
-  --backgroundStrong: #000000;
-  --backgroundHover: #101010;
-  --backgroundPress: #050505;
-  --backgroundFocus: #171717;
-
-  /* Surface depth ladder over the true-black canvas — panels/cards step up from
-     #050505 so they separate cleanly without heavy borders (Linear-grade depth). */
-  --color1: #050505;
-  --color2: #0a0a0a;
-  --color3: #171717;
-  --color4: #1f1f1f;
-  --color5: hsl(0 0% 16%);
-  --color6: hsl(0 0% 22%);
-  --color7: hsl(0 0% 30%);
-  --color8: hsl(0 0% 42%);
-  --color9: hsl(0 0% 55%);
-  --color10: hsl(0 0% 68%);
-  --color11: hsl(0 0% 83%);
-  --color12: hsl(0 0% 95%);
-  --color: #ededed;
-
-  /* Gentle hairlines — present enough to define, quiet enough to disappear on black. */
-  --borderColor: #1f1f1f;
-  --borderColorHover: #333333;
-  --borderColorPress: hsl(0 0% 13%);
-  --borderColorFocus: hsl(0 0% 23%);
-
-  /* Elevation ladder (Material-inspired: ambient + key light). On the true-black
-     canvas a cast shadow alone is nearly invisible, so each level pairs a deep
-     shadow with a faint top highlight + a hairline ring (set on .hz-paper) so a
-     sheet lifts cleanly off black. Brand-neutral — color stays token-driven. */
-  --hz-elevation-1: 0 1px 2px rgba(0, 0, 0, 0.6), 0 1px 1px rgba(0, 0, 0, 0.5);
-  --hz-elevation-2: 0 3px 8px rgba(0, 0, 0, 0.62), 0 1px 3px rgba(0, 0, 0, 0.5);
-  --hz-elevation-3: 0 8px 24px rgba(0, 0, 0, 0.64), 0 2px 6px rgba(0, 0, 0, 0.5);
-  --hz-elevation-4: 0 16px 40px rgba(0, 0, 0, 0.68), 0 6px 14px rgba(0, 0, 0, 0.55);
-  --hz-elevation-5: 0 28px 64px rgba(0, 0, 0, 0.72), 0 12px 24px rgba(0, 0, 0, 0.6);
-  --hz-ring: 0 0 0 1px rgba(255, 255, 255, 0.06);
-  --hz-paper-highlight: inset 0 1px 0 0 rgba(255, 255, 255, 0.05);
-}
-
-/* Light theme — the calm parallel: a neutral off-white base (not stark #fff), soft
-   ink text (not pure black), and quiet hairlines. MONOCHROME by construction — every
-   token is a zero-saturation gray (hue-agnostic), the light twin of the dark ladder,
-   so no surface ever reads a blue/cool tint. Lighter touch than dark, since the
-   console defaults to dark, but kept consistent for the theme toggle. */
-html:root.t_light {
-  --background: hsl(0 0% 99%);
-  --color1: hsl(0 0% 100%);
-  --color2: hsl(0 0% 98%);
-  --color3: hsl(0 0% 95.5%);
-  --color4: hsl(0 0% 92.5%);
-  --color5: hsl(0 0% 89%);
-  --color9: hsl(0 0% 46%);
-  --color10: hsl(0 0% 38%);
-  --color11: hsl(0 0% 22%);
-  --color12: hsl(0 0% 12%);
-  --color: hsl(0 0% 12%);
-  --borderColor: hsl(0 0% 90%);
-  --borderColorHover: hsl(0 0% 82%);
-
-  /* Elevation ladder — light theme: soft NEUTRAL-grey Material shadows (pure black
-     alpha, zero hue) on the off-white base — the calm parallel of the dark ladder. */
-  --hz-elevation-1: 0 1px 2px rgba(0, 0, 0, 0.06), 0 1px 3px rgba(0, 0, 0, 0.1);
-  --hz-elevation-2: 0 3px 8px rgba(0, 0, 0, 0.08), 0 1px 3px rgba(0, 0, 0, 0.06);
-  --hz-elevation-3: 0 10px 24px rgba(0, 0, 0, 0.1), 0 3px 8px rgba(0, 0, 0, 0.07);
-  --hz-elevation-4: 0 18px 40px rgba(0, 0, 0, 0.13), 0 6px 14px rgba(0, 0, 0, 0.08);
-  --hz-elevation-5: 0 28px 60px rgba(0, 0, 0, 0.16), 0 12px 24px rgba(0, 0, 0, 0.1);
-  --hz-ring: 0 0 0 1px rgba(0, 0, 0, 0.05);
-  --hz-paper-highlight: inset 0 1px 0 0 rgba(255, 255, 255, 0.7);
-}
-
-/* Motion — a single fade-up entrance (matches the hanzo.ai marketing feel:
-   ~0.4s ease-out, small upward travel, staggered by the consumer). One place
-   defines it; <FadeIn> applies the class + per-item delay. */
-@keyframes hz-fade-up {
-  from {
-    opacity: 0;
-    transform: translateY(10px);
-  }
-  to {
-    opacity: 1;
-    transform: translateY(0);
-  }
-}
-
-.hz-fade-up {
-  animation: hz-fade-up 0.4s cubic-bezier(0.16, 1, 0.3, 1) both;
-  will-change: transform, opacity;
-}
-
-/* Honor the user's reduced-motion preference — no entrance animation. */
-@media (prefers-reduced-motion: reduce) {
-  .hz-fade-up {
-    animation: none;
-  }
-}
-
-/* Shell chrome motion — the sidebar collapse (width) and the Linear-style
-   two-level nav slide (transform). One place defines the easing; the shell
-   applies the class. `className` forwards to the underlying DOM node on web, so
-   the browser transitions the Gui-driven inline width/transform. */
-.hz-collapse {
-  transition: width 220ms cubic-bezier(0.16, 1, 0.3, 1);
-  will-change: width;
-}
-
-.hz-slide {
-  transition: transform 260ms cubic-bezier(0.16, 1, 0.3, 1);
-  will-change: transform;
-}
-
-/* Backdrop cross-fade behind a SlideOver / dialog. */
-.hz-fade {
-  transition: opacity 240ms cubic-bezier(0.16, 1, 0.3, 1);
-  will-change: opacity;
-}
-
-/* Drag-to-reorder — a pinned row while it is being dragged (pointer DnD). The
-   lifted row gets a subtle lift; siblings ease into place via `.hz-slide`. */
-.hz-drag-item {
-  touch-action: none;
-  transition: transform 180ms cubic-bezier(0.16, 1, 0.3, 1);
-}
-.hz-drag-item[data-dragging='true'] {
-  transition: none;
-  box-shadow: 0 8px 24px rgba(0, 0, 0, 0.28);
-  opacity: 0.96;
-  cursor: grabbing;
-}
-
-@media (prefers-reduced-motion: reduce) {
-  .hz-collapse,
-  .hz-slide,
-  .hz-fade,
-  .hz-drag-item {
-    transition: none;
-  }
-}
-
-/* Sidebar category accordion — a collapsible level-1 section. The body animates
-   its HEIGHT via grid-template-rows 0fr↔1fr (no magic max-height — the row
-   resolves to the real content height) plus a short opacity fade; the header
-   chevron rotates ▸→▾. Collapsed content stays in the DOM (so both directions
-   animate) but is `inert` (out of tab order + a11y tree). One place defines the
-   easing; the shell toggles `data-open`. */
-.hz-acc {
-  display: grid;
-  grid-template-rows: 0fr;
-  transition: grid-template-rows 220ms cubic-bezier(0.16, 1, 0.3, 1);
-}
-.hz-acc[data-open='true'] {
-  grid-template-rows: 1fr;
-}
-.hz-acc-inner {
-  overflow: hidden;
-  min-height: 0;
-  opacity: 0;
-  transition: opacity 180ms ease;
-}
-.hz-acc[data-open='true'] .hz-acc-inner {
-  opacity: 1;
-}
-.hz-chevron {
-  transition: transform 200ms cubic-bezier(0.16, 1, 0.3, 1);
-  will-change: transform;
-}
-@media (prefers-reduced-motion: reduce) {
-  .hz-acc,
-  .hz-acc-inner,
-  .hz-chevron {
-    transition: none;
-  }
-}
-
-/* LivingOverview motion — the "videogame-like" living dashboard. The count-up +
-   live sparkline are driven in JS (rAF, gated by prefers-reduced-motion in the
-   hooks); these are the pure-CSS bits: a loading shimmer, a live-feed pulse, and
-   a brief highlight when a tile's number changes. One place defines the easing. */
-
-/* Skeleton shimmer — an honest "loading", never fabricated content. */
-@keyframes hz-shimmer {
-  0% {
-    background-position: -160px 0;
-  }
-  100% {
-    background-position: 160px 0;
-  }
-}
-
-.hz-skeleton {
-  background-color: var(--color3);
-  background-image: linear-gradient(
-    90deg,
-    transparent 0%,
-    var(--color4) 50%,
-    transparent 100%
-  );
-  background-size: 160px 100%;
-  background-repeat: no-repeat;
-  animation: hz-shimmer 1.2s ease-in-out infinite;
-}
-
-/* Live-feed pulse — the "Live" dot on a streaming panel. */
-@keyframes hz-pulse {
-  0%,
-  100% {
-    opacity: 1;
-    transform: scale(1);
-  }
-  50% {
-    opacity: 0.45;
-    transform: scale(0.82);
-  }
-}
-
-/* Entrance for a freshly-arrived activity row (staggerless — one row at a time). */
-@keyframes hz-row-in {
-  from {
-    opacity: 0;
-    transform: translateY(-6px);
-  }
-  to {
-    opacity: 1;
-    transform: translateY(0);
-  }
-}
-
-.hz-row-in {
-  animation: hz-row-in 0.35s cubic-bezier(0.16, 1, 0.3, 1) both;
-}
-
-@media (prefers-reduced-motion: reduce) {
-  .hz-skeleton {
-    animation: none;
-  }
-  .hz-row-in {
-    animation: none;
-  }
-}
-
-
-/* RailwayDeploy — the deployment pipeline. A smooth flowing gradient marches along the
-   active leg of the track (stroke-dashoffset), a soft halo pulses out from the current
-   station, and the status dot breathes. All reduced-motion-guarded (→ static). One place
-   defines the easing; RailwayDeploy applies the classes. */
-@keyframes hz-rail-flow {
-  to {
-    stroke-dashoffset: -28;
-  }
-}
-.hz-rail-flow {
-  stroke-dasharray: 5 9;
-  animation: hz-rail-flow 0.85s linear infinite;
-}
-
-@keyframes hz-rail-pulse {
-  0% {
-    transform: scale(1);
-    opacity: 0.34;
-  }
-  70% {
-    transform: scale(2.1);
-    opacity: 0;
-  }
-  100% {
-    transform: scale(2.1);
-    opacity: 0;
-  }
-}
-.hz-rail-pulse {
-  transform-box: fill-box;
-  transform-origin: center;
-  animation: hz-rail-pulse 1.7s ease-out infinite;
-}
-
-.hz-rail-dot {
-  animation: hz-pulse 1.5s ease-in-out infinite;
-}
-
-@media (prefers-reduced-motion: reduce) {
-  .hz-rail-flow,
-  .hz-rail-pulse,
-  .hz-rail-dot {
-    animation: none;
-  }
-}
-
-/* DataTable row — the hover fill eases in/out (Tamagui flips the bg instantly;
-   this smooths it to the 140ms ease-out the rest of the product uses). */
-.hz-row {
-  transition: background-color 140ms ease-out;
-}
-@media (prefers-reduced-motion: reduce) {
-  .hz-row {
-    transition: none;
-  }
-}
-
-/* Row-edge pin — the quiet affordance on a search result. It is a REAL, focusable
-   control at all times (opacity, never `display:none`), so the keyboard and a
-   screen reader always reach it; it is simply not drawn until the pointer reaches
-   its row. A pinned or keyboard-selected row opts out of the class entirely, so
-   its pin stays lit — the lit ones are STATE, not chrome.
-   Touch has no hover, so `hover:none` pointers keep it visible: on a phone an
-   invisible control is an absent one.
-   Doubled selector (`:root .hz-pin.hz-pin`, specificity 0,3,0) for the same reason
-   `.hz-paper` is doubled above: Gui injects its compiled style props at `:root ._x-…`
-   (0,2,0), so a plain `.hz-pin` loses and the pin paints at full strength forever. */
-:root .hz-pin.hz-pin {
-  opacity: 0;
-  transition: opacity 140ms ease-out;
-}
-:root .hz-row-pin:hover .hz-pin.hz-pin,
-:root .hz-pin.hz-pin:focus-within,
-:root .hz-pin.hz-pin:hover {
-  opacity: 1;
-}
-@media (hover: none) {
-  :root .hz-pin.hz-pin {
-    opacity: 0.45;
-  }
-}
-@media (prefers-reduced-motion: reduce) {
-  :root .hz-pin.hz-pin {
-    transition: none;
-  }
-}
-
-/* ── Touch targets — WCAG 2.5.5 (AAA) / Apple HIG ≥44px ──────────────────────
-   On phones/tablets (<lg) every control inside the mobile nav drawer must be at
-   least 44px tall to tap reliably. Scoped to `.hz-touch-target` (set on the drawer
-   root only), so the dense DESKTOP sidebar — a separate mount at lg+ that never
-   wears this class — keeps its Linear-grade density. A Gui <Button> renders a real
-   <button>, so this one rule reaches every nav row / control within the drawer.
-   One class, every touch surface (DRY). */
-@media (max-width: 1023.98px) {
-  .hz-touch-target button,
-  .hz-touch-target [role='button'] {
-    min-height: 44px;
-  }
-}
-
-/* ── Chat composer dock — pinned to the viewport bottom on phones/tablets ─────
-   The full-page chat scrolls inside the shell's content scroller; without this the
-   composer sits at the end of a tall welcome/thread and first paints BELOW the fold.
-   Made sticky it rides the bottom edge of the scrollport (the conversation scrolls
-   under it), so the input is always reachable. From lg up the capped, centered
-   column already keeps it in view, so it stays in normal flow. The element carries
-   an opaque background so content scrolls cleanly beneath. */
-@media (max-width: 1023.98px) {
-  .hz-chat-dock {
-    position: sticky;
-    bottom: 0;
-    z-index: var(--z-raised);
-    /* Clear the iOS home indicator when Safari's bottom bar hides (viewport-fit=cover
-       exposes the inset; 0 on devices without one, so no effect elsewhere). */
-    padding-bottom: env(safe-area-inset-bottom);
-  }
-}
-
-/* ── Material paper / 3D elevation ─────────────────────────────────────────────
-   A real depth system for the console's overlay surfaces (drawer, command palette,
-   menus, dialog, support bubble). Layered box-shadow (ambient + key light) read
-   from the per-theme --hz-elevation-* tokens (light AND dark aware). Brand-neutral:
-   the shadow is monochrome and color stays token-driven, so lux/zoo/pars theme
-   cleanly. One place defines the ladder; an overlay wears a class. `className`
-   forwards to the DOM node on web, so a Gui surface can wear these.
-
-   Each selector is written `:root .hz-x.hz-x` on purpose. @hanzo/gui (Tamagui)
-   compiles its own shadow props to an atomic rule it injects at RUNTIME as
-   `:root ._bxsh-…` — specificity (0,2,0). A plain `.hz-paper` is (0,1,0) and loses;
-   `.hz-paper.hz-paper` merely TIES, and a tie is settled by stylesheet order, which
-   runtime injection makes nondeterministic. It lost in practice: an overlay wearing
-   `hz-paper` rendered Tamagui's `0 12px 24px rgba(0,0,0,.33)` instead of this ladder,
-   and on the true-black canvas that shadow is nearly invisible — the sheet did not
-   lift off the page. (0,3,0) wins outright, in either order, with no `!important`. */
-:root .hz-elevation-1.hz-elevation-1 { box-shadow: var(--hz-elevation-1); }
-:root .hz-elevation-2.hz-elevation-2 { box-shadow: var(--hz-elevation-2); }
-:root .hz-elevation-3.hz-elevation-3 { box-shadow: var(--hz-elevation-3); }
-:root .hz-elevation-4.hz-elevation-4 { box-shadow: var(--hz-elevation-4); }
-:root .hz-elevation-5.hz-elevation-5 { box-shadow: var(--hz-elevation-5); }
-
-/* Paper = an elevated sheet: hairline ring + top highlight + a mid cast shadow, so
-   a menu/palette/dialog reads as a physical sheet floating above the page. */
-:root .hz-paper.hz-paper { box-shadow: var(--hz-ring), var(--hz-paper-highlight), var(--hz-elevation-3); }
-:root .hz-paper-4.hz-paper-4 { box-shadow: var(--hz-ring), var(--hz-paper-highlight), var(--hz-elevation-4); }
-:root .hz-paper-5.hz-paper-5 { box-shadow: var(--hz-ring), var(--hz-paper-highlight), var(--hz-elevation-5); }
-
-/* Overlay entrance — a fast, physical scale-fade from the origin (menus, palette,
-   dialog, support sheet). 180ms ease-out enter; the overlay's own unmount handles
-   exit. Reduced-motion → snap (no transform). */
-@keyframes hz-pop-in {
-  from {
-    opacity: 0;
-    transform: translateY(6px) scale(0.985);
-  }
-  to {
-    opacity: 1;
-    transform: translateY(0) scale(1);
-  }
-}
-.hz-pop-in {
-  animation: hz-pop-in 180ms cubic-bezier(0.16, 1, 0.3, 1) both;
-  transform-origin: var(--hz-pop-origin, center);
-  will-change: transform, opacity;
-}
-
-/* Popover MENU entrance — OPACITY-ONLY (never transform). floating-ui positions an
-   anchored menu with an inline `transform: translate(x,y)`, and a CSS-animation that
-   also drives `transform` (like hz-pop-in) OVERRIDES that inline value for the
-   animation's duration — detaching the menu from its trigger. So anchored menus
-   (SelectMenu / ComboBox Popover.Content) fade in with NO transform, keeping the
-   floating-ui anchor exact. The transform-based hz-pop-in stays for the centered
-   Dialog surfaces (CommandPalette / FloatingChat), which are NOT
-   floating-ui-positioned. Reduced-motion → snap. */
-@keyframes hz-menu-in {
-  from {
-    opacity: 0;
-  }
-  to {
-    opacity: 1;
-  }
-}
-.hz-menu-in {
-  animation: hz-menu-in 140ms ease-out both;
-  will-change: opacity;
-}
-
-/* Scrim fade — the dimmed backdrop behind a dialog/palette eases in (Tamagui mounts
-   the overlay instantly otherwise). */
-@keyframes hz-scrim-in {
-  from { opacity: 0; }
-  to { opacity: 1; }
-}
-.hz-scrim-in {
-  animation: hz-scrim-in 160ms ease-out both;
-}
-
-/* Support bubble — a gentle hover lift on the elevated brand-H bubble. */
-.hz-lift {
-  transition:
-    transform 160ms cubic-bezier(0.16, 1, 0.3, 1),
-    box-shadow 160ms cubic-bezier(0.16, 1, 0.3, 1);
-  will-change: transform;
-}
-.hz-lift:hover {
-  transform: translateY(-2px);
-}
-
-/* Hover-paper — a subtle elevation lift on hover for a small affordance (the sidebar
-   brand-H container). Only the H wears this, never the whole row. */
-.hz-hover-paper {
-  transition:
-    box-shadow 160ms ease,
-    transform 160ms cubic-bezier(0.16, 1, 0.3, 1),
-    background-color 140ms ease;
-}
-.hz-hover-paper:hover {
-  box-shadow: var(--hz-elevation-2);
-  transform: translateY(-1px);
-}
-
-@media (prefers-reduced-motion: reduce) {
-  .hz-pop-in,
-  .hz-menu-in,
-  .hz-scrim-in {
-    animation: none;
-  }
-  .hz-lift,
-  .hz-hover-paper {
-    transition: none;
-  }
-  .hz-lift:hover,
-  .hz-hover-paper:hover {
-    transform: none;
-  }
-}
-
-/* ── A11y + responsive hardening ─────────────────────────────────────────────
-   Global floors that hold across every product surface. One place, whole app. */
-
-/* 1. The page body is a hard NO-horizontal-scroll surface. A stray fixed/overwide
-      child (an off-screen drawer mid-transition, a wide table) must clip, never
-      scroll the whole document sideways. `clip` (not `hidden`) does not create a
-      scroll container, so sticky/fixed descendants keep working. */
-html,
-body {
-  overflow-x: clip;
-}
-
-/* 2. Visible keyboard focus, everywhere. `:focus-visible` fires ONLY for keyboard
-      navigation (never a mouse/touch press), so this paints a crisp ring for
-      tab-through without touching pointer interactions. Tamagui focusStyle handles
-      some controls; this is the global floor so nothing is ever focus-invisible.
-      Colour reads from the theme scale, so it adapts in light and dark. */
-:focus-visible {
-  outline: 2px solid var(--color9);
-  outline-offset: 2px;
-  border-radius: 3px;
-}
-:focus:not(:focus-visible) {
-  outline: none;
-}
-
-/* 3. Touch tap targets ≥44px (WCAG 2.5.5 / Apple HIG). On a COARSE pointer
-      (phone/tablet) every top-bar control meets the 44×44 minimum; the desktop
-      mouse density is deliberately left unchanged. Scoped to the top bar so table
-      row-actions and inline chips are untouched. */
-@media (pointer: coarse) {
-  .hz-topbar button {
-    min-height: 44px;
-    min-width: 44px;
-  }
-}
-
-/* 4. ONE typeface per screen. The shared `@hanzogui/shell` chrome (HanzoHeader and
-      its Meet-Hanzo / Products menus, HanzoFooter, HanzoAppHeader, …) sets its own
-      SYSTEM font stack as an INLINE style on its root — `fontFamily: CHROME.font`,
-      i.e. `ui-sans-serif, system-ui, -apple-system, "Segoe UI", …`, which contains no
-      Geist — and its subtree inherits it (the shell's own buttons re-declare
-      `font-family: inherit`). So the logged-out console rendered the header wordmark
-      and nav in the platform's system face while the hero and body below correctly
-      rendered Geist: mixed typography on one screen. Geist itself loads fine (see
-      app/fonts.css) — this is a cascade problem, not a loading one.
-
-      An inline declaration can only be beaten by `!important`, and the rule has to
-      reach descendants because of that `inherit`. Every shell root carries
-      `data-hanzo-shell`, so ONE rule covers the whole set. Code-ish elements keep the
-      mono face declared above, so the two font invariants stay orthogonal. */
-[data-hanzo-shell],
-[data-hanzo-shell] :not(code, pre, kbd, samp) {
-  font-family: var(--font-sans) !important;
-}

app/icon.svg

@@ -1,8 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 67 67" role="img" aria-label="Hanzo">
-<style>path{fill:#000}@media (prefers-color-scheme:dark){path{fill:#fff}}</style>
-<path d="M22.21 67V44.6369H0V67H22.21Z"/>
-<path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z"/>
-<path d="M22.21 0H0V22.3184H22.21V0Z"/>
-<path d="M66.7198 0H44.5098V22.3184H66.7198V0Z"/>
-<path d="M66.7198 67V44.6369H44.5098V67H66.7198Z"/>
-</svg>

app/keys/route.ts

@@ -1,96 +0,0 @@
-/**
- * Per-user `sk-` Cloud API key — the SAME-ORIGIN console route (the fix for the
- * API-keys "sign in to manage API keys" / CORS crack).
- *
- * The browser calls this OWN-origin route (`/keys`) with just its first-party
- * session cookie. This handler resolves the signed-in user from that cookie
- * (`resolveUser`) and mints/reads/revokes the key through IAM as the confidential
- * `hanzo-console` client (`identity.ts` `mintUserKey`/`getUserKey`/`revokeUserKey`,
- * over IAM `mint-user-keys`/`get-user`/`revoke-user-keys` — the WORKING key path,
- * verified live). No credential ever reaches the browser; the `sk-` secret is
- * returned ONLY by POST (show once).
- *
- * Why not `cloud.hanzo.ai/v1/iam/keys` (the old path): that is a DIFFERENT
- * ORIGIN than console.hanzo.ai, so a browser `fetch` is blocked by CORS ("Failed to
- * fetch") — and cloud-api's own keys handler 501s ("IAM client unset") on this
- * deployment anyway. The IAM confidential-client mint the console already uses for
- * `sk-` keys elsewhere (`app/ai` chat) is the ONE authoritative, same-origin,
- * always-working path — so the Org-Settings API-keys surface uses it too (DRY: the
- * exact primitives from `identity.ts`, no new IAM plumbing).
- *
- *   GET    → { hasKey, keyPrefix, createdAt }  (no secret)
- *   POST   → { accessKey }                       (mint/rotate; full sk- shown ONCE)
- *   DELETE → { ok: true }                        (revoke; the old key stops working)
- */
-import { type NextRequest, NextResponse } from 'next/server'
-
-import { resolveUser, mintUserKey, getUserKey, revokeUserKey, mintConfigured } from '~/lib/server/identity'
-import { csrfRefusal } from '~/lib/server/bearer-proxy'
-
-export const runtime = 'nodejs'
-
-const msgOf = (e: unknown) => (e instanceof Error ? e.message : String(e))
-
-/** 401 (not signed in) — the honest state the UI shows to sign in. */
-function unauthorized() {
-  return NextResponse.json({ error: 'Sign in to manage API keys.' }, { status: 401 })
-}
-
-/** GET — the user's current key state (existence + public prefix, NEVER the secret). */
-export async function GET(req: NextRequest) {
-  const user = await resolveUser(req)
-  if (!user) return unauthorized()
-  if (!mintConfigured()) {
-    // Honest, non-leaking: the confidential client isn't wired on this deployment.
-    return NextResponse.json({ error: 'API key management is not configured on this deployment.' }, { status: 501 })
-  }
-  try {
-    const { accessKey, updatedAt } = await getUserKey(user)
-    return NextResponse.json({
-      hasKey: Boolean(accessKey),
-      keyPrefix: accessKey ? accessKey.slice(0, 11) : '',
-      createdAt: updatedAt || '',
-    })
-  } catch (e) {
-    console.error('keys: could not read key state:', msgOf(e))
-    return NextResponse.json({ error: 'Could not read the API key state.' }, { status: 502 })
-  }
-}
-
-/** POST — mint (or rotate) the key. Returns the full `sk-` secret ONCE. */
-export async function POST(req: NextRequest) {
-  // CSRF: minting mutates (and is billable-adjacent) from the auto-sent cookie —
-  // refuse a cross-origin request before any work.
-  const csrf = csrfRefusal(req)
-  if (csrf) return csrf
-  const user = await resolveUser(req)
-  if (!user) return unauthorized()
-  if (!mintConfigured()) {
-    return NextResponse.json({ error: 'API key management is not configured on this deployment.' }, { status: 501 })
-  }
-  try {
-    const accessKey = await mintUserKey(user)
-    return NextResponse.json({ accessKey })
-  } catch (e) {
-    console.error('keys: could not mint key:', msgOf(e))
-    return NextResponse.json({ error: 'Could not create the API key.' }, { status: 502 })
-  }
-}
-
-/** DELETE — revoke the key (the old key stops working; gateway cache ~5m). */
-export async function DELETE(req: NextRequest) {
-  const csrf = csrfRefusal(req)
-  if (csrf) return csrf
-  const user = await resolveUser(req)
-  if (!user) return unauthorized()
-  if (!mintConfigured()) {
-    return NextResponse.json({ error: 'API key management is not configured on this deployment.' }, { status: 501 })
-  }
-  try {
-    await revokeUserKey(user)
-    return NextResponse.json({ ok: true })
-  } catch (e) {
-    console.error('keys: could not revoke key:', msgOf(e))
-    return NextResponse.json({ error: 'Could not revoke the API key.' }, { status: 502 })
-  }
-}

app/layout.tsx

@@ -1,62 +0,0 @@
-import './fonts.css'
-import '@hanzogui/core/reset.css'
-// Hanzo Design System tokens (vendored from hanzoai/design) — the monochrome
-// source of truth. Imported BEFORE globals.css so the console's Tamagui theme can
-// derive its ladder from the design neutral/semantic tokens.
-import './design/index.css'
-// The motion/skeleton classes `@hanzo/ui/product` components emit (`skeleton`,
-// `row`, `tnum`, `fade-up`, `drag`). Console's own markup still names the `hz-`
-// prefixed twins in globals.css below; these are the package's, and without this
-// import a DataTable's skeleton, row hover and tabular figures render unstyled.
-import '@hanzo/ui/styles/motion.css'
-import './globals.css'
-
-import type { Metadata, Viewport } from 'next'
-import type { ReactNode } from 'react'
-import { headers } from 'next/headers'
-
-import { Provider } from '~/components/Provider'
-import { ChunkGuard } from '~/components/ChunkGuard'
-import { BrandTitle } from '~/components/BrandTitle'
-import { resolveConfig } from '~/config'
-
-// The document <title> is SSR metadata, so it must reflect the REQUEST host's
-// brand (console.lux.cloud -> "Lux Cloud Console"), not the build-time default.
-// The visible shell resolves the brand client-side from window.location, but the
-// tab title is server-rendered — without reading the Host header here the browser
-// tab leaks "Hanzo Cloud Console" on Lux/Zoo hosts, a white-label violation.
-//
-// The description is the same metadata read by the same brand, so it resolves the
-// same way. It did not, and shipped `content="Unified admin console for Hanzo Cloud
-// and all cloud products."` to console.lux.cloud and console.zoo.cloud — the title
-// beside it was already correct, which is exactly why nobody noticed. Every
-// brand-visible string in this function comes from `brandName`; adding a literal
-// here re-opens the leak.
-export async function generateMetadata(): Promise<Metadata> {
-  const host = (await headers()).get('host') ?? undefined
-  const { brandName } = resolveConfig(host)
-  return {
-    title: `${brandName} Console`,
-    description: `Unified admin console for ${brandName} and all cloud products.`,
-  }
-}
-
-export const viewport: Viewport = {
-  themeColor: '#000000',
-  // Extend the layout into the display cutout / home-indicator area so the
-  // `env(safe-area-inset-*)` values become non-zero on notched devices — the mobile
-  // drawers + chat composer read them to keep content clear of the notch/indicator.
-  viewportFit: 'cover',
-}
-
-export default function RootLayout({ children }: { children: ReactNode }) {
-  return (
-    <html lang="en" className="t_dark" style={{ backgroundColor: '#000000', colorScheme: 'dark' }} suppressHydrationWarning>
-      <body style={{ margin: 0 }}>
-        <ChunkGuard />
-        <BrandTitle />
-        <Provider>{children}</Provider>
-      </body>
-    </html>
-  )
-}

app/org/iam/[...path]/route.ts

@@ -1,78 +0,0 @@
-/**
- * Server-gated SELF-SERVICE org member proxy — a CUSTOMER managing their OWN org.
- *
- * The `/admin/iam` proxy is GLOBAL-admin only, so a tenant org owner (e.g.
- * Dave/maxpower) could never manage their own members through it. This proxy
- * closes that: it admits ANY authenticated user with an org (`getOrgGate`), then
- * the shared `forwardIam`:
- *   - scopes every reference (query `owner`, `id` owner, and the mutation BODY
- *     owner) to the caller's OWN org — a global admin may cross, a customer never;
- *   - guards get-organization by org NAME (no reading another org's settings);
- *   - requires an ORG ADMIN for writes (invite / change-role / remove), while any
- *     member may READ the roster.
- * IAM enforces its own checks on the user-bound bearer too — this is the matching,
- * fail-closed server gate, not the only one.
- */
-import { type NextRequest, NextResponse } from 'next/server'
-
-import { getOrgGate } from '~/lib/server/identity'
-import { forwardIam } from '~/lib/server/iam-proxy'
-
-export const runtime = 'nodejs'
-
-/** Reads — any member of the org (own org only, unless global). */
-const GET_SEGMENTS = new Set([
-  'get-users',
-  'get-user',
-  'get-roles',
-  'get-organization',
-  // Projects live under the org (IAM-served); the console host's /v1 sends /v1/iam/*
-  // to the cloud binary → 404, so the Projects page routes here (Bearer → IAM).
-  'get-organization-projects',
-])
-
-/** Writes — org admin only, own org only (unless global). */
-const POST_SEGMENTS = new Set([
-  'add-user',
-  'update-user',
-  'delete-user',
-  // Org branding/settings — org-admin only, pinned to the caller's OWN org by both
-  // the `?id` name AND the body name (below), so a brand admin can't retarget another.
-  'update-organization',
-  // Project CRUD — org-admin only (requireAdminForWrite), pinned to the caller's org.
-  'add-project',
-  'delete-project',
-])
-
-/** Org objects are owned by the `admin` metadata org (name guarded separately). */
-const ORG_META = new Set(['get-organization', 'update-organization'])
-/** Segments carrying an org NAME to pin to the caller's scope (read id + write body). */
-const ORG_NAME = new Set(['get-organization', 'update-organization'])
-/** Segments keyed by `organization` (projects) — pin it to the caller's own org so an
- *  omitted/empty organization can't enumerate/pollute across tenants. */
-const ORG_PARAM = new Set(['get-organization-projects', 'add-project', 'delete-project'])
-
-const forbidden = () => NextResponse.json({ error: 'forbidden' }, { status: 403 })
-
-async function handle(req: NextRequest, path: string[], method: 'GET' | 'POST'): Promise<NextResponse> {
-  const gate = await getOrgGate(req)
-  if (!gate) return forbidden()
-  return forwardIam(req, gate, {
-    segment: path.join('/'),
-    method,
-    allowed: method === 'GET' ? GET_SEGMENTS : POST_SEGMENTS,
-    orgMetaSegments: ORG_META,
-    orgNameSegments: ORG_NAME,
-    orgParamSegments: ORG_PARAM,
-    requireAdminForWrite: true,
-  })
-}
-
-type Ctx = { params: Promise<{ path: string[] }> }
-
-export async function GET(req: NextRequest, ctx: Ctx) {
-  return handle(req, (await ctx.params).path, 'GET')
-}
-export async function POST(req: NextRequest, ctx: Ctx) {
-  return handle(req, (await ctx.params).path, 'POST')
-}

app/paas/[...path]/route.ts

@@ -1,128 +0,0 @@
-/**
- * Same-origin proxy to the PaaS control plane (Job 3 — embedded PaaS). The
- * browser calls console2's OWN origin (`/paas/...`); this server-side handler
- * forwards to the ONE Hanzo API endpoint at `/v1/paas/...`, injecting the
- * service token from server-only env (sourced via KMS — never `NEXT_PUBLIC_`,
- * never in the browser bundle). This is the real control-plane API, not an
- * iframe stub.
- *
- * ONE ENDPOINT: there is no per-service API host. `/v1/paas/*` is served by the
- * unified backend behind `api.hanzo.ai` (same `CLOUD_API_URL` every other server
- * proxy here uses — in-cluster in prod, the public gateway everywhere else). It
- * used to aim at `platform.hanzo.ai`, which serves NO `/v1/paas/*` route at all
- * and 401s every `/v1/*` path uniformly, so the board could never load.
- *
- * SECURITY: the forwarded token is a PLATFORM SERVICE token — full control-plane
- * authority, NOT tenant-scoped. So this route is gated to brand admins exactly
- * like the IAM/KMS admin proxies: `getAdminGate` resolves the caller from their
- * own session and requires a verified brand-admin (no gate → 403). Without this,
- * any authenticated browser could drive the whole control plane through the
- * service token. The gate is the control, NOT a deploy-time env toggle.
- *
- * When `PAAS_SERVICE_TOKEN` is unset the proxy returns an honest 501 so the UI
- * can show a truthful "not configured" state — it never fabricates apps/deploys.
- *
- * SCOPE: the browser stamps the active tenant path (X-Org-Id / X-Project-Id /
- * X-Environment) on every call. We forward it to the control plane so PaaS
- * resources scope by org → project → environment like the rest of the console —
- * but the ORG is re-resolved server-side through the admin policy (`orgFor`): a
- * global admin's switched org is honored, a brand admin is PINNED to their own,
- * so the forwarded X-Org-Id is authoritative and never the spoofable claim.
- * Project + environment are sub-scopes the admin picks WITHIN that org, passed
- * through verbatim.
- */
-import { type NextRequest, NextResponse } from 'next/server'
-
-import { getAdminGate } from '~/lib/server/identity'
-import { orgFor as policyOrgFor } from '~/lib/server/admin-policy'
-import { csrfRefusal } from '~/lib/server/bearer-proxy'
-import { fetchWithTimeout } from '~/lib/server/fetch-timeout'
-
-export const runtime = 'nodejs'
-
-const API_URL = (process.env.CLOUD_API_URL ?? 'https://api.hanzo.ai').replace(/\/+$/, '')
-const TOKEN = process.env.PAAS_SERVICE_TOKEN ?? ''
-
-async function forward(req: NextRequest, path: string[]): Promise<NextResponse> {
-  // CSRF FIRST — the service token below is control-plane god-mode, so a cross-site
-  // page carrying the admin's auto-sent cookie must never drive a deploy/scale/delete.
-  // Refuse a cross-origin MUTATION before the admin gate or any body read (safe reads
-  // pass). Defense in depth on top of the session cookie's own SameSite attribute.
-  const csrf = csrfRefusal(req)
-  if (csrf) return csrf
-
-  // Brand-admin gate — the service token below is control-plane god-mode.
-  const gate = await getAdminGate(req)
-  if (!gate) {
-    return NextResponse.json({ error: 'forbidden' }, { status: 403 })
-  }
-  if (!TOKEN) {
-    return NextResponse.json(
-      { error: 'PaaS control plane is not configured (PAAS_SERVICE_TOKEN missing).' },
-      { status: 501 },
-    )
-  }
-  // Resolve the authoritative tenant path. Org: the admin policy honors a
-  // SuperAdmin's switched org (the X-Org-Id the browser sends = currentOrg()) and pins
-  // a brand admin to their own — so we forward the resolved org, never the raw
-  // claim. Project + environment are sub-scopes within that org, forwarded as-is.
-  const org = policyOrgFor(
-    { isSuperAdmin: gate.user.isSuperAdmin, orgScope: gate.orgScope },
-    req.headers.get('X-Org-Id'),
-  )
-  const projectId = req.headers.get('X-Project-Id')
-  const environment = req.headers.get('X-Environment')
-
-  const search = req.nextUrl.search
-  // `/paas/<x>` → `/v1/paas/<x>`. The control plane mounts under `/v1/paas`; this
-  // route prefixed only `/v1`, so every call landed on a path that does not exist
-  // (`/paas/apps` → `/v1/apps` → 404) and the board rendered nothing. The name is
-  // 1:1 on both sides: this proxy is the PaaS plane, so it forwards to the PaaS
-  // plane. It aimed at `/v1/<x>` because that IS where the standalone Node platform
-  // served apps; the plane moved into cloud under `/v1/paas` and the path did not.
-  const url = `${API_URL}/v1/paas/${path.join('/')}${search}`
-  const init: RequestInit = {
-    method: req.method,
-    headers: {
-      Authorization: `Bearer ${TOKEN}`,
-      'Content-Type': 'application/json',
-      Accept: 'application/json',
-      'X-Org-Id': org,
-      ...(projectId ? { 'X-Project-Id': projectId } : {}),
-      ...(environment ? { 'X-Environment': environment } : {}),
-    },
-    // Never cache control-plane reads.
-    cache: 'no-store',
-  }
-  if (req.method !== 'GET' && req.method !== 'HEAD') {
-    init.body = await req.text()
-  }
-  try {
-    const res = await fetchWithTimeout(url, init)
-    const text = await res.text()
-    return new NextResponse(text, {
-      status: res.status,
-      headers: { 'Content-Type': res.headers.get('content-type') ?? 'application/json' },
-    })
-  } catch (e) {
-    return NextResponse.json(
-      { error: `PaaS upstream unreachable: ${e instanceof Error ? e.message : String(e)}` },
-      { status: 502 },
-    )
-  }
-}
-
-type Ctx = { params: Promise<{ path: string[] }> }
-
-export async function GET(req: NextRequest, ctx: Ctx) {
-  return forward(req, (await ctx.params).path)
-}
-export async function POST(req: NextRequest, ctx: Ctx) {
-  return forward(req, (await ctx.params).path)
-}
-export async function PATCH(req: NextRequest, ctx: Ctx) {
-  return forward(req, (await ctx.params).path)
-}
-export async function DELETE(req: NextRequest, ctx: Ctx) {
-  return forward(req, (await ctx.params).path)
-}

app/signin/page.tsx

@@ -1,13 +0,0 @@
-'use client'
-
-/**
- * Sign-in route. The whole experience (tenant credential form / admin silent SSO)
- * lives in the shared `<SignIn/>` component, which `Auth` also renders — so a
- * direct `/signin` load resolves to the form whether it mounts this route or the
- * dashboard shell (the deploy serves the SPA shell for every path).
- */
-import { SignIn } from '~/components/SignIn'
-
-export default function SignInPage() {
-  return <SignIn />
-}

app/system-status/route.ts

@@ -1,43 +0,0 @@
-/**
- * /system-status — same-origin BFF for the global status badge.
- *
- * status.<brand> (Gatus) serves its JSON at `/api/v1/endpoints/statuses` with NO
- * CORS header, so the browser can't read it cross-origin. This route fetches it
- * SERVER-SIDE (no CORS) and returns a small overall summary the badge renders
- * natively — the console's established BFF pattern (no iframe, no third-party
- * script). Public health data only; no auth, no secrets.
- *
- * Fail-soft by construction: any upstream error (down/slow/garbage) returns
- * `overall: 'unknown'` with HTTP 200, so the badge shows a neutral state and the
- * shell never breaks.
- */
-import { NextResponse } from 'next/server'
-
-import { config } from '~/config'
-import { fetchWithTimeout } from '~/lib/server/fetch-timeout'
-import { summarizeStatuses, type StatusSummary } from '~/lib/status/summary'
-
-// Health changes minute-to-minute — always evaluate fresh (short CDN cache below).
-export const dynamic = 'force-dynamic'
-
-const UNKNOWN: StatusSummary = { overall: 'unknown', total: 0, up: 0, down: [] }
-
-export async function GET() {
-  const statusUrl = config.statusUrl
-  let summary = UNKNOWN
-  try {
-    const res = await fetchWithTimeout(
-      `${statusUrl}/api/v1/endpoints/statuses`,
-      { headers: { accept: 'application/json' }, cache: 'no-store' },
-      { timeoutMs: 4000 },
-    )
-    if (res.ok) summary = summarizeStatuses(await res.json())
-  } catch {
-    // fail-soft → UNKNOWN
-  }
-
-  return NextResponse.json(
-    { ...summary, statusUrl, checkedAt: new Date().toISOString() },
-    { headers: { 'Cache-Control': 'public, max-age=30' } },
-  )
-}

app/tasksd/[...path]/route.ts

@@ -1,38 +0,0 @@
-/**
- * Same-origin proxy to the durable task engine (hanzoai/tasks `tasksd`, the native
- * Temporal-style HTTP surface at `/v1/tasks/*`).
- *
- * `tasksd` runs `TASKSD_REQUIRE_IDENTITY=true`: it validates an IAM **Bearer JWT**
- * against the IAM JWKS, unconditionally STRIPS inbound `X-Org-Id`, and mints org +
- * user from the JWT claims (`owner`→org). So — like the `/ai` proxy — the console
- * calls its OWN origin (`/tasksd/...`) with just the session cookie;
- * `forwardWithUserBearer` resolves the signed-in user, mints a short-lived
- * user-bound IAM token (shared per-user cache), and forwards it as the Bearer. No
- * key in the browser, and every read is org-scoped by the JWT server-side.
- *
- * READ-ONLY: only GET is proxied (the console never mutates workflows here), scoped
- * to the `v1/tasks/*` subtree. When the engine is unreachable the UI shows an honest
- * BackendStateCard — never fabricated workflows.
- */
-import { type NextRequest } from 'next/server'
-
-import { forwardWithUserBearer } from '~/lib/server/bearer-proxy'
-
-export const runtime = 'nodejs'
-
-const trim = (s: string) => s.replace(/\/+$/, '')
-/** The durable task engine. Public TLS is not live yet → default to the in-cluster
- *  service. The tasks Service exposes REST on :7243 (http port); there is NO :80,
- *  so target :7243 explicitly. Override with TASKS_URL. `|| default` (not `??`) so a
- *  blank env still falls back to the in-cluster service. */
-const TASKS_URL = trim(process.env.TASKS_URL?.trim() || 'http://tasks.hanzo.svc.cluster.local:7243')
-
-export async function GET(req: NextRequest, ctx: { params: Promise<{ path: string[] }> }) {
-  const rel = (await ctx.params).path.join('/')
-  return forwardWithUserBearer(req, {
-    target: TASKS_URL,
-    path: `v1/tasks/${rel}`,
-    allow: (p) => p === 'v1/tasks' || p.startsWith('v1/tasks/'),
-    unauthorizedMessage: 'Sign in to view tasks.',
-  })
-}

app/training/[...path]/route.ts

@@ -1,141 +0,0 @@
-/**
- * Same-origin proxy to the cloud ML/training surface (`/v1/ml/models` and the
- * fine-tuning broker `/v1/finetune/*`).
- *
- * The console's Training page calls its OWN origin (`/training/...`) with just the
- * first-party session cookie; this server handler resolves the signed-in user from
- * that cookie, mints a SHORT-LIVED, user-bound IAM Bearer (`adminBearer` — the ONE
- * per-user cache shared with the `/v1` bearer proxy), and forwards to the cloud
- * backend's `/v1/...` surface with `Authorization: Bearer <token>` + the active
- * `X-Org-Id`. Training is a TENANT action — any signed-in org user may run it — so
- * this is user-scoped (resolveUser), NOT the control-plane admin gate the `/paas`
- * proxy uses. The cloud backend resolves the org from the token's `owner` claim (and
- * the X-Org-Id the plain-REST train sub-service reads), so a caller can only ever
- * touch their own org's jobs. `POST /v1/finetune/jobs` is billing-gated upstream and
- * returns 402 on an unfunded org — that status flows straight back so the UI can
- * surface it honestly.
- *
- * Why a Bearer and NOT the cookie (the fix for the "Not enabled" 403): cloud-api's
- * `/v1/*` authorizes on a VALIDATED JWT principal and returns 403 "no validated
- * principal" for a cookie-only call — the raw casibase session cookie is NOT a
- * principal it accepts (only the sanitizer's cookie-token names or a Bearer). Minting
- * the same user-bound token the `/v1` proxy uses is the ONE way a signed-in tenant
- * reaches this surface; the cookie is deliberately dropped upstream (it can't
- * authenticate, and a cookie + JWT together risks the public-gateway 431).
- *
- * Least privilege: only the explicit ML/training sub-paths are forwarded; anything
- * else 404s, so this is not a general backend tunnel. No secret ever reaches the
- * browser — the HuggingFace token (for private repos) is resolved from KMS
- * server-side inside the broker, never here.
- */
-import { type NextRequest, NextResponse } from 'next/server'
-
-import { resolveUser, adminBearer } from '~/lib/server/identity'
-import { orgFor } from '~/lib/server/admin-policy'
-import { csrfRefusal } from '~/lib/server/bearer-proxy'
-import { fetchWithTimeout } from '~/lib/server/fetch-timeout'
-
-export const runtime = 'nodejs'
-
-const trim = (s: string) => s.replace(/\/+$/, '')
-const msgOf = (e: unknown) => (e instanceof Error ? e.message : String(e))
-/** Cloud `/v1` backend (hanzoai/ai) — same target lib/server/identity.ts resolves. */
-const CLOUD_API_URL = trim(process.env.CLOUD_API_URL ?? 'http://cloud.hanzo.svc.cluster.local:8000')
-
-/** The exact `/v1/<...>` ML/training sub-paths the console is allowed to reach. */
-const ALLOWED = new Set([
-  // Model serving — the org's deployed kserve InferenceServices.
-  'ml/models',
-  // fine-tuning broker (custom-data runs, HF search) — the ONE training door.
-  'finetune/jobs',
-  'finetune/job',
-  'finetune/cancel',
-  'finetune/deploy',
-  'finetune/presets',
-  'finetune/hf/models',
-  'finetune/hf/datasets',
-  'finetune/hf/repo',
-])
-
-async function forward(req: NextRequest, path: string[]): Promise<NextResponse> {
-  const rel = path.join('/')
-  if (!ALLOWED.has(rel)) {
-    return NextResponse.json({ status: 'error', msg: 'Not found' }, { status: 404 })
-  }
-
-  // CSRF: `POST /finetune/jobs` mutates (and bills) from the auto-sent cookie — refuse a
-  // cross-origin one before any work (safe reads pass).
-  const csrf = csrfRefusal(req, 'casibase')
-  if (csrf) return csrf
-
-  const user = await resolveUser(req)
-  if (!user) {
-    return NextResponse.json(
-      { status: 'error', msg: 'Sign in to manage training.' },
-      { status: 401 },
-    )
-  }
-
-  // Mint a short-lived, user-bound Bearer (the SAME per-user cache the `/v1`
-  // proxy uses). cloud-api's `/v1/*` 403s a cookie-only call ("no validated
-  // principal"); a Bearer is the one credential it accepts. Fail CLOSED with 502 if
-  // the token can't be minted — never fall through to an unauthenticated forward.
-  let bearer: string
-  try {
-    bearer = await adminBearer(user)
-  } catch (e) {
-    // Redact — the exception carries the internal IAM host/port. Log server-side only.
-    console.error('training-proxy: could not mint user bearer:', msgOf(e))
-    return NextResponse.json(
-      { status: 'error', msg: 'Could not authorize the request.' },
-      { status: 502 },
-    )
-  }
-
-  const url = `${CLOUD_API_URL}/v1/${rel}${req.nextUrl.search}`
-  const headers: Record<string, string> = {
-    Authorization: `Bearer ${bearer}`,
-    Accept: 'application/json',
-    'Content-Type': 'application/json',
-    // Org is SERVER-RESOLVED, not the raw browser header: a SuperAdmin's switched
-    // org (?/X-Org-Id) is honored, a non-SuperAdmin caller is PINNED to their own — so a
-    // brand admin can't drive another tenant's training jobs even if the backend
-    // trusted the forwarded header. For a non-SuperAdmin caller this equals the token
-    // owner (the Bearer's own claim), so header and token agree. Matches the /paas +
-    // /admin/kms orgFor pin. The raw session cookie is NOT forwarded (cloud-api can't
-    // validate it as a principal, and cookie + JWT together risks the gateway 431).
-    'X-Org-Id': orgFor({ isSuperAdmin: user.isSuperAdmin, orgScope: user.owner }, req.headers.get('X-Org-Id')),
-  }
-  const projectId = req.headers.get('X-Project-Id')
-  const environment = req.headers.get('X-Environment')
-  if (projectId) headers['X-Project-Id'] = projectId
-  if (environment) headers['X-Environment'] = environment
-
-  const init: RequestInit = { method: req.method, headers, cache: 'no-store' }
-  if (req.method !== 'GET' && req.method !== 'HEAD') {
-    init.body = await req.text()
-  }
-
-  try {
-    const res = await fetchWithTimeout(url, init)
-    const text = await res.text()
-    return new NextResponse(text, {
-      status: res.status,
-      headers: { 'Content-Type': res.headers.get('content-type') ?? 'application/json' },
-    })
-  } catch (e) {
-    return NextResponse.json(
-      { status: 'error', msg: `Fine-tuning backend unreachable: ${e instanceof Error ? e.message : String(e)}` },
-      { status: 502 },
-    )
-  }
-}
-
-type Ctx = { params: Promise<{ path: string[] }> }
-
-export async function GET(req: NextRequest, ctx: Ctx) {
-  return forward(req, (await ctx.params).path)
-}
-export async function POST(req: NextRequest, ctx: Ctx) {
-  return forward(req, (await ctx.params).path)
-}

app/v1/[...path]/route.ts

@@ -1,76 +0,0 @@
-/**
- * Same-origin user-bearer proxy at the console's OWN `/v1/*` — the ONE prefix-free
- * path the browser uses to reach the unified cloud-api surfaces that authorize on a
- * Bearer JWT. CTO contract: every cloud API path is `/v1/`-rooted, ZERO prefix (no
- * `/cloud/`, no `/api/`).
- *
- * The browser holds NO credential: it calls `<origin>/v1/<head>/...` with just its
- * first-party session cookie. This catch-all resolves WHO the caller is from that
- * cookie (`resolveUser`), mints a SHORT-LIVED, user-bound IAM token (shared per-user
- * cache in identity.ts — ONE cache across every proxy), and forwards to cloud-api's
- * `/v1/*` with `Authorization: Bearer <token>`. The backend resolves the ORG from the
- * token's `owner` claim, so tenancy is server-authoritative — a browser can never
- * supply its own org — and the raw session cookie NEVER reaches cloud-api (no
- * cookie-CSRF surface upstream). This is the EXACT transport the `/ai` proxy proved
- * live; every service proxy shares the ONE `forwardWithUserBearer` implementation.
- *
- * DISPATCH: the AI (`models`/`chat`/…), admin-aggregate (`/v1/admin/*`), visor
- * (`regions`/`sizes`/`gpu-sizes`), billing (`/v1/billing/*`) and commerce
- * (`/v1/commerce/*`) heads are routed to their OWN backends by `next.config.mjs`
- * `beforeFiles` rewrites BEFORE they reach this catch-all — so this handler owns
- * exactly the cloud-api `/v1/<head>` surface.
- *
- * Least privilege: only the allow-listed cloud HEADS are reachable
- * (`allowCloudSurface`); `v1/iam/*`, `v1/admin/*`, etc. 404 here — this is not a
- * general cloud-api tunnel. The mutating same-origin (CSRF) guard, the path-traversal
- * rejection, and the bearer mint all live in `forwardWithUserBearer`.
- */
-import { type NextRequest } from 'next/server'
-
-import { forwardWithUserBearer } from '~/lib/server/bearer-proxy'
-import { allowCloudSurface } from '~/lib/server/proxy-allow'
-
-export const runtime = 'nodejs'
-
-const trim = (s: string) => s.replace(/\/+$/, '')
-/** The unified cloud backend (hanzoai/cloud). In-cluster ClusterIP — public egress is CF-403'd.
- *  `|| default` (not `??`) so an env accidentally reconciled to an EMPTY string still falls
- *  back to the in-cluster service (a blank CLOUD_API_URL would otherwise break every cloud page). */
-const CLOUD_API_URL = trim(process.env.CLOUD_API_URL?.trim() || 'http://cloud-api.hanzo.svc.cluster.local:8000')
-
-type Ctx = { params: Promise<{ path: string[] }> }
-
-function handle(req: NextRequest, ctx: Ctx) {
-  return (async () => {
-    // The `[...path]` catch-all sits UNDER `/v1`, so it captures the segments AFTER
-    // `/v1`. Re-prepend the `v1/` root so the allow-list (matches `v1/<head>`) and the
-    // upstream URL (`CLOUD_API_URL/v1/<head>/...`) both see the cloud-api contract path.
-    const path = `v1/${(await ctx.params).path.join('/')}`
-    return forwardWithUserBearer(req, {
-      target: CLOUD_API_URL,
-      path,
-      allow: allowCloudSurface,
-      // Org is authoritative (Bearer owner). Do NOT forward the browser-controlled
-      // X-Project-Id/X-Environment sub-scopes — the data/serverless resources are
-      // org-keyed, and forwarding an unvalidated project id is an attack surface
-      // (RED MEDIUM). A project-scoped feature must validate membership first.
-      unauthorizedMessage: 'Sign in to use Hanzo Cloud.',
-    })
-  })()
-}
-
-export async function GET(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function POST(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function PUT(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function PATCH(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function DELETE(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}

app/v1/ai-accounts/[...path]/route.ts

@@ -1,87 +0,0 @@
-/**
- * AI-account credential store — the per-user connect/list/disconnect route.
- *
- *   GET    v1/accounts               → { providers: masked[] }  (existence + mode, NO secret)
- *   POST   v1/accounts/:providerId   → seal a pasted API key / OAuth token / cookie header
- *   DELETE v1/accounts/:providerId   → drop the sealed credential
- *
- * The secret is sealed into an httpOnly cookie server-side (`lib/server/ai-accounts`)
- * and NEVER echoed back or logged. Every request is session-gated (`resolveUser`); the
- * two mutating verbs are CSRF-guarded (auto-sent cookie → refuse cross-origin first).
- *
- * Namespaced under `/v1/ai-accounts/` so the data plane never shadows the UI tab URLs
- * (`/ai-accounts`, `/ai-accounts/accounts`) — a route handler always wins over the
- * catch-all page, so the two live in disjoint path space (same rule as `/v1/billing/`).
- */
-import { type NextRequest, NextResponse } from 'next/server'
-
-import { resolveUser } from '~/lib/server/identity'
-import { csrfRefusal } from '~/lib/server/bearer-proxy'
-import { applyCookies } from '~/lib/server/session'
-import {
-  readAccounts,
-  accountsCookie,
-  maskAccounts,
-  type AiAccountsStore,
-  type StoredCredential,
-} from '~/lib/server/ai-accounts'
-import { isAiProvider, type ConnectMode } from '~/lib/products/ai-accounts'
-
-export const runtime = 'nodejs'
-
-type Ctx = { params: Promise<{ path: string[] }> }
-
-const MODES: ConnectMode[] = ['api', 'oauth', 'web']
-const unauthorized = () => NextResponse.json({ error: 'Sign in to manage AI accounts.' }, { status: 401 })
-const notFound = () => NextResponse.json({ error: 'Not found.' }, { status: 404 })
-
-export async function GET(req: NextRequest, ctx: Ctx) {
-  const user = await resolveUser(req)
-  if (!user) return unauthorized()
-  const seg = (await ctx.params).path
-  if (seg[0] !== 'accounts' || seg.length !== 1) return notFound()
-  return NextResponse.json({ providers: maskAccounts(readAccounts(req)) })
-}
-
-export async function POST(req: NextRequest, ctx: Ctx) {
-  const csrf = csrfRefusal(req)
-  if (csrf) return csrf
-  const user = await resolveUser(req)
-  if (!user) return unauthorized()
-
-  const seg = (await ctx.params).path
-  const id = seg[1]
-  if (seg[0] !== 'accounts' || !id) return notFound()
-  if (!isAiProvider(id)) return NextResponse.json({ error: 'Unknown provider.' }, { status: 400 })
-
-  const body = (await req.json().catch(() => null)) as { mode?: string; secret?: string; baseUrl?: string } | null
-  const mode = body?.mode as ConnectMode
-  const secret = typeof body?.secret === 'string' ? body.secret.trim() : ''
-  if (!MODES.includes(mode) || !secret) {
-    return NextResponse.json({ error: 'A link mode and a non-empty credential are required.' }, { status: 400 })
-  }
-
-  const cred: StoredCredential = {
-    mode,
-    secret, // sealed at rest by accountsCookie; never logged.
-    baseUrl: body?.baseUrl?.trim() || undefined,
-    connectedAt: new Date().toISOString(),
-  }
-  const next: AiAccountsStore = { ...readAccounts(req), [id]: cred }
-  return applyCookies(NextResponse.json({ providers: maskAccounts(next) }), [accountsCookie(next)])
-}
-
-export async function DELETE(req: NextRequest, ctx: Ctx) {
-  const csrf = csrfRefusal(req)
-  if (csrf) return csrf
-  const user = await resolveUser(req)
-  if (!user) return unauthorized()
-
-  const seg = (await ctx.params).path
-  const id = seg[1]
-  if (seg[0] !== 'accounts' || !id) return notFound()
-
-  const store = readAccounts(req)
-  delete store[id]
-  return applyCookies(NextResponse.json({ providers: maskAccounts(store) }), [accountsCookie(store)])
-}

app/v1/ai-accounts/routing-defaults/route.ts

@@ -1,45 +0,0 @@
-/**
- * AI-accounts ORG routing defaults (READ-ONLY) — the server-driven default the
- * admin set for the whole org, surfaced so the Routing tab can show
- * "Organization default: On/Off" and fall back to it when the user has no explicit
- * override.
- *
- *   GET v1/routing-defaults → cloud-api `{ status, data: { auto_routing_active,
- *                             default_session_routing } }` (streamed through verbatim)
- *
- * This is a pure READ. It forwards to cloud-api's org-scoped
- * `GET /v1/router/defaults` with the caller's short-lived user bearer (org is
- * the token owner — never browser-supplied), the EXACT same auth pattern as the
- * `/v1` proxy. It deliberately does NOT touch the org-settings WRITE path: a
- * customer surface has no clean authenticated path to mint the global-admin write,
- * and forging one is a confused-deputy escalation (see the long note in
- * `settings/route.ts`). Reads are fine; writes stay out.
- *
- * FAIL-SOFT: an older cloud-api with no such endpoint 404s, which streams straight
- * through as a 404 the client treats as "no org default" — the tab then honors the
- * cookie preference alone, exactly as before this endpoint existed.
- *
- * A static route, so it wins over the sibling `[...path]` catch-all for this exact
- * path (same rule as `/v1/ai-accounts/usage` and `/v1/ai-accounts/settings`).
- */
-import { type NextRequest } from 'next/server'
-
-import { forwardWithUserBearer } from '~/lib/server/bearer-proxy'
-
-export const runtime = 'nodejs'
-
-const trim = (s: string) => s.replace(/\/+$/, '')
-/** The unified cloud backend (hanzoai/cloud) — same in-cluster target as the `/v1` proxy. */
-const CLOUD_API_URL = trim(process.env.CLOUD_API_URL?.trim() || 'http://cloud-api.hanzo.svc.cluster.local:8000')
-
-const UPSTREAM_PATH = 'v1/router/defaults'
-
-export async function GET(req: NextRequest) {
-  return forwardWithUserBearer(req, {
-    target: CLOUD_API_URL,
-    path: UPSTREAM_PATH,
-    allow: (p) => p === UPSTREAM_PATH,
-    errorShape: 'casibase',
-    unauthorizedMessage: 'Sign in to read organization routing defaults.',
-  })
-}

app/v1/ai-accounts/settings/route.ts

@@ -1,63 +0,0 @@
-/**
- * AI-accounts NON-SECRET preferences — the org/user settings route.
- *
- *   GET v1/settings  → { settings: { routingEnabled } }
- *   PUT v1/settings  → persist { routingEnabled } (sealed), returns the new settings
- *
- * The one preference today is `routingEnabled` — the org's `model: "auto"` smart-
- * routing default that Hanzo surfaces read. Persisted with the SAME sealed-cookie
- * store as the credential blob (`lib/server/ai-accounts`); there is no secret here,
- * so the seal is for integrity, not confidentiality. Session-gated; the mutating
- * verb is CSRF-guarded (auto-sent cookie → refuse cross-origin first).
- *
- * A static route, so it wins over the sibling `[...path]` catch-all for this exact
- * path (same rule as `/v1/ai-accounts/usage`).
- */
-import { type NextRequest, NextResponse } from 'next/server'
-
-import { resolveUser } from '~/lib/server/identity'
-import { csrfRefusal } from '~/lib/server/bearer-proxy'
-import { applyCookies } from '~/lib/server/session'
-import { readSettings, settingsCookie, normalizeSettings } from '~/lib/server/ai-accounts'
-
-export const runtime = 'nodejs'
-
-const unauthorized = () => NextResponse.json({ error: 'Sign in to manage AI settings.' }, { status: 401 })
-
-export async function GET(req: NextRequest) {
-  const user = await resolveUser(req)
-  if (!user) return unauthorized()
-  return NextResponse.json({ settings: readSettings(req) })
-}
-
-export async function PUT(req: NextRequest) {
-  const csrf = csrfRefusal(req)
-  if (csrf) return csrf
-  const user = await resolveUser(req)
-  if (!user) return unauthorized()
-
-  const body = (await req.json().catch(() => null)) as { routingEnabled?: unknown } | null
-  if (typeof body?.routingEnabled !== 'boolean') {
-    return NextResponse.json({ error: 'routingEnabled (boolean) is required.' }, { status: 400 })
-  }
-  const settings = normalizeSettings(body)
-
-  // Cookie-only, deliberately. cloud-api now enforces per-org auto-routing via
-  // `OrgSettings.AutoRouting` (hanzoai/ai), toggled through
-  // `PUT /v1/org/settings`. But that endpoint is `RequireGlobalAdmin`-gated
-  // (like every /v1/*-model-route admin route) and is NOT gateway-exposed — it is
-  // reachable only on the direct api.cloud.hanzo.ai ingress with a global-admin
-  // session. This Routing tab is a CUSTOMER surface: `resolveUser` here is a tenant
-  // user whose minted `hanzo-console` bearer is NOT global-admin, and the console's
-  // only admin proxy (`/admin/aggregate`) fail-closed-403s a non-global-admin. So
-  // there is NO clean authenticated path for a customer to write cloud-side
-  // OrgSettings, and forging one (a console service token asserting admin authority
-  // for a client-supplied org) would be a confused-deputy privilege escalation —
-  // refused per "do not bodge auth". The toggle therefore stays the sealed-cookie
-  // org preference the Hanzo surfaces read; API `model:"auto"` still honors the
-  // GLOBAL router flag. To make this write real, a global-admin must set the org's
-  // AutoRouting via the admin console (the OrgSettings CRUD), OR cloud-api must add a
-  // self-serve, org-scoped (owner-from-JWT, non-global-admin) auto-routing toggle the
-  // `/ai` proxy can reach — at which point wire that call in here.
-  return applyCookies(NextResponse.json({ settings }), [settingsCookie(settings)])
-}

app/v1/ai-accounts/usage/route.ts

@@ -1,75 +0,0 @@
-/**
- * Unified AI-account usage — the Overview data plane.
- *
- * For each CONNECTED provider it runs the headless `@hanzo/usage` pipeline
- * server-side over the Node host, decrypting the sealed credential into the
- * usage-engine settings (`settingsFor`) only in memory for the fetch. It ALSO
- * merges the org's own Hanzo lane — the REAL commerce usage ledger overview,
- * fetched through the tested `/billing` proxy (the SAME source the Billing/Overview
- * dashboards read), so `/ai-accounts` shows Hanzo + every linked provider side by side.
- *
- * A static route, so it wins over the sibling `[...path]` catch-all for this exact
- * path. Session-gated; a secret is never logged or returned.
- */
-import { type NextRequest, NextResponse } from 'next/server'
-import { nodeHost } from '@hanzo/usage/node'
-import { runPipeline } from '@hanzo/usage'
-
-import { resolveUser } from '~/lib/server/identity'
-import { readAccounts, descriptorFor, settingsFor } from '~/lib/server/ai-accounts'
-import { forwardBilling } from '~/lib/server/billing-proxy'
-import { normalizeUsageRecords } from '~/lib/api/aimetrics'
-import { buildCloudUsageOverview } from '~/lib/api/usage-adapter'
-import type { CloudUsageOverview } from '~/lib/api/usage'
-import type { ProviderUsage } from '~/lib/api/ai-accounts'
-
-export const runtime = 'nodejs'
-
-const msgOf = (e: unknown): string => (e instanceof Error ? e.message : 'Fetch failed.')
-
-/** The org's own Hanzo Cloud lane: the real commerce ledger overview, null on any miss. */
-async function hanzoLane(req: NextRequest): Promise<CloudUsageOverview | null> {
-  try {
-    const res = await forwardBilling(req, ['usage'])
-    if (!res.ok) return null
-    const records = normalizeUsageRecords(await res.json())
-    return buildCloudUsageOverview(records, {
-      range: '30d',
-      topModels: 6,
-      activityType: 'all',
-      activityLimit: 8,
-      activityOffset: 0,
-      now: Date.now(),
-      product: null,
-    })
-  } catch {
-    return null
-  }
-}
-
-/** Run the usage pipeline for one connected provider. */
-async function providerUsage(id: string, cred: ReturnType<typeof readAccounts>[string]): Promise<ProviderUsage> {
-  const descriptor = descriptorFor(id)
-  if (!descriptor) return { id, ok: false, error: 'Unknown provider.' }
-  const { mode, settings } = settingsFor(cred)
-  try {
-    const outcome = await runPipeline(descriptor, { host: nodeHost, sourceMode: mode, settings })
-    if (outcome.result) return { id, ok: true, usage: outcome.result.usage }
-    return { id, ok: false, error: msgOf(outcome.error) }
-  } catch (e) {
-    return { id, ok: false, error: msgOf(e) }
-  }
-}
-
-export async function GET(req: NextRequest) {
-  const user = await resolveUser(req)
-  if (!user) return NextResponse.json({ error: 'Sign in to view usage.' }, { status: 401 })
-
-  const store = readAccounts(req)
-  const [providers, hanzo] = await Promise.all([
-    Promise.all(Object.entries(store).map(([id, cred]) => providerUsage(id, cred))),
-    hanzoLane(req),
-  ])
-
-  return NextResponse.json({ providers, hanzo })
-}

app/v1/billing/[...path]/route.ts

@@ -1,38 +0,0 @@
-/**
- * Per-tenant billing DATA proxy → commerce. Thin route wrapper: the trust boundary,
- * tenant scoping, CSRF guard, and binary (PDF) passthrough all live in the tested
- * `~/lib/server/billing-proxy` (`forwardBilling`) — this file only maps the HTTP verbs.
- *
- * Rooted at `/v1/billing/` (the /v1-first law) — this handler lives at
- * `app/v1/billing/[...path]`, MORE SPECIFIC than the cloud BFF catch-all
- * `app/v1/[...path]`, so `/v1/billing/*` (data) resolves here while `/v1/<other>/*`
- * falls through to the catch-all. And `/v1/billing/*` (data) never collides with the
- * billing UI tab URLs (`/billing/reports`, `/billing/invoices`, …) — they differ at
- * the FIRST path segment, so the tab slugs fall through to the SPA.
- *
- * Verbs: GET (reads: balance/usage/invoices/subscriptions/methods, and the
- * per-invoice PDF), POST (writes: top-up, alerts, save-a-method, cancel/
- * reactivate a subscription), PATCH (edit a budget/spend-alert), DELETE (detach a
- * saved payment method, remove a budget). Each is scoped to the caller's OWN org
- * server-side; a mutating verb is CSRF-guarded (`forwardBilling`).
- */
-import { type NextRequest } from 'next/server'
-
-import { forwardBilling } from '~/lib/server/billing-proxy'
-
-export const runtime = 'nodejs'
-
-type Ctx = { params: Promise<{ path: string[] }> }
-
-export async function GET(req: NextRequest, ctx: Ctx) {
-  return forwardBilling(req, (await ctx.params).path)
-}
-export async function POST(req: NextRequest, ctx: Ctx) {
-  return forwardBilling(req, (await ctx.params).path)
-}
-export async function PATCH(req: NextRequest, ctx: Ctx) {
-  return forwardBilling(req, (await ctx.params).path)
-}
-export async function DELETE(req: NextRequest, ctx: Ctx) {
-  return forwardBilling(req, (await ctx.params).path)
-}

app/v1/catalog/[...path]/route.ts

@@ -1,70 +0,0 @@
-/**
- * Same-origin user-bearer proxy to commerce for the PLATFORM CATALOG admin surface
- * (`/v1/catalog/entries` + `/v1/catalog/seed`) — the SuperAdmin CMS for the product
- * + pricing catalog (the 17 infra tiers increment 1 seeded, plus every product
- * surface docs/pricing/the console read from).
- *
- * The browser calls this OWN-origin route (`/v1/catalog/...`) with just its session
- * cookie; `forwardWithUserBearer` resolves the user, mints a short-lived user-bound
- * IAM token, and forwards to commerce with that Bearer. Commerce's `requireSuperAdmin`
- * (owner=="admin", the `IsSuperAdmin()` home-org predicate) is the AUTHORITATIVE gate:
- * the platform catalog is cross-tenant `system`-namespace data, so an org-level admin
- * is refused 403 — a tenant can never read cost/margin or edit the catalog. The org is
- * server-authoritative (the Bearer owner), never browser-supplied.
- *
- * This is the ADMIN twin of the tenant `/v1/commerce/*` store proxy: a DISTINCT
- * least-privilege boundary (`allowCatalogSurface`) that admits ONLY the catalog
- * entries + seed paths, so it can never tunnel commerce's `/v1/billing`, `/v1/checkout`,
- * `/_/commerce/tenants`, or the merchant store models. It lives at
- * `app/v1/catalog/[...path]` — MORE SPECIFIC than the `app/v1/[...path]` cloud BFF
- * catch-all, so Next resolves `/v1/catalog/*` here (the same precedence as
- * `app/v1/commerce/[...path]`). The path is `/v1/catalog/*` (the REAL commerce mount),
- * so the go:embed console (where the BFF is pruned) reaches the SAME path on the cloud
- * binary's embedded commerce directly.
- */
-import { type NextRequest } from 'next/server'
-
-import { forwardWithUserBearer } from '~/lib/server/bearer-proxy'
-import { allowCatalogSurface } from '~/lib/server/proxy-allow'
-
-export const runtime = 'nodejs'
-
-const trim = (s: string) => s.replace(/\/+$/, '')
-/** Commerce API (commerce.hanzo.ai). In-cluster ClusterIP on :8001; the CR wires
- *  `COMMERCE_URL` (public egress is CF-gated). Override per-deploy / for local dev. */
-const COMMERCE_URL = trim(process.env.COMMERCE_URL ?? 'http://commerce.hanzo.svc:8001')
-
-type Ctx = { params: Promise<{ path: string[] }> }
-
-function handle(req: NextRequest, ctx: Ctx) {
-  return (async () => {
-    // This handler lives under `app/v1/catalog/[...path]`, so the catch-all captures
-    // ONLY the sub-path after `/v1/catalog/` (e.g. `entries`, `entries/cloud-dev`,
-    // `seed`). Commerce serves the catalog admin CRUD at `/v1/catalog/*`, so re-root
-    // the upstream path at `v1/catalog/` — the same path `allowCatalogSurface` and
-    // `forwardWithUserBearer` see (`v1/catalog/entries`).
-    const path = `v1/catalog/${(await ctx.params).path.join('/')}`
-    return forwardWithUserBearer(req, {
-      target: COMMERCE_URL,
-      path,
-      allow: allowCatalogSurface,
-      // Org is authoritative (Bearer owner). Do NOT forward browser X-Project-Id/
-      // X-Environment — the catalog is platform-global and commerce gates on the
-      // SuperAdmin home-org from the token.
-      unauthorizedMessage: 'Sign in as an administrator to edit the catalog.',
-    })
-  })()
-}
-
-export async function GET(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function POST(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function PUT(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function DELETE(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}

app/v1/commerce/[...path]/route.ts

@@ -1,66 +0,0 @@
-/**
- * Same-origin user-bearer proxy to commerce (`commerce.hanzo.svc`) — the store /
- * merchant admin surface (products / orders / customers / collections / variants /
- * discounts / store settings). The browser calls this OWN-origin route
- * (`/v1/commerce/...`) with just its session cookie; `forwardWithUserBearer` resolves
- * the user, mints a short-lived user-bound IAM token, and forwards to commerce with
- * that Bearer. Commerce's EdgeAuth validates the JWT and resolves the org from its
- * `owner` claim (`middleware.TokenRequired` fast-paths IAM auth), so the store is
- * org-scoped SERVER-SIDE — a merchant only ever sees their OWN org's catalog/orders/
- * customers. No token reaches the browser, and the org is never browser-supplied.
- *
- * This is the TENANT store surface (any signed-in org member acts on their own org's
- * store), so it is user-scoped (`resolveUser`), NOT the `/paas` god-mode service-token
- * path. It is also DISTINCT from the `/billing` proxy: money (balance/usage/invoices/
- * Square) stays on `/billing` with its own per-tenant subject scoping — this proxy
- * carries only the store catalog/orders/customers. Least privilege on the path:
- * `allowCommerceSurface` admits only the merchant REST heads (product/order/user/…),
- * so `/v1/billing`, `/v1/checkout`, `/_/commerce/tenants` are NOT reachable here.
- */
-import { type NextRequest } from 'next/server'
-
-import { forwardWithUserBearer } from '~/lib/server/bearer-proxy'
-import { allowCommerceSurface } from '~/lib/server/proxy-allow'
-
-export const runtime = 'nodejs'
-
-const trim = (s: string) => s.replace(/\/+$/, '')
-/** Commerce API (commerce.hanzo.ai). In-cluster ClusterIP on :8001; the CR already
- *  wires `COMMERCE_URL` (public egress is CF-gated). Override per-deploy with COMMERCE_URL. */
-const COMMERCE_URL = trim(process.env.COMMERCE_URL ?? 'http://commerce.hanzo.svc:8001')
-
-type Ctx = { params: Promise<{ path: string[] }> }
-
-function handle(req: NextRequest, ctx: Ctx) {
-  return (async () => {
-    // This handler lives under `app/v1/commerce/[...path]`, so the catch-all captures
-    // ONLY the sub-path after `/v1/commerce/` (e.g. `product`). Commerce serves its REST
-    // models under `/v1/<model>`, so re-root the upstream path at `v1/` — the same path
-    // `allowCommerceSurface` (v1Head) and `forwardWithUserBearer` see (`v1/product`).
-    const path = `v1/${(await ctx.params).path.join('/')}`
-    return forwardWithUserBearer(req, {
-      target: COMMERCE_URL,
-      path,
-      allow: allowCommerceSurface,
-      // Org is authoritative (Bearer owner). Do NOT forward browser X-Project-Id/
-      // X-Environment — the store is org-keyed and commerce re-scopes on the token.
-      unauthorizedMessage: 'Sign in to manage your store.',
-    })
-  })()
-}
-
-export async function GET(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function POST(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function PUT(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function PATCH(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function DELETE(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}

app/v1/economy/[...path]/route.ts

@@ -1,177 +0,0 @@
-/**
- * Per-user proxy to the Lux DEX indexer's `dex` subgraph — the Lux Economy /
- * Markets board's ONE transport. The browser calls console2's OWN origin
- * (`/v1/economy/overview`) with just the session cookie; this handler resolves the
- * caller, resolves the BRAND from the request host, and POSTs a FIXED, allowlisted
- * GraphQL query to the in-cluster graphd per brand-scoped network, returning the
- * NORMALIZED markets + fills + day-data. No graph host or GraphQL query ever reaches
- * the browser, and the browser can never compose one.
- *
- * Security (mirrors app/nodes/[...path]/route.ts):
- *  - Session-gated: an unauthenticated caller gets 401.
- *  - Org/brand-aware: the network set is scoped by `nodeNetworksForBrand(brand)`,
- *    brand resolved from the host — cloud.lux.cloud sees only Lux networks.
- *  - Least privilege: the ONLY path is `overview`, and the ONLY GraphQL query is
- *    the fixed markets+fills+dayData read below — this is not a general GraphQL
- *    tunnel (no client-supplied query, no mutations, no arbitrary entity).
- *
- * Honest by construction: an unset/unreachable graph host yields a `not-reporting`
- * snapshot with the real error — never fabricated markets. The native DEX is a CLOB,
- * so the query asks only for the fields the `dex` subgraph really exposes.
- */
-import { type NextRequest, NextResponse } from 'next/server'
-
-import { brandFromHost } from '~/config'
-import { resolveUser } from '~/lib/server/identity'
-import { nodeNetworksForBrand, type NodeNetworkId } from '~/lib/products/brand-scope'
-import { fetchWithTimeout } from '~/lib/server/fetch-timeout'
-import {
-  normalizeMarkets,
-  normalizeTrades,
-  normalizeDayData,
-  type EconomySnapshot,
-  type RawMarket,
-  type RawFill,
-  type RawMarketDayData,
-} from '~/lib/api/economy'
-
-export const runtime = 'nodejs'
-
-const trim = (s: string) => s.replace(/\/+$/, '')
-
-/**
- * The `dex` subgraph GraphQL endpoint per network — the ONLY endpoint this proxy
- * will query. graphd serves the DEX subgraph at `<prefix>/graphql` (default prefix
- * `/v1/graph/cchain/dex`); each is overridable per-deploy. An unset/unreachable host
- * yields an honest `not-reporting` snapshot — never fake markets. (Cross-cluster
- * reach depends on network policy; when unreachable the board shows honest empty.)
- */
-const GRAPH_HOSTS: Partial<Record<NodeNetworkId, string>> = {
-  'lux-mainnet': trim(process.env.DEX_GRAPHQL_MAINNET ?? 'http://graph.lux-mainnet.svc:8080/v1/graph/cchain/dex/graphql'),
-  'lux-testnet': trim(process.env.DEX_GRAPHQL_TESTNET ?? 'http://graph.lux-testnet.svc:8080/v1/graph/cchain/dex/graphql'),
-  'lux-devnet': trim(process.env.DEX_GRAPHQL_DEVNET ?? 'http://graph.lux-devnet.svc:8080/v1/graph/cchain/dex/graphql'),
-}
-
-/** Per-query timeout (ms). */
-const TIMEOUT_MS = Number(process.env.ECONOMY_TIMEOUT_MS ?? 8000)
-
-/**
- * The ONE fixed GraphQL query — markets (book summary + accrued 24h aggregates),
- * recent fills (the trade feed), and day-data (the historical series, empty until a
- * MarketDayData producer emits). Only fields the `dex` subgraph really exposes.
- */
-const QUERY = `query LuxEconomy {
-  markets(first: 100) {
-    id
-    symbol
-    baseToken
-    quoteToken
-    assetsBound
-    openOrders
-    remaining
-    bestBid
-    bestAsk
-    volume24h
-    tradeCount
-    lastPrice
-    feeTier
-  }
-  fills(first: 40) {
-    id
-    symbol
-    price
-    size
-    side
-    timestamp
-  }
-  marketDayDatas(first: 90) {
-    id
-    date
-    symbol
-    volumeUSD
-    feesUSD
-    tvlUSD
-  }
-}`
-
-interface GraphResp {
-  data?: { markets?: RawMarket[]; fills?: RawFill[]; marketDayDatas?: RawMarketDayData[] }
-  errors?: { message?: string }[]
-}
-
-/** Query ONE network's `dex` subgraph → normalized snapshot. Honest not-reporting on failure. */
-async function probe(net: NodeNetworkId): Promise<EconomySnapshot> {
-  const base: EconomySnapshot = { network: net, status: 'not-reporting', markets: [], trades: [], dayData: [] }
-  const host = GRAPH_HOSTS[net]
-  if (!host) {
-    base.error = 'no DEX GraphQL host configured for this network'
-    return base
-  }
-  try {
-    const res = await fetchWithTimeout(
-      host,
-      {
-        method: 'POST',
-        headers: { 'content-type': 'application/json', accept: 'application/json' },
-        body: JSON.stringify({ query: QUERY }),
-        cache: 'no-store',
-      },
-      { timeoutMs: TIMEOUT_MS },
-    )
-    if (!res.ok) {
-      base.error = `graphql ${res.status}`
-      return base
-    }
-    const json = (await res.json()) as GraphResp
-    if (json?.errors?.length) {
-      base.error = json.errors[0]?.message ?? 'graphql error'
-      return base
-    }
-    const d = json?.data ?? {}
-    return {
-      network: net,
-      status: 'reporting',
-      markets: normalizeMarkets(d.markets),
-      trades: normalizeTrades(d.fills),
-      dayData: normalizeDayData(d.marketDayDatas),
-    }
-  } catch (e) {
-    base.error = e instanceof Error ? e.message : String(e)
-    return base
-  }
-}
-
-async function forward(req: NextRequest, path: string[]): Promise<NextResponse> {
-  // This handler lives at `app/v1/economy/[...path]`, so the catch-all captures the
-  // sub-path after `/v1/economy/`.
-  if (path.join('/') !== 'overview') {
-    return NextResponse.json({ error: 'not found' }, { status: 404 })
-  }
-
-  const user = await resolveUser(req)
-  if (!user) {
-    return NextResponse.json({ error: 'Sign in to view the market economy.' }, { status: 401 })
-  }
-
-  const brand = brandFromHost(req.headers.get('host'))
-  let networks = nodeNetworksForBrand(brand)
-  const only = req.nextUrl.searchParams.get('network') as NodeNetworkId | null
-  if (only) networks = networks.filter((n) => n === only)
-
-  // Query the brand's networks and return the FIRST that reports markets (the live
-  // economy), else the first reporting network, else the first (honest not-reporting).
-  const snaps = await Promise.all(networks.map(probe))
-  const withMarkets = snaps.find((s) => s.status === 'reporting' && s.markets.length > 0)
-  const reporting = snaps.find((s) => s.status === 'reporting')
-  const chosen = withMarkets ?? reporting ?? snaps[0]
-  if (!chosen) {
-    return NextResponse.json({ network: null, status: 'not-reporting', markets: [], trades: [], dayData: [], error: 'no network in scope' })
-  }
-  return NextResponse.json(chosen)
-}
-
-type Ctx = { params: Promise<{ path: string[] }> }
-
-export async function GET(req: NextRequest, ctx: Ctx) {
-  return forward(req, (await ctx.params).path)
-}

app/v1/nodes/[...path]/route.ts

@@ -1,168 +0,0 @@
-/**
- * Per-user proxy to the REAL luxd node RPC — the Nodes module's ONE transport.
- * The browser calls console2's OWN origin (`/v1/nodes/inventory`) with just the
- * session cookie; this handler resolves the caller, resolves the BRAND from the
- * request host, and fetches the allowlisted luxd RPC methods server-side for each
- * network that brand may see, returning NORMALIZED per-node rows. No RPC host or
- * method ever reaches the browser, and the browser can never choose either.
- *
- * Security (mirrors app/bootnode/[...path]/route.ts):
- *  - Session-gated: an unauthenticated caller gets 401 (the RPC data is public,
- *    but the console surface is authenticated, same as every other module).
- *  - Org/brand-aware: the network set is scoped by `nodeNetworksForBrand(brand)`,
- *    brand resolved from the host — so cloud.lux.cloud sees only Lux networks,
- *    console.hanzo.ai (hanzo) sees all.
- *  - Least privilege: the ONLY path is `inventory`, and the ONLY luxd methods
- *    called are the four read methods below — this is not a general RPC tunnel.
- */
-import { type NextRequest, NextResponse } from 'next/server'
-
-import { brandFromHost } from '~/config'
-import { resolveUser } from '~/lib/server/identity'
-import { nodeNetworksForBrand, type NodeNetworkId } from '~/lib/products/brand-scope'
-import {
-  NODE_NETWORK_META,
-  combineInventory,
-  normalizeChains,
-  parseHeight,
-  type NetworkInventory,
-  type RawBlockchain,
-  type RawPeer,
-  type RawValidator,
-} from '~/lib/api/nodes'
-
-export const runtime = 'nodejs'
-
-const trim = (s: string) => s.replace(/\/+$/, '')
-
-/**
- * Public luxd RPC host per network — the ONLY endpoints this proxy will call.
- * These are PUBLIC RPC hosts (not secrets); each is overridable per-deploy so a
- * network can be repointed or disabled without a code change. A host that is
- * unset/unreachable yields an honest `not-reporting` network — never fake rows.
- */
-const HOSTS: Record<NodeNetworkId, string> = {
-  'lux-mainnet': trim(process.env.LUX_MAINNET_RPC ?? 'https://api.lux.network'),
-  'lux-testnet': trim(process.env.LUX_TESTNET_RPC ?? 'https://api.lux-test.network'),
-  'lux-devnet': trim(process.env.LUX_DEVNET_RPC ?? 'https://api.lux-dev.network'),
-  'pars-mainnet': trim(process.env.PARS_MAINNET_RPC ?? 'https://api.pars.network'),
-  // Zoo has no confirmed public primary-network host yet; the default is the
-  // conventional host (api.<brand>.network) and reports honestly when unreachable.
-  'zoo-mainnet': trim(process.env.ZOO_MAINNET_RPC ?? 'https://api.zoo.network'),
-}
-
-/** Per-network probe timeout (ms). */
-const TIMEOUT_MS = Number(process.env.NODES_RPC_TIMEOUT_MS ?? 8000)
-
-/** A single allowlisted luxd JSON-RPC call. `path` and `method` are fixed here. */
-async function rpc<T>(
-  host: string,
-  path: '/v1/bc/P' | '/v1/info',
-  method: string,
-  signal: AbortSignal,
-): Promise<T> {
-  const res = await fetch(`${host}${path}`, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json', accept: 'application/json' },
-    body: JSON.stringify({ jsonrpc: '2.0', id: 1, method }),
-    cache: 'no-store',
-    signal,
-  })
-  if (!res.ok) throw new Error(`${method} ${res.status}`)
-  const json = (await res.json()) as { result?: T; error?: { message?: string } }
-  if (json?.error) throw new Error(json.error.message ?? `${method} error`)
-  return json.result as T
-}
-
-/** Probe ONE network: validators + peers + version + height, normalized. */
-async function probe(net: NodeNetworkId): Promise<NetworkInventory> {
-  const meta = NODE_NETWORK_META[net]
-  const host = HOSTS[net]
-  const base: NetworkInventory = {
-    id: net,
-    chain: meta.chain,
-    env: meta.env,
-    label: meta.label,
-    status: 'not-reporting',
-    validators: 0,
-    peers: 0,
-    nodes: [],
-    chains: [],
-  }
-
-  const ctrl = new AbortController()
-  const timer = setTimeout(() => ctrl.abort(), TIMEOUT_MS)
-  try {
-    const [valR, peerR, verR, hgtR, chainR] = await Promise.allSettled([
-      rpc<{ validators?: RawValidator[] }>(host, '/v1/bc/P', 'platform.getCurrentValidators', ctrl.signal),
-      rpc<{ numPeers?: string; peers?: RawPeer[] }>(host, '/v1/info', 'info.peers', ctrl.signal),
-      rpc<{ version?: string }>(host, '/v1/info', 'info.getNodeVersion', ctrl.signal),
-      rpc<{ height?: string }>(host, '/v1/bc/P', 'platform.getHeight', ctrl.signal),
-      rpc<{ blockchains?: RawBlockchain[] }>(host, '/v1/bc/P', 'platform.getBlockchains', ctrl.signal),
-    ])
-
-    const reachable =
-      valR.status === 'fulfilled' || peerR.status === 'fulfilled' || chainR.status === 'fulfilled'
-    if (!reachable) {
-      const reason =
-        valR.status === 'rejected'
-          ? valR.reason
-          : peerR.status === 'rejected'
-            ? peerR.reason
-            : chainR.status === 'rejected'
-              ? chainR.reason
-              : null
-      base.error = reason instanceof Error ? reason.message : 'unreachable'
-      return base
-    }
-
-    const validators = valR.status === 'fulfilled' ? valR.value?.validators : undefined
-    const peers = peerR.status === 'fulfilled' ? peerR.value?.peers : undefined
-    const nodes = combineInventory(validators, peers, net)
-
-    base.status = 'reporting'
-    base.nodes = nodes
-    base.validators = nodes.filter((n) => n.role === 'validator').length
-    base.peers = nodes.filter((n) => n.role === 'peer').length
-    if (verR.status === 'fulfilled') base.version = verR.value?.version
-    if (hgtR.status === 'fulfilled') base.height = parseHeight(hgtR.value?.height)
-    // Chains are best-effort: a network can report validators/peers yet not answer
-    // getBlockchains — then the chains list is honestly empty (no fabricated chains).
-    if (chainR.status === 'fulfilled') base.chains = normalizeChains(chainR.value?.blockchains)
-    return base
-  } catch (e) {
-    base.error = e instanceof Error ? e.message : String(e)
-    return base
-  } finally {
-    clearTimeout(timer)
-  }
-}
-
-async function forward(req: NextRequest, path: string[]): Promise<NextResponse> {
-  // ONE endpoint — the inventory. No arbitrary RPC pass-through. This handler lives at
-  // `app/v1/nodes/[...path]`, so the catch-all captures the sub-path after `/v1/nodes/`.
-  if (path.join('/') !== 'inventory') {
-    return NextResponse.json({ error: 'not found' }, { status: 404 })
-  }
-
-  const user = await resolveUser(req)
-  if (!user) {
-    return NextResponse.json({ error: 'Sign in to view node infrastructure.' }, { status: 401 })
-  }
-
-  const brand = brandFromHost(req.headers.get('host'))
-  let networks = nodeNetworksForBrand(brand)
-
-  // Optional single-network scope, still gated by the brand's allowed set.
-  const only = req.nextUrl.searchParams.get('network') as NodeNetworkId | null
-  if (only) networks = networks.filter((n) => n === only)
-
-  const inventory = await Promise.all(networks.map(probe))
-  return NextResponse.json({ brand, networks: inventory })
-}
-
-type Ctx = { params: Promise<{ path: string[] }> }
-
-export async function GET(req: NextRequest, ctx: Ctx) {
-  return forward(req, (await ctx.params).path)
-}

app/v1/plans/[...path]/route.ts

@@ -1,67 +0,0 @@
-/**
- * Same-origin user-bearer proxy to commerce for the PLATFORM PLAN admin surface
- * (`/v1/plans/entries` + `/v1/plans/seed`) — the SuperAdmin CMS for the subscription/DNS
- * plan authority (`models/plan`, the source of truth `GET /v1/billing/plans` and the
- * internal-ledger renewal charge derive from).
- *
- * The browser calls this OWN-origin route (`/v1/plans/...`) with just its session
- * cookie; `forwardWithUserBearer` resolves the user, mints a short-lived user-bound IAM
- * token, and forwards to commerce with that Bearer. Commerce's `requireSuperAdmin`
- * (owner=="admin") is the AUTHORITATIVE gate: the plan authority is cross-tenant
- * `system`-namespace PRICING data — a plan's price is the real renewal charge — so an
- * org-level admin is refused 403. The org is server-authoritative (the Bearer owner).
- *
- * The ADMIN twin of the tenant `/v1/commerce/*` store proxy and the sibling
- * `/v1/catalog/*` proxy: a DISTINCT least-privilege boundary (`allowPlansSurface`) that
- * admits ONLY the plan entries + seed paths, so it can never tunnel commerce's
- * `/v1/billing`, `/v1/checkout`, `/_/commerce/tenants`, or the merchant store models. It
- * lives at `app/v1/plans/[...path]` — MORE SPECIFIC than the `app/v1/[...path]` cloud BFF
- * catch-all, so Next resolves `/v1/plans/*` here. The path is `/v1/plans/*` (the REAL
- * commerce mount), so the go:embed console (BFF pruned) reaches the SAME path on the
- * cloud binary's embedded commerce directly.
- */
-import { type NextRequest } from 'next/server'
-
-import { forwardWithUserBearer } from '~/lib/server/bearer-proxy'
-import { allowPlansSurface } from '~/lib/server/proxy-allow'
-
-export const runtime = 'nodejs'
-
-const trim = (s: string) => s.replace(/\/+$/, '')
-/** Commerce API (commerce.hanzo.ai). In-cluster ClusterIP on :8001; the CR wires
- *  `COMMERCE_URL` (public egress is CF-gated). Override per-deploy / for local dev. */
-const COMMERCE_URL = trim(process.env.COMMERCE_URL ?? 'http://commerce.hanzo.svc:8001')
-
-type Ctx = { params: Promise<{ path: string[] }> }
-
-function handle(req: NextRequest, ctx: Ctx) {
-  return (async () => {
-    // This handler lives under `app/v1/plans/[...path]`, so the catch-all captures ONLY
-    // the sub-path after `/v1/plans/` (e.g. `entries`, `entries/pro`, `seed`). Commerce
-    // serves the plan admin CRUD at `/v1/plans/*`, so re-root the upstream path at
-    // `v1/plans/` — the same path `allowPlansSurface` and `forwardWithUserBearer` see.
-    const path = `v1/plans/${(await ctx.params).path.join('/')}`
-    return forwardWithUserBearer(req, {
-      target: COMMERCE_URL,
-      path,
-      allow: allowPlansSurface,
-      // Org is authoritative (Bearer owner). Do NOT forward browser X-Project-Id/
-      // X-Environment — the plan authority is platform-global and commerce gates on the
-      // SuperAdmin home-org from the token.
-      unauthorizedMessage: 'Sign in as an administrator to edit plans.',
-    })
-  })()
-}
-
-export async function GET(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function POST(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function PUT(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function DELETE(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}

app/v1/superbase/[...path]/route.ts

@@ -1,65 +0,0 @@
-/**
- * Per-user proxy to the Hanzo Base control plane (base.hanzo.ai) — the embedded
- * Base module's ONE transport. The browser calls console2's OWN origin
- * (`/v1/superbase/...`) with just the session cookie; `forwardWithUserBearer`
- * resolves the user, mints a short-lived user-bound IAM token (shared per-user
- * cache), and forwards to base.hanzo.ai with that token. No token ever reaches the
- * browser, and the SAME @hanzo/superbase-dashboard screens render here and standalone.
- *
- * NOT the PaaS pattern: PaaS forwards a god-mode SERVICE token and is gated to brand
- * admins. Base authorizes PER USER itself — the `tenants` collection's
- * `ListRule = "owner_iam_user = @request.auth.id"` and admin-only mutations are
- * enforced by Base against the forwarded user identity. So here we forward the
- * USER's own minted bearer (least privilege, tenant-scoped by Base), and the only
- * gate is "must be signed in" (resolveUser → 401). A non-admin simply sees their own
- * tenants and gets Base's 403 on a mutation — honest, not faked.
- *
- * Least privilege on the path too: only the Base DATA PLANE is proxied — the
- * collection schemas (read) and any collection's records (list/get/create/update/
- * delete), via `allowBaseSurface`. Base's admin/settings/backup/log surfaces 404,
- * so this stays a data-plane proxy, not a general Base tunnel. Base still authorizes
- * every read/write per-user and per-collection itself, so a non-admin sees only what
- * a collection's rules permit and gets Base's own honest 403 on a denied mutation.
- * (The tenants manager rides this same proxy — records/tenants is one such path.)
- */
-import { type NextRequest } from 'next/server'
-
-import { forwardWithUserBearer } from '~/lib/server/bearer-proxy'
-import { allowBaseSurface } from '~/lib/server/proxy-allow'
-
-export const runtime = 'nodejs'
-
-const trim = (s: string) => s.replace(/\/+$/, '')
-/** The Base control plane the proxied calls are forwarded to. */
-const BASE_URL = trim(process.env.BASE_DASHBOARD_URL ?? 'https://base.hanzo.ai')
-
-type Ctx = { params: Promise<{ path: string[] }> }
-
-function handle(req: NextRequest, ctx: Ctx) {
-  return (async () => {
-    // This handler lives under `app/v1/superbase/[...path]`, so the catch-all captures
-    // ONLY the sub-path after `/v1/superbase/` (e.g. `collections/...`). Base serves its
-    // data plane under `/v1/collections`, so re-root the upstream path at `v1/` — the same
-    // path `allowBaseSurface` and `forwardWithUserBearer` see (`v1/collections/...`).
-    const path = `v1/${(await ctx.params).path.join('/')}`
-    return forwardWithUserBearer(req, {
-      target: BASE_URL,
-      path,
-      allow: allowBaseSurface,
-      unauthorizedMessage: 'Sign in to manage Base records.',
-    })
-  })()
-}
-
-export async function GET(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function POST(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function PATCH(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function DELETE(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}

app/v1/trading/[...path]/route.ts

@@ -1,185 +0,0 @@
-/**
- * Per-user proxy to the LIVE trading-bot state — the Trading module's ONE
- * live-data transport (the DEPLOYED FLEET is read separately via the `/v1`
- * PaaS proxy). The browser calls console2's OWN origin (`/v1/trading/*`) with just
- * the session cookie; this handler resolves the caller, resolves the BRAND from the
- * request host, and reads the allowlisted upstreams server-side, per network that
- * brand may see. No cluster host or RPC method ever reaches the browser, and the
- * browser can never choose either.
- *
- * Security (mirrors app/nodes/[...path]/route.ts):
- *  - Session-gated: an unauthenticated caller gets 401.
- *  - Org/brand-aware: the network set is scoped by `nodeNetworksForBrand(brand)`,
- *    brand resolved from the host — cloud.lux.cloud sees only Lux networks.
- *  - Least privilege: the ONLY paths are `metrics` and `orderbook`; the ONLY
- *    upstreams are the maker's :2112 /metrics scrape and the DEX read endpoint —
- *    this is not a general RPC/HTTP tunnel.
- *
- * Two upstreams, one concern each:
- *  1. METRICS — GETs the in-cluster maker's Prometheus `:2112/metrics` for a
- *     network and parses it to `MakerStatus`. The maker Service host per network is
- *     env-configurable; unset/unreachable → an honest `not-reporting` status.
- *  2. ORDERBOOK — reads the DEX CLOB `dex_get_orders?market=<poolHex>` for a market
- *     on a network. The DEX read host is env-configurable; the private D-Chain is
- *     not publicly exposed, so an unreachable venue → an honest `not-reporting` book
- *     (never fabricated bids/asks).
- */
-import { type NextRequest, NextResponse } from 'next/server'
-
-import { brandFromHost } from '~/config'
-import { resolveUser } from '~/lib/server/identity'
-import { nodeNetworksForBrand, type NodeNetworkId } from '~/lib/products/brand-scope'
-import { fetchWithTimeout } from '~/lib/server/fetch-timeout'
-import {
-  parseMakerMetrics,
-  normalizeBook,
-  type MakerStatus,
-  type OrderBook,
-  type RawBookOrder,
-} from '~/lib/api/trading'
-
-export const runtime = 'nodejs'
-
-const trim = (s: string) => s.replace(/\/+$/, '')
-
-/**
- * The maker's Prometheus metrics host per network — the ONLY metrics endpoint this
- * proxy will scrape. These point at the in-cluster maker Service (`maker-coherence`,
- * port 2112) per luxd network namespace. Each is overridable per-deploy; an
- * unset/unreachable host yields an honest `not-reporting` status — never fake rows.
- * (Cross-cluster reach depends on network policy; when unreachable the console shows
- * the honest not-reporting state, exactly like the Nodes surface.)
- */
-const MAKER_METRICS_HOSTS: Partial<Record<NodeNetworkId, string>> = {
-  'lux-mainnet': trim(process.env.MAKER_METRICS_MAINNET ?? 'http://maker-coherence.lux-mainnet.svc:2112'),
-  'lux-testnet': trim(process.env.MAKER_METRICS_TESTNET ?? 'http://maker-coherence.lux-testnet.svc:2112'),
-  'lux-devnet': trim(process.env.MAKER_METRICS_DEVNET ?? 'http://maker-coherence.lux-devnet.svc:2112'),
-}
-
-/**
- * The DEX read host per network — the ONLY DEX endpoint this proxy will query for
- * the order book (`<host>/dex/dex_get_orders?market=<poolHex>`). The native D-Chain
- * CLOB is not publicly exposed, so these default to the in-cluster luxd router;
- * unreachable → an honest `not-reporting` book.
- */
-const DEX_READ_HOSTS: Partial<Record<NodeNetworkId, string>> = {
-  'lux-mainnet': trim(process.env.DEX_READ_MAINNET ?? 'http://luxd-0.luxd-headless.lux-mainnet.svc:9630/v1/bc/D'),
-  'lux-testnet': trim(process.env.DEX_READ_TESTNET ?? 'http://luxd-0.luxd-headless.lux-testnet.svc:9640/v1/bc/D'),
-  'lux-devnet': trim(process.env.DEX_READ_DEVNET ?? 'http://luxd-0.luxd-headless.lux-devnet.svc:9650/v1/bc/D'),
-}
-
-/** Per-upstream probe timeout (ms). */
-const TIMEOUT_MS = Number(process.env.TRADING_TIMEOUT_MS ?? 8000)
-
-/** Scrape ONE network's maker metrics → MakerStatus. Honest not-reporting on failure. */
-async function makerStatus(net: NodeNetworkId): Promise<MakerStatus> {
-  const host = MAKER_METRICS_HOSTS[net]
-  const base: MakerStatus = { status: 'not-reporting', symbols: [] }
-  if (!host) {
-    base.error = 'no metrics host configured for this network'
-    return base
-  }
-  try {
-    const res = await fetchWithTimeout(
-      `${host}/metrics`,
-      { headers: { accept: 'text/plain' }, cache: 'no-store' },
-      { timeoutMs: TIMEOUT_MS },
-    )
-    if (!res.ok) {
-      base.error = `metrics ${res.status}`
-      return base
-    }
-    const text = await res.text()
-    const parsed = parseMakerMetrics(text)
-    return { status: 'reporting', ...parsed }
-  } catch (e) {
-    base.error = e instanceof Error ? e.message : String(e)
-    return base
-  }
-}
-
-/** A single allowlisted DEX read call. `method` is fixed here (dex_get_orders). */
-async function dexGetOrders(host: string, poolHex: string): Promise<RawBookOrder[]> {
-  const url = `${host}/dex/dex_get_orders?market=${encodeURIComponent(poolHex)}`
-  const res = await fetchWithTimeout(url, { headers: { accept: 'application/json' }, cache: 'no-store' }, { timeoutMs: TIMEOUT_MS })
-  if (!res.ok) throw new Error(`dex_get_orders ${res.status}`)
-  const json = (await res.json()) as { orders?: RawBookOrder[] }
-  return Array.isArray(json?.orders) ? json.orders : []
-}
-
-/**
- * Read ONE market's order book. A `poolId` (32-byte hex) addresses the book
- * directly; a `symbol`/`base`/`quote` are echoed for display but the book is only
- * readable by poolId (the console does not compute keccak client- or server-side to
- * avoid an eth-crypto dep — the caller supplies the poolId, or the book is honestly
- * not-reporting). Honest not-reporting when the DEX is unreachable.
- */
-async function orderbook(net: NodeNetworkId, params: URLSearchParams): Promise<OrderBook> {
-  const symbol = params.get('symbol') ?? undefined
-  const poolId = params.get('poolId') ?? undefined
-  const base: OrderBook = { network: net, symbol, poolId, status: 'not-reporting', orders: [] }
-
-  const host = DEX_READ_HOSTS[net]
-  if (!host) {
-    base.error = 'no DEX read host configured for this network'
-    return base
-  }
-  if (!poolId) {
-    // No poolId → the book can't be addressed. Honest, never fabricated.
-    base.error = 'order book is read by poolId; none supplied for this market'
-    return base
-  }
-  try {
-    const raw = await dexGetOrders(host, poolId)
-    return { ...base, status: 'reporting', orders: normalizeBook(raw), error: undefined }
-  } catch (e) {
-    base.error = e instanceof Error ? e.message : String(e)
-    return base
-  }
-}
-
-/** Resolve the brand's networks, optionally narrowed to `?network=` (still gated). */
-function scopedNetworks(req: NextRequest): NodeNetworkId[] {
-  const brand = brandFromHost(req.headers.get('host'))
-  let networks = nodeNetworksForBrand(brand)
-  const only = req.nextUrl.searchParams.get('network') as NodeNetworkId | null
-  if (only) networks = networks.filter((n) => n === only)
-  return networks
-}
-
-async function forward(req: NextRequest, path: string[]): Promise<NextResponse> {
-  const route = path.join('/')
-
-  const user = await resolveUser(req)
-  if (!user) {
-    return NextResponse.json({ error: 'Sign in to view trading bots.' }, { status: 401 })
-  }
-
-  if (route === 'metrics') {
-    const networks = scopedNetworks(req)
-    // A single-network scope is the common case (per-bot status); return the first
-    // (the network the caller asked for), or the brand's first if none specified.
-    const net = networks[0]
-    if (!net) return NextResponse.json({ status: 'not-reporting', symbols: [], error: 'no network in scope' })
-    const status = await makerStatus(net)
-    return NextResponse.json(status)
-  }
-
-  if (route === 'orderbook') {
-    const networks = scopedNetworks(req)
-    const net = networks[0]
-    if (!net) {
-      return NextResponse.json({ network: null, status: 'not-reporting', orders: [], error: 'no network in scope' })
-    }
-    const book = await orderbook(net, req.nextUrl.searchParams)
-    return NextResponse.json(book)
-  }
-
-  return NextResponse.json({ error: 'not found' }, { status: 404 })
-}
-
-type Ctx = { params: Promise<{ path: string[] }> }
-
-export async function GET(req: NextRequest, ctx: Ctx) {
-  return forward(req, (await ctx.params).path)
-}

app/v1/vm/[...path]/route.ts

@@ -1,67 +0,0 @@
-/**
- * Same-origin user-bearer proxy to Visor (vm.hanzo.ai) — the compute control plane
- * (regions / gpus / machines / instances). The browser calls this OWN-origin route
- * (`/v1/vm/...`) with just its session cookie; `forwardWithUserBearer` resolves the
- * user, mints a short-lived user-bound IAM token, and forwards to visor with that
- * Bearer. Visor mints org + user from the JWT claims, so compute is org-scoped
- * server-side — a caller only ever sees their own org's machines. No token reaches
- * the browser.
- *
- * NOT the `/paas` pattern: `/paas` forwards a god-mode control-plane SERVICE token
- * and is gated to brand admins. Compute is a TENANT action (any signed-in org user
- * may list/manage their own machines), so this is user-scoped (resolveUser), and
- * visor itself authorizes the forwarded user bearer.
- *
- * Least privilege on the path: only the visor `v1/*` surface is reachable
- * (`allowVisorSurface`); anything else 404s.
- */
-import { type NextRequest } from 'next/server'
-
-import { forwardWithUserBearer } from '~/lib/server/bearer-proxy'
-import { allowVisorSurface } from '~/lib/server/proxy-allow'
-
-export const runtime = 'nodejs'
-
-const trim = (s: string) => s.replace(/\/+$/, '')
-/** Visor (vm.hanzo.ai). In-cluster ClusterIP on :19000 (its Service has NO :80) — public
- *  egress is CF-403'd. Override with VISOR_URL (the CR sets visor.hanzo.svc:19000).
- *  `|| default` (not `??`): if the env is reconciled to an EMPTY string (observed drift on
- *  the live pod), `??` would keep the blank and every machines/GPUs call would fail —
- *  `|| default` treats blank/whitespace as unset so visor ALWAYS resolves. */
-const VISOR_URL = trim(process.env.VISOR_URL?.trim() || 'http://visor.hanzo.svc:19000')
-
-type Ctx = { params: Promise<{ path: string[] }> }
-
-function handle(req: NextRequest, ctx: Ctx) {
-  return (async () => {
-    // This handler lives under `app/v1/vm/[...path]`, so the catch-all captures ONLY the
-    // sub-path after `/v1/vm/` (e.g. `regions`). Visor serves its compute surface under
-    // `/v1/<x>`, so re-root the upstream path at `v1/` — the same path `allowVisorSurface`
-    // and `forwardWithUserBearer` see (`v1/regions`).
-    const path = `v1/${(await ctx.params).path.join('/')}`
-    return forwardWithUserBearer(req, {
-      target: VISOR_URL,
-      path,
-      allow: allowVisorSurface,
-      // Org is authoritative (Bearer owner). Don't forward browser X-Project-Id/
-      // X-Environment (unvalidated sub-scopes) — RED MEDIUM.
-      unauthorizedMessage: 'Sign in to manage compute.',
-    })
-  })()
-}
-
-export async function GET(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function POST(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function PUT(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function PATCH(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}
-export async function DELETE(req: NextRequest, ctx: Ctx) {
-  return handle(req, ctx)
-}

careers

@@ -0,0 +1,13 @@
+_We are Hiring_
+Join us in scaling Langfuse in Berlin, Germany. We are an open source company, we hire in person, we are only hiring technical talent.
+
+_Open Roles_
+
+- Product Engineer, 70-130k EUR, 0.25-0.75% Equity, https://www.ycombinator.com/companies/langfuse/jobs/aAvmoFB-product-engineer
+- Developer Advocate, 60-110k EUR, 0.25-0.5% Equity, https://www.ycombinator.com/companies/langfuse/jobs/uHysbKH-developer-advocate-devrel
+
+_More Info_
+
+- https://langfuse.com/careers
+- https://langfuse.com/docs
+- https://langfuse.com/changelog

css-modules.d.ts

@@ -1,9 +0,0 @@
-// TypeScript 7 reports TS2882 for a side-effect import with no type
-// declaration ("Cannot find module or type declarations for side-effect import
-// of './globals.css'"). TS 5.x let these pass silently.
-//
-// Next.js resolves stylesheet imports through its own loader pipeline, so these
-// specifiers never reach the TypeScript module resolver at build time. The
-// ambient declaration exists to tell the checker they are legitimate, not to
-// give them a shape — hence no exported members.
-declare module '*.css';

css.d.ts

@@ -1,5 +0,0 @@
-// Side-effect CSS imports (`import './globals.css'`, `import '@hanzogui/core/reset.css'`).
-// The bundler owns them; TypeScript only needs to know the specifier resolves.
-// TS7 (tsgo) errors on an unresolvable side-effect import (TS2882) where tsc stayed
-// silent, so the declaration lives here — one place, every stylesheet.
-declare module '*.css'

docker-compose.build.yml

@@ -0,0 +1,88 @@
+version: "3.5"
+
+services:
+  server:
+    build:
+      dockerfile: ./web/Dockerfile
+      context: .
+      args:
+        - NEXT_PUBLIC_LANGFUSE_CLOUD_REGION=${NEXT_PUBLIC_LANGFUSE_CLOUD_REGION}
+    depends_on:
+      - db
+      - redis
+    ports:
+      - "3000:3000"
+    environment:
+      - DATABASE_URL=postgresql://postgres:postgres@db:5432/postgres
+      - NEXTAUTH_SECRET=mysecret
+      - SALT=mysalt
+      - ENCRYPTION_KEY=0000000000000000000000000000000000000000000000000000000000000000 # generate via `openssl rand -hex 32`
+      - NEXTAUTH_URL=http://localhost:3000
+      - TELEMETRY_ENABLED=${TELEMETRY_ENABLED:-true}
+      - LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES=${LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES:-false}
+      - LANGFUSE_INIT_ORG_ID=${LANGFUSE_INIT_ORG_ID:-}
+      - LANGFUSE_INIT_ORG_NAME=${LANGFUSE_INIT_ORG_NAME:-}
+      - LANGFUSE_INIT_PROJECT_ID=${LANGFUSE_INIT_PROJECT_ID:-}
+      - LANGFUSE_INIT_PROJECT_NAME=${LANGFUSE_INIT_PROJECT_NAME:-}
+      - LANGFUSE_INIT_PROJECT_PUBLIC_KEY=${LANGFUSE_INIT_PROJECT_PUBLIC_KEY:-}
+      - LANGFUSE_INIT_PROJECT_SECRET_KEY=${LANGFUSE_INIT_PROJECT_SECRET_KEY:-}
+      - LANGFUSE_INIT_USER_EMAIL=${LANGFUSE_INIT_USER_EMAIL:-}
+      - LANGFUSE_INIT_USER_NAME=${LANGFUSE_INIT_USER_NAME:-}
+      - LANGFUSE_INIT_USER_PASSWORD=${LANGFUSE_INIT_USER_PASSWORD:-}
+    restart: always
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000/api/public/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+
+  worker:
+    build:
+      dockerfile: ./worker/Dockerfile
+      context: .
+      args:
+        - NEXT_PUBLIC_LANGFUSE_CLOUD_REGION=${NEXT_PUBLIC_LANGFUSE_CLOUD_REGION}
+    depends_on:
+      - db
+      - redis
+    ports:
+      - "3030:3030"
+    environment:
+      - DATABASE_URL=postgresql://postgres:postgres@db:5432/postgres
+      - NEXTAUTH_SECRET=mysecret
+      - TELEMETRY_ENABLED=${TELEMETRY_ENABLED:-true}
+      - LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES=${LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES:-false}
+      - PORT=${PORT:-3030}
+      - REDIS_HOST=${REDIS_HOST:-redis}
+      - REDIS_PORT=${REDIS_PORT:-6379}
+      - REDIS_AUTH=${REDIS_AUTH:-myredissecret}
+    restart: always
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3030/api/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+
+  redis:
+    image: redis:7.2.4
+    command: >
+      --requirepass ${REDIS_AUTH:-myredissecret}
+    restart: always
+    ports:
+      - 6379:6379
+
+  db:
+    image: postgres
+    restart: always
+    environment:
+      - POSTGRES_USER=postgres
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_DB=postgres
+    ports:
+      - 5432:5432
+    volumes:
+      - database_data:/var/lib/postgresql/data
+
+volumes:
+  database_data:
+    driver: local

docker-compose.dev-azure.yml

@@ -0,0 +1,63 @@
+services:
+  clickhouse:
+    image: clickhouse/clickhouse-server
+    user: "101:101"
+    container_name: clickhouse
+    hostname: clickhouse
+    environment:
+      CLICKHOUSE_DB: default
+      CLICKHOUSE_USER: clickhouse
+      CLICKHOUSE_PASSWORD: clickhouse
+    volumes:
+      - langfuse_clickhouse_data:/var/lib/clickhouse
+      - langfuse_clickhouse_logs:/var/log/clickhouse-server
+    ports:
+      - "8123:8123"
+      - "9000:9000"
+    depends_on:
+      - postgres
+
+  azurite:
+    image: mcr.microsoft.com/azure-storage/azurite
+    container_name: azurite
+    command: azurite-blob --blobHost 0.0.0.0
+    ports:
+      - "10000:10000"
+    volumes:
+      - langfuse_azurite_data:/data
+
+  redis:
+    image: redis:7.2.4
+    restart: always
+    command: >
+      --requirepass ${REDIS_AUTH:-myredissecret}
+    ports:
+      - 6379:6379
+
+  postgres:
+    image: postgres:${POSTGRES_VERSION:-latest}
+    restart: always
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 3s
+      timeout: 3s
+      retries: 10
+    command: ["postgres", "-c", "log_statement=all"]
+    environment:
+      - POSTGRES_USER=postgres
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_DB=postgres
+    ports:
+      - 5432:5432
+    volumes:
+      - langfuse_postgres_data:/var/lib/postgresql/data
+
+volumes:
+  langfuse_postgres_data:
+    driver: local
+  langfuse_clickhouse_data:
+    driver: local
+  langfuse_clickhouse_logs:
+    driver: local
+  langfuse_azurite_data:
+    driver: local