spck 0.3.1

package/dist/utils/project-dir.js

@@ -0,0 +1,191 @@
+/**
+ * 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
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as crypto from 'crypto';
+import { t } from '../i18n/index.js';
+const PROJECT_DIR_NAME = '.spck-editor';
+const CONFIG_SUBDIR_NAME = 'config';
+/**
+ * Get the home base directory for projects
+ * Called at runtime instead of module load time to avoid issues in test environments
+ */
+function getHomeBaseDir() {
+    return path.join(os.homedir(), '.spck-editor', 'projects');
+}
+/**
+ * Generate a consistent project ID from the project root path
+ */
+export function generateProjectId(projectRoot) {
+    // Resolve to absolute path and normalize
+    const absolutePath = path.resolve(projectRoot);
+    // Generate SHA256 hash of the absolute path
+    const hash = crypto.createHash('sha256').update(absolutePath).digest('hex');
+    // Use first 16 characters for readability (still unique enough)
+    return hash.substring(0, 16);
+}
+/**
+ * Get the home directory location for a project's data
+ */
+export function getProjectDataPath(projectRoot) {
+    const projectId = generateProjectId(projectRoot);
+    return path.join(getHomeBaseDir(), projectId);
+}
+/**
+ * Get the .spck-editor directory path in the project
+ */
+export function getProjectDirPath(projectRoot) {
+    return path.join(projectRoot, PROJECT_DIR_NAME);
+}
+/**
+ * Get the config symlink path (.spck-editor/config)
+ */
+export function getConfigSymlinkPath(projectRoot) {
+    return path.join(projectRoot, PROJECT_DIR_NAME, CONFIG_SUBDIR_NAME);
+}
+/**
+ * @deprecated Use getConfigSymlinkPath() instead
+ * Legacy compatibility - returns config symlink path
+ */
+export function getProjectSymlinkPath(projectRoot) {
+    return getConfigSymlinkPath(projectRoot);
+}
+/**
+ * Check if the project directory exists and is properly set up
+ */
+export function isProjectDirSetup(projectRoot) {
+    const projectDir = getProjectDirPath(projectRoot);
+    const configSymlink = getConfigSymlinkPath(projectRoot);
+    const dataPath = getProjectDataPath(projectRoot);
+    // Check if .spck-editor directory exists
+    if (!fs.existsSync(projectDir)) {
+        return false;
+    }
+    // Check if .spck-editor is a directory (not old-style symlink)
+    try {
+        const stats = fs.lstatSync(projectDir);
+        if (stats.isSymbolicLink()) {
+            // Old structure - needs migration
+            return false;
+        }
+        if (!stats.isDirectory()) {
+            return false;
+        }
+    }
+    catch (error) {
+        return false;
+    }
+    // Check if config symlink exists
+    if (!fs.existsSync(configSymlink)) {
+        return false;
+    }
+    // Check if config is a symlink
+    try {
+        const stats = fs.lstatSync(configSymlink);
+        if (!stats.isSymbolicLink()) {
+            return false;
+        }
+    }
+    catch (error) {
+        return false;
+    }
+    // Check if data directory exists
+    if (!fs.existsSync(dataPath)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Setup the project directory with config symlink
+ * Creates ~/.spck-editor/projects/{project_id}/ and symlinks .spck-editor/config to it
+ */
+export function setupProjectDir(projectRoot) {
+    const projectDir = getProjectDirPath(projectRoot);
+    const configSymlink = getConfigSymlinkPath(projectRoot);
+    const dataPath = getProjectDataPath(projectRoot);
+    const homeBaseDir = getHomeBaseDir();
+    // Ensure home base directory exists
+    if (!fs.existsSync(homeBaseDir)) {
+        fs.mkdirSync(homeBaseDir, { recursive: true, mode: 0o700 });
+    }
+    // Ensure project data directory exists
+    if (!fs.existsSync(dataPath)) {
+        fs.mkdirSync(dataPath, { recursive: true, mode: 0o700 });
+    }
+    // Create .spck-editor directory if it doesn't exist
+    if (!fs.existsSync(projectDir)) {
+        fs.mkdirSync(projectDir, { mode: 0o700 });
+    }
+    // Create subdirectories (.tmp, .trash, logs)
+    const subdirs = ['.tmp', '.trash', 'logs'];
+    for (const subdir of subdirs) {
+        const subdirPath = path.join(projectDir, subdir);
+        if (!fs.existsSync(subdirPath)) {
+            fs.mkdirSync(subdirPath, { mode: 0o700 });
+        }
+    }
+    // Create config symlink if it doesn't exist
+    if (!fs.existsSync(configSymlink)) {
+        fs.symlinkSync(dataPath, configSymlink, 'dir');
+    }
+    else {
+        // Verify existing symlink points to correct location
+        const stats = fs.lstatSync(configSymlink);
+        if (stats.isSymbolicLink()) {
+            const target = fs.readlinkSync(configSymlink);
+            if (target !== dataPath) {
+                // Points to wrong location - remove and recreate
+                fs.unlinkSync(configSymlink);
+                fs.symlinkSync(dataPath, configSymlink, 'dir');
+            }
+        }
+    }
+    console.log(`✅ ${t('projectDir.configured')}`);
+    console.log(`   ${t('projectDir.directory', { path: projectDir })}`);
+    console.log(`   ${t('projectDir.configLink', { symlink: configSymlink, dataPath })}\n`);
+}
+/**
+ * Ensure project directory is set up, creating if needed
+ */
+export function ensureProjectDir(projectRoot) {
+    if (!isProjectDirSetup(projectRoot)) {
+        setupProjectDir(projectRoot);
+    }
+}
+/**
+ * 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 function getProjectFilePath(projectRoot, filename) {
+    const projectDir = getProjectDirPath(projectRoot);
+    // Config files go in the symlinked config directory
+    const configFiles = ['connection-settings.json', '.credentials.json', 'spck-cli.config.json'];
+    if (configFiles.includes(filename)) {
+        const configSymlink = getConfigSymlinkPath(projectRoot);
+        return path.join(configSymlink, filename);
+    }
+    // All other files go in the local .spck-editor directory
+    return path.join(projectDir, filename);
+}
+/**
+ * Remove project directory and all associated data
+ * WARNING: This deletes the data directory in home and the local .spck-editor directory
+ */
+export function removeProjectDir(projectRoot) {
+    const projectDir = getProjectDirPath(projectRoot);
+    const dataPath = getProjectDataPath(projectRoot);
+    // Remove .spck-editor directory if exists (includes config symlink and local files)
+    if (fs.existsSync(projectDir)) {
+        fs.rmSync(projectDir, { recursive: true, force: true });
+    }
+    // Remove data directory in home if exists
+    if (fs.existsSync(dataPath)) {
+        fs.rmSync(dataPath, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=project-dir.js.map

package/dist/utils/ripgrep.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Ripgrep wrapper utility
+ *
+ * Uses system-installed ripgrep (rg) if available
+ */
+/**
+ * Get the ripgrep command name for the current platform
+ */
+export declare function getRipgrepCommand(): string;
+/**
+ * Check if ripgrep is available on the system PATH
+ */
+export declare function isRipgrepAvailable(): Promise<boolean>;
+/**
+ * Execute ripgrep search (buffered - waits for completion)
+ */
+export declare function executeRipgrep(path: string, args: string[], options?: {
+    timeout?: number;
+}): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}>;
+/**
+ * Execute ripgrep search with streaming output
+ * Calls onLine for each line of output as it arrives
+ */
+export declare function executeRipgrepStream(path: string, args: string[], options: {
+    timeout?: number;
+    onLine: (line: string) => void;
+}): Promise<{
+    exitCode: number;
+}>;
+//# sourceMappingURL=ripgrep.d.ts.map

package/dist/utils/ripgrep.js

@@ -0,0 +1,148 @@
+/**
+ * Ripgrep wrapper utility
+ *
+ * Uses system-installed ripgrep (rg) if available
+ */
+import { spawn } from 'child_process';
+/**
+ * Get the ripgrep command name for the current platform
+ */
+export function getRipgrepCommand() {
+    // On Windows, try both 'rg.exe' and 'rg'
+    // On Unix-like systems, use 'rg'
+    return process.platform === 'win32' ? 'rg.exe' : 'rg';
+}
+/**
+ * Check if ripgrep is available on the system PATH
+ */
+export async function isRipgrepAvailable() {
+    const rgCommand = getRipgrepCommand();
+    // Try to execute ripgrep --version to verify it works
+    return new Promise((resolve) => {
+        try {
+            const proc = spawn(rgCommand, ['--version'], {
+                cwd: process.cwd(),
+                stdio: 'ignore',
+                shell: false
+            });
+            proc.on('error', () => resolve(false));
+            proc.on('close', (code) => resolve(code === 0));
+        }
+        catch (err) {
+            resolve(false);
+        }
+    });
+}
+/**
+ * Execute ripgrep search (buffered - waits for completion)
+ */
+export async function executeRipgrep(path, args, options) {
+    const rgCommand = getRipgrepCommand();
+    return new Promise((resolve, reject) => {
+        const proc = spawn(rgCommand, args, {
+            cwd: path,
+            stdio: 'pipe',
+            shell: false
+        });
+        let stdout = '';
+        let stderr = '';
+        let killed = false;
+        // Set timeout if specified
+        const timeout = options?.timeout;
+        let timeoutId;
+        if (timeout) {
+            timeoutId = setTimeout(() => {
+                killed = true;
+                proc.kill();
+                reject(new Error(`Ripgrep execution timed out after ${timeout}ms`));
+            }, timeout);
+        }
+        proc.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('error', (error) => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (!killed) {
+                reject(error);
+            }
+        });
+        proc.on('close', (code) => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (!killed) {
+                resolve({
+                    stdout,
+                    stderr,
+                    exitCode: code ?? -1
+                });
+            }
+        });
+    });
+}
+/**
+ * Execute ripgrep search with streaming output
+ * Calls onLine for each line of output as it arrives
+ */
+export async function executeRipgrepStream(path, args, options) {
+    const rgCommand = getRipgrepCommand();
+    return new Promise((resolve, reject) => {
+        const proc = spawn(rgCommand, args, {
+            cwd: path,
+            stdio: 'pipe',
+            shell: false
+        });
+        let killed = false;
+        let buffer = '';
+        // Set timeout if specified
+        const timeout = options.timeout;
+        let timeoutId;
+        if (timeout) {
+            timeoutId = setTimeout(() => {
+                killed = true;
+                proc.kill();
+                reject(new Error(`Ripgrep execution timed out after ${timeout}ms`));
+            }, timeout);
+        }
+        // Process stdout line by line as it arrives
+        proc.stdout?.on('data', (data) => {
+            buffer += data.toString();
+            const lines = buffer.split('\n');
+            // Keep the last incomplete line in the buffer
+            buffer = lines.pop() || '';
+            // Process complete lines
+            for (const line of lines) {
+                if (line.trim()) {
+                    options.onLine(line);
+                }
+            }
+        });
+        proc.stderr?.on('data', (_data) => {
+            // Ignore stderr for now
+        });
+        proc.on('error', (error) => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (!killed) {
+                reject(error);
+            }
+        });
+        proc.on('close', (code) => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            // Process any remaining buffered data
+            if (buffer.trim()) {
+                options.onLine(buffer);
+            }
+            if (!killed) {
+                resolve({
+                    exitCode: code ?? -1
+                });
+            }
+        });
+    });
+}
+//# sourceMappingURL=ripgrep.js.map

package/dist/utils/tool-detection.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Tool detection for git and ripgrep
+ * Checks if required tools are installed and displays warnings
+ */
+import { ToolDetectionResult } from '../types.js';
+/**
+ * Detect available tools (git and ripgrep)
+ */
+export declare function detectTools(options?: {
+    disableGit?: boolean;
+    disableRipgrep?: boolean;
+}): Promise<ToolDetectionResult>;
+/**
+ * Display feature summary based on detected tools
+ */
+export declare function displayFeatureSummary(tools: ToolDetectionResult, terminalEnabled: boolean, userAuthEnabled?: boolean, browserProxyEnabled?: boolean): void;
+//# sourceMappingURL=tool-detection.d.ts.map

package/dist/utils/tool-detection.js

@@ -0,0 +1,126 @@
+/**
+ * Tool detection for git and ripgrep
+ * Checks if required tools are installed and displays warnings
+ */
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { t } from '../i18n/index.js';
+const execAsync = promisify(exec);
+/**
+ * Check if a command is available
+ */
+async function isCommandAvailable(command) {
+    try {
+        await execAsync(`${command} --version`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Detect available tools (git and ripgrep)
+ */
+export async function detectTools(options) {
+    console.log(`\n=== ${t('tools.title')} ===\n`);
+    const result = {
+        git: false,
+        ripgrep: false
+    };
+    // Check Git (unless force-disabled for development)
+    if (options?.disableGit) {
+        console.log(`⚠️  ${t('tools.gitForceDisabled')}`);
+    }
+    else {
+        result.git = await isCommandAvailable('git');
+        if (result.git) {
+            try {
+                const { stdout } = await execAsync('git --version');
+                console.log(`✅ ${t('tools.gitDetected', { version: stdout.trim() })}`);
+            }
+            catch {
+                console.log(`✅ ${t('tools.gitDetectedShort')}`);
+            }
+        }
+        else {
+            console.warn(`⚠️  ${t('tools.gitNotDetected')}`);
+            console.warn(`   ${t('tools.gitDisabledHint')}`);
+            console.warn(`   ${t('tools.gitInstallHint')}`);
+            console.warn(`   ${t('tools.gitInstallUrl')}\n`);
+        }
+    }
+    // Check Ripgrep (unless force-disabled for development)
+    if (options?.disableRipgrep) {
+        console.log(`⚠️  ${t('tools.ripgrepForceDisabled')}`);
+    }
+    else {
+        result.ripgrep = await isCommandAvailable('rg');
+        if (result.ripgrep) {
+            try {
+                const { stdout } = await execAsync('rg --version');
+                const firstLine = stdout.split('\n')[0];
+                console.log(`✅ ${t('tools.ripgrepDetected', { version: firstLine })}`);
+            }
+            catch {
+                console.log(`✅ ${t('tools.ripgrepDetectedShort')}`);
+            }
+        }
+        else {
+            console.warn(`⚠️  ${t('tools.ripgrepNotDetected')}`);
+            console.warn(`   ${t('tools.ripgrepDisabledHint')}`);
+            console.warn(`   ${t('tools.ripgrepInstallHint')}`);
+            console.warn(`   ${t('tools.ripgrepInstallUrl')}\n`);
+        }
+    }
+    return result;
+}
+/**
+ * Display feature summary based on detected tools
+ */
+export function displayFeatureSummary(tools, terminalEnabled, userAuthEnabled, browserProxyEnabled) {
+    console.log(`\n=== ${t('features.title')} ===\n`);
+    const features = [];
+    // Always available
+    features.push(`✅ ${t('features.filesystem')}`);
+    // Conditional features
+    if (tools.git) {
+        features.push(`✅ ${t('features.gitEnabled')}`);
+    }
+    else {
+        features.push(`❌ ${t('features.gitDisabled')}`);
+    }
+    if (tools.ripgrep) {
+        features.push(`✅ ${t('features.searchFast')}`);
+    }
+    else {
+        features.push(`⚠️  ${t('features.searchBasic')}`);
+    }
+    if (terminalEnabled) {
+        features.push(`✅ ${t('features.terminalEnabled')}`);
+    }
+    else {
+        features.push(`❌ ${t('features.terminalDisabled')}`);
+    }
+    if (browserProxyEnabled !== false) {
+        features.push(`✅ ${t('features.browserProxyEnabled')}`);
+    }
+    else {
+        features.push(`❌ ${t('features.browserProxyDisabled')}`);
+    }
+    features.forEach(feature => console.log(`   ${feature}`));
+    // Display authentication mode
+    console.log(`\n=== ${t('features.securityTitle')} ===\n`);
+    if (userAuthEnabled) {
+        console.log(`   🔐 ${t('features.userAuthEnabled')}`);
+        console.log(`   → ${t('features.userAuthEnabledHint1')}`);
+        console.log(`   → ${t('features.userAuthEnabledHint2')}`);
+        console.log(`   → ${t('features.userAuthEnabledHint3')}\n`);
+    }
+    else {
+        console.log(`   🔓 ${t('features.userAuthDisabled')}`);
+        console.log(`   → ${t('features.userAuthDisabledHint1')}`);
+        console.log(`   → ${t('features.userAuthDisabledHint2')}`);
+        console.log(`   → ${t('features.userAuthDisabledHint3')}\n`);
+    }
+}
+//# sourceMappingURL=tool-detection.js.map

package/dist/watcher/FileWatcher.d.ts

@@ -0,0 +1,10 @@
+/**
+ * File system watcher using chokidar
+ */
+import { EventEmitter } from 'events';
+export declare class FileWatcher extends EventEmitter {
+    private watcher;
+    constructor(rootPath: string, ignorePatterns: string[]);
+    close(): void;
+}
+//# sourceMappingURL=FileWatcher.d.ts.map

package/dist/watcher/FileWatcher.js

@@ -0,0 +1,42 @@
+/**
+ * File system watcher using chokidar
+ */
+import * as chokidar from 'chokidar';
+import { EventEmitter } from 'events';
+export class FileWatcher extends EventEmitter {
+    constructor(rootPath, ignorePatterns) {
+        super();
+        this.watcher = chokidar.watch(rootPath, {
+            ignored: ignorePatterns,
+            persistent: true,
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 100,
+                pollInterval: 50,
+            },
+        });
+        this.watcher.on('change', (path, stats) => {
+            this.emit('change', path, stats?.mtimeMs);
+        });
+        this.watcher.on('unlink', (path) => {
+            this.emit('removed', path);
+        });
+        this.watcher.on('add', (path, stats) => {
+            this.emit('added', path, stats?.mtimeMs);
+        });
+        this.watcher.on('unlinkDir', (path) => {
+            this.emit('removed', path);
+        });
+        this.watcher.on('addDir', (path) => {
+            this.emit('added', path);
+        });
+        this.watcher.on('error', (error) => {
+            console.error('File watcher error:', error);
+            this.emit('error', error);
+        });
+    }
+    close() {
+        this.watcher.close();
+    }
+}
+//# sourceMappingURL=FileWatcher.js.map

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "spck",
+  "version": "0.3.1",
+  "description": "CLI tool for Spck Editor - provides remote filesystem, git, browser proxing, and terminal access",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "spck": "./bin/cli.js"
+  },
+  "scripts": {
+    "build": "tsc && cp src/i18n/locales/*.json dist/i18n/locales/",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "watch": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "prepublishOnly": "npm run lint && npm test",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "spck",
+    "editor",
+    "remote",
+    "filesystem",
+    "git",
+    "terminal"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/spck-io/spck-cli"
+  },
+  "author": "Spck Editor",
+  "license": "MIT",
+  "dependencies": {
+    "@xterm/addon-serialize": "0.13.0",
+    "@xterm/headless": "5.5.0",
+    "chalk": "4.1.2",
+    "chokidar": "3.6.0",
+    "default-shell": "2.2.0",
+    "fossil-delta": "1.0.2",
+    "jsonwebtoken": "9.0.3",
+    "node-fetch": "3.3.2",
+    "node-pty": "1.2.0-beta.10",
+    "open": "8.4.2",
+    "os-locale": "8.0.0",
+    "qrcode-terminal": "0.12.0",
+    "socket.io-client": "4.8.3",
+    "write-file-atomic": "7.0.0",
+    "yargs": "17.7.2"
+  },
+  "devDependencies": {
+    "@types/jsonwebtoken": "^9.0.5",
+    "@types/node": "^20.0.0",
+    "@types/node-fetch": "^2.6.11",
+    "@types/qrcode-terminal": "^0.12.2",
+    "@types/socket.io-client": "^3.0.0",
+    "@types/write-file-atomic": "^4.0.3",
+    "@types/ws": "^8.5.10",
+    "@types/yargs": "^17.0.32",
+    "ts-node": "^10.9.2",
+    "vitest": "^3.0.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}