@tlbx-ai/midterm 8.2.1 → 8.2.4

package/README.md

@@ -31,5 +31,6 @@ Notes:
 
 - Default channel is `stable`
 - If you do not pass `--bind`, the launcher forces `127.0.0.1`
-- If you do not pass `--port`, the launcher opens `https://127.0.0.1:2000`
+- If you do not pass `--port`, the launcher starts at `https://127.0.0.1:2000` and automatically moves to the next free port if `2000` is unavailable
 - The launcher sets `MIDTERM_LAUNCH_MODE=npx` for the child process
+- If you invoke `npx` from WSL but it resolves to Windows `node/npm`, the launcher detects the WSL working directory and runs the Linux MidTerm build inside that distro

package/bin/midterm.js

@@ -5,12 +5,14 @@
 const fs = require('node:fs');
 const fsp = require('node:fs/promises');
 const https = require('node:https');
+const net = require('node:net');
 const os = require('node:os');
 const path = require('node:path');
 const { spawn, spawnSync } = require('node:child_process');
 
 const { version: PACKAGE_VERSION } = require('../package.json');
 const DEFAULT_PORT = 2000;
+const MAX_PORT_SCAN_ATTEMPTS = 100;
 const SERVER_READY_TIMEOUT_MS = 15000;
 const SERVER_READY_INTERVAL_MS = 500;
 const REPO_OWNER = 'tlbx-ai';
@@ -25,39 +27,55 @@ async function main() {
     return;
   }
 
-  const target = getPlatformTarget();
+  const runtime = await detectRuntime();
+  const target = await getPlatformTarget(runtime);
   const release = await resolveRelease(launcher.channel);
-  const installDir = await ensureInstalledRelease(release, target);
-  const mtPath = path.join(installDir, target.binaryName);
-  const mthostPath = path.join(installDir, target.hostBinaryName);
-
-  if (!fs.existsSync(mtPath) || !fs.existsSync(mthostPath)) {
-    throw new Error(`Downloaded release is incomplete: expected ${target.binaryName} and ${target.hostBinaryName}`);
-  }
+  const install = runtime.kind === 'wsl-interop'
+    ? await ensureInstalledReleaseInWsl(release, target, runtime)
+    : await ensureInstalledRelease(release, target);
 
   const childArgs = passthrough.slice();
+  const hasExplicitPort = hasArg(childArgs, '--port');
   const explicitBind = getArgValue(childArgs, '--bind');
   const explicitPort = parsePortArg(getArgValue(childArgs, '--port'));
+  const effectiveBind = explicitBind ?? '127.0.0.1';
+  const startsServer = shouldStartServer(childArgs);
+
+  let effectivePort = explicitPort ?? DEFAULT_PORT;
 
   if (!explicitBind) {
     childArgs.push('--bind', '127.0.0.1');
   }
 
-  const browserUrl = buildBrowserUrl(explicitBind ?? '127.0.0.1', explicitPort ?? DEFAULT_PORT);
+  if (startsServer && !hasExplicitPort) {
+    effectivePort = await findAvailablePort(effectiveBind, DEFAULT_PORT);
+    childArgs.push('--port', String(effectivePort));
+
+    if (effectivePort !== DEFAULT_PORT) {
+      console.error(`@tlbx-ai/midterm: port ${DEFAULT_PORT} is unavailable, using ${effectivePort}`);
+    }
+  }
+
+  const browserUrl = startsServer
+    ? buildBrowserUrl(effectiveBind, effectivePort)
+    : null;
   const childEnv = {
     ...process.env,
     MIDTERM_LAUNCH_MODE: 'npx',
     MIDTERM_NPX: '1',
     MIDTERM_NPX_CHANNEL: launcher.channel,
-    MIDTERM_NPX_PACKAGE_VERSION: PACKAGE_VERSION
+    MIDTERM_NPX_PACKAGE_VERSION: PACKAGE_VERSION,
+    MIDTERM_NPX_RUNTIME: runtime.kind
   };
 
-  const child = spawn(mtPath, childArgs, {
-    stdio: 'inherit',
-    env: childEnv
-  });
+  const child = runtime.kind === 'wsl-interop'
+    ? spawnMidTermInWsl(runtime, install.mtPath, childArgs, childEnv)
+    : spawn(install.mtPath, childArgs, {
+        stdio: 'inherit',
+        env: childEnv
+      });
 
-  if (launcher.openBrowser) {
+  if (launcher.openBrowser && browserUrl) {
     void openBrowserWhenReady(browserUrl);
   }
 
@@ -130,7 +148,105 @@ function printHelp() {
   console.log('All other arguments are passed to mt.');
 }
 
-function getPlatformTarget() {
+async function detectRuntime() {
+  const wslContext = await detectWslInteropContext();
+  if (wslContext) {
+    return wslContext;
+  }
+
+  return {
+    kind: 'native',
+    platform: process.platform,
+    arch: process.arch
+  };
+}
+
+async function detectWslInteropContext() {
+  if (process.platform !== 'win32') {
+    return null;
+  }
+
+  const parsed = findWslInteropPath();
+  if (!parsed) {
+    return null;
+  }
+
+  const linuxHome = getWslCommandOutput(parsed.distroName, ['pwd'], '~');
+  if (!linuxHome.startsWith('/')) {
+    throw new Error(`Failed to determine WSL home directory for ${parsed.distroName}`);
+  }
+
+  const archRaw = getWslCommandOutput(parsed.distroName, ['uname', '-m'], '/');
+
+  return {
+    kind: 'wsl-interop',
+    distroName: parsed.distroName,
+    linuxCwd: parsed.linuxPath,
+    linuxHome,
+    uncRoot: parsed.uncRoot,
+    arch: normalizeWslArchitecture(archRaw)
+  };
+}
+
+function findWslInteropPath() {
+  const candidates = [
+    process.cwd(),
+    process.env.INIT_CWD,
+    process.env.npm_config_local_prefix,
+    getPackageDirectory(process.env.npm_package_json)
+  ];
+
+  for (const candidate of candidates) {
+    const parsed = parseWslUncPath(candidate);
+    if (parsed) {
+      return parsed;
+    }
+  }
+
+  return null;
+}
+
+function getPackageDirectory(packageJsonPath) {
+  if (!packageJsonPath) {
+    return '';
+  }
+
+  return path.win32.dirname(packageJsonPath);
+}
+
+function parseWslUncPath(value) {
+  const normalized = String(value || '');
+  const match = normalized.match(/^\\\\wsl(?:\.localhost|\$)\\([^\\]+)(\\.*)?$/i);
+  if (!match) {
+    return null;
+  }
+
+  const distroName = match[1];
+  const suffix = match[2] || '';
+  const linuxPath = suffix
+    ? suffix.replace(/\\/g, '/')
+    : '/';
+
+  return {
+    distroName,
+    linuxPath,
+    uncRoot: `\\\\wsl.localhost\\${distroName}`
+  };
+}
+
+async function getPlatformTarget(runtime) {
+  if (runtime.kind === 'wsl-interop') {
+    if (runtime.arch === 'x64') {
+      return {
+        assetName: 'mt-linux-x64.tar.gz',
+        binaryName: 'mt',
+        hostBinaryName: 'mthost'
+      };
+    }
+
+    throw new Error(`Unsupported WSL platform: linux ${runtime.arch}`);
+  }
+
   if (process.platform === 'win32' && process.arch === 'x64') {
     return {
       assetName: 'mt-win-x64.zip',
@@ -208,8 +324,12 @@ async function ensureInstalledRelease(release, target) {
     throw new Error(`Release ${release.tag} does not contain ${target.assetName}`);
   }
 
+  const mtPath = path.join(versionDir, target.binaryName);
+  const mthostPath = path.join(versionDir, target.hostBinaryName);
+
   if (fs.existsSync(completeMarker)) {
-    return versionDir;
+    ensureInstalledFilesExist(mtPath, mthostPath, target);
+    return { mtPath, mthostPath };
   }
 
   await fsp.mkdir(cacheRoot, { recursive: true });
@@ -228,7 +348,8 @@ async function ensureInstalledRelease(release, target) {
     await fsp.rm(versionDir, { recursive: true, force: true });
     await fsp.rename(extractDir, versionDir);
     await fsp.writeFile(completeMarker, `${release.tag}\n`, 'utf8');
-    return versionDir;
+    ensureInstalledFilesExist(mtPath, mthostPath, target);
+    return { mtPath, mthostPath };
   } catch (error) {
     await fsp.rm(versionDir, { recursive: true, force: true }).catch(() => {});
     throw error;
@@ -237,6 +358,58 @@ async function ensureInstalledRelease(release, target) {
   }
 }
 
+async function ensureInstalledReleaseInWsl(release, target, runtime) {
+  const cacheRootLinux = path.posix.join(runtime.linuxHome, '.cache', 'midterm', 'npx-cache');
+  const cacheRootUnc = toWslUncPath(runtime, cacheRootLinux);
+  const versionDirLinux = path.posix.join(cacheRootLinux, sanitizeTag(release.tag));
+  const versionDirUnc = toWslUncPath(runtime, versionDirLinux);
+  const completeMarkerUnc = toWslUncPath(runtime, path.posix.join(versionDirLinux, '.complete'));
+  const targetAsset = release.assets.find((asset) => asset.name === target.assetName);
+
+  if (!targetAsset || !targetAsset.browser_download_url) {
+    throw new Error(`Release ${release.tag} does not contain ${target.assetName}`);
+  }
+
+  const mtPath = path.posix.join(versionDirLinux, target.binaryName);
+  const mthostPath = path.posix.join(versionDirLinux, target.hostBinaryName);
+  const mtPathUnc = toWslUncPath(runtime, mtPath);
+  const mthostPathUnc = toWslUncPath(runtime, mthostPath);
+
+  if (fs.existsSync(completeMarkerUnc)) {
+    ensureInstalledFilesExist(mtPathUnc, mthostPathUnc, target);
+    return { mtPath, mthostPath };
+  }
+
+  await fsp.mkdir(cacheRootUnc, { recursive: true });
+
+  const tempName = `staging-${Date.now()}-${process.pid}-${Math.random().toString(16).slice(2)}`;
+  const tempRootLinux = path.posix.join(cacheRootLinux, tempName);
+  const tempRootUnc = toWslUncPath(runtime, tempRootLinux);
+  const archiveLinux = path.posix.join(tempRootLinux, target.assetName);
+  const archiveUnc = toWslUncPath(runtime, archiveLinux);
+  const extractLinux = path.posix.join(tempRootLinux, 'extract');
+  const extractUnc = toWslUncPath(runtime, extractLinux);
+
+  try {
+    await fsp.mkdir(extractUnc, { recursive: true });
+    console.error(`MidTerm ${release.tag}: downloading ${target.assetName}`);
+    await downloadFile(targetAsset.browser_download_url, archiveUnc);
+    console.error(`MidTerm ${release.tag}: extracting`);
+    runWslCommand(runtime, ['tar', '-xzf', archiveLinux, '-C', extractLinux], '/');
+    runWslCommand(runtime, ['chmod', '755', path.posix.join(extractLinux, target.binaryName), path.posix.join(extractLinux, target.hostBinaryName)], '/');
+    await fsp.rm(versionDirUnc, { recursive: true, force: true });
+    await fsp.rename(extractUnc, versionDirUnc);
+    await fsp.writeFile(completeMarkerUnc, `${release.tag}\n`, 'utf8');
+    ensureInstalledFilesExist(mtPathUnc, mthostPathUnc, target);
+    return { mtPath, mthostPath };
+  } catch (error) {
+    await fsp.rm(versionDirUnc, { recursive: true, force: true }).catch(() => {});
+    throw error;
+  } finally {
+    await fsp.rm(tempRootUnc, { recursive: true, force: true }).catch(() => {});
+  }
+}
+
 function getCacheRoot() {
   if (process.platform === 'win32') {
     const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
@@ -286,14 +459,20 @@ function extractArchive(archivePath, destinationPath) {
       '-Command',
       `Expand-Archive -LiteralPath '${escapePowerShell(archivePath)}' -DestinationPath '${escapePowerShell(destinationPath)}' -Force`
     ];
-    const result = spawnSync('powershell', command, { stdio: 'inherit' });
+    const result = spawnSync('powershell', command, {
+      stdio: 'inherit',
+      cwd: getWindowsSubprocessCwd()
+    });
     if (result.status !== 0) {
       throw new Error(`Failed to extract ${path.basename(archivePath)} with PowerShell`);
     }
     return;
   }
 
-  const result = spawnSync('tar', ['-xzf', archivePath, '-C', destinationPath], { stdio: 'inherit' });
+  const result = spawnSync('tar', ['-xzf', archivePath, '-C', destinationPath], {
+    stdio: 'inherit',
+    cwd: getWindowsSubprocessCwd()
+  });
   if (result.status !== 0) {
     throw new Error(`Failed to extract ${path.basename(archivePath)} with tar`);
   }
@@ -341,6 +520,68 @@ function parsePortArg(value) {
   return parsed;
 }
 
+function shouldStartServer(args) {
+  const nonServerFlags = [
+    '--check-update',
+    '--update',
+    '--apply-update',
+    '--version',
+    '-v',
+    '--help',
+    '-h',
+    '--hash-password',
+    '--write-secret',
+    '--generate-cert'
+  ];
+
+  return !nonServerFlags.some((flag) => hasArg(args, flag));
+}
+
+async function findAvailablePort(bindAddress, preferredPort) {
+  for (let offset = 0; offset < MAX_PORT_SCAN_ATTEMPTS; offset++) {
+    const port = preferredPort + offset;
+    if (port > 65535) {
+      break;
+    }
+
+    if (await isPortAvailable(bindAddress, port)) {
+      return port;
+    }
+  }
+
+  throw new Error(`Could not find a free port starting at ${preferredPort}`);
+}
+
+function isPortAvailable(bindAddress, port) {
+  const host = normalizeBindForNetProbe(bindAddress);
+
+  return new Promise((resolve) => {
+    const server = net.createServer();
+
+    server.once('error', (error) => {
+      if (error && (error.code === 'EADDRINUSE' || error.code === 'EACCES')) {
+        resolve(false);
+        return;
+      }
+
+      resolve(false);
+    });
+
+    server.listen(port, host, () => {
+      server.close(() => resolve(true));
+    });
+  });
+}
+
+function normalizeBindForNetProbe(bindAddress) {
+  const raw = String(bindAddress || '').trim();
+  if (!raw || raw === 'localhost') {
+    return '127.0.0.1';
+  }
+
+  return raw.replace(/^\[(.*)\]$/, '$1');
+}
+
 function buildBrowserUrl(bindAddress, port) {
   const normalized = normalizeHostForBrowser(bindAddress);
   return `https://${normalized}:${port}`;
@@ -427,7 +668,8 @@ function openUrl(url) {
   const result = spawn(command, args, {
     detached: true,
     stdio: 'ignore',
-    windowsHide: true
+    windowsHide: true,
+    cwd: getWindowsSubprocessCwd()
   });
   result.on('error', (error) => {
     console.error(`@tlbx-ai/midterm: failed to open browser automatically: ${error.message}`);
@@ -435,6 +677,37 @@ function openUrl(url) {
   result.unref();
 }
 
+function spawnMidTermInWsl(runtime, mtPath, childArgs, childEnv) {
+  const envArgs = ['env'];
+  const passthroughEnv = [
+    'MIDTERM_LAUNCH_MODE',
+    'MIDTERM_NPX',
+    'MIDTERM_NPX_CHANNEL',
+    'MIDTERM_NPX_PACKAGE_VERSION',
+    'MIDTERM_NPX_RUNTIME'
+  ];
+
+  for (const key of passthroughEnv) {
+    if (childEnv[key]) {
+      envArgs.push(`${key}=${childEnv[key]}`);
+    }
+  }
+
+  envArgs.push(mtPath, ...childArgs);
+
+  return spawn('wsl.exe', [
+    '--distribution',
+    runtime.distroName,
+    '--cd',
+    runtime.linuxCwd,
+    '--exec',
+    ...envArgs
+  ], {
+    stdio: 'inherit',
+    cwd: getWindowsSubprocessCwd()
+  });
+}
+
 function forwardSignal(child, signal) {
   process.on(signal, () => {
     if (!child.killed) {
@@ -447,6 +720,93 @@ function escapePowerShell(value) {
   return value.replace(/'/g, "''");
 }
 
+function ensureInstalledFilesExist(mtPath, mthostPath, target) {
+  if (!fs.existsSync(mtPath) || !fs.existsSync(mthostPath)) {
+    throw new Error(`Downloaded release is incomplete: expected ${target.binaryName} and ${target.hostBinaryName}`);
+  }
+}
+
+function toWslUncPath(runtime, linuxPath) {
+  const normalized = String(linuxPath || '/');
+  const suffix = normalized === '/'
+    ? ''
+    : normalized.replace(/\//g, '\\');
+  return `${runtime.uncRoot}${suffix}`;
+}
+
+function getWslCommandOutput(distroName, commandArgs, cwd) {
+  const result = spawnSync('wsl.exe', [
+    '--distribution',
+    distroName,
+    '--cd',
+    cwd,
+    '--exec',
+    ...commandArgs
+  ], {
+    encoding: 'utf8',
+    cwd: getWindowsSubprocessCwd()
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (result.status !== 0) {
+    const stderr = String(result.stderr || '').trim();
+    throw new Error(`WSL command failed: ${stderr || commandArgs.join(' ')}`);
+  }
+
+  return String(result.stdout || '').trim();
+}
+
+function runWslCommand(runtime, commandArgs, cwd) {
+  const result = spawnSync('wsl.exe', [
+    '--distribution',
+    runtime.distroName,
+    '--cd',
+    cwd,
+    '--exec',
+    ...commandArgs
+  ], {
+    stdio: 'inherit',
+    cwd: getWindowsSubprocessCwd()
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (result.status !== 0) {
+    throw new Error(`WSL command failed: ${commandArgs.join(' ')}`);
+  }
+}
+
+function normalizeWslArchitecture(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (normalized === 'x86_64' || normalized === 'amd64') {
+    return 'x64';
+  }
+
+  if (normalized === 'aarch64' || normalized === 'arm64') {
+    return 'arm64';
+  }
+
+  return normalized || process.arch;
+}
+
+function getWindowsSubprocessCwd() {
+  if (process.platform !== 'win32') {
+    return undefined;
+  }
+
+  const cwd = process.cwd();
+  if (/^\\\\/.test(cwd)) {
+    return process.env.SystemRoot || 'C:\\Windows';
+  }
+
+  return undefined;
+}
+
 function compareVersions(leftTag, rightTag) {
   const left = parseVersion(leftTag);
   const right = parseVersion(rightTag);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tlbx-ai/midterm",
-  "version": "8.2.1",
+  "version": "8.2.4",
   "description": "Launch MidTerm via npx by downloading the native binary for your platform",
   "license": "AGPL-3.0-only",
   "repository": {