@sonde/packs 0.1.0 → 0.1.2

package/src/proxmox/probes/vm-config.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest';
+import type { ExecFn } from '../../types.js';
+import type { VmConfigResult } from './vm-config.js';
+import { parseVmConfig, vmConfig } from './vm-config.js';
+
+const SAMPLE_OUTPUT = `boot: order=scsi0;ide2;net0
+cores: 4
+ide2: none,media=cdrom
+memory: 8192
+name: web-server-01
+net0: virtio=AA:BB:CC:DD:EE:FF,bridge=vmbr0,firewall=1
+numa: 0
+ostype: l26
+scsi0: ceph-pool:vm-100-disk-0,iothread=1,size=64G
+scsihw: virtio-scsi-single
+smbios1: uuid=abc-def-123
+sockets: 1
+virtio1: local-lvm:vm-100-disk-1,size=128G`;
+
+describe('parseVmConfig', () => {
+  it('parses key: value pairs into config map', () => {
+    const result = parseVmConfig(SAMPLE_OUTPUT, 100);
+    expect(result.vmid).toBe(100);
+    expect(result.config.name).toBe('web-server-01');
+    expect(result.config.memory).toBe('8192');
+    expect(result.config.cores).toBe('4');
+  });
+
+  it('identifies disk entries with storage backend and size', () => {
+    const result = parseVmConfig(SAMPLE_OUTPUT, 100);
+    expect(result.disks).toHaveLength(2);
+
+    expect(result.disks[0]).toEqual({
+      key: 'scsi0',
+      storage: 'ceph-pool',
+      volume: 'vm-100-disk-0',
+      format: 'raw',
+      size: '64G',
+    });
+
+    expect(result.disks[1]).toEqual({
+      key: 'virtio1',
+      storage: 'local-lvm',
+      volume: 'vm-100-disk-1',
+      format: 'raw',
+      size: '128G',
+    });
+  });
+
+  it('warns about local storage disks', () => {
+    const result = parseVmConfig(SAMPLE_OUTPUT, 100);
+    expect(result.warnings).toHaveLength(1);
+    expect(result.warnings[0]).toContain('local-lvm');
+    expect(result.warnings[0]).toContain('virtio1');
+  });
+
+  it('skips non-disk config entries like net0', () => {
+    const result = parseVmConfig(SAMPLE_OUTPUT, 100);
+    const diskKeys = result.disks.map((d) => d.key);
+    expect(diskKeys).not.toContain('net0');
+  });
+
+  it('handles empty output', () => {
+    const result = parseVmConfig('', 100);
+    expect(result.config).toEqual({});
+    expect(result.disks).toHaveLength(0);
+  });
+
+  it('detects qcow2 format from filename', () => {
+    const output = 'scsi0: local:100/vm-100-disk-0.qcow2,size=32G';
+    const result = parseVmConfig(output, 100);
+    expect(result.disks[0]?.format).toBe('qcow2');
+  });
+});
+
+describe('vmConfig handler', () => {
+  it('calls qm config with vmid and returns parsed result', async () => {
+    const mockExec: ExecFn = async (cmd, args) => {
+      expect(cmd).toBe('qm');
+      expect(args).toEqual(['config', '100']);
+      return SAMPLE_OUTPUT;
+    };
+
+    const result = (await vmConfig({ vmid: 100 }, mockExec)) as VmConfigResult;
+    expect(result.vmid).toBe(100);
+    expect(result.disks).toHaveLength(2);
+  });
+
+  it('throws when vmid is missing', async () => {
+    const mockExec: ExecFn = async () => '';
+    await expect(vmConfig({}, mockExec)).rejects.toThrow('vmid parameter is required');
+  });
+});

package/src/proxmox/probes/vm-config.ts

@@ -0,0 +1,77 @@
+import type { ProbeHandler } from '../../types.js';
+
+export interface DiskEntry {
+  key: string;
+  storage: string;
+  volume: string;
+  format: string;
+  size: string;
+}
+
+export interface VmConfigResult {
+  vmid: number;
+  config: Record<string, string>;
+  disks: DiskEntry[];
+  warnings: string[];
+}
+
+/**
+ * Runs `qm config {vmid}` and parses key: value output.
+ * Identifies disk backends (scsi, ide, virtio, sata, efidisk).
+ */
+export const vmConfig: ProbeHandler = async (params, exec) => {
+  const vmid = params?.vmid as number;
+  if (vmid == null) throw new Error('vmid parameter is required');
+
+  const stdout = await exec('qm', ['config', String(vmid)]);
+  return parseVmConfig(stdout, vmid);
+};
+
+export function parseVmConfig(stdout: string, vmid: number): VmConfigResult {
+  const config: Record<string, string> = {};
+  const lines = stdout.trim().split('\n').filter(Boolean);
+
+  for (const line of lines) {
+    const colonIdx = line.indexOf(':');
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    config[key] = value;
+  }
+
+  const diskPrefixes = ['scsi', 'ide', 'virtio', 'sata', 'efidisk', 'tpmstate'];
+  const disks: DiskEntry[] = [];
+  const warnings: string[] = [];
+
+  for (const [key, value] of Object.entries(config)) {
+    const matchesDisk = diskPrefixes.some((p) => key.startsWith(p));
+    if (!matchesDisk) continue;
+
+    const colonIdx = value.indexOf(':');
+    if (colonIdx === -1) continue;
+
+    const storage = value.slice(0, colonIdx);
+    const rest = value.slice(colonIdx + 1);
+    const commaIdx = rest.indexOf(',');
+    const volume = commaIdx > -1 ? rest.slice(0, commaIdx) : rest;
+    const optsPart = commaIdx > -1 ? rest.slice(commaIdx + 1) : '';
+
+    let format = 'raw';
+    if (volume.endsWith('.qcow2')) format = 'qcow2';
+    else if (volume.endsWith('.vmdk')) format = 'vmdk';
+    else if (optsPart.includes('format=qcow2')) format = 'qcow2';
+    else if (optsPart.includes('format=vmdk')) format = 'vmdk';
+    else if (optsPart.includes('format=raw')) format = 'raw';
+
+    const sizeMatch = optsPart.match(/size=(\S+)/);
+    const size = sizeMatch?.[1] ?? '';
+
+    disks.push({ key, storage, volume, format, size });
+
+    if (storage === 'local' || storage === 'local-lvm') {
+      warnings.push(`Disk ${key} uses local storage (${storage})`);
+    }
+  }
+
+  return { vmid, config, disks, warnings };
+}

package/src/proxmox/probes/vm-locks.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from 'vitest';
+import type { ExecFn } from '../../types.js';
+import type { VmLocksResult } from './vm-locks.js';
+import { parseVmLocks, vmLocks } from './vm-locks.js';
+
+describe('parseVmLocks', () => {
+  it('parses lock files into VM lock entries', () => {
+    const stdout = `lock-100.conf
+lock-101.conf
+lock-200.conf`;
+    const result = parseVmLocks(stdout);
+    expect(result.locks).toHaveLength(3);
+    expect(result.locks[0]).toEqual({ vmid: 100, file: 'lock-100.conf' });
+    expect(result.locks[2]).toEqual({ vmid: 200, file: 'lock-200.conf' });
+  });
+
+  it('generates warning when locks exist', () => {
+    const stdout = 'lock-100.conf\nlock-101.conf';
+    const result = parseVmLocks(stdout);
+    expect(result.warnings).toHaveLength(1);
+    expect(result.warnings[0]).toContain('2 VM(s) locked');
+    expect(result.warnings[0]).toContain('100');
+    expect(result.warnings[0]).toContain('101');
+  });
+
+  it('returns empty for no lock files', () => {
+    const result = parseVmLocks('');
+    expect(result.locks).toHaveLength(0);
+    expect(result.warnings).toHaveLength(0);
+  });
+
+  it('ignores non-lock files', () => {
+    const stdout = `lock-100.conf
+readme.txt
+some-other-file`;
+    const result = parseVmLocks(stdout);
+    expect(result.locks).toHaveLength(1);
+    expect(result.locks[0]?.vmid).toBe(100);
+  });
+});
+
+describe('vmLocks handler', () => {
+  it('calls ls on the lock directory', async () => {
+    const mockExec: ExecFn = async (cmd, args) => {
+      expect(cmd).toBe('ls');
+      expect(args).toEqual(['/run/lock/qemu-server/']);
+      return 'lock-100.conf\nlock-101.conf';
+    };
+
+    const result = (await vmLocks(undefined, mockExec)) as VmLocksResult;
+    expect(result.locks).toHaveLength(2);
+  });
+
+  it('returns empty when directory does not exist', async () => {
+    const mockExec: ExecFn = async () => {
+      throw new Error('No such file or directory');
+    };
+
+    const result = (await vmLocks(undefined, mockExec)) as VmLocksResult;
+    expect(result.locks).toHaveLength(0);
+    expect(result.warnings).toHaveLength(0);
+  });
+});

package/src/proxmox/probes/vm-locks.ts

@@ -0,0 +1,49 @@
+import type { ProbeHandler } from '../../types.js';
+
+export interface VmLock {
+  vmid: number;
+  file: string;
+}
+
+export interface VmLocksResult {
+  locks: VmLock[];
+  warnings: string[];
+}
+
+/**
+ * Lists files in /run/lock/qemu-server/ to find locked VMs.
+ * Lock files are named like "lock-100.conf".
+ */
+export const vmLocks: ProbeHandler = async (_params, exec) => {
+  let stdout: string;
+  try {
+    stdout = await exec('ls', ['/run/lock/qemu-server/']);
+  } catch {
+    // Directory may not exist or be empty
+    return { locks: [], warnings: [] };
+  }
+  return parseVmLocks(stdout);
+};
+
+export function parseVmLocks(stdout: string): VmLocksResult {
+  const files = stdout.trim().split('\n').filter(Boolean);
+  const locks: VmLock[] = [];
+  const warnings: string[] = [];
+
+  for (const file of files) {
+    // Lock files are typically "lock-{vmid}.conf"
+    const match = file.match(/lock-(\d+)\.conf/);
+    if (match) {
+      const vmid = Number.parseInt(match[1] ?? '', 10);
+      if (!Number.isNaN(vmid)) {
+        locks.push({ vmid, file });
+      }
+    }
+  }
+
+  if (locks.length > 0) {
+    warnings.push(`${locks.length} VM(s) locked: ${locks.map((l) => l.vmid).join(', ')}`);
+  }
+
+  return { locks, warnings };
+}

package/src/redis/index.ts

@@ -0,0 +1,14 @@
+import type { Pack } from '../types.js';
+import { redisManifest } from './manifest.js';
+import { info } from './probes/info.js';
+import { keysCount } from './probes/keys-count.js';
+import { memoryUsage } from './probes/memory-usage.js';
+
+export const redisPack: Pack = {
+  manifest: redisManifest,
+  handlers: {
+    'redis.info': info,
+    'redis.keys.count': keysCount,
+    'redis.memory.usage': memoryUsage,
+  },
+};

package/src/redis/manifest.ts

@@ -0,0 +1,52 @@
+import type { PackManifest } from '@sonde/shared';
+
+export const redisManifest: PackManifest = {
+  name: 'redis',
+  version: '0.1.0',
+  description: 'Redis probes: server info, key count, memory usage',
+  requires: {
+    groups: [],
+    files: [],
+    commands: ['redis-cli'],
+  },
+  probes: [
+    {
+      name: 'info',
+      description: 'Get Redis server info (version, uptime, clients, memory)',
+      capability: 'observe',
+      params: {
+        host: { type: 'string', description: 'Redis host', required: false, default: '127.0.0.1' },
+        port: { type: 'number', description: 'Redis port', required: false, default: 6379 },
+      },
+      timeout: 10_000,
+    },
+    {
+      name: 'keys.count',
+      description: 'Count keys per database',
+      capability: 'observe',
+      params: {
+        host: { type: 'string', description: 'Redis host', required: false, default: '127.0.0.1' },
+        port: { type: 'number', description: 'Redis port', required: false, default: 6379 },
+      },
+      timeout: 10_000,
+    },
+    {
+      name: 'memory.usage',
+      description: 'Get Redis memory usage statistics',
+      capability: 'observe',
+      params: {
+        host: { type: 'string', description: 'Redis host', required: false, default: '127.0.0.1' },
+        port: { type: 'number', description: 'Redis port', required: false, default: 6379 },
+      },
+      timeout: 10_000,
+    },
+  ],
+  runbook: {
+    category: 'redis',
+    probes: ['info', 'memory.usage', 'keys.count'],
+    parallel: true,
+  },
+  detect: {
+    commands: ['redis-cli'],
+  },
+};

package/src/redis/probes/info.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from 'vitest';
+import type { ExecFn } from '../../types.js';
+import type { RedisInfoResult } from './info.js';
+import { info, parseRedisInfo } from './info.js';
+
+const SAMPLE_OUTPUT = `# Server
+redis_version:7.2.4
+uptime_in_seconds:86400
+# Clients
+connected_clients:42
+# Memory
+used_memory_human:12.50M
+used_memory_peak_human:15.00M
+# Stats
+total_connections_received:1500
+total_commands_processed:987654
+# Replication
+role:master`;
+
+describe('parseRedisInfo', () => {
+  it('parses key info fields', () => {
+    const result = parseRedisInfo(SAMPLE_OUTPUT);
+    expect(result.version).toBe('7.2.4');
+    expect(result.uptimeSeconds).toBe(86400);
+    expect(result.connectedClients).toBe(42);
+    expect(result.usedMemoryHuman).toBe('12.50M');
+    expect(result.usedMemoryPeakHuman).toBe('15.00M');
+    expect(result.totalConnectionsReceived).toBe(1500);
+    expect(result.totalCommandsProcessed).toBe(987654);
+    expect(result.role).toBe('master');
+  });
+
+  it('stores all key-value pairs in raw', () => {
+    const result = parseRedisInfo(SAMPLE_OUTPUT);
+    expect(result.raw['redis_version']).toBe('7.2.4');
+    expect(result.raw['role']).toBe('master');
+  });
+
+  it('handles empty output', () => {
+    const result = parseRedisInfo('');
+    expect(result.version).toBe('');
+    expect(result.uptimeSeconds).toBe(0);
+    expect(result.connectedClients).toBe(0);
+    expect(result.role).toBe('');
+  });
+});
+
+describe('info handler', () => {
+  it('calls redis-cli with default host/port', async () => {
+    const mockExec: ExecFn = async (cmd, args) => {
+      expect(cmd).toBe('redis-cli');
+      expect(args).toContain('-h');
+      expect(args).toContain('127.0.0.1');
+      expect(args).toContain('-p');
+      expect(args).toContain('6379');
+      expect(args).toContain('INFO');
+      return SAMPLE_OUTPUT;
+    };
+
+    const result = (await info(undefined, mockExec)) as RedisInfoResult;
+    expect(result.version).toBe('7.2.4');
+  });
+
+  it('passes custom host/port', async () => {
+    const mockExec: ExecFn = async (cmd, args) => {
+      expect(args).toContain('redis.example.com');
+      expect(args).toContain('6380');
+      return SAMPLE_OUTPUT;
+    };
+
+    await info({ host: 'redis.example.com', port: 6380 }, mockExec);
+  });
+});

package/src/redis/probes/info.ts

@@ -0,0 +1,46 @@
+import type { ProbeHandler } from '../../types.js';
+
+export interface RedisInfoResult {
+  version: string;
+  uptimeSeconds: number;
+  connectedClients: number;
+  usedMemoryHuman: string;
+  usedMemoryPeakHuman: string;
+  totalConnectionsReceived: number;
+  totalCommandsProcessed: number;
+  role: string;
+  raw: Record<string, string>;
+}
+
+export const info: ProbeHandler = async (params, exec) => {
+  const host = (params?.host as string) ?? '127.0.0.1';
+  const port = String((params?.port as number) ?? 6379);
+
+  const stdout = await exec('redis-cli', ['-h', host, '-p', port, 'INFO']);
+  return parseRedisInfo(stdout);
+};
+
+export function parseRedisInfo(stdout: string): RedisInfoResult {
+  const raw: Record<string, string> = {};
+  for (const line of stdout.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const colonIdx = trimmed.indexOf(':');
+    if (colonIdx === -1) continue;
+    const key = trimmed.slice(0, colonIdx);
+    const value = trimmed.slice(colonIdx + 1);
+    raw[key] = value;
+  }
+
+  return {
+    version: raw['redis_version'] ?? '',
+    uptimeSeconds: Number(raw['uptime_in_seconds']) || 0,
+    connectedClients: Number(raw['connected_clients']) || 0,
+    usedMemoryHuman: raw['used_memory_human'] ?? '',
+    usedMemoryPeakHuman: raw['used_memory_peak_human'] ?? '',
+    totalConnectionsReceived: Number(raw['total_connections_received']) || 0,
+    totalCommandsProcessed: Number(raw['total_commands_processed']) || 0,
+    role: raw['role'] ?? '',
+    raw,
+  };
+}

package/src/redis/probes/keys-count.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest';
+import type { ExecFn } from '../../types.js';
+import type { KeysCountResult } from './keys-count.js';
+import { keysCount, parseKeysCount } from './keys-count.js';
+
+const SAMPLE_OUTPUT = `# Keyspace
+db0:keys=1234,expires=100,avg_ttl=5000
+db1:keys=567,expires=50,avg_ttl=3000`;
+
+describe('parseKeysCount', () => {
+  it('parses keyspace databases', () => {
+    const result = parseKeysCount(SAMPLE_OUTPUT);
+    expect(result.databases).toHaveLength(2);
+    expect(result.databases[0]).toEqual({ db: 0, keys: 1234, expires: 100 });
+    expect(result.databases[1]).toEqual({ db: 1, keys: 567, expires: 50 });
+    expect(result.totalKeys).toBe(1801);
+  });
+
+  it('handles empty output', () => {
+    const result = parseKeysCount('');
+    expect(result.databases).toEqual([]);
+    expect(result.totalKeys).toBe(0);
+  });
+
+  it('handles only header line', () => {
+    const result = parseKeysCount('# Keyspace\n');
+    expect(result.databases).toEqual([]);
+    expect(result.totalKeys).toBe(0);
+  });
+});
+
+describe('keysCount handler', () => {
+  it('calls redis-cli INFO keyspace', async () => {
+    const mockExec: ExecFn = async (cmd, args) => {
+      expect(cmd).toBe('redis-cli');
+      expect(args).toContain('INFO');
+      expect(args).toContain('keyspace');
+      return SAMPLE_OUTPUT;
+    };
+
+    const result = (await keysCount(undefined, mockExec)) as KeysCountResult;
+    expect(result.totalKeys).toBe(1801);
+  });
+});

package/src/redis/probes/keys-count.ts

@@ -0,0 +1,38 @@
+import type { ProbeHandler } from '../../types.js';
+
+export interface DbKeyCount {
+  db: number;
+  keys: number;
+  expires: number;
+}
+
+export interface KeysCountResult {
+  databases: DbKeyCount[];
+  totalKeys: number;
+}
+
+export const keysCount: ProbeHandler = async (params, exec) => {
+  const host = (params?.host as string) ?? '127.0.0.1';
+  const port = String((params?.port as number) ?? 6379);
+
+  const stdout = await exec('redis-cli', ['-h', host, '-p', port, 'INFO', 'keyspace']);
+  return parseKeysCount(stdout);
+};
+
+export function parseKeysCount(stdout: string): KeysCountResult {
+  const databases: DbKeyCount[] = [];
+  for (const line of stdout.split('\n')) {
+    const trimmed = line.trim();
+    // Lines like: db0:keys=123,expires=10,avg_ttl=0
+    const match = trimmed.match(/^db(\d+):keys=(\d+),expires=(\d+)/);
+    if (match) {
+      databases.push({
+        db: Number(match[1]),
+        keys: Number(match[2]),
+        expires: Number(match[3]),
+      });
+    }
+  }
+  const totalKeys = databases.reduce((sum, d) => sum + d.keys, 0);
+  return { databases, totalKeys };
+}

package/src/redis/probes/memory-usage.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest';
+import type { ExecFn } from '../../types.js';
+import type { MemoryUsageResult } from './memory-usage.js';
+import { memoryUsage, parseMemoryUsage } from './memory-usage.js';
+
+const SAMPLE_OUTPUT = `# Memory
+used_memory:13107200
+used_memory_human:12.50M
+used_memory_peak:15728640
+used_memory_peak_human:15.00M
+used_memory_rss:16777216
+used_memory_rss_human:16.00M
+mem_fragmentation_ratio:1.28
+maxmemory:0
+maxmemory_human:0B
+maxmemory_policy:noeviction`;
+
+describe('parseMemoryUsage', () => {
+  it('parses memory fields', () => {
+    const result = parseMemoryUsage(SAMPLE_OUTPUT);
+    expect(result.usedMemory).toBe(13107200);
+    expect(result.usedMemoryHuman).toBe('12.50M');
+    expect(result.usedMemoryPeak).toBe(15728640);
+    expect(result.usedMemoryPeakHuman).toBe('15.00M');
+    expect(result.usedMemoryRss).toBe(16777216);
+    expect(result.usedMemoryRssHuman).toBe('16.00M');
+    expect(result.memFragmentationRatio).toBe(1.28);
+    expect(result.maxmemory).toBe(0);
+    expect(result.maxmemoryHuman).toBe('0B');
+    expect(result.maxmemoryPolicy).toBe('noeviction');
+  });
+
+  it('handles empty output', () => {
+    const result = parseMemoryUsage('');
+    expect(result.usedMemory).toBe(0);
+    expect(result.usedMemoryHuman).toBe('');
+    expect(result.memFragmentationRatio).toBe(0);
+    expect(result.maxmemoryPolicy).toBe('');
+  });
+});
+
+describe('memoryUsage handler', () => {
+  it('calls redis-cli INFO memory', async () => {
+    const mockExec: ExecFn = async (cmd, args) => {
+      expect(cmd).toBe('redis-cli');
+      expect(args).toContain('INFO');
+      expect(args).toContain('memory');
+      return SAMPLE_OUTPUT;
+    };
+
+    const result = (await memoryUsage(undefined, mockExec)) as MemoryUsageResult;
+    expect(result.usedMemory).toBe(13107200);
+  });
+});

package/src/redis/probes/memory-usage.ts

@@ -0,0 +1,46 @@
+import type { ProbeHandler } from '../../types.js';
+
+export interface MemoryUsageResult {
+  usedMemory: number;
+  usedMemoryHuman: string;
+  usedMemoryPeak: number;
+  usedMemoryPeakHuman: string;
+  usedMemoryRss: number;
+  usedMemoryRssHuman: string;
+  memFragmentationRatio: number;
+  maxmemory: number;
+  maxmemoryHuman: string;
+  maxmemoryPolicy: string;
+}
+
+export const memoryUsage: ProbeHandler = async (params, exec) => {
+  const host = (params?.host as string) ?? '127.0.0.1';
+  const port = String((params?.port as number) ?? 6379);
+
+  const stdout = await exec('redis-cli', ['-h', host, '-p', port, 'INFO', 'memory']);
+  return parseMemoryUsage(stdout);
+};
+
+export function parseMemoryUsage(stdout: string): MemoryUsageResult {
+  const kv: Record<string, string> = {};
+  for (const line of stdout.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const colonIdx = trimmed.indexOf(':');
+    if (colonIdx === -1) continue;
+    kv[trimmed.slice(0, colonIdx)] = trimmed.slice(colonIdx + 1);
+  }
+
+  return {
+    usedMemory: Number(kv['used_memory']) || 0,
+    usedMemoryHuman: kv['used_memory_human'] ?? '',
+    usedMemoryPeak: Number(kv['used_memory_peak']) || 0,
+    usedMemoryPeakHuman: kv['used_memory_peak_human'] ?? '',
+    usedMemoryRss: Number(kv['used_memory_rss']) || 0,
+    usedMemoryRssHuman: kv['used_memory_rss_human'] ?? '',
+    memFragmentationRatio: Number.parseFloat(kv['mem_fragmentation_ratio'] ?? '0'),
+    maxmemory: Number(kv['maxmemory']) || 0,
+    maxmemoryHuman: kv['maxmemory_human'] ?? '',
+    maxmemoryPolicy: kv['maxmemory_policy'] ?? '',
+  };
+}