gnoman 0.1.0

package/backend/controllers/contractController.ts

@@ -0,0 +1,49 @@
+import asyncHandler from 'express-async-handler';
+import type { Request, Response } from 'express';
+import { addContract, listContracts, removeContract } from '../services/contractRegistryService';
+import { abiResolver } from '../utils/abiResolver';
+import { getBalance } from '../services/rpcService';
+
+export const listContractsHandler = asyncHandler(async (_req: Request, res: Response) => {
+  const records = listContracts();
+  const balances = await Promise.all(records.map((record) => getBalance(record.address)));
+  res.json(
+    records.map((record, index) => ({
+      ...record,
+      balance: balances[index]
+    }))
+  );
+});
+
+export const addContractHandler = asyncHandler(async (req: Request, res: Response) => {
+  const { address, name, network, tags, type, abi } = req.body as {
+    address: string;
+    name?: string;
+    network?: string;
+    tags?: string[];
+    type?: string;
+    abi?: string;
+  };
+  const record = addContract({ address, name, network, tags, type, abi });
+  res.status(201).json(record);
+});
+
+export const removeContractHandler = asyncHandler(async (req: Request, res: Response) => {
+  const removed = removeContract(req.params.id);
+  if (!removed) {
+    res.status(404).json({ message: 'Contract not found' });
+    return;
+  }
+  res.json(removed);
+});
+
+
+export const resolveContractAbiHandler = asyncHandler(async (req: Request, res: Response) => {
+  const { chainId, address, contractName } = req.body as { chainId?: number; address?: string; contractName?: string };
+  if (!address?.trim()) {
+    res.status(400).json({ message: 'address is required.' });
+    return;
+  }
+  const result = await abiResolver.resolve(Number(chainId) || 1, address, contractName);
+  res.json(result);
+});

package/backend/controllers/devToolsController.ts

@@ -0,0 +1,76 @@
+import asyncHandler from 'express-async-handler';
+import type { Request, Response } from 'express';
+import { decodePayload, discoverContract, estimateGasForFunction, fetchSourceCode, scanSourceCode } from '../services/devToolsService';
+
+export const discoverContractHandler = asyncHandler(async (req: Request, res: Response) => {
+  const { address, chainId } = req.body as { address?: string; chainId?: number };
+  if (!address?.trim()) {
+    res.status(400).json({ message: 'address is required.' });
+    return;
+  }
+  const payload = await discoverContract(address, chainId);
+  res.json(payload);
+});
+
+export const estimateGasHandler = asyncHandler(async (req: Request, res: Response) => {
+  const { address, chainId, functionSignature, args, from, value } = req.body as {
+    address?: string;
+    chainId?: number;
+    functionSignature?: string;
+    args?: string[];
+    from?: string;
+    value?: string;
+  };
+  if (!address?.trim() || !functionSignature?.trim()) {
+    res.status(400).json({ message: 'address and functionSignature are required.' });
+    return;
+  }
+  const payload = await estimateGasForFunction({
+    address,
+    chainId,
+    functionSignature,
+    args: Array.isArray(args) ? args : [],
+    from,
+    value
+  });
+  res.json(payload);
+});
+
+export const scanContractHandler = asyncHandler(async (req: Request, res: Response) => {
+  const { address, chainId, sourceCode } = req.body as { address?: string; chainId?: number; sourceCode?: string };
+  let finalSource = sourceCode?.trim() ?? '';
+  let sourceName = 'manual';
+  if (!finalSource && address?.trim()) {
+    const fetched = await fetchSourceCode(address, chainId);
+    finalSource = fetched.sourceCode;
+    sourceName = fetched.contractName;
+  }
+  if (!finalSource) {
+    res.status(400).json({ message: 'Either address or sourceCode must be provided.' });
+    return;
+  }
+  const report = scanSourceCode(finalSource);
+  res.json({
+    sourceName,
+    findings: report.findings,
+    overallRiskScore: report.overallRiskScore
+  });
+});
+
+export const decodeHandler = asyncHandler(async (req: Request, res: Response) => {
+  const { mode, chainId, txHash, address, calldata, topics, eventData } = req.body as {
+    mode?: 'txHash' | 'rawCalldata' | 'eventLog';
+    chainId?: number;
+    txHash?: string;
+    address?: string;
+    calldata?: string;
+    topics?: string[];
+    eventData?: string;
+  };
+  if (!mode) {
+    res.status(400).json({ message: 'mode is required.' });
+    return;
+  }
+  const payload = await decodePayload({ mode, chainId, txHash, address, calldata, topics, eventData });
+  res.json(payload);
+});

package/backend/controllers/etherscanController.ts

@@ -0,0 +1,59 @@
+import asyncHandler from 'express-async-handler';
+import type { Request, Response } from 'express';
+import { getGasOracle, getTxHistory } from '../services/etherscanService';
+import { abiResolver } from '../utils/abiResolver';
+
+const parseChainId = (value: unknown) => {
+  if (typeof value === 'number' && Number.isInteger(value) && value > 0) {
+    return value;
+  }
+  if (typeof value === 'string' && value.trim()) {
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isInteger(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  return undefined;
+};
+
+export const resolveContractAbi = asyncHandler(async (req: Request, res: Response) => {
+  const { address, chainId, abiNameHint } = req.body as {
+    address: string;
+    chainId?: number | string;
+    abiNameHint?: string;
+  };
+
+  if (!address?.trim()) {
+    res.status(400).json({ message: 'address is required' });
+    return;
+  }
+
+  const resolvedChainId = parseChainId(chainId) ?? 1;
+  const result = await abiResolver.resolve(resolvedChainId, address, abiNameHint);
+
+  res.json({
+    address,
+    chainId: resolvedChainId,
+    ...result,
+    itemCount: result.abi.length
+  });
+});
+
+export const resolveContractAbiFile = asyncHandler(async (req: Request, res: Response) => {
+  const chainId = parseChainId(req.query.chainId) ?? 1;
+  const abiNameHint = typeof req.query.abiNameHint === 'string' ? req.query.abiNameHint : undefined;
+  const result = await abiResolver.resolve(chainId, req.params.address, abiNameHint);
+  res.json({ address: req.params.address, chainId, filePath: result.cachePath, source: result.source, cached: result.cached });
+});
+
+export const getAddressTxHistory = asyncHandler(async (req: Request, res: Response) => {
+  const chainId = parseChainId(req.query.chainId);
+  const history = await getTxHistory(req.params.address, chainId);
+  res.json(history);
+});
+
+export const getCurrentGasOracle = asyncHandler(async (req: Request, res: Response) => {
+  const chainId = parseChainId(req.query.chainId);
+  const oracle = await getGasOracle(chainId);
+  res.json(oracle);
+});

package/backend/controllers/historyController.ts

@@ -0,0 +1,7 @@
+import asyncHandler from 'express-async-handler';
+import type { Request, Response } from 'express';
+import { getHistoryEntries } from '../services/historyService';
+
+export const listHistory = asyncHandler(async (_req: Request, res: Response) => {
+  res.json(getHistoryEntries());
+});

package/backend/controllers/keyringController.ts

@@ -0,0 +1,134 @@
+import asyncHandler from 'express-async-handler';
+import type { Request, Response } from 'express';
+import keyringManager from '../services/keyringAccessor';
+import type { KeyringBackendName } from '../../src/core/backends/types';
+
+const AVAILABLE_BACKENDS: KeyringBackendName[] = ['system', 'file', 'memory'];
+
+const maskValue = (value: string | null) => {
+  if (!value) {
+    return null;
+  }
+  if (value.length <= 4) {
+    return '*'.repeat(value.length);
+  }
+  return `${value.slice(0, 2)}***${value.slice(-2)}`;
+};
+
+const isBackendName = (value: unknown): value is KeyringBackendName =>
+  typeof value === 'string' && AVAILABLE_BACKENDS.includes(value as KeyringBackendName);
+
+const resolveBackend = (req: Request): KeyringBackendName | undefined | null => {
+  const body = req.body as { service?: unknown; backend?: unknown } | undefined;
+  const query = req.query as { service?: unknown; backend?: unknown } | undefined;
+  const candidate = body?.service ?? body?.backend ?? query?.service ?? query?.backend ?? req.params.name;
+  if (candidate === undefined) {
+    return undefined;
+  }
+  if (!isBackendName(candidate)) {
+    return null;
+  }
+  return candidate;
+};
+
+const ensureBackend = async (req: Request, res: Response) => {
+  const requested = resolveBackend(req);
+  if (requested === null) {
+    res.status(400).json({ message: 'Unsupported backend. Use system, file, or memory.' });
+    return null;
+  }
+  if (requested) {
+    await keyringManager.switchBackend(requested);
+  }
+  return keyringManager.currentBackend();
+};
+
+export const listSecrets = asyncHandler(async (_req: Request, res: Response) => {
+  const active = await ensureBackend(_req, res);
+  if (!active) {
+    return;
+  }
+  const secrets = await keyringManager.list();
+  res.json({
+    service: active,
+    backend: active,
+    secrets: Object.entries(secrets).map(([key, value]) => ({
+      key,
+      maskedValue: maskValue(value)
+    }))
+  });
+});
+
+const resolveKey = (req: Request) => req.params.key ?? (req.body as { key?: string }).key;
+
+export const getSecret = asyncHandler(async (req: Request, res: Response) => {
+  const active = await ensureBackend(req, res);
+  if (!active) {
+    return;
+  }
+  const key = resolveKey(req);
+  if (typeof key !== 'string' || key.trim() === '') {
+    res.status(400).json({ message: 'key is required' });
+    return;
+  }
+  const value = await keyringManager.get(key);
+  if (value === null) {
+    res.status(404).json({ message: 'Secret not found' });
+    return;
+  }
+  res.json({ key, value, backend: active, service: active });
+});
+
+export const setSecret = asyncHandler(async (req: Request, res: Response) => {
+  const active = await ensureBackend(req, res);
+  if (!active) {
+    return;
+  }
+  const key = resolveKey(req);
+  const { value } = req.body as { value?: string };
+  if (typeof key !== 'string' || key.trim() === '') {
+    res.status(400).json({ message: 'key is required' });
+    return;
+  }
+  if (typeof value !== 'string') {
+    res.status(400).json({ message: 'value must be a string' });
+    return;
+  }
+  await keyringManager.set(key, value);
+  res.json({
+    key,
+    backend: active,
+    service: active,
+    maskedValue: maskValue(value)
+  });
+});
+
+export const deleteSecret = asyncHandler(async (req: Request, res: Response) => {
+  const active = await ensureBackend(req, res);
+  if (!active) {
+    return;
+  }
+  const key = resolveKey(req);
+  if (typeof key !== 'string' || key.trim() === '') {
+    res.status(400).json({ message: 'key is required' });
+    return;
+  }
+  await keyringManager.delete(key);
+  res.json({ key, backend: active, service: active, deleted: true });
+});
+
+export const getBackend = asyncHandler(async (_req: Request, res: Response) => {
+  const active = keyringManager.currentBackend();
+  res.json({ active, service: active, backend: active, available: AVAILABLE_BACKENDS });
+});
+
+export const switchBackend = asyncHandler(async (req: Request, res: Response) => {
+  const backend = resolveBackend(req);
+  if (!backend) {
+    res.status(400).json({ message: 'Unsupported backend. Use system, file, or memory.' });
+    return;
+  }
+  await keyringManager.switchBackend(backend);
+  const active = keyringManager.currentBackend();
+  res.json({ active, service: active, backend: active, available: AVAILABLE_BACKENDS });
+});

package/backend/controllers/robinhoodController.ts

@@ -0,0 +1,80 @@
+import asyncHandler from 'express-async-handler';
+import type { Request, Response } from 'express';
+import {
+  cancelRobinhoodCryptoOrder,
+  getRobinhoodCryptoAccounts,
+  getRobinhoodCryptoConfigStatus,
+  getRobinhoodCryptoMarketData,
+  getRobinhoodCryptoOrderStatus,
+  purchaseRobinhoodCryptoWithCash,
+  setRobinhoodCryptoConfig,
+  validateRobinhoodCryptoAuth
+} from '../services/robinhood/integrationService';
+
+const USD_EDGE_GATE = 2000;
+
+export const getCryptoCredentialsStatus = asyncHandler(async (_req: Request, res: Response) => {
+  const [status, auth] = await Promise.all([getRobinhoodCryptoConfigStatus(), validateRobinhoodCryptoAuth()]);
+  res.json({ ...status, auth });
+});
+
+export const setCryptoCredentials = asyncHandler(async (req: Request, res: Response) => {
+  const { apiKey, privateKey } = req.body as { apiKey?: string; privateKey?: string };
+  if (!apiKey?.trim()) {
+    res.status(400).json({ message: 'apiKey is required.' });
+    return;
+  }
+  if (!privateKey?.trim()) {
+    res.status(400).json({ message: 'privateKey is required.' });
+    return;
+  }
+  res.json(await setRobinhoodCryptoConfig(apiKey, privateKey));
+});
+
+export const placeCryptoCashOrder = asyncHandler(async (req: Request, res: Response) => {
+  const { symbol, cashAmount } = req.body as { symbol?: string; cashAmount?: number };
+  if (!symbol?.trim()) {
+    res.status(400).json({ message: 'symbol is required.' });
+    return;
+  }
+  const amount = Number(cashAmount);
+  if (!Number.isFinite(amount) || amount <= 0) {
+    res.status(400).json({ message: 'cashAmount must be a positive number.' });
+    return;
+  }
+  if (amount < USD_EDGE_GATE) {
+    res.status(400).json({ message: `cashAmount must be at least ${USD_EDGE_GATE}.` });
+    return;
+  }
+  const order = await purchaseRobinhoodCryptoWithCash(symbol, amount);
+  res.status(201).json(order);
+});
+
+export const getCryptoOrderStatus = asyncHandler(async (req: Request, res: Response) => {
+  const { orderId } = req.params;
+  if (!orderId?.trim()) {
+    res.status(400).json({ message: 'orderId is required.' });
+    return;
+  }
+  const status = await getRobinhoodCryptoOrderStatus(orderId);
+  res.json(status);
+});
+
+export const cancelCryptoOrder = asyncHandler(async (req: Request, res: Response) => {
+  const { orderId } = req.params;
+  if (!orderId?.trim()) {
+    res.status(400).json({ message: 'orderId is required.' });
+    return;
+  }
+  const status = await cancelRobinhoodCryptoOrder(orderId);
+  res.json(status);
+});
+
+export const getCryptoAccounts = asyncHandler(async (_req: Request, res: Response) => {
+  res.json(await getRobinhoodCryptoAccounts());
+});
+
+export const getCryptoMarketData = asyncHandler(async (req: Request, res: Response) => {
+  const symbol = String(req.query.symbol ?? 'BTC-USD');
+  res.json(await getRobinhoodCryptoMarketData(symbol));
+});

package/backend/controllers/safeController.ts

@@ -0,0 +1,167 @@
+import asyncHandler from 'express-async-handler';
+import type { Request, Response } from 'express';
+import {
+  connectToSafe,
+  getOwners,
+  addOwner as addSafeOwner,
+  removeOwner as removeSafeOwner,
+  changeThreshold as changeSafeThreshold,
+  enableModule as enableSafeModule,
+  disableModule as disableSafeModule,
+  addDelegate as addSafeDelegate,
+  removeDelegate as removeSafeDelegate,
+  updateFallbackHandler as updateSafeFallbackHandler,
+  updateGuard as updateSafeGuard,
+  proposeTransaction as proposeSafeTransaction,
+  executeTransaction as executeSafeTransaction,
+  getSafeDetails as getSafeProfile,
+  syncSafeState as syncSafeStateService
+} from '../services/safeService';
+import { holdService } from '../services/transactionHoldService';
+
+export const loadSafe = asyncHandler(async (req: Request, res: Response) => {
+  const { address, rpcUrl } = req.body as { address: string; rpcUrl?: string };
+  const safe = await connectToSafe(address, rpcUrl);
+  res.json(safe);
+});
+
+export const listOwners = asyncHandler(async (req: Request, res: Response) => {
+  const owners = await getOwners(req.params.address);
+  res.json(owners);
+});
+
+export const addOwner = asyncHandler(async (req: Request, res: Response) => {
+  const { owner, threshold } = req.body as { owner: string; threshold: number };
+  const result = await addSafeOwner(req.params.address, owner, threshold);
+  res.json(result);
+});
+
+export const getSafeDetails = asyncHandler(async (req: Request, res: Response) => {
+  const safe = await getSafeProfile(req.params.address);
+  res.json(safe);
+});
+
+export const syncSafeState = asyncHandler(async (req: Request, res: Response) => {
+  const safe = await syncSafeStateService(req.params.address);
+  const balance = await getSafeProfile(req.params.address).then((profile) => profile.balance);
+  res.json({
+    address: safe.address,
+    threshold: safe.threshold,
+    owners: safe.owners,
+    modules: safe.modules,
+    delegates: safe.delegates,
+    fallbackHandler: safe.fallbackHandler,
+    guard: safe.guard,
+    rpcUrl: safe.rpcUrl,
+    network: safe.network,
+    balance
+  });
+});
+
+export const removeOwner = asyncHandler(async (req: Request, res: Response) => {
+  const { threshold } = req.body as { threshold: number };
+  const result = await removeSafeOwner(req.params.address, req.params.ownerAddress, threshold);
+  res.json(result);
+});
+
+export const changeThreshold = asyncHandler(async (req: Request, res: Response) => {
+  const { threshold } = req.body as { threshold: number };
+  const result = await changeSafeThreshold(req.params.address, threshold);
+  res.json(result);
+});
+
+export const enableModule = asyncHandler(async (req: Request, res: Response) => {
+  const { module } = req.body as { module: string };
+  const result = await enableSafeModule(req.params.address, module);
+  res.json(result);
+});
+
+export const disableModule = asyncHandler(async (req: Request, res: Response) => {
+  const result = await disableSafeModule(req.params.address, req.params.moduleAddress);
+  res.json(result);
+});
+
+export const addDelegate = asyncHandler(async (req: Request, res: Response) => {
+  const { address, label } = req.body as { address: string; label?: string };
+  const payload = {
+    address,
+    label: label?.trim() ? label.trim() : 'Proposer',
+    since: new Date().toISOString()
+  };
+  const delegates = await addSafeDelegate(req.params.address, payload);
+  res.json(delegates);
+});
+
+export const removeDelegate = asyncHandler(async (req: Request, res: Response) => {
+  const delegates = await removeSafeDelegate(req.params.address, req.params.delegateAddress);
+  res.json(delegates);
+});
+
+export const updateFallbackHandler = asyncHandler(async (req: Request, res: Response) => {
+  const { handler } = req.body as { handler?: string };
+  const result = await updateSafeFallbackHandler(req.params.address, handler);
+  res.json(result);
+});
+
+export const updateGuard = asyncHandler(async (req: Request, res: Response) => {
+  const { guard } = req.body as { guard?: string };
+  const result = await updateSafeGuard(req.params.address, guard);
+  res.json(result);
+});
+
+export const proposeTransaction = asyncHandler(async (req: Request, res: Response) => {
+  const { tx, meta } = req.body as { tx: unknown; meta?: Record<string, unknown> };
+  const proposal = await proposeSafeTransaction(req.params.address, tx, meta);
+  res.json(proposal);
+});
+
+export const executeTransaction = asyncHandler(async (req: Request, res: Response) => {
+  const { txHash } = req.params;
+  const { password } = req.body as { password?: string };
+  const hold = await holdService.getHold(txHash);
+  if (hold && !holdService.canExecute(hold)) {
+    res.status(423).json({ message: 'Transaction is still in hold period', hold });
+    return;
+  }
+  const execution = await executeSafeTransaction(req.params.address, txHash, password);
+  if (hold) {
+    await holdService.markExecuted(txHash);
+  }
+  res.json(execution);
+});
+
+export const toggleHold = asyncHandler(async (req: Request, res: Response) => {
+  const { enabled, holdHours = 24 } = req.body as { enabled: boolean; holdHours?: number };
+  const policy = await holdService.setHoldState(req.params.address, enabled, holdHours);
+  const summary = holdService.summarize(req.params.address);
+  const effective = await holdService.getEffectivePolicy(req.params.address);
+  res.json({ policy, summary, effective });
+});
+
+export const listHeldTransactions = asyncHandler(async (req: Request, res: Response) => {
+  const [transactions, summary, effective] = await Promise.all([
+    holdService.listHolds(req.params.address),
+    Promise.resolve(holdService.summarize(req.params.address)),
+    holdService.getEffectivePolicy(req.params.address)
+  ]);
+  res.json({ records: transactions, summary, effective });
+});
+
+export const releaseTransactionHold = asyncHandler(async (req: Request, res: Response) => {
+  const hold = await holdService.releaseNow(req.params.txHash);
+  res.json(hold ?? { txHash: req.params.txHash, released: true });
+});
+
+export const getHoldPolicy = asyncHandler(async (req: Request, res: Response) => {
+  const [policy, summary, effective] = await Promise.all([
+    Promise.resolve(holdService.getHoldState(req.params.address)),
+    Promise.resolve(holdService.summarize(req.params.address)),
+    holdService.getEffectivePolicy(req.params.address)
+  ]);
+  res.json({ policy, summary, effective });
+});
+
+export const listHoldPolicies = asyncHandler(async (_req: Request, res: Response) => {
+  const policies = holdService.listHoldPolicies();
+  res.json(policies);
+});

package/backend/controllers/sandboxController.ts

@@ -0,0 +1,63 @@
+import asyncHandler from 'express-async-handler';
+import type { Request, Response } from 'express';
+import {
+  simulateCallStatic,
+  simulateContract,
+  simulateSafe,
+  getHistory,
+  clearHistory,
+  loadAbi,
+  listAbis,
+  startFork,
+  stopFork,
+  forkStatus
+} from '../services/sandboxService';
+
+export const callStaticSimulation = asyncHandler(async (req: Request, res: Response) => {
+  const result = await simulateCallStatic(req.body);
+  res.json(result);
+});
+
+export const contractSimulation = asyncHandler(async (req: Request, res: Response) => {
+  const result = await simulateContract(req.body);
+  res.json(result);
+});
+
+export const safeSimulation = asyncHandler(async (req: Request, res: Response) => {
+  const result = await simulateSafe(req.body);
+  res.json(result);
+});
+
+export const loadAbiHandler = asyncHandler(async (req: Request, res: Response) => {
+  const metadata = loadAbi(req.body);
+  res.json(metadata);
+});
+
+export const listAbisHandler = asyncHandler(async (_req: Request, res: Response) => {
+  res.json(listAbis());
+});
+
+export const historyHandler = asyncHandler(async (_req: Request, res: Response) => {
+  res.json(getHistory());
+});
+
+export const clearHistoryHandler = asyncHandler(async (_req: Request, res: Response) => {
+  clearHistory();
+  res.status(204).send();
+});
+
+export const startForkHandler = asyncHandler(async (req: Request, res: Response) => {
+  const { rpcUrl, blockNumber, port, command } = req.body;
+  const status = startFork(rpcUrl, blockNumber, port, command);
+  res.json(status);
+});
+
+export const stopForkHandler = asyncHandler(async (_req: Request, res: Response) => {
+  const status = stopFork();
+  res.json(status);
+});
+
+export const forkStatusHandler = asyncHandler(async (_req: Request, res: Response) => {
+  const status = forkStatus();
+  res.json(status);
+});

package/backend/controllers/settingsController.ts

@@ -0,0 +1,38 @@
+import asyncHandler from 'express-async-handler';
+import type { Request, Response } from 'express';
+import { getSecureSetting, setSecureSetting } from '../services/secureSettingsService';
+import { runtimeObservability } from '../../src/utils/runtimeObservability';
+
+interface HoldSettingsPayload {
+  enabled: boolean;
+  holdHours?: number;
+}
+
+const HOLD_KEY = 'SAFE_TX_HOLD_ENABLED';
+
+export const getTransactionHoldSettings = asyncHandler(async (_req: Request, res: Response) => {
+  const settings = await getSecureSetting(HOLD_KEY, { enabled: true, holdHours: 24 });
+  res.json(settings);
+});
+
+export const updateTransactionHoldSettings = asyncHandler(async (req: Request, res: Response) => {
+  const { enabled, holdHours = 24 } = req.body as HoldSettingsPayload;
+  if (typeof enabled !== 'boolean') {
+    res.status(400).json({ message: 'enabled must be a boolean' });
+    return;
+  }
+  const numericHours = Number(holdHours);
+  if (!Number.isFinite(numericHours)) {
+    res.status(400).json({ message: 'holdHours must be a number' });
+    return;
+  }
+  const normalizedHours = Math.max(1, Math.min(Math.round(numericHours), 24 * 14));
+  const payload = { enabled, holdHours: normalizedHours };
+  await setSecureSetting(HOLD_KEY, payload);
+  res.json(payload);
+});
+
+
+export const getRuntimeObservability = asyncHandler(async (_req: Request, res: Response) => {
+  res.json(runtimeObservability.snapshot());
+});