xinfer-ai 0.12.1

package/docs/xbot.md

@@ -0,0 +1,110 @@
+# xbot + xInfer
+
+This guide connects `xbot` directly to `xInfer` through the built-in OpenAI-compatible `/v1/chat/completions` endpoint.
+
+```
+xbot -> xInfer (OpenAI-compatible)
+```
+
+## 1) Start xInfer (at port 8000)
+
+```bash
+./run --release --features cuda,nccl,flashinfer,cutlass \
+  --m Qwen/Qwen3.6-27B-FP8
+```
+
+or
+
+```shell
+# Python
+python3 -m xinfer.server --m Qwen/Qwen3.6-27B-FP8
+```
+
+## 2) Discover the served model name
+
+```bash
+curl http://localhost:8000/v1/models
+```
+
+Use the returned `id` in the xbot config.
+
+## 3) Configure xbot
+
+Install xbot:
+
+```bash
+npm install -g @trusted-ai/xbot
+```
+Or:
+
+```bash
+cargo install xbot
+```
+
+Run xbot provider config:
+
+```bash
+xbot onboard
+xbot config --provider
+```
+
+Refer to the following selections:
+
+```shell
+> Select provider to configure: custom
+> Enter a unique name for this custom provider: xinfer
+> Enter API Base URL (e.g. https://api.yourprovider.com/v1): http://localhost:8000/v1/
+> Enter API Key? (Optional for local/custom) No
+
+Fetching available models...
+> Select default model: Qwen3.6-27B-FP8
+Using contextWindowTokens from model metadata: 262144
+
+> Configure subagent provider/model now? No
+
+Configuration saved successfully!
+Config file: /root/.xbot/config.json
+
+Final Provider Config:
+{
+  "api_key": "",
+  "api_base": "http://localhost:8000/v1/",
+  "extra_headers": {},
+  "reasoning_effort": null
+}
+```
+
+## 4) Run xbot
+
+One-shot task
+
+```bash
+cd YOUR PROJECT
+# scan project and init agent file
+xbot chat /init
+# real task
+xbot chat "find bugs in this project."
+```
+**Interactive terminal** (rich TUI)
+
+```bash
+cd YOUR PROJECT
+# you may add .xbot workspace folder to .gitignore
+xbot repl
+```
+
+## Notes
+
+- Tool calls follow the normal OpenAI request/response loop.
+- For Qwen coder models, `--enforce-parser qwen_coder` is usually the most reliable parser setting.
+- If xbot reports a model mismatch, compare your configured model against `GET /v1/models`.
+
+## Troubleshooting
+
+Chat logger:
+
+```bash
+# Log into files (in folder ./log)
+export XINFER_CHAT_LOGGER=1
+```
+

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "xinfer-ai",
+  "version": "0.12.1",
+  "description": "xInfer — a high-performance LLM inference engine in Rust with CUDA/Metal acceleration",
+  "license": "MIT",
+  "homepage": "https://github.com/guoqingbao/xinfer#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/guoqingbao/xinfer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/guoqingbao/xinfer/issues"
+  },
+  "bin": {
+    "xinfer": "bin/xinfer.js"
+  },
+  "scripts": {
+    "prepack": "node scripts/prepare-package.js",
+    "postpack": "node scripts/clean-package.js",
+    "postinstall": "node scripts/install.js"
+  },
+  "files": [
+    "bin/xinfer.js",
+    "scripts/install.js",
+    "docs",
+    "README.md",
+    "LICENSE.txt"
+  ],
+  "keywords": [
+    "llm",
+    "inference",
+    "cuda",
+    "metal",
+    "gpu",
+    "xinfer",
+    "rust"
+  ],
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "cpu": [
+    "arm64",
+    "x64"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}

package/scripts/install.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const https = require("https");
+const os = require("os");
+const path = require("path");
+const { createHash } = require("crypto");
+const { spawnSync } = require("child_process");
+
+const pkg = require("../package.json");
+
+function targetTriple() {
+  const platform = process.platform;
+  const arch = process.arch;
+  if (
+    (platform !== "linux" && platform !== "darwin") ||
+    (arch !== "x64" && arch !== "arm64")
+  ) {
+    throw new Error(
+      `Unsupported platform: ${platform}-${arch}. Supported: linux/darwin x64/arm64.`
+    );
+  }
+  return `${platform}-${arch}`;
+}
+
+/**
+ * Detect CUDA compute capability via nvidia-smi.
+ * Returns the highest SM version across all GPUs (e.g. "90", "89", "80").
+ * Returns null if no NVIDIA GPU detected (e.g. macOS Metal).
+ */
+function detectCudaComputeCap() {
+  // Allow explicit override
+  if (process.env.XINFER_CUDA_COMPUTE_CAP) {
+    return process.env.XINFER_CUDA_COMPUTE_CAP;
+  }
+
+  try {
+    const result = spawnSync(
+      "nvidia-smi",
+      [
+        "--query-gpu=compute_cap",
+        "--format=csv,noheader,nounits",
+      ],
+      { encoding: "utf8", timeout: 10000 }
+    );
+    if (result.status !== 0 || !result.stdout) return null;
+
+    let maxCap = 0;
+    for (const line of result.stdout.trim().split("\n")) {
+      const cap = line.trim();
+      if (!cap) continue;
+      // Parse "8.9" -> 89, "9.0" -> 90, "10.0" -> 100
+      const parts = cap.split(".");
+      const major = parseInt(parts[0], 10);
+      const minor = parseInt(parts[1] || "0", 10);
+      const sm = major * 10 + minor;
+      if (sm > maxCap) maxCap = sm;
+    }
+    return maxCap > 0 ? String(maxCap) : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Map detected SM version to the build variant name.
+ * Build variants match CI matrix: sm70, sm75, sm80, sm89, sm90, sm120
+ */
+function smToVariant(sm) {
+  const n = parseInt(sm, 10);
+  if (n >= 120) return "sm120";
+  if (n >= 90) return "sm90";
+  if (n >= 89) return "sm89";
+  if (n >= 80) return "sm80";
+  if (n >= 75) return "sm75";
+  if (n >= 70) return "sm70";
+  return "sm80";
+}
+
+function download(url, destination, redirects = 0) {
+  if (redirects > 5) {
+    return Promise.reject(
+      new Error(`Too many redirects while downloading ${url}`)
+    );
+  }
+  return new Promise((resolve, reject) => {
+    const proto = url.startsWith("https") ? https : require("http");
+    const request = proto.get(url, (response) => {
+      if (
+        response.statusCode >= 300 &&
+        response.statusCode < 400 &&
+        response.headers.location
+      ) {
+        response.resume();
+        const next = new URL(response.headers.location, url).toString();
+        download(next, destination, redirects + 1).then(resolve, reject);
+        return;
+      }
+      if (response.statusCode !== 200) {
+        response.resume();
+        reject(
+          new Error(`Download failed (${response.statusCode}) for ${url}`)
+        );
+        return;
+      }
+      const file = fs.createWriteStream(destination);
+      response.pipe(file);
+      file.on("finish", () => file.close(resolve));
+      file.on("error", reject);
+    });
+    request.on("error", reject);
+  });
+}
+
+function sha256(file) {
+  const hash = createHash("sha256");
+  hash.update(fs.readFileSync(file));
+  return hash.digest("hex");
+}
+
+function expectedSha(manifest, artifactName) {
+  for (const line of manifest.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parts = trimmed.split(/\s+/);
+    const checksum = parts[0];
+    const name = parts[parts.length - 1].replace(/^\*/, "");
+    if (name === artifactName) return checksum;
+  }
+  return null;
+}
+
+async function main() {
+  const target = targetTriple();
+  const version = process.env.XINFER_INSTALL_VERSION || pkg.version;
+  const tag = process.env.XINFER_INSTALL_TAG || `v${version}`;
+  const base =
+    process.env.XINFER_INSTALL_BASE_URL ||
+    `https://github.com/guoqingbao/xinfer/releases/download/${tag}`;
+
+  let variant = "";
+  if (process.platform === "linux") {
+    const sm = detectCudaComputeCap();
+    if (sm) {
+      variant = `-${smToVariant(sm)}`;
+      console.log(
+        `Detected CUDA compute capability: sm_${sm} -> variant${variant}`
+      );
+    } else {
+      console.log(
+        "No NVIDIA GPU detected; downloading default (sm80) build."
+      );
+      variant = "-sm80";
+    }
+  }
+  // macOS uses metal variant
+  if (process.platform === "darwin") {
+    variant = "-metal";
+  }
+
+  const artifactName = `xinfer-${version}-${target}${variant}.tar.gz`;
+  const artifactUrl = `${base}/${artifactName}`;
+  const sumsUrl = `${base}/SHA256SUMS`;
+  const root = path.resolve(__dirname, "..");
+  const installDir = path.join(root, "vendor", `${target}${variant}`);
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "xinfer-install-"));
+  const archivePath = path.join(tmpDir, artifactName);
+  const sumsPath = path.join(tmpDir, "SHA256SUMS");
+
+  try {
+    console.log(`Downloading ${artifactUrl}...`);
+    await download(sumsUrl, sumsPath);
+    await download(artifactUrl, archivePath);
+    const expected = expectedSha(
+      fs.readFileSync(sumsPath, "utf8"),
+      artifactName
+    );
+    if (!expected) {
+      throw new Error(`No checksum entry found for ${artifactName}`);
+    }
+    const actual = sha256(archivePath);
+    if (actual !== expected) {
+      throw new Error(
+        `Checksum mismatch for ${artifactName}: expected ${expected}, got ${actual}`
+      );
+    }
+
+    fs.rmSync(installDir, { recursive: true, force: true });
+    fs.mkdirSync(installDir, { recursive: true });
+    const tar = spawnSync(
+      "tar",
+      ["-xzf", archivePath, "-C", installDir],
+      { stdio: "inherit" }
+    );
+    if (tar.error) throw tar.error;
+    if (tar.status !== 0) {
+      throw new Error(`tar exited with status ${tar.status}`);
+    }
+    const binary = path.join(installDir, "xinfer");
+    fs.chmodSync(binary, 0o755);
+    console.log(`xinfer installed to ${installDir}`);
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+main().catch((err) => {
+  console.error(`xinfer install failed: ${err.message}`);
+  process.exit(1);
+});