burnrate 0.1.0

package/dist/server/async-tick-server.d.ts

@@ -0,0 +1,5 @@
+/**
+ * BURNRATE Async Tick Server
+ * Processes game ticks at regular intervals using TursoDatabase
+ */
+export {};

package/dist/server/async-tick-server.js

@@ -0,0 +1,63 @@
+/**
+ * BURNRATE Async Tick Server
+ * Processes game ticks at regular intervals using TursoDatabase
+ */
+import { TursoDatabase } from '../db/turso-database.js';
+import { AsyncGameEngine } from '../core/async-engine.js';
+const TICK_INTERVAL = parseInt(process.env.BURNRATE_TICK_INTERVAL || '600000'); // 10 minutes
+async function main() {
+    console.log(`
+╔══════════════════════════════════════════════════════════════╗
+║                   BURNRATE TICK SERVER                       ║
+║              The front doesn't feed itself.                  ║
+╠══════════════════════════════════════════════════════════════╣
+║  Tick interval: ${(TICK_INTERVAL / 1000).toString().padEnd(6)}seconds                              ║
+║  Press Ctrl+C to stop                                        ║
+╚══════════════════════════════════════════════════════════════╝
+`);
+    const db = new TursoDatabase();
+    await db.initialize();
+    const engine = new AsyncGameEngine(db);
+    const currentTick = await db.getCurrentTick();
+    console.log(`[TICK SERVER] Starting at tick ${currentTick}`);
+    async function processTick() {
+        const startTime = Date.now();
+        try {
+            const result = await engine.processTick();
+            const duration = Date.now() - startTime;
+            console.log(`[TICK ${result.tick}] Processed in ${duration}ms, ${result.events.length} events`);
+            // Log significant events
+            for (const event of result.events) {
+                if (event.type === 'zone_captured') {
+                    console.log(`  → Zone ${event.data.zoneName} captured by ${event.data.newOwner || 'neutral'}`);
+                }
+                else if (event.type === 'zone_state_changed') {
+                    console.log(`  → Zone ${event.data.zoneName}: ${event.data.previousState} → ${event.data.newState}`);
+                }
+                else if (event.type === 'combat_resolved') {
+                    console.log(`  → Combat at ${event.data.location}: ${event.data.outcome}`);
+                }
+                else if (event.type === 'shipment_intercepted') {
+                    console.log(`  → Shipment intercepted: ${event.data.outcome}`);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`[TICK ERROR] ${error}`);
+        }
+    }
+    // Process first tick immediately
+    await processTick();
+    // Schedule regular ticks
+    const interval = setInterval(processTick, TICK_INTERVAL);
+    // Graceful shutdown
+    const shutdown = () => {
+        console.log('\n[TICK SERVER] Shutting down...');
+        clearInterval(interval);
+        console.log('[TICK SERVER] Stopped.');
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+main().catch(console.error);

package/dist/server/errors.d.ts

@@ -0,0 +1,78 @@
+/**
+ * BURNRATE API Error Handling
+ * Standardized error responses
+ */
+import { Context } from 'hono';
+import { ZodError } from 'zod';
+export declare const ErrorCodes: {
+    readonly MISSING_API_KEY: "MISSING_API_KEY";
+    readonly INVALID_API_KEY: "INVALID_API_KEY";
+    readonly INSUFFICIENT_TIER: "INSUFFICIENT_TIER";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+    readonly INVALID_INPUT: "INVALID_INPUT";
+    readonly RATE_LIMITED: "RATE_LIMITED";
+    readonly DAILY_LIMIT_REACHED: "DAILY_LIMIT_REACHED";
+    readonly TICK_RATE_LIMITED: "TICK_RATE_LIMITED";
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly ZONE_NOT_FOUND: "ZONE_NOT_FOUND";
+    readonly PLAYER_NOT_FOUND: "PLAYER_NOT_FOUND";
+    readonly UNIT_NOT_FOUND: "UNIT_NOT_FOUND";
+    readonly SHIPMENT_NOT_FOUND: "SHIPMENT_NOT_FOUND";
+    readonly CONTRACT_NOT_FOUND: "CONTRACT_NOT_FOUND";
+    readonly FACTION_NOT_FOUND: "FACTION_NOT_FOUND";
+    readonly NOT_YOUR_RESOURCE: "NOT_YOUR_RESOURCE";
+    readonly INSUFFICIENT_PERMISSION: "INSUFFICIENT_PERMISSION";
+    readonly NOT_IN_FACTION: "NOT_IN_FACTION";
+    readonly ALREADY_IN_FACTION: "ALREADY_IN_FACTION";
+    readonly WRONG_ZONE_TYPE: "WRONG_ZONE_TYPE";
+    readonly WRONG_LOCATION: "WRONG_LOCATION";
+    readonly INSUFFICIENT_RESOURCES: "INSUFFICIENT_RESOURCES";
+    readonly INSUFFICIENT_CREDITS: "INSUFFICIENT_CREDITS";
+    readonly NO_ROUTE: "NO_ROUTE";
+    readonly UNIT_BUSY: "UNIT_BUSY";
+    readonly LICENSE_REQUIRED: "LICENSE_REQUIRED";
+    readonly NAME_TAKEN: "NAME_TAKEN";
+    readonly ALREADY_EXISTS: "ALREADY_EXISTS";
+    readonly CONFLICT: "CONFLICT";
+    readonly INVALID_STATE: "INVALID_STATE";
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+    readonly SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+};
+export type ErrorCode = typeof ErrorCodes[keyof typeof ErrorCodes];
+export declare class GameError extends Error {
+    code: ErrorCode;
+    statusCode: number;
+    details?: Record<string, unknown> | undefined;
+    constructor(code: ErrorCode, message: string, statusCode?: number, details?: Record<string, unknown> | undefined);
+}
+export declare class ValidationError extends GameError {
+    constructor(message: string, details?: Record<string, unknown>);
+    static fromZod(error: ZodError): ValidationError;
+}
+export declare class AuthError extends GameError {
+    constructor(code: ErrorCode, message: string);
+}
+export declare class NotFoundError extends GameError {
+    constructor(resource: string, id?: string);
+}
+export declare class RateLimitError extends GameError {
+    retryAfter?: number | undefined;
+    constructor(code: ErrorCode, message: string, retryAfter?: number | undefined);
+}
+export declare class PermissionError extends GameError {
+    constructor(message: string, code?: ErrorCode);
+}
+export declare class ConflictError extends GameError {
+    constructor(message: string, code?: ErrorCode);
+}
+export interface ErrorResponse {
+    error: {
+        code: ErrorCode;
+        message: string;
+        details?: Record<string, unknown>;
+        requestId: string;
+    };
+}
+export declare function errorResponse(c: Context, error: GameError | Error, requestId?: string): Response;
+import { ZodSchema } from 'zod';
+export declare function validateBody<T>(c: Context, schema: ZodSchema<T>): Promise<T>;

package/dist/server/errors.js

@@ -0,0 +1,156 @@
+/**
+ * BURNRATE API Error Handling
+ * Standardized error responses
+ */
+import { ZodError } from 'zod';
+import { v4 as uuid } from 'uuid';
+// ============================================================================
+// ERROR CODES
+// ============================================================================
+export const ErrorCodes = {
+    // Authentication
+    MISSING_API_KEY: 'MISSING_API_KEY',
+    INVALID_API_KEY: 'INVALID_API_KEY',
+    INSUFFICIENT_TIER: 'INSUFFICIENT_TIER',
+    // Validation
+    VALIDATION_ERROR: 'VALIDATION_ERROR',
+    INVALID_INPUT: 'INVALID_INPUT',
+    // Rate Limiting
+    RATE_LIMITED: 'RATE_LIMITED',
+    DAILY_LIMIT_REACHED: 'DAILY_LIMIT_REACHED',
+    TICK_RATE_LIMITED: 'TICK_RATE_LIMITED',
+    // Resources
+    NOT_FOUND: 'NOT_FOUND',
+    ZONE_NOT_FOUND: 'ZONE_NOT_FOUND',
+    PLAYER_NOT_FOUND: 'PLAYER_NOT_FOUND',
+    UNIT_NOT_FOUND: 'UNIT_NOT_FOUND',
+    SHIPMENT_NOT_FOUND: 'SHIPMENT_NOT_FOUND',
+    CONTRACT_NOT_FOUND: 'CONTRACT_NOT_FOUND',
+    FACTION_NOT_FOUND: 'FACTION_NOT_FOUND',
+    // Permissions
+    NOT_YOUR_RESOURCE: 'NOT_YOUR_RESOURCE',
+    INSUFFICIENT_PERMISSION: 'INSUFFICIENT_PERMISSION',
+    NOT_IN_FACTION: 'NOT_IN_FACTION',
+    ALREADY_IN_FACTION: 'ALREADY_IN_FACTION',
+    // Game State
+    WRONG_ZONE_TYPE: 'WRONG_ZONE_TYPE',
+    WRONG_LOCATION: 'WRONG_LOCATION',
+    INSUFFICIENT_RESOURCES: 'INSUFFICIENT_RESOURCES',
+    INSUFFICIENT_CREDITS: 'INSUFFICIENT_CREDITS',
+    NO_ROUTE: 'NO_ROUTE',
+    UNIT_BUSY: 'UNIT_BUSY',
+    LICENSE_REQUIRED: 'LICENSE_REQUIRED',
+    // Conflicts
+    NAME_TAKEN: 'NAME_TAKEN',
+    ALREADY_EXISTS: 'ALREADY_EXISTS',
+    CONFLICT: 'CONFLICT',
+    // State
+    INVALID_STATE: 'INVALID_STATE',
+    // Server
+    INTERNAL_ERROR: 'INTERNAL_ERROR',
+    SERVICE_UNAVAILABLE: 'SERVICE_UNAVAILABLE'
+};
+// ============================================================================
+// ERROR CLASSES
+// ============================================================================
+export class GameError extends Error {
+    code;
+    statusCode;
+    details;
+    constructor(code, message, statusCode = 400, details) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.details = details;
+        this.name = 'GameError';
+    }
+}
+export class ValidationError extends GameError {
+    constructor(message, details) {
+        super(ErrorCodes.VALIDATION_ERROR, message, 400, details);
+        this.name = 'ValidationError';
+    }
+    static fromZod(error) {
+        const issues = error.issues.map(issue => ({
+            path: issue.path.join('.'),
+            message: issue.message
+        }));
+        return new ValidationError('Validation failed', { issues });
+    }
+}
+export class AuthError extends GameError {
+    constructor(code, message) {
+        super(code, message, 401);
+        this.name = 'AuthError';
+    }
+}
+export class NotFoundError extends GameError {
+    constructor(resource, id) {
+        super(ErrorCodes.NOT_FOUND, id ? `${resource} '${id}' not found` : `${resource} not found`, 404);
+        this.name = 'NotFoundError';
+    }
+}
+export class RateLimitError extends GameError {
+    retryAfter;
+    constructor(code, message, retryAfter) {
+        super(code, message, 429, retryAfter ? { retryAfter } : undefined);
+        this.retryAfter = retryAfter;
+        this.name = 'RateLimitError';
+    }
+}
+export class PermissionError extends GameError {
+    constructor(message, code = ErrorCodes.INSUFFICIENT_PERMISSION) {
+        super(code, message, 403);
+        this.name = 'PermissionError';
+    }
+}
+export class ConflictError extends GameError {
+    constructor(message, code = ErrorCodes.CONFLICT) {
+        super(code, message, 409);
+        this.name = 'ConflictError';
+    }
+}
+export function errorResponse(c, error, requestId) {
+    const rid = requestId || uuid().slice(0, 8);
+    if (error instanceof GameError) {
+        const response = {
+            error: {
+                code: error.code,
+                message: error.message,
+                requestId: rid
+            }
+        };
+        if (error.details) {
+            response.error.details = error.details;
+        }
+        const headers = {};
+        if (error instanceof RateLimitError && error.retryAfter) {
+            headers['Retry-After'] = String(error.retryAfter);
+        }
+        return c.json(response, error.statusCode, headers);
+    }
+    // Unknown error - log it but don't expose details
+    console.error(`[${rid}] Internal error:`, error);
+    return c.json({
+        error: {
+            code: ErrorCodes.INTERNAL_ERROR,
+            message: 'An internal error occurred',
+            requestId: rid
+        }
+    }, 500);
+}
+export async function validateBody(c, schema) {
+    try {
+        const body = await c.req.json();
+        return schema.parse(body);
+    }
+    catch (error) {
+        if (error instanceof ZodError) {
+            throw ValidationError.fromZod(error);
+        }
+        if (error instanceof SyntaxError) {
+            throw new ValidationError('Invalid JSON body');
+        }
+        throw error;
+    }
+}

package/dist/server/rate-limit.d.ts

@@ -0,0 +1,22 @@
+/**
+ * BURNRATE Rate Limiting
+ * In-memory rate limiter with sliding window
+ */
+import { Context, Next } from 'hono';
+interface RateLimitConfig {
+    windowMs: number;
+    maxRequests: number;
+    keyGenerator: (c: Context) => string;
+}
+export declare function rateLimitMiddleware(config?: Partial<RateLimitConfig>): (c: Context, next: Next) => Promise<void>;
+/**
+ * Rate limiter that adjusts based on player tier
+ * Must be used AFTER auth middleware (requires player in context)
+ */
+export declare function tierRateLimitMiddleware(): (c: Context, next: Next) => Promise<void>;
+/**
+ * Stricter rate limit for write operations (mutations)
+ * 10 writes per minute for freelance, scaling up
+ */
+export declare function writeRateLimitMiddleware(): (c: Context, next: Next) => Promise<void>;
+export {};

package/dist/server/rate-limit.js

@@ -0,0 +1,134 @@
+/**
+ * BURNRATE Rate Limiting
+ * In-memory rate limiter with sliding window
+ */
+import { RateLimitError, ErrorCodes } from './errors.js';
+// In-memory store (use Redis in production for horizontal scaling)
+const rateLimitStore = new Map();
+// Clean up old entries periodically
+setInterval(() => {
+    const now = Date.now();
+    const windowMs = 60 * 1000; // 1 minute window
+    for (const [key, entry] of rateLimitStore.entries()) {
+        if (now - entry.windowStart > windowMs * 2) {
+            rateLimitStore.delete(key);
+        }
+    }
+}, 60 * 1000);
+const DEFAULT_CONFIG = {
+    windowMs: 60 * 1000, // 1 minute
+    maxRequests: 100, // 100 requests per minute
+    keyGenerator: (c) => {
+        // Use API key if available, otherwise IP
+        const apiKey = c.req.header('X-API-Key');
+        if (apiKey)
+            return `api:${apiKey}`;
+        const forwarded = c.req.header('X-Forwarded-For');
+        const ip = forwarded ? forwarded.split(',')[0].trim() : 'unknown';
+        return `ip:${ip}`;
+    }
+};
+// Tier-based limits (requests per minute)
+const TIER_RATE_LIMITS = {
+    freelance: 60,
+    operator: 120,
+    command: 300
+};
+// ============================================================================
+// RATE LIMIT MIDDLEWARE
+// ============================================================================
+export function rateLimitMiddleware(config = {}) {
+    const { windowMs, maxRequests, keyGenerator } = { ...DEFAULT_CONFIG, ...config };
+    return async (c, next) => {
+        const key = keyGenerator(c);
+        const now = Date.now();
+        let entry = rateLimitStore.get(key);
+        // Start new window if needed
+        if (!entry || now - entry.windowStart > windowMs) {
+            entry = { count: 0, windowStart: now };
+        }
+        entry.count++;
+        rateLimitStore.set(key, entry);
+        // Check limit
+        if (entry.count > maxRequests) {
+            const retryAfter = Math.ceil((entry.windowStart + windowMs - now) / 1000);
+            throw new RateLimitError(ErrorCodes.RATE_LIMITED, `Rate limit exceeded. Try again in ${retryAfter} seconds.`, retryAfter);
+        }
+        // Add rate limit headers
+        c.header('X-RateLimit-Limit', String(maxRequests));
+        c.header('X-RateLimit-Remaining', String(Math.max(0, maxRequests - entry.count)));
+        c.header('X-RateLimit-Reset', String(Math.ceil((entry.windowStart + windowMs) / 1000)));
+        await next();
+    };
+}
+// ============================================================================
+// TIER-AWARE RATE LIMIT
+// ============================================================================
+/**
+ * Rate limiter that adjusts based on player tier
+ * Must be used AFTER auth middleware (requires player in context)
+ */
+export function tierRateLimitMiddleware() {
+    const windowMs = 60 * 1000; // 1 minute
+    return async (c, next) => {
+        const player = c.get('player');
+        // If no player (public endpoint), use base rate
+        if (!player) {
+            return rateLimitMiddleware({ maxRequests: 30 })(c, next);
+        }
+        const key = `player:${player.id}`;
+        const maxRequests = TIER_RATE_LIMITS[player.tier] || TIER_RATE_LIMITS.freelance;
+        const now = Date.now();
+        let entry = rateLimitStore.get(key);
+        if (!entry || now - entry.windowStart > windowMs) {
+            entry = { count: 0, windowStart: now };
+        }
+        entry.count++;
+        rateLimitStore.set(key, entry);
+        if (entry.count > maxRequests) {
+            const retryAfter = Math.ceil((entry.windowStart + windowMs - now) / 1000);
+            throw new RateLimitError(ErrorCodes.RATE_LIMITED, `Rate limit exceeded (${player.tier} tier: ${maxRequests}/min). Try again in ${retryAfter}s.`, retryAfter);
+        }
+        c.header('X-RateLimit-Limit', String(maxRequests));
+        c.header('X-RateLimit-Remaining', String(Math.max(0, maxRequests - entry.count)));
+        c.header('X-RateLimit-Reset', String(Math.ceil((entry.windowStart + windowMs) / 1000)));
+        await next();
+    };
+}
+// ============================================================================
+// WRITE OPERATION LIMITER
+// ============================================================================
+const writeStore = new Map();
+/**
+ * Stricter rate limit for write operations (mutations)
+ * 10 writes per minute for freelance, scaling up
+ */
+export function writeRateLimitMiddleware() {
+    const windowMs = 60 * 1000;
+    const baseLimits = {
+        freelance: 20,
+        operator: 40,
+        command: 100
+    };
+    return async (c, next) => {
+        const player = c.get('player');
+        if (!player) {
+            await next();
+            return;
+        }
+        const key = `write:${player.id}`;
+        const maxRequests = baseLimits[player.tier] || baseLimits.freelance;
+        const now = Date.now();
+        let entry = writeStore.get(key);
+        if (!entry || now - entry.windowStart > windowMs) {
+            entry = { count: 0, windowStart: now };
+        }
+        entry.count++;
+        writeStore.set(key, entry);
+        if (entry.count > maxRequests) {
+            const retryAfter = Math.ceil((entry.windowStart + windowMs - now) / 1000);
+            throw new RateLimitError(ErrorCodes.RATE_LIMITED, `Write rate limit exceeded. Try again in ${retryAfter}s.`, retryAfter);
+        }
+        await next();
+    };
+}

package/dist/server/tick-server.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * BURNRATE Tick Server
+ * Automatically processes game ticks at regular intervals
+ *
+ * Default: 1 tick every 10 minutes (600,000ms)
+ * For testing: Use --interval flag to speed up
+ */
+export {};

package/dist/server/tick-server.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+/**
+ * BURNRATE Tick Server
+ * Automatically processes game ticks at regular intervals
+ *
+ * Default: 1 tick every 10 minutes (600,000ms)
+ * For testing: Use --interval flag to speed up
+ */
+import { GameDatabase } from '../db/database.js';
+import { GameEngine } from '../core/engine.js';
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+// Configuration
+const TICK_INTERVAL_MS = parseInt(process.env.BURNRATE_TICK_INTERVAL || '600000'); // 10 minutes default
+const DB_DIR = path.join(os.homedir(), '.burnrate');
+const DB_PATH = path.join(DB_DIR, 'game.db');
+// Ensure directory exists
+if (!fs.existsSync(DB_DIR)) {
+    fs.mkdirSync(DB_DIR, { recursive: true });
+}
+// Initialize
+const db = new GameDatabase(DB_PATH);
+const engine = new GameEngine(db);
+// State
+let running = true;
+let tickCount = 0;
+let lastTickTime = Date.now();
+// Logging
+function log(message) {
+    const timestamp = new Date().toISOString();
+    console.log(`[${timestamp}] ${message}`);
+}
+// Process a tick
+function processTick() {
+    const startTime = Date.now();
+    const result = engine.processTick();
+    const duration = Date.now() - startTime;
+    tickCount++;
+    lastTickTime = Date.now();
+    // Log tick summary
+    const eventSummary = {};
+    for (const event of result.events) {
+        eventSummary[event.type] = (eventSummary[event.type] || 0) + 1;
+    }
+    log(`Tick ${result.tick} processed in ${duration}ms (${result.events.length} events)`);
+    // Log important events
+    for (const event of result.events) {
+        if (event.type === 'zone_state_changed') {
+            log(`  Zone ${event.data.zoneName}: ${event.data.previousState} → ${event.data.newState}`);
+        }
+        if (event.type === 'zone_captured') {
+            log(`  Zone ${event.data.zoneName} captured by ${event.data.newOwner || 'neutral'}`);
+        }
+        if (event.type === 'shipment_arrived') {
+            log(`  Shipment ${event.data.shipmentId.slice(0, 8)} arrived at destination`);
+        }
+        if (event.type === 'shipment_intercepted') {
+            log(`  Shipment ${event.data.shipmentId.slice(0, 8)} intercepted! ${event.data.outcome}`);
+        }
+        if (event.type === 'combat_resolved') {
+            log(`  Combat: ${event.data.outcome} (E:${event.data.escortStrength} vs R:${event.data.raiderStrength})`);
+        }
+    }
+}
+// Main loop
+function startTickLoop() {
+    log(`BURNRATE Tick Server started`);
+    log(`Tick interval: ${TICK_INTERVAL_MS}ms (${TICK_INTERVAL_MS / 60000} minutes)`);
+    log(`Database: ${DB_PATH}`);
+    log(`Current tick: ${db.getCurrentTick()}`);
+    log(`Press Ctrl+C to stop\n`);
+    // Process first tick immediately
+    processTick();
+    // Schedule subsequent ticks
+    const interval = setInterval(() => {
+        if (running) {
+            processTick();
+        }
+    }, TICK_INTERVAL_MS);
+    // Graceful shutdown
+    process.on('SIGINT', () => {
+        log('\nShutting down...');
+        running = false;
+        clearInterval(interval);
+        db.close();
+        log(`Processed ${tickCount} ticks total`);
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        log('\nReceived SIGTERM, shutting down...');
+        running = false;
+        clearInterval(interval);
+        db.close();
+        process.exit(0);
+    });
+}
+// Status endpoint (simple file-based for CLI querying)
+function writeStatus() {
+    const statusPath = path.join(DB_DIR, 'server-status.json');
+    const status = {
+        running,
+        tickCount,
+        currentTick: db.getCurrentTick(),
+        lastTickTime: new Date(lastTickTime).toISOString(),
+        intervalMs: TICK_INTERVAL_MS,
+        pid: process.pid
+    };
+    fs.writeFileSync(statusPath, JSON.stringify(status, null, 2));
+}
+// Update status every tick
+setInterval(writeStatus, 5000);
+// Start the server
+startTickLoop();