@mcpjam/inspector 0.3.5 → 0.3.6

package/client/dist/assets/{index-DegSReJM.css → index-CWDemo1t.css}

@@ -1072,6 +1072,9 @@ video {
 .right-2 {
   right: 0.5rem;
 }
+.right-3 {
+  right: 0.75rem;
+}
 .right-4 {
   right: 1rem;
 }
@@ -1134,6 +1137,9 @@ video {
   margin-top: auto;
   margin-bottom: auto;
 }
+.-ml-1 {
+  margin-left: -0.25rem;
+}
 .mb-1 {
   margin-bottom: 0.25rem;
 }
@@ -1167,9 +1173,6 @@ video {
 .ml-7 {
   margin-left: 1.75rem;
 }
-.ml-8 {
-  margin-left: 2rem;
-}
 .ml-auto {
   margin-left: auto;
 }
@@ -1525,6 +1528,9 @@ video {
 .cursor-default {
   cursor: default;
 }
+.cursor-help {
+  cursor: help;
+}
 .cursor-not-allowed {
   cursor: not-allowed;
 }
@@ -1788,6 +1794,10 @@ video {
   --tw-border-opacity: 1;
   border-color: rgb(209 213 219 / var(--tw-border-opacity, 1));
 }
+.border-gray-400 {
+  --tw-border-opacity: 1;
+  border-color: rgb(156 163 175 / var(--tw-border-opacity, 1));
+}
 .border-green-200 {
   --tw-border-opacity: 1;
   border-color: rgb(187 247 208 / var(--tw-border-opacity, 1));
@@ -1901,6 +1911,10 @@ video {
   --tw-bg-opacity: 1;
   background-color: rgb(249 250 251 / var(--tw-bg-opacity, 1));
 }
+.bg-gray-600 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(75 85 99 / var(--tw-bg-opacity, 1));
+}
 .bg-gray-900 {
   --tw-bg-opacity: 1;
   background-color: rgb(17 24 39 / var(--tw-bg-opacity, 1));
@@ -2262,15 +2276,27 @@ video {
 .pb-4 {
   padding-bottom: 1rem;
 }
+.pl-12 {
+  padding-left: 3rem;
+}
 .pl-2 {
   padding-left: 0.5rem;
 }
+.pl-4 {
+  padding-left: 1rem;
+}
 .pr-10 {
   padding-right: 2.5rem;
 }
+.pr-12 {
+  padding-right: 3rem;
+}
 .pr-3 {
   padding-right: 0.75rem;
 }
+.pr-4 {
+  padding-right: 1rem;
+}
 .pr-6 {
   padding-right: 1.5rem;
 }
@@ -2826,6 +2852,11 @@ h1 {
   border-color: hsl(var(--border) / 0.6);
 }
 
+.hover\:border-gray-500:hover {
+  --tw-border-opacity: 1;
+  border-color: rgb(107 114 128 / var(--tw-border-opacity, 1));
+}
+
 .hover\:border-primary\/20:hover {
   border-color: hsl(var(--primary) / 0.2);
 }
@@ -2871,6 +2902,11 @@ h1 {
   background-color: hsl(var(--destructive) / 0.9);
 }
 
+.hover\:bg-gray-700:hover {
+  --tw-bg-opacity: 1;
+  background-color: rgb(55 65 81 / var(--tw-bg-opacity, 1));
+}
+
 .hover\:bg-gray-800\/10:hover {
   background-color: rgb(31 41 55 / 0.1);
 }
@@ -3004,6 +3040,11 @@ h1 {
   color: hsl(var(--foreground));
 }
 
+.hover\:text-gray-600:hover {
+  --tw-text-opacity: 1;
+  color: rgb(75 85 99 / var(--tw-text-opacity, 1));
+}
+
 .hover\:text-primary:hover {
   color: hsl(var(--primary));
 }
@@ -3097,6 +3138,11 @@ h1 {
   --tw-ring-color: rgb(59 130 246 / var(--tw-ring-opacity, 1));
 }
 
+.focus\:ring-indigo-400:focus {
+  --tw-ring-opacity: 1;
+  --tw-ring-color: rgb(129 140 248 / var(--tw-ring-opacity, 1));
+}
+
 .focus\:ring-primary\/20:focus {
   --tw-ring-color: hsl(var(--primary) / 0.2);
 }
@@ -3895,6 +3941,11 @@ h1 {
   --tw-gradient-to: hsl(var(--secondary) / 0.3) var(--tw-gradient-to-position);
 }
 
+.dark\:hover\:text-gray-300:hover:is(.dark *) {
+  --tw-text-opacity: 1;
+  color: rgb(209 213 219 / var(--tw-text-opacity, 1));
+}
+
 .dark\:hover\:text-slate-100:hover:is(.dark *) {
   --tw-text-opacity: 1;
   color: rgb(241 245 249 / var(--tw-text-opacity, 1));
@@ -3983,6 +4034,17 @@ h1 {
   .md\:max-w-\[420px\] {
     max-width: 420px;
   }
+
+  .md\:grid-cols-2 {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+}
+
+@media (min-width: 1024px) {
+
+  .lg\:grid-cols-3 {
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+  }
 }
 
 .\[\&\+div\]\:text-xs+div {

package/client/dist/index.html

@@ -5,8 +5,8 @@
     <link rel="icon" type="image/svg+xml" href="/mcp_jam.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>MCPJam Inspector</title>
-    <script type="module" crossorigin src="/assets/index-DQYTYcqe.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DegSReJM.css">
+    <script type="module" crossorigin src="/assets/index-Bgrnc5s2.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CWDemo1t.css">
   </head>
   <body>
     <div id="root" class="w-full"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcpjam/inspector",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "MCPJam inspector",
   "license": "Apache-2.0",
   "author": "MCPJam (https://mcpjam.com)",

package/server/build/database/DatabaseManager.js

@@ -0,0 +1,108 @@
+/**
+ * DatabaseManager - Basic libSQL database manager for MCPJam Inspector
+ * Simple local SQLite database foundation
+ */
+import { createClient } from "@libsql/client";
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { ensureDirectoryExists, ensureMCPJamDirectory, getResolvedDatabasePath, } from "./utils.js";
+import { DatabaseError, QueryError, } from "./types.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export class DatabaseManager {
+    client;
+    initialized = false;
+    config;
+    constructor(config) {
+        this.config = config || { localPath: getResolvedDatabasePath() };
+        this.client = this.createClient();
+    }
+    createClient() {
+        // Use the configured database path
+        const dbPath = this.config.localPath;
+        return createClient({
+            url: `file:${dbPath}`,
+        });
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        try {
+            console.log("🔄 Initializing database...");
+            // Ensure .mcpjam directory exists and database directory
+            await ensureMCPJamDirectory();
+            const dbPath = getResolvedDatabasePath();
+            await ensureDirectoryExists(dbPath);
+            // Read and execute schema
+            const schemaPath = join(__dirname, "schema.sql");
+            const schema = readFileSync(schemaPath, "utf-8");
+            await this.client.executeMultiple(schema);
+            this.initialized = true;
+            console.log("✅ Database initialized successfully");
+        }
+        catch (error) {
+            throw new DatabaseError("Failed to initialize database", "INIT_ERROR", error);
+        }
+    }
+    // ============================================================================
+    // APP METADATA OPERATIONS
+    // ============================================================================
+    async getMetadata(key) {
+        try {
+            const result = await this.client.execute({
+                sql: "SELECT value FROM app_metadata WHERE key = ?",
+                args: [key],
+            });
+            if (result.rows.length === 0)
+                return null;
+            return result.rows[0].value;
+        }
+        catch (error) {
+            throw new QueryError("Failed to get metadata", undefined, error);
+        }
+    }
+    async setMetadata(key, value) {
+        try {
+            await this.client.execute({
+                sql: "INSERT OR REPLACE INTO app_metadata (key, value) VALUES (?, ?)",
+                args: [key, value],
+            });
+        }
+        catch (error) {
+            throw new QueryError("Failed to set metadata", undefined, error);
+        }
+    }
+    async getAllMetadata() {
+        try {
+            const result = await this.client.execute({
+                sql: "SELECT * FROM app_metadata ORDER BY key",
+                args: [],
+            });
+            return result.rows.map((row) => ({
+                key: row.key,
+                value: row.value,
+                createdAt: new Date(row.created_at),
+                updatedAt: new Date(row.updated_at),
+            }));
+        }
+        catch (error) {
+            throw new QueryError("Failed to get all metadata", undefined, error);
+        }
+    }
+    async deleteMetadata(key) {
+        try {
+            await this.client.execute({
+                sql: "DELETE FROM app_metadata WHERE key = ?",
+                args: [key],
+            });
+        }
+        catch (error) {
+            throw new QueryError("Failed to delete metadata", undefined, error);
+        }
+    }
+    async close() {
+        if (this.client) {
+            this.client.close();
+        }
+    }
+}

package/server/build/database/index.js

@@ -0,0 +1,8 @@
+/**
+ * Database module exports for MCPJam Inspector
+ * Provides comprehensive libSQL database functionality
+ */
+export { DatabaseManager } from "./DatabaseManager.js";
+export { createDatabaseRoutes } from "./routes.js";
+export * from "./types.js";
+export * from "./utils.js";

package/server/build/database/routes.js

@@ -0,0 +1,86 @@
+/**
+ * Database API routes for MCPJam Inspector
+ * Basic endpoints for app metadata operations
+ */
+import { Router } from "express";
+export function createDatabaseRoutes(databaseManager) {
+    const router = Router();
+    // Error handler wrapper
+    const asyncHandler = (fn) => (req, res, next) => {
+        Promise.resolve(fn(req, res, next)).catch(next);
+    };
+    // ============================================================================
+    // APP METADATA OPERATIONS
+    // ============================================================================
+    // Get all metadata
+    router.get("/metadata", asyncHandler(async (req, res) => {
+        const metadata = await databaseManager.getAllMetadata();
+        res.json({
+            success: true,
+            data: metadata,
+            count: metadata.length,
+        });
+    }));
+    // Get single metadata value
+    router.get("/metadata/:key", asyncHandler(async (req, res) => {
+        const value = await databaseManager.getMetadata(req.params.key);
+        if (value === null) {
+            res.status(404).json({
+                success: false,
+                error: "Metadata key not found",
+            });
+            return;
+        }
+        res.json({
+            success: true,
+            data: { key: req.params.key, value },
+        });
+    }));
+    // Set metadata value
+    router.post("/metadata/:key", asyncHandler(async (req, res) => {
+        const { value } = req.body;
+        if (value === undefined) {
+            res.status(400).json({
+                success: false,
+                error: "Missing required field: value",
+            });
+            return;
+        }
+        await databaseManager.setMetadata(req.params.key, value);
+        res.json({
+            success: true,
+            message: "Metadata stored successfully",
+        });
+    }));
+    // Delete metadata key
+    router.delete("/metadata/:key", asyncHandler(async (req, res) => {
+        await databaseManager.deleteMetadata(req.params.key);
+        res.json({
+            success: true,
+            message: "Metadata deleted successfully",
+        });
+    }));
+    // ============================================================================
+    // HEALTH CHECK
+    // ============================================================================
+    router.get("/health", asyncHandler(async (req, res) => {
+        res.json({
+            success: true,
+            message: "Database API is healthy",
+            timestamp: new Date().toISOString(),
+        });
+    }));
+    // Error handling middleware
+    router.use((error, req, res, next) => {
+        console.error("Database API Error:", error);
+        const statusCode = error.status || 500;
+        const message = error.message || "Internal server error";
+        res.status(statusCode).json({
+            success: false,
+            error: message,
+            code: error.code,
+            ...(process.env.NODE_ENV === "development" && { stack: error.stack }),
+        });
+    });
+    return router;
+}

package/server/build/database/types.js

@@ -0,0 +1,27 @@
+/**
+ * Database types and interfaces for MCPJam Inspector
+ * Basic foundation types for local SQLite database
+ */
+// ============================================================================
+// ERROR TYPES
+// ============================================================================
+export class DatabaseError extends Error {
+    code;
+    cause;
+    constructor(message, code, cause) {
+        super(message);
+        this.code = code;
+        this.cause = cause;
+        this.name = "DatabaseError";
+    }
+}
+export class QueryError extends Error {
+    query;
+    cause;
+    constructor(message, query, cause) {
+        super(message);
+        this.query = query;
+        this.cause = cause;
+        this.name = "QueryError";
+    }
+}

package/server/build/database/utils.js

@@ -0,0 +1,86 @@
+/**
+ * Database utilities for MCPJam Inspector
+ * Basic utilities for local SQLite database setup
+ */
+import { mkdir, access } from "fs/promises";
+import { dirname } from "path";
+import { homedir } from "os";
+import { join } from "path";
+/**
+ * Ensures the .mcpjam directory exists in the user's home directory
+ */
+export async function ensureMCPJamDirectory() {
+    const mcpjamDir = join(homedir(), ".mcpjam");
+    try {
+        await access(mcpjamDir);
+    }
+    catch {
+        // Directory doesn't exist, create it
+        await mkdir(mcpjamDir, { recursive: true });
+        console.log(`📁 Created MCPJam directory: ${mcpjamDir}`);
+    }
+    return mcpjamDir;
+}
+/**
+ * Ensures the directory for a given file path exists
+ */
+export async function ensureDirectoryExists(filePath) {
+    const dir = dirname(filePath);
+    try {
+        await access(dir);
+    }
+    catch {
+        await mkdir(dir, { recursive: true });
+    }
+}
+/**
+ * Gets the resolved database path - THE SINGLE SOURCE OF TRUTH
+ * Priority: MCPJAM_DB_PATH env var > default ~/.mcpjam/data.db
+ */
+export function getResolvedDatabasePath() {
+    return process.env.MCPJAM_DB_PATH || join(homedir(), ".mcpjam", "data.db");
+}
+/**
+ * Environment configuration helper
+ */
+export function getDatabaseConfig() {
+    return {
+        localPath: getResolvedDatabasePath(),
+    };
+}
+/**
+ * Checks if the database file exists
+ */
+export async function databaseExists(databasePath) {
+    try {
+        await access(databasePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Database connection test
+ */
+export async function testDatabaseConnection(config) {
+    try {
+        const { createClient } = await import("@libsql/client");
+        // Use the single source of truth for database path
+        const dbPath = config?.localPath || getResolvedDatabasePath();
+        await ensureDirectoryExists(dbPath);
+        const client = createClient({
+            url: `file:${dbPath}`,
+        });
+        // Test the connection with a simple query
+        await client.execute("SELECT 1");
+        client.close();
+        return { success: true };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}