@livedesk/hub 0.1.41 → 0.1.42

package/src/filesystem/hub-filesystem.js

@@ -1,78 +1,78 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { discoverFilesystemRoots } from './roots.js';
-import { OpaquePathRegistry, isPathWithinRoot } from './path-registry.js';
-import { readDirectoryEntries, scanSelection } from './directory-reader.js';
-
-export class HubFilesystem {
-  constructor() {
-    this.registry = new OpaquePathRegistry();
-    this.rootsCache = null;
-    this.rootsLoadedAt = 0;
-  }
-
-  async getRoots({ refresh = false } = {}) {
-    if (!refresh && this.rootsCache && Date.now() - this.rootsLoadedAt < 30_000) return this.rootsCache;
-    const roots = await discoverFilesystemRoots();
-    const entries = roots.map(root => this.registry.register({
-      absolutePath: root.path,
-      rootPath: root.path,
-      rootId: `root:${root.path}`,
-      parentId: 'this-pc',
-      name: root.name,
-      type: 'folder',
-      displayPath: root.displayPath
-    }));
-    this.rootsCache = {
-      roots: entries.map((entry, index) => ({
-        id: entry.id,
-        parentId: 'this-pc',
-        name: entry.name,
-        type: 'drive',
-        size: 0,
-        modifiedAt: null,
-        hasChildren: roots[index].hasChildren,
-        displayPath: roots[index].displayPath,
-        driveType: roots[index].driveType,
-        totalBytes: roots[index].totalBytes,
-        freeBytes: roots[index].freeBytes
-      }))
-    };
-    this.rootsLoadedAt = Date.now();
-    return this.rootsCache;
-  }
-
-  async getEntries(id) {
-    return readDirectoryEntries(this.registry, id);
-  }
-
-  async scan(itemIds) {
-    return scanSelection(this.registry, itemIds);
-  }
-
-  resolve(id) {
-    return this.registry.resolve(id);
-  }
-
-  async registerPersistedFolder(absolutePath, displayPath = absolutePath) {
-    const normalized = path.resolve(String(absolutePath || ''));
-    const roots = await discoverFilesystemRoots();
-    const root = roots.find(candidate => isPathWithinRoot(candidate.path, normalized));
-    if (!root) return null;
-    const stat = await fs.lstat(normalized).catch(() => null);
-    if (!stat?.isDirectory()) return null;
-    return this.registry.register({
-      absolutePath: normalized,
-      rootPath: root.path,
-      rootId: `root:${root.path}`,
-      parentId: null,
-      name: path.basename(normalized) || normalized,
-      type: 'folder',
-      displayPath
-    });
-  }
-}
-
-export function createHubFilesystem() {
-  return new HubFilesystem();
-}
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { discoverFilesystemRoots } from './roots.js';
+import { OpaquePathRegistry, isPathWithinRoot } from './path-registry.js';
+import { readDirectoryEntries, scanSelection } from './directory-reader.js';
+
+export class HubFilesystem {
+  constructor() {
+    this.registry = new OpaquePathRegistry();
+    this.rootsCache = null;
+    this.rootsLoadedAt = 0;
+  }
+
+  async getRoots({ refresh = false } = {}) {
+    if (!refresh && this.rootsCache && Date.now() - this.rootsLoadedAt < 30_000) return this.rootsCache;
+    const roots = await discoverFilesystemRoots();
+    const entries = roots.map(root => this.registry.register({
+      absolutePath: root.path,
+      rootPath: root.path,
+      rootId: `root:${root.path}`,
+      parentId: 'this-pc',
+      name: root.name,
+      type: 'folder',
+      displayPath: root.displayPath
+    }));
+    this.rootsCache = {
+      roots: entries.map((entry, index) => ({
+        id: entry.id,
+        parentId: 'this-pc',
+        name: entry.name,
+        type: 'drive',
+        size: 0,
+        modifiedAt: null,
+        hasChildren: roots[index].hasChildren,
+        displayPath: roots[index].displayPath,
+        driveType: roots[index].driveType,
+        totalBytes: roots[index].totalBytes,
+        freeBytes: roots[index].freeBytes
+      }))
+    };
+    this.rootsLoadedAt = Date.now();
+    return this.rootsCache;
+  }
+
+  async getEntries(id) {
+    return readDirectoryEntries(this.registry, id);
+  }
+
+  async scan(itemIds) {
+    return scanSelection(this.registry, itemIds);
+  }
+
+  resolve(id) {
+    return this.registry.resolve(id);
+  }
+
+  async registerPersistedFolder(absolutePath, displayPath = absolutePath) {
+    const normalized = path.resolve(String(absolutePath || ''));
+    const roots = await discoverFilesystemRoots();
+    const root = roots.find(candidate => isPathWithinRoot(candidate.path, normalized));
+    if (!root) return null;
+    const stat = await fs.lstat(normalized).catch(() => null);
+    if (!stat?.isDirectory()) return null;
+    return this.registry.register({
+      absolutePath: normalized,
+      rootPath: root.path,
+      rootId: `root:${root.path}`,
+      parentId: null,
+      name: path.basename(normalized) || normalized,
+      type: 'folder',
+      displayPath
+    });
+  }
+}
+
+export function createHubFilesystem() {
+  return new HubFilesystem();
+}

package/src/filesystem/path-registry.js

@@ -1,78 +1,78 @@
-import crypto from 'node:crypto';
-import path from 'node:path';
-
-function isWithinRoot(rootPath, candidatePath) {
-  const relative = path.relative(rootPath, candidatePath);
-  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
-}
-
-export class OpaquePathRegistry {
-  constructor({ ttlMs = 30 * 60 * 1000 } = {}) {
-    this.ttlMs = ttlMs;
-    this.entries = new Map();
-    this.byPath = new Map();
-  }
-
-  register({ absolutePath, rootPath, rootId, parentId = null, name, type, displayPath = absolutePath, locked = false }) {
-    const normalizedPath = path.resolve(absolutePath);
-    const normalizedRoot = path.resolve(rootPath);
-    if (!isWithinRoot(normalizedRoot, normalizedPath)) {
-      const error = new Error('filesystem-path-outside-root');
-      error.code = 'PATH_OUTSIDE_ROOT';
-      throw error;
-    }
-    const key = `${rootId}:${normalizedPath}`;
-    const existing = this.byPath.get(key);
-    if (existing && this.entries.has(existing)) {
-      const entry = this.entries.get(existing);
-      entry.expiresAt = Date.now() + this.ttlMs;
-      return entry;
-    }
-    const entry = {
-      id: `fs_${crypto.randomBytes(18).toString('base64url')}`,
-      absolutePath: normalizedPath,
-      rootPath: normalizedRoot,
-      rootId: String(rootId),
-      parentId,
-      name: String(name || path.basename(normalizedPath) || normalizedPath),
-      type: type === 'file' ? 'file' : 'folder',
-      displayPath: String(displayPath || normalizedPath),
-      locked: locked === true,
-      expiresAt: Date.now() + this.ttlMs
-    };
-    this.entries.set(entry.id, entry);
-    this.byPath.set(key, entry.id);
-    return entry;
-  }
-
-  resolve(id) {
-    this.prune();
-    const entry = this.entries.get(String(id || ''));
-    if (!entry) {
-      const error = new Error('invalid-filesystem-id');
-      error.code = 'INVALID_ID';
-      error.status = 400;
-      throw error;
-    }
-    entry.expiresAt = Date.now() + this.ttlMs;
-    return entry;
-  }
-
-  remove(id) {
-    const entry = this.entries.get(String(id || ''));
-    if (!entry) return;
-    this.entries.delete(entry.id);
-    this.byPath.delete(`${entry.rootId}:${entry.absolutePath}`);
-  }
-
-  prune() {
-    const now = Date.now();
-    for (const [id, entry] of this.entries) {
-      if (entry.expiresAt <= now) this.remove(id);
-    }
-  }
-}
-
-export function isPathWithinRoot(rootPath, candidatePath) {
-  return isWithinRoot(path.resolve(rootPath), path.resolve(candidatePath));
-}
+import crypto from 'node:crypto';
+import path from 'node:path';
+
+function isWithinRoot(rootPath, candidatePath) {
+  const relative = path.relative(rootPath, candidatePath);
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+export class OpaquePathRegistry {
+  constructor({ ttlMs = 30 * 60 * 1000 } = {}) {
+    this.ttlMs = ttlMs;
+    this.entries = new Map();
+    this.byPath = new Map();
+  }
+
+  register({ absolutePath, rootPath, rootId, parentId = null, name, type, displayPath = absolutePath, locked = false }) {
+    const normalizedPath = path.resolve(absolutePath);
+    const normalizedRoot = path.resolve(rootPath);
+    if (!isWithinRoot(normalizedRoot, normalizedPath)) {
+      const error = new Error('filesystem-path-outside-root');
+      error.code = 'PATH_OUTSIDE_ROOT';
+      throw error;
+    }
+    const key = `${rootId}:${normalizedPath}`;
+    const existing = this.byPath.get(key);
+    if (existing && this.entries.has(existing)) {
+      const entry = this.entries.get(existing);
+      entry.expiresAt = Date.now() + this.ttlMs;
+      return entry;
+    }
+    const entry = {
+      id: `fs_${crypto.randomBytes(18).toString('base64url')}`,
+      absolutePath: normalizedPath,
+      rootPath: normalizedRoot,
+      rootId: String(rootId),
+      parentId,
+      name: String(name || path.basename(normalizedPath) || normalizedPath),
+      type: type === 'file' ? 'file' : 'folder',
+      displayPath: String(displayPath || normalizedPath),
+      locked: locked === true,
+      expiresAt: Date.now() + this.ttlMs
+    };
+    this.entries.set(entry.id, entry);
+    this.byPath.set(key, entry.id);
+    return entry;
+  }
+
+  resolve(id) {
+    this.prune();
+    const entry = this.entries.get(String(id || ''));
+    if (!entry) {
+      const error = new Error('invalid-filesystem-id');
+      error.code = 'INVALID_ID';
+      error.status = 400;
+      throw error;
+    }
+    entry.expiresAt = Date.now() + this.ttlMs;
+    return entry;
+  }
+
+  remove(id) {
+    const entry = this.entries.get(String(id || ''));
+    if (!entry) return;
+    this.entries.delete(entry.id);
+    this.byPath.delete(`${entry.rootId}:${entry.absolutePath}`);
+  }
+
+  prune() {
+    const now = Date.now();
+    for (const [id, entry] of this.entries) {
+      if (entry.expiresAt <= now) this.remove(id);
+    }
+  }
+}
+
+export function isPathWithinRoot(rootPath, candidatePath) {
+  return isWithinRoot(path.resolve(rootPath), path.resolve(candidatePath));
+}

package/src/filesystem/roots.js

@@ -1,115 +1,115 @@
-import fs from 'node:fs/promises';
-import { constants as fsConstants } from 'node:fs';
-import os from 'node:os';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-
-const execFileAsync = promisify(execFile);
-
-function normalizeRootPath(value) {
-  const text = String(value || '').trim();
-  if (!text) return '';
-  return process.platform === 'win32'
-    ? text.replace(/[\\/]+$/, '\\')
-    : text.replace(/\/+$/, '') || '/';
-}
-
-async function statfsCapacity(rootPath) {
-  try {
-    const stat = await fs.statfs(rootPath);
-    const blockSize = Number(stat.bsize || stat.frsize || 0);
-    return {
-      totalBytes: blockSize > 0 ? Number(stat.blocks || 0) * blockSize : 0,
-      freeBytes: blockSize > 0 ? Number(stat.bavail || stat.bfree || 0) * blockSize : 0
-    };
-  } catch {
-    return { totalBytes: 0, freeBytes: 0 };
-  }
-}
-
-async function windowsDriveTypes() {
-  if (process.platform !== 'win32') return new Map();
-  try {
-    const { stdout } = await execFileAsync('powershell.exe', [
-      '-NoProfile', '-NonInteractive', '-Command',
-      '$ProgressPreference="SilentlyContinue"; Get-CimInstance Win32_LogicalDisk | Select-Object DeviceID,DriveType | ConvertTo-Json -Compress'
-    ], { timeout: 2500, windowsHide: true, maxBuffer: 1024 * 1024 });
-    const parsed = JSON.parse(String(stdout || 'null'));
-    const rows = Array.isArray(parsed) ? parsed : parsed ? [parsed] : [];
-    const names = new Map([[2, 'removable'], [3, 'fixed'], [4, 'network'], [5, 'optical']]);
-    return new Map(rows.map(row => [String(row.DeviceID || '').toUpperCase(), names.get(Number(row.DriveType)) || 'unknown']));
-  } catch {
-    return new Map();
-  }
-}
-
-async function windowsRoots() {
-  const types = await windowsDriveTypes();
-  const roots = [];
-  for (let code = 65; code <= 90; code += 1) {
-    const letter = String.fromCharCode(code);
-    const path = `${letter}:\\`;
-    try {
-      await fs.access(path, fsConstants.R_OK);
-      const capacity = await statfsCapacity(path);
-      const driveType = types.get(`${letter}:`.toUpperCase()) || 'fixed';
-      roots.push({
-        path,
-        name: `${driveType === 'network' ? 'Network' : driveType === 'removable' ? 'External' : 'Drive'} (${letter}:)`,
-        displayPath: path,
-        type: 'drive',
-        driveType,
-        ...capacity,
-        hasChildren: true
-      });
-    } catch {
-      // An unavailable or inaccessible drive is not exposed to the browser.
-    }
-  }
-  return roots;
-}
-
-async function mountedRoots() {
-  const candidates = new Set(['/']);
-  if (process.platform === 'darwin') candidates.add('/Volumes');
-  if (process.platform === 'linux') {
-    candidates.add('/mnt');
-    candidates.add('/media');
-  }
-  const roots = [];
-  for (const candidate of candidates) {
-    try {
-      const stat = await fs.stat(candidate);
-      if (!stat.isDirectory()) continue;
-      const capacity = await statfsCapacity(candidate);
-      roots.push({
-        path: candidate,
-        name: candidate === '/' ? 'System root (/)' : candidate,
-        displayPath: candidate,
-        type: 'drive',
-        driveType: candidate === '/' ? 'fixed' : 'mount',
-        ...capacity,
-        hasChildren: true
-      });
-    } catch {
-      // Keep probing the remaining mount points.
-    }
-  }
-  return roots;
-}
-
-export async function discoverFilesystemRoots() {
-  const roots = process.platform === 'win32' ? await windowsRoots() : await mountedRoots();
-  if (roots.length > 0) return roots;
-  const fallback = process.platform === 'win32' ? `${process.env.SystemDrive || 'C:'}\\` : os.homedir();
-  return [{
-    path: fallback,
-    name: fallback,
-    displayPath: fallback,
-    type: 'drive',
-    driveType: 'unknown',
-    totalBytes: 0,
-    freeBytes: 0,
-    hasChildren: true
-  }];
-}
+import fs from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+import os from 'node:os';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+function normalizeRootPath(value) {
+  const text = String(value || '').trim();
+  if (!text) return '';
+  return process.platform === 'win32'
+    ? text.replace(/[\\/]+$/, '\\')
+    : text.replace(/\/+$/, '') || '/';
+}
+
+async function statfsCapacity(rootPath) {
+  try {
+    const stat = await fs.statfs(rootPath);
+    const blockSize = Number(stat.bsize || stat.frsize || 0);
+    return {
+      totalBytes: blockSize > 0 ? Number(stat.blocks || 0) * blockSize : 0,
+      freeBytes: blockSize > 0 ? Number(stat.bavail || stat.bfree || 0) * blockSize : 0
+    };
+  } catch {
+    return { totalBytes: 0, freeBytes: 0 };
+  }
+}
+
+async function windowsDriveTypes() {
+  if (process.platform !== 'win32') return new Map();
+  try {
+    const { stdout } = await execFileAsync('powershell.exe', [
+      '-NoProfile', '-NonInteractive', '-Command',
+      '$ProgressPreference="SilentlyContinue"; Get-CimInstance Win32_LogicalDisk | Select-Object DeviceID,DriveType | ConvertTo-Json -Compress'
+    ], { timeout: 2500, windowsHide: true, maxBuffer: 1024 * 1024 });
+    const parsed = JSON.parse(String(stdout || 'null'));
+    const rows = Array.isArray(parsed) ? parsed : parsed ? [parsed] : [];
+    const names = new Map([[2, 'removable'], [3, 'fixed'], [4, 'network'], [5, 'optical']]);
+    return new Map(rows.map(row => [String(row.DeviceID || '').toUpperCase(), names.get(Number(row.DriveType)) || 'unknown']));
+  } catch {
+    return new Map();
+  }
+}
+
+async function windowsRoots() {
+  const types = await windowsDriveTypes();
+  const roots = [];
+  for (let code = 65; code <= 90; code += 1) {
+    const letter = String.fromCharCode(code);
+    const path = `${letter}:\\`;
+    try {
+      await fs.access(path, fsConstants.R_OK);
+      const capacity = await statfsCapacity(path);
+      const driveType = types.get(`${letter}:`.toUpperCase()) || 'fixed';
+      roots.push({
+        path,
+        name: `${driveType === 'network' ? 'Network' : driveType === 'removable' ? 'External' : 'Drive'} (${letter}:)`,
+        displayPath: path,
+        type: 'drive',
+        driveType,
+        ...capacity,
+        hasChildren: true
+      });
+    } catch {
+      // An unavailable or inaccessible drive is not exposed to the browser.
+    }
+  }
+  return roots;
+}
+
+async function mountedRoots() {
+  const candidates = new Set(['/']);
+  if (process.platform === 'darwin') candidates.add('/Volumes');
+  if (process.platform === 'linux') {
+    candidates.add('/mnt');
+    candidates.add('/media');
+  }
+  const roots = [];
+  for (const candidate of candidates) {
+    try {
+      const stat = await fs.stat(candidate);
+      if (!stat.isDirectory()) continue;
+      const capacity = await statfsCapacity(candidate);
+      roots.push({
+        path: candidate,
+        name: candidate === '/' ? 'System root (/)' : candidate,
+        displayPath: candidate,
+        type: 'drive',
+        driveType: candidate === '/' ? 'fixed' : 'mount',
+        ...capacity,
+        hasChildren: true
+      });
+    } catch {
+      // Keep probing the remaining mount points.
+    }
+  }
+  return roots;
+}
+
+export async function discoverFilesystemRoots() {
+  const roots = process.platform === 'win32' ? await windowsRoots() : await mountedRoots();
+  if (roots.length > 0) return roots;
+  const fallback = process.platform === 'win32' ? `${process.env.SystemDrive || 'C:'}\\` : os.homedir();
+  return [{
+    path: fallback,
+    name: fallback,
+    displayPath: fallback,
+    type: 'drive',
+    driveType: 'unknown',
+    totalBytes: 0,
+    freeBytes: 0,
+    hasChildren: true
+  }];
+}