@soederpop/luca 0.0.6 → 0.0.8

package/src/node/features/opener.ts

@@ -37,6 +37,19 @@ export class Opener extends Feature {
   static override optionsSchema = FeatureOptionsSchema
   static { Feature.register(this, 'opener') }
 
+  private _binCache: Record<string, string> = {}
+
+  /** Resolve a binary path via `which`, caching the result. */
+  private resolveBin(name: string): string {
+    if (this._binCache[name]) return this._binCache[name]
+    try {
+      this._binCache[name] = this.container.proc.exec(`which ${name}`).trim()
+    } catch {
+      this._binCache[name] = name
+    }
+    return this._binCache[name]
+  }
+
   /**
    * Opens a path or URL with the appropriate application.
    *
@@ -62,18 +75,18 @@ export class Opener extends Feature {
     const proc = this.container.proc
 
     if (platform === 'darwin') {
-      await proc.spawnAndCapture('open', ['-a', 'Google Chrome', url])
+      await proc.spawnAndCapture(this.resolveBin('open'), ['-a', 'Google Chrome', url])
     } else if (platform === 'win32') {
-      await proc.spawnAndCapture('cmd', ['/c', 'start', 'chrome', url])
+      await proc.spawnAndCapture(this.resolveBin('cmd'), ['/c', 'start', 'chrome', url])
     } else {
       // Linux - try google-chrome, then chromium, then fall back to xdg-open
       try {
-        await proc.spawnAndCapture('google-chrome', [url])
+        await proc.spawnAndCapture(this.resolveBin('google-chrome'), [url])
       } catch {
         try {
-          await proc.spawnAndCapture('chromium', [url])
+          await proc.spawnAndCapture(this.resolveBin('chromium'), [url])
         } catch {
-          await proc.spawnAndCapture('xdg-open', [url])
+          await proc.spawnAndCapture(this.resolveBin('xdg-open'), [url])
         }
       }
     }
@@ -93,11 +106,11 @@ export class Opener extends Feature {
     const proc = this.container.proc
 
     if (platform === 'darwin') {
-      await proc.spawnAndCapture('open', ['-a', name])
+      await proc.spawnAndCapture(this.resolveBin('open'), ['-a', name])
     } else if (platform === 'win32') {
-      await proc.spawnAndCapture('cmd', ['/c', 'start', '', name])
+      await proc.spawnAndCapture(this.resolveBin('cmd'), ['/c', 'start', '', name])
     } else {
-      await proc.spawnAndCapture(name.toLowerCase(), [])
+      await proc.spawnAndCapture(this.resolveBin(name.toLowerCase()), [])
     }
   }
 
@@ -113,10 +126,10 @@ export class Opener extends Feature {
     const proc = this.container.proc
 
     try {
-      await proc.spawnAndCapture('code', [path])
+      await proc.spawnAndCapture(this.resolveBin('code'), [path])
     } catch {
       if (this.container.os.platform === 'darwin') {
-        await proc.spawnAndCapture('open', ['-a', 'Visual Studio Code', path])
+        await proc.spawnAndCapture(this.resolveBin('open'), ['-a', 'Visual Studio Code', path])
       } else {
         throw new Error('VS Code CLI (code) not found. Install it from VS Code: Command Palette > "Shell Command: Install code command in PATH"')
       }
@@ -135,10 +148,10 @@ export class Opener extends Feature {
     const proc = this.container.proc
 
     try {
-      await proc.spawnAndCapture('cursor', [path])
+      await proc.spawnAndCapture(this.resolveBin('cursor'), [path])
     } catch {
       if (this.container.os.platform === 'darwin') {
-        await proc.spawnAndCapture('open', ['-a', 'Cursor', path])
+        await proc.spawnAndCapture(this.resolveBin('open'), ['-a', 'Cursor', path])
       } else {
         throw new Error('Cursor CLI (cursor) not found. Install it from Cursor: Command Palette > "Shell Command: Install cursor command in PATH"')
       }
@@ -149,11 +162,11 @@ export class Opener extends Feature {
     const proc = this.container.proc
 
     if (platform === 'darwin') {
-      await proc.spawnAndCapture('open', [target])
+      await proc.spawnAndCapture(this.resolveBin('open'), [target])
     } else if (platform === 'win32') {
-      await proc.spawnAndCapture('cmd', ['/c', 'start', '', target])
+      await proc.spawnAndCapture(this.resolveBin('cmd'), ['/c', 'start', '', target])
     } else {
-      await proc.spawnAndCapture('xdg-open', [target])
+      await proc.spawnAndCapture(this.resolveBin('xdg-open'), [target])
     }
   }
 }

package/src/node/features/os.ts

@@ -2,6 +2,16 @@ import { Feature } from '../feature.js'
 import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
 import os from 'os'
 
+/** Information about a connected display. */
+export interface DisplayInfo {
+  name: string
+  resolution: { width: number; height: number }
+  retina: boolean
+  main: boolean
+  refreshRate?: number
+  connectionType?: string
+}
+
 /**
  * The OS feature provides access to operating system utilities and information.
  * 
@@ -153,6 +163,72 @@ export class OS extends Feature {
   get macAddresses() : string[] {
     return Object.values(this.networkInterfaces).flat().filter(v => typeof v !== 'undefined' && v.internal === false && v.family === 'IPv4').map(v => v?.mac!).filter(Boolean)
   }
+
+  /**
+   * Gets information about all connected displays.
+   *
+   * Platform-specific: currently implemented for macOS (darwin).
+   * Linux and Windows will throw with a clear "not yet implemented" message.
+   *
+   * @returns {DisplayInfo[]} Array of display information objects
+   *
+   * @example
+   * ```typescript
+   * const displays = os.getDisplayInfo()
+   * displays.forEach(d => {
+   *   console.log(`${d.name}: ${d.resolution.width}x${d.resolution.height}${d.retina ? ' (Retina)' : ''}`)
+   * })
+   * ```
+   */
+  getDisplayInfo(): DisplayInfo[] {
+    const platform = this.platform as NodeJS.Platform
+    const handler = this._displayHandlers[platform]
+
+    if (!handler) {
+      throw new Error(`getDisplayInfo() is not yet implemented for platform: ${platform}`)
+    }
+
+    return handler()
+  }
+
+  private _displayHandlers: Partial<Record<NodeJS.Platform, () => DisplayInfo[]>> = {
+    darwin: (): DisplayInfo[] => {
+      const proc = this.container.feature('proc')
+      const raw = proc.exec('system_profiler SPDisplaysDataType -json')
+      const data = JSON.parse(raw)
+      const displays: DisplayInfo[] = []
+
+      for (const gpu of data.SPDisplaysDataType ?? []) {
+        for (const d of gpu.spdisplays_ndrvs ?? []) {
+          const resStr: string = d._spdisplays_resolution ?? ''
+          const resMatch = resStr.match(/(\d+)\s*x\s*(\d+)/)
+          const hzMatch = resStr.match(/@\s*([\d.]+)\s*Hz/i)
+
+          displays.push({
+            name: d._name ?? 'Unknown',
+            resolution: {
+              width: resMatch ? parseInt(resMatch[1], 10) : 0,
+              height: resMatch ? parseInt(resMatch[2], 10) : 0,
+            },
+            retina: /retina/i.test(d._spdisplays_resolution ?? '') || /retina/i.test(d.spdisplays_display_type ?? ''),
+            main: d.spdisplays_main === 'spdisplays_yes' || /yes/i.test(d.spdisplays_main ?? ''),
+            refreshRate: hzMatch ? parseFloat(hzMatch[1]) : undefined,
+            connectionType: d.spdisplays_connection_type ?? undefined,
+          })
+        }
+      }
+
+      return displays
+    },
+
+    linux: (): DisplayInfo[] => {
+      throw new Error('getDisplayInfo() is not yet implemented for Linux')
+    },
+
+    win32: (): DisplayInfo[] => {
+      throw new Error('getDisplayInfo() is not yet implemented for Windows')
+    },
+  }
 }
 
 export default OS

package/src/node/features/port-exposer.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod'
-import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
+import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
 import * as ngrok from '@ngrok/ngrok'
 import { Feature } from '../../feature.js'
 
@@ -49,6 +49,15 @@ export const PortExposerOptionsSchema = FeatureOptionsSchema.extend({
 })
 export type PortExposerOptions = z.infer<typeof PortExposerOptionsSchema>
 
+export const PortExposerEventsSchema = FeatureEventsSchema.extend({
+	exposed: z.tuple([z.object({
+		publicUrl: z.string().optional().describe('The public ngrok URL'),
+		localPort: z.number().describe('The local port being exposed'),
+	}).describe('Exposure details')]).describe('When a local port is successfully exposed via ngrok'),
+	closed: z.tuple([]).describe('When the ngrok tunnel is closed'),
+	error: z.tuple([z.any().describe('The error object')]).describe('When an ngrok operation fails'),
+}).describe('Port Exposer events')
+
 /**
  * Port Exposer Feature
  * 
@@ -81,6 +90,7 @@ export class PortExposer extends Feature<PortExposerState, PortExposerOptions> {
 	static override shortcut = 'portExposer' as const
 	static override stateSchema = PortExposerStateSchema
 	static override optionsSchema = PortExposerOptionsSchema
+	static override eventsSchema = PortExposerEventsSchema
 	static { Feature.register(this, 'portExposer') }
 
 	private ngrokListener?: ngrok.Listener

package/src/node/features/postgres.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod'
 import { SQL } from 'bun'
 import { Feature } from '../feature.js'
-import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
+import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
 import type { ContainerContext } from '../../container.js'
 
 type SqlValue = string | number | boolean | bigint | Uint8Array | Buffer | null
@@ -21,6 +21,21 @@ export const PostgresOptionsSchema = FeatureOptionsSchema.extend({
 export type PostgresState = z.infer<typeof PostgresStateSchema>
 export type PostgresOptions = z.infer<typeof PostgresOptionsSchema>
 
+export const PostgresEventsSchema = FeatureEventsSchema.extend({
+  query: z.tuple([
+    z.string().describe('The SQL query text'),
+    z.array(z.any()).describe('Bound parameter values'),
+    z.number().describe('Number of rows returned'),
+  ]).describe('When a SELECT-like query is executed'),
+  execute: z.tuple([
+    z.string().describe('The SQL statement text'),
+    z.array(z.any()).describe('Bound parameter values'),
+    z.number().describe('Number of rows affected'),
+  ]).describe('When a write/update/delete statement is executed'),
+  error: z.tuple([z.any().describe('The error object')]).describe('When a postgres operation fails'),
+  closed: z.tuple([]).describe('When the postgres connection is closed'),
+}).describe('Postgres events')
+
 /**
  * Postgres feature for safe SQL execution through Bun's native SQL client.
  *
@@ -46,6 +61,7 @@ export class Postgres extends Feature<PostgresState, PostgresOptions> {
   static override shortcut = 'features.postgres' as const
   static override stateSchema = PostgresStateSchema
   static override optionsSchema = PostgresOptionsSchema
+  static override eventsSchema = PostgresEventsSchema
   static { Feature.register(this, 'postgres') }
 
   private _client: SQL

package/src/node/features/proc.ts

@@ -22,6 +22,8 @@ interface SpawnOptions {
   onOutput?: (data: string) => void;
   /** Callback invoked when the process exits */
   onExit?: (code: number) => void;
+  /** Callback invoked when the process starts */
+  onStart?: (childProcess: ChildProcess) => void;
 }
 
 interface RawSpawnOptions {
@@ -69,6 +71,7 @@ export class ChildProcess extends Feature {
   static override shortcut = "features.proc" as const
   static override stateSchema = FeatureStateSchema
   static override optionsSchema = FeatureOptionsSchema
+  // @ts-ignore TODO: fix this
   static { Feature.register(this, 'proc') }
 
   /**
@@ -184,7 +187,7 @@ export class ChildProcess extends Feature {
     const childProcess = proc.childProcess!;
 
     if (typeof options?.onStart === 'function') {
-	    options.onStart(childProcess)
+	    options.onStart(childProcess as any)
     }
 
     if (childProcess.stdout && childProcess.stderr) {

package/src/node/features/python.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod'
-import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
+import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
 import { Feature } from "../feature.js";
 import { existsSync } from 'fs';
 import { join, resolve } from 'path';
@@ -31,6 +31,46 @@ export const PythonOptionsSchema = FeatureOptionsSchema.extend({
 export type PythonState = z.infer<typeof PythonStateSchema>
 export type PythonOptions = z.infer<typeof PythonOptionsSchema>
 
+export const PythonEventsSchema = FeatureEventsSchema.extend({
+  ready: z.tuple([]).describe('When the Python environment is ready for execution'),
+  environmentDetected: z.tuple([z.object({
+    pythonPath: z.string().nullable().describe('Path to the detected Python executable'),
+    environmentType: z.enum(['uv', 'conda', 'venv', 'system']).nullable().describe('Detected environment type'),
+  }).describe('Environment detection result')]).describe('When the Python environment type is detected'),
+  installingDependencies: z.tuple([z.object({
+    command: z.string().describe('The install command being run'),
+  }).describe('Install details')]).describe('When dependency installation begins'),
+  dependenciesInstalled: z.tuple([z.object({
+    stdout: z.string().describe('Standard output from install'),
+    stderr: z.string().describe('Standard error from install'),
+    exitCode: z.number().describe('Process exit code'),
+  }).describe('Install result')]).describe('When dependencies are successfully installed'),
+  dependencyInstallFailed: z.tuple([z.object({
+    stdout: z.string().describe('Standard output from install'),
+    stderr: z.string().describe('Standard error from install'),
+    exitCode: z.number().describe('Process exit code'),
+  }).describe('Install result')]).describe('When dependency installation fails'),
+  codeExecuted: z.tuple([z.object({
+    code: z.string().describe('The Python code that was executed'),
+    variables: z.record(z.any()).describe('Variables passed to the execution'),
+    result: z.object({
+      stdout: z.string().describe('Standard output'),
+      stderr: z.string().describe('Standard error'),
+      exitCode: z.number().describe('Process exit code'),
+    }).describe('Execution result'),
+  }).describe('Code execution details')]).describe('When Python code finishes executing'),
+  fileExecuted: z.tuple([z.object({
+    filePath: z.string().describe('Path to the executed Python file'),
+    variables: z.record(z.any()).describe('Variables passed as arguments'),
+    result: z.object({
+      stdout: z.string().describe('Standard output'),
+      stderr: z.string().describe('Standard error'),
+      exitCode: z.number().describe('Process exit code'),
+    }).describe('Execution result'),
+  }).describe('File execution details')]).describe('When a Python file finishes executing'),
+  localsParseError: z.tuple([z.any().describe('The parse error')]).describe('When captured locals fail to parse as JSON'),
+}).describe('Python events')
+
 /**
  * The Python VM feature provides Python virtual machine capabilities for executing Python code.
  * 
@@ -64,6 +104,7 @@ export class Python<
   static override shortcut = "features.python" as const
   static override stateSchema = PythonStateSchema
   static override optionsSchema = PythonOptionsSchema
+  static override eventsSchema = PythonEventsSchema
   static { Feature.register(this, 'python') }
 
   override get initialState(): T {
@@ -137,6 +178,13 @@ export class Python<
     let pythonPath: string | null = null
     let environmentType: PythonState['environmentType'] = null
 
+    const proc = this.container.feature('proc')
+
+    /** Resolve a binary to its full path via `which`, falling back to the bare name. */
+    const resolveBin = (name: string): string => {
+      try { return proc.exec(`which ${name}`).trim() } catch { return name }
+    }
+
     // Use explicitly provided Python path
     if (this.options.pythonPath) {
       pythonPath = this.options.pythonPath
@@ -145,10 +193,10 @@ export class Python<
     // Check for uv
     else if (existsSync(join(projectDir, 'uv.lock')) || existsSync(join(projectDir, 'pyproject.toml'))) {
       try {
-        const proc = this.container.feature('proc')
-        const result = await proc.execAndCapture('uv run python --version')
+        const uvBin = resolveBin('uv')
+        const result = await proc.execAndCapture(`${uvBin} run python --version`)
         if (result.exitCode === 0) {
-          pythonPath = 'uv run python'
+          pythonPath = `${uvBin} run python`
           environmentType = 'uv'
         }
       } catch (error) {
@@ -158,10 +206,10 @@ export class Python<
     // Check for conda
     else if (existsSync(join(projectDir, 'environment.yml')) || existsSync(join(projectDir, 'conda.yml'))) {
       try {
-        const proc = this.container.feature('proc')
-        const result = await proc.execAndCapture('conda run python --version')
+        const condaBin = resolveBin('conda')
+        const result = await proc.execAndCapture(`${condaBin} run python --version`)
         if (result.exitCode === 0) {
-          pythonPath = 'conda run python'
+          pythonPath = `${condaBin} run python`
           environmentType = 'conda'
         }
       } catch (error) {
@@ -171,10 +219,10 @@ export class Python<
     // Check for venv
     else if (existsSync(join(projectDir, 'venv')) || existsSync(join(projectDir, '.venv'))) {
       const venvPath = existsSync(join(projectDir, 'venv')) ? 'venv' : '.venv'
-      const venvPython = process.platform === 'win32' 
+      const venvPython = process.platform === 'win32'
         ? join(projectDir, venvPath, 'Scripts', 'python.exe')
         : join(projectDir, venvPath, 'bin', 'python')
-      
+
       if (existsSync(venvPython)) {
         pythonPath = venvPython
         environmentType = 'venv'
@@ -184,15 +232,16 @@ export class Python<
     // Fall back to system Python
     if (!pythonPath) {
       try {
-        const proc = this.container.feature('proc')
-        const result = await proc.execAndCapture('python3 --version')
+        const python3Bin = resolveBin('python3')
+        const result = await proc.execAndCapture(`${python3Bin} --version`)
         if (result.exitCode === 0) {
-          pythonPath = 'python3'
+          pythonPath = python3Bin
           environmentType = 'system'
         } else {
-          const result2 = await proc.execAndCapture('python --version')
+          const pythonBin = resolveBin('python')
+          const result2 = await proc.execAndCapture(`${pythonBin} --version`)
           if (result2.exitCode === 0) {
-            pythonPath = 'python'
+            pythonPath = pythonBin
             environmentType = 'system'
           }
         }

package/src/node/features/repl.ts

@@ -61,7 +61,7 @@ export class Repl<
    * Type `.exit` or `exit` to quit. Supports top-level await.
    *
    * @param options - Configuration for the REPL session
-   * @param options.historyPath - Custom path for the history file (defaults to node_modules/.cache/.repl_history)
+   * @param options.historyPath - Custom path for the history file (defaults to ~/.cache/luca/repl-{cwdHash}.history)
    * @param options.context - Additional variables to inject into the VM context
    * @returns The Repl instance
    *
@@ -81,17 +81,20 @@ export class Repl<
 
     const { prompt = "> " } = this.options;
 
-    // Set up history file
+    // Set up history file — per-project history keyed by cwd hash
     const userHistoryPath = options.historyPath || this.options.historyPath
-    this._historyPath = typeof userHistoryPath === 'string'
-      ? this.container.paths.resolve(userHistoryPath)
-      : this.container.paths.resolve('node_modules', '.cache', '.repl_history')
+    if (typeof userHistoryPath === 'string') {
+      this._historyPath = this.container.paths.resolve(userHistoryPath)
+    } else {
+      const cwdHash = this.container.utils.hashObject(this.container.cwd)
+      this._historyPath = this.container.paths.resolve(process.env.HOME!, '.cache', 'luca', `repl-${cwdHash}.history`)
+    }
 
     this.container.fs.ensureFolder(this.container.paths.dirname(this._historyPath))
 
     // Load existing history
     try {
-      const content = fs.readFileSync(this._historyPath, 'utf-8')
+      const content = fs.readFile(this._historyPath, 'utf-8')
       this._history = content.split('\n').filter(Boolean).reverse()
     } catch {}
 
@@ -99,6 +102,7 @@ export class Repl<
     this._vmContext = vm.createContext({
       ...this.container.context,
       ...options.context,
+      setTimeout, setInterval, process, clearInterval, clearTimeout, Buffer, URL, URLSearchParams,
       // @ts-ignore
       client: (...args: any[]) => this.container.client(...args),
     })
@@ -192,4 +196,4 @@ export class Repl<
   }
 }
 
-export default Repl
+export default Repl

package/src/node/features/runpod.ts

@@ -37,11 +37,24 @@ export class Runpod extends Feature<RunpodState, RunpodOptions> {
   static override optionsSchema = RunpodOptionsSchema
   static { Feature.register(this, 'runpod') }
 
+	private _resolvedRunpodctlPath: string | null = null
+
 	/** The proc feature used for executing CLI commands like runpodctl. */
 	get proc() {
 		return this.container.feature('proc')
 	}
 
+	/** Resolve the runpodctl binary path via `which`, caching the result. */
+	get runpodctlPath(): string {
+		if (this._resolvedRunpodctlPath) return this._resolvedRunpodctlPath
+		try {
+			this._resolvedRunpodctlPath = this.proc.exec('which runpodctl').trim()
+		} catch {
+			this._resolvedRunpodctlPath = 'runpodctl'
+		}
+		return this._resolvedRunpodctlPath
+	}
+
 	/** RunPod API key from options or the RUNPOD_API_KEY environment variable. */
 	get apiKey() {
 		return this.options.apiKey || process.env.RUNPOD_API_KEY || ''
@@ -510,7 +523,7 @@ export class Runpod extends Feature<RunpodState, RunpodOptions> {
 	 * ```
 	 */
 	async listPods(detailed = false): Promise<PodInfo[]> {
-		const { stdout: output } = await this.proc.spawnAndCapture('runpodctl', ['get', 'pod', '-a'])
+		const { stdout: output } = await this.proc.spawnAndCapture(this.runpodctlPath, ['get', 'pod', '-a'])
 		const pods = output
 			.trim()
 			.split("\n")
@@ -550,7 +563,7 @@ export class Runpod extends Feature<RunpodState, RunpodOptions> {
 	 * ```
 	 */
 	async getPodInfo(podId: string): Promise<PodInfo> {
-		const { stdout: output } = await this.proc.spawnAndCapture('runpodctl', ['get', 'pod', podId, '-a'])
+		const { stdout: output } = await this.proc.spawnAndCapture(this.runpodctlPath, ['get', 'pod', podId, '-a'])
 
 		return output
 			.trim()
@@ -588,7 +601,7 @@ export class Runpod extends Feature<RunpodState, RunpodOptions> {
 	 * ```
 	 */
 	async listSecureGPUs() {
-		const { stdout: output } = await this.proc.spawnAndCapture('runpodctl', ['get', 'cloud', '--secure'])
+		const { stdout: output } = await this.proc.spawnAndCapture(this.runpodctlPath, ['get', 'cloud', '--secure'])
 
 		return output
 			.split("\n")

package/src/node/features/secure-shell.ts

@@ -58,6 +58,9 @@ export class SecureShell extends Feature<SecureShellState, SecureShellOptions> {
 		}
 	}
 
+	private _resolvedSshPath: string | null = null
+	private _resolvedScpPath: string | null = null
+
 	/**
 	 * Get the proc feature for executing shell commands
 	 */
@@ -65,6 +68,28 @@ export class SecureShell extends Feature<SecureShellState, SecureShellOptions> {
 		return this.container.feature('proc')
 	}
 
+	/** Resolved path to the ssh binary */
+	get sshPath(): string {
+		if (this._resolvedSshPath) return this._resolvedSshPath
+		try {
+			this._resolvedSshPath = this.proc.exec('which ssh').trim()
+		} catch {
+			this._resolvedSshPath = 'ssh'
+		}
+		return this._resolvedSshPath
+	}
+
+	/** Resolved path to the scp binary */
+	get scpPath(): string {
+		if (this._resolvedScpPath) return this._resolvedScpPath
+		try {
+			this._resolvedScpPath = this.proc.exec('which scp').trim()
+		} catch {
+			this._resolvedScpPath = 'scp'
+		}
+		return this._resolvedScpPath
+	}
+
 	/**
 	 * Validate that required options are provided
 	 */
@@ -86,7 +111,7 @@ export class SecureShell extends Feature<SecureShellState, SecureShellOptions> {
 	private buildSSHConnectionString(): string {
 		this.validateOptions()
 		const { host, port = 22, username, key } = this.options
-		let sshCmd = `ssh -p ${port}`
+		let sshCmd = `${this.sshPath} -p ${port}`
 		
 		if (key) {
 			sshCmd += ` -i "${key}"`
@@ -106,7 +131,7 @@ export class SecureShell extends Feature<SecureShellState, SecureShellOptions> {
 	private buildSCPConnectionString(): string {
 		this.validateOptions()
 		const { host, port = 22, username, key } = this.options
-		let scpCmd = `scp -P ${port}`
+		let scpCmd = `${this.scpPath} -P ${port}`
 		
 		if (key) {
 			scpCmd += ` -i "${key}"`

package/src/node/features/semantic-search.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod'
-import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
+import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
 import { type AvailableFeatures } from '@soederpop/luca/feature'
 import { Feature } from '../feature.js'
 import { Database } from 'bun:sqlite'
@@ -34,6 +34,16 @@ export const SemanticSearchStateSchema = FeatureStateSchema.extend({
 export type SemanticSearchOptions = z.infer<typeof SemanticSearchOptionsSchema>
 export type SemanticSearchState = z.infer<typeof SemanticSearchStateSchema>
 
+export const SemanticSearchEventsSchema = FeatureEventsSchema.extend({
+	modelLoaded: z.tuple([]).describe('When the local embedding model is loaded into memory'),
+	dbReady: z.tuple([]).describe('When the SQLite database is initialized and ready'),
+	indexed: z.tuple([z.object({
+		documents: z.number().describe('Number of documents indexed'),
+		chunks: z.number().describe('Number of chunks created'),
+	}).describe('Indexing result')]).describe('When documents are indexed with embeddings'),
+	modelDisposed: z.tuple([]).describe('When the local embedding model is disposed from memory'),
+}).describe('Semantic Search events')
+
 // ── Types ───────────────────────────────────────────────────────────
 
 export interface Chunk {
@@ -273,6 +283,7 @@ function chunkByDocument(doc: DocumentInput): Chunk[] {
 export class SemanticSearch extends Feature<SemanticSearchState, SemanticSearchOptions> {
 	static override stateSchema = SemanticSearchStateSchema
 	static override optionsSchema = SemanticSearchOptionsSchema
+	static override eventsSchema = SemanticSearchEventsSchema
 	static override shortcut = 'features.semanticSearch' as const
 	static { Feature.register(this, 'semanticSearch') }