pluidr 0.7.0 → 0.7.1

package/src/core/squeezeInstaller.js

@@ -1,161 +1,161 @@
-import { execFileSync } from "node:child_process"
-import { chmodSync, mkdirSync, existsSync, writeFileSync, unlinkSync, readFileSync, renameSync } from "node:fs"
-import { extname, join, resolve, dirname } from "node:path"
-import { fileURLToPath } from "node:url"
-import { createHash } from "node:crypto"
-import { getConfigDir } from "./paths.js"
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-
-// Local binary name — friendlier than the upstream "rtk" name
-const BIN_NAME = process.platform === "win32" ? "squeeze.exe" : "squeeze"
-// Name of the binary inside the downloaded archive (upstream uses "rtk")
-const RTK_BIN_NAME = process.platform === "win32" ? "rtk.exe" : "rtk"
-export const ASSETS = {
-  "darwin-arm64": "rtk-aarch64-apple-darwin.tar.gz",
-  "darwin-x64": "rtk-x86_64-apple-darwin.tar.gz",
-  "linux-x64": "rtk-x86_64-unknown-linux-musl.tar.gz",
-  "linux-arm64": "rtk-aarch64-unknown-linux-gnu.tar.gz",
-  "win32-x64": "rtk-x86_64-pc-windows-msvc.zip",
-}
-const RTK_RELEASE_BASE = "https://github.com/rtk-ai/rtk/releases/latest/download"
-
-export function platformAsset() {
-  const key = `${process.platform}-${process.arch}`
-  return ASSETS[key] ?? null
-}
-
-export function validatePath(path) {
-  if (!/^[a-zA-Z0-9_\-\.\:\/\\]+$/.test(path)) {
-    throw new Error(`Invalid path: "${path}" contains unsafe characters`)
-  }
-}
-
-export function findSqueezePath() {
-  try {
-    const [cmd, ...args] =
-      process.platform === "win32" ? ["where", "squeeze"] : ["which", "squeeze"]
-    return execFileSync(cmd, args, { stdio: "pipe" })
-      .toString()
-      .trim()
-      .split(/\r?\n/)[0]
-  } catch {
-    return null
-  }
-}
-
-function extract(archivePath, destDir) {
-  validatePath(archivePath)
-  validatePath(destDir)
-  const isZip = extname(archivePath) === ".zip"
-
-  if (isZip && process.platform === "win32") {
-    execFileSync("powershell", [
-      "-NoProfile",
-      "-Command",
-      "Expand-Archive",
-      "-LiteralPath", archivePath,
-      "-DestinationPath", destDir,
-      "-Force"
-    ], { stdio: "ignore" })
-  } else {
-    execFileSync("tar", ["-xzf", archivePath, "-C", destDir], { stdio: "ignore" })
-  }
-}
-
-function verifyChecksum(buffer, assetName) {
-  const checksumsPath = resolve(__dirname, "../templates/rtk-checksums.json")
-  let checksums
-  try {
-    checksums = JSON.parse(readFileSync(checksumsPath, "utf-8"))
-  } catch {
-    // No checksums file — skip verification
-    return
-  }
-
-  const expectedHash = checksums[assetName]
-  if (expectedHash === null || expectedHash === undefined) {
-    // Hash not yet populated for this platform — silently skip
-    return
-  }
-
-  const computed = createHash("sha256").update(buffer).digest("hex")
-  if (computed !== expectedHash) {
-    throw new Error(
-      `SHA256 mismatch for ${assetName}\n  expected: ${expectedHash}\n  computed: ${computed}`
-    )
-  }
-}
-
-export async function installSqueeze() {
-  let rtkPath = findSqueezePath()
-
-  if (!rtkPath) {
-    // Not on PATH — download it to the managed location
-    const asset = platformAsset()
-    if (!asset) {
-      console.warn("⚠ Squeeze: unsupported platform — squeeze binary unavailable")
-      return
-    }
-
-    const binDir = join(getConfigDir(), "bin")
-    mkdirSync(binDir, { recursive: true })
-
-    const url = `${RTK_RELEASE_BASE}/${asset}`
-    const archivePath = join(binDir, asset)
-
-    try {
-      let response
-      for (let attempt = 1; attempt <= 3; attempt++) {
-        try {
-          response = await fetch(url)
-          if (!response.ok) throw new Error(`HTTP ${response.status}`)
-          break
-        } catch (err) {
-          if (attempt < 3) {
-            // Retry on any error (network, HTTP, etc.) with exponential backoff
-            const delay = Math.pow(2, attempt - 1) * 1000
-            await new Promise(r => setTimeout(r, delay))
-            continue
-          }
-          throw err
-        }
-      }
-
-      const buffer = Buffer.from(await response.arrayBuffer())
-      verifyChecksum(buffer, asset)
-      writeFileSync(archivePath, buffer)
-
-      extract(archivePath, binDir)
-
-      try { unlinkSync(archivePath) } catch {}
-
-      // Archive contains "rtk"/"rtk.exe" — rename to local BIN_NAME ("squeeze")
-      const extracted = join(binDir, RTK_BIN_NAME)
-      rtkPath = join(binDir, BIN_NAME)
-      if (existsSync(extracted) && extracted !== rtkPath) {
-        renameSync(extracted, rtkPath)
-      }
-
-      if (process.platform !== "win32" && existsSync(rtkPath)) {
-        chmodSync(rtkPath, 0o755)
-      }
-
-      // Verify that the downloaded binary is executable and runs on this platform
-      try {
-        execFileSync(rtkPath, ["--help"], { stdio: "ignore" })
-      } catch (err) {
-        // If it throws because of execution format or permissions (e.g. ENOEXEC, EACCES, ENOENT)
-        if (err.code === "ENOEXEC" || err.code === "EACCES" || err.code === "ENOENT") {
-          try { unlinkSync(rtkPath) } catch {}
-          throw new Error(`Downloaded binary is not executable on this platform: ${err.message}`)
-        }
-        // If it ran but exited with non-zero (like returning exit code 1 for --help), that's fine, it means it is executable!
-      }
-    } catch (err) {
-      try { unlinkSync(archivePath) } catch {}
-      console.warn(`⚠ Squeeze: installation failed (${err.message}) — squeeze plugin disabled`)
-      return
-    }
-  }
-}
+import { execFileSync } from "node:child_process"
+import { chmodSync, mkdirSync, existsSync, writeFileSync, unlinkSync, readFileSync, renameSync } from "node:fs"
+import { extname, join, resolve, dirname } from "node:path"
+import { fileURLToPath } from "node:url"
+import { createHash } from "node:crypto"
+import { getConfigDir } from "./paths.js"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+// Local binary name — friendlier than the upstream "rtk" name
+const BIN_NAME = process.platform === "win32" ? "squeeze.exe" : "squeeze"
+// Name of the binary inside the downloaded archive (upstream uses "rtk")
+const RTK_BIN_NAME = process.platform === "win32" ? "rtk.exe" : "rtk"
+export const ASSETS = {
+  "darwin-arm64": "rtk-aarch64-apple-darwin.tar.gz",
+  "darwin-x64": "rtk-x86_64-apple-darwin.tar.gz",
+  "linux-x64": "rtk-x86_64-unknown-linux-musl.tar.gz",
+  "linux-arm64": "rtk-aarch64-unknown-linux-gnu.tar.gz",
+  "win32-x64": "rtk-x86_64-pc-windows-msvc.zip",
+}
+const RTK_RELEASE_BASE = "https://github.com/rtk-ai/rtk/releases/latest/download"
+
+export function platformAsset() {
+  const key = `${process.platform}-${process.arch}`
+  return ASSETS[key] ?? null
+}
+
+export function validatePath(path) {
+  if (!/^[a-zA-Z0-9_\-\.\:\/\\]+$/.test(path)) {
+    throw new Error(`Invalid path: "${path}" contains unsafe characters`)
+  }
+}
+
+export function findSqueezePath() {
+  try {
+    const [cmd, ...args] =
+      process.platform === "win32" ? ["where", "squeeze"] : ["which", "squeeze"]
+    return execFileSync(cmd, args, { stdio: "pipe" })
+      .toString()
+      .trim()
+      .split(/\r?\n/)[0]
+  } catch {
+    return null
+  }
+}
+
+function extract(archivePath, destDir) {
+  validatePath(archivePath)
+  validatePath(destDir)
+  const isZip = extname(archivePath) === ".zip"
+
+  if (isZip && process.platform === "win32") {
+    execFileSync("powershell", [
+      "-NoProfile",
+      "-Command",
+      "Expand-Archive",
+      "-LiteralPath", archivePath,
+      "-DestinationPath", destDir,
+      "-Force"
+    ], { stdio: "ignore" })
+  } else {
+    execFileSync("tar", ["-xzf", archivePath, "-C", destDir], { stdio: "ignore" })
+  }
+}
+
+function verifyChecksum(buffer, assetName) {
+  const checksumsPath = resolve(__dirname, "../templates/rtk-checksums.json")
+  let checksums
+  try {
+    checksums = JSON.parse(readFileSync(checksumsPath, "utf-8"))
+  } catch {
+    // No checksums file — skip verification
+    return
+  }
+
+  const expectedHash = checksums[assetName]
+  if (expectedHash === null || expectedHash === undefined) {
+    // Hash not yet populated for this platform — silently skip
+    return
+  }
+
+  const computed = createHash("sha256").update(buffer).digest("hex")
+  if (computed !== expectedHash) {
+    throw new Error(
+      `SHA256 mismatch for ${assetName}\n  expected: ${expectedHash}\n  computed: ${computed}`
+    )
+  }
+}
+
+export async function installSqueeze() {
+  let rtkPath = findSqueezePath()
+
+  if (!rtkPath) {
+    // Not on PATH — download it to the managed location
+    const asset = platformAsset()
+    if (!asset) {
+      console.warn("⚠ Squeeze: unsupported platform — squeeze binary unavailable")
+      return
+    }
+
+    const binDir = join(getConfigDir(), "bin")
+    mkdirSync(binDir, { recursive: true })
+
+    const url = `${RTK_RELEASE_BASE}/${asset}`
+    const archivePath = join(binDir, asset)
+
+    try {
+      let response
+      for (let attempt = 1; attempt <= 3; attempt++) {
+        try {
+          response = await fetch(url)
+          if (!response.ok) throw new Error(`HTTP ${response.status}`)
+          break
+        } catch (err) {
+          if (attempt < 3) {
+            // Retry on any error (network, HTTP, etc.) with exponential backoff
+            const delay = Math.pow(2, attempt - 1) * 1000
+            await new Promise(r => setTimeout(r, delay))
+            continue
+          }
+          throw err
+        }
+      }
+
+      const buffer = Buffer.from(await response.arrayBuffer())
+      verifyChecksum(buffer, asset)
+      writeFileSync(archivePath, buffer)
+
+      extract(archivePath, binDir)
+
+      try { unlinkSync(archivePath) } catch {}
+
+      // Archive contains "rtk"/"rtk.exe" — rename to local BIN_NAME ("squeeze")
+      const extracted = join(binDir, RTK_BIN_NAME)
+      rtkPath = join(binDir, BIN_NAME)
+      if (existsSync(extracted) && extracted !== rtkPath) {
+        renameSync(extracted, rtkPath)
+      }
+
+      if (process.platform !== "win32" && existsSync(rtkPath)) {
+        chmodSync(rtkPath, 0o755)
+      }
+
+      // Verify that the downloaded binary is executable and runs on this platform
+      try {
+        execFileSync(rtkPath, ["--help"], { stdio: "ignore" })
+      } catch (err) {
+        // If it throws because of execution format or permissions (e.g. ENOEXEC, EACCES, ENOENT)
+        if (err.code === "ENOEXEC" || err.code === "EACCES" || err.code === "ENOENT") {
+          try { unlinkSync(rtkPath) } catch {}
+          throw new Error(`Downloaded binary is not executable on this platform: ${err.message}`)
+        }
+        // If it ran but exited with non-zero (like returning exit code 1 for --help), that's fine, it means it is executable!
+      }
+    } catch (err) {
+      try { unlinkSync(archivePath) } catch {}
+      console.warn(`⚠ Squeeze: installation failed (${err.message}) — squeeze plugin disabled`)
+      return
+    }
+  }
+}

package/src/core/squeezeInstaller.test.js

@@ -1,75 +1,75 @@
-import { describe, it } from "node:test"
-import assert from "node:assert"
-import { platformAsset, validatePath, findSqueezePath, ASSETS } from "./squeezeInstaller.js"
-
-describe("platformAsset", () => {
-  it("returns a string or null for current platform", () => {
-    const result = platformAsset()
-    // On a supported platform: string; on unsupported: null
-    assert.ok(result === null || typeof result === "string")
-  })
-
-  it("returns known asset names for mapped platforms", () => {
-    // Verify the ASSETS map has entries for all known platform combos
-    const knownCombos = [
-      { plat: "darwin", arch: "arm64" },
-      { plat: "darwin", arch: "x64" },
-      { plat: "linux", arch: "x64" },
-      { plat: "linux", arch: "arm64" },
-      { plat: "win32", arch: "x64" },
-    ]
-    for (const { plat, arch } of knownCombos) {
-      const key = `${plat}-${arch}`
-      const asset = ASSETS[key]
-      assert.ok(asset, `ASSETS map should have entry for ${key}`)
-      assert.ok(asset.endsWith(".tar.gz") || asset.endsWith(".zip"),
-        `Asset "${asset}" should end with .tar.gz or .zip`)
-    }
-  })
-})
-
-describe("validatePath", () => {
-  it("accepts simple relative paths", () => {
-    assert.doesNotThrow(() => validatePath("foo/bar"))
-  })
-
-  it("accepts absolute POSIX paths", () => {
-    assert.doesNotThrow(() => validatePath("/home/user/.config"))
-  })
-
-  it("accepts absolute Windows paths", () => {
-    assert.doesNotThrow(() => validatePath("C:\\Users\\test"))
-  })
-
-  it("accepts paths with dots and dashes", () => {
-    assert.doesNotThrow(() => validatePath("./dir/file-name.ext"))
-  })
-
-  it("allows .. in paths (shell metacharacter check only, not path traversal)", () => {
-    assert.doesNotThrow(() => validatePath("../evil"))
-  })
-
-  it("rejects paths with semicolons", () => {
-    assert.throws(() => validatePath("foo;rm -rf /"), /unsafe characters/)
-  })
-
-  it("rejects paths with backticks", () => {
-    assert.throws(() => validatePath("foo`id`"), /unsafe characters/)
-  })
-
-  it("rejects paths with dollar signs", () => {
-    assert.throws(() => validatePath("foo$PATH"), /unsafe characters/)
-  })
-
-  it("rejects paths with pipe characters", () => {
-    assert.throws(() => validatePath("foo|bar"), /unsafe characters/)
-  })
-})
-
-describe("findSqueezePath", () => {
-  it("returns null when squeeze is not available on PATH", () => {
-    const result = findSqueezePath()
-    // Either null (not on PATH) or a non-empty string (found)
-    assert.ok(result === null || typeof result === "string")
-  })
-})
+import { describe, it } from "node:test"
+import assert from "node:assert"
+import { platformAsset, validatePath, findSqueezePath, ASSETS } from "./squeezeInstaller.js"
+
+describe("platformAsset", () => {
+  it("returns a string or null for current platform", () => {
+    const result = platformAsset()
+    // On a supported platform: string; on unsupported: null
+    assert.ok(result === null || typeof result === "string")
+  })
+
+  it("returns known asset names for mapped platforms", () => {
+    // Verify the ASSETS map has entries for all known platform combos
+    const knownCombos = [
+      { plat: "darwin", arch: "arm64" },
+      { plat: "darwin", arch: "x64" },
+      { plat: "linux", arch: "x64" },
+      { plat: "linux", arch: "arm64" },
+      { plat: "win32", arch: "x64" },
+    ]
+    for (const { plat, arch } of knownCombos) {
+      const key = `${plat}-${arch}`
+      const asset = ASSETS[key]
+      assert.ok(asset, `ASSETS map should have entry for ${key}`)
+      assert.ok(asset.endsWith(".tar.gz") || asset.endsWith(".zip"),
+        `Asset "${asset}" should end with .tar.gz or .zip`)
+    }
+  })
+})
+
+describe("validatePath", () => {
+  it("accepts simple relative paths", () => {
+    assert.doesNotThrow(() => validatePath("foo/bar"))
+  })
+
+  it("accepts absolute POSIX paths", () => {
+    assert.doesNotThrow(() => validatePath("/home/user/.config"))
+  })
+
+  it("accepts absolute Windows paths", () => {
+    assert.doesNotThrow(() => validatePath("C:\\Users\\test"))
+  })
+
+  it("accepts paths with dots and dashes", () => {
+    assert.doesNotThrow(() => validatePath("./dir/file-name.ext"))
+  })
+
+  it("allows .. in paths (shell metacharacter check only, not path traversal)", () => {
+    assert.doesNotThrow(() => validatePath("../evil"))
+  })
+
+  it("rejects paths with semicolons", () => {
+    assert.throws(() => validatePath("foo;rm -rf /"), /unsafe characters/)
+  })
+
+  it("rejects paths with backticks", () => {
+    assert.throws(() => validatePath("foo`id`"), /unsafe characters/)
+  })
+
+  it("rejects paths with dollar signs", () => {
+    assert.throws(() => validatePath("foo$PATH"), /unsafe characters/)
+  })
+
+  it("rejects paths with pipe characters", () => {
+    assert.throws(() => validatePath("foo|bar"), /unsafe characters/)
+  })
+})
+
+describe("findSqueezePath", () => {
+  it("returns null when squeeze is not available on PATH", () => {
+    const result = findSqueezePath()
+    // Either null (not on PATH) or a non-empty string (found)
+    assert.ok(result === null || typeof result === "string")
+  })
+})

package/src/core/version.js

@@ -1,8 +1,8 @@
-import { readFileSync } from "node:fs"
-import { resolve, dirname } from "node:path"
-import { fileURLToPath } from "node:url"
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-export const version = JSON.parse(
-  readFileSync(resolve(__dirname, "../../package.json"), "utf-8")
-).version
+import { readFileSync } from "node:fs"
+import { resolve, dirname } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+export const version = JSON.parse(
+  readFileSync(resolve(__dirname, "../../package.json"), "utf-8")
+).version

package/src/core/versionCheck.js

@@ -1,35 +1,44 @@
-import { execFileSync } from "node:child_process"
-import { confirm, isCancel } from "@clack/prompts"
-
-export function fetchLatestVersion() {
-  try {
-    return execFileSync("npm", ["view", "pluidr", "version"], { stdio: "pipe" })
-      .toString()
-      .trim()
-  } catch {
-    return null
-  }
-}
-
-export async function checkAndPromptUpdate(currentVersion) {
-  process.stdout.write("Checking for updates...   ")
-
-  const latest = fetchLatestVersion()
-  if (!latest) {
-    console.log("⚠ Could not reach npm registry — skipping")
-    return false
-  }
-
-  if (latest === currentVersion) {
-    console.log(`✓ Up to date (${currentVersion})`)
-    return false
-  }
-
-  console.log(`⚠ pluidr ${latest} available  (you have ${currentVersion})`)
-
-  const answer = await confirm({ message: "Update now?", initialValue: true })
-  if (isCancel(answer) || !answer) return false
-
-  execFileSync("npm", ["install", "-g", "pluidr"], { stdio: "inherit" })
-  return true
-}
+import { execFileSync, execSync } from "node:child_process"
+import { confirm, isCancel } from "@clack/prompts"
+
+export function fetchLatestVersion() {
+  try {
+    if (process.platform === "win32") {
+      return execSync("npm view pluidr version", { stdio: "pipe" })
+        .toString()
+        .trim()
+    }
+    return execFileSync("npm", ["view", "pluidr", "version"], { stdio: "pipe" })
+      .toString()
+      .trim()
+  } catch {
+    return null
+  }
+}
+
+export async function checkAndPromptUpdate(currentVersion) {
+  process.stdout.write("Checking for updates...   ")
+
+  const latest = fetchLatestVersion()
+  if (!latest) {
+    console.log("⚠ Could not reach npm registry — skipping")
+    return false
+  }
+
+  if (latest === currentVersion) {
+    console.log(`✓ Up to date (${currentVersion})`)
+    return false
+  }
+
+  console.log(`⚠ pluidr ${latest} available  (you have ${currentVersion})`)
+
+  const answer = await confirm({ message: "Update now?", initialValue: true })
+  if (isCancel(answer) || !answer) return false
+
+  if (process.platform === "win32") {
+    execSync("npm install -g pluidr", { stdio: "inherit" })
+  } else {
+    execFileSync("npm", ["install", "-g", "pluidr"], { stdio: "inherit" })
+  }
+  return true
+}

package/src/core/versionCheck.test.js

@@ -1,6 +1,6 @@
 import { describe, it } from "node:test"
 import assert from "node:assert"
-import { execFileSync } from "node:child_process"
+import { execFileSync, execSync } from "node:child_process"
 import { fetchLatestVersion } from "./versionCheck.js"
 
 describe("fetchLatestVersion", () => {
@@ -14,11 +14,21 @@ describe("fetchLatestVersion", () => {
     // Verify the try/catch in fetchLatestVersion swallows errors
     let caught = null
     try {
-      execFileSync("npm", ["view", "__nonexistent_pkg_xyz_pluidr__", "version"], { stdio: "pipe" })
+      if (process.platform === "win32") {
+        execSync("npm view __nonexistent_pkg_xyz_pluidr__ version", { stdio: "pipe" })
+      } else {
+        execFileSync("npm", ["view", "__nonexistent_pkg_xyz_pluidr__", "version"], { stdio: "pipe" })
+      }
     } catch (err) {
       caught = err
     }
     // npm throws on unknown package — fetchLatestVersion handles this and returns null
     assert.ok(caught instanceof Error, "npm should throw for unknown package")
   })
+
+  it("uses execSync on Windows for npm, plain execFileSync on other platforms", () => {
+    // Confirm the platform guard evaluates correctly
+    const useSync = process.platform === "win32"
+    assert.strictEqual(typeof useSync, "boolean")
+  })
 })