@livedesk/hub 0.1.41 → 0.1.43

package/src/filesystem/directory-reader.js

@@ -1,187 +1,187 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { setImmediate as yieldToEventLoop } from 'node:timers/promises';
-import { isPathWithinRoot } from './path-registry.js';
-
-function filesystemError(message, code = 'FILESYSTEM_ERROR', status = 400) {
-  const error = new Error(message);
-  error.code = code;
-  error.status = status;
-  return error;
-}
-
-function safeEntryName(name) {
-  return String(name || '').replace(/[\0\r\n\t]/g, ' ').slice(0, 512);
-}
-
-function toPublicEntry(entry) {
-  return {
-    id: entry.id,
-    parentId: entry.parentId,
-    name: entry.name,
-    type: entry.type,
-    size: entry.size || 0,
-    modifiedAt: entry.modifiedAt || null,
-    extension: entry.type === 'file' ? path.extname(entry.name).toLowerCase() : '',
-    hasChildren: entry.type !== 'file' && entry.hasChildren === true,
-    displayPath: entry.displayPath,
-    locked: entry.locked === true
-  };
-}
-
-async function readEntryStat(absolutePath) {
-  try {
-    return await fs.lstat(absolutePath);
-  } catch (error) {
-    if (error?.code === 'EACCES' || error?.code === 'EPERM') throw filesystemError('filesystem-access-denied', 'ACCESS_DENIED', 403);
-    if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR') throw filesystemError('filesystem-entry-unavailable', 'NOT_FOUND', 404);
-    throw error;
-  }
-}
-
-export async function readDirectoryEntries(registry, folderId) {
-  const folder = registry.resolve(folderId);
-  if (folder.type === 'file') throw filesystemError('filesystem-entry-is-not-folder', 'NOT_A_FOLDER', 400);
-  if (folder.locked) throw filesystemError('filesystem-access-denied', 'ACCESS_DENIED', 403);
-  let entries;
-  try {
-    entries = await fs.readdir(folder.absolutePath, { withFileTypes: true });
-  } catch (error) {
-    if (error?.code === 'EACCES' || error?.code === 'EPERM') throw filesystemError('filesystem-access-denied', 'ACCESS_DENIED', 403);
-    if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR') throw filesystemError('filesystem-entry-unavailable', 'NOT_FOUND', 404);
-    throw error;
-  }
-
-  const output = [];
-  for (const dirent of entries) {
-    const name = safeEntryName(dirent.name);
-    if (!name || name === '.' || name === '..') continue;
-    const absolutePath = path.resolve(folder.absolutePath, name);
-    if (!isPathWithinRoot(folder.rootPath, absolutePath)) continue;
-    const stat = await readEntryStat(absolutePath).catch(error => {
-      if (error?.code === 'ACCESS_DENIED' || error?.code === 'NOT_FOUND') return null;
-      throw error;
-    });
-    if (!stat) continue;
-    const isSymlink = dirent.isSymbolicLink() || stat.isSymbolicLink();
-    const type = !isSymlink && (dirent.isDirectory() || stat.isDirectory()) ? 'folder' : 'file';
-    const child = registry.register({
-      absolutePath,
-      rootPath: folder.rootPath,
-      rootId: folder.rootId,
-      parentId: folder.id,
-      name,
-      type,
-      displayPath: path.join(folder.displayPath, name),
-      locked: isSymlink
-    });
-    output.push(toPublicEntry({
-      ...child,
-      size: type === 'file' ? stat.size : 0,
-      modifiedAt: stat.mtime?.toISOString(),
-      hasChildren: type === 'folder' && !isSymlink
-    }));
-  }
-  output.sort((left, right) => {
-    if (left.type !== right.type) return left.type === 'folder' ? -1 : 1;
-    return left.name.localeCompare(right.name, undefined, { numeric: true, sensitivity: 'base' });
-  });
-  return {
-    folder: toPublicEntry({ ...folder, hasChildren: true }),
-    entries: output
-  };
-}
-
-async function walkDirectory(registry, entry, relativePrefix, output, visited, counters) {
-  const realPath = await fs.realpath(entry.absolutePath).catch(() => entry.absolutePath);
-  if (visited.has(realPath)) return;
-  visited.add(realPath);
-  let dirents;
-  try {
-    dirents = await fs.readdir(entry.absolutePath, { withFileTypes: true });
-  } catch (error) {
-    if (error?.code === 'EACCES' || error?.code === 'EPERM') throw filesystemError('filesystem-access-denied', 'ACCESS_DENIED', 403);
-    throw error;
-  }
-  for (const dirent of dirents) {
-    const name = safeEntryName(dirent.name);
-    if (!name || name === '.' || name === '..' || dirent.isSymbolicLink()) continue;
-    const absolutePath = path.resolve(entry.absolutePath, name);
-    if (!isPathWithinRoot(entry.rootPath, absolutePath)) continue;
-    const stat = await readEntryStat(absolutePath);
-    const relativePath = path.posix.join(relativePrefix, name);
-    if (stat.isDirectory()) {
-      counters.folders += 1;
-      const child = registry.register({
-        absolutePath,
-        rootPath: entry.rootPath,
-        rootId: entry.rootId,
-        parentId: entry.id,
-        name,
-        type: 'folder',
-        displayPath: path.join(entry.displayPath, name)
-      });
-      await walkDirectory(registry, child, relativePath, output, visited, counters);
-    } else if (stat.isFile()) {
-      const child = registry.register({
-        absolutePath,
-        rootPath: entry.rootPath,
-        rootId: entry.rootId,
-        parentId: entry.id,
-        name,
-        type: 'file',
-        displayPath: path.join(entry.displayPath, name)
-      });
-      output.push({
-        id: child.id,
-        absolutePath,
-        relativePath,
-        name,
-        size: stat.size,
-        modifiedMs: stat.mtimeMs,
-        modifiedAt: stat.mtime?.toISOString() || null
-      });
-      counters.files += 1;
-      counters.totalBytes += stat.size;
-    }
-    if ((counters.files + counters.folders) % 100 === 0) await yieldToEventLoop();
-  }
-}
-
-export async function scanSelection(registry, itemIds) {
-  const ids = [...new Set((Array.isArray(itemIds) ? itemIds : []).map(value => String(value || '').trim()).filter(Boolean))].slice(0, 5000);
-  if (ids.length === 0) throw filesystemError('no-filesystem-items-selected', 'NO_SELECTION', 400);
-  const selected = ids.map(id => registry.resolve(id));
-  const selectedPaths = selected.filter(entry => entry.type === 'folder').map(entry => path.resolve(entry.absolutePath));
-  const topLevel = selected.filter(entry => !selectedPaths.some(parent => parent !== entry.absolutePath && isPathWithinRoot(parent, entry.absolutePath)));
-  const files = [];
-  const counters = { files: 0, folders: 0, totalBytes: 0 };
-  const visited = new Set();
-  for (const entry of topLevel) {
-    const stat = await readEntryStat(entry.absolutePath);
-    if (entry.type === 'file' || stat.isFile()) {
-      files.push({
-        id: entry.id,
-        absolutePath: entry.absolutePath,
-        relativePath: entry.name,
-        name: entry.name,
-        size: stat.size,
-        modifiedMs: stat.mtimeMs,
-        modifiedAt: stat.mtime?.toISOString() || null
-      });
-      counters.files += 1;
-      counters.totalBytes += stat.size;
-      continue;
-    }
-    counters.folders += 1;
-    await walkDirectory(registry, entry, entry.name, files, visited, counters);
-  }
-  files.sort((left, right) => left.relativePath.localeCompare(right.relativePath, undefined, { numeric: true }));
-  return { ...counters, files };
-}
-
-export function toFilesystemHttpError(error) {
-  return error?.status
-    ? error
-    : filesystemError('filesystem-operation-failed', 'FILESYSTEM_ERROR', 500);
-}
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { setImmediate as yieldToEventLoop } from 'node:timers/promises';
+import { isPathWithinRoot } from './path-registry.js';
+
+function filesystemError(message, code = 'FILESYSTEM_ERROR', status = 400) {
+  const error = new Error(message);
+  error.code = code;
+  error.status = status;
+  return error;
+}
+
+function safeEntryName(name) {
+  return String(name || '').replace(/[\0\r\n\t]/g, ' ').slice(0, 512);
+}
+
+function toPublicEntry(entry) {
+  return {
+    id: entry.id,
+    parentId: entry.parentId,
+    name: entry.name,
+    type: entry.type,
+    size: entry.size || 0,
+    modifiedAt: entry.modifiedAt || null,
+    extension: entry.type === 'file' ? path.extname(entry.name).toLowerCase() : '',
+    hasChildren: entry.type !== 'file' && entry.hasChildren === true,
+    displayPath: entry.displayPath,
+    locked: entry.locked === true
+  };
+}
+
+async function readEntryStat(absolutePath) {
+  try {
+    return await fs.lstat(absolutePath);
+  } catch (error) {
+    if (error?.code === 'EACCES' || error?.code === 'EPERM') throw filesystemError('filesystem-access-denied', 'ACCESS_DENIED', 403);
+    if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR') throw filesystemError('filesystem-entry-unavailable', 'NOT_FOUND', 404);
+    throw error;
+  }
+}
+
+export async function readDirectoryEntries(registry, folderId) {
+  const folder = registry.resolve(folderId);
+  if (folder.type === 'file') throw filesystemError('filesystem-entry-is-not-folder', 'NOT_A_FOLDER', 400);
+  if (folder.locked) throw filesystemError('filesystem-access-denied', 'ACCESS_DENIED', 403);
+  let entries;
+  try {
+    entries = await fs.readdir(folder.absolutePath, { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === 'EACCES' || error?.code === 'EPERM') throw filesystemError('filesystem-access-denied', 'ACCESS_DENIED', 403);
+    if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR') throw filesystemError('filesystem-entry-unavailable', 'NOT_FOUND', 404);
+    throw error;
+  }
+
+  const output = [];
+  for (const dirent of entries) {
+    const name = safeEntryName(dirent.name);
+    if (!name || name === '.' || name === '..') continue;
+    const absolutePath = path.resolve(folder.absolutePath, name);
+    if (!isPathWithinRoot(folder.rootPath, absolutePath)) continue;
+    const stat = await readEntryStat(absolutePath).catch(error => {
+      if (error?.code === 'ACCESS_DENIED' || error?.code === 'NOT_FOUND') return null;
+      throw error;
+    });
+    if (!stat) continue;
+    const isSymlink = dirent.isSymbolicLink() || stat.isSymbolicLink();
+    const type = !isSymlink && (dirent.isDirectory() || stat.isDirectory()) ? 'folder' : 'file';
+    const child = registry.register({
+      absolutePath,
+      rootPath: folder.rootPath,
+      rootId: folder.rootId,
+      parentId: folder.id,
+      name,
+      type,
+      displayPath: path.join(folder.displayPath, name),
+      locked: isSymlink
+    });
+    output.push(toPublicEntry({
+      ...child,
+      size: type === 'file' ? stat.size : 0,
+      modifiedAt: stat.mtime?.toISOString(),
+      hasChildren: type === 'folder' && !isSymlink
+    }));
+  }
+  output.sort((left, right) => {
+    if (left.type !== right.type) return left.type === 'folder' ? -1 : 1;
+    return left.name.localeCompare(right.name, undefined, { numeric: true, sensitivity: 'base' });
+  });
+  return {
+    folder: toPublicEntry({ ...folder, hasChildren: true }),
+    entries: output
+  };
+}
+
+async function walkDirectory(registry, entry, relativePrefix, output, visited, counters) {
+  const realPath = await fs.realpath(entry.absolutePath).catch(() => entry.absolutePath);
+  if (visited.has(realPath)) return;
+  visited.add(realPath);
+  let dirents;
+  try {
+    dirents = await fs.readdir(entry.absolutePath, { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === 'EACCES' || error?.code === 'EPERM') throw filesystemError('filesystem-access-denied', 'ACCESS_DENIED', 403);
+    throw error;
+  }
+  for (const dirent of dirents) {
+    const name = safeEntryName(dirent.name);
+    if (!name || name === '.' || name === '..' || dirent.isSymbolicLink()) continue;
+    const absolutePath = path.resolve(entry.absolutePath, name);
+    if (!isPathWithinRoot(entry.rootPath, absolutePath)) continue;
+    const stat = await readEntryStat(absolutePath);
+    const relativePath = path.posix.join(relativePrefix, name);
+    if (stat.isDirectory()) {
+      counters.folders += 1;
+      const child = registry.register({
+        absolutePath,
+        rootPath: entry.rootPath,
+        rootId: entry.rootId,
+        parentId: entry.id,
+        name,
+        type: 'folder',
+        displayPath: path.join(entry.displayPath, name)
+      });
+      await walkDirectory(registry, child, relativePath, output, visited, counters);
+    } else if (stat.isFile()) {
+      const child = registry.register({
+        absolutePath,
+        rootPath: entry.rootPath,
+        rootId: entry.rootId,
+        parentId: entry.id,
+        name,
+        type: 'file',
+        displayPath: path.join(entry.displayPath, name)
+      });
+      output.push({
+        id: child.id,
+        absolutePath,
+        relativePath,
+        name,
+        size: stat.size,
+        modifiedMs: stat.mtimeMs,
+        modifiedAt: stat.mtime?.toISOString() || null
+      });
+      counters.files += 1;
+      counters.totalBytes += stat.size;
+    }
+    if ((counters.files + counters.folders) % 100 === 0) await yieldToEventLoop();
+  }
+}
+
+export async function scanSelection(registry, itemIds) {
+  const ids = [...new Set((Array.isArray(itemIds) ? itemIds : []).map(value => String(value || '').trim()).filter(Boolean))].slice(0, 5000);
+  if (ids.length === 0) throw filesystemError('no-filesystem-items-selected', 'NO_SELECTION', 400);
+  const selected = ids.map(id => registry.resolve(id));
+  const selectedPaths = selected.filter(entry => entry.type === 'folder').map(entry => path.resolve(entry.absolutePath));
+  const topLevel = selected.filter(entry => !selectedPaths.some(parent => parent !== entry.absolutePath && isPathWithinRoot(parent, entry.absolutePath)));
+  const files = [];
+  const counters = { files: 0, folders: 0, totalBytes: 0 };
+  const visited = new Set();
+  for (const entry of topLevel) {
+    const stat = await readEntryStat(entry.absolutePath);
+    if (entry.type === 'file' || stat.isFile()) {
+      files.push({
+        id: entry.id,
+        absolutePath: entry.absolutePath,
+        relativePath: entry.name,
+        name: entry.name,
+        size: stat.size,
+        modifiedMs: stat.mtimeMs,
+        modifiedAt: stat.mtime?.toISOString() || null
+      });
+      counters.files += 1;
+      counters.totalBytes += stat.size;
+      continue;
+    }
+    counters.folders += 1;
+    await walkDirectory(registry, entry, entry.name, files, visited, counters);
+  }
+  files.sort((left, right) => left.relativePath.localeCompare(right.relativePath, undefined, { numeric: true }));
+  return { ...counters, files };
+}
+
+export function toFilesystemHttpError(error) {
+  return error?.status
+    ? error
+    : filesystemError('filesystem-operation-failed', 'FILESYSTEM_ERROR', 500);
+}

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();
+}