@sdods/mcp 0.2.0

package/dist/proposals.js

@@ -0,0 +1,188 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { newId } from '@sdods/contracts';
+import { PROPOSALS_DIR, safeJoin } from './fs.js';
+export class ProposalStore {
+    rootDir;
+    dir;
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+        this.dir = resolve(rootDir, PROPOSALS_DIR);
+    }
+    manifestPath(id) {
+        return join(this.dir, id, 'manifest.json');
+    }
+    create(input) {
+        const stamp = new Date()
+            .toISOString()
+            .replace(/[-:]/g, '')
+            .replace(/\..*/, '')
+            .replace('T', '-');
+        const id = `${stamp}-${input.role}-${newId().slice(-6)}`;
+        const pdir = join(this.dir, id);
+        mkdirSync(join(pdir, 'files'), { recursive: true });
+        const files = [];
+        for (const f of input.files) {
+            const op = f.op ?? (existsSync(resolve(this.rootDir, f.path)) ? 'modify' : 'add');
+            // validate the target path stays inside the repo
+            safeJoin(this.rootDir, f.path);
+            if (op === 'delete') {
+                files.push({ path: f.path, op });
+                continue;
+            }
+            const target = safeJoin(join(pdir, 'files'), f.path);
+            mkdirSync(dirname(target), { recursive: true });
+            writeFileSync(target, f.content ?? '');
+            files.push({ path: f.path, op, from: `files/${f.path}` });
+        }
+        const manifest = {
+            id,
+            role: input.role,
+            project: input.project,
+            env: input.env,
+            createdAt: new Date().toISOString(),
+            status: 'pending',
+            summary: input.summary,
+            costUsd: input.costUsd,
+            model: input.model,
+            files,
+            verification: input.verification ?? { status: 'not-run' },
+        };
+        writeFileSync(this.manifestPath(id), JSON.stringify(manifest, null, 2));
+        return manifest;
+    }
+    list(filter = {}) {
+        if (!existsSync(this.dir))
+            return [];
+        return readdirSync(this.dir)
+            .filter((id) => existsSync(this.manifestPath(id)))
+            .map((id) => this.get(id))
+            .filter((m) => Boolean(m))
+            .filter((m) => (filter.status ? m.status === filter.status : true))
+            .filter((m) => (filter.project ? m.project === filter.project : true))
+            .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    }
+    get(id) {
+        const p = this.manifestPath(id);
+        if (!existsSync(p))
+            return undefined;
+        return JSON.parse(readFileSync(p, 'utf8'));
+    }
+    readFile(id, file) {
+        if (!file.from)
+            return undefined;
+        const p = safeJoin(join(this.dir, id), file.from);
+        return existsSync(p) ? readFileSync(p, 'utf8') : undefined;
+    }
+    /** Unified-ish diff for review (no external dependency). */
+    diff(id) {
+        const m = this.get(id);
+        if (!m)
+            throw new Error(`Unknown proposal ${id}`);
+        const parts = [];
+        for (const f of m.files) {
+            const target = resolve(this.rootDir, f.path);
+            const before = f.op !== 'add' && existsSync(target) ? readFileSync(target, 'utf8') : '';
+            const after = f.op === 'delete' ? '' : (this.readFile(id, f) ?? '');
+            parts.push(`--- ${f.op === 'add' ? '/dev/null' : `a/${f.path}`}\n+++ ${f.op === 'delete' ? '/dev/null' : `b/${f.path}`}`);
+            parts.push(simpleDiff(before, after));
+        }
+        return parts.join('\n');
+    }
+    /** Apply to `targetRoot` (default: the repo). Returns the written paths. */
+    accept(id, opts = {}) {
+        const m = this.get(id);
+        if (!m)
+            throw new Error(`Unknown proposal ${id}`);
+        if (m.status === 'rejected')
+            throw new Error(`Proposal ${id} was rejected`);
+        const root = opts.targetRoot ?? this.rootDir;
+        const written = [];
+        for (const f of m.files) {
+            const target = safeJoin(root, f.path);
+            if (f.op === 'delete') {
+                if (existsSync(target))
+                    rmSync(target);
+                written.push(f.path);
+                continue;
+            }
+            const src = safeJoin(join(this.dir, id), f.from);
+            mkdirSync(dirname(target), { recursive: true });
+            copyFileSync(src, target);
+            written.push(f.path);
+        }
+        m.status = 'accepted';
+        m.reviewedAt = new Date().toISOString();
+        m.reviewedBy = opts.reviewedBy;
+        m.appliedTo = relative(this.rootDir, root) || '.';
+        writeFileSync(this.manifestPath(id), JSON.stringify(m, null, 2));
+        return written;
+    }
+    reject(id, reason, reviewedBy) {
+        const m = this.get(id);
+        if (!m)
+            throw new Error(`Unknown proposal ${id}`);
+        m.status = 'rejected';
+        m.reviewedAt = new Date().toISOString();
+        m.reviewedBy = reviewedBy;
+        m.verification = { ...(m.verification ?? {}), notes: reason ?? m.verification?.notes };
+        writeFileSync(this.manifestPath(id), JSON.stringify(m, null, 2));
+        return m;
+    }
+    sizeOf(id) {
+        const dir = join(this.dir, id, 'files');
+        if (!existsSync(dir))
+            return 0;
+        let total = 0;
+        const stack = [dir];
+        while (stack.length) {
+            const cur = stack.pop();
+            for (const n of readdirSync(cur)) {
+                const p = join(cur, n);
+                const st = statSync(p);
+                if (st.isDirectory())
+                    stack.push(p);
+                else
+                    total += st.size;
+            }
+        }
+        return total;
+    }
+}
+/** Line-based diff with +/- markers (LCS on lines, adequate for review output). */
+export function simpleDiff(before, after) {
+    const a = before === '' ? [] : before.split('\n');
+    const b = after === '' ? [] : after.split('\n');
+    const n = a.length;
+    const m = b.length;
+    const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+    for (let i = n - 1; i >= 0; i--) {
+        for (let j = m - 1; j >= 0; j--) {
+            dp[i][j] = a[i] === b[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
+        }
+    }
+    const out = [];
+    let i = 0;
+    let j = 0;
+    while (i < n && j < m) {
+        if (a[i] === b[j]) {
+            out.push(` ${a[i]}`);
+            i++;
+            j++;
+        }
+        else if (dp[i + 1][j] >= dp[i][j + 1]) {
+            out.push(`-${a[i]}`);
+            i++;
+        }
+        else {
+            out.push(`+${b[j]}`);
+            j++;
+        }
+    }
+    while (i < n)
+        out.push(`-${a[i++]}`);
+    while (j < m)
+        out.push(`+${b[j++]}`);
+    return out.join('\n');
+}
+//# sourceMappingURL=proposals.js.map

package/dist/registry/adapters.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/server';
+import type { ToolRegistry } from './registry.js';
+import { type SdodsTool, type ToolContext } from './registry.js';
+/** Register every visible tool on an MCP v2 server. */
+export declare function toMcpServer(reg: ToolRegistry, server: McpServer, ctx: ToolContext): number;
+/** Plain tool definitions the agents package wraps with the Claude Agent SDK `tool()` helper. */
+export interface AgentSdkToolDef {
+    name: string;
+    description: string;
+    inputSchema: Record<string, z.ZodTypeAny>;
+    /**
+     * Parameters as JSON Schema, for a tool that did not come from a zod shape — a tool bridged
+     * from another MCP server, whose schema is already JSON Schema. When set it wins.
+     */
+    parametersJsonSchema?: Record<string, unknown>;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+    };
+    handler: (args: Record<string, unknown>) => Promise<{
+        content: Array<{
+            type: 'text';
+            text: string;
+        } | {
+            type: 'image';
+            data: string;
+            mimeType: string;
+        }>;
+        isError?: boolean;
+    }>;
+}
+export declare function toAgentSdkTools(reg: ToolRegistry, ctx: ToolContext): AgentSdkToolDef[];
+/** OpenAI-compatible function definitions (chat completions `tools`). */
+export interface OpenAiFunctionDef {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}
+export declare function toOpenAiFunctions(reg: ToolRegistry, ctx?: Pick<ToolContext, 'principal' | 'caps'>): OpenAiFunctionDef[];
+/** JSON schema view of a tool (used by docs generation and tests). */
+export declare function toolJsonSchema(tool: SdodsTool<any>): Record<string, unknown>;
+//# sourceMappingURL=adapters.d.ts.map

package/dist/registry/adapters.js

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import {} from './registry.js';
+/** Register every visible tool on an MCP v2 server. */
+export function toMcpServer(reg, server, ctx) {
+    let count = 0;
+    for (const tool of reg.list(ctx)) {
+        server.registerTool(tool.name, {
+            title: tool.title,
+            description: tool.description,
+            inputSchema: tool.shape,
+            annotations: {
+                readOnlyHint: tool.annotations?.readOnlyHint ?? tool.access === 'read',
+                destructiveHint: tool.annotations?.destructiveHint ?? false,
+                idempotentHint: tool.annotations?.idempotentHint ?? tool.access === 'read',
+                openWorldHint: tool.annotations?.openWorldHint ?? false,
+            },
+            _meta: { access: tool.access, capability: tool.capability },
+        }, async (args, extra) => {
+            const serverCtx = extra;
+            const callCtx = {
+                ...ctx,
+                signal: serverCtx?.signal ?? ctx.signal,
+                onProgress: (p) => {
+                    ctx.onProgress?.(p);
+                    void serverCtx?.mcpReq
+                        ?.log?.('info', p.message ?? `${p.current ?? ''}/${p.total ?? ''}`)
+                        .catch(() => undefined);
+                },
+            };
+            const result = await reg.call(tool.name, args, callCtx);
+            return result;
+        });
+        count++;
+    }
+    return count;
+}
+/** Upper bound for one structured tool result inside an agent conversation. */
+const STRUCTURED_LIMIT = 4000;
+function clip(json) {
+    return json.length <= STRUCTURED_LIMIT
+        ? json
+        : `${json.slice(0, STRUCTURED_LIMIT)}… (${json.length - STRUCTURED_LIMIT} more chars; narrow the query or read the file directly)`;
+}
+export function toAgentSdkTools(reg, ctx) {
+    return reg.list(ctx).map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.shape,
+        annotations: { readOnlyHint: tool.access === 'read', destructiveHint: false },
+        handler: async (args) => {
+            const r = await reg.call(tool.name, args, ctx);
+            const content = [...r.content];
+            // The text content is already clipped by `summarize`; appending the whole structured payload
+            // would put it straight back and grow the conversation without bound, so it is clipped too.
+            if (r.structuredContent)
+                content.push({ type: 'text', text: clip(JSON.stringify(r.structuredContent)) });
+            return { content, isError: r.isError };
+        },
+    }));
+}
+export function toOpenAiFunctions(reg, ctx) {
+    const tools = ctx ? reg.list(ctx) : reg.all();
+    return tools.map((tool) => ({
+        type: 'function',
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: z.toJSONSchema(z.object(tool.shape)),
+        },
+    }));
+}
+/** JSON schema view of a tool (used by docs generation and tests). */
+export function toolJsonSchema(tool) {
+    return z.toJSONSchema(z.object(tool.shape));
+}
+//# sourceMappingURL=adapters.js.map

package/dist/registry/registry.d.ts

@@ -0,0 +1,96 @@
+import { z, type ZodRawShape } from 'zod';
+import { type Scope } from '@sdods/contracts';
+export declare const DOCS_BASE_URL = "https://docs.sdods.com";
+export type ToolAccess = 'read' | 'run' | 'write';
+export type Capability = 'core' | 'analyze' | 'run' | 'data' | 'agents' | 'issues' | 'schedules';
+export declare const ALL_CAPABILITIES: Capability[];
+export declare const DEFAULT_CAPABILITIES: Capability[];
+export interface Principal {
+    userId?: string;
+    name?: string;
+    scopes: string[];
+    via: 'stdio' | 'http';
+}
+export interface ToolLogger {
+    info(msg: string, data?: unknown): void;
+    warn(msg: string, data?: unknown): void;
+    debug(msg: string, data?: unknown): void;
+}
+export interface ToolContext {
+    rootDir: string;
+    cwd: string;
+    principal: Principal;
+    caps: Set<Capability>;
+    /** default project/env when the client did not pass one */
+    project?: string;
+    env?: string;
+    onProgress?: (progress: {
+        message?: string;
+        current?: number;
+        total?: number;
+    }) => void;
+    signal?: AbortSignal;
+    logger: ToolLogger;
+}
+export interface ToolAnnotations {
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+}
+export interface ToolResult {
+    /** human readable summary (markdown) */
+    text: string;
+    /** machine readable payload */
+    data?: unknown;
+    isError?: boolean;
+    /** optional images (base64 PNG) */
+    images?: Array<{
+        data: string;
+        mimeType: string;
+    }>;
+}
+export interface SdodsTool<S extends ZodRawShape = ZodRawShape> {
+    name: string;
+    title: string;
+    description: string;
+    shape: S;
+    access: ToolAccess;
+    /** scope domain: projects, features, runs, datasets, agents, integrations, schedules … */
+    domain: string;
+    capability: Capability;
+    annotations?: ToolAnnotations;
+    docsPath?: string;
+    handler: (args: z.infer<z.ZodObject<S>>, ctx: ToolContext) => Promise<ToolResult>;
+}
+export interface McpToolResultShape {
+    content: Array<{
+        type: 'text';
+        text: string;
+    } | {
+        type: 'image';
+        data: string;
+        mimeType: string;
+    }>;
+    structuredContent?: Record<string, unknown>;
+    isError?: boolean;
+    _meta?: Record<string, unknown>;
+}
+export declare function defineTool<S extends ZodRawShape>(tool: SdodsTool<S>): SdodsTool<S>;
+export declare function requiredScope(tool: SdodsTool<any>): Scope | null;
+export declare class ToolRegistry {
+    private readonly tools;
+    register<S extends ZodRawShape>(tool: SdodsTool<S>): this;
+    registerAll(tools: Array<SdodsTool<any>>): this;
+    get(name: string): SdodsTool<any> | undefined;
+    all(): SdodsTool<any>[];
+    /** Tools visible to a principal with the given capabilities (scope + capability gating). */
+    list(ctx: Pick<ToolContext, 'principal' | 'caps'>): SdodsTool<any>[];
+    isAllowed(tool: SdodsTool<any>, ctx: Pick<ToolContext, 'principal' | 'caps'>): boolean;
+    call(name: string, rawArgs: unknown, ctx: ToolContext): Promise<McpToolResultShape>;
+}
+export declare function toMcpResult(tool: SdodsTool<any>, result: ToolResult): McpToolResultShape;
+export declare function errorResult(message: string, data?: Record<string, unknown>): McpToolResultShape;
+/** Summarise a JSON payload for the text part of a result. */
+export declare function summarize(title: string, data: unknown, max?: number): string;
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry/registry.js

@@ -0,0 +1,141 @@
+import { z } from 'zod';
+import { hasScope, isScope, scopeForToolAccess } from '@sdods/contracts';
+export const DOCS_BASE_URL = 'https://docs.sdods.com';
+export const ALL_CAPABILITIES = [
+    'core',
+    'analyze',
+    'run',
+    'data',
+    'agents',
+    'issues',
+    'schedules',
+];
+export const DEFAULT_CAPABILITIES = ['core', 'analyze', 'run', 'data', 'schedules'];
+export function defineTool(tool) {
+    return tool;
+}
+export function requiredScope(tool) {
+    // agents has no read/write pair: run → agents:run, review/apply → agents:review
+    if (tool.domain === 'agents')
+        return tool.access === 'run' ? 'agents:run' : 'agents:review';
+    return scopeForToolAccess(tool.access, tool.domain);
+}
+export class ToolRegistry {
+    tools = new Map();
+    register(tool) {
+        if (this.tools.has(tool.name))
+            throw new Error(`Tool already registered: ${tool.name}`);
+        this.tools.set(tool.name, tool);
+        return this;
+    }
+    registerAll(tools) {
+        for (const t of tools)
+            this.register(t);
+        return this;
+    }
+    get(name) {
+        return this.tools.get(name);
+    }
+    all() {
+        return [...this.tools.values()];
+    }
+    /** Tools visible to a principal with the given capabilities (scope + capability gating). */
+    list(ctx) {
+        return this.all().filter((t) => this.isAllowed(t, ctx));
+    }
+    isAllowed(tool, ctx) {
+        if (!ctx.caps.has(tool.capability))
+            return false;
+        const scope = requiredScope(tool);
+        if (!scope)
+            return true;
+        if (!isScope(scope))
+            return true;
+        return hasScope(ctx.principal.scopes, scope);
+    }
+    async call(name, rawArgs, ctx) {
+        const tool = this.tools.get(name);
+        if (!tool) {
+            return errorResult(`Unknown tool: ${name}`, { code: 'UNKNOWN_TOOL' });
+        }
+        if (!ctx.caps.has(tool.capability)) {
+            return errorResult(`Tool ${name} requires capability "${tool.capability}" (start with --caps ${tool.capability}).`, {
+                code: 'CAPABILITY_DISABLED',
+            });
+        }
+        const scope = requiredScope(tool);
+        if (scope && isScope(scope) && !hasScope(ctx.principal.scopes, scope)) {
+            return errorResult(`Insufficient scope: ${name} requires ${scope}.`, {
+                code: 'INSUFFICIENT_SCOPE',
+                scope,
+            });
+        }
+        const parsed = z.object(tool.shape).safeParse(rawArgs ?? {});
+        if (!parsed.success) {
+            return errorResult(`Invalid arguments for ${name}: ${parsed.error.issues.map((i) => `${i.path.join('.') || '<root>'}: ${i.message}`).join('; ')}`, {
+                code: 'INVALID_ARGS',
+                issues: parsed.error.issues,
+            });
+        }
+        try {
+            const result = await tool.handler(parsed.data, ctx);
+            return toMcpResult(tool, result);
+        }
+        catch (e) {
+            const err = e;
+            ctx.logger.warn(`tool ${name} failed`, { message: err.message });
+            return errorResult(err.message, {
+                code: err.error?.code ?? 'TOOL_FAILED',
+                hint: err.error?.hint,
+                exitCode: err.exitCode,
+            });
+        }
+    }
+}
+export function toMcpResult(tool, result) {
+    const content = [{ type: 'text', text: result.text }];
+    for (const img of result.images ?? [])
+        content.push({ type: 'image', data: img.data, mimeType: img.mimeType });
+    const structured = toStructured(result.data);
+    return {
+        content,
+        ...(structured ? { structuredContent: structured } : {}),
+        ...(result.isError ? { isError: true } : {}),
+        _meta: {
+            docsUrl: `${DOCS_BASE_URL}${tool.docsPath ?? '/docs/reference/mcp-tools'}#${tool.name.replace(/_/g, '-')}`,
+            access: tool.access,
+            capability: tool.capability,
+        },
+    };
+}
+function toStructured(data) {
+    if (data === undefined)
+        return undefined;
+    if (Array.isArray(data))
+        return { items: data };
+    if (data && typeof data === 'object')
+        return data;
+    return { value: data };
+}
+export function errorResult(message, data = {}) {
+    const code = typeof data.code === 'string' ? data.code : 'TOOL_FAILED';
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Error [${code}]: ${message}${data.hint ? `\nHint: ${String(data.hint)}` : ''}`,
+            },
+        ],
+        structuredContent: { error: { message, ...data } },
+        isError: true,
+    };
+}
+/** Summarise a JSON payload for the text part of a result. */
+export function summarize(title, data, max = 4000) {
+    const body = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
+    const clipped = body.length > max
+        ? body.slice(0, max) + `\n… (${body.length - max} more chars in structuredContent)`
+        : body;
+    return `${title}\n\n\`\`\`json\n${clipped}\n\`\`\``;
+}
+//# sourceMappingURL=registry.js.map

package/dist/resources.d.ts

@@ -0,0 +1,5 @@
+import type { McpServer } from '@modelcontextprotocol/server';
+import type { ToolContext } from './registry/registry.js';
+/** MCP resources: features, run summaries, NDJSON, screenshots and proposals. */
+export declare function registerResources(server: McpServer, ctx: ToolContext): void;
+//# sourceMappingURL=resources.d.ts.map

package/dist/resources.js

@@ -0,0 +1,130 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ResourceTemplate } from '@modelcontextprotocol/server';
+import { runFiles } from '@sdods/contracts';
+import { getRun, listRuns, projectRoot, safeJoin, walk } from './fs.js';
+import { ProposalStore } from './proposals.js';
+/** MCP resources: features, run summaries, NDJSON, screenshots and proposals. */
+export function registerResources(server, ctx) {
+    server.registerResource('feature', new ResourceTemplate('sdods://project/{slug}/features/{+path}', {
+        list: async () => {
+            const resources = [];
+            const projectsDir = join(ctx.rootDir, process.env.SDODS_PROJECTS_DIR ?? 'projects');
+            for (const f of walk(projectsDir, (x) => x.endsWith('.feature'), 500)) {
+                const rel = f.slice(projectsDir.length + 1).replace(/\\/g, '/');
+                const [slug, ...rest] = rel.split('/');
+                if (!slug || rest[0] !== 'features')
+                    continue;
+                resources.push({
+                    uri: `sdods://project/${slug}/features/${rest.slice(1).join('/')}`,
+                    name: rel,
+                    mimeType: 'text/x-gherkin',
+                });
+            }
+            return { resources };
+        },
+    }), {
+        title: 'Feature file',
+        description: 'Gherkin feature files per project',
+        mimeType: 'text/x-gherkin',
+    }, async (uri, variables) => {
+        const slug = String(variables.slug);
+        const path = String(variables.path);
+        const file = safeJoin(join(projectRoot(ctx.rootDir, slug), 'features'), path);
+        if (!existsSync(file))
+            throw new Error(`No such feature: ${path}`);
+        return {
+            contents: [{ uri: uri.href, mimeType: 'text/x-gherkin', text: readFileSync(file, 'utf8') }],
+        };
+    });
+    server.registerResource('run-summary', new ResourceTemplate('sdods://run/{runId}/summary', {
+        list: async () => ({
+            resources: listRuns(ctx.rootDir, 50).map((r) => ({
+                uri: `sdods://run/${r.runId}/summary`,
+                name: `run ${r.runId}`,
+                mimeType: 'application/json',
+            })),
+        }),
+    }), {
+        title: 'Run summary',
+        description: 'run.json + summary.json of a run',
+        mimeType: 'application/json',
+    }, async (uri, variables) => {
+        const run = getRun(ctx.rootDir, String(variables.runId));
+        if (!run)
+            throw new Error(`Unknown run ${String(variables.runId)}`);
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: 'application/json',
+                    text: JSON.stringify({ manifest: run.manifest, summary: run.summary }, null, 2),
+                },
+            ],
+        };
+    });
+    server.registerResource('run-messages', new ResourceTemplate('sdods://run/{runId}/messages.ndjson', { list: undefined }), {
+        title: 'Cucumber messages',
+        description: 'NDJSON messages of a run',
+        mimeType: 'application/x-ndjson',
+    }, async (uri, variables) => {
+        const run = getRun(ctx.rootDir, String(variables.runId));
+        const file = run ? join(run.dir, runFiles.messages) : undefined;
+        if (!file || !existsSync(file))
+            throw new Error(`No messages for run ${String(variables.runId)}`);
+        return {
+            contents: [
+                { uri: uri.href, mimeType: 'application/x-ndjson', text: readFileSync(file, 'utf8') },
+            ],
+        };
+    });
+    server.registerResource('screenshot', new ResourceTemplate('sdods://screenshot/{runId}/{fingerprint}/{retry}/{file}', {
+        list: undefined,
+    }), {
+        title: 'Screenshot',
+        description: 'Before/after and scenario screenshots of a run',
+        mimeType: 'image/png',
+    }, async (uri, variables) => {
+        const run = getRun(ctx.rootDir, String(variables.runId));
+        if (!run)
+            throw new Error(`Unknown run ${String(variables.runId)}`);
+        const slug = run.manifest?.projectSlug;
+        const base = slug ? join(run.dir, slug) : run.dir;
+        const file = safeJoin(base, `${String(variables.fingerprint)}/r${String(variables.retry)}/${String(variables.file)}`);
+        if (!existsSync(file))
+            throw new Error(`No such screenshot: ${String(variables.file)}`);
+        return {
+            contents: [
+                { uri: uri.href, mimeType: 'image/png', blob: readFileSync(file).toString('base64') },
+            ],
+        };
+    });
+    server.registerResource('proposal', new ResourceTemplate('sdods://proposal/{id}', {
+        list: async () => ({
+            resources: new ProposalStore(ctx.rootDir).list().map((p) => ({
+                uri: `sdods://proposal/${p.id}`,
+                name: p.summary,
+                mimeType: 'application/json',
+            })),
+        }),
+    }), {
+        title: 'Proposal',
+        description: 'Agent proposal manifest and diff',
+        mimeType: 'application/json',
+    }, async (uri, variables) => {
+        const store = new ProposalStore(ctx.rootDir);
+        const m = store.get(String(variables.id));
+        if (!m)
+            throw new Error(`Unknown proposal ${String(variables.id)}`);
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: 'application/json',
+                    text: JSON.stringify({ ...m, diff: store.diff(m.id) }, null, 2),
+                },
+            ],
+        };
+    });
+}
+//# sourceMappingURL=resources.js.map