agentmemory-cli 1.1.0 → 1.3.0

package/src/commands/secret.ts

@@ -0,0 +1,438 @@
+import chalk from 'chalk';
+import * as fs from 'fs';
+import { createInterface } from 'readline';
+import { getApiKey } from '../lib/config.js';
+import { listSecrets, getSecret, setSecret, deleteSecret, getAllSecrets } from '../lib/api.js';
+import { autoSync } from '../lib/autosync.js';
+import type { SecretType, SecretListItem } from '../types.js';
+
+// Prompt helper
+async function prompt(question: string): Promise<string> {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+async function confirm(question: string): Promise<boolean> {
+  const answer = await prompt(question);
+  return answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
+}
+
+async function promptPassword(question: string): Promise<string> {
+  // Simple password prompt (in production, use a library that masks input)
+  return prompt(question);
+}
+
+const VALID_TYPES: SecretType[] = ['api_key', 'credential', 'connection_string', 'env_var', 'generic'];
+
+// Helper to mask secret values
+function maskValue(value: string): string {
+  if (value.length <= 8) {
+    return '*'.repeat(value.length);
+  }
+  return value.slice(0, 4) + '*'.repeat(value.length - 8) + value.slice(-4);
+}
+
+// Format secret type with icon
+function formatType(type: SecretType): string {
+  const icons: Record<SecretType, string> = {
+    api_key: '🔑',
+    credential: '🔐',
+    connection_string: '🔗',
+    env_var: '📦',
+    generic: '📄',
+  };
+  return `${icons[type] || '📄'} ${type}`;
+}
+
+// Set a secret
+export async function secretSetCommand(
+  name: string,
+  value: string,
+  options: {
+    type?: string;
+    description?: string;
+    json?: boolean;
+  }
+): Promise<void> {
+  const apiKey = getApiKey();
+  
+  // Auto-sync in background (silent)
+  autoSync();
+  
+  if (!apiKey) {
+    console.error(chalk.red('Error: Not configured. Run "agentmemory init" first.'));
+    process.exit(1);
+  }
+  
+  // Validate type
+  const type = (options.type || 'generic') as SecretType;
+  if (!VALID_TYPES.includes(type)) {
+    console.error(chalk.red(`Error: Invalid type. Must be one of: ${VALID_TYPES.join(', ')}`));
+    process.exit(1);
+  }
+  
+  try {
+    const response = await setSecret(name, value, type, options.description);
+    
+    if (options.json) {
+      console.log(JSON.stringify(response, null, 2));
+    } else {
+      const action = response.message?.includes('updated') ? 'updated' : 'created';
+      console.log(chalk.green(`✓ Secret "${name}" ${action} successfully`));
+      console.log(chalk.gray(`  Type: ${formatType(type)}`));
+      if (options.description) {
+        console.log(chalk.gray(`  Description: ${options.description}`));
+      }
+    }
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: error instanceof Error ? error.message : 'Unknown error' }));
+    } else {
+      console.error(chalk.red(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    }
+    process.exit(1);
+  }
+}
+
+// Get a secret value
+export async function secretGetCommand(
+  name: string,
+  options: {
+    show?: boolean;
+    json?: boolean;
+  }
+): Promise<void> {
+  const apiKey = getApiKey();
+  
+  // Auto-sync in background (silent)
+  autoSync();
+  
+  if (!apiKey) {
+    console.error(chalk.red('Error: Not configured. Run "agentmemory init" first.'));
+    process.exit(1);
+  }
+  
+  try {
+    const secret = await getSecret(name);
+    
+    if (options.json) {
+      // In JSON mode, always show full value
+      console.log(JSON.stringify(secret, null, 2));
+    } else {
+      console.log(chalk.cyan(`Secret: ${secret.name}`));
+      console.log(chalk.gray(`Type: ${formatType(secret.type)}`));
+      if (secret.description) {
+        console.log(chalk.gray(`Description: ${secret.description}`));
+      }
+      console.log();
+      
+      // Show value (masked by default)
+      if (options.show) {
+        console.log(chalk.yellow('Value:'), secret.value);
+      } else {
+        console.log(chalk.yellow('Value:'), maskValue(secret.value || ''));
+        console.log(chalk.gray('  (use --show to reveal full value)'));
+      }
+    }
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: error instanceof Error ? error.message : 'Unknown error' }));
+    } else {
+      console.error(chalk.red(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    }
+    process.exit(1);
+  }
+}
+
+// List all secrets
+export async function secretListCommand(
+  options: {
+    type?: string;
+    json?: boolean;
+  }
+): Promise<void> {
+  const apiKey = getApiKey();
+  
+  // Auto-sync in background (silent)
+  autoSync();
+  
+  if (!apiKey) {
+    console.error(chalk.red('Error: Not configured. Run "agentmemory init" first.'));
+    process.exit(1);
+  }
+  
+  try {
+    const type = options.type as SecretType | undefined;
+    if (type && !VALID_TYPES.includes(type)) {
+      console.error(chalk.red(`Error: Invalid type. Must be one of: ${VALID_TYPES.join(', ')}`));
+      process.exit(1);
+    }
+    
+    const response = await listSecrets(500, type);
+    
+    if (options.json) {
+      console.log(JSON.stringify(response, null, 2));
+    } else {
+      if (response.secrets.length === 0) {
+        console.log(chalk.yellow('No secrets found.'));
+        return;
+      }
+      
+      console.log(chalk.cyan(`\nSecrets (${response.total} total):\n`));
+      
+      for (const secret of response.secrets) {
+        console.log(`  ${chalk.white(secret.name)}`);
+        console.log(`    ${formatType(secret.type)}`);
+        if (secret.description) {
+          console.log(`    ${chalk.gray(secret.description)}`);
+        }
+        console.log();
+      }
+    }
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: error instanceof Error ? error.message : 'Unknown error' }));
+    } else {
+      console.error(chalk.red(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    }
+    process.exit(1);
+  }
+}
+
+// Delete a secret
+export async function secretDeleteCommand(
+  name: string,
+  options: {
+    force?: boolean;
+    json?: boolean;
+  }
+): Promise<void> {
+  const apiKey = getApiKey();
+  
+  // Auto-sync in background (silent)
+  autoSync();
+  
+  if (!apiKey) {
+    console.error(chalk.red('Error: Not configured. Run "agentmemory init" first.'));
+    process.exit(1);
+  }
+  
+  // Confirmation (unless --force)
+  if (!options.force && !options.json) {
+    const confirmed = await confirm(`Are you sure you want to delete secret "${name}"? (y/N): `);
+    
+    if (!confirmed) {
+      console.log(chalk.yellow('Cancelled.'));
+      return;
+    }
+  }
+  
+  try {
+    await deleteSecret(name);
+    
+    if (options.json) {
+      console.log(JSON.stringify({ success: true, deleted: name }));
+    } else {
+      console.log(chalk.green(`✓ Secret "${name}" deleted successfully`));
+    }
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: error instanceof Error ? error.message : 'Unknown error' }));
+    } else {
+      console.error(chalk.red(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    }
+    process.exit(1);
+  }
+}
+
+// Export secrets to file (encrypted with password)
+export async function secretsExportCommand(
+  options: {
+    output?: string;
+    json?: boolean;
+  }
+): Promise<void> {
+  const apiKey = getApiKey();
+  
+  // Auto-sync in background (silent)
+  autoSync();
+  
+  if (!apiKey) {
+    console.error(chalk.red('Error: Not configured. Run "agentmemory init" first.'));
+    process.exit(1);
+  }
+  
+  try {
+    // Fetch all secrets with values
+    const secretsList = await getAllSecrets();
+    
+    // Get full values for each secret
+    const secretsWithValues: Array<{
+      name: string;
+      value: string;
+      type: string;
+      description?: string;
+    }> = [];
+    
+    for (const secretItem of secretsList) {
+      const fullSecret = await getSecret(secretItem.name);
+      secretsWithValues.push({
+        name: fullSecret.name,
+        value: fullSecret.value || '',
+        type: fullSecret.type,
+        description: fullSecret.description,
+      });
+    }
+    
+    // Ask for password for encryption
+    const password = await promptPassword('Enter password to encrypt secrets (min 8 chars): ');
+    
+    if (!password || password.length < 8) {
+      console.error(chalk.red('Error: Password must be at least 8 characters'));
+      process.exit(1);
+    }
+    
+    // Simple XOR encryption (for demonstration - in production use proper crypto)
+    const exportData = {
+      version: 1,
+      encrypted: true,
+      secrets: secretsWithValues.map(s => ({
+        ...s,
+        value: simpleEncrypt(s.value, password),
+      })),
+      exported_at: new Date().toISOString(),
+    };
+    
+    const outputPath = options.output || 'secrets-export.json';
+    fs.writeFileSync(outputPath, JSON.stringify(exportData, null, 2));
+    
+    if (options.json) {
+      console.log(JSON.stringify({ success: true, file: outputPath, count: secretsWithValues.length }));
+    } else {
+      console.log(chalk.green(`✓ Exported ${secretsWithValues.length} secrets to ${outputPath}`));
+      console.log(chalk.yellow('⚠ Keep this file secure! It contains encrypted secrets.'));
+    }
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: error instanceof Error ? error.message : 'Unknown error' }));
+    } else {
+      console.error(chalk.red(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    }
+    process.exit(1);
+  }
+}
+
+// Import secrets from file
+export async function secretsImportCommand(
+  file: string,
+  options: {
+    json?: boolean;
+  }
+): Promise<void> {
+  const apiKey = getApiKey();
+  
+  // Auto-sync in background (silent)
+  autoSync();
+  
+  if (!apiKey) {
+    console.error(chalk.red('Error: Not configured. Run "agentmemory init" first.'));
+    process.exit(1);
+  }
+  
+  if (!fs.existsSync(file)) {
+    console.error(chalk.red(`Error: File not found: ${file}`));
+    process.exit(1);
+  }
+  
+  try {
+    const content = fs.readFileSync(file, 'utf-8');
+    const data = JSON.parse(content) as {
+      version: number;
+      encrypted: boolean;
+      secrets: Array<{
+        name: string;
+        value: string;
+        type: string;
+        description?: string;
+      }>;
+    };
+    
+    let secrets = data.secrets;
+    
+    // Decrypt if encrypted
+    if (data.encrypted) {
+      const password = await promptPassword('Enter password to decrypt secrets: ');
+      
+      secrets = secrets.map(s => ({
+        ...s,
+        value: simpleDecrypt(s.value, password),
+      }));
+    }
+    
+    // Import secrets
+    let imported = 0;
+    let errors = 0;
+    
+    for (const secret of secrets) {
+      try {
+        await setSecret(
+          secret.name,
+          secret.value,
+          secret.type as SecretType,
+          secret.description
+        );
+        imported++;
+        if (!options.json) {
+          console.log(chalk.green(`✓ Imported: ${secret.name}`));
+        }
+      } catch (err) {
+        errors++;
+        if (!options.json) {
+          console.log(chalk.red(`✗ Failed: ${secret.name} - ${err instanceof Error ? err.message : 'Unknown error'}`));
+        }
+      }
+    }
+    
+    if (options.json) {
+      console.log(JSON.stringify({ success: true, imported, errors, total: secrets.length }));
+    } else {
+      console.log();
+      console.log(chalk.cyan(`Import complete: ${imported} imported, ${errors} errors`));
+    }
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: error instanceof Error ? error.message : 'Unknown error' }));
+    } else {
+      console.error(chalk.red(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    }
+    process.exit(1);
+  }
+}
+
+// Simple XOR-based encryption (for demonstration)
+// In production, use Node.js crypto module with AES-256-GCM
+function simpleEncrypt(text: string, password: string): string {
+  const result: number[] = [];
+  for (let i = 0; i < text.length; i++) {
+    result.push(text.charCodeAt(i) ^ password.charCodeAt(i % password.length));
+  }
+  return Buffer.from(result).toString('base64');
+}
+
+function simpleDecrypt(encoded: string, password: string): string {
+  const data = Buffer.from(encoded, 'base64');
+  const result: string[] = [];
+  for (let i = 0; i < data.length; i++) {
+    result.push(String.fromCharCode(data[i] ^ password.charCodeAt(i % password.length)));
+  }
+  return result.join('');
+}

package/src/commands/store.ts

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import { storeMemory } from '../lib/api.js';
 import { isConfigured } from '../lib/config.js';
+import { autoSync } from '../lib/autosync.js';
 
 interface StoreOptions {
   category?: string;
@@ -17,6 +18,9 @@ export async function storeCommand(
     process.exit(1);
   }
   
+  // Auto-sync in background (silent)
+  autoSync();
+  
   try {
     // Build metadata
     let metadata: Record<string, unknown> = {};

package/src/commands/upload.ts

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import fs from 'fs';
 import path from 'path';
 import { getApiKey, getApiUrl } from '../lib/config.js';
+import { autoSync } from '../lib/autosync.js';
 
 export async function uploadCommand(
   filePath: string,
@@ -13,6 +14,9 @@ export async function uploadCommand(
     process.exit(1);
   }
 
+  // Auto-sync in background (silent)
+  autoSync();
+
   // Check if file exists
   if (!fs.existsSync(filePath)) {
     console.error(chalk.red(`File not found: ${filePath}`));

package/src/index.ts

@@ -13,13 +13,23 @@ import { importCommand } from './commands/import.js';
 import { uploadCommand } from './commands/upload.js';
 import { filesCommand } from './commands/files.js';
 import { downloadCommand } from './commands/download.js';
+import { 
+  secretSetCommand, 
+  secretGetCommand, 
+  secretListCommand, 
+  secretDeleteCommand,
+  secretsExportCommand,
+  secretsImportCommand
+} from './commands/secret.js';
+import { connectCommand, statusCommand } from './commands/connect.js';
+import { heartbeatCommand, watchCommand, disconnectCommand } from './commands/heartbeat.js';
 
 const program = new Command();
 
 program
   .name('agentmemory')
   .description('CLI tool for AgentMemory - persistent cloud memory for AI agents')
-  .version('1.0.0');
+  .version('1.3.0');
 
 // Init command
 program
@@ -27,6 +37,48 @@ program
   .description('Initialize AgentMemory CLI with your API key')
   .action(initCommand);
 
+// Connect command (auto-sync)
+program
+  .command('connect')
+  .description('Connect and sync all data from cloud')
+  .option('--offline', 'Use cached data (no network)')
+  .option('--no-memories', 'Skip syncing memories to MEMORY.md')
+  .option('--no-secrets', 'Skip showing secrets list')
+  .option('--json', 'Output as JSON')
+  .action(connectCommand);
+
+// Status command
+program
+  .command('status')
+  .description('Check connection status and data counts')
+  .option('--json', 'Output as JSON')
+  .action(statusCommand);
+
+// Heartbeat command
+program
+  .command('heartbeat')
+  .description('Send heartbeat signal (marks agent as online)')
+  .option('--no-sync', 'Skip syncing data')
+  .option('-c, --continuous', 'Run continuous heartbeat')
+  .option('-i, --interval <seconds>', 'Heartbeat interval in seconds', '60')
+  .option('--json', 'Output as JSON')
+  .action(heartbeatCommand);
+
+// Watch command (continuous heartbeat with auto-sync)
+program
+  .command('watch')
+  .description('Keep agent online with continuous heartbeat and auto-sync')
+  .option('-i, --interval <seconds>', 'Heartbeat interval in seconds', '60')
+  .option('--json', 'Output as JSON')
+  .action(watchCommand);
+
+// Disconnect command
+program
+  .command('disconnect')
+  .description('Mark agent as offline')
+  .option('--json', 'Output as JSON')
+  .action(disconnectCommand);
+
 // Store command
 program
   .command('store <content>')
@@ -110,6 +162,59 @@ program
   .option('-i, --info', 'Show file info without downloading')
   .action(downloadCommand);
 
+// Secret commands (grouped)
+const secretCmd = program
+  .command('secret')
+  .description('Manage secrets vault');
+
+// secret set
+secretCmd
+  .command('set <name> <value>')
+  .description('Store a secret')
+  .option('-t, --type <type>', 'Secret type (api_key, credential, connection_string, env_var, generic)', 'generic')
+  .option('-d, --description <text>', 'Description for the secret')
+  .option('--json', 'Output as JSON')
+  .action(secretSetCommand);
+
+// secret get
+secretCmd
+  .command('get <name>')
+  .description('Retrieve a secret')
+  .option('-s, --show', 'Show full value (not masked)')
+  .option('--json', 'Output as JSON')
+  .action(secretGetCommand);
+
+// secret list
+secretCmd
+  .command('list')
+  .description('List all secret names')
+  .option('-t, --type <type>', 'Filter by type')
+  .option('--json', 'Output as JSON')
+  .action(secretListCommand);
+
+// secret delete
+secretCmd
+  .command('delete <name>')
+  .description('Delete a secret')
+  .option('-f, --force', 'Skip confirmation')
+  .option('--json', 'Output as JSON')
+  .action(secretDeleteCommand);
+
+// secrets export (note: "secrets" plural for bulk operations)
+program
+  .command('secrets-export')
+  .description('Export all secrets (encrypted with password)')
+  .option('-o, --output <file>', 'Output file path', 'secrets-export.json')
+  .option('--json', 'Output as JSON')
+  .action(secretsExportCommand);
+
+// secrets import
+program
+  .command('secrets-import <file>')
+  .description('Import secrets from encrypted file')
+  .option('--json', 'Output as JSON')
+  .action(secretsImportCommand);
+
 // Custom help
 program.addHelpText('after', `
 ${chalk.cyan('Examples:')}
@@ -127,6 +232,23 @@ ${chalk.cyan('Examples:')}
   $ agentmemory files --type image            # Filter by type
   $ agentmemory download <id>                 # Download a file
 
+  ${chalk.cyan('Secrets Vault:')}
+  $ agentmemory secret set OPENAI_KEY sk-xxx --type api_key
+  $ agentmemory secret get OPENAI_KEY         # Shows masked value
+  $ agentmemory secret get OPENAI_KEY --show  # Shows full value
+  $ agentmemory secret list                   # List all secrets
+  $ agentmemory secret delete OPENAI_KEY      # Delete a secret
+  $ agentmemory secrets-export                # Export encrypted backup
+  $ agentmemory secrets-import backup.json    # Import from backup
+
+  ${chalk.cyan('Auto-Sync & Heartbeat:')}
+  $ agentmemory connect                       # Sync all data from cloud
+  $ agentmemory status                        # Check connection status
+  $ agentmemory heartbeat                     # Send single heartbeat with sync
+  $ agentmemory watch                         # Continuous heartbeat (keeps online)
+  $ agentmemory watch -i 30                   # Heartbeat every 30 seconds
+  $ agentmemory disconnect                    # Mark agent as offline
+
 ${chalk.cyan('Documentation:')}
   https://agentmemory.cloud/docs
 
@@ -140,7 +262,7 @@ program.parse();
 // Show help if no command provided
 if (!process.argv.slice(2).length) {
   console.log(chalk.cyan(`
-  🧠 AgentMemory CLI v1.0.0
+  🧠 AgentMemory CLI v1.3.0
   
   Persistent cloud memory for AI agents.
   `));