sneakoscope 4.2.0 → 4.4.0

package/dist/core/mcp/xai-mcp-detector.js

@@ -1,157 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-import { exists, nowIso, readText } from '../fsx.js';
-export const XAI_MCP_DETECTION_SCHEMA = 'sks.xai-mcp-detection.v1';
-const XAI_SERVER_RE = /(?:^|[-_\s.])(xai|x-ai|x_ai|grok|x\.ai)(?:$|[-_\s.])/i;
-const SEARCH_TOOL_RE = /(?:search|query|web|retrieve|retrieval|news|grok)/i;
-export function isXaiServerName(name) {
-    return XAI_SERVER_RE.test(normalizeName(name));
-}
-export function isSearchToolName(name) {
-    return SEARCH_TOOL_RE.test(normalizeName(name));
-}
-export async function detectXaiMcp(opts = {}) {
-    const root = path.resolve(opts.root || process.cwd());
-    const home = opts.home || os.homedir();
-    const configPaths = [
-        { path: path.join(home, '.codex', 'config.toml'), source: 'user' },
-        { path: path.join(root, '.codex', 'config.toml'), source: 'project' },
-        { path: path.join(root, '.codex', 'config.json'), source: 'project' }
-    ];
-    const provided = opts.configSources || [];
-    const discovered = [...provided];
-    for (const entry of configPaths) {
-        if (provided.some((source) => path.resolve(source.path) === path.resolve(entry.path)))
-            continue;
-        if (await exists(entry.path)) {
-            discovered.push({ path: entry.path, source: entry.source, text: String(await readText(entry.path, '')) });
-        }
-    }
-    return detectXaiMcpFromConfig(discovered, {
-        checked: configPaths.map((entry) => entry.path),
-        toolLists: opts.toolLists || {}
-    });
-}
-export function detectXaiMcpFromConfig(sources = [], opts = {}) {
-    try {
-        const servers = sources.flatMap((source) => detectServersInSource(source, opts.toolLists || {}));
-        const configured = servers.length > 0;
-        const searchCapable = servers.some((server) => server.search_capable);
-        const configuredButUnverified = configured && !searchCapable && servers.some((server) => server.configured_but_unverified);
-        const status = !configured
-            ? 'missing'
-            : searchCapable
-                ? 'search_capable'
-                : configuredButUnverified
-                    ? 'configured_but_unverified'
-                    : 'configured_no_search';
-        return {
-            schema: XAI_MCP_DETECTION_SCHEMA,
-            generated_at: nowIso(),
-            ok: true,
-            status,
-            configured,
-            search_capable: searchCapable,
-            configured_but_unverified: configuredButUnverified,
-            servers,
-            config_paths_checked: [...new Set([...(opts.checked || []), ...sources.map((source) => source.path)])],
-            config_paths_found: sources.map((source) => source.path),
-            blockers: [],
-            warnings: configuredButUnverified ? ['xai_mcp_configured_but_tool_list_unverified'] : []
-        };
-    }
-    catch (err) {
-        return {
-            schema: XAI_MCP_DETECTION_SCHEMA,
-            generated_at: nowIso(),
-            ok: false,
-            status: 'error',
-            configured: false,
-            search_capable: false,
-            configured_but_unverified: false,
-            servers: [],
-            config_paths_checked: opts.checked || [],
-            config_paths_found: sources.map((source) => source.path),
-            blockers: [`xai_mcp_detection_error:${err instanceof Error ? err.message : String(err)}`],
-            warnings: []
-        };
-    }
-}
-function detectServersInSource(source, toolLists) {
-    const jsonServers = parseJsonServers(source);
-    const tomlServers = jsonServers.length ? [] : parseTomlServerNames(source.text);
-    const names = [...jsonServers, ...tomlServers].filter((server) => isXaiServerName(server.name));
-    return names.map((server) => {
-        const configuredTools = [...server.tools, ...(toolLists[server.name] || []), ...(toolLists[normalizeName(server.name)] || [])];
-        const uniqueTools = [...new Set(configuredTools.map(String).filter(Boolean))];
-        const searchCapable = uniqueTools.some(isSearchToolName);
-        return {
-            name: normalizeName(server.name),
-            source: `${source.source}:${source.path}`,
-            configured: true,
-            search_capable: searchCapable,
-            configured_but_unverified: !searchCapable && uniqueTools.length === 0,
-            tools: uniqueTools,
-            raw_name: server.name
-        };
-    });
-}
-function parseJsonServers(source) {
-    const text = source.text.trim();
-    if (!text.startsWith('{'))
-        return [];
-    try {
-        const parsed = JSON.parse(text);
-        const servers = parsed?.mcp_servers || parsed?.mcpServers || {};
-        return Object.entries(servers).map(([name, value]) => ({
-            name,
-            tools: extractToolNames(value)
-        }));
-    }
-    catch {
-        return [];
-    }
-}
-function parseTomlServerNames(text) {
-    const rows = [];
-    const tableRe = /^\s*\[(?:mcp_servers|mcpServers)\.([^\]]+)\]\s*$/gm;
-    let match;
-    while ((match = tableRe.exec(text)) !== null) {
-        const name = unquote(match[1] || '');
-        const bodyStart = match.index + match[0].length;
-        const nextTable = text.slice(bodyStart).search(/^\s*\[/m);
-        const body = nextTable >= 0 ? text.slice(bodyStart, bodyStart + nextTable) : text.slice(bodyStart);
-        rows.push({ name, tools: extractToolNamesFromText(body) });
-    }
-    return rows;
-}
-function extractToolNames(value) {
-    if (!value || typeof value !== 'object')
-        return [];
-    const possible = [
-        value.tools,
-        value.tool_names,
-        value.capabilities,
-        value.search_tools
-    ];
-    return possible.flatMap((entry) => Array.isArray(entry) ? entry.map(String) : []);
-}
-function extractToolNamesFromText(text) {
-    const tools = [];
-    const arrayRe = /(?:tools|tool_names|capabilities|search_tools)\s*=\s*\[([^\]]*)\]/g;
-    let match;
-    while ((match = arrayRe.exec(text)) !== null) {
-        tools.push(...String(match[1] || '').split(',').map((part) => unquote(part.trim())).filter(Boolean));
-    }
-    const keyRe = /^\s*(search|query|web|retrieve|news|grok)\s*=/gmi;
-    while ((match = keyRe.exec(text)) !== null)
-        tools.push(match[1] || '');
-    return tools;
-}
-function normalizeName(name) {
-    return String(name || '').trim().replace(/^["']|["']$/g, '').toLowerCase();
-}
-function unquote(value) {
-    return String(value || '').trim().replace(/^["']|["']$/g, '');
-}
-//# sourceMappingURL=xai-mcp-detector.js.map

package/dist/core/mcp/xai-search-adapter.js

@@ -1,100 +0,0 @@
-import path from 'node:path';
-import { ensureDir, nowIso, sha256, writeJsonAtomic } from '../fsx.js';
-export const XAI_SEARCH_EVIDENCE_SCHEMA = 'sks.xai-search-evidence.v1';
-export async function runXaiSearch(query, opts = {}) {
-    const timeoutMs = opts.timeoutMs || 10_000;
-    if (opts.configured === false)
-        return blockedEvidence(query, timeoutMs, 'not_configured', ['xai_mcp_missing']);
-    if (!opts.search)
-        return blockedEvidence(query, timeoutMs, 'blocked', ['xai_search_adapter_missing']);
-    try {
-        const raw = await withTimeout(opts.search(query), timeoutMs);
-        const results = normalizeXaiSearchResults(raw);
-        let rawArtifact = null;
-        if (opts.artifactDir) {
-            await ensureDir(opts.artifactDir);
-            rawArtifact = path.join(opts.artifactDir, `xai-search-raw-${sha256(JSON.stringify({ query, raw })).slice(0, 12)}.json`);
-            await writeJsonAtomic(rawArtifact, { schema: 'sks.xai-search-raw-local-only.v1', generated_at: nowIso(), local_only: true, query, raw });
-        }
-        return {
-            schema: XAI_SEARCH_EVIDENCE_SCHEMA,
-            generated_at: nowIso(),
-            ok: true,
-            query,
-            status: 'completed',
-            timeout_ms: timeoutMs,
-            results: results.map((record) => ({ ...record, local_only_raw_artifact: rawArtifact })),
-            raw_response_artifact: rawArtifact,
-            redacted_summary: {
-                result_count: results.length,
-                urls: results.map((record) => record.url)
-            },
-            blockers: []
-        };
-    }
-    catch (err) {
-        const timeout = err instanceof Error && err.message === 'xai_search_timeout';
-        return blockedEvidence(query, timeoutMs, timeout ? 'timeout' : 'blocked', [
-            timeout ? 'xai_search_timeout' : `xai_search_failure:${err instanceof Error ? err.message : String(err)}`
-        ]);
-    }
-}
-export function normalizeXaiSearchResults(raw) {
-    const rows = Array.isArray(raw)
-        ? raw
-        : Array.isArray(raw?.results)
-            ? raw.results
-            : Array.isArray(raw?.data)
-                ? raw.data
-                : [];
-    return rows.map((row, index) => ({
-        provider: 'xai',
-        id: String(row.id || row.url || row.link || `xai-${index + 1}`),
-        title: String(row.title || row.name || row.heading || `X AI result ${index + 1}`),
-        url: row.url || row.link || null,
-        snippet: String(row.snippet || row.summary || row.text || ''),
-        published_at: row.published_at || row.publishedAt || row.date || null,
-        local_only_raw_artifact: null
-    }));
-}
-export function redactXaiRawResponse(raw) {
-    const results = normalizeXaiSearchResults(raw);
-    return {
-        provider: 'xai',
-        result_count: results.length,
-        results: results.map((result) => ({
-            title: result.title,
-            url: result.url,
-            snippet: result.snippet.slice(0, 240),
-            published_at: result.published_at
-        }))
-    };
-}
-function blockedEvidence(query, timeoutMs, status, blockers) {
-    return {
-        schema: XAI_SEARCH_EVIDENCE_SCHEMA,
-        generated_at: nowIso(),
-        ok: false,
-        query,
-        status,
-        timeout_ms: timeoutMs,
-        results: [],
-        raw_response_artifact: null,
-        redacted_summary: { result_count: 0, urls: [] },
-        blockers
-    };
-}
-function withTimeout(promise, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error('xai_search_timeout')), timeoutMs);
-        timer.unref?.();
-        promise.then((value) => {
-            clearTimeout(timer);
-            resolve(value);
-        }, (err) => {
-            clearTimeout(timer);
-            reject(err);
-        });
-    });
-}
-//# sourceMappingURL=xai-search-adapter.js.map

package/dist/scripts/xai-mcp-capability-check.js

@@ -1,14 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const detector = await importDist('core/mcp/xai-mcp-detector.js');
-const detection = detector.detectXaiMcpFromConfig([
-    { path: 'fixture.toml', source: 'provided', text: '[mcp_servers.grok]\ntools = ["search", "query"]\n' }
-]);
-assertGate(detection.ok === true, 'X AI detector must not fail');
-assertGate(detection.configured === true, 'X AI detector must detect configured Grok MCP');
-assertGate(detection.search_capable === true, 'X AI detector must detect search-capable tools');
-const missing = detector.detectXaiMcpFromConfig([]);
-assertGate(missing.ok === true && missing.status === 'missing', 'missing X AI MCP must be ok fallback');
-emitGate('xai-mcp:capability', { configured_status: detection.status, missing_status: missing.status });
-//# sourceMappingURL=xai-mcp-capability-check.js.map