2026-11-21 11:26:01 -08:00
import assert from "node:assert/strict" ;
import { existsSync , readFileSync } from "node:fs" ;
import fs from "node:fs/promises" ;
import http from "node:http" ;
import { createRequire } from "node:module" ;
import type { AddressInfo } from "node:net" ;
import os from "node:os" ;
import path from "node:path" ;
import test , { after } from "node:test" ;
import { Client } from "@modelcontextprotocol/sdk/client/index.js" ;
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js" ;
import { NextRequest } from "next/server" ;
process . env . DATASTACK_DISABLE_LISTEN = "1" ;
import { GET as mcpSettingsGet , POST as mcpSettingsPost } from "../app/api/mcp/route" ;
import { POST as internalMcpPost } from "../app/api/internal/mcp/route" ;
import { POST as teamPost } from "../app/api/team/route" ;
import {
createAdminSessionToken ,
getAdminSessionSecret ,
} from "../core/auth/adminSession" ;
import {
createInitialAdmin ,
resetAdminStateForTests ,
} from "../core/auth/adminUsers" ;
import { clearAuditLogsForTests } from "../core/auth/auditLog" ;
import { DataBufferEngine } from "../core/data/buffer" ;
import {
MCP_PERMISSION_DEFINITIONS ,
McpSettingsManager ,
} from "../core/mcp/mcpSettings" ;
import { SDKManager } from "../core/sdk/sdkManager" ;
import { getInternalIngestionHeaders } from "../core/Security/security" ;
import { CSVStorageManager } from "../core/Storage/csvStorage" ;
const require = createRequire ( import . meta . url );
const ingestionServer = require ( "../server/index.js" ) as {
app : import ( "express" ). Express ;
mcpEngine : {
syncState : ( payload : Record < string , unknown >) => void ;
hydrateFromDatabase : ( pool? : unknown ) => Promise < boolean >;
getStateSnapshot : () => Record < string , unknown >;
resetForTests : () => void ;
};
setDbPoolForTests : ( pool : unknown ) => void ;
stopTimers : () => void ;
};
const { createMcpEngine , hashMcpToken } = require ( "../server/mcp/mcpEngine.js" ) as {
createMcpEngine : ( deps : Record < string , unknown >) => {
syncState : ( payload : Record < string , unknown >) => void ;
hydrateFromDatabase : ( pool? : unknown ) => Promise < boolean >;
handleHttpRequest : ( req : unknown , res : unknown ) => Promise < void >;
getStateSnapshot : () => Record < string , unknown >;
resetForTests : () => void ;
resolveSafeStoragePath : (
rel : string ,
opts ?: { allowWriteRuntimeLogs? : boolean ; requireExists? : boolean },
) => Promise < {
sandboxRoot : string ;
sandboxReal : string ;
relativePath : string ;
fullPath : string ;
} > ;
};
hashMcpToken : ( token : string ) => string ;
};
after ( async () => {
await DataBufferEngine . shutdown ();
ingestionServer . stopTimers ();
resetAdminStateForTests ();
McpSettingsManager . resetForTests ();
clearAuditLogsForTests ();
});
async function setupRbacCookies() {
resetAdminStateForTests ();
await createInitialAdmin ( "owner@datastack.dev" , "OwnerPass123!" );
const secret = getAdminSessionSecret ();
assert . ok ( secret , "Expected admin session secret in test runtime" );
const ownerToken = await createAdminSessionToken (
"owner@datastack.dev" ,
secret ,
Date . now () + 3600 _000 ,
1 ,
"owner" ,
"owner-1" ,
);
const ownerCookie = `datastack_admin_session= ${ ownerToken } ` ;
const createMember = async (
email : string ,
password : string ,
role : "operator" | "viewer" ,
) => {
const res = await teamPost (
new NextRequest ( "http://localhost:3000/api/team" , {
method : "POST" ,
headers : {
"content-type" : "application/json" ,
cookie : ownerCookie ,
},
body : JSON.stringify ({ email , password , role }),
}),
);
assert . equal ( res . status , 201 );
const json = ( await res . json ()) as { member : { id : string } };
const tok = await createAdminSessionToken (
email ,
secret ,
Date . now () + 3600 _000 ,
1 ,
role ,
json . member . id ,
);
return `datastack_admin_session= ${ tok } ` ;
};
const operatorCookie = await createMember (
"operator@datastack.dev" ,
"OperatorPass123!" ,
"operator" ,
);
const viewerCookie = await createMember (
"viewer@datastack.dev" ,
"ViewerPass123!" ,
"viewer" ,
);
return { ownerCookie , operatorCookie , viewerCookie };
}
test ( "R5-Phase-02 [MCP-AUDIT-05 / /api/mcp RBAC]: /api/mcp enforces Owner-only RBAC, auto-mints/rotates/revokes tokens, validates permissions/SSRF, and writes audit logs" , async () => {
McpSettingsManager . resetForTests ();
clearAuditLogsForTests ();
const prevDbUrl = process . env . DATABASE_URL ;
const prevDemoAdmin = process . env . DATASTACK_ALLOW_DEMO_ADMIN ;
const prevIngestionUrl = process . env . INGESTION_INTERNAL_URL ;
delete process . env . DATABASE_URL ;
process . env . DATASTACK_ALLOW_DEMO_ADMIN = "false" ;
const syncPayloads : Array < Record < string , unknown >> = [];
const mockPort4000Sync = http . createServer (( req , res ) => {
const chunks : Buffer [] = [];
req . on ( "data" , ( c ) => chunks . push ( Buffer . from ( c )));
req . on ( "end" , () => {
if ( req . url === "/internal/mcp-sync" && req . method === "POST" ) {
syncPayloads . push (
JSON . parse ( Buffer . concat ( chunks ). toString ( "utf8" )) as Record < string , unknown >,
);
res . statusCode = 200 ;
res . setHeader ( "Content-Type" , "application/json" );
res . end ( JSON . stringify ({ success : true }));
return ;
}
res . statusCode = 404 ;
res . end ();
});
});
await new Promise < void >(( resolve ) =>
mockPort4000Sync . listen ( 0 , "127.0.0.1" , () => resolve ()),
);
const syncPort = ( mockPort4000Sync . address () as AddressInfo ). port ;
process . env . INGESTION_INTERNAL_URL = `http://127.0.0.1: ${ syncPort } ` ;
try {
const { ownerCookie , operatorCookie , viewerCookie } = await setupRbacCookies ();
// 1. Unauthenticated /api/mcp GET & POST -> 401
const unauthGet = await mcpSettingsGet (
new NextRequest ( "http://localhost:3000/api/mcp" , { method : "GET" }),
);
assert . equal ( unauthGet . status , 401 );
// 2. Non-owner roles (viewer & operator) -> 403 INSUFFICIENT_ROLE_PERMISSION
for ( const cookie of [ viewerCookie , operatorCookie ]) {
const roleGet = await mcpSettingsGet (
new NextRequest ( "http://localhost:3000/api/mcp" , {
method : "GET" ,
headers : { cookie },
}),
);
assert . equal ( roleGet . status , 403 );
const rolePost = await mcpSettingsPost (
new NextRequest ( "http://localhost:3000/api/mcp" , {
method : "POST" ,
headers : { cookie , "Content-Type" : "application/json" },
body : JSON.stringify ({ enabled : true }),
}),
);
assert . equal ( rolePost . status , 403 );
}
// 3. Owner GET returns masked public state + 17 permission definitions
const getRes = await mcpSettingsGet (
new NextRequest ( "http://localhost:3000/api/mcp" , {
method : "GET" ,
headers : { cookie : ownerCookie },
}),
);
assert . equal ( getRes . status , 200 );
const getJson = ( await getRes . json ()) as {
settings : { enabled : boolean ; hasToken : boolean ; endpointPath : string };
permissionDefinitions : Array < { key : string } > ;
runtime : { permissionCount : number };
};
assert . equal ( getJson . settings . enabled , false );
assert . equal ( getJson . settings . hasToken , false );
assert . equal ( getJson . settings . endpointPath , "/mcp" );
assert . equal ( getJson . permissionDefinitions . length , 17 );
assert . equal ( getJson . runtime . permissionCount , 17 );
// 4. Reject unknown fields, unknown permission keys, rotate+revoke conflict, and SSRF coolifyUrl
const badFieldRes = await mcpSettingsPost (
new NextRequest ( "http://localhost:3000/api/mcp" , {
method : "POST" ,
headers : { cookie : ownerCookie , "Content-Type" : "application/json" },
body : JSON.stringify ({ rogueField : true }),
}),
);
assert . equal ( badFieldRes . status , 400 );
const badPermRes = await mcpSettingsPost (
new NextRequest ( "http://localhost:3000/api/mcp" , {
method : "POST" ,
headers : { cookie : ownerCookie , "Content-Type" : "application/json" },
body : JSON.stringify ({ permissions : { hack_everything : true } }),
}),
);
assert . equal ( badPermRes . status , 400 );
const ssrfRes = await mcpSettingsPost (
new NextRequest ( "http://localhost:3000/api/mcp" , {
method : "POST" ,
headers : { cookie : ownerCookie , "Content-Type" : "application/json" },
body : JSON.stringify ({ coolifyUrl : "http://169.254.169.254/latest" }),
}),
);
assert . equal ( ssrfRes . status , 400 );
assert . equal ((( await ssrfRes . json ()) as { code : string }). code , "SSRF_BLOCKED_HOST" );
// 5. Enable MCP -> mints Bearer token + toggles permissions + syncs Port 4000
const enableRes = await mcpSettingsPost (
new NextRequest ( "http://localhost:3000/api/mcp" , {
method : "POST" ,
headers : { cookie : ownerCookie , "Content-Type" : "application/json" },
body : JSON.stringify ({
enabled : true ,
allowedIps : "127.0.0.1" ,
permissions : { clients_create : true , files_upload_create : true },
}),
}),
);
assert . equal ( enableRes . status , 200 );
const enableJson = ( await enableRes . json ()) as {
success : boolean ;
issuedToken? : string ;
tokenRotated : boolean ;
settings : { enabled : boolean ; hasToken : boolean ; tokenPreview : string };
bridgeSync : { ok : boolean ; synced : boolean };
};
assert . equal ( enableJson . success , true );
assert . ok ( enableJson . issuedToken ? . startsWith ( "dsmcp_" ));
assert . equal ( enableJson . tokenRotated , true );
assert . equal ( enableJson . settings . enabled , true );
assert . equal ( enableJson . settings . hasToken , true );
assert . equal ( enableJson . bridgeSync . ok , true );
assert . equal ( syncPayloads . length , 1 );
// 6. Rotate token issues new distinct token; revoke disables MCP
const rotateRes = await mcpSettingsPost (
new NextRequest ( "http://localhost:3000/api/mcp" , {
method : "POST" ,
headers : { cookie : ownerCookie , "Content-Type" : "application/json" },
body : JSON.stringify ({ rotateToken : true }),
}),
);
assert . equal ( rotateRes . status , 200 );
const rotateJson = ( await rotateRes . json ()) as { issuedToken? : string };
assert . ok ( rotateJson . issuedToken );
assert . notEqual ( rotateJson . issuedToken , enableJson . issuedToken );
const revokeRes = await mcpSettingsPost (
new NextRequest ( "http://localhost:3000/api/mcp" , {
method : "POST" ,
headers : { cookie : ownerCookie , "Content-Type" : "application/json" },
body : JSON.stringify ({ revokeToken : true }),
}),
);
assert . equal ( revokeRes . status , 200 );
const revokeJson = ( await revokeRes . json ()) as {
settings : { enabled : boolean ; hasToken : boolean };
};
assert . equal ( revokeJson . settings . enabled , false );
assert . equal ( revokeJson . settings . hasToken , false );
} finally {
resetAdminStateForTests ();
McpSettingsManager . resetForTests ();
clearAuditLogsForTests ();
if ( prevDbUrl === undefined ) delete process . env . DATABASE_URL ;
else process . env . DATABASE_URL = prevDbUrl ;
if ( prevDemoAdmin === undefined ) delete process . env . DATASTACK_ALLOW_DEMO_ADMIN ;
else process . env . DATASTACK_ALLOW_DEMO_ADMIN = prevDemoAdmin ;
if ( prevIngestionUrl === undefined ) delete process . env . INGESTION_INTERNAL_URL ;
else process . env . INGESTION_INTERNAL_URL = prevIngestionUrl ;
mockPort4000Sync . closeAllConnections ? .();
await new Promise < void >(( resolve ) => mockPort4000Sync . close (() => resolve ()));
}
});
test ( "R5-Phase-02 [MCP-AUDIT-01/06/07 & ERR-R5-03/04/05/06]: Port 4000 MCP server enforces disabled/auth/IP gates, registers all 17 SDK tools, enforces permissions & path sandbox, and bridges live tools" , async () => {
const tmpRoot = await fs . mkdtemp ( path . join ( os . tmpdir (), "datastack-r5p2-" ));
const tmpDataDir = path . join ( tmpRoot , "data" );
const prevStorageDir = process . env . DATASTACK_STORAGE_DIR ;
const originalBaseDir = CSVStorageManager . baseStorageDir ;
const prevWebInternalUrl = process . env . WEB_INTERNAL_URL ;
const prevIngestionUrl = process . env . INGESTION_INTERNAL_URL ;
process . env . INGESTION_INTERNAL_URL = "http://127.0.0.1:1" ;
await fs . mkdir ( tmpDataDir , { recursive : true });
await fs . mkdir ( path . join ( tmpRoot , ".runtime-logs" ), { recursive : true });
await fs . writeFile (
path . join ( tmpRoot , ".runtime-logs" , "web.log" ),
"[web] started on 3000\n" ,
"utf8" ,
);
await fs . writeFile (
path . join ( tmpDataDir , "active.csv" ),
"clientId,eventId\nc1,e1\n" ,
"utf8" ,
);
await fs . writeFile ( path . join ( tmpDataDir , "active.csv.lock" ), "pid:123" , "utf8" );
const outsideSecret = path . join ( tmpRoot , ".." , `outside- ${ Date . now () } .txt` );
await fs . writeFile ( outsideSecret , "TOP_SECRET" , "utf8" );
const symlinkPath = path . join ( tmpRoot , "escape-link" );
await fs . symlink ( outsideSecret , symlinkPath ). catch (() => undefined );
// Spin up an embedded HTTP wrapper around App Router POST /api/internal/mcp
const bridgeServer = http . createServer ( async ( req , res ) => {
const chunks : Buffer [] = [];
req . on ( "data" , ( c ) => chunks . push ( Buffer . from ( c )));
req . on ( "end" , async () => {
const bodyStr = Buffer . concat ( chunks ). toString ( "utf8" );
const nextReq = new NextRequest ( "http://127.0.0.1:3000/api/internal/mcp" , {
method : req.method || "POST" ,
headers : {
"Content-Type" : req . headers [ "content-type" ] || "application/json" ,
"x-datastack-internal-secret" : String (
req . headers [ "x-datastack-internal-secret" ] || "" ,
),
},
body : req.method === "POST" ? bodyStr : undefined ,
});
const nextRes = await internalMcpPost ( nextReq );
res . statusCode = nextRes . status ;
res . setHeader ( "Content-Type" , "application/json" );
res . end ( await nextRes . text ());
});
});
let mcpHttpServer : http.Server | null = null ;
try {
CSVStorageManager . baseStorageDir = tmpDataDir ;
process . env . DATASTACK_STORAGE_DIR = tmpDataDir ;
clearAuditLogsForTests ();
await new Promise < void >(( resolve ) =>
bridgeServer . listen ( 0 , "127.0.0.1" , () => resolve ()),
);
const bridgePort = ( bridgeServer . address () as AddressInfo ). port ;
process . env . WEB_INTERNAL_URL = `http://127.0.0.1: ${ bridgePort } ` ;
const express = require ( "express" );
const { isClientIpAllowed } = ingestionServer as unknown as {
isClientIpAllowed ?: ( ip : string , allow : string ) => boolean ;
};
const internalHeaders = getInternalIngestionHeaders ();
const engine = createMcpEngine ({
getStorageDataDir : () => tmpDataDir ,
getDbPool : () => null ,
isClientIpAllowed :
typeof isClientIpAllowed === "function"
? isClientIpAllowed
: ( ip : string , list : string ) => list . includes ( ip ),
resolveInternalSecret : () => internalHeaders [ "x-datastack-internal-secret" ],
decryptVaultSecret : ( v : string ) => v ,
validateOutboundUrlAsync : async ( urlStr : string ) => {
const u = new URL ( urlStr );
if ( u . hostname === "169.254.169.254" || u . hostname === "127.0.0.1" ) {
return {
allowed : false ,
code : "SSRF_BLOCKED_HOST" ,
error : `Blocked host ${ u . hostname } ` ,
};
}
return { allowed : true , url : urlStr };
},
flushBuffer : async () => ({ written : 2 , files : [ "active.csv" ] }),
});
const testApp = express ();
testApp . use ( express . json ({ limit : "5mb" }));
testApp . all ( "/mcp" , ( req : unknown , res : unknown ) => {
void engine . handleHttpRequest ( req , res );
});
mcpHttpServer = http . createServer ( testApp );
await new Promise < void >(( resolve ) =>
mcpHttpServer ! . listen ( 0 , "127.0.0.1" , () => resolve ()),
);
const mcpPort = ( mcpHttpServer . address () as AddressInfo ). port ;
const mcpUrl = new URL ( `http://127.0.0.1: ${ mcpPort } /mcp` );
// 1. Disabled by default -> 503 MCP_DISABLED
const disabledRes = await fetch ( mcpUrl , {
method : "POST" ,
headers : { "Content-Type" : "application/json" },
body : JSON.stringify ({ jsonrpc : "2.0" , method : "tools/list" , id : 1 }),
});
assert . equal ( disabledRes . status , 503 );
const disabledJson = ( await disabledRes . json ()) as {
error ?: { data ?: { code? : string } };
};
assert . equal ( disabledJson . error ? . data ? . code , "MCP_DISABLED" );
// 2. Enable with token + IP allowlist
const rawToken = `dsmcp_ ${ "a" . repeat ( 64 ) } ` ;
engine . syncState ({
enabled : true ,
tokenHash : hashMcpToken ( rawToken ),
allowedIps : "203.0.113.0/24" ,
permissions : {
metrics_health_read : true ,
clients_read : true ,
clients_create : false ,
files_list_read : true ,
files_download : true ,
files_upload_create : true ,
files_edit : true ,
files_delete : true ,
storage_maintenance : true ,
build_logs_read : true ,
},
coolifyUrl : "http://127.0.0.1:9999" ,
coolifyToken : "secret_pat" ,
coolifyAppUuid : "app-1" ,
});
// 3. IP blocked -> 403 MCP_IP_FORBIDDEN
const ipBlockedRes = await fetch ( mcpUrl , {
method : "POST" ,
headers : {
"Content-Type" : "application/json" ,
Authorization : `Bearer ${ rawToken } ` ,
},
body : JSON.stringify ({ jsonrpc : "2.0" , method : "tools/list" , id : 2 }),
});
assert . equal ( ipBlockedRes . status , 403 );
assert . equal (
(( await ipBlockedRes . json ()) as { error ?: { data ?: { code? : string } } }). error ? . data
? . code ,
"MCP_IP_FORBIDDEN" ,
);
// 4. Open allowlist to loopback & test invalid Bearer token -> 401 MCP_UNAUTHORIZED
engine . syncState ({ allowedIps : "127.0.0.1" });
const badTokenRes = await fetch ( mcpUrl , {
method : "POST" ,
headers : {
"Content-Type" : "application/json" ,
Authorization : "Bearer dsmcp_wrong_token" ,
},
body : JSON.stringify ({ jsonrpc : "2.0" , method : "tools/list" , id : 3 }),
});
assert . equal ( badTokenRes . status , 401 );
assert . equal (
(( await badTokenRes . json ()) as { error ?: { data ?: { code? : string } } }). error ? . data
? . code ,
"MCP_UNAUTHORIZED" ,
);
// 5. Real @modelcontextprotocol/sdk Client + StreamableHTTPClientTransport session
const mcpClient = new Client ({
name : "r5-phase02-test-client" ,
version : "1.0.0" ,
});
const transport = new StreamableHTTPClientTransport ( mcpUrl , {
requestInit : {
headers : {
Authorization : `Bearer ${ rawToken } ` ,
},
},
});
await mcpClient . connect ( transport );
const listedTools = await mcpClient . listTools ();
assert . equal ( listedTools . tools . length , 17 );
assert . ok ( listedTools . tools . some (( t ) => t . name === "datastack_metrics_health" ));
assert . ok ( listedTools . tools . some (( t ) => t . name === "datastack_files_edit" ));
assert . ok ( listedTools . tools . some (( t ) => t . name === "datastack_storage_maintenance" ));
// 6. Disabled permission blocks tool call (ERR-R5-04 -> MCP_PERMISSION_DENIED)
const deniedClientCreate = await mcpClient . callTool ({
name : "datastack_clients_create" ,
arguments : { clientId : "denied-client" , name : "Denied" },
});
assert . equal ( deniedClientCreate . isError , true );
const deniedPayload = JSON . parse (
2026-11-22 07:39:24 +06:00
(( deniedClientCreate . content as Array < { text : string } > )[ 0 ]). text ,
2026-11-21 11:26:01 -08:00
) as { code : string ; permission : string };
assert . equal ( deniedPayload . code , "MCP_PERMISSION_DENIED" );
assert . equal ( deniedPayload . permission , "clients_create" );
// 7. Enable clients_create live & invoke -> creates client via /api/internal/mcp bridge
engine . syncState ({ permissions : { clients_create : true } });
const testClientId = `mcp-live- ${ Date . now () } ` ;
const createdToolRes = await mcpClient . callTool ({
name : "datastack_clients_create" ,
arguments : { clientId : testClientId , name : "Live MCP Client" , rateLimit : 320 },
});
assert . notEqual ( createdToolRes . isError , true );
const createdPayload = JSON . parse (
2026-11-22 07:39:24 +06:00
(( createdToolRes . content as Array < { text : string } > )[ 0 ]). text ,
2026-11-21 11:26:01 -08:00
) as { success : boolean ; client : { clientId : string ; rateLimit : number ; token? : string } };
assert . equal ( createdPayload . success , true );
assert . equal ( createdPayload . client . clientId , testClientId );
assert . equal ( createdPayload . client . rateLimit , 320 );
assert . ok ( createdPayload . client . token );
// 8. Sandbox path confinement: traversal, symlink, *.lock, and .runtime-logs write protection
const traversalRes = await mcpClient . callTool ({
name : "datastack_files_download" ,
arguments : { path : "../../etc/passwd" },
});
assert . equal ( traversalRes . isError , true );
assert . equal (
2026-11-22 07:39:24 +06:00
( JSON . parse ((( traversalRes . content as Array < { text : string } > )[ 0 ]). text ) as { code : string }). code ,
2026-11-21 11:26:01 -08:00
"PATH_OUTSIDE_ROOT" ,
);
if ( existsSync ( symlinkPath )) {
const symlinkRes = await mcpClient . callTool ({
name : "datastack_files_download" ,
arguments : { path : "escape-link" },
});
assert . equal ( symlinkRes . isError , true );
assert . equal (
2026-11-22 07:39:24 +06:00
( JSON . parse ((( symlinkRes . content as Array < { text : string } > )[ 0 ]). text ) as { code : string }). code ,
2026-11-21 11:26:01 -08:00
"SYMLINK_FORBIDDEN" ,
);
}
const lockReadRes = await mcpClient . callTool ({
name : "datastack_files_download" ,
arguments : { path : "data/active.csv.lock" },
});
assert . equal ( lockReadRes . isError , true );
assert . equal (
2026-11-22 07:39:24 +06:00
( JSON . parse ((( lockReadRes . content as Array < { text : string } > )[ 0 ]). text ) as { code : string }). code ,
2026-11-21 11:26:01 -08:00
"LOCKFILE_PROTECTED" ,
);
const lockedFileUploadRes = await mcpClient . callTool ({
name : "datastack_files_upload" ,
arguments : { path : "data/active.csv" , content : "overwrite" , overwrite : true },
});
assert . equal ( lockedFileUploadRes . isError , true );
assert . equal (
2026-11-22 07:39:24 +06:00
( JSON . parse ((( lockedFileUploadRes . content as Array < { text : string } > )[ 0 ]). text ) as { code : string })
2026-11-21 11:26:01 -08:00
. code ,
"LOCKFILE_PROTECTED" ,
);
const logWriteRes = await mcpClient . callTool ({
name : "datastack_files_upload" ,
arguments : { path : ".runtime-logs/web.log" , content : "tamper" , overwrite : true },
});
assert . equal ( logWriteRes . isError , true );
assert . equal (
2026-11-22 07:39:24 +06:00
( JSON . parse ((( logWriteRes . content as Array < { text : string } > )[ 0 ]). text ) as { code : string }). code ,
2026-11-21 11:26:01 -08:00
"PROTECTED_LOG_DIR" ,
);
// 9. Legitimate files upload -> edit -> download -> list -> delete inside sandbox
const uploadRes = await mcpClient . callTool ({
name : "datastack_files_upload" ,
arguments : { path : "notes/hello.txt" , content : "alpha beta" },
});
assert . notEqual ( uploadRes . isError , true );
const editRes = await mcpClient . callTool ({
name : "datastack_files_edit" ,
arguments : { path : "notes/hello.txt" , search : "beta" , replace : "gamma" },
});
assert . notEqual ( editRes . isError , true );
const dlRes = await mcpClient . callTool ({
name : "datastack_files_download" ,
arguments : { path : "notes/hello.txt" },
});
assert . notEqual ( dlRes . isError , true );
assert . equal (
2026-11-22 07:39:24 +06:00
( JSON . parse ((( dlRes . content as Array < { text : string } > )[ 0 ]). text ) as { content : string }). content ,
2026-11-21 11:26:01 -08:00
"alpha gamma" ,
);
const listRes = await mcpClient . callTool ({
name : "datastack_files_list" ,
arguments : { path : "data" },
});
assert . notEqual ( listRes . isError , true );
2026-11-22 07:39:24 +06:00
const listParsed = JSON . parse ((( listRes . content as Array < { text : string } > )[ 0 ]). text ) as {
2026-11-21 11:26:01 -08:00
entries : Array < { name : string } > ;
};
assert . ok ( listParsed . entries . some (( e ) => e . name === "active.csv" ));
assert . equal (
listParsed . entries . some (( e ) => e . name . endsWith ( ".lock" )),
false ,
);
const delFileRes = await mcpClient . callTool ({
name : "datastack_files_delete" ,
arguments : { path : "notes/hello.txt" },
});
assert . notEqual ( delFileRes . isError , true );
// 10. Metrics, Storage flush (calls local flush + web bridge flush), and SSRF check on Coolify logs
const metricsRes = await mcpClient . callTool ({
name : "datastack_metrics_health" ,
arguments : {},
});
assert . notEqual ( metricsRes . isError , true );
assert . equal (
2026-11-22 07:39:24 +06:00
( JSON . parse ((( metricsRes . content as Array < { text : string } > )[ 0 ]). text ) as { success : boolean }). success ,
2026-11-21 11:26:01 -08:00
true ,
);
const flushRes = await mcpClient . callTool ({
name : "datastack_storage_maintenance" ,
arguments : { action : "flush" },
});
assert . notEqual ( flushRes . isError , true );
2026-11-22 07:39:24 +06:00
const flushPayload = JSON . parse ((( flushRes . content as Array < { text : string } > )[ 0 ]). text ) as {
2026-11-21 11:26:01 -08:00
success : boolean ;
ingestionFlushed : number ;
};
assert . equal ( flushPayload . success , true );
assert . equal ( flushPayload . ingestionFlushed , 2 );
const coolifySsrfRes = await mcpClient . callTool ({
name : "datastack_build_logs" ,
arguments : { includeCoolify : true },
});
assert . equal ( coolifySsrfRes . isError , true );
assert . equal (
2026-11-22 07:39:24 +06:00
( JSON . parse ((( coolifySsrfRes . content as Array < { text : string } > )[ 0 ]). text ) as { code : string }). code ,
2026-11-21 11:26:01 -08:00
"SSRF_BLOCKED_HOST" ,
);
await transport . close (). catch (() => undefined );
await mcpClient . close (). catch (() => undefined );
await SDKManager . deleteClientWithStatsAsync ( testClientId , { purgeFiles : true });
} finally {
CSVStorageManager . baseStorageDir = originalBaseDir ;
if ( prevStorageDir === undefined ) delete process . env . DATASTACK_STORAGE_DIR ;
else process . env . DATASTACK_STORAGE_DIR = prevStorageDir ;
if ( prevWebInternalUrl === undefined ) delete process . env . WEB_INTERNAL_URL ;
else process . env . WEB_INTERNAL_URL = prevWebInternalUrl ;
if ( prevIngestionUrl === undefined ) delete process . env . INGESTION_INTERNAL_URL ;
else process . env . INGESTION_INTERNAL_URL = prevIngestionUrl ;
clearAuditLogsForTests ();
if ( mcpHttpServer ) {
mcpHttpServer . closeAllConnections ? .();
await new Promise < void >(( resolve ) => mcpHttpServer ! . close (() => resolve ()));
}
bridgeServer . closeAllConnections ? .();
await new Promise < void >(( resolve ) => bridgeServer . close (() => resolve ()));
await fs . rm ( outsideSecret , { force : true }). catch (() => undefined );
await fs . rm ( tmpRoot , { recursive : true , force : true });
}
});
test ( "R5-Phase-02 [Port 4000 Routes & Proxy Configs]: server/index.js exposes /internal/mcp-sync & /mcp and Nginx/Next/Compose/Env route /mcp cleanly" , async () => {
try {
const internalHeaders = getInternalIngestionHeaders ();
const expressAppServer = http . createServer ( ingestionServer . app );
await new Promise < void >(( resolve ) =>
expressAppServer . listen ( 0 , "127.0.0.1" , () => resolve ()),
);
const port = ( expressAppServer . address () as AddressInfo ). port ;
try {
// 1. /internal/mcp-sync rejects missing internal secret -> 401
const unauthSync = await fetch ( `http://127.0.0.1: ${ port } /internal/mcp-sync` , {
method : "POST" ,
headers : { "Content-Type" : "application/json" },
body : JSON.stringify ({ enabled : true }),
});
assert . equal ( unauthSync . status , 401 );
// 2. /internal/mcp-sync with valid internal secret updates live mcpEngine state
const tok = `dsmcp_ ${ "b" . repeat ( 64 ) } ` ;
const authSync = await fetch ( `http://127.0.0.1: ${ port } /internal/mcp-sync` , {
method : "POST" ,
headers : {
"Content-Type" : "application/json" ,
"x-datastack-internal-secret" : internalHeaders [ "x-datastack-internal-secret" ],
},
body : JSON.stringify ({
enabled : true ,
tokenHash : hashMcpToken ( tok ),
tokenPreview : "dsmcp_bbbb...bbbb" ,
allowedIps : "127.0.0.1" ,
}),
});
assert . equal ( authSync . status , 200 );
assert . equal ( ingestionServer . mcpEngine . getStateSnapshot (). enabled , true );
// 3. /mcp endpoint responds to MCP initialize JSON-RPC call cleanly
const mcpInit = await fetch ( `http://127.0.0.1: ${ port } /mcp` , {
method : "POST" ,
headers : {
"Content-Type" : "application/json" ,
Authorization : `Bearer ${ tok } ` ,
},
body : JSON.stringify ({
jsonrpc : "2.0" ,
id : 1 ,
method : "initialize" ,
params : {
protocolVersion : "2024-11-05" ,
capabilities : {},
clientInfo : { name : "curl-smoke" , version : "1.0.0" },
},
}),
});
assert . equal ( mcpInit . status , 200 );
const initJson = ( await mcpInit . json ()) as {
result ?: { serverInfo ?: { name? : string } };
};
assert . equal ( initJson . result ? . serverInfo ? . name , "datastack-mcp" );
// 4. hydrateFromDatabase syncs DB mcp_settings row cleanly
ingestionServer . setDbPoolForTests ({
async query ( sql : string ) {
if ( /FROM\s+mcp_settings/i . test ( sql )) {
return {
rowCount : 1 ,
rows : [
{
enabled : false ,
token_hash : "" ,
token_preview : "" ,
allowed_ips : "10.0.0.0/8" ,
permissions_json : JSON.stringify ({ clients_create : true }),
coolify_url : "https://coolify.example.com" ,
coolify_token_enc : "" ,
coolify_app_uuid : "uuid-99" ,
updated_at : new Date (). toISOString (),
},
],
};
}
return { rowCount : 0 , rows : [] };
},
});
assert . equal ( await ingestionServer . mcpEngine . hydrateFromDatabase (), true );
const snap = ingestionServer . mcpEngine . getStateSnapshot () as {
enabled : boolean ;
allowedIps : string ;
permissions : Record < string , boolean >;
};
assert . equal ( snap . enabled , false );
assert . equal ( snap . allowedIps , "10.0.0.0/8" );
assert . equal ( snap . permissions . clients_create , true );
} finally {
ingestionServer . mcpEngine . resetForTests ();
ingestionServer . setDbPoolForTests ( null );
expressAppServer . closeAllConnections ? .();
await new Promise < void >(( resolve ) => expressAppServer . close (() => resolve ()));
}
// 5. Verify Nginx, NextConfig, Compose, Env, and MCP_PERMISSION_DEFINITIONS 1:1 count
assert . equal ( MCP_PERMISSION_DEFINITIONS . length , 17 );
const coolifyNginx = readFileSync (
path . resolve ( process . cwd (), "docker/coolify-nginx.conf" ),
"utf8" ,
);
assert . match (
coolifyNginx ,
/location\s+\/mcp\s*\{[\s\S]*?proxy_pass\s+\$socketio_upstream;[\s\S]*?proxy_buffering\s+off;/ ,
);
const localNginx = readFileSync (
path . resolve ( process . cwd (), "nginx/default.conf" ),
"utf8" ,
);
assert . match (
localNginx ,
/location\s+\/mcp\s*\{[\s\S]*?proxy_pass\s+http:\/\/socketio_upstream;[\s\S]*?proxy_buffering\s+off;/ ,
);
const nextConfig = readFileSync ( path . resolve ( process . cwd (), "next.config.ts" ), "utf8" );
assert . match ( nextConfig , /source:\s*['"]\/mcp['"]/ );
assert . match ( nextConfig , /destination:\s*`\$\{ingestionBase\}\/mcp`/ );
const compose = readFileSync (
path . resolve ( process . cwd (), "docker/docker-compose.yml" ),
"utf8" ,
);
assert . match ( compose , /WEB_INTERNAL_URL:\s*"http:\/\/web:3000"/ );
const envEx = readFileSync ( path . resolve ( process . cwd (), ".env.example" ), "utf8" );
assert . match ( envEx , /WEB_INTERNAL_URL=/ );
} finally {
ingestionServer . stopTimers ();
}
});