tessl/npm-electron-builder

A complete solution to package and build a ready for distribution Electron app for MacOS, Windows and Linux with auto update support out of the box

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Linux Packaging

Name: tessl/npm-electron-builder
Author: tessl

Linux-specific packaging including AppImage, Snap, Flatpak, and traditional package formats (deb, rpm, tar). Supports multiple architectures and comprehensive desktop integration.

Capabilities

Linux Configuration

Core Linux build configuration with desktop integration and package options.

/**
 * Linux-specific build configuration
 */
interface LinuxConfiguration extends PlatformSpecificBuildOptions {
  /** Target configurations (AppImage, snap, deb, etc.) */
  target?: TargetConfiguration | Array<TargetConfiguration | string> | string | null;
  /** Package maintainer */
  maintainer?: string | null;
  /** Package vendor */
  vendor?: string | null;
  /** Application icon */
  icon?: string | null;
  /** Package category */
  packageCategory?: string | null;
  /** Package description */
  description?: string | null;
  /** Package synopsis (short description) */
  synopsis?: string | null;
  /** Package priority */
  priority?: string | null;
  /** MIME types handled by application */
  mimeTypes?: Array<string> | null;
  /** Desktop entry configuration */
  desktop?: LinuxDesktopFile | null;
  /** Executable name */
  executableName?: string | null;
  /** Package depends */
  depends?: Array<string> | null;
  /** RPM build requires */
  fpm?: Array<string> | null;
  /** Package after install script */
  afterInstall?: string | null;
  /** Package after remove script */
  afterRemove?: string | null;
}

Usage Examples:

import { LinuxConfiguration } from "electron-builder";

const linuxConfig: LinuxConfiguration = {
  target: [
    { target: "AppImage", arch: ["x64"] },
    { target: "deb", arch: ["x64", "arm64"] },
    { target: "rpm", arch: ["x64"] },
    { target: "snap", arch: ["x64"] }
  ],
  icon: "build/icon.png",
  category: "Office",
  maintainer: "My Company <support@company.com>",
  vendor: "My Company",
  description: "My application description",
  synopsis: "Short description for package lists",
  packageCategory: "productivity",
  mimeTypes: ["application/x-myapp", "text/x-myapp"],
  desktop: {
    Name: "My Application",
    Comment: "My application description",
    Keywords: "productivity;office;editor"
  }
};

Desktop File Configuration

Linux desktop entry configuration for application integration.

/**
 * Linux desktop entry configuration
 */
interface LinuxDesktopFile {
  /** Application name */
  Name?: string;
  /** Application comment/description */
  Comment?: string;
  /** Application generic name */
  GenericName?: string;
  /** Application keywords */
  Keywords?: string;
  /** Application categories */
  Categories?: string;
  /** Start in terminal */
  Terminal?: boolean;
  /** Show in application menu */
  NoDisplay?: boolean;
  /** Desktop actions */
  Actions?: string;
  /** Startup notification */
  StartupNotify?: boolean;
  /** Startup WM class */
  StartupWMClass?: string;
  /** Additional desktop entry fields */
  [key: string]: any;
}

AppImage Options

Configuration for AppImage portable application format.

/**
 * AppImage configuration options
 */
interface AppImageOptions {
  /** Application license */
  license?: string | null;
  /** Desktop entry overrides */
  desktop?: LinuxDesktopFile | null;
  /** Application category */
  category?: string | null;
  /** System integration behavior */
  systemIntegration?: "ask" | "doNotAsk";
  /** AppImage synopsis */
  synopsis?: string | null;
  /** AppImage description */
  description?: string | null;
  /** Include system libraries */
  includeSystemLibraries?: boolean;
  /** Additional AppImage args */
  args?: Array<string> | null;
}

Usage Examples:

import { AppImageOptions } from "electron-builder";

const appImageOptions: AppImageOptions = {
  license: "MIT",
  category: "Office",
  systemIntegration: "ask",
  synopsis: "Modern text editor",
  description: "A modern, fast text editor with advanced features",
  desktop: {
    Name: "My Editor",
    Comment: "Advanced text editor",
    Keywords: "editor;text;code",
    Categories: "Development;TextEditor;",
    MimeType: "text/plain;text/x-chdr;text/x-csrc;"
  }
};

const config = {
  linux: {
    target: "AppImage"
  },
  appimage: appImageOptions
};

Snap Package Options

Configuration for Ubuntu Snap packages with confinement and plug/slot system.

/**
 * Snap package configuration
 */
interface SnapOptions {
  /** Build packages required during snap build */
  buildPackages?: Array<string> | null;
  /** Stage packages included in snap */
  stagePackages?: Array<string> | null;
  /** Interface plugs for system access */
  plugs?: Array<string> | PlugDescriptor | null;
  /** Interface slots provided by snap */
  slots?: Array<SlotDescriptor> | null;
  /** Build order dependencies */
  after?: Array<string> | null;
  /** Uses staged kernel modules */
  usesStagedKernel?: boolean;
  /** Build environment variables */
  buildEnvironment?: Array<string> | null;
  /** Snap grade (stability level) */
  grade?: "devel" | "stable" | null;
  /** Snap feature assumptions */
  assumes?: Array<string> | null;
  /** Target architectures */
  architectures?: Array<string> | null;
  /** Snap layout configuration */
  layout?: any;
  /** Snap title */
  title?: string | null;
  /** Auto-start application */
  autoStart?: boolean;
  /** Snap summary */
  summary?: string | null;
  /** Snap description */
  description?: string | null;
  /** Base snap to use */
  base?: string | null;
  /** Confinement level */
  confinement?: "devmode" | "strict" | "classic" | null;
  /** Snap environment */
  environment?: { [key: string]: string } | null;
  /** Snap apps configuration */
  apps?: { [key: string]: any } | null;
}

/**
 * Snap plug descriptor for interface connections
 */
interface PlugDescriptor {
  [plugName: string]: {
    interface?: string;
    [key: string]: any;
  };
}

/**
 * Snap slot descriptor for provided interfaces
 */
interface SlotDescriptor {
  [slotName: string]: {
    interface?: string;
    [key: string]: any;
  };
}

Usage Examples:

import { SnapOptions } from "electron-builder";

const snapOptions: SnapOptions = {
  summary: "Modern text editor",
  description: "A modern, fast text editor with advanced features and Git integration",
  grade: "stable",
  confinement: "strict",
  base: "core22",
  architectures: ["amd64"],
  plugs: [
    "default",
    "home",
    "network",
    "network-bind",
    "removable-media"
  ],
  stagePackages: [
    "libnss3",
    "libxss1",
    "libasound2"
  ],
  buildPackages: [
    "build-essential"
  ],
  environment: {
    TMPDIR: "$XDG_RUNTIME_DIR"
  }
};

const config = {
  linux: {
    target: "snap"
  },
  snap: snapOptions
};

Flatpak Options

Configuration for Flatpak application sandboxing and distribution.

/**
 * Flatpak configuration options
 */
interface FlatpakOptions {
  /** Flatpak runtime */
  runtime?: string | null;
  /** Runtime version */
  runtimeVersion?: string | null;
  /** Base application */
  base?: string | null;
  /** Base version */
  baseVersion?: string | null;
  /** SDK for building */
  sdk?: string | null;
  /** Finish args for permissions */
  finishArgs?: Array<string> | null;
  /** Modules to build */
  modules?: Array<any> | null;
  /** Desktop file name */
  desktop?: string | null;
}

Debian Package Options

Configuration for .deb package creation.

/**
 * Debian package options
 */
interface DebOptions extends CommonLinuxOptions {
  /** Package depends */
  depends?: Array<string> | null;
  /** Package recommends */
  recommends?: Array<string> | null;
  /** Package suggests */
  suggests?: Array<string> | null;
  /** Package conflicts */
  conflicts?: Array<string> | null;
  /** Package provides */
  provides?: Array<string> | null;
  /** Package replaces */
  replaces?: Array<string> | null;
  /** Debian package priority */
  priority?: "required" | "important" | "standard" | "optional" | "extra" | null;
  /** Debian section */
  section?: string | null;
  /** Package compression */
  compression?: "xz" | "gzip" | null;
}

/**
 * Common Linux package options
 */
interface CommonLinuxOptions {
  /** After install script */
  afterInstall?: string | null;
  /** After remove script */
  afterRemove?: string | null;
  /** Before install script */
  beforeInstall?: string | null;
  /** Before remove script */
  beforeRemove?: string | null;
  /** Package depends */
  depends?: Array<string> | null;
}

RPM Package Options

Configuration for .rpm package creation.

/**
 * RPM package options (uses fpm)
 */
interface RpmOptions extends CommonLinuxOptions {
  /** RPM group */
  group?: string | null;
  /** RPM requires */
  requires?: Array<string> | null;
  /** RPM provides */
  provides?: Array<string> | null;
  /** RPM conflicts */
  conflicts?: Array<string> | null;
  /** RPM obsoletes */
  obsoletes?: Array<string> | null;
  /** Compression algorithm */
  compression?: "xz" | "gzip" | "bzip2" | null;
}

Linux Target Specific Options

Configuration for Linux-specific target behaviors.

/**
 * Linux target-specific options
 */
interface LinuxTargetSpecificOptions extends TargetSpecificOptions {
  /** Desktop file template */
  desktop?: LinuxDesktopFile | null;
  /** Package maintainer scripts */
  maintainerScripts?: {
    beforeInstall?: string;
    afterInstall?: string;
    beforeRemove?: string;
    afterRemove?: string;
  };
  /** File permissions */
  filePermissions?: {
    [pattern: string]: string;
  };
}

Usage Examples:

import { DebOptions, LinuxConfiguration } from "electron-builder";

// Comprehensive Debian package configuration
const debOptions: DebOptions = {
  depends: [
    "libgtk-3-0",
    "libnotify4", 
    "libnss3",
    "libxss1",
    "libxtst6",
    "libasound2"
  ],
  recommends: [
    "git"
  ],
  section: "editors",
  priority: "optional",
  afterInstall: "scripts/postinst.sh",
  afterRemove: "scripts/postrm.sh",
  compression: "xz"
};

// Multi-format Linux build
const linuxConfig: LinuxConfiguration = {
  target: [
    { target: "AppImage", arch: ["x64"] },
    { target: "deb", arch: ["x64", "arm64"] },
    { target: "rpm", arch: ["x64"] },
    { target: "tar.gz", arch: ["x64", "arm64"] }
  ],
  category: "Development",
  maintainer: "My Company <support@company.com>",
  desktop: {
    Name: "My Editor",
    Comment: "Advanced code editor",
    Keywords: "editor;development;code",
    Categories: "Development;TextEditor;IDE;",
    MimeType: "text/plain;application/json;text/x-python;",
    StartupNotify: true,
    StartupWMClass: "my-editor"
  }
};

const config = {
  linux: linuxConfig,
  deb: debOptions,
  appimage: {
    systemIntegration: "ask"
  },
  snap: {
    confinement: "strict",
    plugs: ["home", "network", "removable-media"]
  }
};

Linux Packager

Linux-specific packager with desktop integration capabilities.

/**
 * Linux packager with desktop integration
 */
class LinuxPackager extends PlatformPackager {
  /** Create desktop entry file */
  createDesktopEntry(desktop: LinuxDesktopFile): Promise<string>;
  
  /** Install desktop file */
  installDesktopEntry(desktopFile: string): Promise<void>;
  
  /** Package application for Linux */
  pack(outDir: string, arch: Arch, targets: Array<Target>): Promise<any>;
  
  /** Get package dependencies */
  getPackageDependencies(): Promise<Array<string>>;
}

Environment and Build Requirements

Linux builds may require additional system packages:

For AppImage:

fuse (for testing AppImages)
desktop-file-utils

For Snap:

snapcraft (snap build tool)
multipass or lxd (for confined builds)

For Flatpak:

flatpak-builder
Runtime and SDK installations

Usage Examples:

# Install AppImage dependencies
sudo apt install fuse desktop-file-utils

# Install Snap dependencies  
sudo snap install snapcraft --classic

# Install Flatpak dependencies
sudo apt install flatpak-builder
flatpak install flathub org.electronjs.Electron2.BaseApp

Linux packaging provides comprehensive support for modern Linux distribution formats while maintaining compatibility with traditional package management systems and desktop environments.

Install with Tessl CLI