@dyyz1993/codenomad 0.15.0

package/dist/clients/connection-manager.js

@@ -0,0 +1,93 @@
+const STALE_CONNECTION_TIMEOUT_MS = 45000;
+const STALE_SWEEP_INTERVAL_MS = 5000;
+export class ClientConnectionManager {
+    constructor(logger) {
+        this.logger = logger;
+        this.connections = new Map();
+        this.subscribers = new Set();
+        this.sweepTimer = setInterval(() => this.sweepStaleConnections(), STALE_SWEEP_INTERVAL_MS);
+        this.sweepTimer.unref?.();
+    }
+    shutdown() {
+        clearInterval(this.sweepTimer);
+        for (const connection of Array.from(this.connections.values())) {
+            this.disconnect(connection.key, "shutdown", false);
+        }
+    }
+    subscribe(listener) {
+        this.subscribers.add(listener);
+        return () => this.subscribers.delete(listener);
+    }
+    register(input) {
+        const key = getConnectionKey(input);
+        const now = Date.now();
+        const existing = this.connections.get(key);
+        if (existing) {
+            this.logger.debug({ clientId: input.clientId, connectionId: input.connectionId }, "Replacing existing client connection");
+            this.disconnect(key, "replaced");
+        }
+        const connection = {
+            key,
+            clientId: input.clientId,
+            connectionId: input.connectionId,
+            connectedAt: now,
+            lastSeenAt: now,
+            close: input.close,
+        };
+        this.connections.set(key, connection);
+        this.logger.debug({ clientId: input.clientId, connectionId: input.connectionId }, "Client connected");
+        this.notify({ type: "connected", connection });
+        return () => this.disconnect(key, "closed");
+    }
+    pong(input) {
+        const key = getConnectionKey(input);
+        const connection = this.connections.get(key);
+        if (!connection) {
+            this.logger.debug({ clientId: input.clientId, connectionId: input.connectionId }, "Ignoring pong for unknown client connection");
+            return false;
+        }
+        connection.lastSeenAt = Date.now();
+        return true;
+    }
+    isConnected(input) {
+        return this.connections.has(getConnectionKey(input));
+    }
+    sweepStaleConnections() {
+        const cutoff = Date.now() - STALE_CONNECTION_TIMEOUT_MS;
+        for (const connection of Array.from(this.connections.values())) {
+            if (connection.lastSeenAt > cutoff)
+                continue;
+            this.logger.debug({ clientId: connection.clientId, connectionId: connection.connectionId }, "Client connection timed out");
+            this.disconnect(connection.key, "timeout");
+        }
+    }
+    disconnect(key, reason, invokeClose = true) {
+        const connection = this.connections.get(key);
+        if (!connection)
+            return;
+        this.connections.delete(key);
+        this.logger.debug({ clientId: connection.clientId, connectionId: connection.connectionId, reason }, "Client disconnected");
+        if (invokeClose) {
+            try {
+                connection.close();
+            }
+            catch (error) {
+                this.logger.warn({ err: error, clientId: connection.clientId, connectionId: connection.connectionId }, "Failed to close stale client connection");
+            }
+        }
+        this.notify({ type: "disconnected", connection, reason });
+    }
+    notify(event) {
+        for (const subscriber of this.subscribers) {
+            try {
+                subscriber(event);
+            }
+            catch (error) {
+                this.logger.warn({ err: error, eventType: event.type }, "Client connection subscriber failed");
+            }
+        }
+    }
+}
+function getConnectionKey(input) {
+    return `${input.clientId}:${input.connectionId}`;
+}

package/dist/config/location.js

@@ -0,0 +1,57 @@
+import os from "os";
+import path from "path";
+function resolvePath(inputPath) {
+    if (inputPath.startsWith("~/")) {
+        return path.join(os.homedir(), inputPath.slice(2));
+    }
+    return path.resolve(inputPath);
+}
+function isYamlPath(filePath) {
+    const lower = filePath.toLowerCase();
+    return lower.endsWith(".yaml") || lower.endsWith(".yml");
+}
+function isJsonPath(filePath) {
+    return filePath.toLowerCase().endsWith(".json");
+}
+/**
+ * Resolve CodeNomad's config location into a stable base directory + derived file paths.
+ *
+ * Supported inputs:
+ * - Directory: "~/.config/codenomad"
+ * - YAML file: "~/.config/codenomad/config.yaml" (or any *.yml/*.yaml)
+ * - Legacy JSON file: "~/.config/codenomad/config.json"
+ */
+export function resolveConfigLocation(raw) {
+    const trimmed = (raw ?? "").trim();
+    const fallback = "~/.config/codenomad/config.json";
+    const input = trimmed.length > 0 ? trimmed : fallback;
+    const resolvedInput = resolvePath(input);
+    if (isYamlPath(resolvedInput)) {
+        const baseDir = path.dirname(resolvedInput);
+        return {
+            baseDir,
+            configYamlPath: resolvedInput,
+            stateYamlPath: path.join(baseDir, "state.yaml"),
+            legacyJsonPath: path.join(baseDir, "config.json"),
+            instancesDir: path.join(baseDir, "instances"),
+        };
+    }
+    if (isJsonPath(resolvedInput)) {
+        const baseDir = path.dirname(resolvedInput);
+        return {
+            baseDir,
+            configYamlPath: path.join(baseDir, "config.yaml"),
+            stateYamlPath: path.join(baseDir, "state.yaml"),
+            legacyJsonPath: resolvedInput,
+            instancesDir: path.join(baseDir, "instances"),
+        };
+    }
+    const baseDir = resolvedInput;
+    return {
+        baseDir,
+        configYamlPath: path.join(baseDir, "config.yaml"),
+        stateYamlPath: path.join(baseDir, "state.yaml"),
+        legacyJsonPath: path.join(baseDir, "config.json"),
+        instancesDir: path.join(baseDir, "instances"),
+    };
+}

package/dist/config/schema.js

@@ -0,0 +1,71 @@
+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"),
+    logLevel: z.enum(["DEBUG", "INFO", "WARN", "ERROR"]).default("DEBUG"),
+    // 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/events/bus.js

@@ -0,0 +1,45 @@
+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("sidecar.updated", handler);
+        this.on("sidecar.removed", handler);
+        this.on("storage.configChanged", handler);
+        this.on("storage.stateChanged", 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("sidecar.updated", handler);
+            this.off("sidecar.removed", handler);
+            this.off("storage.configChanged", handler);
+            this.off("storage.stateChanged", handler);
+            this.off("instance.dataChanged", handler);
+            this.off("instance.event", handler);
+            this.off("instance.eventStatus", handler);
+        };
+    }
+}

package/dist/filesystem/__tests__/browser.test.js

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, it } from "node:test";
+import { FileSystemBrowser } from "../browser";
+import { WINDOWS_DRIVES_ROOT } from "../../api-types";
+const tempRoots = [];
+describe("FileSystemBrowser", () => {
+    afterEach(() => {
+        for (const directory of tempRoots.splice(0)) {
+            fs.rmSync(directory, { recursive: true, force: true });
+        }
+    });
+    it("starts unrestricted browsing from the configured root", () => {
+        const rootDir = createTempRoot();
+        fs.mkdirSync(path.join(rootDir, "project"));
+        const browser = new FileSystemBrowser({ rootDir, unrestricted: true });
+        const listing = browser.browse();
+        assert.equal(listing.metadata.scope, "unrestricted");
+        assert.equal(listing.metadata.currentPath, rootDir);
+        assert.equal(listing.metadata.rootPath, rootDir);
+        assert.equal(listing.metadata.displayPath, rootDir);
+        assert.equal(listing.metadata.pathKind, "absolute");
+        assert.ok(listing.entries.some((entry) => entry.name === "project" && entry.absolutePath === path.join(rootDir, "project")));
+    });
+    it("treats dot as the configured unrestricted root", () => {
+        const rootDir = createTempRoot();
+        const browser = new FileSystemBrowser({ rootDir, unrestricted: true });
+        const listing = browser.browse(".");
+        assert.equal(listing.metadata.currentPath, rootDir);
+        assert.equal(listing.metadata.rootPath, rootDir);
+    });
+    it("allows unrestricted browsing outside the configured root", () => {
+        const rootDir = createTempRoot();
+        const parentDir = path.dirname(rootDir);
+        const browser = new FileSystemBrowser({ rootDir, unrestricted: true });
+        const listing = browser.browse(parentDir);
+        assert.equal(listing.metadata.currentPath, parentDir);
+        assert.equal(listing.metadata.rootPath, rootDir);
+        assert.ok(listing.entries.some((entry) => entry.absolutePath === rootDir));
+    });
+    it("creates folders under the configured unrestricted root by default", () => {
+        const rootDir = createTempRoot();
+        const browser = new FileSystemBrowser({ rootDir, unrestricted: true });
+        const created = browser.createFolder(undefined, "created-folder");
+        assert.equal(created.path, path.join(rootDir, "created-folder"));
+        assert.equal(created.absolutePath, path.join(rootDir, "created-folder"));
+        assert.equal(fs.statSync(created.absolutePath).isDirectory(), true);
+    });
+    it("reports the configured root for the Windows drives pseudo-root", () => {
+        const rootDir = createTempRoot();
+        const browser = new FileSystemBrowser({ rootDir, unrestricted: true, platform: "win32" });
+        const listing = browser.browse(WINDOWS_DRIVES_ROOT);
+        assert.equal(listing.metadata.scope, "unrestricted");
+        assert.equal(listing.metadata.currentPath, WINDOWS_DRIVES_ROOT);
+        assert.equal(listing.metadata.rootPath, rootDir);
+        assert.equal(listing.metadata.pathKind, "drives");
+    });
+});
+function createTempRoot() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "codenomad-browser-"));
+    tempRoots.push(root);
+    return fs.realpathSync(root);
+}

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, 5001);
+        assert.ok(initial);
+        assert.equal(initial[0].name, "file-a");
+        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-b")], 6000);
+        const refreshed = getWorkspaceCandidates(workspacePath, 6001);
+        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,306 @@
+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 = (options.platform ?? 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 };
+    }
+    writeFile(relativePath, contents) {
+        if (this.unrestricted) {
+            throw new Error("writeFile is not available in unrestricted mode");
+        }
+        const resolved = this.toRestrictedAbsolute(relativePath);
+        fs.writeFileSync(resolved, contents, "utf-8");
+    }
+    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.root,
+            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.root,
+            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 ".";
+        }
+        if (path.isAbsolute(input)) {
+            const resolved = path.resolve(input);
+            const relativeToRoot = path.relative(this.root, resolved);
+            if (relativeToRoot === "") {
+                return ".";
+            }
+            if (this.isOutsideRoot(relativeToRoot)) {
+                throw new Error("Access outside of root is not allowed");
+            }
+            return relativeToRoot.replace(/\\+/g, "/");
+        }
+        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 (this.isOutsideRoot(relativeToRoot)) {
+            throw new Error("Access outside of root is not allowed");
+        }
+        return target;
+    }
+    isOutsideRoot(relativeToRoot) {
+        return relativeToRoot === ".." || relativeToRoot.startsWith(`..${path.sep}`) || path.isAbsolute(relativeToRoot);
+    }
+    resolveUnrestrictedPath(input) {
+        if (!input || input === "." || input === "./") {
+            return this.root;
+        }
+        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);
+    }
+}