Add full Next.js autotrader app with SQLite persistence and live Tradovate data

- SQLite DB (better-sqlite3) with firms, account_configs, firm_fees, instruments tables
- REST API routes: firms CRUD, account configs CRUD, state, accounts, instruments
- Live Tradovate WebSocket client: login, sync, positions, auto-liq thresholds
- Dashboard (app/page.tsx): per-firm account list with balance, day P&L, days traded,
  target progress, and Dead/Inactive/Flat status based on Tradovate auto-liq floors
- Account detail page: objectives progress, daily P&L chart, consistency tracking
- Per-firm settings page: account configs and instrument fee management
- Dead detection uses trailingMaxDrawdownLimit - trailingMaxDrawdown from
  userAccountAutoLiqs; filters Tradovate sentinel value (999999999 = no limit)
- FIFO P&L engine with commission accounting for daily P&L history
- Removed manual maxLoss fallback in favour of live Tradovate auto-liq data

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

app/api/firms/[id]/accounts/route.ts

@@ -0,0 +1,67 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getFirmById, createAccountConfig } from '@/lib/db';
+
+export async function POST(
+    req: NextRequest,
+    { params }: { params: Promise<{ id: string }> }
+) {
+    const { id: idStr } = await params;
+    const firmId = parseInt(idStr, 10);
+
+    if (isNaN(firmId)) {
+        return NextResponse.json({ error: 'Invalid firm id' }, { status: 400 });
+    }
+
+    if (!getFirmById(firmId)) {
+        return NextResponse.json({ error: 'Firm not found' }, { status: 404 });
+    }
+
+    const body = await req.json() as {
+        prefix?: string;
+        profitTarget?: number;
+        consistency?: number;
+        minDayPnL?: number;
+        minTradingDays?: number;
+        accountSize?: number;
+        maxLoss?: number;
+    };
+
+    const { prefix, profitTarget, consistency, minDayPnL, minTradingDays, accountSize, maxLoss } = body;
+
+    if (
+        typeof prefix !== 'string' || !prefix.trim() ||
+        typeof profitTarget !== 'number' ||
+        typeof consistency !== 'number' ||
+        typeof minDayPnL !== 'number' ||
+        typeof minTradingDays !== 'number' ||
+        typeof accountSize !== 'number'
+    ) {
+        return NextResponse.json({ error: 'Invalid body' }, { status: 400 });
+    }
+
+    try {
+        const row = createAccountConfig(firmId, {
+            prefix: prefix.trim(),
+            profitTarget,
+            consistency,
+            minDayPnL,
+            minTradingDays,
+            accountSize,
+            maxLoss: maxLoss ?? 0,
+        });
+
+        return NextResponse.json({
+            id: row.id,
+            prefix: row.prefix,
+            profitTarget: row.profit_target,
+            consistency: row.consistency,
+            minDayPnL: row.min_day_pnl,
+            minTradingDays: row.min_trading_days,
+            accountSize: row.account_size,
+            maxLoss: row.max_loss,
+        }, { status: 201 });
+    } catch (err) {
+        console.error('[POST /api/firms/:id/accounts]', err);
+        return NextResponse.json({ error: 'Failed to create account type' }, { status: 500 });
+    }
+}

app/api/firms/[id]/instrument-configs/[instrumentId]/route.ts

@@ -0,0 +1,41 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { upsertFirmInstrumentConfig } from '@/lib/db';
+
+export async function PUT(
+    req: NextRequest,
+    { params }: { params: Promise<{ id: string; instrumentId: string }> }
+) {
+    const { id: idStr, instrumentId: instrIdStr } = await params;
+    const firmId = parseInt(idStr, 10);
+    const instrumentId = parseInt(instrIdStr, 10);
+
+    if (isNaN(firmId) || isNaN(instrumentId)) {
+        return NextResponse.json({ error: 'Invalid id' }, { status: 400 });
+    }
+
+    const body = await req.json() as {
+        allinFee?: number;
+        roundtripFee?: number;
+        banned?: boolean;
+    };
+
+    if (
+        typeof body.allinFee !== 'number' ||
+        typeof body.roundtripFee !== 'number' ||
+        typeof body.banned !== 'boolean'
+    ) {
+        return NextResponse.json({ error: 'Invalid body' }, { status: 400 });
+    }
+
+    try {
+        upsertFirmInstrumentConfig(firmId, instrumentId, {
+            allinFee: body.allinFee,
+            roundtripFee: body.roundtripFee,
+            banned: body.banned,
+        });
+        return NextResponse.json({ success: true });
+    } catch (err) {
+        console.error('[PUT /api/firms/:id/instrument-configs/:instrumentId]', err);
+        return NextResponse.json({ error: 'Failed to save config' }, { status: 500 });
+    }
+}

app/api/firms/[id]/instrument-configs/route.ts

@@ -0,0 +1,21 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getFirmFees } from '@/lib/db';
+
+export async function GET(
+    _req: NextRequest,
+    { params }: { params: Promise<{ id: string }> }
+) {
+    const { id: idStr } = await params;
+    const firmId = parseInt(idStr, 10);
+
+    if (isNaN(firmId)) {
+        return NextResponse.json({ error: 'Invalid firm id' }, { status: 400 });
+    }
+
+    try {
+        return NextResponse.json(getFirmFees(firmId));
+    } catch (err) {
+        console.error('[GET /api/firms/:id/instrument-configs]', err);
+        return NextResponse.json({ error: 'Failed to fetch fees' }, { status: 500 });
+    }
+}

app/api/firms/[id]/route.ts

@@ -1,7 +1,40 @@
 import { NextRequest, NextResponse } from 'next/server';
-import { deleteFirm } from '@/lib/db';
+import { getFirmById, deleteFirm } from '@/lib/db';
 import { removeClient } from '@/lib/clients';
 
+export async function GET(
+    _req: NextRequest,
+    { params }: { params: Promise<{ id: string }> }
+) {
+    const { id: idStr } = await params;
+    const id = parseInt(idStr, 10);
+
+    if (isNaN(id)) {
+        return NextResponse.json({ error: 'Invalid id' }, { status: 400 });
+    }
+
+    const firm = getFirmById(id);
+    if (!firm) {
+        return NextResponse.json({ error: 'Firm not found' }, { status: 404 });
+    }
+
+    return NextResponse.json({
+        id: firm.id,
+        firm: firm.name,
+        username: firm.username,
+        password: firm.password,
+        accounts: firm.accounts.map((a) => ({
+            id: a.id,
+            prefix: a.prefix,
+            profitTarget: a.profit_target,
+            consistency: a.consistency,
+            minDayPnL: a.min_day_pnl,
+            minTradingDays: a.min_trading_days,
+            accountSize: a.account_size,
+        })),
+    });
+}
+
 export async function DELETE(
     _req: NextRequest,
     { params }: { params: Promise<{ id: string }> }