agentmemory-cli 1.0.0 → 1.3.0

package/src/index.ts

@@ -10,13 +10,26 @@ import { deleteCommand } from './commands/delete.js';
 import { syncCommand } from './commands/sync.js';
 import { exportCommand } from './commands/export.js';
 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
@@ -24,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>')
@@ -83,6 +138,83 @@ program
   .option('--json', 'Output as JSON')
   .action(importCommand);
 
+// Upload command (files)
+program
+  .command('upload <file>')
+  .description('Upload a file (images, PDFs, docs, audio, video, etc.)')
+  .option('-d, --description <text>', 'Description for the file')
+  .action(uploadCommand);
+
+// Files command (list files)
+program
+  .command('files')
+  .description('List uploaded files')
+  .option('-l, --limit <number>', 'Maximum number of results', '50')
+  .option('-t, --type <type>', 'Filter by type (image, audio, video, pdf, document)')
+  .option('--json', 'Output as JSON')
+  .action(filesCommand);
+
+// Download command
+program
+  .command('download <id>')
+  .description('Download a file by ID')
+  .option('-o, --output <path>', 'Output file path')
+  .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:')}
@@ -92,6 +224,30 @@ ${chalk.cyan('Examples:')}
   $ agentmemory list --limit 10
   $ agentmemory sync                          # Sync with MEMORY.md
   $ agentmemory export > backup.json
+  
+  ${chalk.cyan('File Operations:')}
+  $ agentmemory upload photo.jpg              # Upload any file
+  $ agentmemory upload doc.pdf -d "Meeting notes"
+  $ agentmemory files                         # List uploaded files
+  $ 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
@@ -106,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.
   `));

package/src/lib/api.ts

@@ -4,7 +4,13 @@ import type {
   MemoriesListResponse, 
   MemoryCreateResponse, 
   MemorySearchResponse,
-  MemorySearchResult 
+  MemorySearchResult,
+  Secret,
+  SecretListItem,
+  SecretsListResponse,
+  SecretResponse,
+  SecretType,
+  SyncConnectResponse
 } from '../types.js';
 
 class ApiError extends Error {
@@ -136,4 +142,83 @@ export async function getAllMemories(): Promise<Memory[]> {
   return allMemories;
 }
 
+// Secrets API functions
+
+export async function listSecrets(
+  limit: number = 100,
+  type?: SecretType
+): Promise<SecretsListResponse> {
+  let endpoint = `/secrets?limit=${limit}`;
+  if (type) {
+    endpoint += `&type=${type}`;
+  }
+  return request<SecretsListResponse>(endpoint);
+}
+
+export async function getSecret(name: string): Promise<Secret> {
+  const response = await request<{ secret: Secret }>(`/secrets/${encodeURIComponent(name)}`);
+  return response.secret;
+}
+
+export async function setSecret(
+  name: string,
+  value: string,
+  type: SecretType = 'generic',
+  description?: string,
+  metadata?: Record<string, unknown>
+): Promise<SecretResponse> {
+  const body: {
+    name: string;
+    value: string;
+    type: SecretType;
+    description?: string;
+    metadata?: Record<string, unknown>;
+  } = { name, value, type };
+  
+  if (description) {
+    body.description = description;
+  }
+  if (metadata) {
+    body.metadata = metadata;
+  }
+  
+  return request<SecretResponse>('/secrets', {
+    method: 'POST',
+    body: JSON.stringify(body),
+  });
+}
+
+export async function deleteSecret(name: string): Promise<void> {
+  await request<{ message: string; name: string }>(
+    `/secrets/${encodeURIComponent(name)}`,
+    { method: 'DELETE' }
+  );
+}
+
+export async function getAllSecrets(): Promise<SecretListItem[]> {
+  const response = await listSecrets(500);
+  return response.secrets;
+}
+
+// Sync connect API
+export async function syncConnect(options?: {
+  include_files?: boolean;
+  memories_limit?: number;
+  secrets_limit?: number;
+}): Promise<SyncConnectResponse> {
+  return request<SyncConnectResponse>('/sync/connect', {
+    method: 'POST',
+    body: JSON.stringify(options || {}),
+  });
+}
+
+export async function checkConnection(): Promise<{
+  connected: boolean;
+  agent: { id: string; name: string };
+  counts: { memories: number; secrets: number };
+  server_time: string;
+}> {
+  return request('/sync/connect');
+}
+
 export { ApiError };

package/src/lib/autosync.ts

@@ -0,0 +1,160 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { getApiKey, getApiUrl, getMemoryFilePath } from './config.js';
+
+const CONFIG_DIR = path.join(os.homedir(), '.agentmemory');
+const SYNC_CACHE_FILE = path.join(CONFIG_DIR, 'sync-cache.json');
+const SYNC_INTERVAL_MS = 30000; // Only sync if last sync was 30+ seconds ago
+
+interface SyncCache {
+  last_sync: string;
+  last_sync_ms: number;
+  memory_count: number;
+  secret_count: number;
+}
+
+function loadSyncCache(): SyncCache | null {
+  try {
+    if (fs.existsSync(SYNC_CACHE_FILE)) {
+      return JSON.parse(fs.readFileSync(SYNC_CACHE_FILE, 'utf-8'));
+    }
+  } catch {
+    // Ignore errors
+  }
+  return null;
+}
+
+function saveSyncCache(cache: SyncCache): void {
+  try {
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(SYNC_CACHE_FILE, JSON.stringify(cache, null, 2));
+  } catch {
+    // Ignore errors
+  }
+}
+
+/**
+ * Silent auto-sync - runs at the start of every command
+ * - Sends heartbeat to mark agent as online
+ * - Syncs memories to local MEMORY.md file
+ * - Caches results to avoid syncing too frequently
+ * - Never throws errors or prints output (silent)
+ */
+export async function autoSync(): Promise<void> {
+  const apiKey = getApiKey();
+  if (!apiKey) return; // Not configured yet
+
+  // Check if we synced recently (within 30 seconds)
+  const cache = loadSyncCache();
+  if (cache && Date.now() - cache.last_sync_ms < SYNC_INTERVAL_MS) {
+    return; // Skip sync, too recent
+  }
+
+  const apiUrl = getApiUrl();
+
+  try {
+    // Send heartbeat with sync
+    const response = await fetch(`${apiUrl}/heartbeat`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ sync: true }),
+    });
+
+    if (!response.ok) return;
+
+    const data = await response.json() as {
+      sync?: {
+        memories: {
+          items: Array<{
+            id: string;
+            content: string;
+            metadata?: Record<string, unknown>;
+            created_at: string;
+            updated_at?: string;
+          }>;
+          count: number;
+        };
+        secrets: {
+          count: number;
+        };
+        synced_at: string;
+      };
+    };
+
+    if (!data.sync) return;
+
+    // Save memories to local MEMORY.md file (silently)
+    if (data.sync.memories.items.length > 0) {
+      try {
+        const memoryFilePath = getMemoryFilePath();
+        const dir = path.dirname(memoryFilePath);
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+
+        const lines: string[] = [
+          '# Agent Memory',
+          '',
+          `> Last synced: ${data.sync.synced_at}`,
+          `> Total memories: ${data.sync.memories.count}`,
+          '',
+          '---',
+          '',
+        ];
+
+        for (const memory of data.sync.memories.items) {
+          lines.push(`<!-- id: ${memory.id} -->`);
+          if (memory.metadata && Object.keys(memory.metadata).length > 0) {
+            lines.push(`<!-- metadata: ${JSON.stringify(memory.metadata)} -->`);
+          }
+          lines.push(memory.content);
+          lines.push('');
+          lines.push('---');
+          lines.push('');
+        }
+
+        fs.writeFileSync(memoryFilePath, lines.join('\n'));
+      } catch {
+        // Silently ignore file write errors
+      }
+    }
+
+    // Update cache
+    saveSyncCache({
+      last_sync: data.sync.synced_at,
+      last_sync_ms: Date.now(),
+      memory_count: data.sync.memories.count,
+      secret_count: data.sync.secrets.count,
+    });
+  } catch {
+    // Silently ignore all errors - auto-sync should never break commands
+  }
+}
+
+/**
+ * Quick heartbeat - just marks agent as online, no sync
+ * Use this for commands that don't need fresh data
+ */
+export async function quickHeartbeat(): Promise<void> {
+  const apiKey = getApiKey();
+  if (!apiKey) return;
+
+  const apiUrl = getApiUrl();
+
+  try {
+    await fetch(`${apiUrl}/heartbeat`, {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+      },
+    });
+  } catch {
+    // Silently ignore
+  }
+}

package/src/types.ts

@@ -45,3 +45,70 @@ export interface SyncStatus {
     cloud: Memory;
   }>;
 }
+
+// Secrets types
+export type SecretType = 'api_key' | 'credential' | 'connection_string' | 'env_var' | 'generic';
+
+export interface Secret {
+  id: string;
+  name: string;
+  value?: string;
+  type: SecretType;
+  description?: string;
+  metadata?: Record<string, unknown>;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface SecretListItem {
+  id: string;
+  name: string;
+  type: SecretType;
+  description?: string;
+  metadata?: Record<string, unknown>;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface SecretsListResponse {
+  secrets: SecretListItem[];
+  total: number;
+  limit: number;
+  offset: number;
+}
+
+export interface SecretResponse {
+  secret: Secret;
+  message?: string;
+}
+
+// Sync connect types
+export interface SyncConnectResponse {
+  agent: {
+    id: string;
+    name: string;
+    memory_count: number;
+    created_at: string;
+  };
+  plan: {
+    name: string;
+    activated: boolean;
+    limits: {
+      memories: number;
+      secrets: number;
+    };
+  };
+  sync: {
+    memories: {
+      items: Memory[];
+      total: number;
+      has_more: boolean;
+    };
+    secrets: {
+      items: SecretListItem[];
+      total: number;
+      has_more: boolean;
+    };
+    synced_at: string;
+  };
+}