@j0hanz/thinkseq-mcp 2.0.0 → 2.2.0

package/dist/app.js

@@ -1,5 +1,8 @@
+import { readFile } from 'node:fs/promises';
+import process from 'node:process';
 import { resolvePackageIdentity, resolveRunDependencies, } from './appConfig/runDependencies.js';
 import { buildShutdownDependencies } from './appConfig/shutdown.js';
+import { runWithContext } from './lib/context.js';
 import { installConsoleBridge, installMcpLogging } from './lib/mcpLogging.js';
 const toError = (value) => value instanceof Error ? value : new Error(String(value));
 const createExit = (proc, exit) => exit ?? ((code) => proc.exit(code));
@@ -8,6 +11,19 @@ const createHandlerFor = (logError, exit) => (label) => (value) => {
     logError(`thinkseq: ${label}: ${error.message}`);
     exit(1);
 };
+async function getLocalIconData() {
+    try {
+        const iconPath = new URL('../assets/logo.svg', import.meta.url);
+        const buffer = await readFile(iconPath);
+        if (buffer.length > 2 * 1024 * 1024) {
+            console.warn('Warning: logo.svg is larger than 2MB');
+        }
+        return `data:image/svg+xml;base64,${buffer.toString('base64')}`;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function installProcessErrorHandlers(deps = {}) {
     const proc = deps.processLike ?? process;
     const logError = deps.logError ?? console.error;
@@ -20,16 +36,19 @@ export async function run(deps = {}) {
     const resolved = resolveRunDependencies(deps);
     const pkg = await resolved.readPackageJson(AbortSignal.timeout(resolved.packageReadTimeoutMs));
     const { name, version } = resolvePackageIdentity(pkg);
-    const server = resolved.createServer(name, version);
+    const localIcon = await getLocalIconData();
+    const server = resolved.createServer(name, version, localIcon);
     installMcpLogging(server);
     const { flush: flushConsole, restore: restoreConsole } = installConsoleBridge(server);
     process.on('exit', restoreConsole);
-    resolved.publishLifecycleEvent({
-        type: 'lifecycle.started',
-        ts: resolved.now(),
-    });
+    runWithContext(() => {
+        resolved.publishLifecycleEvent({
+            type: 'lifecycle.started',
+            ts: resolved.now(),
+        });
+    }, { requestId: 'lifecycle.started' });
     const engine = resolved.engineFactory();
-    resolved.registerTool(server, engine);
+    resolved.registerTool(server, engine, localIcon);
     const transport = await resolved.connectServer(server);
     flushConsole();
     resolved.installShutdownHandlers(buildShutdownDependencies(resolved, { server, engine, transport }));

package/dist/appConfig/env.d.ts

@@ -0,0 +1,3 @@
+export declare const APP_ENV: {
+    readonly INCLUDE_TEXT_CONTENT: boolean;
+};

package/dist/appConfig/env.js

@@ -0,0 +1,9 @@
+import process from 'node:process';
+const FALSY_ENV_VALUES = new Set(['0', 'false', 'no', 'off']);
+function resolveIncludeTextContent() {
+    const raw = process.env.THINKSEQ_INCLUDE_TEXT_CONTENT;
+    return raw === undefined || !FALSY_ENV_VALUES.has(raw.trim().toLowerCase());
+}
+export const APP_ENV = {
+    INCLUDE_TEXT_CONTENT: resolveIncludeTextContent(),
+};

package/dist/appConfig/runDependencies.d.ts

@@ -8,9 +8,9 @@ export interface RunDependencies {
     shutdownTimeoutMs?: number;
     readPackageJson?: (signal?: AbortSignal) => Promise<PackageInfo>;
     publishLifecycleEvent?: (event: LifecycleEvent) => void;
-    createServer?: (name: string, version: string) => ServerLike;
+    createServer?: (name: string, version: string, icon?: string) => ServerLike;
     connectServer?: (server: ServerLike, createTransport?: () => TransportLike) => Promise<TransportLike>;
-    registerTool?: (server: ServerLike, engine: EngineLike) => void;
+    registerTool?: (server: ServerLike, engine: EngineLike, icon?: string) => void;
     engineFactory?: () => EngineLike;
     installShutdownHandlers?: (deps: ShutdownDependencies) => void;
     now?: () => number;
@@ -21,9 +21,9 @@ export interface ResolvedRunDependencies {
     shutdownTimeoutMs?: number;
     readPackageJson: (signal?: AbortSignal) => Promise<PackageInfo>;
     publishLifecycleEvent: (event: LifecycleEvent) => void;
-    createServer: (name: string, version: string) => ServerLike;
+    createServer: (name: string, version: string, icon?: string) => ServerLike;
     connectServer: (server: ServerLike, createTransport?: () => TransportLike) => Promise<TransportLike>;
-    registerTool: (server: ServerLike, engine: EngineLike) => void;
+    registerTool: (server: ServerLike, engine: EngineLike, icon?: string) => void;
     engineFactory: () => EngineLike;
     installShutdownHandlers: (deps: ShutdownDependencies) => void;
     now: () => number;

package/dist/appConfig/runDependencies.js

@@ -1,4 +1,4 @@
-import { readFileSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
 import { McpServer, ResourceTemplate, } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ThinkingEngine } from '../engine.js';
@@ -9,55 +9,68 @@ import { registerThinkSeq } from '../tools/thinkseq.js';
 import { installShutdownHandlers } from './shutdown.js';
 const INSTRUCTIONS_URL = new URL('../instructions.md', import.meta.url);
 const INSTRUCTIONS_FALLBACK = 'ThinkSeq is a tool for structured, sequential thinking with revision support.';
-function readInstructionsText() {
+async function readInstructionsText() {
     try {
-        return readFileSync(INSTRUCTIONS_URL, { encoding: 'utf8' });
+        return await readFile(INSTRUCTIONS_URL, { encoding: 'utf8' });
     }
     catch {
         return INSTRUCTIONS_FALLBACK;
     }
 }
-function loadServerInstructions() {
-    const raw = readInstructionsText();
+function loadServerInstructions(raw) {
     const trimmed = raw.trim();
     return trimmed.length > 0 ? trimmed : INSTRUCTIONS_FALLBACK;
 }
-function registerInstructionsResource(server) {
-    server.registerResource('instructions', new ResourceTemplate('internal://instructions', {
-        list: () => ({
-            resources: [
-                {
-                    uri: 'internal://instructions',
-                    name: 'Instructions',
-                    mimeType: 'text/markdown',
-                },
-            ],
-        }),
-    }), { title: 'Instructions', mimeType: 'text/markdown' }, (uri) => ({
-        contents: [
+const INSTRUCTIONS_RESOURCE_TEMPLATE = new ResourceTemplate('internal://instructions', {
+    list: () => ({
+        resources: [
             {
-                uri: uri.href,
-                text: readInstructionsText(),
+                uri: 'internal://instructions',
+                name: 'Instructions',
                 mimeType: 'text/markdown',
             },
         ],
-    }));
+    }),
+});
+const INSTRUCTIONS_METADATA = {
+    title: 'Instructions',
+    mimeType: 'text/markdown',
+};
+const readInstructionsResource = (uri) => ({
+    contents: [
+        {
+            uri: uri.href,
+            text: INSTRUCTIONS_TEXT,
+            mimeType: 'text/markdown',
+        },
+    ],
+});
+function registerInstructionsResource(server) {
+    server.registerResource('instructions', INSTRUCTIONS_RESOURCE_TEMPLATE, INSTRUCTIONS_METADATA, readInstructionsResource);
 }
-const SERVER_INSTRUCTIONS = loadServerInstructions();
+const INSTRUCTIONS_TEXT = await readInstructionsText();
+const SERVER_INSTRUCTIONS = loadServerInstructions(INSTRUCTIONS_TEXT);
 const DEFAULT_PACKAGE_READ_TIMEOUT_MS = 2000;
-function buildServerConfig() {
+function buildServerCapabilities(overrides = {}) {
     return {
-        instructions: SERVER_INSTRUCTIONS,
-        capabilities: {
-            logging: {},
-            tools: { listChanged: false },
-            resources: { subscribe: false, listChanged: false },
-            prompts: { listChanged: false },
-        },
+        logging: {},
+        tools: { listChanged: false },
+        resources: { subscribe: false, listChanged: false },
+        prompts: { listChanged: false },
+        ...overrides,
     };
 }
-const defaultCreateServer = (name, version) => {
-    const server = new McpServer({ name, version }, buildServerConfig());
+const defaultCreateServer = (name, version, icon) => {
+    const capabilities = buildServerCapabilities();
+    const server = new McpServer({ name, version }, {
+        instructions: SERVER_INSTRUCTIONS,
+        capabilities,
+        ...(icon
+            ? {
+                icons: [{ src: icon, mimeType: 'image/svg+xml', sizes: ['any'] }],
+            }
+            : {}),
+    });
     registerInstructionsResource(server);
     server.registerPrompt('get-help', {
         description: 'Get usage instructions for this server',

package/dist/appConfig/shutdown.js

@@ -1,3 +1,4 @@
+import { runWithContext } from '../lib/context.js';
 import { publishLifecycleEvent } from '../lib/diagnostics.js';
 const DEFAULT_SHUTDOWN_TIMEOUT_MS = 5000;
 function isRecord(value) {
@@ -35,11 +36,13 @@ function buildShutdownRunner(deps, proc) {
         if (shuttingDown)
             return;
         shuttingDown = true;
-        emit({
-            type: 'lifecycle.shutdown',
-            ts: timestamp(),
-            signal,
-        });
+        runWithContext(() => {
+            emit({
+                type: 'lifecycle.shutdown',
+                ts: timestamp(),
+                signal,
+            });
+        }, { requestId: `lifecycle.shutdown:${signal}` });
         await closeAllWithinTimeout([deps.server, deps.engine, deps.transport], timeoutMs);
         proc.exit(0);
     };