@namera-ai/cli 0.0.0

package/dist/index.mjs

@@ -0,0 +1,3270 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import { NodeHttpServer, NodeRuntime, NodeServices, NodeStdio } from "@effect/platform-node";
+import { Config, ConfigProvider, Console, Data, Duration, Effect, FileSystem, Layer, Logger, Option, Path, Redacted, Schema, SchemaTransformation, ServiceMap, Struct } from "effect";
+import { Argument, Command, Flag, GlobalFlag, Prompt } from "effect/unstable/cli";
+import { arbitrum, arbitrumSepolia, arcTestnet, avalanche, avalancheFuji, base, baseSepolia, celo, celoSepolia, mainnet, monad, monadTestnet, optimism, optimismSepolia, polygon, polygonAmoy, scroll, scrollSepolia, sepolia, tempoModerato, unichain, unichainSepolia, zora, zoraSepolia } from "viem/chains";
+import os from "node:os";
+import { Wallet } from "@ethereumjs/wallet";
+import { createPublicClient, formatEther, formatUnits, hexToBytes, http, isHex, parseEther, parseUnits, toFunctionSelector, toHex, zeroAddress } from "viem";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+import { createServer } from "node:http";
+import { McpServer, Tool, Toolkit } from "effect/unstable/ai";
+import { HttpRouter } from "effect/unstable/http";
+import { getBalance, readContract } from "viem/actions";
+import { createSessionKey, createSessionKeyClient, deserializePermissionAccountParams, isSessionKeyInstalled } from "@namera-ai/sdk/session-key";
+import { executeTransaction } from "@namera-ai/sdk/transaction";
+import { CallPolicyVersion, CallType, ParamCondition, toCallPolicy, toGasPolicy, toRateLimitPolicy, toSignatureCallerPolicy, toSudoPolicy, toTimestampPolicy } from "@namera-ai/sdk/policy";
+import { createAccountClient } from "@namera-ai/sdk/account";
+import { NdJson } from "json-nd";
+//#region src/dto/keystore.ts
+const Keystore = Schema.Struct({
+	version: Schema.Number,
+	id: Schema.String,
+	address: Schema.String,
+	crypto: Schema.Any
+});
+Schema.Struct({
+	path: Schema.String,
+	alias: Schema.String,
+	data: Keystore
+});
+const GetKeystoreParams = Schema.Struct({ alias: Schema.String.annotate({ description: "The alias of the wallet to retrieve" }) });
+const ListKeystoreParams = Schema.Void;
+const CreateKeystoreParams = Schema.Struct({
+	alias: Schema.String.annotate({ description: "The alias of the wallet to create" }),
+	password: Schema.redact(Schema.String).annotate({ description: "The password to encrypt the keystore with" })
+});
+const DecryptKeystoreParams = Schema.Struct({
+	alias: Schema.String.annotate({ description: "The alias of the keystore to decrypt" }),
+	password: Schema.redact(Schema.String).annotate({ description: "The password to decrypt the keystore with" })
+});
+Schema.Struct({
+	address: Schema.String.annotate({ description: "The address of the keystore" }),
+	alias: Schema.String.annotate({ description: "The alias of the keystore" }),
+	privateKey: Schema.Redacted(Schema.String).annotate({ description: "The private key of the keystore" }),
+	publicKey: Schema.String.annotate({ description: "The public key of the keystore" })
+});
+const ImportKeystoreParams = Schema.Struct({
+	alias: Schema.String.annotate({ description: "The alias of the keystore to import" }),
+	privateKey: Schema.String.annotate({ description: "The private key of the keystore to import" }),
+	password: Schema.redact(Schema.String).annotate({ description: "The password to encrypt the keystore with" })
+});
+const RemoveKeystoreParams = Schema.Struct({ alias: Schema.String.annotate({ description: "The alias of the keystore to remove" }) });
+Schema.Struct({
+	alias: Schema.String.annotate({ description: "The alias of the keystore to get the signer for" }),
+	password: Schema.redact(Schema.String).annotate({ description: "The password to decrypt the keystore with" })
+});
+//#endregion
+//#region src/dto/mcp.ts
+const StartMcpServerParams = Schema.Struct({
+	smartAccountAlias: Schema.String.annotate({ description: "The alias of the smart account to use for the MCP server" }),
+	transport: Schema.Literals(["http", "stdio"]).annotate({ description: "The transport to use for the MCP server" }),
+	port: Schema.optional(Schema.Int.check(Schema.makeFilter((v) => v > 0 && v < 65536))).annotate({ description: "The port to use for the MCP server when using http transport" }),
+	sessionKeys: Schema.mutableKey(Schema.Record(Schema.String, Schema.String))
+});
+//#endregion
+//#region src/schema/chain.ts
+const supportedMainnetChains = {
+	"eth-mainnet": {
+		...mainnet,
+		key: "eth-mainnet"
+	},
+	"opt-mainnet": {
+		...optimism,
+		key: "opt-mainnet"
+	},
+	"polygon-mainnet": {
+		...polygon,
+		key: "polygon-mainnet"
+	},
+	"arb-mainnet": {
+		...arbitrum,
+		key: "arb-mainnet"
+	},
+	"zora-mainnet": {
+		...zora,
+		key: "zora-mainnet"
+	},
+	"base-mainnet": {
+		...base,
+		key: "base-mainnet"
+	},
+	"avax-mainnet": {
+		...avalanche,
+		key: "avax-mainnet"
+	},
+	"unichain-mainnet": {
+		...unichain,
+		key: "unichain-mainnet"
+	},
+	"celo-mainnet": {
+		...celo,
+		key: "celo-mainnet"
+	},
+	"scroll-mainnet": {
+		...scroll,
+		key: "scroll-mainnet"
+	},
+	"monad-mainnet": {
+		...monad,
+		key: "monad-mainnet"
+	}
+};
+const supportedTestnetChains = {
+	"eth-sepolia": {
+		...sepolia,
+		key: "eth-sepolia"
+	},
+	"opt-sepolia": {
+		...optimismSepolia,
+		key: "opt-sepolia"
+	},
+	"polygon-amoy": {
+		...polygonAmoy,
+		key: "polygon-amoy"
+	},
+	"arb-sepolia": {
+		...arbitrumSepolia,
+		key: "arb-sepolia"
+	},
+	"zora-sepolia": {
+		...zoraSepolia,
+		key: "zora-sepolia"
+	},
+	"base-sepolia": {
+		...baseSepolia,
+		key: "base-sepolia"
+	},
+	"tempo-moderato": {
+		...tempoModerato,
+		key: "tempo-moderato"
+	},
+	"avax-fuji": {
+		...avalancheFuji,
+		key: "avax-fuji"
+	},
+	"unichain-sepolia": {
+		...unichainSepolia,
+		key: "unichain-sepolia"
+	},
+	"monad-testnet": {
+		...monadTestnet,
+		key: "monad-testnet"
+	},
+	"celo-sepolia": {
+		...celoSepolia,
+		key: "celo-sepolia"
+	},
+	"scroll-sepolia": {
+		...scrollSepolia,
+		key: "scroll-sepolia"
+	},
+	"arc-testnet": {
+		...arcTestnet,
+		key: "arc-testnet"
+	}
+};
+const SupportedChain = Schema.Literals([...Object.keys(supportedMainnetChains), ...Object.keys(supportedTestnetChains)]);
+const supportedChains = {
+	...supportedMainnetChains,
+	...supportedTestnetChains
+};
+const getChain = (chain) => {
+	return supportedChains[chain];
+};
+const getChainFromId = (chainId) => {
+	return Object.values(supportedChains).find((c) => c.id === chainId);
+};
+const chainIdToChainName = (chainId) => {
+	const chain = getChainFromId(chainId);
+	if (!chain) throw new Error(`Chain with id ${chainId} not found`);
+	return chain.key;
+};
+//#endregion
+//#region src/schema/common.ts
+const BigIntFromString = Schema.String.pipe(Schema.decodeTo(Schema.BigInt, SchemaTransformation.transform({
+	encode: (v) => v.toString(),
+	decode: (v) => BigInt(v)
+})));
+const EthereumAddress = Schema.TemplateLiteral(["0x", Schema.String.check(Schema.isPattern(/^[0-9a-fA-F]{40}$/))]);
+const Hex = Schema.TemplateLiteral(["0x", Schema.String.check(Schema.isPattern(/^[0-9a-fA-F]*$/))]);
+const EntrypointVersion = Schema.Literals([
+	"0.7",
+	"0.8",
+	"0.9"
+]);
+const KernelVersion = Schema.Literals([
+	"0.3.0",
+	"0.3.1",
+	"0.3.2",
+	"0.3.3"
+]);
+const OwnerType = Schema.Literals([
+	"ecdsa",
+	"passkey",
+	"multisig"
+]);
+//#endregion
+//#region src/schema/policy.ts
+const SudoPolicyParams = Schema.Struct({ type: Schema.Literal("sudo") });
+const TimestampPolicyParams = Schema.Struct({
+	type: Schema.Literal("timestamp"),
+	validAfter: Schema.optional(Schema.Number).pipe(Schema.withDecodingDefault(() => 0)).annotate({ description: "The timestamp in seconds after which signer is valid. If not provided, the signer is valid immediately." }),
+	validUntil: Schema.optional(Schema.Number).pipe(Schema.withDecodingDefault(() => 0)).annotate({ description: "The timestamp in seconds until which signer is valid. If not provided, the signer is valid indefinitely." })
+});
+const SignatureCallerPolicyParams = Schema.Struct({
+	type: Schema.Literal("signature-caller"),
+	allowedCallers: Schema.mutable(Schema.Array(EthereumAddress)).annotate({ description: "List of addresses that are allowed to validate messages signed by the signer." })
+});
+const RateLimitPolicyParams = Schema.Struct({
+	type: Schema.Literal("rate-limit"),
+	interval: Schema.optional(Schema.Number).annotate({ description: "Length of interval in seconds" }),
+	count: Schema.Number.annotate({ description: "The number of calls allowed within the interval" }),
+	startAt: Schema.optional(Schema.Number).annotate({ description: "The timestamp in seconds at which the rate limit starts. Before this signer cannot sign any UserOperations" })
+});
+const GasPolicyParams = Schema.Struct({
+	type: Schema.Literal("gas"),
+	amount: Schema.optional(BigIntFromString).annotate({ description: "Amount, in wei that the signer can spend on gas, in total across all UserOps it sends." }),
+	enforcePaymaster: Schema.optional(Schema.Boolean).annotate({
+		description: "If set to true, enforce that a paymaster must be used.",
+		default: false
+	})
+});
+const CallPolicyVersion$1 = Schema.Literals([
+	"0.0.1",
+	"0.0.2",
+	"0.0.3",
+	"0.0.4",
+	"0.0.5"
+]);
+const CallType$1 = Schema.Literals([
+	"call",
+	"delegatecall",
+	"batch-call"
+]);
+const ParamCondition$1 = Schema.Literals([
+	"EQUAL",
+	"GREATER_THAN",
+	"LESS_THAN",
+	"GREATER_THAN_OR_EQUAL",
+	"LESS_THAN_OR_EQUAL",
+	"NOT_EQUAL",
+	"ONE_OF",
+	"SLICE_EQUAL"
+]);
+const ConditionValue = Schema.Union([
+	Schema.Struct({
+		condition: ParamCondition$1.pick(["ONE_OF"]),
+		value: Schema.mutable(Schema.Array(Schema.Any)).annotate({ description: "The value of the argument to use with the operator." })
+	}),
+	Schema.Struct({
+		condition: ParamCondition$1.pick(["SLICE_EQUAL"]),
+		value: Schema.Any.annotate({ description: "The value of the argument to use with the operator." }),
+		start: Schema.Number,
+		length: Schema.Number
+	}),
+	Schema.Struct({
+		condition: ParamCondition$1.pick([
+			"EQUAL",
+			"GREATER_THAN",
+			"LESS_THAN",
+			"GREATER_THAN_OR_EQUAL",
+			"LESS_THAN_OR_EQUAL",
+			"NOT_EQUAL",
+			"SLICE_EQUAL"
+		]),
+		value: Schema.Any.annotate({ description: "The value of the argument to use with the operator." })
+	}),
+	Schema.Null
+]);
+const ParamRule = Schema.Struct({
+	condition: ParamCondition$1,
+	offset: Schema.Number,
+	params: Schema.Union([Hex, Schema.mutable(Schema.Array(Hex))])
+});
+const PermissionCore = Schema.Struct({
+	callType: Schema.optional(CallType$1).pipe(Schema.withDecodingDefault(() => "call")).annotate({
+		description: "The type of call to make",
+		default: "call"
+	}),
+	target: EthereumAddress.annotate({ description: "The target contract to call or address to send ETH to. If this is zeroAddress, then the target can be any contract as long as the ABI matches (or it can be any address if no ABI is specified)" }),
+	selector: Schema.optional(Hex).annotate({ description: "The function selector if the target is a contract" }),
+	valueLimit: Schema.optional(BigIntFromString).annotate({ description: "The maximum value in wei that can be sent to the target" }),
+	rules: Schema.optional(Schema.Array(ParamRule))
+});
+const PermissionManual = PermissionCore;
+const PermissionWithABI = PermissionCore.mapFields(Struct.omit(["rules"])).mapFields(Struct.assign({
+	abi: Schema.mutable(Schema.Array(Schema.Any)).annotate({ description: "The ABI of the target contract" }),
+	functionName: Schema.String.annotate({ description: "The function name" }),
+	args: Schema.optional(Schema.Array(ConditionValue)).annotate({ description: "An array of conditions, each corresponding to an argument, in the order that the arguments are laid out. use null to skip an argument." })
+}));
+const Permission = Schema.Union([PermissionManual, PermissionWithABI]);
+const CallPolicyParams = Schema.Struct({
+	type: Schema.Literal("call"),
+	policyVersion: CallPolicyVersion$1,
+	permissions: Schema.optional(Schema.Array(Permission))
+});
+const PolicyParams = Schema.Union([
+	SudoPolicyParams,
+	TimestampPolicyParams,
+	SignatureCallerPolicyParams,
+	RateLimitPolicyParams,
+	GasPolicyParams,
+	CallPolicyParams
+]);
+//#endregion
+//#region src/dto/session-key.ts
+const BaseSessionKey = Schema.Struct({
+	smartAccountAlias: Schema.String,
+	serializedAccounts: Schema.Array(Schema.Struct({
+		chain: SupportedChain,
+		serializedAccount: Schema.String
+	}))
+}).mapFields(Struct.assign(Keystore.fields));
+const EcdsaSessionKey = Schema.Struct({
+	sessionKeyType: Schema.Literal("ecdsa"),
+	sessionKeyAddress: EthereumAddress,
+	smartAccountAlias: Schema.String
+}).mapFields(Struct.assign(BaseSessionKey.fields));
+const PasskeySessionKey = Schema.Struct({
+	sessionKeyType: Schema.Literal("passkey"),
+	passKeyName: Schema.String
+}).mapFields(Struct.assign(BaseSessionKey.fields));
+const SessionKey = Schema.Union([EcdsaSessionKey, PasskeySessionKey]);
+Schema.Struct({
+	alias: Schema.String,
+	data: SessionKey,
+	path: Schema.String
+});
+const CreateSessionKeyParams = Schema.Struct({
+	alias: Schema.String.annotate({ description: "The alias of the session key to create" }),
+	chains: Schema.mutable(Schema.Array(SupportedChain)).annotate({ description: "The chains to create the session key for" }),
+	policyParams: Schema.mutable(Schema.Array(PolicyParams)),
+	smartAccountAlias: Schema.String.annotate({ description: "The alias of the smart account to create the session key for" }),
+	ownerKeystorePassword: Schema.redact(Schema.String).annotate({ description: "The password to decrypt the owner keystore with" }),
+	sessionKeyPassword: Schema.redact(Schema.String).annotate({ description: "The password to encrypt the session key with" })
+});
+Schema.Struct({ alias: Schema.String.annotate({ description: "The alias of the session key to retrieve" }) });
+const ListSessionKeysParams = Schema.Struct({ smartAccount: Schema.optional(Schema.String).annotate({ description: "The alias of the smart account to list session keys for" }) });
+const GetSessionKeyInfoParams = Schema.Struct({ alias: Schema.String.annotate({ description: "The alias of the session key to retrieve" }) });
+const GetSessionKeyStatusParams = Schema.Struct({
+	alias: Schema.String.annotate({ description: "The alias of the session key to retrieve" }),
+	chain: SupportedChain.annotate({ description: "The chain to retrieve the session key status for" }),
+	rpcUrl: Schema.redact(Schema.String.pipe(Schema.optional)).annotate({
+		description: "The RPC URL to use for the chain",
+		default: "Public RPC URL"
+	})
+});
+const RemoveSessionKeyParams = Schema.Struct({ alias: Schema.String.annotate({ description: "The alias of the session key to remove" }) });
+//#endregion
+//#region src/dto/smart-account.ts
+const LocalSmartAccount = Schema.Struct({
+	entryPointVersion: EntrypointVersion,
+	index: BigIntFromString,
+	kernelVersion: KernelVersion,
+	ownerAlias: Schema.String,
+	ownerType: OwnerType,
+	smartAccountAddress: EthereumAddress
+});
+Schema.Struct({
+	data: LocalSmartAccount,
+	path: Schema.String,
+	alias: Schema.String
+});
+const CreateSmartAccountParams = Schema.Struct({
+	alias: Schema.String.annotate({ description: "The alias of the smart account to create" }),
+	ownerAlias: Schema.String.annotate({ description: "The alias of the owner keystore" }),
+	ownerPassword: Schema.redact(Schema.String).annotate({ description: "The password of the owner keystore" }),
+	index: Schema.optional(BigIntFromString.check(Schema.makeFilter((v) => v >= 0n))).annotate({
+		description: "The index of the smart account",
+		default: 0n
+	})
+});
+Schema.Struct({ alias: Schema.String.annotate({ description: "The alias of the smart account to retrieve" }) });
+const ListSmartAccountParams = Schema.Void;
+const GetSmartAccountInfoParams = Schema.Struct({ alias: Schema.String.annotate({ description: "The alias of the smart account to retrieve" }) });
+const RemoveSmartAccountParams = Schema.Struct({ alias: Schema.String.annotate({ description: "The alias of the smart account to remove" }) });
+const GetSmartAccountStatusParams = Schema.Struct({
+	alias: Schema.String.annotate({ description: "The alias of the smart account" }),
+	chain: SupportedChain.annotate({ description: "The chain to get the status for" }),
+	rpcUrl: Schema.redact(Schema.String.pipe(Schema.optional)).annotate({
+		description: "The RPC URL to use for the chain",
+		default: "Public RPC URL"
+	})
+});
+const ImportSmartAccountParams = LocalSmartAccount.pipe(Schema.fieldsAssign({ alias: Schema.String.annotate({ description: "The alias of the smart account to import" }) }));
+//#endregion
+//#region src/flags/global.ts
+const globalOutput = GlobalFlag.setting("output")({ flag: Flag.choice("output", [
+	"pretty",
+	"json",
+	"ndjson"
+]).pipe(Flag.withAlias("o"), Flag.withDefault("pretty"), Flag.withDescription("Output format (pretty, json, ndjson)")) });
+const globalQuite = GlobalFlag.setting("quite")({ flag: Flag.boolean("quite").pipe(Flag.withAlias("q"), Flag.withDefault(false), Flag.withDescription("Do not print output")) });
+const globalParams = GlobalFlag.setting("params")({ flag: Flag.string("params").pipe(Flag.optional, Flag.withDescription("JSON Parameters to pass to the command")) });
+const getGlobalFlags = () => Effect.gen(function* () {
+	const out = yield* globalOutput;
+	const quite = yield* globalQuite;
+	return {
+		out,
+		params: yield* globalParams,
+		quite
+	};
+});
+const globalFlags = [
+	globalOutput,
+	globalQuite,
+	globalParams
+];
+//#endregion
+//#region src/types/index.ts
+const entityName = {
+	keystore: "Keystore",
+	"session-key": "Session Key",
+	"smart-account": "Smart Account"
+};
+//#endregion
+//#region src/layers/config.ts
+/**
+* Domain error for configuration and entity storage operations.
+*/
+var ConfigManagerError = class extends Data.TaggedError("@namera-ai/cli/ConfigManagerError") {};
+/**
+* Service tag for resolving {@link ConfigManager} from the Effect context.
+*/
+const ConfigManager = ServiceMap.Service("@namera-ai/cli/ConfigManager");
+/**
+* Live layer that persists CLI entities in the user's config directory.
+*/
+const layer$7 = Layer.effect(ConfigManager, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const getConfigDirPath = () => Effect.gen(function* () {
+		const homeDir = yield* Effect.sync(() => os.homedir());
+		return path.join(homeDir, ".namera");
+	});
+	const ensureConfigDirExists = () => Effect.gen(function* () {
+		const baseDir = yield* getConfigDirPath();
+		const directoriesToCreate = [
+			"smart-accounts",
+			"session-keys",
+			"keystores"
+		].map((dir) => path.join(baseDir, dir));
+		yield* Effect.forEach(directoriesToCreate, (dirPath) => fs.makeDirectory(dirPath, { recursive: true }).pipe(Effect.catchTag("PlatformError", (e) => Effect.fail(new ConfigManagerError({
+			code: "InitializationError",
+			message: e.message
+		})))), { concurrency: "unbounded" });
+	});
+	const getEntityPath = (entity) => Effect.gen(function* () {
+		const baseDir = yield* getConfigDirPath();
+		return path.join(baseDir, `${entity.type}s`, entity.alias);
+	});
+	const checkEntityExists = (entity) => Effect.gen(function* () {
+		const entityPath = yield* getEntityPath(entity);
+		return yield* fs.exists(entityPath).pipe(Effect.catchTag("PlatformError", (e) => Effect.fail(new ConfigManagerError({
+			code: e.reason._tag,
+			message: e.message
+		}))));
+	});
+	const getEntity = (entity) => Effect.gen(function* () {
+		const entityPath = yield* getEntityPath(entity);
+		if (yield* checkEntityExists(entity)) {
+			const content = yield* fs.readFileString(entityPath);
+			return {
+				alias: entity.alias,
+				content,
+				path: entityPath,
+				type: entity.type
+			};
+		}
+		return yield* Effect.fail(new ConfigManagerError({
+			code: "EntityNotFound",
+			message: `${entityName[entity.type]} with alias ${entity.alias} does not exist`
+		}));
+	}).pipe(Effect.catchTag("PlatformError", (e) => Effect.fail(new ConfigManagerError({
+		code: e.reason._tag,
+		message: e.message
+	}))));
+	const getEntitiesForType = (type) => Effect.gen(function* () {
+		const baseDir = yield* getConfigDirPath();
+		const entitiesDir = path.join(baseDir, `${type}s`);
+		const effects = (yield* fs.readDirectory(entitiesDir)).map((entityName) => Effect.gen(function* () {
+			const entityPath = path.join(entitiesDir, entityName);
+			return {
+				alias: entityName,
+				content: yield* fs.readFileString(entityPath),
+				path: entityPath,
+				type
+			};
+		}));
+		return yield* Effect.all(effects, { concurrency: "unbounded" });
+	}).pipe(Effect.catchTag("PlatformError", (e) => Effect.fail(new ConfigManagerError({
+		code: e.reason._tag,
+		message: e.message
+	}))));
+	const storeEntity = (entity) => Effect.gen(function* () {
+		const entityPath = yield* getEntityPath(entity);
+		if (yield* checkEntityExists({
+			alias: entity.alias,
+			type: entity.type
+		})) return yield* Effect.fail(new ConfigManagerError({
+			code: "EntityAlreadyExists",
+			message: `Entity ${entity.alias} already exists`
+		}));
+		yield* fs.writeFileString(entityPath, entity.content);
+		return {
+			alias: entity.alias,
+			content: entity.content,
+			path: entityPath,
+			type: entity.type
+		};
+	}).pipe(Effect.catchTag("PlatformError", (e) => Effect.fail(new ConfigManagerError({
+		code: e.reason._tag,
+		message: e.message
+	}))));
+	const removeEntity = (entity) => Effect.gen(function* () {
+		const entityPath = yield* getEntityPath(entity);
+		yield* fs.remove(entityPath).pipe(Effect.catchTag("PlatformError", (e) => Effect.fail(new ConfigManagerError({
+			code: e.reason._tag,
+			message: e.message
+		}))));
+	});
+	return ConfigManager.of({
+		checkEntityExists,
+		ensureConfigDirExists,
+		getConfigDirPath,
+		getEntitiesForType,
+		getEntity,
+		getEntityPath,
+		storeEntity,
+		removeEntity
+	});
+}));
+//#endregion
+//#region src/layers/prompt.ts
+/**
+* Service tag for resolving {@link PromptManager} from the Effect context.
+*/
+const PromptManager = ServiceMap.Service("@namera-ai/cli/PromptManager");
+/**
+* Live layer that validates and returns interactive prompt input.
+*/
+const layer$6 = Layer.effect(PromptManager, Effect.gen(function* () {
+	const configManager = yield* ConfigManager;
+	const aliasPrompt = (params) => Effect.gen(function* () {
+		return yield* Prompt.text({
+			message: params.message,
+			validate: (v) => Effect.gen(function* () {
+				if (v.trim() === "") return yield* Effect.fail("Alias cannot be empty");
+				const exists = yield* configManager.checkEntityExists({
+					alias: v,
+					type: params.type
+				}).pipe(Effect.catchTag("@namera-ai/cli/ConfigManagerError", (e) => Effect.fail(e.message)));
+				if (params.aliasType === "new" && exists) return yield* Effect.fail(`${entityName[params.type]} with alias ${v} already exists`);
+				if (params.aliasType === "existing" && !exists) return yield* Effect.fail(`${entityName[params.type]} with alias ${v} does not exist`);
+				return v;
+			})
+		});
+	});
+	const passwordPrompt = (params) => Effect.gen(function* () {
+		return yield* Prompt.password({
+			message: params.message,
+			validate: (v) => Effect.gen(function* () {
+				if (v.trim() === "") return yield* Effect.fail("Password cannot be empty");
+				if (params.validate) return yield* params.validate(v);
+				return v;
+			})
+		});
+	});
+	const selectPrompt = (params) => Effect.gen(function* () {
+		return yield* Prompt.select(params);
+	});
+	const multiSelectPrompt = (params) => Effect.gen(function* () {
+		return yield* Prompt.multiSelect(params);
+	});
+	function hexPrompt(params) {
+		return Effect.gen(function* () {
+			const validate = (v) => Effect.gen(function* () {
+				if (v.trim() === "") return yield* Effect.fail("Hex cannot be empty");
+				if (!isHex(v)) return yield* Effect.fail("Invalid hex value");
+				if (hexToBytes(v).length !== params.length) return yield* Effect.fail(`Hex value must be ${params.length} bytes`);
+				return v;
+			});
+			if (params.redacted) return yield* Prompt.password({
+				message: params.message,
+				validate
+			});
+			return yield* Prompt.text({
+				message: params.message,
+				validate
+			});
+		});
+	}
+	return PromptManager.of({
+		aliasPrompt,
+		passwordPrompt,
+		selectPrompt,
+		hexPrompt,
+		multiSelectPrompt
+	});
+}));
+//#endregion
+//#region src/layers/keystore.ts
+/**
+* Service tag for resolving {@link KeystoreManager} from the Effect context.
+*/
+const KeystoreManager = ServiceMap.Service("@namera-ai/cli/KeystoreManager");
+/**
+* Domain error for keystore management operations.
+*/
+var KeystoreManagerError = class extends Data.TaggedError("@namera-ai/cli/KeystoreManagerError") {};
+/**
+* Live layer wiring the keystore manager with configuration and prompts.
+*/
+const layer$5 = Layer.effect(KeystoreManager, Effect.gen(function* () {
+	const configManager = yield* ConfigManager;
+	const promptManager = yield* PromptManager;
+	const getKeystore = (params) => Effect.gen(function* () {
+		const res = yield* configManager.getEntity({
+			alias: params.alias,
+			type: "keystore"
+		});
+		const parsedKeystore = yield* Effect.try({
+			catch: () => new KeystoreManagerError({
+				code: "KeystoreParseError",
+				message: "Unable to parse keystore"
+			}),
+			try: () => JSON.parse(res.content)
+		});
+		return {
+			alias: res.alias,
+			data: {
+				...parsedKeystore,
+				address: `0x${parsedKeystore.address}`
+			},
+			path: res.path
+		};
+	});
+	const listKeystores = () => Effect.gen(function* () {
+		const effects = (yield* configManager.getEntitiesForType("keystore")).map((entity) => Effect.gen(function* () {
+			const parsedKeystore = yield* Effect.try({
+				catch: () => new KeystoreManagerError({
+					code: "KeystoreParseError",
+					message: "Unable to parse keystore"
+				}),
+				try: () => JSON.parse(entity.content)
+			});
+			return {
+				alias: entity.alias,
+				data: {
+					...parsedKeystore,
+					address: `0x${parsedKeystore.address}`
+				},
+				path: entity.path
+			};
+		}));
+		return yield* Effect.all(effects, { concurrency: "unbounded" });
+	});
+	const createKeystore = (params) => Effect.gen(function* () {
+		const entityPath = yield* configManager.getEntityPath({
+			alias: params.alias,
+			type: "keystore"
+		});
+		if (yield* configManager.checkEntityExists({
+			alias: params.alias,
+			type: "keystore"
+		})) return yield* Effect.fail(new KeystoreManagerError({
+			code: "KeystoreAlreadyExists",
+			message: `Keystore with alias ${params.alias} already exists`
+		}));
+		const keystoreString = yield* Effect.tryPromise({
+			catch: () => new KeystoreManagerError({
+				code: "KeystoreCreationFailed",
+				message: "Failed to create keystore"
+			}),
+			try: () => Wallet.generate().toV3String(params.password)
+		});
+		yield* configManager.storeEntity({
+			alias: params.alias,
+			content: keystoreString,
+			path: entityPath,
+			type: "keystore"
+		});
+		const keystore = yield* Effect.try({
+			catch: () => new KeystoreManagerError({
+				code: "KeystoreParseError",
+				message: "Unable to parse keystore"
+			}),
+			try: () => JSON.parse(keystoreString)
+		});
+		return {
+			alias: params.alias,
+			data: {
+				...keystore,
+				address: `0x${keystore.address}`
+			},
+			path: entityPath
+		};
+	});
+	const decryptKeystore = (params) => Effect.gen(function* () {
+		const keystore = yield* getKeystore({ alias: params.alias });
+		const wallet = yield* Effect.tryPromise({
+			catch: () => new KeystoreManagerError({
+				code: "KeystoreDecryptionFailed",
+				message: "Failed to decrypt keystore"
+			}),
+			try: () => Wallet.fromV3(keystore.data, params.password)
+		});
+		return {
+			address: wallet.getChecksumAddressString(),
+			alias: params.alias,
+			privateKey: Redacted.make(wallet.getPrivateKeyString()),
+			publicKey: wallet.getPublicKeyString()
+		};
+	});
+	const selectKeystore = (params) => Effect.gen(function* () {
+		const keystores = yield* listKeystores();
+		return yield* promptManager.selectPrompt({
+			message: params.message,
+			choices: keystores.map((k) => ({
+				title: k.alias,
+				value: k,
+				description: k.data.address
+			}))
+		});
+	});
+	const importKeystore = (params) => Effect.gen(function* () {
+		const entityPath = yield* configManager.getEntityPath({
+			alias: params.alias,
+			type: "keystore"
+		});
+		if (yield* configManager.checkEntityExists({
+			alias: params.alias,
+			type: "keystore"
+		})) return yield* Effect.fail(new KeystoreManagerError({
+			code: "KeystoreAlreadyExists",
+			message: `Keystore with alias ${params.alias} already exists`
+		}));
+		const keystoreString = yield* Effect.tryPromise({
+			catch: () => new KeystoreManagerError({
+				code: "KeystoreCreationFailed",
+				message: "Failed to create keystore"
+			}),
+			try: () => Wallet.fromPrivateKey(hexToBytes(params.privateKey)).toV3String(params.password)
+		});
+		yield* configManager.storeEntity({
+			alias: params.alias,
+			content: keystoreString,
+			path: entityPath,
+			type: "keystore"
+		});
+		const keystore = yield* Effect.try({
+			catch: () => new KeystoreManagerError({
+				code: "KeystoreParseError",
+				message: "Unable to parse keystore"
+			}),
+			try: () => JSON.parse(keystoreString)
+		});
+		return {
+			alias: params.alias,
+			data: keystore,
+			path: entityPath
+		};
+	});
+	const removeKeystore = (params) => Effect.gen(function* () {
+		if (!(yield* configManager.checkEntityExists({
+			alias: params.alias,
+			type: "keystore"
+		}))) return yield* Effect.fail(new KeystoreManagerError({
+			code: "KeystoreNotFound",
+			message: `Keystore with alias ${params.alias} does not exist`
+		}));
+		return yield* configManager.removeEntity({
+			alias: params.alias,
+			type: "keystore"
+		});
+	});
+	const getSigner = (params) => Effect.gen(function* () {
+		const keystore = yield* getKeystore({ alias: params.alias });
+		return privateKeyToAccount(toHex((yield* Effect.tryPromise({
+			catch: () => new KeystoreManagerError({
+				code: "KeystoreDecryptionFailed",
+				message: "Failed to decrypt keystore"
+			}),
+			try: () => Wallet.fromV3(keystore.data, params.password)
+		})).getPrivateKey()));
+	});
+	const getKeystorePassword = (params) => Effect.gen(function* () {
+		const keystore = yield* getKeystore({ alias: params.alias });
+		return yield* promptManager.passwordPrompt({
+			message: params.message,
+			validate: (v) => Effect.gen(function* () {
+				if (v.trim() === "") return yield* Effect.fail("Password cannot be empty");
+				yield* Effect.tryPromise({
+					try: () => Wallet.fromV3(keystore.data, v),
+					catch: () => new KeystoreManagerError({
+						code: "DecryptError",
+						message: `Invalid password for keystore ${params.alias}`
+					})
+				}).pipe(Effect.catch(() => Effect.fail("Invalid password")));
+				return v;
+			})
+		});
+	});
+	return KeystoreManager.of({
+		createKeystore,
+		decryptKeystore,
+		getKeystore,
+		listKeystores,
+		selectKeystore,
+		importKeystore,
+		removeKeystore,
+		getSigner,
+		getKeystorePassword
+	});
+}));
+//#endregion
+//#region src/layers/mcp-context.ts
+const McpContext = ServiceMap.Service("@namera-ai/cli/McpContext");
+//#endregion
+//#region src/mcp/helpers/common.ts
+const EmptyArgs = Schema.Record(Schema.String, Schema.Unknown);
+var InsufficientPermissions = class extends Schema.TaggedErrorClass()("InsufficientPermissions", {}) {};
+//#endregion
+//#region src/mcp/tools/account/address.ts
+const GetAddressTool = Tool.make("get_wallet_address", {
+	dependencies: [McpContext],
+	description: "Get the address of the wallet",
+	failure: Schema.Never,
+	parameters: EmptyArgs,
+	success: Schema.String
+});
+const getAddressToolHandler = () => Effect.gen(function* () {
+	return (yield* McpContext).smartAccount.smartAccountAddress;
+});
+//#endregion
+//#region src/layers/web3.ts
+/**
+* Service tag for resolving {@link Web3Service} from the Effect context.
+*/
+const Web3Service = ServiceMap.Service("@namera-ai/cli/Web3Service");
+/**
+* Live layer that wires web3 clients and chain selection prompts.
+*/
+const layer$4 = Layer.effect(Web3Service, Effect.gen(function* () {
+	const promptManager = yield* PromptManager;
+	const chainNameToEnvVar = (chain, suffix) => {
+		return `${chain.replaceAll("-", "_").toUpperCase()}_${suffix}`;
+	};
+	const getRpcUrl = (params) => Effect.gen(function* () {
+		let rpcUrl;
+		if (params.rpcUrl) rpcUrl = params.rpcUrl;
+		else {
+			const envVarName = chainNameToEnvVar(params.chain, "RPC_URL");
+			const envRpcUrl = yield* Config.option(Config.redacted(envVarName));
+			if (envRpcUrl._tag === "Some") rpcUrl = Redacted.value(envRpcUrl.value);
+			else rpcUrl = void 0;
+		}
+		return rpcUrl;
+	}).pipe(Effect.orDie);
+	const getBundlerUrl = (params) => Effect.gen(function* () {
+		let bundlerUrl;
+		if (params.bundlerUrl) bundlerUrl = params.bundlerUrl;
+		else {
+			const envVarName = chainNameToEnvVar(params.chain, "BUNDLER_URL");
+			const envRpcUrl = yield* Config.option(Config.redacted(envVarName));
+			if (envRpcUrl._tag === "Some") bundlerUrl = Redacted.value(envRpcUrl.value);
+			else bundlerUrl = `https://public.pimlico.io/v2/${getChain(params.chain).id}/rpc`;
+		}
+		return bundlerUrl;
+	}).pipe(Effect.orDie);
+	const getPublicClient = (params) => Effect.gen(function* () {
+		const rpcUrl = yield* getRpcUrl(params);
+		return createPublicClient({
+			chain: getChain(params.chain),
+			transport: http(rpcUrl)
+		});
+	});
+	const getBundlerTransport = (params) => Effect.gen(function* () {
+		return http(yield* getBundlerUrl(params));
+	});
+	const selectChain = (params) => Effect.gen(function* () {
+		const chains = Object.values(supportedChains);
+		return yield* promptManager.selectPrompt({
+			message: params.message,
+			choices: chains.map((c) => ({
+				title: c.name,
+				value: c.key
+			}))
+		});
+	});
+	const multiSelectChain = (params) => Effect.gen(function* () {
+		const chains = Object.values(supportedChains);
+		return yield* promptManager.multiSelectPrompt({
+			message: params.message,
+			choices: chains.map((c) => ({
+				title: c.name,
+				value: c.key
+			})),
+			min: 1
+		});
+	});
+	return Web3Service.of({
+		getPublicClient,
+		selectChain,
+		multiSelectChain,
+		getBundlerTransport
+	});
+}));
+//#endregion
+//#region src/mcp/helpers/session-key.ts
+const toPolicyMap = (policies) => {
+	const map = {};
+	for (const p of policies) {
+		if (p.type === "timestamp") {
+			if (map.timestamp) return null;
+			map.timestamp = p;
+		}
+		if (p.type === "call") {
+			if (map.call) return null;
+			map.call = p;
+		}
+		if (p.type === "signature-caller") {
+			if (map.signatureCaller) return null;
+			map.signatureCaller = p;
+		}
+		if (p.type === "gas") {
+			if (map.gas) return null;
+			map.gas = p;
+		}
+		if (p.type === "rate-limit") {
+			if (map.rateLimit) return null;
+			map.rateLimit = p;
+		}
+		if (p.type === "sudo") {
+			if (map.sudo) return null;
+			map.sudo = p;
+		}
+	}
+	return map;
+};
+function evaluateTimestamp(policy, _chainIds, _operation) {
+	const now = Date.now();
+	if (policy.validAfter !== void 0 && now < policy.validAfter * 1e3) return false;
+	if (policy.validUntil !== void 0 && now >= policy.validUntil * 1e3) return false;
+	return true;
+}
+function evaluateSignature(policy, chainIds, operation) {
+	const callers = operation.allowedCallers;
+	if (!callers || callers.length === 0) return false;
+	if (!chainIds.includes(operation.chainId)) return false;
+	return callers.every((caller) => policy.allowedCallers.includes(caller));
+}
+function evaluateCall(policy, chainIds, operation) {
+	const permissions = policy.permissions ?? [];
+	if (permissions.length === 0) return false;
+	const { batches } = operation;
+	if (batches.length === 0) return false;
+	return batches.every((batch) => {
+		const { calls, chainId } = batch;
+		return calls.every((call) => {
+			const { to, value = 0n, data } = call;
+			if (!chainIds.includes(chainId)) return false;
+			return permissions.some((p) => {
+				if (p.target !== to) return false;
+				if (value > (p.valueLimit ?? 0n)) return false;
+				const isContractCall = data.length >= 10;
+				if ("functionName" in p) {
+					if (!isContractCall) return false;
+					if (!p.selector) return false;
+					if (data.slice(0, 10) !== p.selector) return false;
+					return true;
+				}
+				return true;
+			});
+		});
+	});
+}
+const evaluateSessionKey = (sessionKey, operation) => {
+	if (operation.intent === "read") return true;
+	const accountParams = deserializePermissionAccountParams(sessionKey.data.serializedAccounts[0]?.serializedAccount ?? "");
+	const chainIds = sessionKey.data.serializedAccounts.map((a) => getChain(a.chain).id);
+	const p = toPolicyMap((accountParams.permissionParams.policies ?? []).map((x) => x.policyParams));
+	if (!p) return false;
+	const hasSudo = Boolean(p.sudo);
+	if (hasSudo && (p.call || p.signatureCaller)) return false;
+	if (p.timestamp && !evaluateTimestamp(p.timestamp, chainIds, operation)) return false;
+	if (!hasSudo) {
+		if (operation.intent === "transaction") {
+			if (!p.call) return false;
+			if (!evaluateCall(p.call, chainIds, operation)) return false;
+		}
+		if (operation.intent === "sign") {
+			if (!p.signatureCaller) return false;
+			if (!evaluateSignature(p.signatureCaller, chainIds, operation)) return false;
+		}
+	}
+	return true;
+};
+const getSessionKeyClient = (params) => Effect.gen(function* () {
+	const { sessionKeys, smartAccount } = yield* McpContext;
+	const key = sessionKeys.filter((sk) => {
+		return evaluateSessionKey(sk, params.operation);
+	})[0];
+	if (!key) return yield* Effect.fail(new InsufficientPermissions());
+	const web3Service = yield* Web3Service;
+	let chainId;
+	if (params.operation.intent === "read") chainId = params.operation.chainId;
+	else if (params.operation.intent === "sign") chainId = params.operation.chainId;
+	else chainId = params.operation.batches[0]?.chainId ?? 1;
+	const chainName = chainIdToChainName(chainId);
+	const chain = getChain(chainName);
+	const publicClient = yield* web3Service.getPublicClient({ chain: chainName });
+	const bundlerTransport = yield* web3Service.getBundlerTransport({ chain: chainName });
+	const serializedAccount = key.data.serializedAccounts.find((a) => a.chain === chainName)?.serializedAccount ?? "";
+	return yield* Effect.promise(() => createSessionKeyClient({
+		type: "ecdsa",
+		bundlerTransport,
+		chain,
+		client: publicClient,
+		entrypointVersion: smartAccount.entryPointVersion,
+		kernelVersion: smartAccount.kernelVersion,
+		serializedAccount,
+		sessionKeySigner: key.signer
+	}));
+});
+//#endregion
+//#region src/mcp/tools/account/get-balance.ts
+const GetBalanceToolParams = Schema.Struct({
+	address: EthereumAddress.annotate({ description: "The address to get the balance for" }),
+	chain: SupportedChain.annotate({ description: "The chain to get the balance for" })
+});
+const GetBalanceToolResult = Schema.Struct({
+	nativeCurrency: Schema.Struct({
+		name: Schema.String.annotate({ description: "The name of the currency" }),
+		symbol: Schema.String.annotate({ description: "The symbol of the currency" }),
+		decimals: Schema.Number.annotate({ description: "The number of decimals the currency has" })
+	}).annotate({ description: "The native currency of the chain" }),
+	balance: Schema.Struct({
+		amount: Schema.String.annotate({ description: "Balance in atomic units" }),
+		formatted: Schema.String.annotate({ description: "Balance in native currency units" })
+	})
+});
+const GetBalanceTool = Tool.make("get_balance", {
+	dependencies: [McpContext, Web3Service],
+	description: "Get the address of the wallet",
+	failure: InsufficientPermissions,
+	parameters: GetBalanceToolParams,
+	success: GetBalanceToolResult
+});
+const getBalanceToolHandler = (params) => Effect.gen(function* () {
+	const sessionKeyClient = yield* getSessionKeyClient({ operation: {
+		intent: "read",
+		chainId: getChain(params.chain).id
+	} });
+	const res = yield* Effect.promise(() => getBalance(sessionKeyClient.client, { address: params.address }));
+	return {
+		nativeCurrency: sessionKeyClient.chain.nativeCurrency,
+		balance: {
+			amount: res.toString(),
+			formatted: formatUnits(res, sessionKeyClient.chain.nativeCurrency.decimals)
+		}
+	};
+});
+//#endregion
+//#region src/mcp/tools/account/index.ts
+const AccountTools = Toolkit.make(GetAddressTool, GetBalanceTool);
+const AccountToolsHandlers = AccountTools.toLayer(Effect.succeed({
+	get_wallet_address: getAddressToolHandler,
+	get_balance: getBalanceToolHandler
+}));
+//#endregion
+//#region src/mcp/tools/read/read-contract.ts
+const ReadContractToolParams = Schema.Struct({
+	chain: SupportedChain.annotate({ description: "The chain to use for the transfer" }),
+	contractAddress: EthereumAddress.annotate({ description: "The ethereum address of the contract to read" }),
+	abi: Schema.Array(Schema.Any).annotate({ description: "The ABI of the contract to read" }),
+	functionName: Schema.String.annotate({ description: "The name of the function to call on the contract" }),
+	args: Schema.Array(Schema.Any).annotate({ description: "The arguments to pass to the function" })
+});
+const ReadContractTool = Tool.make("read_contract", {
+	dependencies: [McpContext, Web3Service],
+	description: "Read data from a specified contract.",
+	failure: InsufficientPermissions,
+	parameters: ReadContractToolParams,
+	success: Schema.Any.annotate({ description: "The data returned by the contract" })
+});
+const readContractToolHandler = (params) => Effect.gen(function* () {
+	const client = yield* getSessionKeyClient({ operation: {
+		intent: "read",
+		chainId: getChain(params.chain).id
+	} });
+	readContract(client, {
+		address: params.contractAddress,
+		abi: params.abi,
+		functionName: params.functionName,
+		args: params.args
+	});
+	return yield* Effect.promise(() => readContract(client, {
+		address: params.contractAddress,
+		abi: params.abi,
+		functionName: params.functionName,
+		args: params.args
+	}));
+});
+//#endregion
+//#region src/mcp/tools/read/index.ts
+const ReadTools = Toolkit.make(ReadContractTool);
+const ReadToolsHandlers = ReadTools.toLayer(Effect.succeed({ read_contract: (params) => readContractToolHandler(params) }));
+//#endregion
+//#region src/schema/tx.ts
+const Call = Schema.Struct({
+	to: EthereumAddress.annotate({ description: "The target address to call" }),
+	data: Hex.annotate({ description: "The data to send with the call" }),
+	value: Schema.optional(BigIntFromString).annotate({ description: "The value to send with the call" })
+});
+const Batch = Schema.Struct({
+	chainId: Schema.Int.annotate({ description: "The chain ID to execute the transaction on" }),
+	nonceKey: Schema.optional(Schema.String).annotate({ description: "The nonce key to use, for 2D Parallel transactions." }),
+	calls: Schema.mutable(Schema.Array(Call))
+});
+Schema.Struct({ batches: Schema.mutable(Schema.Array(Batch)) });
+//#endregion
+//#region src/mcp/tools/transaction/execute-transaction.ts
+const ExecuteTransactionToolParams = Batch;
+const ExecuteTransactionTool = Tool.make("execute_transaction", {
+	dependencies: [McpContext, Web3Service],
+	description: "Send transactions.",
+	failure: InsufficientPermissions,
+	parameters: ExecuteTransactionToolParams,
+	success: Schema.String.annotate({ description: "The transaction hash for the executed transaction." })
+});
+const executeTransactionToolHandler = (params) => Effect.gen(function* () {
+	const batches = [{
+		chainId: params.chainId,
+		nonceKey: params.nonceKey,
+		calls: params.calls
+	}];
+	const client = yield* getSessionKeyClient({ operation: {
+		intent: "transaction",
+		batches
+	} });
+	return (yield* Effect.promise(() => executeTransaction({
+		clients: [client],
+		batches
+	})))[0]?.receipt.transactionHash;
+});
+//#endregion
+//#region src/mcp/tools/transaction/native-transfer.ts
+const NativeTransferToolParams = Schema.Struct({
+	chain: SupportedChain.annotate({ description: "The chain to use for the transfer" }),
+	address: EthereumAddress.annotate({ description: "The ethereum address to transfer to" }),
+	amount: Schema.String.annotate({ description: "The amount of native tokens to transfer" }),
+	unit: Schema.Literals([
+		"wei",
+		"gwei",
+		"ether"
+	])
+});
+const NativeTransferTool = Tool.make("native_transfer", {
+	dependencies: [McpContext, Web3Service],
+	description: "Transfer Native Tokens to a specified address.",
+	failure: InsufficientPermissions,
+	parameters: NativeTransferToolParams,
+	success: Schema.String.annotate({ description: "The transaction hash of the transfer" })
+});
+const nativeTransferToolHandler = (params) => Effect.gen(function* () {
+	const decimals = () => {
+		if (params.unit === "wei") return 1;
+		if (params.unit === "gwei") return 9;
+		return 18;
+	};
+	const amount = parseUnits(params.amount.toString(), decimals());
+	const batches = [{
+		chainId: getChain(params.chain).id,
+		calls: [{
+			to: params.address,
+			value: amount,
+			data: "0x"
+		}]
+	}];
+	const client = yield* getSessionKeyClient({ operation: {
+		intent: "transaction",
+		batches
+	} });
+	return (yield* Effect.promise(() => executeTransaction({
+		clients: [client],
+		batches
+	})))[0]?.receipt.transactionHash;
+});
+//#endregion
+//#region src/mcp/tools/transaction/index.ts
+const TransactionTools = Toolkit.make(NativeTransferTool, ExecuteTransactionTool);
+const TransactionToolsHandlers = TransactionTools.toLayer(Effect.succeed({
+	native_transfer: (params) => nativeTransferToolHandler(params),
+	execute_transaction: (params) => executeTransactionToolHandler(params)
+}));
+//#endregion
+//#region src/mcp/mcp.ts
+const Account = Layer.effectDiscard(McpServer.registerToolkit(AccountTools)).pipe(Layer.provideMerge(AccountToolsHandlers));
+const Transfer = Layer.effectDiscard(McpServer.registerToolkit(TransactionTools)).pipe(Layer.provideMerge(TransactionToolsHandlers));
+const Read = Layer.effectDiscard(McpServer.registerToolkit(ReadTools)).pipe(Layer.provideMerge(ReadToolsHandlers));
+const McpLive = Layer.mergeAll(Account, Transfer, Read);
+//#endregion
+//#region src/mcp/index.ts
+const MCP_SERVER_NAME = "Namera MCP Server";
+const MCP_SERVER_VERSION = "0.0.1";
+const McpRouter = McpLive.pipe(Layer.provideMerge(McpServer.layerHttp({
+	name: MCP_SERVER_NAME,
+	path: "/mcp",
+	version: MCP_SERVER_VERSION
+})), Layer.provideMerge(HttpRouter.cors({
+	allowedHeaders: [
+		"Content-Type",
+		"Authorization",
+		"mcp-session-id",
+		"mcp-protocol-version"
+	],
+	allowedMethods: [
+		"GET",
+		"POST",
+		"PUT",
+		"DELETE",
+		"PATCH",
+		"OPTIONS"
+	],
+	allowedOrigins: ["*"],
+	credentials: false,
+	exposedHeaders: ["mcp-session-id", "mcp-protocol-version"]
+})));
+const McpStdio = McpLive.pipe(Layer.provideMerge(McpServer.layerStdio({
+	name: MCP_SERVER_NAME,
+	version: MCP_SERVER_VERSION
+})), Layer.provide(NodeStdio.layer), Layer.provide(Layer.succeed(Logger.LogToStderr)(true)));
+const startMcpHttpServer = (port) => Layer.launch(HttpRouter.serve(McpRouter).pipe(Layer.provideMerge(NodeHttpServer.layer(createServer, { port }))));
+const startMcpStdioServer = () => Layer.launch(McpStdio);
+//#endregion
+//#region src/helpers/policy.ts
+/** biome-ignore-all lint/complexity/noExcessiveCognitiveComplexity: safe */
+const toCallPolicyVersion = (version) => {
+	switch (version) {
+		case "0.0.1": return CallPolicyVersion.V0_0_1;
+		case "0.0.2": return CallPolicyVersion.V0_0_2;
+		case "0.0.3": return CallPolicyVersion.V0_0_3;
+		case "0.0.4": return CallPolicyVersion.V0_0_4;
+		case "0.0.5": return CallPolicyVersion.V0_0_5;
+		default: throw new Error("Invalid call policy version");
+	}
+};
+const conditionToParamCondition = (condition) => {
+	if (condition === "EQUAL") return ParamCondition.EQUAL;
+	if (condition === "GREATER_THAN") return ParamCondition.GREATER_THAN;
+	if (condition === "LESS_THAN") return ParamCondition.LESS_THAN;
+	if (condition === "GREATER_THAN_OR_EQUAL") return ParamCondition.GREATER_THAN_OR_EQUAL;
+	if (condition === "LESS_THAN_OR_EQUAL") return ParamCondition.LESS_THAN_OR_EQUAL;
+	if (condition === "NOT_EQUAL") return ParamCondition.NOT_EQUAL;
+	if (condition === "ONE_OF") return ParamCondition.ONE_OF;
+	if (condition === "SLICE_EQUAL") return ParamCondition.SLICE_EQUAL;
+	return ParamCondition.EQUAL;
+};
+const policyParamsToPolicies = (params) => {
+	const policies = [];
+	for (const param of params) if (param.type === "sudo") policies.push(toSudoPolicy({}));
+	else if (param.type === "timestamp") policies.push(toTimestampPolicy(param));
+	else if (param.type === "gas") policies.push(toGasPolicy(param));
+	else if (param.type === "rate-limit") policies.push(toRateLimitPolicy(param));
+	else if (param.type === "signature-caller") policies.push(toSignatureCallerPolicy(param));
+	else if (param.type === "call") policies.push(toCallPolicy({
+		policyVersion: toCallPolicyVersion(param.policyVersion),
+		permissions: !param.permissions ? void 0 : param.permissions.map((p) => {
+			const callType = (() => {
+				if (!p.callType) return CallType.CALL;
+				if (p.callType === "call") return CallType.CALL;
+				if (p.callType === "delegatecall") return CallType.DELEGATE_CALL;
+				return CallType.BATCH_CALL;
+			})();
+			if ("abi" in p) return {
+				callType,
+				target: p.target,
+				valueLimit: p.valueLimit,
+				abi: p.abi,
+				functionName: p.functionName,
+				selector: p.selector,
+				args: !p.args ? void 0 : p.args.map((a) => {
+					if (a === null) return null;
+					const c = a.condition;
+					if (c === "ONE_OF") return {
+						condition: ParamCondition.ONE_OF,
+						value: a.value
+					};
+					if (c === "SLICE_EQUAL" && "start" in a) return {
+						condition: ParamCondition.SLICE_EQUAL,
+						value: a.value,
+						start: a.start,
+						length: a.length
+					};
+					return {
+						condition: conditionToParamCondition(c),
+						value: a.value
+					};
+				})
+			};
+			return {
+				callType,
+				target: p.target,
+				selector: p.selector,
+				valueLimit: p.valueLimit,
+				rules: p.rules ? p.rules.map((r) => {
+					return {
+						offset: r.offset,
+						params: r.params,
+						condition: conditionToParamCondition(r.condition)
+					};
+				}) : void 0
+			};
+		})
+	}));
+	else throw new Error("Invalid policy type");
+	return policies;
+};
+//#endregion
+//#region src/layers/smart-account.ts
+/**
+* Service tag for resolving {@link SmartAccountManager} from the Effect context.
+*/
+const SmartAccountManager = ServiceMap.Service("@namera-ai/cli/SmartAccountManager");
+/**
+* Domain error for smart account lifecycle operations.
+*/
+var SmartAccountManagerError = class extends Data.TaggedError("@namera-ai/cli/SmartAccountManagerError") {};
+/**
+* Live layer that manages smart account storage and derivation.
+*/
+const layer$3 = Layer.effect(SmartAccountManager, Effect.gen(function* () {
+	const configManager = yield* ConfigManager;
+	const keystoreManager = yield* KeystoreManager;
+	const promptManager = yield* PromptManager;
+	const web3Service = yield* Web3Service;
+	const getSmartAccount = (params) => Effect.gen(function* () {
+		const res = yield* configManager.getEntity({
+			alias: params.alias,
+			type: "smart-account"
+		});
+		const parsedSmartAccount = Schema.decodeUnknownSync(Schema.fromJsonString(LocalSmartAccount))(res.content);
+		return {
+			alias: res.alias,
+			data: parsedSmartAccount,
+			path: res.path
+		};
+	});
+	const listSmartAccounts = () => Effect.gen(function* () {
+		const effects = (yield* configManager.getEntitiesForType("smart-account")).map((entity) => Effect.gen(function* () {
+			const parsedSmartAccount = Schema.decodeUnknownSync(Schema.fromJsonString(LocalSmartAccount))(entity.content);
+			return {
+				alias: entity.alias,
+				data: parsedSmartAccount,
+				path: entity.path
+			};
+		}));
+		return yield* Effect.all(effects, { concurrency: "unbounded" });
+	});
+	const createSmartAccount = (params) => Effect.gen(function* () {
+		const existingAccounts = yield* listSmartAccounts();
+		const entityPath = yield* configManager.getEntityPath({
+			alias: params.alias,
+			type: "smart-account"
+		});
+		const ownerKeystore = yield* keystoreManager.getKeystore({ alias: params.ownerAlias });
+		const ownerSigner = yield* keystoreManager.getSigner({
+			alias: params.ownerAlias,
+			password: params.ownerPassword
+		});
+		const publicClient = createPublicClient({
+			chain: mainnet,
+			transport: http()
+		});
+		const entryPointVersion = "0.7";
+		const kernelVersion = "0.3.2";
+		const index = BigInt(params.index ?? 0);
+		const ownerType = "ecdsa";
+		const saAddress = (yield* Effect.tryPromise({
+			try: () => createAccountClient({
+				type: "ecdsa",
+				bundlerTransport: http(),
+				chain: mainnet,
+				client: publicClient,
+				entrypointVersion: entryPointVersion,
+				kernelVersion,
+				signer: ownerSigner
+			}),
+			catch: () => new SmartAccountManagerError({
+				code: "KernelAddressGenerationError",
+				message: `Unable to compute smart account address for Address: ${ownerKeystore.data.address} and Index: ${params.index}`
+			})
+		})).account.address;
+		if (existingAccounts.find((d) => d.data.smartAccountAddress === saAddress)) return yield* Effect.fail(new SmartAccountManagerError({
+			code: "SmartAccountAlreadyExists",
+			message: `Smart account for owner: ${ownerKeystore.alias} and index: ${params.index} already exists`
+		}));
+		const saData = {
+			entryPointVersion,
+			kernelVersion,
+			ownerAlias: ownerKeystore.alias,
+			ownerType,
+			smartAccountAddress: saAddress,
+			index
+		};
+		const data = {
+			data: saData,
+			path: entityPath,
+			alias: params.alias
+		};
+		const encoded = Schema.encodeSync(LocalSmartAccount)(saData);
+		yield* configManager.storeEntity({
+			alias: params.alias,
+			content: JSON.stringify(encoded),
+			path: entityPath,
+			type: "smart-account"
+		});
+		return data;
+	});
+	const selectSmartAccount = (params) => Effect.gen(function* () {
+		const smartAccounts = yield* listSmartAccounts();
+		return yield* promptManager.selectPrompt({
+			message: params.message,
+			choices: smartAccounts.map((a) => ({
+				title: a.alias,
+				value: a,
+				description: a.data.smartAccountAddress
+			}))
+		});
+	});
+	const removeSmartAccount = (params) => Effect.gen(function* () {
+		const sa = yield* getSmartAccount({ alias: params.alias });
+		return yield* configManager.removeEntity({
+			alias: sa.alias,
+			type: "smart-account"
+		});
+	});
+	const getSmartAccountStatus = (params) => Effect.gen(function* () {
+		const sa = yield* getSmartAccount({ alias: params.alias });
+		const publicClient = yield* web3Service.getPublicClient({
+			chain: params.chain,
+			rpcUrl: params.rpcUrl
+		});
+		const code = yield* Effect.promise(() => publicClient.getCode({ address: sa.data.smartAccountAddress }));
+		return Boolean(code);
+	});
+	const importSmartAccount = (params) => Effect.gen(function* () {
+		const { alias, ...rest } = params;
+		const entityPath = yield* configManager.getEntityPath({
+			alias: params.alias,
+			type: "smart-account"
+		});
+		const ownerKeystore = yield* keystoreManager.getKeystore({ alias: params.ownerAlias });
+		if ((yield* listSmartAccounts()).find((d) => d.data.smartAccountAddress === rest.smartAccountAddress)) return yield* Effect.fail(new SmartAccountManagerError({
+			code: "SmartAccountAlreadyExists",
+			message: `Smart account for owner: ${ownerKeystore.alias} and address: ${rest.smartAccountAddress} already exists`
+		}));
+		yield* configManager.storeEntity({
+			alias: params.alias,
+			content: JSON.stringify(Schema.encodeSync(LocalSmartAccount)(rest)),
+			path: entityPath,
+			type: "smart-account"
+		});
+		return {
+			alias: params.alias,
+			data: rest,
+			path: entityPath
+		};
+	});
+	return SmartAccountManager.of({
+		createSmartAccount,
+		getSmartAccount,
+		listSmartAccounts,
+		selectSmartAccount,
+		removeSmartAccount,
+		getSmartAccountStatus,
+		importSmartAccount
+	});
+}));
+//#endregion
+//#region src/layers/session-key.ts
+const SessionKeyManager = ServiceMap.Service("@namera-ai/cli/SessionKeyManager");
+var SessionKeyManagerError = class extends Data.TaggedError("@namera-ai/cli/SessionKeyManagerError") {};
+const layer$2 = Layer.effect(SessionKeyManager, Effect.gen(function* () {
+	const configManager = yield* ConfigManager;
+	const promptManager = yield* PromptManager;
+	const keystoreManager = yield* KeystoreManager;
+	const smartAccountManager = yield* SmartAccountManager;
+	const web3Service = yield* Web3Service;
+	const createSessionKey$1 = (params) => Effect.gen(function* () {
+		if (yield* configManager.checkEntityExists({
+			alias: params.alias,
+			type: "session-key"
+		})) return yield* Effect.fail(new SessionKeyManagerError({
+			code: "SessionKeyAlreadyExists",
+			message: `Session key for alias ${params.alias} already exists`
+		}));
+		const entityPath = yield* configManager.getEntityPath({
+			alias: params.alias,
+			type: "session-key"
+		});
+		const sa = yield* smartAccountManager.getSmartAccount({ alias: params.smartAccountAlias });
+		const ownerSigner = yield* keystoreManager.getSigner({
+			alias: sa.data.ownerAlias,
+			password: params.ownerKeystorePassword
+		});
+		const policies = policyParamsToPolicies(params.policyParams);
+		const clients = yield* Effect.all(params.chains.map((chain) => web3Service.getPublicClient({ chain })), { concurrency: "unbounded" });
+		const sessionPrivateKey = generatePrivateKey();
+		const sessionKeyAccount = privateKeyToAccount(sessionPrivateKey);
+		const res = yield* Effect.promise(() => createSessionKey({
+			type: "ecdsa",
+			accountType: "ecdsa",
+			sessionPrivateKey,
+			clients,
+			entrypointVersion: sa.data.entryPointVersion,
+			kernelVersion: sa.data.kernelVersion,
+			index: sa.data.index,
+			signer: ownerSigner,
+			policies
+		}));
+		const encData = yield* Effect.tryPromise({
+			try: () => Wallet.fromPrivateKey(hexToBytes(sessionPrivateKey)).toV3(params.sessionKeyPassword),
+			catch: () => new SessionKeyManagerError({
+				code: "EncryptionError",
+				message: "Failed to encrypt session key"
+			})
+		});
+		const data = {
+			sessionKeyType: "ecdsa",
+			serializedAccounts: res.serializedAccounts.map((a) => ({
+				chain: chainIdToChainName(a.chainId),
+				serializedAccount: a.serializedAccount
+			})),
+			sessionKeyAddress: sessionKeyAccount.address,
+			smartAccountAlias: sa.alias,
+			...encData
+		};
+		yield* configManager.storeEntity({
+			alias: params.alias,
+			content: JSON.stringify(data),
+			path: entityPath,
+			type: "session-key"
+		});
+		return {
+			alias: params.alias,
+			data,
+			path: entityPath
+		};
+	});
+	const getSessionKey = (params) => Effect.gen(function* () {
+		const res = yield* configManager.getEntity({
+			alias: params.alias,
+			type: "session-key"
+		});
+		const parsed = Schema.decodeUnknownOption(Schema.fromJsonString(SessionKey))(res.content);
+		if (parsed._tag === "None") return yield* Effect.fail(new SessionKeyManagerError({
+			code: "SessionKeyParseError",
+			message: "Unable to parse session key"
+		}));
+		return {
+			alias: res.alias,
+			data: parsed.value,
+			path: res.path
+		};
+	});
+	const listSessionKeys = (params) => Effect.gen(function* () {
+		const effects = (yield* configManager.getEntitiesForType("session-key")).map((entity) => Effect.gen(function* () {
+			const parsed = Schema.decodeUnknownOption(Schema.fromJsonString(SessionKey))(entity.content);
+			if (parsed._tag === "None") return yield* Effect.fail(new SessionKeyManagerError({
+				code: "SessionKeyParseError",
+				message: "Unable to parse session key"
+			}));
+			return {
+				alias: entity.alias,
+				data: parsed.value,
+				path: entity.path
+			};
+		}));
+		const allKeys = yield* Effect.all(effects, { concurrency: "unbounded" });
+		if (params.smartAccount) return allKeys.filter((k) => k.data.smartAccountAlias === params.smartAccount);
+		return allKeys;
+	});
+	const selectSessionKey = (params) => Effect.gen(function* () {
+		const sessionKeys = yield* listSessionKeys({});
+		return yield* promptManager.selectPrompt({
+			message: params.message,
+			choices: sessionKeys.map((sk) => ({
+				title: sk.alias,
+				value: sk,
+				description: `${sk.data.sessionKeyType === "ecdsa" ? sk.data.sessionKeyAddress : sk.data.passKeyName} (${sk.data.smartAccountAlias})`
+			}))
+		});
+	});
+	const getSessionKeyStatus = (params) => Effect.gen(function* () {
+		const sessionKey = yield* getSessionKey({ alias: params.alias });
+		const sa = yield* smartAccountManager.getSmartAccount({ alias: sessionKey.data.smartAccountAlias });
+		const publicClient = yield* web3Service.getPublicClient({
+			chain: params.chain,
+			rpcUrl: params.rpcUrl
+		});
+		if (sessionKey.data.sessionKeyType !== "ecdsa") return yield* Effect.fail(new SessionKeyManagerError({
+			code: "SessionKeyParseError",
+			message: "Only ECDSA session keys have an on-chain status"
+		}));
+		const sessionKeyAddress = sessionKey.data.sessionKeyAddress;
+		return yield* Effect.tryPromise({
+			try: () => isSessionKeyInstalled(publicClient, {
+				accountAddress: sa.data.smartAccountAddress,
+				sessionKeyAddress
+			}),
+			catch: () => false
+		}).pipe(Effect.catch(() => Effect.succeed(false)));
+	});
+	const multiSelectSessionKeys = (params) => Effect.gen(function* () {
+		const allKeys = yield* listSessionKeys({ smartAccount: params.smartAccount });
+		return yield* promptManager.multiSelectPrompt({
+			message: params.message,
+			choices: allKeys.map((k) => ({
+				title: k.alias,
+				value: k,
+				description: `${k.data.sessionKeyType === "ecdsa" ? k.data.sessionKeyAddress : k.data.passKeyName} (${k.data.smartAccountAlias})`
+			})),
+			min: 1
+		});
+	});
+	const getSessionKeyPassword = (params) => Effect.gen(function* () {
+		const key = yield* getSessionKey({ alias: params.alias });
+		return yield* promptManager.passwordPrompt({
+			message: params.message,
+			validate: (v) => Effect.gen(function* () {
+				if (v.trim() === "") return yield* Effect.fail("Password cannot be empty");
+				yield* Effect.tryPromise({
+					try: () => Wallet.fromV3(key.data, v),
+					catch: () => new SessionKeyManagerError({
+						code: "DecryptError",
+						message: `Invalid password for session key ${params.alias}`
+					})
+				}).pipe(Effect.catch(() => Effect.fail("Invalid password")));
+				return v;
+			})
+		});
+	});
+	const getSessionKeySigner = (params) => Effect.gen(function* () {
+		const key = yield* getSessionKey({ alias: params.alias });
+		const signer = yield* Effect.tryPromise({
+			try: async () => {
+				return privateKeyToAccount(toHex((await Wallet.fromV3(key.data, params.password)).getPrivateKey()));
+			},
+			catch: () => new SessionKeyManagerError({
+				code: "DecryptError",
+				message: `Invalid password for session key ${params.alias}`
+			})
+		});
+		return {
+			...key,
+			signer
+		};
+	});
+	const removeSessionKey = (params) => Effect.gen(function* () {
+		const key = yield* getSessionKey({ alias: params.alias });
+		return yield* configManager.removeEntity({
+			alias: key.alias,
+			type: "session-key"
+		});
+	});
+	return SessionKeyManager.of({
+		createSessionKey: createSessionKey$1,
+		getSessionKey,
+		listSessionKeys,
+		selectSessionKey,
+		getSessionKeyStatus,
+		multiSelectSessionKeys,
+		getSessionKeyPassword,
+		getSessionKeySigner,
+		removeSessionKey
+	});
+}));
+//#endregion
+//#region src/layers/mcp.ts
+const McpManager = ServiceMap.Service("@namera-ai/cli/McpManager");
+const layer$1 = Layer.effect(McpManager, Effect.gen(function* () {
+	const smartAccountManager = yield* SmartAccountManager;
+	const sessionKeyManager = yield* SessionKeyManager;
+	const startMcpServer = (params) => Effect.gen(function* () {
+		const sa = yield* smartAccountManager.getSmartAccount({ alias: params.smartAccountAlias });
+		const sessionKeys = Object.entries(params.sessionKeys);
+		const sessionKeysWithSigners = yield* Effect.all(sessionKeys.map(([alias, password]) => sessionKeyManager.getSessionKeySigner({
+			alias,
+			password
+		})));
+		const context = McpContext.of({
+			smartAccount: sa.data,
+			sessionKeys: sessionKeysWithSigners
+		});
+		if (params.transport === "stdio") yield* startMcpStdioServer().pipe(Effect.provideService(McpContext, context));
+		else yield* startMcpHttpServer(params.port ?? 8080).pipe(Effect.provideService(McpContext, context));
+	});
+	return McpManager.of({ startMcpServer });
+}));
+//#endregion
+//#region src/helpers/pretty.ts
+/** biome-ignore-all lint/suspicious/noExplicitAny: safe */
+const keyColors = [
+	"\x1B[36m",
+	"\x1B[35m",
+	"\x1B[34m",
+	"\x1B[32m",
+	"\x1B[33m"
+];
+const reset = "\x1B[0m";
+const bold = "\x1B[1m";
+/**
+* Returns a shallow copy of an object with humanized key names.
+*/
+const transformKeys = (obj) => {
+	return Object.fromEntries(Object.entries(obj).map(([k, v]) => [formatKey(k), v]));
+};
+/**
+* Humanizes a key by spacing words and title-casing tokens.
+*/
+const formatKey = (key) => key.replace(/[_-]/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/\b\w/g, (c) => c.toUpperCase());
+/**
+* Formats a primitive-like value for display.
+*/
+const formatValue = (value) => {
+	if (value === null) return "null";
+	if (typeof value === "bigint") return `${value}n`;
+	if (value instanceof Date) return value.toISOString();
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return String(value);
+};
+/**
+* Returns true when a value is a display-friendly primitive.
+*/
+const isPrimitive = (v) => v === null || typeof v !== "object" || v instanceof Date;
+/**
+* Determines whether an array contains only flat objects of primitives.
+*/
+const isFlatObjectArray = (arr) => arr.length > 0 && arr.every((item) => item && typeof item === "object" && !Array.isArray(item) && Object.values(item).every(isPrimitive));
+/**
+* Formats objects or arrays into a human-friendly CLI display string.
+*
+* Uses colorized keys when printing objects, and falls back to tabular
+* output for flat object arrays at the root level.
+*/
+const prettyFormat = (input, depth = 0, isRoot = true) => {
+	const indent = 2;
+	const maxDepth = 6;
+	const space = " ".repeat(indent * depth);
+	if (depth > maxDepth) return `${space}…`;
+	if (isRoot && Array.isArray(input) && isFlatObjectArray(input)) {
+		const transformed = input.map(transformKeys);
+		console.table(transformed);
+		return "";
+	}
+	if (Array.isArray(input)) return input.map((item, i) => {
+		if (isPrimitive(item)) return `${space}${formatValue(item)}`;
+		return `${space}[${i}]\n${prettyFormat(item, depth + 1, false)}`;
+	}).join("\n");
+	return Object.entries(input).map(([key, value]) => {
+		const k = `${bold}${keyColors[depth % keyColors.length]}${formatKey(key)}${reset}`;
+		if (isPrimitive(value)) return `${space}${k}: ${formatValue(value)}`;
+		return `${space}${k}:\n${prettyFormat(value, depth + 1, false)}`;
+	}).join("\n");
+};
+//#endregion
+//#region src/layers/output.ts
+/**
+* Service tag for resolving {@link OutputFormatter} from the Effect context.
+*/
+const OutputFormatter = ServiceMap.Service("@namera-ai/cli/OutputFormatter");
+/**
+* Live layer that formats output as pretty, JSON, or NDJSON.
+*/
+const layer = Layer.succeed(OutputFormatter, OutputFormatter.of({ format: (data, format) => Effect.gen(function* () {
+	if (format === "pretty") return prettyFormat(data);
+	if (format === "json") return JSON.stringify(data, null, 2);
+	if (Array.isArray(data)) return NdJson.stringify(data);
+	return NdJson.stringify([data]);
+}) }));
+//#endregion
+//#region src/commands/keystore/create.ts
+const createKeystoreHandler = (flagAlias, flagPassword) => Effect.gen(function* () {
+	const promptManager = yield* PromptManager;
+	const keystoreManager = yield* KeystoreManager;
+	const outputFormatter = yield* OutputFormatter;
+	const globalFlags = yield* getGlobalFlags();
+	let params;
+	if (globalFlags.params._tag === "Some") params = Schema.decodeUnknownSync(Schema.fromJsonString(CreateKeystoreParams))(globalFlags.params.value);
+	else {
+		let alias;
+		let password;
+		if (flagAlias._tag === "Some") alias = flagAlias.value;
+		else alias = yield* promptManager.aliasPrompt({
+			aliasType: "new",
+			message: "Enter alias for keystore:",
+			type: "keystore"
+		});
+		if (flagPassword._tag === "Some") password = flagPassword.value;
+		else password = yield* promptManager.passwordPrompt({ message: "Enter password for keystore:" });
+		params = {
+			alias,
+			password: Redacted.value(password)
+		};
+	}
+	const res = yield* keystoreManager.createKeystore(params);
+	const data = {
+		address: res.data.address,
+		alias: res.alias,
+		path: res.path
+	};
+	if (globalFlags.quite) return;
+	const output = yield* outputFormatter.format(data, globalFlags.out);
+	yield* Console.log(output);
+});
+const alias$12 = Flag.string("alias").pipe(Flag.withDescription("The alias of the keystore to create"), Flag.withAlias("a"), Flag.optional);
+const password$2 = Flag.redacted("password").pipe(Flag.withDescription("The password to encrypt the keystore with"), Flag.withAlias("p"), Flag.optional);
+/**
+* Command that creates a new keystore and stores it locally.
+*/
+const createKeystoreCommand = Command.make("create", {
+	alias: alias$12,
+	password: password$2
+}, ({ alias, password }) => createKeystoreHandler(alias, password)).pipe(Command.withAlias("c"), Command.withDescription("Creates a random keypair and stores it as keystore"), Command.withExamples([
+	{
+		command: "namera keystore create -a my-wallet",
+		description: "Creates a new keystore with alias 'my-wallet'"
+	},
+	{
+		command: "namera keystore create --alias my-wallet --password my-password",
+		description: "Creates a new keystore with alias 'my-wallet' and password 'my-password'"
+	},
+	{
+		command: `namera keystore create --params '{"alias":"my-wallet","password":"my-password"}'`,
+		description: "Creates a new keystore with json params"
+	},
+	{
+		command: "namera schema keystore.create",
+		description: "Get the schema for the create command"
+	}
+]));
+//#endregion
+//#region src/commands/keystore/decrypt.ts
+const handler$14 = (flagAlias, flagPassword) => Effect.gen(function* () {
+	const keystoreManager = yield* KeystoreManager;
+	const promptManager = yield* PromptManager;
+	const outputFormatter = yield* OutputFormatter;
+	const globalFlags = yield* getGlobalFlags();
+	let params;
+	if (globalFlags.params._tag === "Some") params = Schema.decodeUnknownSync(Schema.fromJsonString(DecryptKeystoreParams))(globalFlags.params.value);
+	else {
+		let alias;
+		let password;
+		if (flagAlias._tag === "Some") alias = flagAlias.value;
+		else alias = (yield* keystoreManager.selectKeystore({ message: "Select keystore:" })).alias;
+		if (flagPassword._tag === "Some") password = flagPassword.value;
+		else password = yield* promptManager.passwordPrompt({ message: "Enter password for keystore:" });
+		params = {
+			alias,
+			password: Redacted.value(password)
+		};
+	}
+	const res = yield* keystoreManager.decryptKeystore(params);
+	const data = {
+		alias: res.alias,
+		address: res.address,
+		publicKey: res.publicKey,
+		privateKey: Redacted.value(res.privateKey)
+	};
+	if (globalFlags.quite) return;
+	const output = yield* outputFormatter.format(data, globalFlags.out);
+	yield* Console.log(output);
+});
+const alias$11 = Flag.string("alias").pipe(Flag.withDescription("The alias of the keystore to decrypt"), Flag.withAlias("a"), Flag.optional);
+const password$1 = Flag.redacted("password").pipe(Flag.withDescription("The password to decrypt the keystore with"), Flag.withAlias("p"), Flag.optional);
+/**
+* Command that decrypts a keystore and prints key material.
+*/
+const decryptKeystoreCommand = Command.make("decrypt", {
+	alias: alias$11,
+	password: password$1
+}, ({ alias, password }) => handler$14(alias, password)).pipe(Command.withAlias("d"), Command.withDescription("Decrypt a keystore to get the private key"), Command.withExamples([
+	{
+		command: "namera keystore decrypt",
+		description: "Decrypt a keystore with alias and password prompts"
+	},
+	{
+		command: "namera keystore decrypt --alias my-wallet --password my-password",
+		description: "Decrypt a keystore with alias and password"
+	},
+	{
+		command: `namera keystore decrypt --params '{"alias":"my-wallet","password":"my-password"}'`,
+		description: "Decrypt a keystore with json params"
+	},
+	{
+		command: "namera schema keystore.decrypt",
+		description: "Get the schema for the decrypt command"
+	}
+]));
+//#endregion
+//#region src/commands/keystore/import.ts
+const handler$13 = (flagAlias, flagPassword, flagPrivateKey) => Effect.gen(function* () {
+	const keystoreManager = yield* KeystoreManager;
+	const promptManager = yield* PromptManager;
+	const outputFormatter = yield* OutputFormatter;
+	const globalFlags = yield* getGlobalFlags();
+	let params;
+	if (globalFlags.params._tag === "Some") params = Schema.decodeUnknownSync(Schema.fromJsonString(ImportKeystoreParams))(globalFlags.params.value);
+	else {
+		let alias;
+		let password;
+		let privateKey;
+		if (flagAlias._tag === "Some") alias = flagAlias.value;
+		else alias = yield* promptManager.aliasPrompt({
+			aliasType: "new",
+			message: "Enter alias for keystore:",
+			type: "keystore"
+		});
+		if (flagPassword._tag === "Some") password = flagPassword.value;
+		else password = yield* promptManager.passwordPrompt({ message: "Enter password for keystore:" });
+		if (flagPrivateKey._tag === "Some") privateKey = flagPrivateKey.value;
+		else privateKey = yield* promptManager.hexPrompt({
+			redacted: true,
+			length: 32,
+			message: "Enter private key:"
+		});
+		params = {
+			alias,
+			password: Redacted.value(password),
+			privateKey: Redacted.value(privateKey)
+		};
+	}
+	const res = yield* keystoreManager.importKeystore(params);
+	const data = {
+		alias: res.alias,
+		address: res.data.address,
+		path: res.path
+	};
+	if (globalFlags.quite) return;
+	const output = yield* outputFormatter.format(data, globalFlags.out);
+	yield* Console.log(output);
+});
+const alias$10 = Flag.string("alias").pipe(Flag.withDescription("The alias of the keystore to import"), Flag.withAlias("a"), Flag.optional);
+const privateKey = Flag.redacted("private-key").pipe(Flag.withDescription("The private key of the keystore to import"), Flag.optional);
+const password = Flag.redacted("password").pipe(Flag.withDescription("The password to encrypt the keystore with"), Flag.withAlias("p"), Flag.optional);
+/**
+* Command that imports a keystore from a private key.
+*/
+const importKeystoreCommand = Command.make("import", {
+	alias: alias$10,
+	privateKey,
+	password
+}, ({ alias, password, privateKey }) => handler$13(alias, password, privateKey)).pipe(Command.withAlias("i"), Command.withDescription("Import a keystore from a private key"), Command.withExamples([
+	{
+		command: "namera keystore import",
+		description: "Import a keystore with interactive prompts"
+	},
+	{
+		command: "namera keystore import --alias my-wallet",
+		description: "Import a keystore with alias 'my-wallet'"
+	},
+	{
+		command: "namera keystore import -a my-wallet -p my-password --private-key 0x1234567890abcdef",
+		description: "Import a keystore with alias 'my-wallet', password 'my-password', and private key '0x1234567890abcdef'"
+	},
+	{
+		command: "namera schema keystore.import",
+		description: "Get the schema for the import command"
+	}
+]));
+//#endregion
+//#region src/commands/keystore/info.ts
+const getKeystoreInfoHandler = (flagAlias) => Effect.gen(function* () {
+	const keystoreManager = yield* KeystoreManager;
+	const outputFormatter = yield* OutputFormatter;
+	const globalFlags = yield* getGlobalFlags();
+	let params;
+	if (globalFlags.params._tag === "Some") params = Schema.decodeUnknownSync(Schema.fromJsonString(GetKeystoreParams))(globalFlags.params.value);
+	else {
+		let alias;
+		if (flagAlias._tag === "Some") alias = flagAlias.value;
+		else alias = (yield* keystoreManager.selectKeystore({ message: "Select keystore:" })).alias;
+		params = { alias };
+	}
+	const res = yield* keystoreManager.getKeystore(params);
+	const data = {
+		alias: res.alias,
+		address: res.data.address,
+		path: res.path
+	};
+	if (globalFlags.quite) return;
+	const output = yield* outputFormatter.format(data, globalFlags.out);
+	yield* Console.log(output);
+});
+const alias$9 = Flag.string("alias").pipe(Flag.withDescription("The alias of the keystore to retrieve"), Flag.withAlias("a"), Flag.optional);
+/**
+* Command that returns metadata for a keystore.
+*/
+const getKeystoreInfoCommand = Command.make("info", { alias: alias$9 }, ({ alias }) => getKeystoreInfoHandler(alias)).pipe(Command.withDescription("Get information about a keystore"), Command.withExamples([
+	{
+		command: "namera keystore info",
+		description: "Get information about a keystore with alias prompt"
+	},
+	{
+		command: "namera keystore info --alias my-wallet",
+		description: "Get information about a keystore with alias 'my-wallet'"
+	},
+	{
+		command: `namera keystore info --params '{"alias":"my-wallet"}'`,
+		description: "Get information about a keystore with json params"
+	},
+	{
+		command: "namera keystore info --alias my-wallet --output json",
+		description: "Get information about a keystore in json format"
+	},
+	{
+		command: "namera schema keystore.info",
+		description: "Get the schema for the info command"
+	}
+]));
+//#endregion
+//#region src/commands/keystore/list.ts
+const listKeystoreHandler = () => Effect.gen(function* () {
+	const keystoreManager = yield* KeystoreManager;
+	const outputFormatter = yield* OutputFormatter;
+	const globalFlags = yield* getGlobalFlags();
+	const data = (yield* keystoreManager.listKeystores()).map((k) => ({
+		alias: k.alias,
+		address: k.data.address,
+		path: k.path
+	}));
+	if (globalFlags.quite) return;
+	const output = yield* outputFormatter.format(data, globalFlags.out);
+	yield* Console.log(output);
+});
+/**
+* Command that lists all stored keystores.
+*/
+const listKeystoresCommand = Command.make("list", {}, () => listKeystoreHandler()).pipe(Command.withAlias("ls"), Command.withDescription("List all keystores"), Command.withExamples([
+	{
+		command: "namera keystore list",
+		description: "List all keystores"
+	},
+	{
+		command: "namera keystore list --output json",
+		description: "List all keystores in json format"
+	},
+	{
+		command: "namera keystore list --output ndjson",
+		description: "List all keystores in ndjson format"
+	},
+	{
+		command: "namera schema keystore.list",
+		description: "Get the schema for the list command"
+	}
+]));
+//#endregion
+//#region src/commands/keystore/remove.ts
+const handler$12 = (flagAlias) => Effect.gen(function* () {
+	const keystoreManager = yield* KeystoreManager;
+	const outputFormatter = yield* OutputFormatter;
+	const globalFlags = yield* getGlobalFlags();
+	let params;
+	if (globalFlags.params._tag === "Some") params = Schema.decodeUnknownSync(Schema.fromJsonString(RemoveKeystoreParams))(globalFlags.params.value);
+	else {
+		let alias;
+		if (flagAlias._tag === "Some") alias = flagAlias.value;
+		else alias = (yield* keystoreManager.selectKeystore({ message: "Select keystore:" })).alias;
+		params = { alias };
+	}
+	yield* keystoreManager.removeKeystore(params);
+	const data = { success: true };
+	if (globalFlags.quite) return;
+	const output = yield* outputFormatter.format(data, globalFlags.out);
+	yield* Console.log(output);
+});
+const alias$8 = Flag.string("alias").pipe(Flag.withDescription("The alias of the keystore to remove"), Flag.withAlias("a"), Flag.optional);
+const removeKeystoreCommand = Command.make("remove", { alias: alias$8 }, ({ alias }) => handler$12(alias)).pipe(Command.withAlias("rm"), Command.withDescription("Remove a keystore"), Command.withExamples([
+	{
+		command: "namera keystore remove",
+		description: "Remove a keystore with alias prompt"
+	},
+	{
+		command: "namera keystore remove --alias my-wallet",
+		description: "Remove a keystore with alias 'my-wallet'"
+	},
+	{
+		command: `namera keystore remove --params '{"alias":"my-wallet"}'`,
+		description: "Remove a keystore with json params"
+	},
+	{
+		command: "namera schema keystore.remove",
+		description: "Get the schema for the remove command"
+	}
+]));
+//#endregion
+//#region src/commands/keystore/index.ts
+/**
+* Command group for keystore-related operations.
+*/
+const keystoreCommands = Command.make("keystore", {}, () => Effect.void).pipe(Command.withDescription("Keystore management utilities."), Command.withAlias("k"), Command.withSubcommands([
+	createKeystoreCommand,
+	listKeystoresCommand,
+	getKeystoreInfoCommand,
+	decryptKeystoreCommand,
+	importKeystoreCommand,
+	removeKeystoreCommand
+]));
+//#endregion
+//#region src/commands/mcp/start.ts
+const handler$11 = (flagSmartAccount, flagSessionKeys, flagTransport, flagPort) => Effect.gen(function* () {
+	const smartAccountManager = yield* SmartAccountManager;
+	const sessionKeyManager = yield* SessionKeyManager;
+	const mcpManager = yield* McpManager;
+	const globalFlags = yield* getGlobalFlags();
+	let params;
+	if (globalFlags.params._tag === "Some") params = Schema.decodeUnknownSync(Schema.fromJsonString(StartMcpServerParams))(globalFlags.params.value);
+	else {
+		let smartAccountAlias;
+		let sessionKeys = {};
+		let transport;
+		let port;
+		if (flagSmartAccount._tag === "Some") smartAccountAlias = flagSmartAccount.value;
+		else smartAccountAlias = (yield* smartAccountManager.selectSmartAccount({ message: "Select smart account to use for the MCP server" })).alias;
+		if (flagSessionKeys._tag === "Some") sessionKeys = flagSessionKeys.value;
+		else {
+			const keys = yield* sessionKeyManager.multiSelectSessionKeys({
+				message: "Select session keys to use for the MCP server",
+				smartAccount: smartAccountAlias
+			});
+			for (const key of keys) {
+				const pass = yield* sessionKeyManager.getSessionKeyPassword({
+					alias: key.alias,
+					message: `Enter password for session key ${key.alias}:`
+				});
+				sessionKeys[key.alias] = Redacted.value(pass);
+			}
+		}
+		if (flagTransport._tag === "Some") transport = flagTransport.value;
+		else transport = "stdio";
+		if (flagPort._tag === "Some") port = flagPort.value;
+		else port = 8080;
+		params = {
+			smartAccountAlias,
+			sessionKeys,
+			transport,
+			port
+		};
+	}
+	yield* mcpManager.startMcpServer(params);
+});
+const smartAccount = Flag.string("smart-account").pipe(Flag.withAlias("sa"), Flag.optional, Flag.withDescription("The smart account alias to use for the MCP server"));
+const sessionKeys = Flag.keyValuePair("session-key").pipe(Flag.withAlias("sk"), Flag.optional, Flag.withDescription("The session key aliases, password pairs to use for the MCP server"));
+const transport = Flag.choice("transport", ["stdio", "http"]).pipe(Flag.withAlias("t"), Flag.optional, Flag.withDescription("The transport to use for the MCP server"));
+const port = Flag.integer("port").pipe(Flag.withAlias("p"), Flag.optional, Flag.withDescription("The port to use for the MCP server when using http transport"));
+const startMcpCommand = Command.make("start", {
+	smartAccount,
+	sessionKeys,
+	transport,
+	port
+}, ({ smartAccount, sessionKeys, transport, port }) => handler$11(smartAccount, sessionKeys, transport, port)).pipe(Command.withAlias("s"), Command.withDescription("Starts the local MCP server."), Command.withExamples([
+	{
+		command: "namera mcp start --smart-account my-smart --session-key my-key=my-password",
+		description: "Starts the local MCP server with a single session key and the default transport"
+	},
+	{
+		command: "namera mcp start --smart-account my-smart --session-key my-key=my-password --transport http --port 8080",
+		description: "Starts the local MCP server with a single session key and http transport on port 8080"
+	},
+	{
+		command: "namera mcp start --smart-account my-smart --session-key my-key=my-password --session-key my-other-key=my-other-password",
+		description: "Starts the local MCP server with multiple session keys and the default transport"
+	},
+	{
+		command: "namera schema mcp.start",
+		description: "Get the schema for the start command"
+	}
+]));
+//#endregion
+//#region src/commands/mcp/index.ts
+const mcpCommands = Command.make("mcp", {}, () => Effect.void).pipe(Command.withDescription("Start and manage the Namera MCP server"), Command.withSubcommands([startMcpCommand]));
+//#endregion
+//#region src/helpers/paths.ts
+/** biome-ignore-all lint/suspicious/noExplicitAny: safe */
+/**
+* Returns the value at a dot-delimited path within a nested object.
+*
+* @param obj - Object to traverse.
+* @param path - Dot-delimited lookup path.
+*/
+const getSchema = (obj, path) => {
+	return path.split(".").reduce((acc, key) => acc[key], obj);
+};
+/**
+* Extracts all dot-delimited paths that terminate at Effect schemas.
+*
+* @param obj - Object tree to scan.
+* @param prefix - Internal prefix used to build nested paths.
+*/
+const extractPaths = (obj, prefix = "") => {
+	return Object.entries(obj).flatMap(([key, value]) => {
+		const newPath = prefix ? `${prefix}.${key}` : key;
+		if (Schema.isSchema(value)) return [newPath];
+		if (typeof value === "object" && value !== null) return extractPaths(value, newPath);
+		return [];
+	});
+};
+//#endregion
+//#region src/commands/schema/index.ts
+/**
+* Schema registry keyed by command path.
+*/
+const schemas = {
+	keystore: {
+		create: CreateKeystoreParams,
+		decrypt: DecryptKeystoreParams,
+		info: GetKeystoreParams,
+		list: ListKeystoreParams,
+		import: ImportKeystoreParams,
+		remove: RemoveKeystoreParams
+	},
+	"smart-account": {
+		create: CreateSmartAccountParams,
+		list: ListSmartAccountParams,
+		info: GetSmartAccountInfoParams,
+		remove: RemoveSmartAccountParams,
+		status: GetSmartAccountStatusParams,
+		import: ImportSmartAccountParams
+	},
+	"session-key": {
+		create: CreateSessionKeyParams,
+		list: ListSessionKeysParams,
+		info: GetSessionKeyInfoParams,
+		remove: RemoveSessionKeyParams,
+		status: GetSessionKeyStatusParams
+	},
+	mcp: { start: StartMcpServerParams }
+};
+const commands$1 = extractPaths(schemas);
+const command$1 = Argument.choice("command", commands$1).pipe(Argument.withDescription("The command to get the schema for"));
+/**
+* Command that prints JSON Schema for a given CLI command.
+*/
+const schemaCommand = Command.make("schema", { command: command$1 }, ({ command }) => Effect.gen(function* () {
+	const schema = getSchema(schemas, command);
+	const json = Schema.toJsonSchemaDocument(schema);
+	yield* Console.log(JSON.stringify(json, null, 2));
+})).pipe(Command.withDescription("Get the schema for a command"));
+//#endregion
+//#region src/commands/session-key/create/prompts/base.ts
+const policyChoices = [
+	{
+		description: "Grant access to all operations",
+		title: "Sudo Permission",
+		value: "sudo"
+	},
+	{
+		description: "Whitelist addresses, contract and functions",
+		title: "Call Permission",
+		value: "call"
+	},
+	{
+		description: "Specify the start and end time for when the key is valid",
+		title: "Timestamp Permission",
+		value: "timestamp"
+	},
+	{
+		description: "Specify the allowed gas usage for the session key",
+		title: "Gas Permission",
+		value: "gas"
+	},
+	{
+		description: "Specify which addresses can verify signatures from this session key",
+		title: "Signature Permission",
+		value: "signature-caller"
+	},
+	{
+		description: "Specify the allowed gas usage for the session key",
+		title: "Rate Limit Permission",
+		value: "rate-limit"
+	},
+	{
+		description: "Complete the session key creation",
+		title: "Done",
+		value: "done"
+	}
+];
+const policyChoicePrompt = (prevPolicies) => Effect.gen(function* () {
+	const choices = policyChoices.filter((c) => !prevPolicies.some((p) => p.type === c.value));
+	return yield* Prompt.select({
+		choices,
+		message: "Select Permission type you want to add for this session key"
+	});
+});
+//#endregion
+//#region src/commands/session-key/create/prompts/common.ts
+const addressPrompt = (message) => Prompt.text({
+	message,
+	validate: (value) => Effect.gen(function* () {
+		const res = Schema.decodeUnknownOption(EthereumAddress)(value);
+		if (Option.isNone(res)) return yield* Effect.fail("Invalid Ethereum Address");
+		return value;
+	})
+});
+const etherPrompt = (message) => Prompt.text({
+	message,
+	validate: (val) => Effect.gen(function* () {
+		const schema = Schema.NumberFromString.check(Schema.isGreaterThanOrEqualTo(0));
+		const res = Schema.decodeOption(schema)(val);
+		if (Option.isNone(res)) return yield* Effect.fail("Invalid Number");
+		return res.value.toString();
+	})
+});
+//#endregion
+//#region src/commands/session-key/create/prompts/call.ts
+const getEOAPermission = () => Effect.gen(function* () {
+	return [{
+		target: yield* addressPrompt("Enter target address:"),
+		valueLimit: parseEther(yield* etherPrompt("Max value that can be transferred (in ETH units):"), "wei")
+	}];
+});
+const getSmartContractPermission = () => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const address = yield* addressPrompt("Enter smart contract address:");
+	const maxLimit = yield* etherPrompt("Max value that can be transferred (in ETH units)");
+	const abiFilePath = yield* Prompt.file({ message: "Select the ABI file for the smart contract" });
+	const abiString = yield* fs.readFileString(abiFilePath).pipe(Effect.orDie);
+	const functions = JSON.parse(abiString).filter((e) => e.type === "function");
+	const allowedFunctions = yield* Prompt.multiSelect({
+		choices: functions.map((f) => {
+			let signature = `${f.name}(`;
+			for (let i = 0; i < f.inputs.length; i++) {
+				const sep = f.inputs.length === 0 || i === f.inputs.length - 1 ? "" : ", ";
+				const input = f.inputs[i];
+				signature += `${input.type}${input.name ? ` ${input.name}` : ""}${sep}`;
+			}
+			signature += ")";
+			return {
+				description: signature,
+				title: f.name,
+				value: f
+			};
+		}),
+		message: "Select the functions you want to allow",
+		min: 1
+	});
+	const weiUnits = parseEther(maxLimit);
+	return allowedFunctions.map((f) => {
+		return {
+			abi: [f],
+			functionName: f.name,
+			selector: toFunctionSelector(f),
+			target: address,
+			valueLimit: weiUnits
+		};
+	});
+});
+const getPermissions = () => Effect.gen(function* () {
+	const permissions = [];
+	const targetAddressPrompt = Prompt.select({
+		choices: [{
+			title: "EOA",
+			value: "eoa"
+		}, {
+			title: "Smart Contract",
+			value: "smart-contract"
+		}],
+		message: "Select target address type"
+	});
+	while (true) {
+		if (permissions.length > 0) {
+			if (!(yield* Prompt.confirm({ message: "Do you want to add another call permission?" }))) break;
+		}
+		if ((yield* targetAddressPrompt) === "eoa") {
+			const res = yield* getEOAPermission();
+			permissions.push(...res);
+		} else {
+			const res = yield* getSmartContractPermission();
+			permissions.push(...res);
+		}
+	}
+	return permissions;
+});
+const getCallPolicyParams = Effect.gen(function* () {
+	return {
+		permissions: yield* getPermissions(),
+		policyVersion: "0.0.4",
+		type: "call"
+	};
+});
+//#endregion
+//#region src/commands/session-key/create/prompts/gas.ts
+const getGasPolicyParams = Effect.gen(function* () {
+	const allowed = yield* etherPrompt("Total amount of gas allowed (in ETH units)");
+	const enforcePaymaster = yield* Prompt.confirm({ message: "Should UserOperations require Paymaster?" });
+	return {
+		amount: parseEther(allowed),
+		type: "gas",
+		enforcePaymaster
+	};
+});
+//#endregion
+//#region src/commands/session-key/create/prompts/rate-limit.ts
+/** biome-ignore-all lint/suspicious/noExplicitAny: safe */
+const getRateLimitPolicyParams = Effect.gen(function* () {
+	const interval = yield* Prompt.text({
+		message: "Duration for which rate limit is enforced? (e.g. 1 hour, 1 day, 1 week)",
+		validate: (v) => Effect.gen(function* () {
+			if (Duration.fromInput(v)._tag === "None") return yield* Effect.fail("Invalid duration");
+			return v;
+		})
+	});
+	const intervalDuration = Duration.fromInputUnsafe(interval);
+	const count = yield* Prompt.integer({
+		message: "Number of requests allowed per interval.",
+		validate: (v) => Effect.gen(function* () {
+			if (v < 1) return yield* Effect.fail("Count must be greater than 0");
+			return v;
+		})
+	});
+	const startAt = yield* Prompt.date({
+		initial: /* @__PURE__ */ new Date(),
+		message: "Date at which the rate limit is enforced.",
+		validate: (d) => Effect.gen(function* () {
+			if (d < /* @__PURE__ */ new Date()) return yield* Effect.fail("Date must be in the future");
+			return d;
+		})
+	});
+	return {
+		type: "rate-limit",
+		count,
+		interval: Duration.toMillis(intervalDuration),
+		startAt: Math.floor(startAt.getTime() / 1e3)
+	};
+});
+//#endregion
+//#region src/commands/session-key/create/prompts/signature-caller.ts
+const getSignatureCallerPolicyParams = Effect.gen(function* () {
+	return {
+		type: "signature-caller",
+		allowedCallers: (yield* Prompt.text({
+			message: "Comma-separated list of allowed callers:",
+			validate: (v) => Effect.gen(function* () {
+				const address = v.split(",").map((a) => a.trim());
+				for (let i = 0; i < address.length; i++) {
+					const a = address[i];
+					if (Schema.decodeUnknownOption(EthereumAddress)(a)._tag === "None") return yield* Effect.fail(`Invalid Ethereum Address at index ${i}`);
+				}
+				return v;
+			})
+		})).split(",").map((a) => a.trim()).map((a) => Schema.decodeUnknownSync(EthereumAddress)(a))
+	};
+});
+//#endregion
+//#region src/commands/session-key/create/prompts/timestamp.ts
+const getTimestampPolicyParams = Effect.gen(function* () {
+	const validAfter = yield* Prompt.date({
+		initial: /* @__PURE__ */ new Date(),
+		message: "Time after which the key becomes valid.",
+		validate: (d) => Effect.gen(function* () {
+			if (d < /* @__PURE__ */ new Date()) return yield* Effect.fail("Date must be in the future");
+			return d;
+		})
+	});
+	const validUntil = yield* Prompt.date({
+		initial: /* @__PURE__ */ new Date(),
+		message: "Time until which the key becomes valid.",
+		validate: (d) => Effect.gen(function* () {
+			if (d < /* @__PURE__ */ new Date()) return yield* Effect.fail("Date must be in the future");
+			if (d < validAfter) return yield* Effect.fail("Valid until must be after valid after");
+			return d;
+		})
+	});
+	return {
+		type: "timestamp",
+		validAfter: Math.floor(validAfter.getTime() / 1e3),
+		validUntil: Math.floor(validUntil.getTime() / 1e3)
+	};
+});
+//#endregion
+//#region src/commands/session-key/create/prompts/index.ts
+const getPoliciesFromUser = () => Effect.gen(function* () {
+	const policyParams = [];
+	while (true) {
+		if (policyParams.length > 0) {
+			if (!(yield* Prompt.confirm({ message: "Do you want to add another policy?" }))) break;
+		}
+		const policyType = yield* policyChoicePrompt(policyParams);
+		if (policyType === "sudo") {
+			policyParams.push({ type: "sudo" });
+			break;
+		}
+		if (policyType === "timestamp") {
+			const res = yield* getTimestampPolicyParams;
+			policyParams.push(res);
+		} else if (policyType === "call") {
+			const res = yield* getCallPolicyParams;
+			policyParams.push(res);
+		} else if (policyType === "gas") {
+			const res = yield* getGasPolicyParams;
+			policyParams.push(res);
+		} else if (policyType === "rate-limit") {
+			const res = yield* getRateLimitPolicyParams;
+			policyParams.push(res);
+		} else if (policyType === "signature-caller") {
+			const res = yield* getSignatureCallerPolicyParams;
+			policyParams.push(res);
+		} else break;
+	}
+	return policyParams;
+});
+//#endregion
+//#region src/commands/session-key/create/index.ts
+const handler$10 = (flagAlias, flagSmartAccountAlias, flagSessionKeyPassword, flagOwnerKeystorePassword) => Effect.gen(function* () {
+	const promptManager = yield* PromptManager;
+	const web3Service = yield* Web3Service;
+	const smartAccountManager = yield* SmartAccountManager;
+	const sessionKeyManager = yield* SessionKeyManager;
+	const outputFormatter = yield* OutputFormatter;
+	const globalFlags = yield* getGlobalFlags();
+	let params;
+	if (globalFlags.params._tag === "Some") params = Schema.decodeUnknownSync(Schema.fromJsonString(CreateSessionKeyParams))(globalFlags.params.value);
+	else {
+		let alias;
+		let smartAccountAlias;
+		let sessionKeyPassword;
+		let ownerKeystorePassword;
+		if (flagAlias._tag === "Some") alias = flagAlias.value;
+		else alias = yield* promptManager.aliasPrompt({
+			aliasType: "new",
+			message: "Enter alias for session key:",
+			type: "session-key"
+		});
+		if (flagSmartAccountAlias._tag === "Some") smartAccountAlias = flagSmartAccountAlias.value;
+		else smartAccountAlias = (yield* smartAccountManager.selectSmartAccount({ message: "Select smart account:" })).alias;
+		const chains = yield* web3Service.multiSelectChain({ message: "Select chains:" });
+		if (flagSessionKeyPassword._tag === "Some") sessionKeyPassword = flagSessionKeyPassword.value;
+		else sessionKeyPassword = yield* promptManager.passwordPrompt({ message: "Enter session key password:" });
+		const sa = yield* smartAccountManager.getSmartAccount({ alias: smartAccountAlias });
+		if (flagOwnerKeystorePassword._tag === "Some") ownerKeystorePassword = flagOwnerKeystorePassword.value;
+		else ownerKeystorePassword = yield* promptManager.passwordPrompt({ message: `Enter keystore password for owner (${sa.data.ownerAlias}):` });
+		const policyParams = yield* getPoliciesFromUser();
+		params = {
+			alias,
+			chains,
+			smartAccountAlias,
+			sessionKeyPassword: Redacted.value(sessionKeyPassword),
+			ownerKeystorePassword: Redacted.value(ownerKeystorePassword),
+			policyParams
+		};
+	}
+	const res = yield* sessionKeyManager.createSessionKey(params);
+	const data = {
+		...res.data.sessionKeyType === "ecdsa" ? { sessionKeyAddress: res.data.sessionKeyAddress } : { passKeyName: res.data.passKeyName },
+		smartAccount: res.data.smartAccountAlias,
+		chains: res.data.serializedAccounts.map((a) => getChain(a.chain).name)
+	};
+	if (globalFlags.quite) return;
+	const output = yield* outputFormatter.format(data, globalFlags.out);
+	yield* Console.log(output);
+});
+const alias$7 = Flag.string("alias").pipe(Flag.withDescription("The alias of the session key to create"), Flag.withAlias("a"), Flag.optional);
+const smartAccountAlias$1 = Flag.string("smart-account").pipe(Flag.withDescription("The alias of the smart account to create session key for"), Flag.withAlias("sa"), Flag.optional);
+const sessionKeyPassword = Flag.redacted("password").pipe(Flag.withDescription("Password to encrypt session key"), Flag.withAlias("p"), Flag.optional);
+const ownerKeystorePassword = Flag.redacted("owner-password").pipe(Flag.withDescription("Password to encrypt session key"), Flag.withAlias("op"), Flag.optional);
+/**
+* Command that creates a new session key and stores it locally.
+*/
+const createSessionKeyCommand = Command.make("create", {
+	alias: alias$7,
+	smartAccountAlias: smartAccountAlias$1,
+	sessionKeyPassword,
+	ownerKeystorePassword
+}, ({ alias, smartAccountAlias, sessionKeyPassword, ownerKeystorePassword }) => handler$10(alias, smartAccountAlias, sessionKeyPassword, ownerKeystorePassword)).pipe(Command.withAlias("c"), Command.withDescription("Creates a new session key"), Command.withExamples([{
+	command: "namera session-key create",
+	description: "Creates a new session key with interactive prompts"
+}, {
+	command: "namera schema session-key.create",
+	description: "Get the schema for session key create command"
+}]));
+//#endregion
+//#region src/helpers/humanize.ts
+const humanizeDuration = (input) => {
+	const millis = Duration.toMillis(Duration.fromInputUnsafe(input));
+	let seconds = Math.floor(millis / 1e3);
+	const units = [
+		{
+			label: "year",
+			value: 3600 * 24 * 365
+		},
+		{
+			label: "month",
+			value: 3600 * 24 * 30
+		},
+		{
+			label: "day",
+			value: 3600 * 24
+		},
+		{
+			label: "hour",
+			value: 3600
+		},
+		{
+			label: "minute",
+			value: 60
+		},
+		{
+			label: "second",
+			value: 1
+		}
+	];
+	const parts = [];
+	for (const unit of units) if (seconds >= unit.value) {
+		const count = Math.floor(seconds / unit.value);
+		seconds %= unit.value;
+		parts.push(`${count} ${unit.label}${count > 1 ? "s" : ""}`);
+	}
+	return parts.length > 0 ? parts.join(" ") : "0 seconds";
+};
+const humanizeRelativeTime = (target) => {
+	const now = Date.now();
+	const diff = (target instanceof Date ? target.getTime() : target * 1e3) - now;
+	const abs = Math.abs(diff);
+	const seconds = Math.floor(abs / 1e3);
+	for (const unit of [
+		{
+			label: "year",
+			value: 31536e3
+		},
+		{
+			label: "month",
+			value: 2592e3
+		},
+		{
+			label: "day",
+			value: 86400
+		},
+		{
+			label: "hour",
+			value: 3600
+		},
+		{
+			label: "minute",
+			value: 60
+		},
+		{
+			label: "second",
+			value: 1
+		}
+	]) if (seconds >= unit.value) {
+		const count = Math.floor(seconds / unit.value);
+		const formatted = `${count} ${unit.label}${count > 1 ? "s" : ""}`;
+		return diff > 0 ? `in ${formatted}` : `${formatted} ago`;
+	}
+	return "just now";
+};
+const humanizePolicyParams = (serializedAccount) => {
+	const params = deserializePermissionAccountParams(serializedAccount);
+	const result = {};
+	result.permissionId = params.permissionParams.permissionId;
+	for (const policy of params.permissionParams.policies ?? []) {
+		const params = policy.policyParams;
+		if (params.type === "sudo") result.sudoPolicy = { enabled: true };
+		else if (params.type === "gas") result.gasPolicy = {
+			enabled: true,
+			allowed: `${formatEther(params.allowed ?? 0n)} ETH`,
+			...params.enforcePaymaster && { enforcePaymaster: params.enforcePaymaster },
+			...params.allowedPaymaster !== zeroAddress && { allowedPaymaster: params.allowedPaymaster }
+		};
+		else if (params.type === "timestamp") {
+			const validAfter = params.validAfter ?? 0;
+			const validUntil = params.validUntil ?? 0;
+			result.timestampPolicy = {
+				enabled: true,
+				starts: humanizeRelativeTime(validAfter),
+				ends: humanizeRelativeTime(validUntil)
+			};
+		} else if (params.type === "rate-limit") {
+			const formattedInterval = humanizeDuration(params.interval ?? 0);
+			result.rateLimitPolicy = {
+				enabled: true,
+				count: params.count,
+				interval: formattedInterval,
+				starts: humanizeRelativeTime(params.startAt ?? 0)
+			};
+		} else if (params.type === "signature-caller") result.signatureCallerPolicy = {
+			enabled: true,
+			allowedCallers: params.allowedCallers
+		};
+		else if (params.type === "call") {
+			result.callPolicy = {
+				enabled: true,
+				policyVersion: params.policyVersion
+			};
+			if (!params.permissions || params.permissions.length === 0) continue;
+			for (const permission of params.permissions) {
+				result.callPolicy.permissions = result.callPolicy.permissions ?? [];
+				if ("abi" in permission) {
+					const formattedValue = formatEther(permission.valueLimit ?? 0n);
+					const abiFn = permission.abi?.find((f) => f.type === "function" && f.name === permission.functionName);
+					const cyan = "\x1B[36m";
+					const yellow = "\x1B[33m";
+					const magenta = "\x1B[35m";
+					const reset = "\x1B[0m";
+					let fnName = `${magenta}${permission.functionName ?? "unknown"}${reset}(`;
+					if (abiFn) abiFn.inputs.forEach((input, i) => {
+						if (i > 0) fnName += ", ";
+						fnName += `${cyan}${input.type}${reset}${input.name ? ` ${yellow}${input.name}${reset}` : ""}`;
+					});
+					fnName += ")";
+					result.callPolicy.permissions.push({
+						targetAddress: permission.target,
+						valueLimit: `${formattedValue} ETH`,
+						functionName: fnName
+					});
+				} else {
+					const formattedValue = formatEther(permission.valueLimit ?? 0n);
+					result.callPolicy.permissions.push({
+						targetAddress: permission.target,
+						valueLimit: `${formattedValue} ETH`
+					});
+				}
+			}
+		}
+	}
+	return result;
+};
+//#endregion
+//#region src/commands/session-key/info.ts
+const handler$9 = (flagAlias) => Effect.gen(function* () {
+	const sessionKeyManager = yield* SessionKeyManager;
+	const outputFormatter = yield* OutputFormatter;
+	const globalFlags = yield* getGlobalFlags();
+	let params;
+	if (globalFlags.params._tag === "Some") params = Schema.decodeUnknownSync(Schema.fromJsonString(GetSessionKeyInfoParams))(globalFlags.params.value);
+	else {
+		let alias;
+		if (flagAlias._tag === "Some") alias = flagAlias.value;
+		else alias = (yield* sessionKeyManager.selectSessionKey({ message: "Select Session Key:" })).alias;
+		params = { alias };
+	}
+	const res = yield* sessionKeyManager.getSessionKey(params);
+	const data = {
+		alias: res.alias,
+		...res.data.sessionKeyType === "ecdsa" ? { address: res.data.sessionKeyAddress } : { passKeyName: res.data.passKeyName },
+		smartAccount: res.data.smartAccountAlias,
+		chains: res.data.serializedAccounts.map((a) => getChain(a.chain).name).join(", "),
+		policies: humanizePolicyParams(res.data.serializedAccounts[0]?.serializedAccount ?? "")
+	};
+	if (globalFlags.quite) return;
+	const output = yield* outputFormatter.format(data, globalFlags.out);
+	yield* Console.log(output);
+});
+const alias$6 = Flag.string("alias").pipe(Flag.withDescription("The alias of the session key to get info for"), Flag.withAlias("a"), Flag.optional);
+const getSessionKeyInfoCommand = Command.make("info", { alias: alias$6 }, ({ alias }) => handler$9(alias)).pipe(Command.withDescription("Get information about a session key"), Command.withExamples([
+	{
+		command: "namera session-key info",
+		description: "Get information about a session key with alias prompt"
+	},
+	{
+		command: "namera session-key info --alias my-session-key",
+		description: "Get information about a session key with alias 'my-session-key'"
+	},
+	{
+		command: `namera session-key info --params '{"alias":"my-session-key"}'`,
+		description: "Get information about a session key with json params"
+	},
+	{
+		command: "namera session-key info --alias my-wallet --output json",
+		description: "Get information about a session key in json format"
+	},
+	{
+		command: "namera schema session-key.info",
+		description: "Get the schema for the session key info command"
+	}
+]));
+//#endregion
+//#region src/commands/session-key/list.ts
+const handler$8 = (flagSmartAccountAlias) => Effect.gen(function* () {
+	const sessionKeyManager = yield* SessionKeyManager;
+	const outputFormatter = yield* OutputFormatter;
+	const globalFlags = yield* getGlobalFlags();
+	const data = (yield* sessionKeyManager.listSessionKeys({ smartAccount: flagSmartAccountAlias._tag === "Some" ? flagSmartAccountAlias.value : void 0 })).map((d) => ({
+		alias: d.alias,
+		...d.data.sessionKeyType === "ecdsa" ? { address: d.data.sessionKeyAddress } : { passKeyName: d.data.passKeyName },
+		smartAccount: d.data.smartAccountAlias,
+		chains: d.data.serializedAccounts.map((a) => getChain(a.chain).name).join(", ")
+	}));
+	if (globalFlags.quite) return;
+	const output = yield* outputFormatter.format(data, globalFlags.out);
+	yield* Console.log(output);
+});
+const smartAccountAlias = Flag.string("smart-account").pipe(Flag.withDescription("The alias of the smart account to list session keys for"), Flag.withAlias("sa"), Flag.optional);
+/**
+* Command that lists all locally stored session keys.
+*/
+const listSessionKeysCommand = Command.make("list", { smartAccountAlias }, ({ smartAccountAlias }) => handler$8(smartAccountAlias)).pipe(Command.withAlias("ls"), Command.withDescription("List session keys"), Command.withExamples([
+	{
+		command: "namera session-key list",
+		description: "List all session keys"
+	},
+	{
+		command: "namera session-key list --smart-account my-smart",
+		description: "List all session keys for smart account 'my-smart'"
+	},
+	{
+		command: `namera session-key list --params '{"smartAccount":"my-smart"}'`,
+		description: "List all session keys for smart account 'my-smart'"
+	},
+	{
+		command: "namera session-key list --output json",
+		description: "List all session keys in json format"
+	},
+	{
+		command: "namera schema session-key.list",
+		description: "Get the schema for the list session key command"
+	}
+]));
+//#endregion
+//#region src/commands/session-key/remove.ts
+const handler$7 = (flagAlias) => Effect.gen(function* () {
+	const sessionKeyManager = yield* SessionKeyManager;
+	const outputFormatter = yield* OutputFormatter;
+	const globalFlags = yield* getGlobalFlags();
+	let params;
+	if (globalFlags.params._tag === "Some") params = Schema.decodeUnknownSync(Schema.fromJsonString(RemoveSessionKeyParams))(globalFlags.params.value);
+	else {
+		let alias;
+		if (flagAlias._tag === "Some") alias = flagAlias.value;
+		else alias = (yield* sessionKeyManager.selectSessionKey({ message: "Select Session Key:" })).alias;
+		params = { alias };
+	}
+	yield* sessionKeyManager.removeSessionKey(params);
+	const data = { success: true };
+	if (globalFlags.quite) return;
+	const output = yield* outputFormatter.format(data, globalFlags.out);
+	yield* Console.log(output);
+});
+const alias$5 = Flag.string("alias").pipe(Flag.withDescription("The alias of the session key to remove"), Flag.withAlias("a"), Flag.optional);
+const removeSessionKeyCommand = Command.make("remove", { alias: alias$5 }, ({ alias }) => handler$7(alias)).pipe(Command.withAlias("rm"), Command.withDescription("Remove a Session Key"), Command.withExamples([
+	{
+		command: "namera session-key remove",
+		description: "Remove a session key with alias prompt"
+	},
+	{
+		command: "namera session-key remove --alias my-session-key",
+		description: "Remove a session key with alias 'my-session-key'"
+	},
+	{
+		command: `namera session-key remove --params '{"alias":"my-session-key"}'`,
+		description: "Remove a session key with json params"
+	},
+	{
+		command: "namera schema session-key.remove",
+		description: "Get the schema for the remove session key command"
+	}
+]));
+const chainAndRpcUrl = {
+	chain: Flag.choice("chain", Object.keys(supportedChains)).pipe(Flag.withDescription("Chain Name"), Flag.optional),
+	rpcUrl: Flag.string("rpc-url").pipe(Flag.withDescription("RPC URL"), Flag.optional)
+};
+//#endregion
+//#region src/commands/session-key/status.ts
+const handler$6 = (flagAlias, flagChain, flagRpcUrl) => Effect.gen(function* () {
+	const web3Service = yield* Web3Service;
+	const sessionKeyManager = yield* SessionKeyManager;
+	const outputFormatter = yield* OutputFormatter;
+	const globalFlags = yield* getGlobalFlags();
+	let params;
+	if (globalFlags.params._tag === "Some") params = Schema.decodeUnknownSync(Schema.fromJsonString(GetSessionKeyStatusParams))(globalFlags.params.value);
+	else {
+		let alias;
+		let chain;
+		const rpcUrl = flagRpcUrl._tag === "Some" ? flagRpcUrl.value : void 0;
+		if (flagAlias._tag === "Some") alias = flagAlias.value;
+		else alias = (yield* sessionKeyManager.selectSessionKey({ message: "Select Session Key:" })).alias;
+		if (flagChain._tag === "Some") chain = flagChain.value;
+		else chain = yield* web3Service.selectChain({ message: "Select Chain:" });
+		params = {
+			alias,
+			chain,
+			rpcUrl
+		};
+	}
+	const data = { installed: yield* sessionKeyManager.getSessionKeyStatus(params) };
+	if (globalFlags.quite) return;
+	const output = yield* outputFormatter.format(data, globalFlags.out);
+	yield* Console.log(output);
+});
+const alias$4 = Flag.string("alias").pipe(Flag.withDescription("The alias of the session key"), Flag.withAlias("a"), Flag.optional);
+const getSessionKeyStatusCommand = Command.make("status", {
+	alias: alias$4,
+	...chainAndRpcUrl
+}, ({ alias, chain, rpcUrl }) => handler$6(alias, chain, rpcUrl)).pipe(Command.withDescription("Get Session key status for a given chain"), Command.withExamples([
+	{
+		command: "namera session-key status -a my-smart --chain eth-mainnet",
+		description: "Get Session key status for a given chain"
+	},
+	{
+		command: "namera session-key status --alias my-smart --chain eth-mainnet --rpc-url https://rpc.ankr.com/eth",
+		description: "Get Session key status for a given chain with custom RPC URL"
+	},
+	{
+		command: `namera session-key status --params '{"alias":"my-session-key","chain":"eth-mainnet"}'`,
+		description: "Get Session key status for a given chain with json params"
+	},
+	{
+		command: "namera schema session-key.status",
+		description: "Get the schema for the session key status command"
+	}
+]));
+//#endregion
+//#region src/commands/session-key/index.ts
+/**
+* Command group for session-key related operations.
+*/
+const sessionKeyCommands = Command.make("session-key", {}, () => Effect.void).pipe(Command.withAlias("sk"), Command.withDescription("Session Key management commands."), Command.withSubcommands([
+	createSessionKeyCommand,
+	listSessionKeysCommand,
+	getSessionKeyInfoCommand,
+	getSessionKeyStatusCommand,
+	removeSessionKeyCommand
+]));
+//#endregion
+//#region src/commands/smart-account/create.ts
+const handler$5 = (flagAlias, flagOwnerAlias, flagOwnerPassword, flagIndex) => Effect.gen(function* () {
+	const promptManager = yield* PromptManager;
+	const keystoreManager = yield* KeystoreManager;
+	const smartAccountManager = yield* SmartAccountManager;
+	const outputFormatter = yield* OutputFormatter;
+	const globalFlags = yield* getGlobalFlags();
+	let params;
+	if (globalFlags.params._tag === "Some") params = Schema.decodeUnknownSync(Schema.fromJsonString(CreateSmartAccountParams))(globalFlags.params.value);
+	else {
+		let alias;
+		let ownerAlias;
+		let ownerPassword;
+		let index;
+		if (flagAlias._tag === "Some") alias = flagAlias.value;
+		else alias = yield* promptManager.aliasPrompt({
+			aliasType: "new",
+			message: "Enter alias for smart account:",
+			type: "smart-account"
+		});
+		if (flagOwnerAlias._tag === "Some") ownerAlias = flagOwnerAlias.value;
+		else ownerAlias = (yield* keystoreManager.selectKeystore({ message: "Select owner keystore:" })).alias;
+		if (flagOwnerPassword._tag === "Some") ownerPassword = flagOwnerPassword.value;
+		else ownerPassword = yield* keystoreManager.getKeystorePassword({
+			alias: ownerAlias,
+			message: `Enter password for owner (${ownerAlias}):`
+		});
+		if (flagIndex._tag === "Some") index = BigInt(flagIndex.value);
+		else index = 0n;
+		params = {
+			alias,
+			ownerAlias,
+			index,
+			ownerPassword: Redacted.value(ownerPassword)
+		};
+	}
+	const res = yield* smartAccountManager.createSmartAccount(params);
+	const data = {
+		address: res.data.smartAccountAddress,
+		kernelVersion: res.data.kernelVersion,
+		index: Number(res.data.index),
+		owner: res.data.ownerAlias
+	};
+	if (globalFlags.quite) return;
+	const output = yield* outputFormatter.format(data, globalFlags.out);
+	yield* Console.log(output);
+});
+const alias$3 = Flag.string("alias").pipe(Flag.withDescription("The alias of the smart account to create"), Flag.withAlias("a"), Flag.optional);
+const ownerAlias = Flag.string("owner-alias").pipe(Flag.withDescription("The alias of the owner keystore"), Flag.withAlias("oa"), Flag.optional);
+const ownerPassword = Flag.redacted("owner-password").pipe(Flag.withDescription("The password of the owner keystore"), Flag.withAlias("op"), Flag.optional);
+const index = Flag.integer("index").pipe(Flag.withDescription("The index of the smart account"), Flag.withAlias("i"), Flag.optional);
+/**
+* Command that creates a new smart account and stores it locally.
+*
+* Accepts alias, owner alias, and index via flags or JSON params.
+*/
+const createSmartAccountCommand = Command.make("create", {
+	alias: alias$3,
+	ownerAlias,
+	ownerPassword,
+	index
+}, ({ alias, ownerAlias, ownerPassword, index }) => handler$5(alias, ownerAlias, ownerPassword, index)).pipe(Command.withAlias("c"), Command.withDescription("Creates a new smart account"), Command.withExamples([
+	{
+		command: "namera smart-account create",
+		description: "Creates a new smart account with interactive prompts"
+	},
+	{
+		command: "namera smart-account create --alias my-smart --owner-alias my-owner --index 0",
+		description: "Creates a new smart account with alias 'my-smart', owner alias 'my-owner', and index 0"
+	},
+	{
+		command: `namera smart-account create --params '{"alias":"my-smart","owner-alias":"my-owner","index":0}'`,
+		description: "Creates a new smart account with json params"
+	},
+	{
+		command: "namera schema smart-account.create",
+		description: "Get the schema for the create command"
+	}
+]));
+//#endregion
+//#region src/commands/smart-account/import.ts
+const handler$4 = () => Effect.gen(function* () {
+	const smartAccountManager = yield* SmartAccountManager;
+	const outputFormatter = yield* OutputFormatter;
+	const globalFlags = yield* getGlobalFlags();
+	if (globalFlags.params._tag === "None") return yield* Effect.fail(new SmartAccountManagerError({
+		code: "SmartAccountImportError",
+		message: "Smart Account import is only supported via JSON params"
+	}));
+	const params = Schema.decodeUnknownSync(Schema.fromJsonString(ImportSmartAccountParams))(globalFlags.params.value);
+	const res = yield* smartAccountManager.importSmartAccount(params);
+	const data = {
+		alias: res.alias,
+		address: res.data.smartAccountAddress,
+		owner: res.data.ownerAlias,
+		index: Number(res.data.index),
+		kernelVersion: res.data.kernelVersion
+	};
+	if (globalFlags.quite) return;
+	const output = yield* outputFormatter.format(data, globalFlags.out);
+	yield* Console.log(output);
+});
+/**
+* Command that imports a smart account using JSON params only.
+*/
+const importSmartAccountCommand = Command.make("import", {}, () => handler$4()).pipe(Command.withAlias("i"), Command.withDescription("Import a smart account"), Command.withExamples([{
+	command: `namera smart-account import --params '{"alias":"my-smart","ownerAlias":"my-owner","index":0,"kernelVersion":"0.3.2","smartAccountAddress":"0x1bC710cbA70f8Ce638dC5c8F50FDb05d87a7D652","entryPointVersion":"0.7","ownerType":"ecdsa"}'`,
+	description: "Import a smart account with json params"
+}, {
+	command: "namera schema smart-account.import",
+	description: "Get the schema for the smart account import command"
+}]));
+//#endregion
+//#region src/commands/smart-account/info.ts
+const handler$3 = (flagAlias) => Effect.gen(function* () {
+	const smartAccountManager = yield* SmartAccountManager;
+	const outputFormatter = yield* OutputFormatter;
+	const globalFlags = yield* getGlobalFlags();
+	let params;
+	if (globalFlags.params._tag === "Some") params = Schema.decodeUnknownSync(Schema.fromJsonString(GetKeystoreParams))(globalFlags.params.value);
+	else {
+		let alias;
+		if (flagAlias._tag === "Some") alias = flagAlias.value;
+		else alias = (yield* smartAccountManager.selectSmartAccount({ message: "Select Smart Account:" })).alias;
+		params = { alias };
+	}
+	const res = yield* smartAccountManager.getSmartAccount(params);
+	const data = {
+		alias: res.alias,
+		address: res.data.smartAccountAddress,
+		owner: res.data.ownerAlias,
+		index: Number(res.data.index),
+		kernelVersion: res.data.kernelVersion
+	};
+	if (globalFlags.quite) return;
+	const output = yield* outputFormatter.format(data, globalFlags.out);
+	yield* Console.log(output);
+});
+const alias$2 = Flag.string("alias").pipe(Flag.withDescription("The alias of the smart account to retrieve"), Flag.withAlias("a"), Flag.optional);
+/**
+* Command that returns stored metadata for a smart account.
+*
+* Accepts alias via flag or JSON params, otherwise prompts for selection.
+*/
+const getSmartAccountInfoCommand = Command.make("info", { alias: alias$2 }, ({ alias }) => handler$3(alias)).pipe(Command.withDescription("Get information about a smart account"), Command.withExamples([
+	{
+		command: "namera smart-account info",
+		description: "Get information about a smart account with alias prompt"
+	},
+	{
+		command: "namera smart-account info --alias my-smart",
+		description: "Get information about a smart account with alias 'my-smart'"
+	},
+	{
+		command: `namera smart-account info --params '{"alias":"my-smart"}'`,
+		description: "Get information about a smart account with json params"
+	},
+	{
+		command: "namera smart-account info --alias my-wallet --output json",
+		description: "Get information about a smart account in json format"
+	},
+	{
+		command: "namera schema smart-account.info",
+		description: "Get the schema for the smart account info command"
+	}
+]));
+//#endregion
+//#region src/commands/smart-account/list.ts
+const handler$2 = () => Effect.gen(function* () {
+	const smartAccountManager = yield* SmartAccountManager;
+	const outputFormatter = yield* OutputFormatter;
+	const globalFlags = yield* getGlobalFlags();
+	const data = (yield* smartAccountManager.listSmartAccounts()).map((d) => ({
+		alias: d.alias,
+		address: d.data.smartAccountAddress,
+		owner: d.data.ownerAlias,
+		index: Number(d.data.index),
+		kernelVersion: d.data.kernelVersion
+	}));
+	if (globalFlags.quite) return;
+	const output = yield* outputFormatter.format(data, globalFlags.out);
+	yield* Console.log(output);
+});
+/**
+* Command that lists all locally stored smart accounts.
+*/
+const listSmartAccountsCommand = Command.make("list", {}, () => handler$2()).pipe(Command.withAlias("ls"), Command.withDescription("List all smart accounts"), Command.withExamples([
+	{
+		command: "namera smart-account list",
+		description: "List all smart accounts"
+	},
+	{
+		command: "namera smart-account list --output json",
+		description: "List all smart accounts in json format"
+	},
+	{
+		command: "namera smart-account list --output ndjson",
+		description: "List all smart accounts in ndjson format"
+	},
+	{
+		command: "namera schema smart-account.list",
+		description: "Get the schema for the list smart account command"
+	}
+]));
+//#endregion
+//#region src/commands/smart-account/remove.ts
+const handler$1 = (flagAlias) => Effect.gen(function* () {
+	const smartAccountManager = yield* SmartAccountManager;
+	const outputFormatter = yield* OutputFormatter;
+	const globalFlags = yield* getGlobalFlags();
+	let params;
+	if (globalFlags.params._tag === "Some") params = Schema.decodeUnknownSync(Schema.fromJsonString(RemoveSmartAccountParams))(globalFlags.params.value);
+	else {
+		let alias;
+		if (flagAlias._tag === "Some") alias = flagAlias.value;
+		else alias = (yield* smartAccountManager.selectSmartAccount({ message: "Select Smart Account:" })).alias;
+		params = { alias };
+	}
+	yield* smartAccountManager.removeSmartAccount(params);
+	const data = { success: true };
+	if (globalFlags.quite) return;
+	const output = yield* outputFormatter.format(data, globalFlags.out);
+	yield* Console.log(output);
+});
+const alias$1 = Flag.string("alias").pipe(Flag.withDescription("The alias of the smart account to remove"), Flag.withAlias("a"), Flag.optional);
+/**
+* Command that removes a locally stored smart account by alias.
+*/
+const removeSmartAccountCommand = Command.make("remove", { alias: alias$1 }, ({ alias }) => handler$1(alias)).pipe(Command.withAlias("rm"), Command.withDescription("Remove a Smart Account"), Command.withExamples([
+	{
+		command: "namera smart-account remove",
+		description: "Remove a smart-account with alias prompt"
+	},
+	{
+		command: "namera smart-account remove --alias my-smart",
+		description: "Remove a smart account with alias 'my-smart'"
+	},
+	{
+		command: `namera smart-account remove --params '{"alias":"my-smart"}'`,
+		description: "Remove a smart account with json params"
+	},
+	{
+		command: "namera schema smart-account.remove",
+		description: "Get the schema for the remove smart account command"
+	}
+]));
+//#endregion
+//#region src/commands/smart-account/status.ts
+const handler = (flagAlias, flagChain, flagRpcUrl) => Effect.gen(function* () {
+	const web3Service = yield* Web3Service;
+	const smartAccountManager = yield* SmartAccountManager;
+	const outputFormatter = yield* OutputFormatter;
+	const globalFlags = yield* getGlobalFlags();
+	let params;
+	if (globalFlags.params._tag === "Some") params = Schema.decodeUnknownSync(Schema.fromJsonString(GetSmartAccountStatusParams))(globalFlags.params.value);
+	else {
+		let alias;
+		let chain;
+		const rpcUrl = flagRpcUrl._tag === "Some" ? flagRpcUrl.value : void 0;
+		if (flagAlias._tag === "Some") alias = flagAlias.value;
+		else alias = (yield* smartAccountManager.selectSmartAccount({ message: "Select Smart Account:" })).alias;
+		if (flagChain._tag === "Some") chain = flagChain.value;
+		else chain = yield* web3Service.selectChain({ message: "Select Chain:" });
+		params = {
+			alias,
+			chain,
+			rpcUrl
+		};
+	}
+	const data = { deployed: yield* smartAccountManager.getSmartAccountStatus(params) };
+	if (globalFlags.quite) return;
+	const output = yield* outputFormatter.format(data, globalFlags.out);
+	yield* Console.log(output);
+});
+const alias = Flag.string("alias").pipe(Flag.withDescription("The alias of the smart account"), Flag.withAlias("a"), Flag.optional);
+/**
+* Command that checks deployment status of a smart account on a chain.
+*/
+const getSmartAccountStatus = Command.make("status", {
+	alias,
+	...chainAndRpcUrl
+}, ({ alias, chain, rpcUrl }) => handler(alias, chain, rpcUrl)).pipe(Command.withDescription("Get Smart Account Deployment Status for a given chain"), Command.withExamples([
+	{
+		command: "namera smart-account status -a my-smart --chain eth-mainnet",
+		description: "Get Smart Account Deployment Status for a given chain"
+	},
+	{
+		command: "namera smart-account status --alias my-smart --chain eth-mainnet --rpc-url https://rpc.ankr.com/eth",
+		description: "Get Smart Account Deployment Status for a given chain with custom RPC URL"
+	},
+	{
+		command: `namera smart-account status --params '{"alias":"my-smart","chain":"eth-mainnet"}'`,
+		description: "Get Smart Account Deployment Status for a given chain with json params"
+	}
+]));
+//#endregion
+//#region src/commands/index.ts
+/**
+* Root CLI command set.
+*/
+const commands = [
+	keystoreCommands,
+	Command.make("smart-account", {}, () => Effect.void).pipe(Command.withAlias("sa"), Command.withDescription("Smart Account management utilities."), Command.withSubcommands([
+		createSmartAccountCommand,
+		listSmartAccountsCommand,
+		getSmartAccountInfoCommand,
+		removeSmartAccountCommand,
+		getSmartAccountStatus,
+		importSmartAccountCommand
+	])),
+	sessionKeyCommands,
+	mcpCommands,
+	schemaCommand
+];
+//#endregion
+//#region src/index.ts
+const command = Command.make("namera", {}, () => Effect.void).pipe(Command.withDescription("Programmable Session keys for Smart Contracts Accounts."), Command.withGlobalFlags(globalFlags), Command.withSubcommands(commands), Command.withExamples([{
+	command: "namera --help",
+	description: "Print help"
+}, {
+	command: "namera --version",
+	description: "Print version"
+}]));
+const Layers = layer$1.pipe(Layer.provideMerge(layer$2), Layer.provideMerge(layer$3), Layer.provideMerge(layer$5), Layer.provideMerge(layer$4), Layer.provideMerge(layer$6), Layer.provideMerge(layer$7), Layer.provideMerge(layer), Layer.provideMerge(NodeServices.layer));
+Effect.gen(function* () {
+	yield* (yield* ConfigManager).ensureConfigDirExists();
+	yield* Command.run(command, { version: "0.0.1" });
+}).pipe(Effect.provide(Layers), Effect.provideService(ConfigProvider.ConfigProvider, ConfigProvider.fromEnv()), Effect.catch((e) => Console.error(e.message))).pipe(NodeRuntime.runMain);
+//#endregion
+export {};
+
+//# sourceMappingURL=index.mjs.map