@dambrogia/openclaw-agents-backup 0.1.0

package/tests/restore.test.ts

@@ -0,0 +1,167 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import { performRestore } from '../src/restore';
+import { AgentArchiveMetadata } from '../src/types';
+
+describe('Restore', () => {
+  let testBackupRepo: string;
+  let testRestorePath: string;
+  const originalEnv = process.env.BACKUP_ENCRYPTION_PASSWORD;
+
+  beforeEach(() => {
+    testBackupRepo = `/tmp/test-backup-restore-${Date.now()}`;
+    testRestorePath = `/tmp/test-restore-path-${Date.now()}`;
+
+    fs.mkdirSync(testBackupRepo, { recursive: true });
+    fs.mkdirSync(testRestorePath, { recursive: true });
+
+    // Set encryption password for tests
+    process.env.BACKUP_ENCRYPTION_PASSWORD = 'test-password-12345';
+  });
+
+  afterAll(() => {
+    // Restore original env
+    if (originalEnv) {
+      process.env.BACKUP_ENCRYPTION_PASSWORD = originalEnv;
+    } else {
+      delete process.env.BACKUP_ENCRYPTION_PASSWORD;
+    }
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(testBackupRepo)) {
+      fs.rmSync(testBackupRepo, { recursive: true });
+    }
+    if (fs.existsSync(testRestorePath)) {
+      fs.rmSync(testRestorePath, { recursive: true });
+    }
+  });
+
+  describe('performRestore', () => {
+    it('should fail if backup repo does not exist', async () => {
+      const result = await performRestore('/nonexistent/backup', null, testRestorePath);
+      expect(result.success).toBe(false);
+      expect(result.message).toContain('not found');
+    });
+
+    it('should fail if archives directory does not exist', async () => {
+      const result = await performRestore(testBackupRepo, null, testRestorePath);
+      expect(result.success).toBe(false);
+      expect(result.message).toContain('Archives directory not found');
+    });
+
+    it('should return zero agents restored if no agent archives exist', async () => {
+      fs.mkdirSync(path.join(testBackupRepo, 'archives'), { recursive: true });
+      const result = await performRestore(testBackupRepo, null, testRestorePath);
+      expect(result.success).toBe(true);
+      expect(result.agentsRestored).toBe(0);
+    });
+
+    it('should handle restore when agent metadata is present', async () => {
+      const archivesPath = path.join(testBackupRepo, 'archives');
+      const agentPath = path.join(archivesPath, 'test-agent');
+      const workspacePath = path.join(agentPath, 'workspace');
+
+      fs.mkdirSync(workspacePath, { recursive: true });
+
+      // Create minimal agent metadata
+      const metadata: AgentArchiveMetadata = {
+        id: 'test-agent',
+        identityName: 'test-identity',
+        identityEmoji: '⚙️',
+        identitySource: 'identity',
+        workspace: path.join(testRestorePath, 'workspace'),
+        agentDir: path.join(testRestorePath, 'agentDir'),
+        model: 'test-model',
+        bindings: 0,
+        isDefault: false,
+        routes: [],
+        backedUpAt: new Date().toISOString()
+      };
+
+      fs.writeFileSync(
+        path.join(agentPath, 'agent.json'),
+        JSON.stringify(metadata, null, 2)
+      );
+
+      const result = await performRestore(testBackupRepo, null, testRestorePath);
+      expect(result.success).toBe(true);
+      expect(result.agentsRestored).toBe(1);
+    });
+
+    it('should warn when auth-profiles.json exists in backup and confirmAuthOverwrite is false', async () => {
+      const archivesPath = path.join(testBackupRepo, 'archives');
+      const agentPath = path.join(archivesPath, 'test-agent');
+      const agentDirPath = path.join(agentPath, 'agentDir', 'agent');
+      const workspacePath = path.join(agentPath, 'workspace');
+
+      fs.mkdirSync(workspacePath, { recursive: true });
+      fs.mkdirSync(agentDirPath, { recursive: true });
+
+      // Create auth-profiles.json in the backup
+      fs.writeFileSync(path.join(agentDirPath, 'auth-profiles.json'), '{"key": "secret"}');
+
+      // Create minimal agent metadata
+      const metadata: AgentArchiveMetadata = {
+        id: 'test-agent',
+        identityName: 'test-identity',
+        identityEmoji: '⚙️',
+        identitySource: 'identity',
+        workspace: path.join(testRestorePath, 'workspace'),
+        agentDir: path.join(testRestorePath, 'agentDir'),
+        model: 'test-model',
+        bindings: 0,
+        isDefault: false,
+        routes: [],
+        backedUpAt: new Date().toISOString()
+      };
+
+      fs.writeFileSync(
+        path.join(agentPath, 'agent.json'),
+        JSON.stringify(metadata, null, 2)
+      );
+
+      const result = await performRestore(testBackupRepo, null, testRestorePath, false);
+      expect(result.success).toBe(false);
+      expect(result.authOverwriteWarning).toBe(true);
+      expect(result.message).toContain('auth-profiles.json');
+    });
+
+    it('should allow restore when auth-profiles.json exists and confirmAuthOverwrite is true', async () => {
+      const archivesPath = path.join(testBackupRepo, 'archives');
+      const agentPath = path.join(archivesPath, 'test-agent');
+      const agentDirPath = path.join(agentPath, 'agentDir', 'agent');
+      const workspacePath = path.join(agentPath, 'workspace');
+
+      fs.mkdirSync(workspacePath, { recursive: true });
+      fs.mkdirSync(agentDirPath, { recursive: true });
+
+      // Create auth-profiles.json in the backup
+      fs.writeFileSync(path.join(agentDirPath, 'auth-profiles.json'), '{"key": "secret"}');
+
+      // Create minimal agent metadata
+      const metadata: AgentArchiveMetadata = {
+        id: 'test-agent',
+        identityName: 'test-identity',
+        identityEmoji: '⚙️',
+        identitySource: 'identity',
+        workspace: path.join(testRestorePath, 'workspace'),
+        agentDir: path.join(testRestorePath, 'agentDir'),
+        model: 'test-model',
+        bindings: 0,
+        isDefault: false,
+        routes: [],
+        backedUpAt: new Date().toISOString()
+      };
+
+      fs.writeFileSync(
+        path.join(agentPath, 'agent.json'),
+        JSON.stringify(metadata, null, 2)
+      );
+
+      const result = await performRestore(testBackupRepo, null, testRestorePath, true);
+      expect(result.success).toBe(true);
+      expect(result.agentsRestored).toBe(1);
+    });
+  });
+});

package/tests/utils.test.ts

@@ -0,0 +1,51 @@
+import { getCurrentTimestamp, pathExists, ensureDirectoryExists } from '../src/utils';
+import * as fs from 'fs';
+
+describe('Utils', () => {
+  describe('getCurrentTimestamp', () => {
+    it('should return ISO formatted timestamp', () => {
+      const timestamp = getCurrentTimestamp();
+      expect(timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
+    });
+
+    it('should return a valid date', () => {
+      const timestamp = getCurrentTimestamp();
+      const date = new Date(timestamp);
+      expect(date).toBeInstanceOf(Date);
+      expect(date.getTime()).toBeLessThanOrEqual(Date.now());
+    });
+  });
+
+  describe('pathExists', () => {
+    it('should return true for existing path', () => {
+      expect(pathExists(__filename)).toBe(true);
+    });
+
+    it('should return false for non-existing path', () => {
+      expect(pathExists('/nonexistent/path/to/file')).toBe(false);
+    });
+  });
+
+  describe('ensureDirectoryExists', () => {
+    it('should create directory if it does not exist', () => {
+      const testDir = `/tmp/test-dir-${Date.now()}`;
+      ensureDirectoryExists(testDir);
+      expect(fs.existsSync(testDir)).toBe(true);
+      fs.rmSync(testDir, { recursive: true });
+    });
+
+    it('should not fail if directory already exists', () => {
+      const testDir = `/tmp/test-dir-existing-${Date.now()}`;
+      fs.mkdirSync(testDir);
+      expect(() => ensureDirectoryExists(testDir)).not.toThrow();
+      fs.rmSync(testDir, { recursive: true });
+    });
+
+    it('should create nested directories', () => {
+      const testDir = `/tmp/test/nested/dir-${Date.now()}`;
+      ensureDirectoryExists(testDir);
+      expect(fs.existsSync(testDir)).toBe(true);
+      fs.rmSync('/tmp/test', { recursive: true });
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}