Skip to content
Tauri 中文网
指南 手册 博客 Nodejs.cn

Node.js 作为 sidecar

在本指南中，我们将把一个 Node.js 应用打包成一个自包含的二进制文件，以便在 Tauri 应用中用作 sidecar，而无需终端用户安装 Node.js。本示例教程仅适用于桌面操作系统。

¥In this guide we are going to package a Node.js application to a self contained binary to be used as a sidecar in a Tauri application without requiring the end user to have a Node.js installation. This example tutorial is applicable for desktop operating systems only.

我们建议先阅读通用 sidecar 指南，以更深入地了解 Tauri sidecar 的工作原理。

¥We recommend reading the general sidecar guide first for a deeper understanding of how Tauri sidecars work.

目标

Section titled “目标”

¥Goals

  • 将 Node.js 应用打包为二进制文件。

    ¥Package a Node.js application as a binary.

  • 将此二进制文件集成为 Tauri sidecar。

    ¥Integrate this binary as a Tauri sidecar.

实现细节

Section titled “实现细节”

¥Implementation Details

  • 为此，我们使用 pkg 工具，但任何其他可以将 JavaScript 或 Typescript 编译为二进制应用的工具都可以使用。

    ¥For this we use the pkg tool, but any other tool that can compile JavaScript or Typescript into a binary application will work.

  • 你也可以将 Node 运行时本身嵌入到你的 Tauri 应用中，并将打包的 JavaScript 作为资源发送，但这会将 JavaScript 内容发送为可读文件，并且运行时通常比 pkg 打包的应用更大。

    ¥You can also embed the Node runtime itself into your Tauri application and ship bundled JavaScript as a resource, but this will ship the JavaScript content as readable-ish files and the runtime is usually larger than a pkg packaged application.

在此示例中，我们将创建一个 Node.js 应用，该应用从命令行 process.argv 读取输入并使用 console.log 将输出写入 stdout。
你可以利用其他进程间通信系统，例如本地服务器、stdin/stdout 或本地套接字。请注意，每个都有自己的优点、缺点和安全问题。

¥In this example we will create a Node.js application that reads input from the command line process.argv and writes output to stdout using console.log.
You can leverage alternative inter-process communication systems such as a localhost server, stdin/stdout or local sockets. Note that each has their own advantages, drawbacks and security concerns.

先决条件

Section titled “先决条件”

¥Prerequisites

使用 shell 插件设置的现有 Tauri 应用，可在本地为你编译和运行。

¥An existing Tauri application set up with the shell plugin, that compiles and runs for you locally.

:::note 注意

请首先按照 shell 插件指南 正确设置和初始化插件。如果插件未初始化和配置，示例将无法运行。

¥Please follow the shell plugin guide first to set up and initialize the plugin correctly. Without the plugin being initialized and configured the example won’t work.

:::

指南

Section titled “指南”

¥Guide

  1. Section titled “Initialize Sidecar Project”

    Let’s create a new Node.js project to contain our sidecar implementation. Create a new directory in your Tauri application root folder (in this example we will call it sidecar-app) and run the init command of your preferred Node.js package manager inside the directory:

    npm init

    We will compile our Node.js application to a self container binary using pkg among other options. Let’s install it as a development dependency into the new sidecar-app:

    npm add @yao-pkg/pkg --save-dev
  2. Write Sidecar Logic
    Section titled “Write Sidecar Logic”

    Now we can start writing JavaScript code that will be executed by our Tauri application.

    In this example we will process a command from the command line argmuents and write output to stdout, which means our process will be short lived and only handle a single command at a time. If your application must be long lived, consider using alternative inter-process communication systems.

    Let’s create a index.js file in our sidecar-app directory and write a basic Node.js app:

    sidecar-app/index.js
    const command = process.argv[2];
    

    switch (command) {
      case 'hello':
        const message = process.argv[3];
        console.log(`Hello ${message}!`);
        break;
      default:
        console.error(`unknown command ${command}`);
        process.exit(1);
    }
  3. Section titled “Package the Sidecar”

    To package our Node.js application into a self contained binary, create a script in package.json:

    sidecar-app/package.json
    {
      "scripts": {
        "build": "pkg index.ts --output my-sidecar"
      }
    }
    npm run build

    This will create the sidecar-app/my-sidecar binary on Linux and macOS, and a sidecar-app/my-sidecar.exe executable on Windows.

    For sidecar applications, we need to ensure that the binary is named in the correct pattern, for more information read Embedding External Binaries To rename this file to the expected Tauri sidecar filename and also move to our Tauri project, we can use the following Node.js script as a starting example:

    sidecar-app/rename.js
    import { execSync } from 'child_process';
    import fs from 'fs';
    

    const ext = process.platform === 'win32' ? '.exe' : '';
    

    const rustInfo = execSync('rustc -vV');
    const targetTriple = /host: (\S+)/g.exec(rustInfo)[1];
    if (!targetTriple) {
      console.error('Failed to determine platform target triple');
    }
    // TODO: create `src-tauri/binaries` dir
    fs.renameSync(
      `my-sidecar${ext}`,
      `../src-tauri/binaries/my-sidecar-${targetTriple}${ext}`
    );

    And run node rename.js from the sidecar-app directory.

    At this step the /src-tauri/binaries directory should contain the renamed sidecar binary.

  4. Setup plugin-shell permission
    Section titled “Setup plugin-shell permission”

    After installing the shell plugin make sure you configure the required capabilities.

    Note that we use "args": true but you can optionally provide an array ["hello"], read more.

    src-tauri/capabilities/default.json
    {
      "permissions": [
        "core:default",
        "opener:default",
        {
          "identifier": "shell:allow-execute",
          "allow": [
            {
              "args": true,
              "name": "binaries/my-sidecar",
              "sidecar": true
            }
          ]
        }
      ]
    }
  5. Configure the Sidecar in the Tauri Application
    Section titled “Configure the Sidecar in the Tauri Application”

    Now that we have our Node.js application ready, we can connect it to our Tauri application by configuring the bundle > externalBin array:

    src-tauri/tauri.conf.json
    {
      "bundle": {
        "externalBin": ["binaries/my-sidecar"]
      }
    }

    The Tauri CLI will handle the bundling of the sidecar binary as long as it exists as src-tauri/binaries/my-sidecar-<target-triple>.

  6. Section titled “Execute the Sidecar”

    We can run the sidecar binary either from Rust code or directly from JavaScript.

    Let’s execute the hello command in the Node.js sidecar directly:

    import { Command } from '@tauri-apps/plugin-shell';
    

    const message = 'Tauri';
    

    const command = Command.sidecar('binaries/my-sidecar', ['hello', message]);
    const output = await command.execute();
    // once everything is configured it should log "Hello Tauri" in the browser console.
    console.log(output.stdout)
  7. Section titled “Running”

    Lets test it

    npm run tauri dev

    Open the DevTools with F12 (or Cmd+Option+I on macOS) and you should see the output of the sidecar command.

    If you find any issues, please open an issue on GitHub.

Tauri v2.9 中文网 - 粤ICP备13048890号
Nodejs.cn 旗下网站