spck 0.3.1

package/src/setup/wizard.ts

@@ -0,0 +1,242 @@
+/**
+ * Interactive setup wizard for spck-cli
+ * Configures CLI to connect to proxy server
+ */
+
+import * as readline from 'readline';
+import { ServerConfig } from '../types.js';
+import { saveConfig, createDefaultConfig } from '../config/config.js';
+import { ensureProjectDir } from '../utils/project-dir.js';
+import { gitignoreExists, isSpckEditorIgnored, addSpckEditorToGitignore } from '../utils/gitignore.js';
+import { t } from '../i18n/index.js';
+
+const USER_AUTH_DOCS_URL = 'https://spck.io/docs/cli#user-authentication';
+
+/**
+ * Create readline interface
+ */
+function createPrompt(): readline.Interface {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+}
+
+/**
+ * Prompt user for input
+ */
+function question(rl: readline.Interface, query: string): Promise<string> {
+  return new Promise((resolve) => {
+    rl.question(query, (answer) => {
+      resolve(answer);
+    });
+  });
+}
+
+/**
+ * Ask yes/no question
+ */
+async function questionYesNo(
+  rl: readline.Interface,
+  query: string,
+  defaultValue: boolean
+): Promise<boolean> {
+  const answer = await question(rl, query);
+  const normalized = answer.trim().toLowerCase();
+
+  if (normalized === '') {
+    return defaultValue;
+  }
+
+  return normalized === 'y' || normalized === 'yes';
+}
+
+/**
+ * Run the setup wizard
+ */
+export async function runSetup(configPath?: string): Promise<ServerConfig> {
+  const rl = createPrompt();
+
+  console.log('\n' + '='.repeat(60));
+  console.log('     ' + t('setup.title'));
+  console.log('='.repeat(60) + '\n');
+
+  console.log(t('setup.description1'));
+  console.log(t('setup.description2'));
+  console.log(t('setup.description3') + '\n');
+
+  try {
+    // Step 1: Root directory
+    console.log('--- ' + t('setup.projectConfig') + ' ---\n');
+
+    const root = await question(
+      rl,
+      t('setup.rootDirPrompt', { default: process.cwd() })
+    );
+    const rootPath = root.trim() || process.cwd();
+
+    // Step 1.5: Server name (for QR code identification)
+    const defaultConfig = createDefaultConfig();
+
+    // Step 2: Terminal service
+    console.log('\n--- ' + t('setup.terminalConfig') + ' ---\n');
+    console.log(t('setup.terminalDescription'));
+
+    const terminalEnabled = await questionYesNo(
+      rl,
+      t('setup.terminalPrompt'),
+      true
+    );
+
+    let maxBufferedLines = 5000;
+    let maxTerminals = 10;
+
+    // Step 4: Advanced terminal configuration
+    if (terminalEnabled) {
+      const advancedTerminal = await questionYesNo(
+        rl,
+        '\n' + t('setup.advancedTerminalPrompt'),
+        false
+      );
+
+      if (advancedTerminal) {
+        console.log('');
+        const bufferInput = await question(
+          rl,
+          t('setup.maxBufferPrompt', { default: String(maxBufferedLines) })
+        );
+        maxBufferedLines = parseInt(bufferInput) || 5000;
+
+        console.log('   ' + t('setup.maxBufferHint') + '\n');
+
+        const maxTermInput = await question(
+          rl,
+          t('setup.maxTerminalsPrompt', { default: String(maxTerminals) })
+        );
+        maxTerminals = parseInt(maxTermInput) || 10;
+      }
+    }
+
+    // Step 5: Browser proxy configuration
+    console.log('\n--- ' + t('setup.browserProxyConfig') + ' ---\n');
+    console.log(t('setup.browserProxyDescription') + '\n');
+
+    const browserProxyEnabled = await questionYesNo(
+      rl,
+      t('setup.browserProxyPrompt'),
+      true
+    );
+
+    // Step 6: Security configuration
+    console.log('\n--- ' + t('setup.securityConfig') + ' ---\n');
+    console.log(t('setup.securityDescription1'));
+    console.log(t('setup.securityDescription2'));
+    console.log(t('setup.securityDescription3'));
+    console.log(t('setup.securityDocsHint', { url: USER_AUTH_DOCS_URL }) + '\n');
+
+    const userAuthEnabled = await questionYesNo(
+      rl,
+      t('setup.securityPrompt'),
+      false
+    );
+
+    // Step 6: .gitignore configuration (advanced)
+    let shouldAddToGitignore = false;
+
+    if (gitignoreExists(rootPath)) {
+      if (!isSpckEditorIgnored(rootPath)) {
+        console.log('\n--- ' + t('setup.gitConfig') + ' ---\n');
+        console.log(t('setup.gitignoreDetected'));
+        console.log(t('setup.gitignoreRecommend1'));
+        console.log(t('setup.gitignoreRecommend2') + '\n');
+
+        shouldAddToGitignore = await questionYesNo(
+          rl,
+          t('setup.gitignorePrompt'),
+          true
+        );
+      }
+    }
+
+    rl.close();
+
+    // Create configuration
+    const config: ServerConfig = {
+      version: 1,
+      root: rootPath,
+      name: defaultConfig.name,
+      terminal: {
+        enabled: terminalEnabled,
+        maxBufferedLines,
+        maxTerminals
+      },
+      security: {
+        userAuthenticationEnabled: userAuthEnabled
+      },
+      browserProxy: {
+        enabled: browserProxyEnabled
+      },
+      filesystem: {
+        maxFileSize: '10MB',
+        watchIgnorePatterns: [
+          '**/.git/**',
+          '**/.spck-editor/**',
+          '**/node_modules/**',
+          '**/*.log',
+          '**/.DS_Store',
+          '**/dist/**',
+          '**/build/**'
+        ]
+      }
+    };
+
+    // Ensure project directory exists (creates symlink)
+    ensureProjectDir(config.root);
+
+    // Save configuration
+    saveConfig(config, configPath);
+
+    // Add to .gitignore if requested
+    if (shouldAddToGitignore) {
+      try {
+        addSpckEditorToGitignore(config.root);
+        console.log('\n✅ ' + t('setup.gitignoreAdded'));
+      } catch (error: any) {
+        console.warn('\n⚠️  ' + t('setup.gitignoreFailed', { message: error.message }));
+        console.warn('   ' + t('setup.gitignoreManualHint'));
+      }
+    }
+
+    console.log('\n' + '='.repeat(60));
+    console.log('✅ ' + t('config.saved'));
+    console.log('='.repeat(60) + '\n');
+
+    displayConfigSummary(config);
+
+    return config;
+
+  } catch (error: any) {
+    rl.close();
+    console.error('\n❌ ' + t('setup.setupFailed', { message: error.message }));
+    throw error;
+  }
+}
+
+/**
+ * Display configuration summary
+ */
+function displayConfigSummary(config: ServerConfig): void {
+  console.log(t('setup.configSummary'));
+  console.log('  ' + t('setup.summaryName', { name: config.name || t('setup.summaryNameNotSet') }));
+  console.log('  ' + t('setup.summaryRoot', { root: config.root }));
+  console.log('  ' + t('setup.summaryTerminal', { status: config.terminal.enabled ? t('setup.summaryEnabled') : t('setup.summaryDisabled') }));
+
+  if (config.terminal.enabled) {
+    console.log('  ' + t('setup.summaryMaxBuffer', { value: String(config.terminal.maxBufferedLines) }));
+    console.log('  ' + t('setup.summaryMaxProcesses', { value: String(config.terminal.maxTerminals) }));
+  }
+
+  console.log('  ' + t('setup.summaryUserAuth', { status: config.security.userAuthenticationEnabled ? t('setup.summaryEnabled') : t('setup.summaryDisabled') }));
+  console.log('  ' + t('setup.summaryBrowserProxy', { status: config.browserProxy?.enabled !== false ? t('setup.summaryEnabled') : t('setup.summaryDisabled') }));
+  console.log('');
+}

package/src/types/fossil-delta.d.ts

@@ -0,0 +1,4 @@
+declare module 'fossil-delta' {
+  export function create(origin: Buffer, target: Buffer): Buffer;
+  export function apply(origin: Buffer, delta: Buffer): Buffer;
+}

package/src/types.ts

@@ -0,0 +1,287 @@
+/**
+ * Core type definitions for spck-cli server
+ */
+
+// Minimal Socket interface for our needs (not dependent on socket.io)
+export interface SocketInterface {
+  id: string;
+  emit(event: string, data?: any): boolean;
+  on(event: string, listener: (...args: any[]) => void): this;
+  off(event: string, listener: (...args: any[]) => void): this;
+  broadcast: {
+    emit(event: string, data?: any): boolean;
+  };
+  data: {
+    uid: string;       // CLI user ID (from Firebase auth)
+    deviceId: string;  // Mobile device ID (identifies the specific device)
+  };
+}
+
+// Server Configuration
+export interface ServerConfig {
+  version: number;
+  root: string;
+  name?: string; // Optional: Friendly name for QR code identification
+
+  terminal: {
+    enabled: boolean;
+    maxBufferedLines: number;
+    maxTerminals: number;
+  };
+
+  security: {
+    userAuthenticationEnabled: boolean;
+  };
+
+  filesystem: {
+    maxFileSize: string;
+    watchIgnorePatterns: string[];
+  };
+
+  browserProxy?: {
+    enabled: boolean;
+  };
+}
+
+// Connection Settings (stored in .spck-editor/config/connection-settings.json)
+export interface ConnectionSettings {
+  serverToken: string;
+  serverTokenExpiry: number;
+  clientId: string;
+  secret: string;
+  userId: string;
+  connectedAt: number;
+}
+
+// Stored credentials (persisted to ~/.spck-editor/.credentials.json)
+// Only refreshToken and userId are persisted - firebaseToken is generated on demand
+export interface StoredCredentials {
+  refreshToken: string;
+  userId: string;
+  proxyServerUrl?: string;
+}
+
+// Global config (persisted to ~/.spck-editor/global.config)
+export interface GlobalConfig {
+  knownDeviceIds: string[];
+}
+
+// Firebase Credentials (runtime - includes ephemeral ID token)
+export interface FirebaseCredentials {
+  firebaseToken: string;
+  firebaseTokenExpiry: number;
+  refreshToken: string;
+  userId: string;
+}
+
+// JSON-RPC 2.0 Types
+export interface JSONRPCRequest {
+  jsonrpc: '2.0';
+  method: string;
+  params?: any;
+  id?: number | string;
+  timestamp?: number;
+  hmac: string;
+  nonce: string;
+}
+
+export interface JSONRPCResponse {
+  jsonrpc: '2.0';
+  result?: any;
+  error?: JSONRPCError;
+  id: number | string | null;
+}
+
+export interface JSONRPCError {
+  code: number;
+  message: string;
+  data?: any;
+}
+
+export interface JSONRPCNotification {
+  jsonrpc: '2.0';
+  method: string;
+  params?: any;
+}
+
+// JWT Payload
+export interface JWTPayload {
+  aud: string;
+  iat: number;
+  exp: number;
+  iss: string;
+  sub: string;
+  [key: string]: any;
+}
+
+// Socket with user data (extends our minimal socket interface)
+export interface AuthenticatedSocket extends SocketInterface {}
+
+// Error codes (JSON-RPC 2.0 + custom)
+export enum ErrorCode {
+  // Standard JSON-RPC 2.0
+  PARSE_ERROR = -32700,
+  INVALID_REQUEST = -32600,
+  METHOD_NOT_FOUND = -32601,
+  INVALID_PARAMS = -32602,
+  INTERNAL_ERROR = -32603,
+
+  // Authentication & Security
+  AUTHENTICATION_FAILED = -32001,
+  JWT_EXPIRED = -32002,
+  HMAC_VALIDATION_FAILED = -32003,
+  PERMISSION_DENIED = -32005,
+
+  // Filesystem
+  FILE_NOT_FOUND = -32004,
+  WRITE_CONFLICT = -32006,
+  INVALID_PATH = -32007,
+  FILE_TOO_LARGE = -32031,
+  INVALID_ENCODING = -32032,
+  DELTA_PATCH_FAILED = -32033,
+
+  // Git
+  GIT_OPERATION_FAILED = -32010,
+  INVALID_OID = -32011,
+  REPOSITORY_NOT_FOUND = -32012,
+
+  // Terminal
+  TERMINAL_NOT_FOUND = -32020,
+  TERMINAL_LIMIT_EXCEEDED = -32021,
+  TERMINAL_PROCESS_EXITED = -32022,
+
+  // Browser Proxy
+  BROWSER_PROXY_REQUEST_FAILED = -32050,
+
+  // General
+  OPERATION_TIMEOUT = -32030,
+  UID_NOT_AUTHORIZED = -32040,
+  FEATURE_DISABLED = -32041,
+}
+
+// Helper to create JSON-RPC error
+export function createRPCError(
+  code: ErrorCode,
+  message: string,
+  data?: any
+): JSONRPCError {
+  return { code, message, data };
+}
+
+// Proxy Protocol Messages
+
+// Handshake protocol message types
+export type HandshakeMessageType =
+  | 'auth'
+  | 'auth_result'
+  | 'request_user_verification'
+  | 'user_verification'
+  | 'protocol_info'
+  | 'protocol_selected'
+  | 'connected';
+
+// Client authentication message (JWT signed with shared secret)
+export interface ClientAuthMessage {
+  type: 'auth';
+  jwt: string;
+}
+
+// Auth result message (CLI -> Client)
+export interface AuthResultMessage {
+  type: 'auth_result';
+  success: boolean;
+  error?: string;
+}
+
+// User verification request (CLI -> Client)
+export interface UserVerificationRequestMessage {
+  type: 'request_user_verification';
+  message: string;
+}
+
+// User verification response (Client -> CLI)
+export interface UserVerificationMessage {
+  type: 'user_verification';
+  firebaseToken: string;
+}
+
+// Protocol info message (CLI -> Client)
+export interface ProtocolInfoMessage {
+  type: 'protocol_info';
+  minVersion: number;
+  maxVersion: number;
+  features: {
+    terminal: boolean;
+    git: boolean;
+    fastSearch: boolean;
+  };
+}
+
+// Protocol selected message (Client -> CLI)
+export interface ProtocolSelectedMessage {
+  type: 'protocol_selected';
+  version: number;
+  ready: boolean;
+}
+
+// Connection established message (CLI -> Client)
+export interface ConnectedMessage {
+  type: 'connected';
+  message: string;
+}
+
+// Union type for all handshake messages
+export type HandshakeMessage =
+  | ClientAuthMessage
+  | AuthResultMessage
+  | UserVerificationRequestMessage
+  | UserVerificationMessage
+  | ProtocolInfoMessage
+  | ProtocolSelectedMessage
+  | ConnectedMessage;
+
+// Proxy server events (from server to CLI)
+export interface FreeTierInfo {
+  dailyLimitSeconds: number;
+  usedSeconds: number;
+}
+
+export interface ProxyAuthenticatedEvent {
+  token: string;
+  clientId: string;
+  userId: string;
+  expiresAt: number;
+  freeTierInfo?: FreeTierInfo | null;
+}
+
+export interface ProxyClientConnectingEvent {
+  connectionId: string;
+}
+
+export interface ProxyMultipleConnectionEvent {
+  existingConnections: string[];
+  newConnectionId: string;
+}
+
+export interface ProxyClientMessageEvent {
+  connectionId: string;
+  data: any;
+}
+
+export interface ProxyClientDisconnectedEvent {
+  connectionId: string;
+  reason?: string;
+  resetTime?: number;
+}
+
+export interface ProxyErrorEvent {
+  code: string;
+  message: string;
+  [key: string]: any;
+}
+
+// Tool detection result
+export interface ToolDetectionResult {
+  git: boolean;
+  ripgrep: boolean;
+}

package/src/utils/__tests__/gitignore.test.ts

@@ -0,0 +1,174 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+/**
+ * Tests for .gitignore utilities
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import {
+  gitignoreExists,
+  isSpckEditorIgnored,
+  addSpckEditorToGitignore,
+  getGitignorePath,
+} from '../gitignore';
+
+describe('gitignore utilities', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    // Create a temporary directory for each test
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'spck-gitignore-test-'));
+  });
+
+  afterEach(() => {
+    // Clean up temporary directory
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('gitignoreExists', () => {
+    it('should return false when .gitignore does not exist', () => {
+      expect(gitignoreExists(tempDir)).toBe(false);
+    });
+
+    it('should return true when .gitignore exists', () => {
+      const gitignorePath = path.join(tempDir, '.gitignore');
+      fs.writeFileSync(gitignorePath, 'node_modules/\n', 'utf8');
+
+      expect(gitignoreExists(tempDir)).toBe(true);
+    });
+  });
+
+  describe('isSpckEditorIgnored', () => {
+    it('should return false when .gitignore does not exist', () => {
+      expect(isSpckEditorIgnored(tempDir)).toBe(false);
+    });
+
+    it('should return false when .spck-editor/ is not in .gitignore', () => {
+      const gitignorePath = path.join(tempDir, '.gitignore');
+      fs.writeFileSync(gitignorePath, 'node_modules/\ndist/\n', 'utf8');
+
+      expect(isSpckEditorIgnored(tempDir)).toBe(false);
+    });
+
+    it('should return true when .spck-editor/ is in .gitignore', () => {
+      const gitignorePath = path.join(tempDir, '.gitignore');
+      fs.writeFileSync(gitignorePath, 'node_modules/\n.spck-editor/\ndist/\n', 'utf8');
+
+      expect(isSpckEditorIgnored(tempDir)).toBe(true);
+    });
+
+    it('should return false when only .spck-editor (without slash) is in .gitignore', () => {
+      const gitignorePath = path.join(tempDir, '.gitignore');
+      fs.writeFileSync(gitignorePath, 'node_modules/\n.spck-editor\ndist/\n', 'utf8');
+
+      expect(isSpckEditorIgnored(tempDir)).toBe(false);
+    });
+
+    it('should ignore comments in .gitignore', () => {
+      const gitignorePath = path.join(tempDir, '.gitignore');
+      fs.writeFileSync(
+        gitignorePath,
+        '# This is a comment\nnode_modules/\n# .spck-editor/\ndist/\n',
+        'utf8'
+      );
+
+      expect(isSpckEditorIgnored(tempDir)).toBe(false);
+    });
+
+    it('should ignore empty lines in .gitignore', () => {
+      const gitignorePath = path.join(tempDir, '.gitignore');
+      fs.writeFileSync(gitignorePath, 'node_modules/\n\n\ndist/\n', 'utf8');
+
+      expect(isSpckEditorIgnored(tempDir)).toBe(false);
+    });
+
+    it('should handle .gitignore with only whitespace lines', () => {
+      const gitignorePath = path.join(tempDir, '.gitignore');
+      fs.writeFileSync(gitignorePath, '   \n\t\n\n', 'utf8');
+
+      expect(isSpckEditorIgnored(tempDir)).toBe(false);
+    });
+  });
+
+  describe('addSpckEditorToGitignore', () => {
+    it('should create .gitignore with .spck-editor/ when file does not exist', () => {
+      addSpckEditorToGitignore(tempDir);
+
+      const gitignorePath = path.join(tempDir, '.gitignore');
+      expect(fs.existsSync(gitignorePath)).toBe(true);
+
+      const content = fs.readFileSync(gitignorePath, 'utf8');
+      expect(content).toContain('.spck-editor/');
+      expect(content).toContain('# Spck CLI project data');
+    });
+
+    it('should append .spck-editor/ to existing .gitignore', () => {
+      const gitignorePath = path.join(tempDir, '.gitignore');
+      fs.writeFileSync(gitignorePath, 'node_modules/\ndist/\n', 'utf8');
+
+      addSpckEditorToGitignore(tempDir);
+
+      const content = fs.readFileSync(gitignorePath, 'utf8');
+      expect(content).toContain('node_modules/');
+      expect(content).toContain('dist/');
+      expect(content).toContain('.spck-editor/');
+      expect(content).toContain('# Spck CLI project data');
+    });
+
+    it('should add newline before comment if .gitignore does not end with newline', () => {
+      const gitignorePath = path.join(tempDir, '.gitignore');
+      fs.writeFileSync(gitignorePath, 'node_modules/', 'utf8'); // No trailing newline
+
+      addSpckEditorToGitignore(tempDir);
+
+      const content = fs.readFileSync(gitignorePath, 'utf8');
+      expect(content).toBe('node_modules/\n\n# Spck CLI project data\n.spck-editor/\n');
+    });
+
+    it('should not add .spck-editor/ if already present', () => {
+      const gitignorePath = path.join(tempDir, '.gitignore');
+      const initialContent = 'node_modules/\n.spck-editor/\ndist/\n';
+      fs.writeFileSync(gitignorePath, initialContent, 'utf8');
+
+      addSpckEditorToGitignore(tempDir);
+
+      const content = fs.readFileSync(gitignorePath, 'utf8');
+      // Content should be unchanged
+      expect(content).toBe(initialContent);
+    });
+
+    it('should add .spck-editor/ even if .spck-editor (without slash) is present', () => {
+      const gitignorePath = path.join(tempDir, '.gitignore');
+      const initialContent = 'node_modules/\n.spck-editor\ndist/\n';
+      fs.writeFileSync(gitignorePath, initialContent, 'utf8');
+
+      addSpckEditorToGitignore(tempDir);
+
+      const content = fs.readFileSync(gitignorePath, 'utf8');
+      // Should add the pattern since .spck-editor (without slash) is different from .spck-editor/
+      expect(content).toContain('.spck-editor/');
+      expect(content).toContain('# Spck CLI project data');
+    });
+
+    it('should handle empty .gitignore file', () => {
+      const gitignorePath = path.join(tempDir, '.gitignore');
+      fs.writeFileSync(gitignorePath, '', 'utf8');
+
+      addSpckEditorToGitignore(tempDir);
+
+      const content = fs.readFileSync(gitignorePath, 'utf8');
+      expect(content).toContain('.spck-editor/');
+      expect(content).toContain('# Spck CLI project data');
+    });
+  });
+
+  describe('getGitignorePath', () => {
+    it('should return correct .gitignore path', () => {
+      const expected = path.join(tempDir, '.gitignore');
+      expect(getGitignorePath(tempDir)).toBe(expected);
+    });
+  });
+});