@lvce-editor/shared-process 0.80.7 → 0.80.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.80.7",
+  "version": "0.80.10",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -18,19 +18,20 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "1.5.1",
-    "@lvce-editor/extension-host-helper-process": "0.80.7",
+    "@lvce-editor/auth-process": "1.6.0",
+    "@lvce-editor/extension-host-helper-process": "0.80.10",
     "@lvce-editor/ipc": "15.0.0",
     "@lvce-editor/json-rpc": "8.0.0",
     "@lvce-editor/jsonc-parser": "1.5.0",
     "@lvce-editor/pretty-error": "2.0.0",
-    "@lvce-editor/rpc-registry": "9.20.0",
+    "@lvce-editor/rpc-registry": "9.22.0",
     "@lvce-editor/verror": "1.7.0",
     "is-object": "^1.0.2",
     "xdg-basedir": "^5.1.0"
   },
   "optionalDependencies": {
     "@lvce-editor/embeds-process": "4.4.0",
-    "@lvce-editor/file-system-process": "5.0.0",
+    "@lvce-editor/file-system-process": "5.1.0",
     "@lvce-editor/file-watcher-process": "3.6.0",
     "@lvce-editor/network-process": "5.2.0",
     "@lvce-editor/preload": "1.5.0",

package/src/parts/AuthProcess/AuthProcess.js

@@ -0,0 +1,13 @@
+import * as LaunchAuthProcess from '../LaunchAuthProcess/LaunchAuthProcess.js';
+export const state = {
+    /**
+     * @type {any}
+     */
+    ipc: undefined,
+};
+export const getOrCreate = async () => {
+    if (!state.ipc) {
+        state.ipc = LaunchAuthProcess.launchAuthProcess();
+    }
+    return state.ipc;
+};

package/src/parts/AuthProcessPath/AuthProcessPath.js

@@ -0,0 +1,3 @@
+import * as Path from '../Path/Path.js';
+import * as Root from '../Root/Root.js';
+export const authProcessPath = Path.join(Root.root, 'packages', 'shared-process', 'node_modules', '@lvce-editor', 'auth-process', 'dist', 'index.js');

package/src/parts/AuthProcessState/AuthProcessState.js

@@ -0,0 +1,12 @@
+const state = {
+    ref: 0,
+};
+export const increment = () => {
+    state.ref++;
+};
+export const hasRef = () => {
+    return state.ref > 0;
+};
+export const decrement = async () => {
+    state.ref--;
+};

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', '28473cd', 'extensions');
+    const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', '27c0844', 'extensions');
     return builtinExtensionsPath;
 };

package/src/parts/HandleIpcAuthProcess/HandleIpcAuthProcess.js

@@ -0,0 +1,11 @@
+import * as AuthProcess from '../AuthProcess/AuthProcess.js';
+export const targetMessagePort = () => {
+    return AuthProcess.getOrCreate();
+};
+export const upgradeMessagePort = (port, message) => {
+    return {
+        type: 'send',
+        method: 'HandleMessagePort.handleMessagePort',
+        params: [port, message.ipcId],
+    };
+};

package/src/parts/HandleIpcModule/HandleIpcModule.js

@@ -1,4 +1,5 @@
 import * as Assert from '../Assert/Assert.js';
+import * as HandleIpcAuthProcess from '../HandleIpcAuthProcess/HandleIpcAuthProcess.js';
 import * as HandleIpcClipBoardProcess from '../HandleIpcClipBoardProcess/HandleIpcClipBoardProcess.js';
 import * as HandleIpcEmbedsProcess from '../HandleIpcEmbedsProcess/HandleIpcEmbedsProcess.js';
 import * as HandleIpcExtensionHostHelperProcess from '../HandleIpcExtensionHostHelperProcess/HandleIpcExtensionHostHelperProcess.js';
@@ -11,6 +12,8 @@ import * as IpcId from '../IpcId/IpcId.js';
 export const getModule = (ipcId) => {
     Assert.number(ipcId);
     switch (ipcId) {
+        case IpcId.AuthProcess:
+            return HandleIpcAuthProcess;
         case IpcId.SharedProcess:
             return HandleIpcSharedProcess;
         case IpcId.EmbedsProcess:

package/src/parts/HandleMessagePortForAuthProcess/HandleMessagePortForAuthProcess.ipc.js

@@ -0,0 +1,6 @@
+import * as HandleMessagePortForAuthProcess from './HandleMessagePortForAuthProcess.js';
+export const name = 'HandleMessagePortForAuthProcess';
+export const Commands = {
+    handleMessagePortForAuthProcess: HandleMessagePortForAuthProcess.handleMessagePortForAuthProcess,
+    handleAuthProcessIpcClosed: HandleMessagePortForAuthProcess.handleAuthProcessIpcClosed,
+};

package/src/parts/HandleMessagePortForAuthProcess/HandleMessagePortForAuthProcess.js

@@ -0,0 +1,20 @@
+import * as AuthProcess from '../AuthProcess/AuthProcess.js';
+import * as AuthProcessState from '../AuthProcessState/AuthProcessState.js';
+import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js';
+import * as IpcId from '../IpcId/IpcId.js';
+export const handleMessagePortForAuthProcess = (port, ipcId) => {
+    AuthProcessState.increment();
+    return HandleIncomingIpc.handleIncomingIpc(IpcId.AuthProcess, port, {
+        ipcId,
+    });
+};
+export const handleAuthProcessIpcClosed = async () => {
+    AuthProcessState.decrement();
+    if (AuthProcessState.hasRef()) {
+        return;
+    }
+    const promise = AuthProcess.state.ipc;
+    AuthProcess.state.ipc = undefined;
+    const ipc = await promise;
+    ipc.dispose();
+};

package/src/parts/IpcId/IpcId.js

@@ -1,4 +1,5 @@
 import { RpcId } from '@lvce-editor/rpc-registry';
+export const AuthProcess = RpcId.AuthWorker;
 export const EmbedsProcess = RpcId.EmbedsProcess;
 export const EmbedsWorker = RpcId.EmbedsWorker;
 export const ExtensionHostHelperProcess = 3;

package/src/parts/LaunchAuthProcess/LaunchAuthProcess.js

@@ -0,0 +1,14 @@
+import * as AuthProcessPath from '../AuthProcessPath/AuthProcessPath.js';
+import * as IpcId from '../IpcId/IpcId.js';
+import * as IsElectron from '../IsElectron/IsElectron.js';
+import * as LaunchProcess from '../LaunchProcess/LaunchProcess.js';
+export const launchAuthProcess = async () => {
+    const ipc = await LaunchProcess.launchProcess({
+        name: 'Auth Process',
+        targetRpcId: IpcId.AuthProcess,
+        defaultPath: AuthProcessPath.authProcessPath,
+        isElectron: IsElectron.isElectron,
+        settingName: 'develop.authProcessPath',
+    });
+    return ipc;
+};

package/src/parts/Module/Module.js

@@ -83,8 +83,8 @@ export const load = (moduleId) => {
             return import('../Os/Os.ipc.js');
         case ModuleId.PlatformPaths:
             return import('../PlatformPaths/PlatformPaths.ipc.js');
-        case ModuleId.OAuthServer:
-            return import('../OAuthServer/OAuthServer.ipc.js');
+        case ModuleId.HandleMessagePortForAuthProcess:
+            return import('../HandleMessagePortForAuthProcess/HandleMessagePortForAuthProcess.ipc.js');
         case ModuleId.OutputChannel:
             return import('../OutputChannel/OutputChannel.ipc.js');
         case ModuleId.Performance:

package/src/parts/ModuleId/ModuleId.js

@@ -76,4 +76,4 @@ export const HandleMessagePortForFileSystemProcess = 81;
 export const HandleMessagePortForClipBoardProcess = 82;
 export const Exec = 83;
 export const PlatformPaths = 84;
-export const OAuthServer = 85;
+export const HandleMessagePortForAuthProcess = 86;

package/src/parts/ModuleMap/ModuleMap.js

@@ -188,10 +188,9 @@ export const getModuleId = (commandId) => {
             return ModuleId.GetWindowId;
         case 'Exec.exec':
             return ModuleId.Exec;
-        case 'OAuthServer.create':
-        case 'OAuthServer.getCode':
-        case 'OAuthServer.dispose':
-            return ModuleId.OAuthServer;
+        case 'HandleMessagePortForAuthProcess.handleMessagePortForAuthProcess':
+        case 'HandleMessagePortForAuthProcess.handleAuthProcessIpcClosed':
+            return ModuleId.HandleMessagePortForAuthProcess;
         case 'PlatformPaths.getDisabledExtensionsJsonPath':
         case 'PlatformPaths.getDisabledExtensionsJsonUri':
             return ModuleId.PlatformPaths;

package/src/parts/Platform/Platform.js

@@ -41,9 +41,9 @@ export const getAppImageName = () => {
 export const getSetupName = () => {
     return 'Lvce-Setup';
 };
-export const version = '0.80.7';
-export const commit = '28473cd';
-export const date = '2026-04-22T19:34:14.000Z';
+export const version = '0.80.10';
+export const commit = '27c0844';
+export const date = '2026-04-28T21:15:08.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', '28473cd', 'packages', 'preload', 'dist', 'index.js');
+    return join(Root.root, 'static', '27c0844', 'packages', 'preload', 'dist', 'index.js');
 };

package/src/parts/SendIncomingIpc/SendIncomingIpc.js

@@ -4,6 +4,7 @@ import * as IpcTransferState from '../IpcTransferState/IpcTransferState.js';
 import * as JsonRpc from '../JsonRpc/JsonRpc.js';
 const supportsPartialIpcHandling = (ipcId) => {
     switch (ipcId) {
+        case IpcId.AuthProcess:
         case IpcId.TerminalProcess:
         case IpcId.ProcessExplorer:
         case IpcId.EmbedsProcess:

package/src/parts/OAuthServer/OAuthServer.ipc.js

@@ -1,7 +0,0 @@
-import * as OAuthServer from './OAuthServer.js';
-export const name = 'OAuthServer';
-export const Commands = {
-    create: OAuthServer.create,
-    getCode: OAuthServer.getCode,
-    dispose: OAuthServer.dispose,
-};

package/src/parts/OAuthServer/OAuthServer.js

@@ -1,165 +0,0 @@
-import { createServer } from 'node:http';
-import * as Assert from '../Assert/Assert.js';
-/** @type {Record<string, {
-  server: import('node:http').Server | undefined,
-  portPromise: Promise<number> | undefined,
-  successHtml: string,
-  errorHtml: string,
-  codeQueue: string[],
-  codePromise: Promise<string> | undefined,
-  resolveCode: ((value: string) => void) | undefined,
-  rejectCode: ((reason?: unknown) => void) | undefined,
-}>} */
-const states = Object.create(null);
-const getOrCreateState = (id) => {
-    if (!states[id]) {
-        states[id] = {
-            server: undefined,
-            portPromise: undefined,
-            successHtml: '',
-            errorHtml: '',
-            codeQueue: [],
-            codePromise: undefined,
-            resolveCode: undefined,
-            rejectCode: undefined,
-        };
-    }
-    return states[id];
-};
-const clearPendingCodePromise = (state) => {
-    state.codePromise = undefined;
-    state.resolveCode = undefined;
-    state.rejectCode = undefined;
-};
-const resolveCode = (state, code) => {
-    if (state.resolveCode) {
-        const { resolveCode } = state;
-        clearPendingCodePromise(state);
-        resolveCode(code);
-        return;
-    }
-    state.codeQueue.push(code);
-};
-const rejectPendingCode = (state, error) => {
-    if (!state.rejectCode) {
-        return;
-    }
-    const { rejectCode } = state;
-    clearPendingCodePromise(state);
-    rejectCode(error);
-};
-const getCodeFromRequest = (request) => {
-    if (!request.url) {
-        return undefined;
-    }
-    const url = new URL(request.url, 'http://localhost');
-    const code = url.searchParams.get('code');
-    return code || undefined;
-};
-const handleRequest = (id, request, response) => {
-    const state = states[id];
-    let html = '';
-    if (state) {
-        const code = getCodeFromRequest(request);
-        if (code) {
-            resolveCode(state, code);
-            html = state.successHtml;
-        }
-        else {
-            html = state.errorHtml;
-        }
-    }
-    response.writeHead(200, {
-        'Content-Type': 'text/html; charset=utf-8',
-        'Cache-Control': 'no-store',
-    });
-    response.end(html);
-};
-const listen = (server) => {
-    const { promise, resolve, reject } = Promise.withResolvers();
-    const onError = (error) => {
-        server.off('listening', onListening);
-        reject(error);
-    };
-    const onListening = () => {
-        server.off('error', onError);
-        const address = server.address();
-        if (!address || typeof address === 'string') {
-            reject(new Error('failed to determine oauth server port'));
-            return;
-        }
-        resolve(address.port);
-    };
-    server.once('error', onError);
-    server.once('listening', onListening);
-    server.listen(0, 'localhost');
-    return promise;
-};
-const getOrCreateCodePromise = (state) => {
-    if (!state.codePromise) {
-        const { promise, resolve, reject } = Promise.withResolvers();
-        state.codePromise = promise;
-        state.resolveCode = resolve;
-        state.rejectCode = reject;
-    }
-    return state.codePromise;
-};
-export const create = async (id, successHtml, errorHtml) => {
-    Assert.string(id);
-    Assert.string(successHtml);
-    Assert.string(errorHtml);
-    const state = getOrCreateState(id);
-    state.successHtml = successHtml;
-    state.errorHtml = errorHtml;
-    if (state.portPromise) {
-        return state.portPromise;
-    }
-    const server = createServer((request, response) => {
-        handleRequest(id, request, response);
-    });
-    state.server = server;
-    state.portPromise = listen(server);
-    try {
-        return await state.portPromise;
-    }
-    catch (error) {
-        state.server = undefined;
-        state.portPromise = undefined;
-        delete states[id];
-        throw error;
-    }
-};
-export const getCode = async (id) => {
-    Assert.string(id);
-    const state = states[id];
-    if (!state || !state.server) {
-        throw new Error(`oauth server ${id} not found`);
-    }
-    if (state.codeQueue.length > 0) {
-        return state.codeQueue.shift();
-    }
-    return getOrCreateCodePromise(state);
-};
-export const dispose = async (id) => {
-    Assert.string(id);
-    const state = getOrCreateState(id);
-    if (!state.server) {
-        delete states[id];
-        return;
-    }
-    const { server } = state;
-    state.server = undefined;
-    state.portPromise = undefined;
-    state.codeQueue = [];
-    rejectPendingCode(state, new Error('oauth server disposed'));
-    const { promise, resolve, reject } = Promise.withResolvers();
-    server.close((error) => {
-        if (error) {
-            reject(error);
-            return;
-        }
-        resolve(undefined);
-    });
-    await promise;
-    delete states[id];
-};