mercury-tech-cli 1.0.0-beta.2 → 1.0.0-beta.20

package/README.md

@@ -1,20 +1,26 @@
 # mercury-tech-cli
 
-The `mercury` command from npm or bun.
+The `mercury` command from npm or bun, on macOS (Apple silicon and Intel), Linux x64 and
+Windows x64.
 
 ```sh
 bun install -g mercury-tech-cli     # or: npm install -g mercury-tech-cli
 mercury
 ```
 
-Mercury runs on its own bundled runtime, never on npm's or bun's engine. The
-first `mercury` run downloads the release archive for your machine from
-[GitHub Releases](https://github.com/Whq02/MercuryCLI/releases), verifies its
-SHA-256, and runs the archive's own user-local installer (no administrator
-access: `~/.mercury/versions/` and `~/.local/bin/mercury`). Later runs go
-straight to the installed command; `mercury update` moves between versions.
+The first time you run `mercury`, it downloads the release archive for your
+platform from GitHub Releases, checks its SHA-256 against the release's
+checksum list, and runs the installer included in the archive.
 
-macOS and Linux. On Windows use PowerShell:
+You don't need administrator access. Versions are stored under
+`~/.mercury/versions/`, with the `mercury` command in `~/.local/bin` on
+macOS and Linux, or `%LOCALAPPDATA%\Mercury\bin` on Windows.
+
+After setup, running `mercury` starts the installed version using its
+bundled Node runtime. Your system's Node version only matters for the
+launcher. Use `mercury update` to change versions.
+
+The PowerShell installer is the other Windows route:
 
 ```powershell
 irm https://mercury-cli.ai/install.ps1 | iex

package/bin/mercury.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+'use strict'
+// mercury-tech-cli — the `mercury` command from npm or bun, on macOS (Apple
+// silicon and Intel), Linux x64 and Windows x64.
+//
+// Mercury runs on its own bundled runtime, never on npm's or bun's engine, so
+// this launcher only fetches: on first run it downloads the release archive
+// for this machine from GitHub Releases, verifies its SHA-256, unpacks it,
+// and runs the archive's own `mercury install` (user-local, no administrator
+// access: ~/.mercury/versions + ~/.local/bin/mercury; on Windows
+// %LOCALAPPDATA%\Mercury\bin\mercury.cmd). Every later run hands straight to
+// the installed command. Rerunning is safe.
+//
+// Knobs (all optional):
+//   MERCURY_VERSION           a release tag to install instead of this package's
+//   MERCURY_INSTALL_BASE_URL  where the assets live (https:// or file://)
+//   MERCURY_INSTALL_ARGS      extra `mercury install` args, e.g. --force
+//   MERCURYCLI_PIN=1          run this package's release even when another
+//                             version is installed and active (by default an
+//                             installed Mercury is never downgraded; `mercury
+//                             update` moves versions)
+const fs = require('node:fs')
+const os = require('node:os')
+const path = require('node:path')
+const crypto = require('node:crypto')
+const { spawn, spawnSync } = require('node:child_process')
+
+const PACKAGE_RELEASE = '1.0.0-beta.20'
+const REPO = 'Whq02/MercuryCLI'
+const WIN = process.platform === 'win32'
+const release = (process.env.MERCURY_VERSION || PACKAGE_RELEASE).replace(/^v/, '')
+const tag = `v${release}`
+
+// The same roots the product's own stable command resolves.
+const versionsDir = process.env.MERCURY_VERSIONS_DIR
+  || path.join(process.env.MERCURY_CONFIG_DIR || process.env.MERCURY_HOME || path.join(os.homedir(), '.mercury'), 'versions')
+const stable = WIN
+  ? path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'Mercury', 'bin', 'mercury.cmd')
+  : path.join(os.homedir(), '.local', 'bin', 'mercury')
+
+function say(msg) { process.stderr.write(`mercury: ${msg}\n`) }
+function die(msg) { say(msg); process.exit(1) }
+
+function installedVersion() {
+  try { return fs.readFileSync(path.join(versionsDir, 'current.txt'), 'utf8').split(/\r?\n/)[0].trim() } catch { return '' }
+}
+function stableExists() {
+  try { fs.accessSync(stable, WIN ? fs.constants.F_OK : fs.constants.X_OK); return true } catch { return false }
+}
+
+// Windows: a .cmd runs only through cmd.exe. Each argument is quoted the way
+// the C runtime unquotes it; cmd's /s strips the outer pair around the line.
+function winQuote(arg) {
+  if (arg !== '' && !/[\s"]/.test(arg)) return arg
+  return '"' + arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, '$1$1') + '"'
+}
+function start(cmd, args, stdio) {
+  if (WIN) {
+    const line = [cmd, ...args].map(winQuote).join(' ')
+    return spawn(process.env.ComSpec || 'cmd.exe', ['/d', '/s', '/c', `"${line}"`], { stdio, windowsVerbatimArguments: true })
+  }
+  return spawn(cmd, args, { stdio })
+}
+
+function handOver(args) {
+  const child = start(stable, args, 'inherit')
+  // Ctrl+C reaches Mercury directly; this launcher only waits for it.
+  const hold = () => {}
+  process.on('SIGINT', hold)
+  process.on('SIGTERM', hold)
+  child.on('error', e => die(`could not start ${stable}: ${e.message}`))
+  child.on('exit', (code, signal) => process.exit(code === null ? (signal ? 1 : 0) : code))
+}
+
+function target() {
+  const { platform, arch } = process
+  if (platform === 'darwin') {
+    // A x64 node under Rosetta still runs on Apple silicon: ask the kernel.
+    const apple = arch === 'arm64'
+      || (spawnSync('sysctl', ['-n', 'hw.optional.arm64'], { encoding: 'utf8' }).stdout || '').trim() === '1'
+    if (apple) return 'macos-arm64'
+    return 'macos-x64'
+  }
+  if (platform === 'linux' && arch === 'x64') return 'linux-x64'
+  if (platform === 'linux' && arch === 'arm64') die(`no Linux arm64 build yet — build from source: https://github.com/${REPO}`)
+  if (platform === 'win32') {
+    if (arch === 'arm64') say('no Windows arm64 build yet — installing the x64 build (runs under emulation)')
+    return 'windows-x64'
+  }
+  die(`no build for ${platform} ${arch} — build from source: https://github.com/${REPO}`)
+}
+
+async function fetchBytes(url) {
+  if (url.startsWith('file://')) return fs.readFileSync(new URL(url))
+  let last
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    try {
+      const res = await fetch(url, { redirect: 'follow' })
+      if (!res.ok) throw new Error(`HTTP ${res.status}`)
+      return Buffer.from(await res.arrayBuffer())
+    } catch (e) {
+      last = e
+      await new Promise(r => setTimeout(r, 1000 * attempt))
+    }
+  }
+  throw last
+}
+
+function unpack(archive, dir) {
+  if (WIN) {
+    // Windows 10 1803+ ships tar.exe (bsdtar), which reads zip; PowerShell is the fallback.
+    if (spawnSync('tar', ['-xf', archive, '-C', dir], { stdio: 'ignore' }).status === 0) return
+    const q = s => `'${s.replace(/'/g, "''")}'`
+    const ps = spawnSync('powershell', ['-NoProfile', '-NonInteractive', '-Command',
+      `Expand-Archive -LiteralPath ${q(archive)} -DestinationPath ${q(dir)} -Force`], { stdio: 'ignore' })
+    if (ps.status === 0) return
+    die('could not unpack the archive: neither tar nor PowerShell Expand-Archive worked')
+  }
+  const tar = spawnSync('tar', ['-xzf', archive, '-C', dir], { stdio: ['ignore', 'ignore', 'inherit'] })
+  if (tar.status !== 0) die('could not unpack the archive: first run needs tar')
+}
+
+// The installer's chatter goes to stderr: stdout stays Mercury's own.
+function runInstaller(launcher, extra) {
+  return new Promise(resolve => {
+    const child = start(launcher, ['install', ...extra], ['inherit', 'pipe', 'inherit'])
+    child.stdout.pipe(process.stderr)
+    child.on('error', e => die(`could not run the installer: ${e.message}`))
+    child.on('exit', code => resolve(code === null ? 1 : code))
+  })
+}
+
+async function main() {
+  const args = process.argv.slice(2)
+  const installed = installedVersion()
+  if (stableExists() && (installed === release || (installed !== '' && process.env.MERCURYCLI_PIN !== '1'))) {
+    handOver(args)
+    return
+  }
+
+  const t = target()
+  const asset = `mercury-${tag}-${t}.${WIN ? 'zip' : 'tar.gz'}`
+  const base = process.env.MERCURY_INSTALL_BASE_URL || `https://github.com/${REPO}/releases/download/${tag}`
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'mercury-tech-cli-'))
+  const cleanup = () => { try { fs.rmSync(tmp, { recursive: true, force: true }) } catch {} }
+  process.on('exit', cleanup)
+
+  say(`first run — installing Mercury ${tag} for ${t}`)
+  let bytes, sums
+  try { bytes = await fetchBytes(`${base}/${asset}`) } catch (e) { die(`download failed: ${base}/${asset} (${e.message})`) }
+  try { sums = (await fetchBytes(`${base}/SHA256SUMS.txt`)).toString('utf8') } catch (e) { die(`download failed: ${base}/SHA256SUMS.txt (${e.message})`) }
+  const want = sums.split(/\r?\n/)
+    .map(l => l.trim().match(/^([0-9a-fA-F]{64})\s+\*?(.+)$/))
+    .find(m => m && m[2] === asset)
+  if (!want) die(`${asset} is not listed in SHA256SUMS.txt`)
+  const got = crypto.createHash('sha256').update(bytes).digest('hex')
+  if (got !== want[1].toLowerCase()) die(`checksum mismatch for ${asset} — nothing installed`)
+  say('checksum ok')
+
+  const archive = path.join(tmp, asset)
+  fs.writeFileSync(archive, bytes)
+  unpack(archive, tmp)
+  const launcher = path.join(tmp, 'mercury', WIN ? 'mercury.cmd' : 'mercury')
+  if (!fs.existsSync(launcher)) die('the archive has no launcher')
+  const extra = (process.env.MERCURY_INSTALL_ARGS || '').split(' ').filter(Boolean)
+  const code = await runInstaller(launcher, extra)
+  if (code !== 0) die(`mercury install exited ${code}`)
+  if (!stableExists()) die(`installed, but ${stable} is missing — rerun with MERCURY_INSTALL_ARGS=--force`)
+  cleanup()
+  handOver(args)
+}
+
+main().catch(e => die(e && e.message ? e.message : String(e)))

package/package.json

@@ -1,33 +1,38 @@
 {
   "name": "mercury-tech-cli",
-  "version": "1.0.0-beta.2",
-  "description": "Mercury \u2014 a terminal harness for software development. This package installs Mercury's own runtime on first run; it never runs Mercury on npm's or bun's engine.",
+  "version": "1.0.0-beta.20",
+  "description": "Run multiple AI coding sessions in one terminal. Mix and match model providers, spawn cross-company agents, and use built-in debugging, screen control, and voice dictation.",
   "homepage": "https://mercury-cli.ai",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Whq02/MercuryCLI.git"
+    "url": "https://github.com/Whq02/MercuryCLI"
   },
   "bugs": {
     "url": "https://github.com/Whq02/MercuryCLI/issues"
   },
-  "license": "SEE LICENSE IN LICENSE.md",
+  "license": "BUSL-1.1",
   "bin": {
-    "mercury": "bin/mercury"
+    "mercury": "bin/mercury.js"
+  },
+  "engines": {
+    "node": ">=18"
   },
-  "os": [
-    "darwin",
-    "linux"
-  ],
   "files": [
     "bin",
     "README.md",
     "LICENSE.md"
   ],
   "keywords": [
-    "mercury",
+    "ai",
+    "coding-agent",
     "cli",
     "terminal",
-    "agent",
-    "harness"
+    "llm",
+    "agents",
+    "mcp",
+    "openai",
+    "anthropic",
+    "gemini",
+    "deepseek"
   ]
 }

package/bin/mercury

@@ -1,55 +0,0 @@
-#!/bin/sh
-# mercury-tech-cli — the `mercury` command from npm or bun.
-#
-# Mercury runs on its own bundled runtime, never on npm's or bun's engine, so
-# this file is a plain shell script: on first run it downloads the release
-# archive for this machine from GitHub Releases, verifies its SHA-256, and
-# runs the archive's own `mercury install` (user-local, no administrator
-# access: ~/.mercury/versions/ + ~/.local/bin/mercury). Every later run
-# hands straight to the installed command. Rerunning is safe.
-set -eu
-PKG_VERSION="1.0.0-beta.2"
-REPO="Whq02/MercuryCLI"
-home=${MERCURY_CONFIG_DIR:-"$HOME/.mercury"}
-current="$home/versions/current.txt"
-installed=""
-if [ -f "$current" ]; then installed=$(head -1 "$current" 2>/dev/null | tr -d '[:space:]'); fi
-stable="$HOME/.local/bin/mercury"
-
-if [ "$installed" = "$PKG_VERSION" ] && [ -x "$stable" ]; then
-  exec "$stable" "$@"
-fi
-if [ -n "$installed" ] && [ -x "$stable" ] && [ "${MERCURYCLI_PIN:-}" != "1" ]; then
-  # A different version is installed and active: run it — `mercury update`
-  # moves versions; this package never downgrades what you have. Set
-  # MERCURYCLI_PIN=1 to force this package's version.
-  exec "$stable" "$@"
-fi
-
-die() { printf 'mercury: %s\n' "$*" >&2; exit 1; }
-command -v curl >/dev/null 2>&1 || die "first run needs 'curl'"
-command -v tar >/dev/null 2>&1 || die "first run needs 'tar'"
-os=$(uname -s); arch=$(uname -m)
-case "$os/$arch" in
-  Darwin/arm64) target=macos-arm64 ;;
-  Darwin/x86_64) die "no Intel Mac build in this release (Apple silicon, Linux x64 and Windows x64 ship) — build from source: https://github.com/$REPO" ;;
-  Linux/x86_64|Linux/amd64) target=linux-x64 ;;
-  *) die "no build for $os $arch — Windows: irm https://mercury-cli.ai/install.ps1 | iex ; others: build from source at https://github.com/$REPO" ;;
-esac
-version="v$PKG_VERSION"
-asset="mercury-$version-$target.tar.gz"
-base=${MERCURY_INSTALL_BASE_URL:-"https://github.com/$REPO/releases/download/$version"}
-tmp=$(mktemp -d "${TMPDIR:-/tmp}/mercury-tech-cli.XXXXXX")
-trap 'rm -rf "$tmp"' EXIT
-printf 'mercury: first run — installing Mercury %s for %s\n' "$version" "$target" >&2
-curl -fsSL --retry 3 -o "$tmp/$asset" "$base/$asset" || die "download failed: $base/$asset"
-curl -fsSL --retry 3 -o "$tmp/SHA256SUMS.txt" "$base/SHA256SUMS.txt" || die "download failed: $base/SHA256SUMS.txt"
-want=$(grep " $asset\$" "$tmp/SHA256SUMS.txt" | awk '{print $1}' | head -1)
-[ -n "$want" ] || die "$asset is not listed in SHA256SUMS.txt"
-if command -v sha256sum >/dev/null 2>&1; then got=$(sha256sum "$tmp/$asset" | awk '{print $1}'); else got=$(shasum -a 256 "$tmp/$asset" | awk '{print $1}'); fi
-[ "$got" = "$want" ] || die "checksum mismatch for $asset — nothing installed"
-tar -xzf "$tmp/$asset" -C "$tmp"
-[ -x "$tmp/mercury/mercury" ] || die "the archive has no launcher"
-"$tmp/mercury/mercury" install >&2
-[ -x "$stable" ] || die "installed, but $stable is missing — run: $tmp/mercury/mercury install --force"
-exec "$stable" "$@"