luxlabs 1.0.0

package/commands/data.js

@@ -0,0 +1,966 @@
+const axios = require('axios');
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const {
+  getApiUrl,
+  getStudioApiUrl,
+  getAuthHeaders,
+  isAuthenticated,
+  getOrgId,
+  getProjectId,
+  loadConfig,
+} = require('../lib/config');
+const {
+  error,
+  success,
+  info,
+  formatJson,
+  formatTable,
+  requireArgs,
+  readFile,
+  parseJson,
+} = require('../lib/helpers');
+
+// Local storage directory (shared with Electron app)
+const LUX_STUDIO_DIR = path.join(os.homedir(), '.lux-studio');
+
+/**
+ * Get the tables directory for local storage (project-scoped)
+ */
+function getTablesDir() {
+  const orgId = getOrgId();
+  const projectId = getProjectId();
+  if (!orgId) return null;
+  return path.join(LUX_STUDIO_DIR, orgId, 'projects', projectId, 'data', 'tables');
+}
+
+/**
+ * Get the tables API base URL (project-scoped)
+ */
+function getTablesApiUrl() {
+  const studioApiUrl = getStudioApiUrl();
+  const projectId = getProjectId();
+  if (!projectId) {
+    throw new Error('No project ID found. Run this command from a Lux Studio project directory.');
+  }
+  return `${studioApiUrl}/api/projects/${projectId}/tables`;
+}
+
+/**
+ * Get auth headers for Studio API (uses Authorization Bearer)
+ */
+function getStudioAuthHeaders() {
+  const config = loadConfig();
+  if (!config || !config.apiKey || !config.orgId) {
+    return {};
+  }
+  return {
+    'Authorization': `Bearer ${config.apiKey}`,
+    'X-Org-Id': config.orgId,
+    'Content-Type': 'application/json',
+  };
+}
+
+/**
+ * Ensure local storage directories exist
+ */
+function ensureLocalDirs() {
+  const tablesDir = getTablesDir();
+  if (tablesDir && !fs.existsSync(tablesDir)) {
+    fs.mkdirSync(tablesDir, { recursive: true });
+  }
+}
+
+/**
+ * Validate table name
+ * - Must be lowercase alphanumeric with underscores and dots
+ * - Cannot start with system. or _ (reserved)
+ * - Must start with a letter
+ */
+function validateTableName(name) {
+  // Only block system tables (matching API's isSystemTable check)
+  if (name.startsWith('system.') || name.startsWith('_')) {
+    return {
+      valid: false,
+      error: `Table name "${name}" is reserved. System tables cannot be created.`
+    };
+  }
+
+  // Validate format: lowercase alphanumeric with underscores and dots
+  if (!/^[a-z][a-z0-9_.]*$/.test(name)) {
+    return {
+      valid: false,
+      error: `Invalid table name "${name}"\n` +
+             `  Table names must be lowercase, start with a letter,\n` +
+             `  and contain only letters, numbers, underscores, and dots`
+    };
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Save a table schema to local storage
+ * Project-scoped tables (no user. prefix)
+ */
+function saveTableToLocal(tableName, columns = []) {
+  const tablesDir = getTablesDir();
+  if (!tablesDir) {
+    console.log(chalk.dim('  (No orgId - skipping local storage)'));
+    return;
+  }
+
+  ensureLocalDirs();
+
+  const tableSchema = {
+    id: tableName,
+    name: tableName,
+    type: 'user',
+    read_only: false,
+    schema: columns.map(col => ({
+      name: col.name,
+      type: col.type,
+      primaryKey: col.primaryKey || false,
+      notNull: col.notNull || false,
+      defaultValue: col.defaultValue || null,
+    })),
+    indexes: [],
+    syncedAt: new Date().toISOString(),
+  };
+
+  const safeName = tableName.replace(/[<>:"/\\|?*]/g, '_');
+  const tablePath = path.join(tablesDir, `${safeName}.json`);
+  fs.writeFileSync(tablePath, JSON.stringify(tableSchema, null, 2));
+  console.log(chalk.dim(`  (Saved to local: ${tablePath})`));
+}
+
+/**
+ * Delete a table schema from local storage
+ */
+function deleteTableFromLocal(tableName) {
+  const tablesDir = getTablesDir();
+  if (!tablesDir) return;
+
+  const safeName = tableName.replace(/[<>:"/\\|?*]/g, '_');
+  const tablePath = path.join(tablesDir, `${safeName}.json`);
+
+  if (fs.existsSync(tablePath)) {
+    fs.unlinkSync(tablePath);
+    console.log(chalk.dim(`  (Removed from local: ${tablePath})`));
+  }
+}
+
+async function handleData(args) {
+  // Check authentication
+  if (!isAuthenticated()) {
+    console.log(
+      chalk.red('❌ Not authenticated. Run'),
+      chalk.white('lux login'),
+      chalk.red('first.')
+    );
+    process.exit(1);
+  }
+
+  const command = args[0];
+
+  if (!command) {
+    console.log(`
+${chalk.bold('Usage:')} lux data <command> [args]
+
+${chalk.bold('Table Commands:')}
+  tables list                           List all tables
+  tables sync                           Sync tables to local storage
+  tables init <name> [--schema <json>]  Create new table
+  tables get <table-name>               Get table schema
+  tables delete <table-name>            Delete table
+  tables query <table-name> [limit]     List rows (default limit: 100)
+  tables insert <table-name> <json>     Insert row
+  tables update <table-name> <row-id> <json>   Update row by rowid
+  tables delete-row <table-name> <row-id>      Delete row by rowid
+  tables export <table-name> [file]     Export table to CSV
+  tables import <table-name> <csv-file> Import CSV to table
+
+${chalk.bold('KV Commands:')}
+  kv list                               List all KV namespaces
+  kv init <name> [description]          Create new KV namespace
+  kv delete <namespace-id>              Delete namespace
+  kv keys <namespace-id>                List all keys in namespace
+  kv get <namespace-id> <key>           Get key value
+  kv set <namespace-id> <key> <value>   Set key value
+  kv delete-key <namespace-id> <key>    Delete key
+  kv export <namespace-id> [file]       Export namespace to JSON
+  kv import <namespace-id> <json-file>  Import JSON to namespace
+  kv sync [namespace-id]                Sync KV data to local storage
+  kv local <namespace-id>               Read KV from local storage
+
+${chalk.bold('Examples:')}
+  lux data tables init customers --schema '{"columns":[{"name":"id","type":"TEXT","primaryKey":true}]}'
+  lux data tables init customers   (interactive mode)
+  lux data tables list
+  lux data tables query customers 50
+  lux data tables insert customers '{"id":"1","name":"John"}'
+  lux data kv init sessions "User session storage"
+  lux data kv set kv_abc user:123 '{"name":"John"}'
+`);
+    process.exit(0);
+  }
+
+  const apiUrl = getApiUrl();
+
+  try {
+    // ============ TABLE COMMANDS ============
+    if (command === 'tables') {
+      const subCommand = args[1];
+
+      if (!subCommand) {
+        error('Missing table subcommand. Run "lux data" to see available commands.');
+        return;
+      }
+
+      switch (subCommand) {
+        case 'sync': {
+          // Sync all tables from cloud to local storage
+          info('Syncing tables to local storage...');
+          const tablesApiUrl = getTablesApiUrl();
+          const { data } = await axios.get(tablesApiUrl, {
+            headers: getStudioAuthHeaders(),
+          });
+
+          if (!data.tables || data.tables.length === 0) {
+            console.log('\n(No tables to sync)\n');
+          } else {
+            ensureLocalDirs();
+            let synced = 0;
+
+            for (const table of data.tables) {
+              const tableName = table.name;
+              if (!tableName) continue;
+
+              try {
+                // Fetch table schema details
+                const detailResponse = await axios.get(
+                  `${tablesApiUrl}/${encodeURIComponent(tableName)}`,
+                  { headers: getStudioAuthHeaders() }
+                );
+
+                // New API returns { table: { columns } }
+                const tableData = detailResponse.data.table || {};
+                const columns = tableData.columns || [];
+
+                // Save to local storage
+                const tablesDir = getTablesDir();
+                if (tablesDir) {
+                  const tableSchema = {
+                    id: tableName,
+                    name: tableName,
+                    type: 'user',
+                    read_only: false,
+                    schema: columns.map(col => ({
+                      name: col.name,
+                      type: col.type,
+                      primaryKey: col.pk === 1,
+                      notNull: col.notnull === 1,
+                      defaultValue: col.dflt_value,
+                    })),
+                    indexes: [],
+                    syncedAt: new Date().toISOString(),
+                  };
+
+                  const safeName = tableName.replace(/[<>:"/\\|?*]/g, '_');
+                  const tablePath = path.join(tablesDir, `${safeName}.json`);
+                  fs.writeFileSync(tablePath, JSON.stringify(tableSchema, null, 2));
+                  console.log(chalk.dim(`  ✓ ${tableName}`));
+                  synced++;
+                }
+              } catch (err) {
+                console.log(chalk.yellow(`  ✗ ${tableName}: ${err.message}`));
+              }
+            }
+
+            success(`Synced ${synced}/${data.tables.length} tables to local storage`);
+            const tablesDir = getTablesDir();
+            if (tablesDir) {
+              console.log(chalk.dim(`  Location: ${tablesDir}`));
+            }
+          }
+          break;
+        }
+
+        case 'list': {
+          info('Loading tables...');
+          const tablesApiUrl = getTablesApiUrl();
+          const { data } = await axios.get(tablesApiUrl, {
+            headers: getStudioAuthHeaders(),
+          });
+
+          if (!data.tables || data.tables.length === 0) {
+            console.log('\n(No tables found)\n');
+          } else {
+            console.log(`\nFound ${data.tables.length} table(s):\n`);
+            formatTable(data.tables.map(t => ({
+              name: t.name,
+              columns: t.columnCount || 0,
+              rows: t.rowCount || 0,
+            })));
+            console.log('');
+          }
+          break;
+        }
+
+        case 'init': {
+          requireArgs(args.slice(2), 1, 'lux data tables init <name> [--schema <json>]');
+          let name = args[2];
+
+          // Validate table name
+          const validation = validateTableName(name);
+          if (!validation.valid) {
+            error(validation.error);
+            process.exit(1);
+          }
+
+          // Check for --schema flag for non-interactive mode
+          const schemaFlagIndex = args.indexOf('--schema');
+          let schema;
+
+          if (schemaFlagIndex !== -1 && args[schemaFlagIndex + 1]) {
+            // Non-interactive mode: parse schema from --schema flag
+            const schemaArg = args[schemaFlagIndex + 1];
+            schema = parseJson(schemaArg, 'schema');
+          } else {
+            // Interactive mode: prompt for schema
+            console.log('\n' + chalk.yellow('📝 Define your table schema in JSON format:'));
+            console.log(chalk.gray('Example:'));
+            console.log(chalk.gray(JSON.stringify({
+              columns: [
+                { name: 'id', type: 'TEXT', primaryKey: true, notNull: true },
+                { name: 'email', type: 'TEXT', notNull: true },
+                { name: 'created_at', type: 'INTEGER', notNull: true }
+              ]
+            }, null, 2)));
+            console.log('\n' + chalk.yellow('Paste your schema JSON (press Enter twice when done):'));
+
+            // Read multiline input
+            const lines = [];
+            const readline = require('readline').createInterface({
+              input: process.stdin,
+              output: process.stdout
+            });
+
+            let emptyLineCount = 0;
+            for await (const line of readline) {
+              if (line.trim() === '') {
+                emptyLineCount++;
+                if (emptyLineCount >= 2) {
+                  break;
+                }
+              } else {
+                emptyLineCount = 0;
+                lines.push(line);
+              }
+            }
+            readline.close();
+
+            const schemaJson = lines.join('\n');
+            schema = parseJson(schemaJson, 'schema');
+          }
+
+          info(`Creating table: ${name}`);
+          const tablesApiUrl = getTablesApiUrl();
+
+          // Map columns to API format (matching Electron's format)
+          const apiColumns = schema.columns.map(col => ({
+            name: col.name,
+            type: col.type.toUpperCase(), // API expects uppercase types: TEXT, INTEGER, REAL, BLOB
+            nullable: !col.notNull,
+            primaryKey: col.primaryKey || false,
+            defaultValue: col.defaultValue,
+          }));
+
+          const { data } = await axios.post(
+            tablesApiUrl,
+            { name, columns: apiColumns },
+            { headers: getStudioAuthHeaders() }
+          );
+
+          success('Table created!');
+          console.log(`   Name: ${data.table.name}`);
+
+          // Save to local storage for Electron app
+          saveTableToLocal(data.table.name, schema.columns);
+          break;
+        }
+
+        case 'get': {
+          requireArgs(args.slice(2), 1, 'lux data tables get <table-name>');
+          const tableName = args[2];
+
+          info(`Loading table: ${tableName}`);
+          const tablesApiUrl = getTablesApiUrl();
+          const { data } = await axios.get(
+            `${tablesApiUrl}/${encodeURIComponent(tableName)}`,
+            { headers: getStudioAuthHeaders() }
+          );
+
+          console.log(`\n📝 Table: ${data.table.name}`);
+          console.log(`📊 Columns: ${data.table.columnCount}`);
+          console.log(`\n📋 Schema:\n`);
+          formatTable(data.table.columns.map(col => ({
+            name: col.name,
+            type: col.type,
+            primaryKey: col.pk === 1 ? 'Yes' : 'No',
+            notNull: col.notnull === 1 ? 'Yes' : 'No',
+          })));
+          console.log('');
+          break;
+        }
+
+        case 'delete': {
+          requireArgs(args.slice(2), 1, 'lux data tables delete <table-name>');
+          const tableName = args[2];
+
+          info(`Deleting table: ${tableName}`);
+          const tablesApiUrl = getTablesApiUrl();
+          await axios.delete(
+            `${tablesApiUrl}/${encodeURIComponent(tableName)}`,
+            { headers: getStudioAuthHeaders() }
+          );
+
+          success('Table deleted!');
+
+          // Remove from local storage
+          deleteTableFromLocal(tableName);
+          break;
+        }
+
+        case 'query': {
+          // Query command - list rows from table
+          requireArgs(args.slice(2), 1, 'lux data tables query <table-name> [limit]');
+          const tableName = args[2];
+          const limit = args[3] ? parseInt(args[3]) : 100;
+
+          info(`Fetching rows from ${tableName}...`);
+          const tablesApiUrl = getTablesApiUrl();
+          const { data } = await axios.get(
+            `${tablesApiUrl}/${encodeURIComponent(tableName)}/rows?limit=${limit}`,
+            { headers: getStudioAuthHeaders() }
+          );
+
+          if (!data.rows || data.rows.length === 0) {
+            console.log('\n(No rows found)\n');
+          } else {
+            console.log('');
+            formatTable(data.rows);
+            console.log(`\n${chalk.green('✓')} ${data.rows.length} row(s) returned (total: ${data.pagination.total})\n`);
+          }
+          break;
+        }
+
+        case 'insert': {
+          requireArgs(args.slice(2), 2, 'lux data tables insert <table-name> <json>');
+          const tableName = args[2];
+          const jsonData = args.slice(3).join(' ');
+          const rowData = parseJson(jsonData, 'row data');
+
+          info('Inserting row...');
+          const tablesApiUrl = getTablesApiUrl();
+          const { data } = await axios.post(
+            `${tablesApiUrl}/${encodeURIComponent(tableName)}/rows`,
+            rowData,
+            { headers: getStudioAuthHeaders() }
+          );
+
+          success('Row inserted!');
+          if (data.row) {
+            console.log(`   Row ID: ${data.row.rowid}`);
+          }
+          break;
+        }
+
+        case 'update': {
+          requireArgs(args.slice(2), 3, 'lux data tables update <table-name> <row-id> <json>');
+          const tableName = args[2];
+          const rowId = args[3];
+          const jsonData = args.slice(4).join(' ');
+          const rowData = parseJson(jsonData, 'row data');
+
+          info('Updating row...');
+          const tablesApiUrl = getTablesApiUrl();
+          const { data } = await axios.put(
+            `${tablesApiUrl}/${encodeURIComponent(tableName)}/rows/${rowId}`,
+            rowData,
+            { headers: getStudioAuthHeaders() }
+          );
+
+          success('Row updated!');
+          break;
+        }
+
+        case 'delete-row': {
+          requireArgs(args.slice(2), 2, 'lux data tables delete-row <table-name> <row-id>');
+          const tableName = args[2];
+          const rowId = args[3];
+
+          info('Deleting row...');
+          const tablesApiUrl = getTablesApiUrl();
+          await axios.delete(
+            `${tablesApiUrl}/${encodeURIComponent(tableName)}/rows/${rowId}`,
+            { headers: getStudioAuthHeaders() }
+          );
+
+          success('Row deleted!');
+          break;
+        }
+
+        case 'export': {
+          requireArgs(args.slice(2), 1, 'lux data tables export <table-name> [file]');
+          const tableName = args[2];
+          const outputFile = args[3];
+
+          info('Exporting table...');
+          const tablesApiUrl = getTablesApiUrl();
+          const { data } = await axios.get(
+            `${tablesApiUrl}/${encodeURIComponent(tableName)}/rows?limit=10000`,
+            { headers: getStudioAuthHeaders() }
+          );
+
+          if (!data.rows || data.rows.length === 0) {
+            console.log('\n(No rows to export)\n');
+            return;
+          }
+
+          // Convert to CSV
+          const headers = Object.keys(data.rows[0]).filter(h => h !== 'rowid');
+          const csv = [
+            headers.join(','),
+            ...data.rows.map(row => headers.map(h => JSON.stringify(row[h])).join(','))
+          ].join('\n');
+
+          if (outputFile) {
+            fs.writeFileSync(outputFile, csv);
+            success(`Exported ${data.rows.length} rows to ${outputFile}`);
+          } else {
+            console.log('\n' + csv + '\n');
+          }
+          break;
+        }
+
+        case 'import': {
+          requireArgs(args.slice(2), 2, 'lux data tables import <table-name> <csv-file>');
+          const tableName = args[2];
+          const csvFile = args[3];
+
+          const csvContent = readFile(csvFile);
+          const lines = csvContent.trim().split('\n');
+          const headers = lines[0].split(',').map(h => h.trim().replace(/^"|"$/g, ''));
+          const rows = lines.slice(1).map(line => {
+            const values = line.split(',').map(v => {
+              const trimmed = v.trim().replace(/^"|"$/g, '');
+              try {
+                return JSON.parse(trimmed);
+              } catch {
+                return trimmed;
+              }
+            });
+            const row = {};
+            headers.forEach((h, i) => row[h] = values[i]);
+            return row;
+          });
+
+          info(`Importing ${rows.length} rows...`);
+          const tablesApiUrl = getTablesApiUrl();
+
+          // Use bulk insert
+          const { data } = await axios.post(
+            `${tablesApiUrl}/${encodeURIComponent(tableName)}/rows/bulk`,
+            { rows },
+            { headers: getStudioAuthHeaders() }
+          );
+
+          success(`Imported ${data.inserted}/${rows.length} rows`);
+          if (data.errors && data.errors.length > 0) {
+            console.log(chalk.yellow(`  ${data.errors.length} rows failed`));
+          }
+          break;
+        }
+
+        default:
+          error(`Unknown table subcommand: ${subCommand}`);
+      }
+    }
+
+    // ============ KV COMMANDS ============
+    else if (command === 'kv') {
+      const subCommand = args[1];
+
+      if (!subCommand) {
+        error('Missing KV subcommand. Run "lux data" to see available commands.');
+        return;
+      }
+
+      switch (subCommand) {
+        case 'list': {
+          info('Loading KV namespaces...');
+          const { data } = await axios.get(`${apiUrl}/api/kv`, {
+            headers: getAuthHeaders(),
+          });
+
+          if (!data.namespaces || data.namespaces.length === 0) {
+            console.log('\n(No KV namespaces found)\n');
+          } else {
+            console.log(`\nFound ${data.namespaces.length} namespace(s):\n`);
+            formatTable(data.namespaces.map(ns => ({
+              id: ns.id,
+              name: ns.name,
+              description: ns.description || '',
+              created_at: new Date(ns.created_at * 1000).toLocaleString(),
+            })));
+            console.log('');
+          }
+          break;
+        }
+
+        case 'init': {
+          requireArgs(args.slice(2), 1, 'lux data kv init <name> [description]');
+          const name = args[2];
+          const description = args[3] || '';
+
+          info(`Creating KV namespace: ${name}`);
+          const { data } = await axios.post(
+            `${apiUrl}/api/kv`,
+            { name, description },
+            { headers: getAuthHeaders() }
+          );
+
+          success('KV namespace created!');
+          console.log(`   ID: ${data.namespace.id}`);
+          console.log(`   Name: ${data.namespace.name}`);
+          break;
+        }
+
+        case 'delete': {
+          requireArgs(args.slice(2), 1, 'lux data kv delete <namespace-id>');
+          const namespaceId = args[2];
+
+          info(`Deleting namespace: ${namespaceId}`);
+          await axios.delete(
+            `${apiUrl}/api/kv/${namespaceId}`,
+            { headers: getAuthHeaders() }
+          );
+
+          success('Namespace deleted!');
+          break;
+        }
+
+        case 'keys': {
+          requireArgs(args.slice(2), 1, 'lux data kv keys <namespace-id>');
+          const namespaceId = args[2];
+
+          info('Loading keys...');
+          const { data } = await axios.get(
+            `${apiUrl}/api/kv/${namespaceId}/keys`,
+            { headers: getAuthHeaders() }
+          );
+
+          if (!data.keys || data.keys.length === 0) {
+            console.log('\n(No keys found)\n');
+          } else {
+            console.log(`\nFound ${data.keys.length} key(s):\n`);
+            data.keys.forEach(key => console.log(`  - ${key.name}`));
+            console.log('');
+          }
+          break;
+        }
+
+        case 'get': {
+          requireArgs(args.slice(2), 2, 'lux data kv get <namespace-id> <key>');
+          const namespaceId = args[2];
+          const key = args[3];
+
+          info(`Getting key: ${key}`);
+          const { data } = await axios.get(
+            `${apiUrl}/api/kv/${namespaceId}/keys/${encodeURIComponent(key)}`,
+            { headers: getAuthHeaders() }
+          );
+
+          console.log(`\nKey: ${data.key}`);
+          console.log(`Value:\n`);
+          try {
+            console.log(formatJson(JSON.parse(data.value)));
+          } catch {
+            console.log(data.value);
+          }
+          console.log('');
+          break;
+        }
+
+        case 'set': {
+          requireArgs(args.slice(2), 3, 'lux data kv set <namespace-id> <key> <value>');
+          const namespaceId = args[2];
+          const key = args[3];
+          const value = args.slice(4).join(' ');
+
+          info(`Setting key: ${key}`);
+          await axios.put(
+            `${apiUrl}/api/kv/${namespaceId}/keys/${encodeURIComponent(key)}`,
+            { value },
+            { headers: getAuthHeaders() }
+          );
+
+          success('Key set!');
+          break;
+        }
+
+        case 'delete-key': {
+          requireArgs(args.slice(2), 2, 'lux data kv delete-key <namespace-id> <key>');
+          const namespaceId = args[2];
+          const key = args[3];
+
+          info(`Deleting key: ${key}`);
+          await axios.delete(
+            `${apiUrl}/api/kv/${namespaceId}/keys/${encodeURIComponent(key)}`,
+            { headers: getAuthHeaders() }
+          );
+
+          success('Key deleted!');
+          break;
+        }
+
+        case 'export': {
+          requireArgs(args.slice(2), 1, 'lux data kv export <namespace-id> [file]');
+          const namespaceId = args[2];
+          const outputFile = args[3];
+
+          info('Exporting namespace...');
+
+          // Get all keys
+          const { data: keysData } = await axios.get(
+            `${apiUrl}/api/kv/${namespaceId}/keys`,
+            { headers: getAuthHeaders() }
+          );
+
+          if (!keysData.keys || keysData.keys.length === 0) {
+            console.log('\n(No keys to export)\n');
+            return;
+          }
+
+          // Get all values
+          const exported = {};
+          for (const keyInfo of keysData.keys) {
+            const { data } = await axios.get(
+              `${apiUrl}/api/kv/${namespaceId}/keys/${encodeURIComponent(keyInfo.name)}`,
+              { headers: getAuthHeaders() }
+            );
+            exported[data.key] = data.value;
+          }
+
+          const json = JSON.stringify(exported, null, 2);
+
+          if (outputFile) {
+            fs.writeFileSync(outputFile, json);
+            success(`Exported ${keysData.keys.length} keys to ${outputFile}`);
+          } else {
+            console.log('\n' + json + '\n');
+          }
+          break;
+        }
+
+        case 'import': {
+          requireArgs(args.slice(2), 2, 'lux data kv import <namespace-id> <json-file>');
+          const namespaceId = args[2];
+          const jsonFile = args[3];
+
+          const jsonContent = readFile(jsonFile);
+          const data = parseJson(jsonContent, 'KV data');
+
+          const pairs = Object.entries(data).map(([key, value]) => ({
+            key,
+            value: typeof value === 'string' ? value : JSON.stringify(value),
+          }));
+
+          info(`Importing ${pairs.length} keys...`);
+          await axios.post(
+            `${apiUrl}/api/kv/${namespaceId}/bulk`,
+            { pairs },
+            { headers: getAuthHeaders() }
+          );
+
+          success(`Imported ${pairs.length} keys`);
+          break;
+        }
+
+        case 'sync': {
+          // Sync KV data from cloud to local storage
+          const namespaceId = args[2]; // Optional - if not provided, sync all
+
+          // Get org ID and storage path
+          const { getOrgId } = require('../lib/config');
+          const orgId = getOrgId();
+          const os = require('os');
+          const kvDir = path.join(os.homedir(), '.lux-studio', orgId, 'data', 'kv');
+
+          if (!fs.existsSync(kvDir)) {
+            fs.mkdirSync(kvDir, { recursive: true });
+          }
+
+          if (namespaceId) {
+            // Sync single namespace
+            info(`Syncing namespace ${namespaceId} to local storage...`);
+
+            // Fetch all keys with values
+            const { data: keysData } = await axios.get(
+              `${apiUrl}/api/kv/${namespaceId}/keys?limit=1000&fetchValues=true`,
+              { headers: getAuthHeaders() }
+            );
+
+            const keys = keysData.keys || [];
+            const nsDir = path.join(kvDir, namespaceId);
+            if (!fs.existsSync(nsDir)) {
+              fs.mkdirSync(nsDir, { recursive: true });
+            }
+
+            // Build index and save values
+            const index = {};
+            for (const k of keys) {
+              const sanitizedKey = k.name.replace(/[^a-zA-Z0-9._-]/g, '_');
+              index[k.name] = { sanitizedKey, metadata: k.metadata };
+
+              const data = {
+                key: k.name,
+                value: k.value || '',
+                metadata: k.metadata,
+                syncedAt: new Date().toISOString(),
+              };
+              fs.writeFileSync(
+                path.join(nsDir, `${sanitizedKey}.json`),
+                JSON.stringify(data, null, 2)
+              );
+            }
+            fs.writeFileSync(
+              path.join(nsDir, '_index.json'),
+              JSON.stringify(index, null, 2)
+            );
+
+            success(`Synced ${keys.length} keys to ${nsDir}`);
+          } else {
+            // Sync all namespaces
+            info('Syncing all KV namespaces to local storage...');
+
+            const { data: nsData } = await axios.get(`${apiUrl}/api/kv`, {
+              headers: getAuthHeaders(),
+            });
+
+            const namespaces = nsData.namespaces || [];
+            let totalKeys = 0;
+
+            for (const ns of namespaces) {
+              try {
+                const { data: keysData } = await axios.get(
+                  `${apiUrl}/api/kv/${ns.id}/keys?limit=1000&fetchValues=true`,
+                  { headers: getAuthHeaders() }
+                );
+
+                const keys = keysData.keys || [];
+                const nsDir = path.join(kvDir, ns.id);
+                if (!fs.existsSync(nsDir)) {
+                  fs.mkdirSync(nsDir, { recursive: true });
+                }
+
+                const index = {};
+                for (const k of keys) {
+                  const sanitizedKey = k.name.replace(/[^a-zA-Z0-9._-]/g, '_');
+                  index[k.name] = { sanitizedKey, metadata: k.metadata };
+
+                  const data = {
+                    key: k.name,
+                    value: k.value || '',
+                    metadata: k.metadata,
+                    syncedAt: new Date().toISOString(),
+                  };
+                  fs.writeFileSync(
+                    path.join(nsDir, `${sanitizedKey}.json`),
+                    JSON.stringify(data, null, 2)
+                  );
+                }
+                fs.writeFileSync(
+                  path.join(nsDir, '_index.json'),
+                  JSON.stringify(index, null, 2)
+                );
+
+                totalKeys += keys.length;
+                console.log(`  ✓ ${ns.name}: ${keys.length} keys`);
+              } catch (err) {
+                console.error(`  ✗ ${ns.name}: ${err.message}`);
+              }
+            }
+
+            success(`Synced ${namespaces.length} namespaces (${totalKeys} total keys) to ${kvDir}`);
+          }
+          break;
+        }
+
+        case 'local': {
+          // Read KV from local storage
+          requireArgs(args.slice(2), 1, 'lux data kv local <namespace-id>');
+          const namespaceId = args[2];
+
+          const { getOrgId } = require('../lib/config');
+          const orgId = getOrgId();
+          const os = require('os');
+          const nsDir = path.join(os.homedir(), '.lux-studio', orgId, 'data', 'kv', namespaceId);
+
+          if (!fs.existsSync(nsDir)) {
+            console.log('\n(No local data found. Run "lux data kv sync" first.)\n');
+            return;
+          }
+
+          const indexPath = path.join(nsDir, '_index.json');
+          if (!fs.existsSync(indexPath)) {
+            console.log('\n(No index found. Run "lux data kv sync" first.)\n');
+            return;
+          }
+
+          const index = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
+          const keys = Object.keys(index);
+
+          if (keys.length === 0) {
+            console.log('\n(No keys in local storage)\n');
+            return;
+          }
+
+          console.log(`\nFound ${keys.length} key(s) in local storage:\n`);
+          for (const key of keys) {
+            const entry = index[key];
+            const filePath = path.join(nsDir, `${entry.sanitizedKey}.json`);
+            if (fs.existsSync(filePath)) {
+              const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+              console.log(`  ${chalk.cyan(key)}:`);
+              try {
+                console.log(`    ${formatJson(JSON.parse(data.value))}`);
+              } catch {
+                console.log(`    ${data.value}`);
+              }
+              console.log(`    ${chalk.gray(`(synced: ${data.syncedAt})`)}`);
+            }
+          }
+          console.log('');
+          break;
+        }
+
+        default:
+          error(`Unknown KV subcommand: ${subCommand}`);
+      }
+    }
+
+    else {
+      error(`Unknown command: ${command}\n\nRun 'lux data' to see available commands`);
+    }
+  } catch (err) {
+    const errorMessage =
+      err.response?.data?.error || err.message || 'Unknown error';
+    error(`${errorMessage}`);
+  }
+}
+
+module.exports = { handleData };