@toothfairyai/tfcode 2.7.0 → 2.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toothfairyai/tfcode",
-  "version": "2.7.0",
+  "version": "2.7.1",
   "bin": {
     "tfcode": "./bin/tfcode.js"
   },
@@ -9,18 +9,18 @@
   },
   "license": "MIT",
   "optionalDependencies": {
-    "@toothfairyai/tfcode-linux-arm64": "2.7.0",
-    "@toothfairyai/tfcode-windows-x64": "2.7.0",
-    "@toothfairyai/tfcode-linux-x64-baseline-musl": "2.7.0",
-    "@toothfairyai/tfcode-darwin-x64-baseline": "2.7.0",
-    "@toothfairyai/tfcode-linux-x64-musl": "2.7.0",
-    "@toothfairyai/tfcode-windows-x64-baseline": "2.7.0",
-    "@toothfairyai/tfcode-linux-arm64-musl": "2.7.0",
-    "@toothfairyai/tfcode-windows-arm64": "2.7.0",
-    "@toothfairyai/tfcode-linux-x64": "2.7.0",
-    "@toothfairyai/tfcode-darwin-x64": "2.7.0",
-    "@toothfairyai/tfcode-linux-x64-baseline": "2.7.0",
-    "@toothfairyai/tfcode-darwin-arm64": "2.7.0"
+    "@toothfairyai/tfcode-linux-arm64": "2.7.1",
+    "@toothfairyai/tfcode-windows-x64": "2.7.1",
+    "@toothfairyai/tfcode-linux-x64-baseline-musl": "2.7.1",
+    "@toothfairyai/tfcode-darwin-x64-baseline": "2.7.1",
+    "@toothfairyai/tfcode-linux-x64-musl": "2.7.1",
+    "@toothfairyai/tfcode-windows-x64-baseline": "2.7.1",
+    "@toothfairyai/tfcode-linux-arm64-musl": "2.7.1",
+    "@toothfairyai/tfcode-windows-arm64": "2.7.1",
+    "@toothfairyai/tfcode-linux-x64": "2.7.1",
+    "@toothfairyai/tfcode-darwin-x64": "2.7.1",
+    "@toothfairyai/tfcode-linux-x64-baseline": "2.7.1",
+    "@toothfairyai/tfcode-darwin-arm64": "2.7.1"
   },
   "engines": {
     "node": ">=18"

package/postinstall.mjs

@@ -9,9 +9,6 @@ import { fileURLToPath } from "url"
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
 
-const GITEA_HOST = process.env.TFCODE_GITEA_HOST || "gitea.toothfairyai.com"
-const GITEA_REPO = process.env.TFCODE_GITEA_REPO || "ToothFairyAI/tf_code"
-
 function detectPlatform() {
   let platform
   switch (os.platform()) {
@@ -72,180 +69,12 @@ function detectPlatform() {
   return { platform, arch, needsBaseline, abi }
 }
 
-async function getVersion() {
-  try {
-    const res = await fetch(`https://${GITEA_HOST}/api/v1/repos/${GITEA_REPO}/releases/latest`)
-    const data = await res.json()
-    return data.tag_name?.replace(/^v/, "") || "1.0.0"
-  } catch {
-    return "1.0.0"
-  }
-}
-
-// Detect the machine architecture of an existing binary. Returns "arm64",
-// "x64", or null when it can't be determined (null => keep existing binary).
-function detectBinaryMachineArch(binaryPath, platform) {
-  try {
-    if (platform === "win32") {
-      const buf = fs.readFileSync(binaryPath)
-      if (buf.length < 0x40) return null
-      const pe = buf.readUInt32LE(0x3c)
-      if (pe + 6 > buf.length) return null
-      const machine = buf.readUInt16LE(pe + 4)
-      if (machine === 0x8664) return "x64"
-      if (machine === 0xaa64) return "arm64"
-      return null
-    }
-    const out = spawnSync("file", [binaryPath], { encoding: "utf8" }).stdout || ""
-    if (/arm64|aarch64/i.test(out)) return "arm64"
-    if (/x86-64|x86_64/i.test(out)) return "x64"
-    return null
-  } catch {
-    return null
-  }
-}
-
-// A missing/unparseable binary is treated as a match so installs never break
-// when detection isn't possible; a real mismatch forces a re-download.
-function binaryArchMatches(binaryPath, expectedArch, platform) {
-  const actual = detectBinaryMachineArch(binaryPath, platform)
-  if (!actual) return true
-  return actual === expectedArch
-}
-
-async function downloadBinary() {
+function targetName() {
   const { platform, arch, needsBaseline, abi } = detectPlatform()
-  const version = await getVersion()
-
-  // Check if binary already exists (included in npm package)
-  const binaryName = platform === "windows" ? "tfcode.exe" : "tfcode"
-  const binDir = path.join(__dirname, "bin")
-  const existingBinary = path.join(binDir, binaryName)
-
-  if (fs.existsSync(existingBinary) && binaryArchMatches(existingBinary, arch, platform)) {
-    console.log(`✓ Binary already exists at ${existingBinary}`)
-    // Still need to copy app dir from platform package if missing
-    const targetAppDir = path.join(binDir, "app")
-    if (!fs.existsSync(path.join(targetAppDir, "dist", "index.html"))) {
-      let target = `tfcode-${platform}-${arch}`
-      if (needsBaseline) target += "-baseline"
-      if (abi) target += `-${abi}`
-      const pkgName = `@toothfairyai/${target}`
-      try {
-        const pkgUrl = import.meta.resolve(`${pkgName}/package.json`)
-        const pkgDir = path.dirname(fileURLToPath(pkgUrl))
-        const srcAppDir = path.join(pkgDir, "bin", "app")
-        if (fs.existsSync(path.join(srcAppDir, "dist", "index.html"))) {
-          fs.cpSync(srcAppDir, targetAppDir, { recursive: true })
-          console.log("✓ Web app copied from platform package")
-        }
-        copyComputerAssets(path.join(pkgDir, "bin"), binDir)
-      } catch (e) {
-        console.log(`! Could not copy web app: ${e.message}`)
-      }
-    }
-    return
-  }
-
-  // Build filename for download
   let target = `tfcode-${platform}-${arch}`
   if (needsBaseline) target += "-baseline"
   if (abi) target += `-${abi}`
-
-  const ext = platform === "linux" ? ".tar.gz" : ".zip"
-  const filename = `${target}${ext}`
-  const url = `https://${GITEA_HOST}/${GITEA_REPO}/releases/download/v${version}/${filename}`
-
-  console.log(`Downloading tfcode v${version} for ${target}...`)
-
-  // Download
-  if (!fs.existsSync(binDir)) fs.mkdirSync(binDir, { recursive: true })
-
-  const tmpDir = path.join(os.tmpdir(), `tfcode-install-${process.pid}`)
-  fs.mkdirSync(tmpDir, { recursive: true })
-  const archivePath = path.join(tmpDir, filename)
-
-  // Use curl to download
-  const curlResult = spawnSync("curl", ["-fsSL", "-o", archivePath, url], { stdio: "inherit" })
-  if (curlResult.status !== 0) {
-    console.error(`Failed to download from ${url}`)
-    console.error("Trying npm package fallback...")
-
-    // Fallback to npm optionalDependencies
-    try {
-      const pkgName = `@toothfairyai/${target}`
-
-      // ESM-compatible module resolution
-      let pkgDir
-      try {
-        const pkgUrl = import.meta.resolve(`${pkgName}/package.json`)
-        const pkgPath = fileURLToPath(pkgUrl)
-        pkgDir = path.dirname(pkgPath)
-      } catch (e) {
-        console.error(`Could not resolve ${pkgName}:`, e.message)
-        throw e
-      }
-
-      const binaryName = platform === "windows" ? "tfcode.exe" : "tfcode"
-      const binaryPath = path.join(pkgDir, "bin", binaryName)
-
-      console.log(`Looking for binary at: ${binaryPath}`)
-
-      if (fs.existsSync(binaryPath)) {
-        console.log(`Found binary at npm package location`)
-        setupBinary(binaryPath, platform)
-        return
-      } else {
-        console.error(`Binary not found at ${binaryPath}`)
-      }
-    } catch (e) {
-      console.error("npm package fallback failed:", e.message)
-    }
-
-    console.error("")
-    console.error("Installation failed. The binary could not be downloaded or found.")
-    console.error("")
-    console.error("Possible solutions:")
-    console.error("  1. If this is a private installation, set TFCODE_GITEA_HOST to an accessible host")
-    console.error("  2. Manually download the binary and place it in the bin/ directory")
-    console.error("  3. Contact ToothFairyAI support for assistance")
-    console.error("")
-    process.exit(1)
-  }
-
-  // Extract
-  console.log("Extracting...")
-  if (platform === "linux") {
-    spawnSync("tar", ["-xzf", archivePath, "-C", tmpDir], { stdio: "inherit" })
-  } else {
-    spawnSync("unzip", ["-q", archivePath, "-d", tmpDir], { stdio: "inherit" })
-  }
-
-  // Move binary
-  const extractedBinary = path.join(tmpDir, "tfcode")
-  const targetBinary = path.join(binDir, binaryName)
-
-  if (fs.existsSync(extractedBinary)) {
-    if (fs.existsSync(targetBinary)) fs.unlinkSync(targetBinary)
-    fs.copyFileSync(extractedBinary, targetBinary)
-    fs.chmodSync(targetBinary, 0o755)
-    console.log(`Installed tfcode to ${targetBinary}`)
-  }
-
-  // Move app directory
-  const extractedAppDir = path.join(tmpDir, "app")
-  const targetAppDir = path.join(binDir, "app")
-  if (fs.existsSync(path.join(extractedAppDir, "dist", "index.html"))) {
-    if (fs.existsSync(targetAppDir)) fs.rmSync(targetAppDir, { recursive: true, force: true })
-    fs.cpSync(extractedAppDir, targetAppDir, { recursive: true })
-    console.log("Installed web app")
-  }
-
-  // Move bundled computer-use helpers (cliclick on macOS, if archived)
-  copyComputerAssets(tmpDir, binDir)
-
-  // Cleanup
-  fs.rmSync(tmpDir, { recursive: true, force: true })
+  return target
 }
 
 // Copy bundled computer-use helper binaries (e.g. cliclick on macOS) from a
@@ -266,35 +95,64 @@ function copyComputerAssets(srcBinDir, dstBinDir) {
   console.log("✓ Computer-use helpers copied from platform package")
 }
 
-function setupBinary(sourcePath, platform) {
-  const binDir = path.join(__dirname, "bin")
+// The binary ships in the platform-specific optionalDependency
+// (@toothfairyai/tfcode-<platform>-<arch>[-baseline][-musl]). Link it into
+// this package's bin/ dir and copy the web app + computer-use helpers.
+function setupFromPlatformPackage() {
+  const { platform } = detectPlatform()
+  const pkgName = `@toothfairyai/${targetName()}`
   const binaryName = platform === "windows" ? "tfcode.exe" : "tfcode"
-  const targetBinary = path.join(binDir, binaryName)
+  const binDir = path.join(__dirname, "bin")
+
+  // ESM-compatible module resolution
+  let pkgDir
+  try {
+    const pkgUrl = import.meta.resolve(`${pkgName}/package.json`)
+    const pkgPath = fileURLToPath(pkgUrl)
+    pkgDir = path.dirname(pkgPath)
+  } catch (e) {
+    console.error(`Could not resolve ${pkgName}: ${e.message}`)
+    console.error("")
+    console.error("The platform package for your machine was not installed.")
+    console.error("")
+    console.error("Possible solutions:")
+    console.error(`  1. Install it explicitly: npm install ${pkgName}`)
+    console.error("  2. Clear the npm cache and reinstall: npm cache clean --force && npm install @toothfairyai/tfcode")
+    console.error("  3. Contact ToothFairyAI support for assistance")
+    console.error("")
+    process.exit(1)
+  }
+
+  const sourceBinary = path.join(pkgDir, "bin", binaryName)
+  if (!fs.existsSync(sourceBinary)) {
+    console.error(`Binary not found at ${sourceBinary}`)
+    process.exit(1)
+  }
 
+  // Link (or copy) the binary into bin/
   if (!fs.existsSync(binDir)) fs.mkdirSync(binDir, { recursive: true })
+  const targetBinary = path.join(binDir, binaryName)
   if (fs.existsSync(targetBinary)) fs.unlinkSync(targetBinary)
-
-  // Try hardlink, fall back to copy
   try {
-    fs.linkSync(sourcePath, targetBinary)
+    fs.linkSync(sourceBinary, targetBinary)
   } catch {
-    fs.copyFileSync(sourcePath, targetBinary)
+    fs.copyFileSync(sourceBinary, targetBinary)
   }
-
   fs.chmodSync(targetBinary, 0o755)
   console.log(`tfcode installed to ${targetBinary}`)
 
-  // Also copy app dir from platform package
-  const sourceDir = path.dirname(sourcePath)
-  const srcAppDir = path.join(sourceDir, "app")
+  // Copy app dir
+  const srcAppDir = path.join(pkgDir, "bin", "app")
   const targetAppDir = path.join(binDir, "app")
   if (fs.existsSync(path.join(srcAppDir, "dist", "index.html"))) {
     if (fs.existsSync(targetAppDir)) fs.rmSync(targetAppDir, { recursive: true, force: true })
     fs.cpSync(srcAppDir, targetAppDir, { recursive: true })
     console.log("Web app copied from platform package")
+  } else {
+    console.log("! Web app not found in platform package")
   }
-  // Also copy bundled computer-use helpers (cliclick on macOS) if present.
-  copyComputerAssets(sourceDir, binDir)
+
+  copyComputerAssets(path.join(pkgDir, "bin"), binDir)
 }
 
 async function main() {
@@ -304,8 +162,8 @@ async function main() {
   console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
   console.log("")
 
-  // Download and setup binary
-  await downloadBinary()
+  // Setup binary from the npm platform package
+  setupFromPlatformPackage()
 
   // Check for Python (needed for TF integration)
   try {