fix(runtime): align bundled service launch paths

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: newbe36524

src/main/code-server-manager.ts

@@ -6,8 +6,9 @@ import {
 } from './code-server-runtime.js';
 import type DependencyManagementService from './dependency-management-service.js';
 import type { ConfigManager } from './config.js';
+import { getNodeExecutableRelativePath } from './embedded-node-runtime-config.js';
 import { buildPm2MajorHomePaths } from './portable-toolchain-paths.js';
-import { ensurePm2HomeAlias } from './pm2-home-alias.js';
+import { ensureNoSpacePathAlias, ensurePm2HomeAlias } from './pm2-home-alias.js';
 import {
   injectCodeServerRuntimeEnv,
   injectManagedCliPathEnv,
@@ -297,7 +298,7 @@ export class CodeServerManager {
       }
 
       const snapshot = await this.getRuntimeSnapshot();
-      if (!snapshot.wrapperPath && !(process.platform === 'win32' && snapshot.entryScriptPath)) {
+      if (!snapshot.wrapperPath && !snapshot.entryScriptPath) {
         throw new Error(snapshot.message ?? 'Vendored code-server runtime is not ready.');
       }
 
@@ -310,8 +311,7 @@ export class CodeServerManager {
       const runtimeEnv = injectCodeServerRuntimeEnv(pm2.env, this.pathManager, {
         platform: process.platform,
       });
-      const nodeExecutablePath = pm2.env.HAGICODE_NODE_EXECUTABLE_PATH ?? pm2.env.HAGICODE_DOTNET_EXE;
-      const launchSpec = this.resolveLaunchSpec(snapshot, nodeExecutablePath);
+      const launchSpec = await this.resolveLaunchSpec(snapshot);
       await this.renderEcosystem(paths, launchSpec, runtimeEnv.env);
 
       if (action === 'start') {
@@ -569,10 +569,9 @@ export class CodeServerManager {
     }
   }
 
-  private resolveLaunchSpec(
+  private async resolveLaunchSpec(
     runtime: VendoredRuntimeStatusSnapshot,
-    nodeExecutablePath: string | undefined,
-  ): CodeServerLaunchSpec {
+  ): Promise<CodeServerLaunchSpec> {
     const args = [
       '--bind-addr',
       `127.0.0.1:${this.getConfig().port}`,
@@ -585,24 +584,46 @@ export class CodeServerManager {
       '--disable-telemetry',
     ];
 
-    if (process.platform === 'win32' && runtime.entryScriptPath && nodeExecutablePath) {
+    const runtimeRoot = await ensureNoSpacePathAlias(
+      this.pathManager.getCodeServerRuntimeRoot(),
+      'code-server-runtime',
+    );
+    const portableToolchainRoot = await ensureNoSpacePathAlias(
+      this.pathManager.getPortableToolchainRoot(),
+      'desktop-toolchain',
+    );
+
+    if (runtime.entryScriptPath) {
+      const aliasedEntryScriptPath = path.join(
+        runtimeRoot,
+        path.relative(this.pathManager.getCodeServerRuntimeRoot(), runtime.entryScriptPath),
+      );
+      const nodeExecutablePath = path.join(
+        portableToolchainRoot,
+        getNodeExecutableRelativePath(process.platform),
+      );
       return {
         script: nodeExecutablePath,
-        args: [runtime.entryScriptPath, ...args],
+        args: [aliasedEntryScriptPath, ...args],
         interpreterNone: true,
-        cwd: this.pathManager.getCodeServerRuntimeRoot(),
+        cwd: runtimeRoot,
       };
     }
 
     if (!runtime.wrapperPath) {
       throw new Error(runtime.message ?? 'Vendored code-server runtime is not ready.');
     }
 
+    const aliasedWrapperPath = path.join(
+      runtimeRoot,
+      path.relative(this.pathManager.getCodeServerRuntimeRoot(), runtime.wrapperPath),
+    );
+
     return {
-      script: runtime.wrapperPath,
+      script: aliasedWrapperPath,
       args,
       interpreterNone: true,
-      cwd: this.pathManager.getCodeServerRuntimeRoot(),
+      cwd: runtimeRoot,
     };
   }
 

src/main/hagiscript-runtime-context.ts

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import type { DependencyManagementService } from './dependency-management-service.js';
+import { ensureNoSpacePathAlias } from './pm2-home-alias.js';
 import type { PathManager } from './path-manager.js';
 import type { ActiveRuntimeDescriptor } from '../types/distribution-mode.js';
 
@@ -77,6 +78,15 @@ export class HagiscriptRuntimeContextResolver {
     const runtimeHome = path.resolve(this.pathManager.getRuntimeProgramHome());
     const runtimeDataRoot = path.resolve(this.pathManager.getRuntimeDataHome());
     const runtimeRoot = path.resolve(input.activeRuntime.rootPath);
+    const aliasedRuntimeHome = await ensureNoSpacePathAlias(runtimeHome, 'desktop-runtime-home');
+    const aliasedRuntimeRoot = await ensureNoSpacePathAlias(runtimeRoot, 'desktop-active-runtime-root');
+    const dotnetRuntimeRoot = path.resolve(this.pathManager.getEmbeddedRuntimeRoot(this.pathManager.getCurrentPlatform()));
+    const aliasedDotnetRuntimeRoot = await ensureNoSpacePathAlias(dotnetRuntimeRoot, 'desktop-dotnet-runtime-root');
+    const serviceWorkingDirectory = path.resolve(input.serviceWorkingDirectory);
+    const aliasedServiceWorkingDirectory = await ensureNoSpacePathAlias(
+      serviceWorkingDirectory,
+      'desktop-service-working-directory',
+    );
     const runtimeLogsDirectory = path.join(runtimeDataRoot, 'logs');
     const runtimeStateFilePath = path.join(runtimeDataRoot, 'state.json');
     const serviceDataHome = path.join(runtimeDataRoot, 'components', SERVER_RUNTIME_DATA_DIR);
@@ -90,14 +100,17 @@ export class HagiscriptRuntimeContextResolver {
       manifestPath,
       `${JSON.stringify(
         this.buildManifestOverride({
-          runtimeRoot,
-          runtimeHome,
+          runtimeRoot: aliasedRuntimeRoot,
+          runtimeHome: aliasedRuntimeHome,
           runtimeDataRoot,
           npmPrefix: path.resolve(hagiscriptContext.environment.npmGlobalPrefix),
           hagiscriptPackageRoot,
-          dotnetRuntimeRoot: path.resolve(this.pathManager.getEmbeddedRuntimeRoot(this.pathManager.getCurrentPlatform())),
-          servicePayloadPath: path.resolve(input.servicePayloadPath),
-          serviceWorkingDirectory: path.resolve(input.serviceWorkingDirectory),
+          dotnetRuntimeRoot: aliasedDotnetRuntimeRoot,
+          servicePayloadPath: path.join(
+            aliasedServiceWorkingDirectory,
+            path.basename(path.resolve(input.servicePayloadPath)),
+          ),
+          serviceWorkingDirectory: aliasedServiceWorkingDirectory,
           serviceEnv: input.serviceEnv ?? {},
         }),
         null,
@@ -111,8 +124,8 @@ export class HagiscriptRuntimeContextResolver {
       hagiscriptExecutablePath,
       hagiscriptPackageRoot,
       commandEnv: hagiscriptContext.commandEnv,
-      runtimeRoot,
-      runtimeHome,
+      runtimeRoot: aliasedRuntimeRoot,
+      runtimeHome: aliasedRuntimeHome,
       runtimeDataRoot,
       runtimeLogsDirectory,
       runtimeStateFilePath,
@@ -123,8 +136,11 @@ export class HagiscriptRuntimeContextResolver {
       manifestPath,
       manifestDirectory,
       appName: 'hagicode-server',
-      servicePayloadPath: path.resolve(input.servicePayloadPath),
-      serviceWorkingDirectory: path.resolve(input.serviceWorkingDirectory),
+      servicePayloadPath: path.join(
+        aliasedServiceWorkingDirectory,
+        path.basename(path.resolve(input.servicePayloadPath)),
+      ),
+      serviceWorkingDirectory: aliasedServiceWorkingDirectory,
       cleanup: async () => {
         await fs.rm(manifestDirectory, { recursive: true, force: true });
       },

src/main/non-interactive-runtime-lifecycle.ts

@@ -21,6 +21,7 @@ import { CodeServerManager } from './code-server-manager.js';
 import OmniRouteManager from './omniroute-manager.js';
 import { CODE_SERVER_PROCESS_NAME } from '../types/code-server-management.js';
 import { OMNIROUTE_PROCESS_NAME } from '../types/omniroute-management.js';
+import type { ActiveRuntimeDescriptor } from '../types/distribution-mode.js';
 
 const DEFAULT_VERIFICATION_TIMEOUT_MS = 30_000;
 const DEFAULT_POLL_INTERVAL_MS = 1_000;
@@ -204,6 +205,17 @@ function createEmptyBackendReport(): BackendLifecycleReport {
   };
 }
 
+function buildEmbeddedRuntimeDescriptor(pathManager: PathManager): ActiveRuntimeDescriptor {
+  return {
+    kind: 'portable-fixed',
+    rootPath: pathManager.getEmbeddedRuntimeRoot(),
+    versionId: `embedded-${app.getVersion()}-${pathManager.getCurrentPlatform()}`,
+    versionLabel: app.getVersion(),
+    displayName: 'embedded-runtime',
+    isReadOnly: true,
+  };
+}
+
 async function verifyCodeServerLifecycle(input: {
   manager: CodeServerManager;
   pm2Command: string | null;
@@ -373,7 +385,9 @@ async function verifyBackendLifecycle(input: {
   const packageSourceConfigManager = new PackageSourceConfigManager(input.configManager.getStore() as unknown as Store);
   const versionManager = new VersionManager(dependencyManager, packageSourceConfigManager);
   const distributionModeState = await versionManager.initializeDistributionMode();
-  const activeRuntime = distributionModeState.activeRuntime ?? await versionManager.getActiveRuntimeDescriptor();
+  const activeRuntime = distributionModeState.activeRuntime
+    ?? await versionManager.getActiveRuntimeDescriptor()
+    ?? buildEmbeddedRuntimeDescriptor(input.pathManager);
 
   report.activeRuntimeRoot = activeRuntime?.rootPath ?? null;
   if (!activeRuntime) {

src/main/omniroute-manager.ts

@@ -6,10 +6,11 @@ import { app, shell } from 'electron';
 import log from 'electron-log';
 import { ConfigManager } from './config.js';
 import type DependencyManagementService from './dependency-management-service.js';
+import { getNodeExecutableRelativePath } from './embedded-node-runtime-config.js';
 import { buildOmniRouteDependencyRemediation } from './omniroute-remediation.js';
 import { inspectVendoredOmniRouteRuntime } from './omniroute-runtime.js';
 import { Pm2DotnetManager, resolvePm2LaunchPlan } from './pm2-dotnet-manager.js';
-import { ensurePm2HomeAlias } from './pm2-home-alias.js';
+import { ensureNoSpacePathAlias, ensurePm2HomeAlias } from './pm2-home-alias.js';
 import { injectManagedCliPathEnv, resolvePathEnvKey } from './portable-toolchain-env.js';
 import { buildPm2MajorHomePaths } from './portable-toolchain-paths.js';
 import { resolveCommandLaunch } from './toolchain-launch.js';
@@ -482,13 +483,12 @@ export class OmniRouteManager {
         throw new Error(remediation.message);
       }
       const pm2ExecutablePath = pm2Context.executablePath;
-      const nodeExecutablePath = pm2Context.environment.node.executablePath;
-      if (!pm2ExecutablePath || !nodeExecutablePath || !runtime.entryScriptPath) {
+      if (!pm2ExecutablePath || !runtime.entryScriptPath) {
         throw new Error('Desktop-managed OmniRoute dependencies are unavailable.');
       }
 
       await this.renderEnvironment(paths);
-      const launchSpec = this.resolveVendoredRuntimeLaunchSpec(paths, nodeExecutablePath, runtime.entryScriptPath);
+      const launchSpec = await this.resolveVendoredRuntimeLaunchSpec(runtime);
       await this.renderEcosystemConfig(paths, launchSpec, managedPm2Env);
 
       if (action === 'start') {
@@ -658,16 +658,27 @@ export class OmniRouteManager {
     }
   }
 
-  private resolveVendoredRuntimeLaunchSpec(
-    paths: OmniRouteManagedPaths,
-    nodeExecutablePath: string,
-    entryScriptPath: string,
-  ): ManagedCliLaunchSpec {
+  private async resolveVendoredRuntimeLaunchSpec(
+    runtime: VendoredRuntimeStatusSnapshot,
+  ): Promise<ManagedCliLaunchSpec> {
+    const runtimeRoot = await ensureNoSpacePathAlias(
+      this.pathManager.getOmniRouteRuntimeRoot(),
+      'omniroute-runtime',
+    );
+    const bundledNodeExecutablePath = path.join(
+      runtimeRoot,
+      'toolchain',
+      getNodeExecutableRelativePath(process.platform),
+    );
+    const entryScriptPath = path.join(
+      runtimeRoot,
+      path.relative(this.pathManager.getOmniRouteRuntimeRoot(), runtime.entryScriptPath ?? ''),
+    );
     return {
-      script: stripWrappingQuotes(nodeExecutablePath),
+      script: stripWrappingQuotes(bundledNodeExecutablePath),
       args: [entryScriptPath, 'serve', '--no-open'],
       interpreterNone: true,
-      cwd: paths.root,
+      cwd: runtimeRoot,
     };
   }
 

src/main/pm2-home-alias.ts

@@ -6,17 +6,14 @@ function sanitizeSegment(value: string): string {
   return value.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'pm2';
 }
 
-export async function ensurePm2HomeAlias(targetPath: string, label: string): Promise<string> {
-  await fs.mkdir(targetPath, { recursive: true });
-  if (!targetPath.includes(' ')) {
-    return targetPath;
-  }
-
-  const aliasRoot = process.platform === 'win32'
-    ? path.join(path.parse(targetPath).root, 'hagicode-desktop-pm2-home')
-    : path.join('/tmp', 'hagicode-desktop-pm2-home');
+async function ensureSymlinkAlias(input: {
+  targetPath: string;
+  label: string;
+  aliasRoot: string;
+  type: 'dir' | 'file';
+}): Promise<string> {
+  const { targetPath, label, aliasRoot, type } = input;
   await fs.mkdir(aliasRoot, { recursive: true });
-
   const digest = createHash('sha256').update(targetPath).digest('hex').slice(0, 12);
   const aliasPath = path.join(aliasRoot, `${sanitizeSegment(label)}-${digest}`);
 
@@ -33,6 +30,39 @@ export async function ensurePm2HomeAlias(targetPath: string, label: string): Pro
   }
 
   await fs.rm(aliasPath, { recursive: true, force: true });
-  await fs.symlink(targetPath, aliasPath, process.platform === 'win32' ? 'junction' : 'dir');
+  await fs.symlink(targetPath, aliasPath, process.platform === 'win32' ? 'junction' : type);
   return aliasPath;
 }
+
+export async function ensureNoSpacePathAlias(targetPath: string, label: string): Promise<string> {
+  if (process.platform === 'win32') {
+    return targetPath;
+  }
+  if (!targetPath.includes(' ')) {
+    return targetPath;
+  }
+
+  const stats = await fs.lstat(targetPath);
+  return ensureSymlinkAlias({
+    targetPath,
+    label,
+    aliasRoot: path.join('/tmp', 'hagicode-desktop-path-alias'),
+    type: stats.isDirectory() ? 'dir' : 'file',
+  });
+}
+
+export async function ensurePm2HomeAlias(targetPath: string, label: string): Promise<string> {
+  await fs.mkdir(targetPath, { recursive: true });
+  if (!targetPath.includes(' ')) {
+    return targetPath;
+  }
+
+  return ensureSymlinkAlias({
+    targetPath,
+    label,
+    aliasRoot: process.platform === 'win32'
+    ? path.join(path.parse(targetPath).root, 'hagicode-desktop-pm2-home')
+    : path.join('/tmp', 'hagicode-desktop-pm2-home'),
+    type: 'dir',
+  });
+}