Index of every page on this site: llms.txt
All skills
jimliu avatar

/baoyu-electron-extract

@bf1ff07 official
by Jim Liu 宝玉jimliu/baoyu-skills28k stars
3,011
Run it yourself

Extracts resources and JavaScript from any installed Electron app (`.asar` bundle), restoring original sources from `.js.map` files when available or formatting minified code with Prettier otherwise. Use when user wants to "extract Electron app", "decompile Electron", "get the source code of <app>", "inspect app.asar", "看 Electron 应用源码", "提取 .asar", or asks how a desktop Electron app is built. Skips `node_modules` and supports both macOS and Windows.

Use this Skill: https://skilld.dev/gh/jimliu/baoyu-skills/baoyu-electron-extract

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈123 tokens for metadata: the name and description. ≈1.8k when used: this file.

Description uses 6.0% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈479 characters, or 6.0%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Electron App Extract

User Input Tools

When this skill prompts the user, follow this tool-selection rule (priority order):

  1. Prefer built-in user-input tools exposed by the current agent runtime — e.g., AskUserQuestion, request_user_input, clarify, ask_user, or any equivalent.
  2. Fallback: if no such tool exists, emit a numbered plain-text message and ask the user to reply with the chosen number/answer for each question.
  3. Batching: if the tool supports multiple questions per call, combine all applicable questions into a single call; if only single-question, ask them one at a time in priority order.

Concrete AskUserQuestion references below are examples — substitute the local equivalent in other runtimes.

Script Directory

{baseDir} = this SKILL.md's directory. Resolve ${BUN_X}: bun if installed; else npx -y bun; else suggest installing bun. Replace {baseDir} and ${BUN_X} with actual values.

Script Purpose
scripts/main.ts App discovery + asar extraction + source-map restoration + Prettier formatting

Workflow

1. Determine the input. Accepts an app name (e.g., Codex) or absolute path (/Applications/Codex.app, a .asar file, or a Windows install dir). Ask for it if not given; ask for a custom output directory if they want one.

2. Run the script.

${BUN_X} {baseDir}/scripts/main.ts "<app>" [--output <dir>] [--asar <path>] [--force]

If unsure discovery will find the right bundle, run with --dry-run first (prints resolved paths, writes nothing).

3. Handle the result.

  • Success → report output paths and counts (extracted / restored / formatted).
  • Multiple matches → script lists candidates and exits non-zero. Ask the user which one (via AskUserQuestion or the runtime equivalent), then re-run with the chosen absolute path.
  • Existing non-empty output dir → script refuses without --force. Ask whether to overwrite (--force) or pick a new --output.
  • Unsupported platform / no match → suggest --asar /full/path/to/app.asar if the user knows where the bundle lives.

4. Point the user at the result (default ~/Downloads/<AppName>-electron-extract/):

  • restored/ exists → original source tree reconstructed from .js.map files; read this first.
  • Only extracted/ (no maps) → JS/CSS in extracted/ was Prettier-formatted in place; read from there.

Usage

${BUN_X} {baseDir}/scripts/main.ts Codex                                   # → ~/Downloads/Codex-electron-extract/
${BUN_X} {baseDir}/scripts/main.ts "/Applications/Visual Studio Code.app"  # .app bundle, install dir, or .asar
${BUN_X} {baseDir}/scripts/main.ts "C:\Users\you\AppData\Local\Programs\codex"
${BUN_X} {baseDir}/scripts/main.ts --asar /Applications/Codex.app/Contents/Resources/app.asar Codex
${BUN_X} {baseDir}/scripts/main.ts Codex --output ~/work/codex-source
${BUN_X} {baseDir}/scripts/main.ts Codex --json                            # one JSON line on stdout

Options

Option Short Description Default
<app> App name or absolute path. Required unless --asar is given. —
--output -o Output directory ~/Downloads/<AppName>-electron-extract
--asar Override the resolved .asar path auto-discovered
--force -f Allow writing into a non-empty existing output dir false
--skip-format Skip Prettier formatting false
--skip-restore Skip source-map restoration false
--no-unpacked Don't copy app.asar.unpacked/ alongside false
--dry-run Print resolved paths and exit without writing false
--json Emit one JSON-line summary on stdout (suppresses normal output) false

Output layout

~/Downloads/<AppName>-electron-extract/
├── extract-report.json          # JSON summary: counts, warnings, resolved paths
├── extracted/                   # raw asar contents (JS/CSS Prettier-formatted when no map)
│   └── ...                      # node_modules left untouched (skipped from format)
├── extracted.unpacked/          # copied from <asar>.unpacked/ if present
│   └── ...                      # native modules (.node), large assets
└── restored/                    # only present if at least one .js.map was usable
    └── <original/source/tree>   # rebuilt from sourcesContent in each .js.map

Source-Map Path Restoration

Original source names and directory structure are preserved as far as the map allows:

  • Each sources[] entry resolves with sourceRoot when present, then relative to the .js.map file's directory inside extracted/ — e.g. .vite/main/index.js.map + ../../src/main.ts → restored/src/main.ts.
  • ../ segments are not treated as automatically unsafe: resolve from the map location first, then sanitize the final path so it stays under restored/. A path climbing above extracted/ keeps its readable remainder — .vite/main/index.js.map + ../../../shared/src/lib/foo.ts → restored/shared/src/lib/foo.ts.
  • URL/query decorations are stripped (webpack://, file://, ?loader suffixes).
  • restored/__unknown/<hash>.<ext> only when the source name is empty or can't be reduced to a safe file path.
  • node_modules and webpack/runtime/* entries are skipped (bundler/runtime noise).

Notes

  • node_modules is always skipped, for both source-map restoration and Prettier formatting.
  • Restoration needs embedded sourcesContent (common for webpack, esbuild, Vite, rollup). Maps referencing external files without embedding them are skipped and the .js is Prettier-formatted instead; skipped maps appear in extract-report.json under warnings.
  • App discovery: macOS /Applications + ~/Applications; Windows %LOCALAPPDATA%\Programs, %PROGRAMFILES%, %PROGRAMFILES(X86)%, %APPDATA%. Multiple matches → script exits and lists them; re-run with an absolute path. Linux/other: pass --asar /path/to/app.asar.
  • Safety: refuses to write to /, the user home directly, or the current working directory, and refuses to populate an existing non-empty output dir without --force.
  • No global installs: @electron/asar and prettier resolve on-the-fly via npx -y; first run is slower while npx caches them.

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No alerts18d3 checks · Risk SAFE
  • Gen Agent Trust Hub18d

    This skill extracts resources and source code from Electron applications. It utilizes well-known tools like Prettier and Electron Asar, which it dynamically fetches from the NPM registry if they are not already installed. While the skill implements robust path sanitization to prevent directory traversal attacks, the nature of extracting and inspecting third-party code creates an inherent surface for indirect prompt injection.

  • Socket18d

    No alerts

  • Snyk18d

    Risk: LOW · No issues

Signed by skilld at bf1ff07. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub yesterday.

Activeupdated 3 weeks ago
version
1.119.0
Other metadata
metadata
{
  "openclaw": {
    "homepage": "https://github.com/JimLiu/baoyu-skills#baoyu-electron-extract",
    "requires": {
      "anyBins": [
        "bun",
        "npx"
      ]
    }
  }
}
  • electron
  • asar
  • source-map
  • decompilation
  • reverse-engineering
  • macos
  • windows
  • javascript
  • code-extraction

README badge

README badge for jimliu/baoyu-skills/baoyu-electron-extract

Extracts code and resources from installed Electron apps by unpacking `.asar` bundles and restoring original sources from `.js.map` files or formatting minified code with Prettier. Covers macOS and Windows app discovery; skips `node_modules` and handles both source-mapped and minified codebases.

Generated from the current SKILL.md.

Does this work on Linux?
No. The skill searches `/Applications` and `~/Applications` on macOS, and Windows program directories on Windows. For Linux, you must pass the `--asar` flag with the explicit path to the `.asar` file.
What happens if the app doesn't have source maps?
The extracted JavaScript is formatted with Prettier instead. Source maps are only used when the `.js.map` file embeds `sourcesContent`, which is common in modern bundlers but not guaranteed.
Does this require bun to be installed?
Either bun or npx must be available. If bun is installed, it will be used; otherwise the skill falls back to `npx -y bun`.
Will node_modules be extracted?
node_modules directories are always skipped during extraction and formatting because they are vendored dependencies and not part of the app's source code.
What if the app discovery finds multiple matches?
The script lists all candidates and exits. You then re-run it with the absolute path to the specific app you want to extract.

Generated from the current SKILL.md. These answers refresh after source changes.