@treedy/lsp-mcp 0.1.0 → 0.1.3

package/README.md

@@ -5,10 +5,10 @@ Unified MCP server aggregating multi-language LSP backends for code intelligence
 ## Features
 
 - **Unified Entry Point**: Single MCP server for multiple languages
-- **Namespaced Tools**: `python/hover`, `typescript/definition`, etc.
-- **Auto Language Detection**: Infers language from file extensions
+- **Namespaced Tools**: `python_hover`, `typescript_definition`, etc.
+- **On-Demand Loading**: Backends are installed and started only when needed
+- **Dynamic Tool Registration**: Backend tools are discovered automatically
 - **Skill Prompts**: Best practices exposed as MCP prompts for agents
-- **Lazy Loading**: Backends start on first use
 - **Graceful Degradation**: Clear error messages when backends unavailable
 
 ## Installation
@@ -67,17 +67,17 @@ This ensures backends are always up-to-date when the server starts. To disable a
 
 | Tool | Description |
 |------|-------------|
-| `{lang}/hover` | Get type information and documentation |
-| `{lang}/definition` | Go to definition |
-| `{lang}/references` | Find all references |
-| `{lang}/completions` | Code completion suggestions |
-| `{lang}/diagnostics` | Type errors and warnings |
-| `{lang}/symbols` | Extract symbols from file |
-| `{lang}/rename` | Rename symbol |
-| `{lang}/search` | Regex pattern search |
-| `{lang}/signature_help` | Function signature help |
-| `{lang}/update_document` | Update file for incremental analysis |
-| `{lang}/status` | Backend status |
+| `{lang}_hover` | Get type information and documentation |
+| `{lang}_definition` | Go to definition |
+| `{lang}_references` | Find all references |
+| `{lang}_completions` | Code completion suggestions |
+| `{lang}_diagnostics` | Type errors and warnings |
+| `{lang}_symbols` | Extract symbols from file |
+| `{lang}_rename` | Rename symbol |
+| `{lang}_search` | Regex pattern search |
+| `{lang}_signature_help` | Function signature help |
+| `{lang}_update_document` | Update file for incremental analysis |
+| `{lang}_status` | Backend status |
 
 Replace `{lang}` with `python` or `typescript`.
 
@@ -85,20 +85,41 @@ Replace `{lang}` with `python` or `typescript`.
 
 | Tool | Description |
 |------|-------------|
-| `python/move` | Move function/class to another module |
-| `python/change_signature` | Modify function signature |
-| `python/function_signature` | Get current function signature |
-| `python/set_backend` | Switch between rope/pyright |
-| `python/set_python_path` | Set Python interpreter |
+| `python_move` | Move function/class to another module |
+| `python_change_signature` | Modify function signature |
+| `python_function_signature` | Get current function signature |
+| `python_set_backend` | Switch between rope/pyright |
+| `python_set_python_path` | Set Python interpreter |
 
 ### Meta Tools
 
 | Tool | Description |
 |------|-------------|
+| `list_backends` | List available backends and their status |
+| `start_backend` | Install and start a backend (downloads if needed) |
 | `status` | Overall server and backend status with versions |
 | `check_versions` | Detailed version info for server and all backends |
 | `switch_python_backend` | Switch Python provider |
 
+## Quick Start
+
+1. **List available backends**:
+   ```
+   list_backends
+   ```
+
+2. **Start a backend** (this will download and install if needed):
+   ```
+   start_backend language=python
+   start_backend language=typescript
+   ```
+
+3. **Use backend tools** (available after starting):
+   ```
+   python_hover file=/path/to/file.py line=10 column=5
+   typescript_definition file=/path/to/file.ts line=15 column=10
+   ```
+
 ## Available Prompts (Skills)
 
 The server exposes skill documentation as MCP prompts that agents can request:
@@ -142,7 +163,7 @@ Repeat until clean
 
 ```json
 {
-  "name": "python/hover",
+  "name": "python_hover",
   "arguments": {
     "file": "/path/to/file.py",
     "line": 10,
@@ -155,7 +176,7 @@ Repeat until clean
 
 ```json
 {
-  "name": "typescript/definition",
+  "name": "typescript_definition",
   "arguments": {
     "file": "/path/to/file.ts",
     "line": 15,
@@ -193,7 +214,7 @@ This will automatically route to the Python backend.
 │                                                                  │
 │  ┌────────────────────────────────────────────────────────────┐ │
 │  │                    Tool Router                              │ │
-│  │  - Parse tool name (python/hover → {lang, tool})           │ │
+│  │  - Parse tool name (python_hover → {lang, tool})           │ │
 │  │  - Infer language from file extension                      │ │
 │  │  - Route to appropriate backend                            │ │
 │  └────────────────────────────────────────────────────────────┘ │

package/dist/index.js

@@ -19835,6 +19835,9 @@ class StdioServerTransport {
   }
 }
 
+// src/index.ts
+import { createRequire as createRequire2 } from "module";
+
 // src/config.ts
 function loadConfig() {
   const pythonEnabled = getEnvBool("LSP_MCP_PYTHON_ENABLED", true);
@@ -20739,84 +20742,6 @@ class BackendManager {
   }
 }
 
-// src/backends/python.ts
-var pythonPositionSchema = {
-  file: exports_external.string().describe("Absolute path to the Python file"),
-  line: exports_external.number().int().positive().describe("Line number (1-based)"),
-  column: exports_external.number().int().positive().describe("Column number (1-based)")
-};
-var pythonToolDescriptions = {
-  hover: "Get type information and documentation at a specific position in a Python file",
-  definition: "Go to definition of a symbol at a specific position in a Python file",
-  references: "Find all references to a symbol at a specific position in a Python file",
-  completions: "Get code completion suggestions at a specific position in a Python file",
-  diagnostics: "Get type errors and warnings for a Python file or directory",
-  symbols: "Extract symbols (classes, functions, methods, variables) from a Python file",
-  rename: "Rename a symbol and update all references in Python files",
-  search: "Search for a regex pattern in Python files",
-  signature_help: "Get function signature help at a specific position in a Python file",
-  update_document: "Update file content for incremental analysis in Python",
-  status: "Check Python/Pyright environment status",
-  move: "Move a function or class to another Python module",
-  change_signature: "Change the signature of a Python function",
-  function_signature: "Get the current signature of a Python function",
-  set_backend: "Set the backend (rope/pyright) for Python code analysis",
-  set_python_path: "Set the Python interpreter path for code analysis"
-};
-
-// src/backends/typescript.ts
-var typescriptPositionSchema = {
-  file: exports_external.string().describe("Absolute path to the TypeScript/JavaScript file"),
-  line: exports_external.number().int().positive().describe("Line number (1-based)"),
-  column: exports_external.number().int().positive().describe("Column number (1-based)")
-};
-var typescriptToolDescriptions = {
-  hover: "Get type information and documentation at a specific position in a TypeScript/JavaScript file",
-  definition: "Go to definition of a symbol at a specific position",
-  references: "Find all references to a symbol at a specific position",
-  completions: "Get code completion suggestions at a specific position",
-  diagnostics: "Get type errors and warnings for a TypeScript/JavaScript file",
-  symbols: "Extract symbols (classes, functions, methods, variables) from a file",
-  rename: "Preview renaming a symbol (shows all locations that would be renamed)",
-  search: "Search for a regex pattern in TypeScript/JavaScript files",
-  signature_help: "Get function signature help at a specific position",
-  update_document: "Update file content for incremental analysis",
-  status: "Check TypeScript environment status for a project"
-};
-
-// src/tools/schemas.ts
-var positionArgs = {
-  file: exports_external.string().describe("Absolute path to the file"),
-  line: exports_external.number().int().positive().describe("Line number (1-based)"),
-  column: exports_external.number().int().positive().describe("Column number (1-based)")
-};
-var searchArgs = {
-  pattern: exports_external.string().describe("The regex pattern to search for"),
-  path: exports_external.string().optional().describe("Directory or file to search in"),
-  glob: exports_external.string().optional().describe("Glob pattern to filter files"),
-  caseSensitive: exports_external.boolean().default(true).describe("Whether the search is case sensitive"),
-  maxResults: exports_external.number().int().positive().default(50).describe("Maximum number of results")
-};
-var diagnosticsArgs = {
-  path: exports_external.string().describe("Path to a file or directory to check")
-};
-var renameArgs = {
-  ...positionArgs,
-  newName: exports_external.string().describe("New name for the symbol")
-};
-var symbolsArgs = {
-  file: exports_external.string().describe("Absolute path to the file"),
-  query: exports_external.string().optional().describe("Optional filter query for symbol names")
-};
-var updateDocumentArgs = {
-  file: exports_external.string().describe("Absolute path to the file"),
-  content: exports_external.string().describe("New content for the file")
-};
-var completionsArgs = {
-  ...positionArgs,
-  limit: exports_external.number().int().positive().default(20).describe("Maximum number of completions to return")
-};
-
 // src/tools/meta.ts
 import { readFileSync } from "fs";
 import { dirname, join } from "path";
@@ -20852,8 +20777,9 @@ async function status(backendManager, config2) {
       status: v.status
     })),
     usage: {
-      namespaced: "Use python/hover or typescript/hover to specify language",
-      auto_infer: "Or provide a file path and language will be inferred from extension"
+      list: "Use list_backends to see available backends",
+      start: "Use start_backend to install and start a backend",
+      tools: "Once started, tools are available as python_hover, typescript_definition, etc."
     }
   };
   return {
@@ -20921,6 +20847,99 @@ function switchPythonBackend(provider) {
     content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
   };
 }
+async function listBackends(backendManager, config2) {
+  const backendStatus = backendManager.getStatus();
+  const backends = [
+    {
+      name: "python",
+      enabled: config2.python.enabled,
+      provider: config2.python.provider,
+      status: backendStatus.python?.status || "not_started",
+      tools: backendStatus.python?.tools || 0,
+      description: "Python code intelligence (hover, definition, references, refactoring)",
+      startCommand: "Use start_backend tool with language='python'"
+    },
+    {
+      name: "typescript",
+      enabled: config2.typescript.enabled,
+      status: backendStatus.typescript?.status || "not_started",
+      tools: backendStatus.typescript?.tools || 0,
+      description: "TypeScript/JavaScript code intelligence",
+      startCommand: "Use start_backend tool with language='typescript'"
+    }
+  ];
+  const result = {
+    backends,
+    usage: {
+      start: "Call start_backend with language='python' or 'typescript' to install and start a backend",
+      tools: "Once started, backend tools will be available as {language}_{tool} (e.g., python_hover)"
+    }
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+  };
+}
+var startBackendSchema = {
+  language: exports_external.enum(["python", "typescript"]).describe("The backend to start")
+};
+async function startBackend(language, backendManager, config2, registerToolsCallback) {
+  if (language === "python" && !config2.python.enabled) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          error: "Python backend is disabled",
+          hint: "Set LSP_MCP_PYTHON_ENABLED=true to enable"
+        }, null, 2)
+      }]
+    };
+  }
+  if (language === "typescript" && !config2.typescript.enabled) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          error: "TypeScript backend is disabled",
+          hint: "Set LSP_MCP_TYPESCRIPT_ENABLED=true to enable"
+        }, null, 2)
+      }]
+    };
+  }
+  try {
+    const toolCount = await registerToolsCallback(language);
+    const backendStatus = backendManager.getStatus();
+    const status2 = backendStatus[language];
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          language,
+          status: status2?.status,
+          serverName: status2?.serverName,
+          version: status2?.version,
+          toolsRegistered: toolCount,
+          message: `${language} backend started successfully. ${toolCount} tools are now available.`,
+          usage: `Tools are available as ${language}_hover, ${language}_definition, etc.`
+        }, null, 2)
+      }]
+    };
+  } catch (error2) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          language,
+          error: String(error2),
+          hint: "Check if the backend package is available and network connection is working"
+        }, null, 2)
+      }]
+    };
+  }
+}
 
 // src/prompts.ts
 var skillsContent = {
@@ -21419,151 +21438,121 @@ Or use file extension auto-detection by providing a file path.
 }
 
 // src/index.ts
+var require2 = createRequire2(import.meta.url);
+var packageJson = require2("../package.json");
 var config2 = loadConfig();
 var backendManager = new BackendManager(config2);
+var startedBackends = new Set;
 var server = new McpServer({
   name: "lsp-mcp",
-  version: "0.1.0"
+  version: packageJson.version
 });
 registerPrompts(server);
+function jsonSchemaToZod(schema) {
+  const result = {};
+  if (!schema || !schema.properties) {
+    return result;
+  }
+  const required2 = new Set(schema.required || []);
+  for (const [key, prop] of Object.entries(schema.properties)) {
+    let zodType;
+    switch (prop.type) {
+      case "string":
+        zodType = exports_external.string();
+        if (prop.enum) {
+          zodType = exports_external.enum(prop.enum);
+        }
+        break;
+      case "number":
+      case "integer":
+        zodType = exports_external.number();
+        if (prop.type === "integer") {
+          zodType = zodType.int();
+        }
+        if (prop.exclusiveMinimum !== undefined) {
+          zodType = zodType.gt(prop.exclusiveMinimum);
+        }
+        if (prop.minimum !== undefined) {
+          zodType = zodType.gte(prop.minimum);
+        }
+        if (prop.maximum !== undefined) {
+          zodType = zodType.lte(prop.maximum);
+        }
+        break;
+      case "boolean":
+        zodType = exports_external.boolean();
+        break;
+      case "array":
+        if (prop.items?.type === "string") {
+          zodType = exports_external.array(exports_external.string());
+        } else {
+          zodType = exports_external.array(exports_external.any());
+        }
+        break;
+      case "object":
+        zodType = exports_external.record(exports_external.any());
+        break;
+      default:
+        zodType = exports_external.any();
+    }
+    if (prop.description) {
+      zodType = zodType.describe(prop.description);
+    }
+    if (prop.default !== undefined) {
+      zodType = zodType.default(prop.default);
+    }
+    if (!required2.has(key)) {
+      zodType = zodType.optional();
+    }
+    result[key] = zodType;
+  }
+  return result;
+}
+function registerBackendTools(language, tools) {
+  let count = 0;
+  for (const tool of tools) {
+    const namespacedName = `${language}_${tool.name}`;
+    const zodSchema = jsonSchemaToZod(tool.inputSchema);
+    server.registerTool(namespacedName, {
+      description: tool.description || `${language} ${tool.name} tool`,
+      inputSchema: zodSchema
+    }, async (args) => backendManager.callTool(language, tool.name, args));
+    console.error(`[lsp-mcp] Registered ${namespacedName}`);
+    count++;
+  }
+  return count;
+}
+async function startAndRegisterBackend(language) {
+  if (startedBackends.has(language)) {
+    const status2 = backendManager.getStatus()[language];
+    console.error(`[lsp-mcp] ${language} backend already started (${status2?.tools} tools)`);
+    return status2?.tools || 0;
+  }
+  console.error(`[lsp-mcp] Starting ${language} backend...`);
+  try {
+    const tools = await backendManager.getTools(language);
+    const count = registerBackendTools(language, tools);
+    startedBackends.add(language);
+    console.error(`[lsp-mcp] ${language}: ${count} tools registered`);
+    return count;
+  } catch (error2) {
+    console.error(`[lsp-mcp] Failed to start ${language} backend:`, error2);
+    throw error2;
+  }
+}
 server.registerTool("status", { description: "Get status of all LSP backends and server configuration" }, async () => status(backendManager, config2));
 server.registerTool("check_versions", { description: "Check versions of all backends and server. Shows installed versions and how to check for updates." }, async () => checkVersions(backendManager, config2));
 server.registerTool("switch_python_backend", {
   description: "Switch the Python backend provider (requires restart)",
   inputSchema: switchPythonBackendSchema
 }, async ({ provider }) => switchPythonBackend(provider));
-if (config2.python.enabled) {
-  const backendOption = exports_external.enum(["rope", "pyright"]).optional().describe("Backend to use (rope/pyright)");
-  server.registerTool("python/hover", {
-    description: pythonToolDescriptions.hover,
-    inputSchema: { ...positionArgs, backend: backendOption }
-  }, async (args) => backendManager.callTool("python", "hover", args));
-  server.registerTool("python/definition", {
-    description: pythonToolDescriptions.definition,
-    inputSchema: { ...positionArgs, backend: backendOption }
-  }, async (args) => backendManager.callTool("python", "definition", args));
-  server.registerTool("python/references", {
-    description: pythonToolDescriptions.references,
-    inputSchema: { ...positionArgs, backend: backendOption }
-  }, async (args) => backendManager.callTool("python", "references", args));
-  server.registerTool("python/completions", {
-    description: pythonToolDescriptions.completions,
-    inputSchema: { ...completionsArgs, backend: backendOption }
-  }, async (args) => backendManager.callTool("python", "completions", args));
-  server.registerTool("python/diagnostics", {
-    description: pythonToolDescriptions.diagnostics,
-    inputSchema: diagnosticsArgs
-  }, async (args) => backendManager.callTool("python", "diagnostics", args));
-  server.registerTool("python/symbols", {
-    description: pythonToolDescriptions.symbols,
-    inputSchema: { ...symbolsArgs, backend: backendOption }
-  }, async (args) => backendManager.callTool("python", "symbols", args));
-  server.registerTool("python/rename", {
-    description: pythonToolDescriptions.rename,
-    inputSchema: { ...positionArgs, new_name: exports_external.string().describe("New name for the symbol") }
-  }, async (args) => backendManager.callTool("python", "rename", args));
-  server.registerTool("python/search", {
-    description: pythonToolDescriptions.search,
-    inputSchema: searchArgs
-  }, async (args) => backendManager.callTool("python", "search", args));
-  server.registerTool("python/signature_help", {
-    description: pythonToolDescriptions.signature_help,
-    inputSchema: positionArgs
-  }, async (args) => backendManager.callTool("python", "signature_help", args));
-  server.registerTool("python/update_document", {
-    description: pythonToolDescriptions.update_document,
-    inputSchema: updateDocumentArgs
-  }, async (args) => backendManager.callTool("python", "update_document", args));
-  server.registerTool("python/status", {
-    description: pythonToolDescriptions.status
-  }, async () => backendManager.callTool("python", "status", {}));
-  server.registerTool("python/move", {
-    description: pythonToolDescriptions.move,
-    inputSchema: {
-      ...positionArgs,
-      destination: exports_external.string().describe('Destination module path (e.g., "mypackage.utils")'),
-      preview: exports_external.boolean().default(false).describe("If true, only show what would change")
-    }
-  }, async (args) => backendManager.callTool("python", "move", args));
-  server.registerTool("python/change_signature", {
-    description: pythonToolDescriptions.change_signature,
-    inputSchema: {
-      ...positionArgs,
-      new_params: exports_external.array(exports_external.string()).optional().describe("New parameter order"),
-      add_param: exports_external.string().optional().describe("Name of parameter to add"),
-      add_param_default: exports_external.string().optional().describe("Default value for added parameter"),
-      add_param_index: exports_external.number().int().optional().describe("Index where to insert new param"),
-      remove_param: exports_external.string().optional().describe("Name of parameter to remove"),
-      preview: exports_external.boolean().default(false).describe("If true, only show what would change")
-    }
-  }, async (args) => backendManager.callTool("python", "change_signature", args));
-  server.registerTool("python/function_signature", {
-    description: pythonToolDescriptions.function_signature,
-    inputSchema: positionArgs
-  }, async (args) => backendManager.callTool("python", "function_signature", args));
-  server.registerTool("python/set_backend", {
-    description: pythonToolDescriptions.set_backend,
-    inputSchema: {
-      backend: exports_external.enum(["rope", "pyright"]).describe("The backend to use"),
-      tool: exports_external.string().optional().describe("Optional tool name to set backend for")
-    }
-  }, async (args) => backendManager.callTool("python", "set_backend", args));
-  server.registerTool("python/set_python_path", {
-    description: pythonToolDescriptions.set_python_path,
-    inputSchema: {
-      python_path: exports_external.string().describe("Absolute path to the Python interpreter"),
-      workspace: exports_external.string().optional().describe("Optional workspace to set the path for")
-    }
-  }, async (args) => backendManager.callTool("python", "set_python_path", args));
-}
-if (config2.typescript.enabled) {
-  server.registerTool("typescript/hover", {
-    description: typescriptToolDescriptions.hover,
-    inputSchema: positionArgs
-  }, async (args) => backendManager.callTool("typescript", "hover", args));
-  server.registerTool("typescript/definition", {
-    description: typescriptToolDescriptions.definition,
-    inputSchema: positionArgs
-  }, async (args) => backendManager.callTool("typescript", "definition", args));
-  server.registerTool("typescript/references", {
-    description: typescriptToolDescriptions.references,
-    inputSchema: positionArgs
-  }, async (args) => backendManager.callTool("typescript", "references", args));
-  server.registerTool("typescript/completions", {
-    description: typescriptToolDescriptions.completions,
-    inputSchema: completionsArgs
-  }, async (args) => backendManager.callTool("typescript", "completions", args));
-  server.registerTool("typescript/diagnostics", {
-    description: typescriptToolDescriptions.diagnostics,
-    inputSchema: diagnosticsArgs
-  }, async (args) => backendManager.callTool("typescript", "diagnostics", args));
-  server.registerTool("typescript/symbols", {
-    description: typescriptToolDescriptions.symbols,
-    inputSchema: symbolsArgs
-  }, async (args) => backendManager.callTool("typescript", "symbols", args));
-  server.registerTool("typescript/rename", {
-    description: typescriptToolDescriptions.rename,
-    inputSchema: renameArgs
-  }, async (args) => backendManager.callTool("typescript", "rename", args));
-  server.registerTool("typescript/search", {
-    description: typescriptToolDescriptions.search,
-    inputSchema: searchArgs
-  }, async (args) => backendManager.callTool("typescript", "search", args));
-  server.registerTool("typescript/signature_help", {
-    description: typescriptToolDescriptions.signature_help,
-    inputSchema: positionArgs
-  }, async (args) => backendManager.callTool("typescript", "signature_help", args));
-  server.registerTool("typescript/update_document", {
-    description: typescriptToolDescriptions.update_document,
-    inputSchema: updateDocumentArgs
-  }, async (args) => backendManager.callTool("typescript", "update_document", args));
-  server.registerTool("typescript/status", {
-    description: typescriptToolDescriptions.status,
-    inputSchema: {
-      file: exports_external.string().describe("A TypeScript/JavaScript file to check project status for")
-    }
-  }, async (args) => backendManager.callTool("typescript", "status", args));
-}
+server.registerTool("list_backends", {
+  description: "List available backends and their status. Shows which backends are installed, running, and how many tools they provide."
+}, async () => listBackends(backendManager, config2));
+server.registerTool("start_backend", {
+  description: "Start a backend and register its tools. This will download and install the backend if needed, then make its tools available.",
+  inputSchema: startBackendSchema
+}, async ({ language }) => startBackend(language, backendManager, config2, startAndRegisterBackend));
 async function gracefulShutdown(signal) {
   console.error(`
 [lsp-mcp] Received ${signal}, shutting down gracefully...`);
@@ -21581,12 +21570,15 @@ process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
 process.on("SIGINT", () => gracefulShutdown("SIGINT"));
 async function main() {
   console.error("LSP MCP Server - Unified Multi-Language Code Intelligence");
+  console.error(`  Version: ${packageJson.version}`);
   console.error("  Python:", config2.python.enabled ? `enabled (${config2.python.provider})` : "disabled");
   console.error("  TypeScript:", config2.typescript.enabled ? "enabled" : "disabled");
   console.error("");
-  console.error("Tools are namespaced: python/hover, typescript/definition, etc.");
+  console.error("Backends are loaded on-demand. Use these tools to get started:");
+  console.error("  - list_backends: See available backends and their status");
+  console.error("  - start_backend: Install and start a backend (e.g., start_backend language=python)");
+  console.error("");
   console.error("Prompts available: code-navigation, refactoring, code-analysis, lsp-rules, lsp-quick-start");
-  console.error("Backends start lazily on first tool call.");
   console.error("");
   const transport = new StdioServerTransport;
   await server.connect(transport);
@@ -21597,4 +21589,4 @@ main().catch((error2) => {
   process.exit(1);
 });
 
-//# debugId=4B43BCFD3247DF0564756E2164756E21
+//# debugId=A15518B7EDCDD67064756E2164756E21