add-ipc-surface

Define and implement cross-process IPC surfaces in Electron applications.

27|1|Updated Jan 26, 2026
One-click install
npx skills add https://github.com/hua-bang/pulse-agent --skill add-ipc-surface
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: add-ipc-surface
Source: https://github.com/hua-bang/pulse-agent/tree/main/apps/canvas-workspace/harness/skills/add-ipc-surface
Command: npx skills add https://github.com/hua-bang/pulse-agent --skill add-ipc-surface

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

This Skill unit provides a structured approach to adding or extending cross-process IPC (Inter-Process Communication) surfaces in Electron applications, ensuring consistent communication between different processes and components.

Core Features & Use Cases

  • Contract Definition: Helps define IPC contracts with a clear, JSON-safe data shape specification.
  • API Interface Placement: Guides the placement of API interfaces to avoid common pitfalls and boundary issues.
  • Main and Preload Side Handling: Offers guidance on implementing IPC logic on the main and preload sides.
  • Renderer Interaction: Provides instructions on how the renderer interacts with IPC surfaces.

Quick Start

Run the describe-canvas tool to snapshot the current IPC contract, and follow the steps outlined to implement a new IPC surface for your Electron application.

Frequently Asked Questions about add-ipc-surface

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I define and implement a cross-process IPC surface in Electron?

To implement an Electron IPC surface, you must define a clear contract with a JSON-safe data shape, place API interfaces correctly, and handle logic across main and preload sides. This ensures reliable cross-process communication.

What is the best way to maintain contract parity for Electron IPC?

Maintaining IPC contract parity requires a structured process for defining data shapes and managing logic across main, preload, and renderer sides. This approach ensures consistent communication and prevents boundary issues.

How do I structure main and preload side handling for Electron IPC logic?

Electron IPC logic requires implementing handlers on the main side and exposing safe interfaces on the preload side. Proper placement of these API interfaces avoids common pitfalls and ensures secure renderer interaction.

When do I need to define a JSON-safe data shape for an IPC contract?

You need a JSON-safe data shape for an IPC contract whenever passing complex objects between Electron processes. Defining this shape explicitly maintains contract parity and ensures reliable cross-process serialization.

Does this approach to adding IPC surfaces work with existing Electron applications?

Yes, this approach works with existing Electron applications by snapshotting the current IPC contract. You can then follow the outlined steps to extend or add new IPC surfaces while maintaining secure communication.

Why do common boundary issues occur when placing Electron IPC API interfaces?

Boundary issues occur when API interfaces are misplaced between Electron processes. Following structured guidance for interface placement avoids these pitfalls and ensures the renderer interacts securely with the IPC surface.