npm - insforge - Versions diffs - 0.3.2 → 1.2.10 - Mend

insforge 0.3.2 → 1.2.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (507) hide show

package/backend/src/api/routes/openapi.ts DELETED Viewed

@@ -1,82 +0,0 @@
-import { Router, Request, Response } from 'express';
-import { OpenAPIService } from '@/core/documentation/openapi.js';
-import { AppError } from '@/api/middleware/error.js';
-import { ERROR_CODES } from '@/types/error-constants.js';
-import { successResponse } from '@/utils/response.js';
-import logger from '@/utils/logger.js';
-const router = Router();
-const openAPIService = OpenAPIService.getInstance();
-/**
- * GET /api/openapi
- * Get the OpenAPI specification document
- */
-router.get('/', async (_req: Request, res: Response, next) => {
-  try {
-    const openAPIDocument = await openAPIService.generateOpenAPIDocument();
-    successResponse(res, openAPIDocument);
-  } catch (error) {
-    logger.error('Failed to generate OpenAPI document', {
-      error: error instanceof Error ? error.message : String(error),
-    });
-    next(new AppError('Failed to generate OpenAPI document', 500, ERROR_CODES.INTERNAL_ERROR));
-  }
-});
-/**
- * GET /api/openapi/swagger
- * Serve Swagger UI HTML page
- */
-router.get('/swagger', (_req: Request, res: Response) => {
-  const html = `
-    <!DOCTYPE html>
-    <html lang="en">
-    <head>
-      <meta charset="utf-8" />
-      <meta name="viewport" content="width=device-width, initial-scale=1" />
-      <title>InsForge API Documentation</title>
-      <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css" />
-      <style>
-        body {
-          margin: 0;
-          padding: 0;
-        }
-        .swagger-ui .topbar {
-          display: none;
-        }
-      </style>
-    </head>
-    <body>
-      <div id="swagger-ui"></div>
-      <script src="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
-      <script>
-        window.onload = () => {
-          window.ui = SwaggerUIBundle({
-            url: '/api/openapi',
-            dom_id: '#swagger-ui',
-            deepLinking: true,
-            presets: [
-              SwaggerUIBundle.presets.apis,
-              SwaggerUIBundle.SwaggerUIStandalonePreset
-            ],
-            layout: 'BaseLayout',
-            tryItOutEnabled: true,
-            requestInterceptor: (request) => {
-              // Add API key from localStorage if available
-              const apiKey = localStorage.getItem('insforge_api_key');
-              if (apiKey) {
-                request.headers['x-api-key'] = apiKey;
-              }
-              return request;
-            }
-          });
-        };
-      </script>
-    </body>
-    </html>
-  `;
-  res.type('html').send(html);
-});
-export { router as openAPIRouter };

package/backend/src/api/routes/usage.ts DELETED Viewed

@@ -1,96 +0,0 @@
-import { Router } from 'express';
-import { DatabaseManager } from '@/core/database/manager.js';
-import { verifyApiKey, verifyCloudBackend } from '@/api/middleware/auth.js';
-export const usageRouter = Router();
-// Create MCP tool usage record
-usageRouter.post('/mcp', verifyApiKey, async (req, res, next) => {
-  try {
-    const { tool_name, success = true } = req.body;
-    if (!tool_name) {
-      return res.status(400).json({
-        error: 'VALIDATION_ERROR',
-        message: 'tool_name is required',
-      });
-    }
-    const dbManager = DatabaseManager.getInstance();
-    const db = dbManager.getDb();
-    // Insert MCP usage record directly
-    await db
-      .prepare(
-        `
-      INSERT INTO _mcp_usage (tool_name, success)
-      VALUES ($1, $2)
-    `
-      )
-      .run(tool_name, success);
-    res.json({ success: true });
-  } catch (error) {
-    next(error);
-  }
-});
-// Get usage statistics (called by cloud backend)
-usageRouter.get('/stats', verifyCloudBackend, async (req, res, next) => {
-  try {
-    const { start_date, end_date } = req.query;
-    if (!start_date || !end_date) {
-      return res.status(400).json({
-        error: 'VALIDATION_ERROR',
-        message: 'start_date and end_date are required',
-      });
-    }
-    const dbManager = DatabaseManager.getInstance();
-    const db = dbManager.getDb();
-    // Get MCP tool usage count within date range
-    const mcpResult = await db
-      .prepare(
-        `
-      SELECT COUNT(*) as count
-      FROM _mcp_usage
-      WHERE success = true
-        AND created_at >= $1
-        AND created_at < $2
-    `
-      )
-      .get(new Date(start_date as string), new Date(end_date as string));
-    const mcpUsageCount = parseInt(mcpResult?.count || '0');
-    // Get database size (in bytes)
-    const dbSizeResult = await db
-      .prepare(
-        `
-      SELECT pg_database_size(current_database()) as size
-    `
-      )
-      .get();
-    const databaseSize = parseInt(dbSizeResult?.size || '0');
-    // Get total storage size from _storage table
-    const storageResult = await db
-      .prepare(
-        `
-      SELECT COALESCE(SUM(size), 0) as total_size
-      FROM _storage
-    `
-      )
-      .get();
-    const storageSize = parseInt(storageResult?.total_size || '0');
-    res.json({
-      mcp_usage_count: mcpUsageCount,
-      database_size_bytes: databaseSize,
-      storage_size_bytes: storageSize,
-    });
-  } catch (error) {
-    next(error);
-  }
-});

package/backend/src/core/ai/client.ts DELETED Viewed

@@ -1,242 +0,0 @@
-import OpenAI from 'openai';
-import jwt from 'jsonwebtoken';
-import { isCloudEnvironment } from '@/utils/environment';
-import { AppError } from '@/api/middleware/error';
-import { ERROR_CODES } from '@/types/error-constants';
-interface CloudCredentialsResponse {
-  openrouter?: {
-    api_key: string;
-    limit?: number;
-    expired_at?: string | null;
-    usage?: number;
-    limit_remaining?: number;
-  };
-}
-interface CloudCredentials {
-  apiKey: string;
-  limitRemaining?: number;
-  expiredAt?: Date | null;
-}
-interface OpenRouterKeyInfo {
-  data: {
-    label: string;
-    usage: number;
-    limit: number | null;
-    is_free_tier: boolean;
-  };
-}
-interface OpenRouterLimitation {
-  label: string;
-  limit: number | null;
-  usage: number;
-  is_provisioning_key: boolean;
-  limit_remaining: number | null;
-  is_free_tier: boolean;
-  rate_limit: {
-    requests: number;
-    interval: string;
-    note: string;
-  };
-}
-export class AIClientService {
-  private static instance: AIClientService;
-  private cloudCredentials: CloudCredentials | undefined;
-  private openRouterClient: OpenAI | null = null;
-  private currentApiKey: string | undefined;
-  private constructor() {}
-  static getInstance(): AIClientService {
-    if (!AIClientService.instance) {
-      AIClientService.instance = new AIClientService();
-    }
-    return AIClientService.instance;
-  }
-  /**
-   * Create or recreate the OpenAI client with the given API key
-   */
-  private createClient(apiKey: string): OpenAI {
-    this.currentApiKey = apiKey;
-    return new OpenAI({
-      baseURL: 'https://openrouter.ai/api/v1',
-      apiKey,
-      defaultHeaders: {
-        'HTTP-Referer': 'https://insforge.dev',
-        'X-Title': 'InsForge',
-      },
-    });
-  }
-  /**
-   * Get OpenRouter API key based on environment
-   * In cloud environment: fetches from cloud API with JWT authentication
-   * In local environment: returns from environment variable
-   */
-  async getApiKey(): Promise<string> {
-    if (isCloudEnvironment()) {
-      if (
-        this.cloudCredentials &&
-        (!this.cloudCredentials.expiredAt || new Date() <= this.cloudCredentials.expiredAt)
-      ) {
-        return this.cloudCredentials.apiKey;
-      } else {
-        return await this.fetchCloudApiKey();
-      }
-    }
-    const apiKey = process.env.OPENROUTER_API_KEY;
-    if (!apiKey) {
-      throw new AppError(
-        'OPENROUTER_API_KEY not found in environment variables',
-        500,
-        ERROR_CODES.AI_INVALID_API_KEY
-      );
-    }
-    return apiKey;
-  }
-  /**
-   * Get the OpenAI client, creating or updating it as needed
-   * This is the main method services should use
-   */
-  async getClient(): Promise<OpenAI> {
-    if (!this.openRouterClient) {
-      this.openRouterClient = this.createClient(await this.getApiKey());
-      return this.openRouterClient;
-    }
-    if (isCloudEnvironment()) {
-      const apiKey = await this.getApiKey();
-      if (this.currentApiKey !== apiKey) {
-        this.openRouterClient = this.createClient(apiKey);
-      }
-    }
-    return this.openRouterClient;
-  }
-  /**
-   * Check if AI services are properly configured
-   */
-  isConfigured(): boolean {
-    if (isCloudEnvironment()) {
-      return true;
-    }
-    return !!process.env.OPENROUTER_API_KEY;
-  }
-  /**
-   * Get remaining credits for the current API key from OpenRouter
-   */
-  async getRemainingCredits(): Promise<{
-    usage: number;
-    limit: number | null;
-    remaining: number | null;
-  }> {
-    try {
-      const apiKey = await this.getApiKey();
-      if (isCloudEnvironment()) {
-        // Use InsForge API for cloud environment
-        const response = await fetch(
-          `https://api.insforge.dev/ai/v1/limitations?credential=${encodeURIComponent(apiKey)}`,
-          {
-            method: 'GET',
-          }
-        );
-        if (!response.ok) {
-          throw new Error(`Failed to fetch key info: ${response.statusText}`);
-        }
-        const result = (await response.json()) as { data: OpenRouterLimitation };
-        const keyInfo = result.data;
-        return {
-          usage: keyInfo.usage,
-          limit: keyInfo.limit,
-          remaining: keyInfo.limit_remaining,
-        };
-      } else {
-        // Use OpenRouter API for local environment
-        const response = await fetch('https://openrouter.ai/api/v1/key', {
-          method: 'GET',
-          headers: {
-            Authorization: `Bearer ${apiKey}`,
-          },
-        });
-        if (!response.ok) {
-          throw new AppError(
-            `Invalid OpenRouter API Key`,
-            500,
-            ERROR_CODES.AI_INVALID_API_KEY,
-            'Check your OpenRouter key and try again.'
-          );
-        }
-        const keyInfo = (await response.json()) as OpenRouterKeyInfo;
-        return {
-          usage: keyInfo.data.usage,
-          limit: keyInfo.data.limit,
-          remaining: keyInfo.data.limit !== null ? keyInfo.data.limit - keyInfo.data.usage : null,
-        };
-      }
-    } catch (error) {
-      console.error('Failed to fetch remaining credits:', error);
-      throw error;
-    }
-  }
-  /**
-   * Fetch API key from cloud service
-   */
-  private async fetchCloudApiKey(): Promise<string> {
-    try {
-      const projectId = process.env.PROJECT_ID;
-      if (!projectId) {
-        throw new Error('PROJECT_ID not found in environment variables');
-      }
-      const jwtSecret = process.env.JWT_SECRET;
-      if (!jwtSecret) {
-        throw new Error('JWT_SECRET not found in environment variables');
-      }
-      // Sign a token for authentication
-      const token = jwt.sign({ projectId }, jwtSecret, { expiresIn: '1h' });
-      // Fetch API key from cloud service with sign token as query parameter
-      const response = await fetch(
-        `https://api.insforge.dev/ai/v1/credentials/${projectId}?sign=${token}`
-      );
-      if (!response.ok) {
-        throw new Error(`Failed to fetch cloud API key: ${response.statusText}`);
-      }
-      const data = (await response.json()) as CloudCredentialsResponse;
-      // Extract API key from the openrouter object in response
-      if (!data.openrouter?.api_key) {
-        throw new Error('Invalid response: missing openrouter API Key');
-      }
-      // Store credentials with metadata
-      this.cloudCredentials = {
-        apiKey: data.openrouter.api_key,
-        limitRemaining: data.openrouter.limit_remaining,
-        expiredAt: data.openrouter.expired_at ? new Date(data.openrouter.expired_at) : null,
-      };
-      return data.openrouter.api_key;
-    } catch (error) {
-      console.error('Failed to fetch cloud API key:', error);
-      throw error;
-    }
-  }
-}

package/backend/src/core/ai/model.ts DELETED Viewed

@@ -1,117 +0,0 @@
-import { isCloudEnvironment } from '@/utils/environment';
-import { AIClientService } from './client';
-import type { RawOpenRouterModel } from '@/types/ai';
-import type { OpenRouterModel } from '@insforge/shared-schemas';
-export interface ModelProviderInfo {
-  provider: string;
-  configured: boolean;
-  models: OpenRouterModel[];
-}
-export interface ListModelsResponse {
-  text: ModelProviderInfo[];
-  image: ModelProviderInfo[];
-}
-export class AIModelService {
-  /**
-   * Get all available AI models
-   * Fetches from cloud API if in cloud environment, otherwise from OpenRouter directly
-   */
-  static async getModels(): Promise<ListModelsResponse> {
-    const credentialsService = AIClientService.getInstance();
-    const configured = credentialsService.isConfigured();
-    if (!configured) {
-      return {
-        text: [
-          {
-            provider: 'openrouter',
-            configured: false,
-            models: [],
-          },
-        ],
-        image: [
-          {
-            provider: 'openrouter',
-            configured: false,
-            models: [],
-          },
-        ],
-      };
-    }
-    // Get API key from credentials service
-    const apiKey = await credentialsService.getApiKey();
-    // Determine the API endpoint based on environment
-    const apiUrl = isCloudEnvironment()
-      ? 'https://api.insforge.dev/ai/v1/models'
-      : 'https://openrouter.ai/api/v1/models/user';
-    // Fetch models from the appropriate endpoint
-    const response = await fetch(apiUrl, {
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-      },
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to fetch models: ${response.statusText}`);
-    }
-    const data = (await response.json()) as { data: RawOpenRouterModel[] };
-    const models = data.data || [];
-    const textModels: OpenRouterModel[] = [];
-    const imageModels: OpenRouterModel[] = [];
-    for (const model of models) {
-      // Classify based on output modality
-      const transformedModel: OpenRouterModel = {
-        ...model,
-        architecture: model.architecture
-          ? {
-              inputModalities: model.architecture.input_modalities || [],
-              outputModalities: model.architecture.output_modalities || [],
-              tokenizer: model.architecture.tokenizer || '',
-              instructType: model.architecture.instruct_type || '',
-            }
-          : undefined,
-        topProvider: model.topProvider
-          ? {
-              isModerated: model.topProvider.is_moderated,
-              contextLength: model.topProvider.context_length,
-              maxCompletionTokens: model.topProvider.max_completion_tokens,
-            }
-          : undefined,
-      };
-      if (model.architecture?.output_modalities?.includes('image')) {
-        imageModels.push(transformedModel);
-      }
-      if (model.architecture?.output_modalities?.includes('text')) {
-        textModels.push(transformedModel);
-      }
-    }
-    return {
-      text: [
-        {
-          provider: 'openrouter',
-          configured: true,
-          models: textModels,
-        },
-      ],
-      image: [
-        {
-          provider: 'openrouter',
-          configured: true,
-          models: imageModels,
-        },
-      ],
-    };
-  }
-}