agentmemory-cli 1.1.0 → 1.3.0

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;
+  };
+}