@lvce-editor/shared-process 0.25.10 → 0.25.11

package/src/parts/ExtensionHostHelperProcessIpc/ExtensionHostHelperProcessIpc.js

@@ -1,15 +1,14 @@
-import * as IpcParent from '../IpcParent/IpcParent.js'
-import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js'
-import * as Id from '../Id/Id.js'
-
+import * as IpcParent from '../IpcParent/IpcParent.js';
+import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js';
+import * as Id from '../Id/Id.js';
 export const create = async ({ method }) => {
-  const extensionHostHelperProcessPath = await PlatformPaths.getExtensionHostHelperProcessPath()
-  const id = Id.create()
-  const ipc = await IpcParent.create({
-    method,
-    path: extensionHostHelperProcessPath,
-    execArgv: ['--max-old-space-size=60', '--enable-source-maps'],
-    name: `Extension Host Helper Process ${id}`,
-  })
-  return ipc
-}
+    const extensionHostHelperProcessPath = await PlatformPaths.getExtensionHostHelperProcessPath();
+    const id = Id.create();
+    const ipc = await IpcParent.create({
+        method,
+        path: extensionHostHelperProcessPath,
+        execArgv: ['--max-old-space-size=60', '--enable-source-maps'],
+        name: `Extension Host Helper Process ${id}`,
+    });
+    return ipc;
+};

package/src/parts/ExtensionHostRpc/ExtensionHostRpc.js

@@ -1,82 +1,73 @@
-import * as Assert from '../Assert/Assert.js'
-import * as Timeout from '../Timeout/Timeout.js'
-import { VError } from '../VError/VError.js'
-import * as Logger from '../Logger/Logger.js'
+import * as Assert from '../Assert/Assert.js';
+import * as Timeout from '../Timeout/Timeout.js';
+import { VError } from '../VError/VError.js';
+import * as Logger from '../Logger/Logger.js';
 // TODO maybe rename to extension host management for clarity
-
-const CONNECTION_TIMEOUT = 3000
-
+const CONNECTION_TIMEOUT = 3000;
 export const create = async (ipc, socket) => {
-  Assert.object(socket)
-
-  const handleChildProcessError = (error) => {
-    Logger.error(`[Extension Host] ${error}`)
-  }
-
-  const handleChildProcessExit = (exitCode) => {
-    Logger.info(`[SharedProcess] Extension Host exited with code ${exitCode}`)
-  }
-
-  const handleSocketClose = () => {
-    Logger.info('[shared process] disposing extension host')
-    ipc.dispose()
-  }
-
-  socket.on('close', handleSocketClose)
-
-  ipc.on('error', handleChildProcessError)
-
-  ipc.on('exit', handleChildProcessExit)
-
-  await new Promise((resolve, reject) => {
-    const handleFirstError = (error) => {
-      cleanup()
-      reject(error)
-    }
-    const handleFirstExit = (exitCode) => {
-      cleanup()
-      reject(new VError(`Extension Host exited with code ${exitCode}`))
-    }
-    const handleFirstMessage = (message) => {
-      cleanup()
-      if (message === 'ready') {
-        resolve(undefined)
-      } else {
-        reject(new VError('Unexpected first message from extension host'))
-      }
-    }
+    Assert.object(socket);
+    const handleChildProcessError = (error) => {
+        Logger.error(`[Extension Host] ${error}`);
+    };
+    const handleChildProcessExit = (exitCode) => {
+        Logger.info(`[SharedProcess] Extension Host exited with code ${exitCode}`);
+    };
     const handleSocketClose = () => {
-      cleanup()
-      ipc.off('error', handleChildProcessError)
-      ipc.off('exit', handleChildProcessExit)
-      resolve(undefined)
-    }
-    const cleanup = () => {
-      ipc.off('error', handleFirstError)
-      ipc.off('exit', handleFirstExit)
-      ipc.off('message', handleFirstMessage)
-      clearTimeout(timeout)
-    }
-    const handleTimeout = () => {
-      cleanup()
-      reject(new VError('Extension host did not connect'))
-    }
-    const timeout = Timeout.setTimeout(handleTimeout, CONNECTION_TIMEOUT)
-    ipc.on('error', handleFirstError)
-    ipc.on('exit', handleFirstExit)
-    ipc.on('message', handleFirstMessage)
-    socket.on('close', handleSocketClose)
-  })
-
-  return {
-    on(event, listener) {
-      ipc.on(event, listener)
-    },
-    send(message) {
-      ipc.send(message)
-    },
-    dispose() {
-      ipc.dispose()
-    },
-  }
-}
+        Logger.info('[shared process] disposing extension host');
+        ipc.dispose();
+    };
+    socket.on('close', handleSocketClose);
+    ipc.on('error', handleChildProcessError);
+    ipc.on('exit', handleChildProcessExit);
+    await new Promise((resolve, reject) => {
+        const handleFirstError = (error) => {
+            cleanup();
+            reject(error);
+        };
+        const handleFirstExit = (exitCode) => {
+            cleanup();
+            reject(new VError(`Extension Host exited with code ${exitCode}`));
+        };
+        const handleFirstMessage = (message) => {
+            cleanup();
+            if (message === 'ready') {
+                resolve(undefined);
+            }
+            else {
+                reject(new VError('Unexpected first message from extension host'));
+            }
+        };
+        const handleSocketClose = () => {
+            cleanup();
+            ipc.off('error', handleChildProcessError);
+            ipc.off('exit', handleChildProcessExit);
+            resolve(undefined);
+        };
+        const cleanup = () => {
+            ipc.off('error', handleFirstError);
+            ipc.off('exit', handleFirstExit);
+            ipc.off('message', handleFirstMessage);
+            clearTimeout(timeout);
+        };
+        const handleTimeout = () => {
+            cleanup();
+            reject(new VError('Extension host did not connect'));
+        };
+        const timeout = Timeout.setTimeout(handleTimeout, CONNECTION_TIMEOUT);
+        ipc.on('error', handleFirstError);
+        ipc.on('exit', handleFirstExit);
+        ipc.on('message', handleFirstMessage);
+        socket.on('close', handleSocketClose);
+    });
+    return {
+        on(event, listener) {
+            ipc.on(event, listener);
+        },
+        send(message) {
+            ipc.send(message);
+        },
+        dispose() {
+            ipc.dispose();
+        },
+    };
+};

package/src/parts/ExtensionInstall/ExtensionInstall.ipc.js

@@ -1,8 +1,6 @@
-import * as ExensionInstall from './ExtensionInstall.js'
-
-export const name = 'ExtensionInstall'
-
+import * as ExensionInstall from './ExtensionInstall.js';
+export const name = 'ExtensionInstall';
 // prettier-ignore
 export const Commands = {
-  install: ExensionInstall.install,
-}
+    install: ExensionInstall.install,
+};

package/src/parts/ExtensionInstall/ExtensionInstall.js

@@ -1,25 +1,23 @@
-import * as ExtensionInstallParseInput from '../ExtensionInstallParseInput/ExtensionInstallParseInput.js'
-import * as ExtensionInstallType from '../ExtensionInstallType/ExtensionInstallType.js'
-
+import * as ExtensionInstallParseInput from '../ExtensionInstallParseInput/ExtensionInstallParseInput.js';
+import * as ExtensionInstallType from '../ExtensionInstallType/ExtensionInstallType.js';
 const getModule = (type) => {
-  switch (type) {
-    case ExtensionInstallType.GithubRepository:
-      return import('../ExtensionInstallFromGitHub/ExtensionInstallFromGitHub.js')
-    case ExtensionInstallType.Url:
-      return import('../ExtensionInstallFromUrl/ExtensionInstallFromUrl.js')
-    case ExtensionInstallType.File:
-      return import('../ExtensionInstallFromFile/ExtensionInstallFromFile.js')
-    default:
-      throw new Error('module not found')
-  }
-}
-
+    switch (type) {
+        case ExtensionInstallType.GithubRepository:
+            return import('../ExtensionInstallFromGitHub/ExtensionInstallFromGitHub.js');
+        case ExtensionInstallType.Url:
+            return import('../ExtensionInstallFromUrl/ExtensionInstallFromUrl.js');
+        case ExtensionInstallType.File:
+            return import('../ExtensionInstallFromFile/ExtensionInstallFromFile.js');
+        default:
+            throw new Error('module not found');
+    }
+};
 export const install = async (input) => {
-  const parsed = ExtensionInstallParseInput.parse(input)
-  if (parsed.type === ExtensionInstallType.ParsingError) {
-    throw new Error(`Cannot install ${input}: ${parsed.options.message}`)
-  }
-  const module = await getModule(parsed.type)
-  // @ts-ignore
-  await module.install(parsed.options)
-}
+    const parsed = ExtensionInstallParseInput.parse(input);
+    if (parsed.type === ExtensionInstallType.ParsingError) {
+        throw new Error(`Cannot install ${input}: ${parsed.options.message}`);
+    }
+    const module = await getModule(parsed.type);
+    // @ts-ignore
+    await module.install(parsed.options);
+};

package/src/parts/ExtensionInstallFromFile/ExtensionInstallFromFile.js

@@ -1,36 +1,35 @@
-import * as Extract from '../Extract/Extract.js'
-import * as FileSystem from '../FileSystem/FileSystem.js'
-import * as JsonFile from '../JsonFile/JsonFile.js'
-import * as Path from '../Path/Path.js'
-import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js'
-import { VError } from '../VError/VError.js'
-
+import * as Extract from '../Extract/Extract.js';
+import * as FileSystem from '../FileSystem/FileSystem.js';
+import * as JsonFile from '../JsonFile/JsonFile.js';
+import * as Path from '../Path/Path.js';
+import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js';
+import { VError } from '../VError/VError.js';
 const getCachedExtensionFolderName = (path) => {
-  const baseName = Path.basename(path)
-  if (baseName.endsWith('.tar.br')) {
-    return 'file-' + baseName.slice(0, -'.tar.br'.length)
-  }
-  return `file-${baseName}`
-}
-
+    const baseName = Path.basename(path);
+    if (baseName.endsWith('.tar.br')) {
+        return 'file-' + baseName.slice(0, -'.tar.br'.length);
+    }
+    return `file-${baseName}`;
+};
 export const install = async ({ path }) => {
-  try {
-    const cachedExtensionsPath = PlatformPaths.getCachedExtensionsPath()
-    const cachedExtensionFolderName = getCachedExtensionFolderName(path)
-    const cachedExtensionPath = Path.join(cachedExtensionsPath, cachedExtensionFolderName)
-    await Extract.extractTarBr(path, cachedExtensionPath)
-    const extensionsPath = PlatformPaths.getExtensionsPath()
-    const manifestPath = Path.join(cachedExtensionPath, 'extension.json')
-    const manifestJson = await JsonFile.readJson(manifestPath)
-    const { id } = manifestJson
-    if (!id) {
-      throw new Error('missing id in extension manifest')
+    try {
+        const cachedExtensionsPath = PlatformPaths.getCachedExtensionsPath();
+        const cachedExtensionFolderName = getCachedExtensionFolderName(path);
+        const cachedExtensionPath = Path.join(cachedExtensionsPath, cachedExtensionFolderName);
+        await Extract.extractTarBr(path, cachedExtensionPath);
+        const extensionsPath = PlatformPaths.getExtensionsPath();
+        const manifestPath = Path.join(cachedExtensionPath, 'extension.json');
+        const manifestJson = await JsonFile.readJson(manifestPath);
+        const { id } = manifestJson;
+        if (!id) {
+            throw new Error('missing id in extension manifest');
+        }
+        const outDir = Path.join(extensionsPath, id);
+        await FileSystem.remove(outDir);
+        await FileSystem.mkdir(Path.dirname(outDir));
+        await FileSystem.rename(cachedExtensionPath, outDir);
+    }
+    catch (error) {
+        throw new VError(error, `Failed to install ${path}`);
     }
-    const outDir = Path.join(extensionsPath, id)
-    await FileSystem.remove(outDir)
-    await FileSystem.mkdir(Path.dirname(outDir))
-    await FileSystem.rename(cachedExtensionPath, outDir)
-  } catch (error) {
-    throw new VError(error, `Failed to install ${path}`)
-  }
-}
+};

package/src/parts/ExtensionInstallFromGitHub/ExtensionInstallFromGitHub.js

@@ -1,32 +1,32 @@
-import * as DownloadAndExtract from '../DownloadAndExtract/DownloadAndExtract.js'
-import * as FileSystem from '../FileSystem/FileSystem.js'
-import * as JsonFile from '../JsonFile/JsonFile.js'
-import * as Path from '../Path/Path.js'
-import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js'
-import { VError } from '../VError/VError.js'
-
+import * as DownloadAndExtract from '../DownloadAndExtract/DownloadAndExtract.js';
+import * as FileSystem from '../FileSystem/FileSystem.js';
+import * as JsonFile from '../JsonFile/JsonFile.js';
+import * as Path from '../Path/Path.js';
+import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js';
+import { VError } from '../VError/VError.js';
 export const install = async ({ user, repo, branch }) => {
-  try {
-    const cachedExtensionsPath = PlatformPaths.getCachedExtensionsPath()
-    const url = `https://codeload.github.com/${user}/${repo}/tar.gz/${branch}`
-    const cachedExtensionPath = Path.join(cachedExtensionsPath, `github-${user}-${repo}-${branch}`)
-    await DownloadAndExtract.downloadAndExtractTarGz({
-      url,
-      outDir: cachedExtensionPath,
-      strip: 1,
-    })
-    const extensionsPath = PlatformPaths.getExtensionsPath()
-    const manifestPath = Path.join(cachedExtensionPath, 'extension.json')
-    const manifestJson = await JsonFile.readJson(manifestPath)
-    const { id } = manifestJson
-    if (!id) {
-      throw new Error('missing id in extension manifest')
+    try {
+        const cachedExtensionsPath = PlatformPaths.getCachedExtensionsPath();
+        const url = `https://codeload.github.com/${user}/${repo}/tar.gz/${branch}`;
+        const cachedExtensionPath = Path.join(cachedExtensionsPath, `github-${user}-${repo}-${branch}`);
+        await DownloadAndExtract.downloadAndExtractTarGz({
+            url,
+            outDir: cachedExtensionPath,
+            strip: 1,
+        });
+        const extensionsPath = PlatformPaths.getExtensionsPath();
+        const manifestPath = Path.join(cachedExtensionPath, 'extension.json');
+        const manifestJson = await JsonFile.readJson(manifestPath);
+        const { id } = manifestJson;
+        if (!id) {
+            throw new Error('missing id in extension manifest');
+        }
+        const outDir = Path.join(extensionsPath, id);
+        await FileSystem.remove(outDir);
+        await FileSystem.mkdir(extensionsPath);
+        await FileSystem.rename(cachedExtensionPath, outDir);
     }
-    const outDir = Path.join(extensionsPath, id)
-    await FileSystem.remove(outDir)
-    await FileSystem.mkdir(extensionsPath)
-    await FileSystem.rename(cachedExtensionPath, outDir)
-  } catch (error) {
-    throw new VError(error, `Failed to install ${user}/${repo}`)
-  }
-}
+    catch (error) {
+        throw new VError(error, `Failed to install ${user}/${repo}`);
+    }
+};

package/src/parts/ExtensionInstallFromUrl/ExtensionInstallFromUrl.js

@@ -1,32 +1,32 @@
-import { rename, rm } from 'node:fs/promises'
-import { join } from 'node:path'
-import * as Download from '../Download/Download.js'
-import * as Extract from '../Extract/Extract.js'
-import * as JsonFile from '../JsonFile/JsonFile.js'
-import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js'
-import * as TmpFile from '../TmpFile/TmpFile.js'
-import { VError } from '../VError/VError.js'
-
+import { rename, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import * as Download from '../Download/Download.js';
+import * as Extract from '../Extract/Extract.js';
+import * as JsonFile from '../JsonFile/JsonFile.js';
+import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js';
+import * as TmpFile from '../TmpFile/TmpFile.js';
+import { VError } from '../VError/VError.js';
 export const install = async ({ url }) => {
-  try {
-    // TODO cache extension tar br file, probably by url <cachedExtensions>/user/repo/releases/<tag>/<fileName>
-    // const cachedExtensionsPath = Platform.getCachedExtensionsPath()
-    // const outFile = join(cachedExtensionsPath, 'installed-extension.tar.br')
-    const extensionsPath = PlatformPaths.getExtensionsPath()
-    const tmpFile = await TmpFile.getTmpFile()
-    await Download.download(url, tmpFile)
-    const tmpDir = await TmpFile.getTmpDir()
-    await Extract.extractTarBr(tmpFile, tmpDir)
-    const manifestPath = join(tmpDir, 'extension.json')
-    const manifestJson = await JsonFile.readJson(manifestPath)
-    const { id } = manifestJson
-    if (!id) {
-      throw new Error('missing id in extension manifest')
+    try {
+        // TODO cache extension tar br file, probably by url <cachedExtensions>/user/repo/releases/<tag>/<fileName>
+        // const cachedExtensionsPath = Platform.getCachedExtensionsPath()
+        // const outFile = join(cachedExtensionsPath, 'installed-extension.tar.br')
+        const extensionsPath = PlatformPaths.getExtensionsPath();
+        const tmpFile = await TmpFile.getTmpFile();
+        await Download.download(url, tmpFile);
+        const tmpDir = await TmpFile.getTmpDir();
+        await Extract.extractTarBr(tmpFile, tmpDir);
+        const manifestPath = join(tmpDir, 'extension.json');
+        const manifestJson = await JsonFile.readJson(manifestPath);
+        const { id } = manifestJson;
+        if (!id) {
+            throw new Error('missing id in extension manifest');
+        }
+        const outDir = join(extensionsPath, id);
+        await rm(outDir, { recursive: true, force: true });
+        await rename(tmpDir, outDir);
     }
-    const outDir = join(extensionsPath, id)
-    await rm(outDir, { recursive: true, force: true })
-    await rename(tmpDir, outDir)
-  } catch (error) {
-    throw new VError(error, `Failed to install "${url}"`)
-  }
-}
+    catch (error) {
+        throw new VError(error, `Failed to install "${url}"`);
+    }
+};

package/src/parts/ExtensionInstallParseInput/ExtensionInstallParseInput.js

@@ -1,50 +1,47 @@
-import * as ExtensionInstallType from '../ExtensionInstallType/ExtensionInstallType.js'
-import * as Path from '../Path/Path.js'
-import * as ParseUrlGithub from '../ParseUrlGithub/ParseUrlGithub.js'
-
+import * as ExtensionInstallType from '../ExtensionInstallType/ExtensionInstallType.js';
+import * as Path from '../Path/Path.js';
+import * as ParseUrlGithub from '../ParseUrlGithub/ParseUrlGithub.js';
 const parseUrl = (input) => {
-  if (input.startsWith('https://github.com')) {
-    return ParseUrlGithub.parseUrlGithub(input)
-  }
-  if (input.endsWith('.tar.br')) {
-    return {
-      type: ExtensionInstallType.Url,
-      options: {
-        url: input,
-      },
+    if (input.startsWith('https://github.com')) {
+        return ParseUrlGithub.parseUrlGithub(input);
+    }
+    if (input.endsWith('.tar.br')) {
+        return {
+            type: ExtensionInstallType.Url,
+            options: {
+                url: input,
+            },
+        };
     }
-  }
-  return {
-    type: ExtensionInstallType.ParsingError,
-    options: {
-      message: 'Failed to parse url',
-    },
-  }
-}
-
+    return {
+        type: ExtensionInstallType.ParsingError,
+        options: {
+            message: 'Failed to parse url',
+        },
+    };
+};
 const parseFile = (input) => {
-  return {
-    type: ExtensionInstallType.File,
-    options: {
-      path: input,
-    },
-  }
-}
-
+    return {
+        type: ExtensionInstallType.File,
+        options: {
+            path: input,
+        },
+    };
+};
 export const parse = (input) => {
-  if (input.startsWith('https://')) {
-    return parseUrl(input)
-  }
-  if (input.startsWith('.')) {
-    return parseFile(input)
-  }
-  if (Path.isAbsolute(input)) {
-    return parseFile(input)
-  }
-  return {
-    type: ExtensionInstallType.ParsingError,
-    options: {
-      message: 'Failed to parse input',
-    },
-  }
-}
+    if (input.startsWith('https://')) {
+        return parseUrl(input);
+    }
+    if (input.startsWith('.')) {
+        return parseFile(input);
+    }
+    if (Path.isAbsolute(input)) {
+        return parseFile(input);
+    }
+    return {
+        type: ExtensionInstallType.ParsingError,
+        options: {
+            message: 'Failed to parse input',
+        },
+    };
+};

package/src/parts/ExtensionInstallType/ExtensionInstallType.js

@@ -1,7 +1,4 @@
-export const Url = 1
-
-export const GithubRepository = 2
-
-export const ParsingError = 3
-
-export const File = 4
+export const Url = 1;
+export const GithubRepository = 2;
+export const ParsingError = 3;
+export const File = 4;

package/src/parts/ExtensionLink/ExtensionLink.js

@@ -1,45 +1,45 @@
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
-import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
-import * as FileSystem from '../FileSystem/FileSystem.js'
-import * as Path from '../Path/Path.js'
-import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js'
-import * as SymLink from '../SymLink/SymLink.js'
-import { VError } from '../VError/VError.js'
-
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js';
+import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js';
+import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js';
+import * as FileSystem from '../FileSystem/FileSystem.js';
+import * as Path from '../Path/Path.js';
+import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js';
+import * as SymLink from '../SymLink/SymLink.js';
+import { VError } from '../VError/VError.js';
 const linkFallBack = async (path) => {
-  try {
-    const manifest = await ExtensionManifest.get(path)
-    if (manifest.status === ExtensionManifestStatus.Rejected) {
-      throw manifest.reason
+    try {
+        const manifest = await ExtensionManifest.get(path);
+        if (manifest.status === ExtensionManifestStatus.Rejected) {
+            throw manifest.reason;
+        }
+        const linkedExtensionsPath = PlatformPaths.getLinkedExtensionsPath();
+        // @ts-ignore
+        const to = Path.join(linkedExtensionsPath, manifest.id);
+        await FileSystem.remove(to);
+        await SymLink.createSymLink(path, to);
     }
-    const linkedExtensionsPath = PlatformPaths.getLinkedExtensionsPath()
-    // @ts-ignore
-    const to = Path.join(linkedExtensionsPath, manifest.id)
-    await FileSystem.remove(to)
-    await SymLink.createSymLink(path, to)
-  } catch (error) {
-    throw new VError(error, `Failed to link extension`)
-  }
-}
-
-export const link = async (path) => {
-  try {
-    const manifest = await ExtensionManifest.get(path)
-    if (manifest.status === ExtensionManifestStatus.Rejected) {
-      throw manifest.reason
+    catch (error) {
+        throw new VError(error, `Failed to link extension`);
     }
-    const linkedExtensionsPath = PlatformPaths.getLinkedExtensionsPath()
-    // @ts-ignore
-    const to = Path.join(linkedExtensionsPath, manifest.id)
-    await SymLink.createSymLink(path, to)
-  } catch (error) {
-    if (error && error.code === ErrorCodes.E_MANIFEST_NOT_FOUND) {
-      throw new VError(`Failed to link extension: Extension manifest not found '${error.path}'`)
+};
+export const link = async (path) => {
+    try {
+        const manifest = await ExtensionManifest.get(path);
+        if (manifest.status === ExtensionManifestStatus.Rejected) {
+            throw manifest.reason;
+        }
+        const linkedExtensionsPath = PlatformPaths.getLinkedExtensionsPath();
+        // @ts-ignore
+        const to = Path.join(linkedExtensionsPath, manifest.id);
+        await SymLink.createSymLink(path, to);
     }
-    if (error && error.code === ErrorCodes.EEXIST) {
-      return linkFallBack(path)
+    catch (error) {
+        if (error && error.code === ErrorCodes.E_MANIFEST_NOT_FOUND) {
+            throw new VError(`Failed to link extension: Extension manifest not found '${error.path}'`);
+        }
+        if (error && error.code === ErrorCodes.EEXIST) {
+            return linkFallBack(path);
+        }
+        throw new VError(error, `Failed to link extension`);
     }
-    throw new VError(error, `Failed to link extension`)
-  }
-}
+};