infsh 0.0.2 → 1.19.5

package/install.js

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+
+const http = require("http");
+const https = require("https");
+const tls = require("tls");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const zlib = require("zlib");
+const crypto = require("crypto");
+
+// BELT_MANIFEST_URL points the installer at a mirror of dist.inference.sh.
+const MANIFEST_URL =
+  process.env.BELT_MANIFEST_URL || "https://dist.inference.sh/cli/manifest.json";
+
+const PLATFORM = { darwin: "darwin", linux: "linux", win32: "windows" }[
+  process.platform
+];
+const ARCH = { x64: "amd64", arm64: "arm64" }[process.arch];
+
+if (!PLATFORM || !ARCH) {
+  console.error(`Unsupported platform: ${process.platform}/${process.arch}`);
+  process.exit(1);
+}
+
+const KEY = `${PLATFORM}-${ARCH}`;
+
+// Pick the manifest build for `key`. Releases before the native windows-arm64
+// build have no such key; the amd64 build runs under emulation there.
+function selectBuild(builds, key = KEY, log = console.log) {
+  if (builds[key]) return { key, build: builds[key] };
+  if (key === "windows-arm64" && builds["windows-amd64"]) {
+    log("note: no windows-arm64 build in this release, using windows-amd64 under emulation");
+    return { key: "windows-amd64", build: builds["windows-amd64"] };
+  }
+  return null;
+}
+
+// Where the curl installer puts the binary; run.js falls back to it when the
+// package's own copy is missing (e.g. --ignore-scripts).
+function getInstallDir() {
+  if (process.platform === "win32") {
+    return path.join(os.homedir(), ".local", "bin");
+  }
+  if (process.getuid && process.getuid() === 0) {
+    return "/usr/local/bin";
+  }
+  return path.join(os.homedir(), ".local", "bin");
+}
+
+// --- proxy support (HTTPS_PROXY / HTTP_PROXY / NO_PROXY), no dependencies ---
+
+function defaultPort(u) {
+  return Number(u.port) || (u.protocol === "https:" ? 443 : 80);
+}
+
+// NO_PROXY: comma-separated hosts or domain suffixes (leading dot optional,
+// port suffix ignored); "*" disables proxying entirely.
+function noProxyMatches(hostname, env = process.env) {
+  const raw = env.NO_PROXY || env.no_proxy;
+  if (!raw) return false;
+  const host = hostname.toLowerCase();
+  return raw
+    .split(",")
+    .map((r) => r.trim().toLowerCase())
+    .filter(Boolean)
+    .some((rule) => {
+      if (rule === "*") return true;
+      const r = rule.replace(/:\d+$/, "").replace(/^\./, "");
+      return host === r || host.endsWith(`.${r}`);
+    });
+}
+
+// The proxy URL to use for `target`, or null for a direct connection.
+function proxyFor(target, env = process.env) {
+  if (noProxyMatches(target.hostname, env)) return null;
+  const raw =
+    target.protocol === "https:"
+      ? env.HTTPS_PROXY || env.https_proxy
+      : env.HTTP_PROXY || env.http_proxy;
+  if (!raw) return null;
+  return new URL(raw.includes("://") ? raw : `http://${raw}`);
+}
+
+// Open a CONNECT tunnel to `target` through `proxy` and resolve the raw socket.
+function connectThroughProxy(proxy, target) {
+  return new Promise((resolve, reject) => {
+    const hostPort = `${target.hostname}:${defaultPort(target)}`;
+    const headers = { Host: hostPort };
+    if (proxy.username) {
+      const creds = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
+      headers["Proxy-Authorization"] = `Basic ${Buffer.from(creds).toString("base64")}`;
+    }
+    const mod = proxy.protocol === "https:" ? https : http;
+    const req = mod.request({
+      host: proxy.hostname,
+      port: defaultPort(proxy),
+      method: "CONNECT",
+      path: hostPort,
+      headers,
+      agent: false,
+    });
+    req.on("connect", (res, socket) => {
+      if (res.statusCode !== 200) {
+        socket.destroy();
+        return reject(new Error(`proxy ${proxy.host} refused CONNECT ${hostPort}: HTTP ${res.statusCode}`));
+      }
+      resolve(socket);
+    });
+    req.on("error", (err) => reject(new Error(`proxy ${proxy.host}: ${err.message}`)));
+    req.end();
+  });
+}
+
+// GET `url` following redirects. Honors HTTPS_PROXY / HTTP_PROXY (http or
+// https proxy URL, optional basic auth) via a CONNECT tunnel, and NO_PROXY.
+async function fetch(url, redirects = 0) {
+  if (redirects > 10) throw new Error(`too many redirects for ${url}`);
+  const target = new URL(url);
+  const mod = target.protocol === "https:" ? https : http;
+  const options = {};
+  const proxy = proxyFor(target);
+  if (proxy) {
+    const socket = await connectThroughProxy(proxy, target);
+    // A createConnection without an agent makes the request use this socket.
+    options.createConnection =
+      target.protocol === "https:"
+        ? () => tls.connect({ socket, servername: target.hostname })
+        : () => socket;
+  }
+  const res = await new Promise((resolve, reject) => {
+    mod.get(url, options, resolve).on("error", reject);
+  });
+  if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+    res.resume();
+    return fetch(new URL(res.headers.location, url).href, redirects + 1);
+  }
+  if (res.statusCode !== 200) {
+    res.resume();
+    throw new Error(`HTTP ${res.statusCode} for ${url}`);
+  }
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    res.on("data", (c) => chunks.push(c));
+    res.on("end", () => resolve(Buffer.concat(chunks)));
+    res.on("error", reject);
+  });
+}
+
+// Extract a single file matching `prefix` from a .zip buffer.
+// ZIP central directory is at the end of the file — parse it to find entries.
+function extractFromZip(buf, prefix) {
+  // Find End of Central Directory record (signature 0x06054b50)
+  let eocdOffset = -1;
+  for (let i = buf.length - 22; i >= 0; i--) {
+    if (buf.readUInt32LE(i) === 0x06054b50) {
+      eocdOffset = i;
+      break;
+    }
+  }
+  if (eocdOffset === -1) throw new Error("invalid zip: EOCD not found");
+
+  const cdOffset = buf.readUInt32LE(eocdOffset + 16);
+  const cdEntries = buf.readUInt16LE(eocdOffset + 10);
+
+  let pos = cdOffset;
+  for (let i = 0; i < cdEntries; i++) {
+    if (buf.readUInt32LE(pos) !== 0x02014b50) throw new Error("invalid zip: bad central dir");
+    const nameLen = buf.readUInt16LE(pos + 28);
+    const extraLen = buf.readUInt16LE(pos + 30);
+    const commentLen = buf.readUInt16LE(pos + 32);
+    const localOffset = buf.readUInt32LE(pos + 42);
+    const name = buf.toString("utf8", pos + 46, pos + 46 + nameLen);
+
+    if (name.startsWith(prefix)) {
+      // Read local file header at localOffset (signature 0x04034b50)
+      const lh = localOffset;
+      const lhNameLen = buf.readUInt16LE(lh + 26);
+      const lhExtraLen = buf.readUInt16LE(lh + 28);
+      const compMethod = buf.readUInt16LE(lh + 8);
+      const compSize = buf.readUInt32LE(lh + 18);
+      const dataStart = lh + 30 + lhNameLen + lhExtraLen;
+      const compressed = buf.subarray(dataStart, dataStart + compSize);
+
+      if (compMethod === 0) return { name, data: compressed };
+      if (compMethod === 8) return { name, data: zlib.inflateRawSync(compressed) };
+      throw new Error(`unsupported zip compression method: ${compMethod}`);
+    }
+
+    pos += 46 + nameLen + extraLen + commentLen;
+  }
+  return null;
+}
+
+// Extract a single file matching `prefix` from a .tar.gz buffer.
+function extractFromTarGz(buf, prefix) {
+  const tar = zlib.gunzipSync(buf);
+  let offset = 0;
+  while (offset < tar.length - 512) {
+    const header = tar.subarray(offset, offset + 512);
+    if (header[0] === 0) break; // end of archive
+
+    const name = header.toString("utf8", 0, 100).replace(/\0.*/, "");
+    const sizeStr = header.toString("utf8", 124, 136).replace(/\0.*/, "").trim();
+    const size = parseInt(sizeStr, 8) || 0;
+    const dataStart = offset + 512;
+
+    if (name.startsWith(prefix)) {
+      return { name, data: tar.subarray(dataStart, dataStart + size) };
+    }
+
+    // Advance past header + data (rounded up to 512-byte blocks)
+    offset = dataStart + Math.ceil(size / 512) * 512;
+  }
+  return null;
+}
+
+// Write `data` to `dest` without ever leaving `dest` missing: stage next to it
+// and rename over. Windows refuses to replace a running exe but allows renaming
+// it, so the old file is moved aside first there.
+function installFile(dest, data) {
+  const staging = `${dest}.new-${process.pid}`;
+  fs.writeFileSync(staging, data, { mode: 0o755 });
+  try {
+    if (process.platform === "win32" && fs.existsSync(dest)) {
+      const old = `${dest}.old`;
+      try { fs.unlinkSync(old); } catch {}
+      fs.renameSync(dest, old);
+      try {
+        fs.renameSync(staging, dest);
+      } catch (err) {
+        fs.renameSync(old, dest);
+        throw err;
+      }
+      try { fs.unlinkSync(old); } catch {}
+    } else {
+      // rename replaces a symlink itself rather than writing through it.
+      fs.renameSync(staging, dest);
+    }
+  } finally {
+    try { fs.unlinkSync(staging); } catch {}
+  }
+}
+
+async function main() {
+  console.log(`Downloading belt for ${PLATFORM}/${ARCH}...`);
+
+  const manifest = JSON.parse(await fetch(MANIFEST_URL));
+  const selected = selectBuild(manifest.builds || {});
+  if (!selected) {
+    console.error(`No build found for ${KEY}`);
+    process.exit(1);
+  }
+  const { build } = selected;
+
+  const archive = await fetch(build.url);
+
+  // Verify checksum
+  const actual = crypto.createHash("sha256").update(archive).digest("hex");
+  if (build.sha256 && actual !== build.sha256) {
+    console.error(`Checksum mismatch!\n  expected: ${build.sha256}\n  got:      ${actual}`);
+    process.exit(1);
+  }
+
+  // Extract binary — pure Node, no shell commands, no MSYS path mangling
+  const entry = build.url.endsWith(".zip")
+    ? extractFromZip(archive, "inferencesh-cli")
+    : extractFromTarGz(archive, "inferencesh-cli");
+
+  if (!entry) {
+    console.error("Binary not found in archive");
+    process.exit(1);
+  }
+
+  // Only the package's own bin/ copy is written: npm's bin shims (belt,
+  // infsh, inferencesh -> run.js) put it on PATH for `npm i -g`, and npx runs
+  // it directly. Writing a second copy to ~/.local/bin left two binaries that
+  // self-updated independently and shadowed each other.
+  const ext = PLATFORM === "windows" ? ".exe" : "";
+  const npmBin = path.join(__dirname, "bin");
+  fs.mkdirSync(npmBin, { recursive: true });
+  installFile(path.join(npmBin, `belt${ext}`), entry.data);
+
+  console.log(`Installed belt ${manifest.version}`);
+}
+
+if (require.main === module) {
+  main().catch((err) => {
+    console.error("belt installation failed:", err.message);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  extractFromZip,
+  extractFromTarGz,
+  fetch,
+  getInstallDir,
+  installFile,
+  main,
+  noProxyMatches,
+  proxyFor,
+  selectBuild,
+};

package/package.json

@@ -1 +1,34 @@
-{"name":"infsh","version":"0.0.2","description":"inference.sh CLI — run AI apps, manage skills, connect MCP servers. Install: npx @inferencesh/belt","repository":"https://github.com/inference-sh/cli","bin":{"infsh":"index.js"}}
+{
+  "name": "infsh",
+  "version": "1.19.5",
+  "description": "inference.sh CLI — run AI apps, manage skills, connect MCP servers",
+  "homepage": "https://inference.sh",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/inference-sh/cli.git"
+  },
+  "license": "MIT",
+  "bin": {
+    "belt": "run.js",
+    "infsh": "run.js",
+    "inferencesh": "run.js"
+  },
+  "scripts": {
+    "postinstall": "node install.js",
+    "test": "node --test install.test.js run.test.js package.test.js"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "files": [
+    "install.js",
+    "run.js",
+    "bin/"
+  ]
+}

package/run.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+const { spawn } = require("child_process");
+const { existsSync } = require("fs");
+const path = require("path");
+const { getInstallDir, main: install } = require("./install.js");
+
+const ext = process.platform === "win32" ? ".exe" : "";
+
+// The postinstall copy, then the persistent one install.js also writes.
+function findBinary() {
+  const candidates = [
+    path.join(__dirname, "bin", `belt${ext}`),
+    path.join(getInstallDir(), `belt${ext}`),
+  ];
+  return candidates.find((p) => existsSync(p));
+}
+
+function run(bin) {
+  const child = spawn(bin, process.argv.slice(2), { stdio: "inherit" });
+  child.on("error", (err) => {
+    console.error(err.message);
+    process.exit(1);
+  });
+  child.on("exit", (code) => process.exit(code ?? 1));
+}
+
+async function start() {
+  let bin = findBinary();
+  if (!bin) {
+    // postinstall did not run (--ignore-scripts) or failed: install now.
+    // Its progress goes to stderr so stdout stays clean for the command.
+    const log = console.log;
+    console.log = console.error;
+    try {
+      await install();
+    } catch (err) {
+      console.error(
+        "belt binary not found and could not be downloaded: " + err.message + "\n" +
+        "install directly instead:\n" +
+        "  macOS / Linux / Git Bash:  curl -fsSL https://cli.inference.sh | sh\n" +
+        "  Windows PowerShell:        irm https://cli.inference.sh/install.ps1 | iex"
+      );
+      process.exit(1);
+    } finally {
+      console.log = log;
+    }
+    bin = findBinary();
+  }
+  run(bin);
+}
+
+start();

package/index.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-console.log("Install the inference.sh CLI: npx @inferencesh/belt");
-process.exit(1);