@layer-ai/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { default as authRouter } from './routes/auth.js';
+export { default as gatesRouter } from './routes/gates.js';
+export { default as keysRouter } from './routes/keys.js';
+export { default as logsRouter } from './routes/logs.js';
+export { default as completeRouter } from './routes/complete.js';
+export { authenticate } from './middleware/auth.js';
+export { db } from './lib/db/postgres.js';
+export { default as redis } from './lib/db/redis.js';
+export { createCompletion as createOpenAICompletion } from './services/providers/openai.js';
+export { createCompletion as createAnthropicCompletion } from './services/providers/anthropic.js';
+export { createCompletion as createGoogleCompletion } from './services/providers/google.js';
+export type { ProviderResponse } from './services/providers/openai.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGjE,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGpD,OAAO,EAAE,EAAE,EAAE,MAAM,sBAAsB,CAAC;AAC1C,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAGrD,OAAO,EAAE,gBAAgB,IAAI,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAC5F,OAAO,EAAE,gBAAgB,IAAI,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAClG,OAAO,EAAE,gBAAgB,IAAI,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAC5F,YAAY,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC"}

package/dist/index.js

@@ -0,0 +1,15 @@
+// Routes
+export { default as authRouter } from './routes/auth.js';
+export { default as gatesRouter } from './routes/gates.js';
+export { default as keysRouter } from './routes/keys.js';
+export { default as logsRouter } from './routes/logs.js';
+export { default as completeRouter } from './routes/complete.js';
+// Middleware
+export { authenticate } from './middleware/auth.js';
+// Database
+export { db } from './lib/db/postgres.js';
+export { default as redis } from './lib/db/redis.js';
+// Services - only export specific items to avoid conflicts
+export { createCompletion as createOpenAICompletion } from './services/providers/openai.js';
+export { createCompletion as createAnthropicCompletion } from './services/providers/anthropic.js';
+export { createCompletion as createGoogleCompletion } from './services/providers/google.js';

package/dist/lib/db/postgres.d.ts

@@ -0,0 +1,27 @@
+import pg from 'pg';
+import type { User, ApiKey, Gate } from '@layer-ai/sdk';
+declare function getPool(): pg.Pool;
+export declare const db: {
+    query(text: string, params?: any[]): Promise<pg.QueryResult<any>>;
+    getUserByEmail(email: string): Promise<User | null>;
+    getUserById(id: string): Promise<User | null>;
+    createUser(email: string, passwordHash: string): Promise<User>;
+    getApiKeyByHash(keyHash: string): Promise<ApiKey | null>;
+    createApiKey(userId: string, keyHash: string, keyPrefix: string, name: string): Promise<ApiKey>;
+    updateApiKeyLastUsed(keyHash: string): Promise<void>;
+    getApiKeysForUser(userId: string): Promise<ApiKey[]>;
+    deleteApiKey(id: string, userId: string): Promise<boolean>;
+    getGateByUserAndName(userId: string, gateName: string): Promise<Gate | null>;
+    getGatesForUser(userId: string): Promise<Gate[]>;
+    createGate(userId: string, data: any): Promise<Gate>;
+    getGateById(id: string): Promise<Gate | null>;
+    updateGate(id: string, data: any): Promise<Gate | null>;
+    deleteGate(id: string): Promise<boolean>;
+    logRequest(data: any): Promise<void>;
+    getSessionKeyByHash(keyHash: string): Promise<{
+        userId: string;
+        expiresAt: Date;
+    } | null>;
+};
+export default getPool;
+//# sourceMappingURL=postgres.d.ts.map

package/dist/lib/db/postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../../src/lib/db/postgres.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,CAAC;AACpB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAyB,MAAM,eAAe,CAAC;AAO/E,iBAAS,OAAO,IAAI,EAAE,CAAC,IAAI,CAqB1B;AA0BD,eAAO,MAAM,EAAE;gBAEK,MAAM,WAAW,GAAG,EAAE;0BASZ,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;oBAQnC,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;sBAQ3B,MAAM,gBAAgB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;6BASrC,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;yBAQnC,MAAM,WAAW,MAAM,aAAa,MAAM,QAAQ,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;kCAQjE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;8BAO1B,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;qBAQnC,MAAM,UAAU,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;iCAS7B,MAAM,YAAY,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;4BAQpD,MAAM,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;uBAQ7B,MAAM,QAAQ,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;oBAsBpC,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;mBAQ9B,MAAM,QAAQ,GAAG,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;mBAgCxC,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;qBASvB,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;iCAgBP,MAAM,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,IAAI,CAAA;KAAE,GAAG,IAAI,CAAC;CAOhG,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/lib/db/postgres.js

@@ -0,0 +1,168 @@
+import pg from 'pg';
+const { Pool } = pg;
+// Lazy-initialize connection pool
+let pool = null;
+function getPool() {
+    if (!pool) {
+        pool = new Pool({
+            connectionString: process.env.DATABASE_URL,
+            ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false,
+            max: 20, // max num of connections
+            idleTimeoutMillis: 30000,
+            connectionTimeoutMillis: 2000,
+        });
+        // test connection on startup
+        pool.on('connect', () => {
+            console.log('Connected to PostgreSQL database');
+        });
+        pool.on('error', (err) => {
+            console.error('Unexpected database error:', err);
+            process.exit(-1);
+        });
+    }
+    return pool;
+}
+// function to convert snake_case DB cols to camelCase TypeScript
+function toCamelCase(obj) {
+    if (!obj)
+        return obj;
+    const converted = {};
+    for (const key in obj) {
+        const camelKey = key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+        let value = obj[key];
+        // Convert numeric strings to numbers for specific fields
+        if ((camelKey === 'temperature' || camelKey === 'topP') && typeof value === 'string') {
+            value = parseFloat(value);
+        }
+        if (camelKey === 'maxTokens' && typeof value === 'string') {
+            value = parseInt(value, 10);
+        }
+        converted[camelKey] = value;
+    }
+    return converted;
+}
+// Database query functions
+export const db = {
+    // generic query function 
+    async query(text, params) {
+        const start = Date.now();
+        const res = await getPool().query(text, params);
+        const duration = Date.now() - start;
+        console.log('Executed query', { text, duration, rows: res.rowCount });
+        return res;
+    },
+    // Users
+    async getUserByEmail(email) {
+        const result = await getPool().query('SELECT * FROM users WHERE email = $1', [email]);
+        return result.rows[0] ? toCamelCase(result.rows[0]) : null;
+    },
+    async getUserById(id) {
+        const result = await getPool().query('SELECT * FROM users WHERE id = $1', [id]);
+        return result.rows[0] ? toCamelCase(result.rows[0]) : null;
+    },
+    async createUser(email, passwordHash) {
+        const result = await getPool().query('INSERT INTO users (email, password_hash) VALUES ($1, $2) RETURNING *', [email, passwordHash]);
+        return toCamelCase(result.rows[0]);
+    },
+    // API Keys
+    async getApiKeyByHash(keyHash) {
+        const result = await getPool().query('SELECT * FROM api_keys WHERE key_hash = $1 AND is_active = true', [keyHash]);
+        return result.rows[0] ? toCamelCase(result.rows[0]) : null;
+    },
+    async createApiKey(userId, keyHash, keyPrefix, name) {
+        const result = await getPool().query('INSERT INTO api_keys (user_id, key_hash, key_prefix, name) VALUES ($1, $2, $3, $4) RETURNING *', [userId, keyHash, keyPrefix, name]);
+        return toCamelCase(result.rows[0]);
+    },
+    async updateApiKeyLastUsed(keyHash) {
+        await getPool().query('UPDATE api_keys SET last_used_at = NOW() WHERE key_hash = $1', [keyHash]);
+    },
+    async getApiKeysForUser(userId) {
+        const result = await getPool().query('SELECT id, user_id, key_prefix, name, created_at, last_used_at FROM api_keys WHERE user_id = $1 AND is_active = true ORDER BY created_at DESC', [userId]);
+        return result.rows.map(toCamelCase);
+    },
+    async deleteApiKey(id, userId) {
+        const result = await getPool().query('UPDATE api_keys SET is_active = false WHERE id = $1 AND user_id = $2', [id, userId]);
+        return (result.rowCount ?? 0) > 0;
+    },
+    // Gates 
+    async getGateByUserAndName(userId, gateName) {
+        const result = await getPool().query('SELECT * FROM gates WHERE user_id = $1 AND name = $2', [userId, gateName]);
+        return result.rows[0] ? toCamelCase(result.rows[0]) : null;
+    },
+    async getGatesForUser(userId) {
+        const result = await getPool().query('SELECT * FROM gates WHERE user_id = $1 ORDER BY created_at DESC', [userId]);
+        return result.rows.map(toCamelCase);
+    },
+    async createGate(userId, data) {
+        const result = await getPool().query(`INSERT INTO gates (user_id, name, description, model, system_prompt, allow_overrides, temperature, max_tokens, top_p, tags, routing_strategy, fallback_models)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12) RETURNING *`, [
+            userId,
+            data.name,
+            data.description,
+            data.model,
+            data.systemPrompt,
+            data.allowOverrides ? JSON.stringify(data.allowOverrides) : null,
+            data.temperature,
+            data.maxTokens,
+            data.topP,
+            JSON.stringify(data.tags || []),
+            data.routingStrategy || 'single',
+            JSON.stringify(data.fallbackModels || [])
+        ]);
+        return toCamelCase(result.rows[0]);
+    },
+    async getGateById(id) {
+        const result = await getPool().query('SELECT * FROM gates WHERE id = $1', [id]);
+        return result.rows[0] ? toCamelCase(result.rows[0]) : null;
+    },
+    async updateGate(id, data) {
+        const result = await getPool().query(`UPDATE gates SET
+        description = COALESCE($2, description),
+        model = COALESCE($3, model),
+        system_prompt = COALESCE($4, system_prompt),
+        allow_overrides = COALESCE($5, allow_overrides),
+        temperature = COALESCE($6, temperature),
+        max_tokens = COALESCE($7, max_tokens),
+        top_p = COALESCE($8, top_p),
+        tags = COALESCE($9, tags),
+        routing_strategy = COALESCE($10, routing_strategy),
+        fallback_models = COALESCE($11, fallback_models),
+        updated_at = NOW()
+      WHERE id = $1 RETURNING *`, [
+            id,
+            data.description,
+            data.model,
+            data.systemPrompt,
+            data.allowOverrides ? JSON.stringify(data.allowOverrides) : null,
+            data.temperature,
+            data.maxTokens,
+            data.topP,
+            data.tags ? JSON.stringify(data.tags) : null,
+            data.routingStrategy,
+            data.fallbackModels ? JSON.stringify(data.fallbackModels) : null,
+        ]);
+        return result.rows[0] ? toCamelCase(result.rows[0]) : null;
+    },
+    async deleteGate(id) {
+        const result = await getPool().query('DELETE FROM gates WHERE id = $1', [id]);
+        return (result.rowCount ?? 0) > 0;
+    },
+    // Request Logging 
+    async logRequest(data) {
+        await getPool().query(`INSERT INTO requests (
+      user_id, gate_id, gate_name, model_requested, model_used, prompt_tokens,
+      completion_tokens, total_tokens, cost_usd, latency_ms, success, 
+      error_message, user_agent, ip_address)
+      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)`, [
+            data.userId, data.gateId, data.gateName, data.modelRequested, data.modelUsed, data.promptTokens,
+            data.completionTokens, data.totalTokens, data.costUsd, data.latencyMs, data.success,
+            data.errorMessage, data.userAgent, data.ipAddress
+        ]);
+    },
+    // Session Keys
+    async getSessionKeyByHash(keyHash) {
+        const result = await getPool().query('SELECT user_id, expires_at FROM session_keys WHERE key_hash = $1 AND expires_at > NOW()', [keyHash]);
+        return result.rows[0] ? toCamelCase(result.rows[0]) : null;
+    }
+};
+export default getPool;

package/dist/lib/db/redis.d.ts

@@ -0,0 +1,12 @@
+import Redis from 'ioredis';
+import type { Gate } from '@layer-ai/sdk';
+declare const redis: Redis;
+export declare const cache: {
+    getGate(userId: string, gateName: string): Promise<Gate | null>;
+    setGate(userId: string, gateName: string, gate: Gate): Promise<void>;
+    invalidateGate(userId: string, gateName: string): Promise<void>;
+    invalidateUserGates(userId: string): Promise<void>;
+    ping(): Promise<boolean>;
+};
+export default redis;
+//# sourceMappingURL=redis.d.ts.map

package/dist/lib/db/redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../../src/lib/db/redis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,SAAS,CAAC;AAC5B,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAG1C,QAAA,MAAM,KAAK,OAcT,CAAC;AAmBH,eAAO,MAAM,KAAK;oBAEM,MAAM,YAAY,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;oBAqB/C,MAAM,YAAY,MAAM,QAAQ,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;2BAW7C,MAAM,YAAY,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;gCAUnC,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAc1C,OAAO,CAAC,OAAO,CAAC;CAQ/B,CAAC;AAEF,eAAe,KAAK,CAAC"}

package/dist/lib/db/redis.js

@@ -0,0 +1,95 @@
+import Redis from 'ioredis';
+// Create redis client
+const redis = new Redis(process.env.REDIS_URL || 'redis://localhost:6379', {
+    maxRetriesPerRequest: 3,
+    retryStrategy(times) {
+        const delay = Math.min(times * 50, 2000);
+        return delay;
+    },
+    reconnectOnError(err) {
+        const targetError = 'READONLY';
+        if (err.message.includes(targetError)) {
+            // Reconnect when redis is in readonly mode
+            return true;
+        }
+        return false;
+    },
+});
+// Connection event handlers
+redis.on('connect', () => {
+    console.log('Connected to Redis cache');
+});
+redis.on('error', (err) => {
+    console.error('Redis connection error:', err);
+});
+// Cache key builders
+const CACHE_TTL = 300;
+function getGateCacheKey(userId, gateName) {
+    return `gate:${userId}:${gateName}`;
+}
+// Cache operations
+export const cache = {
+    // get the gate
+    async getGate(userId, gateName) {
+        try {
+            const key = getGateCacheKey(userId, gateName);
+            const cached = await redis.get(key);
+            if (!cached) {
+                return null;
+            }
+            const gate = JSON.parse(cached);
+            gate.createdAt = new Date(gate.createdAt);
+            gate.updatedAt = new Date(gate.updatedAt);
+            return gate;
+        }
+        catch (error) {
+            console.error('Redis get error:', error);
+            return null; // if we fail, then we fetch from the db
+        }
+    },
+    // Set gate in cache
+    async setGate(userId, gateName, gate) {
+        try {
+            const key = getGateCacheKey(userId, gateName);
+            await redis.setex(key, CACHE_TTL, JSON.stringify(gate));
+        }
+        catch (error) {
+            console.error('Redis set error:', error);
+            // cache miss here is okay
+        }
+    },
+    // Invalidate gate cache
+    async invalidateGate(userId, gateName) {
+        try {
+            const key = getGateCacheKey(userId, gateName);
+            await redis.del(key);
+        }
+        catch (error) {
+            console.error('Redis delete error:', error);
+        }
+    },
+    // Invalidate all gates for a user
+    async invalidateUserGates(userId) {
+        try {
+            const pattern = `gate:${userId}:*`;
+            const keys = await redis.keys(pattern);
+            if (keys.length > 0) {
+                await redis.del(...keys);
+            }
+        }
+        catch (error) {
+            console.error('Redis bulk delete error:', error);
+        }
+    },
+    // health check 
+    async ping() {
+        try {
+            const result = await redis.ping();
+            return result === 'PONG';
+        }
+        catch (error) {
+            return false;
+        }
+    },
+};
+export default redis;

package/dist/middleware/auth.d.ts

@@ -0,0 +1,22 @@
+import { Request, Response, NextFunction } from 'express';
+declare global {
+    namespace Express {
+        interface Request {
+            userId?: string;
+            apiKeyHash?: string;
+        }
+    }
+}
+/**
+ * Auth middleware for api key validation
+ *
+ * Expected header format:
+ * Authorization: Bearer layer_abc123...
+ */
+export declare function authenticate(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * Optional middleware for endpoints that don't require auth
+ * like the health check public endpoints etc.
+ */
+export declare function optionalAuth(req: Request, res: Response, next: NextFunction): void;
+//# sourceMappingURL=auth.d.ts.map

package/dist/middleware/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAK1D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,OAAO,CAAC;QAChB,UAAU,OAAO;YACf,MAAM,CAAC,EAAE,MAAM,CAAC;YAChB,UAAU,CAAC,EAAE,MAAM,CAAC;SACrB;KACF;CACF;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,CAAC,CA8Ef;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,IAAI,CAWN"}

package/dist/middleware/auth.js

@@ -0,0 +1,89 @@
+import crypto from 'crypto';
+import { db } from '../lib/db/postgres.js';
+/**
+ * Auth middleware for api key validation
+ *
+ * Expected header format:
+ * Authorization: Bearer layer_abc123...
+ */
+export async function authenticate(req, res, next) {
+    try {
+        // Extract Authorization header
+        const authHeader = req.headers.authorization;
+        if (!authHeader) {
+            res.status(401).json({
+                error: 'unauthorized',
+                message: 'Missing Authorization header',
+            });
+            return;
+        }
+        // check format: "Bearer layer_..."
+        if (!authHeader.startsWith('Bearer ')) {
+            res.status(401).json({
+                error: 'unauthorized',
+                message: 'Invalid Authorization header format. Expected: Bearer <api_key>',
+            });
+            return;
+        }
+        const apiKey = authHeader.substring(7); // Remove "Bearer "
+        if (!apiKey || !apiKey.startsWith('layer_')) {
+            res.status(401).json({
+                error: 'unauthorized',
+                message: 'Invalid API key format. Must start with "layer_"',
+            });
+            return;
+        }
+        const keyHash = crypto
+            .createHash('sha256')
+            .update(apiKey)
+            .digest('hex');
+        const apiKeyRecord = await db.getApiKeyByHash(keyHash);
+        if (!apiKeyRecord) {
+            // Not an API key (it's potentially a session key)
+            const sessionKey = await db.getSessionKeyByHash(keyHash);
+            if (!sessionKey) {
+                res.status(401).json({ error: 'unauthorized', message: 'Invalid API key' });
+                return;
+            }
+            req.userId = sessionKey.userId;
+            next();
+            return;
+        }
+        if (!apiKeyRecord.isActive) {
+            res.status(401).json({
+                error: 'unauthorized',
+                message: 'API key has been revoked',
+            });
+            return;
+        }
+        // Attach userId to request for downstream handlers
+        req.userId = apiKeyRecord.userId;
+        req.apiKeyHash = keyHash;
+        // Update last_used_at timestamp (async, dont await)
+        db.updateApiKeyLastUsed(keyHash).catch((err) => {
+            console.error('Failed to update API key last_used_at:', err);
+        });
+        next();
+    }
+    catch (error) {
+        console.error('Authentication error:', error);
+        res.status(500).json({
+            error: 'internal_error',
+            message: 'Authentication failed'
+        });
+    }
+}
+/**
+ * Optional middleware for endpoints that don't require auth
+ * like the health check public endpoints etc.
+ */
+export function optionalAuth(req, res, next) {
+    const authHeader = req.headers.authorization;
+    if (!authHeader) {
+        // No auth header = proceed without userId
+        next();
+        return;
+    }
+    // if auth header exists, validate it 
+    authenticate(req, res, next);
+}

package/dist/routes/auth.d.ts

@@ -0,0 +1,4 @@
+import type { Router as RouterType } from 'express';
+declare const router: RouterType;
+export default router;
+//# sourceMappingURL=auth.d.ts.map

package/dist/routes/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/routes/auth.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,SAAS,CAAC;AAKpD,QAAA,MAAM,MAAM,EAAE,UAAqB,CAAC;AA4FpC,eAAe,MAAM,CAAC"}

package/dist/routes/auth.js

@@ -0,0 +1,82 @@
+import { Router } from 'express';
+import bcrypt from 'bcryptjs';
+import crypto from 'crypto';
+import { db } from '../lib/db/postgres.js';
+const router = Router();
+// POST /auth/signup
+router.post('/signup', async (req, res) => {
+    try {
+        const { email, password } = req.body;
+        if (!email || !password) {
+            res.status(400).json({ error: 'bad_request', message: 'Email and password required' });
+            return;
+        }
+        const existing = await db.getUserByEmail(email);
+        if (existing) {
+            res.status(409).json({ error: 'conflict', message: 'Email already registered' });
+            return;
+        }
+        const passwordHash = await bcrypt.hash(password, 10);
+        const user = await db.createUser(email, passwordHash);
+        res.status(201).json({ id: user.id, email: user.email });
+    }
+    catch (error) {
+        console.error('Signup error:', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to create account ' });
+    }
+});
+// POST /auth/login
+router.post('/login', async (req, res) => {
+    try {
+        const { email, password } = req.body;
+        if (!email || !password) {
+            res.status(400).json({ error: 'bad_request', message: 'Email and password required' });
+            return;
+        }
+        const user = await db.getUserByEmail(email);
+        if (!user) {
+            res.status(401).json({ error: 'unauthorized', message: 'Invalid credentials' });
+            return;
+        }
+        const valid = await bcrypt.compare(password, user.passwordHash);
+        if (!valid) {
+            res.status(401).json({ error: 'unauthorized', message: 'Invalid credentials' });
+            return;
+        }
+        res.json({ id: user.id, email: user.email });
+    }
+    catch (error) {
+        console.error('Login error', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to login' });
+    }
+});
+// POST /auth/token
+router.post('/token', async (req, res) => {
+    try {
+        const { email, password } = req.body;
+        if (!email || !password) {
+            res.status(400).json({ error: 'bad_request', message: 'Email and password required' });
+            return;
+        }
+        const user = await db.getUserByEmail(email);
+        if (!user) {
+            res.status(401).json({ error: 'unauthorized', message: 'Invalid credentials' });
+            return;
+        }
+        const valid = await bcrypt.compare(password, user.passwordHash);
+        if (!valid) {
+            res.status(401).json({ error: 'unauthorized', message: 'Invalid credentials' });
+            return;
+        }
+        const rawKey = `layer_${crypto.randomBytes(32).toString('hex')}`;
+        const keyHash = crypto.createHash('sha256').update(rawKey).digest('hex');
+        const keyPrefix = rawKey.substring(0, 12); // "layer_xxxxxx"
+        await db.createApiKey(user.id, keyHash, keyPrefix, 'CLI');
+        res.status(201).json({ apiKey: rawKey });
+    }
+    catch (error) {
+        console.error('api key creation error', error);
+        res.status(500).json({ error: 'internal_error', message: 'Failed to create api key' });
+    }
+});
+export default router;

package/dist/routes/complete.d.ts

@@ -0,0 +1,4 @@
+import type { Router as RouterType } from 'express';
+declare const router: RouterType;
+export default router;
+//# sourceMappingURL=complete.d.ts.map

package/dist/routes/complete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complete.d.ts","sourceRoot":"","sources":["../../src/routes/complete.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,SAAS,CAAC;AAWpD,QAAA,MAAM,MAAM,EAAE,UAAqB,CAAC;AA2QpC,eAAe,MAAM,CAAC"}