@tlbx-ai/midterm 0.1.0 → 8.2.3

package/README.md

@@ -6,7 +6,7 @@ Launch MidTerm through `npx`.
 npx @tlbx-ai/midterm
 ```
 
-The launcher downloads the native MidTerm release for your platform, caches it in your user profile, and runs it locally.
+The launcher downloads the native MidTerm release for your platform, caches it in your user profile, runs it locally, and opens MidTerm in your default browser.
 
 Supported platforms:
 
@@ -24,10 +24,13 @@ npx @tlbx-ai/midterm -- --port 2001 --bind 127.0.0.1
 Launcher-only options:
 
 - `--channel stable|dev`
+- `--no-browser`
 - `--help-launcher`
 
 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`
 - 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

@@ -4,11 +4,15 @@
 
 const fs = require('node:fs');
 const fsp = require('node:fs/promises');
+const https = require('node:https');
 const os = require('node:os');
 const path = require('node:path');
 const { spawn, spawnSync } = require('node:child_process');
 
-const PACKAGE_VERSION = '0.1.0';
+const { version: PACKAGE_VERSION } = require('../package.json');
+const DEFAULT_PORT = 2000;
+const SERVER_READY_TIMEOUT_MS = 15000;
+const SERVER_READY_INTERVAL_MS = 500;
 const REPO_OWNER = 'tlbx-ai';
 const REPO_NAME = 'MidTerm';
 const GITHUB_API = `https://api.github.com/repos/${REPO_OWNER}/${REPO_NAME}`;
@@ -21,33 +25,41 @@ 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();
-  if (!hasArg(childArgs, '--bind')) {
+  const explicitBind = getArgValue(childArgs, '--bind');
+  const explicitPort = parsePortArg(getArgValue(childArgs, '--port'));
+
+  if (!explicitBind) {
     childArgs.push('--bind', '127.0.0.1');
   }
 
+  const browserUrl = buildBrowserUrl(explicitBind ?? '127.0.0.1', explicitPort ?? DEFAULT_PORT);
   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) {
+    void openBrowserWhenReady(browserUrl);
+  }
 
   forwardSignal(child, 'SIGINT');
   forwardSignal(child, 'SIGTERM');
@@ -66,7 +78,8 @@ async function main() {
 function parseArgs(args) {
   const launcher = {
     help: false,
-    channel: 'stable'
+    channel: 'stable',
+    openBrowser: true
   };
   const passthrough = [];
 
@@ -83,6 +96,11 @@ function parseArgs(args) {
       continue;
     }
 
+    if (arg === '--no-browser') {
+      launcher.openBrowser = false;
+      continue;
+    }
+
     if (arg === '--channel') {
       const value = args[i + 1];
       if (value !== 'stable' && value !== 'dev') {
@@ -106,12 +124,85 @@ function printHelp() {
   console.log('');
   console.log('Launcher options:');
   console.log('  --channel stable|dev  Choose the release channel (default: stable)');
+  console.log('  --no-browser          Do not auto-open MidTerm in the default browser');
   console.log('  --help-launcher       Show launcher help');
   console.log('');
   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 = parseWslUncPath(process.cwd());
+  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 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',
@@ -189,8 +280,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 });
@@ -209,7 +304,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;
@@ -218,6 +314,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');
@@ -267,14 +415,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`);
   }
@@ -295,6 +449,159 @@ function hasArg(args, name) {
   return args.some((arg) => arg === name || arg.startsWith(`${name}=`));
 }
 
+function getArgValue(args, name) {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === name) {
+      return args[i + 1];
+    }
+    if (arg.startsWith(`${name}=`)) {
+      return arg.slice(name.length + 1);
+    }
+  }
+
+  return undefined;
+}
+
+function parsePortArg(value) {
+  if (!value) {
+    return undefined;
+  }
+
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535) {
+    return undefined;
+  }
+
+  return parsed;
+}
+
+function buildBrowserUrl(bindAddress, port) {
+  const normalized = normalizeHostForBrowser(bindAddress);
+  return `https://${normalized}:${port}`;
+}
+
+function normalizeHostForBrowser(bindAddress) {
+  const raw = String(bindAddress || '').trim();
+  if (!raw || raw === '0.0.0.0' || raw === '::' || raw === '[::]') {
+    return '127.0.0.1';
+  }
+
+  const host = raw.replace(/^\[(.*)\]$/, '$1');
+  if (host.includes(':')) {
+    return `[${host}]`;
+  }
+
+  return host;
+}
+
+async function openBrowserWhenReady(url) {
+  const ready = await waitForServer(url, SERVER_READY_TIMEOUT_MS);
+  if (!ready) {
+    console.error(`@tlbx-ai/midterm: server did not become ready within ${SERVER_READY_TIMEOUT_MS}ms, opening browser anyway`);
+  }
+
+  openUrl(url);
+}
+
+async function waitForServer(url, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+
+  while (Date.now() < deadline) {
+    if (await probeUrl(url)) {
+      return true;
+    }
+
+    await sleep(SERVER_READY_INTERVAL_MS);
+  }
+
+  return false;
+}
+
+function probeUrl(url) {
+  return new Promise((resolve) => {
+    const request = https.request(url, {
+      method: 'GET',
+      rejectUnauthorized: false,
+      timeout: SERVER_READY_INTERVAL_MS
+    }, (response) => {
+      response.resume();
+      resolve(true);
+    });
+
+    request.on('error', () => resolve(false));
+    request.on('timeout', () => {
+      request.destroy();
+      resolve(false);
+    });
+    request.end();
+  });
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+function openUrl(url) {
+  let command;
+  let args;
+
+  if (process.platform === 'win32') {
+    command = 'cmd';
+    args = ['/c', 'start', '', url];
+  } else if (process.platform === 'darwin') {
+    command = 'open';
+    args = [url];
+  } else {
+    command = 'xdg-open';
+    args = [url];
+  }
+
+  const result = spawn(command, args, {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+    cwd: getWindowsSubprocessCwd()
+  });
+  result.on('error', (error) => {
+    console.error(`@tlbx-ai/midterm: failed to open browser automatically: ${error.message}`);
+  });
+  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) {
@@ -307,6 +614,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": "0.1.0",
+  "version": "8.2.3",
   "description": "Launch MidTerm via npx by downloading the native binary for your platform",
   "license": "AGPL-3.0-only",
   "repository": {