@plusonelabs/cue 0.0.90 → 0.0.96-e2e-bench-windows.1

package/README.txt

@@ -0,0 +1,7 @@
+Flat npm package artifact for local install testing.
+
+Install examples:
+  npm install -g ./plusonelabs-cue-<version>.tgz
+
+On Windows (supported path), the host wrapper forwards into WSL.
+Install Cue inside WSL as well (or use a separate local WSL runtime artifact) before testing wrapper commands.

package/bin/cue.js

@@ -0,0 +1,550 @@
+#!/usr/bin/env node
+/* global console, process */
+
+import fs from 'fs';
+import { spawn, spawnSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+
+const FORCE_WINDOWS_WRAPPER = process.env.CUE_FORCE_WINDOWS_HOST_WRAPPER === '1';
+const isWindowsHost = process.platform === 'win32' || FORCE_WINDOWS_WRAPPER;
+const WRAPPER_DEBUG = process.env.CUE_WINDOWS_WRAPPER_DEBUG === '1';
+
+async function main() {
+  if (!isWindowsHost) {
+    await runCliEntrypoint();
+    return;
+  }
+
+  const normalizedArgv = normalizeWindowsWrapperArgv(process.argv);
+  const args = normalizedArgv.slice(2);
+  if (args.includes('--windows-bootstrap')) {
+    const rawBootstrapArgs = args.filter((arg) => arg !== '--windows-bootstrap');
+    const code = runWindowsBootstrap(normalizeWindowsBootstrapArgs(rawBootstrapArgs));
+    process.exit(code);
+  }
+
+  if (isWindowsHost && args[0] === 'update') {
+    const code = runWindowsHostUpdateFlow(args.slice(1));
+    process.exit(code);
+  }
+
+  const exitCode = await runCueInWsl(args);
+  process.exit(exitCode);
+}
+
+async function runCliEntrypoint() {
+  const baseDir = path.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path.join(baseDir, '..', 'dist', 'cli.mjs'),
+    path.join(baseDir, '..', 'dist', 'src', 'cli.js'),
+  ];
+
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) {
+      continue;
+    }
+    await import(pathToFileURL(candidate).href);
+    return;
+  }
+
+  console.error('Cue CLI entrypoint not found in package.');
+  console.error('Expected one of:');
+  for (const candidate of candidates) {
+    console.error(`  - ${candidate}`);
+  }
+  process.exit(1);
+}
+
+function runWindowsBootstrap(extraArgs) {
+  const powershellCommand = resolvePowerShellCommand();
+  if (!powershellCommand) {
+    console.error('PowerShell was not found. Run bootstrap manually from PowerShell.');
+    return 1;
+  }
+
+  const scriptPath = path.join(
+    path.dirname(fileURLToPath(import.meta.url)),
+    'windows-bootstrap.ps1'
+  );
+  if (!fs.existsSync(scriptPath)) {
+    console.error(`Windows bootstrap script not found: ${scriptPath}`);
+    return 1;
+  }
+
+  const psArgs = [
+    '-NoProfile',
+    '-ExecutionPolicy',
+    'Bypass',
+    '-File',
+    scriptPath,
+    ...extraArgs,
+  ];
+  const result = spawnSync(powershellCommand, psArgs, { stdio: 'inherit' });
+  if (result.error) {
+    console.error(`Failed to run PowerShell bootstrap: ${result.error.message}`);
+    return 1;
+  }
+  return typeof result.status === 'number' ? result.status : 1;
+}
+
+function normalizeWindowsBootstrapArgs(args) {
+  const normalized = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+
+    if (arg === '--install' || arg === '--install-cue') {
+      normalized.push('-InstallCue');
+      continue;
+    }
+
+    if (arg === '--no-systemd' || arg === '--skip-systemd-check') {
+      normalized.push('-RequireSystemd:$false');
+      continue;
+    }
+
+    if (arg === '--distro') {
+      const value = args[i + 1];
+      if (value) {
+        normalized.push('-Distro', value);
+        i += 1;
+        continue;
+      }
+    }
+
+    if (arg === '--json') {
+      normalized.push('-Json');
+      continue;
+    }
+
+    if (arg === '--runtime-url') {
+      const value = args[i + 1];
+      if (value) {
+        normalized.push('-RuntimeUrl', value);
+        i += 1;
+        continue;
+      }
+    }
+
+    if (arg === '--runtime-sha256') {
+      const value = args[i + 1];
+      if (value) {
+        normalized.push('-RuntimeSha256', value);
+        i += 1;
+        continue;
+      }
+    }
+
+    normalized.push(arg);
+  }
+
+  return normalized;
+}
+
+function resolvePowerShellCommand() {
+  const candidates = process.env.CUE_POWERSHELL_EXE
+    ? [process.env.CUE_POWERSHELL_EXE]
+    : ['powershell.exe', 'pwsh.exe'];
+
+  for (const candidate of candidates) {
+    const result = spawnSync(candidate, ['-NoProfile', '-Command', '$PSVersionTable.PSVersion.Major'], {
+      stdio: 'ignore',
+    });
+    if (!result.error) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+function resolveWindowsUpdateCommand() {
+  const nodeDir = path.dirname(process.execPath);
+  const commandCandidates = [
+    {
+      name: 'bun',
+      checks: ['bun', 'bun.exe'],
+      args: ['add', '-g', '@plusonelabs/cue@latest'],
+      label: 'bun add -g @plusonelabs/cue@latest',
+    },
+    {
+      name: 'npm',
+      checks: ['npm', 'npm.cmd', 'npm.exe', path.join(nodeDir, 'npm.cmd'), path.join(nodeDir, 'npm.exe')],
+      args: ['install', '-g', '@plusonelabs/cue@latest'],
+      label: 'npm install -g @plusonelabs/cue@latest',
+    },
+  ];
+
+  for (const candidate of commandCandidates) {
+    for (const checkCmd of candidate.checks) {
+      const check = runWindowsTool(checkCmd, ['--version'], 'ignore');
+      if (!check.error && check.status === 0) {
+        return {
+          name: candidate.name,
+          cmd: checkCmd,
+          args: candidate.args,
+          label: candidate.label,
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
+function runWindowsHostUpdateFlow(extraArgs) {
+  if (extraArgs.length > 0) {
+    console.error('cue update on Windows does not support additional arguments yet.');
+    console.error('Run `cue --windows-bootstrap --install-cue` directly if you need custom bootstrap flags.');
+    return 1;
+  }
+
+  const updateCommand = resolveWindowsUpdateCommand();
+  if (!updateCommand) {
+    console.error('No supported host package manager found for Windows update (need bun or npm).');
+    return 1;
+  }
+
+  console.log('Windows host detected (WSL2-supported mode).');
+  console.log(`Updating host package with: ${updateCommand.label}`);
+  console.log('');
+
+  const hostUpdate = runWindowsTool(updateCommand.cmd, updateCommand.args, 'inherit');
+  if (hostUpdate.error) {
+    console.error(`Host package update failed: ${hostUpdate.error.message}`);
+    return 1;
+  }
+  if (typeof hostUpdate.status === 'number' && hostUpdate.status !== 0) {
+    console.error(`Host package update failed (exit ${hostUpdate.status}).`);
+    return hostUpdate.status;
+  }
+
+  console.log('');
+  console.log('Refreshing WSL runtime with bootstrap (--install-cue)...');
+  console.log('');
+
+  const bootstrapCode = runWindowsBootstrap(['-InstallCue']);
+  if (bootstrapCode !== 0) {
+    console.error('WSL runtime refresh failed during Windows update flow.');
+    return bootstrapCode;
+  }
+
+  console.log('');
+  console.log('Windows host and WSL runtime update flow completed.');
+  return 0;
+}
+
+function quoteCmdArg(value) {
+  const text = String(value ?? '');
+  if (text.length === 0) {
+    return '""';
+  }
+  if (!/[ \t"&()<>^|]/.test(text)) {
+    return text;
+  }
+  return `"${text.replace(/"/g, '""')}"`;
+}
+
+function runWindowsTool(command, args, stdio) {
+  const cmdLine = [command, ...args].map(quoteCmdArg).join(' ');
+  return spawnSync('cmd.exe', ['/d', '/s', '/c', cmdLine], {
+    stdio,
+    windowsHide: false,
+  });
+}
+
+async function runCueInWsl(userArgs) {
+  const wslExe = process.env.CUE_WSL_EXE || 'wsl.exe';
+  const statusCheck = spawnSync(wslExe, ['--status'], { stdio: 'ignore' });
+  if (statusCheck.error) {
+    printWslMissingHelp(statusCheck.error);
+    return 1;
+  }
+
+  const mappedCwd = windowsPathToWslPath(process.cwd());
+  if (!mappedCwd) {
+    console.error(`Warning: could not map Windows cwd to WSL path: ${process.cwd()}`);
+    console.error('Cue will start in the default WSL working directory.');
+  }
+
+  const distro = (process.env.CUE_WSL_DISTRO || '').trim();
+  if (distro && !validateRequestedWslDistro(wslExe, distro)) {
+    return 1;
+  }
+  const wslArgs = [];
+  if (distro) {
+    wslArgs.push('-d', distro);
+  }
+  wslArgs.push(
+    '-e',
+    'bash',
+    '-lc',
+    WSL_LAUNCH_SCRIPT,
+    'cue-wsl-wrapper',
+    mappedCwd || '__CUE_NO_CWD__',
+    ...userArgs
+  );
+
+  const child = spawn(wslExe, wslArgs, {
+    stdio: 'inherit',
+    windowsHide: false,
+    env: {
+      ...process.env,
+      CUE_WINDOWS_HOST_WRAPPER: '1',
+    },
+  });
+
+  debugLog('Launching WSL wrapper', {
+    wslExe,
+    distro: distro || '(default)',
+    mappedCwd: mappedCwd || null,
+    args: userArgs,
+  });
+
+  return await new Promise((resolve) => {
+    let settled = false;
+    const settle = (code) => {
+      if (settled) return;
+      settled = true;
+      resolve(code);
+    };
+
+    child.on('error', (error) => {
+      console.error(`Failed to launch WSL: ${error.message}`);
+      settle(1);
+    });
+
+    child.on('exit', (code, signal) => {
+      if (typeof code === 'number') {
+        settle(code);
+        return;
+      }
+      if (signal) {
+        console.error(`WSL process exited due to signal: ${signal}`);
+      }
+      settle(1);
+    });
+
+    process.on('SIGINT', () => child.kill('SIGINT'));
+    process.on('SIGTERM', () => child.kill('SIGTERM'));
+  });
+}
+
+function validateRequestedWslDistro(wslExe, distro) {
+  const listed = listWslDistros(wslExe);
+  if (!listed.ok) {
+    debugLog('WSL distro listing unavailable; skipping CUE_WSL_DISTRO validation', {
+      error: listed.error,
+    });
+    return true;
+  }
+
+  const requested = distro.trim().toLowerCase();
+  const matched = listed.names.some((name) => name.toLowerCase() === requested);
+  if (matched) {
+    return true;
+  }
+
+  console.error(`WSL distro not found: ${distro}`);
+  if (listed.names.length > 0) {
+    console.error('Available distros:');
+    for (const name of listed.names) {
+      console.error(`  - ${name}`);
+    }
+  }
+  console.error('Update CUE_WSL_DISTRO or unset it to use the default WSL distro.');
+  console.error('Tip: Run `cue --windows-bootstrap` from PowerShell to validate your WSL setup.');
+  return false;
+}
+
+function listWslDistros(wslExe) {
+  const attempts = [
+    ['--list', '--quiet'],
+    ['-l', '-q'],
+  ];
+
+  let lastError = null;
+  for (const args of attempts) {
+    const result = spawnSync(wslExe, args, {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true,
+    });
+    if (result.error) {
+      lastError = result.error.message;
+      continue;
+    }
+    if (typeof result.status === 'number' && result.status !== 0) {
+      const detail = String(result.stderr || result.stdout || '').trim();
+      lastError = detail || `wsl exited with code ${result.status}`;
+      continue;
+    }
+
+    return { ok: true, names: parseWslDistroList(String(result.stdout || '')) };
+  }
+
+  return { ok: false, names: [], error: lastError || 'unknown error' };
+}
+
+function parseWslDistroList(output) {
+  const nullChar = String.fromCharCode(0);
+  return output
+    .split(/\r?\n/)
+    .map((line) =>
+      line
+        .replaceAll(nullChar, '')
+        .replace(/^\s*\*?\s*/, '')
+        .trim()
+    )
+    .filter(Boolean);
+}
+
+function debugLog(message, payload) {
+  if (!WRAPPER_DEBUG) return;
+  const suffix =
+    payload && typeof payload === 'object'
+      ? ` ${JSON.stringify(payload)}`
+      : payload !== undefined
+        ? ` ${String(payload)}`
+        : '';
+  console.error(`[cue windows-wrapper] ${message}${suffix}`);
+}
+
+function normalizeWindowsWrapperArgv(argv) {
+  if (!isWindowsHost || !Array.isArray(argv) || argv.length < 2) {
+    return argv;
+  }
+
+  const stripControlChars = (value) => {
+    let out = '';
+    for (let i = 0; i < value.length; i += 1) {
+      const code = value.charCodeAt(i);
+      if (code >= 32 && code !== 127) {
+        out += value[i];
+      }
+    }
+    return out;
+  };
+
+  const normalizeArg = (value) =>
+    stripControlChars(String(value ?? ''))
+      .replace(/^['"]+|['"]+$/g, '')
+      .trim();
+
+  const normalizeCandidate = (value) => normalizeArg(value).replace(/^\\\\\?\\/, '');
+
+  const execPath = normalizeCandidate(process.execPath);
+  const execPathLower = execPath.toLowerCase();
+  const execBase = path.basename(execPathLower);
+
+  const looksLikeExecPath = (value) => {
+    if (value === undefined) return false;
+    const normalized = normalizeCandidate(value);
+    if (!normalized) return false;
+    const lower = normalized.toLowerCase();
+    const base = path.basename(lower);
+    return (
+      lower === execPathLower ||
+      base === execBase ||
+      lower.endsWith('\\node.exe') ||
+      lower.endsWith('/node.exe') ||
+      (base === 'node.exe' && fs.existsSync(normalized))
+    );
+  };
+
+  const next = [...argv];
+
+  // Windows shims can inject duplicate node.exe tokens near the front of argv.
+  for (let i = 1; i <= 4 && i < next.length; ) {
+    if (looksLikeExecPath(next[i])) {
+      next.splice(i, 1);
+      continue;
+    }
+    i += 1;
+  }
+
+  if (WRAPPER_DEBUG && next.length !== argv.length) {
+    debugLog('Normalized Windows argv', {
+      before: argv,
+      after: next,
+    });
+  }
+
+  return next;
+}
+
+function printWslMissingHelp(error) {
+  console.error('WSL2 is required for Cue on Windows (supported path).');
+  console.error(`WSL launch failed: ${error.message}`);
+  console.error('');
+  console.error('Next steps:');
+  console.error('  1) Install WSL2 and Ubuntu LTS');
+  console.error('  2) Run `cue --windows-bootstrap` from PowerShell');
+  console.error('  3) Install Cue inside WSL (Ubuntu): bun add -g @plusonelabs/cue');
+}
+
+function windowsPathToWslPath(inputPath) {
+  if (!inputPath) return null;
+  const normalized = inputPath.replaceAll('/', '\\');
+
+  const driveMatch = normalized.match(/^([A-Za-z]):\\(.*)$/);
+  if (driveMatch) {
+    const drive = driveMatch[1].toLowerCase();
+    const rest = driveMatch[2].replaceAll('\\', '/');
+    return `/mnt/${drive}/${rest}`;
+  }
+
+  const wslUncMatch = normalized.match(/^\\\\wsl(?:\\.localhost)?\\[^\\]+\\(.*)$/i);
+  if (wslUncMatch) {
+    return `/${wslUncMatch[1].replaceAll('\\', '/')}`;
+  }
+
+  return null;
+}
+
+const WSL_LAUNCH_SCRIPT = `
+set -e
+cwd="$1"
+shift
+if [ "$cwd" != "__CUE_NO_CWD__" ]; then
+  cd "$cwd"
+fi
+if [ -d "$HOME/.cue/bin" ]; then
+  PATH="$HOME/.cue/bin:$PATH"
+fi
+cue_path="$(command -v cue || true)"
+if [ -z "$cue_path" ]; then
+  echo "Cue is not installed inside WSL." >&2
+  echo "Install inside Ubuntu: bun add -g @plusonelabs/cue" >&2
+  echo "Or install via bootstrap runtime artifact and ensure ~/.cue/bin is on PATH." >&2
+  exit 127
+fi
+case "$cue_path" in
+  /mnt/*|*.exe|*.cmd)
+    echo "Cue inside WSL resolves to a Windows command: $cue_path" >&2
+    echo "A Linux cue runtime should be installed in ~/.cue/bin or via Bun/npm inside WSL." >&2
+    echo "If you used bootstrap artifact install, add ~/.cue/bin to PATH or restart your shell." >&2
+    exit 126
+    ;;
+esac
+node_path="$(command -v node || true)"
+if [ -z "$node_path" ]; then
+  echo "Linux Node.js runtime is not installed inside WSL." >&2
+  echo "Cue requires a Linux node binary in Ubuntu (not only Windows npm/node)." >&2
+  echo "Example: sudo apt update && sudo apt install -y nodejs npm" >&2
+  exit 125
+fi
+case "$node_path" in
+  /mnt/*|*.exe|*.cmd)
+    echo "WSL node resolves to a Windows executable: $node_path" >&2
+    echo "Install a Linux Node.js runtime in Ubuntu (example: sudo apt install -y nodejs npm)." >&2
+    exit 125
+    ;;
+esac
+exec "$cue_path" "$@"
+`;
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});