@soederpop/luca 0.0.26 → 0.0.29

package/src/introspection/generated.web.ts

@@ -1,7 +1,7 @@
 import { setBuildTimeData, setContainerBuildTimeData } from './index.js';
 
 // Auto-generated introspection registry data
-// Generated at: 2026-03-22T20:57:23.113Z
+// Generated at: 2026-03-24T01:41:39.159Z
 
 setBuildTimeData('features.containerLink', {
   "id": "features.containerLink",

package/src/node/features/file-manager.ts

@@ -3,7 +3,7 @@ import { FeatureEventsSchema, FeatureStateSchema, FeatureOptionsSchema } from '.
 import { State } from "../../state.js";
 import { Feature } from "../feature.js";
 import { parse, relative, join as pathJoin } from "path";
-import { statSync, readFileSync, existsSync } from "fs";
+import { statSync, readFileSync, existsSync, readdirSync, lstatSync } from "fs";
 import micromatch from "micromatch";
 import { castArray } from "lodash-es";
 import chokidar from "chokidar";
@@ -339,7 +339,28 @@ export class FileManager<
           }
         }
       }
+
+      // git ls-files doesn't traverse symlinked directories — walk them via fs
+      // to pick up their contents. fs.walk now follows symlinks natively.
+      try {
+        const topEntries = readdirSync(cwd, { withFileTypes: true });
+        for (const entry of topEntries) {
+          if (entry.isSymbolicLink()) {
+            const fullPath = pathJoin(cwd, entry.name);
+            try {
+              const target = statSync(fullPath);
+              if (target.isDirectory()) {
+                const walked = await fs.walkAsync(fullPath, { exclude });
+                for (const absFile of walked.files) {
+                  fileIds.push(relative(cwd, absFile));
+                }
+              }
+            } catch {}
+          }
+        }
+      } catch {}
     } else {
+      // fs.walkAsync follows symlinks, so non-git repos get symlink support for free
       await fs.walkAsync(cwd).then(({ files } : { files: string[] }) => fileIds.push(...files));
     }
 

package/src/node/features/fs.ts

@@ -9,11 +9,13 @@ import {
   readFileSync,
   cpSync,
   renameSync,
+  lstatSync,
+  realpathSync,
 
   rmSync as nodeRmSync,
 } from "fs";
 import { join, resolve, dirname, relative } from "path";
-import { readFile, stat, unlink, mkdir, writeFile, appendFile, readdir, cp, rename, rm as nodeRm } from "fs/promises";
+import { readFile, stat, lstat, realpath, unlink, mkdir, writeFile, appendFile, readdir, cp, rename, rm as nodeRm } from "fs/promises";
 import { native as rimraf } from 'rimraf'
 
 type WalkOptions = {
@@ -40,6 +42,16 @@ function matchesPattern(filePath: string, patterns: string[]): boolean {
   })
 }
 
+/** Sync: check if a symlink target is a directory */
+function lstatFollowIsDir(fullPath: string): boolean {
+  try { return statSync(fullPath).isDirectory() } catch { return false }
+}
+
+/** Async: check if a symlink target is a directory */
+async function lstatFollowIsDirAsync(fullPath: string): Promise<boolean> {
+  try { return (await stat(fullPath)).isDirectory() } catch { return false }
+}
+
 /**
  * The FS feature provides methods for interacting with the file system, relative to the
  * container's cwd.
@@ -472,6 +484,28 @@ export class FS extends Feature {
     return stat(filePath).then(() => true).catch(() => false)
   }
 
+  /**
+   * Checks if a path is a symbolic link.
+   *
+   * @param {string} path - The path to check
+   * @returns {boolean} True if the path is a symlink
+   */
+  isSymlink(path: string): boolean {
+    const filePath = this.container.paths.resolve(path);
+    try { return lstatSync(filePath).isSymbolicLink() } catch { return false }
+  }
+
+  /**
+   * Resolves a symlink to its real path. Returns the resolved path as-is if not a symlink.
+   *
+   * @param {string} path - The path to resolve
+   * @returns {string} The real path after resolving all symlinks
+   */
+  realpath(path: string): string {
+    const filePath = this.container.paths.resolve(path);
+    return realpathSync(filePath)
+  }
+
   /**
    * Synchronously returns the stat object for a file or directory.
    *
@@ -811,7 +845,9 @@ export class FS extends Feature {
         const fullPath = join(baseDir, name);
         const relativePath = relative(resolvedBase, fullPath)
         const outputPath = useRelative ? relativePath : fullPath;
-        const isDir = entry.isDirectory();
+        // Follow symlinks: isDirectory() returns false for symlinks,
+        // so check isSymbolicLink() and resolve to the real target
+        const isDir = entry.isDirectory() || (entry.isSymbolicLink() && lstatFollowIsDir(fullPath));
 
         if (excludePatterns.length && matchesPattern(relativePath, excludePatterns)) {
           continue
@@ -888,7 +924,9 @@ export class FS extends Feature {
         const fullPath = join(currentDir, name);
         const relativePath = relative(resolvedBase, fullPath)
         const outputPath = useRelative ? relativePath : fullPath;
-        const isDir = entry.isDirectory();
+        // Follow symlinks: isDirectory() returns false for symlinks,
+        // so check isSymbolicLink() and resolve to the real target
+        const isDir = entry.isDirectory() || (entry.isSymbolicLink() && await lstatFollowIsDirAsync(fullPath));
 
         if (excludePatterns.length && matchesPattern(relativePath, excludePatterns)) {
           continue

package/src/node/features/helpers.ts

@@ -438,24 +438,22 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
       }
     } catch {}
 
-    // Try fileManager first (faster in git repos), fall back to Glob
+    // Try fileManager first (faster in git repos, and now symlink-aware),
+    // fall back to fs.walk which also follows symlinks natively.
     let files: string[] = []
     try {
       const fm = await this.ensureFileManager()
-      // fileManager may store absolute or relative keys — use absolute patterns
       const absPatterns = [`${dir}/*.ts`, `${dir}/**/*.ts`]
       const relPatterns = [`${type}/*.ts`, `${type}/**/*.ts`]
       const matched = fm.match([...absPatterns, ...relPatterns])
       files = matched.map((f: string) => f.startsWith('/') ? f : resolve(this.rootDir, f))
     } catch {}
 
-    // Fall back to Glob if fileManager found nothing
+    // Fall back to fs.walk if fileManager found nothing
     if (files.length === 0) {
-      const { Glob } = globalThis.Bun || (await import('bun'))
-      const glob = new Glob('**/*.ts')
-      for await (const file of glob.scan({ cwd: dir })) {
-        files.push(resolve(dir, file))
-      }
+      const { fs } = this.container
+      const walked = fs.walk(dir, { include: ['**/*.ts'] })
+      files = walked.files
     }
 
     for (const absPath of files) {
@@ -550,10 +548,15 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
    */
   private async discoverCommandsViaVM(dir: string): Promise<void> {
     this.seedVirtualModules()
-    const { Glob } = globalThis.Bun || (await import('bun'))
-    const glob = new Glob('*.ts')
-
-    for await (const file of glob.scan({ cwd: dir })) {
+    const { fs } = this.container
+    // Commands are top-level only (not recursive) — walk and filter to *.ts in the immediate dir
+    const walked = fs.walk(dir, { include: ['*.ts'] })
+    const tsFiles = walked.files
+      .map(f => parse(f))
+      .filter(p => p.dir === dir) // top-level only
+      .map(p => p.base)
+
+    for (const file of tsFiles) {
       if (file === 'index.ts') continue
 
       const absPath = resolve(dir, file)
@@ -619,10 +622,14 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
    */
   private async discoverSelectorsViaVM(dir: string): Promise<void> {
     this.seedVirtualModules()
-    const { Glob } = globalThis.Bun || (await import('bun'))
-    const glob = new Glob('*.ts')
+    const { fs } = this.container
+    const walked = fs.walk(dir, { include: ['*.ts'] })
+    const tsFiles = walked.files
+      .map(f => parse(f))
+      .filter(p => p.dir === dir)
+      .map(p => p.base)
 
-    for await (const file of glob.scan({ cwd: dir })) {
+    for (const file of tsFiles) {
       if (file === 'index.ts') continue
 
       const absPath = resolve(dir, file)
@@ -661,10 +668,10 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
    * Actual mounting to an express server is handled separately by ExpressServer.useEndpoints().
    */
   private async discoverEndpoints(dir: string): Promise<void> {
-    const { Glob } = globalThis.Bun || (await import('bun'))
-    const glob = new Glob('**/*.ts')
+    const { fs } = this.container
+    const walked = fs.walk(dir, { include: ['**/*.ts'] })
 
-    for await (const file of glob.scan({ cwd: dir, absolute: true })) {
+    for (const file of walked.files) {
       try {
         const mod = await this.loadModuleExports(file)
         const endpointModule = mod.default || mod