@brass-lantern/mcp 2.3.0 → 2.3.1

package/README.md

@@ -18,7 +18,7 @@ Or in any client’s JSON config:
 { "mcpServers": { "brass-lantern": { "command": "npx", "args": ["-y", "@brass-lantern/mcp"] } } }
 ```
 
-Node 24 or later. World paths are relative to where the client starts the server. Worlds must be inside that directory or one you allow with `--root <dir>` (repeatable).
+Node 24 or later. World paths are relative to where the client starts the server. Worlds must be inside that directory or one you allow with `--root <dir>` (repeatable). Each `audit_world` and `play` call runs in its own worker thread and is stopped after 10 seconds; `--timeout <seconds>` changes that.
 
 ## Tools
 

package/dist/cli.js

@@ -2,15 +2,18 @@
 // The stdio entry point an MCP client launches (`npx -y @brass-lantern/mcp`). Nothing may be
 // written to stdout except through the transport: it carries the protocol.
 import { readFileSync } from 'node:fs';
-import * as bundled from '@brass-lantern/engine';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { createServer } from "./server.js";
-import { keepRunningOnCrash, parseRoots, quietStdout } from "./stdio.js";
+import { keepRunningOnCrash, parseRoots, parseTimeout, quietStdout } from "./stdio.js";
 const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+// Each audit_world and play runs in its own worker (stdout piped to stderr); these two are a
+// second layer, for anything that still runs on the main thread.
 quietStdout();
 // A world's late throw (a timer, a stray promise) is logged to stderr instead of ending the server.
 keepRunningOnCrash();
 // --root <dir> (repeatable) allows worlds from another directory besides the launch directory.
 const roots = parseRoots(process.argv.slice(2), process.cwd());
-const server = createServer({ bundled, roots, cwd: process.cwd(), version: pkg.version });
+// --timeout <seconds> bounds one audit_world or play call (default 10).
+const timeoutMs = parseTimeout(process.argv.slice(2));
+const server = createServer({ roots, cwd: process.cwd(), timeoutMs, timeoutHint: 'Raise the limit with --timeout <seconds>.', version: pkg.version });
 await server.connect(new StdioServerTransport());

package/dist/docs/pages/guide/coding-agents.md

@@ -109,12 +109,16 @@ The “not understood by the parser” note marks input the regex parser can’t
 
 The server audits and plays a world with the engine the world’s own project uses, so a project on 2.2 is checked by 2.2’s rules. It looks for `@brass-lantern/engine` from the world file. If the project has none, the server uses the engine bundled with it, and the reply says “bundled with the MCP server” without further comment. If the project’s engine is found but can’t be used (it can’t be resolved or fails to import, or lacks `createGame` or `auditWorld`), the server falls back to the bundled one and adds a note saying why. Every reply states the engine version and whose it is, so you always know what you were checked against.
 
-A world file is re-read on every call, so an edit shows on the next one. That covers `.ts` and `.mts` worlds and the project files they import (loaded with no module cache), and `.mjs` and `.js` worlds along with the project files they import. Packages a world imports stay cached and are not reloaded.
+A world file is re-read on every call, so an edit shows on the next one: each `audit_world` and `play` call runs in a fresh worker thread, which loads the world, the project files it imports and the packages it uses from scratch.
 
 ### Safety and limits
 
 The server **runs the world module it is pointed at**, with your permissions, the same way your test runner runs your tests. Point it at code you trust. It speaks only over local stdio and makes no network calls of its own. A world file is only loaded when it is inside the directory the server started in or one you passed with `--root`, compared after resolving symlinks; anything else is refused with a message naming `--root`. That check confines which world file is loaded, not what the module then imports or does: any module inside an allowed directory can be run. It is not a sandbox.
 
-A world’s console output (`console.log`, `dir`, `table` and the rest) goes to stderr, so it can’t break the protocol.
+Each `audit_world` and `play` call runs in its own worker thread, with a deadline:
 
-Two limits to know: a world whose script loops forever hangs the server until the client restarts it, and a world that calls `process.exit()` ends the server the same way. There is no per-call timeout yet.
+- A world that takes longer than 10 seconds (a script that loops forever, say) is stopped, and the call returns an error saying so. Start the server with `--timeout <seconds>` to allow longer.
+- A world that calls `process.exit()` ends only its worker; the call returns an error, and the server keeps answering. So does a world that crashes.
+- Whatever a world writes to stdout (`console.log`, `process.stdout.write`, its own `Console`) goes to the server’s stderr, so it can’t break the protocol.
+
+The worker is not a sandbox either: it runs with the server’s permissions, and a world that writes straight to file descriptor 1 (`fs.writeSync(1, …)`) still reaches the protocol stream. In a worker `process.chdir()` and `process.abort()` throw, but `process.kill(process.pid)` still ends the whole server, and there is no memory limit per world.

package/dist/engine.js

@@ -21,9 +21,11 @@ export async function resolveEngine(worldFile, bundled) {
     }
     catch (error) {
         const { code, message } = error;
-        // Silent only for a genuine “not installed”; anything else (a broken exports map, a malformed
-        // package.json) means the project has an engine we couldn’t use, which the agent should know.
-        if (code === 'MODULE_NOT_FOUND' && typeof message === 'string' && message.includes('@brass-lantern/engine'))
+        // Silent only for a genuine “not installed”, whose message quotes the bare specifier. Anything
+        // else (a broken exports map, a malformed package.json, an exports target that’s missing, whose
+        // message names a path inside the package) means the project has an engine we couldn’t use,
+        // which the agent should know.
+        if (code === 'MODULE_NOT_FOUND' && typeof message === 'string' && message.includes(`'@brass-lantern/engine'`))
             return fallback();
         return fallback(`couldn’t resolve the project’s @brass-lantern/engine (${typeof message === 'string' ? message.split('\n')[0] : String(error)}); used the bundled engine`);
     }

package/dist/job.d.ts

@@ -0,0 +1,22 @@
+import { type Engine } from './engine.ts';
+/** One audit_world or play call: everything a worker needs, all structured-cloneable. */
+export interface Job {
+    op: 'audit' | 'play';
+    /** The world path as the agent gave it (already checked against the roots). */
+    path: string;
+    exportName?: string;
+    cwd: string;
+    commands?: string[];
+    seed?: number;
+}
+/** A tool reply in plain form. */
+export interface JobResult {
+    text: string;
+    isError: boolean;
+}
+/**
+ * Loads the world and its engine and runs the report; any failure becomes an error result. The
+ * worker calls this with the engine it imported; it runs the world's code in whatever thread
+ * calls it.
+ */
+export declare function runJob(job: Job, bundled: Engine): Promise<JobResult>;

package/dist/job.js

@@ -0,0 +1,29 @@
+import { resolveEngine } from "./engine.js";
+import { loadWorld, WorldLoadError } from "./load.js";
+import { auditReport, header, playReport } from "./tools.js";
+/**
+ * Loads the world and its engine and runs the report; any failure becomes an error result. The
+ * worker calls this with the engine it imported; it runs the world's code in whatever thread
+ * calls it.
+ */
+export async function runJob(job, bundled) {
+    let loaded;
+    try {
+        loaded = await loadWorld(job.path, job.exportName, job.cwd);
+    }
+    catch (error) {
+        if (error instanceof WorldLoadError)
+            return { text: error.message, isError: true };
+        return { text: `The world couldn’t be loaded: ${error instanceof Error ? error.message : String(error)}`, isError: true };
+    }
+    let resolved;
+    try {
+        resolved = await resolveEngine(loaded.file, bundled);
+        const text = job.op === 'audit' ? auditReport(loaded, resolved) : playReport(loaded, resolved, job.commands ?? [], job.seed);
+        return { text, isError: false };
+    }
+    catch (error) {
+        const lines = resolved ? [...header(loaded, resolved), ''] : [];
+        return { text: `${lines.join('\n')}${lines.length ? '\n' : ''}The engine threw: ${error instanceof Error ? error.message : String(error)}`, isError: true };
+    }
+}

package/dist/load.js

@@ -24,8 +24,9 @@ export function isWorldShaped(value) {
  * Bare specifiers (packages) are never touched, whatever their real path: a symlinked package
  * (workspaces, npm link) has no /node_modules/ in its resolved URL, and re-instantiating it per
  * load would leak its whole graph. So packages stay cached and are not reloaded; each call keeps
- * one generation of the world's own project files for the life of the process. The hook only
- * touches modules whose importer carries the query; nothing else in the process is affected.
+ * one generation of the world's own project files for as long as the loader lives. The server
+ * loads each world in a fresh worker thread, so there the hook and those modules last one call.
+ * The hook only touches modules whose importer carries the query; nothing else is affected.
  */
 const FRESH_HOOK = `
 export async function resolve(specifier, context, next) {

package/dist/run.d.ts

@@ -0,0 +1,16 @@
+import type { Job, JobResult } from './job.ts';
+/** How long a world gets by default: 10 s. */
+export declare const DEFAULT_TIMEOUT_MS = 10000;
+/** The longest delay setTimeout honors (2^31 − 1 ms, about 24.8 days); past it, Node fires after 1 ms. */
+export declare const MAX_TIMEOUT_MS = 2147483647;
+/**
+ * Runs a job in a fresh worker thread, so a world that loops forever, calls process.exit(),
+ * crashes or writes to stdout can't freeze, end or corrupt the server. The worker's stdout and
+ * stderr go to this process's stderr. Never rejects: every outcome (a worker that can't even
+ * start included) is a result. `timeoutHint` ends the timeout message; `workerUrl` is for tests.
+ */
+export declare function runInWorker(job: Job, { timeoutMs: requested, timeoutHint, workerUrl }?: {
+    timeoutMs?: number;
+    timeoutHint?: string;
+    workerUrl?: URL;
+}): Promise<JobResult>;

package/dist/run.js

@@ -0,0 +1,57 @@
+import { Worker } from 'node:worker_threads';
+/** How long a world gets by default: 10 s. */
+export const DEFAULT_TIMEOUT_MS = 10_000;
+/** The longest delay setTimeout honors (2^31 − 1 ms, about 24.8 days); past it, Node fires after 1 ms. */
+export const MAX_TIMEOUT_MS = 2_147_483_647;
+// From source (tests, the repo) the worker is TypeScript and the engine resolves to its source;
+// published, both are plain JavaScript in dist/.
+const fromSource = import.meta.url.endsWith('.ts');
+const WORKER_URL = new URL(fromSource ? './worker.ts' : './worker.js', import.meta.url);
+// Published, the worker deliberately gets no flags: an empty execArgv stops it inheriting the
+// server's own (process.execArgv), which a world's worker has no business running under.
+const EXEC_ARGV = fromSource ? ['--import', 'tsx', '--conditions=@brass-lantern/source'] : [];
+/** How long a worker that has answered may linger before it is stopped. */
+const GRACE_MS = 500;
+const seconds = (ms) => String(Number((ms / 1000).toFixed(3)));
+/**
+ * Runs a job in a fresh worker thread, so a world that loops forever, calls process.exit(),
+ * crashes or writes to stdout can't freeze, end or corrupt the server. The worker's stdout and
+ * stderr go to this process's stderr. Never rejects: every outcome (a worker that can't even
+ * start included) is a result. `timeoutHint` ends the timeout message; `workerUrl` is for tests.
+ */
+export function runInWorker(job, { timeoutMs: requested = DEFAULT_TIMEOUT_MS, timeoutHint = 'Raise the server’s timeout.', workerUrl = WORKER_URL } = {}) {
+    // NaN means the default; anything past setTimeout's limit (Infinity included) is capped.
+    const timeoutMs = Number.isNaN(requested) ? DEFAULT_TIMEOUT_MS : Math.min(Math.max(requested, 1), MAX_TIMEOUT_MS);
+    return new Promise((resolve) => {
+        let worker;
+        try {
+            worker = new Worker(workerUrl, { workerData: job, stdout: true, stderr: true, execArgv: EXEC_ARGV });
+        }
+        catch (error) {
+            resolve({ isError: true, text: `The world runner couldn’t start: ${error instanceof Error ? error.message : String(error)}` });
+            return;
+        }
+        // Forwarded chunk by chunk rather than piped, so concurrent calls add no listeners to stderr.
+        const forward = (chunk) => process.stderr.write(chunk);
+        worker.stdout.on('data', forward);
+        worker.stderr.on('data', forward);
+        let settled = false;
+        const settle = (result, grace = GRACE_MS) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(result);
+            // A world may leave timers running: once the answer is in, the worker gets a moment to exit
+            // on its own (flushing its output to stderr), then goes.
+            if (grace === 0)
+                void worker.terminate();
+            else
+                setTimeout(() => void worker.terminate(), grace).unref();
+        };
+        const timer = setTimeout(() => settle({ isError: true, text: `The world didn’t finish within ${seconds(timeoutMs)} s (a script may loop forever). ${timeoutHint}` }, 0), timeoutMs);
+        worker.on('message', (result) => settle(typeof result?.text === 'string' ? { text: result.text, isError: result.isError === true } : { isError: true, text: 'The world crashed: its worker sent something other than a result.' }));
+        worker.on('error', (error) => settle({ isError: true, text: `The world crashed: ${error instanceof Error ? error.message : String(error)}` }));
+        worker.on('exit', (code) => settle({ isError: true, text: `The world ended before answering (exit code ${code}); a world shouldn’t call process.exit() or leave a top-level await pending.` }));
+    });
+}

package/dist/server.d.ts

@@ -1,9 +1,15 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { type Engine } from './engine.ts';
+import type { Engine } from './engine.ts';
+import { type Job, type JobResult } from './job.ts';
 export { quietStdout } from './stdio.ts';
+export type { Job, JobResult } from './job.ts';
 export interface ServerOptions {
-    /** The engine to use when a world’s project has none of its own. */
-    bundled: Engine;
+    /**
+     * @deprecated Only used by a custom runJob; pass `runJob: inProcessRunner(engine)` to run
+     * in-process with your engine (without the timeout). The default runner’s worker imports this
+     * package’s own @brass-lantern/engine (an engine can’t cross threads).
+     */
+    bundled?: Engine;
     /** Where the docs bundle is. Default: the one shipped with this package (dist/docs). */
     docsDir?: string;
     /** Relative world paths resolve against this (the client’s launch directory). */
@@ -11,7 +17,25 @@ export interface ServerOptions {
     /** Worlds must live inside one of these directories (symlinks resolved). Default: [cwd]. */
     roots?: string[];
     version: string;
+    /**
+     * How long one audit_world or play call may run before its worker is stopped, in milliseconds.
+     * Default 10 s. Must be a positive number (createServer throws a RangeError otherwise); past
+     * 2147483647 (about 24.8 days, setTimeout’s limit) it is capped.
+     */
+    timeoutMs?: number;
+    /** The last sentence of the timeout message, saying how to raise the limit. Default: “Raise the server’s timeout.” */
+    timeoutHint?: string;
+    /**
+     * Runs one audit_world or play call. Default: a fresh worker thread per call with the deadline
+     * above, so a world can’t freeze, end or write over the server.
+     */
+    runJob?: (job: Job) => Promise<JobResult>;
 }
+/**
+ * A runJob that runs each call in this thread with `engine` as the fallback engine: the 2.3.0
+ * behavior. No timeout and no isolation, so a world that loops forever freezes the server.
+ */
+export declare function inProcessRunner(engine: Engine): (job: Job) => Promise<JobResult>;
 /**
  * The brass-lantern MCP server, unconnected: pass it a transport. Stdout-based transports also
  * want quietStdout(), so a world’s console output can’t corrupt the protocol.

package/dist/server.js

@@ -4,13 +4,21 @@ import { fileURLToPath } from 'node:url';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import { docsReport, readDocs } from "./docs.js";
-import { resolveEngine } from "./engine.js";
-import { loadWorld, WorldLoadError } from "./load.js";
-import { auditReport, header, MAX_COMMANDS, playReport } from "./tools.js";
+import { runJob as runJobWith } from "./job.js";
+import { DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS, runInWorker } from "./run.js";
+import { MAX_COMMANDS } from "./tools.js";
 export { quietStdout } from "./stdio.js";
 const reply = (text, isError = false) => ({ content: [{ type: 'text', text }], ...(isError ? { isError: true } : {}) });
 const PATH = z.string().min(1).describe('The world module: a .ts, .mts, .js or .mjs file, relative to the directory the server was started in, or absolute.');
 const EXPORT = z.string().min(1).optional().describe('Which export is the world. Default: the default export, else the only world-shaped export.');
+/**
+ * A runJob that runs each call in this thread with `engine` as the fallback engine: the 2.3.0
+ * behavior. No timeout and no isolation, so a world that loops forever freezes the server.
+ */
+export function inProcessRunner(engine) {
+    return (job) => runJobWith(job, engine);
+}
+let bundledNoted = false;
 /**
  * The brass-lantern MCP server, unconnected: pass it a transport. Stdout-based transports also
  * want quietStdout(), so a world’s console output can’t corrupt the protocol.
@@ -38,34 +46,27 @@ export function createServer(options) {
             return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
         });
     };
-    /** Loads the world and its engine, runs `report`, and turns any failure into an error result. */
-    async function withWorld(path, exportName, report) {
-        if (!allowed(path))
-            return reply(`${path}: outside the allowed directories (${roots.join(', ')}). Start the server with --root <dir> to allow another.`, true);
-        let loaded;
-        try {
-            loaded = await loadWorld(path, exportName, options.cwd);
-        }
-        catch (error) {
-            if (error instanceof WorldLoadError)
-                return reply(error.message, true);
-            return reply(`The world couldn’t be loaded: ${error instanceof Error ? error.message : String(error)}`, true);
-        }
-        let resolved;
-        try {
-            resolved = await resolveEngine(loaded.file, options.bundled);
-            return reply(report(loaded, resolved));
-        }
-        catch (error) {
-            const lines = resolved ? [...header(loaded, resolved), ''] : [];
-            return reply(`${lines.join('\n')}${lines.length ? '\n' : ''}The engine threw: ${error instanceof Error ? error.message : String(error)}`, true);
-        }
+    if (options.bundled && !options.runJob && !bundledNoted) {
+        bundledNoted = true;
+        process.stderr.write('brass-lantern-mcp: the bundled option is ignored (each call runs in a worker with this package’s engine); pass runJob: inProcessRunner(engine) to use your engine in-process.\n');
+    }
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    if (!(timeoutMs > 0))
+        throw new RangeError(`timeoutMs must be a positive number of milliseconds (it is capped at ${MAX_TIMEOUT_MS})`);
+    const { timeoutHint } = options;
+    const runJob = options.runJob ?? ((job) => runInWorker(job, { timeoutMs, timeoutHint }));
+    /** Checks the roots here (an outside path never reaches the runner), then runs the job. */
+    async function withWorld(job) {
+        if (!allowed(job.path))
+            return reply(`${job.path}: outside the allowed directories (${roots.join(', ')}). Start the server with --root <dir> to allow another.`, true);
+        const result = await runJob(job);
+        return reply(result.text, result.isError);
     }
     server.registerTool('audit_world', {
         title: 'Audit a Brass Lantern world',
         description: 'Checks a world file the way the engine’s auditWorld does: exits that go nowhere, conditions that don’t parse, effects naming things that don’t exist, unmapped flag labels and more. Reports the engine version used.',
         inputSchema: { path: PATH, export: EXPORT },
-    }, ({ path, export: exportName }) => withWorld(path, exportName, auditReport));
+    }, ({ path, export: exportName }) => withWorld({ op: 'audit', path, exportName, cwd: options.cwd }));
     server.registerTool('play', {
         title: 'Play commands in a Brass Lantern world',
         description: `Starts a fresh game (seeded, so runs repeat exactly) and types each command, as a player would, with no LLM. Returns the transcript and the final state (room, inventory, flags, score, moves, game over). Each call starts from the beginning; at most ${MAX_COMMANDS} commands.`,
@@ -75,7 +76,7 @@ export function createServer(options) {
             commands: z.array(z.string()).min(1).describe('Commands to type, in order (e.g. ["open drawer", "take key", "north"]).'),
             seed: z.number().int().optional().describe('Random seed. Default 1.'),
         },
-    }, ({ path, export: exportName, commands, seed }) => withWorld(path, exportName, (loaded, resolved) => playReport(loaded, resolved, commands, seed)));
+    }, ({ path, export: exportName, commands, seed }) => withWorld({ op: 'play', path, exportName, cwd: options.cwd, commands, seed }));
     server.registerTool('docs', {
         title: 'Brass Lantern documentation',
         description: 'The docs for this version: with no arguments, the index of pages; with “page”, one page’s markdown (e.g. reference/world-schema); with “query”, the best-matching sections. If both are given, “page” wins.',

package/dist/stdio.d.ts

@@ -11,6 +11,12 @@ export declare function quietStdout(): () => void;
  * against `cwd`. A trailing `--root` with no directory is ignored, with a warning through `warn`.
  */
 export declare function parseRoots(args: readonly string[], cwd: string, warn?: (message: string) => void): string[];
+/**
+ * How long one audit_world or play call may run, in milliseconds: `--timeout <seconds>` (the last
+ * one wins), else 10 s. A missing, non-numeric or non-positive value is ignored with a warning;
+ * one past setTimeout's limit (2147483 s, about 24.8 days) is capped at it, with a warning.
+ */
+export declare function parseTimeout(args: readonly string[], warn?: (message: string) => void): number;
 /**
  * A world can throw after its tool call has returned (a timer, a stray promise). Node's default
  * would end the server mid-session; instead, log the error to stderr and keep serving. Returns a

package/dist/stdio.js

@@ -1,5 +1,6 @@
 import { Console } from 'node:console';
 import { resolve } from 'node:path';
+import { DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS } from "./run.js";
 /**
  * Stdout carries the MCP protocol, so a world's console output (at load or while a script runs)
  * would corrupt it. Swaps the global console for one whose stdout and stderr are both
@@ -32,6 +33,31 @@ export function parseRoots(args, cwd, warn = (m) => process.stderr.write(`${m}\n
     }
     return roots;
 }
+/**
+ * How long one audit_world or play call may run, in milliseconds: `--timeout <seconds>` (the last
+ * one wins), else 10 s. A missing, non-numeric or non-positive value is ignored with a warning;
+ * one past setTimeout's limit (2147483 s, about 24.8 days) is capped at it, with a warning.
+ */
+export function parseTimeout(args, warn = (m) => process.stderr.write(`${m}\n`)) {
+    const DEFAULT = DEFAULT_TIMEOUT_MS;
+    const MAX_MS = MAX_TIMEOUT_MS;
+    let ms = DEFAULT;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] !== '--timeout')
+            continue;
+        const value = args[i + 1];
+        const seconds = value === undefined || value.trim() === '' ? NaN : Number(value);
+        if (Number.isFinite(seconds) && seconds > 0) {
+            ms = Math.min(seconds * 1000, MAX_MS);
+            if (seconds * 1000 > MAX_MS)
+                warn(`brass-lantern-mcp: --timeout is capped at ${Math.floor(MAX_MS / 1000)} seconds`);
+        }
+        else
+            warn(`brass-lantern-mcp: --timeout needs a positive number of seconds; using ${DEFAULT / 1000}`);
+        i += 1;
+    }
+    return ms;
+}
 /**
  * A world can throw after its tool call has returned (a timer, a stray promise). Node's default
  * would end the server mid-session; instead, log the error to stderr and keep serving. Returns a

package/dist/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/worker.js

@@ -0,0 +1,6 @@
+// The worker entry: runs one audit_world or play job (workerData) and posts the result back.
+// Its stdout and stderr are piped to the server's stderr, and run.ts terminates it on the deadline.
+import { parentPort, workerData } from 'node:worker_threads';
+import * as bundled from '@brass-lantern/engine';
+import { runJob } from "./job.js";
+parentPort?.postMessage(await runJob(workerData, bundled));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brass-lantern/mcp",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "author": "Todd Greco <mrballistic@gmail.com>",
   "description": "A Model Context Protocol server for brass-lantern: lets a coding agent audit, play and read the docs for the text-adventure world it is writing.",
   "license": "MIT",