gnoman 0.1.0

package/gnoman2.0/main/main.ts

@@ -0,0 +1,234 @@
+import type { BrowserWindow as BrowserWindowType } from 'electron';
+import { app, BrowserWindow as BrowserWindowCtor, ipcMain } from 'electron';
+import { fork, type ChildProcess } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as url from 'url';
+import { registerIpcHandlers } from './ipcHandlers';
+
+const isDev = process.env.NODE_ENV === 'development';
+const backendPort = Number.parseInt(process.env.PORT ?? '4399', 10);
+
+const sleep = (ms: number) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+
+let backendProcess: ChildProcess | null = null;
+
+const resolveBackendEntry = () => {
+  const searchRoots = new Set<string>();
+  let current = path.resolve(__dirname);
+
+  for (let depth = 0; depth < 6; depth += 1) {
+    searchRoots.add(current);
+
+    const distDir = path.join(current, 'dist');
+    if (fs.existsSync(distDir)) {
+      searchRoots.add(distDir);
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+
+  const suffixes: string[][] = [
+    ['backend', 'index.js'],
+    ['backend', 'backend', 'index.js']
+  ];
+
+  for (const root of searchRoots) {
+    for (const parts of suffixes) {
+      const candidate = path.join(root, ...parts);
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+  }
+
+  return undefined;
+};
+
+const backendHealthUrl = `http://127.0.0.1:${backendPort}/api/health`;
+
+const isBackendReachable = async () => {
+  try {
+    const response = await fetch(backendHealthUrl, { cache: 'no-store' });
+    return response.ok;
+  } catch (error) {
+    const maybeErrno = error as { code?: string };
+    if (maybeErrno.code !== 'ECONNREFUSED') {
+      console.warn('Backend health probe failed:', error);
+    }
+    return false;
+  }
+};
+
+const ensureBackendRunning = async () => {
+  if (await isBackendReachable()) {
+    return;
+  }
+
+  if (!backendProcess) {
+    const backendEntry = resolveBackendEntry();
+
+    if (!backendEntry) {
+      console.error('Unable to locate backend bundle. Have you run `npm run build:backend`?');
+      return;
+    }
+
+    backendProcess = fork(backendEntry, {
+      cwd: path.join(__dirname, '..'),
+      env: {
+        ...process.env,
+        PORT: backendPort.toString()
+      },
+      stdio: 'inherit'
+    });
+
+    backendProcess.on('exit', (code, signal) => {
+      backendProcess = null;
+      if (signal) {
+        console.warn(`Backend exited after receiving signal ${signal}.`);
+        return;
+      }
+
+      if (code && code !== 0) {
+        console.error(`Backend process exited with code ${code}.`);
+      }
+    });
+
+    backendProcess.on('error', (error) => {
+      console.error('Failed to launch embedded backend:', error);
+    });
+  }
+
+  for (let attempt = 0; attempt < 40; attempt += 1) {
+    if (await isBackendReachable()) {
+      return;
+    }
+
+    await sleep(250);
+  }
+
+  console.error('Timed out waiting for embedded backend to report healthy.');
+};
+
+if (!isDev) {
+  app.commandLine.appendSwitch('allow-file-access-from-files');
+}
+
+if (process.platform === 'linux') {
+  const sanitizeGtkModules = (envVar: string) => {
+    const modules = process.env[envVar];
+
+    if (!modules) {
+      return;
+    }
+
+    const sanitizedModules = modules
+      .split(':')
+      .map((moduleName) => moduleName.trim())
+      .filter((moduleName) => moduleName && moduleName !== 'colorreload-gtk-module');
+
+    if (sanitizedModules.length === 0) {
+      delete process.env[envVar];
+      return;
+    }
+
+    const normalized = sanitizedModules.join(':');
+
+    if (normalized !== modules) {
+      process.env[envVar] = normalized;
+    }
+  };
+
+  sanitizeGtkModules('GTK_MODULES');
+  sanitizeGtkModules('GTK3_MODULES');
+}
+
+let mainWindow: BrowserWindowType | null = null;
+
+const createWindow = async () => {
+  mainWindow = new BrowserWindowCtor({
+    width: 1280,
+    height: 840,
+    webPreferences: {
+      preload: path.join(__dirname, 'preload/index.js'),
+      contextIsolation: true,
+      nodeIntegration: false,
+      sandbox: true
+    }
+  });
+
+  mainWindow.setTitle('GNOMAN 2.0');
+
+  if (isDev) {
+    const devServerURL = process.env.VITE_DEV_SERVER_URL || 'http://localhost:5173';
+    await mainWindow.loadURL(devServerURL);
+    mainWindow.webContents.openDevTools({ mode: 'detach' });
+  } else {
+    const resolveRendererIndex = () => {
+      const candidates = [
+        path.resolve(__dirname, '..', '..', 'renderer', 'index.html'),
+        path.resolve(__dirname, '..', 'renderer', 'index.html')
+      ];
+
+      for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+          return candidate;
+        }
+      }
+
+      console.error('Unable to locate renderer bundle. Have you run `npm run build:renderer`?');
+      return undefined;
+    };
+
+    const rendererIndex = resolveRendererIndex();
+
+    if (!rendererIndex) {
+      throw new Error('Renderer bundle missing from build output.');
+    }
+
+    await mainWindow.loadURL(
+      url.format({
+        pathname: rendererIndex,
+        protocol: 'file:',
+        slashes: true
+      })
+    );
+  }
+
+  mainWindow.on('closed', () => {
+    mainWindow = null;
+  });
+};
+
+app.on('window-all-closed', () => {
+  if (process.platform !== 'darwin') {
+    app.quit();
+  }
+});
+
+app.on('before-quit', () => {
+  if (backendProcess) {
+    backendProcess.removeAllListeners();
+    backendProcess.kill();
+    backendProcess = null;
+  }
+});
+
+app.on('activate', () => {
+  if (mainWindow === null) {
+    void createWindow();
+  }
+});
+
+app.whenReady().then(async () => {
+  registerIpcHandlers(ipcMain);
+  await ensureBackendRunning();
+  await createWindow();
+});
+

package/gnoman2.0/main/preload/index.ts

@@ -0,0 +1,31 @@
+import { contextBridge } from "electron";
+import { validateAndSave, loadToken } from "./licenseBridge";
+
+contextBridge.exposeInMainWorld("safevault", {
+  validateLicense: (key: string) => validateAndSave(key),
+  loadLicense: () => {
+    const token = loadToken();
+    if (!token) return { ok: false, reason: "none" };
+    return validateAndSave(token);
+  },
+});
+
+import { ipcRenderer } from "electron";
+
+type IpcChannels = "keyring:list" | "keyring:add" | "keyring:get" | "keyring:delete";
+
+type GnomanAPI = {
+  invoke: <T = unknown>(channel: IpcChannels, payload?: unknown) => Promise<T>;
+};
+
+const api: GnomanAPI = {
+  invoke: (channel, payload) => ipcRenderer.invoke(channel, payload)
+};
+
+contextBridge.exposeInMainWorld("gnoman", api);
+
+declare global {
+  interface Window {
+    gnoman: GnomanAPI;
+  }
+}

package/gnoman2.0/main/preload/licenseBridge.ts

@@ -0,0 +1,73 @@
+// main/preload/licenseBridge.ts
+import { execFileSync } from "node:child_process";
+import * as path from "node:path";
+import * as fs from "node:fs";
+
+const ROOT = process.cwd();
+const PUB_KEY_PATH = path.join(ROOT, "backend/licenses/license_public.pem");
+const SAFEVAULT_DIR = path.join(ROOT, ".safevault");
+const ENV_PATH = path.join(SAFEVAULT_DIR, "license.env");
+const PYTHON_BRIDGE = `
+import sys
+from backend.licenses.verify_license import verify_token
+
+
+def main():
+    _, pub_path, token, product, version = sys.argv
+    result = verify_token(pub_path, token, product, version)
+    print("True" if result else "False")
+
+
+if __name__ == "__main__":
+    main()
+`;
+
+// ensure .safevault exists
+if (!fs.existsSync(SAFEVAULT_DIR)) fs.mkdirSync(SAFEVAULT_DIR, { recursive: true });
+
+/**
+ * Run verify_license.py directly to confirm the token offline.
+ * Returns true if valid, false otherwise.
+ */
+export function verifyOfflineLicense(token: string): boolean {
+  try {
+    const out = execFileSync(
+      "python3",
+      ["-c", PYTHON_BRIDGE, PUB_KEY_PATH, token, "GNOMAN", "2.0.0"],
+      {
+        encoding: "utf8",
+        timeout: 5000,
+      }
+    );
+    return out.trim() === "True";
+  } catch {
+    return false;
+  }
+}
+
+/** Persist valid token in .safevault/license.env */
+function persistToken(token: string) {
+  const content = [
+    `LICENSE_KEY=${token}`,
+    `VALIDATED_AT=${Math.floor(Date.now() / 1000)}`,
+  ].join("\n");
+  fs.writeFileSync(ENV_PATH, content, "utf8");
+}
+
+/** Load previously saved token (if any) */
+export function loadToken(): string | null {
+  if (!fs.existsSync(ENV_PATH)) return null;
+  const lines = fs.readFileSync(ENV_PATH, "utf8").split(/\r?\n/);
+  const kv = Object.fromEntries(lines.filter(Boolean).map(l => l.split("=", 2)));
+  return kv.LICENSE_KEY || null;
+}
+
+/** Validate key and save if valid */
+export function validateAndSave(token: string): { ok: boolean; reason?: string } {
+  const valid = verifyOfflineLicense(token);
+  if (valid) {
+    persistToken(token);
+    return { ok: true };
+  }
+  return { ok: false, reason: "invalid_or_expired" };
+}

package/gnoman2.0/modules/sandbox/abiLoader.ts

@@ -0,0 +1,78 @@
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+import { Interface, FunctionFragment, ParamType, type InterfaceAbi } from 'ethers';
+import type { AbiFunctionDescription, AbiFunctionInput, AbiLoadRequest, AbiMetadata } from './types';
+
+const SAFE_ABI_CANDIDATES = [
+  path.join(__dirname, 'safe.abi.json'),
+  path.join(process.cwd(), 'modules/sandbox/safe.abi.json')
+];
+
+const resolveSafeAbiPath = () => {
+  for (const candidate of SAFE_ABI_CANDIDATES) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return SAFE_ABI_CANDIDATES[0];
+};
+
+export const loadSafeAbi = (): AbiMetadata => {
+  const abiSource = readFileSync(resolveSafeAbiPath(), 'utf8');
+  return parseAbi({ abi: abiSource, name: 'Safe' });
+};
+
+export const parseAbi = ({ abi, name }: AbiLoadRequest): AbiMetadata => {
+  const abiJson: InterfaceAbi = typeof abi === 'string' ? JSON.parse(abi) : abi;
+  const iface = new Interface(abiJson);
+  const functionFragments = iface.fragments.filter((fragment): fragment is FunctionFragment => fragment.type === 'function');
+  const functions: AbiFunctionDescription[] = functionFragments.map((fn) => ({
+    name: fn.name,
+    stateMutability: fn.stateMutability,
+    inputs: fn.inputs.map(mapParam),
+    outputs: fn.outputs?.map(mapParam) ?? [],
+    payable: fn.payable,
+    constant: fn.constant ?? false
+  }));
+
+  return {
+    name: name ?? functionFragments[0]?.name ?? 'Contract',
+    abi: abiJson,
+    functions
+  };
+};
+
+const mapParam = (fragment: ParamType): AbiFunctionInput => ({
+  name: fragment.name,
+  type: fragment.type,
+  internalType: (fragment as { internalType?: string }).internalType,
+  indexed:
+    (fragment as { indexed?: boolean | null }).indexed === null
+      ? undefined
+      : (fragment as { indexed?: boolean | null }).indexed ?? undefined
+});
+
+export const loadAbiFromFile = (filePath: string, name?: string): AbiMetadata => {
+  if (!existsSync(filePath)) {
+    throw new Error(`ABI file not found at ${filePath}`);
+  }
+  const raw = readFileSync(filePath, 'utf8');
+  return parseAbi({ abi: raw, name: name ?? path.basename(filePath) });
+};
+
+export const validateFunctionExists = (metadata: AbiMetadata, functionName: string) => {
+  const exists = metadata.functions.some((fn) => fn.name === functionName);
+  if (!exists) {
+    throw new Error(`Function ${functionName} not found in ABI ${metadata.name}`);
+  }
+};
+
+export const requireSafeAbi = (): AbiMetadata => {
+  const safePath = resolveSafeAbiPath();
+  if (!existsSync(safePath)) {
+    throw new Error('Safe ABI definition missing');
+  }
+  const abiSource = readFileSync(safePath, 'utf8');
+  return parseAbi({ abi: abiSource, name: 'Safe' });
+};
+

package/gnoman2.0/modules/sandbox/contractSimulator.ts

@@ -0,0 +1,241 @@
+import { JsonRpcProvider, Wallet, Interface, getAddress, isHexString, ZeroAddress, type InterfaceAbi } from 'ethers';
+import type {
+  ContractSimulationRequest,
+  ContractSimulationResult,
+  SimulationParameterMap,
+  AbiMetadata
+} from './types';
+import { randomUUID } from 'crypto';
+
+const TRACE_METHOD = 'debug_traceCall';
+
+const toHexValue = (value?: string) => {
+  if (!value) return undefined;
+  return isHexString(value) ? value : `0x${BigInt(value).toString(16)}`;
+};
+
+export interface SimulationContext {
+  metadata: AbiMetadata;
+  request: ContractSimulationRequest;
+  abiInterface: Interface;
+}
+
+export const buildProvider = async (rpcUrl: string) => {
+  const provider = new JsonRpcProvider(rpcUrl);
+  await provider.getNetwork();
+  return provider;
+};
+
+export const encodeParameters = (abiInterface: Interface, functionName: string, parameters: SimulationParameterMap) => {
+  const fragment = abiInterface.getFunction(functionName);
+  if (!fragment) {
+    throw new Error(`Function ${functionName} not found in ABI`);
+  }
+  const orderedArgs = fragment.inputs.map((input, index) => {
+    if (input.name && input.name in parameters) {
+      return parameters[input.name];
+    }
+    const fallbackKey = `arg_${index}`;
+    if (fallbackKey in parameters) {
+      return parameters[fallbackKey];
+    }
+    throw new Error(`Missing parameter ${input.name || fallbackKey}`);
+  });
+  return abiInterface.encodeFunctionData(functionName, orderedArgs);
+};
+
+const decodeReturn = (abiInterface: Interface, functionName: string, data: string | null | undefined) => {
+  if (!data) return null;
+  try {
+    return abiInterface.decodeFunctionResult(functionName, data);
+  } catch (error) {
+    return { error: (error as Error).message };
+  }
+};
+
+const captureTrace = async (
+  provider: JsonRpcProvider,
+  request: ContractSimulationRequest,
+  callData: string,
+  from: string
+) => {
+  try {
+    const trace = await provider.send(TRACE_METHOD, [
+      {
+        from,
+        to: request.contractAddress,
+        data: callData,
+        gas: request.gasLimit,
+        value: request.value ? toHexValue(request.value) : undefined
+      },
+      'latest',
+      {
+        enableMemory: true,
+        enableReturnData: true,
+        disableStack: false
+      }
+    ]);
+    return trace;
+  } catch (error) {
+    return { error: (error as Error).message };
+  }
+};
+
+const runStaticCall = async (
+  provider: JsonRpcProvider,
+  abiInterface: Interface,
+  request: ContractSimulationRequest,
+  callData: string,
+  from: string
+) => {
+  try {
+    const result = await provider.call({
+      to: request.contractAddress,
+      data: callData,
+      from,
+      value: request.value ? toHexValue(request.value) : undefined
+    });
+    return { success: true as const, result };
+  } catch (error) {
+    return { success: false as const, error: error as Error };
+  }
+};
+
+const estimateGas = async (
+  provider: JsonRpcProvider,
+  request: ContractSimulationRequest,
+  callData: string,
+  from: string
+) => {
+  try {
+    const estimate = await provider.estimateGas({
+      to: request.contractAddress,
+      data: callData,
+      from,
+      value: request.value ? toHexValue(request.value) : undefined,
+      gasLimit: request.gasLimit ? BigInt(request.gasLimit) : undefined
+    });
+    return estimate.toString();
+  } catch (error) {
+    return undefined;
+  }
+};
+
+export const simulateContractCall = async (
+  metadata: AbiMetadata,
+  request: ContractSimulationRequest
+): Promise<ContractSimulationResult> => {
+  const provider = await buildProvider(request.rpcUrl);
+  const network = await provider.getNetwork();
+  const abiInterface = new Interface(metadata.abi as InterfaceAbi);
+  const contractAddress = getAddress(request.contractAddress);
+  const fromAddress = request.from ? getAddress(request.from) : ZeroAddress;
+  const callData = encodeParameters(abiInterface, request.functionName, request.parameters);
+  const gasEstimate = await estimateGas(provider, { ...request, contractAddress }, callData, fromAddress);
+  const staticResult = await runStaticCall(provider, abiInterface, { ...request, contractAddress }, callData, fromAddress);
+
+  let decoded: unknown = null;
+  let revertReason: string | undefined;
+
+  if (staticResult.success) {
+    decoded = decodeReturn(abiInterface, request.functionName, staticResult.result);
+  } else {
+    const error = staticResult.error;
+    revertReason = error.message;
+  }
+
+  const trace = await captureTrace(provider, { ...request, contractAddress }, callData, fromAddress);
+
+  const record: ContractSimulationResult = {
+    id: randomUUID(),
+    timestamp: new Date().toISOString(),
+    success: staticResult.success,
+    network: {
+      chainId: Number(network.chainId.toString()),
+      name: network.name
+    },
+    gasEstimate,
+    gasLimit: request.gasLimit,
+    returnData: staticResult.success ? staticResult.result : undefined,
+    decodedReturnData: decoded ?? undefined,
+    error: staticResult.success ? undefined : staticResult.error?.message,
+    revertReason,
+    trace,
+    callData,
+    functionName: request.functionName,
+    contractAddress,
+    parameters: request.parameters,
+    forkMode: Boolean(request.fork),
+    rpcUrl: request.rpcUrl,
+    value: request.value
+  };
+
+  return record;
+};
+
+export const simulateOnFork = async (
+  metadata: AbiMetadata,
+  request: ContractSimulationRequest,
+  forkRpcUrl: string
+): Promise<ContractSimulationResult> => {
+  const provider = await buildProvider(forkRpcUrl);
+  const abiInterface = new Interface(metadata.abi as InterfaceAbi);
+  const contractAddress = getAddress(request.contractAddress);
+  const callData = encodeParameters(abiInterface, request.functionName, request.parameters);
+  const fromWallet = Wallet.createRandom().connect(provider);
+  const gasEstimate = await provider.estimateGas({
+    to: contractAddress,
+    data: callData,
+    value: request.value ? toHexValue(request.value) : undefined,
+    gasLimit: request.gasLimit ? BigInt(request.gasLimit) : undefined,
+    from: await fromWallet.getAddress()
+  });
+
+  try {
+    const response = await provider.call({
+      to: contractAddress,
+      data: callData,
+      from: await fromWallet.getAddress(),
+      value: request.value ? toHexValue(request.value) : undefined
+    });
+
+    return {
+      id: randomUUID(),
+      timestamp: new Date().toISOString(),
+      success: true,
+      network: {
+        chainId: Number((await provider.getNetwork()).chainId.toString()),
+        name: (await provider.getNetwork()).name
+      },
+      gasEstimate: gasEstimate.toString(),
+      returnData: response,
+      decodedReturnData: decodeReturn(abiInterface, request.functionName, response) ?? undefined,
+      callData,
+      functionName: request.functionName,
+      contractAddress,
+      parameters: request.parameters,
+      forkMode: true,
+      rpcUrl: forkRpcUrl,
+      value: request.value
+    };
+  } catch (error) {
+    return {
+      id: randomUUID(),
+      timestamp: new Date().toISOString(),
+      success: false,
+      network: {
+        chainId: Number((await provider.getNetwork()).chainId.toString()),
+        name: (await provider.getNetwork()).name
+      },
+      gasEstimate: gasEstimate.toString(),
+      error: (error as Error).message,
+      callData,
+      functionName: request.functionName,
+      contractAddress,
+      parameters: request.parameters,
+      forkMode: true,
+      rpcUrl: forkRpcUrl,
+      value: request.value
+    };
+  }
+};

package/gnoman2.0/modules/sandbox/formBuilder.ts

@@ -0,0 +1,16 @@
+import type { AbiFunctionDescription } from './types';
+
+export interface ParameterField {
+  name: string;
+  type: string;
+  placeholder: string;
+}
+
+export const buildParameterFields = (fn?: AbiFunctionDescription): ParameterField[] => {
+  if (!fn) return [];
+  return fn.inputs.map((input, index) => ({
+    name: input.name || `arg_${index}`,
+    type: input.type,
+    placeholder: input.type
+  }));
+};

package/gnoman2.0/modules/sandbox/index.ts

@@ -0,0 +1,6 @@
+import SandboxManager from './sandboxManager';
+
+const sandboxManager = new SandboxManager();
+
+export default sandboxManager;
+export * from './types';