spck 0.3.1

package/bin/cli.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+/**
+ * CLI entry point - thin wrapper that executes the main TypeScript entry point
+ * All CLI logic is in dist/index.js (compiled from src/index.ts)
+ */
+
+import { validateCurrentWorkingDirectory } from './validate-cwd.js';
+
+// CRITICAL: Validate CWD BEFORE importing any other modules
+// Many Node.js modules call process.cwd() during initialization and will crash
+// if the current directory doesn't exist (deleted, network fs unmounted, etc.)
+validateCurrentWorkingDirectory();
+
+import('../dist/index.js').then((module) => {
+  module.main().catch((error) => {
+    console.error('Error:', error.message);
+    process.exit(1);
+  });
+});

package/bin/validate-cwd.js

@@ -0,0 +1,41 @@
+import os from 'os';
+
+/**
+ * Validate current working directory and recover if invalid
+ *
+ * This MUST be called before importing any modules that might call process.cwd()
+ * during initialization (e.g., yargs, graceful-fs, @npmcli/config).
+ *
+ * Handles edge case where:
+ * - User cd'd into a directory that was then deleted
+ * - Network filesystem became inaccessible
+ * - Directory permissions changed
+ */
+export function validateCurrentWorkingDirectory() {
+  try {
+    process.cwd();
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      // Current directory doesn't exist - fall back to home directory
+      const homeDir = os.homedir();
+
+      console.error('\n⚠️  Warning: Current working directory no longer exists');
+      console.error(`   Changing to home directory: ${homeDir}\n`);
+
+      try {
+        process.chdir(homeDir);
+        console.log('✅ Successfully changed to home directory\n');
+      } catch (chdirError) {
+        console.error('\n❌ Fatal Error: Cannot access home directory');
+        console.error('   Your filesystem may be corrupted or inaccessible.');
+        console.error(`   Error: ${chdirError.message}\n`);
+        process.exit(1);
+      }
+    } else {
+      // Some other error with process.cwd()
+      console.error('\n❌ Fatal Error: Cannot determine current working directory');
+      console.error(`   Error: ${error.message}\n`);
+      process.exit(1);
+    }
+  }
+}

package/dist/config/__tests__/config.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config.test.d.ts.map

package/dist/config/__tests__/config.test.js

@@ -0,0 +1,262 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+/**
+ * Unit tests for config management
+ */
+import * as fs from 'fs';
+import { loadConfig, saveConfig, ConfigNotFoundError, createDefaultConfig, parseFileSize, } from '../config.js';
+// Mock fs module
+vi.mock('fs');
+const mockFs = fs;
+describe('config', () => {
+    const mockCwd = '/mock/project';
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.spyOn(process, 'cwd').mockReturnValue(mockCwd);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('loadConfig()', () => {
+        const validConfig = {
+            version: 1,
+            root: '/mock/root',
+            terminal: {
+                enabled: true,
+                maxBufferedLines: 5000,
+                maxTerminals: 10,
+            },
+            security: {
+                userAuthenticationEnabled: false,
+            },
+            browserProxy: {
+                enabled: true
+            },
+            filesystem: {
+                maxFileSize: '100MB',
+                watchIgnorePatterns: ['node_modules/**'],
+            },
+        };
+        beforeEach(() => {
+            // Mock root directory exists for validation
+            mockFs.existsSync.mockImplementation((path) => {
+                if (path === '/mock/root')
+                    return true;
+                return false;
+            });
+        });
+        it('should throw ConfigNotFoundError if file does not exist', () => {
+            mockFs.existsSync.mockReturnValue(false);
+            expect(() => loadConfig()).toThrow(ConfigNotFoundError);
+        });
+        it('should load and return valid config', () => {
+            mockFs.existsSync.mockImplementation((_path) => {
+                // Config file and root directory exist
+                return true;
+            });
+            mockFs.readFileSync.mockReturnValue(JSON.stringify(validConfig));
+            const result = loadConfig();
+            expect(result).toEqual(validConfig);
+        });
+        it('should throw CORRUPTED error for invalid JSON', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.readFileSync.mockReturnValue('not valid json{');
+            expect(() => {
+                try {
+                    loadConfig();
+                }
+                catch (error) {
+                    expect(error.code).toBe('CORRUPTED');
+                    throw error;
+                }
+            }).toThrow();
+        });
+        it('should throw CORRUPTED error for invalid version', () => {
+            const invalidConfig = {
+                ...validConfig,
+                version: 999,
+            };
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.readFileSync.mockReturnValue(JSON.stringify(invalidConfig));
+            expect(() => {
+                try {
+                    loadConfig();
+                }
+                catch (error) {
+                    expect(error.code).toBe('CORRUPTED');
+                    throw error;
+                }
+            }).toThrow();
+        });
+        it('should throw CORRUPTED error for missing root', () => {
+            const invalidConfig = {
+                ...validConfig,
+                root: undefined,
+            };
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.readFileSync.mockReturnValue(JSON.stringify(invalidConfig));
+            expect(() => {
+                try {
+                    loadConfig();
+                }
+                catch (error) {
+                    expect(error.code).toBe('CORRUPTED');
+                    throw error;
+                }
+            }).toThrow();
+        });
+        it('should throw error if root directory does not exist', () => {
+            mockFs.existsSync.mockImplementation((path) => {
+                // Config exists, but root doesn't
+                if (path.includes('.spck-editor'))
+                    return true;
+                return false;
+            });
+            mockFs.readFileSync.mockReturnValue(JSON.stringify(validConfig));
+            expect(() => loadConfig()).toThrow('Root directory does not exist');
+        });
+        it('should use custom config path when provided', () => {
+            const customPath = 'custom/config.json';
+            mockFs.existsSync.mockReturnValue(false);
+            expect(() => loadConfig(customPath)).toThrow(ConfigNotFoundError);
+        });
+    });
+    describe('saveConfig()', () => {
+        const validConfig = {
+            version: 1,
+            root: mockCwd,
+            terminal: {
+                enabled: true,
+                maxBufferedLines: 5000,
+                maxTerminals: 10,
+            },
+            security: {
+                userAuthenticationEnabled: false,
+            },
+            filesystem: {
+                maxFileSize: '100MB',
+                watchIgnorePatterns: [],
+            },
+        };
+        beforeEach(() => {
+            // Mock root directory exists for validation
+            mockFs.existsSync.mockImplementation((path) => {
+                if (path === mockCwd)
+                    return true;
+                return false;
+            });
+            mockFs.mkdirSync.mockReturnValue(undefined);
+            mockFs.writeFileSync.mockReturnValue(undefined);
+        });
+        it('should create directory if it does not exist', () => {
+            mockFs.existsSync.mockImplementation((path) => {
+                // Root exists, but .spck-editor doesn't
+                if (path === mockCwd)
+                    return true;
+                return false;
+            });
+            saveConfig(validConfig);
+            expect(mockFs.mkdirSync).toHaveBeenCalled();
+        });
+        it('should write config file', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            saveConfig(validConfig);
+            expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('spck-cli.config.json'), JSON.stringify(validConfig, null, 2), 'utf8');
+        });
+        it('should validate config before saving', () => {
+            const invalidConfig = {
+                ...validConfig,
+                version: 999, // Invalid version
+            };
+            expect(() => saveConfig(invalidConfig)).toThrow('Invalid config version');
+        });
+        it('should throw error with operation context on write failure', () => {
+            const mockError = new Error('ENOSPC');
+            mockError.code = 'ENOSPC';
+            mockFs.writeFileSync.mockImplementation(() => {
+                throw mockError;
+            });
+            mockFs.existsSync.mockReturnValue(true);
+            expect(() => {
+                try {
+                    saveConfig(validConfig);
+                }
+                catch (error) {
+                    expect(error.operation).toBe('save config');
+                    throw error;
+                }
+            }).toThrow();
+        });
+    });
+    describe('createDefaultConfig()', () => {
+        it('should create config with default values', () => {
+            const config = createDefaultConfig();
+            expect(config.version).toBe(1);
+            expect(config.root).toBe(mockCwd);
+            expect(config.terminal.enabled).toBe(true);
+            expect(config.security.userAuthenticationEnabled).toBe(false);
+        });
+        it('should merge overrides with defaults', () => {
+            const overrides = {
+                root: '/custom/root',
+                terminal: {
+                    enabled: false,
+                    maxBufferedLines: 1000,
+                    maxTerminals: 5,
+                },
+            };
+            const config = createDefaultConfig(overrides);
+            expect(config.root).toBe('/custom/root');
+            expect(config.terminal.enabled).toBe(false);
+            expect(config.terminal.maxBufferedLines).toBe(1000);
+        });
+    });
+    describe('parseFileSize()', () => {
+        it('should parse bytes correctly', () => {
+            expect(parseFileSize('100B')).toBe(100);
+            expect(parseFileSize('100')).toBe(100);
+        });
+        it('should parse kilobytes correctly', () => {
+            expect(parseFileSize('1KB')).toBe(1024);
+            expect(parseFileSize('10KB')).toBe(10240);
+        });
+        it('should parse megabytes correctly', () => {
+            expect(parseFileSize('1MB')).toBe(1024 * 1024);
+            expect(parseFileSize('100MB')).toBe(100 * 1024 * 1024);
+        });
+        it('should parse gigabytes correctly', () => {
+            expect(parseFileSize('1GB')).toBe(1024 * 1024 * 1024);
+            expect(parseFileSize('2GB')).toBe(2 * 1024 * 1024 * 1024);
+        });
+        it('should handle decimal values', () => {
+            expect(parseFileSize('1.5MB')).toBe(1.5 * 1024 * 1024);
+            expect(parseFileSize('0.5GB')).toBe(0.5 * 1024 * 1024 * 1024);
+        });
+        it('should be case insensitive', () => {
+            expect(parseFileSize('1mb')).toBe(1024 * 1024);
+            expect(parseFileSize('1MB')).toBe(1024 * 1024);
+            expect(parseFileSize('1Mb')).toBe(1024 * 1024);
+        });
+        it('should handle spaces', () => {
+            expect(parseFileSize('100 MB')).toBe(100 * 1024 * 1024);
+        });
+        it('should throw error for invalid format', () => {
+            expect(() => parseFileSize('invalid')).toThrow('Invalid file size format');
+            expect(() => parseFileSize('100XB')).toThrow('Invalid file size format');
+            expect(() => parseFileSize('')).toThrow('Invalid file size format');
+        });
+    });
+    describe('ConfigNotFoundError', () => {
+        it('should create error with config path', () => {
+            const error = new ConfigNotFoundError('/path/to/config.json');
+            expect(error.name).toBe('ConfigNotFoundError');
+            expect(error.message).toContain('/path/to/config.json');
+            expect(error.configPath).toBe('/path/to/config.json');
+        });
+        it('should be instance of Error', () => {
+            const error = new ConfigNotFoundError('/path');
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(ConfigNotFoundError);
+        });
+    });
+});
+//# sourceMappingURL=config.test.js.map

package/dist/config/__tests__/credentials.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=credentials.test.d.ts.map