@jinshuju/mcp 0.0.0-stage → 0.3.0

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { createApp, MCP_PATH, type AppOptions } from './app.js';
+export { McpAnalytics, analyticsFromConfig, CONTEXT_DESCRIPTION, CONTEXT_INSTRUCTIONS, type AnalyticsOptions } from './analytics.js';
+export { buildServer, INSTRUCTIONS, META, type BuildServerOptions } from './server.js';
+export { TOOLS, SCHEMAS, toToolResult } from './tools.js';
+export { OPERATIONS, runComposite } from './composites.js';
+export { JinshujuApi, buildUrl, buildBody, bodyPayload, TransportError, type ApiResponse } from './api.js';
+export { configFromEnv, DEFAULTS, type Config } from './config.js';
+export { StaticCredential, MissingCredentialError, type Credential } from './credential.js';
+export { CliSessionCredential, resolveCredential, DEFAULT_CONFIG_PATH } from './cli-credential.js';
+export { TokenVerifier, bearerToken, challenge, loadAuthServerMetadata, sha256 } from './auth.js';
+export type { ToolSpec, OperationSpec, ParamSpec, BodySpec, GeneratedMeta, JsonSchema } from './types.js';
+export { VERSION, SERVER_NAME, SERVER_TITLE } from './version.js';

package/dist/index.js

@@ -0,0 +1,12 @@
+export { createApp, MCP_PATH } from './app.js';
+export { McpAnalytics, analyticsFromConfig, CONTEXT_DESCRIPTION, CONTEXT_INSTRUCTIONS } from './analytics.js';
+export { buildServer, INSTRUCTIONS, META } from './server.js';
+export { TOOLS, SCHEMAS, toToolResult } from './tools.js';
+export { OPERATIONS, runComposite } from './composites.js';
+export { JinshujuApi, buildUrl, buildBody, bodyPayload, TransportError } from './api.js';
+export { configFromEnv, DEFAULTS } from './config.js';
+export { StaticCredential, MissingCredentialError } from './credential.js';
+export { CliSessionCredential, resolveCredential, DEFAULT_CONFIG_PATH } from './cli-credential.js';
+export { TokenVerifier, bearerToken, challenge, loadAuthServerMetadata, sha256 } from './auth.js';
+export { VERSION, SERVER_NAME, SERVER_TITLE } from './version.js';
+//# sourceMappingURL=index.js.map

package/dist/node.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/node.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+/** Node process entry, used by the official deployment (Docker / k8s). */
+import { serve } from '@hono/node-server';
+import { analyticsFromConfig } from './analytics.js';
+import { createApp } from './app.js';
+import { configFromEnv } from './config.js';
+import { VERSION } from './version.js';
+const port = Number(process.env.PORT ?? 8787);
+const host = process.env.HOST ?? '0.0.0.0';
+const config = configFromEnv();
+const analytics = analyticsFromConfig(config);
+const app = createApp({ config, analytics });
+serve({ fetch: app.fetch, port, hostname: host }, (info) => {
+    console.error(`jinshuju-mcp ${VERSION} listening on http://${info.address}:${info.port}/mcp`);
+});
+// posthog-node sends in timed batches; flush the queued events before the process exits.
+if (analytics) {
+    const stop = () => {
+        analytics
+            .shutdown()
+            .catch((error) => console.error('posthog shutdown failed:', error))
+            .finally(() => process.exit(0));
+    };
+    process.once('SIGTERM', stop);
+    process.once('SIGINT', stop);
+}
+//# sourceMappingURL=node.js.map

package/dist/result.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Turns an API response into a CallToolResult the model can read: compact JSON on success (truncated when needed),
+ * and on failure the HTTP status + the server's error_description / errors[] + a line on what to do.
+ */
+import type { CallToolResult } from '@modelcontextprotocol/server';
+import type { ApiResponse } from './api.js';
+import type { ToolSpec } from './types.js';
+/** The 403 hint; it names the scope itself, so analytics.ts leaves it out when looking for a scope failure in the API's own words. */
+export declare const FORBIDDEN_HINT = "No permission, a quota is used up, or the OAuth scope is insufficient.";
+export declare function toToolResult(tool: ToolSpec, res: ApiResponse, maxResultChars: number): CallToolResult;

package/dist/result.js

@@ -0,0 +1,81 @@
+function errorLines(res) {
+    const lines = [];
+    const body = res.json;
+    const stated = body?.error_description ?? body?.message ?? body?.error;
+    if (typeof stated === 'string' && stated.trim())
+        lines.push(stated.trim());
+    const errors = body?.errors;
+    if (Array.isArray(errors)) {
+        for (const item of errors) {
+            if (typeof item === 'string')
+                lines.push(`- ${item}`);
+            else if (item && typeof item === 'object') {
+                const { pointer, message, code, index, reason } = item;
+                const where = pointer ?? (index === undefined ? undefined : `row ${index}`);
+                const what = message ?? reason ?? JSON.stringify(item);
+                lines.push(`- ${where === undefined ? '' : `${where}: `}${what}${code ? ` (${code})` : ''}`);
+            }
+        }
+    }
+    if (!lines.length && res.text)
+        lines.push(res.text);
+    return lines;
+}
+/** The 403 hint; it names the scope itself, so analytics.ts leaves it out when looking for a scope failure in the API's own words. */
+export const FORBIDDEN_HINT = 'No permission, a quota is used up, or the OAuth scope is insufficient.';
+function hint(status, res) {
+    switch (status) {
+        case 400:
+            return 'Arguments or data failed validation: fix them as described above and retry.';
+        case 401:
+            return 'The credential is invalid or expired: re-authorize, or use another access token.';
+        case 402:
+            return 'The current plan does not include API v1.';
+        case 403:
+            return FORBIDDEN_HINT;
+        case 404:
+            return 'The resource does not exist or this credential cannot access it (check the token / serial number).';
+        case 415:
+            return 'The request body must be JSON.';
+        case 422:
+            return 'Rejected; see the reasons above. A batch returns 422 only when every item failed.';
+        case 429:
+            return `Rate limit exceeded; retry ${res.retryAfter ? `in ${res.retryAfter} seconds` : 'later'}.`;
+        default:
+            return status >= 500 ? 'Jinshuju server error; retry later, and report it if it keeps happening.' : '';
+    }
+}
+export function toToolResult(tool, res, maxResultChars) {
+    const note = res.warnings ? `\n⚠ Server warnings about the arguments (X-API-Input-Warnings): ${res.warnings}` : '';
+    if (res.status >= 200 && res.status < 300) {
+        const payload = res.json;
+        let text = payload === undefined ? (res.text ?? '') : JSON.stringify(payload);
+        let truncated = false;
+        if (text.length > maxResultChars) {
+            truncated = true;
+            text =
+                `${text.slice(0, maxResultChars)}\n… (Result truncated: ${text.length} characters in all. ` +
+                    'Narrow it with fields / limit / filters / keyword, or page through it with next.)';
+        }
+        const result = { content: [{ type: 'text', text: text + note }] };
+        if (tool.outputSchema) {
+            // A tool that declares an outputSchema must return structuredContent. When truncated, don't stuff the whole large result in again; return a small explanatory object.
+            if (truncated) {
+                result.structuredContent = { truncated: true, total_chars: JSON.stringify(payload).length };
+            }
+            else if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
+                result.structuredContent = payload;
+            }
+            else {
+                result.structuredContent = { result: payload };
+            }
+        }
+        return result;
+    }
+    const lines = [`HTTP ${res.status}: ${tool.name} failed.`, ...errorLines(res)];
+    const h = hint(res.status, res);
+    if (h)
+        lines.push(h);
+    return { isError: true, content: [{ type: 'text', text: lines.join('\n') + note }] };
+}
+//# sourceMappingURL=result.js.map

package/dist/server.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Assembles an McpServer. Stateless: one per HTTP request / per stdio connection, cheap and independent of each other.
+ */
+import { McpServer } from '@modelcontextprotocol/server';
+import type { Config } from './config.js';
+import type { Credential } from './credential.js';
+import { type ToolRuntime } from './tools.js';
+import type { GeneratedMeta } from './types.js';
+export declare const META: GeneratedMeta;
+export declare const INSTRUCTIONS: string;
+export interface BuildServerOptions {
+    credential: Credential;
+    config?: Partial<Config>;
+    fetch?: typeof fetch;
+    /** Server instructions, INSTRUCTIONS by default; with intent collection on in HTTP mode, the context argument's note is appended */
+    instructions?: string;
+    /** Callback when a tool throws (the HTTP deployment reports to Sentry); the error still goes to the model as usual */
+    onToolError?: ToolRuntime['onError'];
+}
+export declare function buildServer({ credential, config, fetch: fetchImpl, instructions, onToolError }: BuildServerOptions): McpServer;

package/dist/server.js

@@ -0,0 +1,59 @@
+/**
+ * Assembles an McpServer. Stateless: one per HTTP request / per stdio connection, cheap and independent of each other.
+ */
+import { McpServer, ResourceTemplate } from '@modelcontextprotocol/server';
+import { JinshujuApi } from './api.js';
+import { DEFAULTS } from './config.js';
+import { registerGeneratedTools, registerSchemaTools, SCHEMAS } from './tools.js';
+import { SERVER_NAME, SERVER_TITLE, VERSION } from './version.js';
+import metaJson from './generated/meta.json' with { type: 'json' };
+export const META = metaJson;
+export const INSTRUCTIONS = [
+    'MCP server for Jinshuju (金数据) forms, tables and entries. Each tool maps to the open API v1 and is generated from its openapi.yaml.',
+    "Usual path: list_forms finds the form token → get_form shows the fields' api_code → list_entries / count_entries / aggregate_entries read entries;",
+    'create_entry / patch_entries write them, keyed by api_code.',
+    'To create a form: get_schema("FieldInput") lists the field types, get_schema("<Type>Input") shows a type\'s properties, then call create_form.',
+    'Wherever an input says `Shape: schema "X"`, look X up with get_schema; do not guess.',
+    "An error gives the HTTP status and the server's error_description / errors; fix the call as they say and retry. On 429, wait as Retry-After says.",
+    'A personal token sees only the forms its user created or that are shared with them; an account token sees every form in the account.'
+].join('\n');
+export function buildServer({ credential, config, fetch: fetchImpl, instructions, onToolError }) {
+    const cfg = { ...DEFAULTS, ...config };
+    const api = new JinshujuApi({
+        baseUrl: cfg.apiBaseUrl,
+        fetch: fetchImpl,
+        timeoutMs: cfg.timeoutMs,
+        userAgent: `jinshuju-mcp/${VERSION}`
+    });
+    const server = new McpServer({ name: SERVER_NAME, title: SERVER_TITLE, version: VERSION, websiteUrl: 'https://open.jinshuju.net/mcp' }, { instructions: instructions ?? INSTRUCTIONS });
+    registerGeneratedTools(server, { api, credential, maxResultChars: cfg.maxResultChars, onError: onToolError });
+    registerSchemaTools(server, META.pointerSchemas);
+    // The same schema catalog is also exposed as resources, for clients that prefer resources.
+    server.registerResource('schema', new ResourceTemplate('jinshuju://schemas/{name}', {
+        list: () => ({
+            resources: META.pointerSchemas.map((name) => ({
+                uri: `jinshuju://schemas/${name}`,
+                name,
+                title: `schema ${name}`,
+                mimeType: 'application/schema+json',
+                description: SCHEMAS[name]?.description?.split('\n')[0]
+            }))
+        }),
+        complete: {
+            name: (value) => Object.keys(SCHEMAS)
+                .filter((n) => n.toLowerCase().startsWith(value.toLowerCase()))
+                .slice(0, 20)
+        }
+    }), {
+        title: 'API v1 schemas',
+        description: 'JSON Schemas from components.schemas of openapi.yaml, read by name.',
+        mimeType: 'application/schema+json'
+    }, async (uri, { name }) => {
+        const schema = SCHEMAS[String(name)];
+        if (!schema)
+            throw new Error(`No schema named ${String(name)}`);
+        return { contents: [{ uri: uri.href, mimeType: 'application/schema+json', text: JSON.stringify(schema) }] };
+    });
+    return server;
+}
+//# sourceMappingURL=server.js.map

package/dist/stdio.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/stdio.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+/**
+ * Local stdio entry: `claude mcp add jinshuju -- npx -y @jinshuju/mcp`.
+ * The credential comes from JINSHUJU_ACCESS_TOKEN, or from ~/.jinshuju/config.json after logging in with @jinshuju/cli.
+ */
+import { serveStdio } from '@modelcontextprotocol/server/stdio';
+import { configFromEnv } from './config.js';
+import { resolveCredential } from './cli-credential.js';
+import { MissingCredentialError } from './credential.js';
+import { buildServer } from './server.js';
+import { VERSION } from './version.js';
+if (process.argv.includes('--version') || process.argv.includes('-V')) {
+    console.log(VERSION);
+    process.exit(0);
+}
+try {
+    const credential = await resolveCredential();
+    const config = configFromEnv();
+    console.error(`jinshuju-mcp ${VERSION}: ${credential.describe()}`);
+    serveStdio(() => buildServer({ credential, config }));
+}
+catch (error) {
+    if (error instanceof MissingCredentialError) {
+        console.error(error.message);
+        process.exit(3);
+    }
+    throw error;
+}
+//# sourceMappingURL=stdio.js.map

package/dist/tools.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Registers the generated ToolSpecs as MCP tools: a one-to-one tool sends its request directly; a composite tool goes to composites.ts.
+ */
+import { type McpServer } from '@modelcontextprotocol/server';
+import type { JinshujuApi } from './api.js';
+import type { Credential } from './credential.js';
+import type { ToolSpec, JsonSchema } from './types.js';
+export { toToolResult } from './result.js';
+export declare const TOOLS: ToolSpec[];
+export declare const SCHEMAS: Record<string, JsonSchema>;
+export interface ToolRuntime {
+    api: JinshujuApi;
+    credential: Credential;
+    maxResultChars: number;
+    /** Told first when a tool throws (the HTTP deployment reports to Sentry); the error still goes to the model as usual; stdio passes none */
+    onError?: (error: unknown, tool: string) => void;
+}
+export declare function registerGeneratedTools(server: McpServer, runtime: ToolRuntime): void;
+/** Lists the schema names that can be looked up, for get_schema's error and the resources list. */
+export declare function schemaNames(): string[];
+export declare function registerSchemaTools(server: McpServer, pointerSchemas: string[]): void;

package/dist/tools.js

@@ -0,0 +1,84 @@
+/**
+ * Registers the generated ToolSpecs as MCP tools: a one-to-one tool sends its request directly; a composite tool goes to composites.ts.
+ */
+import { fromJsonSchema } from '@modelcontextprotocol/server';
+import { TransportError } from './api.js';
+import { runComposite } from './composites.js';
+import { toToolResult } from './result.js';
+import { toolInputValidator } from './validation.js';
+import toolsJson from './generated/tools.json' with { type: 'json' };
+import schemasJson from './generated/schemas.json' with { type: 'json' };
+export { toToolResult } from './result.js';
+export const TOOLS = toolsJson;
+export const SCHEMAS = schemasJson;
+/**
+ * outputSchema only tells the model what comes back; it never rejects a response:
+ * when openapi.yaml and the live implementation disagree now and then, a successful API call must not turn into a tool error.
+ */
+const permissiveValidator = {
+    getValidator: () => (input) => ({ valid: true, data: input, errorMessage: undefined })
+};
+export function registerGeneratedTools(server, runtime) {
+    for (const tool of TOOLS) {
+        server.registerTool(tool.name, {
+            title: tool.title,
+            description: tool.description,
+            inputSchema: fromJsonSchema(tool.inputSchema, toolInputValidator),
+            outputSchema: tool.outputSchema ? fromJsonSchema(tool.outputSchema, permissiveValidator) : undefined,
+            annotations: tool.annotations
+        }, async (args) => {
+            try {
+                if (tool.composite)
+                    return await runComposite(tool, args ?? {}, runtime);
+                const res = await runtime.api.call(tool, args ?? {}, runtime.credential);
+                return toToolResult(tool, res, runtime.maxResultChars);
+            }
+            catch (error) {
+                runtime.onError?.(error, tool.name);
+                if (error instanceof TransportError) {
+                    return { isError: true, content: [{ type: 'text', text: `${error.message}. Retry later.` }] };
+                }
+                throw error;
+            }
+        });
+    }
+}
+/** Lists the schema names that can be looked up, for get_schema's error and the resources list. */
+export function schemaNames() {
+    return Object.keys(SCHEMAS);
+}
+export function registerSchemaTools(server, pointerSchemas) {
+    server.registerTool('get_schema', {
+        title: 'Show a schema',
+        description: 'Returns the full JSON Schema of a schema in openapi.yaml. Where a tool input or result says `Shape: schema "X"` or ' +
+            '`Returns schema "X"`, look X up here; a schema that branches on type (such as FieldInput) carries x-variants, ' +
+            `which names the schema of each branch. Common ones: ${pointerSchemas.slice(0, 6).join(', ')}.`,
+        inputSchema: fromJsonSchema({
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Schema name, e.g. FieldInput, TextFieldInput, FormSettingWriteInput' }
+            },
+            required: ['name'],
+            additionalProperties: false
+        }, toolInputValidator),
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+    }, async ({ name }) => {
+        const schema = SCHEMAS[name];
+        if (!schema) {
+            const candidates = schemaNames()
+                .filter((n) => n.toLowerCase().includes(name.toLowerCase()))
+                .slice(0, 10);
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: `No schema named ${name}.${candidates.length ? ` Similar names: ${candidates.join(', ')}` : ''}`
+                    }
+                ]
+            };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(schema) }] };
+    });
+}
+//# sourceMappingURL=tools.js.map

package/dist/types.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The shape of the generated output (src/generated/*.json). A change here needs the same change in scripts/generate.ts.
+ */
+export type JsonSchema = Record<string, unknown>;
+export type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
+export interface ParamSpec {
+    name: string;
+    in: 'path' | 'query';
+    required: boolean;
+    /** A query array is serialized as name[]=a&name[]=b (the server reads it as an array) */
+    array?: boolean;
+    /** Declared with `content: application/json`: sent as one query value holding JSON text (a string is passed through as is) */
+    json?: boolean;
+}
+export interface BodySpec {
+    contentType: 'application/json' | 'multipart/form-data';
+    required: boolean;
+    /** Body properties sit at the top level of the arguments: the keys left after removing path / query parameters are the body */
+    flatten: boolean;
+    /** When not flattened, the argument key that holds the body */
+    param?: string;
+    /** Wrapped once more as { [wrap]: payload } before sending (for projection tools) */
+    wrap?: string;
+}
+/** One openapi operation: everything needed to send its request at runtime */
+export interface OperationSpec {
+    operationId: string;
+    summary: string;
+    description: string;
+    tag: string;
+    method: HttpMethod;
+    path: string;
+    params: ParamSpec[];
+    paramNames: string[];
+    body?: BodySpec;
+    successStatus: number;
+    scopes: string[];
+    responseSchema?: string;
+}
+export interface ToolAnnotations {
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+}
+export type CompositeKind = 'scene_form_create' | 'scene_form_update' | 'count_entries';
+/** One MCP tool: an operation + input / output schemas; a composite tool also carries composite */
+export interface ToolSpec extends OperationSpec {
+    name: string;
+    title: string;
+    inputSchema: JsonSchema;
+    outputSchema?: JsonSchema;
+    annotations: ToolAnnotations;
+    composite?: {
+        kind: CompositeKind;
+        scene?: string;
+        settingOperation?: string;
+        settingKey?: string;
+    };
+}
+export interface GeneratedMeta {
+    generatedFrom: {
+        title: string;
+        version: string;
+        sha256: string;
+    };
+    baseUrl: string;
+    toolCount: number;
+    operationCount: number;
+    /** Tool name -> operationId (a+b for a composite tool) */
+    tools: Record<string, string>;
+    pointerSchemas: string[];
+    omitSchemas: string[];
+    tags: Record<string, string>;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/validation.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Tool argument validator: behaves the same on Node and Workers, and its errors name the argument at fault.
+ *
+ * On Node the SDK uses Ajv by default, which reports an extra key only as "data must NOT have additional properties"
+ * without naming it, leaving the model to guess and drop keys one at a time. This uses the pure-JS @cfworker/json-schema
+ * engine everywhere (it is what Workers uses anyway), and checks for extra top-level keys before the engine, listing the
+ * extra and the accepted argument names directly.
+ */
+import type { jsonSchemaValidator } from '@modelcontextprotocol/server';
+/**
+ * The intent argument PostHog MCP analytics (analytics.ts) adds to every tool. The model fills it from the tool list, which
+ * may be cached: clients keep sending it after analytics is turned off, so validation always accepts and strips it, on or
+ * off, and it never reaches the API.
+ */
+export declare const CONTEXT_ARGUMENT = "context";
+export declare const toolInputValidator: jsonSchemaValidator;

package/dist/validation.js

@@ -0,0 +1,56 @@
+import { CfWorkerJsonSchemaValidator } from '@modelcontextprotocol/server/validators/cf-worker';
+const engine = new CfWorkerJsonSchemaValidator({ shortcircuit: false });
+/**
+ * The intent argument PostHog MCP analytics (analytics.ts) adds to every tool. The model fills it from the tool list, which
+ * may be cached: clients keep sending it after analytics is turned off, so validation always accepts and strips it, on or
+ * off, and it never reaches the API.
+ */
+export const CONTEXT_ARGUMENT = 'context';
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * Engine errors look like `#/limit: Instance type "string" is invalid. Expected "integer".`; this turns the JSON pointer
+ * into an argument path, and drops the vague outer errors the engine adds after a sub-schema fails ("Property x does not
+ * match schema" and the like).
+ */
+const NOISE = [/^Property "[^"]+" does not match (additional properties )?schema\.$/, /^False boolean schema\.$/];
+function readable(message) {
+    if (!message)
+        return 'Invalid arguments';
+    const lines = message
+        .split('; ')
+        .map((line) => line.replace(/^#\/?([^:]*):\s*/, (_m, path) => (path ? `${path.replace(/\//g, '.')}: ` : '')));
+    const specific = lines.filter((line) => !NOISE.some((re) => re.test(line.replace(/^[^:]*: /, ''))));
+    return [...new Set(specific.length > 0 ? specific : lines)].join('; ');
+}
+export const toolInputValidator = {
+    getValidator(schema) {
+        const validate = engine.getValidator(schema);
+        const known = Object.keys(schema.properties ?? {});
+        const strict = schema.additionalProperties === false;
+        const stripContext = !known.includes(CONTEXT_ARGUMENT);
+        return (raw) => {
+            let input = raw;
+            if (stripContext && isRecord(raw) && CONTEXT_ARGUMENT in raw) {
+                const { [CONTEXT_ARGUMENT]: _context, ...rest } = raw;
+                input = rest;
+            }
+            if (strict && isRecord(input)) {
+                const extra = Object.keys(input).filter((key) => !known.includes(key));
+                if (extra.length > 0) {
+                    return {
+                        valid: false,
+                        data: undefined,
+                        errorMessage: `Unknown arguments: ${extra.join(', ')}. This tool accepts only: ${known.join(', ')}`
+                    };
+                }
+            }
+            const result = validate(input);
+            if (result.valid)
+                return result;
+            return { valid: false, data: undefined, errorMessage: readable(result.errorMessage) };
+        };
+    }
+};
+//# sourceMappingURL=validation.js.map

package/dist/version.d.ts

@@ -0,0 +1,3 @@
+export declare const VERSION = "0.3.0";
+export declare const SERVER_NAME = "jinshuju";
+export declare const SERVER_TITLE = "Jinshuju MCP Server";

package/dist/version.js

@@ -0,0 +1,5 @@
+// release-please keeps this in sync through extra-files; the runtime does not read package.json because Workers has no file system.
+export const VERSION = '0.3.0'; // x-release-please-version
+export const SERVER_NAME = 'jinshuju';
+export const SERVER_TITLE = 'Jinshuju MCP Server';
+//# sourceMappingURL=version.js.map

package/dist/worker.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Cloudflare Workers entry (an optional deployment). No Durable Objects / KV: the server is fully stateless.
+ * With SENTRY_DSN set, exceptions go to Sentry (the SDK reads SENTRY_DSN / SENTRY_ENVIRONMENT from env itself); without it,
+ * nothing is sent.
+ */
+import { type CloudflareOptions } from '@sentry/cloudflare';
+type Env = Record<string, string | undefined>;
+/** Errors only, no tracing; no request bodies / IPs / cookies: tool arguments and results hold user data, same policy as analytics.ts. */
+export declare function sentryOptions(): CloudflareOptions;
+declare const _default: {
+    fetch(request: Request, env: Env, ctx: unknown): Promise<Response> | Response;
+};
+export default _default;

package/dist/worker.js

@@ -0,0 +1,30 @@
+/**
+ * Cloudflare Workers entry (an optional deployment). No Durable Objects / KV: the server is fully stateless.
+ * With SENTRY_DSN set, exceptions go to Sentry (the SDK reads SENTRY_DSN / SENTRY_ENVIRONMENT from env itself); without it,
+ * nothing is sent.
+ */
+import { withSentry } from '@sentry/cloudflare';
+import { createApp } from './app.js';
+import { configFromEnv } from './config.js';
+import { VERSION } from './version.js';
+let app;
+/** Errors only, no tracing; no request bodies / IPs / cookies: tool arguments and results hold user data, same policy as analytics.ts. */
+export function sentryOptions() {
+    return {
+        // Releases are organization-wide in Sentry, so the worker name keeps them apart from goldendata's; the name cannot contain /, so the npm package name won't do
+        release: `jinshuju-mcp@${VERSION}`,
+        dataCollection: { httpBodies: [], userInfo: false, cookies: false },
+        // Events are sent from the server, so the IP Sentry infers from the connection is this service's, not the user's; the javascript platform infers it by default, so turn it off explicitly
+        beforeSend(event) {
+            event.sdk = { ...event.sdk, settings: { ...event.sdk?.settings, infer_ip: 'never' } };
+            return event;
+        }
+    };
+}
+export default withSentry(sentryOptions, {
+    fetch(request, env, ctx) {
+        app ??= createApp({ config: configFromEnv(env) });
+        return app.fetch(request, env, ctx);
+    }
+});
+//# sourceMappingURL=worker.js.map