spindb 0.9.2 → 0.10.0

package/core/config-manager.ts

@@ -5,11 +5,13 @@ import { promisify } from 'util'
 import { dirname } from 'path'
 import { paths } from '../config/paths'
 import { logDebug, logWarning } from './error-handler'
+import { platformService } from './platform-service'
 import type {
   SpinDBConfig,
   BinaryConfig,
   BinaryTool,
   BinarySource,
+  SQLiteEngineRegistry,
 } from '../types'
 
 const execAsync = promisify(exec)
@@ -164,73 +166,12 @@ export class ConfigManager {
 
   /**
    * Detect a binary on the system PATH
+   * Uses platformService for cross-platform detection (handles which/where and .exe extension)
    */
   async detectSystemBinary(tool: BinaryTool): Promise<string | null> {
-    try {
-      const { stdout } = await execAsync(`which ${tool}`)
-      const path = stdout.trim()
-      if (path && existsSync(path)) {
-        return path
-      }
-    } catch (error) {
-      logDebug('which command failed for binary detection', {
-        tool,
-        error: error instanceof Error ? error.message : String(error),
-      })
-    }
-
-    // Check common locations
-    const commonPaths = this.getCommonBinaryPaths(tool)
-    for (const path of commonPaths) {
-      if (existsSync(path)) {
-        return path
-      }
-    }
-
-    return null
-  }
-
-  /**
-   * Get common installation paths for database tools
-   */
-  private getCommonBinaryPaths(tool: BinaryTool): string[] {
-    const commonPaths: string[] = []
-
-    // Homebrew (macOS ARM)
-    commonPaths.push(`/opt/homebrew/bin/${tool}`)
-    // Homebrew (macOS Intel)
-    commonPaths.push(`/usr/local/bin/${tool}`)
-
-    // PostgreSQL-specific paths
-    if (POSTGRESQL_TOOLS.includes(tool) || tool === 'pgcli') {
-      commonPaths.push(`/opt/homebrew/opt/libpq/bin/${tool}`)
-      commonPaths.push(`/usr/local/opt/libpq/bin/${tool}`)
-      // Postgres.app (macOS)
-      commonPaths.push(
-        `/Applications/Postgres.app/Contents/Versions/latest/bin/${tool}`,
-      )
-      // Linux PostgreSQL paths
-      commonPaths.push(`/usr/lib/postgresql/17/bin/${tool}`)
-      commonPaths.push(`/usr/lib/postgresql/16/bin/${tool}`)
-      commonPaths.push(`/usr/lib/postgresql/15/bin/${tool}`)
-      commonPaths.push(`/usr/lib/postgresql/14/bin/${tool}`)
-    }
-
-    // MySQL-specific paths
-    if (MYSQL_TOOLS.includes(tool) || tool === 'mycli') {
-      commonPaths.push(`/opt/homebrew/opt/mysql/bin/${tool}`)
-      commonPaths.push(`/opt/homebrew/opt/mysql-client/bin/${tool}`)
-      commonPaths.push(`/usr/local/opt/mysql/bin/${tool}`)
-      commonPaths.push(`/usr/local/opt/mysql-client/bin/${tool}`)
-      // Linux MySQL/MariaDB paths
-      commonPaths.push(`/usr/bin/${tool}`)
-      commonPaths.push(`/usr/sbin/${tool}`)
-    }
-
-    // General Linux paths
-    commonPaths.push(`/usr/bin/${tool}`)
-
-    return commonPaths
+    // Use platformService which handles cross-platform differences
+    // (which vs where, .exe extension, platform-specific search paths)
+    return platformService.findToolPath(tool)
   }
 
   /**
@@ -349,6 +290,37 @@ export class ConfigManager {
     config.binaries = {}
     await this.save()
   }
+
+  // ============================================================
+  // SQLite Registry Methods
+  // ============================================================
+
+  /**
+   * Get the SQLite registry from config
+   * Returns empty registry if none exists
+   */
+  async getSqliteRegistry(): Promise<SQLiteEngineRegistry> {
+    const config = await this.load()
+    return (
+      config.registry?.sqlite ?? {
+        version: 1,
+        entries: [],
+        ignoreFolders: {},
+      }
+    )
+  }
+
+  /**
+   * Save the SQLite registry to config
+   */
+  async saveSqliteRegistry(registry: SQLiteEngineRegistry): Promise<void> {
+    const config = await this.load()
+    if (!config.registry) {
+      config.registry = {}
+    }
+    config.registry.sqlite = registry
+    await this.save()
+  }
 }
 
 export const configManager = new ConfigManager()

package/core/dependency-manager.ts

@@ -22,9 +22,37 @@ import {
 } from '../config/os-dependencies'
 import { platformService } from './platform-service'
 import { configManager } from './config-manager'
+import type { BinaryTool } from '../types'
 
 const execAsync = promisify(exec)
 
+/**
+ * Known binary tools that can be registered in config
+ */
+const KNOWN_BINARY_TOOLS: readonly BinaryTool[] = [
+  'psql',
+  'pg_dump',
+  'pg_restore',
+  'pg_basebackup',
+  'mysql',
+  'mysqldump',
+  'mysqlpump',
+  'mysqld',
+  'mysqladmin',
+  'sqlite3',
+  'pgcli',
+  'mycli',
+  'litecli',
+  'usql',
+] as const
+
+/**
+ * Type guard to check if a string is a known BinaryTool
+ */
+function isBinaryTool(binary: string): binary is BinaryTool {
+  return KNOWN_BINARY_TOOLS.includes(binary as BinaryTool)
+}
+
 export type DependencyStatus = {
   dependency: Dependency
   installed: boolean
@@ -79,7 +107,17 @@ export async function findBinary(
   binary: string,
 ): Promise<{ path: string; version?: string } | null> {
   try {
-    // Use platformService to find the binary path
+    // First check if we have this binary registered in config (e.g., from downloaded PostgreSQL)
+    if (isBinaryTool(binary)) {
+      const configPath = await configManager.getBinaryPath(binary)
+      if (configPath) {
+        const version =
+          (await platformService.getToolVersion(configPath)) || undefined
+        return { path: configPath, version }
+      }
+    }
+
+    // Fall back to system PATH search
     const path = await platformService.findToolPath(binary)
     if (!path) return null
 

package/core/platform-service.ts

@@ -121,6 +121,28 @@ export abstract class BasePlatformService {
    */
   abstract getZonkyPlatform(): string | null
 
+  /**
+   * Get the null device path for this platform ('/dev/null' on Unix, 'NUL' on Windows)
+   */
+  abstract getNullDevice(): string
+
+  /**
+   * Get the executable file extension for this platform ('' on Unix, '.exe' on Windows)
+   */
+  abstract getExecutableExtension(): string
+
+  /**
+   * Terminate a process by PID
+   * @param pid - Process ID to terminate
+   * @param force - If true, force kill (SIGKILL on Unix, /F on Windows)
+   */
+  abstract terminateProcess(pid: number, force: boolean): Promise<void>
+
+  /**
+   * Check if a process is running by PID
+   */
+  abstract isProcessRunning(pid: number): boolean
+
   /**
    * Copy text to clipboard
    */
@@ -153,13 +175,17 @@ export abstract class BasePlatformService {
   async findToolPath(toolName: string): Promise<string | null> {
     const whichConfig = this.getWhichCommand()
 
-    // First try the which/where command
+    // First try the which/where command (with timeout to prevent hanging)
     try {
-      const { stdout } = await execAsync(`${whichConfig.command} ${toolName}`)
-      const path = stdout.trim().split('\n')[0]
-      if (path && existsSync(path)) {
-        return path
-      }
+      const cmd = [whichConfig.command, ...whichConfig.args, toolName]
+        .filter(Boolean)
+        .join(' ')
+      const { stdout } = await execAsync(cmd, { timeout: 5000 })
+      const path = stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0)
+      if (path && existsSync(path)) return path
     } catch {
       // Not found via which, continue to search paths
     }
@@ -186,7 +212,9 @@ export abstract class BasePlatformService {
    */
   async getToolVersion(toolPath: string): Promise<string | null> {
     try {
-      const { stdout } = await execAsync(`"${toolPath}" --version`)
+      const { stdout } = await execAsync(`"${toolPath}" --version`, {
+        timeout: 5000,
+      })
       const match = stdout.match(/(\d+\.\d+(\.\d+)?)/)
       return match ? match[1] : null
     } catch {
@@ -332,6 +360,28 @@ class DarwinPlatformService extends BasePlatformService {
     return null
   }
 
+  getNullDevice(): string {
+    return '/dev/null'
+  }
+
+  getExecutableExtension(): string {
+    return ''
+  }
+
+  async terminateProcess(pid: number, force: boolean): Promise<void> {
+    const signal = force ? 'SIGKILL' : 'SIGTERM'
+    process.kill(pid, signal)
+  }
+
+  isProcessRunning(pid: number): boolean {
+    try {
+      process.kill(pid, 0)
+      return true
+    } catch {
+      return false
+    }
+  }
+
   protected buildToolPath(dir: string, toolName: string): string {
     return `${dir}/${toolName}`
   }
@@ -517,6 +567,28 @@ class LinuxPlatformService extends BasePlatformService {
     return null
   }
 
+  getNullDevice(): string {
+    return '/dev/null'
+  }
+
+  getExecutableExtension(): string {
+    return ''
+  }
+
+  async terminateProcess(pid: number, force: boolean): Promise<void> {
+    const signal = force ? 'SIGKILL' : 'SIGTERM'
+    process.kill(pid, signal)
+  }
+
+  isProcessRunning(pid: number): boolean {
+    try {
+      process.kill(pid, 0)
+      return true
+    } catch {
+      return false
+    }
+  }
+
   protected buildToolPath(dir: string, toolName: string): string {
     return `${dir}/${toolName}`
   }
@@ -591,9 +663,12 @@ class Win32PlatformService extends BasePlatformService {
   }
 
   async detectPackageManager(): Promise<PackageManagerInfo | null> {
+    // Timeout for package manager detection (5 seconds)
+    const timeout = 5000
+
     // Try chocolatey
     try {
-      await execAsync('choco --version')
+      await execAsync('choco --version', { timeout })
       return {
         id: 'choco',
         name: 'Chocolatey',
@@ -602,12 +677,12 @@ class Win32PlatformService extends BasePlatformService {
         updateCommand: 'choco upgrade all',
       }
     } catch {
-      // Not chocolatey
+      // Not chocolatey or timed out
     }
 
     // Try winget
     try {
-      await execAsync('winget --version')
+      await execAsync('winget --version', { timeout })
       return {
         id: 'winget',
         name: 'Windows Package Manager',
@@ -616,7 +691,21 @@ class Win32PlatformService extends BasePlatformService {
         updateCommand: 'winget upgrade --all',
       }
     } catch {
-      // Not winget
+      // Not winget or timed out
+    }
+
+    // Try scoop
+    try {
+      await execAsync('scoop --version', { timeout })
+      return {
+        id: 'scoop',
+        name: 'Scoop',
+        checkCommand: 'scoop --version',
+        installTemplate: 'scoop install {package}',
+        updateCommand: 'scoop update *',
+      }
+    } catch {
+      // Not scoop or timed out
     }
 
     return null
@@ -627,6 +716,40 @@ class Win32PlatformService extends BasePlatformService {
     return null
   }
 
+  getNullDevice(): string {
+    return 'NUL'
+  }
+
+  getExecutableExtension(): string {
+    return '.exe'
+  }
+
+  async terminateProcess(pid: number, force: boolean): Promise<void> {
+    // On Windows, use taskkill command
+    // /T = terminate child processes, /F = force termination
+    const args = force ? `/F /PID ${pid} /T` : `/PID ${pid}`
+    try {
+      await execAsync(`taskkill ${args}`)
+    } catch (error) {
+      // taskkill exits with error if process doesn't exist, which is fine
+      const e = error as { code?: number }
+      // Error code 128 means "process not found" which is acceptable
+      if (e.code !== 128) {
+        throw error
+      }
+    }
+  }
+
+  isProcessRunning(pid: number): boolean {
+    try {
+      // process.kill with signal 0 works on Windows for checking process existence
+      process.kill(pid, 0)
+      return true
+    } catch {
+      return false
+    }
+  }
+
   protected buildToolPath(dir: string, toolName: string): string {
     return `${dir}\\${toolName}.exe`
   }
@@ -652,3 +775,18 @@ export function createPlatformService(): BasePlatformService {
 
 // Export singleton instance for convenience
 export const platformService = createPlatformService()
+
+/**
+ * Check if running on Windows
+ */
+export function isWindows(): boolean {
+  return process.platform === 'win32'
+}
+
+/**
+ * Get spawn options for Windows shell requirements.
+ * Windows needs shell:true for proper command execution with quoted paths.
+ */
+export function getWindowsSpawnOptions(): { shell: true } | Record<string, never> {
+  return isWindows() ? { shell: true } : {}
+}