pal-explorer-cli 0.4.0

package/extensions/@palexplorer/discovery/extension.json

@@ -0,0 +1,16 @@
+{
+  "name": "discovery",
+  "version": "1.0.0",
+  "description": "Discover servers via DHT — adds @handles, online presence, and server-assisted peer finding",
+  "author": "Palexplorer Team",
+  "license": "MIT",
+  "main": "index.js",
+  "hooks": ["on:app:ready"],
+  "permissions": ["config:read", "config:write", "identity:read"],
+  "config": {
+    "refreshInterval": { "type": "number", "default": 1800000, "description": "Server list refresh interval in ms (default: 30 min)" },
+    "enableGossip": { "type": "boolean", "default": true, "description": "Exchange server lists with connected peers" }
+  },
+  "pro": false,
+  "minAppVersion": "0.4.0"
+}

package/extensions/@palexplorer/discovery/index.js

@@ -0,0 +1,111 @@
+import crypto from 'crypto';
+import sodium from 'sodium-native';
+
+// Well-known Ed25519 public key for verifying the server list.
+// The server list is published to DHT (BEP44 mutable) signed with the corresponding private key.
+// This is the ONLY constant — no hardcoded server URLs.
+const SERVER_LIST_PUBLIC_KEY = '39832cac9958f83e15c31d2c93ae2fd7338417bd74aa8e7bb0dbe3c45e857560';
+const SERVER_LIST_SALT = 'pal:servers';
+
+let ctx = null;
+let refreshTimer = null;
+let dhtInstance = null;
+
+export async function activate(context) {
+  ctx = context;
+
+  const firstRun = !ctx.config.get('initialized');
+  if (firstRun) {
+    ctx.config.set('initialized', true);
+    ctx.logger.info('Discovery extension enabled. Fetching server list from DHT...');
+  }
+
+  await fetchServerList();
+
+  const interval = ctx.config.get('refreshInterval') || 1800000;
+  refreshTimer = setInterval(() => fetchServerList(), interval);
+}
+
+export function deactivate() {
+  if (refreshTimer) {
+    clearInterval(refreshTimer);
+    refreshTimer = null;
+  }
+  if (dhtInstance) {
+    try { dhtInstance.destroy(); } catch {}
+    dhtInstance = null;
+  }
+}
+
+async function getDHT() {
+  if (dhtInstance) return dhtInstance;
+  const { DHTDiscovery } = await import('../../../lib/core/dhtDiscovery.js');
+  dhtInstance = new DHTDiscovery();
+  await dhtInstance.ready;
+  return dhtInstance;
+}
+
+async function fetchServerList() {
+  try {
+    const dht = await getDHT();
+    const pk = Buffer.from(SERVER_LIST_PUBLIC_KEY, 'hex');
+    const salt = Buffer.from(SERVER_LIST_SALT);
+    const target = crypto.createHash('sha1').update(Buffer.concat([pk, salt])).digest();
+
+    const result = await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => resolve(null), 15000);
+      dht.dht.get(target, (err, res) => {
+        clearTimeout(timeout);
+        if (err) return resolve(null);
+        resolve(res);
+      });
+    });
+
+    if (!result || !result.v) {
+      ctx.logger.warn('No server list found in DHT (not published yet?)');
+      return;
+    }
+
+    const data = JSON.parse(result.v.toString());
+    if (!data.servers || !Array.isArray(data.servers)) {
+      ctx.logger.warn('Invalid server list format from DHT');
+      return;
+    }
+
+    // Signature is verified by the DHT layer (bittorrent-dht verify callback)
+    const { addBootstrapServer } = await import('../../../lib/core/serverList.js');
+    let added = 0;
+    for (const entry of data.servers) {
+      const url = typeof entry === 'string' ? entry : entry?.url;
+      if (url) {
+        addBootstrapServer(url);
+        added++;
+      }
+    }
+
+    if (added > 0) {
+      ctx.logger.info(`Discovered ${added} server(s) via DHT`);
+    }
+  } catch (err) {
+    ctx.logger.warn(`DHT server list fetch failed: ${err.message}`);
+  }
+}
+
+// Called by the gossip protocol when a peer shares their server list
+export async function onGossipServers(servers) {
+  if (!ctx || !Array.isArray(servers)) return;
+  const enableGossip = ctx.config.get('enableGossip') !== false;
+  if (!enableGossip) return;
+
+  const { addBootstrapServer } = await import('../../../lib/core/serverList.js');
+  for (const url of servers) {
+    if (typeof url === 'string' && url.startsWith('https://')) {
+      addBootstrapServer(url);
+    }
+  }
+}
+
+// Export for pe server list to show source
+export function getPublicKey() {
+  return SERVER_LIST_PUBLIC_KEY;
+}

package/extensions/@palexplorer/email-notifications/extension.json

@@ -0,0 +1,23 @@
+{
+  "name": "email-notifications",
+  "version": "1.0.0",
+  "description": "Email notifications for share invites, transfers, peer activity, and security alerts via SMTP or API providers",
+  "author": "Palexplorer Team",
+  "license": "Proprietary",
+  "main": "index.js",
+  "hooks": ["after:share:create", "after:download:complete", "on:peer:connect", "on:peer:disconnect", "on:auth:login"],
+  "permissions": ["config:read", "config:write", "net:http", "notifications", "identity:read"],
+  "config": {
+    "provider": { "type": "string", "default": "smtp", "description": "Email provider: smtp, sendgrid, mailgun, or resend" },
+    "smtpHost": { "type": "string", "default": "", "description": "SMTP server hostname" },
+    "smtpPort": { "type": "number", "default": 587, "description": "SMTP server port" },
+    "smtpUser": { "type": "string", "default": "", "description": "SMTP username" },
+    "smtpPass": { "type": "string", "default": "", "description": "SMTP password" },
+    "apiKey": { "type": "string", "default": "", "description": "API key for SendGrid/Mailgun/Resend" },
+    "fromAddress": { "type": "string", "default": "noreply@palexplorer.com", "description": "Sender email address" },
+    "toAddress": { "type": "string", "default": "", "description": "Recipient email address" },
+    "events": { "type": "array", "default": ["share:invite", "transfer:complete", "security:alert"], "description": "Enabled event types" }
+  },
+  "tier": "free",
+  "minAppVersion": "0.5.0"
+}

package/extensions/@palexplorer/email-notifications/index.js

@@ -0,0 +1,242 @@
+import { createConnection } from 'node:net';
+import { connect as tlsConnect } from 'node:tls';
+
+const EVENT_TEMPLATES = {
+  'share:invite': {
+    subject: 'New Share Invite — Palexplorer',
+    body: (d) => `You received a share invite: "${d.name}" from ${d.from || 'a peer'}.`,
+  },
+  'transfer:complete': {
+    subject: 'Transfer Complete — Palexplorer',
+    body: (d) => `Transfer "${d.name}" completed (${formatSize(d.size)}).`,
+  },
+  'peer:online': {
+    subject: 'Peer Online — Palexplorer',
+    body: (d) => `Your pal ${d.peerName || d.peerId?.slice(0, 12)} came online.`,
+  },
+  'peer:offline': {
+    subject: 'Peer Offline — Palexplorer',
+    body: (d) => `Your pal ${d.peerName || d.peerId?.slice(0, 12)} went offline.`,
+  },
+  'share:expiring': {
+    subject: 'Share Expiring Soon — Palexplorer',
+    body: (d) => `Share "${d.name}" expires in ${d.hoursLeft} hours.`,
+  },
+  'security:alert': {
+    subject: 'Security Alert — Palexplorer',
+    body: (d) => `Security alert: ${d.reason || 'Unknown event'}.`,
+  },
+};
+
+let ctx = null;
+
+export function activate(context) {
+  ctx = context;
+  const { hooks, config, logger } = context;
+
+  const toAddress = config.get('toAddress');
+  if (!toAddress) {
+    logger.warn('Email notifications enabled but no recipient address configured');
+  }
+
+  context.emailNotify = {
+    async send(eventType, data) {
+      return sendNotification(eventType, data, context);
+    },
+
+    async testConnection() {
+      return testProvider(context);
+    },
+  };
+
+  hooks.on('after:share:create', async (details) => {
+    if (isEnabled('share:invite', config)) {
+      await sendNotification('share:invite', details, context).catch(err => {
+        logger.warn(`Email notification failed: ${err.message}`);
+      });
+    }
+  });
+
+  hooks.on('after:download:complete', async (details) => {
+    if (isEnabled('transfer:complete', config)) {
+      await sendNotification('transfer:complete', details, context).catch(err => {
+        logger.warn(`Email notification failed: ${err.message}`);
+      });
+    }
+  });
+
+  hooks.on('on:peer:connect', async (details) => {
+    if (isEnabled('peer:online', config)) {
+      await sendNotification('peer:online', details, context).catch(err => {
+        logger.warn(`Email notification failed: ${err.message}`);
+      });
+    }
+  });
+
+  hooks.on('on:peer:disconnect', async (details) => {
+    if (isEnabled('peer:offline', config)) {
+      await sendNotification('peer:offline', details, context).catch(err => {
+        logger.warn(`Email notification failed: ${err.message}`);
+      });
+    }
+  });
+
+  hooks.on('on:auth:login', async (details) => {
+    if (details.failed && isEnabled('security:alert', config)) {
+      await sendNotification('security:alert', { reason: `Failed login attempt from ${details.ip || 'unknown'}` }, context).catch(() => {});
+    }
+  });
+
+  logger.info('Email notifications enabled', { provider: config.get('provider') });
+}
+
+export function deactivate() {
+  ctx = null;
+}
+
+function isEnabled(eventType, config) {
+  const events = config.get('events') || [];
+  return events.includes(eventType);
+}
+
+async function sendNotification(eventType, data, ctx) {
+  const template = EVENT_TEMPLATES[eventType];
+  if (!template) throw new Error(`Unknown event type: ${eventType}`);
+
+  const to = ctx.config.get('toAddress');
+  if (!to) throw new Error('No recipient address configured');
+
+  const subject = template.subject;
+  const body = template.body(data || {});
+  const from = ctx.config.get('fromAddress');
+  const provider = ctx.config.get('provider');
+
+  ctx.logger.info(`Sending ${eventType} notification to ${to} via ${provider}`);
+
+  if (provider === 'sendgrid') {
+    return sendViaSendGrid(from, to, subject, body, ctx);
+  } else if (provider === 'mailgun') {
+    return sendViaMailgun(from, to, subject, body, ctx);
+  } else if (provider === 'resend') {
+    return sendViaResend(from, to, subject, body, ctx);
+  } else {
+    return sendViaSMTP(from, to, subject, body, ctx);
+  }
+}
+
+async function sendViaSendGrid(from, to, subject, body, ctx) {
+  const apiKey = ctx.config.get('apiKey');
+  if (!apiKey) throw new Error('SendGrid API key not configured');
+
+  const res = await ctx.http('https://api.sendgrid.com/v3/mail/send', {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      personalizations: [{ to: [{ email: to }] }],
+      from: { email: from },
+      subject,
+      content: [{ type: 'text/plain', value: body }],
+    }),
+  });
+
+  if (!res.ok) throw new Error(`SendGrid error: ${res.status}`);
+}
+
+async function sendViaMailgun(from, to, subject, body, ctx) {
+  const apiKey = ctx.config.get('apiKey');
+  if (!apiKey) throw new Error('Mailgun API key not configured');
+
+  const domain = from.split('@')[1];
+  const res = await ctx.http(`https://api.mailgun.net/v3/${domain}/messages`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Basic ${Buffer.from(`api:${apiKey}`).toString('base64')}`,
+      'Content-Type': 'application/x-www-form-urlencoded',
+    },
+    body: new URLSearchParams({ from, to, subject, text: body }).toString(),
+  });
+
+  if (!res.ok) throw new Error(`Mailgun error: ${res.status}`);
+}
+
+async function sendViaResend(from, to, subject, body, ctx) {
+  const apiKey = ctx.config.get('apiKey');
+  if (!apiKey) throw new Error('Resend API key not configured');
+
+  const res = await ctx.http('https://api.resend.com/emails', {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ from, to, subject, text: body }),
+  });
+
+  if (!res.ok) {
+    const err = await res.text().catch(() => '');
+    throw new Error(`Resend error: ${res.status} ${err}`);
+  }
+}
+
+async function sendViaSMTP(from, to, subject, body, ctx) {
+  const host = ctx.config.get('smtpHost');
+  const port = ctx.config.get('smtpPort');
+  const user = ctx.config.get('smtpUser');
+  const pass = ctx.config.get('smtpPass');
+
+  if (!host) throw new Error('SMTP host not configured');
+
+  return new Promise((resolve, reject) => {
+    const socket = port === 465
+      ? tlsConnect({ host, port }, () => doSMTP(socket))
+      : createConnection({ host, port }, () => doSMTP(socket));
+
+    const commands = [
+      `EHLO palexplorer\r\n`,
+      ...(port !== 465 ? [`STARTTLS\r\n`] : []),
+      ...(user ? [`AUTH LOGIN\r\n`, `${Buffer.from(user).toString('base64')}\r\n`, `${Buffer.from(pass).toString('base64')}\r\n`] : []),
+      `MAIL FROM:<${from}>\r\n`,
+      `RCPT TO:<${to}>\r\n`,
+      `DATA\r\n`,
+      `From: ${from}\r\nTo: ${to}\r\nSubject: ${subject}\r\n\r\n${body}\r\n.\r\n`,
+      `QUIT\r\n`,
+    ];
+
+    let idx = 0;
+    function doSMTP(sock) {
+      sock.on('data', () => {
+        if (idx < commands.length) {
+          sock.write(commands[idx++]);
+        } else {
+          sock.end();
+          resolve();
+        }
+      });
+      sock.on('error', reject);
+      sock.setTimeout(10000, () => { sock.destroy(); reject(new Error('SMTP timeout')); });
+    }
+  });
+}
+
+async function testProvider(ctx) {
+  const provider = ctx.config.get('provider');
+  const to = ctx.config.get('toAddress');
+  if (!to) return { ok: false, error: 'No recipient configured' };
+
+  try {
+    await sendNotification('security:alert', { reason: 'Test notification' }, ctx);
+    return { ok: true, provider };
+  } catch (err) {
+    return { ok: false, provider, error: err.message };
+  }
+}
+
+function formatSize(bytes) {
+  if (!bytes) return '0 B';
+  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${units[i]}`;
+}

package/extensions/@palexplorer/explorer-integration/extension.json

@@ -0,0 +1,13 @@
+{
+  "name": "explorer-integration",
+  "version": "1.0.0",
+  "description": "Add 'Share with Pal' to your file manager context menu (Explorer, Finder, Nautilus)",
+  "author": "Palexplorer Team",
+  "license": "MIT",
+  "main": "index.js",
+  "hooks": [],
+  "permissions": ["fs:write"],
+  "config": {},
+  "pro": false,
+  "minAppVersion": "0.5.0"
+}

package/extensions/@palexplorer/explorer-integration/index.js

@@ -0,0 +1,122 @@
+import fs from 'fs';
+import path from 'path';
+import { exec } from 'child_process';
+
+let ctx = null;
+
+function isHeadless() {
+  return process.platform === 'linux' && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY;
+}
+
+export function activate(context) {
+  ctx = context;
+  if (!isHeadless()) {
+    ctx.logger.info('Explorer integration loaded. Use `pe explorer install` to set up.');
+  }
+}
+
+export function deactivate() {}
+
+export async function install() {
+  const p = process.platform;
+  if (p === 'win32') return installWindows();
+  if (p === 'darwin') return installFinder();
+  if (p === 'linux') return installNautilus();
+  throw new Error(`No file manager integration for ${p}`);
+}
+
+export async function uninstall() {
+  const p = process.platform;
+  if (p === 'win32') return uninstallWindows();
+  if (p === 'darwin') return uninstallFinder();
+  if (p === 'linux') return uninstallNautilus();
+  throw new Error(`No file manager integration for ${p}`);
+}
+
+async function installWindows() {
+  // Delegates to existing Windows explorer util
+  const { installExplorerContextMenu } = await import('../../../lib/utils/explorer.js');
+  await installExplorerContextMenu();
+}
+
+async function uninstallWindows() {
+  const { uninstallExplorerContextMenu } = await import('../../../lib/utils/explorer.js');
+  await uninstallExplorerContextMenu();
+}
+
+async function installFinder() {
+  const workflowDir = path.join(
+    process.env.HOME,
+    'Library/Services/Share with Pal.workflow/Contents'
+  );
+
+  fs.mkdirSync(workflowDir, { recursive: true });
+
+  fs.writeFileSync(path.join(workflowDir, 'Info.plist'), `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>NSServices</key>
+    <array>
+        <dict>
+            <key>NSMenuItem</key>
+            <dict>
+                <key>default</key>
+                <string>Share with Pal</string>
+            </dict>
+            <key>NSMessage</key>
+            <string>runWorkflowAsService</string>
+            <key>NSSendFileTypes</key>
+            <array>
+                <string>public.item</string>
+            </array>
+        </dict>
+    </array>
+</dict>
+</plist>
+`);
+
+  fs.writeFileSync(path.join(workflowDir, 'share-with-pal.sh'), `#!/bin/bash
+for f in "$@"; do
+  pe share "$f"
+done
+`, { mode: 0o755 });
+
+  ctx?.logger.info(`Finder Quick Action created at ${workflowDir}`);
+}
+
+async function uninstallFinder() {
+  const dir = path.join(process.env.HOME, 'Library/Services/Share with Pal.workflow');
+  if (fs.existsSync(dir)) fs.rmSync(dir, { recursive: true });
+}
+
+async function installNautilus() {
+  const scriptDir = path.join(process.env.HOME, '.local/share/nautilus/scripts');
+  fs.mkdirSync(scriptDir, { recursive: true });
+
+  fs.writeFileSync(path.join(scriptDir, 'Share with Pal'), `#!/bin/bash
+IFS=$'\\n'
+for f in $NAUTILUS_SCRIPT_SELECTED_FILE_PATHS; do
+  pe share "$f"
+done
+`, { mode: 0o755 });
+
+  const actionsDir = path.join(process.env.HOME, '.local/share/file-manager/actions');
+  fs.mkdirSync(actionsDir, { recursive: true });
+
+  fs.writeFileSync(path.join(actionsDir, 'palexplorer-share.desktop'), `[Desktop Action]
+Name=Share with Pal
+Icon=palexplorer
+Exec=pe share %f
+MimeType=inode/directory;application/octet-stream;
+`);
+
+  ctx?.logger.info('Nautilus script installed');
+}
+
+async function uninstallNautilus() {
+  const script = path.join(process.env.HOME, '.local/share/nautilus/scripts/Share with Pal');
+  const action = path.join(process.env.HOME, '.local/share/file-manager/actions/palexplorer-share.desktop');
+  if (fs.existsSync(script)) fs.unlinkSync(script);
+  if (fs.existsSync(action)) fs.unlinkSync(action);
+}

package/extensions/@palexplorer/groups/extension.json

@@ -0,0 +1,17 @@
+{
+  "name": "groups",
+  "version": "1.0.0",
+  "description": "Create and manage groups of pals",
+  "author": "Palexplorer Team",
+  "license": "MIT",
+  "main": "index.js",
+  "hooks": ["on:app:ready"],
+  "permissions": [],
+  "contributes": {
+    "pages": [
+      { "id": "groups", "label": "groups", "icon": "UsersRound", "section": "social" }
+    ]
+  },
+  "config": { "enabled": { "type": "boolean", "default": true } },
+  "pro": false
+}

package/extensions/@palexplorer/groups/index.js

@@ -0,0 +1,2 @@
+export function activate(context) {}
+export function deactivate() {}

package/extensions/@palexplorer/networks/extension.json

@@ -0,0 +1,17 @@
+{
+  "name": "networks",
+  "version": "1.0.0",
+  "description": "Private overlay networks for organizations",
+  "author": "Palexplorer Team",
+  "license": "MIT",
+  "main": "index.js",
+  "hooks": ["on:app:ready"],
+  "permissions": [],
+  "contributes": {
+    "pages": [
+      { "id": "networks", "label": "networks", "icon": "Globe", "section": "system" }
+    ]
+  },
+  "config": { "enabled": { "type": "boolean", "default": false } },
+  "pro": false
+}

package/extensions/@palexplorer/networks/index.js

@@ -0,0 +1,2 @@
+export function activate(context) {}
+export function deactivate() {}

package/extensions/@palexplorer/share-links/extension.json

@@ -0,0 +1,17 @@
+{
+  "name": "share-links",
+  "version": "1.0.0",
+  "description": "Create and manage shareable download links",
+  "author": "Palexplorer Team",
+  "license": "MIT",
+  "main": "index.js",
+  "hooks": ["on:app:ready"],
+  "permissions": [],
+  "contributes": {
+    "pages": [
+      { "id": "links", "label": "links", "icon": "Key", "section": "content" }
+    ]
+  },
+  "config": { "enabled": { "type": "boolean", "default": true } },
+  "pro": false
+}

package/extensions/@palexplorer/share-links/index.js

@@ -0,0 +1,2 @@
+export function activate(context) {}
+export function deactivate() {}

package/extensions/@palexplorer/sync/extension.json

@@ -0,0 +1,17 @@
+{
+  "name": "sync",
+  "version": "1.0.0",
+  "description": "Two-way folder synchronization between devices",
+  "author": "Palexplorer Team",
+  "license": "MIT",
+  "main": "index.js",
+  "hooks": ["on:app:ready"],
+  "permissions": [],
+  "contributes": {
+    "pages": [
+      { "id": "sync", "label": "sync", "icon": "FolderSync", "section": "content" }
+    ]
+  },
+  "config": { "enabled": { "type": "boolean", "default": true } },
+  "pro": false
+}

package/extensions/@palexplorer/sync/index.js

@@ -0,0 +1,2 @@
+export function activate(context) {}
+export function deactivate() {}

package/extensions/@palexplorer/user-mgmt/extension.json

@@ -0,0 +1,17 @@
+{
+  "name": "user-mgmt",
+  "version": "1.0.0",
+  "description": "Multi-user management and role assignment",
+  "author": "Palexplorer Team",
+  "license": "MIT",
+  "main": "index.js",
+  "hooks": ["on:app:ready"],
+  "permissions": [],
+  "contributes": {
+    "pages": [
+      { "id": "users", "label": "users", "icon": "Users", "section": "system", "minLevel": "owner" }
+    ]
+  },
+  "config": { "enabled": { "type": "boolean", "default": false } },
+  "pro": false
+}

package/extensions/@palexplorer/user-mgmt/index.js

@@ -0,0 +1,2 @@
+export function activate(context) {}
+export function deactivate() {}

package/extensions/@palexplorer/vfs/extension.json

@@ -0,0 +1,17 @@
+{
+  "name": "vfs",
+  "version": "1.0.0",
+  "description": "Mount Palexplorer shares as a virtual drive (WebDAV)",
+  "author": "Palexplorer Team",
+  "license": "MIT",
+  "main": "index.js",
+  "hooks": ["on:app:ready", "on:app:shutdown", "after:share:create", "after:share:revoke"],
+  "permissions": ["shares:read", "config:read", "config:write"],
+  "config": {
+    "port": { "type": "number", "default": 1900, "description": "WebDAV server port" },
+    "driveLetter": { "type": "string", "default": "P", "description": "Windows drive letter" },
+    "autoMount": { "type": "boolean", "default": true, "description": "Auto-mount on startup" }
+  },
+  "pro": false,
+  "minAppVersion": "0.5.0"
+}