aavegotchi-cli 0.1.0

package/dist/commands/tx.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTxSendCommand = runTxSendCommand;
+exports.runTxStatusCommand = runTxStatusCommand;
+exports.runTxResumeCommand = runTxResumeCommand;
+exports.runTxWatchCommand = runTxWatchCommand;
+const args_1 = require("../args");
+const chains_1 = require("../chains");
+const config_1 = require("../config");
+const errors_1 = require("../errors");
+const tx_engine_1 = require("../tx-engine");
+function parseNoncePolicy(value) {
+    if (!value) {
+        return "safe";
+    }
+    if (value === "safe" || value === "replace" || value === "manual") {
+        return value;
+    }
+    throw new errors_1.CliError("INVALID_NONCE_POLICY", `Unsupported nonce policy '${value}'.`, 2);
+}
+function requireHexAddress(value, name) {
+    if (!value || !/^0x[a-fA-F0-9]{40}$/.test(value)) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", `${name} must be an EVM address.`, 2, {
+            value,
+        });
+    }
+    return value.toLowerCase();
+}
+function parseHexData(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (!/^0x([a-fA-F0-9]{2})*$/.test(value)) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "--data must be hex bytes prefixed with 0x.", 2, {
+            value,
+        });
+    }
+    return value;
+}
+function parseOptionalBigInt(value, name) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!/^\d+$/.test(value)) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", `${name} must be a non-negative integer string.`, 2, {
+            value,
+        });
+    }
+    return BigInt(value);
+}
+function parseNumberFlag(value, flag, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", `${flag} must be a non-negative integer.`, 2, {
+            value,
+        });
+    }
+    return parsed;
+}
+async function runTxSendCommand(ctx) {
+    const config = (0, config_1.loadConfig)();
+    const requestedProfile = (0, args_1.getFlagString)(ctx.args.flags, "profile") || ctx.globals.profile;
+    const profile = (0, config_1.getProfileOrThrow)(config, requestedProfile);
+    const policy = (0, config_1.getPolicyOrThrow)(config, profile.policy);
+    const chain = (0, chains_1.resolveChain)(profile.chain);
+    const rpcUrl = (0, chains_1.resolveRpcUrl)(chain, (0, args_1.getFlagString)(ctx.args.flags, "rpc-url") || profile.rpcUrl);
+    const to = requireHexAddress((0, args_1.getFlagString)(ctx.args.flags, "to"), "--to");
+    const valueWei = parseOptionalBigInt((0, args_1.getFlagString)(ctx.args.flags, "value-wei"), "--value-wei");
+    const data = parseHexData((0, args_1.getFlagString)(ctx.args.flags, "data"));
+    const idempotencyKey = (0, args_1.getFlagString)(ctx.args.flags, "idempotency-key");
+    const noncePolicy = parseNoncePolicy((0, args_1.getFlagString)(ctx.args.flags, "nonce-policy"));
+    const nonceValue = (0, args_1.getFlagString)(ctx.args.flags, "nonce");
+    const nonce = nonceValue ? parseNumberFlag(nonceValue, "--nonce", 0) : undefined;
+    const waitForReceipt = (0, args_1.getFlagBoolean)(ctx.args.flags, "wait") || (0, args_1.getFlagBoolean)(ctx.args.flags, "confirm");
+    const timeoutMs = parseNumberFlag((0, args_1.getFlagString)(ctx.args.flags, "timeout-ms"), "--timeout-ms", 120000);
+    if (noncePolicy === "manual" && nonce === undefined) {
+        throw new errors_1.CliError("MISSING_NONCE", "--nonce is required when --nonce-policy=manual.", 2);
+    }
+    const intent = {
+        idempotencyKey,
+        profileName: profile.name,
+        chainId: profile.chainId,
+        rpcUrl,
+        signer: profile.signer,
+        policy,
+        to,
+        data,
+        valueWei,
+        noncePolicy,
+        nonce,
+        waitForReceipt,
+        timeoutMs,
+        command: "tx send",
+    };
+    const result = await (0, tx_engine_1.executeTxIntent)(intent, chain);
+    return {
+        profile: profile.name,
+        policy: policy.name,
+        chainId: chain.chainId,
+        ...result,
+    };
+}
+async function runTxStatusCommand(ctx) {
+    const idempotencyKey = (0, args_1.getFlagString)(ctx.args.flags, "idempotency-key");
+    const txHash = (0, args_1.getFlagString)(ctx.args.flags, "tx-hash");
+    if (idempotencyKey) {
+        const entry = (0, tx_engine_1.getJournalEntryByIdempotency)(idempotencyKey);
+        if (!entry) {
+            throw new errors_1.CliError("TX_NOT_FOUND", `No transaction found for '${idempotencyKey}'.`, 2);
+        }
+        return {
+            type: "idempotency",
+            entry,
+        };
+    }
+    if (txHash) {
+        const entry = (0, tx_engine_1.getJournalEntryByHash)(txHash);
+        if (!entry) {
+            throw new errors_1.CliError("TX_NOT_FOUND", `No transaction found for hash '${txHash}'.`, 2);
+        }
+        return {
+            type: "hash",
+            entry,
+        };
+    }
+    return {
+        type: "recent",
+        entries: (0, tx_engine_1.getRecentJournalEntries)(parseNumberFlag((0, args_1.getFlagString)(ctx.args.flags, "limit"), "--limit", 20)),
+    };
+}
+async function runTxResumeCommand(ctx) {
+    const idempotencyKey = (0, args_1.getFlagString)(ctx.args.flags, "idempotency-key");
+    if (!idempotencyKey) {
+        throw new errors_1.CliError("MISSING_ARGUMENT", "tx resume requires --idempotency-key <value>.", 2);
+    }
+    const config = (0, config_1.loadConfig)();
+    const requestedProfile = (0, args_1.getFlagString)(ctx.args.flags, "profile") || ctx.globals.profile;
+    const profile = (0, config_1.getProfileOrThrow)(config, requestedProfile);
+    const chain = (0, chains_1.resolveChain)(profile.chain);
+    const rpcUrl = (0, chains_1.resolveRpcUrl)(chain, (0, args_1.getFlagString)(ctx.args.flags, "rpc-url") || profile.rpcUrl);
+    const timeoutMs = parseNumberFlag((0, args_1.getFlagString)(ctx.args.flags, "timeout-ms"), "--timeout-ms", 120000);
+    const result = await (0, tx_engine_1.resumeTransaction)(idempotencyKey, chain, rpcUrl, timeoutMs);
+    return {
+        profile: profile.name,
+        ...result,
+    };
+}
+async function runTxWatchCommand(ctx) {
+    const idempotencyKey = (0, args_1.getFlagString)(ctx.args.flags, "idempotency-key");
+    if (!idempotencyKey) {
+        throw new errors_1.CliError("MISSING_ARGUMENT", "tx watch requires --idempotency-key <value>.", 2);
+    }
+    const intervalMs = parseNumberFlag((0, args_1.getFlagString)(ctx.args.flags, "interval-ms"), "--interval-ms", 3000);
+    const timeoutMs = parseNumberFlag((0, args_1.getFlagString)(ctx.args.flags, "timeout-ms"), "--timeout-ms", 180000);
+    const started = Date.now();
+    while (Date.now() - started < timeoutMs) {
+        const entry = (0, tx_engine_1.getJournalEntryByIdempotency)(idempotencyKey);
+        if (entry?.status === "confirmed") {
+            return {
+                idempotencyKey,
+                status: "confirmed",
+                entry,
+            };
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    throw new errors_1.CliError("TIMEOUT", `Timed out waiting for '${idempotencyKey}' to confirm.`, 2, {
+        timeoutMs,
+    });
+}

package/dist/config.js

@@ -0,0 +1,198 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultPolicy = createDefaultPolicy;
+exports.resolveAgcliHome = resolveAgcliHome;
+exports.resolveConfigPath = resolveConfigPath;
+exports.resolveJournalPath = resolveJournalPath;
+exports.resolveKeychainPath = resolveKeychainPath;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.upsertProfile = upsertProfile;
+exports.upsertPolicy = upsertPolicy;
+exports.setActiveProfile = setActiveProfile;
+exports.getProfileOrThrow = getProfileOrThrow;
+exports.getPolicyOrThrow = getPolicyOrThrow;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const errors_1 = require("./errors");
+const schemas_1 = require("./schemas");
+const CONFIG_FILE = "config.json";
+const JOURNAL_FILE = "journal.sqlite";
+const KEYCHAIN_FILE = "keychain.json";
+function nowIso() {
+    return new Date().toISOString();
+}
+function createDefaultPolicy(name = "default", timestamp = nowIso()) {
+    return {
+        name,
+        maxValueWei: undefined,
+        maxGasLimit: undefined,
+        maxFeePerGasWei: undefined,
+        maxPriorityFeePerGasWei: undefined,
+        allowedTo: undefined,
+        createdAt: timestamp,
+        updatedAt: timestamp,
+    };
+}
+function createDefaultConfig() {
+    const timestamp = nowIso();
+    return {
+        schemaVersion: 2,
+        profiles: {},
+        policies: {
+            default: createDefaultPolicy("default", timestamp),
+        },
+    };
+}
+function resolveAgcliHome(customHome) {
+    if (customHome) {
+        return customHome;
+    }
+    if (process.env.AGCLI_HOME) {
+        return process.env.AGCLI_HOME;
+    }
+    return path.join(os.homedir(), ".aavegotchi-cli");
+}
+function resolveConfigPath(customHome) {
+    const home = resolveAgcliHome(customHome);
+    return path.join(home, CONFIG_FILE);
+}
+function resolveJournalPath(customHome) {
+    const home = resolveAgcliHome(customHome);
+    return path.join(home, JOURNAL_FILE);
+}
+function resolveKeychainPath(customHome) {
+    const home = resolveAgcliHome(customHome);
+    return path.join(home, KEYCHAIN_FILE);
+}
+function migrateLegacyConfig(raw) {
+    const legacy = schemas_1.legacyCliConfigSchema.parse(raw);
+    const base = createDefaultConfig();
+    const policies = { ...base.policies };
+    for (const profile of Object.values(legacy.profiles)) {
+        if (!policies[profile.policy]) {
+            policies[profile.policy] = createDefaultPolicy(profile.policy, profile.createdAt);
+        }
+    }
+    return {
+        schemaVersion: 2,
+        activeProfile: legacy.activeProfile,
+        profiles: legacy.profiles,
+        policies,
+    };
+}
+function loadConfig(customHome) {
+    const configPath = resolveConfigPath(customHome);
+    if (!fs.existsSync(configPath)) {
+        return createDefaultConfig();
+    }
+    const raw = fs.readFileSync(configPath, "utf8");
+    let parsedJson;
+    try {
+        parsedJson = JSON.parse(raw);
+    }
+    catch {
+        throw new errors_1.CliError("INVALID_CONFIG", `Config file is not valid JSON: ${configPath}`, 2);
+    }
+    if (typeof parsedJson === "object" &&
+        parsedJson !== null &&
+        "schemaVersion" in parsedJson &&
+        parsedJson.schemaVersion === 1) {
+        return migrateLegacyConfig(parsedJson);
+    }
+    const parsed = schemas_1.cliConfigSchema.safeParse(parsedJson);
+    if (!parsed.success) {
+        throw new errors_1.CliError("INVALID_CONFIG", `Unsupported config format in ${configPath}.`, 2, {
+            issues: parsed.error.issues,
+        });
+    }
+    return parsed.data;
+}
+function saveConfig(config, customHome) {
+    const home = resolveAgcliHome(customHome);
+    const configPath = resolveConfigPath(customHome);
+    fs.mkdirSync(home, { recursive: true });
+    const tmpPath = `${configPath}.tmp`;
+    fs.writeFileSync(tmpPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+    fs.renameSync(tmpPath, configPath);
+    return configPath;
+}
+function upsertProfile(config, profile) {
+    return {
+        ...config,
+        profiles: {
+            ...config.profiles,
+            [profile.name]: profile,
+        },
+    };
+}
+function upsertPolicy(config, policy) {
+    return {
+        ...config,
+        policies: {
+            ...config.policies,
+            [policy.name]: policy,
+        },
+    };
+}
+function setActiveProfile(config, profileName) {
+    if (!config.profiles[profileName]) {
+        throw new errors_1.CliError("PROFILE_NOT_FOUND", `Profile '${profileName}' does not exist.`, 2);
+    }
+    return {
+        ...config,
+        activeProfile: profileName,
+    };
+}
+function getProfileOrThrow(config, profileName) {
+    const selectedName = profileName || config.activeProfile;
+    if (!selectedName) {
+        throw new errors_1.CliError("NO_ACTIVE_PROFILE", "No active profile. Set one with 'ag profile use --profile <name>'.", 2);
+    }
+    const profile = config.profiles[selectedName];
+    if (!profile) {
+        throw new errors_1.CliError("PROFILE_NOT_FOUND", `Profile '${selectedName}' does not exist.`, 2);
+    }
+    return profile;
+}
+function getPolicyOrThrow(config, policyName) {
+    const policy = config.policies[policyName];
+    if (!policy) {
+        throw new errors_1.CliError("POLICY_NOT_FOUND", `Policy '${policyName}' does not exist.`, 2);
+    }
+    return policy;
+}

package/dist/errors.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliError = void 0;
+exports.assertCondition = assertCondition;
+exports.toCliError = toCliError;
+class CliError extends Error {
+    code;
+    exitCode;
+    details;
+    constructor(code, message, exitCode = 1, details) {
+        super(message);
+        this.code = code;
+        this.exitCode = exitCode;
+        this.details = details;
+    }
+}
+exports.CliError = CliError;
+function assertCondition(condition, code, message, details) {
+    if (!condition) {
+        throw new CliError(code, message, 2, details);
+    }
+}
+function toCliError(error) {
+    if (error instanceof CliError) {
+        return error;
+    }
+    if (error instanceof Error) {
+        return new CliError("UNEXPECTED_ERROR", error.message, 1);
+    }
+    return new CliError("UNEXPECTED_ERROR", "An unknown error occurred.", 1);
+}

package/dist/idempotency.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveIdempotencyKey = deriveIdempotencyKey;
+exports.resolveIdempotencyKey = resolveIdempotencyKey;
+const crypto_1 = require("crypto");
+function deriveIdempotencyKey(intent) {
+    const source = JSON.stringify({
+        command: intent.command,
+        profileName: intent.profileName,
+        chainId: intent.chainId,
+        to: intent.to,
+        data: intent.data || "0x",
+        valueWei: intent.valueWei?.toString() || "0",
+        noncePolicy: intent.noncePolicy,
+        nonce: intent.nonce,
+    });
+    return (0, crypto_1.createHash)("sha256").update(source).digest("hex");
+}
+function resolveIdempotencyKey(intent) {
+    return intent.idempotencyKey || deriveIdempotencyKey(intent);
+}

package/dist/index.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const args_1 = require("./args");
+const command_runner_1 = require("./command-runner");
+const errors_1 = require("./errors");
+const logger_1 = require("./logger");
+const output_1 = require("./output");
+async function run() {
+    const args = (0, args_1.parseArgv)(process.argv.slice(2));
+    const globals = (0, args_1.normalizeGlobals)(args);
+    (0, logger_1.initializeLogger)(globals);
+    const commandPath = (0, command_runner_1.normalizeCommandPath)(args.positionals);
+    if (commandPath[0] === "help") {
+        (0, output_1.outputHelp)();
+        return;
+    }
+    const ctx = {
+        commandPath,
+        args,
+        globals,
+    };
+    const { commandName, data } = await (0, command_runner_1.executeCommand)(ctx);
+    (0, output_1.outputSuccess)(commandName, data, globals);
+}
+run().catch((error) => {
+    const args = (0, args_1.parseArgv)(process.argv.slice(2));
+    const globals = (0, args_1.normalizeGlobals)(args);
+    (0, logger_1.initializeLogger)(globals);
+    const cliError = (0, errors_1.toCliError)(error);
+    (0, output_1.outputError)(args.positionals.join(" ") || "unknown", cliError, globals);
+    process.exitCode = cliError.exitCode;
+});