mova_agent 0.1.1

package/src/episodes/episode_writer_atomic.ts

@@ -0,0 +1,44 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * Atomically writes an episode file with backup preservation.
+ * Steps:
+ * 1) Serialize data to JSON.
+ * 2) Write to <target>.tmp.
+ * 3) If <target> exists, copy it to episodes/_backup/<timestamp>_<basename>.bak.
+ * 4) Rename tmp to target (atomic replace).
+ */
+export async function writeEpisodeAtomic(targetPath: string, data: any): Promise<void> {
+  const serialized = JSON.stringify(data, null, 2);
+  const tempPath = `${targetPath}.tmp`;
+  const dir = path.dirname(targetPath);
+  const backupDir = path.join(dir, '_backup');
+  const baseName = path.basename(targetPath);
+  const backupName = `${Date.now()}_${baseName}.bak`;
+  const backupPath = path.join(backupDir, backupName);
+
+  await fs.ensureDir(dir);
+  await fs.ensureDir(backupDir);
+
+  const originalExists = await fs.pathExists(targetPath);
+
+  try {
+    await fs.writeFile(tempPath, serialized, { encoding: 'utf8' });
+
+    if (originalExists) {
+      // Keep original intact in case rename fails
+      await fs.copyFile(targetPath, backupPath);
+    }
+
+    // Replace original with temp atomically
+    await fs.rename(tempPath, targetPath);
+  } catch (error) {
+    // Clean up temp file if it was written
+    if (await fs.pathExists(tempPath)) {
+      await fs.remove(tempPath);
+    }
+    // If something went wrong before rename, ensure original stays
+    throw error;
+  }
+}

package/src/evidence/evidence_writer.ts

@@ -0,0 +1,74 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+class EvidenceWriter {
+  /**
+   * Создает директорию для улик выполнения
+   */
+  async createRunDirectory(requestId: string, runId: string): Promise<string> {
+    try {
+      const evidenceDir = path.join('artifacts', 'mova_agent', requestId, 'runs', runId);
+      await fs.ensureDir(evidenceDir);
+      return evidenceDir;
+    } catch (error: any) {
+      throw new Error(`Failed to create evidence directory: ${error.message}`);
+    }
+  }
+
+  /**
+   * Записывает артефакт в директорию улик
+   */
+  async writeArtifact(evidenceDir: string, filename: string, data: any): Promise<void> {
+    try {
+      // Делаем редактирование чувствительных данных перед записью
+      const sanitizedData = this.sanitizeData(data);
+      const filePath = path.join(evidenceDir, filename);
+      await fs.ensureDir(path.dirname(filePath));
+      await fs.writeJson(filePath, sanitizedData, { spaces: 2 });
+    } catch (error: any) {
+      throw new Error(`Failed to write artifact ${filename}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Удаляет чувствительные данные перед записью
+   */
+  private sanitizeData(data: any): any {
+    if (!data || typeof data !== 'object') {
+      return data;
+    }
+
+    // Рекурсивная очистка данных
+    const result = Array.isArray(data) ? [] : {};
+
+    for (const [key, value] of Object.entries(data)) {
+      // Проверяем, является ли ключ потенциально чувствительным
+      const lowerKey = key.toLowerCase();
+      if (
+        lowerKey.includes('password') ||
+        lowerKey.includes('secret') ||
+        lowerKey.includes('token') ||
+        lowerKey.includes('key') ||
+        lowerKey.includes('auth')
+      ) {
+        // Заменяем чувствительные данные на маскированное представление
+        if (typeof value === 'string') {
+          (result as any)[key] = `*** REDACTED (length=${value.length}) ***`;
+        } else if (typeof value === 'object') {
+          (result as any)[key] = `*** REDACTED (object) ***`;
+        } else {
+          (result as any)[key] = `*** REDACTED ***`;
+        }
+      } else if (typeof value === 'object' && value !== null) {
+        // Рекурсивно очищаем вложенные объекты
+        (result as any)[key] = this.sanitizeData(value);
+      } else {
+        (result as any)[key] = value;
+      }
+    }
+
+    return result;
+  }
+}
+
+export { EvidenceWriter };

package/src/handlers/registry.ts

@@ -0,0 +1,53 @@
+import { getDriver } from '../drivers';
+
+// Тип для контекста выполнения
+export interface ExecutionContext {
+  run_id: string;
+  request_id: string;
+  evidence_dir: string;
+  caps?: any;
+  redaction_rules?: string[];
+  step_outputs: Map<string, any>;
+}
+
+// Тип для обработчика
+export type HandlerFunction = (input: any, tool: any, context: ExecutionContext) => Promise<any>;
+
+class HandlerRegistryClass {
+  private handlers: { [key: string]: HandlerFunction } = {};
+
+  constructor() {
+    this.handlers = {
+      noop: this.buildHandler('noop'),
+      http: this.buildHandler('http'),
+      restricted_shell: this.buildHandler('restricted_shell'),
+    };
+  }
+
+  private buildHandler(driverName: string): HandlerFunction {
+    return async (input, tool, _context) => {
+      const driver = getDriver(driverName);
+      return driver.execute(input, {
+        driverName,
+        allowlist: tool?.binding?.destination_allowlist,
+        limits: tool?.binding?.limits,
+        bindings: tool?.binding,
+      });
+    };
+  }
+
+  getInstance(): { [key: string]: HandlerFunction } {
+    return new Proxy(this.handlers, {
+      get: (target, prop: string) => {
+        if (!target[prop]) {
+          target[prop] = this.buildHandler(prop);
+        }
+        return target[prop];
+      },
+    });
+  }
+}
+
+const registryInstance = new HandlerRegistryClass();
+
+export { registryInstance as HandlerRegistry };