site-agent-pro 1.0.0

package/dist/trade/extractor.js

@@ -0,0 +1,148 @@
+const EVM_ADDRESS_PATTERN = /\b0x[a-fA-F0-9]{40}\b/g;
+const DEPOSIT_ADDRESS_HINT_PATTERN = /\b(?:send(?:\s+your)?|deposit|transfer|recipient|wallet address|sale(?:s)? address|sell address|copy address)\b/i;
+const QUOTE_ID_PATTERN = /\b(?:quote(?:\s+id)?|reference|ref)\s*[:#-]?\s*([a-z0-9_-]{6,})\b/i;
+const EXPIRY_PATTERN = /\b(?:expires?|valid until)\s*[:#-]?\s*([^\n]+)$/i;
+const CHAIN_NAME_MAP = {
+    ethereum: 1,
+    mainnet: 1,
+    sepolia: 11155111,
+    polygon: 137,
+    mumbai: 80001,
+    arbitrum: 42161,
+    optimism: 10,
+    base: 8453,
+    avalanche: 43114,
+    bsc: 56
+};
+function inferAssetKind(tokenSymbol) {
+    const normalized = tokenSymbol.trim().toUpperCase();
+    if (["ETH", "MATIC", "POL", "BNB", "AVAX"].includes(normalized)) {
+        return "native";
+    }
+    return "erc20";
+}
+function normalizeText(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function uniqueStrings(values) {
+    return [...new Set(values.map((value) => normalizeText(value)).filter(Boolean))];
+}
+function findDepositAddressCandidate(lines) {
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = normalizeText(lines[index] || "");
+        if (!line) {
+            continue;
+        }
+        const addressMatches = line.match(EVM_ADDRESS_PATTERN) ?? [];
+        if (addressMatches.length > 0 && DEPOSIT_ADDRESS_HINT_PATTERN.test(line)) {
+            return {
+                address: addressMatches[0],
+                evidence: uniqueStrings([line, lines[index - 1] || "", lines[index + 1] || ""]).slice(0, 4)
+            };
+        }
+        if (DEPOSIT_ADDRESS_HINT_PATTERN.test(line)) {
+            const nextWindow = [lines[index + 1] || "", lines[index + 2] || ""];
+            for (const candidateLine of nextWindow) {
+                const candidateAddress = normalizeText(candidateLine).match(EVM_ADDRESS_PATTERN)?.[0];
+                if (candidateAddress) {
+                    return {
+                        address: candidateAddress,
+                        evidence: uniqueStrings([line, candidateLine, lines[index + 2] || ""]).slice(0, 4)
+                    };
+                }
+            }
+        }
+    }
+    return null;
+}
+function parseAmountAndSymbol(taskGoal, lines) {
+    const textSources = [taskGoal, ...lines];
+    const patterns = [
+        /\b(?:sell|send|transfer)\s+([0-9]+(?:\.[0-9]+)?)\s+([A-Za-z][A-Za-z0-9]{1,11})\b/i,
+        /\b([0-9]+(?:\.[0-9]+)?)\s+([A-Za-z][A-Za-z0-9]{1,11})\b.*\b(?:sell|send|transfer)\b/i
+    ];
+    for (const source of textSources) {
+        const normalized = normalizeText(source);
+        for (const pattern of patterns) {
+            const match = normalized.match(pattern);
+            if (match?.[1] && match?.[2]) {
+                return {
+                    amount: match[1],
+                    tokenSymbol: match[2].toUpperCase()
+                };
+            }
+        }
+    }
+    return null;
+}
+function inferChainId(lines, defaultChainId) {
+    const blob = normalizeText(lines.join(" ")).toLowerCase();
+    for (const [name, chainId] of Object.entries(CHAIN_NAME_MAP)) {
+        if (blob.includes(name)) {
+            return chainId;
+        }
+    }
+    return defaultChainId ?? null;
+}
+function findQuoteId(lines) {
+    for (const line of lines) {
+        const match = normalizeText(line).match(QUOTE_ID_PATTERN);
+        if (match?.[1]) {
+            return match[1];
+        }
+    }
+    return undefined;
+}
+function findExpiryLine(lines) {
+    for (const line of lines) {
+        const match = normalizeText(line).match(EXPIRY_PATTERN);
+        if (match?.[1]) {
+            return match[1];
+        }
+    }
+    return undefined;
+}
+export function taskLooksLikeTrade(taskGoal) {
+    return /\b(?:sell|cash\s*out|offramp|send(?:\s+crypto)?|transfer(?:\s+crypto)?|deposit(?:\s+crypto)?)\b/i.test(taskGoal);
+}
+export function pageLooksTradeReady(pageState) {
+    const lines = [
+        ...pageState.visibleLines,
+        ...pageState.headings,
+        ...pageState.interactive.map((item) => item.text)
+    ];
+    return Boolean(findDepositAddressCandidate(lines));
+}
+export function extractSellInstruction(args) {
+    const evidenceLines = uniqueStrings([
+        ...args.pageState.visibleLines,
+        ...args.pageState.headings,
+        ...args.pageState.interactive.map((item) => item.text)
+    ]).slice(0, 80);
+    const depositAddress = findDepositAddressCandidate(evidenceLines);
+    if (!depositAddress) {
+        return null;
+    }
+    const amountAndSymbol = parseAmountAndSymbol(args.taskGoal, evidenceLines);
+    const chainId = inferChainId(depositAddress.evidence.concat(evidenceLines), args.defaultChainId);
+    if (!amountAndSymbol || !chainId) {
+        return null;
+    }
+    return {
+        mode: "deposit_address_transfer",
+        chainFamily: "evm",
+        chainId,
+        assetKind: inferAssetKind(amountAndSymbol.tokenSymbol),
+        tokenSymbol: amountAndSymbol.tokenSymbol,
+        tokenContract: undefined,
+        tokenDecimals: undefined,
+        amount: amountAndSymbol.amount,
+        recipientAddress: depositAddress.address,
+        recipientMemo: undefined,
+        quoteId: findQuoteId(evidenceLines),
+        expiresAt: findExpiryLine(evidenceLines),
+        sourceUrl: args.pageState.url,
+        sourceTitle: args.pageState.title,
+        evidenceText: uniqueStrings([...depositAddress.evidence, args.taskGoal]).slice(0, 8)
+    };
+}

package/dist/trade/policy.js

@@ -0,0 +1,35 @@
+import { config } from "../config.js";
+export function getTradePolicy() {
+    return config.tradePolicy;
+}
+export function buildDefaultTradeRunOptions(overrides) {
+    return {
+        enabled: overrides?.enabled ?? config.tradePolicy.enabledByDefault,
+        dryRun: overrides?.dryRun ?? false,
+        strategy: overrides?.strategy ?? "auto",
+        confirmations: overrides?.confirmations ?? config.tradePolicy.confirmationsRequired
+    };
+}
+export function resolveTokenRegistryEntry(args) {
+    const normalizedSymbol = args.symbol.trim().toUpperCase();
+    const normalizedContract = args.contract?.trim().toLowerCase();
+    const matches = args.policy.tokenRegistry.filter((entry) => {
+        if (entry.chainId !== args.chainId) {
+            return false;
+        }
+        if (entry.symbol !== normalizedSymbol) {
+            return false;
+        }
+        if (!normalizedContract) {
+            return true;
+        }
+        return (entry.contract || "").trim().toLowerCase() === normalizedContract;
+    });
+    if (matches.length === 0) {
+        return { entry: null, ambiguous: false };
+    }
+    if (matches.length > 1 && !normalizedContract) {
+        return { entry: null, ambiguous: true };
+    }
+    return { entry: matches[0] ?? null, ambiguous: false };
+}

package/dist/trade/session.js

@@ -0,0 +1,31 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { writeJson } from "../utils/files.js";
+import { SellInstructionSchema, TradeExecutionRecordsSchema } from "./types.js";
+const TRADE_EXECUTIONS_FILE = "trade-executions.json";
+export function resolveTradeExecutionsPath(runDir) {
+    return path.join(runDir, TRADE_EXECUTIONS_FILE);
+}
+export function computeInstructionFingerprint(instruction) {
+    const normalized = SellInstructionSchema.parse(instruction);
+    return crypto.createHash("sha256").update(JSON.stringify(normalized)).digest("hex");
+}
+export function readTradeExecutionRecords(runDir) {
+    const artifactPath = resolveTradeExecutionsPath(runDir);
+    if (!fs.existsSync(artifactPath)) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(fs.readFileSync(artifactPath, "utf8"));
+        return TradeExecutionRecordsSchema.parse(parsed);
+    }
+    catch {
+        return [];
+    }
+}
+export function appendTradeExecutionRecord(runDir, record) {
+    const nextRecords = [...readTradeExecutionRecords(runDir), record];
+    writeJson(resolveTradeExecutionsPath(runDir), nextRecords);
+    return nextRecords;
+}

package/dist/trade/types.js

@@ -0,0 +1,107 @@
+import { z } from "zod";
+export const TradeStrategySchema = z.enum(["auto", "dapp_only", "deposit_only"]);
+export const TradeRunOptionsSchema = z.object({
+    enabled: z.boolean().default(false),
+    dryRun: z.boolean().default(false),
+    strategy: TradeStrategySchema.default("auto"),
+    confirmations: z.number().int().min(0).max(12).default(1)
+});
+export const TradeTokenRegistryEntrySchema = z.object({
+    chainId: z.number().int().positive(),
+    symbol: z.string().min(1).transform((value) => value.trim().toUpperCase()),
+    assetKind: z.enum(["native", "erc20"]),
+    contract: z
+        .string()
+        .optional()
+        .transform((value) => {
+        const trimmed = value?.trim();
+        return trimmed ? trimmed : undefined;
+    }),
+    decimals: z.number().int().min(0).max(36)
+});
+export const TradePolicySchema = z.object({
+    enabledByDefault: z.boolean().default(false),
+    allowlistedChainIds: z.array(z.number().int().positive()).default([]),
+    tokenRegistry: z.array(TradeTokenRegistryEntrySchema).default([]),
+    maxTokenAmount: z
+        .string()
+        .optional()
+        .transform((value) => {
+        const trimmed = value?.trim();
+        return trimmed ? trimmed : undefined;
+    }),
+    requireExactTokenContract: z.boolean().default(true),
+    receiptTimeoutMs: z.number().int().positive().default(120000),
+    confirmationsRequired: z.number().int().min(0).max(12).default(1)
+});
+export const SellInstructionSchema = z.object({
+    mode: z.enum(["dapp_managed", "deposit_address_transfer"]),
+    chainFamily: z.literal("evm"),
+    chainId: z.number().int().positive(),
+    assetKind: z.enum(["native", "erc20"]),
+    tokenSymbol: z.string().min(1).transform((value) => value.trim().toUpperCase()),
+    tokenContract: z
+        .string()
+        .optional()
+        .transform((value) => {
+        const trimmed = value?.trim();
+        return trimmed ? trimmed : undefined;
+    }),
+    tokenDecimals: z.number().int().min(0).max(36).optional(),
+    amount: z.string().min(1),
+    recipientAddress: z.string().min(1),
+    recipientMemo: z
+        .string()
+        .optional()
+        .transform((value) => {
+        const trimmed = value?.trim();
+        return trimmed ? trimmed : undefined;
+    }),
+    quoteId: z
+        .string()
+        .optional()
+        .transform((value) => {
+        const trimmed = value?.trim();
+        return trimmed ? trimmed : undefined;
+    }),
+    expiresAt: z
+        .string()
+        .optional()
+        .transform((value) => {
+        const trimmed = value?.trim();
+        return trimmed ? trimmed : undefined;
+    }),
+    sourceUrl: z.string().url(),
+    sourceTitle: z.string(),
+    evidenceText: z.array(z.string()).default([])
+});
+export const TradeExecutionStatusSchema = z.enum([
+    "dry_run",
+    "broadcast",
+    "confirmed",
+    "blocked",
+    "failed"
+]);
+export const TradeValidationResultSchema = z.object({
+    ok: z.boolean(),
+    reasons: z.array(z.string()).default([])
+});
+export const TradeExecutionRecordSchema = z.object({
+    id: z.string(),
+    fingerprint: z.string(),
+    time: z.string(),
+    source: z.enum(["browser", "cli"]),
+    strategy: TradeStrategySchema,
+    selectedMode: z.enum(["dapp_managed", "deposit_address_transfer", "unsupported"]),
+    dryRun: z.boolean(),
+    status: TradeExecutionStatusSchema,
+    instruction: SellInstructionSchema.optional(),
+    validation: TradeValidationResultSchema,
+    txHash: z.string().nullable().default(null),
+    confirmationsRequested: z.number().int().min(0).max(12).default(1),
+    confirmationsReached: z.number().int().min(0).max(12).default(0),
+    receipt: z.record(z.string(), z.unknown()).nullable().default(null),
+    error: z.string().nullable().default(null),
+    note: z.string()
+});
+export const TradeExecutionRecordsSchema = z.array(TradeExecutionRecordSchema);

package/dist/trade/validator.js

@@ -0,0 +1,148 @@
+import { getWalletAddress, getWalletChainId, isWalletConfigured } from "../wallet/wallet.js";
+import { parseTokenAmount, readErc20Balance, readNativeBalance } from "./evm/erc20.js";
+import { resolveTokenRegistryEntry } from "./policy.js";
+function normalizeAddress(value) {
+    return value.trim().toLowerCase();
+}
+function isEvmAddress(value) {
+    return /^0x[a-fA-F0-9]{40}$/.test(value.trim());
+}
+function isNumberishDecimal(value) {
+    return /^[0-9]+(?:\.[0-9]+)?$/.test(value.trim());
+}
+function compareDecimalStrings(left, right) {
+    const [leftWhole = "0", leftFraction = ""] = left.trim().split(".");
+    const [rightWhole = "0", rightFraction = ""] = right.trim().split(".");
+    const normalizedLeftWhole = leftWhole.replace(/^0+/, "") || "0";
+    const normalizedRightWhole = rightWhole.replace(/^0+/, "") || "0";
+    if (normalizedLeftWhole.length !== normalizedRightWhole.length) {
+        return normalizedLeftWhole.length > normalizedRightWhole.length ? 1 : -1;
+    }
+    if (normalizedLeftWhole !== normalizedRightWhole) {
+        return normalizedLeftWhole > normalizedRightWhole ? 1 : -1;
+    }
+    const maxFractionLength = Math.max(leftFraction.length, rightFraction.length);
+    const normalizedLeftFraction = leftFraction.padEnd(maxFractionLength, "0");
+    const normalizedRightFraction = rightFraction.padEnd(maxFractionLength, "0");
+    if (normalizedLeftFraction === normalizedRightFraction) {
+        return 0;
+    }
+    return normalizedLeftFraction > normalizedRightFraction ? 1 : -1;
+}
+export async function validateSellInstruction(args) {
+    const reasons = [];
+    const walletChainId = getWalletChainId();
+    const normalizedInstruction = {
+        ...args.instruction,
+        tokenSymbol: args.instruction.tokenSymbol.trim().toUpperCase(),
+        recipientAddress: args.instruction.recipientAddress.trim()
+    };
+    if (!args.runOptions.enabled) {
+        reasons.push("Trade execution is disabled for this run.");
+    }
+    if (!isWalletConfigured()) {
+        reasons.push("Wallet execution is not configured.");
+    }
+    if (normalizedInstruction.chainFamily !== "evm") {
+        reasons.push("Only EVM trade execution is supported in this build.");
+    }
+    if (!isEvmAddress(normalizedInstruction.recipientAddress)) {
+        reasons.push("Recipient address is not a valid EVM address.");
+    }
+    if (!isNumberishDecimal(normalizedInstruction.amount)) {
+        reasons.push("Amount must be a numeric decimal string.");
+    }
+    if (normalizedInstruction.chainId !== walletChainId) {
+        reasons.push(`Instruction chain ${normalizedInstruction.chainId} does not match the configured wallet chain ${walletChainId}.`);
+    }
+    if (args.policy.allowlistedChainIds.length > 0 &&
+        !args.policy.allowlistedChainIds.includes(normalizedInstruction.chainId)) {
+        reasons.push(`Chain ${normalizedInstruction.chainId} is not in the allowed trade chain list.`);
+    }
+    if (normalizedInstruction.recipientMemo) {
+        reasons.push("Recipient memo or tag flows are not supported for EVM transfers in this build.");
+    }
+    if (normalizedInstruction.expiresAt) {
+        const expiresAtMs = Date.parse(normalizedInstruction.expiresAt);
+        if (!Number.isFinite(expiresAtMs)) {
+            reasons.push("Instruction expiry could not be parsed.");
+        }
+        else if (expiresAtMs <= Date.now()) {
+            reasons.push("Instruction quote or deposit window has already expired.");
+        }
+    }
+    const registryResolution = resolveTokenRegistryEntry({
+        policy: args.policy,
+        chainId: normalizedInstruction.chainId,
+        symbol: normalizedInstruction.tokenSymbol,
+        contract: normalizedInstruction.tokenContract
+    });
+    if (registryResolution.ambiguous) {
+        reasons.push(`Token symbol '${normalizedInstruction.tokenSymbol}' maps to multiple registry entries on chain ${normalizedInstruction.chainId}; a contract address is required.`);
+    }
+    const registryEntry = registryResolution.entry;
+    if (registryEntry) {
+        normalizedInstruction.assetKind = registryEntry.assetKind;
+        normalizedInstruction.tokenDecimals = registryEntry.decimals;
+        if (registryEntry.contract) {
+            normalizedInstruction.tokenContract = registryEntry.contract;
+        }
+    }
+    if (normalizedInstruction.assetKind === "native" && normalizedInstruction.tokenDecimals === undefined) {
+        normalizedInstruction.tokenDecimals = 18;
+    }
+    if (normalizedInstruction.assetKind === "erc20") {
+        if (!normalizedInstruction.tokenContract) {
+            reasons.push(`No ERC-20 contract address is known for token '${normalizedInstruction.tokenSymbol}'.`);
+        }
+        if (args.policy.requireExactTokenContract && !normalizedInstruction.tokenContract) {
+            reasons.push("Trade policy requires an exact token contract for ERC-20 transfers.");
+        }
+        if (normalizedInstruction.tokenDecimals === undefined) {
+            reasons.push(`No decimals are known for token '${normalizedInstruction.tokenSymbol}'.`);
+        }
+    }
+    if (args.policy.maxTokenAmount &&
+        isNumberishDecimal(normalizedInstruction.amount) &&
+        compareDecimalStrings(normalizedInstruction.amount, args.policy.maxTokenAmount) > 0) {
+        reasons.push(`Amount ${normalizedInstruction.amount} exceeds the configured max token amount ${args.policy.maxTokenAmount}.`);
+    }
+    if (reasons.length === 0) {
+        try {
+            const walletAddress = await getWalletAddress();
+            if (normalizedInstruction.assetKind === "native") {
+                const balance = await readNativeBalance(walletAddress);
+                const amountBaseUnits = await parseTokenAmount(normalizedInstruction.amount, normalizedInstruction.tokenDecimals ?? 18);
+                if (balance <= 0n) {
+                    reasons.push("The wallet does not have a native balance available for this transfer.");
+                }
+                else if (balance < amountBaseUnits) {
+                    reasons.push("The wallet does not have enough native balance for this transfer amount.");
+                }
+            }
+            else if (normalizedInstruction.tokenContract) {
+                const balance = await readErc20Balance({
+                    contract: normalizedInstruction.tokenContract,
+                    owner: walletAddress
+                });
+                const amountBaseUnits = await parseTokenAmount(normalizedInstruction.amount, normalizedInstruction.tokenDecimals ?? 0);
+                if (balance <= 0n) {
+                    reasons.push(`The wallet does not hold a positive ${normalizedInstruction.tokenSymbol} balance.`);
+                }
+                else if (balance < amountBaseUnits) {
+                    reasons.push(`The wallet does not hold enough ${normalizedInstruction.tokenSymbol} for this transfer amount.`);
+                }
+            }
+        }
+        catch (error) {
+            reasons.push(`Unable to verify wallet balance before execution: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return {
+        validation: {
+            ok: reasons.length === 0,
+            reasons
+        },
+        normalizedInstruction
+    };
+}

package/dist/utils/files.js

@@ -0,0 +1,59 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const DEFAULT_RENDER_DATA_ROOT = "/opt/render/project/src/data";
+export function ensureDir(dirPath) {
+    fs.mkdirSync(dirPath, { recursive: true });
+}
+export function readUtf8(filePath) {
+    return fs.readFileSync(filePath, "utf8");
+}
+export function writeJson(filePath, data) {
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf8");
+}
+export function writeText(filePath, content) {
+    fs.writeFileSync(filePath, content, "utf8");
+}
+function resolveDataRoot() {
+    const configuredRoot = process.env.SITE_AGENT_DATA_DIR?.trim();
+    if (configuredRoot) {
+        ensureDir(configuredRoot);
+        return configuredRoot;
+    }
+    if (process.env.RENDER === "true") {
+        ensureDir(DEFAULT_RENDER_DATA_ROOT);
+        return DEFAULT_RENDER_DATA_ROOT;
+    }
+    // Some serverless runtimes expose a read-only working tree.
+    if (process.cwd().startsWith('/var/task')) {
+        const tempRoot = path.join(os.tmpdir(), "site-agent-pro");
+        ensureDir(tempRoot);
+        return tempRoot;
+    }
+    return process.cwd();
+}
+export function timestampSlug() {
+    return new Date().toISOString().replace(/[:.]/g, "-");
+}
+export function safeSlug(input) {
+    return input
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/(^-|-$)/g, "");
+}
+export function resolveRunsDir() {
+    const dir = path.join(resolveDataRoot(), "runs");
+    ensureDir(dir);
+    return dir;
+}
+export function resolveRunDir(baseUrl) {
+    const host = new URL(baseUrl).hostname.replace(/^www\./, "");
+    const dir = path.join(resolveRunsDir(), `${timestampSlug()}-${safeSlug(host)}`);
+    ensureDir(dir);
+    return dir;
+}
+export function resolveSubmissionsDir() {
+    const dir = path.join(resolveDataRoot(), "submissions");
+    ensureDir(dir);
+    return dir;
+}

package/dist/utils/log.js

@@ -0,0 +1,24 @@
+import { inspect } from "node:util";
+function isDebugEnabled() {
+    const value = process.env.SITE_AGENT_DEBUG?.trim().toLowerCase();
+    return value === "1" || value === "true" || value === "yes" || value === "on";
+}
+export function info(message) {
+    process.stdout.write(`[INFO] ${message}\n`);
+}
+export function warn(message) {
+    process.stderr.write(`[WARN] ${message}\n`);
+}
+export function error(message) {
+    process.stderr.write(`[ERROR] ${message}\n`);
+}
+export function debug(message, details) {
+    if (!isDebugEnabled()) {
+        return;
+    }
+    if (details === undefined) {
+        process.stdout.write(`[DEBUG] ${message}\n`);
+        return;
+    }
+    process.stdout.write(`[DEBUG] ${message} ${inspect(details, { depth: 4, breakLength: 120 })}\n`);
+}

package/dist/utils/playwrightCompat.js

@@ -0,0 +1,14 @@
+const PLAYWRIGHT_PAGE_COMPAT_INIT_SCRIPT = `
+(() => {
+  if (typeof globalThis.__name !== "function") {
+    Object.defineProperty(globalThis, "__name", {
+      configurable: true,
+      writable: true,
+      value: (target) => target
+    });
+  }
+})();
+`;
+export async function installPlaywrightPageCompat(context) {
+    await context.addInitScript({ content: PLAYWRIGHT_PAGE_COMPAT_INIT_SCRIPT });
+}

package/dist/utils/time.js

@@ -0,0 +1,3 @@
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}