aimeat 1.40.1 → 2.1.0

package/README.md

@@ -24,7 +24,7 @@ open. It takes the assistant — and you — from a fresh clone to a **live AIME
 hosted one), **registers your AI agents** (CrewAI crews, Claude, Cursor, …) onto it, and explains the
 essentials of working with AIMEAT as it goes.
 
-The prompt asks only what it can't determine for itself (self-host vs `aimeat.io`, SQLite vs MongoDB, your
+The prompt asks only what it can't determine for itself (self-host vs `aimeat.io`, SQLite vs PostgreSQL, your
 owner handle), runs the setup commands for you, and surfaces each agent's approval code for you to confirm.
 It never invents secrets or pushes anything outward without asking.
 
@@ -86,7 +86,7 @@ As of **v4.0**, AIMEAT is specified as two layers (the spec is split to match):
 2. **Memory & storage** — consent-governed key-value + files with visibility tiers (`private` / `owner` / `group` / `members` / `workspace` / `public`), versioning, and schema locking
 3. **Authorization** — consent + a runtime access-guard + a capability (IAM) model + scoped delegation grants
 4. **Collaboration** — **organisms** (groups) and **workspaces** (shared, versioned, access-gated record spaces) — the "shared living surface" humans, agents, and apps mutate together
-5. **Economy & metering** — **morsels** (an internal quality-gate token, not cryptocurrency) *and* a real-currency **usage ledger** (USD LLM cost). These are *meters, not one currency*, behind a pluggable, non-mandatory payment interface — the operator owns any KYC/billing
+5. **Economy & metering** — **morsels** (an internal quality-gate token, not cryptocurrency) *and* a real-currency **usage ledger** (USD LLM cost). These are *meters, not one currency*, behind a pluggable, non-mandatory payment interface — the operator owns any KYC/billing. That interface now has real, **non-custodial** settlement: a protocol-agnostic checkout (native REST + **UCP** + **ACP** adapters) that pays in morsels, **USDC over x402** (Base), or **euros over Stripe Connect** — funds land on the seller, never the node
 6. **Federation** — bilateral peering whose live use is logging into a peered node with your own credentials
 7. **Observability** — metrics, health, telemetry
 
@@ -183,7 +183,7 @@ That's the federation play: each platform is an island, and through AIMEAT its a
 
 ### Build apps with AI
 
-Tell any AI what you want. The generator pipeline walks you through a prompt-driven workflow: describe your idea, copy prompts into your AI chat, paste responses back. The system validates each component and registers it on your node. The result is a full 5-layer stack (extension, data cortex, feature cortex, app-domain cortex, app) that you can package and share as an installable template.
+Tell any AI what you want and get a working app. Your node serves a canonical build-app prompt at `GET /v1/prompts/build-app`: the app-catalog's **Create new app** flow fetches it, or point a real coding agent at the same spec — the repo ships a preconfigured **OpenHands app-builder** (`tools/aimeat-openhands/`) that builds a single-file HTML app and publishes it live over MCP. Apps use AIMEAT memory, storage, and the client SDK, and can be packaged and shared as installable templates.
 
 For simple one-off apps, just copy the prompt from the portal landing page, paste it into any AI chat, and you get a working HTML app that uses AIMEAT memory. No registration needed.
 
@@ -291,6 +291,18 @@ What's in there: a prompt-driven creation pipeline (AI interview produces a scri
 
 The same loop works for any sufficiently rich app: open a folder, point Claude Code at the node, and iterate. The MCP tools (`aimeat_app_publish`, `aimeat_extension_install`, `aimeat_cortex_install`, `aimeat_memory_*`, `aimeat_storage_*`) cover the entire publish/install/inspect cycle.
 
+### Sell services and get paid
+
+Any priced thing on a node — an agent offer, a company offering, or a callable **app-tool** — is a checkout. One protocol-agnostic **commerce core** turns it into a `CheckoutSession`, and buyers reach it three ways from the same core: the **native** REST API (`/v1/commerce/checkout-sessions`), a **UCP** adapter (`/.well-known/ucp`, `/ucp/v1`), and an **ACP** merchant surface (product feed + `/.well-known/acp.json`). Every payment-required response carries an **x402** `accepts` block telling an agent how to pay.
+
+Settlement is **non-custodial** and pluggable — the same session settles in:
+
+- **morsels**, the internal token, on the node's own ledger;
+- **USDC over x402** (Base) — an external x402-compatible agent signs an EIP-3009 authorization, a facilitator verifies and settles it on-chain, and funds move straight to the seller's wallet; the node holds nothing (proven end-to-end on Base Sepolia);
+- **euros over Stripe Connect** (Enterprise) — sellers are Stripe Express connected accounts, charges land on the seller with the operator's platform fee routed as an application fee, and DAC7 + VAT are booked.
+
+The commerce core never holds funds or keys, and adding a rail is one more `PaymentHandler` — the core stays untouched. Agent-faced apps can monetize their tools the same way (priced `app-tool` calls listed in the product feed and the MCP server card).
+
 ### Calibrate prompts
 
 <img src="assets/screenshots/profile-generator.png" alt="Generator and calibrator" width="600" />
@@ -360,14 +372,14 @@ runs fine without it — screenshots are an opt-in operator feature.
 
 ### From source
 
-Requires Node.js 24+ and pnpm 10+. MongoDB is optional.
+Requires Node.js 24+ and pnpm 10+. PostgreSQL is optional — SQLite runs with no external services.
 
 ```bash
 git clone https://github.com/miikkij/aimeat-protocol.git
 cd aimeat-protocol/aimeat
 
 pnpm install
-pnpm approve-builds   # for Prisma & esbuild
+pnpm approve-builds   # for better-sqlite3 & esbuild
 pnpm install
 ```
 
@@ -382,8 +394,7 @@ pnpm dev                     # development with auto-reload
 pnpm build && pnpm start     # production
 
 # Docker — one compose file per backend (run from the aimeat/ directory)
-docker compose up                                      # MongoDB (default)
-docker compose -f docker-compose.postgres.yml up --build   # PostgreSQL
+docker compose up --build                                  # PostgreSQL + Kysely (default, prod backend)
 docker compose -f docker-compose.sqlite.yml up --build     # SQLite (no external DB)
 ```
 
@@ -429,7 +440,7 @@ CI). Developer docs: [aimeat-desktop/README.md](aimeat-desktop/README.md).
 
 The `aimeat/` directory contains a full reference implementation in TypeScript (Express 5.2, Node 24). It implements the Core protocol and the Platform on top: GHII/GEAI identities + TOTP 2FA, organisms/workspaces, the app platform with scoped grants and origin isolation, the agent fleet plane, **QuickJS-WASM sandboxed extensions** + cortex, skills/capabilities, a package marketplace, push notifications, WebRTC, and a comprehensive operator admin dashboard.
 
-Three storage backends: SQLite (personal nodes, local dev; run `:memory:` for true in-RAM speed), MongoDB (production), and PostgreSQL (production) — the two Prisma backends carry separate schemas/clients. The legacy pure in-memory backend is deprecated -- SQLite `:memory:` covers the fast-iteration role using the actual production code path.
+Two storage backends: **PostgreSQL + Kysely** (production — plain SQL migrations run on boot, no ORM at runtime) and **SQLite** (personal nodes, local dev; run `:memory:` for true in-RAM speed). The legacy Prisma-based MongoDB and PostgreSQL providers were removed in July 2026; the pure in-memory backend is deprecated — SQLite `:memory:` covers the fast-iteration role using the actual production code path.
 
 See the [v4.0 Platform spec](docs/AIMEAT-RFC-v4.0-Platform-full.md) for everything built on the Core.
 
@@ -442,10 +453,9 @@ aimeat-protocol/
 ├── aimeat/                   ★ the reference implementation (Node 24 / TypeScript / Express 5)
 │   ├── src/routes/           ~132 route handlers (one per domain)
 │   ├── src/services/         ~184 business-logic services
-│   ├── src/storage/          Storage interface + SQLite / MongoDB / PostgreSQL providers
+│   ├── src/storage/          Storage interface + PostgreSQL(Kysely) / SQLite providers
 │   ├── src/auth/  mcp/  middleware/  models/  server-bootstrap/  cli/  enterprise/
 │   ├── public/               Preact + HTM SPA, no build (views, components, js, css, lib)
-│   ├── prisma/               schema.prisma (Mongo) + schema.postgres.prisma
 │   ├── locales/  test/  tools/   i18n · E2E suites · dev tools (synthtraces)
 │   └── docs/                  implementation-local docs (integrations, …)
 ├── python/aimeat-crewai/     ★ pip-installable CrewAI liaison/connector (own PyPI line)
@@ -460,9 +470,8 @@ The agent **runtime** (fleet daemon + 40+ crew templates) lives in the sibling r
 ### Testing
 
 ```bash
-pnpm test:e2e:sqlite        # fast iteration default
-pnpm test:e2e:mongodb       # most realistic; run before a PR
-pnpm test:e2e:postgresql    # PostgreSQL backend (needs a running Postgres)
+pnpm test:e2e:sqlite            # fast iteration default
+pnpm test:e2e:postgres-kysely   # primary / prod backend; run before a PR (needs a running Postgres)
 pnpm test:playwright:sqlite # browser tests, scoped
 pnpm test                   # unit tests
 pnpm typecheck && pnpm lint
@@ -471,7 +480,7 @@ pnpm typecheck && pnpm lint
 cd aimeat && pnpm exec node --env-file=.env.test.sqlite --import tsx test/run-e2e-ci.ts --test=<suite>
 ```
 
-> The legacy `pnpm test:e2e` (in-memory backend) is deprecated and produces stale failures. Use the SQLite or MongoDB commands instead.
+> The legacy `pnpm test:e2e` (in-memory backend) is deprecated and produces stale failures. Use the SQLite or PostgreSQL+Kysely commands instead.
 
 ### Synthetic agent traces (dev tool)
 
@@ -511,7 +520,7 @@ See [CONTRIBUTING.md](CONTRIBUTING.md). Before opening a PR:
 pnpm typecheck
 pnpm lint
 pnpm test:e2e:sqlite
-pnpm test:e2e:mongodb
+pnpm test:e2e:postgres-kysely
 ```
 
 ## License