agentmemory-cli 1.0.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

@@ -0,0 +1,117 @@
+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,
+  options: { description?: string }
+): Promise<void> {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    console.error(chalk.red('Not configured. Run: agentmemory init'));
+    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}`));
+    process.exit(1);
+  }
+
+  const absolutePath = path.resolve(filePath);
+  const fileName = path.basename(absolutePath);
+  const fileBuffer = fs.readFileSync(absolutePath);
+  const fileSize = fileBuffer.length;
+
+  // Check file size (100MB limit)
+  if (fileSize > 100 * 1024 * 1024) {
+    console.error(chalk.red('File too large. Maximum size is 100MB.'));
+    process.exit(1);
+  }
+
+  console.log(chalk.blue(`Uploading ${fileName} (${formatSize(fileSize)})...`));
+
+  try {
+    // Create FormData
+    const FormData = (await import('form-data')).default;
+    const form = new FormData();
+    form.append('file', fileBuffer, {
+      filename: fileName,
+      contentType: getMimeType(fileName),
+    });
+    if (options.description) {
+      form.append('description', options.description);
+    }
+
+    const apiUrl = getApiUrl();
+    
+    // Use node-fetch with form-data
+    const nodeFetch = (await import('node-fetch')).default;
+    const response = await nodeFetch(`${apiUrl}/files`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        ...form.getHeaders(),
+      },
+      body: form,
+    }) as unknown as Response;
+
+    const data = await response.json() as { success?: boolean; memory?: { id: string; file_name: string }; error?: string };
+
+    if (!response.ok) {
+      console.error(chalk.red(`Error: ${data.error || 'Upload failed'}`));
+      process.exit(1);
+    }
+
+    console.log(chalk.green('✓ File uploaded successfully!'));
+    console.log(chalk.gray(`  ID: ${data.memory?.id}`));
+    console.log(chalk.gray(`  Name: ${data.memory?.file_name}`));
+  } catch (error) {
+    console.error(chalk.red(`Upload failed: ${error instanceof Error ? error.message : 'Unknown error'}`));
+    process.exit(1);
+  }
+}
+
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+function getMimeType(fileName: string): string {
+  const ext = path.extname(fileName).toLowerCase();
+  const mimeTypes: Record<string, string> = {
+    '.txt': 'text/plain',
+    '.md': 'text/markdown',
+    '.json': 'application/json',
+    '.pdf': 'application/pdf',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.xls': 'application/vnd.ms-excel',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.zip': 'application/zip',
+    '.js': 'text/javascript',
+    '.ts': 'text/typescript',
+    '.py': 'text/x-python',
+    '.html': 'text/html',
+    '.css': 'text/css',
+    '.yaml': 'text/yaml',
+    '.yml': 'text/yaml',
+  };
+  return mimeTypes[ext] || 'application/octet-stream';
+}