@startanaicompany/cli 1.8.0 → 1.9.2

package/.claude/settings.local.json

@@ -14,7 +14,13 @@
       "Bash(echo:*)",
       "Bash(timeout 15 /home/goryanio2025-ai/saac-cli/bin/saac.js logs:*)",
       "Bash(timeout 30 /home/goryanio2025-ai/saac-cli/bin/saac.js deploy:*)",
-      "Bash(timeout 60 /home/goryanio2025-ai/saac-cli/bin/saac.js deploy:*)"
+      "Bash(timeout 60 /home/goryanio2025-ai/saac-cli/bin/saac.js deploy:*)",
+      "Bash(/home/goryanio2025-ai/saac-cli/bin/saac.js db info:*)",
+      "Bash(/home/goryanio2025-ai/saac-cli/bin/saac.js db list:*)",
+      "Bash(/home/goryanio2025-ai/saac-cli/bin/saac.js db sql:*)",
+      "Bash(/home/goryanio2025-ai/saac-cli/bin/saac.js db redis PING:*)",
+      "Bash(/home/goryanio2025-ai/saac-cli/bin/saac.js db redis SET:*)",
+      "Bash(/home/goryanio2025-ai/saac-cli/bin/saac.js db redis GET:*)"
     ],
     "deny": [],
     "ask": []

package/README.md

@@ -15,6 +15,7 @@
 - 🔄 **Auto-healing** - Automatically fixes common deployment issues
 - 🖥️ **Remote Shell** - Access your container via WebSocket (Project Aurora)
 - 🔧 **Remote Execution** - Run commands inside your container
+- 🗄️ **Database Management** - Direct access to PostgreSQL and Redis
 - 📊 **Real-time Logs** - View runtime and deployment logs
 
 ## Installation
@@ -47,7 +48,11 @@ saac deploy
 # 7. View logs
 saac logs
 
-# 8. Access your container shell
+# 8. Query your database
+saac db sql "SELECT NOW()"
+saac db redis PING
+
+# 9. Access your container shell
 saac shell
 ```
 
@@ -66,6 +71,11 @@ saac shell
   - [Remote Shell (saac shell)](#remote-shell)
   - [Remote Execution (saac exec)](#remote-execution)
   - [Local Development (saac run)](#local-development)
+- [Database Management](#database-management)
+  - [List Containers (saac db list)](#list-containers)
+  - [SQL Queries (saac db sql)](#sql-queries)
+  - [Redis Commands (saac db redis)](#redis-commands)
+  - [Connection Info (saac db info)](#connection-info)
 - [Logs & Monitoring](#logs--monitoring)
 - [Domain Management](#domain-management)
 - [Complete Workflows](#complete-workflows)
@@ -1599,6 +1609,231 @@ postgresql://user:pass@db.internal:5432/myapp
 
 ---
 
+## Database Management
+
+Manage and query your application's databases directly from the CLI.
+
+### List Containers
+
+#### `saac db list`
+
+List all database containers for your application.
+
+```bash
+saac db list
+saac db ls  # Alias
+```
+
+**Shows:**
+- Container name
+- Type (postgres, redis, app)
+- Status (running, healthy, stopped)
+- Docker image
+
+**Example output:**
+```
+Database Containers for my-app
+───────────────────────────────
+
+┌─────────────────────────────┬──────────┬────────────┬──────────────────┐
+│ Container Name              │ Type     │ Status     │ Image            │
+├─────────────────────────────┼──────────┼────────────┼──────────────────┤
+│ postgres-abc123-456def      │ postgres │ healthy    │ postgres:15      │
+│ redis-abc123-456def         │ redis    │ healthy    │ redis:7          │
+│ app-abc123-456def           │ app      │ running    │ node:18          │
+└─────────────────────────────┴──────────┴────────────┴──────────────────┘
+```
+
+### SQL Queries
+
+#### `saac db sql <query>`
+
+Execute SQL queries on your PostgreSQL database.
+
+```bash
+# Simple SELECT query
+saac db sql "SELECT NOW()"
+
+# Query your data
+saac db sql "SELECT * FROM users LIMIT 10"
+
+# Count records
+saac db sql "SELECT COUNT(*) FROM posts"
+
+# Specify database name (optional)
+saac db sql "SELECT version()" --db my_database
+
+# Write operations (CREATE, INSERT, UPDATE, DELETE)
+saac db sql "INSERT INTO users (name, email) VALUES ('John', 'john@example.com')" --write
+saac db sql "UPDATE users SET active = true WHERE id = 123" --write
+saac db sql "DELETE FROM sessions WHERE expires_at < NOW()" --write
+```
+
+**Options:**
+- `--db <name>` - Database name (default: from environment variables)
+- `--write` - Allow write operations (INSERT, UPDATE, DELETE, CREATE, DROP)
+
+**Security:**
+- Read-only by default (SELECT, SHOW, DESCRIBE, EXPLAIN)
+- Write operations require `--write` flag
+- Dangerous operations (DROP, TRUNCATE) require `--write` flag
+- Rate limit: 60 queries per 5 minutes
+
+**Example output:**
+```bash
+$ saac db sql "SELECT * FROM users LIMIT 3"
+
+Executing SQL Query on my-app
+──────────────────────────────
+
+┌────┬─────────────┬──────────────────┬────────────────────┐
+│ id │ name        │ email            │ created_at         │
+├────┼─────────────┼──────────────────┼────────────────────┤
+│ 1  │ Alice       │ alice@example.com│ 2026-02-15 10:00:00│
+│ 2  │ Bob         │ bob@example.com  │ 2026-02-15 11:30:00│
+│ 3  │ Charlie     │ charlie@test.com │ 2026-02-16 09:15:00│
+└────┴─────────────┴──────────────────┴────────────────────┘
+
+Rows returned: 3
+```
+
+### Redis Commands
+
+#### `saac db redis <command>`
+
+Execute Redis commands.
+
+```bash
+# Test connection
+saac db redis PING
+
+# Get a key
+saac db redis GET mykey
+
+# Set a key
+saac db redis SET mykey "hello world"
+
+# Hash operations
+saac db redis HSET user:123 name "John"
+saac db redis HGETALL user:123
+
+# List operations
+saac db redis LPUSH mylist "item1"
+saac db redis LRANGE mylist 0 -1
+
+# Check key existence
+saac db redis EXISTS mykey
+
+# Get key type
+saac db redis TYPE mykey
+```
+
+**Supported Commands:**
+- String: GET, SET, APPEND, INCR, DECR
+- Hash: HGET, HSET, HGETALL, HDEL
+- List: LPUSH, RPUSH, LRANGE, LLEN
+- Set: SADD, SMEMBERS, SISMEMBER
+- Sorted Set: ZADD, ZRANGE, ZSCORE
+- Key: EXISTS, DEL, TYPE, EXPIRE, TTL
+- Info: PING, INFO, DBSIZE
+
+**Blocked Commands** (for safety):
+- FLUSHDB, FLUSHALL (data loss)
+- CONFIG (security)
+- SHUTDOWN (availability)
+
+**Example output:**
+```bash
+$ saac db redis GET user:session:abc123
+
+Executing Redis Command on my-app
+──────────────────────────────────
+
+Command: GET user:session:abc123
+
+✓ Result:
+{"userId":"123","expires":"2026-02-20T10:00:00Z"}
+```
+
+### Connection Info
+
+#### `saac db info`
+
+Show database connection information.
+
+```bash
+saac db info
+```
+
+**Shows:**
+- PostgreSQL host, port, database name
+- Redis host, port
+- Internal network addresses
+
+**Example output:**
+```
+Database Connection Info for my-app
+────────────────────────────────────
+
+✓ PostgreSQL:
+    Host: postgres.internal
+    Port: 5432
+    Database: myapp_db
+
+✓ Redis:
+    Host: redis.internal
+    Port: 6379
+
+ℹ Note: These are internal network addresses
+      (only accessible within the application network)
+```
+
+### Database Management Workflows
+
+**Create table and insert data:**
+```bash
+# 1. Create table
+saac db sql "CREATE TABLE users (id SERIAL PRIMARY KEY, name VARCHAR(100), email VARCHAR(100))" --write
+
+# 2. Insert data
+saac db sql "INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com')" --write
+
+# 3. Query data
+saac db sql "SELECT * FROM users"
+```
+
+**Redis caching workflow:**
+```bash
+# 1. Set cache value
+saac db redis SET cache:users:123 "{\"name\":\"Alice\",\"email\":\"alice@example.com\"}"
+
+# 2. Get cache value
+saac db redis GET cache:users:123
+
+# 3. Set expiration
+saac db redis EXPIRE cache:users:123 3600
+
+# 4. Check TTL
+saac db redis TTL cache:users:123
+```
+
+**Check database health:**
+```bash
+# List all containers
+saac db list
+
+# Check PostgreSQL version
+saac db sql "SELECT version()"
+
+# Test Redis connection
+saac db redis PING
+
+# View connection details
+saac db info
+```
+
+---
+
 ## Logs & Monitoring
 
 View runtime logs and deployment logs for your application.
@@ -2496,7 +2731,33 @@ MIT © StartAnAiCompany
 
 ## Changelog
 
-### Version 1.4.20 (Latest)
+### Version 1.9.1 (Latest)
+- Fixed `saac exec` to use SSE command channel for faster, more reliable execution
+- Migrated from direct docker exec to daemon-based execution
+- Consistent with database commands (sql, redis, containers)
+- No more 30-second timeouts - average response time ~500ms
+
+### Version 1.9.0
+- **New: Database Management Commands**
+- Added `saac db list` - List all database containers (postgres, redis, app)
+- Added `saac db sql <query>` - Execute SQL queries with formatted table output
+- Added `saac db redis <command>` - Execute Redis commands (GET, SET, PING, etc.)
+- Added `saac db info` - Show database connection information
+- Read-only by default with `--write` flag for modifications
+- Rate limiting: 60 queries per 5 minutes
+- Uses SSE command channel with ~1s response time
+
+### Version 1.8.0
+- Made deploy streaming the default behavior
+- Changed `--stream` flag to `--no-stream` for fire-and-forget mode
+- Improved visibility for AI agents and users during deployments
+
+### Version 1.7.0
+- Added real-time deploy streaming with `--stream` flag
+- Added `--no-cache` flag for clean rebuilds
+- Improved deployment visibility
+
+### Version 1.4.20
 - Fixed logs command - handle logs as string instead of array
 - Backend returns `result.logs` as string, not array
 

package/bin/saac.js

@@ -34,6 +34,7 @@ const manual = require('../src/commands/manual');
 const run = require('../src/commands/run');
 const shell = require('../src/commands/shell');
 const execCmd = require('../src/commands/exec');
+const db = require('../src/commands/db');
 
 // Configure CLI
 program
@@ -266,6 +267,34 @@ program
     }
   });
 
+// Database commands
+const dbCommand = program
+  .command('db')
+  .description('Manage application databases');
+
+dbCommand
+  .command('list')
+  .alias('ls')
+  .description('List database containers (postgres, redis, etc.)')
+  .action(db.list);
+
+dbCommand
+  .command('sql <query>')
+  .description('Execute SQL query (read-only by default)')
+  .option('--db <name>', 'Database name (default: from env vars)')
+  .option('--write', 'Allow write operations (INSERT, UPDATE, DELETE)')
+  .action(db.sql);
+
+dbCommand
+  .command('redis <command...>')
+  .description('Execute Redis command (e.g., GET mykey, HGETALL user:123)')
+  .action(db.redis);
+
+dbCommand
+  .command('info')
+  .description('Show database connection information')
+  .action(db.info);
+
 // Environment variable commands
 const envCommand = program
   .command('env')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startanaicompany/cli",
-  "version": "1.8.0",
+  "version": "1.9.2",
   "description": "Official CLI for StartAnAiCompany.com - Deploy AI recruitment sites with ease",
   "main": "src/index.js",
   "bin": {

package/src/commands/db.js

@@ -0,0 +1,322 @@
+/**
+ * Database management commands
+ */
+
+const api = require('../lib/api');
+const { getProjectConfig, ensureAuthenticated } = require('../lib/config');
+const logger = require('../lib/logger');
+const { table } = require('table');
+
+/**
+ * Poll for command result with timeout
+ */
+async function pollForResult(applicationUuid, commandId, commandType, maxWaitSeconds = 120) {
+  const startTime = Date.now();
+  const pollInterval = 1000; // 1 second
+
+  while (true) {
+    const elapsed = (Date.now() - startTime) / 1000;
+
+    if (elapsed > maxWaitSeconds) {
+      throw new Error(`Command timed out after ${maxWaitSeconds} seconds`);
+    }
+
+    try {
+      const result = await api.getDbCommandResult(applicationUuid, commandType, commandId);
+
+      if (result.status === 'completed') {
+        return result;
+      }
+
+      if (result.status === 'failed') {
+        const errorMsg = result.result?.error || result.error || 'Command failed';
+        throw new Error(errorMsg);
+      }
+
+      // Still pending, wait and retry
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+    } catch (error) {
+      // If error is not a 404 (command not found yet), rethrow
+      if (error.response?.status !== 404) {
+        throw error;
+      }
+      // 404 means command not processed yet, keep polling
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+    }
+  }
+}
+
+/**
+ * List database containers
+ */
+async function list(options) {
+  try {
+    if (!(await ensureAuthenticated())) {
+      logger.error('Not logged in');
+      logger.info('Run: saac login -e <email> -k <api-key>');
+      process.exit(1);
+    }
+
+    const projectConfig = getProjectConfig();
+    if (!projectConfig || !projectConfig.applicationUuid) {
+      logger.error('No application found in current directory');
+      logger.info('Run: saac init or saac create');
+      process.exit(1);
+    }
+
+    const { applicationUuid, applicationName } = projectConfig;
+
+    logger.section(`Database Containers for ${applicationName}`);
+    logger.newline();
+
+    const spin = logger.spinner('Fetching database containers...').start();
+
+    try {
+      const response = await api.listDbContainers(applicationUuid);
+      const commandId = response.command_id;
+
+      spin.text = 'Waiting for daemon to respond...';
+      const result = await pollForResult(applicationUuid, commandId, 'containers');
+
+      spin.succeed('Database containers retrieved');
+      logger.newline();
+
+      if (result.result && result.result.containers) {
+        const containers = result.result.containers;
+
+        if (containers.length === 0) {
+          logger.info('No database containers found');
+          return;
+        }
+
+        // Display as table
+        const tableData = [
+          ['Container Name', 'Type', 'Status', 'Image']
+        ];
+
+        containers.forEach(container => {
+          tableData.push([
+            container.name || 'N/A',
+            container.type || 'N/A',
+            container.status || 'N/A',
+            container.image || 'N/A'
+          ]);
+        });
+
+        console.log(table(tableData, {
+          header: {
+            alignment: 'center',
+            content: 'Database Containers'
+          }
+        }));
+      } else {
+        logger.warn('No container data in response');
+      }
+    } catch (error) {
+      spin.fail('Failed to fetch database containers');
+      throw error;
+    }
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Execute SQL query
+ */
+async function sql(query, options) {
+  try {
+    if (!(await ensureAuthenticated())) {
+      logger.error('Not logged in');
+      logger.info('Run: saac login -e <email> -k <api-key>');
+      process.exit(1);
+    }
+
+    const projectConfig = getProjectConfig();
+    if (!projectConfig || !projectConfig.applicationUuid) {
+      logger.error('No application found in current directory');
+      logger.info('Run: saac init or saac create');
+      process.exit(1);
+    }
+
+    const { applicationUuid, applicationName } = projectConfig;
+
+    logger.section(`Executing SQL Query on ${applicationName}`);
+    logger.newline();
+
+    const spin = logger.spinner('Executing query...').start();
+
+    try {
+      const requestBody = {
+        query: query,
+        allow_writes: options.write || false
+      };
+
+      if (options.db) {
+        requestBody.db_name = options.db;
+      }
+
+      const response = await api.executeSql(applicationUuid, requestBody);
+      const commandId = response.command_id;
+
+      spin.text = 'Waiting for daemon to execute query...';
+      const result = await pollForResult(applicationUuid, commandId, 'sql');
+
+      spin.succeed('Query executed');
+      logger.newline();
+
+      if (result.result && result.result.output) {
+        // Display CSV output as table
+        const csvData = result.result.output;
+        const rows = csvData.trim().split('\n').map(row => row.split(','));
+
+        if (rows.length > 0) {
+          console.log(table(rows));
+          logger.newline();
+          logger.info(`Rows returned: ${rows.length - 1}`); // -1 for header
+        } else {
+          logger.info('Query returned no results');
+        }
+      } else if (result.result && result.result.error) {
+        logger.error('Query error:');
+        logger.log(result.result.error);
+      } else {
+        logger.info('Query completed (no output)');
+      }
+    } catch (error) {
+      spin.fail('Query execution failed');
+      throw error;
+    }
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Execute Redis command
+ */
+async function redis(commandArgs, options) {
+  try {
+    if (!(await ensureAuthenticated())) {
+      logger.error('Not logged in');
+      logger.info('Run: saac login -e <email> -k <api-key>');
+      process.exit(1);
+    }
+
+    const projectConfig = getProjectConfig();
+    if (!projectConfig || !projectConfig.applicationUuid) {
+      logger.error('No application found in current directory');
+      logger.info('Run: saac init or saac create');
+      process.exit(1);
+    }
+
+    const { applicationUuid, applicationName } = projectConfig;
+
+    // Join command args into a single string
+    const command = commandArgs.join(' ');
+
+    logger.section(`Executing Redis Command on ${applicationName}`);
+    logger.newline();
+    logger.info(`Command: ${command}`);
+    logger.newline();
+
+    const spin = logger.spinner('Executing command...').start();
+
+    try {
+      const response = await api.executeRedis(applicationUuid, { command });
+      const commandId = response.command_id;
+
+      spin.text = 'Waiting for daemon to execute command...';
+      const result = await pollForResult(applicationUuid, commandId, 'redis');
+
+      spin.succeed('Command executed');
+      logger.newline();
+
+      if (result.result && result.result.output) {
+        logger.success('Result:');
+        logger.log(result.result.output);
+      } else if (result.result && result.result.error) {
+        logger.error('Command error:');
+        logger.log(result.result.error);
+      } else {
+        logger.info('Command completed (no output)');
+      }
+    } catch (error) {
+      spin.fail('Command execution failed');
+      throw error;
+    }
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Show database connection info
+ */
+async function info(options) {
+  try {
+    if (!(await ensureAuthenticated())) {
+      logger.error('Not logged in');
+      logger.info('Run: saac login -e <email> -k <api-key>');
+      process.exit(1);
+    }
+
+    const projectConfig = getProjectConfig();
+    if (!projectConfig || !projectConfig.applicationUuid) {
+      logger.error('No application found in current directory');
+      logger.info('Run: saac init or saac create');
+      process.exit(1);
+    }
+
+    const { applicationUuid, applicationName } = projectConfig;
+
+    logger.section(`Database Connection Info for ${applicationName}`);
+    logger.newline();
+
+    const spin = logger.spinner('Fetching connection info...').start();
+
+    try {
+      const result = await api.getDbInfo(applicationUuid);
+
+      spin.succeed('Connection info retrieved');
+      logger.newline();
+
+      if (result.postgres) {
+        logger.success('PostgreSQL:');
+        logger.field('  Host', result.postgres.host || 'postgres.internal');
+        logger.field('  Port', result.postgres.port || '5432');
+        logger.field('  Database', result.postgres.database || 'N/A');
+        logger.newline();
+      }
+
+      if (result.redis) {
+        logger.success('Redis:');
+        logger.field('  Host', result.redis.host || 'redis.internal');
+        logger.field('  Port', result.redis.port || '6379');
+        logger.newline();
+      }
+
+      if (!result.postgres && !result.redis) {
+        logger.warn('No database connection info available');
+      }
+
+      logger.info('Note: These are internal network addresses (only accessible within the application network)');
+    } catch (error) {
+      spin.fail('Failed to fetch connection info');
+      throw error;
+    }
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  list,
+  sql,
+  redis,
+  info
+};

package/src/commands/exec.js

@@ -7,6 +7,45 @@ const { getProjectConfig, ensureAuthenticated } = require('../lib/config');
 const logger = require('../lib/logger');
 const { table } = require('table');
 
+/**
+ * Poll for command result with timeout
+ */
+async function pollForResult(applicationUuid, commandId, maxWaitSeconds = 120) {
+  const startTime = Date.now();
+  const pollInterval = 1000; // 1 second
+
+  while (true) {
+    const elapsed = (Date.now() - startTime) / 1000;
+
+    if (elapsed > maxWaitSeconds) {
+      throw new Error(`Command timed out after ${maxWaitSeconds} seconds`);
+    }
+
+    try {
+      const result = await api.getDbCommandResult(applicationUuid, 'exec', commandId);
+
+      if (result.status === 'completed') {
+        return result;
+      }
+
+      if (result.status === 'failed') {
+        const errorMsg = result.result?.error || result.error || 'Command failed';
+        throw new Error(errorMsg);
+      }
+
+      // Still pending, wait and retry
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+    } catch (error) {
+      // If error is not a 404 (command not found yet), rethrow
+      if (error.response?.status !== 404) {
+        throw error;
+      }
+      // 404 means command not processed yet, keep polling
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+    }
+  }
+}
+
 /**
  * Execute a command in the remote container
  * @param {string} command - Command to execute
@@ -39,7 +78,7 @@ async function exec(command, options = {}) {
     const execRequest = {
       command,
       workdir: options.workdir || '/app',
-      timeout: options.timeout || 30
+      timeout: parseInt(options.timeout) || 30
     };
 
     // Validate timeout
@@ -56,34 +95,52 @@ async function exec(command, options = {}) {
     logger.field('  Timeout', `${execRequest.timeout}s`);
     logger.newline();
 
-    const spin = logger.spinner('Executing command in container...').start();
+    const spin = logger.spinner('Queueing command...').start();
 
+    let response;
     let result;
     try {
-      result = await api.executeCommand(applicationUuid, execRequest);
+      // Queue the command
+      response = await api.executeCommand(applicationUuid, execRequest);
+      const commandId = response.command_id;
+
+      spin.text = 'Waiting for daemon to execute command...';
+
+      // Poll for result with timeout buffer
+      result = await pollForResult(applicationUuid, commandId, execRequest.timeout + 30);
+
       spin.succeed('Command executed');
     } catch (error) {
-      spin.fail('Command execution failed');
+      spin.fail('Command not allowed');
 
       if (error.response?.status === 400) {
-        const data = error.response.data;
+        const data = error.response.data || {};
         logger.newline();
 
-        if (data.error === 'VALIDATION_ERROR') {
-          logger.error('Command validation failed');
+        // Show clear "command not allowed" message for all 400 errors
+        logger.error('This command is blocked for security reasons');
+
+        // Show backend error message if available (note: field is 'error', not 'message')
+        if (data.error) {
           logger.newline();
-          logger.warn(data.message);
-
-          if (data.message.includes('not in allowlist')) {
-            logger.newline();
-            logger.info('Allowed commands include:');
-            logger.log('  Node.js: npm, node, npx, yarn, pnpm');
-            logger.log('  Python: python, python3, pip, poetry');
-            logger.log('  Ruby: bundle, rake, rails');
-            logger.log('  Shell: sh, bash, echo, cat, ls, pwd');
-            logger.log('  Database: psql, mysql, mongosh');
-          }
+          logger.warn(data.error);
         }
+
+        logger.newline();
+        logger.info('Allowed commands include:');
+        logger.log('  Node.js: npm, node, npx, yarn, pnpm');
+        logger.log('  Python: python, python3, pip, poetry');
+        logger.log('  Ruby: bundle, rake, rails, ruby');
+        logger.log('  Shell: sh, bash, echo, cat, ls, pwd, env');
+        logger.log('  Database: psql, mysql, mongosh');
+        logger.log('  Build: go, cargo, make, cmake');
+        logger.newline();
+        logger.info('Blocked for security:');
+        logger.log('  System commands: whoami, ps, top, kill');
+        logger.log('  Destructive operations: rm, chmod, chown');
+        logger.log('  Advanced shell features: pipes (|), redirects (>), command substitution');
+
+        process.exit(1);
       } else if (error.response?.status === 408) {
         logger.newline();
         logger.error('Command execution timed out');
@@ -105,37 +162,50 @@ async function exec(command, options = {}) {
     logger.newline();
 
     // Display execution results
-    logger.success(`✓ Execution ID: ${result.execution_id}`);
-    logger.newline();
+    const execResult = result.result || {};
+
+    // Calculate duration
+    let duration = 'N/A';
+    if (result.created_at && result.completed_at) {
+      const start = new Date(result.created_at);
+      const end = new Date(result.completed_at);
+      duration = `${end - start}ms`;
+    }
 
-    logger.field('Exit Code', result.exit_code === 0
-      ? logger.chalk.green(result.exit_code)
-      : logger.chalk.red(result.exit_code)
+    logger.field('Exit Code', execResult.exit_code !== undefined
+      ? (execResult.exit_code === 0
+          ? logger.chalk.green(execResult.exit_code)
+          : logger.chalk.red(execResult.exit_code))
+      : 'N/A'
     );
-    logger.field('Duration', `${result.duration_ms}ms`);
-    logger.field('Started', new Date(result.started_at).toLocaleString());
-    logger.field('Completed', new Date(result.completed_at).toLocaleString());
+    logger.field('Duration', duration);
+    if (result.created_at) {
+      logger.field('Started', new Date(result.created_at).toLocaleString());
+    }
+    if (result.completed_at) {
+      logger.field('Completed', new Date(result.completed_at).toLocaleString());
+    }
 
     // Display stdout
-    if (result.stdout) {
+    if (execResult.stdout) {
       logger.newline();
       logger.info('Standard Output:');
       logger.section('─'.repeat(60));
-      console.log(result.stdout.trim());
+      console.log(execResult.stdout.trim());
       logger.section('─'.repeat(60));
     }
 
     // Display stderr
-    if (result.stderr) {
+    if (execResult.stderr) {
       logger.newline();
       logger.warn('Standard Error:');
       logger.section('─'.repeat(60));
-      console.error(result.stderr.trim());
+      console.error(execResult.stderr.trim());
       logger.section('─'.repeat(60));
     }
 
     // If no output
-    if (!result.stdout && !result.stderr) {
+    if (!execResult.stdout && !execResult.stderr) {
       logger.newline();
       logger.info('(No output)');
     }

package/src/lib/api.js

@@ -319,6 +319,65 @@ async function listGitRepositories(gitHost, options = {}) {
   return response.data;
 }
 
+/**
+ * List database containers for an application
+ * @param {string} uuid - Application UUID
+ * @returns {Promise<object>} - { command_id, status }
+ */
+async function listDbContainers(uuid) {
+  const client = createClient();
+  const response = await client.get(`/applications/${uuid}/db/containers`);
+  return response.data;
+}
+
+/**
+ * Execute SQL query on application database
+ * @param {string} uuid - Application UUID
+ * @param {object} queryData - { query, db_name?, allow_writes? }
+ * @returns {Promise<object>} - { command_id, status }
+ */
+async function executeSql(uuid, queryData) {
+  const client = createClient();
+  const response = await client.post(`/applications/${uuid}/db/sql`, queryData);
+  return response.data;
+}
+
+/**
+ * Get result of a database command (universal endpoint for all command types)
+ * @param {string} uuid - Application UUID
+ * @param {string} commandType - 'sql', 'redis', 'containers' (not used, kept for API compatibility)
+ * @param {string} commandId - Command ID
+ * @returns {Promise<object>} - { status, result, command_type, created_at, completed_at }
+ */
+async function getDbCommandResult(uuid, commandType, commandId) {
+  const client = createClient();
+  const response = await client.get(`/applications/${uuid}/db/result/${commandId}`);
+  return response.data;
+}
+
+/**
+ * Execute Redis command on application database
+ * @param {string} uuid - Application UUID
+ * @param {object} commandData - { command }
+ * @returns {Promise<object>} - { command_id, status }
+ */
+async function executeRedis(uuid, commandData) {
+  const client = createClient();
+  const response = await client.post(`/applications/${uuid}/db/redis`, commandData);
+  return response.data;
+}
+
+/**
+ * Get database connection information
+ * @param {string} uuid - Application UUID
+ * @returns {Promise<object>} - { postgres: {...}, redis: {...} }
+ */
+async function getDbInfo(uuid) {
+  const client = createClient();
+  const response = await client.get(`/applications/${uuid}/db/info`);
+  return response.data;
+}
+
 module.exports = {
   createClient,
   login,
@@ -345,4 +404,9 @@ module.exports = {
   executeCommand,
   getExecutionHistory,
   listGitRepositories,
+  listDbContainers,
+  executeSql,
+  getDbCommandResult,
+  executeRedis,
+  getDbInfo,
 };