@lvce-editor/shared-process 0.89.3 → 0.90.2

package/config/defaultSettings.json

@@ -35,12 +35,10 @@
 
   "sessionReplay.enabled": false,
 
-  "serviceWorker.enabled": false,
-
   "simpleBrowser.suggestions": false,
 
   "terminal.backend": "real",
-  "terminal.renderer": "termterm",
+  "terminal.renderer": "xterm",
   "terminal.separateConnection": false,
 
   "window.titleBarStyle": "custom",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.89.3",
+  "version": "0.90.2",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -19,7 +19,7 @@
   "dependencies": {
     "@lvce-editor/assert": "1.7.0",
     "@lvce-editor/auth-process": "1.9.0",
-    "@lvce-editor/extension-host-helper-process": "0.89.3",
+    "@lvce-editor/extension-host-helper-process": "0.90.2",
     "@lvce-editor/ipc": "16.3.0",
     "@lvce-editor/json-rpc": "8.2.0",
     "@lvce-editor/jsonc-parser": "1.5.0",
@@ -28,6 +28,7 @@
     "@lvce-editor/rpc-registry": "9.35.0",
     "@lvce-editor/verror": "1.7.0",
     "is-object": "^1.0.2",
+    "markdown-it": "^14.3.0",
     "xdg-basedir": "^5.1.0"
   },
   "optionalDependencies": {

package/src/parts/BuiltinExtensionsPath/BuiltinExtensionsPath.js

@@ -3,6 +3,6 @@ import { fileURLToPath } from 'url'
 
 export const getBuiltinExtensionsPath = () => {
   const staticServerPath = fileURLToPath(import.meta.resolve('@lvce-editor/static-server'))
-  const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', 'f1db6cb', 'extensions')
+  const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', '6faf35c', 'extensions')
   return builtinExtensionsPath
 }

package/src/parts/LanguageServerConnection/LanguageServerConnection.js

@@ -1,7 +1,11 @@
 import { spawn,                                     } from 'node:child_process'
-import { basename } from 'node:path'
+import { basename, extname } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { LanguageServerMessageParser } from '../LanguageServerMessageParser/LanguageServerMessageParser.js'
+import {
+  executeMarkdownLanguageServerRequest,
+  isMarkdownLanguageServerRequest,
+} from '../MarkdownLanguageServerRequest/MarkdownLanguageServerRequest.js'
 
                           
                     
@@ -36,6 +40,21 @@ import { LanguageServerMessageParser } from '../LanguageServerMessageParser/Lang
                           
                       
  
+
+const getSpawnOptions = (uri, argv) => {
+  const executablePath = fileURLToPath(uri)
+  const extension = extname(executablePath).toLowerCase()
+  if (extension === '.js' || extension === '.mjs' || extension === '.cjs') {
+    return {
+      args: [executablePath, ...argv],
+      command: process.execPath,
+    }
+  }
+  return {
+    args: argv,
+    command: executablePath,
+  }
+}
 
 const getPosition = (text, offset) => {
   const safeOffset = Math.max(0, Math.min(offset, text.length))
@@ -62,13 +81,15 @@ export class LanguageServerConnection {
                    pendingRequests = new Map                                 ()
                    ready               
                    rootUri        
+          markdownConfigured = false
           nextRequestId = 1
           running = true
           stderr = ''
 
   constructor({ argv, rootUri, uri }                                 ) {
     this.rootUri = rootUri
-    this.child = spawn(fileURLToPath(uri), [...argv], {
+    const { args, command } = getSpawnOptions(uri, argv)
+    this.child = spawn(command, [...args], {
       stdio: ['pipe', 'pipe', 'pipe'],
     })
     this.child.stdout.on('data', (chunk) => {
@@ -103,6 +124,7 @@ export class LanguageServerConnection {
 
   async complete(textDocument, offset)                              {
     await this.ready
+    this.configureMarkdown(textDocument.languageId)
     this.syncDocument(textDocument)
     const result = await this.sendRequest('textDocument/completion', {
       context: {
@@ -122,6 +144,35 @@ export class LanguageServerConnection {
     return []
   }
 
+          configureMarkdown(languageId)       {
+    if (languageId !== 'markdown' || this.markdownConfigured) {
+      return
+    }
+    this.markdownConfigured = true
+    this.sendNotification('workspace/didChangeConfiguration', {
+      settings: {
+        markdown: {
+          occurrencesHighlight: {
+            enabled: true,
+          },
+          preferredMdPathExtensionStyle: 'auto',
+          server: {
+            log: 'off',
+          },
+          suggest: {
+            paths: {
+              enabled: true,
+              includeWorkspaceHeaderCompletions: 'never',
+            },
+          },
+          validate: {
+            enabled: false,
+          },
+        },
+      },
+    })
+  }
+
           async initialize()                {
     await this.sendRequest('initialize', {
       capabilities: {
@@ -217,7 +268,7 @@ export class LanguageServerConnection {
 
           handleMessage(message)       {
     if (message.method && message.id !== undefined && message.id !== null) {
-      this.handleServerRequest(message)
+      void this.handleServerRequest(message)
       return
     }
     if (message.id === undefined || message.id === null) {
@@ -235,24 +286,40 @@ export class LanguageServerConnection {
     pending.resolve(message.result)
   }
 
-          handleServerRequest(message)       {
-    let result          = null
-    if (message.method === 'workspace/configuration') {
-      const itemCount = Array.isArray(message.params?.items) ? message.params.items.length : 0
-      result = Array.from({ length: itemCount }).fill(null)
-    } else if (message.method === 'workspace/workspaceFolders') {
-      result = [
-        {
-          name: getWorkspaceName(this.rootUri),
-          uri: this.rootUri,
+          async handleServerRequest(message)                {
+    try {
+      let result          = null
+      if (message.method === 'workspace/configuration') {
+        const itemCount = Array.isArray(message.params?.items) ? message.params.items.length : 0
+        result = Array.from({ length: itemCount }).fill(null)
+      } else if (message.method === 'workspace/workspaceFolders') {
+        result = [
+          {
+            name: getWorkspaceName(this.rootUri),
+            uri: this.rootUri,
+          },
+        ]
+      } else if (isMarkdownLanguageServerRequest(message.method || '')) {
+        result = await executeMarkdownLanguageServerRequest(message.method || '', message.params || {}, {
+          documents: this.documents,
+          rootUri: this.rootUri,
+        })
+      }
+      this.sendMessage({
+        id: message.id,
+        jsonrpc: '2.0',
+        result,
+      })
+    } catch (error) {
+      this.sendMessage({
+        error: {
+          code: -32_603,
+          message: error instanceof Error ? error.message : String(error),
         },
-      ]
+        id: message.id,
+        jsonrpc: '2.0',
+      })
     }
-    this.sendMessage({
-      id: message.id,
-      jsonrpc: '2.0',
-      result,
-    })
   }
 
           handleExit(error)       {

package/src/parts/MarkdownLanguageServerRequest/MarkdownLanguageServerRequest.js

@@ -0,0 +1,116 @@
+import MarkdownIt from 'markdown-it'
+import { readFile, readdir, stat } from 'node:fs/promises'
+import { isAbsolute, relative, resolve, sep } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+                         
+                       
+ 
+
+                                                       
+                                                        
+                          
+ 
+
+                                 
+                        
+                       
+ 
+
+const markdownFileExtensions = new Set(['.markdown', '.md', '.mdown', '.mdtext', '.mdtxt', '.mdwn', '.mkd', '.mkdn'])
+const ignoredDirectories = new Set(['.git', 'node_modules'])
+const markdownIt = new MarkdownIt({ html: true })
+
+export const isMarkdownLanguageServerRequest = (method) => {
+  return (
+    method === 'markdown/parse' ||
+    method === 'markdown/fs/readFile' ||
+    method === 'markdown/fs/readDirectory' ||
+    method === 'markdown/fs/stat' ||
+    method === 'markdown/findMarkdownFilesInWorkspace'
+  )
+}
+
+const getWorkspacePath = (uri, rootUri) => {
+  const rootPath = resolve(fileURLToPath(rootUri))
+  const targetPath = resolve(fileURLToPath(uri))
+  const relativePath = relative(rootPath, targetPath)
+  if (relativePath === '..' || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+    throw new Error(`Language server file request is outside the workspace`)
+  }
+  return targetPath
+}
+
+const getMarkdownText = async (params, context) => {
+  if (typeof params.text === 'string') {
+    return params.text
+  }
+  if (!params.uri) {
+    throw new Error(`Markdown parse request is missing a uri`)
+  }
+  const document = context.documents.get(params.uri)
+  if (document) {
+    return document.text
+  }
+  const path = getWorkspacePath(params.uri, context.rootUri)
+  return readFile(path, 'utf8')
+}
+
+const findMarkdownFiles = async (rootPath) => {
+  const result           = []
+  const visit = async (directory) => {
+    const entries = await readdir(directory, { withFileTypes: true })
+    await Promise.all(
+      entries.map(async (entry) => {
+        const path = resolve(directory, entry.name)
+        if (entry.isDirectory()) {
+          if (ignoredDirectories.has(entry.name)) {
+            return
+          }
+          await visit(path)
+          return
+        }
+        const extensionIndex = entry.name.lastIndexOf('.')
+        const extension = extensionIndex === -1 ? '' : entry.name.slice(extensionIndex).toLowerCase()
+        if (markdownFileExtensions.has(extension)) {
+          result.push(pathToFileURL(path).href)
+        }
+      }),
+    )
+  }
+  await visit(rootPath)
+  return result.sort()
+}
+
+export const executeMarkdownLanguageServerRequest = async (
+  method,
+  params,
+  context,
+) => {
+  if (method === 'markdown/parse') {
+    return markdownIt.parse(await getMarkdownText(params, context), {})
+  }
+  if (method === 'markdown/findMarkdownFilesInWorkspace') {
+    return findMarkdownFiles(getWorkspacePath(context.rootUri, context.rootUri))
+  }
+  if (!params.uri) {
+    throw new Error(`Markdown file request is missing a uri`)
+  }
+  const path = getWorkspacePath(params.uri, context.rootUri)
+  if (method === 'markdown/fs/readFile') {
+    return [...(await readFile(path))]
+  }
+  if (method === 'markdown/fs/readDirectory') {
+    const entries = await readdir(path, { withFileTypes: true })
+    return entries.map((entry) => [entry.name, { isDirectory: entry.isDirectory() }])
+  }
+  if (method === 'markdown/fs/stat') {
+    try {
+      const fileStat = await stat(path)
+      return { isDirectory: fileStat.isDirectory() }
+    } catch {
+      return undefined
+    }
+  }
+  throw new Error(`Unsupported Markdown language server request: ${method}`)
+}

package/src/parts/Platform/Platform.js

@@ -61,11 +61,11 @@ export const getSetupName = () => {
   return 'Lvce-Setup'
 }
 
-export const version = '0.89.3'
+export const version = '0.90.2'
 
-export const commit = 'f1db6cb'
+export const commit = '6faf35c'
 
-export const date = '2026-07-14T11:58:48.000Z'
+export const date = '2026-07-15T08:29:42.000Z'
 
 export const getVersion = () => {
   return version

package/src/parts/PreloadUrl/PreloadUrl.js

@@ -2,5 +2,5 @@ import { join } from 'node:path'
 import * as Root from '../Root/Root.js'
 
 export const getPreloadUrl = () => {
-  return join(Root.root, 'static', 'f1db6cb', 'packages', 'preload', 'dist', 'index.js')
+  return join(Root.root, 'static', '6faf35c', 'packages', 'preload', 'dist', 'index.js')
 }