@vespermcp/mcp-server 1.2.22 → 1.2.24

package/build/web/web-core.js

@@ -0,0 +1,242 @@
+function nowIso() {
+    return new Date().toISOString();
+}
+function clamp01(x) {
+    if (!Number.isFinite(x))
+        return 0;
+    return Math.max(0, Math.min(1, x));
+}
+function scoreTo01(score0to100) {
+    return clamp01(Number(score0to100 || 0) / 100);
+}
+export class WebCoreEngine {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async find(input) {
+        const query = String(input.query || "").trim();
+        if (!query)
+            throw new Error("query is required");
+        const limit = Math.max(1, Math.min(50, Number(input.limit || 10)));
+        const requested = (input.sources && input.sources.length > 0 ? input.sources : ["arxiv", "github"])
+            .filter((s) => s === "arxiv" || s === "github" || s === "semantic_scholar" || s === "hackernews");
+        const arxivFullText = input.arxiv_full_text === true;
+        const githubIncludeReadme = input.github_include_readme === true;
+        const collectedAt = nowIso();
+        const results = [];
+        const telemetry = { per_source: [] };
+        const perSource = Math.max(1, Math.ceil(limit / Math.max(1, requested.length)));
+        for (const source of requested) {
+            if (source === "arxiv") {
+                const t0 = Date.now();
+                try {
+                    const out = await this.deps.arxivSource.discoverWithTelemetry(query, perSource, { full_text: arxivFullText });
+                    const docs = out.results.map((m) => this.fromArxiv(m, collectedAt)).filter((d) => d !== null);
+                    results.push(...docs);
+                    telemetry.per_source.push({
+                        source,
+                        cache_hit: out.cacheHit,
+                        latency_ms: out.latencyMs || (Date.now() - t0),
+                        result_count: docs.length,
+                        pdf_extract_ms_total: out.pdf_extract_ms_total,
+                    });
+                }
+                catch (e) {
+                    telemetry.per_source.push({
+                        source,
+                        cache_hit: false,
+                        latency_ms: Date.now() - t0,
+                        result_count: 0,
+                        error: e?.message || String(e),
+                    });
+                }
+            }
+            if (source === "github") {
+                const t0 = Date.now();
+                try {
+                    const out = await this.deps.githubSource.discoverWithTelemetry(query, perSource, { include_readme: githubIncludeReadme });
+                    const docs = out.results.map((m) => this.fromGithub(m, collectedAt)).filter((d) => d !== null);
+                    results.push(...docs);
+                    telemetry.per_source.push({
+                        source,
+                        cache_hit: out.cacheHit,
+                        latency_ms: out.latencyMs || (Date.now() - t0),
+                        result_count: docs.length,
+                        readme_fetch_ms_total: out.readme_fetch_ms_total,
+                    });
+                }
+                catch (e) {
+                    telemetry.per_source.push({
+                        source,
+                        cache_hit: false,
+                        latency_ms: Date.now() - t0,
+                        result_count: 0,
+                        error: e?.message || String(e),
+                    });
+                }
+            }
+            if (source === "semantic_scholar") {
+                const t0 = Date.now();
+                try {
+                    const out = await this.deps.semanticScholarSource.discoverWithTelemetry(query, perSource);
+                    const docs = out.results.map((m) => this.fromSemanticScholar(m, collectedAt)).filter((d) => d !== null);
+                    results.push(...docs);
+                    telemetry.per_source.push({
+                        source,
+                        cache_hit: out.cacheHit,
+                        latency_ms: out.latencyMs || (Date.now() - t0),
+                        result_count: docs.length,
+                    });
+                }
+                catch (e) {
+                    telemetry.per_source.push({
+                        source,
+                        cache_hit: false,
+                        latency_ms: Date.now() - t0,
+                        result_count: 0,
+                        error: e?.message || String(e),
+                    });
+                }
+            }
+            if (source === "hackernews") {
+                const t0 = Date.now();
+                try {
+                    const out = await this.deps.hackerNewsSource.discoverWithTelemetry(query, perSource);
+                    const docs = out.results.map((m) => this.fromHackerNews(m, collectedAt)).filter((d) => d !== null);
+                    results.push(...docs);
+                    telemetry.per_source.push({
+                        source,
+                        cache_hit: out.cacheHit,
+                        latency_ms: out.latencyMs || (Date.now() - t0),
+                        result_count: docs.length,
+                    });
+                }
+                catch (e) {
+                    telemetry.per_source.push({
+                        source,
+                        cache_hit: false,
+                        latency_ms: Date.now() - t0,
+                        result_count: 0,
+                        error: e?.message || String(e),
+                    });
+                }
+            }
+        }
+        return {
+            query,
+            sources: requested,
+            results: results.slice(0, limit),
+            collected_at: collectedAt,
+            telemetry,
+        };
+    }
+    fromArxiv(meta, collectedAt) {
+        const arxivId = meta.id;
+        const absUrl = meta.metadata_url || `https://arxiv.org/abs/${arxivId}`;
+        const pdfUrl = meta.download_url || `https://arxiv.org/pdf/${arxivId}`;
+        const title = meta.name;
+        const abstract = meta.description;
+        const authors = Array.isArray(meta.authors) ? meta.authors : undefined;
+        const content = meta.webcore_content || abstract;
+        if (!absUrl || !content)
+            return null;
+        return {
+            source_type: "arxiv",
+            source_url: absUrl,
+            content,
+            metadata_json: {
+                arxiv_id: arxivId,
+                title,
+                authors,
+                categories: meta.tags,
+                updated_at: meta.last_updated,
+                pdf_url: pdfUrl,
+                abstract,
+                pdf_text_present: !!meta.webcore_content,
+                pdf_text_preview_length: meta.webcore_content ? meta.webcore_content.length : 0,
+            },
+            quality_score: scoreTo01(meta.quality_score),
+            collected_at: collectedAt,
+            content_type: meta.webcore_content ? "paper_fulltext" : "paper_abstract",
+        };
+    }
+    fromGithub(meta, collectedAt) {
+        const fullName = meta.id;
+        const url = meta.metadata_url || meta.download_url || `https://github.com/${fullName}`;
+        const content = meta.webcore_content || meta.description || meta.name;
+        if (!url || !content)
+            return null;
+        return {
+            source_type: "github",
+            source_url: url,
+            content,
+            metadata_json: {
+                full_name: fullName,
+                name: meta.name,
+                description: meta.description,
+                stars: meta.stars,
+                forks_proxy_downloads: meta.downloads,
+                topics: meta.tags,
+                license_id: meta.license?.id,
+                license_name: meta.license?.name,
+                updated_at: meta.last_updated,
+                language: (meta.languages || [])[0],
+                readme_present: !!meta.webcore_content,
+                readme_preview_length: meta.webcore_content ? meta.webcore_content.length : 0,
+            },
+            quality_score: scoreTo01(meta.quality_score),
+            collected_at: collectedAt,
+            content_type: meta.webcore_content ? "text" : "repo",
+        };
+    }
+    fromSemanticScholar(meta, collectedAt) {
+        const paperId = meta.id;
+        const url = meta.metadata_url || meta.download_url || (paperId ? `https://www.semanticscholar.org/paper/${paperId}` : "");
+        const content = meta.description;
+        if (!url || !content)
+            return null;
+        return {
+            source_type: "semantic_scholar",
+            source_url: url,
+            content,
+            metadata_json: {
+                paper_id: paperId,
+                title: meta.name,
+                authors: meta.authors,
+                abstract: meta.description,
+                tags: meta.tags,
+                citation_count: meta.stars,
+                updated_at: meta.last_updated,
+            },
+            quality_score: scoreTo01(meta.quality_score),
+            collected_at: collectedAt,
+            content_type: "paper_abstract",
+        };
+    }
+    fromHackerNews(meta, collectedAt) {
+        const itemId = meta.id;
+        const url = meta.metadata_url || meta.download_url || (itemId ? `https://news.ycombinator.com/item?id=${itemId}` : "");
+        const content = meta.description;
+        const authors = meta.authors;
+        if (!url || !content)
+            return null;
+        return {
+            source_type: "hackernews",
+            source_url: url,
+            content,
+            metadata_json: {
+                item_id: itemId,
+                title: meta.name,
+                authors,
+                points: meta.stars,
+                comments_proxy: meta.downloads,
+                tags: meta.tags,
+                updated_at: meta.last_updated,
+            },
+            quality_score: scoreTo01(meta.quality_score),
+            collected_at: collectedAt,
+            content_type: "thread",
+        };
+    }
+}

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@vespermcp/mcp-server",
-  "version": "1.2.22",
+  "version": "1.2.24",
   "description": "AI-powered dataset discovery, quality analysis, and preparation MCP server with multimodal support (text, image, audio, video)",
   "type": "module",
   "main": "build/index.js",
   "bin": {
+    "vespermcp": "build/index.js",
     "vesper-wizard": "wizard.cjs"
   },
   "files": [
@@ -66,10 +67,13 @@
     "npm": ">=8.0.0"
   },
   "dependencies": {
+    "@aws-sdk/client-s3": "^3.1017.0",
+    "@aws-sdk/credential-providers": "^3.1017.0",
     "@huggingface/hub": "^2.7.1",
     "@modelcontextprotocol/sdk": "^1.25.2",
     "@polar-sh/nextjs": "^0.9.4",
     "@supabase/supabase-js": "^2.98.0",
+    "@vercel/analytics": "^2.0.0",
     "@xenova/transformers": "^2.17.2",
     "adm-zip": "^0.5.16",
     "ajv": "^8.17.1",
@@ -77,6 +81,7 @@
     "better-sqlite3": "^12.6.0",
     "inquirer": "^13.3.0",
     "lodash": "^4.17.21",
+    "pdf-parse": "^2.4.5",
     "uuid": "^13.0.0",
     "zod": "^4.3.5",
     "zod-to-json-schema": "^3.25.1"

package/scripts/wizard.cjs

@@ -18,6 +18,7 @@ const readline = require('readline');
 const HOME = os.homedir();
 const VESPER_DIR = path.join(HOME, '.vesper');
 const CONFIG_TOML = path.join(VESPER_DIR, 'config.toml');
+const CONFIG_JSON = path.join(VESPER_DIR, 'config.json');
 const DATA_DIR = path.join(VESPER_DIR, 'data');
 const IS_WIN = process.platform === 'win32';
 const APPDATA = process.env.APPDATA || path.join(HOME, 'AppData', 'Roaming');
@@ -49,6 +50,32 @@ function writeToml(filePath, data) {
   fs.writeFileSync(filePath, lines.join('\n') + '\n', 'utf8');
 }
 
+function readWizardState() {
+  if (!fs.existsSync(CONFIG_JSON)) return {};
+  try {
+    const content = fs.readFileSync(CONFIG_JSON, 'utf8').trim();
+    return content ? JSON.parse(content) : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeWizardState(state) {
+  ensureDir(path.dirname(CONFIG_JSON));
+  fs.writeFileSync(CONFIG_JSON, JSON.stringify(state, null, 2), 'utf8');
+}
+
+function hasCompletedOnboarding() {
+  const state = readWizardState();
+  return state.onboardingCompleted === true;
+}
+
+function markOnboardingCompleted() {
+  const state = readWizardState();
+  state.onboardingCompleted = true;
+  writeWizardState(state);
+}
+
 function dim(text) { return `\x1b[2m${text}\x1b[0m`; }
 function bold(text) { return `\x1b[1m${text}\x1b[0m`; }
 function green(text) { return `\x1b[32m${text}\x1b[0m`; }
@@ -155,6 +182,10 @@ function openBrowser(url) {
   } catch { /* browser open is best-effort */ }
 }
 
+function isInteractiveTerminal() {
+  return Boolean(process.stdin && process.stdin.isTTY && process.stdout && process.stdout.isTTY);
+}
+
 function askYesNo(question) {
   return new Promise((resolve) => {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -282,8 +313,16 @@ async function deviceAuthFlow() {
   console.log(`  │                                               │`);
   console.log(`  └───────────────────────────────────────────────┘\n`);
 
-  openBrowser(loginUrl);
-  console.log(`  ${dim('Browser opened automatically.')}`);
+  const shouldAutoOpenBrowser = process.env.VESPER_WIZARD_AUTO_OPEN !== '0';
+  if (shouldAutoOpenBrowser) {
+    openBrowser(loginUrl);
+    if (!hasCompletedOnboarding()) {
+      markOnboardingCompleted();
+    }
+    console.log(`  ${dim('Browser opened automatically for device auth.')}`);
+  } else {
+    console.log(`  ${dim('Browser auto-open disabled via VESPER_WIZARD_AUTO_OPEN=0. Open the URL manually to continue.')}`);
+  }
   console.log(`  ${dim('Waiting for you to sign in...')}\n`);
 
   // Step 3: Poll until confirmed or expired
@@ -386,7 +425,7 @@ function getAllAgentConfigs() {
 
 function installMcpToAgent(agent) {
   const npxCmd = IS_WIN ? 'npx.cmd' : 'npx';
-  const serverEntry = { command: npxCmd, args: ['-y', '@vespermcp/mcp-server@latest'] };
+  const serverEntry = { command: npxCmd, args: ['-y', '-p', '@vespermcp/mcp-server@latest', 'vespermcp'] };
 
   try {
     if (agent.format === 'toml') {
@@ -437,6 +476,13 @@ async function checkServerHealth() {
 
 // ── Main Wizard ──────────────────────────────────────────────
 async function main() {
+  if (!isInteractiveTerminal()) {
+    console.error(red('vesper-wizard is interactive and cannot run in MCP stdio mode.'));
+    console.error(dim('Use this command for MCP server runtime instead:'));
+    console.error(cyan('npx -y -p @vespermcp/mcp-server@latest vespermcp'));
+    process.exit(2);
+  }
+
   printBanner();
 
   console.log(`  ${green('→')} Setting up Vesper on ${bold(os.hostname())}\n`);
@@ -487,17 +533,22 @@ async function main() {
   console.log(` ${green('✓')}`);
   console.log(`      ${dim('Mode:')} ${dim(vaultData.auth_mode === 'cloud' ? 'cloud (linked to Vesper account)' : 'single local Vesper key (no external keys required)')}`);
 
-  // ─── Step 4: Install @vespermcp/mcp-server ─────────────────
-  console.log(`\n  ${dim('[')}${cyan('4/6')}${dim(']')} Installing Vesper MCP server...`);
+  // ─── Step 4: Verify @vespermcp/mcp-server command ───────────
+  console.log(`\n  ${dim('[')}${cyan('4/6')}${dim(']')} Verifying Vesper MCP server command...`);
   try {
     const npmCmd = IS_WIN ? 'npx.cmd' : 'npx';
-    spawnSync(npmCmd, ['-y', '@vespermcp/mcp-server@latest', '--setup', '--silent'], {
-      stdio: 'inherit',
-      timeout: 120000,
+    const verify = spawnSync(npmCmd, ['-y', '-p', '@vespermcp/mcp-server@latest', 'vespermcp', '--version'], {
+      stdio: 'pipe',
+      timeout: 30000,
+      encoding: 'utf8',
     });
-    console.log(`      ${green('✓')} @vespermcp/mcp-server installed`);
+    if (verify.status === 0) {
+      console.log(`      ${green('✓')} @vespermcp/mcp-server command is available`);
+    } else {
+      console.log(`      ${yellow('⚠')} Could not verify vespermcp binary. MCP clients will still install it on first run.`);
+    }
   } catch {
-    console.log(`      ${yellow('⚠')} Could not auto-install — run manually: npx -y @vespermcp/mcp-server@latest --setup`);
+    console.log(`      ${yellow('⚠')} Could not verify vespermcp binary. MCP clients will still install it on first run.`);
   }
 
   // ─── Step 5: Auto-configure all detected IDEs ──────────────

package/scripts/wizard.js

@@ -18,6 +18,7 @@ const readline = require('readline');
 const HOME = os.homedir();
 const VESPER_DIR = path.join(HOME, '.vesper');
 const CONFIG_TOML = path.join(VESPER_DIR, 'config.toml');
+const CONFIG_JSON = path.join(VESPER_DIR, 'config.json');
 const DATA_DIR = path.join(VESPER_DIR, 'data');
 const IS_WIN = process.platform === 'win32';
 const APPDATA = process.env.APPDATA || path.join(HOME, 'AppData', 'Roaming');
@@ -49,6 +50,32 @@ function writeToml(filePath, data) {
   fs.writeFileSync(filePath, lines.join('\n') + '\n', 'utf8');
 }
 
+function readWizardState() {
+  if (!fs.existsSync(CONFIG_JSON)) return {};
+  try {
+    const content = fs.readFileSync(CONFIG_JSON, 'utf8').trim();
+    return content ? JSON.parse(content) : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeWizardState(state) {
+  ensureDir(path.dirname(CONFIG_JSON));
+  fs.writeFileSync(CONFIG_JSON, JSON.stringify(state, null, 2), 'utf8');
+}
+
+function hasCompletedOnboarding() {
+  const state = readWizardState();
+  return state.onboardingCompleted === true;
+}
+
+function markOnboardingCompleted() {
+  const state = readWizardState();
+  state.onboardingCompleted = true;
+  writeWizardState(state);
+}
+
 function dim(text) { return `\x1b[2m${text}\x1b[0m`; }
 function bold(text) { return `\x1b[1m${text}\x1b[0m`; }
 function green(text) { return `\x1b[32m${text}\x1b[0m`; }
@@ -282,8 +309,13 @@ async function deviceAuthFlow() {
   console.log(`  │                                               │`);
   console.log(`  └───────────────────────────────────────────────┘\n`);
 
-  openBrowser(loginUrl);
-  console.log(`  ${dim('Browser opened automatically.')}`);
+  if (!hasCompletedOnboarding()) {
+    openBrowser(loginUrl);
+    markOnboardingCompleted();
+    console.log(`  ${dim('Browser opened automatically (first-time onboarding).')}`);
+  } else {
+    console.log(`  ${dim('Browser auto-open skipped (onboarding already completed).')}`);
+  }
   console.log(`  ${dim('Waiting for you to sign in...')}\n`);
 
   // Step 3: Poll until confirmed or expired

package/wizard.cjs

@@ -1,3 +1,3 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 require('./scripts/wizard.cjs');