@pixelbyte-software/pixcode 1.41.3 → 1.41.5

package/scripts/smoke/runtime-manager.mjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const root = process.cwd();
+
+function read(relativePath) {
+  return fs.readFileSync(path.join(root, relativePath), 'utf8');
+}
+
+const managerSource = read('server/services/runtime-manager.js');
+assert.match(managerSource, /RUNTIME_DEFINITIONS/, 'Runtime manager should define a central runtime registry.');
+assert.match(managerSource, /node/, 'Runtime manager should include Node.js.');
+assert.match(managerSource, /php/, 'Runtime manager should include PHP.');
+assert.match(managerSource, /python/, 'Runtime manager should include Python.');
+assert.match(managerSource, /go/, 'Runtime manager should include Go.');
+assert.match(managerSource, /java/, 'Runtime manager should include Java.');
+assert.match(managerSource, /rust/, 'Runtime manager should include Rust.');
+assert.match(managerSource, /discoverRuntime/, 'Runtime manager should expose runtime discovery.');
+assert.match(managerSource, /resolveLiveViewRuntime/, 'Runtime manager should expose Live View runtime resolution.');
+
+const liveViewSource = read('server/services/live-view.js');
+assert.match(liveViewSource, /resolveLiveViewRuntime/, 'Live View should route runtime checks through the runtime manager.');
+assert.match(liveViewSource, /runtime:\s*session\.runtime/, 'Live View public session payload should expose runtime diagnostics.');
+assert.ok(
+  liveViewSource.includes('target.runtime'),
+  'Live View start should keep the runtime manager result on the session.',
+);
+
+const {
+  discoverRuntime,
+  resolveLiveViewRuntime,
+  runtimeManager,
+} = await import('../../server/services/runtime-manager.js');
+
+assert.equal(typeof runtimeManager.discover, 'function', 'Runtime manager should expose a discover method.');
+
+const nodeRuntime = await discoverRuntime('node');
+assert.equal(nodeRuntime.id, 'node');
+assert.equal(nodeRuntime.status, 'available', 'The current Node runtime should be detected as available.');
+assert.ok(nodeRuntime.path, 'Node runtime should include an executable path.');
+assert.match(nodeRuntime.version || '', /\d+\.\d+\.\d+/, 'Node runtime should include a version.');
+
+const missingPython = await discoverRuntime('python', {
+  strictPath: true,
+  env: {
+    ...process.env,
+    PATH: '',
+    Path: '',
+  },
+});
+assert.equal(missingPython.status, 'missing', 'Missing Python should produce a missing runtime status.');
+assert.match(missingPython.diagnostic.message, /Python/i, 'Missing Python diagnostics should name the runtime.');
+assert.match(missingPython.diagnostic.action, /python/i, 'Missing Python diagnostics should include an actionable install command.');
+
+const nodeLiveRuntime = await resolveLiveViewRuntime({
+  id: 'npm-dev-vite',
+  label: 'Vite dev server',
+  framework: 'Vite',
+  command: 'npm',
+  args: ['run', 'dev'],
+  displayCommand: 'npm run dev',
+  packageManager: 'npm',
+}, {
+  env: {
+    ...process.env,
+    PATH: '',
+    Path: '',
+  },
+  preferManaged: true,
+});
+assert.equal(nodeLiveRuntime.runtime.id, 'node', 'JavaScript Live View commands should resolve to the Node runtime.');
+assert.equal(nodeLiveRuntime.managedRuntime?.id, 'npm', 'JavaScript Live View commands should keep the managed npm hook.');
+assert.equal(nodeLiveRuntime.available, true, 'Managed npm should keep JavaScript projects runnable when npm is missing.');
+assert.match(nodeLiveRuntime.reason, /Node package runner/i, 'Managed npm diagnostics should explain the package runner.');
+
+const phpLiveRuntime = await resolveLiveViewRuntime({
+  id: 'php-built-in',
+  label: 'PHP built-in server',
+  framework: 'PHP',
+  command: 'php',
+  args: ['-S', '127.0.0.1:$PORT', '-t', '.'],
+  displayCommand: 'php -S 127.0.0.1:$PORT -t .',
+}, {
+  env: {
+    ...process.env,
+    PATH: '',
+    Path: '',
+  },
+  preferManaged: true,
+});
+assert.equal(phpLiveRuntime.runtime.id, 'php', 'PHP Live View commands should resolve to the PHP runtime.');
+assert.equal(phpLiveRuntime.managedRuntime?.id, 'frankenphp', 'PHP Live View commands should keep the managed FrankenPHP hook.');
+assert.equal(phpLiveRuntime.available, true, 'Managed PHP should keep PHP projects runnable when php is missing.');
+assert.match(phpLiveRuntime.reason, /PHP runtime/i, 'Managed PHP diagnostics should explain the Pixcode runtime.');
+
+console.log('runtime manager smoke passed');

package/server/routes/live-view.js

@@ -31,6 +31,29 @@ function buildUrls(req, session) {
   };
 }
 
+function buildEnvironmentTunnel(tunnel, urls) {
+  const active = Boolean(tunnel?.running && urls?.external);
+  return {
+    status: active ? 'active' : 'local-only',
+    url: active ? urls.external : null,
+    localUrl: urls?.local || null,
+    preferredUrl: urls?.preferred || urls?.local || null,
+  };
+}
+
+function attachEnvironmentRuntimeState(environment, urls, tunnel) {
+  if (!environment) return environment;
+  return {
+    ...environment,
+    urls,
+    tunnel: buildEnvironmentTunnel(tunnel, urls),
+    diagnostics: {
+      ...environment.diagnostics,
+      publicTunnelReady: Boolean(tunnel?.running && urls?.external),
+    },
+  };
+}
+
 function escapeHtml(value) {
   return String(value ?? '')
     .replaceAll('&', '&')
@@ -202,10 +225,13 @@ router.get('/:projectName/status', async (req, res) => {
     const { projectName } = req.params;
     const projectPath = await resolveProjectPath(projectName);
     const state = await getLiveViewState(projectName, projectPath);
+    const urls = buildUrls(req, state.session);
+    const tunnel = getTunnelState();
     res.json({
       ...state,
-      urls: buildUrls(req, state.session),
-      tunnel: getTunnelState(),
+      urls,
+      tunnel,
+      environment: attachEnvironmentRuntimeState(state.environment, urls, tunnel),
     });
   } catch (error) {
     res.status(error.statusCode || 500).json({ error: error.message || 'Failed to read Live View state' });
@@ -217,11 +243,15 @@ router.post('/:projectName/start', async (req, res) => {
     const { projectName } = req.params;
     const projectPath = await resolveProjectPath(projectName);
     const session = await startLiveView(projectName, projectPath, req.body || {});
+    const state = await getLiveViewState(projectName, projectPath);
+    const urls = buildUrls(req, session);
+    const tunnel = getTunnelState();
     res.json({
       success: true,
       session,
-      urls: buildUrls(req, session),
-      tunnel: getTunnelState(),
+      urls,
+      tunnel,
+      environment: attachEnvironmentRuntimeState(state.environment, urls, tunnel),
     });
   } catch (error) {
     const status = error.code === 'LIVE_VIEW_NOT_AVAILABLE' ? 422 : 500;
@@ -234,11 +264,15 @@ router.post('/:projectName/restart', async (req, res) => {
     const { projectName } = req.params;
     const projectPath = await resolveProjectPath(projectName);
     const session = await restartLiveView(projectName, projectPath, req.body || {});
+    const state = await getLiveViewState(projectName, projectPath);
+    const urls = buildUrls(req, session);
+    const tunnel = getTunnelState();
     res.json({
       success: true,
       session,
-      urls: buildUrls(req, session),
-      tunnel: getTunnelState(),
+      urls,
+      tunnel,
+      environment: attachEnvironmentRuntimeState(state.environment, urls, tunnel),
     });
   } catch (error) {
     res.status(500).json({ error: error.message || 'Failed to restart Live View' });
@@ -248,11 +282,14 @@ router.post('/:projectName/restart', async (req, res) => {
 router.post('/:projectName/stop', async (req, res) => {
   try {
     const session = await stopLiveView(req.params.projectName);
+    const urls = buildUrls(req, session);
+    const tunnel = getTunnelState();
     res.json({
       success: true,
       session,
-      urls: buildUrls(req, session),
-      tunnel: getTunnelState(),
+      urls,
+      tunnel,
+      environment: attachEnvironmentRuntimeState(null, urls, tunnel),
     });
   } catch (error) {
     res.status(500).json({ error: error.message || 'Failed to stop Live View' });

package/server/services/live-view.js

@@ -5,13 +5,13 @@ import net from 'node:net';
 import path from 'node:path';
 
 import { buildCliSpawnEnv } from './install-jobs.js';
-import { ensureManagedRuntime, getManagedRuntimeStatus } from './managed-runtimes.js';
+import { ensureManagedRuntime } from './managed-runtimes.js';
+import { resolveLiveViewRuntime } from './runtime-manager.js';
 
 const sessionsByProject = new Map();
 const sessionsByShareId = new Map();
 const READY_TIMEOUT_MS = 12000;
 const LOG_LIMIT = 200;
-const RUNTIME_CHECK_TIMEOUT_MS = 1800;
 
 const localUrlRegex = /https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[[^\]]+\])(?::(\d+))?[^\s"'<>]*/i;
 
@@ -82,88 +82,6 @@ function buildDisplayCommand(command, args) {
   return [command, ...args].join(' ');
 }
 
-function quoteForPosixShell(value) {
-  return `'${String(value).replaceAll("'", "'\\''")}'`;
-}
-
-function quoteForWindowsShell(value) {
-  return `"${String(value).replaceAll('"', '""')}"`;
-}
-
-function isPathLikeCommand(command) {
-  return path.isAbsolute(command) || command.includes('/') || command.includes('\\');
-}
-
-function runtimeMissingReason(command, framework) {
-  const base = `${command} is not available on this machine.`;
-  if (framework === 'PHP' || command === 'php') {
-    return 'Pixcode can prepare a local PHP runtime automatically before starting this project.';
-  }
-  if (command === 'npm' || command === 'pnpm' || command === 'yarn' || command === 'bun') {
-    return `${base} Pixcode can prepare a local Node package runner automatically before starting this project.`;
-  }
-  if (command === 'python' || command === 'python3') {
-    return `${base} Pixcode does not have a managed Python runtime for this stack yet.`;
-  }
-  return `${base} Pixcode does not have a managed ${framework || command} runtime for this stack yet.`;
-}
-
-async function checkCommandAvailability(command, env = process.env) {
-  if (!command || command.includes('\n') || command.includes('\r')) return true;
-
-  if (isPathLikeCommand(command)) {
-    try {
-      await fs.access(command);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  const checker = process.platform === 'win32'
-    ? {
-      command: process.env.ComSpec || 'cmd.exe',
-      args: ['/d', '/s', '/c', `where ${quoteForWindowsShell(command)}`],
-    }
-    : {
-      command: '/bin/sh',
-      args: ['-lc', `command -v ${quoteForPosixShell(command)}`],
-    };
-
-  return new Promise((resolve) => {
-    let settled = false;
-    let child = null;
-    const finish = (available) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve(available);
-    };
-
-    const timer = setTimeout(() => {
-      try {
-        child?.kill();
-      } catch {
-        // Ignore a raced process exit.
-      }
-      finish(true);
-    }, RUNTIME_CHECK_TIMEOUT_MS);
-
-    child = spawn(checker.command, checker.args, {
-      env,
-      stdio: 'ignore',
-      windowsHide: true,
-    });
-
-    child.on('error', (error) => {
-      finish(error?.code === 'ENOENT' ? false : true);
-    });
-    child.on('exit', (code) => {
-      finish(code === 0);
-    });
-  });
-}
-
 function buildPackageCommand(packageManager, scriptName, id, label, framework, extraArgs = []) {
   const args = packageRunArgs(packageManager, scriptName, extraArgs);
   return {
@@ -376,6 +294,91 @@ function buildManagedPhpCommand(runtimeStatus) {
   };
 }
 
+function publicCommand(command) {
+  if (!command) return null;
+  return {
+    id: command.id,
+    label: command.label,
+    displayCommand: command.displayCommand,
+    custom: command.custom === true || command.id === 'custom',
+  };
+}
+
+function liveViewEnvironmentMode(target, session) {
+  const kind = session?.kind || target?.kind || 'none';
+  if (kind === 'static') return 'static';
+  if (kind === 'process') return 'local-process';
+  return 'unavailable';
+}
+
+function liveViewEnvironmentStatus(target, session) {
+  if (session?.status) return session.status;
+  if (target?.available) return 'ready';
+  return 'unavailable';
+}
+
+function liveViewEnvironmentCommand(target, session) {
+  return publicCommand(session?.command) || publicCommand(target?.command);
+}
+
+function liveViewEnvironmentLogs(session) {
+  return Array.isArray(session?.log) ? session.log.slice(-40) : [];
+}
+
+function liveViewEnvironmentRuntime(target, session) {
+  return session?.runtime || target?.runtime || null;
+}
+
+function liveViewEnvironmentManagedRuntime(target, session) {
+  return session?.managedRuntime || target?.managedRuntime || target?.command?.managedRuntime || null;
+}
+
+export function buildLiveViewEnvironment({ target = null, session = null } = {}) {
+  const mode = liveViewEnvironmentMode(target, session);
+  const status = liveViewEnvironmentStatus(target, session);
+  const command = liveViewEnvironmentCommand(target, session);
+  const framework = session?.framework || target?.framework || null;
+  const label = session?.label || target?.label || framework || 'Live View';
+  const runtime = liveViewEnvironmentRuntime(target, session);
+  const managedRuntime = liveViewEnvironmentManagedRuntime(target, session);
+  const logs = liveViewEnvironmentLogs(session);
+  const reason = session?.error || target?.reason || null;
+
+  return {
+    id: mode === 'unavailable' ? 'live-view-unavailable' : `live-view-${mode}`,
+    mode,
+    status,
+    framework,
+    label,
+    command,
+    runtime,
+    managedRuntime,
+    port: session?.port ?? null,
+    upstreamUrl: session?.upstreamUrl ?? null,
+    sharePath: session?.sharePath ?? null,
+    logs,
+    diagnostics: {
+      runnerKind: session?.kind || target?.kind || 'none',
+      targetAvailable: Boolean(target?.available || session),
+      reason,
+      error: session?.error || null,
+      exitCode: session?.exitCode ?? null,
+      exitSignal: session?.exitSignal ?? null,
+      spawnErrorCode: session?.spawnErrorCode ?? null,
+      startedAt: session?.startedAt || null,
+      stoppedAt: session?.stoppedAt || null,
+      readyTimeoutMs: READY_TIMEOUT_MS,
+      staticServing: mode === 'static',
+      customCommand: command?.custom === true,
+      publicTunnelReady: false,
+    },
+    tunnel: {
+      status: 'local-only',
+      url: null,
+    },
+  };
+}
+
 function detectPackageCommand(packageJson, packageManager) {
   const scripts = packageJson.scripts || {};
   const devScript = String(scripts.dev || '');
@@ -596,11 +599,13 @@ export async function detectLiveViewTarget(projectPath, options = {}) {
 
   const processCommand = await detectProcessCommand(projectPath);
   if (processCommand) {
+    const runtimeResolution = await resolveLiveViewRuntime(processCommand, {
+      env: options.env || process.env,
+      preferManaged: true,
+    });
+
     if (isPackageManagerCommand(processCommand.command)) {
-      const managedRuntime = await getManagedRuntimeStatus('npm', {
-        env: options.env || process.env,
-        preferManaged: true,
-      });
+      const managedRuntime = runtimeResolution.managedRuntime;
       const command = buildManagedPackageCommand(processCommand, managedRuntime);
       return {
         available: true,
@@ -609,17 +614,13 @@ export async function detectLiveViewTarget(projectPath, options = {}) {
         framework: processCommand.framework,
         command,
         managedRuntime,
-        reason: managedRuntime.status === 'missing'
-          ? 'Pixcode will prepare a local Node package runner automatically before starting this project.'
-          : 'Pixcode will run this project with its managed Node package runner.',
+        runtime: runtimeResolution.runtime,
+        reason: runtimeResolution.reason,
       };
     }
 
     if (processCommand.framework === 'PHP' || processCommand.command === 'php') {
-      const managedRuntime = await getManagedRuntimeStatus('frankenphp', {
-        env: options.env || process.env,
-        preferManaged: true,
-      });
+      const managedRuntime = runtimeResolution.managedRuntime;
       const command = buildManagedPhpCommand(managedRuntime);
       return {
         available: true,
@@ -628,14 +629,12 @@ export async function detectLiveViewTarget(projectPath, options = {}) {
         framework: command.framework,
         command,
         managedRuntime,
-        reason: managedRuntime.status === 'missing'
-          ? 'Pixcode will prepare a local PHP runtime automatically before starting this project.'
-          : 'Pixcode will run this project with its managed PHP runtime.',
+        runtime: runtimeResolution.runtime,
+        reason: runtimeResolution.reason,
       };
     }
 
-    const runtimeAvailable = await checkCommandAvailability(processCommand.command, options.env || process.env);
-    if (!runtimeAvailable) {
+    if (!runtimeResolution.available) {
       return {
         available: false,
         kind: 'process',
@@ -643,7 +642,8 @@ export async function detectLiveViewTarget(projectPath, options = {}) {
         framework: processCommand.framework,
         command: processCommand,
         missingRuntime: processCommand.command,
-        reason: runtimeMissingReason(processCommand.command, processCommand.framework),
+        runtime: runtimeResolution.runtime,
+        reason: runtimeResolution.reason,
       };
     }
 
@@ -653,6 +653,7 @@ export async function detectLiveViewTarget(projectPath, options = {}) {
       label: processCommand.label,
       framework: processCommand.framework,
       command: processCommand,
+      runtime: runtimeResolution.runtime,
     };
   }
 
@@ -732,11 +733,8 @@ function publicSession(session) {
     kind: session.kind,
     framework: session.framework,
     label: session.label,
-    command: session.command ? {
-      id: session.command.id,
-      label: session.command.label,
-      displayCommand: session.command.displayCommand,
-    } : null,
+    command: publicCommand(session.command),
+    runtime: session.runtime || null,
     managedRuntime: session.managedRuntime || null,
     port: session.port,
     upstreamUrl: session.upstreamUrl,
@@ -753,9 +751,11 @@ function publicSession(session) {
 export async function getLiveViewState(projectName, projectPath) {
   const target = await detectLiveViewTarget(projectPath);
   const session = sessionsByProject.get(projectName) ?? null;
+  const publicLiveViewSession = publicSession(session);
   return {
     target,
-    session: publicSession(session),
+    session: publicLiveViewSession,
+    environment: buildLiveViewEnvironment({ target, session: publicLiveViewSession }),
   };
 }
 
@@ -780,6 +780,7 @@ export async function startLiveView(projectName, projectPath, options = {}) {
         command: customCommand,
         args: [],
         displayCommand: customCommand,
+        custom: true,
         shell: true,
       },
     }
@@ -803,6 +804,7 @@ export async function startLiveView(projectName, projectPath, options = {}) {
       label: target.label,
       staticRoot: target.staticRoot,
       command: null,
+      runtime: null,
       port: null,
       upstreamUrl: null,
       startedAt: new Date().toISOString(),
@@ -842,6 +844,7 @@ export async function startLiveView(projectName, projectPath, options = {}) {
     framework: target.framework,
     label: target.label,
     command,
+    runtime: target.runtime || null,
     managedRuntime: runtimeStatus,
     port,
     host: '127.0.0.1',