handoff-app 2.0.0-2 → 2.0.0-3

package/src/cli/scaffold.ts

@@ -2,10 +2,10 @@ import * as p from '@clack/prompts';
 import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
+import { isEntryCovered, writeEntries } from '../config/entries';
 import Handoff from '../index';
 
 // Constants
-const CONFIG_FILES = ['handoff.config.ts', 'handoff.config.js', 'handoff.config.cjs', 'handoff.config.json'] as const;
 const COMPONENTS_DIR = 'components';
 const DEFAULT_GROUPS = [
   { value: 'Atomic Elements', label: 'Atomic Elements' },
@@ -199,182 +199,6 @@ const countMatchingRegisteredComponents = (
   return registeredIds.filter((id) => figmaSet.has(id.toLowerCase())).length;
 };
 
-/**
- * Check if components will be auto-loaded by an existing entry
- * e.g., if 'components' directory is listed, all subdirectories are auto-loaded
- */
-const willComponentsAutoLoad = (existingPaths: string[]): boolean => {
-  // Normalize paths for comparison
-  const normalizedPaths = existingPaths.map((p) => p.replace(/\/$/, '').toLowerCase());
-  // If 'components' directory itself is in the list, all components auto-load
-  return normalizedPaths.includes(COMPONENTS_DIR);
-};
-
-/**
- * Format component paths as a properly indented array string for JS files
- */
-const formatComponentsArray = (paths: string[], indent: string = '      '): string => {
-  if (paths.length === 0) return '[]';
-  if (paths.length === 1) return `['${paths[0]}']`;
-  return `[\n${paths.map((p) => `${indent}'${p}',`).join('\n')}\n${indent.slice(2)}]`;
-};
-
-/**
- * Update handoff config file to add component paths
- */
-const updateConfigFile = async (
-  handoff: Handoff,
-  componentNames: string[]
-): Promise<{ success: boolean; isJsConfig: boolean; configPath: string; skipped: boolean }> => {
-  const configFile = CONFIG_FILES.find((file) =>
-    fs.existsSync(path.resolve(handoff.workingPath, file))
-  );
-
-  const newComponentPaths = componentNames.map((name) => `${COMPONENTS_DIR}/${name}`);
-
-  if (!configFile) {
-    // Create a new handoff.config.json
-    const newConfig = {
-      entries: {
-        components: newComponentPaths,
-      },
-    };
-    const configPath = path.resolve(handoff.workingPath, 'handoff.config.json');
-    await fs.writeJSON(configPath, newConfig, { spaces: 2 });
-    return { success: true, isJsConfig: false, configPath, skipped: false };
-  }
-
-  const configPath = path.resolve(handoff.workingPath, configFile);
-
-  if (configFile.endsWith('.json')) {
-    const config = await fs.readJSON(configPath);
-
-    // Initialize entries if not present
-    if (!config.entries) {
-      config.entries = {};
-    }
-    if (!config.entries.components) {
-      config.entries.components = [];
-    }
-
-    // Check if components will auto-load
-    if (willComponentsAutoLoad(config.entries.components)) {
-      return { success: true, isJsConfig: false, configPath, skipped: true };
-    }
-
-    // Add new component paths
-    const existingPaths = new Set(config.entries.components);
-    for (const componentPath of newComponentPaths) {
-      if (!existingPaths.has(componentPath)) {
-        config.entries.components.push(componentPath);
-      }
-    }
-
-    await fs.writeJSON(configPath, config, { spaces: 2 });
-    return { success: true, isJsConfig: false, configPath, skipped: false };
-  }
-
-  // For code config files, try to update them programmatically
-  if (configFile.endsWith('.ts') || configFile.endsWith('.js') || configFile.endsWith('.cjs')) {
-    try {
-      let content = await fs.readFile(configPath, 'utf8');
-
-      // Check if entries.components already exists
-      const hasEntriesComponents = /entries\s*:\s*\{[\s\S]*?components\s*:/.test(content);
-      
-      if (hasEntriesComponents) {
-        // Find and update the components array
-        // Match: components: [...] or components: ["..."]
-        const componentsArrayRegex = /(components\s*:\s*\[)([^\]]*)(\])/;
-        const match = content.match(componentsArrayRegex);
-        
-        if (match) {
-          const existingContent = match[2].trim();
-          const existingPaths = existingContent
-            .split(',')
-            .map((s) => s.trim().replace(/['"]/g, ''))
-            .filter((s) => s.length > 0);
-          
-          // Check if components will auto-load
-          if (willComponentsAutoLoad(existingPaths)) {
-            return { success: true, isJsConfig: true, configPath, skipped: true };
-          }
-          
-          const existingSet = new Set(existingPaths);
-          const pathsToAdd = newComponentPaths.filter((p) => !existingSet.has(p));
-          
-          if (pathsToAdd.length > 0) {
-            const allPaths = [...existingPaths, ...pathsToAdd];
-            // Format with proper indentation (detect existing indentation)
-            const indentMatch = content.match(/components\s*:\s*\[\s*\n(\s*)/);
-            const indent = indentMatch ? indentMatch[1] : '      ';
-            const formattedArray = formatComponentsArray(allPaths, indent);
-            content = content.replace(componentsArrayRegex, `components: ${formattedArray}`);
-            await fs.writeFile(configPath, content, 'utf8');
-          }
-          return { success: true, isJsConfig: true, configPath, skipped: false };
-        }
-      }
-      
-      // If entries exists but no components, or no entries at all
-      // Try to add the entries.components section
-      const hasEntries = /entries\s*:\s*\{/.test(content);
-      
-      if (hasEntries) {
-        // Add components to existing entries object with proper formatting
-        const formattedArray = formatComponentsArray(newComponentPaths);
-        content = content.replace(
-          /(entries\s*:\s*\{)/,
-          `$1\n    components: ${formattedArray},`
-        );
-        await fs.writeFile(configPath, content, 'utf8');
-        return { success: true, isJsConfig: true, configPath, skipped: false };
-      }
-      
-      // No entries object, try to add it before the closing of exported object
-      const formattedArray = formatComponentsArray(newComponentPaths);
-      const entriesBlock = `  entries: {\n    components: ${formattedArray},\n  },\n`;
-      
-      // Try to insert after module.exports = {
-      if (content.includes('module.exports = {')) {
-        content = content.replace(
-          /(module\.exports\s*=\s*\{)/,
-          `$1\n${entriesBlock}`
-        );
-        await fs.writeFile(configPath, content, 'utf8');
-        return { success: true, isJsConfig: true, configPath, skipped: false };
-      }
-
-      // Try to insert after export default {
-      if (/export\s+default\s+\{/.test(content)) {
-        content = content.replace(
-          /(export\s+default\s+\{)/,
-          `$1\n${entriesBlock}`
-        );
-        await fs.writeFile(configPath, content, 'utf8');
-        return { success: true, isJsConfig: true, configPath, skipped: false };
-      }
-
-      // Try to insert into defineConfig({ ... })
-      if (/defineConfig\s*\(\s*\{/.test(content)) {
-        content = content.replace(
-          /(defineConfig\s*\(\s*\{)/,
-          `$1\n${entriesBlock}`
-        );
-        await fs.writeFile(configPath, content, 'utf8');
-        return { success: true, isJsConfig: true, configPath, skipped: false };
-      }
-      
-      // Fallback: couldn't parse the JS config
-      return { success: false, isJsConfig: true, configPath, skipped: false };
-    } catch {
-      return { success: false, isJsConfig: true, configPath, skipped: false };
-    }
-  }
-
-  return { success: false, isJsConfig: false, configPath, skipped: false };
-};
-
 /**
  * Create component files
  */
@@ -609,21 +433,6 @@ export const runScaffold = async (handoff: Handoff): Promise<void> => {
     componentNames.push(config.name);
   }
 
-  // Update config if requested
-  let configUpdateResult: { success: boolean; isJsConfig: boolean; configPath: string; skipped: boolean } | null = null;
-  if (updateConfig) {
-    configUpdateResult = await updateConfigFile(handoff, componentNames);
-    if (!configUpdateResult.success) {
-      const relativePath = path.relative(handoff.workingPath, configUpdateResult.configPath);
-      p.log.warn(
-        `Could not automatically update ${relativePath}. Please manually add these paths to entries.components:`
-      );
-      for (const name of componentNames) {
-        console.log(chalk.yellow(`  'components/${name}'`));
-      }
-    }
-  }
-
   generationSpinner.stop('Files created successfully');
 
   // Display summary
@@ -633,12 +442,26 @@ export const runScaffold = async (handoff: Handoff): Promise<void> => {
     console.log(chalk.dim(`  ${relativePath}`));
   }
 
-  if (updateConfig && configUpdateResult?.success) {
-    const configFileName = path.basename(configUpdateResult.configPath);
-    if (configUpdateResult.skipped) {
-      p.log.info(`Config already includes 'components' directory - new components will auto-load`);
+  // Update config if requested. Components already covered by a collection directory auto-load,
+  // so we only write the uncovered ones into entries.components.
+  if (updateConfig) {
+    const componentDirs = componentNames.map((name) => path.resolve(handoff.workingPath, COMPONENTS_DIR, name));
+    const uncovered = componentDirs.filter((dir) => !isEntryCovered(handoff, 'components', dir));
+
+    if (uncovered.length === 0) {
+      p.log.info(`Config already covers these components - they'll auto-load`);
     } else {
-      p.log.success(`Updated ${configFileName} with component paths`);
+      const result = await writeEntries(handoff, 'components', uncovered);
+      if (result.status === 'added') {
+        const configFileName = result.configPath ? path.basename(result.configPath) : 'handoff.config.json';
+        p.log.success(`Updated ${configFileName} with component paths`);
+      } else {
+        const where = result.configPath ? path.relative(handoff.workingPath, result.configPath) : 'handoff.config';
+        p.log.warn(`Could not automatically update ${where}. Please manually add these paths to entries.components:`);
+        for (const rel of result.pending) {
+          console.log(chalk.yellow(`  '${rel}'`));
+        }
+      }
     }
   }
 

package/src/commands/index.ts

@@ -9,6 +9,8 @@ import ejectPagesCommand from './eject/pages';
 import ejectThemeCommand from './eject/theme';
 import fetchCommand from './fetch';
 import initCommand from './init';
+import loginCommand from './login';
+import logoutCommand from './logout';
 import makeComponentCommand from './make/component';
 import makePageCommand from './make/page';
 import makeTemplateCommand from './make/template';
@@ -29,6 +31,8 @@ export const commands = [
   ejectThemeCommand,
   fetchCommand,
   initCommand,
+  loginCommand,
+  logoutCommand,
   makePageCommand,
   makeComponentCommand,
   makeTemplateCommand,

package/src/commands/login/index.ts

@@ -0,0 +1,48 @@
+import { CommandModule } from 'yargs';
+import Handoff from '../../';
+import { loginWithDevice } from '../../cli/auth/device';
+import { cliAuthFilePath } from '../../cli/auth/store';
+import { resolveRegistryConnection } from '../../registry/connection';
+import { Logger } from '../../utils/logger';
+import { SharedArgs } from '../types';
+import { getSharedOptions } from '../utils';
+
+export interface LoginArgs extends SharedArgs {
+  url?: string;
+  browser?: boolean;
+}
+
+const command: CommandModule<{}, LoginArgs> = {
+  command: 'login',
+  describe: 'Sign in to a registry using browser device authorization',
+  builder: (yargs) =>
+    getSharedOptions(yargs)
+      .option('url', {
+        type: 'string',
+        describe: 'Registry URL, including its base path when configured',
+      })
+      .option('browser', {
+        type: 'boolean',
+        default: true,
+        describe: 'Open the approval URL in the default browser (disable with --no-browser)',
+      }),
+  handler: async (args: LoginArgs) => {
+    const handoff = new Handoff(args.debug, args.force);
+    try {
+      const configured = resolveRegistryConnection(handoff.config);
+      const remoteUrl = args.url?.trim() || configured.url;
+      if (!remoteUrl) {
+        throw new Error(`Pass --url <registry-url>, configure runtime.registryConnection.url, or set "${configured.urlEnv}".`);
+      }
+
+      await loginWithDevice(handoff.workingPath, remoteUrl, { openBrowser: args.browser !== false });
+      Logger.success(`Logged in. Credentials saved to ${cliAuthFilePath(handoff.workingPath)}.`);
+      Logger.info('Publish and checkout commands will use this login for the matching registry URL.');
+    } catch (error) {
+      Logger.error(error instanceof Error ? error.message : String(error));
+      process.exitCode = 1;
+    }
+  },
+};
+
+export default command;

package/src/commands/logout/index.ts

@@ -0,0 +1,51 @@
+import { CommandModule } from 'yargs';
+import Handoff from '../../';
+import { revokeAccessToken } from '../../cli/auth/device';
+import { clearCliAuth, cliAuthFilePath, cliAuthMatchesRegistry, normalizeRegistryUrl, readCliAuth } from '../../cli/auth/store';
+import { Logger } from '../../utils/logger';
+import { SharedArgs } from '../types';
+import { getSharedOptions } from '../utils';
+
+export interface LogoutArgs extends SharedArgs {
+  url?: string;
+}
+
+const command: CommandModule<{}, LogoutArgs> = {
+  command: 'logout',
+  describe: 'Revoke and remove saved registry credentials',
+  builder: (yargs) =>
+    getSharedOptions(yargs).option('url', {
+      type: 'string',
+      describe: 'Revoke credentials only when they belong to this exact registry URL',
+    }),
+  handler: async (args: LogoutArgs) => {
+    const handoff = new Handoff(args.debug, args.force);
+    const auth = await readCliAuth(handoff.workingPath);
+    if (args.url && auth && !cliAuthMatchesRegistry(auth, args.url)) {
+      Logger.error(`The saved login belongs to ${auth.remoteUrl}, not ${normalizeRegistryUrl(args.url)}. No credentials were changed.`);
+      process.exitCode = 1;
+      return;
+    }
+
+    if (auth) {
+      try {
+        await revokeAccessToken(auth);
+      } catch (error) {
+        Logger.warn(
+          `Could not revoke the registry token remotely (${error instanceof Error ? error.message : String(error)}). ` +
+            'It will still be removed from this workspace.'
+        );
+      }
+    }
+
+    try {
+      await clearCliAuth(handoff.workingPath);
+      Logger.success(`Logged out. Removed ${cliAuthFilePath(handoff.workingPath)}.`);
+    } catch (error) {
+      Logger.error(`Could not remove saved credentials: ${error instanceof Error ? error.message : String(error)}`);
+      process.exitCode = 1;
+    }
+  },
+};
+
+export default command;

package/src/config/entries.ts

@@ -0,0 +1,175 @@
+/**
+ * Registering directory-list entries (`entries.components` / `entries.patterns`) in the handoff
+ * config. Both scaffolding new component stubs and checking entities out of a registry need a
+ * freshly-written entity to be discoverable by the workspace build, so both have to handle every
+ * way a path can be declared:
+ *
+ * - a collection directory (e.g. `"components"`) whose subdirectories are entities: a new sibling
+ *   is auto-discovered at runtime, so nothing needs writing to the config;
+ * - an individual entity directory (e.g. `"components/button"`): the entity stays invisible until
+ *   its own path is added to the list.
+ *
+ * {@link isEntryCovered} answers "does this already load?" by reusing the runtime expansion
+ * ({@link getComponentsForPath}); {@link writeEntries} appends the paths that don't, across the
+ * `.json`, `.ts`, `.js`, and `.cjs` config formats.
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import { Config } from '../types/config';
+import { arePathsEqual } from '../utils/path';
+import { getComponentsForPath } from './runtime';
+
+/** The `entries` keys whose values are declared as a list of directory paths. */
+export type EntryKind = 'components' | 'patterns';
+
+/** Minimal handoff shape needed here; avoids importing the full Handoff class (circular dep). */
+interface ConfigContext {
+  config?: Config;
+  workingPath: string;
+}
+
+/** Config files in precedence order; the first that exists is the one we mutate. */
+const CONFIG_FILES = ['handoff.config.ts', 'handoff.config.js', 'handoff.config.cjs', 'handoff.config.json'] as const;
+
+/** Outcome of {@link writeEntries}: `added` on success, `unsupported` when the config couldn't be edited. */
+export interface WriteEntriesResult {
+  status: 'added' | 'unsupported';
+  /** The config file written (or that would need editing); null only when none exists and creation failed. */
+  configPath: string | null;
+  /** Workspace-relative POSIX paths written into the config. */
+  added: string[];
+  /** Workspace-relative POSIX paths the caller must add manually (`status: 'unsupported'`). */
+  pending: string[];
+}
+
+/** Workspace-relative, POSIX-separated path used as a config entry value. */
+const toEntryPath = (handoff: ConfigContext, targetDir: string): string =>
+  path.relative(handoff.workingPath, targetDir).split(path.sep).join('/');
+
+/**
+ * True when `targetDir` already loads through an existing `entries[kind]` declaration: listed
+ * directly, or sitting under a declared collection directory that runtime discovery expands.
+ * Reuses the same expansion the runtime uses, so every declaration style is covered.
+ */
+export const isEntryCovered = (handoff: ConfigContext, kind: EntryKind, targetDir: string): boolean => {
+  const configured = handoff.config?.entries?.[kind];
+  if (!configured?.length) {
+    return false;
+  }
+  return configured
+    .flatMap((entry) => getComponentsForPath(path.resolve(handoff.workingPath, entry)))
+    .some((dir) => arePathsEqual(dir, targetDir));
+};
+
+/** Format an entry array as source, matching the surrounding indentation of a code config. */
+const formatEntryArray = (paths: string[], indent: string): string => {
+  if (paths.length === 0) return '[]';
+  if (paths.length === 1) return `['${paths[0]}']`;
+  return `[\n${paths.map((entry) => `${indent}'${entry}',`).join('\n')}\n${indent.slice(2)}]`;
+};
+
+/** Append entry paths to a structured `.json` config (lossless read/modify/write). */
+const addToJsonConfig = async (configPath: string, kind: EntryKind, relPaths: string[]): Promise<boolean> => {
+  try {
+    const config = await fs.readJSON(configPath);
+    config.entries = config.entries ?? {};
+    const existing: string[] = Array.isArray(config.entries[kind]) ? config.entries[kind] : [];
+    const existingSet = new Set(existing);
+    for (const relPath of relPaths) {
+      if (!existingSet.has(relPath)) existing.push(relPath);
+    }
+    config.entries[kind] = existing;
+    await fs.writeJSON(configPath, config, { spaces: 2 });
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Best-effort splice of entry paths into an executable `.ts` / `.js` / `.cjs` config. These are
+ * modules, not data, so there's no lossless structured write; if a computed or spread `entries`
+ * array can't be edited textually, the caller falls back to printing the paths for the user to add.
+ */
+const addToCodeConfig = async (configPath: string, kind: EntryKind, relPaths: string[]): Promise<boolean> => {
+  try {
+    let content = await fs.readFile(configPath, 'utf8');
+    const arrayBlock = formatEntryArray(relPaths, '      ');
+
+    // 1) An `entries: { ... <kind>: [ ... ] }` array already exists, so merge into it.
+    const hasKeyArray = new RegExp(`entries\\s*:\\s*\\{[\\s\\S]*?${kind}\\s*:`).test(content);
+    const arrayRegex = new RegExp(`(${kind}\\s*:\\s*\\[)([^\\]]*)(\\])`);
+    const match = hasKeyArray ? content.match(arrayRegex) : null;
+    if (match) {
+      const existing = match[2]
+        .split(',')
+        .map((s) => s.trim().replace(/['"]/g, ''))
+        .filter(Boolean);
+      const existingSet = new Set(existing);
+      const toAdd = relPaths.filter((relPath) => !existingSet.has(relPath));
+      if (toAdd.length > 0) {
+        const indentMatch = content.match(new RegExp(`${kind}\\s*:\\s*\\[\\s*\\n(\\s*)`));
+        const indent = indentMatch ? indentMatch[1] : '      ';
+        content = content.replace(arrayRegex, `${kind}: ${formatEntryArray([...existing, ...toAdd], indent)}`);
+        await fs.writeFile(configPath, content, 'utf8');
+      }
+      return true;
+    }
+
+    // 2) An `entries` object exists but not this key, so add the key.
+    if (/entries\s*:\s*\{/.test(content)) {
+      content = content.replace(/(entries\s*:\s*\{)/, `$1\n    ${kind}: ${arrayBlock},`);
+      await fs.writeFile(configPath, content, 'utf8');
+      return true;
+    }
+
+    // 3) No `entries` object, so insert one into the exported config object.
+    const entriesBlock = `  entries: {\n    ${kind}: ${arrayBlock},\n  },\n`;
+    for (const anchor of [/module\.exports\s*=\s*\{/, /export\s+default\s+\{/, /defineConfig\s*\(\s*\{/]) {
+      if (anchor.test(content)) {
+        content = content.replace(anchor, (matched) => `${matched}\n${entriesBlock}`);
+        await fs.writeFile(configPath, content, 'utf8');
+        return true;
+      }
+    }
+
+    return false;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Add `targetDirs` to `entries[kind]` in the workspace config so the build discovers them. Callers
+ * should first drop already-loading dirs via {@link isEntryCovered}. Paths are stored workspace-
+ * relative; a `.json` config is edited losslessly, a code config best-effort. When no config file
+ * exists a minimal `handoff.config.json` is created.
+ */
+export const writeEntries = async (handoff: ConfigContext, kind: EntryKind, targetDirs: string[]): Promise<WriteEntriesResult> => {
+  const relPaths = [...new Set(targetDirs.map((dir) => toEntryPath(handoff, dir)))];
+  const configFile = CONFIG_FILES.find((file) => fs.existsSync(path.resolve(handoff.workingPath, file)));
+  const configPath = configFile ? path.resolve(handoff.workingPath, configFile) : null;
+
+  if (relPaths.length === 0) {
+    return { status: 'added', configPath, added: [], pending: [] };
+  }
+
+  if (!configPath) {
+    const newConfigPath = path.resolve(handoff.workingPath, 'handoff.config.json');
+    try {
+      await fs.writeJSON(newConfigPath, { entries: { [kind]: relPaths } }, { spaces: 2 });
+      return { status: 'added', configPath: newConfigPath, added: relPaths, pending: [] };
+    } catch {
+      return { status: 'unsupported', configPath: null, added: [], pending: relPaths };
+    }
+  }
+
+  const ok = configPath.endsWith('.json')
+    ? await addToJsonConfig(configPath, kind, relPaths)
+    : await addToCodeConfig(configPath, kind, relPaths);
+
+  return ok
+    ? { status: 'added', configPath, added: relPaths, pending: [] }
+    : { status: 'unsupported', configPath, added: [], pending: relPaths };
+};

package/src/config/index.ts

@@ -13,3 +13,7 @@ export { initRuntimeConfig } from './runtime';
 
 // Config validation
 export { validateConfig } from './validator';
+
+// Registering directory-list entries (components/patterns)
+export { isEntryCovered, writeEntries } from './entries';
+export type { EntryKind, WriteEntriesResult } from './entries';

package/src/config/runtime.ts

@@ -348,25 +348,26 @@ const collectPageMarkdownPaths = (rootDir: string, relativeParts: string[] = [])
 };
 
 /**
- * Returns a list of component directories for a given path.
- *
- * This function determines whether the provided `searchPath` is:
- * 1. A single component directory (contains a config file named after the directory)
- * 2. A collection of component directories (subdirectories are components)
- *
- * A directory is considered a component if it contains a config file matching
- * `{dirname}.json`, `{dirname}.js`, or `{dirname}.cjs`.
+ * True when `searchPath` is itself a single component directory: it holds a declaration file named
+ * after the directory (`{dirname}.handoff.*`, or a legacy `{dirname}.{json,js,cjs}`). This is what
+ * separates a declared component from a collection directory.
+ */
+export const isComponentDirectory = (searchPath: string): boolean =>
+  !!resolveComponentDeclaration(searchPath, path.basename(searchPath));
+
+/**
+ * Returns the component directories for a given path. If `searchPath` is itself a component
+ * directory it's returned as-is; otherwise each subdirectory is treated as a potential component.
  *
  * @param searchPath - The absolute path to check for components.
- * @returns An array of string paths to component directories.
+ * @returns Paths to the component directories.
  */
 export const getComponentsForPath = (searchPath: string): string[] => {
-  const dirName = path.basename(searchPath);
-  const hasOwnConfig = !!resolveComponentDeclaration(searchPath, dirName);
+  if (isComponentDirectory(searchPath)) {
+    return [searchPath];
+  }
 
-  // Check if searchPath itself is a component directory (has a config file named after the directory)
-  if (hasOwnConfig) {
-    // This directory is a single component
+  if (!fs.existsSync(searchPath)) {
     return [searchPath];
   }