slopcode 0.2.106 → 0.2.110

package/bin/slopcode

@@ -40,6 +40,7 @@ const archMap = {
   arm: "arm",
 }
 const supported = {
+  android: ["arm64", "x64"],
   darwin: ["arm64", "x64"],
   linux: ["arm64", "x64"],
   windows: ["x64"],
@@ -136,9 +137,8 @@ function supportsAvx2() {
 
 function names(prefix) {
   const kind = libc()
-  if (kind === "bionic") return []
-
-  const base = `${prefix}-${platform}-${arch}`
+  const base = kind === "bionic" ? `${prefix}-android-${arch}` : `${prefix}-${platform}-${arch}`
+  if (kind === "bionic") return [`@slopcode-ai/slopcode-android-${arch}`, base]
   const avx2 = supportsAvx2()
   const baseline = arch === "x64" && !avx2
 
@@ -206,25 +206,20 @@ function supportedMessage() {
 
 function termuxMessage() {
   return [
-    "SlopCode does not ship a native Android/Termux (bionic) binary yet.",
-    "Run SlopCode inside a Termux proot Linux distro:",
-    "  pkg install proot-distro",
-    "  proot-distro install debian",
-    "  proot-distro login debian",
-    "  apt update && apt install -y curl ca-certificates git",
-    "  curl -fsSL https://slopcode.dev/install | bash",
+    "SlopCode native Termux support could not find the Android runtime.",
+    "Reinstall from Termux with:",
+    "  pkg update",
+    "  pkg install nodejs git ripgrep neovim tar",
+    "  npm install -g slopcode@latest --include=optional",
+    "If postinstall could not download the runtime, install the matching GitHub release asset manually.",
   ].join("\n")
 }
 
-if (libc() === "bionic") {
-  clearCache()
-  console.error(termuxMessage())
-  process.exit(1)
-}
+const useCache = libc() !== "bionic"
 
 const packageNames = names("slopcode-bin")
 const resolvedNames = Array.from(new Set([...packageNames, ...names("slopcode")]))
-const hit = cacheReady(resolvedNames)
+const hit = useCache ? cacheReady(resolvedNames) : undefined
 if (hit) {
   run(hit)
 }
@@ -268,6 +263,10 @@ function findBinary(startDir) {
 
 const resolved = resolveBinary() || findBinary(scriptDir)
 if (!resolved) {
+  if (libc() === "bionic") {
+    console.error(termuxMessage())
+    process.exit(1)
+  }
   console.error(
     "It seems that your package manager failed to install the right version of the slopcode CLI for your platform. You can try manually installing " +
       packageNames.map((n) => `\"${n}\"`).join(" or ") +

package/package.json

@@ -34,19 +34,19 @@
   "scripts": {
     "postinstall": "bun ./postinstall.mjs || node ./postinstall.mjs"
   },
-  "version": "0.2.106",
+  "version": "0.2.110",
   "license": "MIT",
   "optionalDependencies": {
-    "slopcode-bin-darwin-arm64": "0.2.106",
-    "slopcode-bin-linux-x64-baseline": "0.2.106",
-    "slopcode-bin-windows-x64": "0.2.106",
-    "slopcode-bin-linux-x64": "0.2.106",
-    "slopcode-bin-linux-x64-baseline-musl": "0.2.106",
-    "slopcode-bin-linux-x64-musl": "0.2.106",
-    "slopcode-bin-linux-arm64": "0.2.106",
-    "slopcode-bin-windows-x64-baseline": "0.2.106",
-    "slopcode-bin-linux-arm64-musl": "0.2.106",
-    "slopcode-bin-darwin-x64-baseline": "0.2.106",
-    "slopcode-bin-darwin-x64": "0.2.106"
+    "slopcode-bin-darwin-arm64": "0.2.110",
+    "slopcode-bin-linux-x64-baseline": "0.2.110",
+    "slopcode-bin-windows-x64": "0.2.110",
+    "slopcode-bin-linux-x64": "0.2.110",
+    "slopcode-bin-linux-x64-baseline-musl": "0.2.110",
+    "slopcode-bin-linux-x64-musl": "0.2.110",
+    "slopcode-bin-linux-arm64": "0.2.110",
+    "slopcode-bin-windows-x64-baseline": "0.2.110",
+    "slopcode-bin-linux-arm64-musl": "0.2.110",
+    "slopcode-bin-darwin-x64-baseline": "0.2.110",
+    "slopcode-bin-darwin-x64": "0.2.110"
   }
 }

package/postinstall.mjs

@@ -10,6 +10,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const require = createRequire(import.meta.url)
 const pkg = require("./package.json")
 const supported = {
+  android: ["arm64", "x64"],
   darwin: ["arm64", "x64"],
   linux: ["arm64", "x64"],
   windows: ["x64"],
@@ -91,9 +92,9 @@ function supportsAvx2(platform, arch) {
 }
 
 function names(platform, arch) {
-  const base = `slopcode-bin-${platform}-${arch}`
   const libc = detectLibc(platform, arch)
-  if (libc === "bionic") return []
+  const base = `slopcode-bin-${libc === "bionic" ? "android" : platform}-${arch}`
+  if (libc === "bionic") return [`@slopcode-ai/slopcode-android-${arch}`, base, `slopcode-android-${arch}`]
   const avx2 = supportsAvx2(platform, arch)
   const baseline = arch === "x64" && !avx2
 
@@ -141,16 +142,69 @@ function supportedMessage() {
 
 function termuxMessage() {
   return [
-    "SlopCode does not ship a native Android/Termux (bionic) binary yet.",
-    "Run SlopCode inside a Termux proot Linux distro:",
-    "  pkg install proot-distro",
-    "  proot-distro install debian",
-    "  proot-distro login debian",
-    "  apt update && apt install -y curl ca-certificates git",
-    "  curl -fsSL https://slopcode.dev/install | bash",
+    "SlopCode native Termux support could not install the Android runtime.",
+    "Install from Termux with:",
+    "  pkg update",
+    "  pkg install nodejs git ripgrep neovim tar",
+    "  npm install -g slopcode@latest --include=optional",
+    "If that still fails, install the matching GitHub release asset manually.",
   ].join("\n")
 }
 
+function androidPackage(arch) {
+  return `@slopcode-ai/slopcode-android-${arch}`
+}
+
+function androidTarget(arch) {
+  return path.join(__dirname, "node_modules", "@slopcode-ai", `slopcode-android-${arch}`)
+}
+
+function androidUrl(arch) {
+  return `https://github.com/teamslop/slopcode/releases/download/v${pkg.version}/slopcode-android-${arch}.tar.gz`
+}
+
+async function androidAsset(arch, tmp) {
+  if (process.env.SLOPCODE_ANDROID_ASSET_PATH) return process.env.SLOPCODE_ANDROID_ASSET_PATH
+  const out = path.join(tmp, `slopcode-android-${arch}.tar.gz`)
+  const res = await fetch(process.env.SLOPCODE_ANDROID_ASSET_URL || androidUrl(arch))
+  if (!res.ok) throw new Error(`Failed to download Android runtime: ${res.status} ${res.statusText}`)
+  await fs.promises.writeFile(out, Buffer.from(await res.arrayBuffer()))
+  return out
+}
+
+async function installAndroid(arch) {
+  const tmp = await fs.promises.mkdtemp(path.join(os.tmpdir(), "slopcode-android-"))
+  const target = androidTarget(arch)
+  try {
+    const archive = await androidAsset(arch, tmp)
+    const extract = path.join(tmp, "package")
+    await fs.promises.mkdir(extract, { recursive: true })
+    const result = require("child_process").spawnSync("tar", ["-xzf", archive, "-C", extract], {
+      encoding: "utf8",
+      timeout: 120000,
+    })
+    if (result.status !== 0) {
+      throw new Error((result.stderr || result.stdout || "tar failed").trim())
+    }
+    const binary = path.join(extract, "bin", "slopcode")
+    if (!fs.existsSync(binary)) throw new Error("Downloaded Android runtime is missing bin/slopcode")
+    await fs.promises.rm(target, { recursive: true, force: true })
+    await fs.promises.mkdir(path.dirname(target), { recursive: true })
+    await fs.promises.rename(extract, target)
+    fs.chmodSync(path.join(target, "bin", "slopcode"), 0o755)
+    return {
+      binaryPath: path.join(target, "bin", "slopcode"),
+      binaryName: "slopcode",
+      packageName: androidPackage(arch),
+      platform: "android",
+      arch,
+      libc: "bionic",
+    }
+  } finally {
+    await fs.promises.rm(tmp, { recursive: true, force: true })
+  }
+}
+
 function findBinary() {
   const { platform, arch } = detectPlatformAndArch()
   const binaryName = platform === "windows" ? "slopcode.exe" : "slopcode"
@@ -214,11 +268,6 @@ function writeMeta(input) {
 async function main() {
   try {
     const { platform, arch } = detectPlatformAndArch()
-    if (detectLibc(platform, arch) === "bionic") {
-      clearCache()
-      console.log(termuxMessage())
-      return
-    }
 
     if (!(supported[platform] ?? []).includes(arch)) {
       clearCache()
@@ -236,10 +285,25 @@ async function main() {
     const found = findBinary()
     if (!found) {
       clearCache()
+      if (detectLibc(platform, arch) === "bionic") {
+        try {
+          await installAndroid(arch)
+          console.log("Android/Termux runtime installed from GitHub release asset")
+        } catch (error) {
+          console.log(termuxMessage())
+          console.error(error.message)
+        }
+        return
+      }
       console.log("No platform binary package detected during postinstall; runtime resolver will handle it")
       return
     }
 
+    if (found.libc === "bionic") {
+      clearCache()
+      console.log("Android/Termux runtime package detected; runtime resolver will launch it")
+      return
+    }
     clearCache()
     const target = path.join(__dirname, "bin", ".slopcode")
     const { targetPath } = prepareBinDirectory(".slopcode")