pluidr 0.7.6 → 0.8.1

package/src/core/squeezeInstaller.js

@@ -1,158 +1,158 @@
-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,79 +1,79 @@
-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 spaces", () => {
-    assert.doesNotThrow(() => validatePath("C:\\Users\\John Doe\\.config"))
-  })
-
-  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 spaces", () => {
+    assert.doesNotThrow(() => validatePath("C:\\Users\\John Doe\\.config"))
+  })
+
+  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/themeWriter.js

@@ -1,12 +1,26 @@
-import { mkdirSync, copyFileSync } from "node:fs"
+import { mkdirSync, cpSync, existsSync, readdirSync, unlinkSync } from "node:fs"
 import { resolve } from "node:path"
 import { getThemesDir } from "./paths.js"
 
 export function writeThemes(templatesDir, destDir) {
-  const sourcePath = resolve(templatesDir, "themes", "pluidr-contrast.json")
+  const sourcePath = resolve(templatesDir, "themes")
   const targetDir = destDir || getThemesDir()
-  const destPath = resolve(targetDir, "pluidr-contrast.json")
+
+  // Clear any existing .json files in targetDir to prevent stale themes
+  if (existsSync(targetDir)) {
+    try {
+      for (const file of readdirSync(targetDir)) {
+        if (file.endsWith(".json")) {
+          unlinkSync(resolve(targetDir, file))
+        }
+      }
+    } catch {
+      // Ignore
+    }
+  }
 
   mkdirSync(targetDir, { recursive: true })
-  copyFileSync(sourcePath, destPath)
+  if (existsSync(sourcePath)) {
+    cpSync(sourcePath, targetDir, { recursive: true })
+  }
 }

package/src/core/themeWriter.test.js

@@ -16,11 +16,11 @@ describe("themeWriter", () => {
     const tmpSrcDir = mkdtempSync(join(tmpdir(), "pluidr-theme-src-"))
     const srcThemesDir = join(tmpSrcDir, "themes")
     mkdirSync(srcThemesDir, { recursive: true })
-    writeFileSync(join(srcThemesDir, "pluidr-contrast.json"), "mock-theme-content", "utf-8")
+    writeFileSync(join(srcThemesDir, "pluidr-dark.json"), "mock-theme-content", "utf-8")
 
     writeThemes(tmpSrcDir, destDir)
 
-    const destPath = join(destDir, "pluidr-contrast.json")
+    const destPath = join(destDir, "pluidr-dark.json")
     assert.ok(existsSync(destPath), "theme file should be copied")
     assert.strictEqual(readFileSync(destPath, "utf-8"), "mock-theme-content")
 

package/src/core/tuiConfigWriter.js

@@ -1,7 +1,8 @@
 import { readFileSync, writeFileSync, existsSync } from "node:fs"
-import { getTuiConfigPath } from "./paths.js"
+import { join } from "node:path"
+import { getTuiConfigPath, getConfigDir } from "./paths.js"
 
-export function writeTuiConfig(themeName, customPath) {
+export function writeTuiConfig(themeName, customPath, animationName) {
   const path = customPath || getTuiConfigPath()
   let config = {
     "$schema": "https://opencode.ai/tui.json"
@@ -16,7 +17,25 @@ export function writeTuiConfig(themeName, customPath) {
     }
   }
 
-  config.theme = themeName
+  if (themeName) config.theme = themeName
+  // Ensure animation is never in tui.json to prevent OpenCode validation failure
+  delete config.animation
 
   writeFileSync(path, JSON.stringify(config, null, 2), "utf-8")
+
+  // Write animation to pluidr.json instead
+  if (animationName) {
+    const configDir = customPath ? join(customPath, "..") : getConfigDir()
+    const pluidrPath = join(configDir, "pluidr.json")
+    let pluidrConfig = {}
+    if (existsSync(pluidrPath)) {
+      try {
+        pluidrConfig = JSON.parse(readFileSync(pluidrPath, "utf-8"))
+      } catch {
+        // Ignore
+      }
+    }
+    pluidrConfig.animation = animationName
+    writeFileSync(pluidrPath, JSON.stringify(pluidrConfig, null, 2), "utf-8")
+  }
 }

package/src/core/tuiConfigWriter.test.js

@@ -13,13 +13,19 @@ describe("tuiConfigWriter", () => {
     if (existsSync(destDir)) rmSync(destDir, { recursive: true })
   })
 
-  it("writes new tui.json with theme name if it does not exist", () => {
-    writeTuiConfig("pluidr-contrast", tuiPath)
+  it("writes new tui.json with theme name if it does not exist, and animation to pluidr.json", () => {
+    writeTuiConfig("pluidr-dark", tuiPath, "wave")
 
     assert.ok(existsSync(tuiPath))
     const parsed = JSON.parse(readFileSync(tuiPath, "utf-8"))
-    assert.strictEqual(parsed.theme, "pluidr-contrast")
+    assert.strictEqual(parsed.theme, "pluidr-dark")
+    assert.strictEqual(parsed.animation, undefined) // should not exist in tui.json
     assert.strictEqual(parsed["$schema"], "https://opencode.ai/tui.json")
+
+    const pluidrPath = join(destDir, "pluidr.json")
+    assert.ok(existsSync(pluidrPath))
+    const pluidrConfig = JSON.parse(readFileSync(pluidrPath, "utf-8"))
+    assert.strictEqual(pluidrConfig.animation, "wave")
   })
 
   it("updates existing tui.json theme name while preserving other fields", () => {
@@ -29,10 +35,10 @@ describe("tuiConfigWriter", () => {
       "font": "monolisa"
     }, null, 2), "utf-8")
 
-    writeTuiConfig("pluidr-contrast", tuiPath)
+    writeTuiConfig("pluidr-dark", tuiPath)
 
     const parsed = JSON.parse(readFileSync(tuiPath, "utf-8"))
-    assert.strictEqual(parsed.theme, "pluidr-contrast")
+    assert.strictEqual(parsed.theme, "pluidr-dark")
     assert.strictEqual(parsed.font, "monolisa")
   })
 })

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