@opencraw/mcp 0.1.44 → 0.1.47

package/dist/index.esm.js

@@ -1,8 +1,13 @@
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { readRecordsFile, diffRecords, memorySink, jsonLinesSink, createCrawler, RecipeSet, RecipeValidationError, RecipeBindingError, parseOutputRecipe, parseInputRecipe, bindRecipeSet } from '@opencraw/core';
+import { readRecordsFile, diffRecords, memorySink, fileSink, createCrawler, RecipeSet, RecipeValidationError, RecipeBindingError, parseOutputRecipe, parseInputRecipe, bindRecipeSet } from '@opencraw/core';
 import { diffReport, readRecipeFiles, probeUrl, loadForRun, loadPlugins, resolveAccess } from '@opencraw/cli';
 import { z } from 'zod';
+import { readdir, readFile } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
 
 /** Changes returned at most; the counts cover all of them. */
 const CHANGE_LIMIT = 200;
@@ -56,6 +61,191 @@ async function diffTool(args) {
   }
 }
 
+/**
+ * The topic id of a documentation file: its path under the docs folder, without the extension and with forward slashes, so `recipes/authoring.md` is
+ * `recipes/authoring`.
+ *
+ * @param relativePath - The file's path under the docs folder.
+ * @returns The id.
+ */
+function topicIdOf(relativePath) {
+  return relativePath.replaceAll('\\', '/').replace(/\.md$/i, '');
+}
+/**
+ * The title of a document: its first top-level heading, else its id.
+ *
+ * @param markdown - The document.
+ * @param fallback - The id, when there is no heading.
+ * @returns The title.
+ */
+function titleOf(markdown, fallback) {
+  const heading = outlineOf(markdown).find(candidate => candidate.level === 1);
+  return heading?.text ?? fallback;
+}
+/**
+ * Every heading of a Markdown document, in order. A line inside a fenced code block is not a heading (a shell comment starts with `#` too).
+ *
+ * @param markdown - The document.
+ * @returns The headings.
+ */
+function outlineOf(markdown) {
+  const headings = [];
+  let fence;
+  for (const [line, text] of markdown.split(/\r?\n/).entries()) {
+    const marker = /^\s*(`{3,}|~{3,})/.exec(text)?.[1];
+    if (marker !== undefined) {
+      if (fence === undefined) fence = marker[0];else if (marker[0] === fence) fence = undefined;
+      continue;
+    }
+    if (fence !== undefined) continue;
+    const match = /^(#{1,6}) (.+)$/.exec(text);
+    if (match !== null) headings.push({
+      level: match[1].length,
+      text: match[2].trim().replace(/ #+$/, ''),
+      line
+    });
+  }
+  return headings;
+}
+/**
+ * One section of a document: from the heading whose text contains `heading` (case-insensitive; an exact match wins over a partial one) to the next
+ * heading of the same or a higher level, so its subsections come with it.
+ *
+ * @param markdown - The document.
+ * @param heading - What the heading says, or part of it.
+ * @returns The section's text, or `undefined` when no heading matches.
+ */
+function sectionOf(markdown, heading) {
+  const wanted = heading.trim().toLowerCase();
+  const headings = outlineOf(markdown);
+  const start = headings.find(candidate => candidate.text.toLowerCase() === wanted) ?? headings.find(candidate => candidate.text.toLowerCase().includes(wanted));
+  if (start === undefined) return undefined;
+  const end = headings.find(candidate => candidate.line > start.line && candidate.level <= start.level);
+  const lines = markdown.split(/\r?\n/);
+  return lines.slice(start.line, end?.line ?? lines.length).join('\n').trim();
+}
+
+/** The folders under the docs folder whose Markdown files are documentation for a person (or an agent) using OpenCraw. */
+const FOLDERS = ['recipes', 'how-it-works', 'studio'];
+/**
+ * The documents under a docs folder: the Markdown files directly inside `recipes`, `how-it-works` and `studio` (their pictures and capture scripts are
+ * not documentation to read).
+ *
+ * @param root - The docs folder.
+ * @returns The topics, ordered by id.
+ */
+async function listTopics(root) {
+  const topics = [];
+  for (const folder of FOLDERS) {
+    let names;
+    try {
+      names = await readdir(join(root, folder));
+    } catch {
+      continue;
+    }
+    const documents = names.filter(file => file.toLowerCase().endsWith('.md'));
+    for (const name of documents) {
+      const id = topicIdOf(`${folder}/${name}`);
+      const text = await readFile(join(root, folder, name), 'utf8');
+      topics.push({
+        id,
+        title: titleOf(text, id),
+        size: text.length
+      });
+    }
+  }
+  return topics.sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+ * One document's text.
+ *
+ * @param root - The docs folder.
+ * @param id - The topic id from `listTopics` (never a path: nothing outside the listed folders is read).
+ * @returns The Markdown, or `undefined` when there is no such topic.
+ */
+async function readTopic(root, id) {
+  const known = await listTopics(root);
+  if (known.every(topic => topic.id !== id)) return undefined;
+  return await readFile(join(root, `${id}.md`), 'utf8');
+}
+
+/** Input schema for the `docs` tool. */
+const docsInputShape = {
+  topic: z.string().optional().describe('A document id from the list this tool returns without a topic (`recipes/authoring`, `how-it-works/06-documents`, `studio/manual`…). Leave out to list every document.'),
+  section: z.string().optional().describe('A heading (or part of one) of that document: only that section comes back, subsections included. A long document answers with its outline until you ask for a section.')
+};
+/** A document longer than this many characters comes back as its outline, and the section asked for. */
+const WHOLE_DOCUMENT_LIMIT = 30_000;
+function text$1(value, isError = false) {
+  return {
+    content: [{
+      type: 'text',
+      text: typeof value === 'string' ? value : JSON.stringify(value)
+    }],
+    ...(isError && {
+      isError
+    }),
+    ...(typeof value === 'object' && value !== null && {
+      structuredContent: value
+    })
+  };
+}
+/**
+ * The `docs` tool: OpenCraw's own documentation, for an agent that has to write recipes right: the authoring guide (every step, selector, transform
+ * and policy), how it all works, the examples and the Studio manual. Without a topic it lists what there is; with one it gives the document, or just
+ * the section asked for, so a long guide costs only what is read.
+ *
+ * @param args - The tool's parsed input.
+ * @param root - The docs folder (the packaged copy, or the repository's).
+ * @returns The MCP tool result.
+ */
+async function docsTool(args, root) {
+  const topics = await listTopics(root);
+  if (topics.length === 0) return text$1('The documentation is not installed with this server.', true);
+  if (args.topic === undefined) return text$1({
+    topics,
+    hint: 'Ask for one with { topic }, and for part of a long one with { topic, section }.'
+  });
+  const document = await readTopic(root, args.topic);
+  if (document === undefined) {
+    const close = topics.filter(topic => topic.id.includes(args.topic?.toLowerCase() ?? '') || args.topic?.includes(topic.id) === true).map(topic => topic.id);
+    return text$1(`There is no document "${args.topic}". ${close.length > 0 ? `Did you mean: ${close.join(', ')}?` : `The documents are: ${topics.map(topic => topic.id).join(', ')}.`}`, true);
+  }
+  if (args.section !== undefined) {
+    const section = sectionOf(document, args.section);
+    return section === undefined ? text$1({
+      topic: args.topic,
+      error: `no heading contains "${args.section}"`,
+      outline: outlineOf(document).map(heading => `${'#'.repeat(heading.level)} ${heading.text}`)
+    }, true) : text$1({
+      topic: args.topic,
+      section: args.section,
+      text: section
+    });
+  }
+  if (document.length <= WHOLE_DOCUMENT_LIMIT) return text$1({
+    topic: args.topic,
+    text: document
+  });
+  return text$1({
+    topic: args.topic,
+    outline: outlineOf(document).map(heading => `${'#'.repeat(heading.level)} ${heading.text}`),
+    note: `This document is ${String(document.length)} characters: ask for a section with { topic, section } using a heading from the outline.`
+  });
+}
+
+/**
+ * Where the documentation is: a `docs` folder beside `dist` in the installed package (copied there at build), or the repository's own `docs` when the server runs
+ * from a checkout.
+ *
+ * @returns The docs folder.
+ */
+function docsRoot() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [join(here, '..', 'docs'), join(here, '..', '..', '..', 'docs')];
+  return candidates.find(candidate => existsSync(join(candidate, 'recipes'))) ?? candidates[0];
+}
+
 /** Input schema for the `list_recipes` tool. */
 const listRecipesInputShape = {
   dir: z.string().describe('A directory of recipe files.')
@@ -173,7 +363,7 @@ const RECORD_CAP = 50;
 /** Input schema for the `run` tool. */
 const runInputShape = {
   ...recipeSourceShape,
-  out: z.string().optional().describe('Write records to this JSON Lines file instead of returning them inline. Use for a crawl expected to produce more than a handful of records.'),
+  out: z.string().optional().describe('Write records to this file instead of returning them inline; its extension is the format: .jsonl, .json, .csv, .xlsx, .yml/.yaml, .html or .pdf (any other extension is an error). Use for a crawl expected to produce more than a handful of records.'),
   append: z.boolean().optional().describe('Keep what "out" holds and add to it; each line carries _key. Needs "out".'),
   resume: z.boolean().optional().describe('Skip records "out" already has. Needs "append".'),
   only: z.array(z.string()).optional().describe('Run only these input recipe ids.'),
@@ -216,9 +406,23 @@ async function runTool(args) {
     };
   }
   let crawler;
-  const sink = args.dryRun === true || args.out === undefined ? memorySink() : jsonLinesSink(args.out, {
-    append: args.append
-  });
+  let sink;
+  try {
+    sink = args.dryRun === true || args.out === undefined ? memorySink() : fileSink(args.out, {
+      append: args.append,
+      browser: {
+        executablePath: args.browserPath ?? process.env.OPENCRAW_CHROMIUM
+      }
+    });
+  } catch (error) {
+    return {
+      content: [{
+        type: 'text',
+        text: error instanceof Error ? error.message : String(error)
+      }],
+      isError: true
+    };
+  }
   try {
     const pluginsFile = serverFile('OPENCRAW_PLUGINS') ?? serverFile('OPENCRAW_HOOKS');
     const plugins = pluginsFile === undefined ? undefined : await loadPlugins(pluginsFile);
@@ -294,6 +498,229 @@ function loadErrorText(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
+/**
+ * Sends one command to a running Studio (`POST /api/command`, the same door its own page uses) and reads the answer.
+ *
+ * @param instance - The Studio to talk to.
+ * @param command - A command `@opencraw/studio`'s `studioCommandSchema` accepts.
+ * @returns The JSON the Studio answered.
+ * @throws Error with the Studio's own message when it refuses.
+ */
+async function sendStudioCommand(instance, command) {
+  const response = await fetch(`${instance.url}/api/command`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      'x-opencraw-token': instance.token
+    },
+    body: JSON.stringify(command)
+  });
+  const body = await response.json();
+  if (!response.ok) throw new Error(body.error ?? `Studio answered ${String(response.status)}`);
+  return body;
+}
+
+/** Where running Studios announce themselves. */
+function instancesDirectory() {
+  return join(homedir(), '.opencraw', 'studio');
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    // EPERM: the process exists but is not ours to signal.
+    return error.code === 'EPERM';
+  }
+}
+function instanceOf(text) {
+  try {
+    const value = JSON.parse(text);
+    return typeof value.pid === 'number' && typeof value.url === 'string' && typeof value.token === 'string' && typeof value.startedAt === 'string' ? {
+      pid: value.pid,
+      url: value.url,
+      token: value.token,
+      folder: value.folder,
+      startedAt: value.startedAt
+    } : undefined;
+  } catch {
+    return undefined;
+  }
+}
+/** The announcement files in a directory; none when it does not exist yet. */
+async function namesIn(directory) {
+  try {
+    const names = await readdir(directory);
+    return names.filter(file => file.endsWith('.json'));
+  } catch {
+    return [];
+  }
+}
+/** A file's text; empty when it vanished (its Studio just stopped). */
+async function textOf(file) {
+  try {
+    return await readFile(file, 'utf8');
+  } catch {
+    return '';
+  }
+}
+/**
+ * The Studios running on this machine, the newest first. A file whose process is gone (Studio was killed
+ * and could not withdraw it) is left out.
+ *
+ * @param directory - Where Studios announce themselves.
+ * @returns The live Studios.
+ */
+async function runningStudios(directory = instancesDirectory()) {
+  const found = [];
+  const names = await namesIn(directory);
+  for (const name of names) {
+    const instance = instanceOf(await textOf(join(directory, name)));
+    if (instance !== undefined && isAlive(instance.pid)) found.push(instance);
+  }
+  return found.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+}
+
+/** Input schema for `studio_status`: nothing. */
+const studioStatusInputShape = {};
+/** Input schema for `studio_open_recipe`. */
+const studioOpenRecipeInputShape = {
+  path: z.string().min(1).describe('A recipe file (`*.input.json` / `*.ocw-in.json`), a folder of recipes, or a document, as an absolute path.'),
+  workspace: z.string().optional().describe('The folder a document belongs to, when `path` is a document.')
+};
+/** Input schema for `studio_run_sample`. */
+const studioRunSampleInputShape = {
+  recipeId: z.string().min(1).describe('The id of an input recipe in the folder Studio has open.'),
+  maxRecords: z.number().int().positive().optional().describe('Stop after this many records. Default 10.'),
+  waitSeconds: z.number().int().positive().max(300).optional().describe('How long to wait for the run to finish before answering that it is still running. Default 60.')
+};
+const NO_STUDIO = 'No Studio is running. Start one with `opencraw studio <folder>`, or open a recipe from the OpenCraw view in VS Code ("Open in Studio"), then ask again.';
+const POLL_MS = 500;
+function text(value, isError = false) {
+  return {
+    content: [{
+      type: 'text',
+      text: typeof value === 'string' ? value : JSON.stringify(value)
+    }],
+    ...(isError && {
+      isError
+    }),
+    ...(typeof value === 'object' && value !== null && {
+      structuredContent: value
+    })
+  };
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function studioOf(directory) {
+  const [newest] = await runningStudios(directory);
+  return newest;
+}
+/**
+ * `studio_status`: whether a Studio is running, which folder it has open, how many pages are watching and what it is running.
+ *
+ * @param directory - Where Studios announce themselves; the default is the user's own.
+ * @returns The MCP tool result.
+ */
+async function studioStatusTool(directory) {
+  const studio = await studioOf(directory);
+  if (studio === undefined) return text({
+    running: false,
+    hint: NO_STUDIO
+  });
+  try {
+    const status = await sendStudioCommand(studio, {
+      type: 'studio-status'
+    });
+    return text({
+      running: true,
+      url: studio.url,
+      ...status
+    });
+  } catch (error) {
+    return text(`Studio did not answer: ${messageOf(error)}`, true);
+  }
+}
+/**
+ * `studio_open_recipe`: opens a recipe, a folder or a document in the Studio the person is looking at, so they watch the work happen.
+ *
+ * @param args - What to open.
+ * @param directory - Where Studios announce themselves.
+ * @returns The MCP tool result.
+ */
+async function studioOpenRecipeTool(args, directory) {
+  const studio = await studioOf(directory);
+  if (studio === undefined) return text(NO_STUDIO, true);
+  try {
+    const {
+      pages
+    } = await sendStudioCommand(studio, {
+      type: 'ask-ui',
+      request: {
+        kind: 'open',
+        path: args.path,
+        workspace: args.workspace
+      }
+    });
+    if (pages === 0) return text({
+      opened: false,
+      hint: 'Studio is running but no page is open on it. Ask the person to open Studio in their browser.',
+      url: studio.url
+    });
+    return text({
+      opened: true,
+      pages
+    });
+  } catch (error) {
+    return text(`Studio refused: ${messageOf(error)}`, true);
+  }
+}
+/**
+ * `studio_run_sample`: runs an input recipe as a sample in Studio (the person sees the records arrive), waits for it, and returns the
+ * counts and the first records.
+ *
+ * @param args - The recipe, how many records to stop at and how long to wait.
+ * @param directory - Where Studios announce themselves.
+ * @returns The MCP tool result.
+ */
+async function studioRunSampleTool(args, directory) {
+  const studio = await studioOf(directory);
+  if (studio === undefined) return text(NO_STUDIO, true);
+  try {
+    const {
+      folder
+    } = await sendStudioCommand(studio, {
+      type: 'studio-status'
+    });
+    if (folder === undefined) return text('Studio has no folder open yet. Call studio_open_recipe with a recipe file or a folder first.', true);
+    await sendStudioCommand(studio, {
+      type: 'run-sample',
+      recipeId: args.recipeId,
+      budget: {
+        maxRecords: args.maxRecords ?? 10
+      }
+    });
+    const deadline = Date.now() + (args.waitSeconds ?? 60) * 1000;
+    for (;;) {
+      const status = await sendStudioCommand(studio, {
+        type: 'run-status',
+        recipeId: args.recipeId
+      });
+      if (status.state !== 'running') return text(status);
+      if (Date.now() >= deadline) return text({
+        ...status,
+        hint: 'Still running; ask again with studio_run_sample or look in Studio.'
+      });
+      await new Promise(resolve => {
+        setTimeout(resolve, POLL_MS);
+      });
+    }
+  } catch (error) {
+    return text(`Studio could not run it: ${messageOf(error)}`, true);
+  }
+}
+
 /** Input schema for the `validate` tool. */
 const validateInputShape = recipeSourceShape;
 /**
@@ -394,7 +821,7 @@ const SERVER_INFO = {
 };
 /**
  * Builds the MCP server: one tool per crawl primitive (`probe`, `validate`,
- * `run`, `list_recipes`, `diff`), each a thin wrapper over `@opencraw/core` and
+ * `run`, `list_recipes`, `diff`), `docs` and the `studio_` tools that drive a running Studio, each a thin wrapper over `@opencraw/core` and
  * `@opencraw/cli`'s structured helpers. No transport is attached; `main`
  * connects it over stdio.
  *
@@ -422,6 +849,22 @@ function createServer() {
     description: 'Compare two runs\' JSON Lines files by record key: what was added, removed, and changed (each field before and after). Use to report what changed in a source since the last crawl.',
     inputSchema: diffInputShape
   }, args => diffTool(args));
+  server.registerTool('docs', {
+    description: 'OpenCraw\'s own documentation: the authoring guide (every step, selector, transform and policy), how it works, the examples and the Studio manual. Without a topic it lists the documents; with one it gives the document, or just a section of it. Read the guide before writing a recipe you are not sure of, instead of guessing.',
+    inputSchema: docsInputShape
+  }, args => docsTool(args, docsRoot()));
+  server.registerTool('studio_status', {
+    description: 'Whether OpenCraw Studio is running on this machine, which folder it has open, how many pages are watching and which recipe it is sampling. Call it before the other studio_ tools.',
+    inputSchema: studioStatusInputShape
+  }, () => studioStatusTool());
+  server.registerTool('studio_open_recipe', {
+    description: 'Open a recipe, a folder of recipes or a document in the Studio the person has open, so they watch the recipe being built. Does nothing to the files.',
+    inputSchema: studioOpenRecipeInputShape
+  }, args => studioOpenRecipeTool(args));
+  server.registerTool('studio_run_sample', {
+    description: 'Run an input recipe as a sample in Studio (the person sees the records arrive) and get back the counts, the first records and what was rejected. Studio must have the folder of that recipe open: call studio_open_recipe first.',
+    inputSchema: studioRunSampleInputShape
+  }, args => studioRunSampleTool(args));
   return server;
 }
 

package/dist/list-tool/index.d.ts

@@ -0,0 +1,3 @@
+export { listRecipesTool, listRecipesInputShape } from './list-recipes-tool.handler';
+export type { ListRecipesResult } from './list-recipes-tool.handler';
+//# sourceMappingURL=index.d.ts.map

package/dist/list-tool/list-recipes-tool.handler.d.ts

@@ -0,0 +1,32 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+/** Input schema for the `list_recipes` tool. */
+export declare const listRecipesInputShape: {
+    dir: z.ZodString;
+};
+/** What the `list_recipes` tool returns. */
+export interface ListRecipesResult {
+    outputs: {
+        path: string;
+        id?: string;
+    }[];
+    inputs: {
+        path: string;
+        id?: string;
+        output?: string;
+        mode?: string;
+    }[];
+    others: string[];
+}
+/**
+ * The `list_recipes` tool: what recipes already exist in a directory, cheaper
+ * than a full `validate` call, so an agent can check before writing a new one
+ * or find what an existing output recipe already covers.
+ *
+ * @param args - The tool's parsed input.
+ * @returns The MCP tool result.
+ */
+export declare function listRecipesTool(args: {
+    dir: string;
+}): Promise<CallToolResult>;
+//# sourceMappingURL=list-recipes-tool.handler.d.ts.map

package/dist/main.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Runs the server over stdio until the transport closes. This is what
+ * `bin/opencraw-mcp.mjs` calls; an MCP host launches it as a subprocess and
+ * talks JSON-RPC over stdin/stdout, so there is no argv to parse.
+ */
+export declare function main(): Promise<void>;
+//# sourceMappingURL=main.d.ts.map

package/dist/probe-tool/index.d.ts

@@ -0,0 +1,2 @@
+export { probeTool, probeInputShape } from './probe-tool.handler';
+//# sourceMappingURL=index.d.ts.map

package/dist/probe-tool/probe-tool.handler.d.ts

@@ -0,0 +1,27 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+/** Input schema for the `probe` tool: a raw zod shape, as `McpServer.registerTool` expects. */
+export declare const probeInputShape: {
+    url: z.ZodString;
+    browser: z.ZodOptional<z.ZodBoolean>;
+    browserPath: z.ZodOptional<z.ZodString>;
+    insecureTls: z.ZodOptional<z.ZodBoolean>;
+    userAgent: z.ZodOptional<z.ZodString>;
+    access: z.ZodOptional<z.ZodString>;
+};
+/**
+ * The `probe` tool: fetches a page and reports where its data lives, so an
+ * agent can write an extraction recipe without guessing selectors.
+ *
+ * @param args - The tool's parsed input.
+ * @returns The MCP tool result: the probe findings as JSON text.
+ */
+export declare function probeTool(args: {
+    url: string;
+    browser?: boolean;
+    browserPath?: string;
+    insecureTls?: boolean;
+    userAgent?: string;
+    access?: string;
+}): Promise<CallToolResult>;
+//# sourceMappingURL=probe-tool.handler.d.ts.map

package/dist/recipe-source/index.d.ts

@@ -0,0 +1,3 @@
+export { recipeSourceShape, recipeSourceOf } from './recipe-source.mapper';
+export type { RecipeSourceArgs } from './recipe-source.mapper';
+//# sourceMappingURL=index.d.ts.map

package/dist/recipe-source/recipe-source.mapper.d.ts

@@ -0,0 +1,21 @@
+import type { RecipeSource } from '@opencraw/core';
+import { z } from 'zod';
+/** The two ways a tool takes recipes: files, or the recipes themselves. */
+export declare const recipeSourceShape: {
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    recipes: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>>;
+};
+/** A tool's recipe arguments. */
+export interface RecipeSourceArgs {
+    paths?: string[];
+    recipes?: string | Record<string, unknown>[];
+}
+/**
+ * The recipe source a tool call names.
+ *
+ * @param args - The tool's parsed input.
+ * @returns What core reads: the paths, or the inline recipes.
+ * @throws Error when the call gives both or neither.
+ */
+export declare function recipeSourceOf(args: RecipeSourceArgs): RecipeSource;
+//# sourceMappingURL=recipe-source.mapper.d.ts.map

package/dist/run-tool/index.d.ts

@@ -0,0 +1,3 @@
+export { runTool, runInputShape } from './run-tool.handler';
+export type { RunResult } from './run-tool.handler';
+//# sourceMappingURL=index.d.ts.map

package/dist/run-tool/run-tool.handler.d.ts

@@ -0,0 +1,51 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { CrawlReport } from '@opencraw/core';
+import { z } from 'zod';
+import type { RecipeSourceArgs } from '../recipe-source';
+/** Input schema for the `run` tool. */
+export declare const runInputShape: {
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    recipes: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>>;
+    out: z.ZodOptional<z.ZodString>;
+    append: z.ZodOptional<z.ZodBoolean>;
+    resume: z.ZodOptional<z.ZodBoolean>;
+    only: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+    headed: z.ZodOptional<z.ZodBoolean>;
+    browserPath: z.ZodOptional<z.ZodString>;
+    insecureTls: z.ZodOptional<z.ZodBoolean>;
+    userAgent: z.ZodOptional<z.ZodString>;
+    access: z.ZodOptional<z.ZodString>;
+    parallel: z.ZodOptional<z.ZodInt>;
+};
+interface RunArgs extends RecipeSourceArgs {
+    out?: string;
+    append?: boolean;
+    resume?: boolean;
+    only?: string[];
+    dryRun?: boolean;
+    headed?: boolean;
+    browserPath?: string;
+    insecureTls?: boolean;
+    userAgent?: string;
+    access?: string;
+    parallel?: number;
+}
+/** What the `run` tool returns. */
+export interface RunResult {
+    report: CrawlReport;
+    /** Present when "out" was not given: the records this call produced, capped. */
+    records?: Record<string, unknown>[];
+    truncated?: boolean;
+}
+/**
+ * The `run` tool: crawls the recipes in `paths` or `recipes` (exactly one
+ * output recipe, any number of inputs) and returns what happened,
+ * structured, instead of the cli's printed summary.
+ *
+ * @param args - The tool's parsed input.
+ * @returns The MCP tool result.
+ */
+export declare function runTool(args: RunArgs): Promise<CallToolResult>;
+export {};
+//# sourceMappingURL=run-tool.handler.d.ts.map

package/dist/server/create-server.use-case.d.ts

@@ -0,0 +1,11 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Builds the MCP server: one tool per crawl primitive (`probe`, `validate`,
+ * `run`, `list_recipes`, `diff`), `docs` and the `studio_` tools that drive a running Studio, each a thin wrapper over `@opencraw/core` and
+ * `@opencraw/cli`'s structured helpers. No transport is attached; `main`
+ * connects it over stdio.
+ *
+ * @returns The server, ready to `connect`.
+ */
+export declare function createServer(): McpServer;
+//# sourceMappingURL=create-server.use-case.d.ts.map

package/dist/server/index.d.ts

@@ -0,0 +1,2 @@
+export { createServer } from './create-server.use-case';
+//# sourceMappingURL=index.d.ts.map