sublime-mcp 1.4.1

package/http.js

@@ -0,0 +1,43 @@
+// PROOF: F5 — 2026-08-17. Per-endpoint HTTP timeouts. Quick reads stay at
+// 10s so a hung backend fails fast; batch / install / search / find /
+// eval_python_latest / run_build get 120s because those can legitimately
+// exceed 10s while Sublime is still working.
+
+const port = process.platform === 'win32' ? 9500 : 9501;
+export const BASE = process.env.SUBLIME_MCP_BASE ?? `http://127.0.0.1:${port}`;
+
+export const DEFAULT_TIMEOUT_MS = 10_000;
+export const SLOW_TIMEOUT_MS = 120_000;
+export const SLOW_ENDPOINTS = new Set([
+  '/batch',
+  '/install_package',
+  '/search_packages',
+  '/find_in_files',
+  '/eval_python_latest',
+  '/run_build',
+]);
+
+export function timeoutMsFor(endpoint) {
+  return SLOW_ENDPOINTS.has(endpoint) ? SLOW_TIMEOUT_MS : DEFAULT_TIMEOUT_MS;
+}
+
+export async function get(endpoint, params = {}) {
+  const url = new URL(endpoint, BASE);
+  for (const [k, v] of Object.entries(params)) {
+    url.searchParams.set(k, String(v));
+  }
+  const r = await fetch(url, { signal: AbortSignal.timeout(timeoutMsFor(endpoint)) });
+  if (!r.ok) throw new Error(`HTTP ${r.status} from ${endpoint}`);
+  return r.json();
+}
+
+export async function post(endpoint, body = {}) {
+  const r = await fetch(new URL(endpoint, BASE), {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(timeoutMsFor(endpoint)),
+  });
+  if (!r.ok) throw new Error(`HTTP ${r.status} from ${endpoint}`);
+  return r.json();
+}

package/index.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { BASE, get, post } from './http.js';
+
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+// Fallback catalog, generated from the backend _MCP_TOOLS. Used only when
+// dynamic /mcp_tools discovery fails.
+const FALLBACK_TOOLS = JSON.parse(
+  readFileSync(join(dirname(fileURLToPath(import.meta.url)), 'fallback-tools.json'), 'utf8'),
+).tools;
+
+process.stderr.write(`mcp-commander: BASE=${BASE} platform=${process.platform}\n`);
+
+function ok(data) {
+  return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+
+const server = new McpServer({ name: 'sublime-mcp', version: '1.4.0' });
+server.setToolRequestHandlers();
+
+// ── JSON Schema → Zod (shallow) for dynamic discovery ────────────────────────
+// Backend /mcp_tools returns full JSON Schemas; MCP SDK registerTool requires
+// Zod shapes. Convert properties/required/defaults so clients still see real
+// param docs instead of empty passthrough objects.
+
+function jsonSchemaPropToZod(prop) {
+  if (!prop || typeof prop !== 'object') return z.unknown();
+  let t;
+  switch (prop.type) {
+    case 'string':
+      t = z.string();
+      break;
+    case 'integer':
+      t = z.number().int();
+      break;
+    case 'number':
+      t = z.number();
+      break;
+    case 'boolean':
+      t = z.boolean();
+      break;
+    case 'array':
+      t = z.array(prop.items ? jsonSchemaPropToZod(prop.items) : z.unknown());
+      break;
+    case 'object':
+      t = prop.properties ? jsonSchemaToZod(prop) : z.record(z.string(), z.unknown());
+      break;
+    default:
+      t = z.unknown();
+  }
+  if (prop.description) t = t.describe(prop.description);
+  return t;
+}
+
+function jsonSchemaToZod(schema) {
+  if (!schema || typeof schema !== 'object') return z.object({}).passthrough();
+  const props = schema.properties || {};
+  const required = new Set(schema.required || []);
+  const shape = {};
+  for (const [key, prop] of Object.entries(props)) {
+    let field = jsonSchemaPropToZod(prop);
+    if (!required.has(key)) {
+      if (prop && Object.prototype.hasOwnProperty.call(prop, 'default')) {
+        field = field.default(prop.default);
+      } else {
+        field = field.optional();
+      }
+    } else if (prop && Object.prototype.hasOwnProperty.call(prop, 'default')) {
+      field = field.default(prop.default);
+    }
+    shape[key] = field;
+  }
+  if (Object.keys(shape).length === 0) return z.object({}).passthrough();
+  // Allow extra keys agents sometimes send; backend is the real validator.
+  return z.object(shape).passthrough();
+}
+
+// ── Dynamic tool discovery from backend ──────────────────────────────────────
+
+async function loadDynamicTools() {
+  const MAX_RETRIES = 3;
+  const RETRY_DELAY_MS = 2000;
+
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      const toolsList = await get('/mcp_tools');
+      if (!toolsList?.tools) throw new Error('backend returned no tool list');
+
+      for (const tool of toolsList.tools) {
+        const inputSchema = jsonSchemaToZod(tool.inputSchema);
+        server.registerTool(
+          tool.name,
+          { description: tool.description, inputSchema },
+          async (args) => ok(await post('/' + tool.name, args ?? {})),
+        );
+      }
+      process.stderr.write(`mcp-commander: loaded ${toolsList.tools.length} dynamic tools from backend (attempt ${attempt})\n`);
+      return true;
+    } catch (e) {
+      if (attempt === MAX_RETRIES) {
+        process.stderr.write(`mcp-commander: dynamic tool discovery failed after ${MAX_RETRIES} attempts: ${e.message}\n`);
+      } else {
+        process.stderr.write(`mcp-commander: dynamic tool discovery attempt ${attempt} failed, retrying...\n`);
+        await new Promise(resolve => setTimeout(resolve, RETRY_DELAY_MS));
+      }
+    }
+  }
+
+  return false;
+}
+
+// ── generated fallback catalog ────────────────────────────────────────────────
+
+function registerFallbackTools() {
+  // GENERATED CATALOG. fallback-tools.json is produced from the backend's
+  // _MCP_TOOLS by tools/generate_fallback_catalog.py, so a discovery miss
+  // exposes the same tool surface the backend actually serves instead of a
+  // hand-maintained subset (F10). Every backend tool has a POST /{name}
+  // alias, so one uniform call shape works for all of them.
+  for (const tool of FALLBACK_TOOLS) {
+    server.registerTool(
+      tool.name,
+      { description: tool.description, inputSchema: jsonSchemaToZod(tool.inputSchema) },
+      async (args) => ok(await post('/' + tool.name, args ?? {})),
+    );
+  }
+  process.stderr.write(`mcp-commander: registered ${FALLBACK_TOOLS.length} generated fallback tools\n`);
+}
+
+// ── startup ───────────────────────────────────────────────────────────────────
+
+if (!await loadDynamicTools()) {
+  process.stderr.write('mcp-commander: dynamic discovery failed, using generated fallback catalog\n');
+  registerFallbackTools();
+}
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "sublime-mcp",
+  "version": "1.4.1",
+  "description": "MCP server for Sublime Text 4 — exposes editor state and editing tools to AI assistants via the Model Context Protocol.",
+  "type": "module",
+  "bin": {
+    "sublime-mcp": "bin/cli.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dpc00/sublime-mcp.git"
+  },
+  "keywords": [
+    "sublime-text",
+    "mcp",
+    "ai",
+    "claude"
+  ],
+  "author": "Donald Chitester",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/dpc00/sublime-mcp/issues"
+  },
+  "homepage": "https://github.com/dpc00/sublime-mcp#readme",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.4.3",
+    "prompts": "^2.4.2"
+  }
+}

package/test_batch.mjs

@@ -0,0 +1,72 @@
+// Integration test for packages/node-proxy/index.js.
+//
+// Unlike hitting port 9500 or 9502 directly, this launches index.js as a real
+// subprocess and speaks MCP over stdio — the same code path a real MCP client
+// (e.g. Claude Code configured with a stdio server entry) uses. This is what
+// caught the missing `_POST["/batch"]` route on the HTTP bridge: node-proxy's
+// dynamic tool discovery (loadDynamicTools) picks up `batch` from /mcp_tools
+// fine, but the generic passthrough posts to /batch on port 9500, which
+// 404'd until that route was added to sublime_mcp.py.
+//
+// Prerequisites:
+//   - Sublime Text running with sublime_mcp.py loaded (HTTP bridge on 9500)
+//   - At least one file open in ST
+//
+// Run:
+//   cd packages/node-proxy
+//   node test_batch.mjs
+
+import assert from 'node:assert/strict';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+
+async function main() {
+  const transport = new StdioClientTransport({
+    command: 'node',
+    args: ['index.js'],
+    cwd: import.meta.dirname,
+    stderr: 'pipe',
+  });
+
+  const client = new Client({ name: 'test-batch', version: '1.0.0' });
+  await client.connect(transport);
+
+  try {
+    const tools = await client.listTools();
+    const names = tools.tools.map(t => t.name);
+    assert.ok(names.includes('batch'), 'batch tool not discovered from backend');
+    console.log('PASS: batch discovered dynamically (%d tools total)', names.length);
+
+    const result = await client.callTool({
+      name: 'batch',
+      arguments: { calls: [{ tool: 'get_line_count' }, { tool: 'get_selection' }] },
+    });
+    const data = JSON.parse(result.content[0].text);
+    assert.ok(Array.isArray(data.results), 'batch response missing results array');
+    assert.equal(data.results.length, 2, 'expected 2 results');
+    assert.ok('line_count' in data.results[0], 'get_line_count result missing line_count');
+    assert.ok('selections' in data.results[1], 'get_selection result missing selections');
+    console.log('PASS: batch call returned populated results via the real proxy subprocess');
+
+    const failResult = await client.callTool({
+      name: 'batch',
+      arguments: { calls: [{ tool: 'get_line_count' }, { tool: 'no_such_tool_xyz' }] },
+    });
+    const failData = JSON.parse(failResult.content[0].text);
+    assert.equal(failData.results.length, 2);
+    assert.ok('error' in failData.results[1], 'expected error for unknown tool');
+    console.log('PASS: batch partial failure does not abort the whole call');
+  } finally {
+    await client.close();
+  }
+}
+
+main()
+  .then(() => {
+    console.log('All tests passed.');
+    process.exit(0);
+  })
+  .catch(err => {
+    console.error('FAIL:', err);
+    process.exit(1);
+  });

package/test_fallback_catalog.mjs

@@ -0,0 +1,111 @@
+// Integration test for the generated fallback catalog (F10).
+//
+// Launches index.js as a real MCP stdio subprocess against a fake backend
+// that deliberately fails `/mcp_tools` discovery, forcing the fallback path.
+// Before the fix that path exposed a hand-maintained 71-tool subset; it must
+// now expose the full generated catalog and route calls correctly.
+//
+// No Sublime Text required — the fake backend stands in for the HTTP bridge.
+//
+// Run:
+//   cd packages/node-proxy
+//   node test_fallback_catalog.mjs
+
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import { readFileSync } from 'node:fs';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+
+const CATALOG = JSON.parse(
+  readFileSync(new URL('./fallback-tools.json', import.meta.url), 'utf8'),
+).tools;
+
+// Fake bridge: 404 on /mcp_tools (kills discovery), echo on POST /{tool}.
+function startFakeBackend() {
+  const seen = [];
+  const server = http.createServer((req, res) => {
+    if (req.url.startsWith('/mcp_tools')) {
+      res.writeHead(404).end('no discovery for you');
+      return;
+    }
+    let body = '';
+    req.on('data', chunk => { body += chunk; });
+    req.on('end', () => {
+      seen.push({ url: req.url, method: req.method, body });
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ echo: req.url, args: body ? JSON.parse(body) : null }));
+    });
+  });
+  return new Promise(resolve => {
+    server.listen(0, '127.0.0.1', () => resolve({ server, seen, port: server.address().port }));
+  });
+}
+
+async function main() {
+  const { server, seen, port } = await startFakeBackend();
+
+  const transport = new StdioClientTransport({
+    command: 'node',
+    args: ['index.js'],
+    cwd: import.meta.dirname,
+    env: { ...process.env, SUBLIME_MCP_BASE: `http://127.0.0.1:${port}` },
+    stderr: 'pipe',
+  });
+
+  const client = new Client({ name: 'test-fallback-catalog', version: '1.0.0' });
+  await client.connect(transport);
+
+  try {
+    const listed = await client.listTools();
+    const names = new Set(listed.tools.map(t => t.name));
+
+    assert.equal(
+      names.size,
+      CATALOG.length,
+      `fallback exposed ${names.size} tools, expected the full generated catalog (${CATALOG.length})`,
+    );
+    for (const tool of CATALOG) {
+      assert.ok(names.has(tool.name), `fallback is missing ${tool.name}`);
+    }
+    console.log('PASS: discovery failure still exposes all %d generated tools', names.size);
+
+    // batch was the headline F10 omission: absent from the old hand-written
+    // fallback, so a discovery miss removed it from the agent entirely.
+    assert.ok(names.has('batch'), 'batch missing from fallback catalog');
+    const result = await client.callTool({
+      name: 'batch',
+      arguments: { calls: [{ tool: 'get_line_count' }] },
+    });
+    const data = JSON.parse(result.content[0].text);
+    assert.equal(data.echo, '/batch', 'batch did not route to POST /batch');
+    assert.deepEqual(data.args, { calls: [{ tool: 'get_line_count' }] });
+    console.log('PASS: batch routes through the fallback path with its arguments intact');
+
+    // A no-parameter tool must still post cleanly.
+    await client.callTool({ name: 'get_line_count', arguments: {} });
+    assert.ok(
+      seen.some(r => r.url === '/get_line_count' && r.method === 'POST'),
+      'get_line_count did not POST to its tool-name alias',
+    );
+    console.log('PASS: no-parameter tools post to their /{name} alias');
+
+    // Schemas must survive, not degrade to untyped passthrough.
+    const openFile = listed.tools.find(t => t.name === 'open_file');
+    assert.ok(openFile.inputSchema?.properties?.path, 'open_file lost its typed schema');
+    console.log('PASS: generated schemas reach the client');
+  } finally {
+    await client.close();
+    server.close();
+  }
+}
+
+main()
+  .then(() => {
+    console.log('All tests passed.');
+    process.exit(0);
+  })
+  .catch(err => {
+    console.error('FAIL:', err);
+    process.exit(1);
+  });