@jamestesting888/tum-mcp 0.0.0-stage → 0.4.1

package/npm/download.mjs

@@ -0,0 +1,38 @@
+import { createHash } from 'node:crypto';
+import { writeFile } from 'node:fs/promises';
+import https from 'node:https';
+
+const hosts = new Set(['github.com', 'objects.githubusercontent.com', 'release-assets.githubusercontent.com', 'releases.astral.sh']);
+
+export async function download(url, destination, expected, redirects = 0) {
+  const target = new URL(url);
+  if (target.protocol !== 'https:' || !hosts.has(target.hostname) || redirects > 5) throw new Error('Untrusted runtime download origin.');
+  await new Promise((resolve, reject) => {
+    const request = https.get(target, { timeout: 30000, headers: { 'User-Agent': 'tum-mcp-bootstrap' } }, response => {
+      if ([301, 302, 303, 307, 308].includes(response.statusCode)) {
+        response.resume();
+        if (!response.headers.location) return reject(new Error('Runtime redirect has no location.'));
+        download(new URL(response.headers.location, target).href, destination, expected, redirects + 1).then(resolve, reject);
+        return;
+      }
+      if (response.statusCode !== 200) { response.resume(); reject(new Error(`Runtime download returned HTTP ${response.statusCode}.`)); return; }
+      let size = 0;
+      const chunks = [];
+      response.on('data', chunk => {
+        size += chunk.length;
+        if (size > 64 * 1024 * 1024) response.destroy(new Error('Runtime download exceeds the size budget.'));
+        else chunks.push(chunk);
+      });
+      response.on('error', reject);
+      response.on('end', async () => {
+        try {
+          const bytes = Buffer.concat(chunks);
+          if (createHash('sha256').update(bytes).digest('hex') !== expected) throw new Error('Runtime checksum mismatch.');
+          await writeFile(destination, bytes, { mode: 0o600 }); resolve();
+        } catch (error) { reject(error); }
+      });
+    });
+    request.on('timeout', () => request.destroy(new Error('Runtime download timed out.')));
+    request.on('error', reject);
+  });
+}

package/npm/runtime.mjs

@@ -0,0 +1,96 @@
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { chmod, mkdir, mkdtemp, rename, rm, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { download } from './download.mjs';
+
+const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const pins = JSON.parse(readFileSync(join(packageRoot, 'npm/uv-artifacts.json'), 'utf8'));
+
+export function dataRoot() {
+  if (process.env.TUM_MCP_DATA_DIR) return process.env.TUM_MCP_DATA_DIR;
+  if (process.platform === 'darwin') return join(homedir(), 'Library/Application Support/TUMMCP');
+  if (process.platform === 'win32') return join(process.env.LOCALAPPDATA || join(homedir(), 'AppData/Local'), 'TUMMCP');
+  return join(process.env.XDG_DATA_HOME || join(homedir(), '.local/share'), 'TUMMCP');
+}
+
+function run(executable, args) {
+  const env = { ...process.env };
+  delete env.VIRTUAL_ENV; delete env.PYTHONPATH; delete env.PYTHONHOME;
+  const result = spawnSync(executable, args, { env, stdio: ['ignore', 'inherit', 'inherit'], shell: false, timeout: 600000 });
+  if (result.error) throw new Error(`Managed runtime subprocess could not start (${result.error.code || 'unknown'}); check executable permissions and mount options.`);
+  if (result.status !== 0) throw new Error('Managed runtime setup failed; inspect the diagnostics above.');
+}
+
+export function currentPython() {
+  try {
+    const current = JSON.parse(readFileSync(join(dataRoot(), 'runtime.json'), 'utf8'));
+    if (!/^[a-f0-9]{64}$/.test(current.identity)) return null;
+    const manifest = JSON.parse(readFileSync(join(packageRoot, 'npm/backend/manifest.json'), 'utf8'));
+    if (current.identity !== manifest.wheelSha256) return null;
+    const runtime = join(dataRoot(), 'runtimes', current.identity);
+    const expected = join(runtime, process.platform === 'win32' ? 'Scripts/python.exe' : 'bin/python');
+    if (current.python !== expected || !existsSync(expected)) return null;
+    if (readFileSync(join(runtime, '.tum-mcp-ready'), 'utf8') !== current.identity) return null;
+    return expected;
+  } catch { return null; }
+}
+
+function matchingUv(executable) {
+  const found = spawnSync(executable, ['--version'], { encoding: 'utf8', shell: false, timeout: 10000 });
+  return found.status === 0 && found.stdout.trim().split(' ')[1] === pins.version;
+}
+
+export async function ensureRuntime() {
+  const backend = join(packageRoot, 'npm/backend');
+  const manifest = JSON.parse(readFileSync(join(backend, 'manifest.json'), 'utf8'));
+  if (!/^[a-zA-Z0-9_.-]+\.whl$/.test(manifest.wheel)) throw new Error('Invalid backend manifest.');
+  for (const [name, expected] of [[manifest.wheel, manifest.wheelSha256], ['requirements.txt', manifest.requirementsSha256]]) {
+    if (createHash('sha256').update(readFileSync(join(backend, name))).digest('hex') !== expected) throw new Error('Backend integrity check failed.');
+  }
+  const identity = manifest.wheelSha256;
+  const runtime = join(dataRoot(), 'runtimes', identity);
+  const python = join(runtime, process.platform === 'win32' ? 'Scripts/python.exe' : 'bin/python');
+  await mkdir(dataRoot(), { recursive: true, mode: 0o700 });
+  // A per-runtime directory lock prevents concurrent setup from corrupting a venv.
+  const lock = join(dataRoot(), 'setup.lock');
+  try { await mkdir(lock, { mode: 0o700 }); }
+  catch (error) { if (error.code === 'EEXIST') throw new Error('Another setup is running; retry when it finishes.'); throw error; }
+  try {
+    const ready = join(runtime, '.tum-mcp-ready');
+    if (!existsSync(python) || !existsSync(ready) || readFileSync(ready, 'utf8') !== identity) {
+      const cachedUv = join(dataRoot(), process.platform === 'win32' ? 'uv.exe' : 'uv');
+      let uv = matchingUv('uv') ? 'uv' : matchingUv(cachedUv) ? cachedUv : null;
+      if (!uv) {
+        const systems = { darwin: 'apple-darwin', linux: 'unknown-linux-gnu', win32: 'pc-windows-msvc' };
+        const arches = { arm64: 'aarch64', x64: 'x86_64' };
+        const target = `${arches[process.arch]}-${systems[process.platform]}`;
+        const artifact = pins.artifacts[target];
+        if (!artifact) throw new Error('Unsupported platform/architecture; use a documented manual installation.');
+        const temporary = await mkdtemp(join(dataRoot(), 'bootstrap-'));
+        try {
+          const archive = join(temporary, process.platform === 'win32' ? 'uv.zip' : 'uv.tar.gz');
+          await download(artifact.url, archive, artifact.sha256);
+          run('tar', ['-xf', archive, '-C', temporary]);
+          const extracted = process.platform === 'win32' ? join(temporary, 'uv.exe') : join(temporary, `uv-${target}`, 'uv');
+          uv = join(dataRoot(), process.platform === 'win32' ? 'uv.exe' : 'uv');
+          await rename(extracted, uv); if (process.platform !== 'win32') await chmod(uv, 0o700);
+        } finally { await rm(temporary, { recursive: true, force: true }); }
+      }
+      await mkdir(dirname(runtime), { recursive: true, mode: 0o700 });
+      if (existsSync(runtime)) await rm(runtime, { recursive: true, force: true });
+      run(uv, ['venv', '--managed-python', '--python', pins.python, runtime]);
+      run(uv, ['pip', 'sync', '--python', python, '--require-hashes', '--only-binary', ':all:', join(backend, 'requirements.txt')]);
+      run(uv, ['pip', 'install', '--python', python, '--no-deps', '--no-index', join(backend, manifest.wheel)]);
+    }
+    try { run(python, ['-I', '-m', 'tum_mcp', 'version']); }
+    catch (error) { await rm(ready, { force: true }); throw error; }
+    await writeFile(ready, identity, { mode: 0o600 });
+    await writeFile(join(dataRoot(), 'runtime.pending.json'), JSON.stringify({ identity, python }), { mode: 0o600 });
+    await rename(join(dataRoot(), 'runtime.pending.json'), join(dataRoot(), 'runtime.json'));
+    return python;
+  } finally { await rm(lock, { recursive: true, force: true }); }
+}

package/npm/tum-mcp.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { currentPython, ensureRuntime } from './runtime.mjs';
+
+const args = process.argv.slice(2);
+try {
+  if (args.length === 0 || (args.length === 1 && ['--help', '-h'].includes(args[0]))) {
+    console.log('TUM MCP 0.4.1\nCommands: setup [--client codex|claude|generic], connect, scope, discover, status, doctor, serve, skills, workspace, actions, logout, uninstall, update\nRun setup explicitly to provision the managed Python backend.');
+  } else if (['--version', 'version'].includes(args[0])) {
+    console.log('0.4.1');
+  } else {
+    const setup = ['setup', 'update'].includes(args[0]);
+    const python = setup ? await ensureRuntime() : currentPython();
+    if (!python) throw new Error('SETUP_REQUIRED: Run tum-mcp setup first.');
+    const forwarded = args[0] === 'update' ? ['status'] : args;
+    const env = { ...process.env }; delete env.PYTHONPATH; delete env.PYTHONHOME;
+    const child = spawnSync(python, ['-I', '-m', 'tum_mcp', ...forwarded], { env, stdio: 'inherit', shell: false });
+    if (child.error) throw new Error('Managed backend could not start; run setup again.');
+    process.exitCode = child.status ?? 1;
+  }
+} catch (error) { console.error(error.message); process.exitCode = 2; }

package/npm/uv-artifacts.json

@@ -0,0 +1,30 @@
+{
+  "version": "0.12.5",
+  "python": "3.13.15",
+  "artifacts": {
+    "aarch64-apple-darwin": {
+      "url": "https://github.com/astral-sh/uv/releases/download/0.12.5/uv-aarch64-apple-darwin.tar.gz",
+      "sha256": "5bb0e5fe008a773c3dbcb97ff79cd89e1241464fe9d2f986d52ad8f1b037bd62"
+    },
+    "x86_64-apple-darwin": {
+      "url": "https://github.com/astral-sh/uv/releases/download/0.12.5/uv-x86_64-apple-darwin.tar.gz",
+      "sha256": "b3b2137477cf96c9686ebfb71524614cec780c673fd73e59bce099aef02e70e8"
+    },
+    "x86_64-unknown-linux-gnu": {
+      "url": "https://github.com/astral-sh/uv/releases/download/0.12.5/uv-x86_64-unknown-linux-gnu.tar.gz",
+      "sha256": "68a509da24b06b4223a1c0175fb5eb5bc79342b76cbeff0cfe51ac3f5b17b6b2"
+    },
+    "aarch64-unknown-linux-gnu": {
+      "url": "https://github.com/astral-sh/uv/releases/download/0.12.5/uv-aarch64-unknown-linux-gnu.tar.gz",
+      "sha256": "9bf43b4d1a07665bf64d4c4e710930b382321a785e0eb10aac07f46471f86a31"
+    },
+    "x86_64-pc-windows-msvc": {
+      "url": "https://github.com/astral-sh/uv/releases/download/0.12.5/uv-x86_64-pc-windows-msvc.zip",
+      "sha256": "4c4d49d8738847d9b71ba319e49a5688c93eac0fe6204b1df24e98528dddf39a"
+    },
+    "aarch64-pc-windows-msvc": {
+      "url": "https://github.com/astral-sh/uv/releases/download/0.12.5/uv-aarch64-pc-windows-msvc.zip",
+      "sha256": "724279317fee6e5fa8ad1908e4eba2bbe764ef1ece5b3f4597927b62b1fe562a"
+    }
+  }
+}

package/package.json

@@ -1,6 +1,16 @@
 {
   "name": "@jamestesting888/tum-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.1",
+  "description": "Local-first TUM Moodle, Artemis, and Zulip integration with campus workflow skills",
+  "license": "MIT",
+  "type": "module",
+  "bin": {"tum-mcp": "npm/tum-mcp.mjs"},
+  "engines": {"node": ">=22.14.0"},
+  "files": ["npm/tum-mcp.mjs", "npm/runtime.mjs", "npm/download.mjs", "npm/uv-artifacts.json", "npm/backend/*.whl", "npm/backend/requirements.txt", "npm/backend/manifest.json", "LICENSE", "NOTICE", "README.md", "docs/setup.md", "docs/development.md", "docs/tum-mcp.md", "docs/credential-storage-options.md"],
+  "scripts": {"prepack": "node npm/build.mjs", "test": "node --test npm/test/*.test.mjs", "test:consumer": "node npm/smoke-consumer.mjs"},
+  "publishConfig": {"access": "public"},
+  "repository": {"type": "git", "url": "git+https://github.com/jamestesting0/tum-moodle-integration.git"},
+  "homepage": "https://github.com/jamestesting0/tum-moodle-integration#readme",
+  "bugs": {"url": "https://github.com/jamestesting0/tum-moodle-integration/issues"},
+  "keywords": ["mcp", "tum", "moodle", "artemis", "zulip", "codex"]
+}