spindb 0.34.0 → 0.34.5

package/cli/commands/info.ts

@@ -9,7 +9,7 @@ import { paths } from '../../config/paths'
 import { getEngine } from '../../engines'
 import { uiError, uiInfo, header } from '../ui/theme'
 import { getEngineIcon } from '../constants'
-import { Engine, type ContainerConfig } from '../../types'
+import { isFileBasedEngine, type ContainerConfig } from '../../types'
 
 function formatDate(dateString: string): string {
   const date = new Date(dateString)
@@ -19,8 +19,8 @@ function formatDate(dateString: string): string {
 async function getActualStatus(
   config: ContainerConfig,
 ): Promise<'running' | 'stopped' | 'available' | 'missing'> {
-  // SQLite: check file existence instead of running status
-  if (config.engine === Engine.SQLite) {
+  // File-based engines: check file existence instead of running status
+  if (isFileBasedEngine(config.engine)) {
     const fileExists = existsSync(config.database)
     return fileExists ? 'available' : 'missing'
   }
@@ -59,11 +59,11 @@ async function displayContainerInfo(
   }
 
   const icon = getEngineIcon(config.engine)
-  const isSQLite = config.engine === Engine.SQLite
+  const isFileBased = isFileBasedEngine(config.engine)
 
   // Status display based on engine type
   let statusDisplay: string
-  if (isSQLite) {
+  if (isFileBased) {
     statusDisplay =
       actualStatus === 'available'
         ? chalk.blue('🔵 available')
@@ -87,8 +87,8 @@ async function displayContainerInfo(
     chalk.gray('  ') + chalk.white('Status:'.padEnd(14)) + statusDisplay,
   )
 
-  // Show file path for SQLite, port for server databases
-  if (isSQLite) {
+  // Show file path for file-based engines, port for server databases
+  if (isFileBased) {
     console.log(
       chalk.gray('  ') +
         chalk.white('File:'.padEnd(14)) +
@@ -113,8 +113,8 @@ async function displayContainerInfo(
       chalk.gray(formatDate(config.created)),
   )
 
-  // Don't show data dir for SQLite (file path is already shown)
-  if (!isSQLite) {
+  // Don't show data dir for file-based engines (file path is already shown)
+  if (!isFileBased) {
     console.log(
       chalk.gray('  ') +
         chalk.white('Data Dir:'.padEnd(14)) +
@@ -176,11 +176,11 @@ async function displayAllContainersInfo(
 
   for (const container of containers) {
     const actualStatus = await getActualStatus(container)
-    const isSQLite = container.engine === Engine.SQLite
+    const isFileBased = isFileBasedEngine(container.engine)
 
     // Status display based on engine type
     let statusDisplay: string
-    if (isSQLite) {
+    if (isFileBased) {
       statusDisplay =
         actualStatus === 'available'
           ? chalk.blue('🔵 available')
@@ -195,9 +195,9 @@ async function displayAllContainersInfo(
     // getEngineIcon() includes trailing space for consistent alignment
     const engineDisplay = `${getEngineIcon(container.engine)}${container.engine}`
 
-    // Show truncated file path for SQLite instead of port
+    // Show truncated file path for file-based engines instead of port
     let portOrPath: string
-    if (isSQLite) {
+    if (isFileBased) {
       const fileName = basename(container.database)
       // Truncate if longer than 8 chars to fit in 8-char column
       portOrPath = fileName.length > 8 ? fileName.slice(0, 7) + '…' : fileName
@@ -223,11 +223,21 @@ async function displayAllContainersInfo(
   )
   const running = statusChecks.filter((s) => s === 'running').length
   const stopped = statusChecks.filter((s) => s === 'stopped').length
+  const fileAvailable = statusChecks.filter((s) => s === 'available').length
+  const fileMissing = statusChecks.filter((s) => s === 'missing').length
+
+  const parts: string[] = []
+  if (running + stopped > 0) {
+    parts.push(`${running} running, ${stopped} stopped`)
+  }
+  if (fileAvailable + fileMissing > 0) {
+    parts.push(
+      `${fileAvailable} file-based available${fileMissing > 0 ? `, ${fileMissing} missing` : ''}`,
+    )
+  }
 
   console.log(
-    chalk.gray(
-      `  ${containers.length} container(s): ${running} running, ${stopped} stopped`,
-    ),
+    chalk.gray(`  ${containers.length} container(s): ${parts.join('; ')}`),
   )
   console.log()
 

package/cli/commands/list.ts

@@ -6,20 +6,31 @@ import { containerManager } from '../../core/container-manager'
 import { getEngine } from '../../engines'
 import { uiInfo, uiError, formatBytes } from '../ui/theme'
 import { getEngineIcon } from '../constants'
-import { Engine } from '../../types'
+import { Engine, isFileBasedEngine } from '../../types'
 import type { ContainerConfig } from '../../types'
-import { sqliteRegistry } from '../../engines/sqlite/registry'
 import {
-  scanForUnregisteredSqliteFiles,
+  scanForUnregisteredFiles,
   deriveContainerName,
-} from '../../engines/sqlite/scanner'
+  getRegistryForEngine,
+  type UnregisteredFile,
+} from '../../engines/file-based-utils'
+
+type UnregisteredFileWithEngine = UnregisteredFile & { engine: Engine }
 
 /**
- * Prompt user about unregistered SQLite files in CWD
+ * Prompt user about unregistered file-based database files in CWD
  * Returns true if user registered any files (refresh needed)
  */
 async function promptUnregisteredFiles(): Promise<boolean> {
-  const unregistered = await scanForUnregisteredSqliteFiles()
+  const [sqliteFiles, duckdbFiles] = await Promise.all([
+    scanForUnregisteredFiles(Engine.SQLite),
+    scanForUnregisteredFiles(Engine.DuckDB),
+  ])
+
+  const unregistered: UnregisteredFileWithEngine[] = [
+    ...sqliteFiles.map((f) => ({ ...f, engine: Engine.SQLite as Engine })),
+    ...duckdbFiles.map((f) => ({ ...f, engine: Engine.DuckDB as Engine })),
+  ]
 
   if (unregistered.length === 0) {
     return false
@@ -29,6 +40,7 @@ async function promptUnregisteredFiles(): Promise<boolean> {
 
   for (let i = 0; i < unregistered.length; i++) {
     const file = unregistered[i]
+    const engineLabel = file.engine === Engine.SQLite ? 'SQLite' : 'DuckDB'
     const prompt =
       unregistered.length > 1 ? `[${i + 1} of ${unregistered.length}] ` : ''
 
@@ -36,7 +48,7 @@ async function promptUnregisteredFiles(): Promise<boolean> {
       {
         type: 'list',
         name: 'action',
-        message: `${prompt}Unregistered SQLite database "${file.fileName}" found in current directory. Register with SpinDB?`,
+        message: `${prompt}Unregistered ${engineLabel} database "${file.fileName}" found in current directory. Register with SpinDB?`,
         choices: [
           { name: 'Yes', value: 'yes' },
           { name: 'No', value: 'no' },
@@ -46,7 +58,11 @@ async function promptUnregisteredFiles(): Promise<boolean> {
     ])
 
     if (action === 'yes') {
-      const suggestedName = deriveContainerName(file.fileName)
+      const registry = getRegistryForEngine(file.engine)
+      const suggestedName = deriveContainerName(
+        file.fileName,
+        file.engine as Engine.SQLite | Engine.DuckDB,
+      )
       const { containerName } = await inquirer.prompt<{
         containerName: string
       }>([
@@ -66,7 +82,7 @@ async function promptUnregisteredFiles(): Promise<boolean> {
       ])
 
       // Check if name already exists
-      if (await sqliteRegistry.exists(containerName)) {
+      if (await registry.exists(containerName)) {
         console.log(
           chalk.yellow(
             `  Container "${containerName}" already exists. Skipping.`,
@@ -75,7 +91,7 @@ async function promptUnregisteredFiles(): Promise<boolean> {
         continue
       }
 
-      await sqliteRegistry.add({
+      await registry.add({
         name: containerName,
         filePath: file.absolutePath,
         created: new Date().toISOString(),
@@ -85,7 +101,9 @@ async function promptUnregisteredFiles(): Promise<boolean> {
       )
       anyRegistered = true
     } else if (action === 'ignore') {
-      await sqliteRegistry.addIgnoreFolder(dirname(file.absolutePath))
+      await getRegistryForEngine(file.engine).addIgnoreFolder(
+        dirname(file.absolutePath),
+      )
       console.log(chalk.gray('  Folder will be ignored in future scans.'))
       break // Exit early
     }
@@ -101,8 +119,8 @@ async function promptUnregisteredFiles(): Promise<boolean> {
 async function getContainerSize(
   container: ContainerConfig,
 ): Promise<number | null> {
-  // SQLite can always get size (it's just file size)
-  if (container.engine === Engine.SQLite) {
+  // File-based engines can always get size (it's just file size)
+  if (isFileBasedEngine(container.engine)) {
     try {
       const engine = getEngine(container.engine)
       return await engine.getDatabaseSize(container)
@@ -127,10 +145,10 @@ export const listCommand = new Command('list')
   .alias('ls')
   .description('List all containers')
   .option('--json', 'Output as JSON')
-  .option('--no-scan', 'Skip scanning for unregistered SQLite files in CWD')
+  .option('--no-scan', 'Skip scanning for unregistered database files in CWD')
   .action(async (options: { json?: boolean; scan?: boolean }) => {
     try {
-      // Scan for unregistered SQLite files in CWD (unless JSON mode or --no-scan)
+      // Scan for unregistered file-based database files in CWD (unless JSON mode or --no-scan)
       if (!options.json && options.scan !== false) {
         await promptUnregisteredFiles()
       }
@@ -173,9 +191,9 @@ export const listCommand = new Command('list')
         const container = containers[i]
         const size = sizes[i]
 
-        // SQLite uses different status labels (blue/white icons)
+        // File-based engines use different status labels (blue/white icons)
         let statusDisplay: string
-        if (container.engine === Engine.SQLite) {
+        if (isFileBasedEngine(container.engine)) {
           statusDisplay =
             container.status === 'running'
               ? chalk.blue('🔵 available')
@@ -193,9 +211,9 @@ export const listCommand = new Command('list')
 
         const sizeDisplay = size !== null ? formatBytes(size) : '—'
 
-        // SQLite shows truncated file name instead of port
+        // File-based engines show truncated file name instead of port
         let portOrPath: string
-        if (container.engine === Engine.SQLite) {
+        if (isFileBasedEngine(container.engine)) {
           const fileName = basename(container.database)
           // Truncate if longer than 8 chars to fit in 8-char column
           portOrPath =
@@ -219,10 +237,10 @@ export const listCommand = new Command('list')
       console.log()
 
       const serverContainers = containers.filter(
-        (c) => c.engine !== Engine.SQLite,
+        (c) => !isFileBasedEngine(c.engine),
       )
-      const sqliteContainers = containers.filter(
-        (c) => c.engine === Engine.SQLite,
+      const fileBasedContainers = containers.filter((c) =>
+        isFileBasedEngine(c.engine),
       )
 
       const running = serverContainers.filter(
@@ -231,10 +249,10 @@ export const listCommand = new Command('list')
       const stopped = serverContainers.filter(
         (c) => c.status !== 'running',
       ).length
-      const available = sqliteContainers.filter(
+      const available = fileBasedContainers.filter(
         (c) => c.status === 'running',
       ).length
-      const missing = sqliteContainers.filter(
+      const missing = fileBasedContainers.filter(
         (c) => c.status !== 'running',
       ).length
 
@@ -242,9 +260,9 @@ export const listCommand = new Command('list')
       if (serverContainers.length > 0) {
         parts.push(`${running} running, ${stopped} stopped`)
       }
-      if (sqliteContainers.length > 0) {
+      if (fileBasedContainers.length > 0) {
         parts.push(
-          `${available} SQLite available${missing > 0 ? `, ${missing} missing` : ''}`,
+          `${available} file-based available${missing > 0 ? `, ${missing} missing` : ''}`,
         )
       }
 

package/cli/commands/menu/shell-handlers.ts

@@ -42,6 +42,7 @@ import {
 import { getEngine } from '../../../engines'
 import { createSpinner } from '../../ui/spinner'
 import { uiError, uiWarning, uiInfo, uiSuccess } from '../../ui/theme'
+import { logDebug } from '../../../core/error-handler'
 import { pressEnterToContinue } from './shared'
 import { paths } from '../../../config/paths'
 import { getEngineConfig } from '../../../config/engines-registry'
@@ -237,8 +238,8 @@ export async function handleOpenShell(
     engineSpecificValue = null
     engineSpecificInstallValue = null
   } else if (config.engine === 'influxdb') {
-    // InfluxDB uses REST API, no interactive shell
-    defaultShellName = 'Web Dashboard'
+    // InfluxDB uses influxdb3 query subcommand (same binary as server)
+    defaultShellName = 'influxdb3 query'
     engineSpecificCli = null
     engineSpecificInstalled = false
     engineSpecificValue = null
@@ -334,7 +335,11 @@ export async function handleOpenShell(
       value: 'api-info',
     })
   } else if (config.engine === 'influxdb') {
-    // InfluxDB: REST API only, no web dashboard or interactive shell
+    // InfluxDB: influxdb3 query CLI + API info
+    choices.push({
+      name: `▸ Use default shell (influxdb3 query)`,
+      value: 'default',
+    })
     choices.push({
       name: `ℹ Show API info`,
       value: 'api-info',
@@ -353,7 +358,7 @@ export async function handleOpenShell(
   } else {
     // Non-REST-API engines: show default shell option
     choices.push({
-      name: `>_ Use default shell (${defaultShellName})`,
+      name: `▸ Use default shell (${defaultShellName})`,
       value: 'default',
     })
   }
@@ -362,7 +367,7 @@ export async function handleOpenShell(
   if (engineSpecificCli !== null) {
     if (engineSpecificInstalled) {
       choices.push({
-        name: `⚡ Use ${engineSpecificCli} (enhanced features, recommended)`,
+        name: `★ Use ${engineSpecificCli} (enhanced features, recommended)`,
         value: engineSpecificValue!,
       })
     } else {
@@ -378,7 +383,7 @@ export async function handleOpenShell(
   if (engineConfig.queryLanguage === 'sql') {
     if (usqlInstalled) {
       choices.push({
-        name: '⚡ Use usql (universal SQL client)',
+        name: '★ Use usql (universal SQL client)',
         value: 'usql',
       })
     } else {
@@ -394,7 +399,7 @@ export async function handleOpenShell(
     const dblabPath = await configManager.getBinaryPath('dblab')
     if (dblabPath) {
       choices.push({
-        name: '⚡ Use dblab (visual TUI)',
+        name: '★ Use dblab (visual TUI)',
         value: 'dblab',
       })
     } else {
@@ -415,6 +420,15 @@ export async function handleOpenShell(
     })
   }
 
+  if (config.engine === 'questdb') {
+    const httpPort = config.port + 188
+    choices.push(new inquirer.Separator(chalk.gray(`───── Web Panel ─────`)))
+    choices.push({
+      name: `◎ Open Web Console (port ${httpPort})`,
+      value: 'browser',
+    })
+  }
+
   if (config.engine === 'duckdb') {
     choices.push(new inquirer.Separator(chalk.gray(`───── Web Panel ─────`)))
     choices.push({
@@ -487,6 +501,16 @@ export async function handleOpenShell(
       console.log()
       openInBrowser(playUrl)
       await pressEnterToContinue()
+    } else if (config.engine === 'questdb') {
+      // QuestDB Web Console on HTTP port (PG port + 188)
+      const httpPort = config.port + 188
+      const consoleUrl = `http://127.0.0.1:${httpPort}`
+      console.log()
+      console.log(uiInfo(`Opening QuestDB Web Console in browser...`))
+      console.log(chalk.gray(`  ${consoleUrl}`))
+      console.log()
+      openInBrowser(consoleUrl)
+      await pressEnterToContinue()
     }
     return
   }
@@ -1482,22 +1506,109 @@ async function launchShell(
     await pressEnterToContinue()
     return
   } else if (config.engine === 'influxdb') {
-    // InfluxDB: REST API only, no web dashboard
-    // This branch shouldn't be reached since we removed the 'default' choice,
-    // but handle gracefully just in case
-    console.log()
-    console.log(chalk.cyan('InfluxDB REST API:'))
-    console.log(chalk.white(`  HTTP: http://127.0.0.1:${config.port}`))
-    console.log()
-    console.log(chalk.gray('Example curl commands:'))
-    console.log(chalk.gray(`  curl http://127.0.0.1:${config.port}/health`))
-    console.log(
-      chalk.gray(
-        `  curl -H "Content-Type: application/json" http://127.0.0.1:${config.port}/api/v3/query_sql -d '{"db":"mydb","q":"SELECT 1"}'`,
-      ),
-    )
-    console.log()
-    await pressEnterToContinue()
+    // InfluxDB: influxdb3 query is one-shot (no REPL), use interactive loop
+    const engine = getEngine(config.engine)
+    const influxdbPath = await engine
+      .getInfluxDBPath(config.version)
+      .catch(() => null)
+    if (!influxdbPath) {
+      console.log(
+        uiWarning('influxdb3 not found. Run: spindb engines download influxdb'),
+      )
+      await pressEnterToContinue()
+      return
+    }
+    // Query available databases from the REST API
+    let db = database || config.name
+    try {
+      const resp = await fetch(
+        `http://127.0.0.1:${config.port}/api/v3/configure/database?format=json`,
+      )
+      if (resp.ok) {
+        const databases = (await resp.json()) as Array<Record<string, string>>
+        const dbNames = databases
+          .map((d) => d['iox::database'] || d.name)
+          .filter((n) => n && n !== '_internal')
+        if (dbNames.length === 0) {
+          console.log(
+            uiWarning(
+              'No databases exist yet. Write data first to create a database.',
+            ),
+          )
+          console.log(
+            chalk.gray(
+              `  curl -X POST "http://127.0.0.1:${config.port}/api/v3/write_lp?db=${db}" -H "Content-Type: text/plain" -d 'measurement,tag=value field=1'`,
+            ),
+          )
+          console.log()
+          await pressEnterToContinue()
+          return
+        }
+        if (!dbNames.includes(db)) {
+          if (dbNames.length === 1) {
+            db = dbNames[0]
+          } else {
+            const { chosenDb } = await escapeablePrompt<{ chosenDb: string }>([
+              {
+                type: 'list',
+                name: 'chosenDb',
+                message: 'Select database:',
+                choices: dbNames,
+              },
+            ])
+            db = chosenDb
+          }
+        }
+      }
+    } catch {
+      // Server may not support this endpoint; proceed with default db
+    }
+    console.log(chalk.cyan(`InfluxDB SQL Console (${db})`))
+    console.log(chalk.gray(`  Type SQL queries, or "exit" to quit.\n`))
+    let running = true
+    while (running) {
+      const { sql } = await escapeablePrompt<{ sql: string }>([
+        {
+          type: 'input',
+          name: 'sql',
+          message: chalk.blue('sql>'),
+        },
+      ])
+      const trimmed = (sql || '').trim()
+      if (
+        trimmed.toLowerCase() === 'exit' ||
+        trimmed.toLowerCase() === 'quit'
+      ) {
+        running = false
+        break
+      }
+      if (!trimmed) {
+        continue
+      }
+      const queryProcess = spawn(
+        influxdbPath,
+        [
+          'query',
+          '--host',
+          `http://127.0.0.1:${config.port}`,
+          '--database',
+          db,
+          '--',
+          trimmed,
+        ],
+        { stdio: 'inherit' },
+      )
+      await new Promise<void>((resolve) => {
+        queryProcess.on('error', (err) => {
+          console.error(uiError(`Query failed: ${err.message}`))
+          resolve()
+        })
+        queryProcess.on('close', () => {
+          logDebug('influxdb query process exited')
+          resolve()
+        })
+      })
+    }
     return
   } else if (config.engine === 'couchdb') {
     // CouchDB: Open Fauxton dashboard in browser (served at /_utils)

package/cli/commands/menu/sql-handlers.ts

@@ -5,6 +5,7 @@ import { spawn } from 'child_process'
 import { containerManager } from '../../../core/container-manager'
 import { getMissingDependencies } from '../../../core/dependency-manager'
 import { getEngine } from '../../../engines'
+import { Engine } from '../../../types'
 import { paths } from '../../../config/paths'
 import { promptInstallDependencies, escapeablePrompt } from '../../ui/prompts'
 import { uiError, uiWarning, uiInfo, uiSuccess } from '../../ui/theme'
@@ -92,7 +93,51 @@ export async function handleRunSql(
   const filePath = stripQuotes(rawFilePath)
 
   // Use provided database or fall back to container's default
-  const databaseName = database || config.database
+  let databaseName = database || config.database
+
+  // InfluxDB: discover real databases (they're created implicitly on write)
+  // Cannot use engine.listDatabases() here because it falls back to
+  // container.database when the list is empty, hiding the "no databases"
+  // state that we need to detect for the .lp warning.
+  if (config.engine === Engine.InfluxDB) {
+    try {
+      const resp = await fetch(
+        `http://127.0.0.1:${config.port}/api/v3/configure/database?format=json`,
+      )
+      if (resp.ok) {
+        const databases = (await resp.json()) as Array<Record<string, string>>
+        const dbNames = databases
+          .map((d) => d['iox::database'] || d.name)
+          .filter((n) => n && n !== '_internal')
+        if (dbNames.length === 0 && !filePath.endsWith('.lp')) {
+          console.log(
+            uiWarning(
+              'No databases exist yet. Seed data with a .lp file first.',
+            ),
+          )
+          await pressEnterToContinue()
+          return
+        }
+        if (!dbNames.includes(databaseName)) {
+          if (dbNames.length === 1) {
+            databaseName = dbNames[0]
+          } else if (dbNames.length > 1) {
+            const { chosenDb } = await escapeablePrompt<{ chosenDb: string }>([
+              {
+                type: 'list',
+                name: 'chosenDb',
+                message: 'Select database:',
+                choices: dbNames,
+              },
+            ])
+            databaseName = chosenDb
+          }
+        }
+      }
+    } catch {
+      // Proceed with default
+    }
+  }
 
   console.log()
   console.log(uiInfo(`Running ${scriptType} file against "${databaseName}"...`))

package/cli/commands/menu/update-handlers.ts

@@ -11,7 +11,7 @@ import { checkEngineDependencies } from '../../../core/dependency-manager'
 import { createSpinner } from '../../ui/spinner'
 import { header, uiSuccess, uiError, uiWarning, uiInfo } from '../../ui/theme'
 import { pressEnterToContinue } from './shared'
-import { Engine } from '../../../types'
+import { type Engine, isFileBasedEngine } from '../../../types'
 
 export async function handleCheckUpdate(): Promise<void> {
   console.clear()
@@ -189,7 +189,7 @@ async function checkContainers(): Promise<HealthCheckResult> {
     }
 
     const details = Object.entries(byEngine).map(([engine, counts]) => {
-      if (engine === Engine.SQLite) {
+      if (isFileBasedEngine(engine as Engine)) {
         return `${engine}: ${counts.running} exist, ${counts.stopped} missing`
       }
       return `${engine}: ${counts.running} running, ${counts.stopped} stopped`

package/cli/commands/sqlite.ts

@@ -7,8 +7,13 @@ import {
   scanForUnregisteredSqliteFiles,
   deriveContainerName,
 } from '../../engines/sqlite/scanner'
+import {
+  isValidExtensionForEngine,
+  formatExtensionsForEngine,
+} from '../../engines/file-based-utils'
 import { containerManager } from '../../core/container-manager'
 import { uiSuccess, uiError, uiInfo } from '../ui/theme'
+import { Engine } from '../../types'
 import { detachCommand } from './detach'
 
 export const sqliteCommand = new Command('sqlite').description(
@@ -146,6 +151,22 @@ sqliteCommand
       try {
         const absolutePath = resolve(path)
 
+        // Validate extension matches SQLite
+        if (!isValidExtensionForEngine(absolutePath, Engine.SQLite)) {
+          const msg = `File extension must be one of: ${formatExtensionsForEngine(Engine.SQLite)}`
+          if (options.json) {
+            console.log(JSON.stringify({ success: false, error: msg }))
+          } else {
+            console.error(uiError(msg))
+            console.log(
+              chalk.gray(
+                '  For DuckDB files, use: spindb duckdb attach <path>',
+              ),
+            )
+          }
+          process.exit(1)
+        }
+
         if (!existsSync(absolutePath)) {
           if (options.json) {
             console.log(

package/cli/index.ts

@@ -27,6 +27,7 @@ import { doctorCommand } from './commands/doctor'
 import { attachCommand } from './commands/attach'
 import { detachCommand } from './commands/detach'
 import { sqliteCommand } from './commands/sqlite'
+import { duckdbCommand } from './commands/duckdb'
 import { databasesCommand } from './commands/databases'
 import { pullCommand } from './commands/pull'
 import { whichCommand } from './commands/which'
@@ -142,6 +143,7 @@ export async function run(): Promise<void> {
   program.addCommand(attachCommand)
   program.addCommand(detachCommand)
   program.addCommand(sqliteCommand)
+  program.addCommand(duckdbCommand)
   program.addCommand(databasesCommand)
   program.addCommand(pullCommand)
   program.addCommand(whichCommand)

package/config/engines.json

@@ -291,8 +291,8 @@
       "defaultVersion": "3.8.0",
       "defaultPort": 8086,
       "runtime": "server",
-      "queryLanguage": "sql",
-      "scriptFileLabel": null,
+      "queryLanguage": "rest",
+      "scriptFileLabel": "Run LP/SQL file",
       "connectionScheme": "http",
       "superuser": null,
       "clientTools": ["influxdb3"],

package/engines/base-engine.ts

@@ -161,6 +161,14 @@ export abstract class BaseEngine {
     throw new Error('typedb_console_bin not found')
   }
 
+  /**
+   * Get the path to the influxdb3 binary if available
+   * Default implementation throws; InfluxDB engine overrides this method.
+   */
+  async getInfluxDBPath(_version?: string): Promise<string> {
+    throw new Error('influxdb3 not found')
+  }
+
   /**
    * Get the path to the sqlite3 client if available
    * Default implementation returns null; SQLite engine overrides this method.