lanesh 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,17 @@
-# Temporary Holding Version
+# lanesh
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Share skills and shells across your machines through one MCP endpoint.
+
+This package installs the `lanesh` command. On first run it downloads the
+native binary for your platform from
+[GitHub Releases](https://github.com/jtsang4/lanesh/releases), verifies its
+SHA-256 checksum, and stores it in `~/.lanesh/bin` (override with
+`LANESH_HOME`).
+
+```sh
+npx lanesh --help
+# or
+npm install -g lanesh
+```
+
+See the [project README](https://github.com/jtsang4/lanesh#readme) for details.

package/bin/lanesh.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+
+import { ensureBinary } from '../lib/launcher.js';
+
+const { version } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+
+let bin;
+try {
+  bin = await ensureBinary(version);
+} catch (err) {
+  process.stderr.write(`lanesh: ${err.message}\n`);
+  process.exit(1);
+}
+
+const child = spawn(bin, process.argv.slice(2), { stdio: 'inherit', windowsHide: true });
+
+for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+  process.on(signal, () => child.kill(signal));
+}
+
+child.on('error', (err) => {
+  process.stderr.write(`lanesh: failed to start ${bin}: ${err.message}\n`);
+  process.exit(1);
+});
+
+child.on('exit', (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal);
+    return;
+  }
+  process.exit(code ?? 1);
+});

package/lib/launcher.js

@@ -0,0 +1,170 @@
+// Resolves, downloads and verifies the native lanesh binary.
+//
+// The npm package ships no binary. On first run it downloads the release
+// binary that matches this package's version into a Lanesh-managed directory
+// (~/.lanesh/bin by default), so that the daemon can later update itself
+// without fighting npm over files in node_modules.
+
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { chmodSync, existsSync, mkdirSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+
+export const DEFAULT_DOWNLOAD_BASE = 'https://github.com/jtsang4/lanesh/releases/download';
+
+const OS_MAP = { darwin: 'darwin', linux: 'linux', win32: 'windows' };
+const ARCH_MAP = { x64: 'amd64', arm64: 'arm64' };
+
+/** Maps Node's platform/arch to Go's GOOS/GOARCH, or throws if unsupported. */
+export function resolveTarget(platform = process.platform, arch = process.arch) {
+  const os = OS_MAP[platform];
+  const goarch = ARCH_MAP[arch];
+  if (!os || !goarch) {
+    throw new Error(`lanesh does not provide a binary for ${platform}/${arch}`);
+  }
+  return { os, arch: goarch, exe: os === 'windows' ? '.exe' : '' };
+}
+
+/** Name of the raw binary release asset, matching .goreleaser.yaml. */
+export function assetName(version, target) {
+  return `lanesh_${version}_${target.os}_${target.arch}${target.exe}`;
+}
+
+export function laneshHome(env = process.env) {
+  return env.LANESH_HOME || join(homedir(), '.lanesh');
+}
+
+export function binaryPath(env = process.env, target = resolveTarget()) {
+  return join(laneshHome(env), 'bin', `lanesh${target.exe}`);
+}
+
+function parseVersion(v) {
+  const m = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/.exec(String(v).trim());
+  if (!m) return null;
+  return { nums: [Number(m[1]), Number(m[2]), Number(m[3])], pre: m[4] ?? '' };
+}
+
+/** Compares two semantic versions. Unparseable versions sort lowest. */
+export function compareVersions(a, b) {
+  const pa = parseVersion(a);
+  const pb = parseVersion(b);
+  if (!pa || !pb) return pa ? 1 : pb ? -1 : 0;
+  for (let i = 0; i < 3; i++) {
+    if (pa.nums[i] !== pb.nums[i]) return pa.nums[i] < pb.nums[i] ? -1 : 1;
+  }
+  return comparePrerelease(pa.pre, pb.pre);
+}
+
+// Orders prerelease tags per semver (numeric identifiers compare numerically).
+function comparePrerelease(a, b) {
+  if (a === b) return 0;
+  if (!a) return 1;
+  if (!b) return -1;
+  const xa = a.split('.');
+  const xb = b.split('.');
+  for (let i = 0; i < Math.min(xa.length, xb.length); i++) {
+    const na = /^\d+$/.test(xa[i]);
+    const nb = /^\d+$/.test(xb[i]);
+    if (na && nb) {
+      const d = Number(xa[i]) - Number(xb[i]);
+      if (d !== 0) return d < 0 ? -1 : 1;
+    } else if (na !== nb) {
+      return na ? -1 : 1;
+    } else if (xa[i] !== xb[i]) {
+      return xa[i] < xb[i] ? -1 : 1;
+    }
+  }
+  return xa.length === xb.length ? 0 : xa.length < xb.length ? -1 : 1;
+}
+
+/** Returns true for versions that have no published release (local builds). */
+export function isDevelopmentVersion(v) {
+  return !parseVersion(v) || String(v).includes('development');
+}
+
+/** Extracts the sha256 for `name` from a goreleaser checksums.txt body. */
+export function findChecksum(checksums, name) {
+  for (const line of checksums.split('\n')) {
+    const [sum, file] = line.trim().split(/\s+/);
+    if (file === name) return sum.toLowerCase();
+  }
+  return null;
+}
+
+export function installedVersion(bin) {
+  if (!existsSync(bin)) return null;
+  try {
+    return execFileSync(bin, ['version', '--short'], { encoding: 'utf8', timeout: 10_000 }).trim();
+  } catch {
+    return null;
+  }
+}
+
+async function fetchOk(url) {
+  const res = await fetch(url, { redirect: 'follow' });
+  if (!res.ok) throw new Error(`download failed: ${url} (${res.status} ${res.statusText})`);
+  return res;
+}
+
+/** Downloads, verifies and atomically installs the binary for `version`. */
+export async function install(version, { env = process.env, target = resolveTarget() } = {}) {
+  const base = (env.LANESH_DOWNLOAD_BASE || DEFAULT_DOWNLOAD_BASE).replace(/\/+$/, '');
+  const name = assetName(version, target);
+  const dir = `${base}/v${version}`;
+
+  const [checksums, binary] = await Promise.all([
+    fetchOk(`${dir}/checksums.txt`).then((r) => r.text()),
+    fetchOk(`${dir}/${name}`).then(async (r) => Buffer.from(await r.arrayBuffer()))
+  ]);
+
+  const expected = findChecksum(checksums, name);
+  if (!expected) throw new Error(`no checksum for ${name} in checksums.txt`);
+  const actual = createHash('sha256').update(binary).digest('hex');
+  if (actual !== expected) {
+    throw new Error(`checksum mismatch for ${name}: expected ${expected}, got ${actual}`);
+  }
+
+  const bin = binaryPath(env, target);
+  mkdirSync(join(laneshHome(env), 'bin'), { recursive: true });
+  const tmp = `${bin}.download`;
+  writeFileSync(tmp, binary, { mode: 0o755 });
+  chmodSync(tmp, 0o755);
+
+  if (target.os === 'windows' && existsSync(bin)) {
+    // A running .exe cannot be overwritten or deleted, but it can be renamed.
+    for (const f of readdirSync(dirname(bin))) {
+      if (f.startsWith(`${basename(bin)}.old`)) {
+        try {
+          rmSync(join(dirname(bin), f), { force: true });
+        } catch {
+          // still running
+        }
+      }
+    }
+    renameSync(bin, `${bin}.old-${Date.now()}`);
+  }
+  renameSync(tmp, bin);
+  return bin;
+}
+
+/**
+ * Returns the path of a binary at least as new as `wanted`, downloading it if
+ * needed. A newer managed binary (for example after a self-update) is kept.
+ */
+export async function ensureBinary(wanted, { env = process.env, target = resolveTarget() } = {}) {
+  const bin = binaryPath(env, target);
+  const current = installedVersion(bin);
+
+  if (isDevelopmentVersion(wanted)) {
+    if (current) return bin;
+    throw new Error(
+      `this is a development build of the lanesh npm package; install a release or place a binary at ${bin}`
+    );
+  }
+  if (current && !isDevelopmentVersion(current) && compareVersions(current, wanted) >= 0) {
+    return bin;
+  }
+  process.stderr.write(`lanesh: installing v${wanted} to ${bin}\n`);
+  return install(wanted, { env, target });
+}

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "lanesh",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Share skills and shells across your machines through one MCP endpoint.",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "agent",
+    "skills",
+    "remote-execution",
+    "cli"
+  ],
+  "homepage": "https://github.com/jtsang4/lanesh#readme",
+  "bugs": {
+    "url": "https://github.com/jtsang4/lanesh/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jtsang4/lanesh.git",
+    "directory": "build/npm"
+  },
+  "license": "MIT",
+  "author": "jtsang4",
+  "type": "module",
+  "bin": {
+    "lanesh": "bin/lanesh.js"
+  },
+  "files": [
+    "bin",
+    "lib"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}