pal-explorer-cli 0.4.0

package/lib/core/users.js

@@ -0,0 +1,225 @@
+import config from '../utils/config.js';
+import { signConfigKey } from '../utils/configIntegrity.js';
+
+const ROLES = ['owner', 'user', 'guest'];
+
+let guestProfile = null;
+
+export function addGuestProfile(publicKey, handle) {
+  guestProfile = {
+    publicKey,
+    handle: handle || null,
+    name: 'Guest',
+    role: 'guest',
+    isGuest: true,
+    createdAt: new Date().toISOString(),
+    lastLogin: new Date().toISOString(),
+  };
+  return guestProfile;
+}
+
+export function removeGuestProfile() {
+  guestProfile = null;
+}
+
+export function isGuestActive() {
+  return guestProfile !== null;
+}
+
+function getUserStore() {
+  return config.get('users') || { activeUser: null, profiles: [] };
+}
+
+function saveUserStore(store) {
+  config.set('users', store);
+  signConfigKey('users').catch(() => {});
+}
+
+export function getProfiles() {
+  return getUserStore().profiles;
+}
+
+export function getActiveUser() {
+  if (guestProfile) return guestProfile;
+  const store = getUserStore();
+  if (!store.activeUser || store.profiles.length === 0) return null;
+  return store.profiles.find(p => p.publicKey === store.activeUser) || null;
+}
+
+export function getActivePublicKey() {
+  const store = getUserStore();
+  return store.activeUser || null;
+}
+
+export function setActiveUser(publicKey) {
+  const store = getUserStore();
+  const profile = store.profiles.find(p => p.publicKey === publicKey);
+  if (!profile) throw new Error('User profile not found');
+  profile.lastLogin = new Date().toISOString();
+  store.activeUser = publicKey;
+  saveUserStore(store);
+  return profile;
+}
+
+export function addProfile(publicKey, handle, name, role = 'user') {
+  if (!ROLES.includes(role)) throw new Error(`Invalid role: ${role}`);
+  const store = getUserStore();
+
+  if (store.profiles.find(p => p.publicKey === publicKey)) {
+    throw new Error('Profile already exists for this key');
+  }
+
+  const profile = {
+    publicKey,
+    handle: handle || null,
+    name: name || 'User',
+    role,
+    createdAt: new Date().toISOString(),
+    lastLogin: new Date().toISOString(),
+  };
+
+  store.profiles.push(profile);
+
+  if (!store.activeUser || store.profiles.length === 1) {
+    store.activeUser = publicKey;
+  }
+
+  saveUserStore(store);
+  return profile;
+}
+
+export function removeProfile(publicKey) {
+  const store = getUserStore();
+  const profile = store.profiles.find(p => p.publicKey === publicKey);
+  if (!profile) throw new Error('Profile not found');
+  if (profile.role === 'owner') throw new Error('Cannot remove the owner profile');
+
+  store.profiles = store.profiles.filter(p => p.publicKey !== publicKey);
+
+  if (store.activeUser === publicKey) {
+    const owner = store.profiles.find(p => p.role === 'owner');
+    store.activeUser = owner?.publicKey || store.profiles[0]?.publicKey || null;
+  }
+
+  saveUserStore(store);
+  return true;
+}
+
+export function promoteProfile(publicKey, newRole) {
+  if (!['user', 'guest'].includes(newRole)) throw new Error(`Cannot set role to: ${newRole}`);
+  const store = getUserStore();
+  const profile = store.profiles.find(p => p.publicKey === publicKey);
+  if (!profile) throw new Error('Profile not found');
+  if (profile.role === 'owner') throw new Error('Cannot change owner role');
+  profile.role = newRole;
+  saveUserStore(store);
+  return profile;
+}
+
+export function updateProfileHandle(publicKey, handle) {
+  const store = getUserStore();
+  const profile = store.profiles.find(p => p.publicKey === publicKey);
+  if (!profile) return null;
+  profile.handle = handle;
+  saveUserStore(store);
+  return profile;
+}
+
+export function isOwner(publicKey) {
+  const store = getUserStore();
+  const profile = store.profiles.find(p => p.publicKey === publicKey);
+  return profile && profile.role === 'owner';
+}
+
+export function requireRole(minRole) {
+  const active = getActiveUser();
+  if (!active) throw new Error('No active user. Run `pe login` first.');
+
+  const roleLevel = { owner: 2, user: 1, guest: 0 };
+  if ((roleLevel[active.role] || 0) < (roleLevel[minRole] || 0)) {
+    throw new Error(`This action requires ${minRole} role. You are: ${active.role}`);
+  }
+  return active;
+}
+
+export function migrateToMultiUser() {
+  const store = getUserStore();
+  if (store.profiles.length > 0) return false;
+
+  const identity = config.get('identity');
+  if (!identity?.publicKey) return false;
+
+  const profile = {
+    publicKey: identity.publicKey,
+    handle: identity.handle || null,
+    name: identity.name || 'Owner',
+    role: 'owner',
+    createdAt: identity.createdAt || new Date().toISOString(),
+    lastLogin: new Date().toISOString(),
+  };
+
+  store.profiles = [profile];
+  store.activeUser = identity.publicKey;
+  saveUserStore(store);
+
+  // Migrate existing friends to be scoped to this user
+  const friends = config.get('friends') || [];
+  if (friends.length > 0) {
+    config.set(`userdata.${identity.publicKey}.friends`, friends);
+  }
+
+  return true;
+}
+
+// Per-user data accessors
+export function getUserData(key) {
+  const pk = getActivePublicKey();
+  if (!pk) return null;
+  return config.get(`userdata.${pk}.${key}`) ?? null;
+}
+
+export function setUserData(key, value) {
+  const pk = getActivePublicKey();
+  if (!pk) throw new Error('No active user');
+  config.set(`userdata.${pk}.${key}`, value);
+}
+
+export function getUserFriends() {
+  return getUserData('friends') || [];
+}
+
+export function setUserFriends(friends) {
+  setUserData('friends', friends);
+}
+
+export function getUserReceivedShares() {
+  return getUserData('receivedShares') || [];
+}
+
+export function setUserReceivedShares(shares) {
+  setUserData('receivedShares', shares);
+}
+
+export function getFriends() {
+  const pk = getActivePublicKey();
+  if (pk) {
+    const perUser = config.get(`userdata.${pk}.friends`);
+    if (perUser !== undefined && perUser !== null) return perUser;
+    // Non-owners get empty list if no per-user data (no fallback to global)
+    const active = getActiveUser();
+    if (active && active.role !== 'owner') return [];
+  }
+  return config.get('friends') || [];
+}
+
+export function saveFriends(friends) {
+  const pk = getActivePublicKey();
+  if (pk) {
+    config.set(`userdata.${pk}.friends`, friends);
+  }
+  // Only write global for owner (backward compat)
+  const active = getActiveUser();
+  if (!active || active.role === 'owner') {
+    config.set('friends', friends);
+  }
+}

package/lib/core/vfs.js

@@ -0,0 +1,216 @@
+import { v2 as webdav } from 'webdav-server';
+import { exec } from 'child_process';
+import crypto from 'crypto';
+import path from 'path';
+import config from '../utils/config.js';
+
+export class VirtualDrive {
+  constructor(port = 1900) {
+    this.port = port;
+    this.token = null;
+    this.server = null;
+    this.mounted = false;
+    this.driveLetter = 'P';
+    this.shares = new Map();
+  }
+
+  async start() {
+    this.token = crypto.randomBytes(32).toString('hex');
+
+    const userManager = new webdav.SimpleUserManager();
+    const user = userManager.addUser('pal', this.token, false);
+
+    const privilegeManager = new webdav.SimplePathPrivilegeManager();
+    privilegeManager.setRights(user, '/', ['all']);
+
+    this.server = new webdav.WebDAVServer({
+      port: this.port,
+      hostname: '127.0.0.1',
+      requireAuthentification: true,
+      httpAuthentication: new webdav.HTTPBasicAuthentication(userManager, 'Palexplorer VFS'),
+      privilegeManager,
+    });
+
+    return new Promise((resolve, reject) => {
+      this.server.start((serverOrError) => {
+        if (serverOrError instanceof Error) {
+          return reject(new Error(`WebDAV server failed to start on port ${this.port}: ${serverOrError.message}`));
+        }
+        console.log(`WebDAV server started on http://127.0.0.1:${this.port} (auth required)`);
+        resolve();
+      });
+    });
+  }
+
+  async stop() {
+    if (!this.server) return;
+    return new Promise((resolve) => {
+      this.server.stop(() => {
+        this.server = null;
+        this.token = null;
+        resolve();
+      });
+    });
+  }
+
+  async addShare(shareName, localPath) {
+    return new Promise((resolve, reject) => {
+      if (!this.server) {
+        return reject(new Error('WebDAV server not running. Call start() first.'));
+      }
+      this.server.setFileSystem(`/${shareName}`, new webdav.PhysicalFileSystem(localPath), (success) => {
+        if (success) {
+          this.shares.set(shareName, localPath);
+          console.log(`Added share to VFS: /${shareName} -> ${localPath}`);
+          resolve(true);
+        } else {
+          reject(new Error(`Failed to add share: /${shareName}`));
+        }
+      });
+    });
+  }
+
+  async removeShare(shareName) {
+    if (!this.server) return;
+    this.server.removeFileSystem(`/${shareName}`, () => {
+      this.shares.delete(shareName);
+    });
+  }
+
+  async syncShares() {
+    const configShares = config.get('shares') || [];
+    const activeNames = new Set();
+
+    for (const share of configShares) {
+      if (share.status !== 'active') continue;
+      const name = path.basename(share.path);
+      activeNames.add(name);
+      if (!this.shares.has(name)) {
+        try {
+          await this.addShare(name, share.path);
+        } catch {
+          // Skip shares that fail to add (e.g., path doesn't exist)
+        }
+      }
+    }
+
+    // Remove shares no longer in config
+    for (const [name] of this.shares) {
+      if (!activeNames.has(name)) {
+        await this.removeShare(name);
+      }
+    }
+  }
+
+  status() {
+    return {
+      running: !!this.server,
+      mounted: this.mounted,
+      driveLetter: this.driveLetter,
+      port: this.port,
+      shareCount: this.shares.size,
+      shares: Array.from(this.shares.entries()).map(([name, localPath]) => ({ name, localPath })),
+    };
+  }
+
+  async mount(driveLetter = 'P') {
+    this.driveLetter = driveLetter;
+
+    if (process.platform === 'darwin') {
+      const mountPoint = `/Volumes/Palexplorer`;
+      const cmd = `mkdir -p "${mountPoint}" && mount_webdav -s -S http://127.0.0.1:${this.port} "${mountPoint}"`;
+      return new Promise((resolve, reject) => {
+        exec(cmd, (err) => {
+          if (err) {
+            console.warn('VFS mount failed on macOS. Ensure webdav support is available.');
+            return resolve(); // non-fatal
+          }
+          this.mounted = true;
+          console.log(`Mounted Virtual Drive at ${mountPoint}`);
+          resolve();
+        });
+      });
+    }
+
+    if (process.platform === 'linux') {
+      const mountPoint = `${process.env.HOME}/Palexplorer`;
+      const cmd = `mkdir -p "${mountPoint}" && mount -t davfs http://127.0.0.1:${this.port} "${mountPoint}"`;
+      return new Promise((resolve, reject) => {
+        exec(cmd, (err) => {
+          if (err) {
+            console.warn('VFS mount failed on Linux. Install davfs2: sudo apt install davfs2');
+            return resolve(); // non-fatal
+          }
+          this.mounted = true;
+          console.log(`Mounted Virtual Drive at ${mountPoint}`);
+          resolve();
+        });
+      });
+    }
+
+    if (process.platform !== 'win32') return;
+
+    if (!/^[A-Za-z]$/.test(driveLetter)) throw new Error('Invalid drive letter');
+    const cmd = `net use ${driveLetter}: http://127.0.0.1:${this.port} /user:pal ${this.token} /persistent:yes`;
+
+    return new Promise((resolve, reject) => {
+      exec(cmd, (err, stdout, stderr) => {
+        if (err) {
+          if (stderr && stderr.includes('85')) {
+            this.mounted = true;
+            return resolve();
+          }
+          if (stderr && stderr.includes('67')) {
+            console.warn(`Virtual Drive: WebClient service not running, ${driveLetter}: drive skipped.`);
+            return resolve();
+          }
+          return reject(new Error(`Mount failed: ${stderr || err.message}`));
+        }
+        this.mounted = true;
+        console.log(`Mounted Virtual Drive at ${driveLetter}:`);
+        resolve();
+      });
+    });
+  }
+
+  async unmount(driveLetter = 'P') {
+    if (process.platform === 'darwin') {
+      const mountPoint = `/Volumes/Palexplorer`;
+      return new Promise((resolve) => {
+        exec(`umount "${mountPoint}"`, () => {
+          this.mounted = false;
+          resolve();
+        });
+      });
+    }
+
+    if (process.platform === 'linux') {
+      const mountPoint = `${process.env.HOME}/Palexplorer`;
+      return new Promise((resolve) => {
+        exec(`umount "${mountPoint}"`, () => {
+          this.mounted = false;
+          resolve();
+        });
+      });
+    }
+
+    if (process.platform !== 'win32') return;
+
+    if (!/^[A-Za-z]$/.test(driveLetter)) throw new Error('Invalid drive letter');
+    const cmd = `net use ${driveLetter}: /delete /yes`;
+
+    return new Promise((resolve, reject) => {
+      exec(cmd, (err) => {
+        if (err) return reject(new Error(`Unmount failed: ${err.message}`));
+        this.mounted = false;
+        resolve();
+      });
+    });
+  }
+}
+
+export const vfs = new VirtualDrive();
+
+export function getMountStatus() {
+  return vfs.status();
+}