@mondaydotcomorg/atp-server 0.17.14

package/src/instrumentation/state-manager.ts

@@ -0,0 +1,237 @@
+/**
+ * State Manager for Execution State Capture and Restoration
+ */
+import type { CacheProvider } from '@mondaydotcomorg/atp-protocol';
+import { log } from '@mondaydotcomorg/atp-runtime';
+import { Serializer } from './serializer.js';
+import type { ExecutionState, StatementState, SerializedValue, BranchDecision } from './types.js';
+
+export class StateManager {
+	private state: ExecutionState;
+	private resumeMode: boolean = false;
+	private serializer: Serializer;
+	private captureInterval: number;
+	private statementCounter: number = 0;
+
+	constructor(
+		private executionId: string,
+		private clientId: string,
+		private cache: CacheProvider | undefined,
+		private logger: ReturnType<typeof log.child>,
+		options?: { captureInterval?: number }
+	) {
+		this.serializer = new Serializer();
+		this.captureInterval = options?.captureInterval || 10;
+
+		this.state = {
+			executionId,
+			clientId,
+			currentStatementId: -1,
+			statements: [],
+			variables: [],
+			controlFlow: [],
+		};
+	}
+
+	/**
+	 * Capture state at a statement boundary
+	 * In resume mode, skip already-executed statements
+	 */
+	async capture(statementId: number, getVars: () => Record<string, unknown>): Promise<void> {
+		this.logger.debug('State capture', { statementId, resumeMode: this.resumeMode });
+
+		if (this.resumeMode) {
+			const cached = this.findStatement(statementId);
+			if (cached) {
+				this.logger.debug('Skipping cached statement', { statementId });
+				return;
+			}
+		}
+
+		const vars = getVars();
+		const serializedVars: Record<string, SerializedValue> = {};
+
+		for (const [name, value] of Object.entries(vars)) {
+			try {
+				serializedVars[name] = this.serializer.serialize(value, vars);
+			} catch (e) {
+				this.logger.warn('Failed to serialize variable', { name, error: e });
+			}
+		}
+
+		const statementState: StatementState = {
+			id: statementId,
+			executed: true,
+			variables: serializedVars,
+			timestamp: Date.now(),
+		};
+
+		this.state.statements.push([statementId, statementState]);
+		this.state.currentStatementId = statementId;
+		this.statementCounter++;
+
+		if (this.cache && this.statementCounter % this.captureInterval === 0) {
+			await this.persist();
+		}
+	}
+
+	/**
+	 * Wrap external calls with caching
+	 */
+	async call<T>(statementId: number, fn: () => T | Promise<T>): Promise<T> {
+		if (this.resumeMode) {
+			const cached = this.findStatement(statementId);
+			if (cached && cached.result !== undefined) {
+				this.logger.debug('Using cached call result', { statementId });
+				return this.serializer.deserialize(cached.result) as T;
+			}
+		}
+
+		this.logger.debug('Executing call', { statementId });
+		const result = await fn();
+
+		try {
+			const serialized = this.serializer.serialize(result);
+			const statement = this.findStatement(statementId);
+			if (statement) {
+				statement.result = serialized;
+			}
+		} catch (e) {
+			this.logger.warn('Failed to serialize call result', { statementId });
+		}
+
+		if (this.cache) {
+			await this.persist();
+		}
+
+		return result;
+	}
+
+	/**
+	 * Track control flow branches
+	 */
+	branch(statementId: number, condition: boolean): boolean {
+		this.logger.debug('Branch decision', { statementId, condition });
+
+		if (this.resumeMode) {
+			const cached = this.state.controlFlow.find((b) => b.statementId === statementId);
+			if (cached) {
+				this.logger.debug('Using cached branch decision', {
+					statementId,
+					decision: cached.taken,
+				});
+				return cached.taken;
+			}
+		}
+
+		const decision: BranchDecision = {
+			statementId,
+			taken: condition,
+			timestamp: Date.now(),
+		};
+		this.state.controlFlow.push(decision);
+
+		return condition;
+	}
+
+	/**
+	 * Persist state to cache
+	 */
+	/**
+	 * Persist current execution state to cache
+	 */
+	async persist(): Promise<void> {
+		if (!this.cache) return;
+
+		const key = this.getCacheKey();
+
+		try {
+			await this.cache.set(key, this.state, 3600);
+
+			this.logger.debug('State persisted', {
+				executionId: this.executionId,
+				statements: this.state.statements.length,
+			});
+		} catch (e) {
+			this.logger.error('Failed to persist state', { error: e });
+		}
+	}
+
+	/**
+	 * Load state for resume
+	 */
+	async loadForResume(executionId: string): Promise<boolean> {
+		if (!this.cache) {
+			this.logger.warn('Cannot load state: no cache provider');
+			return false;
+		}
+
+		const key = `execution-state:${this.clientId}:${executionId}`;
+
+		try {
+			const persisted = await this.cache.get<ExecutionState>(key);
+
+			if (!persisted) {
+				this.logger.warn('No persisted state found', { executionId });
+				return false;
+			}
+
+			this.state = persisted;
+			this.resumeMode = true;
+
+			this.logger.info('State loaded for resume', {
+				executionId,
+				statements: this.state.statements.length,
+				currentStatement: this.state.currentStatementId,
+			});
+
+			return true;
+		} catch (e) {
+			this.logger.error('Failed to load state', { error: e });
+			return false;
+		}
+	}
+
+	/**
+	 * Cleanup state from cache
+	 */
+	async cleanup(): Promise<void> {
+		if (!this.cache) return;
+
+		const key = this.getCacheKey();
+
+		try {
+			await this.cache.delete(key);
+			this.logger.debug('State cleaned up', { executionId: this.executionId });
+		} catch (e) {
+			this.logger.warn('Failed to cleanup state', { error: e });
+		}
+	}
+
+	/**
+	 * Get execution progress
+	 */
+	getProgress(): number {
+		if (this.state.statements.length === 0) return 0;
+		return (this.state.currentStatementId / this.state.statements.length) * 100;
+	}
+
+	/**
+	 * Get statistics
+	 */
+	getStats(): { statementsExecuted: number; statementsCached: number } {
+		return {
+			statementsExecuted: this.state.statements.length,
+			statementsCached: this.resumeMode ? this.state.statements.length : 0,
+		};
+	}
+
+	private findStatement(id: number): StatementState | undefined {
+		const entry = this.state.statements.find(([sid]) => sid === id);
+		return entry ? entry[1] : undefined;
+	}
+
+	private getCacheKey(): string {
+		return `execution-state:${this.clientId}:${this.executionId}`;
+	}
+}

package/src/instrumentation/transformer.ts

@@ -0,0 +1,84 @@
+/**
+ * Code Instrumentation Engine
+ */
+import { parse } from '@babel/parser';
+import traverse from '@babel/traverse';
+import generate from '@babel/generator';
+import * as t from '@babel/types';
+import type { InstrumentedCode, InstrumentationMetadata } from './types.js';
+
+export class CodeInstrumentor {
+	private statementId = 0;
+
+	/**
+	 * Instrument code with state capture calls
+	 */
+	instrument(code: string): InstrumentedCode {
+		this.statementId = 0;
+
+		const ast = parse(code, {
+			sourceType: 'module',
+			plugins: ['typescript'],
+			allowAwaitOutsideFunction: true,
+			allowReturnOutsideFunction: true,
+		});
+
+		const metadata: InstrumentationMetadata = {
+			statements: [],
+			variables: new Set(),
+			functions: [],
+		};
+
+		traverse(ast, {
+			VariableDeclaration: (path) => {
+				path.node.declarations.forEach((decl) => {
+					if (t.isIdentifier(decl.id)) {
+						metadata.variables.add(decl.id.name);
+					}
+				});
+			},
+
+			FunctionDeclaration: (path) => {
+				if (path.node.id) {
+					metadata.functions.push({
+						name: path.node.id.name,
+						line: path.node.loc?.start.line,
+					});
+				}
+			},
+
+			Statement: (path) => {
+				if (
+					t.isFunctionDeclaration(path.node) ||
+					t.isClassDeclaration(path.node) ||
+					t.isImportDeclaration(path.node) ||
+					t.isExportDeclaration(path.node) ||
+					path.node.type.includes('Export')
+				) {
+					return;
+				}
+
+				if (t.isBlockStatement(path.parent) && path.key !== 'body') {
+					return;
+				}
+
+				const id = this.statementId++;
+
+				metadata.statements.push({
+					id,
+					line: path.node.loc?.start.line,
+					type: path.node.type,
+				});
+			},
+		});
+
+		const result = generate(ast, {
+			sourceMaps: false,
+		});
+
+		return {
+			code: result.code,
+			metadata,
+		};
+	}
+}

package/src/instrumentation/types.ts

@@ -0,0 +1,76 @@
+/**
+ * Types for code instrumentation and state capture system
+ */
+
+export interface InstrumentationMetadata {
+	statements: StatementMetadata[];
+	variables: Set<string>;
+	functions: FunctionMetadata[];
+}
+
+export interface StatementMetadata {
+	id: number;
+	line?: number;
+	type: string;
+}
+
+export interface FunctionMetadata {
+	name: string;
+	line?: number;
+}
+
+export interface InstrumentedCode {
+	code: string;
+	sourceMap?: any;
+	metadata: InstrumentationMetadata;
+}
+
+export interface SerializedValue {
+	type:
+		| 'primitive'
+		| 'object'
+		| 'array'
+		| 'function'
+		| 'date'
+		| 'regexp'
+		| 'map'
+		| 'set'
+		| 'circular'
+		| 'nonserializable';
+	value?: unknown;
+	className?: string;
+	properties?: Record<string, SerializedValue>;
+	source?: string;
+	closure?: Record<string, SerializedValue>;
+	isAsync?: boolean;
+	isGenerator?: boolean;
+	isArrow?: boolean;
+	pattern?: string;
+	flags?: string;
+	entries?: Array<[SerializedValue, SerializedValue]>;
+	items?: SerializedValue[];
+	refId?: string;
+}
+
+export interface ExecutionState {
+	executionId: string;
+	clientId: string;
+	currentStatementId: number;
+	statements: Array<[number, StatementState]>;
+	variables: Array<[string, SerializedValue]>;
+	controlFlow: BranchDecision[];
+}
+
+export interface StatementState {
+	id: number;
+	executed: boolean;
+	variables: Record<string, SerializedValue>;
+	result?: SerializedValue;
+	timestamp: number;
+}
+
+export interface BranchDecision {
+	statementId: number;
+	taken: boolean;
+	timestamp: number;
+}

package/src/middleware/audit.ts

@@ -0,0 +1,101 @@
+import type { AuditSink, AuditEvent } from '@mondaydotcomorg/atp-protocol';
+import { log } from '@mondaydotcomorg/atp-runtime';
+
+export interface AuditConfig {
+	enabled: boolean;
+	sinks?: AuditSink | AuditSink[];
+}
+
+interface AuditExecutionOptions {
+	executionId?: string;
+	apiKey?: string;
+	ip?: string;
+	code: string;
+	result: any;
+}
+
+let auditQueue: AuditEvent[] = [];
+let flushTimer: NodeJS.Timeout | null = null;
+let auditSinks: AuditSink[] = [];
+let isShutdown = false;
+
+const FLUSH_INTERVAL = 5000;
+const MAX_QUEUE_SIZE = 100;
+
+export function initAudit(sinks?: AuditSink | AuditSink[]): void {
+	if (sinks) {
+		auditSinks = Array.isArray(sinks) ? sinks : [sinks];
+	}
+	isShutdown = false;
+	startFlushTimer();
+}
+
+export async function auditExecution(options: AuditExecutionOptions): Promise<void> {
+	if (isShutdown || auditSinks.length === 0) {
+		return;
+	}
+
+	const event: AuditEvent = {
+		eventId: options.executionId || `exec_${Date.now()}`,
+		timestamp: Date.now(),
+		clientId: options.apiKey || 'anonymous',
+		eventType: 'execution',
+		action: 'complete',
+		code: options.code,
+		status: options.result.status === 'completed' ? 'success' : 'failed',
+		resourceId: options.executionId,
+		metadata: {
+			ip: options.ip,
+			result: options.result,
+		},
+	};
+
+	auditQueue.push(event);
+
+	if (auditQueue.length >= MAX_QUEUE_SIZE) {
+		await flushAuditQueue();
+	}
+}
+
+export async function flushAuditQueue(): Promise<void> {
+	if (auditQueue.length === 0 || auditSinks.length === 0) {
+		return;
+	}
+
+	const events = [...auditQueue];
+	auditQueue = [];
+
+	try {
+		await Promise.all(
+			auditSinks.map(async (sink) => {
+				if (sink.writeBatch) {
+					await sink.writeBatch(events);
+				} else {
+					await Promise.all(events.map((event) => sink.write(event)));
+				}
+			})
+		);
+	} catch (error) {
+		log.error('Failed to flush audit queue', { error });
+	}
+}
+
+function startFlushTimer(): void {
+	if (flushTimer) {
+		clearInterval(flushTimer);
+	}
+	flushTimer = setInterval(() => {
+		flushAuditQueue().catch((error) => {
+			log.error('Failed to flush audit queue on timer', { error });
+		});
+	}, FLUSH_INTERVAL);
+}
+
+export function shutdownAudit(): void {
+	isShutdown = true;
+	if (flushTimer) {
+		clearInterval(flushTimer);
+		flushTimer = null;
+	}
+	auditSinks = [];
+}