marble-headed-mcp 0.1.21 → 0.1.24

package/README.md

@@ -0,0 +1 @@
+# marble-headed-mcp

package/dist/index.js

@@ -7,6 +7,7 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 const DEFAULT_BASE_URL = 'http://localhost:4000';
+const WEBAPP_LOG_PATH = '/tmp/webapp';
 const execFileAsync = promisify(execFile);
 function normalizeBaseUrl(input) {
     return input.replace(/\/+$/, '');
@@ -79,6 +80,129 @@ async function getJson(pathname) {
     }
     return { status: response.status, ok: response.ok, text, json };
 }
+function splitLogLines(content) {
+    const normalized = content.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    const lines = normalized.split('\n');
+    if (lines.length && lines[lines.length - 1] === '') {
+        lines.pop();
+    }
+    return lines;
+}
+async function readWebappLogLines() {
+    try {
+        const content = await fs.readFile(WEBAPP_LOG_PATH, 'utf8');
+        return { ok: true, lines: splitLogLines(content) };
+    }
+    catch (error) {
+        return { ok: false, error: error?.message || String(error) };
+    }
+}
+function normalizePositiveInt(value) {
+    if (typeof value !== 'number' || Number.isNaN(value))
+        return null;
+    const rounded = Math.floor(value);
+    if (rounded <= 0)
+        return null;
+    return rounded;
+}
+function buildLineRecords(lines, startIndex) {
+    const records = [];
+    for (let i = startIndex; i < lines.length; i += 1) {
+        records.push({ lineNumber: i + 1, text: lines[i] });
+    }
+    return records;
+}
+function buildMatcher(pattern) {
+    const trimmed = typeof pattern === 'string' ? pattern.trim() : '';
+    if (!trimmed) {
+        return () => true;
+    }
+    try {
+        const regex = new RegExp(trimmed);
+        return (line) => regex.test(line);
+    }
+    catch (error) {
+        return (line) => line.includes(trimmed);
+    }
+}
+function mergeRanges(ranges) {
+    if (!ranges.length)
+        return [];
+    const sorted = [...ranges].sort((a, b) => a.start - b.start);
+    const merged = [];
+    for (const range of sorted) {
+        const last = merged[merged.length - 1];
+        if (!last || range.start > last.end + 1) {
+            merged.push({ start: range.start, end: range.end });
+        }
+        else {
+            last.end = Math.max(last.end, range.end);
+        }
+    }
+    return merged;
+}
+async function fetchAllWebappLogs(args) {
+    const numberOfHits = normalizePositiveInt(args.number_of_hits);
+    if (!numberOfHits) {
+        return { ok: false, error: 'number_of_hits must be a positive integer.' };
+    }
+    const readResult = await readWebappLogLines();
+    if (!readResult.ok) {
+        return { ok: false, error: readResult.error };
+    }
+    const totalLines = readResult.lines.length;
+    const startIndex = Math.max(0, totalLines - numberOfHits);
+    const selected = readResult.lines.slice(startIndex);
+    const lines = buildLineRecords(selected, startIndex);
+    return {
+        ok: true,
+        totalLines,
+        returnedLines: lines.length,
+        lines,
+    };
+}
+async function fetchGrepWebappLogs(args) {
+    const numberOfHits = normalizePositiveInt(args.number_of_hits);
+    if (!numberOfHits) {
+        return { ok: false, error: 'number_of_hits must be a positive integer.' };
+    }
+    const context = normalizePositiveInt(args.context) ?? 0;
+    const matcher = buildMatcher(args.grep_pattern);
+    const readResult = await readWebappLogLines();
+    if (!readResult.ok) {
+        return { ok: false, error: readResult.error };
+    }
+    const lines = readResult.lines;
+    const hitIndices = [];
+    const hitLines = [];
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        if (matcher(lines[index])) {
+            hitIndices.push(index);
+            hitLines.push({ lineNumber: index + 1, text: lines[index] });
+            if (hitIndices.length >= numberOfHits) {
+                break;
+            }
+        }
+    }
+    const ranges = mergeRanges(hitIndices.map((hit) => ({
+        start: Math.max(0, hit - context),
+        end: Math.min(lines.length - 1, hit + context),
+    })));
+    const contextLines = [];
+    for (const range of ranges) {
+        for (let i = range.start; i <= range.end; i += 1) {
+            contextLines.push({ lineNumber: i + 1, text: lines[i] });
+        }
+    }
+    return {
+        ok: true,
+        totalLines: lines.length,
+        matchedHits: hitIndices.length,
+        hitLines,
+        contextLines,
+        ranges: ranges.map((range) => ({ startLine: range.start + 1, endLine: range.end + 1 })),
+    };
+}
 async function fetchWorkflowEntries(runId) {
     if (!runId)
         return null;
@@ -314,9 +438,11 @@ const TOOLS = [
             type: 'object',
             properties: {
                 projectId: { type: 'number', description: 'Project id to fetch logs for.' },
-                timeStart: { type: 'string', description: 'Start timestamp (ISO). Optional.' },
-                timeEnd: { type: 'string', description: 'End timestamp (ISO). Optional.' },
-                limit: { type: 'number', description: 'Maximum number of log entries to return. A reasonable default is 1000.' },
+                timestampStart: { type: 'string', description: 'Start timestamp (ISO). Optional. Legacy `timeStart` is also accepted.' },
+                timestampEnd: { type: 'string', description: 'End timestamp (ISO). Optional. Legacy `timeEnd` is also accepted.' },
+                timeStart: { type: 'string', description: 'Legacy start timestamp (ISO). Optional.' },
+                timeEnd: { type: 'string', description: 'Legacy end timestamp (ISO). Optional.' },
+                freshness: { type: 'string', description: 'Relative freshness (e.g., "3h" or "1d") to fetch recent logs instead of timestamps.' },
             },
             required: ['projectId'],
             additionalProperties: false,
@@ -334,6 +460,32 @@ const TOOLS = [
             additionalProperties: false,
         },
     },
+    {
+        name: 'fetch_all_webapp_logs',
+        description: 'Get the last number_of_hits logs from /tmp/webapp.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                number_of_hits: { type: 'number', description: 'Number of log lines to return from the end of /tmp/webapp.' },
+            },
+            required: ['number_of_hits'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'fetch_grep_webapp_logs',
+        description: 'Grep backwards from the end of /tmp/webapp for number_of_hits matches and return context lines without duplication.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                number_of_hits: { type: 'number', description: 'Number of matching log hits to return from the end of /tmp/webapp.' },
+                grep_pattern: { type: 'string', description: 'Optional regex pattern to match log lines.' },
+                context: { type: 'number', description: 'Number of surrounding lines to include around each hit.' },
+            },
+            required: ['number_of_hits'],
+            additionalProperties: false,
+        },
+    },
     {
         name: 'save_image_url',
         description: 'Download an image URL to /tmp and return the file path.',
@@ -462,7 +614,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return { content: [{ type: 'text', text: JSON.stringify(payload || { status: result.status, body: result.text }, null, 2) }] };
             }
             case 'get_container_logs': {
-                const result = await postJson('/api/gcloud/read', args);
+                const result = await postHeadedJson('/get_container_logs', args);
                 const payload = (result.json && typeof result.json === 'object') ? result.json : null;
                 if (!result.ok || !payload) {
                     const fallbackText = result.text || '';
@@ -521,6 +673,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const result = await postHeadedJson('/get_instance_files', args);
                 return { content: [{ type: 'text', text: JSON.stringify(result.json || { status: result.status, body: result.text }, null, 2) }] };
             }
+            case 'fetch_all_webapp_logs': {
+                const result = await fetchAllWebappLogs(args);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'fetch_grep_webapp_logs': {
+                const result = await fetchGrepWebappLogs(args);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
             case 'save_image_url': {
                 const saveResult = await saveImageFromUrl({
                     url: args?.url,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marble-headed-mcp",
-  "version": "0.1.21",
+  "version": "0.1.24",
   "description": "MCP server for Marble headed automation endpoints",
   "main": "dist/index.js",
   "type": "module",