@axhub/genie 0.2.7 → 0.2.8

package/server/utils/workspaceRoots.js

@@ -0,0 +1,154 @@
+import os from 'os';
+import path from 'path';
+
+export const UNIX_WORKSPACE_ROOTS = '__workspace_roots__';
+
+export function parseWorkspaceRoots(value) {
+  if (!value || typeof value !== 'string') {
+    return [];
+  }
+
+  const seen = new Set();
+  const roots = [];
+
+  for (const entry of value.split(',')) {
+    const trimmed = entry.trim();
+    if (!trimmed) continue;
+
+    const resolved = path.resolve(trimmed);
+    if (seen.has(resolved)) continue;
+
+    seen.add(resolved);
+    roots.push(resolved);
+  }
+
+  return roots;
+}
+
+export function getDefaultWorkspaceRoots({
+  platform = process.platform,
+  homeDir = os.homedir()
+} = {}) {
+  if (platform === 'win32') {
+    return [];
+  }
+
+  const roots = [path.resolve(homeDir)];
+
+  if (platform === 'darwin') {
+    roots.push('/Volumes');
+  } else if (platform === 'linux') {
+    roots.push('/mnt', '/media');
+    const userName = path.basename(homeDir);
+    if (userName) {
+      roots.push(path.join('/run/media', userName));
+    }
+  }
+
+  return [...new Set(roots.map((root) => path.resolve(root)))];
+}
+
+export function resolveWorkspaceRootSettings({
+  env = process.env,
+  platform = process.platform,
+  homeDir = os.homedir()
+} = {}) {
+  const configuredRoots = parseWorkspaceRoots(env.WORKSPACES_ROOTS);
+  const hasWorkspaceRootRestriction = configuredRoots.length > 0 || platform !== 'win32';
+  const allowedWorkspaceRoots = configuredRoots.length > 0
+    ? configuredRoots
+    : (hasWorkspaceRootRestriction ? getDefaultWorkspaceRoots({ platform, homeDir }) : []);
+
+  return {
+    defaultWorkspaceRoot: path.resolve(homeDir),
+    hasWorkspaceRootRestriction,
+    allowedWorkspaceRoots,
+  };
+}
+
+const workspaceRootSettings = resolveWorkspaceRootSettings();
+
+export const DEFAULT_WORKSPACES_ROOT = workspaceRootSettings.defaultWorkspaceRoot;
+export const HAS_WORKSPACES_ROOT_RESTRICTION = workspaceRootSettings.hasWorkspaceRootRestriction;
+export const WORKSPACES_ROOTS = workspaceRootSettings.allowedWorkspaceRoots;
+
+export function expandWorkspacePath(inputPath, homeDir = DEFAULT_WORKSPACES_ROOT) {
+  if (!inputPath) return inputPath;
+  if (inputPath === '~') {
+    return homeDir;
+  }
+  if (inputPath.startsWith('~/') || inputPath.startsWith('~\\')) {
+    return path.join(homeDir, inputPath.slice(2));
+  }
+  return inputPath;
+}
+
+export function isPathWithinAllowedRoots(candidatePath, allowedRoots) {
+  const normalizedCandidate = path.resolve(candidatePath);
+
+  return allowedRoots.some((allowedRoot) => {
+    const normalizedRoot = path.resolve(allowedRoot);
+    return normalizedCandidate === normalizedRoot
+      || normalizedCandidate.startsWith(normalizedRoot + path.sep);
+  });
+}
+
+export async function resolveAllowedWorkspaceRoots({
+  fsImpl,
+  allowedWorkspaceRoots = WORKSPACES_ROOTS
+} = {}) {
+  const resolvedRoots = [];
+  const seen = new Set();
+
+  for (const root of allowedWorkspaceRoots) {
+    let resolvedRoot;
+
+    try {
+      resolvedRoot = await fsImpl.realpath(root);
+    } catch (error) {
+      resolvedRoot = path.resolve(root);
+    }
+
+    if (seen.has(resolvedRoot)) continue;
+    seen.add(resolvedRoot);
+    resolvedRoots.push(resolvedRoot);
+  }
+
+  return resolvedRoots;
+}
+
+export function formatAllowedWorkspaceRoots(allowedRoots) {
+  return allowedRoots.join(', ');
+}
+
+export function shouldUseVirtualWorkspaceRoots({
+  dirPath,
+  hasWorkspaceRootRestriction = HAS_WORKSPACES_ROOT_RESTRICTION
+} = {}) {
+  return hasWorkspaceRootRestriction
+    && (!dirPath || dirPath === UNIX_WORKSPACE_ROOTS);
+}
+
+export function buildWorkspaceRootSuggestions({
+  allowedWorkspaceRoots = WORKSPACES_ROOTS,
+  homeDir = DEFAULT_WORKSPACES_ROOT
+} = {}) {
+  const resolvedHomeDir = path.resolve(homeDir);
+  const seen = new Set();
+  const suggestions = [];
+
+  for (const root of allowedWorkspaceRoots) {
+    const resolvedRoot = path.resolve(root);
+    if (seen.has(resolvedRoot)) continue;
+
+    seen.add(resolvedRoot);
+    suggestions.push({
+      path: resolvedRoot,
+      name: resolvedRoot === resolvedHomeDir ? 'Home' : (path.basename(resolvedRoot) || resolvedRoot),
+      type: 'directory',
+      isWorkspaceRoot: true
+    });
+  }
+
+  return suggestions;
+}