@lvce-editor/shared-process 0.89.2 → 0.90.1

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.2",
+  "version": "0.90.1",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -18,28 +18,29 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "1.7.0",
-    "@lvce-editor/auth-process": "1.8.0",
-    "@lvce-editor/extension-host-helper-process": "0.89.2",
+    "@lvce-editor/auth-process": "1.9.0",
+    "@lvce-editor/extension-host-helper-process": "0.90.1",
     "@lvce-editor/ipc": "16.3.0",
     "@lvce-editor/json-rpc": "8.2.0",
     "@lvce-editor/jsonc-parser": "1.5.0",
     "@lvce-editor/pretty-error": "2.0.0",
     "@lvce-editor/process-explorer": "3.10.0",
-    "@lvce-editor/rpc-registry": "9.33.0",
+    "@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": {
     "@lvce-editor/embeds-process": "4.9.1",
-    "@lvce-editor/file-system-process": "5.3.0",
-    "@lvce-editor/file-watcher-process": "4.2.0",
+    "@lvce-editor/file-system-process": "5.4.0",
+    "@lvce-editor/file-watcher-process": "4.4.0",
     "@lvce-editor/network-process": "5.2.0",
     "@lvce-editor/preload": "1.5.0",
     "@lvce-editor/preview-process": "11.0.0",
-    "@lvce-editor/pty-host": "8.2.0",
+    "@lvce-editor/pty-host": "8.3.0",
     "@lvce-editor/search-process": "15.1.0",
-    "@lvce-editor/typescript-compile-process": "5.2.0",
+    "@lvce-editor/typescript-compile-process": "5.3.0",
     "open": "^11.0.0",
     "tail": "^2.2.6",
     "tmp-promise": "^3.0.3",

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', '331d398', 'extensions')
+  const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', 'd347596', 'extensions')
   return builtinExtensionsPath
 }

package/src/parts/ElectronProcess/ElectronProcess.ipc.js

@@ -3,6 +3,9 @@ import * as ElectronProcess from './ElectronProcess.js'
 export const name = 'ElectronProcess'
 
 export const Commands = {
+  getArgv: ElectronProcess.getArgv,
   getChromeVersion: ElectronProcess.getChromeVersion,
   getElectronVersion: ElectronProcess.getElectronVersion,
+  writeStderr: ElectronProcess.writeStderr,
+  writeStdout: ElectronProcess.writeStdout,
 }

package/src/parts/ElectronProcess/ElectronProcess.js

@@ -1,5 +1,9 @@
 import * as ParentIpc from '../MainProcess/MainProcess.js'
 
+export const getArgv = () => {
+  return ParentIpc.invoke('Process.getArgv')
+}
+
 export const getElectronVersion = () => {
   return ParentIpc.invoke('Process.getElectronVersion')
 }
@@ -7,3 +11,11 @@ export const getElectronVersion = () => {
 export const getChromeVersion = () => {
   return ParentIpc.invoke('Process.getChromeVersion')
 }
+
+export const writeStderr = (value) => {
+  return ParentIpc.invoke('Process.writeStderr', value)
+}
+
+export const writeStdout = (value) => {
+  return ParentIpc.invoke('Process.writeStdout', value)
+}

package/src/parts/Exit/Exit.js

@@ -1,5 +1,8 @@
 import * as ParentIpc from '../MainProcess/MainProcess.js'
 
-export const exit = () => {
-  return ParentIpc.invoke('Exit.exit')
+export const exit = (code) => {
+  if (code === undefined) {
+    return ParentIpc.invoke('Exit.exit')
+  }
+  return ParentIpc.invoke('Exit.exit', code)
 }

package/src/parts/IsPromptMode/IsPromptMode.js

@@ -0,0 +1,6 @@
+const promptFlag = '--prompt'
+const promptWithValuePrefix = `${promptFlag}=`
+
+export const isPromptMode = (argv) => {
+  return argv.some((argument) => argument === promptFlag || argument.startsWith(promptWithValuePrefix))
+}

package/src/parts/LanguageServer/LanguageServer.ipc.js

@@ -0,0 +1,7 @@
+import * as LanguageServer from './LanguageServer.js'
+
+export const name = 'LanguageServer'
+
+export const Commands = {
+  complete: LanguageServer.complete,
+}

package/src/parts/LanguageServer/LanguageServer.js

@@ -0,0 +1,78 @@
+import { dirname } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { LanguageServerConnection } from '../LanguageServerConnection/LanguageServerConnection.js'
+
+                        
+                             
+                       
+                      
+ 
+
+                                  
+                                  
+                     
+                         
+                                     
+                      
+ 
+
+                           
+                                  
+                                               
+                      
+ 
+
+const connections = new Map                         ()
+
+const normalizeDocumentUri = (uri) => {
+  if (uri.startsWith('/')) {
+    return pathToFileURL(uri).href
+  }
+  return uri
+}
+
+const getRootUri = (documentUri) => {
+  if (documentUri.startsWith('file:')) {
+    return new URL('.', documentUri).href
+  }
+  if (documentUri.startsWith('/')) {
+    return pathToFileURL(dirname(documentUri)).href
+  }
+  return new URL('.', documentUri).href
+}
+
+const hasSameOptions = (state, uri, argv) => {
+  return state.uri === uri && state.argv.length === argv.length && state.argv.every((argument, index) => argument === argv[index])
+}
+
+const getConnection = (id, uri, argv, rootUri) => {
+  const existing = connections.get(id)
+  if (existing && existing.connection.isRunning() && hasSameOptions(existing, uri, argv)) {
+    return existing.connection
+  }
+  existing?.connection.dispose()
+  const connection = new LanguageServerConnection({ argv, rootUri, uri })
+  connections.set(id, {
+    argv: [...argv],
+    connection,
+    uri,
+  })
+  return connection
+}
+
+export const complete = async ({ argv, id, offset, textDocument, uri }                 ) => {
+  const normalizedDocument = {
+    ...textDocument,
+    uri: normalizeDocumentUri(textDocument.uri),
+  }
+  const rootUri = getRootUri(normalizedDocument.uri)
+  const connection = getConnection(`${id}:${rootUri}`, uri, argv, rootUri)
+  return connection.complete(normalizedDocument, offset)
+}
+
+export const disposeAll = () => {
+  for (const state of connections.values()) {
+    state.connection.dispose()
+  }
+  connections.clear()
+}

package/src/parts/LanguageServerConnection/LanguageServerConnection.js

@@ -0,0 +1,354 @@
+import { spawn,                                     } from 'node:child_process'
+import { basename } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { LanguageServerMessageParser } from '../LanguageServerMessageParser/LanguageServerMessageParser.js'
+import {
+  executeMarkdownLanguageServerRequest,
+  isMarkdownLanguageServerRequest,
+} from '../MarkdownLanguageServerRequest/MarkdownLanguageServerRequest.js'
+
+                          
+                    
+                          
+                             
+   
+                                      
+                          
+                       
+                           
+ 
+
+                          
+                                         
+                                            
+ 
+
+                        
+                             
+                       
+                      
+ 
+
+                         
+                             
+                       
+                          
+ 
+
+                                                  
+                                  
+                          
+                      
+ 
+
+const getPosition = (text, offset) => {
+  const safeOffset = Math.max(0, Math.min(offset, text.length))
+  const before = text.slice(0, safeOffset)
+  const lastLineBreak = before.lastIndexOf('\n')
+  return {
+    character: lastLineBreak === -1 ? safeOffset : safeOffset - lastLineBreak - 1,
+    line: before.split('\n').length - 1,
+  }
+}
+
+const getWorkspaceName = (rootUri) => {
+  try {
+    return basename(fileURLToPath(rootUri)) || 'workspace'
+  } catch {
+    return 'workspace'
+  }
+}
+
+export class LanguageServerConnection {
+                   child                                
+                   documents = new Map                       ()
+                   parser = new LanguageServerMessageParser()
+                   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], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+    this.child.stdout.on('data', (chunk) => {
+      this.handleData(chunk)
+    })
+    this.child.stderr.on('data', (chunk) => {
+      this.stderr += chunk.toString()
+    })
+    this.child.on('error', (error) => {
+      this.handleExit(error)
+    })
+    this.child.on('exit', (code, signal) => {
+      const detail = this.stderr.trim()
+      const suffix = detail ? `: ${detail}` : ''
+      this.handleExit(new Error(`Language server exited with code ${code} and signal ${signal}${suffix}`))
+    })
+    this.ready = this.initialize()
+  }
+
+  isRunning()          {
+    return this.running
+  }
+
+  dispose()       {
+    if (!this.running) {
+      return
+    }
+    this.running = false
+    this.child.kill()
+    this.rejectPendingRequests(new Error('Language server was disposed'))
+  }
+
+  async complete(textDocument, offset)                              {
+    await this.ready
+    this.configureMarkdown(textDocument.languageId)
+    this.syncDocument(textDocument)
+    const result = await this.sendRequest('textDocument/completion', {
+      context: {
+        triggerKind: 1,
+      },
+      position: getPosition(textDocument.text, offset),
+      textDocument: {
+        uri: textDocument.uri,
+      },
+    })
+    if (Array.isArray(result)) {
+      return result
+    }
+    if (result && typeof result === 'object' && Array.isArray((result).items)) {
+      return (result).items
+    }
+    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: {
+        textDocument: {
+          completion: {
+            completionItem: {
+              snippetSupport: true,
+            },
+          },
+          synchronization: {
+            didSave: true,
+            dynamicRegistration: false,
+          },
+        },
+        workspace: {
+          configuration: true,
+          workspaceFolders: true,
+        },
+      },
+      clientInfo: {
+        name: 'Lvce Editor',
+      },
+      processId: process.pid,
+      rootUri: this.rootUri,
+      workspaceFolders: [
+        {
+          name: getWorkspaceName(this.rootUri),
+          uri: this.rootUri,
+        },
+      ],
+    })
+    this.sendNotification('initialized', {})
+  }
+
+          syncDocument(textDocument)       {
+    const previous = this.documents.get(textDocument.uri)
+    if (!previous || previous.languageId !== textDocument.languageId) {
+      if (previous) {
+        this.sendNotification('textDocument/didClose', {
+          textDocument: {
+            uri: textDocument.uri,
+          },
+        })
+      }
+      const next = {
+        languageId: textDocument.languageId,
+        text: textDocument.text,
+        version: 1,
+      }
+      this.documents.set(textDocument.uri, next)
+      this.sendNotification('textDocument/didOpen', {
+        textDocument: {
+          languageId: next.languageId,
+          text: next.text,
+          uri: textDocument.uri,
+          version: next.version,
+        },
+      })
+      return
+    }
+    if (previous.text === textDocument.text) {
+      return
+    }
+    const next = {
+      ...previous,
+      text: textDocument.text,
+      version: previous.version + 1,
+    }
+    this.documents.set(textDocument.uri, next)
+    this.sendNotification('textDocument/didChange', {
+      contentChanges: [
+        {
+          text: next.text,
+        },
+      ],
+      textDocument: {
+        uri: textDocument.uri,
+        version: next.version,
+      },
+    })
+  }
+
+          handleData(chunk)       {
+    try {
+      const messages = this.parser.push(chunk)
+      for (const message of messages) {
+        this.handleMessage(message)
+      }
+    } catch (error) {
+      this.handleExit(error instanceof Error ? error : new Error(String(error)))
+    }
+  }
+
+          handleMessage(message)       {
+    if (message.method && message.id !== undefined && message.id !== null) {
+      void this.handleServerRequest(message)
+      return
+    }
+    if (message.id === undefined || message.id === null) {
+      return
+    }
+    const pending = this.pendingRequests.get(message.id)
+    if (!pending) {
+      return
+    }
+    this.pendingRequests.delete(message.id)
+    if (message.error) {
+      pending.reject(new Error(message.error.message || `Language server request failed with code ${message.error.code}`))
+      return
+    }
+    pending.resolve(message.result)
+  }
+
+          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',
+      })
+    }
+  }
+
+          handleExit(error)       {
+    if (!this.running) {
+      return
+    }
+    this.running = false
+    this.rejectPendingRequests(error)
+  }
+
+          rejectPendingRequests(error)       {
+    for (const pending of this.pendingRequests.values()) {
+      pending.reject(error)
+    }
+    this.pendingRequests.clear()
+  }
+
+          sendNotification(method, params)       {
+    this.sendMessage({
+      jsonrpc: '2.0',
+      method,
+      params,
+    })
+  }
+
+          sendRequest(method, params)                   {
+    if (!this.running) {
+      return Promise.reject(new Error('Language server is not running'))
+    }
+    const id = this.nextRequestId++
+    const promise = new Promise         ((resolve, reject) => {
+      this.pendingRequests.set(id, { reject, resolve })
+    })
+    this.sendMessage({
+      id,
+      jsonrpc: '2.0',
+      method,
+      params,
+    })
+    return promise
+  }
+
+          sendMessage(message)       {
+    const content = JSON.stringify(message)
+    const header = `Content-Length: ${Buffer.byteLength(content)}\r\n\r\n`
+    this.child.stdin.write(header + content)
+  }
+}

package/src/parts/LanguageServerMessageParser/LanguageServerMessageParser.js

@@ -0,0 +1,32 @@
+const headerSeparator = Buffer.from('\r\n\r\n')
+const contentLengthRegex = /(?:^|\r\n)Content-Length:\s*(\d+)/i
+
+export class LanguageServerMessageParser {
+          buffer = Buffer.alloc(0)
+
+  push(chunk)                     {
+    this.buffer = Buffer.concat([this.buffer, chunk])
+    const messages            = []
+    while (true) {
+      const headerEnd = this.buffer.indexOf(headerSeparator)
+      if (headerEnd === -1) {
+        break
+      }
+      const header = this.buffer.subarray(0, headerEnd).toString('ascii')
+      const match = contentLengthRegex.exec(header)
+      if (!match) {
+        throw new Error('Language server message is missing Content-Length')
+      }
+      const contentLength = Number(match[1])
+      const contentStart = headerEnd + headerSeparator.length
+      const contentEnd = contentStart + contentLength
+      if (this.buffer.length < contentEnd) {
+        break
+      }
+      const content = this.buffer.subarray(contentStart, contentEnd).toString('utf8')
+      this.buffer = this.buffer.subarray(contentEnd)
+      messages.push(JSON.parse(content))
+    }
+    return messages
+  }
+}

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/Module/Module.js

@@ -110,6 +110,8 @@ export const load = (moduleId) => {
       return import('../InstallExtension/InstallExtension.ipc.js')
     case ModuleId.IsAutoUpdateSupported:
       return import('../IsAutoUpdateSupported/IsAutoUpdateSupported.ipc.js')
+    case ModuleId.LanguageServer:
+      return import('../LanguageServer/LanguageServer.ipc.js')
     case ModuleId.OpenExternal:
       return import('../OpenExternal/OpenExternal.ipc.js')
     case ModuleId.OpenNativeFolder:

package/src/parts/ModuleId/ModuleId.js

@@ -78,3 +78,4 @@ export const HandleMessagePortForClipBoardProcess = 82
 export const Exec = 83
 export const PlatformPaths = 84
 export const HandleMessagePortForAuthProcess = 86
+export const LanguageServer = 87

package/src/parts/ModuleMap/ModuleMap.js

@@ -67,8 +67,11 @@ export const getModuleId = (commandId) => {
     case 'ElectronPowerSaveBlocker.start':
     case 'ElectronPowerSaveBlocker.stop':
       return ModuleId.ElectronPowerSaveBlocker
+    case 'ElectronProcess.getArgv':
     case 'ElectronProcess.getChromeVersion':
     case 'ElectronProcess.getElectronVersion':
+    case 'ElectronProcess.writeStderr':
+    case 'ElectronProcess.writeStdout':
       return ModuleId.ElectronProcess
     case 'ElectronSafeStorage.decryptString':
     case 'ElectronSafeStorage.encryptString':
@@ -244,6 +247,8 @@ export const getModuleId = (commandId) => {
       return ModuleId.InstallExtension
     case 'IsAutoUpdateSupported.isAutoUpdateSupported':
       return ModuleId.IsAutoUpdateSupported
+    case 'LanguageServer.complete':
+      return ModuleId.LanguageServer
     case 'ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage':
       return ModuleId.ListProcessesWithMemoryUsage
     case 'Native.openFolder':

package/src/parts/Platform/Platform.js

@@ -61,11 +61,11 @@ export const getSetupName = () => {
   return 'Lvce-Setup'
 }
 
-export const version = '0.89.2'
+export const version = '0.90.1'
 
-export const commit = '331d398'
+export const commit = 'd347596'
 
-export const date = '2026-07-14T10:36:39.000Z'
+export const date = '2026-07-14T15:50:53.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', '331d398', 'packages', 'preload', 'dist', 'index.js')
+  return join(Root.root, 'static', 'd347596', 'packages', 'preload', 'dist', 'index.js')
 }

package/src/parts/ResolveRoot/ResolveRoot.js

@@ -5,6 +5,7 @@ import * as Env from '../Env/Env.js'
 import * as GetWorkspaceId from '../GetWorkspaceId/GetWorkspaceId.js'
 import * as IsAbsolutePath from '../IsAbsolutePath/IsAbsolutePath.js'
 import * as IsElectron from '../IsElectron/IsElectron.js'
+import * as IsPromptMode from '../IsPromptMode/IsPromptMode.js'
 import * as ParentIpc from '../MainProcess/MainProcess.js'
 import * as Platform from '../Platform/Platform.js'
 import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js'
@@ -33,7 +34,7 @@ export const resolveRoot = async () => {
     const argv = await ParentIpc.invoke('Process.getArgv')
     const relevantArgv = argv.slice(1)
     const last = relevantArgv.at(-1)
-    if (last && last === '.') {
+    if (IsPromptMode.isPromptMode(relevantArgv) || (last && last === '.')) {
       const actual = process.cwd()
       return {
         homeDir: PlatformPaths.getHomeDir(),