TPT Production

Fully automated production platform — 3D printing, robotics, and AI agents coordinate to fulfil orders end-to-end with minimal human involvement.

Overview

TPT Production connects consumers who want custom manufactured goods with maker shops (3D printers, CNC machines, robotics cells) via an automated platform. Orders are routed, produced, and tracked without human dispatch.

| Role | What they do | |---|---| | Consumer | Browse catalog, upload designs, place orders, track in real time | | Maker | Register shop + capabilities, receive jobs, accept/complete via API or dashboard | | Supplier | External material/component vendor integrated via API config | | AI Agent | Any of the above via API key — auto-routing, auto-accepting, auto-completing | | Admin | Platform oversight — orders, routing decisions, payments, royalties |

Tech Stack

| Layer | Technology | |---|---| | API | Hono + @hono/zod-openapi | | Job Queue | BullMQ on Redis 7 | | Real-time | Socket.io (order status push) | | Database | Prisma ORM — SQLite (dev) / PostgreSQL 16 (prod) | | Payments | Stripe checkout + webhooks | | Storage | Cloudflare R2 (or local filesystem) | | Frontend | Next.js 15 App Router + shadcn/ui | | Monorepo | Turborepo + pnpm workspaces | | Containers | Docker + nginx reverse proxy |

Repository Layout

tpt-production/
├── apps/
│   ├── api/          # Hono REST API + OpenAPI + BullMQ workers
│   ├── web/          # Next.js 15 consumer marketplace
│   └── admin/        # Next.js 15 maker/admin portal
├── packages/
│   ├── db/           # Prisma schema, migrations, generated client
│   ├── types/        # Shared TypeScript enums and API types
│   ├── core/         # Routing engine, pricing, credits logic
│   └── ui/           # Shared shadcn/ui components
├── nginx/            # nginx.conf for production reverse proxy
├── docs/             # env.md, deployment.md
├── docker-compose.yml          # Dev infrastructure (Postgres + Redis)
└── docker-compose.prod.yml     # Full production stack

Quick Start

Prerequisites

Node.js 20+
pnpm 9+
Docker (for Postgres + Redis)

1. Clone & install

git clone https://github.com/PhillipT1/tpt-production.git
cd tpt-production
pnpm install

2. Configure environment

cp .env.example .env
# Edit .env — at minimum set ADMIN_API_TOKEN and ADMIN_SECRET

3. Start infrastructure

docker compose up -d   # PostgreSQL 16 on :5432, Redis 7 on :6379

4. Run database migrations

cd packages/db
pnpm migrate:dev
cd ../..

5. Start all apps

pnpm dev

| Service | URL | |---|---| | API + Swagger | http://localhost:8787 / http://localhost:8787/docs | | Consumer Web | http://localhost:3000 | | Admin Portal | http://localhost:3001 |

Feature Flags

All flags default to false except ENABLE_FREE_ECONOMY=true. Set in .env:

| Flag | What it enables | |---|---| | ENABLE_FREE_ECONOMY | All prices resolve to 0; orders route without payment | | ENABLE_CREDITS | Credit accounts, earn/spend/refund ledger | | ENABLE_PAYMENTS | Stripe checkout + webhook processing | | ENABLE_DRM | Design file DRM + royalty calculation on job completion | | ENABLE_PRICE_DECAY | Linear/exponential/step price decay schedules | | ENABLE_AI_AGENTS | API key auth, OpenAPI spec endpoint, agent webhooks |

API

The Hono API exposes ~50 endpoints documented via OpenAPI. Once running:

Swagger UI: http://localhost:8787/docs
OpenAPI JSON: http://localhost:8787/openapi.json (agent-consumable)

Authentication

| Method | Header | Used for | |---|---|---| | Admin token | Authorization: Bearer <ADMIN_API_TOKEN> or X-API-Key | Admin endpoints | | API key | X-API-Key: <key> | Agent endpoints (scoped) |

Production Deployment

See docs/deployment.md for the full guide. Quick reference:

# 1. Create .env with all production secrets
# 2. Switch DATABASE_URL to PostgreSQL connection string
# 3. Build and start
docker compose -f docker-compose.prod.yml up -d --build

The production compose file starts: PostgreSQL, Redis, a one-shot migration runner, the API, web, admin, and nginx (ports 80 + 3001).

Database: The schema defaults to SQLite for development. Before production deploy, set DATABASE_URL to a PostgreSQL connection string. See docs/deployment.md.

Development Commands

Run from repo root:

pnpm dev          # Turborepo watch mode across all packages
pnpm build        # Build all packages (cached)
pnpm lint         # ESLint across workspace
pnpm type-check   # TypeScript strict check
pnpm format       # Prettier (100-char, double quotes, 2-space)

Database (from packages/db):

pnpm migrate:dev  # Apply Prisma migrations
pnpm studio       # Open Prisma Studio

Tests:

pnpm --filter @tpt/core test       # Unit tests (routing, pricing)
pnpm --filter @tpt/api test        # Integration tests (order lifecycle)

Architecture Highlights

Routing Engine

packages/core/src/routing/ — routeOrder() scores maker candidates using:

Geo distance (Haversine formula)
Cost (listing price vs. shop cost estimate)
Capacity (available job slots)
Capabilities (material + machine type match)

Weights are env-configurable. Accepts a customScorer plugin for AI integration.

Pricing Engine

packages/core/src/pricing/ — resolvePrice() handles:

FIXED — static price
COST_PLUS — base cost + margin
FREE — zero (respects ENABLE_FREE_ECONOMY)
DECAY — linear, exponential, or step price decay over time

Order Lifecycle

Consumer places order
  → BullMQ routing job queued
  → Routing engine scores shops → FulfillmentJob created (PENDING)
  → Maker accepts (IN_PRODUCTION)
  → Maker completes → DeliveryAssignment created (IN_TRANSIT)
  → Carrier/agent pushes TrackingEvents → Socket.io broadcasts to consumer
  → DELIVERED

Contributing

See CONTRIBUTING.md. All contributions require a signed-off commit (git commit -s).

Security

To report a vulnerability, see SECURITY.md.

License

Apache License 2.0 — see LICENSE.

tpt-production

Languages