sidekick-shared 0.24.5 → 0.25.0

package/dist/providers/openCode.js

@@ -60,6 +60,7 @@ const sessionContext_1 = require("../context/sessionContext");
 const openCodeParser_1 = require("../parsers/openCodeParser");
 const openCodeDatabase_1 = require("./openCodeDatabase");
 const zaiQuota_1 = require("../zaiQuota");
+const diagnostics_1 = require("./diagnostics");
 const modelContext_1 = require("../modelContext");
 // ---------------------------------------------------------------------------
 // Helper functions
@@ -169,6 +170,17 @@ function makeDbSessionPath(dataDir, projectId, sessionId) {
 function isDbSessionPath(sessionPath) {
     return sessionPath.includes(path.sep + DB_SESSION_PREFIX + path.sep);
 }
+function workspaceMatches(left, right) {
+    const a = path
+        .resolve(left)
+        .replace(/[\\/]+$/, '')
+        .toLowerCase();
+    const b = path
+        .resolve(right)
+        .replace(/[\\/]+$/, '')
+        .toLowerCase();
+    return a === b || a.startsWith(b + path.sep) || b.startsWith(a + path.sep);
+}
 /** Extract project ID from a synthetic DB session path. */
 function extractProjectIdFromDbPath(sessionPath) {
     const prefix = path.sep + DB_SESSION_PREFIX + path.sep;
@@ -650,10 +662,14 @@ class OpenCodeProvider {
     db = null;
     dbInitialized = false;
     dbStatus = { available: false, kind: 'db_missing' };
+    diagnostics;
     /** Cache of session metadata populated during listing */
     sessionMetaCache = new Map();
     /** Runtime-reported context window limit (overrides static map when set). */
     dynamicContextWindowLimit = null;
+    constructor(options = {}) {
+        this.diagnostics = new diagnostics_1.ProviderDiagnosticTracker(this.id, options);
+    }
     /** Lazy-initialize the database connection. */
     ensureDb() {
         if (this.dbInitialized)
@@ -667,12 +683,31 @@ class OpenCodeProvider {
         this.dbStatus = db.getRuntimeStatus();
         return this.db;
     }
+    async ensureDbAsync() {
+        if (this.db)
+            return this.db;
+        return new openCodeDatabase_1.OpenCodeDatabase(getOpenCodeDataDir());
+    }
+    /**
+     * Cache an async-created database only after an operation proved it usable.
+     * Sync paths treat a cached `db` as "open() succeeded", so adopting an
+     * unproven instance would cut them off from the file-storage fallback.
+     */
+    adoptDbIfAvailable(db) {
+        if (this.db || !db.getRuntimeStatus().available)
+            return;
+        this.db = db;
+        this.dbInitialized = true;
+    }
     getRuntimeStatus() {
         const db = this.ensureDb();
         if (db)
             return db.getRuntimeStatus();
         return this.dbStatus;
     }
+    getLastOperationStatus() {
+        return this.diagnostics.getLastOperationStatus();
+    }
     canMonitorDirectory(dir) {
         if (fs.existsSync(dir))
             return true;
@@ -738,8 +773,10 @@ class OpenCodeProvider {
         const db = this.ensureDb();
         const dbStatus = this.getRuntimeStatus();
         const projectId = resolveProjectId(workspacePath, db, dbStatus);
-        if (!projectId)
+        if (!projectId) {
+            this.recordDatabaseStatus('findActiveSession', dbStatus.kind === 'db_missing');
             return null;
+        }
         // DB primary
         if (db) {
             const session = db.getMostRecentSession(projectId);
@@ -749,14 +786,18 @@ class OpenCodeProvider {
                     title: session.title,
                     timeUpdated: session.time_updated,
                 });
+                this.recordDatabaseStatus('findActiveSession', true);
                 return syntheticPath;
             }
         }
         if (dbStatus.kind !== 'db_missing') {
+            this.recordDatabaseStatus('findActiveSession', dbStatus.available);
             return null;
         }
         // File fallback
-        return this.findActiveSessionFromFiles(projectId);
+        const result = this.findActiveSessionFromFiles(projectId);
+        this.recordDatabaseStatus('findActiveSession', true);
+        return result;
     }
     findActiveSessionFromFiles(projectId) {
         const sessionDir = path.join(getStorageDir(), 'session', projectId);
@@ -817,18 +858,64 @@ class OpenCodeProvider {
         const db = this.ensureDb();
         const dbStatus = this.getRuntimeStatus();
         const projectId = resolveProjectId(workspacePath, db, dbStatus);
-        if (!projectId)
+        if (!projectId) {
+            this.recordDatabaseStatus('findAllSessions', dbStatus.kind === 'db_missing');
             return [];
+        }
         // DB primary
         if (db) {
-            return this.mapDbSessions(projectId);
+            const sessions = this.mapDbSessions(projectId);
+            this.recordDatabaseStatus('findAllSessions', true);
+            return sessions;
         }
         if (dbStatus.kind !== 'db_missing') {
+            this.recordDatabaseStatus('findAllSessions', dbStatus.available);
             return [];
         }
         // File fallback
         const sessionDir = path.join(getStorageDir(), 'session', projectId);
-        return this.findSessionsInDirectoryFromFiles(sessionDir);
+        const sessions = this.findSessionsInDirectoryFromFiles(sessionDir);
+        this.recordDatabaseStatus('findAllSessions', true);
+        return sessions;
+    }
+    findSessionById(workspacePath, sessionId) {
+        const normalizedId = sessionId.trim();
+        if (!normalizedId || path.basename(normalizedId) !== normalizedId)
+            return null;
+        try {
+            const db = this.ensureDb();
+            if (db) {
+                const session = db.getSession(normalizedId);
+                if (session && workspaceMatches(session.directory, workspacePath)) {
+                    const syntheticPath = makeDbSessionPath(getOpenCodeDataDir(), session.project_id, session.id);
+                    this.sessionMetaCache.set(syntheticPath, {
+                        title: session.title,
+                        timeUpdated: session.time_updated,
+                    });
+                    this.recordDatabaseStatus('findSessionById', true);
+                    return syntheticPath;
+                }
+            }
+            const projectId = resolveProjectId(workspacePath, db, this.getRuntimeStatus());
+            if (projectId) {
+                const candidate = path.join(getStorageDir(), 'session', projectId, `${normalizedId}.json`);
+                try {
+                    if (fs.statSync(candidate).isFile()) {
+                        this.recordDatabaseStatus('findSessionById', true);
+                        return candidate;
+                    }
+                }
+                catch {
+                    // Missing legacy session is a normal miss.
+                }
+            }
+            this.recordDatabaseStatus('findSessionById', true);
+            return null;
+        }
+        catch {
+            this.recordDatabaseStatus('findSessionById', false);
+            return null;
+        }
     }
     findSessionsInDirectory(dir) {
         const db = this.ensureDb();
@@ -837,7 +924,9 @@ class OpenCodeProvider {
         if (db && dir.includes(path.sep + DB_SESSION_PREFIX + path.sep)) {
             const projectId = extractProjectIdFromDbPath(dir + path.sep + 'dummy.json');
             if (projectId) {
-                return this.mapDbSessions(projectId);
+                const sessions = this.mapDbSessions(projectId);
+                this.recordDatabaseStatus('findSessionsInDirectory', true);
+                return sessions;
             }
         }
         // For a DB-backed directory path ending with the project ID,
@@ -845,14 +934,19 @@ class OpenCodeProvider {
         if (db) {
             const dirName = path.basename(dir);
             if (db.hasProject(dirName)) {
-                return this.mapDbSessions(dirName);
+                const sessions = this.mapDbSessions(dirName);
+                this.recordDatabaseStatus('findSessionsInDirectory', true);
+                return sessions;
             }
         }
         if (dbStatus.kind !== 'db_missing') {
+            this.recordDatabaseStatus('findSessionsInDirectory', dbStatus.available);
             return [];
         }
         // File fallback
-        return this.findSessionsInDirectoryFromFiles(dir);
+        const sessions = this.findSessionsInDirectoryFromFiles(dir);
+        this.recordDatabaseStatus('findSessionsInDirectory', true);
+        return sessions;
     }
     findSessionsInDirectoryFromFiles(dir) {
         try {
@@ -879,6 +973,159 @@ class OpenCodeProvider {
             return [];
         }
     }
+    listAllSessionFiles() {
+        try {
+            const db = this.ensureDb();
+            if (db) {
+                const dataDir = getOpenCodeDataDir();
+                const files = db.getAllSessions().map((session) => {
+                    const syntheticPath = makeDbSessionPath(dataDir, session.project_id, session.id);
+                    this.sessionMetaCache.set(syntheticPath, {
+                        title: session.title,
+                        timeUpdated: session.time_updated,
+                    });
+                    return {
+                        path: syntheticPath,
+                        mtime: new Date(session.time_updated),
+                        label: session.title ?? undefined,
+                        sizeBytes: 0,
+                        sessionId: session.id,
+                        workspacePath: session.directory,
+                        createdAt: new Date(session.time_created),
+                    };
+                });
+                this.recordDatabaseStatus('listAllSessionFiles', true);
+                return files;
+            }
+            if (this.getRuntimeStatus().kind !== 'db_missing') {
+                this.recordDatabaseStatus('listAllSessionFiles', true);
+                return [];
+            }
+            const root = path.join(getStorageDir(), 'session');
+            const results = [];
+            let projectDirs = [];
+            try {
+                projectDirs = fs.readdirSync(root, { withFileTypes: true });
+            }
+            catch {
+                this.recordDatabaseStatus('listAllSessionFiles', true);
+                return [];
+            }
+            for (const entry of projectDirs) {
+                if (!entry.isDirectory())
+                    continue;
+                for (const sessionPath of this.findSessionsInDirectoryFromFiles(path.join(root, entry.name))) {
+                    try {
+                        const stats = fs.statSync(sessionPath);
+                        results.push({
+                            path: sessionPath,
+                            mtime: stats.mtime,
+                            sizeBytes: stats.size,
+                            sessionId: path.basename(sessionPath, '.json'),
+                        });
+                    }
+                    catch {
+                        // Session vanished between listing and stat.
+                    }
+                }
+            }
+            this.recordDatabaseStatus('listAllSessionFiles', true);
+            return results.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+        }
+        catch {
+            this.recordDatabaseStatus('listAllSessionFiles', false);
+            return [];
+        }
+    }
+    async listSessionFilesAsync(workspacePath) {
+        const db = await this.ensureDbAsync();
+        const sessions = await db.getAllSessionsAsync();
+        this.dbStatus = db.getRuntimeStatus();
+        this.adoptDbIfAvailable(db);
+        if (this.dbStatus.available) {
+            const dataDir = getOpenCodeDataDir();
+            const files = [];
+            for (const session of sessions) {
+                if (workspacePath && !workspaceMatches(session.directory, workspacePath))
+                    continue;
+                const syntheticPath = makeDbSessionPath(dataDir, session.project_id, session.id);
+                this.sessionMetaCache.set(syntheticPath, {
+                    title: session.title,
+                    timeUpdated: session.time_updated,
+                });
+                files.push({
+                    path: syntheticPath,
+                    mtime: new Date(session.time_updated),
+                    label: session.title ?? undefined,
+                    sizeBytes: 0,
+                    sessionId: session.id,
+                    workspacePath: session.directory,
+                    createdAt: new Date(session.time_created),
+                });
+            }
+            this.recordDatabaseStatus('listSessionFilesAsync', true);
+            return files;
+        }
+        const root = path.join(getStorageDir(), 'session');
+        const results = [];
+        let projectDirs = [];
+        try {
+            projectDirs = await fs.promises.readdir(root, { withFileTypes: true });
+        }
+        catch {
+            this.recordDatabaseStatus('listSessionFilesAsync', true);
+            return [];
+        }
+        for (const project of projectDirs) {
+            if (!project.isDirectory())
+                continue;
+            let entries = [];
+            try {
+                entries = await fs.promises.readdir(path.join(root, project.name), {
+                    withFileTypes: true,
+                });
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                if (!entry.isFile() || !entry.name.endsWith('.json'))
+                    continue;
+                const sessionPath = path.join(root, project.name, entry.name);
+                try {
+                    const [stat, raw] = await Promise.all([
+                        fs.promises.stat(sessionPath),
+                        workspacePath ? fs.promises.readFile(sessionPath, 'utf8') : Promise.resolve(null),
+                    ]);
+                    let session = null;
+                    if (raw !== null) {
+                        try {
+                            session = JSON.parse(raw);
+                        }
+                        catch {
+                            continue;
+                        }
+                        const directory = session.directory;
+                        if (directory && !workspaceMatches(directory, workspacePath))
+                            continue;
+                    }
+                    results.push({
+                        path: sessionPath,
+                        mtime: stat.mtime,
+                        sizeBytes: stat.size,
+                        sessionId: path.basename(entry.name, '.json'),
+                        workspacePath: session?.directory,
+                    });
+                }
+                catch {
+                    // Skip inaccessible sessions.
+                }
+                await new Promise((resolve) => setImmediate(resolve));
+            }
+        }
+        this.recordDatabaseStatus('listSessionFilesAsync', true);
+        return results.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    }
     getAllProjectFolders(workspacePath) {
         const db = this.ensureDb();
         const folders = [];
@@ -917,14 +1164,19 @@ class OpenCodeProvider {
                 }
                 return b.lastModified.getTime() - a.lastModified.getTime();
             });
-            if (folders.length > 0)
+            if (folders.length > 0) {
+                this.recordDatabaseStatus('getAllProjectFolders', true);
                 return folders;
+            }
         }
         if (dbStatus.kind !== 'db_missing') {
+            this.recordDatabaseStatus('getAllProjectFolders', dbStatus.available);
             return [];
         }
         // File fallback
-        return this.getAllProjectFoldersFromFiles(workspacePath);
+        const fallback = this.getAllProjectFoldersFromFiles(workspacePath);
+        this.recordDatabaseStatus('getAllProjectFolders', true);
+        return fallback;
     }
     getAllProjectFoldersFromFiles(workspacePath) {
         const folders = [];
@@ -1031,11 +1283,60 @@ class OpenCodeProvider {
         if (db) {
             const session = db.getSession(sessionId);
             if (session?.title) {
+                this.recordDatabaseStatus('extractSessionLabel', true);
                 return truncateTitle(session.title);
             }
         }
         // File fallback
-        return this.extractSessionLabelFromFiles(sessionPath, sessionId);
+        const label = this.extractSessionLabelFromFiles(sessionPath, sessionId);
+        this.recordDatabaseStatus('extractSessionLabel', label !== null || !isDbSessionPath(sessionPath));
+        return label;
+    }
+    async extractSessionLabelsAsync(sessionPaths) {
+        const results = new Map();
+        const unresolved = [];
+        for (const sessionPath of sessionPaths) {
+            const cached = this.sessionMetaCache.get(sessionPath);
+            if (cached)
+                results.set(sessionPath, cached.title ? truncateTitle(cached.title) : null);
+            else
+                unresolved.push(sessionPath);
+        }
+        if (unresolved.length > 0 && (!this.dbInitialized || this.dbStatus.available)) {
+            const db = await this.ensureDbAsync();
+            const byId = new Map(unresolved.map((item) => [this.getSessionId(item), item]));
+            const sessions = await db.getSessionsByIdsAsync([...byId.keys()]);
+            this.dbStatus = db.getRuntimeStatus();
+            this.adoptDbIfAvailable(db);
+            for (const session of sessions) {
+                const sessionPath = byId.get(session.id);
+                if (!sessionPath)
+                    continue;
+                this.sessionMetaCache.set(sessionPath, {
+                    title: session.title,
+                    timeUpdated: session.time_updated,
+                });
+                results.set(sessionPath, session.title ? truncateTitle(session.title) : null);
+            }
+        }
+        for (const sessionPath of unresolved) {
+            if (results.has(sessionPath))
+                continue;
+            if (isDbSessionPath(sessionPath)) {
+                results.set(sessionPath, null);
+                continue;
+            }
+            try {
+                const session = JSON.parse(await fs.promises.readFile(sessionPath, 'utf8'));
+                results.set(sessionPath, session.title ? truncateTitle(session.title) : null);
+            }
+            catch {
+                results.set(sessionPath, null);
+            }
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+        this.recordDatabaseStatus('extractSessionLabelsAsync', true);
+        return results;
     }
     extractSessionLabelFromFiles(sessionPath, sessionId) {
         if (isDbSessionPath(sessionPath))
@@ -1343,6 +1644,9 @@ class OpenCodeProvider {
     getProjectsBaseDir() {
         return path.join(getStorageDir(), 'session');
     }
+    getWatchRoots() {
+        return [getOpenCodeDataDir(), this.getProjectsBaseDir()];
+    }
     // --- Stats ---
     readSessionStats(sessionPath) {
         const sessionId = path.basename(sessionPath, '.json');
@@ -1453,6 +1757,37 @@ class OpenCodeProvider {
         }
         return null;
     }
+    async getSessionMetadataAsync(sessionPath) {
+        if (!isDbSessionPath(sessionPath)) {
+            try {
+                return { mtime: (await fs.promises.stat(sessionPath)).mtime };
+            }
+            catch {
+                return null;
+            }
+        }
+        const cached = this.sessionMetaCache.get(sessionPath);
+        try {
+            const db = await this.ensureDbAsync();
+            const sessionId = this.getSessionId(sessionPath);
+            const session = (await db.getSessionsByIdsAsync([sessionId]))[0];
+            this.dbStatus = db.getRuntimeStatus();
+            this.adoptDbIfAvailable(db);
+            if (session) {
+                this.sessionMetaCache.set(sessionPath, {
+                    title: session.title,
+                    timeUpdated: session.time_updated,
+                });
+                this.recordDatabaseStatus('getSessionMetadataAsync', true);
+                return { mtime: new Date(session.time_updated) };
+            }
+            this.recordDatabaseStatus('getSessionMetadataAsync', cached !== undefined);
+        }
+        catch {
+            this.recordDatabaseStatus('getSessionMetadataAsync', cached !== undefined);
+        }
+        return cached ? { mtime: new Date(cached.timeUpdated) } : null;
+    }
     /**
      * Returns the latest assistant message's token snapshot for context window sizing.
      * Cumulative session totals are derived from readNew() events processed by SessionMonitor.
@@ -1602,6 +1937,21 @@ class OpenCodeProvider {
         this.sessionMetaCache.clear();
         this.dynamicContextWindowLimit = null;
     }
+    recordDatabaseStatus(operation, usable) {
+        const status = this.db?.getRuntimeStatus() ?? this.dbStatus;
+        const diagnostic = (0, diagnostics_1.diagnosticFromRuntimeStatus)(this.id, 'query', status);
+        if (!diagnostic || status.kind === 'db_missing') {
+            // A genuinely absent OpenCode DB is expected for legacy file storage.
+            this.diagnostics.available(operation);
+            return;
+        }
+        this.diagnostics.degraded(operation, status, {
+            kind: diagnostic.kind,
+            severity: diagnostic.severity,
+            phase: diagnostic.phase,
+            message: diagnostic.message,
+        }, usable);
+    }
     // --- z.ai (GLM Coding Plan) compatibility quota derivation ---
     /**
      * Derives a z.ai coding-plan `QuotaState` from OpenCode assistant turns

package/dist/providers/openCodeDatabase.d.ts

@@ -17,12 +17,22 @@ export declare class OpenCodeDatabase {
     open(): boolean;
     close(): void;
     private query;
+    private queryAsync;
     private queryOne;
     findProjectByWorktree(workspacePath: string): DbProject | null;
     findProjectBySessionDirectory(workspacePath: string): DbProject | null;
     getAllProjects(): DbProject[];
     hasProject(projectId: string): boolean;
     getSessionsForProject(projectId: string): DbSession[];
+    /** Get every root session in one query for global preview enumeration. */
+    getAllSessions(): DbSession[];
+    /** Enumerate root sessions with one non-blocking sqlite3 subprocess. */
+    getAllSessionsAsync(): Promise<DbSession[]>;
+    /**
+     * Resolve many sessions with non-blocking sqlite3 subprocesses — one per
+     * chunk of ids, so the inlined query stays clear of argv length limits.
+     */
+    getSessionsByIdsAsync(sessionIds: readonly string[]): Promise<DbSession[]>;
     /** Get the most recently updated session for a project (excludes subagent child sessions). */
     getMostRecentSession(projectId: string): DbSession | null;
     /** Get child sessions (subagents) whose parent_id matches the given session ID. */

package/dist/providers/openCodeDatabase.js

@@ -41,6 +41,11 @@ exports.OpenCodeDatabase = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
+/**
+ * Ids per inlined `IN (…)` query. Values are passed inside a single argv
+ * element to sqlite3, so an unbounded list would hit E2BIG on large stores.
+ */
+const SQL_ID_CHUNK_SIZE = 400;
 class OpenCodeDatabase {
     dbPath;
     runtimeStatus = null;
@@ -127,6 +132,23 @@ class OpenCodeDatabase {
             return [];
         }
     }
+    async queryAsync(sql, params = []) {
+        if (!this.isAvailable()) {
+            this.runtimeStatus = { available: false, kind: 'db_missing' };
+            return [];
+        }
+        const query = bindSqlParams(sql, params);
+        try {
+            const result = await execSqlite(this.dbPath, query);
+            this.runtimeStatus = { available: true, kind: 'available' };
+            const trimmed = result.trim();
+            return trimmed ? JSON.parse(trimmed) : [];
+        }
+        catch (error) {
+            this.runtimeStatus = toRuntimeStatus(error, 'query_failed');
+            return [];
+        }
+    }
     queryOne(sql, params = []) {
         const results = this.query(sql, params);
         return results[0] ?? null;
@@ -181,6 +203,27 @@ class OpenCodeDatabase {
     getSessionsForProject(projectId) {
         return this.query('SELECT id, project_id, title, directory, time_created, time_updated FROM session WHERE project_id = ? AND parent_id IS NULL ORDER BY time_updated DESC', [projectId]);
     }
+    /** Get every root session in one query for global preview enumeration. */
+    getAllSessions() {
+        return this.query('SELECT id, project_id, title, directory, time_created, time_updated FROM session WHERE parent_id IS NULL ORDER BY time_updated DESC');
+    }
+    /** Enumerate root sessions with one non-blocking sqlite3 subprocess. */
+    getAllSessionsAsync() {
+        return this.queryAsync('SELECT id, project_id, title, directory, time_created, time_updated FROM session WHERE parent_id IS NULL ORDER BY time_updated DESC');
+    }
+    /**
+     * Resolve many sessions with non-blocking sqlite3 subprocesses — one per
+     * chunk of ids, so the inlined query stays clear of argv length limits.
+     */
+    async getSessionsByIdsAsync(sessionIds) {
+        const results = [];
+        for (let i = 0; i < sessionIds.length; i += SQL_ID_CHUNK_SIZE) {
+            const chunk = sessionIds.slice(i, i + SQL_ID_CHUNK_SIZE);
+            const placeholders = chunk.map(() => '?').join(', ');
+            results.push(...(await this.queryAsync(`SELECT id, project_id, title, directory, time_created, time_updated FROM session WHERE id IN (${placeholders})`, [...chunk])));
+        }
+        return results;
+    }
     /** Get the most recently updated session for a project (excludes subagent child sessions). */
     getMostRecentSession(projectId) {
         return this.queryOne('SELECT id, project_id, title, directory, time_created, time_updated FROM session WHERE project_id = ? AND parent_id IS NULL ORDER BY time_updated DESC LIMIT 1', [projectId]);
@@ -315,6 +358,32 @@ class OpenCodeDatabase {
     }
 }
 exports.OpenCodeDatabase = OpenCodeDatabase;
+function bindSqlParams(sql, params) {
+    let paramIndex = 0;
+    return sql.replace(/\?/g, () => {
+        if (paramIndex >= params.length)
+            return '?';
+        const param = params[paramIndex++];
+        if (typeof param === 'number')
+            return Number.isFinite(param) ? String(param) : '0';
+        return `'${String(param).replace(/'/g, "''")}'`;
+    });
+}
+function execSqlite(dbPath, query) {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.execFile)('sqlite3', ['-json', '-readonly', dbPath, query], {
+            encoding: 'utf8',
+            timeout: 4_000,
+            killSignal: 'SIGKILL',
+            maxBuffer: 50 * 1024 * 1024,
+        }, (error, stdout) => {
+            if (error)
+                reject(error);
+            else
+                resolve(stdout);
+        });
+    });
+}
 function normalizePath(input) {
     try {
         return fs.realpathSync(input);