transcript/scripts/setup-sidecar.mjs

// Baixa o release `*-shared` oficial do k2-fsa/sherpa-onnx v1.12.23 e extrai
// apenas o binário `sherpa-onnx-offline` para `src-tauri/binaries/sherpa-onnx-offline-<triple><ext>`.
//
// O shared lib já vem com as DLLs/so de `onnxruntime` no diretório `bin/`. Essas
// DLLs adicionais são empacotadas como `resources` do Tauri (ver tauri.conf.json)
// para que o executável as encontre em produção.
//
// Uso:
//   node scripts/setup-sidecar.mjs
//
// Variáveis de ambiente opcionais:
//   SHERPA_ONNX_VERSION  (default: v1.12.23)
//   SHERPA_ONNX_TRIPLE   (default: detectado via `rustc -vV`)

import { execFileSync } from "node:child_process";
import {
  existsSync,
  mkdirSync,
  chmodSync,
  createWriteStream,
  statSync,
  renameSync,
  copyFileSync,
} from "node:fs";
import { dirname, join, resolve, sep as pathSep } from "node:path";
import { pipeline } from "node:stream/promises";
import { fileURLToPath } from "node:url";
import process from "node:process";

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
const repoRoot = resolve(__dirname, "..");
const binariesDir = join(repoRoot, "src-tauri", "binaries");
mkdirSync(binariesDir, { recursive: true });

const DEFAULT_VERSION = "v1.12.23";

const PLATFORM_MAP = [
  { keys: ["linux", "x64"], asset: "sherpa-onnx-v1.12.23-linux-x64-shared.tar.bz2", triple: "x86_64-unknown-linux-gnu", ext: "" },
  { keys: ["linux", "arm64"], asset: "sherpa-onnx-v1.12.23-linux-aarch64-shared.tar.bz2", triple: "aarch64-unknown-linux-gnu", ext: "" },
  { keys: ["darwin", "x64"], asset: "sherpa-onnx-v1.12.23-osx-universal2-shared.tar.bz2", triple: "x86_64-apple-darwin", ext: "" },
  { keys: ["darwin", "arm64"], asset: "sherpa-onnx-v1.12.23-osx-universal2-shared.tar.bz2", triple: "aarch64-apple-darwin", ext: "" },
  { keys: ["win32", "x64"], asset: "sherpa-onnx-v1.12.23-win-x64-shared.tar.bz2", triple: "x86_64-pc-windows-msvc", ext: ".exe" },
];

const RELEASE_BASE = "https://github.com/k2-fsa/sherpa-onnx/releases/download";

function detectTriple() {
  if (process.env.SHERPA_ONNX_TRIPLE) return process.env.SHERPA_ONNX_TRIPLE;
  try {
    const output = execFileSync("rustc", ["-vV"], { encoding: "utf8" });
    const line = output.split("\n").find((l) => l.startsWith("host:"));
    if (line) return line.replace("host:", "").trim();
  } catch {
    // cai para detecção por platform/arch
  }
  const os = process.platform;
  const archName = process.arch;
  return PLATFORM_MAP.find(
    (p) => (p.keys[0] === "win32" ? os === "win32" : p.keys[0] === os) && p.keys[1] === archName,
  )?.triple;
}

function pickAsset(triple) {
  const found = PLATFORM_MAP.find((p) => p.triple === triple);
  if (!found) {
    throw new Error(
      `Não há binário pré-buildado para o target ${triple}. Edite scripts/setup-sidecar.mjs para apontar para um build customizado.`,
    );
  }
  return found;
}

async function download(url, dest) {
  const res = await fetch(url);
  if (!res.ok) {
    throw new Error(`download falhou: ${res.status} ${res.statusText} em ${url}`);
  }
  if (!res.body) {
    throw new Error(`resposta vazia em ${url}`);
  }
  await pipeline(res.body, createWriteStream(dest));
  return statSync(dest).size;
}

function extractTarBzip2(archive, cwd) {
  // `tar` (bsdtar) no Windows não aceita bem paths com backslash nem `D:`
  // em `-C`. Usamos `cwd` + path relativo para evitar isso.
  const prefix = cwd.endsWith(pathSep) ? cwd : cwd + pathSep;
  const relArchive = archive.startsWith(prefix) ? archive.slice(prefix.length) : archive;
  execFileSync("tar", ["-xjf", relArchive], { stdio: "inherit", cwd });
}

function moveExtractedBin(extractedBinDir, expectedNames, dest) {
  for (const name of expectedNames) {
    const candidate = join(extractedBinDir, name);
    if (existsSync(candidate)) {
      renameSync(candidate, dest);
      return;
    }
  }
  throw new Error(
    `binário sherpa-onnx-offline não encontrado em ${extractedBinDir}; nomes esperados: ${expectedNames.join(", ")}`,
  );
}

function copyExtraSharedLibs(extractedRoot, ext) {
  // As DLLs adicionais (onnxruntime, providers_shared) precisam acompanhar o
  // executável em runtime. Copiamos para `src-tauri/binaries/` lado a lado
  // do binário renomeado; o empacotamento final via tauri.conf.json
  // resources cuida de movê-las para junto do .exe no instalador.
  const binDir = join(extractedRoot, "bin");
  if (!existsSync(binDir)) return;
  for (const file of ["onnxruntime.dll", "onnxruntime_providers_shared.dll", "cargs.dll"]) {
    const src = join(binDir, file);
    if (existsSync(src)) {
      const destName = ext === ".exe" ? file : file.replace(/\.dll$/, ".so");
      copyFileSync(src, join(binariesDir, destName));
    }
  }
}

async function main() {
  const triple = detectTriple();
  if (!triple) {
    throw new Error("Não foi possível detectar o target triple do host.");
  }
  const asset = pickAsset(triple);
  const version = process.env.SHERPA_ONNX_VERSION || DEFAULT_VERSION;
  const assetName = asset.asset.replace(/v1\.12\.23/, version);
  const versionNoV = version.replace(/^v/, "");
  const url = `${RELEASE_BASE}/v${versionNoV}/${assetName}`;
  const finalPath = join(binariesDir, `sherpa-onnx-offline-${triple}${asset.ext}`);

  if (existsSync(finalPath) && statSync(finalPath).size > 1024 * 1024) {
    console.log(`✓ sidecar já presente em ${finalPath} (${statSync(finalPath).size} bytes)`);
    return;
  }

  const archivePath = join(binariesDir, assetName);
  console.log(`↓ baixando ${url}`);
  const size = await download(url, archivePath);
  console.log(`✓ ${size} bytes baixados em ${archivePath}`);

  console.log("↓ extraindo…");
  extractTarBzip2(archivePath, binariesDir);

  const extractedRoot = join(binariesDir, assetName.replace(/\.tar\.bz2$/, ""));
  const expected = asset.ext === ".exe" ? ["sherpa-onnx-offline.exe", "sherpa-onnx-offline"] : ["sherpa-onnx-offline"];
  moveExtractedBin(join(extractedRoot, "bin"), expected, finalPath);
  copyExtraSharedLibs(extractedRoot, asset.ext);

  if (asset.ext === "") {
    try {
      chmodSync(finalPath, 0o755);
    } catch {
      // ignore em Windows
    }
  }

  console.log(`✓ sidecar pronto em ${finalPath}`);
}

main().catch((error) => {
  console.error(`falha: ${error.message}`);
  process.exitCode = 1;
});