spck 0.3.1

package/dist/utils/logger.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Simple, readable logging utility for network operations
+ */
+/**
+ * Log a filesystem read operation
+ */
+export declare function logFsRead(method: string, params: {
+    path?: string;
+    src?: string;
+    target?: string;
+    oldpath?: string;
+    [key: string]: any;
+}, uid: string, success: boolean, error?: any, metadata?: Record<string, any>): void;
+/**
+ * Log a filesystem write operation
+ */
+export declare function logFsWrite(method: string, params: {
+    path?: string;
+    src?: string;
+    target?: string;
+    oldpath?: string;
+    [key: string]: any;
+}, uid: string, success: boolean, error?: any, metadata?: Record<string, any>): void;
+/**
+ * Log a git read operation
+ */
+export declare function logGitRead(method: string, params: {
+    dir?: string;
+    [key: string]: any;
+}, uid: string, success: boolean, error?: any, metadata?: Record<string, any>): void;
+/**
+ * Log a git write operation
+ */
+export declare function logGitWrite(method: string, params: {
+    dir?: string;
+    message?: string;
+    filepaths?: string[];
+    ref?: string;
+    [key: string]: any;
+}, uid: string, success: boolean, error?: any, metadata?: Record<string, any>): void;
+/**
+ * Log a terminal read operation
+ */
+export declare function logTerminalRead(method: string, params: {
+    terminalId?: string;
+    [key: string]: any;
+}, uid: string, success: boolean, error?: any, metadata?: Record<string, any>): void;
+/**
+ * Log a terminal write operation
+ */
+export declare function logTerminalWrite(method: string, params: {
+    terminalId?: string;
+    data?: string;
+    cols?: number;
+    rows?: number;
+    [key: string]: any;
+}, uid: string, success: boolean, error?: any, metadata?: Record<string, any>): void;
+/**
+ * Log a search operation
+ */
+export declare function logSearchRead(method: string, params: {
+    path?: string;
+    searchTerm?: string;
+    [key: string]: any;
+}, uid: string, success: boolean, error?: any, metadata?: Record<string, any>): void;
+/**
+ * Log an authentication event
+ */
+export declare function logAuth(event: string, details: Record<string, any>, level?: 'info' | 'warn' | 'error'): void;
+/**
+ * Log connection events (client connecting, authenticated, disconnected)
+ */
+export declare function logConnection(event: 'connecting' | 'authenticated' | 'auth_failed' | 'disconnected' | 'ready', deviceId?: string, metadata?: Record<string, any>): void;
+/**
+ * Log a browser proxy request
+ */
+export declare function logBrowserProxy(params: {
+    url?: string;
+    method?: string;
+    requestId?: string;
+    [key: string]: any;
+}, uid: string, success: boolean, error?: any, metadata?: Record<string, any>): void;
+declare const _default: {
+    logFsRead: typeof logFsRead;
+    logFsWrite: typeof logFsWrite;
+    logGitRead: typeof logGitRead;
+    logGitWrite: typeof logGitWrite;
+    logTerminalRead: typeof logTerminalRead;
+    logTerminalWrite: typeof logTerminalWrite;
+    logSearchRead: typeof logSearchRead;
+    logBrowserProxy: typeof logBrowserProxy;
+    logAuth: typeof logAuth;
+    logConnection: typeof logConnection;
+};
+export default _default;
+//# sourceMappingURL=logger.d.ts.map

package/dist/utils/logger.js

@@ -0,0 +1,456 @@
+/**
+ * Simple, readable logging utility for network operations
+ */
+import chalk from 'chalk';
+import * as path from 'path';
+import * as fs from 'fs';
+const LOG_RETENTION_DAYS = 30;
+let logDirInitialized = false;
+let cleanupScheduled = false;
+/**
+ * Get log directory path (lazy - doesn't create it)
+ */
+function getLogDir() {
+    return path.join(process.cwd(), '.spck-editor', 'logs');
+}
+/**
+ * Ensure log directory exists (lazy initialization)
+ * Called only when actually writing logs
+ */
+function ensureLogDirectory() {
+    if (logDirInitialized) {
+        return;
+    }
+    try {
+        const logDir = getLogDir();
+        // Check if .spck-editor exists and is accessible
+        const spckEditorDir = path.join(process.cwd(), '.spck-editor');
+        if (!fs.existsSync(spckEditorDir)) {
+            // .spck-editor directory not set up yet - skip logging to file
+            return;
+        }
+        // Create logs subdirectory if needed
+        if (!fs.existsSync(logDir)) {
+            fs.mkdirSync(logDir, { recursive: true });
+        }
+        logDirInitialized = true;
+        // Schedule cleanup only once, after first successful initialization
+        if (!cleanupScheduled) {
+            cleanupScheduled = true;
+            // Run cleanup after a short delay (not immediately on import)
+            setTimeout(() => {
+                cleanOldLogs();
+                setInterval(cleanOldLogs, 24 * 60 * 60 * 1000).unref();
+            }, 1000).unref();
+        }
+    }
+    catch (error) {
+        // Silently fail if we can't create log directory
+        // Logging will just go to console only
+    }
+}
+/**
+ * Get current log file path with date
+ */
+function getCurrentLogFile() {
+    const date = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
+    return path.join(getLogDir(), `spck-cli-${date}.log`);
+}
+/**
+ * Clean up old log files (retention policy)
+ */
+function cleanOldLogs() {
+    try {
+        const logDir = getLogDir();
+        if (!fs.existsSync(logDir)) {
+            return;
+        }
+        const files = fs.readdirSync(logDir);
+        const now = Date.now();
+        const retentionMs = LOG_RETENTION_DAYS * 24 * 60 * 60 * 1000;
+        for (const file of files) {
+            if (file.startsWith('spck-cli-') && file.endsWith('.log')) {
+                const filePath = path.join(logDir, file);
+                const stats = fs.statSync(filePath);
+                if (now - stats.mtimeMs > retentionMs) {
+                    fs.unlinkSync(filePath);
+                    console.log(chalk.gray(`[Logger] Deleted old log file: ${file}`));
+                }
+            }
+        }
+    }
+    catch (error) {
+        // Silently fail cleanup errors
+    }
+}
+/**
+ * Format timestamp for display (compact format for files)
+ * Format: MM-DD HH:MM:SS
+ */
+function formatTime() {
+    const now = new Date();
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const day = String(now.getDate()).padStart(2, '0');
+    const hours = String(now.getHours()).padStart(2, '0');
+    const minutes = String(now.getMinutes()).padStart(2, '0');
+    const seconds = String(now.getSeconds()).padStart(2, '0');
+    return `${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+/**
+ * Format timestamp for terminal display (compact format)
+ */
+function formatTimeCompact() {
+    const now = new Date();
+    // Format: HH:MM:SS
+    return now.toTimeString().substring(0, 8);
+}
+/**
+ * Format UID for display (truncate if needed)
+ */
+function formatUid(uid, maxLen = 12) {
+    if (uid.length <= maxLen)
+        return uid;
+    return uid.substring(0, maxLen - 3) + '...';
+}
+/**
+ * Write log entry to file
+ */
+function writeToFile(message) {
+    try {
+        // Lazy initialization - only create log directory when actually writing
+        ensureLogDirectory();
+        if (!logDirInitialized) {
+            // Log directory couldn't be initialized, skip file logging
+            return;
+        }
+        const logFile = getCurrentLogFile();
+        const timestamp = formatTime();
+        fs.appendFileSync(logFile, `[${timestamp}] ${message}\n`);
+    }
+    catch (error) {
+        // Silently fail file writes to not disrupt service
+    }
+}
+/**
+ * Format path for display (truncate if too long)
+ */
+function formatPath(p, maxLen = 50) {
+    if (!p)
+        return '';
+    if (p.length <= maxLen)
+        return p;
+    return '...' + p.substring(p.length - maxLen + 3);
+}
+/**
+ * Format byte count as human-readable size string
+ */
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+// Debounce state for browser proxy console output
+const BROWSER_PROXY_DEBOUNCE_MS = 1000;
+let _browserDebounceTimer = null;
+let _browserSuccessCount = 0;
+let _browserTotalBytes = 0;
+let _browserLastUid = '';
+function flushBrowserProxyLog() {
+    if (_browserSuccessCount === 0)
+        return;
+    const timestamp = chalk.gray(formatTimeCompact());
+    const uidStr = chalk.gray(formatUid(_browserLastUid));
+    const sizeStr = chalk.gray(formatBytes(_browserTotalBytes));
+    const countStr = chalk.white(String(_browserSuccessCount));
+    console.log(`${timestamp} ${uidStr} ${chalk.green('✓')} ${chalk.blueBright('BROWSER')} ${countStr} files fetched (${sizeStr})`);
+    _browserSuccessCount = 0;
+    _browserTotalBytes = 0;
+    _browserLastUid = '';
+    _browserDebounceTimer = null;
+}
+/**
+ * Log a filesystem read operation
+ */
+export function logFsRead(method, params, uid, success, error, metadata) {
+    const filepath = params.path || params.src || params.oldpath;
+    const displayPath = formatPath(filepath);
+    const metaStr = metadata ? ` ${chalk.gray(JSON.stringify(metadata))}` : '';
+    const timestamp = chalk.gray(formatTimeCompact());
+    const uidStr = chalk.gray(formatUid(uid));
+    if (success) {
+        const msg = `${timestamp} ${uidStr} ${chalk.green('✓')} ${chalk.cyan('FS')} ${chalk.white(method.padEnd(12))} ${chalk.gray(displayPath)}${metaStr}`;
+        console.log(msg);
+        writeToFile(`[INFO] FS READ ${method} ${filepath} uid=${uid} success=true${metaStr}`);
+    }
+    else {
+        const errMsg = error?.message || String(error);
+        const msg = `${timestamp} ${uidStr} ${chalk.red('✗')} ${chalk.cyan('FS')} ${chalk.white(method.padEnd(12))} ${chalk.gray(displayPath)} ${chalk.red(errMsg)}`;
+        console.log(msg);
+        writeToFile(`[ERROR] FS READ ${method} ${filepath} uid=${uid} success=false error="${errMsg}"`);
+    }
+}
+/**
+ * Log a filesystem write operation
+ */
+export function logFsWrite(method, params, uid, success, error, metadata) {
+    const filepath = params.path || params.src || params.target || params.oldpath;
+    const displayPath = formatPath(filepath);
+    const srcTarget = params.src && params.target
+        ? `${formatPath(params.src, 25)} → ${formatPath(params.target, 25)}`
+        : displayPath;
+    const metaStr = metadata ? ` ${chalk.gray(JSON.stringify(metadata))}` : '';
+    const timestamp = chalk.gray(formatTimeCompact());
+    const uidStr = chalk.gray(formatUid(uid));
+    if (success) {
+        const msg = `${timestamp} ${uidStr} ${chalk.green('✓')} ${chalk.yellow('FS')} ${chalk.white(method.padEnd(12))} ${chalk.gray(srcTarget)}${metaStr}`;
+        console.log(msg);
+        writeToFile(`[INFO] FS WRITE ${method} ${filepath} uid=${uid} success=true${metaStr}`);
+    }
+    else {
+        const errMsg = error?.message || String(error);
+        const msg = `${timestamp} ${uidStr} ${chalk.red('✗')} ${chalk.yellow('FS')} ${chalk.white(method.padEnd(12))} ${chalk.gray(srcTarget)} ${chalk.red(errMsg)}`;
+        console.log(msg);
+        writeToFile(`[ERROR] FS WRITE ${method} ${filepath} uid=${uid} success=false error="${errMsg}"`);
+    }
+}
+/**
+ * Log a git read operation
+ */
+export function logGitRead(method, params, uid, success, error, metadata) {
+    const dir = formatPath(params.dir);
+    const metaStr = metadata ? ` ${chalk.gray(JSON.stringify(metadata))}` : '';
+    const timestamp = chalk.gray(formatTimeCompact());
+    const uidStr = chalk.gray(formatUid(uid));
+    if (success) {
+        const msg = `${timestamp} ${uidStr} ${chalk.green('✓')} ${chalk.magenta('GIT')} ${chalk.white(method.padEnd(12))} ${chalk.gray(dir)}${metaStr}`;
+        console.log(msg);
+        writeToFile(`[INFO] GIT READ ${method} dir=${params.dir} uid=${uid} success=true${metaStr}`);
+    }
+    else {
+        const errMsg = error?.message || String(error);
+        const msg = `${timestamp} ${uidStr} ${chalk.red('✗')} ${chalk.magenta('GIT')} ${chalk.white(method.padEnd(12))} ${chalk.gray(dir)} ${chalk.red(errMsg)}`;
+        console.log(msg);
+        writeToFile(`[ERROR] GIT READ ${method} dir=${params.dir} uid=${uid} success=false error="${errMsg}"`);
+    }
+}
+/**
+ * Log a git write operation
+ */
+export function logGitWrite(method, params, uid, success, error, metadata) {
+    const dir = formatPath(params.dir);
+    const details = [];
+    if (params.message)
+        details.push(`msg="${params.message.substring(0, 30)}${params.message.length > 30 ? '...' : ''}"`);
+    if (params.filepaths?.length)
+        details.push(`files=${params.filepaths.length}`);
+    if (params.ref)
+        details.push(`ref=${params.ref}`);
+    const detailStr = details.length ? ` ${chalk.gray(details.join(' '))}` : '';
+    const metaStr = metadata ? ` ${chalk.gray(JSON.stringify(metadata))}` : '';
+    const timestamp = chalk.gray(formatTimeCompact());
+    const uidStr = chalk.gray(formatUid(uid));
+    if (success) {
+        const msg = `${timestamp} ${uidStr} ${chalk.green('✓')} ${chalk.yellow('GIT')} ${chalk.white(method.padEnd(12))} ${chalk.gray(dir)}${detailStr}${metaStr}`;
+        console.log(msg);
+        writeToFile(`[INFO] GIT WRITE ${method} dir=${params.dir} uid=${uid} success=true${detailStr}${metaStr}`);
+    }
+    else {
+        const errMsg = error?.message || String(error);
+        const msg = `${timestamp} ${uidStr} ${chalk.red('✗')} ${chalk.yellow('GIT')} ${chalk.white(method.padEnd(12))} ${chalk.gray(dir)} ${chalk.red(errMsg)}`;
+        console.log(msg);
+        writeToFile(`[ERROR] GIT WRITE ${method} dir=${params.dir} uid=${uid} success=false error="${errMsg}"`);
+    }
+}
+/**
+ * Log a terminal read operation
+ */
+export function logTerminalRead(method, params, uid, success, error, metadata) {
+    const termId = params.terminalId || 'all';
+    const metaStr = metadata ? ` ${chalk.gray(JSON.stringify(metadata))}` : '';
+    const timestamp = chalk.gray(formatTimeCompact());
+    const uidStr = chalk.gray(formatUid(uid));
+    if (success) {
+        const msg = `${timestamp} ${uidStr} ${chalk.green('✓')} ${chalk.blue('TERM')} ${chalk.white(method.padEnd(12))} ${chalk.gray(termId)}${metaStr}`;
+        console.log(msg);
+        writeToFile(`[INFO] TERMINAL READ ${method} terminalId=${termId} uid=${uid} success=true${metaStr}`);
+    }
+    else {
+        const errMsg = error?.message || String(error);
+        const msg = `${timestamp} ${uidStr} ${chalk.red('✗')} ${chalk.blue('TERM')} ${chalk.white(method.padEnd(12))} ${chalk.gray(termId)} ${chalk.red(errMsg)}`;
+        console.log(msg);
+        writeToFile(`[ERROR] TERMINAL READ ${method} terminalId=${termId} uid=${uid} success=false error="${errMsg}"`);
+    }
+}
+/**
+ * Log a terminal write operation
+ */
+export function logTerminalWrite(method, params, uid, success, error, metadata) {
+    const termId = params.terminalId || metadata?.terminalId || 'new';
+    const details = [];
+    if (params.cols && params.rows)
+        details.push(`${params.cols}x${params.rows}`);
+    if (params.data)
+        details.push(`${params.data.length}b`);
+    const detailStr = details.length ? ` ${chalk.gray(details.join(' '))}` : '';
+    const metaStr = metadata && !metadata.terminalId ? ` ${chalk.gray(JSON.stringify(metadata))}` : '';
+    const timestamp = chalk.gray(formatTimeCompact());
+    const uidStr = chalk.gray(formatUid(uid));
+    if (success) {
+        const msg = `${timestamp} ${uidStr} ${chalk.green('✓')} ${chalk.yellow('TERM')} ${chalk.white(method.padEnd(12))} ${chalk.gray(termId)}${detailStr}${metaStr}`;
+        console.log(msg);
+        writeToFile(`[INFO] TERMINAL WRITE ${method} terminalId=${termId} uid=${uid} success=true${detailStr}${metaStr}`);
+    }
+    else {
+        const errMsg = error?.message || String(error);
+        const msg = `${timestamp} ${uidStr} ${chalk.red('✗')} ${chalk.yellow('TERM')} ${chalk.white(method.padEnd(12))} ${chalk.gray(termId)} ${chalk.red(errMsg)}`;
+        console.log(msg);
+        writeToFile(`[ERROR] TERMINAL WRITE ${method} terminalId=${termId} uid=${uid} success=false error="${errMsg}"`);
+    }
+}
+/**
+ * Log a search operation
+ */
+export function logSearchRead(method, params, uid, success, error, metadata) {
+    const filepath = formatPath(params.path);
+    const searchTerm = params.searchTerm ? `"${params.searchTerm.substring(0, 30)}${params.searchTerm.length > 30 ? '...' : ''}'"` : '';
+    const details = [];
+    if (searchTerm)
+        details.push(searchTerm);
+    if (metadata?.matches !== undefined)
+        details.push(`matches=${metadata.matches}`);
+    if (metadata?.method)
+        details.push(metadata.method);
+    const detailStr = details.length ? ` ${chalk.gray(details.join(' '))}` : '';
+    const metaStr = metadata && !metadata.matches && !metadata.method ? ` ${chalk.gray(JSON.stringify(metadata))}` : '';
+    const timestamp = chalk.gray(formatTimeCompact());
+    const uidStr = chalk.gray(formatUid(uid));
+    if (success) {
+        const msg = `${timestamp} ${uidStr} ${chalk.green('✓')} ${chalk.green('SEARCH')} ${chalk.white(method.padEnd(12))} ${chalk.gray(filepath)}${detailStr}${metaStr}`;
+        console.log(msg);
+        writeToFile(`[INFO] SEARCH ${method} ${params.path} searchTerm="${params.searchTerm}" uid=${uid} success=true${detailStr}${metaStr}`);
+    }
+    else {
+        const errMsg = error?.message || String(error);
+        const msg = `${timestamp} ${uidStr} ${chalk.red('✗')} ${chalk.green('SEARCH')} ${chalk.white(method.padEnd(12))} ${chalk.gray(filepath)} ${chalk.red(errMsg)}`;
+        console.log(msg);
+        writeToFile(`[ERROR] SEARCH ${method} ${params.path} searchTerm="${params.searchTerm}" uid=${uid} success=false error="${errMsg}"`);
+    }
+}
+/**
+ * Log an authentication event
+ */
+export function logAuth(event, details, level = 'info') {
+    const timestamp = chalk.gray(formatTimeCompact());
+    const deviceId = details.deviceId ? chalk.gray(formatUid(details.deviceId)) : '';
+    const userId = details.userId ? chalk.gray(`user=${details.userId}`) : '';
+    const metaStr = Object.entries(details)
+        .filter(([key]) => key !== 'deviceId' && key !== 'userId')
+        .map(([key, val]) => `${key}=${val}`)
+        .join(' ');
+    let symbol;
+    let color;
+    let logLevel;
+    if (level === 'error') {
+        symbol = chalk.red('✗');
+        color = chalk.red;
+        logLevel = 'ERROR';
+    }
+    else if (level === 'warn') {
+        symbol = chalk.yellow('⚠');
+        color = chalk.yellow;
+        logLevel = 'WARN';
+    }
+    else {
+        symbol = chalk.green('✓');
+        color = chalk.green;
+        logLevel = 'INFO';
+    }
+    const msg = `${timestamp} ${deviceId} ${userId} ${symbol} ${color('AUTH')} ${chalk.white(event.padEnd(20))} ${chalk.gray(metaStr)}`;
+    console.log(msg);
+    writeToFile(`[${logLevel}] AUTH ${event} ${metaStr}`);
+}
+/**
+ * Log connection events (client connecting, authenticated, disconnected)
+ */
+export function logConnection(event, deviceId, metadata) {
+    const timestamp = chalk.gray(formatTimeCompact());
+    const deviceStr = deviceId ? chalk.gray(formatUid(deviceId)) : chalk.gray('...');
+    const metaStr = metadata ? ` ${chalk.gray(JSON.stringify(metadata))}` : '';
+    let symbol;
+    let color;
+    let logLevel;
+    switch (event) {
+        case 'connecting':
+            symbol = '🔌';
+            color = chalk.blue;
+            logLevel = 'INFO';
+            break;
+        case 'authenticated':
+            symbol = chalk.green('✓');
+            color = chalk.green;
+            logLevel = 'INFO';
+            break;
+        case 'auth_failed':
+            symbol = chalk.red('✗');
+            color = chalk.red;
+            logLevel = 'ERROR';
+            break;
+        case 'disconnected':
+            symbol = '🔌';
+            color = chalk.gray;
+            logLevel = 'INFO';
+            break;
+        case 'ready':
+            symbol = '🎉';
+            color = chalk.green;
+            logLevel = 'INFO';
+            break;
+        default:
+            symbol = 'ℹ';
+            color = chalk.gray;
+            logLevel = 'INFO';
+    }
+    const msg = `${timestamp} ${deviceStr} ${symbol} ${color('CONN')} ${chalk.white(event.padEnd(15))}${metaStr}`;
+    console.log(msg);
+    writeToFile(`[${logLevel}] CONN ${event} deviceId=${deviceId || 'unknown'}${metaStr}`);
+}
+/**
+ * Log a browser proxy request
+ */
+export function logBrowserProxy(params, uid, success, error, metadata) {
+    const httpMethod = (params.method || 'GET').toUpperCase();
+    if (success) {
+        writeToFile(`[INFO] BROWSER PROXY ${httpMethod} ${params.url} uid=${uid} success=true status=${metadata?.status}`);
+        // Accumulate and debounce console output into a single summary line
+        _browserSuccessCount++;
+        _browserTotalBytes += metadata?.size ?? 0;
+        _browserLastUid = uid;
+        if (_browserDebounceTimer)
+            clearTimeout(_browserDebounceTimer);
+        _browserDebounceTimer = setTimeout(flushBrowserProxyLog, BROWSER_PROXY_DEBOUNCE_MS);
+    }
+    else {
+        const displayUrl = formatPath(params.url, 60);
+        const timestamp = chalk.gray(formatTimeCompact());
+        const uidStr = chalk.gray(formatUid(uid));
+        const errMsg = error?.message || String(error);
+        const msg = `${timestamp} ${uidStr} ${chalk.red('✗')} ${chalk.blueBright('BROWSER')} ${chalk.white(httpMethod.padEnd(7))} ${chalk.gray(displayUrl)} ${chalk.red(errMsg)}`;
+        console.log(msg);
+        writeToFile(`[ERROR] BROWSER PROXY ${httpMethod} ${params.url} uid=${uid} success=false error="${errMsg}"`);
+    }
+}
+export default {
+    logFsRead,
+    logFsWrite,
+    logGitRead,
+    logGitWrite,
+    logTerminalRead,
+    logTerminalWrite,
+    logSearchRead,
+    logBrowserProxy,
+    logAuth,
+    logConnection,
+};
+//# sourceMappingURL=logger.js.map

package/dist/utils/project-dir.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Project directory management with symlink support
+ * .spck-editor/ is a regular directory with .spck-editor/config symlinked to ~/.spck-editor/projects/{id}
+ * This prevents accidental git commits of secrets while avoiding cross-device link errors
+ */
+/**
+ * Generate a consistent project ID from the project root path
+ */
+export declare function generateProjectId(projectRoot: string): string;
+/**
+ * Get the home directory location for a project's data
+ */
+export declare function getProjectDataPath(projectRoot: string): string;
+/**
+ * Get the .spck-editor directory path in the project
+ */
+export declare function getProjectDirPath(projectRoot: string): string;
+/**
+ * Get the config symlink path (.spck-editor/config)
+ */
+export declare function getConfigSymlinkPath(projectRoot: string): string;
+/**
+ * @deprecated Use getConfigSymlinkPath() instead
+ * Legacy compatibility - returns config symlink path
+ */
+export declare function getProjectSymlinkPath(projectRoot: string): string;
+/**
+ * Check if the project directory exists and is properly set up
+ */
+export declare function isProjectDirSetup(projectRoot: string): boolean;
+/**
+ * Setup the project directory with config symlink
+ * Creates ~/.spck-editor/projects/{project_id}/ and symlinks .spck-editor/config to it
+ */
+export declare function setupProjectDir(projectRoot: string): void;
+/**
+ * Ensure project directory is set up, creating if needed
+ */
+export declare function ensureProjectDir(projectRoot: string): void;
+/**
+ * Get the absolute path to a file within the project directory
+ * Files go in .spck-editor/{filename} (local) or .spck-editor/config/{filename} (symlinked)
+ * Config files (like connection-settings.json) go in the config subdirectory
+ */
+export declare function getProjectFilePath(projectRoot: string, filename: string): string;
+/**
+ * Remove project directory and all associated data
+ * WARNING: This deletes the data directory in home and the local .spck-editor directory
+ */
+export declare function removeProjectDir(projectRoot: string): void;
+//# sourceMappingURL=project-dir.d.ts.map