spck 0.3.1

package/src/config/__tests__/credentials.test.ts

@@ -0,0 +1,494 @@
+import { describe, it, expect, beforeEach, afterEach, vi, type Mocked } from 'vitest';
+/**
+ * Unit tests for credentials management
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import {
+  loadCredentials,
+  saveCredentials,
+  loadConnectionSettings,
+  saveConnectionSettings,
+  isServerTokenExpired,
+  getCredentialsPath,
+  getConnectionSettingsPath,
+  getGlobalConfigPath,
+  loadGlobalConfig,
+  saveGlobalConfig,
+  clearCredentials,
+  clearConnectionSettings,
+} from '../credentials.js';
+import { StoredCredentials, GlobalConfig } from '../../types.js';
+
+// Mock modules
+vi.mock('fs');
+vi.mock('os');
+
+const mockFs = fs as Mocked<typeof fs>;
+const mockOs = os as Mocked<typeof os>;
+
+describe('credentials', () => {
+  const mockHomedir = '/mock/home';
+  const mockCwd = '/mock/project';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockOs.homedir.mockReturnValue(mockHomedir);
+    vi.spyOn(process, 'cwd').mockReturnValue(mockCwd);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('getCredentialsPath()', () => {
+    it('should return path in user home directory', () => {
+      const path = getCredentialsPath();
+      expect(path).toBe(`${mockHomedir}/.spck-editor/.credentials.json`);
+    });
+  });
+
+  describe('getConnectionSettingsPath()', () => {
+    it('should return path in .spck-editor/config subdirectory', () => {
+      const path = getConnectionSettingsPath();
+      expect(path).toBe(`${mockCwd}/.spck-editor/config/connection-settings.json`);
+    });
+  });
+
+  describe('loadCredentials()', () => {
+    it('should return null if file does not exist', () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      const result = loadCredentials();
+
+      expect(result).toBeNull();
+    });
+
+    it('should load and return valid stored credentials', () => {
+      const mockCredentials: StoredCredentials = {
+        refreshToken: 'mock-refresh-token',
+        userId: 'user-123',
+      };
+
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify(mockCredentials));
+
+      const result = loadCredentials();
+
+      expect(result).toEqual(mockCredentials);
+    });
+
+    it('should throw CORRUPTED error for invalid JSON', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue('invalid json{');
+
+      expect(() => loadCredentials()).toThrow('Credentials file is corrupted');
+      expect(() => {
+        try {
+          loadCredentials();
+        } catch (error: any) {
+          expect(error.code).toBe('CORRUPTED');
+          throw error;
+        }
+      }).toThrow();
+    });
+
+    it('should throw CORRUPTED error for missing refreshToken', () => {
+      const invalidCredentials = {
+        userId: 'user-123',
+      };
+
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify(invalidCredentials));
+
+      expect(() => {
+        try {
+          loadCredentials();
+        } catch (error: any) {
+          expect(error.code).toBe('CORRUPTED');
+          throw error;
+        }
+      }).toThrow();
+    });
+
+    it('should throw CORRUPTED error for missing userId', () => {
+      const invalidCredentials = {
+        refreshToken: 'mock-refresh-token',
+      };
+
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify(invalidCredentials));
+
+      expect(() => {
+        try {
+          loadCredentials();
+        } catch (error: any) {
+          expect(error.code).toBe('CORRUPTED');
+          throw error;
+        }
+      }).toThrow();
+    });
+
+    it('should only return refreshToken and userId even if file has extra fields', () => {
+      const storedWithExtra = {
+        refreshToken: 'mock-refresh-token',
+        userId: 'user-123',
+        firebaseToken: 'old-token',
+        firebaseTokenExpiry: Date.now(),
+      };
+
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify(storedWithExtra));
+
+      const result = loadCredentials();
+
+      // Should only return the stored credentials fields
+      expect(result).toEqual({
+        refreshToken: 'mock-refresh-token',
+        userId: 'user-123',
+      });
+    });
+  });
+
+  describe('saveCredentials()', () => {
+    const mockCredentials: StoredCredentials = {
+      refreshToken: 'mock-refresh-token',
+      userId: 'user-123',
+    };
+
+    it('should create directory if it does not exist', () => {
+      mockFs.existsSync.mockReturnValue(false);
+      mockFs.mkdirSync.mockReturnValue(undefined);
+      mockFs.writeFileSync.mockReturnValue(undefined);
+
+      saveCredentials(mockCredentials);
+
+      expect(mockFs.mkdirSync).toHaveBeenCalledWith(
+        `${mockHomedir}/.spck-editor`,
+        { recursive: true, mode: 0o700 }
+      );
+    });
+
+    it('should write only refreshToken and userId with correct permissions', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.writeFileSync.mockReturnValue(undefined);
+
+      saveCredentials(mockCredentials);
+
+      // Should only persist refreshToken + userId
+      const expectedStored: StoredCredentials = {
+        refreshToken: 'mock-refresh-token',
+        userId: 'user-123',
+      };
+
+      expect(mockFs.writeFileSync).toHaveBeenCalledWith(
+        `${mockHomedir}/.spck-editor/.credentials.json`,
+        JSON.stringify(expectedStored, null, 2),
+        { encoding: 'utf8', mode: 0o600 }
+      );
+    });
+
+    it('should throw error with operation context on write failure', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      const mockError: any = new Error('ENOSPC: no space left');
+      mockError.code = 'ENOSPC';
+      mockFs.writeFileSync.mockImplementation(() => {
+        throw mockError;
+      });
+
+      expect(() => {
+        try {
+          saveCredentials(mockCredentials);
+        } catch (error: any) {
+          expect(error.operation).toBe('save credentials');
+          throw error;
+        }
+      }).toThrow();
+    });
+  });
+
+  describe('loadConnectionSettings()', () => {
+    it('should return null if file does not exist', () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      const result = loadConnectionSettings();
+
+      expect(result).toBeNull();
+    });
+
+    it('should load and return valid connection settings', () => {
+      const mockSettings = {
+        serverToken: 'server-token',
+        serverTokenExpiry: Date.now() + 3600000,
+        clientId: 'client-123',
+        secret: 'secret-abc',
+        userId: 'user-123',
+        connectedAt: Date.now(),
+      };
+
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify(mockSettings));
+
+      const result = loadConnectionSettings();
+
+      expect(result).toEqual(mockSettings);
+    });
+
+    it('should throw CORRUPTED error for invalid JSON', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue('not valid json');
+
+      expect(() => {
+        try {
+          loadConnectionSettings();
+        } catch (error: any) {
+          expect(error.code).toBe('CORRUPTED');
+          throw error;
+        }
+      }).toThrow();
+    });
+
+    it('should throw CORRUPTED error for missing required fields', () => {
+      const invalidSettings = {
+        serverToken: 'token',
+        // missing clientId and secret
+      };
+
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify(invalidSettings));
+
+      expect(() => {
+        try {
+          loadConnectionSettings();
+        } catch (error: any) {
+          expect(error.code).toBe('CORRUPTED');
+          throw error;
+        }
+      }).toThrow();
+    });
+  });
+
+  describe('saveConnectionSettings()', () => {
+    const mockSettings = {
+      serverToken: 'server-token',
+      serverTokenExpiry: Date.now() + 3600000,
+      clientId: 'client-123',
+      secret: 'secret-abc',
+      userId: 'user-123',
+      connectedAt: Date.now(),
+    };
+
+    it('should create directory if it does not exist', () => {
+      mockFs.existsSync.mockReturnValue(false);
+      mockFs.mkdirSync.mockReturnValue(undefined);
+      mockFs.writeFileSync.mockReturnValue(undefined);
+
+      saveConnectionSettings(mockSettings);
+
+      expect(mockFs.mkdirSync).toHaveBeenCalledWith(
+        `${mockCwd}/.spck-editor/config`,
+        { recursive: true, mode: 0o700 }
+      );
+    });
+
+    it('should write settings file with restricted permissions', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.writeFileSync.mockReturnValue(undefined);
+
+      saveConnectionSettings(mockSettings);
+
+      expect(mockFs.writeFileSync).toHaveBeenCalledWith(
+        `${mockCwd}/.spck-editor/config/connection-settings.json`,
+        JSON.stringify(mockSettings, null, 2),
+        { encoding: 'utf8', mode: 0o600 }
+      );
+    });
+
+    it('should throw error with operation context on write failure', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      const mockError: any = new Error('EACCES: permission denied');
+      mockError.code = 'EACCES';
+      mockFs.writeFileSync.mockImplementation(() => {
+        throw mockError;
+      });
+
+      expect(() => {
+        try {
+          saveConnectionSettings(mockSettings);
+        } catch (error: any) {
+          expect(error.operation).toBe('save connection settings');
+          throw error;
+        }
+      }).toThrow();
+    });
+  });
+
+  describe('isServerTokenExpired()', () => {
+    it('should return true if settings is null', () => {
+      expect(isServerTokenExpired(null)).toBe(true);
+    });
+
+    it('should return true if serverTokenExpiry is missing', () => {
+      expect(isServerTokenExpired({ serverToken: 'token' })).toBe(true);
+    });
+
+    it('should return true if token has expired', () => {
+      const expiredSettings = {
+        serverToken: 'token',
+        serverTokenExpiry: Date.now() - 1000,
+      };
+
+      expect(isServerTokenExpired(expiredSettings)).toBe(true);
+    });
+
+    it('should return false if token is still valid', () => {
+      const validSettings = {
+        serverToken: 'token',
+        serverTokenExpiry: Date.now() + 3600000,
+      };
+
+      expect(isServerTokenExpired(validSettings)).toBe(false);
+    });
+  });
+
+  describe('clearCredentials()', () => {
+    it('should delete credentials file if it exists', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.unlinkSync.mockReturnValue(undefined);
+
+      clearCredentials();
+
+      expect(mockFs.unlinkSync).toHaveBeenCalledWith(
+        `${mockHomedir}/.spck-editor/.credentials.json`
+      );
+    });
+
+    it('should do nothing if file does not exist', () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      clearCredentials();
+
+      expect(mockFs.unlinkSync).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('clearConnectionSettings()', () => {
+    it('should delete settings file if it exists', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.unlinkSync.mockReturnValue(undefined);
+
+      clearConnectionSettings();
+
+      expect(mockFs.unlinkSync).toHaveBeenCalledWith(
+        `${mockCwd}/.spck-editor/config/connection-settings.json`
+      );
+    });
+
+    it('should do nothing if file does not exist', () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      clearConnectionSettings();
+
+      expect(mockFs.unlinkSync).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('getGlobalConfigPath()', () => {
+    it('should return path in user home directory', () => {
+      const configPath = getGlobalConfigPath();
+      expect(configPath).toBe(`${mockHomedir}/.spck-editor/global.config`);
+    });
+  });
+
+  describe('loadGlobalConfig()', () => {
+    it('should return default config if file does not exist', () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      const result = loadGlobalConfig();
+
+      expect(result).toEqual({ knownDeviceIds: [] });
+    });
+
+    it('should load and return valid global config', () => {
+      const mockConfig: GlobalConfig = {
+        knownDeviceIds: ['device-aaa', 'device-bbb'],
+      };
+
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify(mockConfig));
+
+      const result = loadGlobalConfig();
+
+      expect(result).toEqual(mockConfig);
+    });
+
+    it('should return default config if JSON is invalid', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue('not valid json{');
+
+      const result = loadGlobalConfig();
+
+      expect(result).toEqual({ knownDeviceIds: [] });
+    });
+
+    it('should return default config if knownDeviceIds is not an array', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify({ knownDeviceIds: 'bad' }));
+
+      const result = loadGlobalConfig();
+
+      expect(result).toEqual({ knownDeviceIds: [] });
+    });
+
+    it('should return empty knownDeviceIds if field is missing', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify({}));
+
+      const result = loadGlobalConfig();
+
+      expect(result).toEqual({ knownDeviceIds: [] });
+    });
+  });
+
+  describe('saveGlobalConfig()', () => {
+    const mockConfig: GlobalConfig = {
+      knownDeviceIds: ['device-aaa', 'device-bbb'],
+    };
+
+    it('should create directory if it does not exist', () => {
+      mockFs.existsSync.mockReturnValue(false);
+      mockFs.mkdirSync.mockReturnValue(undefined);
+      mockFs.writeFileSync.mockReturnValue(undefined);
+
+      saveGlobalConfig(mockConfig);
+
+      expect(mockFs.mkdirSync).toHaveBeenCalledWith(
+        `${mockHomedir}/.spck-editor`,
+        { recursive: true, mode: 0o700 }
+      );
+    });
+
+    it('should write config file with correct content and restricted permissions', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.writeFileSync.mockReturnValue(undefined);
+
+      saveGlobalConfig(mockConfig);
+
+      expect(mockFs.writeFileSync).toHaveBeenCalledWith(
+        `${mockHomedir}/.spck-editor/global.config`,
+        JSON.stringify(mockConfig, null, 2),
+        { encoding: 'utf8', mode: 0o600 }
+      );
+    });
+
+    it('should not create directory if it already exists', () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.writeFileSync.mockReturnValue(undefined);
+
+      saveGlobalConfig(mockConfig);
+
+      expect(mockFs.mkdirSync).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/config/config.ts

@@ -0,0 +1,206 @@
+/**
+ * Configuration management for spck-cli server
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { ServerConfig } from '../types.js';
+import { getProjectFilePath } from '../utils/project-dir.js';
+import { t } from '../i18n/index.js';
+
+const DEFAULT_CONFIG_FILENAME = 'spck-cli.config.json';
+
+/**
+ * Load server configuration from file
+ * If config file doesn't exist, runs setup wizard
+ * @throws {ConfigNotFoundError} if file doesn't exist
+ * @throws {Error} with code 'CORRUPTED' if file is corrupted
+ */
+export function loadConfig(configPath?: string): ServerConfig {
+  // If a custom config path is provided, use it as-is
+  // Otherwise use the default location in the project directory
+  const fullPath = configPath
+    ? path.resolve(process.cwd(), configPath)
+    : getProjectFilePath(process.cwd(), DEFAULT_CONFIG_FILENAME);
+
+  if (!fs.existsSync(fullPath)) {
+    console.log('\n' + t('config.fileNotFound', { path: fullPath }));
+    console.log(t('config.fileNotFoundHint') + '\n');
+
+    // Signal to caller that setup is needed
+    throw new ConfigNotFoundError(fullPath);
+  }
+
+  try {
+    const configData = fs.readFileSync(fullPath, 'utf8');
+    const config: ServerConfig = JSON.parse(configData);
+
+    // Validate required fields
+    validateConfig(config);
+
+    // Backward-compatibility: populate missing optional sections and re-save
+    let needsSave = false;
+    if (!config.browserProxy) {
+      config.browserProxy = { enabled: true };
+      needsSave = true;
+    }
+    if (needsSave) {
+      try { saveConfig(config, configPath); } catch { /* best-effort */ }
+    }
+
+    return config;
+  } catch (error: any) {
+    // JSON parse error or validation error
+    if (error instanceof SyntaxError || (error.message && error.message.includes('Invalid'))) {
+      console.warn('⚠️  ' + t('config.fileCorrupted', { path: fullPath }));
+      console.warn('   ' + t('config.fileCorruptedHint') + '\n');
+      const corruptedError: any = new Error('Configuration file is corrupted');
+      corruptedError.code = 'CORRUPTED';
+      corruptedError.path = fullPath;
+      corruptedError.originalError = error;
+      throw corruptedError;
+    }
+    // Other errors (permission, etc.)
+    throw error;
+  }
+}
+
+/**
+ * Custom error for missing configuration
+ */
+export class ConfigNotFoundError extends Error {
+  constructor(public configPath: string) {
+    super(`Configuration file not found: ${configPath}`);
+    this.name = 'ConfigNotFoundError';
+  }
+}
+
+/**
+ * Save server configuration to file
+ * @throws {Error} with code 'EACCES' for permission errors
+ * @throws {Error} with code 'ENOSPC' for disk full errors
+ */
+export function saveConfig(config: ServerConfig, configPath?: string): void {
+  // If a custom config path is provided, use it as-is
+  // Otherwise use the default location in the project directory
+  const fullPath = configPath
+    ? path.resolve(process.cwd(), configPath)
+    : getProjectFilePath(process.cwd(), DEFAULT_CONFIG_FILENAME);
+
+  try {
+    // Ensure directory exists
+    const dir = path.dirname(fullPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    // Validate before saving
+    validateConfig(config);
+
+    // Write config file
+    fs.writeFileSync(fullPath, JSON.stringify(config, null, 2), 'utf8');
+  } catch (error: any) {
+    // Add context to error
+    error.path = error.path || fullPath;
+    error.operation = 'save config';
+    throw error;
+  }
+}
+
+/**
+ * Validate configuration
+ */
+function validateConfig(config: ServerConfig): void {
+  if (!config.version || config.version !== 1) {
+    throw new Error('Invalid config version. Expected version 1.');
+  }
+
+  if (!config.root || typeof config.root !== 'string') {
+    throw new Error('Invalid or missing root directory in configuration.');
+  }
+
+  if (!fs.existsSync(config.root)) {
+    throw new Error(`Root directory does not exist: ${config.root}`);
+  }
+
+  if (!config.terminal || typeof config.terminal !== 'object') {
+    throw new Error('Invalid or missing terminal configuration.');
+  }
+
+  if (typeof config.terminal.enabled !== 'boolean') {
+    throw new Error('Terminal enabled must be a boolean.');
+  }
+
+  if (!config.security || typeof config.security !== 'object') {
+    throw new Error('Invalid or missing security configuration.');
+  }
+
+  if (!config.filesystem || typeof config.filesystem !== 'object') {
+    throw new Error('Invalid or missing filesystem configuration.');
+  }
+}
+
+/**
+ * Get current directory name for default server name
+ */
+function getDefaultServerName(): string {
+  const cwd = process.cwd();
+  return path.basename(cwd);
+}
+
+/**
+ * Create default configuration template
+ */
+export function createDefaultConfig(overrides: Partial<ServerConfig> = {}): ServerConfig {
+  return {
+    version: 1,
+    root: process.cwd(),
+    name: getDefaultServerName(),
+    terminal: {
+      enabled: true,
+      maxBufferedLines: 5000,
+      maxTerminals: 10,
+    },
+    security: {
+      userAuthenticationEnabled: false,
+    },
+    filesystem: {
+      maxFileSize: '10MB',
+      watchIgnorePatterns: [
+        '**/.git/**',
+        '**/.spck-editor/**',
+        '**/node_modules/**',
+        '**/*.log',
+        '**/.DS_Store',
+        '**/dist/**',
+        '**/build/**'
+      ],
+    },
+    browserProxy: {
+      enabled: true,
+    },
+    ...overrides,
+  };
+}
+
+/**
+ * Parse file size string to bytes
+ */
+export function parseFileSize(sizeStr: string): number {
+  const match = sizeStr.match(/^(\d+(?:\.\d+)?)\s*(B|KB|MB|GB)?$/i);
+  if (!match) {
+    throw new Error(`Invalid file size format: ${sizeStr}`);
+  }
+
+  const value = parseFloat(match[1]);
+  const unit = (match[2] || 'B').toUpperCase();
+
+  const multipliers: { [key: string]: number } = {
+    B: 1,
+    KB: 1024,
+    MB: 1024 * 1024,
+    GB: 1024 * 1024 * 1024,
+  };
+
+  return value * multipliers[unit];
+}