@neuralnomads/codenomad-dev 0.10.3-dev-20260213-ba418a85

package/dist/config/schema.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+const ModelPreferenceSchema = z.object({
+    providerId: z.string(),
+    modelId: z.string(),
+});
+const AgentModelSelectionSchema = z.record(z.string(), ModelPreferenceSchema);
+const AgentModelSelectionsSchema = z.record(z.string(), AgentModelSelectionSchema);
+const PreferencesSchema = z
+    .object({
+    showThinkingBlocks: z.boolean().default(false),
+    thinkingBlocksExpansion: z.enum(["expanded", "collapsed"]).default("expanded"),
+    showTimelineTools: z.boolean().default(true),
+    promptSubmitOnEnter: z.boolean().default(false),
+    lastUsedBinary: z.string().optional(),
+    locale: z.string().optional(),
+    environmentVariables: z.record(z.string()).default({}),
+    modelRecents: z.array(ModelPreferenceSchema).default([]),
+    modelFavorites: z.array(ModelPreferenceSchema).default([]),
+    modelThinkingSelections: z.record(z.string(), z.string()).default({}),
+    diffViewMode: z.enum(["split", "unified"]).default("split"),
+    toolOutputExpansion: z.enum(["expanded", "collapsed"]).default("expanded"),
+    diagnosticsExpansion: z.enum(["expanded", "collapsed"]).default("expanded"),
+    showUsageMetrics: z.boolean().default(true),
+    autoCleanupBlankSessions: z.boolean().default(true),
+    listeningMode: z.enum(["local", "all"]).default("local"),
+    // OS notifications
+    osNotificationsEnabled: z.boolean().default(false),
+    osNotificationsAllowWhenVisible: z.boolean().default(false),
+    notifyOnNeedsInput: z.boolean().default(true),
+    notifyOnIdle: z.boolean().default(true),
+})
+    // Preserve unknown preference keys so newer configs survive older binaries.
+    .passthrough();
+const RecentFolderSchema = z.object({
+    path: z.string(),
+    lastAccessed: z.number().nonnegative(),
+});
+const OpenCodeBinarySchema = z.object({
+    path: z.string(),
+    version: z.string().optional(),
+    lastUsed: z.number().nonnegative(),
+    label: z.string().optional(),
+});
+const ConfigFileSchema = z
+    .object({
+    preferences: PreferencesSchema.default({}),
+    recentFolders: z.array(RecentFolderSchema).default([]),
+    opencodeBinaries: z.array(OpenCodeBinarySchema).default([]),
+    theme: z.enum(["light", "dark", "system"]).optional(),
+})
+    // Preserve unknown top-level keys so optional future features survive downgrades.
+    .passthrough();
+// On-disk config.yaml only stores stable configuration (not volatile state like recent folders).
+const ConfigYamlSchema = z
+    .object({
+    preferences: PreferencesSchema.default({}),
+    opencodeBinaries: z.array(OpenCodeBinarySchema).default([]),
+    theme: z.enum(["light", "dark", "system"]).optional(),
+})
+    .passthrough();
+// On-disk state.yaml stores server-scoped mutable state (per-server, not per-client).
+const StateFileSchema = z
+    .object({
+    recentFolders: z.array(RecentFolderSchema).default([]),
+})
+    .passthrough();
+const DEFAULT_CONFIG = ConfigFileSchema.parse({});
+const DEFAULT_CONFIG_YAML = ConfigYamlSchema.parse({});
+const DEFAULT_STATE = StateFileSchema.parse({});
+export { ModelPreferenceSchema, AgentModelSelectionSchema, AgentModelSelectionsSchema, PreferencesSchema, RecentFolderSchema, OpenCodeBinarySchema, ConfigFileSchema, ConfigYamlSchema, StateFileSchema, DEFAULT_CONFIG, DEFAULT_CONFIG_YAML, DEFAULT_STATE, };

package/dist/config/store.js

@@ -0,0 +1,200 @@
+import fs from "fs";
+import path from "path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { ConfigFileSchema, ConfigYamlSchema, DEFAULT_CONFIG, DEFAULT_CONFIG_YAML, DEFAULT_STATE, StateFileSchema, } from "./schema";
+export class ConfigStore {
+    constructor(location, eventBus, logger) {
+        this.location = location;
+        this.eventBus = eventBus;
+        this.logger = logger;
+        this.cache = DEFAULT_CONFIG;
+        this.state = DEFAULT_STATE;
+        this.loaded = false;
+    }
+    load() {
+        if (this.loaded) {
+            return this.cache;
+        }
+        try {
+            const configYamlPath = this.location.configYamlPath;
+            const stateYamlPath = this.location.stateYamlPath;
+            const legacyJsonPath = this.location.legacyJsonPath;
+            if (fs.existsSync(configYamlPath)) {
+                const configDoc = this.readYamlFile(configYamlPath, DEFAULT_CONFIG_YAML, ConfigYamlSchema, "config");
+                const stateDoc = fs.existsSync(stateYamlPath)
+                    ? this.readYamlFile(stateYamlPath, DEFAULT_STATE, StateFileSchema, "state")
+                    : DEFAULT_STATE;
+                this.state = stateDoc;
+                this.cache = this.mergeDocs(configDoc, stateDoc);
+                this.logger.debug({ configYamlPath, stateYamlPath }, "Loaded existing YAML config/state");
+            }
+            else if (fs.existsSync(legacyJsonPath)) {
+                const migrated = this.migrateFromLegacyJson(legacyJsonPath);
+                this.state = migrated.state;
+                this.cache = migrated.config;
+            }
+            else {
+                // Fresh install: write defaults.
+                this.state = DEFAULT_STATE;
+                this.cache = this.mergeDocs(DEFAULT_CONFIG_YAML, DEFAULT_STATE);
+                this.persist();
+                this.logger.debug({ configYamlPath, stateYamlPath }, "No config files found, created default YAML config/state");
+            }
+        }
+        catch (error) {
+            this.logger.warn({ err: error }, "Failed to load config/state, using defaults");
+            this.state = DEFAULT_STATE;
+            this.cache = this.mergeDocs(DEFAULT_CONFIG_YAML, DEFAULT_STATE);
+        }
+        this.loaded = true;
+        return this.cache;
+    }
+    get() {
+        return this.load();
+    }
+    replace(config) {
+        const validated = ConfigFileSchema.parse(config);
+        this.commit(validated);
+    }
+    /**
+     * Apply a merge-patch update to the current config.
+     * - Missing keys are preserved.
+     * - Object values are merged recursively.
+     * - Explicit `null` deletes keys.
+     * - Arrays are replaced.
+     */
+    mergePatch(patch) {
+        if (!patch || typeof patch !== "object" || Array.isArray(patch)) {
+            throw new Error("Config patch must be a JSON object");
+        }
+        const current = this.get();
+        const next = applyMergePatch(current, patch);
+        const validated = ConfigFileSchema.parse(next);
+        this.commit(validated);
+    }
+    commit(next) {
+        this.cache = next;
+        this.loaded = true;
+        this.state = {
+            ...this.state,
+            recentFolders: next.recentFolders,
+        };
+        this.persist();
+        const published = Boolean(this.eventBus);
+        this.eventBus?.publish({ type: "config.appChanged", config: this.cache });
+        this.logger.debug({ broadcast: published }, "Config SSE event emitted");
+        this.logger.trace({ config: this.cache }, "Config payload");
+    }
+    persist() {
+        try {
+            const configYamlPath = this.location.configYamlPath;
+            const stateYamlPath = this.location.stateYamlPath;
+            fs.mkdirSync(this.location.baseDir, { recursive: true });
+            fs.mkdirSync(path.dirname(configYamlPath), { recursive: true });
+            const configYaml = stringifyYaml(stripRecentFolders(this.cache));
+            const stateYaml = stringifyYaml(this.state);
+            fs.writeFileSync(configYamlPath, ensureTrailingNewline(configYaml), "utf-8");
+            fs.writeFileSync(stateYamlPath, ensureTrailingNewline(stateYaml), "utf-8");
+            this.logger.debug({ configYamlPath, stateYamlPath }, "Persisted YAML config/state");
+        }
+        catch (error) {
+            this.logger.warn({ err: error }, "Failed to persist config");
+        }
+    }
+    mergeDocs(configDoc, stateDoc) {
+        const merged = {
+            ...configDoc,
+            // State wins for recent folders.
+            recentFolders: stateDoc.recentFolders ?? [],
+        };
+        return ConfigFileSchema.parse(merged);
+    }
+    readYamlFile(filePath, fallback, schema, label) {
+        try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            const parsed = parseYaml(content);
+            return schema.parse(parsed ?? {});
+        }
+        catch (error) {
+            this.logger.warn({ err: error, filePath, label }, "Failed to read YAML file, using defaults");
+            return fallback;
+        }
+    }
+    migrateFromLegacyJson(legacyJsonPath) {
+        const configYamlPath = this.location.configYamlPath;
+        const stateYamlPath = this.location.stateYamlPath;
+        const content = fs.readFileSync(legacyJsonPath, "utf-8");
+        const parsed = JSON.parse(content);
+        const legacy = ConfigFileSchema.parse(parsed);
+        const state = StateFileSchema.parse({
+            ...DEFAULT_STATE,
+            recentFolders: legacy.recentFolders ?? [],
+        });
+        const merged = this.mergeDocs(stripRecentFolders(legacy), state);
+        // Persist YAML docs first, then move legacy aside.
+        try {
+            fs.mkdirSync(this.location.baseDir, { recursive: true });
+            fs.writeFileSync(configYamlPath, ensureTrailingNewline(stringifyYaml(stripRecentFolders(merged))), "utf-8");
+            fs.writeFileSync(stateYamlPath, ensureTrailingNewline(stringifyYaml(state)), "utf-8");
+            this.logger.info({ legacyJsonPath, configYamlPath, stateYamlPath }, "Migrated config.json -> YAML");
+        }
+        catch (error) {
+            this.logger.warn({ err: error }, "Failed to persist migrated YAML config/state");
+        }
+        try {
+            const bakPath = pickBackupPath(legacyJsonPath);
+            fs.renameSync(legacyJsonPath, bakPath);
+            this.logger.info({ legacyJsonPath, bakPath }, "Moved legacy config.json to backup");
+        }
+        catch (error) {
+            this.logger.warn({ err: error, legacyJsonPath }, "Failed to rename legacy config.json to backup");
+        }
+        return { config: merged, state };
+    }
+}
+function ensureTrailingNewline(content) {
+    if (!content)
+        return "\n";
+    return content.endsWith("\n") ? content : `${content}\n`;
+}
+function stripRecentFolders(config) {
+    const clone = { ...config };
+    delete clone.recentFolders;
+    return clone;
+}
+function isPlainObject(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    if (Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+function applyMergePatch(current, patch) {
+    // RFC 7396-ish merge patch with explicit null deletes.
+    if (!isPlainObject(patch)) {
+        return patch;
+    }
+    const base = isPlainObject(current) ? { ...current } : {};
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === null) {
+            delete base[key];
+            continue;
+        }
+        if (isPlainObject(value) && isPlainObject(base[key])) {
+            base[key] = applyMergePatch(base[key], value);
+            continue;
+        }
+        // Arrays and scalars replace.
+        base[key] = value;
+    }
+    return base;
+}
+function pickBackupPath(legacyJsonPath) {
+    const base = legacyJsonPath.endsWith(".json") ? legacyJsonPath.slice(0, -".json".length) : legacyJsonPath;
+    const preferred = `${base}.json.bak`;
+    if (!fs.existsSync(preferred)) {
+        return preferred;
+    }
+    return `${base}.json.bak.${Date.now()}`;
+}

package/dist/events/bus.js

@@ -0,0 +1,41 @@
+import { EventEmitter } from "events";
+export class EventBus extends EventEmitter {
+    constructor(logger) {
+        super();
+        this.logger = logger;
+    }
+    publish(event) {
+        if (event.type !== "instance.event" && event.type !== "instance.eventStatus") {
+            this.logger?.debug({ type: event.type }, "Publishing workspace event");
+            if (this.logger?.isLevelEnabled("trace")) {
+                this.logger.trace({ event }, "Workspace event payload");
+            }
+        }
+        return super.emit(event.type, event);
+    }
+    onEvent(listener) {
+        const handler = (event) => listener(event);
+        this.on("workspace.created", handler);
+        this.on("workspace.started", handler);
+        this.on("workspace.error", handler);
+        this.on("workspace.stopped", handler);
+        this.on("workspace.log", handler);
+        this.on("config.appChanged", handler);
+        this.on("config.binariesChanged", handler);
+        this.on("instance.dataChanged", handler);
+        this.on("instance.event", handler);
+        this.on("instance.eventStatus", handler);
+        return () => {
+            this.off("workspace.created", handler);
+            this.off("workspace.started", handler);
+            this.off("workspace.error", handler);
+            this.off("workspace.stopped", handler);
+            this.off("workspace.log", handler);
+            this.off("config.appChanged", handler);
+            this.off("config.binariesChanged", handler);
+            this.off("instance.dataChanged", handler);
+            this.off("instance.event", handler);
+            this.off("instance.eventStatus", handler);
+        };
+    }
+}

package/dist/filesystem/__tests__/search-cache.test.js

@@ -0,0 +1,40 @@
+import assert from "node:assert/strict";
+import { beforeEach, describe, it } from "node:test";
+import { clearWorkspaceSearchCache, getWorkspaceCandidates, refreshWorkspaceCandidates, WORKSPACE_CANDIDATE_CACHE_TTL_MS, } from "../search-cache";
+describe("workspace search cache", () => {
+    beforeEach(() => {
+        clearWorkspaceSearchCache();
+    });
+    it("expires cached candidates after the TTL", () => {
+        const workspacePath = "/tmp/workspace";
+        const startTime = 1000;
+        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-a")], startTime);
+        const beforeExpiry = getWorkspaceCandidates(workspacePath, startTime + WORKSPACE_CANDIDATE_CACHE_TTL_MS - 1);
+        assert.ok(beforeExpiry);
+        assert.equal(beforeExpiry.length, 1);
+        assert.equal(beforeExpiry[0].name, "file-a");
+        const afterExpiry = getWorkspaceCandidates(workspacePath, startTime + WORKSPACE_CANDIDATE_CACHE_TTL_MS + 1);
+        assert.equal(afterExpiry, undefined);
+    });
+    it("replaces cached entries when manually refreshed", () => {
+        const workspacePath = "/tmp/workspace";
+        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-a")], 5000);
+        const initial = getWorkspaceCandidates(workspacePath);
+        assert.ok(initial);
+        assert.equal(initial[0].name, "file-a");
+        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-b")], 6000);
+        const refreshed = getWorkspaceCandidates(workspacePath);
+        assert.ok(refreshed);
+        assert.equal(refreshed[0].name, "file-b");
+    });
+});
+function createEntry(name) {
+    return {
+        name,
+        path: name,
+        absolutePath: `/tmp/${name}`,
+        type: "file",
+        size: 1,
+        modifiedAt: new Date().toISOString(),
+    };
+}

package/dist/filesystem/browser.js

@@ -0,0 +1,285 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { WINDOWS_DRIVES_ROOT, } from "../api-types";
+const WINDOWS_DRIVE_LETTERS = Array.from({ length: 26 }, (_, i) => String.fromCharCode(65 + i));
+export class FileSystemBrowser {
+    constructor(options) {
+        this.root = path.resolve(options.rootDir);
+        this.unrestricted = Boolean(options.unrestricted);
+        this.homeDir = os.homedir();
+        this.isWindows = process.platform === "win32";
+    }
+    list(relativePath = ".", options = {}) {
+        if (this.unrestricted) {
+            throw new Error("Relative listing is unavailable when running with unrestricted root");
+        }
+        const includeFiles = options.includeFiles ?? true;
+        const normalizedPath = this.normalizeRelativePath(relativePath);
+        const absolutePath = this.toRestrictedAbsolute(normalizedPath);
+        return this.readDirectoryEntries(absolutePath, {
+            includeFiles,
+            formatPath: (entryName) => this.buildRelativePath(normalizedPath, entryName),
+            formatAbsolutePath: (entryName) => this.resolveRestrictedAbsoluteChild(normalizedPath, entryName),
+        });
+    }
+    browse(targetPath, options = {}) {
+        const includeFiles = options.includeFiles ?? true;
+        if (this.unrestricted) {
+            return this.listUnrestricted(targetPath, includeFiles);
+        }
+        return this.listRestrictedWithMetadata(targetPath, includeFiles);
+    }
+    createFolder(parentPath, folderName) {
+        const name = this.normalizeFolderName(folderName);
+        if (this.unrestricted) {
+            const resolvedParent = this.resolveUnrestrictedPath(parentPath);
+            if (this.isWindows && resolvedParent === WINDOWS_DRIVES_ROOT) {
+                throw new Error("Cannot create folders at drive root");
+            }
+            this.assertDirectoryExists(resolvedParent);
+            const absolutePath = this.resolveAbsoluteChild(resolvedParent, name);
+            fs.mkdirSync(absolutePath);
+            return { path: absolutePath, absolutePath };
+        }
+        const normalizedParent = this.normalizeRelativePath(parentPath);
+        const parentAbsolute = this.toRestrictedAbsolute(normalizedParent);
+        this.assertDirectoryExists(parentAbsolute);
+        const relativePath = this.buildRelativePath(normalizedParent, name);
+        const absolutePath = this.toRestrictedAbsolute(relativePath);
+        fs.mkdirSync(absolutePath);
+        return { path: relativePath, absolutePath };
+    }
+    readFile(relativePath) {
+        if (this.unrestricted) {
+            throw new Error("readFile is not available in unrestricted mode");
+        }
+        const resolved = this.toRestrictedAbsolute(relativePath);
+        return fs.readFileSync(resolved, "utf-8");
+    }
+    listRestrictedWithMetadata(relativePath, includeFiles) {
+        const normalizedPath = this.normalizeRelativePath(relativePath);
+        const absolutePath = this.toRestrictedAbsolute(normalizedPath);
+        const entries = this.readDirectoryEntries(absolutePath, {
+            includeFiles,
+            formatPath: (entryName) => this.buildRelativePath(normalizedPath, entryName),
+            formatAbsolutePath: (entryName) => this.resolveRestrictedAbsoluteChild(normalizedPath, entryName),
+        });
+        const metadata = {
+            scope: "restricted",
+            currentPath: normalizedPath,
+            parentPath: normalizedPath === "." ? undefined : this.getRestrictedParent(normalizedPath),
+            rootPath: this.root,
+            homePath: this.homeDir,
+            displayPath: this.resolveRestrictedAbsolute(normalizedPath),
+            pathKind: "relative",
+        };
+        return { entries, metadata };
+    }
+    listUnrestricted(targetPath, includeFiles) {
+        const resolvedPath = this.resolveUnrestrictedPath(targetPath);
+        if (this.isWindows && resolvedPath === WINDOWS_DRIVES_ROOT) {
+            return this.listWindowsDrives();
+        }
+        const entries = this.readDirectoryEntries(resolvedPath, {
+            includeFiles,
+            formatPath: (entryName) => this.resolveAbsoluteChild(resolvedPath, entryName),
+            formatAbsolutePath: (entryName) => this.resolveAbsoluteChild(resolvedPath, entryName),
+        });
+        const parentPath = this.getUnrestrictedParent(resolvedPath);
+        const metadata = {
+            scope: "unrestricted",
+            currentPath: resolvedPath,
+            parentPath,
+            rootPath: this.homeDir,
+            homePath: this.homeDir,
+            displayPath: resolvedPath,
+            pathKind: "absolute",
+        };
+        return { entries, metadata };
+    }
+    listWindowsDrives() {
+        if (!this.isWindows) {
+            throw new Error("Drive listing is only supported on Windows hosts");
+        }
+        const entries = [];
+        for (const letter of WINDOWS_DRIVE_LETTERS) {
+            const drivePath = `${letter}:\\`;
+            try {
+                if (fs.existsSync(drivePath)) {
+                    entries.push({
+                        name: `${letter}:`,
+                        path: drivePath,
+                        absolutePath: drivePath,
+                        type: "directory",
+                    });
+                }
+            }
+            catch {
+                // Ignore inaccessible drives
+            }
+        }
+        // Provide a generic UNC root entry so users can navigate to network shares manually.
+        entries.push({
+            name: "UNC Network",
+            path: "\\\\",
+            absolutePath: "\\\\",
+            type: "directory",
+        });
+        const metadata = {
+            scope: "unrestricted",
+            currentPath: WINDOWS_DRIVES_ROOT,
+            parentPath: undefined,
+            rootPath: this.homeDir,
+            homePath: this.homeDir,
+            displayPath: "Drives",
+            pathKind: "drives",
+        };
+        return { entries, metadata };
+    }
+    normalizeFolderName(input) {
+        const name = input.trim();
+        if (!name) {
+            throw new Error("Folder name is required");
+        }
+        if (name === "." || name === "..") {
+            throw new Error("Invalid folder name");
+        }
+        if (name.startsWith("~")) {
+            throw new Error("Invalid folder name");
+        }
+        if (name.includes("/") || name.includes("\\")) {
+            throw new Error("Folder name must not include path separators");
+        }
+        if (name.includes("\u0000")) {
+            throw new Error("Invalid folder name");
+        }
+        return name;
+    }
+    assertDirectoryExists(directory) {
+        if (!fs.existsSync(directory)) {
+            throw new Error(`Directory does not exist: ${directory}`);
+        }
+        const stats = fs.statSync(directory);
+        if (!stats.isDirectory()) {
+            throw new Error(`Path is not a directory: ${directory}`);
+        }
+    }
+    readDirectoryEntries(directory, options) {
+        const dirents = fs.readdirSync(directory, { withFileTypes: true });
+        const results = [];
+        for (const entry of dirents) {
+            const absoluteEntryPath = path.join(directory, entry.name);
+            let stats;
+            try {
+                // Use fs.statSync (not Dirent.isDirectory) so symlinks to directories
+                // are treated as directories in directory-only listings.
+                stats = fs.statSync(absoluteEntryPath);
+            }
+            catch {
+                // Skip entries we cannot stat (insufficient permissions, etc.)
+                continue;
+            }
+            const isDirectory = stats.isDirectory();
+            if (!options.includeFiles && !isDirectory) {
+                continue;
+            }
+            results.push({
+                name: entry.name,
+                path: options.formatPath(entry.name),
+                absolutePath: options.formatAbsolutePath(entry.name),
+                type: isDirectory ? "directory" : "file",
+                size: isDirectory ? undefined : stats.size,
+                modifiedAt: stats.mtime.toISOString(),
+            });
+        }
+        return results.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    normalizeRelativePath(input) {
+        if (!input || input === "." || input === "./" || input === "/") {
+            return ".";
+        }
+        let normalized = input.replace(/\\+/g, "/");
+        if (normalized.startsWith("./")) {
+            normalized = normalized.replace(/^\.\/+/, "");
+        }
+        if (normalized.startsWith("/")) {
+            normalized = normalized.replace(/^\/+/g, "");
+        }
+        return normalized === "" ? "." : normalized;
+    }
+    buildRelativePath(parent, child) {
+        if (!parent || parent === ".") {
+            return this.normalizeRelativePath(child);
+        }
+        return this.normalizeRelativePath(`${parent}/${child}`);
+    }
+    resolveRestrictedAbsolute(relativePath) {
+        return this.toRestrictedAbsolute(relativePath);
+    }
+    resolveRestrictedAbsoluteChild(parent, child) {
+        const normalized = this.buildRelativePath(parent, child);
+        return this.toRestrictedAbsolute(normalized);
+    }
+    toRestrictedAbsolute(relativePath) {
+        const normalized = this.normalizeRelativePath(relativePath);
+        const target = path.resolve(this.root, normalized);
+        const relativeToRoot = path.relative(this.root, target);
+        if (relativeToRoot.startsWith("..") || path.isAbsolute(relativeToRoot) && relativeToRoot !== "") {
+            throw new Error("Access outside of root is not allowed");
+        }
+        return target;
+    }
+    resolveUnrestrictedPath(input) {
+        if (!input || input === "." || input === "./") {
+            return this.homeDir;
+        }
+        if (this.isWindows) {
+            if (input === WINDOWS_DRIVES_ROOT) {
+                return WINDOWS_DRIVES_ROOT;
+            }
+            const normalized = path.win32.normalize(input);
+            if (/^[a-zA-Z]:/.test(normalized) || normalized.startsWith("\\\\")) {
+                return normalized;
+            }
+            return path.win32.resolve(this.homeDir, normalized);
+        }
+        if (input.startsWith("/")) {
+            return path.posix.normalize(input);
+        }
+        return path.posix.resolve(this.homeDir, input);
+    }
+    resolveAbsoluteChild(parent, child) {
+        if (this.isWindows) {
+            return path.win32.normalize(path.win32.join(parent, child));
+        }
+        return path.posix.normalize(path.posix.join(parent, child));
+    }
+    getRestrictedParent(relativePath) {
+        const normalized = this.normalizeRelativePath(relativePath);
+        if (normalized === ".") {
+            return undefined;
+        }
+        const segments = normalized.split("/");
+        segments.pop();
+        return segments.length === 0 ? "." : segments.join("/");
+    }
+    getUnrestrictedParent(currentPath) {
+        if (this.isWindows) {
+            const normalized = path.win32.normalize(currentPath);
+            const parsed = path.win32.parse(normalized);
+            if (normalized === WINDOWS_DRIVES_ROOT) {
+                return undefined;
+            }
+            if (normalized === parsed.root) {
+                return WINDOWS_DRIVES_ROOT;
+            }
+            return path.win32.dirname(normalized);
+        }
+        const normalized = path.posix.normalize(currentPath);
+        if (normalized === "/") {
+            return undefined;
+        }
+        return path.posix.dirname(normalized);
+    }
+}

package/dist/filesystem/search-cache.js

@@ -0,0 +1,43 @@
+import path from "path";
+export const WORKSPACE_CANDIDATE_CACHE_TTL_MS = 30000;
+const workspaceCandidateCache = new Map();
+export function getWorkspaceCandidates(rootDir, now = Date.now()) {
+    const key = normalizeKey(rootDir);
+    const cached = workspaceCandidateCache.get(key);
+    if (!cached) {
+        return undefined;
+    }
+    if (cached.expiresAt <= now) {
+        workspaceCandidateCache.delete(key);
+        return undefined;
+    }
+    return cloneEntries(cached.candidates);
+}
+export function refreshWorkspaceCandidates(rootDir, builder, now = Date.now()) {
+    const key = normalizeKey(rootDir);
+    const freshCandidates = builder();
+    if (!freshCandidates || freshCandidates.length === 0) {
+        workspaceCandidateCache.delete(key);
+        return [];
+    }
+    const storedCandidates = cloneEntries(freshCandidates);
+    workspaceCandidateCache.set(key, {
+        expiresAt: now + WORKSPACE_CANDIDATE_CACHE_TTL_MS,
+        candidates: storedCandidates,
+    });
+    return cloneEntries(storedCandidates);
+}
+export function clearWorkspaceSearchCache(rootDir) {
+    if (typeof rootDir === "undefined") {
+        workspaceCandidateCache.clear();
+        return;
+    }
+    const key = normalizeKey(rootDir);
+    workspaceCandidateCache.delete(key);
+}
+function cloneEntries(entries) {
+    return entries.map((entry) => ({ ...entry }));
+}
+function normalizeKey(rootDir) {
+    return path.resolve(rootDir);
+}