@creeperhost/modlens-mcp 1.6.17 → 1.6.19

package/scripts/test-project-gradle.mjs

@@ -0,0 +1,76 @@
+// Real Gradle -> export -> ModLens source/member/search assertions. No game launch.
+// Set MODLENS_TEST_GRADLE_HOME and JAVA_HOME. Optional argument: moddev (NeoForge 1.21.1).
+// Uses a disposable fixture; retained on failure for diagnosis.
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { mkdtemp, mkdir, writeFile, readFile, readdir, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ProjectStore } from '../dist/tools/project.js';
+
+const moddev = process.argv[2] === 'moddev';
+const root = await mkdtemp(join(tmpdir(), 'modlens-gradle-smoke-'));
+const repo = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const gradleHome = process.env.MODLENS_TEST_GRADLE_HOME;
+if (!gradleHome || !process.env.JAVA_HOME) throw new Error('Set MODLENS_TEST_GRADLE_HOME and JAVA_HOME');
+const launcher = (await readdir(join(gradleHome, 'lib'))).find(n => /^gradle-launcher-.*\.jar$/.test(n));
+if (!launcher) throw new Error('Gradle launcher JAR missing');
+const java = join(process.env.JAVA_HOME, 'bin', process.platform === 'win32' ? 'java.exe' : 'java');
+const write = async (path, text) => { await mkdir(dirname(join(root, path)), { recursive: true }); await writeFile(join(root, path), text); };
+const run = (sourceSet = 'main') => execFileSync(java, ['-classpath', join(gradleHome, 'lib', launcher), 'org.gradle.launcher.GradleMain',
+    '--no-daemon', '--console=plain', '--no-configuration-cache', '-I', join(repo, 'scripts/gradle/modlens.init.gradle'), `-PmodlensSourceSet=${sourceSet}`, ':modlensExport'],
+    { cwd: root, env: process.env, stdio: 'inherit', timeout: 1200_000 });
+let passed = false;
+try {
+    if (moddev) {
+        await write('settings.gradle', "pluginManagement { repositories { gradlePluginPortal(); maven { url = 'https://maven.neoforged.net/releases' } } }\nrootProject.name = 'modlens-at-smoke'\n");
+        await write('build.gradle', "plugins { id 'java'; id 'net.neoforged.moddev' version '2.0.141' }\njava { toolchain { languageVersion = JavaLanguageVersion.of(21) } }\nneoForge { version = '21.1.209' }\n");
+        await write('gradle.properties', 'minecraft_version=1.21.1\norg.gradle.jvmargs=-Xmx3G\n');
+        await write('src/main/resources/META-INF/accesstransformer.cfg', '# baseline\n');
+    } else {
+        await write('settings.gradle', "rootProject.name = 'modlens-classpath-smoke'\ninclude 'library'\n");
+        await write('build.gradle', "plugins { id 'java' }\ndependencies { implementation project(':library') }\nsourceSets { client { compileClasspath = sourceSets.main.compileClasspath } }\n");
+        await write('library/build.gradle', "plugins { id 'java' }\n");
+        await write('library/src/main/java/example/Target.java', 'package example; public class Target { private final int counter = 7; public int read() { return counter; } }\n');
+    }
+    run();
+    const key = (await readFile(join(root, '.gradle/modlens/project-key.txt'), 'utf8')).trim();
+    const store = new ProjectStore(join(root, 'server-projects'));
+    const first = await store.importBuffer(key, await readFile(join(root, 'build/modlens/main/environment.zip')));
+    const target = moddev ? 'net.minecraft.world.level.Level' : 'example.Target';
+    const fieldName = moddev ? 'isDebug' : 'counter';
+    const field = async id => (await store.members(key, id, target)).result.fields.find(f => f.name === fieldName);
+    const before = await field(first.environmentId);
+    assert.ok(before, `Missing ${fieldName}`);
+    assert.ok(before.access & 0x10, 'baseline field must be final');
+    if (moddev) await write('src/main/resources/META-INF/accesstransformer.cfg', 'public-f net.minecraft.world.level.Level isDebug\n');
+    else await write('library/src/main/java/example/Target.java', 'package example; public class Target { public int counter = 7; public int read() { return counter; } }\n');
+    run();
+    assert.equal((await readFile(join(root, '.gradle/modlens/project-key.txt'), 'utf8')).trim(), key, 'export must preserve private key');
+    const second = await store.importBuffer(key, await readFile(join(root, 'build/modlens/main/environment.zip')));
+    assert.notEqual(first.environmentId, second.environmentId);
+    const after = await field(second.environmentId);
+    assert.ok(after.access & 1, 'transformed field must be public');
+    assert.equal(after.access & 0x10, 0, 'transformed field must not be final');
+    assert.ok((await field(first.environmentId)).access & 0x10, 'baseline must stay final');
+    const source = await store.source(key, second.environmentId, target, 1, 1000);
+    assert.match(source.source, new RegExp(`public (?!final)\\w+ ${fieldName}`));
+    if (moddev) assert.equal(source.origin, 'gradle-sources', 'adapter must supply actual transformed sources');
+    const search = await store.search(key, second.environmentId, `public ${moddev ? 'boolean' : 'int'} ${fieldName}`, 200);
+    assert.ok(search.results.some(r => r.className === target.replaceAll('.', '/')));
+    assert.equal((await store.list('f'.repeat(64))).length, 0);
+    if (!moddev) {
+        run('client'); // sibling :library has no client source set and must not break this export
+        const client = await store.importBuffer(key, await readFile(join(root, 'build/modlens/client/environment.zip')));
+        assert.equal(client.sourceSet, 'client');
+        assert.equal((await field(client.environmentId)).access, 1);
+    }
+    console.log(JSON.stringify({ passed: true, toolchain: second.toolchain, beforeAccess: before.access, afterAccess: after.access,
+        classCount: second.classCount, sourceCount: second.sourceCount, first: first.environmentId, second: second.environmentId }, null, 2));
+    // Keep a bundle for the optional HTTP smoke, without copying any project key into the repository.
+    if (process.env.MODLENS_KEEP_FIXTURE !== '1') passed = true;
+} finally {
+    if (passed) await rm(root, { recursive: true, force: true });
+    else console.log(`Fixture retained: ${root}`);
+}

package/scripts/test-project-http.mjs

@@ -0,0 +1,98 @@
+// Real HTTP MCP transport and shipped uploader smoke. Uses a disposable server/cache on loopback.
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { createHash, randomBytes } from 'node:crypto';
+import { mkdtemp, writeFile, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createServer } from 'node:net';
+import { once } from 'node:events';
+import AdmZip from 'adm-zip';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+
+const repo = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const root = await mkdtemp(join(tmpdir(), 'modlens-http-smoke-'));
+const listener = createServer();
+listener.listen(0, '127.0.0.1'); await once(listener, 'listening');
+const port = listener.address().port;
+await new Promise(resolveClose => listener.close(resolveClose));
+const endpoint = `http://127.0.0.1:${port}/mcp`;
+const keyFile = process.argv[3] ?? join(root, 'key.txt');
+const bundlePath = process.argv[2] ?? join(root, 'environment.zip');
+const target = process.argv[4] ?? 'example.Target';
+const key = process.argv[3] ? (await readFile(keyFile, 'utf8')).trim() : randomBytes(32).toString('hex');
+if (!process.argv[2]) {
+    await writeFile(keyFile, `${key}\n`);
+    const jar = new AdmZip();
+    jar.addFile('example/Target.class', Buffer.from('test class entry'));
+    jar.addFile('example/Target.java', Buffer.from('package example; public class Target { public int counter; }'));
+    // An incompressible payload exercises multiple full upload chunks.
+    jar.addFile('payload.bin', randomBytes(2 * 1024 * 1024));
+    const bytes = jar.toBuffer();
+    const bundle = new AdmZip();
+    bundle.addFile('artifacts/0.jar', bytes);
+    bundle.addFile('manifest.json', Buffer.from(JSON.stringify({ format: 'modlens-project-v1', project: 'http-smoke:', sourceSet: 'main',
+        toolchain: 'gradle-compile-classpath', minecraftVersion: '', loaderVersion: '', mappings: 'compile-classpath', javaVersion: 21, transformations: [],
+        artifacts: [{ path: 'artifacts/0.jar', name: 'prepared.jar', size: bytes.length, sha256: createHash('sha256').update(bytes).digest('hex'), kind: 'classpath' }] })));
+    await writeFile(bundlePath, bundle.toBuffer());
+}
+const env = { ...process.env, MCP_PORT: String(port), MCP_HOST: '127.0.0.1', MODLENS_AUTO_EMBED: '0',
+    MODLENS_CACHE_ROOT: join(root, 'cache'), MODLENS_HOME: root, DATABASE_URL: `file:${join(root, 'unused.db')}`, MODLENS_VERBOSE: '1' };
+const server = spawn(process.execPath, [join(repo, 'dist/server.js')], { cwd: root, env, stdio: ['ignore', 'ignore', 'pipe'] });
+let logs = '';
+server.stderr.on('data', b => { logs += b; });
+const stopped = once(server, 'exit');
+const client = new Client({ name: 'project-http-test', version: '1.0.0' });
+let passed = false;
+try {
+    await new Promise((resolveReady, reject) => {
+        const timer = setTimeout(() => reject(new Error('HTTP server startup timed out')), 30_000);
+        const ready = () => { if (logs.includes('listening on')) { clearTimeout(timer); server.stderr.off('data', ready); resolveReady(); } };
+        server.stderr.on('data', ready);
+        server.once('error', reject);
+        server.once('exit', () => { clearTimeout(timer); reject(new Error(`Server exited before startup: ${logs}`)); });
+        ready();
+    });
+    const uploader = spawn(process.execPath, [join(repo, 'scripts/project-upload.mjs'), endpoint, bundlePath, keyFile], { cwd: root, env, stdio: ['ignore', 'pipe', 'pipe'] });
+    let output = ''; let error = '';
+    uploader.stdout.on('data', b => { output += b; }); uploader.stderr.on('data', b => { error += b; });
+    const [code] = await once(uploader, 'exit');
+    assert.equal(code, 0, error);
+    assert.ok(!output.includes(key), 'uploader must not print project key');
+    const imported = JSON.parse(output);
+    await client.connect(new StreamableHTTPClientTransport(new URL(endpoint)));
+    const call = (action, args = {}) => client.callTool({ name: 'project', arguments: { action, projectKey: key, environmentId: imported.environmentId, ...args } }, undefined, { timeout: 300_000 });
+    const tools = await client.listTools();
+    assert.ok(tools.tools.some(t => t.name === 'project'));
+    const source = await call('source', { className: target });
+    assert.ok(!source.isError, JSON.stringify(source));
+    assert.ok(JSON.parse(source.content[0].text).source.length > 0);
+    if (process.argv[5]) {
+        const members = await call('members', { className: target });
+        assert.ok(!members.isError, JSON.stringify(members));
+        const field = JSON.parse(members.content[0].text).result.fields.find(f => f.name === process.argv[5]);
+        assert.equal(field?.access, 1, 'remote member view must preserve the public, non-final AT result');
+        const searched = await call('search', { query: `public boolean ${process.argv[5]}`, limit: 200 });
+        assert.ok(!searched.isError, JSON.stringify(searched));
+        assert.ok(JSON.parse(searched.content[0].text).results.some(r => r.className === target.replaceAll('.', '/')));
+    }
+    const wrongKey = await call('info', { projectKey: randomBytes(32).toString('hex') });
+    assert.ok(wrongKey.isError);
+    const local = await call('import_local', { bundlePath });
+    assert.ok(local.isError, 'HTTP must reject host-local import');
+    const failedChunk = await call('upload_chunk', { uploadId: 'f'.repeat(64), offset: 0, data: 'SENSITIVE_PAYLOAD' });
+    assert.ok(failedChunk.isError);
+    const large = await fetch(endpoint, { method: 'POST', body: 'x'.repeat(9 * 1024 * 1024) });
+    assert.equal(large.status, 413);
+    assert.ok(!logs.includes(key), 'server logs must redact project key');
+    assert.ok(!logs.includes('SENSITIVE_PAYLOAD'), 'server logs must redact upload bytes');
+    console.log(`PASS: HTTP upload, ${imported.classCount} classes, source query, project isolation, host-path rejection, body limits and log redaction`);
+    passed = true;
+} finally {
+    await client.close();
+    server.kill(); await stopped;
+    if (passed) await rm(root, { recursive: true, force: true });
+    else console.log(`HTTP fixture retained: ${root}`);
+}

package/scripts/test-setup.mjs

@@ -0,0 +1,18 @@
+import { execFileSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+const require = createRequire(import.meta.url);
+
+// npm ci generates the default PostgreSQL client. Generate SQLite before Vitest
+// imports application modules, including when tests run before the build in CI.
+export default function setup() {
+    execFileSync(process.execPath, [
+        require.resolve("prisma/build/index.js"), "generate",
+        "--schema", fileURLToPath(new URL("../prisma/backends/schema.sqlite.prisma", import.meta.url)),
+    ], {
+        cwd: fileURLToPath(new URL("..", import.meta.url)),
+        env: { ...process.env, PRISMA_HIDE_UPDATE_MESSAGE: "1" },
+        stdio: "pipe",
+    });
+}