@lvce-editor/shared-process 0.81.15 → 0.82.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.81.15",
+  "version": "0.82.1",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -19,7 +19,7 @@
   "dependencies": {
     "@lvce-editor/assert": "1.5.1",
     "@lvce-editor/auth-process": "1.6.0",
-    "@lvce-editor/extension-host-helper-process": "0.81.15",
+    "@lvce-editor/extension-host-helper-process": "0.82.1",
     "@lvce-editor/ipc": "16.0.0",
     "@lvce-editor/json-rpc": "8.0.0",
     "@lvce-editor/jsonc-parser": "1.5.0",

package/src/parts/BuiltinExtensionsPath/BuiltinExtensionsPath.js

@@ -2,6 +2,6 @@ import { join } from 'path';
 import { fileURLToPath } from 'url';
 export const getBuiltinExtensionsPath = () => {
     const staticServerPath = fileURLToPath(import.meta.resolve('@lvce-editor/static-server'));
-    const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', 'deea804', 'extensions');
+    const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', '318496f', 'extensions');
     return builtinExtensionsPath;
 };

package/src/parts/Cli/Cli.js

@@ -1,9 +1,11 @@
 import * as CliModule from '../CliModule/CliModule.js';
 import * as Logger from '../Logger/Logger.js';
 import * as Process from '../Process/Process.js';
+import * as TransientLinkedExtensions from '../TransientLinkedExtensions/TransientLinkedExtensions.js';
 export const handleCliArgs = async (parsedArgs) => {
     const module = await CliModule.getModule(parsedArgs);
     try {
+        await TransientLinkedExtensions.validate();
         await module.handleCliArgs(parsedArgs._);
     }
     catch (error) {

package/src/parts/ExtensionList/ExtensionList.js

@@ -3,6 +3,7 @@ import * as ExtensionManifestInputType from '../ExtensionManifestInputType/Exten
 import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js';
 import * as ExtensionManifests from '../ExtensionManifests/ExtensionManifests.js';
 import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js';
+import * as TransientLinkedExtensions from '../TransientLinkedExtensions/TransientLinkedExtensions.js';
 import * as BuiltinExtensionsPath from '../BuiltinExtensionsPath/BuiltinExtensionsPath.js';
 import { VError } from '../VError/VError.js';
 const getManifestVersion = (json) => {
@@ -42,7 +43,14 @@ const getManifestInfos = (manifests) => {
 };
 export const list = async () => {
     try {
+        const transientLinkedExtensions = TransientLinkedExtensions.getLinkedExtensions().map((link) => {
+            return {
+                type: ExtensionManifestInputType.LinkedExtension,
+                path: link.resolvedPath,
+            };
+        });
         const manifests = await ExtensionManifests.getAll([
+            ...transientLinkedExtensions,
             {
                 type: ExtensionManifestInputType.LinkedExtensionsFolder,
                 path: PlatformPaths.getLinkedExtensionsPath(),

package/src/parts/ExtensionManagement/ExtensionManagement.js

@@ -7,6 +7,7 @@ import * as ExtensionManifests from '../ExtensionManifests/ExtensionManifests.js
 import * as GetEtagFromStats from '../GetEtagFromStats/GetEtagFromStats.js';
 import * as GetExtensionEtags from '../GetExtensionEtags/GetExtensionEtags.js';
 import * as PlatformPaths from '../PlatformPaths/PlatformPaths.js';
+import * as TransientLinkedExtensions from '../TransientLinkedExtensions/TransientLinkedExtensions.js';
 import { VError } from '../VError/VError.js';
 export const enable = async (id) => {
     try {
@@ -80,11 +81,18 @@ export const getInstalledExtensions = () => {
     ], BuiltinExtensionsPath.getBuiltinExtensionsPath());
 };
 export const getExtensions = () => {
+    const transientLinkedExtensions = TransientLinkedExtensions.getLinkedExtensions().map((link) => {
+        return {
+            type: ExtensionManifestInputType.LinkedExtension,
+            path: link.resolvedPath,
+        };
+    });
     return ExtensionManifests.getAll([
         {
             type: ExtensionManifestInputType.OnlyExtension,
             path: PlatformPaths.getOnlyExtensionPath(),
         },
+        ...transientLinkedExtensions,
         {
             type: ExtensionManifestInputType.Folder,
             path: PlatformPaths.getLinkedExtensionsPath(),
@@ -100,11 +108,18 @@ export const getExtensions = () => {
     ], BuiltinExtensionsPath.getBuiltinExtensionsPath());
 };
 export const getExtensionsEtag = async () => {
+    const transientLinkedExtensions = TransientLinkedExtensions.getLinkedExtensions().map((link) => {
+        return {
+            type: ExtensionManifestInputType.LinkedExtension,
+            path: link.resolvedPath,
+        };
+    });
     const stats = await GetExtensionEtags.getExtensionEtags([
         {
             type: ExtensionManifestInputType.OnlyExtension,
             path: PlatformPaths.getOnlyExtensionPath(),
         },
+        ...transientLinkedExtensions,
         {
             type: ExtensionManifestInputType.Folder,
             path: PlatformPaths.getLinkedExtensionsPath(),

package/src/parts/ExtensionManifestInputType/ExtensionManifestInputType.js

@@ -1,3 +1,4 @@
 export const Folder = 1;
 export const OnlyExtension = 2;
 export const LinkedExtensionsFolder = 3;
+export const LinkedExtension = 4;

package/src/parts/ExtensionManifests/ExtensionManifests.js

@@ -2,6 +2,7 @@ import * as DeduplicateExtensions from '../DeduplicateExtensions/DeduplicateExte
 import { getDisabledExtensionIds } from '../ExtensionManagement/ExtensionManagement.js';
 import * as ExtensionManifestInputType from '../ExtensionManifestInputType/ExtensionManifestInputType.js';
 import * as ExtensionManifestsGetFromFolder from './ExtensionManifestsFromFolder.js';
+import * as ExtensionManifestsGetFromLinkedExtension from './ExtensionManifestsFromLinkedExtension.js';
 import * as ExtensionManifestsGetFromLinkedExtensionsFolder from './ExtensionManifestsFromLinkedExtensionsFolder.js';
 import * as ExtensionManifestsGetFromOnlyExtension from './ExtensionManifestsFromOnlyExtension.js';
 const getModule = (type) => {
@@ -10,6 +11,8 @@ const getModule = (type) => {
             return ExtensionManifestsGetFromFolder;
         case ExtensionManifestInputType.OnlyExtension:
             return ExtensionManifestsGetFromOnlyExtension;
+        case ExtensionManifestInputType.LinkedExtension:
+            return ExtensionManifestsGetFromLinkedExtension;
         case ExtensionManifestInputType.LinkedExtensionsFolder:
             return ExtensionManifestsGetFromLinkedExtensionsFolder;
         default:

package/src/parts/ExtensionManifests/ExtensionManifestsFromLinkedExtension.js

@@ -0,0 +1,17 @@
+import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js';
+import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js';
+export const getExtensionManifests = async (path) => {
+    if (!path) {
+        return [];
+    }
+    const manifest = await ExtensionManifest.get(path);
+    if (manifest.status === ExtensionManifestStatus.Rejected) {
+        return [manifest];
+    }
+    return [
+        {
+            ...manifest,
+            symlink: path,
+        },
+    ];
+};

package/src/parts/GetExtensionEtags/GetExtensionEtags.js

@@ -11,13 +11,26 @@ const serializeStats = (stats) => {
         size,
     };
 };
+const getManifestStats = async (path) => {
+    const absolutePath = join(path, 'extension.json');
+    try {
+        const stats = await stat(absolutePath);
+        return [serializeStats(stats)];
+    }
+    catch (error) {
+        if (IsEnoentError.isEnoentError(error)) {
+            const monoRepoPath = join(path, 'packages', 'extension', 'extension.json');
+            const stats = await stat(monoRepoPath);
+            return [serializeStats(stats)];
+        }
+        throw error;
+    }
+};
 const getOnly = async (path) => {
     if (!path) {
         return [];
     }
-    const absolutePath = join(path, 'extension.json');
-    const stats = await stat(absolutePath);
-    return [serializeStats(stats)];
+    return getManifestStats(path);
 };
 const getFolder = async (path) => {
     try {
@@ -42,6 +55,7 @@ const get = (input) => {
         case ExtensionManifestInputType.LinkedExtensionsFolder:
             return getFolder(input.path);
         case ExtensionManifestInputType.OnlyExtension:
+        case ExtensionManifestInputType.LinkedExtension:
             return getOnly(input.path);
         default:
             return [];

package/src/parts/HandleElectronReady/HandleElectronReady.js

@@ -1,11 +1,22 @@
 import * as AppWindow from '../AppWindow/AppWindow.js';
 import * as Assert from '../Assert/Assert.js';
+import * as ExitCode from '../ExitCode/ExitCode.js';
+import * as Logger from '../Logger/Logger.js';
 import * as Preferences from '../Preferences/Preferences.js';
 import * as PreloadUrl from '../PreloadUrl/PreloadUrl.js';
+import * as Process from '../Process/Process.js';
+import * as TransientLinkedExtensions from '../TransientLinkedExtensions/TransientLinkedExtensions.js';
 export const handleElectronReady = async (parsedArgs, workingDirectory) => {
     Assert.object(parsedArgs);
     Assert.string(workingDirectory);
-    const preferences = await Preferences.getAllSafe();
-    const preloadUrl = PreloadUrl.getPreloadUrl();
-    await AppWindow.createAppWindow({ preferences, parsedArgs, workingDirectory, preloadUrl });
+    try {
+        await TransientLinkedExtensions.validate();
+        const preferences = await Preferences.getAllSafe();
+        const preloadUrl = PreloadUrl.getPreloadUrl();
+        await AppWindow.createAppWindow({ preferences, parsedArgs, workingDirectory, preloadUrl });
+    }
+    catch (error) {
+        Logger.error(error);
+        Process.exit(ExitCode.ExpectedError);
+    }
 };

package/src/parts/Platform/Platform.js

@@ -41,9 +41,9 @@ export const getAppImageName = () => {
 export const getSetupName = () => {
     return 'Lvce-Setup';
 };
-export const version = '0.81.15';
-export const commit = 'deea804';
-export const date = '2026-05-27T19:30:41.000Z';
+export const version = '0.82.1';
+export const commit = '318496f';
+export const date = '2026-05-28T15:23:50.000Z';
 export const getVersion = () => {
     return version;
 };

package/src/parts/PreloadUrl/PreloadUrl.js

@@ -1,5 +1,5 @@
 import { join } from 'node:path';
 import * as Root from '../Root/Root.js';
 export const getPreloadUrl = () => {
-    return join(Root.root, 'static', 'deea804', 'packages', 'preload', 'dist', 'index.js');
+    return join(Root.root, 'static', '318496f', 'packages', 'preload', 'dist', 'index.js');
 };

package/src/parts/Process/Process.js

@@ -12,7 +12,18 @@ export const exit = (code) => {
 export const setExitCode = (exitCode) => {
     process.exitCode = exitCode;
 };
-export const { argv } = process;
+export const argv = new Proxy([], {
+    get(_target, property) {
+        const value = Reflect.get(process.argv, property);
+        if (typeof value === 'function') {
+            return value.bind(process.argv);
+        }
+        return value;
+    },
+    set(_target, property, value) {
+        return Reflect.set(process.argv, property, value);
+    },
+});
 export const cwd = () => {
     return process.cwd();
 };

package/src/parts/TransientLinkedExtensions/TransientLinkedExtensions.js

@@ -0,0 +1,66 @@
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js';
+import * as FileSystem from '../FileSystem/FileSystem.js';
+import * as Path from '../Path/Path.js';
+import * as Process from '../Process/Process.js';
+const getCliLinkArgs = () => {
+    const links = [];
+    const argv = Process.argv.slice(2);
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--link') {
+            const value = argv[i + 1];
+            links.push({
+                path: value || '',
+                source: '--link',
+            });
+            i++;
+            continue;
+        }
+        if (arg.startsWith('--link=')) {
+            links.push({
+                path: arg.slice('--link='.length),
+                source: '--link',
+            });
+        }
+    }
+    return links;
+};
+const resolveLinkPath = (path) => {
+    if (Path.isAbsolute(path)) {
+        return path;
+    }
+    return Path.join(Process.cwd(), path);
+};
+export const getLinkedExtensions = () => {
+    return getCliLinkArgs().map((link) => {
+        return {
+            ...link,
+            resolvedPath: resolveLinkPath(link.path),
+        };
+    });
+};
+const createMissingPathError = (link) => {
+    const error = new Error(`Failed to start: ${link.source} requires a folder path`);
+    // @ts-ignore
+    error.code = ErrorCodes.ENOENT;
+    return error;
+};
+const createPathNotFoundError = (link) => {
+    const message = link.path === link.resolvedPath ? link.path : `${link.path} (resolved to ${link.resolvedPath})`;
+    const error = new Error(`Failed to start: ${link.source} path does not exist: ${message}`);
+    // @ts-ignore
+    error.code = ErrorCodes.ENOENT;
+    return error;
+};
+export const validate = async () => {
+    const links = getLinkedExtensions();
+    for (const link of links) {
+        if (!link.path) {
+            throw createMissingPathError(link);
+        }
+        if (!(await FileSystem.exists(link.resolvedPath))) {
+            throw createPathNotFoundError(link);
+        }
+    }
+    return links;
+};