@masonator/coolify-mcp 2.6.5 → 2.6.6

package/dist/__tests__/mcp-server.test.js

@@ -148,41 +148,46 @@ describe('CoolifyMcpServer v2', () => {
     });
 });
 describe('truncateLogs', () => {
+    // Plain text log tests
     it('should return logs unchanged when within limits', () => {
         const logs = 'line1\nline2\nline3';
         const result = truncateLogs(logs, 200, 50000);
-        expect(result).toBe(logs);
+        expect(result.logs).toBe(logs);
+        expect(result.total).toBe(3);
     });
     it('should truncate to last N lines', () => {
         const logs = 'line1\nline2\nline3\nline4\nline5';
         const result = truncateLogs(logs, 3, 50000);
-        expect(result).toBe('line3\nline4\nline5');
+        expect(result.logs).toBe('line3\nline4\nline5');
+        expect(result.total).toBe(5);
+        expect(result.showing_start).toBe(3);
+        expect(result.showing_end).toBe(5);
     });
     it('should truncate by character limit when lines are huge', () => {
         const hugeLine = 'x'.repeat(100);
         const logs = `${hugeLine}\n${hugeLine}\n${hugeLine}`;
         const result = truncateLogs(logs, 200, 50);
-        expect(result.length).toBeLessThanOrEqual(50);
-        expect(result.startsWith('...[truncated]...')).toBe(true);
+        expect(result.logs.length).toBeLessThanOrEqual(50);
+        expect(result.logs.startsWith('...[truncated]...')).toBe(true);
     });
     it('should not add truncation prefix when under char limit', () => {
         const logs = 'line1\nline2\nline3';
         const result = truncateLogs(logs, 200, 50000);
-        expect(result.startsWith('...[truncated]...')).toBe(false);
+        expect(result.logs.startsWith('...[truncated]...')).toBe(false);
     });
     it('should handle empty logs', () => {
         const result = truncateLogs('', 200, 50000);
-        expect(result).toBe('');
+        expect(result.logs).toBe('');
     });
     it('should use default limits when not specified', () => {
         const logs = 'line1\nline2';
         const result = truncateLogs(logs);
-        expect(result).toBe(logs);
+        expect(result.logs).toBe(logs);
     });
     it('should respect custom line limit', () => {
         const lines = Array.from({ length: 300 }, (_, i) => `line${i + 1}`).join('\n');
         const result = truncateLogs(lines, 50, 50000);
-        const resultLines = result.split('\n');
+        const resultLines = result.logs.split('\n');
         expect(resultLines.length).toBe(50);
         expect(resultLines[0]).toBe('line251');
         expect(resultLines[49]).toBe('line300');
@@ -190,7 +195,90 @@ describe('truncateLogs', () => {
     it('should respect custom char limit', () => {
         const logs = 'x'.repeat(1000);
         const result = truncateLogs(logs, 200, 100);
-        expect(result.length).toBe(100);
+        expect(result.logs.length).toBe(100);
+    });
+    // Pagination tests (plain text)
+    it('should paginate plain text logs (page 2 = older entries)', () => {
+        const logs = Array.from({ length: 30 }, (_, i) => `line${i + 1}`).join('\n');
+        const page1 = truncateLogs(logs, 10, 50000, 1);
+        const page2 = truncateLogs(logs, 10, 50000, 2);
+        const page3 = truncateLogs(logs, 10, 50000, 3);
+        expect(page1.logs).toContain('line30');
+        expect(page1.logs).toContain('line21');
+        expect(page1.logs).not.toContain('line20');
+        expect(page2.logs).toContain('line20');
+        expect(page2.logs).toContain('line11');
+        expect(page2.logs).not.toContain('line10');
+        expect(page3.logs).toContain('line10');
+        expect(page3.logs).toContain('line1');
+        expect(page1.showing_start).toBe(21);
+        expect(page1.showing_end).toBe(30);
+    });
+    // JSON array format tests (Coolify deployment logs)
+    it('should parse JSON array logs and return last N visible entries', () => {
+        const entries = [
+            { output: 'Building...', timestamp: '2026-01-01T00:00:01Z', hidden: false },
+            { output: 'docker pull', timestamp: '2026-01-01T00:00:02Z', hidden: true },
+            { output: 'Compiling...', timestamp: '2026-01-01T00:00:03Z', hidden: false },
+            { output: 'Done.', timestamp: '2026-01-01T00:00:04Z', hidden: false },
+        ];
+        const result = truncateLogs(JSON.stringify(entries), 2, 50000);
+        expect(result.logs).toContain('Compiling...');
+        expect(result.logs).toContain('Done.');
+        expect(result.logs).not.toContain('Building...');
+        expect(result.logs).not.toContain('docker pull');
+        expect(result.total).toBe(3); // 3 visible entries
+    });
+    it('should filter hidden entries from JSON logs', () => {
+        const entries = [
+            { output: 'visible1', timestamp: '2026-01-01T00:00:01Z', hidden: false },
+            { output: 'hidden1', timestamp: '2026-01-01T00:00:02Z', hidden: true },
+            { output: 'hidden2', timestamp: '2026-01-01T00:00:03Z', hidden: true },
+            { output: 'visible2', timestamp: '2026-01-01T00:00:04Z', hidden: false },
+        ];
+        const result = truncateLogs(JSON.stringify(entries), 200, 50000);
+        expect(result.logs).toContain('visible1');
+        expect(result.logs).toContain('visible2');
+        expect(result.logs).not.toContain('hidden1');
+        expect(result.logs).not.toContain('hidden2');
+    });
+    it('should format JSON log entries with timestamp and output', () => {
+        const entries = [
+            { output: 'Starting deploy', timestamp: '2026-01-01T10:00:00Z', hidden: false },
+        ];
+        const result = truncateLogs(JSON.stringify(entries), 200, 50000);
+        expect(result.logs).toBe('[2026-01-01T10:00:00Z] Starting deploy');
+    });
+    it('should paginate JSON logs (page 2 = older entries)', () => {
+        const entries = Array.from({ length: 30 }, (_, i) => ({
+            output: `step ${i + 1}`,
+            timestamp: `2026-01-01T00:00:${String(i).padStart(2, '0')}Z`,
+            hidden: false,
+        }));
+        const page1 = truncateLogs(JSON.stringify(entries), 10, 50000, 1);
+        const page2 = truncateLogs(JSON.stringify(entries), 10, 50000, 2);
+        expect(page1.logs).toContain('step 30');
+        expect(page1.logs).toContain('step 21');
+        expect(page1.logs).not.toContain('step 20');
+        expect(page2.logs).toContain('step 20');
+        expect(page2.logs).toContain('step 11');
+        expect(page2.logs).not.toContain('step 10');
+        expect(page1.total).toBe(30);
+        expect(page1.showing_start).toBe(21);
+        expect(page1.showing_end).toBe(30);
+        expect(page2.showing_start).toBe(11);
+        expect(page2.showing_end).toBe(20);
+    });
+    it('should return metadata with total and showing range', () => {
+        const entries = Array.from({ length: 50 }, (_, i) => ({
+            output: `step ${i}`,
+            timestamp: `2026-01-01T00:00:${String(i).padStart(2, '0')}Z`,
+            hidden: false,
+        }));
+        const result = truncateLogs(JSON.stringify(entries), 10, 50000);
+        expect(result.total).toBe(50);
+        expect(result.showing_start).toBe(41);
+        expect(result.showing_end).toBe(50);
     });
 });
 // =============================================================================

package/dist/lib/mcp-server.d.ts

@@ -6,11 +6,19 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
 import type { CoolifyConfig, ResponseAction, ResponsePagination } from '../types/coolify.js';
 export declare const VERSION: string;
+export interface TruncatedLogsResult {
+    logs: string;
+    total: number;
+    showing_start: number;
+    showing_end: number;
+}
 /**
- * Truncate logs by line count and character count.
+ * Truncate logs by entry count with pagination support.
+ * Handles both JSON array format (Coolify deployment logs) and plain text.
+ * Page 1 = most recent entries, page 2 = next older batch, etc.
  * Exported for testing.
  */
-export declare function truncateLogs(logs: string, lineLimit?: number, charLimit?: number): string;
+export declare function truncateLogs(logs: string, lineLimit?: number, charLimit?: number, page?: number): TruncatedLogsResult;
 /** Generate contextual actions for an application based on its status */
 export declare function getApplicationActions(uuid: string, status?: string): ResponseAction[];
 /** Generate contextual actions for a deployment */

package/dist/lib/mcp-server.js

@@ -25,21 +25,55 @@ function wrap(fn) {
 }
 const TRUNCATION_PREFIX = '...[truncated]...\n';
 /**
- * Truncate logs by line count and character count.
+ * Truncate logs by entry count with pagination support.
+ * Handles both JSON array format (Coolify deployment logs) and plain text.
+ * Page 1 = most recent entries, page 2 = next older batch, etc.
  * Exported for testing.
  */
-export function truncateLogs(logs, lineLimit = 200, charLimit = 50000) {
-    // First: limit by lines
-    const logLines = logs.split('\n');
-    const limitedLines = logLines.slice(-lineLimit);
-    let truncatedLogs = limitedLines.join('\n');
-    // Second: limit by characters (safety net for huge lines)
-    if (truncatedLogs.length > charLimit) {
-        // Account for prefix length to stay within limit
+export function truncateLogs(logs, lineLimit = 200, charLimit = 50000, page = 1) {
+    // Try parsing as JSON array (Coolify deployment log format)
+    let lines;
+    let total;
+    try {
+        const entries = JSON.parse(logs);
+        if (Array.isArray(entries)) {
+            const visible = entries.filter((e) => !e.hidden);
+            total = visible.length;
+            const end = total - (page - 1) * lineLimit;
+            const start = Math.max(0, end - lineLimit);
+            const slice = visible.slice(start, end);
+            lines = slice.map((e) => `[${e.timestamp ?? ''}] ${e.output ?? ''}`);
+        }
+        else {
+            const allLines = logs.split('\n');
+            total = allLines.length;
+            const end = total - (page - 1) * lineLimit;
+            const start = Math.max(0, end - lineLimit);
+            lines = allLines.slice(start, end);
+        }
+    }
+    catch {
+        // Plain text logs — split by newlines
+        const allLines = logs.split('\n');
+        total = allLines.length;
+        const end = total - (page - 1) * lineLimit;
+        const start = Math.max(0, end - lineLimit);
+        lines = allLines.slice(start, end);
+    }
+    const end = total - (page - 1) * lineLimit;
+    const start = Math.max(0, end - lineLimit);
+    let result = lines.join('\n');
+    // Safety net: limit by characters
+    if (result.length > charLimit) {
         const prefixLen = TRUNCATION_PREFIX.length;
-        truncatedLogs = TRUNCATION_PREFIX + truncatedLogs.slice(-(charLimit - prefixLen));
+        result = TRUNCATION_PREFIX + result.slice(-(charLimit - prefixLen));
     }
-    return truncatedLogs;
+    return {
+        logs: result,
+        total,
+        showing_start: start + 1,
+        showing_end: Math.min(end, total),
+    };
 }
 // =============================================================================
 // Action Generators for HATEOAS-style responses
@@ -676,22 +710,48 @@ export class CoolifyMcpServer extends McpServer {
         this.tool('deployment', 'Manage deployment: get/cancel/list_for_app (logs excluded by default, use lines param to include)', {
             action: z.enum(['get', 'cancel', 'list_for_app']),
             uuid: z.string(),
-            lines: z.number().optional(), // Include logs truncated to last N lines (omit for no logs)
+            lines: z.number().optional(), // Include logs truncated to last N entries (omit for no logs)
+            page: z.number().optional(), // Log page (1=most recent, 2=older, etc.)
             max_chars: z.number().optional(), // Limit log output to last N chars (default: 50000)
-        }, async ({ action, uuid, lines, max_chars }) => {
+        }, async ({ action, uuid, lines, page, max_chars }) => {
             switch (action) {
                 case 'get':
                     // If lines param specified, include logs and truncate
                     if (lines !== undefined) {
+                        const p = page ?? 1;
+                        const ll = lines;
                         return wrapWithActions(async () => {
                             const deployment = (await this.client.getDeployment(uuid, {
                                 includeLogs: true,
                             }));
                             if (deployment.logs) {
-                                deployment.logs = truncateLogs(deployment.logs, lines, max_chars ?? 50000);
+                                const result = truncateLogs(deployment.logs, ll, max_chars ?? 50000, p);
+                                deployment.logs = result.logs;
+                                return {
+                                    ...deployment,
+                                    logs_meta: {
+                                        total_entries: result.total,
+                                        showing: `${result.showing_start}-${result.showing_end} of ${result.total}`,
+                                    },
+                                };
                             }
-                            return deployment;
-                        }, (dep) => getDeploymentActions(dep.uuid, dep.status, dep.application_uuid));
+                            return { ...deployment, logs_meta: undefined };
+                        }, (dep) => getDeploymentActions(dep.uuid, dep.status, dep.application_uuid), (dep) => {
+                            const total = dep.logs_meta?.total_entries ?? 0;
+                            const hasOlder = p * ll < total;
+                            const pagination = {};
+                            if (hasOlder)
+                                pagination.next = {
+                                    tool: 'deployment',
+                                    args: { action: 'get', uuid, lines: ll, page: p + 1 },
+                                };
+                            if (p > 1)
+                                pagination.prev = {
+                                    tool: 'deployment',
+                                    args: { action: 'get', uuid, lines: ll, page: p - 1 },
+                                };
+                            return Object.keys(pagination).length > 0 ? pagination : undefined;
+                        });
                     }
                     // Otherwise return essential info without logs
                     return wrapWithActions(() => this.client.getDeployment(uuid), (dep) => getDeploymentActions(dep.uuid, dep.status, dep.application_uuid));

package/dist/types/coolify.d.ts

@@ -907,11 +907,11 @@ export interface ResponseAction {
 export interface ResponsePagination {
     next?: {
         tool: string;
-        args: Record<string, number>;
+        args: Record<string, string | number>;
     };
     prev?: {
         tool: string;
-        args: Record<string, number>;
+        args: Record<string, string | number>;
     };
 }
 export interface DeploymentEssential {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@masonator/coolify-mcp",
   "scope": "@masonator",
-  "version": "2.6.5",
+  "version": "2.6.6",
   "description": "MCP server implementation for Coolify",
   "type": "module",
   "main": "./dist/index.js",