@sdods/mcp 0.2.0

package/dist/tools/run.js

@@ -0,0 +1,387 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { runFiles } from '@sdods/contracts';
+import { SdodsCliError, sdodsCli } from '../cli.js';
+import { getRun, lastRun, listRuns, listScenarioDirs, readScenarioDir, screenshotUri, } from '../fs.js';
+import { defineTool, summarize } from '../registry/registry.js';
+const runArgs = {
+    project: z.string(),
+    env: z.string().optional(),
+    tags: z.string().optional().describe('Cucumber tag expression, e.g. "@smoke and not @mock"'),
+    layers: z.array(z.enum(['ui', 'api', 'hybrid', 'recorded'])).optional(),
+    browsers: z
+        .array(z.enum(['chromium', 'firefox', 'webkit', 'mobile-chrome', 'mobile-safari']))
+        .optional(),
+    process: z
+        .string()
+        .optional()
+        .describe('named process (pr-check, nightly-regression, release-gate …)'),
+    modules: z.array(z.string()).optional(),
+    harMode: z.enum(['off', 'update', 'replay']).optional(),
+    workers: z.number().int().positive().optional(),
+    retries: z.number().int().min(0).optional(),
+    grep: z.string().optional(),
+    headed: z.boolean().optional(),
+    strict: z.boolean().optional().describe('with harMode replay: abort on any un-recorded request'),
+    runId: z.string().optional(),
+};
+function buildRunCli(a) {
+    const cli = ['run', '-p', a.project];
+    if (a.env)
+        cli.push('-e', a.env);
+    if (a.tags)
+        cli.push('-t', a.tags);
+    for (const l of a.layers ?? [])
+        cli.push('-l', l);
+    for (const b of a.browsers ?? [])
+        cli.push('-b', b);
+    if (a.process)
+        cli.push('--process', a.process);
+    for (const m of a.modules ?? [])
+        cli.push('--module', m);
+    if (a.harMode === 'replay')
+        cli.push('--har-replay');
+    if (a.harMode === 'update')
+        cli.push('--har-update');
+    if (a.strict)
+        cli.push('--strict');
+    if (a.workers)
+        cli.push('-w', String(a.workers));
+    if (a.retries !== undefined)
+        cli.push('--retries', String(a.retries));
+    if (a.grep)
+        cli.push('--grep', a.grep);
+    if (a.headed)
+        cli.push('--headed');
+    if (a.runId)
+        cli.push('--run-id', a.runId);
+    return cli;
+}
+function scenarioView(runId, s) {
+    return {
+        fingerprint: s.fingerprint,
+        retry: s.retry,
+        meta: s.meta,
+        screenshots: s.screenshots.map((sh) => ({
+            ...sh,
+            uri: screenshotUri(runId, s.fingerprint, s.retry, sh.file),
+        })),
+        apiSnapshots: s.apiSnapshots,
+        healEvents: s.healEvents,
+    };
+}
+function summaryText(runId, summary, exitCode) {
+    const s = summary;
+    const t = s?.totals;
+    const head = t
+        ? `Run ${runId}: ${t.passed ?? 0} passed, ${t.failed ?? 0} failed, ${t.skipped ?? 0} skipped, ${t.flaky ?? 0} flaky (exit ${exitCode})`
+        : `Run ${runId} finished with exit code ${exitCode}`;
+    return summarize(head, summary ?? { runId, exitCode });
+}
+export const runTools = [
+    defineTool({
+        name: 'run_tests',
+        title: 'Run tests',
+        description: 'Run a project slice through `sdods run` (lint → generate specs → run suite). Streams progress lines; returns the run id, totals, failed scenarios and report paths. Test failures are returned as data, not as a tool error.',
+        shape: runArgs,
+        access: 'run',
+        domain: 'runs',
+        capability: 'run',
+        annotations: { openWorldHint: true },
+        docsPath: '/docs/reference/cli-commands/run',
+        handler: async (args, ctx) => {
+            const cli = buildRunCli(args);
+            let runId = args.runId;
+            const onLine = (line) => {
+                const m = /run[- ]?id[:=]\s*([0-9a-f-]{20,})/i.exec(line);
+                if (m && !runId)
+                    runId = m[1];
+                const p = /\[(\d+)\/(\d+)\]/.exec(line);
+                ctx.onProgress?.({
+                    message: line.slice(0, 200),
+                    current: p ? Number(p[1]) : undefined,
+                    total: p ? Number(p[2]) : undefined,
+                });
+            };
+            let exitCode = 0;
+            let json;
+            try {
+                const r = await sdodsCli(cli, {
+                    cwd: ctx.rootDir,
+                    signal: ctx.signal,
+                    onLine,
+                    timeoutMs: 60 * 60_000,
+                });
+                json = r.json;
+            }
+            catch (e) {
+                if (!(e instanceof SdodsCliError))
+                    throw e;
+                if (e.notSupported)
+                    return {
+                        text: 'sdods run is not available in this build.',
+                        data: { note: 'command not available in this build' },
+                    };
+                if (e.exitCode !== 1)
+                    throw e; // config/lint errors are real errors
+                exitCode = 1;
+                json = safeJson(e.stderr) ?? safeJson(e.message);
+            }
+            const summaryObj = json ?? {};
+            runId = runId ?? summaryObj.runId ?? lastRun(ctx.rootDir)?.runId;
+            const run = runId ? getRun(ctx.rootDir, runId) : undefined;
+            const summary = run?.summary ?? json;
+            return {
+                text: summaryText(runId ?? '?', summary, exitCode),
+                data: { runId, exitCode, summary, manifest: run?.manifest },
+            };
+        },
+    }),
+    defineTool({
+        name: 'run_tests_async',
+        title: 'Start a run (async)',
+        description: 'Start `sdods run` in the background and return immediately with the run id; poll with run_get.',
+        shape: runArgs,
+        access: 'run',
+        domain: 'runs',
+        capability: 'run',
+        annotations: { openWorldHint: true },
+        handler: async (args, ctx) => {
+            const { newRunId } = await import('@sdods/contracts');
+            const runId = args.runId ?? newRunId();
+            const cli = buildRunCli({ ...args, runId });
+            void sdodsCli(cli, { cwd: ctx.rootDir, timeoutMs: 60 * 60_000 }).catch(() => undefined);
+            return {
+                text: `Run ${runId} started. Poll with run_get { runId: "${runId}" }.`,
+                data: { runId, status: 'running' },
+            };
+        },
+    }),
+    defineTool({
+        name: 'run_list',
+        title: 'List runs',
+        description: 'Recent runs from the artifacts directory (newest first) with manifest and totals.',
+        shape: {
+            limit: z.number().int().positive().max(200).optional(),
+            project: z.string().optional(),
+        },
+        access: 'read',
+        domain: 'runs',
+        capability: 'run',
+        handler: async (args, ctx) => {
+            const runs = listRuns(ctx.rootDir, args.limit ?? 20)
+                .filter((r) => (args.project ? r.manifest?.projectSlug === args.project : true))
+                .map((r) => ({
+                runId: r.runId,
+                project: r.manifest?.projectSlug,
+                env: r.manifest?.env,
+                startedAt: r.manifest?.startedAt,
+                status: r.summary?.status ?? (r.summary ? 'finished' : 'running'),
+                totals: r.summary?.totals,
+                process: r.manifest?.process,
+            }));
+            return { text: summarize(`Runs (${runs.length})`, runs), data: runs };
+        },
+    }),
+    defineTool({
+        name: 'run_get',
+        title: 'Get run',
+        description: 'Manifest, summary, report paths and the scenario list of a run (use "last" for the latest).',
+        shape: { runId: z.string() },
+        access: 'read',
+        domain: 'runs',
+        capability: 'run',
+        handler: async (args, ctx) => {
+            const run = args.runId === 'last' ? lastRun(ctx.rootDir) : getRun(ctx.rootDir, args.runId);
+            if (!run)
+                throw Object.assign(new Error(`Unknown run ${args.runId}`), {
+                    error: { code: 'NOT_FOUND' },
+                });
+            const scenarios = listScenarioDirs(run.dir, run.manifest?.projectSlug).map((s) => ({
+                fingerprint: s.fingerprint,
+                retry: s.retry,
+                name: s.meta?.scenarioName,
+                feature: s.meta?.featureUri,
+                status: s.meta?.status,
+                durationMs: s.meta?.durationMs,
+                screenshots: s.screenshots.length,
+                apiCalls: s.apiSnapshots.length / 2,
+                heals: s.healEvents.length,
+            }));
+            const data = {
+                runId: run.runId,
+                dir: run.dir,
+                status: run.summary?.status ??
+                    (existsSync(join(run.dir, runFiles.summary)) ? 'finished' : 'running'),
+                manifest: run.manifest,
+                summary: run.summary,
+                reports: {
+                    html: join(run.dir, runFiles.htmlReport),
+                    dashboard: join(run.dir, runFiles.dashboard),
+                    messages: join(run.dir, runFiles.messages),
+                },
+                scenarios,
+            };
+            return {
+                text: summarize(`Run ${run.runId}`, { ...data, scenarios: scenarios.slice(0, 50) }),
+                data,
+            };
+        },
+    }),
+    defineTool({
+        name: 'run_get_scenario',
+        title: 'Get scenario result',
+        description: 'One scenario of a run: meta, steps, before/after screenshot URIs (sdods://screenshot/…), API request/response snapshots and heal events.',
+        shape: {
+            runId: z.string(),
+            fingerprint: z.string(),
+            retry: z.number().int().min(0).optional(),
+        },
+        access: 'read',
+        domain: 'runs',
+        capability: 'run',
+        handler: async (args, ctx) => {
+            const run = args.runId === 'last' ? lastRun(ctx.rootDir) : getRun(ctx.rootDir, args.runId);
+            if (!run)
+                throw Object.assign(new Error(`Unknown run ${args.runId}`), {
+                    error: { code: 'NOT_FOUND' },
+                });
+            const all = listScenarioDirs(run.dir, run.manifest?.projectSlug).filter((s) => s.fingerprint === args.fingerprint || s.meta?.scenarioName === args.fingerprint);
+            if (!all.length)
+                throw Object.assign(new Error(`Scenario ${args.fingerprint} not found in run ${run.runId}`), { error: { code: 'NOT_FOUND' } });
+            const pick = args.retry !== undefined
+                ? all.find((s) => s.retry === args.retry)
+                : all.sort((a, b) => b.retry - a.retry)[0];
+            const s = pick ?? all[0];
+            const data = {
+                runId: run.runId,
+                ...scenarioView(run.runId, readScenarioDir(s.dir, s.fingerprint, s.retry)),
+                attempts: all.map((a) => a.retry),
+            };
+            return {
+                text: summarize(`Scenario ${s.meta?.scenarioName ?? s.fingerprint} (retry ${s.retry})`, data),
+                data,
+            };
+        },
+    }),
+    defineTool({
+        name: 'run_last_failed',
+        title: 'Last failed scenarios',
+        description: 'Failed scenarios of the latest run (or a given run) with error messages and failure screenshots.',
+        shape: { runId: z.string().optional(), project: z.string().optional() },
+        access: 'read',
+        domain: 'runs',
+        capability: 'run',
+        handler: async (args, ctx) => {
+            const run = args.runId
+                ? getRun(ctx.rootDir, args.runId)
+                : listRuns(ctx.rootDir, 50).find((r) => args.project ? r.manifest?.projectSlug === args.project : true);
+            if (!run)
+                return { text: 'No runs found.', data: { failed: [] } };
+            const failed = listScenarioDirs(run.dir, run.manifest?.projectSlug)
+                .filter((s) => s.meta?.status && s.meta.status !== 'passed' && s.meta.status !== 'skipped')
+                .map((s) => ({
+                fingerprint: s.fingerprint,
+                retry: s.retry,
+                name: s.meta?.scenarioName,
+                feature: s.meta?.featureUri,
+                status: s.meta?.status,
+                error: s.meta?.errorMessage,
+                failureShot: s.screenshots.find((x) => x.phase === 'failure')
+                    ? screenshotUri(run.runId, s.fingerprint, s.retry, 'scenario-failure.png')
+                    : undefined,
+            }));
+            const fromSummary = run.summary?.failed ?? [];
+            return {
+                text: summarize(`Failed in ${run.runId}: ${failed.length || fromSummary.length}`, failed.length ? failed : fromSummary),
+                data: { runId: run.runId, failed: failed.length ? failed : fromSummary },
+            };
+        },
+    }),
+    defineTool({
+        name: 'heal_events',
+        title: 'Heal events',
+        description: 'Self-healing locator events of a run (or the last run): original selector, chosen strategy, candidates and scores.',
+        shape: { runId: z.string().optional(), project: z.string().optional() },
+        access: 'read',
+        domain: 'runs',
+        capability: 'run',
+        handler: async (args, ctx) => {
+            const run = args.runId
+                ? getRun(ctx.rootDir, args.runId)
+                : listRuns(ctx.rootDir, 50).find((r) => args.project ? r.manifest?.projectSlug === args.project : true);
+            if (!run)
+                return { text: 'No runs found.', data: { events: [] } };
+            const events = listScenarioDirs(run.dir, run.manifest?.projectSlug).flatMap((s) => s.healEvents.map((e) => ({
+                fingerprint: s.fingerprint,
+                retry: s.retry,
+                scenario: s.meta?.scenarioName,
+                ...e,
+            })));
+            return {
+                text: summarize(`Heal events in ${run.runId}: ${events.length}`, events),
+                data: { runId: run.runId, events },
+            };
+        },
+    }),
+    defineTool({
+        name: 'heal_locator_stats',
+        title: 'Locator stats',
+        description: 'Aggregate heal events across recent runs per original selector: occurrences, winning strategies, suggested selector.',
+        shape: {
+            project: z.string().optional(),
+            runs: z.number().int().positive().max(200).optional(),
+        },
+        access: 'read',
+        domain: 'runs',
+        capability: 'run',
+        handler: async (args, ctx) => {
+            const stats = new Map();
+            for (const run of listRuns(ctx.rootDir, args.runs ?? 30).filter((r) => args.project ? r.manifest?.projectSlug === args.project : true)) {
+                for (const s of listScenarioDirs(run.dir, run.manifest?.projectSlug)) {
+                    for (const raw of s.healEvents) {
+                        const key = String(raw.originalSelector ?? raw.original ?? '?');
+                        const entry = stats.get(key) ?? {
+                            selector: key,
+                            description: raw.description,
+                            occurrences: 0,
+                            strategies: {},
+                            lastRun: run.runId,
+                        };
+                        entry.occurrences++;
+                        const strategy = String(raw.strategyUsed ??
+                            raw.chosen?.strategy ??
+                            'none');
+                        entry.strategies[strategy] = (entry.strategies[strategy] ?? 0) + 1;
+                        entry.suggested =
+                            raw.healedSelector ??
+                                raw.chosen?.selector ??
+                                entry.suggested;
+                        stats.set(key, entry);
+                    }
+                }
+            }
+            const rows = [...stats.values()].sort((a, b) => b.occurrences - a.occurrences);
+            return { text: summarize(`Locator stats (${rows.length} selectors)`, rows), data: rows };
+        },
+    }),
+];
+function safeJson(s) {
+    if (!s)
+        return undefined;
+    const m = /\{[\s\S]*\}$/m.exec(s.trim());
+    if (!m)
+        return undefined;
+    try {
+        return JSON.parse(m[0]);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readRunLog(dir) {
+    const f = join(dir, runFiles.log);
+    return existsSync(f) ? readFileSync(f, 'utf8') : undefined;
+}
+//# sourceMappingURL=run.js.map

package/dist/transports/http.d.ts

@@ -0,0 +1,40 @@
+import { type IncomingMessage, type Server, type ServerResponse } from 'node:http';
+import { NodeStreamableHTTPServerTransport } from '@modelcontextprotocol/node';
+import { type BuildServerOptions } from '../server.js';
+import type { Principal } from '../registry/registry.js';
+export type Authenticate = (token: string | undefined, req: IncomingMessage) => Promise<Principal | null> | Principal | null;
+export interface HttpTransportOptions extends Omit<BuildServerOptions, 'principal'> {
+    /** Resolve a bearer token to a principal. Default denies everything. */
+    authenticate?: Authenticate;
+    /** idle session eviction (ms) */
+    sessionIdleMs?: number;
+    /** allowed Host header values (defaults to localhost variants); '*' disables the check */
+    allowedHosts?: string[];
+    path?: string;
+}
+interface Session {
+    transport: NodeStreamableHTTPServerTransport;
+    principalKey: string;
+    lastSeen: number;
+    close(): Promise<void>;
+}
+/**
+ * Node request handler for the streamable-HTTP MCP endpoint. Mount it on any http server
+ * (Fastify can pass raw req/res). Sessions are token-bound and evicted when idle.
+ */
+export declare function createMcpHttpHandler(opts?: HttpTransportOptions): {
+    handler: (req: IncomingMessage, res: ServerResponse, parsedBody?: unknown) => Promise<void>;
+    sessions: Map<string, Session>;
+    close(): Promise<void>;
+};
+/** Standalone HTTP server (`sdods mcp --http --port 4001`). */
+export declare function serveSdodsHttp(opts?: HttpTransportOptions & {
+    port?: number;
+    host?: string;
+}): Promise<{
+    server: Server;
+    port: number;
+    close(): Promise<void>;
+}>;
+export {};
+//# sourceMappingURL=http.d.ts.map

package/dist/transports/http.js

@@ -0,0 +1,151 @@
+import { randomUUID } from 'node:crypto';
+import { createServer } from 'node:http';
+import { NodeStreamableHTTPServerTransport } from '@modelcontextprotocol/node';
+import { buildSdodsMcpServer } from '../server.js';
+/**
+ * Node request handler for the streamable-HTTP MCP endpoint. Mount it on any http server
+ * (Fastify can pass raw req/res). Sessions are token-bound and evicted when idle.
+ */
+export function createMcpHttpHandler(opts = {}) {
+    const sessions = new Map();
+    const authenticate = opts.authenticate ?? (() => null);
+    const idleMs = opts.sessionIdleMs ?? 30 * 60_000;
+    const evict = setInterval(() => {
+        const now = Date.now();
+        for (const [id, s] of sessions)
+            if (now - s.lastSeen > idleMs)
+                void s.close().finally(() => sessions.delete(id));
+    }, 60_000);
+    evict.unref();
+    const handler = async (req, res, parsedBody) => {
+        const header = req.headers.authorization;
+        const token = header?.toLowerCase().startsWith('bearer ') ? header.slice(7).trim() : undefined;
+        const principal = await authenticate(token, req);
+        if (!principal) {
+            res.writeHead(401, {
+                'content-type': 'application/json',
+                'www-authenticate': 'Bearer realm="sdods"',
+            });
+            res.end(JSON.stringify({
+                error: {
+                    code: 'AUTH_FAILED',
+                    message: 'A valid bearer token is required.',
+                    hint: 'Create one with `sdods tokens create` and pass Authorization: Bearer <token>.',
+                },
+            }));
+            return;
+        }
+        const principalKey = principal.userId ?? principal.name ?? token ?? 'anonymous';
+        const sid = req.headers['mcp-session-id'];
+        const sessionId = Array.isArray(sid) ? sid[0] : sid;
+        let session = sessionId ? sessions.get(sessionId) : undefined;
+        if (session && session.principalKey !== principalKey) {
+            res.writeHead(403, { 'content-type': 'application/json' });
+            res.end(JSON.stringify({
+                error: { code: 'AUTH_FAILED', message: 'Session belongs to another principal.' },
+            }));
+            return;
+        }
+        if (!session) {
+            if (req.method !== 'POST') {
+                res.writeHead(400, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({
+                    error: {
+                        code: 'INVALID_REQUEST',
+                        message: 'No session; send an initialize request first.',
+                    },
+                }));
+                return;
+            }
+            const built = buildSdodsMcpServer({ ...opts, principal: { ...principal, via: 'http' } });
+            const transport = new NodeStreamableHTTPServerTransport({
+                sessionIdGenerator: () => randomUUID(),
+                onsessioninitialized: (id) => {
+                    sessions.set(id, {
+                        transport,
+                        principalKey,
+                        lastSeen: Date.now(),
+                        close: () => built.server.close(),
+                    });
+                },
+            });
+            transport.onclose = () => {
+                if (transport.sessionId)
+                    sessions.delete(transport.sessionId);
+            };
+            await built.server.connect(transport);
+            session = {
+                transport,
+                principalKey,
+                lastSeen: Date.now(),
+                close: () => built.server.close(),
+            };
+        }
+        session.lastSeen = Date.now();
+        await session.transport.handleRequest(req, res, parsedBody);
+    };
+    return {
+        handler,
+        sessions,
+        async close() {
+            clearInterval(evict);
+            for (const s of sessions.values())
+                await s.close().catch(() => undefined);
+            sessions.clear();
+        },
+    };
+}
+/** Standalone HTTP server (`sdods mcp --http --port 4001`). */
+export function serveSdodsHttp(opts = {}) {
+    const path = opts.path ?? '/mcp';
+    const mcp = createMcpHttpHandler(opts);
+    const server = createServer((req, res) => {
+        const url = new URL(req.url ?? '/', 'http://localhost');
+        if (url.pathname === '/healthz') {
+            res.writeHead(200, { 'content-type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, sessions: mcp.sessions.size }));
+            return;
+        }
+        if (url.pathname !== path) {
+            res.writeHead(404);
+            res.end();
+            return;
+        }
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', () => {
+            const raw = Buffer.concat(chunks).toString('utf8');
+            let body;
+            if (raw) {
+                try {
+                    body = JSON.parse(raw);
+                }
+                catch {
+                    res.writeHead(400, { 'content-type': 'application/json' });
+                    res.end(JSON.stringify({ error: { code: 'INVALID_REQUEST', message: 'Body is not JSON' } }));
+                    return;
+                }
+            }
+            mcp.handler(req, res, body).catch((e) => {
+                if (!res.headersSent)
+                    res.writeHead(500, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({ error: { code: 'INTERNAL', message: e.message } }));
+            });
+        });
+    });
+    return new Promise((resolve) => {
+        server.listen(opts.port ?? 4001, opts.host ?? '127.0.0.1', () => {
+            const addr = server.address();
+            const port = typeof addr === 'object' && addr ? addr.port : (opts.port ?? 4001);
+            resolve({
+                server,
+                port,
+                close: async () => {
+                    await mcp.close();
+                    await new Promise((r) => server.close(() => r()));
+                },
+            });
+        });
+    });
+}
+//# sourceMappingURL=http.js.map

package/dist/transports/stdio.d.ts

@@ -0,0 +1,6 @@
+import { type BuildServerOptions } from '../server.js';
+/** Serve SDODS over stdio (used by `sdods mcp`). Logs go to stderr only. */
+export declare function serveSdodsStdio(opts?: BuildServerOptions): {
+    close(): Promise<void>;
+};
+//# sourceMappingURL=stdio.d.ts.map

package/dist/transports/stdio.js

@@ -0,0 +1,15 @@
+import { serveStdio } from '@modelcontextprotocol/server/stdio';
+import { buildSdodsMcpServer } from '../server.js';
+/** Serve SDODS over stdio (used by `sdods mcp`). Logs go to stderr only. */
+export function serveSdodsStdio(opts = {}) {
+    const built = buildSdodsMcpServer({
+        ...opts,
+        principal: opts.principal ?? { name: 'local', scopes: ['*'], via: 'stdio' },
+    });
+    built.ctx.logger.info(`serving ${built.toolCount} tools over stdio (caps: ${[...built.ctx.caps].join(',')})`);
+    const handle = serveStdio(() => built.server, {
+        onerror: (e) => built.ctx.logger.warn('stdio error', { message: e?.message ?? String(e) }),
+    });
+    return { close: () => handle.close() };
+}
+//# sourceMappingURL=stdio.js.map

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@sdods/mcp",
+  "version": "0.2.0",
+  "description": "SDODS MCP server: project analysis, runs, results and proposals as tools for AI clients.",
+  "license": "Apache-2.0",
+  "author": "SDODS <admin@sdods.com>",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./registry": "./dist/registry/registry.js",
+    "./server": "./dist/server.js",
+    "./cli": "./dist/cli.js",
+    "./proposals": "./dist/proposals.js",
+    "./prompts": "./dist/prompts/index.js",
+    "./install": "./dist/install/index.js",
+    "./transports/stdio": "./dist/transports/stdio.js",
+    "./transports/http": "./dist/transports/http.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@sdods/contracts": "0.2.0",
+    "@cucumber/gherkin": "^42.0.1",
+    "@cucumber/messages": "^34.2.1",
+    "@modelcontextprotocol/node": "^2.0.0",
+    "@modelcontextprotocol/server": "^2.0.0",
+    "csv-parse": "^7.0.2",
+    "yaml": "^2.9.0",
+    "zod": "^4.5.4",
+    "smol-toml": "^1.8.0"
+  },
+  "homepage": "https://sdods.com",
+  "bugs": {
+    "url": "https://github.com/siri1410/SDODS/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/siri1410/SDODS.git",
+    "directory": "packages/mcp"
+  },
+  "keywords": [
+    "sdods",
+    "automation",
+    "orchestration",
+    "testing",
+    "bdd",
+    "ai-agents",
+    "mcp"
+  ]
+}