spindb 0.38.1 → 0.40.0

package/dist/cli/commands/menu/shell-handlers.js

@@ -14,6 +14,9 @@ import { configManager } from '../../../core/config-manager.js';
 import { getPgwebStatus, stopPgweb, PGWEB_VERSION, } from '../../../core/pgweb-utils.js';
 import { DBLAB_ENGINES, DBLAB_VERSION, getDblabArgs, getDblabPlatformSuffix, } from '../../../core/dblab-utils.js';
 import { getEngine } from '../../../engines/index.js';
+import { isRemoteContainer } from '../../../types/index.js';
+import { loadCredentials } from '../../../core/credential-manager.js';
+import { redactConnectionString, parseConnectionString, } from '../../../core/remote-container.js';
 import { createSpinner } from '../../ui/spinner.js';
 import { uiError, uiWarning, uiInfo, uiSuccess } from '../../ui/theme.js';
 import { logDebug } from '../../../core/error-handler.js';
@@ -50,17 +53,28 @@ export async function handleCopyConnectionString(containerName, database) {
         return;
     }
     const engine = getEngine(config.engine);
-    // Use provided database or fall back to container's default
-    const connectionString = engine.getConnectionString(config, database);
+    // Remote containers: use stored connection string (full from credentials)
+    let connectionString;
+    let displayString;
+    if (isRemoteContainer(config)) {
+        const creds = await loadCredentials(config.name, config.engine, 'remote');
+        connectionString =
+            creds?.connectionString ?? config.remote?.connectionString ?? '';
+        displayString = redactConnectionString(connectionString);
+    }
+    else {
+        connectionString = engine.getConnectionString(config, database);
+        displayString = connectionString;
+    }
     const copied = await platformService.copyToClipboard(connectionString);
     console.log();
     if (copied) {
         console.log(uiSuccess('Connection string copied to clipboard'));
-        console.log(chalk.gray(`  ${connectionString}`));
+        console.log(chalk.gray(`  ${displayString}`));
     }
     else {
         console.log(uiWarning('Could not copy to clipboard. Connection string:'));
-        console.log(chalk.cyan(`  ${connectionString}`));
+        console.log(chalk.cyan(`  ${displayString}`));
     }
     console.log();
     await escapeablePrompt([
@@ -78,9 +92,19 @@ export async function handleOpenShell(containerName, database) {
         return;
     }
     const engine = getEngine(config.engine);
+    const isRemote = isRemoteContainer(config);
     // Use provided database or fall back to container's default
     const activeDatabase = database || config.database;
-    const connectionString = engine.getConnectionString(config, activeDatabase);
+    // For remote containers, use the stored remote connection string
+    let connectionString;
+    if (isRemote) {
+        const creds = await loadCredentials(config.name, config.engine, 'remote');
+        connectionString =
+            creds?.connectionString ?? config.remote?.connectionString ?? '';
+    }
+    else {
+        connectionString = engine.getConnectionString(config, activeDatabase);
+    }
     const shellCheckSpinner = createSpinner('Checking available shells...');
     shellCheckSpinner.start();
     const [usqlInstalled, pgcliInstalled, mycliInstalled, litecliInstalled, iredisInstalled,] = await Promise.all([
@@ -93,6 +117,16 @@ export async function handleOpenShell(containerName, database) {
     shellCheckSpinner.stop();
     // Clear the spinner line
     process.stdout.write('\x1b[1A\x1b[2K');
+    // REST API engines (no CLI shell) can't be used remotely via console
+    if (isRemote &&
+        ['qdrant', 'meilisearch', 'influxdb', 'weaviate', 'couchdb'].includes(config.engine)) {
+        console.log();
+        console.log(uiInfo('Console is not available for linked remote REST API databases.'));
+        console.log(chalk.gray("  Use your provider's web dashboard or API tools directly."));
+        console.log();
+        await pressEnterToContinue();
+        return;
+    }
     // Engine-specific shell names
     let defaultShellName;
     let engineSpecificCli;
@@ -364,7 +398,8 @@ export async function handleOpenShell(containerName, database) {
         }
     }
     // dblab visual TUI (supports PostgreSQL, MySQL, MariaDB, CockroachDB, SQLite, QuestDB)
-    if (DBLAB_ENGINES.has(config.engine)) {
+    // Not available for remote containers (hardcodes local connection)
+    if (DBLAB_ENGINES.has(config.engine) && !isRemote) {
         const dblabPath = await configManager.getBinaryPath('dblab');
         if (dblabPath) {
             choices.push({
@@ -379,8 +414,8 @@ export async function handleOpenShell(containerName, database) {
             });
         }
     }
-    // Web Panel section for engines with browser-based UIs
-    if (config.engine === 'clickhouse') {
+    // Web Panel section for engines with browser-based UIs (local only)
+    if (config.engine === 'clickhouse' && !isRemote) {
         const httpPort = config.port + 1;
         choices.push(new inquirer.Separator(chalk.gray(`───── Web Panel ─────`)));
         choices.push({
@@ -388,7 +423,7 @@ export async function handleOpenShell(containerName, database) {
             value: 'browser',
         });
     }
-    if (config.engine === 'questdb') {
+    if (config.engine === 'questdb' && !isRemote) {
         const httpPort = config.port + 188;
         choices.push(new inquirer.Separator(chalk.gray(`───── Web Panel ─────`)));
         choices.push({
@@ -396,16 +431,17 @@ export async function handleOpenShell(containerName, database) {
             value: 'browser',
         });
     }
-    if (config.engine === 'duckdb') {
+    if (config.engine === 'duckdb' && !isRemote) {
         choices.push(new inquirer.Separator(chalk.gray(`───── Web Panel ─────`)));
         choices.push({
             name: `◎ Open Web UI (built-in, port 4213)`,
             value: 'duckdb-ui',
         });
     }
-    if (config.engine === 'postgresql' ||
-        config.engine === 'cockroachdb' ||
-        config.engine === 'ferretdb') {
+    if (!isRemote &&
+        (config.engine === 'postgresql' ||
+            config.engine === 'cockroachdb' ||
+            config.engine === 'ferretdb')) {
         choices.push(new inquirer.Separator(chalk.gray(`───── Web Panel ─────`)));
         const pgwebPath = await configManager.getBinaryPath('pgweb');
         if (pgwebPath) {
@@ -1179,6 +1215,24 @@ async function launchPgweb(containerName, config, database) {
 async function launchShell(containerName, config, connectionString, shellType, database) {
     console.log(uiInfo(`Connecting to ${containerName}...`));
     console.log();
+    const isRemote = isRemoteContainer(config);
+    // Parse remote connection string for host/port/user/password
+    let rHost = '127.0.0.1';
+    let rPort = config.port;
+    let rUser = '';
+    let rPass = '';
+    if (isRemote) {
+        try {
+            const parsed = parseConnectionString(connectionString);
+            rHost = parsed.host || config.remote?.host || '127.0.0.1';
+            rPort = parsed.port || config.port;
+            rUser = parsed.username || '';
+            rPass = parsed.password || '';
+        }
+        catch {
+            /* use defaults */
+        }
+    }
     let shellCmd;
     let shellArgs;
     let installHint;
@@ -1190,17 +1244,22 @@ async function launchShell(containerName, config, connectionString, shellType, d
         installHint = 'brew install pgcli';
     }
     else if (shellType === 'mycli') {
-        // mycli: mycli -h host -P port -u user database
+        // mycli accepts connection strings directly
         shellCmd = 'mycli';
-        shellArgs = [
-            '-h',
-            '127.0.0.1',
-            '-P',
-            String(config.port),
-            '-u',
-            'root',
-            database,
-        ];
+        if (isRemote) {
+            shellArgs = [connectionString];
+        }
+        else {
+            shellArgs = [
+                '-h',
+                '127.0.0.1',
+                '-P',
+                String(config.port),
+                '-u',
+                'root',
+                database,
+            ];
+        }
         installHint = 'brew install mycli';
     }
     else if (shellType === 'litecli') {
@@ -1232,30 +1291,46 @@ async function launchShell(containerName, config, connectionString, shellType, d
         // MySQL uses downloaded binaries - get the actual path
         const mysqlPath = await configManager.getBinaryPath('mysql');
         shellCmd = mysqlPath || 'mysql';
-        shellArgs = [
-            '-u',
-            'root',
-            '-h',
-            '127.0.0.1',
-            '-P',
-            String(config.port),
-            database,
-        ];
+        if (isRemote) {
+            shellArgs = ['-h', rHost, '-P', String(rPort), '-u', rUser || 'root'];
+            if (rPass)
+                shellArgs.push(`-p${rPass}`);
+            shellArgs.push(database);
+        }
+        else {
+            shellArgs = [
+                '-u',
+                'root',
+                '-h',
+                '127.0.0.1',
+                '-P',
+                String(config.port),
+                database,
+            ];
+        }
         installHint = 'spindb engines download mysql';
     }
     else if (config.engine === 'mariadb') {
         // MariaDB uses downloaded binaries, not system PATH - get the actual path
         const mariadbPath = await configManager.getBinaryPath('mariadb');
         shellCmd = mariadbPath || 'mariadb';
-        shellArgs = [
-            '-u',
-            'root',
-            '-h',
-            '127.0.0.1',
-            '-P',
-            String(config.port),
-            database,
-        ];
+        if (isRemote) {
+            shellArgs = ['-h', rHost, '-P', String(rPort), '-u', rUser || 'root'];
+            if (rPass)
+                shellArgs.push(`-p${rPass}`);
+            shellArgs.push(database);
+        }
+        else {
+            shellArgs = [
+                '-u',
+                'root',
+                '-h',
+                '127.0.0.1',
+                '-P',
+                String(config.port),
+                database,
+            ];
+        }
         installHint = 'spindb engines download mariadb';
     }
     else if (config.engine === 'mongodb' || config.engine === 'ferretdb') {
@@ -1266,20 +1341,47 @@ async function launchShell(containerName, config, connectionString, shellType, d
     else if (shellType === 'iredis') {
         // iredis: enhanced Redis CLI
         shellCmd = 'iredis';
-        shellArgs = ['-h', '127.0.0.1', '-p', String(config.port), '-n', database];
+        if (isRemote) {
+            shellArgs = ['-h', rHost, '-p', String(rPort)];
+            if (rPass)
+                shellArgs.push('-a', rPass);
+            if (database)
+                shellArgs.push('-n', database);
+        }
+        else {
+            shellArgs = ['-h', '127.0.0.1', '-p', String(config.port), '-n', database];
+        }
         installHint = 'brew install iredis';
     }
     else if (config.engine === 'redis') {
         // Default Redis shell
         shellCmd = 'redis-cli';
-        shellArgs = ['-h', '127.0.0.1', '-p', String(config.port), '-n', database];
+        if (isRemote) {
+            shellArgs = ['-h', rHost, '-p', String(rPort)];
+            if (rPass)
+                shellArgs.push('-a', rPass);
+            if (database)
+                shellArgs.push('-n', database);
+        }
+        else {
+            shellArgs = ['-h', '127.0.0.1', '-p', String(config.port), '-n', database];
+        }
         installHint = 'brew install redis';
     }
     else if (config.engine === 'valkey') {
         // Default Valkey shell
         const valkeyCliPath = await configManager.getBinaryPath('valkey-cli');
         shellCmd = valkeyCliPath || 'valkey-cli';
-        shellArgs = ['-h', '127.0.0.1', '-p', String(config.port), '-n', database];
+        if (isRemote) {
+            shellArgs = ['-h', rHost, '-p', String(rPort)];
+            if (rPass)
+                shellArgs.push('-a', rPass);
+            if (database)
+                shellArgs.push('-n', database);
+        }
+        else {
+            shellArgs = ['-h', '127.0.0.1', '-p', String(config.port), '-n', database];
+        }
         installHint = 'spindb engines download valkey';
     }
     else if (config.engine === 'clickhouse') {
@@ -1289,12 +1391,16 @@ async function launchShell(containerName, config, connectionString, shellType, d
         shellArgs = [
             'client',
             '--host',
-            '127.0.0.1',
+            isRemote ? rHost : '127.0.0.1',
             '--port',
-            String(config.port),
+            String(isRemote ? rPort : config.port),
             '--database',
             database,
         ];
+        if (isRemote && rUser)
+            shellArgs.push('--user', rUser);
+        if (isRemote && rPass)
+            shellArgs.push('--password', rPass);
         installHint = 'spindb engines download clickhouse';
     }
     else if (config.engine === 'qdrant') {
@@ -1447,19 +1553,36 @@ async function launchShell(containerName, config, connectionString, shellType, d
             .catch(() => 'surreal');
         const namespace = config.name.replace(/-/g, '_');
         shellCmd = surrealPath;
-        shellArgs = [
-            'sql',
-            '--endpoint',
-            `ws://127.0.0.1:${config.port}`,
-            '--namespace',
-            namespace,
-            '--database',
-            database || 'default',
-            '--username',
-            'root',
-            '--password',
-            'root',
-        ];
+        if (isRemote) {
+            shellArgs = [
+                'sql',
+                '--endpoint',
+                `ws://${rHost}:${rPort}`,
+                '--namespace',
+                namespace,
+                '--database',
+                database || 'default',
+            ];
+            if (rUser)
+                shellArgs.push('--username', rUser);
+            if (rPass)
+                shellArgs.push('--password', rPass);
+        }
+        else {
+            shellArgs = [
+                'sql',
+                '--endpoint',
+                `ws://127.0.0.1:${config.port}`,
+                '--namespace',
+                namespace,
+                '--database',
+                database || 'default',
+                '--username',
+                'root',
+                '--password',
+                'root',
+            ];
+        }
         installHint = 'spindb engines download surrealdb';
         // SurrealDB writes history.txt to cwd - use container directory
         spawnCwd = join(paths.containers, 'surrealdb', config.name);
@@ -1471,24 +1594,34 @@ async function launchShell(containerName, config, connectionString, shellType, d
             .getCockroachPath(config.version)
             .catch(() => 'cockroach');
         shellCmd = cockroachPath;
-        shellArgs = [
-            'sql',
-            '--insecure',
-            '--host',
-            `127.0.0.1:${config.port}`,
-            '--database',
-            database,
-        ];
+        if (isRemote) {
+            // Use --url for remote connections (supports full connection strings)
+            shellArgs = ['sql', '--url', connectionString];
+        }
+        else {
+            shellArgs = [
+                'sql',
+                '--insecure',
+                '--host',
+                `127.0.0.1:${config.port}`,
+                '--database',
+                database,
+            ];
+        }
         installHint = 'spindb engines download cockroachdb';
     }
     else if (config.engine === 'questdb') {
         // QuestDB uses PostgreSQL wire protocol on port 8812
-        // Default credentials: admin/quest
         shellCmd = 'psql';
-        const db = database || 'qdb';
-        // QuestDB connection string with explicit password
-        const questDbConnStr = `postgresql://admin:quest@127.0.0.1:${config.port}/${db}`;
-        shellArgs = [questDbConnStr];
+        if (isRemote) {
+            shellArgs = [connectionString];
+        }
+        else {
+            // Default credentials: admin/quest
+            const db = database || 'qdb';
+            const questDbConnStr = `postgresql://admin:quest@127.0.0.1:${config.port}/${db}`;
+            shellArgs = [questDbConnStr];
+        }
         installHint = 'brew install libpq && brew link --force libpq';
     }
     else if (config.engine === 'typedb') {
@@ -1510,8 +1643,6 @@ async function launchShell(containerName, config, connectionString, shellType, d
     }
     else if (config.engine === 'tigerbeetle') {
         // TigerBeetle uses tigerbeetle repl command
-        // Cluster ID 0 is the default for local single-node development.
-        // TigerBeetle format/start also use cluster 0 (see engines/tigerbeetle/index.ts).
         const clusterId = 0;
         const engine = getEngine(config.engine);
         const tigerbeetlePath = await engine
@@ -1521,7 +1652,7 @@ async function launchShell(containerName, config, connectionString, shellType, d
         shellArgs = [
             'repl',
             `--cluster=${clusterId}`,
-            `--addresses=127.0.0.1:${config.port}`,
+            `--addresses=${isRemote ? rHost : '127.0.0.1'}:${isRemote ? rPort : config.port}`,
         ];
         installHint = 'spindb engines download tigerbeetle';
     }