[Rust] Tauri × sidecarで他言語バイナリを連携する [Node]

% cargo install tauri-cli

% cargo install create-tauri-app --locked

% cargo create-tauri-app sidecar-example
% cd sidecar-example

cargo tauri dev

% mkdir /path/your/node_example
% cd /path/your/node_example
% npm init -y

///path/your/node_example/index.js

const args = process.argv.slice(2);
const inputArg = args.find(arg => arg.startsWith('--input='));

if (inputArg) {
    const input = inputArg.split('=')[1];
    console.log(`Hello, ${input}!`);
} else {
    console.log('Hello from Node.js sidecar!');
}

% npm install pkg --save

{
  ・・・・
  "scripts": {
    "build": "pkg . --targets node18-macos-arm64,node18-macos-x64,node18-linux-x64,node18-win-x64 --output dist/node-sidecar"
  },
  "pkg": {
    "assets": [],
    "targets": [
      "node18-macos-arm64",
      "node18-macos-x64",
      "node18-linux-x64",
      "node18-win-x64"
    ],
    "outputPath": "dist"
  },

  ・・・・
}

% npm run build

・・・

% ls node-example/dist/
node-sidecar-linux-x64	
node-sidecar-macos-arm64  
node-sidecar-macos-x64  
node-sidecar-win-x64.exe

node-sidecar-aarch64-apple-darwin

% rustc -vV
・・・
host: aarch64-apple-darwin
・・・

#tauri側にbinariesディレクトリ作成
% mkdir -p /path/your/sidecar-example/src-tauri/binaries

% cd /path/your/node_example

# nodeバイナリをtauriアプリにコピー
% cp dist/node-sidecar-macos-arm64 /path/your/sidecar-example/src-tauri/binaries/node-sidecar-aarch64-apple-darwin

{
  ・・・
  "bundle": {
    "active": true,
    "targets": "all",
    "icon": [
      ・・・
    ],
    "externalBin": [
      "binaries/node-sidecar"
    ]
  }
}

//sidecar-example/src/main.js
const { invoke } = window.__TAURI__.core;
const { Command } = window.__TAURI__.shell;
const { listen } = window.__TAURI__.event;

let greetInputEl;
let sidecarOutputEl;

// サイドカーのイベントをListen
async function setupSidecarListeners() {
  // 標準出力のイベントをリッスン
  await listen('sidecar-output', (event) => {
    console.log('Received sidecar output:', event.payload);
    if (sidecarOutputEl) {
      sidecarOutputEl.textContent = event.payload;
    }
  });

  // エラー出力のイベントをリッスン
  await listen('sidecar-error', (event) => {
    console.error('Received sidecar error:', event.payload);
    if (sidecarOutputEl) {
      sidecarOutputEl.textContent = `Error: ${event.payload}`;
    }
  });

  // プロセス終了のイベントをリッスン
  await listen('sidecar-terminated', (event) => {
    console.log('Sidecar terminated:', event.payload);
  });
}

async function greet() {
  const name = greetInputEl.value;
  console.log('Running sidecar with name:', name);

  try {
    // サイドカーを実行
    await invoke("run_sidecar", { input: name });
  } catch (error) {
    console.error('Error running sidecar:', error);
  }
}

window.addEventListener("DOMContentLoaded", async () => {
  console.log('DOM Content Loaded');

  greetInputEl = document.querySelector("#greet-input");
  sidecarOutputEl = document.querySelector("#sidecar-output");

  // サイドカーのイベントリスナーをセットアップ
  await setupSidecarListeners();

  document.querySelector("#greet-form").addEventListener("submit", (e) => {
    e.preventDefault();
    console.log('Form submitted');
    greet();
  });
});

use tauri_plugin_shell::ShellExt;
use tauri_plugin_shell::process::CommandEvent;
use tauri::Emitter;

・・・

// サイドカーを実行する関数
#[tauri::command]
async fn run_sidecar(app: tauri::AppHandle, window: tauri::Window, input: Option<String>) -> Result<(), String> {
    println!("Starting sidecar execution...");

    // サイドカーコマンドを取得（ファイル名のみを指定）
    let sidecar_command = match app.shell().sidecar("node-sidecar") {
      ・・・
    };

    // 引数を設定
    let mut args = vec!["--app=tauri-app".to_string()];

    // 入力引数を準備
    if let Some(input_data) = input {
        println!("Adding input argument: {}", input_data);
        args.push(format!("--input={}", input_data));
    }

    println!("Executing sidecar with args: {:?}", args);

    // サイドカーを実行し、出力を取得
    let (mut rx, _child) = sidecar_command
        .args(args)
        .spawn()
        .map_err(|e| e.to_string())?;

    println!("Sidecar process started");

    // 非同期タスクとして実行
    tauri::async_runtime::spawn(async move {
        while let Some(event) = rx.recv().await {
            match event {
                CommandEvent::Stdout(line) => {
                    let line_str = String::from_utf8_lossy(&line);
                    window.emit("sidecar-output", Some(line_str.to_string()))
                        .expect("failed to emit event");
                }
                ・・・・
                CommandEvent::Terminated(status) => {
                    println!("Process terminated with status: {:?}", status);
                    window.emit("sidecar-terminated", Some(format!("{:?}", status)))
                        .expect("failed to emit event");
                    break;
                }
                _ => {}
            }
        }
    });

    Ok(())
}

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_shell::init())
        .plugin(tauri_plugin_opener::init())
        .invoke_handler(tauri::generate_handler![greet, run_sidecar])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}