Skip to main content
electron-protocol-handler-setup Register and handle custom URL protocols (deep linking) across platforms for Electron applications
Ir a la instalación Skills Marketplace Descubre y explora habilidades de IA creadas por la comunidad.
Instalar con Codex o Claude Copia este prompt, pégalo en Codex, Claude u otro asistente, y deja que revise la página de la skill y la instale por ti.
Mostrar detalles del prompt Un comando directo omite el prompt de revisión. Revisa el origen antes de ejecutarlo.
npx skills add https://github.com/a5c-ai/babysitter --skill electron-protocol-handler-setupEl comando permanece en una sola línea. Desplázate horizontalmente para revisarlo antes de copiarlo.
¿Prefieres una copia local? Descarga los archivos que SkillsMP tiene disponibles ahora.
Descargar Zip Descargando... Ocupaciones relacionadas SOC
Basado en la clasificación ocupacional SOC
Reference for querying the Atlas knowledge graph through its MCP tools — the SECONDARY enrichment/comparison layer that adds best-practice context to systems you have ALREADY scanned from your real sources (`az`, repos, dirs). Use when you need to look up nodes, edges, kinds, clusters, stats, or wiki pages in Atlas to compare against your real inventory. (atlas graph, query atlas, atlas mcp, search the graph, graph neighbors, atlas record, atlas kinds, enrichment layer)
Atlas turns your STATED NEED into a real systems atlas by SCANNING your actual sources (Azure via `az`, git repos, local dirs) and process/data mining them, THEN enriching against the Atlas knowledge graph. Use this skill when asked to inventory/map your real systems, scan your cloud + repos + directories, mine the real processes or data they contain, or collect their real constraints/gotchas. (atlas, scan my systems, inventory our azure account, map my repos, real systems atlas, process mining, data mining, collect nuances, system discovery)
assimilate-popular-workflows This skill should be used when the user asks to "find skills in the wild", "assimilate popular workflows", "discover SKILL.md files in repos", "research external skills", "find workflow patterns", "survey the skill landscape", "what skills exist out there", or wants to investigate public repositories for extractable processes, babysitter plugins, and reusable procedural insights. Searches GitHub for SKILL.md files, classifies repos by archetype, and maintains structured research under docs/reference-repos/.
Explorador de archivos
2 archivos name electron-protocol-handler-setup description Register and handle custom URL protocols (deep linking) across platforms for Electron applications allowed-tools Read, Write, Edit, Bash, Glob, Grep tags ["electron","deep-linking","protocol-handler","url-scheme","desktop"] graph {"domains":["domain:software-engineering"],"specializations":["specialization:desktop-development"],"skillAreas":["skill-area:desktop-ui-frameworks","skill-area:cross-platform-desktop","skill-area:protocol-design"],"roles":["role:desktop-developer","role:fullstack-engineer"],"workflows":["workflow:feature-development","workflow:release-management"]}
electron-protocol-handler-setup
Register and handle custom URL protocols (deep linking) for Electron applications across Windows, macOS, and Linux. This skill enables apps to respond to custom URL schemes like myapp:// for deep linking and inter-application communication.
Capabilities
Register custom protocol handlers at OS level
Handle protocol URLs in running application
Configure electron-builder for protocol registration
Implement secure URL parsing and validation
Handle protocol activation on app launch
Support single-instance enforcement with protocol handling
Generate platform-specific registration scripts
Test protocol handling in development
Input Schema {
"type" : "object" ,
"properties" : {
"projectPath" : {
"type" : "string" ,
"description" : "Path to the Electron project root"
} ,
"protocols" : {
"type" : "array" ,
"items" : {
"type" : "object" ,
"properties" : {
"scheme" : { "type" : "string" , "description" : "Protocol scheme (e.g., 'myapp')" } ,
"name" : { "type" : "string" , "description" : "Human-readable name" } ,
"role" : { "enum" : [ "Viewer" , "Editor" , "Shell" , "None" ] , "default" : "Viewer" }
} ,
"required" : [ "scheme" , "name" ]
}
} ,
"singleInstance" : {
"type" : "boolean" ,
"description" : "Enforce single instance with protocol relay" ,
"default" : true } ,
"securityOptions" : {
"type" : "object" ,
"properties" : {
"validateUrls" : { "type" : "boolean" , "default" : true } ,
"allowedHosts" : { "type" : "array" , "items" : { "type" : "string" } } ,
"sanitizeParams" : { "type" : "boolean" , "default" : true }
}
} ,
"targetPlatforms" : {
"type" : "array" ,
"items" : { "enum" : [ "win32" , "darwin" , "linux" ] }
}
} ,
"required" : [ "projectPath" , "protocols" ]
}
Output Schema {
"type" : "object" ,
"properties" : {
"success" : { "type" : "boolean" } ,
"files" : {
"type" : "array" ,
"items" : {
"type" : "object" ,
"properties" : {
"path" : { "type" : "string" } ,
"description" : { "type" : "string" }
}
}
} ,
"configuration" : {
"type" : "object" ,
"properties" : {
"electronBuilder" : { "type" : "object" } ,
"packageJson" : { "type" : "object" }
}
} ,
"testUrls" : {
"type" : "array" ,
"items" : { "type" : "string" }
}
} ,
"required" : [ "success" ]
}
Platform Registration
macOS (Info.plist) <key > CFBundleURLTypes</key >
<array >
<dict >
<key > CFBundleURLName</key >
<string > My App Protocol</string >
<key > CFBundleURLSchemes</key >
<array >
<string > myapp</string >
</array >
</dict >
</array >
Windows (Registry)
nsis:
perMachine: true : "installer.nsh"
; installer.nsh
!macro customInstall
WriteRegStr HKCU "Software\Classes\myapp" "" "URL:My App Protocol"
WriteRegStr HKCU "Software\Classes\myapp" "URL Protocol" ""
WriteRegStr HKCU "Software\Classes\myapp\shell\open\command" "" '"$INSTDIR\MyApp.exe" "%1"'
!macroend
Linux (Desktop Entry) [Desktop Entry]
Name =My App
Exec =/opt/myapp/myapp %u
Type =Application
MimeType =x-scheme-handler/myapp
Implementation
Protocol Handler Class
const { app, shell } = require ('electron' );
const url = require ('url' );
class ProtocolHandler {
constructor (mainWindow, options = {} ) {
this .mainWindow = mainWindow;
this .scheme = options.scheme || 'myapp' ;
this .allowedHosts = options.allowedHosts || [];
this .handlers = new Map ();
}
register (if (process.defaultApp ) {
app.setAsDefaultProtocolClient (this .scheme , process.execPath , [
path.resolve (process.argv [1 ])
]);
} else {
app.setAsDefaultProtocolClient (this .scheme );
}
}
unregister (removeAsDefaultProtocolClient (this .scheme );
}
handleUrl (protocolUrl ) {
if (!this .validateUrl (protocolUrl)) {
console .error ('Invalid protocol URL:' , protocolUrl);
return ;
}
const parsed = url.parse (protocolUrl, true );
const route = parsed.host || parsed.pathname ?.slice (2 );
const params = parsed.query ;
const handler = this .handlers .get (route);
if (handler) {
handler (params, parsed);
} else {
console .warn ('No handler for route:' , route);
}
if (this .mainWindow ) {
if (this .mainWindow .isMinimized ()) {
this .mainWindow .restore ();
}
this .mainWindow .focus ();
}
}
validateUrl (protocolUrl ) {
try {
const parsed = url.parse (protocolUrl);
if (parsed.protocol !== `${this .scheme} :` ) {
return false ;
}
if (this .allowedHosts .length > 0 && parsed.host ) {
if (!this .allowedHosts .includes (parsed.host )) {
return false ;
}
}
return true ;
} catch {
return false ;
}
}
on (route, handler ) {
this .handlers .set (route, handler);
}
}
module .exports = ProtocolHandler ;
Main Process Integration
const { app } = require ('electron' );
const ProtocolHandler = require ('./protocol-handler' );
const gotTheLock = app.requestSingleInstanceLock ();
if (!gotTheLock) {
app.quit ();
} else {
let mainWindow;
let protocolHandler;
app.on ('second-instance' , (event, commandLine ) => {
const url = commandLine.find (arg =>startsWith ('myapp://' ));
if (url) {
protocolHandler.handleUrl (url);
}
if (mainWindow) {
if (mainWindow.isMinimized ()) mainWindow.restore ();
mainWindow.focus ();
}
});
app.on ('open-url' , (event, url ) => {
event.preventDefault ();
if (protocolHandler) {
protocolHandler.handleUrl (url);
}
});
app.whenReady ().then (() => {
mainWindow = createWindow ();
protocolHandler = new ProtocolHandler (mainWindow, {
scheme : 'myapp' ,
allowedHosts : ['open' , 'auth' , 'share' ]
});
protocolHandler.register ();
protocolHandler.on ('open' , (params ) => {
mainWindow.webContents .send ('protocol:open' , params);
});
protocolHandler.on ('auth' , (params ) => {
handleOAuthCallback (params);
});
const launchUrl = process.argv .find (arg =>startsWith ('myapp://' ));
if (launchUrl) {
protocolHandler.handleUrl (launchUrl);
}
});
}
electron-builder Configuration
protocols:
- name: "My App Protocol"
schemes:
- myapp
role: Viewer
mac:
extendInfo:
CFBundleURLTypes:
- CFBundleURLName: "My App Protocol"
CFBundleURLSchemes:
- myapp
linux:
mimeTypes:
- x-scheme-handler/myapp
desktop:
MimeType: "x-scheme-handler/myapp;"
Security Considerations
Validate all URLs : Never trust protocol URL contentWhitelist routes : Only handle known routesSanitize parameters : Clean query parameters before useAvoid code execution : Never eval protocol URL contentLog suspicious URLs : Track invalid protocol attempts
validateParams (params ) {
const sanitized = {};
const allowedParams = ['id' , 'action' , 'token' ];
for (const [key, value] of Object .entries (params)) {
if (allowedParams.includes (key)) {
sanitized[key] = String (value).slice (0 , 1000 );
}
}
return sanitized;
}
Testing
open "myapp://open?file=test.txt"
start "" "myapp://open?file=test.txt"
xdg-open "myapp://open?file=test.txt"
Related Skills
electron-ipc-security-audit - Secure protocol handlinginter-app-communication process - IPC patternselectron-builder-config - Package protocol handlers
Related Agents
electron-architect - Architecture guidancedesktop-security-auditor - Security review 