@openfort/cli 0.1.7 → 0.1.9

package/dist/cli.js

@@ -1,19 +1,21 @@
 #!/usr/bin/env node
 import {
   CREDENTIALS_PATH,
-  ensureConfigDir
-} from "./chunk-QJGHQ7ID.js";
+  ensureConfigDir,
+  loadEnvFile,
+  requireApiKey,
+  writeEnvKey
+} from "./chunk-SVNLXGFY.js";
 
 // src/cli.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { Cli as Cli13, z as z15, Errors as Errors4 } from "incur";
-import Openfort from "@openfort/openfort-node";
+import { readFileSync } from "fs";
+import { Cli as Cli14, z as z14 } from "incur";
 
-// src/vars.ts
-import { z } from "incur";
-var varsSchema = z.object({
-  openfort: z.custom()
-});
+// src/commands/login.ts
+import { randomBytes } from "crypto";
+import { createServer } from "http";
+import open from "open";
+import { Cli, z } from "incur";
 
 // src/constants.ts
 var API_BASE_URL = process.env.OPENFORT_BASE_URL || "https://api.openfort.io";
@@ -21,40 +23,6 @@ var OPENFORT_SHIELD_URL = process.env.OPENFORT_SHIELD_URL || "https://shield.ope
 var AUTH_PAGE_URL = process.env.OPENFORT_AUTH_PAGE_URL || "https://dashboard.openfort.io";
 var CLI_CALLBACK_PORT = Number(process.env.OPENFORT_CLI_CALLBACK_PORT) || 8271;
 
-// src/commands/login.ts
-import { randomBytes } from "crypto";
-import { createServer } from "http";
-import open from "open";
-import { z as z2 } from "incur";
-
-// src/env.ts
-import { readFileSync, writeFileSync, existsSync } from "fs";
-function loadEnvFile(envPath) {
-  const entries = /* @__PURE__ */ new Map();
-  if (!existsSync(envPath)) return entries;
-  const content = readFileSync(envPath, "utf-8");
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-    const eqIndex = trimmed.indexOf("=");
-    if (eqIndex === -1) continue;
-    const key = trimmed.slice(0, eqIndex).trim();
-    const value = trimmed.slice(eqIndex + 1).trim();
-    entries.set(key, value);
-  }
-  return entries;
-}
-function writeEnvKey(envPath, key, value) {
-  const entries = loadEnvFile(envPath);
-  entries.set(key, value);
-  const lines = [];
-  for (const [k, v] of entries) {
-    lines.push(`${k}=${v}`);
-  }
-  writeFileSync(envPath, `${lines.join("\n")}
-`);
-}
-
 // src/commands/login.ts
 function base64url(buffer) {
   return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
@@ -151,7 +119,7 @@ function waitForCallback(port, state) {
       reject(new Error("Login timed out after 5 minutes. Please try again."));
     }, 5 * 60 * 1e3);
     const server = createServer((req, res) => {
-      const url = new URL(req.url, `http://localhost:${port}`);
+      const url = new URL(req.url ?? "/", `http://localhost:${port}`);
       if (url.pathname === "/callback") {
         const apiKey = url.searchParams.get("api_key");
         const publishableKey = url.searchParams.get("publishable_key");
@@ -186,12 +154,12 @@ function waitForCallback(port, state) {
     server.listen(port);
   });
 }
-var loginConfig = {
+var login = Cli.create("login", {
   description: "Log in to Openfort via browser and save your API key.",
-  output: z2.object({
-    apiKey: z2.string().describe("The API key saved to credentials"),
-    project: z2.string().describe("The project name"),
-    credentialsPath: z2.string().describe("Path to the credentials file")
+  output: z.object({
+    apiKey: z.string().describe("The API key saved to credentials"),
+    project: z.string().describe("The project name"),
+    credentialsPath: z.string().describe("Path to the credentials file")
   }),
   async run(c) {
     const state = generateState();
@@ -236,10 +204,40 @@ var loginConfig = {
       }
     );
   }
-};
+});
+
+// src/commands/accounts.ts
+import { Cli as Cli2, z as z2, middleware } from "incur";
+
+// src/client.ts
+import Openfort from "@openfort/openfort-node";
+var cached;
+function getOpenfort() {
+  if (cached) return cached;
+  let apiKey = process.env.OPENFORT_API_KEY;
+  if (!apiKey) {
+    const creds = loadEnvFile(CREDENTIALS_PATH);
+    apiKey = creds.get("OPENFORT_API_KEY");
+    if (apiKey) {
+      process.env.OPENFORT_API_KEY = apiKey;
+      const pk = creds.get("OPENFORT_PUBLISHABLE_KEY");
+      if (pk && !process.env.OPENFORT_PUBLISHABLE_KEY) process.env.OPENFORT_PUBLISHABLE_KEY = pk;
+      const ws = creds.get("OPENFORT_WALLET_SECRET");
+      if (ws && !process.env.OPENFORT_WALLET_SECRET) process.env.OPENFORT_WALLET_SECRET = ws;
+    }
+  }
+  if (!apiKey) {
+    throw new Error("OPENFORT_API_KEY is required. Run: openfort login");
+  }
+  cached = new Openfort(apiKey, {
+    walletSecret: process.env.OPENFORT_WALLET_SECRET,
+    publishableKey: process.env.OPENFORT_PUBLISHABLE_KEY,
+    basePath: API_BASE_URL
+  });
+  return cached;
+}
 
 // src/commands/accounts.ts
-import { Cli, z as z3, middleware } from "incur";
 var requireWallet = middleware((c, next) => {
   const missing = [];
   if (!process.env.OPENFORT_WALLET_SECRET) missing.push("OPENFORT_WALLET_SECRET");
@@ -256,9 +254,8 @@ var requireWallet = middleware((c, next) => {
   }
   return next();
 });
-var evm = Cli.create("evm", {
-  description: "EVM wallet management.",
-  vars: varsSchema
+var evm = Cli2.create("evm", {
+  description: "EVM wallet management."
 });
 evm.command("create", {
   description: "Create a new EVM backend wallet.",
@@ -267,13 +264,13 @@ evm.command("create", {
   ],
   hint: "Requires OPENFORT_WALLET_SECRET and OPENFORT_PUBLISHABLE_KEY.",
   middleware: [requireWallet],
-  output: z3.object({
-    id: z3.string().describe("Account ID"),
-    address: z3.string().describe("Wallet address"),
-    custody: z3.string().describe("Custody type")
+  output: z2.object({
+    id: z2.string().describe("Account ID"),
+    address: z2.string().describe("Wallet address"),
+    custody: z2.string().describe("Custody type")
   }),
   async run(c) {
-    const account = await c.var.openfort.accounts.evm.backend.create();
+    const account = await getOpenfort().accounts.evm.backend.create();
     return c.ok(
       { id: account.id, address: account.address, custody: account.custody },
       {
@@ -290,25 +287,25 @@ evm.command("create", {
 });
 evm.command("list", {
   description: "List EVM backend wallets.",
-  options: z3.object({
-    limit: z3.number().optional().describe("Max results"),
-    skip: z3.number().optional().describe("Offset")
+  options: z2.object({
+    limit: z2.number().optional().describe("Max results"),
+    skip: z2.number().optional().describe("Offset")
   }),
   alias: { limit: "l" },
   examples: [
     { description: "List all EVM backend wallets" },
     { options: { limit: 5 }, description: "Show first 5 wallets" }
   ],
-  output: z3.object({
-    accounts: z3.array(z3.object({
-      id: z3.string(),
-      address: z3.string(),
-      custody: z3.string()
+  output: z2.object({
+    accounts: z2.array(z2.object({
+      id: z2.string(),
+      address: z2.string(),
+      custody: z2.string()
     })),
-    total: z3.number().optional()
+    total: z2.number().optional()
   }),
   async run(c) {
-    const res = await c.var.openfort.accounts.evm.backend.list({
+    const res = await getOpenfort().accounts.evm.backend.list({
       limit: c.options.limit,
       skip: c.options.skip
     });
@@ -324,25 +321,25 @@ evm.command("list", {
 });
 evm.command("list-delegated", {
   description: "List EVM delegated accounts.",
-  options: z3.object({
-    limit: z3.number().optional().describe("Max results"),
-    skip: z3.number().optional().describe("Offset")
+  options: z2.object({
+    limit: z2.number().optional().describe("Max results"),
+    skip: z2.number().optional().describe("Offset")
   }),
   alias: { limit: "l" },
   examples: [
     { description: "List all EVM delegated accounts" },
     { options: { limit: 5 }, description: "Show first 5 accounts" }
   ],
-  output: z3.object({
-    accounts: z3.array(z3.object({
-      id: z3.string(),
-      address: z3.string(),
-      custody: z3.string()
+  output: z2.object({
+    accounts: z2.array(z2.object({
+      id: z2.string(),
+      address: z2.string(),
+      custody: z2.string()
     })),
-    total: z3.number().optional()
+    total: z2.number().optional()
   }),
   async run(c) {
-    const res = await c.var.openfort.accounts.evm.list({
+    const res = await getOpenfort().accounts.evm.list({
       accountType: "Delegated Account",
       limit: c.options.limit,
       skip: c.options.skip
@@ -359,25 +356,25 @@ evm.command("list-delegated", {
 });
 evm.command("list-smart", {
   description: "List EVM smart accounts.",
-  options: z3.object({
-    limit: z3.number().optional().describe("Max results"),
-    skip: z3.number().optional().describe("Offset")
+  options: z2.object({
+    limit: z2.number().optional().describe("Max results"),
+    skip: z2.number().optional().describe("Offset")
   }),
   alias: { limit: "l" },
   examples: [
     { description: "List all EVM smart accounts" },
     { options: { limit: 5 }, description: "Show first 5 accounts" }
   ],
-  output: z3.object({
-    accounts: z3.array(z3.object({
-      id: z3.string(),
-      address: z3.string(),
-      custody: z3.string()
+  output: z2.object({
+    accounts: z2.array(z2.object({
+      id: z2.string(),
+      address: z2.string(),
+      custody: z2.string()
     })),
-    total: z3.number().optional()
+    total: z2.number().optional()
   }),
   async run(c) {
-    const res = await c.var.openfort.accounts.evm.list({
+    const res = await getOpenfort().accounts.evm.list({
       accountType: "Smart Account",
       limit: c.options.limit,
       skip: c.options.skip
@@ -394,19 +391,19 @@ evm.command("list-smart", {
 });
 evm.command("get", {
   description: "Get an EVM backend wallet by ID or address.",
-  args: z3.object({
-    id: z3.string().describe("Account ID or address")
+  args: z2.object({
+    id: z2.string().describe("Account ID or address")
   }),
   examples: [
     { args: { id: "acc_1a2b3c4d" }, description: "Get wallet by ID" }
   ],
-  output: z3.object({
-    id: z3.string(),
-    address: z3.string(),
-    custody: z3.string()
+  output: z2.object({
+    id: z2.string(),
+    address: z2.string(),
+    custody: z2.string()
   }),
   async run(c) {
-    const a = await c.var.openfort.accounts.evm.backend.get({ id: c.args.id });
+    const a = await getOpenfort().accounts.evm.backend.get({ id: c.args.id });
     return c.ok({
       id: a.id,
       address: a.address,
@@ -416,43 +413,43 @@ evm.command("get", {
 });
 evm.command("delete", {
   description: "Delete an EVM backend wallet.",
-  args: z3.object({
-    id: z3.string().describe("Account ID (acc_...)")
+  args: z2.object({
+    id: z2.string().describe("Account ID (acc_...)")
   }),
   examples: [
     { args: { id: "acc_1a2b3c4d" }, description: "Delete a wallet" }
   ],
-  output: z3.object({
-    id: z3.string(),
-    deleted: z3.boolean()
+  output: z2.object({
+    id: z2.string(),
+    deleted: z2.boolean()
   }),
   async run(c) {
-    const res = await c.var.openfort.accounts.evm.backend.delete(c.args.id);
+    const res = await getOpenfort().accounts.evm.backend.delete(c.args.id);
     return c.ok({ id: res.id, deleted: res.deleted });
   }
 });
 evm.command("update", {
   description: "Upgrade an EVM backend wallet to a delegated account (EIP-7702).",
-  args: z3.object({
-    id: z3.string().describe("Account ID (acc_...)")
+  args: z2.object({
+    id: z2.string().describe("Account ID (acc_...)")
   }),
-  options: z3.object({
-    chainId: z3.number().describe("Chain ID to deploy on"),
-    implementationType: z3.string().describe("Target implementation type (e.g. CaliburV9)")
+  options: z2.object({
+    chainId: z2.number().describe("Chain ID to deploy on"),
+    implementationType: z2.string().describe("Target implementation type (e.g. CaliburV9)")
   }),
   examples: [
     { args: { id: "acc_1a2b3c4d" }, options: { chainId: 8453, implementationType: "CaliburV9" }, description: "Upgrade to delegated account on Base" }
   ],
-  output: z3.object({
-    id: z3.string(),
-    address: z3.string(),
-    accountType: z3.string(),
-    chainId: z3.number().optional(),
-    chainType: z3.string()
+  output: z2.object({
+    id: z2.string(),
+    address: z2.string(),
+    accountType: z2.string(),
+    chainId: z2.number().optional(),
+    chainType: z2.string()
   }),
   async run(c) {
-    const account = await c.var.openfort.accounts.evm.backend.get({ id: c.args.id });
-    const res = await c.var.openfort.accounts.evm.backend.update({
+    const account = await getOpenfort().accounts.evm.backend.get({ id: c.args.id });
+    const res = await getOpenfort().accounts.evm.backend.update({
       walletId: account.walletId,
       chainId: c.options.chainId,
       accountId: account.id,
@@ -479,22 +476,22 @@ evm.command("update", {
 });
 evm.command("sign", {
   description: "Sign data with an EVM backend wallet.",
-  args: z3.object({
-    id: z3.string().describe("Account ID (acc_...)")
+  args: z2.object({
+    id: z2.string().describe("Account ID (acc_...)")
   }),
-  options: z3.object({
-    data: z3.string().describe("Hex-encoded data to sign")
+  options: z2.object({
+    data: z2.string().describe("Hex-encoded data to sign")
   }),
   examples: [
     { args: { id: "acc_1a2b3c4d" }, options: { data: "0xdeadbeef" }, description: "Sign a message hash" }
   ],
   hint: "Requires OPENFORT_WALLET_SECRET and OPENFORT_PUBLISHABLE_KEY.",
   middleware: [requireWallet],
-  output: z3.object({
-    signature: z3.string()
+  output: z2.object({
+    signature: z2.string()
   }),
   async run(c) {
-    const signature = await c.var.openfort.accounts.evm.backend.sign({
+    const signature = await getOpenfort().accounts.evm.backend.sign({
       id: c.args.id,
       data: c.options.data
     });
@@ -503,21 +500,21 @@ evm.command("sign", {
 });
 evm.command("import", {
   description: "Import a private key as an EVM backend wallet.",
-  options: z3.object({
-    privateKey: z3.string().describe("Private key (hex string)")
+  options: z2.object({
+    privateKey: z2.string().describe("Private key (hex string)")
   }),
   examples: [
     { options: { privateKey: "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" }, description: "Import a private key" }
   ],
   hint: "Requires OPENFORT_WALLET_SECRET and OPENFORT_PUBLISHABLE_KEY.",
   middleware: [requireWallet],
-  output: z3.object({
-    id: z3.string(),
-    address: z3.string(),
-    custody: z3.string()
+  output: z2.object({
+    id: z2.string(),
+    address: z2.string(),
+    custody: z2.string()
   }),
   async run(c) {
-    const account = await c.var.openfort.accounts.evm.backend.import({
+    const account = await getOpenfort().accounts.evm.backend.import({
       privateKey: c.options.privateKey
     });
     return c.ok({
@@ -529,18 +526,18 @@ evm.command("import", {
 });
 evm.command("export", {
   description: "Export an EVM backend wallet private key.",
-  args: z3.object({
-    id: z3.string().describe("Account ID (acc_...)")
+  args: z2.object({
+    id: z2.string().describe("Account ID (acc_...)")
   }),
   examples: [
     { args: { id: "acc_1a2b3c4d" }, description: "Export private key" }
   ],
   middleware: [requireWallet],
-  output: z3.object({
-    privateKey: z3.string()
+  output: z2.object({
+    privateKey: z2.string()
   }),
   async run(c) {
-    const privateKey = await c.var.openfort.accounts.evm.backend.export({
+    const privateKey = await getOpenfort().accounts.evm.backend.export({
       id: c.args.id
     });
     return c.ok({ privateKey });
@@ -548,13 +545,13 @@ evm.command("export", {
 });
 evm.command("send-transaction", {
   description: "Send a gasless EVM transaction (auto-delegates via EIP-7702 if needed).",
-  args: z3.object({
-    id: z3.string().describe("Account ID (acc_...)")
+  args: z2.object({
+    id: z2.string().describe("Account ID (acc_...)")
   }),
-  options: z3.object({
-    chainId: z3.number().describe("Chain ID"),
-    interactions: z3.string().describe('Interactions as JSON: [{"to":"0x...","data":"0x...","value":"0"}]'),
-    policy: z3.string().optional().describe("Fee sponsorship ID (pol_...)")
+  options: z2.object({
+    chainId: z2.number().describe("Chain ID"),
+    interactions: z2.string().describe('Interactions as JSON: [{"to":"0x...","data":"0x...","value":"0"}]'),
+    policy: z2.string().optional().describe("Fee sponsorship ID (pol_...)")
   }),
   examples: [
     {
@@ -567,15 +564,15 @@ evm.command("send-transaction", {
     }
   ],
   middleware: [requireWallet],
-  output: z3.object({
-    id: z3.string(),
-    chainId: z3.number(),
-    transactionHash: z3.string().optional()
+  output: z2.object({
+    id: z2.string(),
+    chainId: z2.number(),
+    transactionHash: z2.string().optional()
   }),
   async run(c) {
-    const account = await c.var.openfort.accounts.evm.backend.get({ id: c.args.id });
+    const account = await getOpenfort().accounts.evm.backend.get({ id: c.args.id });
     const interactions = JSON.parse(c.options.interactions);
-    const res = await c.var.openfort.accounts.evm.backend.sendTransaction({
+    const res = await getOpenfort().accounts.evm.backend.sendTransaction({
       account,
       chainId: c.options.chainId,
       interactions,
@@ -588,9 +585,8 @@ evm.command("send-transaction", {
     });
   }
 });
-var solana = Cli.create("solana", {
-  description: "Solana wallet management.",
-  vars: varsSchema
+var solana = Cli2.create("solana", {
+  description: "Solana wallet management."
 });
 solana.command("create", {
   description: "Create a new Solana backend wallet.",
@@ -599,13 +595,13 @@ solana.command("create", {
   ],
   hint: "Requires OPENFORT_WALLET_SECRET and OPENFORT_PUBLISHABLE_KEY.",
   middleware: [requireWallet],
-  output: z3.object({
-    id: z3.string().describe("Account ID"),
-    address: z3.string().describe("Wallet address"),
-    custody: z3.string().describe("Custody type")
+  output: z2.object({
+    id: z2.string().describe("Account ID"),
+    address: z2.string().describe("Wallet address"),
+    custody: z2.string().describe("Custody type")
   }),
   async run(c) {
-    const account = await c.var.openfort.accounts.solana.backend.create();
+    const account = await getOpenfort().accounts.solana.backend.create();
     return c.ok(
       { id: account.id, address: account.address, custody: account.custody },
       {
@@ -621,24 +617,24 @@ solana.command("create", {
 });
 solana.command("list", {
   description: "List Solana backend wallets.",
-  options: z3.object({
-    limit: z3.number().optional().describe("Max results"),
-    skip: z3.number().optional().describe("Offset")
+  options: z2.object({
+    limit: z2.number().optional().describe("Max results"),
+    skip: z2.number().optional().describe("Offset")
   }),
   alias: { limit: "l" },
   examples: [
     { description: "List all Solana wallets" }
   ],
-  output: z3.object({
-    accounts: z3.array(z3.object({
-      id: z3.string(),
-      address: z3.string(),
-      custody: z3.string()
+  output: z2.object({
+    accounts: z2.array(z2.object({
+      id: z2.string(),
+      address: z2.string(),
+      custody: z2.string()
     })),
-    total: z3.number().optional()
+    total: z2.number().optional()
   }),
   async run(c) {
-    const res = await c.var.openfort.accounts.solana.backend.list({
+    const res = await getOpenfort().accounts.solana.backend.list({
       limit: c.options.limit,
       skip: c.options.skip
     });
@@ -654,19 +650,19 @@ solana.command("list", {
 });
 solana.command("get", {
   description: "Get a Solana backend wallet by ID or address.",
-  args: z3.object({
-    id: z3.string().describe("Account ID or address")
+  args: z2.object({
+    id: z2.string().describe("Account ID or address")
   }),
   examples: [
     { args: { id: "acc_1a2b3c4d" }, description: "Get wallet by ID" }
   ],
-  output: z3.object({
-    id: z3.string(),
-    address: z3.string(),
-    custody: z3.string()
+  output: z2.object({
+    id: z2.string(),
+    address: z2.string(),
+    custody: z2.string()
   }),
   async run(c) {
-    const a = await c.var.openfort.accounts.solana.backend.get({ id: c.args.id });
+    const a = await getOpenfort().accounts.solana.backend.get({ id: c.args.id });
     return c.ok({
       id: a.id,
       address: a.address,
@@ -676,18 +672,18 @@ solana.command("get", {
 });
 solana.command("sign", {
   description: "Sign data with a Solana backend wallet.",
-  args: z3.object({
-    id: z3.string().describe("Account ID (acc_...)")
+  args: z2.object({
+    id: z2.string().describe("Account ID (acc_...)")
   }),
-  options: z3.object({
-    data: z3.string().describe("Data to sign (base64-encoded)")
+  options: z2.object({
+    data: z2.string().describe("Data to sign (base64-encoded)")
   }),
   alias: { data: "d" },
   hint: "Requires OPENFORT_WALLET_SECRET and OPENFORT_PUBLISHABLE_KEY.",
   middleware: [requireWallet],
-  output: z3.object({
-    account: z3.string(),
-    signature: z3.string()
+  output: z2.object({
+    account: z2.string(),
+    signature: z2.string()
   }),
   examples: [
     {
@@ -697,44 +693,44 @@ solana.command("sign", {
     }
   ],
   async run(c) {
-    const signature = await c.var.openfort.accounts.solana.backend.sign(c.args.id, c.options.data);
+    const signature = await getOpenfort().accounts.solana.backend.sign(c.args.id, c.options.data);
     return c.ok({ account: c.args.id, signature });
   }
 });
 solana.command("delete", {
   description: "Delete a Solana backend wallet.",
-  args: z3.object({
-    id: z3.string().describe("Account ID (acc_...)")
+  args: z2.object({
+    id: z2.string().describe("Account ID (acc_...)")
   }),
   examples: [
     { args: { id: "acc_1a2b3c4d" }, description: "Delete a wallet" }
   ],
-  output: z3.object({
-    id: z3.string(),
-    deleted: z3.boolean()
+  output: z2.object({
+    id: z2.string(),
+    deleted: z2.boolean()
   }),
   async run(c) {
-    const res = await c.var.openfort.accounts.solana.backend.delete(c.args.id);
+    const res = await getOpenfort().accounts.solana.backend.delete(c.args.id);
     return c.ok({ id: res.id, deleted: res.deleted });
   }
 });
 solana.command("import", {
   description: "Import a private key as a Solana backend wallet.",
-  options: z3.object({
-    privateKey: z3.string().describe("Private key (hex-encoded 32 bytes or base58)")
+  options: z2.object({
+    privateKey: z2.string().describe("Private key (hex-encoded 32 bytes or base58)")
   }),
   examples: [
     { options: { privateKey: "abc123..." }, description: "Import a Solana private key" }
   ],
   hint: "Requires OPENFORT_WALLET_SECRET and OPENFORT_PUBLISHABLE_KEY.",
   middleware: [requireWallet],
-  output: z3.object({
-    id: z3.string(),
-    address: z3.string(),
-    custody: z3.string()
+  output: z2.object({
+    id: z2.string(),
+    address: z2.string(),
+    custody: z2.string()
   }),
   async run(c) {
-    const account = await c.var.openfort.accounts.solana.backend.import({
+    const account = await getOpenfort().accounts.solana.backend.import({
       privateKey: c.options.privateKey
     });
     return c.ok({
@@ -746,18 +742,18 @@ solana.command("import", {
 });
 solana.command("export", {
   description: "Export a Solana backend wallet private key.",
-  args: z3.object({
-    id: z3.string().describe("Account ID (acc_...)")
+  args: z2.object({
+    id: z2.string().describe("Account ID (acc_...)")
   }),
   examples: [
     { args: { id: "acc_1a2b3c4d" }, description: "Export private key" }
   ],
   middleware: [requireWallet],
-  output: z3.object({
-    privateKey: z3.string()
+  output: z2.object({
+    privateKey: z2.string()
   }),
   async run(c) {
-    const privateKey = await c.var.openfort.accounts.solana.backend.export({
+    const privateKey = await getOpenfort().accounts.solana.backend.export({
       id: c.args.id
     });
     return c.ok({ privateKey });
@@ -765,14 +761,14 @@ solana.command("export", {
 });
 solana.command("transfer", {
   description: "Transfer SOL or SPL tokens.",
-  args: z3.object({
-    id: z3.string().describe("Account ID (acc_...)")
+  args: z2.object({
+    id: z2.string().describe("Account ID (acc_...)")
   }),
-  options: z3.object({
-    to: z3.string().describe("Destination address (base58)"),
-    amount: z3.string().describe("Amount in base units (lamports for SOL)"),
-    token: z3.string().optional().describe('Token: "sol" (default), "usdc", or mint address'),
-    cluster: z3.enum(["devnet", "mainnet-beta"]).default("mainnet-beta").describe("Cluster: devnet or mainnet-beta")
+  options: z2.object({
+    to: z2.string().describe("Destination address (base58)"),
+    amount: z2.string().describe("Amount in base units (lamports for SOL)"),
+    token: z2.string().optional().describe('Token: "sol" (default), "usdc", or mint address'),
+    cluster: z2.enum(["devnet", "mainnet-beta"]).default("mainnet-beta").describe("Cluster: devnet or mainnet-beta")
   }),
   examples: [
     {
@@ -787,12 +783,12 @@ solana.command("transfer", {
     }
   ],
   middleware: [requireWallet],
-  output: z3.object({
-    signature: z3.string()
+  output: z2.object({
+    signature: z2.string()
   }),
   async run(c) {
-    const account = await c.var.openfort.accounts.solana.backend.get({ id: c.args.id });
-    const res = await c.var.openfort.accounts.solana.backend.transfer({
+    const account = await getOpenfort().accounts.solana.backend.get({ id: c.args.id });
+    const res = await getOpenfort().accounts.solana.backend.transfer({
       account,
       to: c.options.to,
       amount: BigInt(c.options.amount),
@@ -802,17 +798,16 @@ solana.command("transfer", {
     return c.ok({ signature: res.signature });
   }
 });
-var accounts = Cli.create("accounts", {
-  description: "Manage wallets and accounts.",
-  vars: varsSchema
+var accounts = Cli2.create("accounts", {
+  description: "Manage wallets and accounts."
 });
 accounts.command("list", {
   description: "List all accounts across chains.",
-  options: z3.object({
-    limit: z3.number().optional().describe("Max results"),
-    skip: z3.number().optional().describe("Offset"),
-    chainType: z3.enum(["EVM", "SVM"]).optional().describe("Filter by chain type"),
-    custody: z3.enum(["Developer", "User"]).optional().describe("Filter by custody")
+  options: z2.object({
+    limit: z2.number().optional().describe("Max results"),
+    skip: z2.number().optional().describe("Offset"),
+    chainType: z2.enum(["EVM", "SVM"]).optional().describe("Filter by chain type"),
+    custody: z2.enum(["Developer", "User"]).optional().describe("Filter by custody")
   }),
   alias: { limit: "l" },
   examples: [
@@ -820,23 +815,23 @@ accounts.command("list", {
     { options: { chainType: "EVM" }, description: "Filter to EVM accounts only" },
     { options: { custody: "Developer", limit: 10 }, description: "List developer-custody wallets" }
   ],
-  output: z3.object({
-    data: z3.array(z3.object({
-      id: z3.string(),
-      wallet: z3.string().describe("Wallet ID"),
-      accountType: z3.string().describe("Account type"),
-      address: z3.string(),
-      ownerAddress: z3.string().optional(),
-      chainType: z3.string(),
-      chainId: z3.number().optional(),
-      custody: z3.string(),
-      createdAt: z3.number(),
-      updatedAt: z3.number()
+  output: z2.object({
+    data: z2.array(z2.object({
+      id: z2.string(),
+      wallet: z2.string().describe("Wallet ID"),
+      accountType: z2.string().describe("Account type"),
+      address: z2.string(),
+      ownerAddress: z2.string().optional(),
+      chainType: z2.string(),
+      chainId: z2.number().optional(),
+      custody: z2.string(),
+      createdAt: z2.number(),
+      updatedAt: z2.number()
     })),
-    total: z3.number()
+    total: z2.number()
   }),
   async run(c) {
-    const res = await c.var.openfort.accounts.list({
+    const res = await getOpenfort().accounts.list({
       limit: c.options.limit,
       skip: c.options.skip,
       chainType: c.options.chainType,
@@ -863,38 +858,37 @@ accounts.command(evm);
 accounts.command(solana);
 
 // src/commands/contracts.ts
-import { Cli as Cli2, z as z4 } from "incur";
-var contractItem = z4.object({
-  id: z4.string(),
-  createdAt: z4.number(),
-  name: z4.string().nullable(),
-  chainId: z4.number(),
-  address: z4.string(),
-  deleted: z4.boolean(),
-  abi: z4.array(z4.any()),
-  publicVerification: z4.boolean()
-});
-var contracts = Cli2.create("contracts", {
-  description: "Manage smart contracts.",
-  vars: varsSchema
+import { Cli as Cli3, z as z3 } from "incur";
+var contractItem = z3.object({
+  id: z3.string(),
+  createdAt: z3.number(),
+  name: z3.string().nullable(),
+  chainId: z3.number(),
+  address: z3.string(),
+  deleted: z3.boolean(),
+  abi: z3.array(z3.record(z3.string(), z3.unknown())),
+  publicVerification: z3.boolean()
+});
+var contracts = Cli3.create("contracts", {
+  description: "Manage smart contracts."
 });
 contracts.command("list", {
   description: "List registered contracts.",
-  options: z4.object({
-    limit: z4.number().optional().describe("Max results"),
-    skip: z4.number().optional().describe("Offset")
+  options: z3.object({
+    limit: z3.number().optional().describe("Max results"),
+    skip: z3.number().optional().describe("Offset")
   }),
   alias: { limit: "l" },
   examples: [
     { description: "List all contracts" },
     { options: { limit: 5 }, description: "List first 5 contracts" }
   ],
-  output: z4.object({
-    data: z4.array(contractItem),
-    total: z4.number()
+  output: z3.object({
+    data: z3.array(contractItem),
+    total: z3.number()
   }),
   async run(c) {
-    const res = await c.var.openfort.contracts.list({
+    const res = await getOpenfort().contracts.list({
       limit: c.options.limit,
       skip: c.options.skip
     });
@@ -915,11 +909,11 @@ contracts.command("list", {
 });
 contracts.command("create", {
   description: "Register a smart contract.",
-  options: z4.object({
-    name: z4.string().describe("Contract name"),
-    address: z4.string().describe("Contract address"),
-    chainId: z4.number().describe("Chain ID"),
-    abi: z4.string().optional().describe("Contract ABI as JSON string")
+  options: z3.object({
+    name: z3.string().describe("Contract name"),
+    address: z3.string().describe("Contract address"),
+    chainId: z3.number().describe("Chain ID"),
+    abi: z3.string().optional().describe("Contract ABI as JSON string")
   }),
   output: contractItem,
   examples: [
@@ -933,7 +927,7 @@ contracts.command("create", {
     }
   ],
   async run(c) {
-    const res = await c.var.openfort.contracts.create({
+    const res = await getOpenfort().contracts.create({
       name: c.options.name,
       address: c.options.address,
       chainId: c.options.chainId,
@@ -964,15 +958,15 @@ contracts.command("create", {
 });
 contracts.command("get", {
   description: "Get a contract by ID.",
-  args: z4.object({
-    id: z4.string().describe("Contract ID (con_...)")
+  args: z3.object({
+    id: z3.string().describe("Contract ID (con_...)")
   }),
   examples: [
     { args: { id: "con_1a2b3c4d" }, description: "Get contract details" }
   ],
   output: contractItem,
   async run(c) {
-    const ct = await c.var.openfort.contracts.get(c.args.id);
+    const ct = await getOpenfort().contracts.get(c.args.id);
     return c.ok({
       id: ct.id,
       createdAt: ct.createdAt,
@@ -987,21 +981,21 @@ contracts.command("get", {
 });
 contracts.command("update", {
   description: "Update a contract.",
-  args: z4.object({
-    id: z4.string().describe("Contract ID (con_...)")
+  args: z3.object({
+    id: z3.string().describe("Contract ID (con_...)")
   }),
-  options: z4.object({
-    name: z4.string().optional().describe("New name"),
-    address: z4.string().optional().describe("New address"),
-    chainId: z4.number().optional().describe("New chain ID"),
-    abi: z4.string().optional().describe("New ABI as JSON string")
+  options: z3.object({
+    name: z3.string().optional().describe("New name"),
+    address: z3.string().optional().describe("New address"),
+    chainId: z3.number().optional().describe("New chain ID"),
+    abi: z3.string().optional().describe("New ABI as JSON string")
   }),
   examples: [
     { args: { id: "con_1a2b3c4d" }, options: { name: "USDC v2" }, description: "Rename a contract" }
   ],
   output: contractItem,
   async run(c) {
-    const res = await c.var.openfort.contracts.update(c.args.id, {
+    const res = await getOpenfort().contracts.update(c.args.id, {
       name: c.options.name,
       address: c.options.address,
       chainId: c.options.chainId,
@@ -1021,48 +1015,47 @@ contracts.command("update", {
 });
 contracts.command("delete", {
   description: "Delete a contract.",
-  args: z4.object({
-    id: z4.string().describe("Contract ID (con_...)")
+  args: z3.object({
+    id: z3.string().describe("Contract ID (con_...)")
   }),
   examples: [
     { args: { id: "con_1a2b3c4d" }, description: "Delete a contract" }
   ],
-  output: z4.object({
-    id: z4.string(),
-    deleted: z4.boolean()
+  output: z3.object({
+    id: z3.string(),
+    deleted: z3.boolean()
   }),
   async run(c) {
-    const res = await c.var.openfort.contracts.delete(c.args.id);
+    const res = await getOpenfort().contracts.delete(c.args.id);
     return c.ok({ id: res.id, deleted: res.deleted });
   }
 });
 
 // src/commands/paymasters.ts
-import { Cli as Cli3, z as z5 } from "incur";
-var paymasterItem = z5.object({
-  id: z5.string(),
-  createdAt: z5.number(),
-  address: z5.string(),
-  url: z5.string().optional(),
-  context: z5.record(z5.string(), z5.unknown()).optional()
-});
-var paymasters = Cli3.create("paymasters", {
-  description: "Manage ERC-4337 paymasters.",
-  vars: varsSchema
+import { Cli as Cli4, z as z4 } from "incur";
+var paymasterItem = z4.object({
+  id: z4.string(),
+  createdAt: z4.number(),
+  address: z4.string(),
+  url: z4.string().optional(),
+  context: z4.record(z4.string(), z4.unknown()).optional()
+});
+var paymasters = Cli4.create("paymasters", {
+  description: "Manage ERC-4337 paymasters."
 });
 paymasters.command("create", {
   description: "Create a paymaster.",
-  options: z5.object({
-    address: z5.string().describe("Paymaster contract address"),
-    name: z5.string().optional().describe("Paymaster name"),
-    url: z5.string().optional().describe("Paymaster URL")
+  options: z4.object({
+    address: z4.string().describe("Paymaster contract address"),
+    name: z4.string().optional().describe("Paymaster name"),
+    url: z4.string().optional().describe("Paymaster URL")
   }),
   examples: [
     { options: { address: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789", name: "EntryPoint v0.6 Paymaster" }, description: "Create a paymaster for ERC-4337 v0.6" }
   ],
   output: paymasterItem,
   async run(c) {
-    const res = await c.var.openfort.paymasters.create({
+    const res = await getOpenfort().paymasters.create({
       address: c.options.address,
       name: c.options.name,
       url: c.options.url
@@ -1089,15 +1082,15 @@ paymasters.command("create", {
 });
 paymasters.command("get", {
   description: "Get a paymaster by ID.",
-  args: z5.object({
-    id: z5.string().describe("Paymaster ID (pay_...)")
+  args: z4.object({
+    id: z4.string().describe("Paymaster ID (pay_...)")
   }),
   examples: [
     { args: { id: "pay_1a2b3c4d" }, description: "Get paymaster details" }
   ],
   output: paymasterItem,
   async run(c) {
-    const p = await c.var.openfort.paymasters.get(c.args.id);
+    const p = await getOpenfort().paymasters.get(c.args.id);
     return c.ok({
       id: p.id,
       createdAt: p.createdAt,
@@ -1109,20 +1102,20 @@ paymasters.command("get", {
 });
 paymasters.command("update", {
   description: "Update a paymaster.",
-  args: z5.object({
-    id: z5.string().describe("Paymaster ID (pay_...)")
+  args: z4.object({
+    id: z4.string().describe("Paymaster ID (pay_...)")
   }),
-  options: z5.object({
-    address: z5.string().optional().describe("Paymaster address"),
-    name: z5.string().optional().describe("New name"),
-    url: z5.string().optional().describe("New URL")
+  options: z4.object({
+    address: z4.string().describe("Paymaster address"),
+    name: z4.string().optional().describe("New name"),
+    url: z4.string().optional().describe("New URL")
   }),
   examples: [
     { args: { id: "pay_1a2b3c4d" }, options: { address: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789", name: "Updated Paymaster" }, description: "Update paymaster name" }
   ],
   output: paymasterItem,
   async run(c) {
-    const res = await c.var.openfort.paymasters.update(c.args.id, {
+    const res = await getOpenfort().paymasters.update(c.args.id, {
       address: c.options.address,
       name: c.options.name,
       url: c.options.url
@@ -1138,57 +1131,56 @@ paymasters.command("update", {
 });
 paymasters.command("delete", {
   description: "Delete a paymaster.",
-  args: z5.object({
-    id: z5.string().describe("Paymaster ID (pay_...)")
+  args: z4.object({
+    id: z4.string().describe("Paymaster ID (pay_...)")
   }),
   examples: [
     { args: { id: "pay_1a2b3c4d" }, description: "Delete a paymaster" }
   ],
-  output: z5.object({
-    id: z5.string(),
-    deleted: z5.boolean()
+  output: z4.object({
+    id: z4.string(),
+    deleted: z4.boolean()
   }),
   async run(c) {
-    const res = await c.var.openfort.paymasters.delete(c.args.id);
+    const res = await getOpenfort().paymasters.delete(c.args.id);
     return c.ok({ id: res.id, deleted: res.deleted });
   }
 });
 
 // src/commands/policies.ts
-import { Cli as Cli4, z as z6 } from "incur";
+import { Cli as Cli5, z as z5 } from "incur";
 var policyScopes = ["project", "account", "transaction"];
-var policies = Cli4.create("policies", {
-  description: "Manage rules and conditions for backend wallets and fee sponsorship.",
-  vars: varsSchema
+var policies = Cli5.create("policies", {
+  description: "Manage rules and conditions for backend wallets and fee sponsorship."
 });
 policies.command("list", {
   description: "List policies.",
-  options: z6.object({
-    limit: z6.number().optional().describe("Max results"),
-    skip: z6.number().optional().describe("Offset"),
-    scope: z6.enum(policyScopes).optional().describe("Filter by scope"),
-    enabled: z6.boolean().optional().describe("Filter by enabled status")
+  options: z5.object({
+    limit: z5.number().optional().describe("Max results"),
+    skip: z5.number().optional().describe("Offset"),
+    scope: z5.enum(policyScopes).optional().describe("Filter by scope"),
+    enabled: z5.boolean().optional().describe("Filter by enabled status")
   }),
   alias: { limit: "l" },
   examples: [
     { description: "List all policies" },
     { options: { scope: "project", enabled: true }, description: "List enabled project-scope policies" }
   ],
-  output: z6.object({
-    data: z6.array(z6.object({
-      id: z6.string(),
-      createdAt: z6.number(),
-      scope: z6.string(),
-      description: z6.string().nullable(),
-      accountId: z6.string().nullable(),
-      enabled: z6.boolean(),
-      priority: z6.number()
+  output: z5.object({
+    data: z5.array(z5.object({
+      id: z5.string(),
+      createdAt: z5.number(),
+      scope: z5.string(),
+      description: z5.string().nullable(),
+      accountId: z5.string().nullable(),
+      enabled: z5.boolean(),
+      priority: z5.number()
     })),
-    total: z6.number()
+    total: z5.number()
   }),
   async run(c) {
     const scopeFilter = c.options.scope ? [c.options.scope] : void 0;
-    const res = await c.var.openfort.policies.list({
+    const res = await getOpenfort().policies.list({
       limit: c.options.limit,
       skip: c.options.skip,
       scope: scopeFilter,
@@ -1210,19 +1202,19 @@ policies.command("list", {
 });
 policies.command("create", {
   description: "Create a policy with criteria-based rules.",
-  options: z6.object({
-    scope: z6.enum(policyScopes).describe("Policy scope"),
-    description: z6.string().optional().describe("Policy description"),
-    priority: z6.number().optional().describe("Priority (higher = evaluated first)"),
-    rules: z6.string().describe("Rules as JSON string")
+  options: z5.object({
+    scope: z5.enum(policyScopes).describe("Policy scope"),
+    description: z5.string().optional().describe("Policy description"),
+    priority: z5.number().optional().describe("Priority (higher = evaluated first)"),
+    rules: z5.string().describe("Rules as JSON string")
   }),
-  output: z6.object({
-    id: z6.string(),
-    createdAt: z6.number(),
-    scope: z6.string(),
-    description: z6.string().nullable(),
-    enabled: z6.boolean(),
-    priority: z6.number()
+  output: z5.object({
+    id: z5.string(),
+    createdAt: z5.number(),
+    scope: z5.string(),
+    description: z5.string().nullable(),
+    enabled: z5.boolean(),
+    priority: z5.number()
   }),
   examples: [
     {
@@ -1244,7 +1236,7 @@ policies.command("create", {
   async run(c) {
     const rules = JSON.parse(c.options.rules);
     const scope = c.options.scope;
-    const res = await c.var.openfort.policies.create({
+    const res = await getOpenfort().policies.create({
       scope,
       description: c.options.description,
       priority: c.options.priority,
@@ -1273,24 +1265,24 @@ policies.command("create", {
 });
 policies.command("get", {
   description: "Get a policy by ID.",
-  args: z6.object({
-    id: z6.string().describe("Policy ID (ply_...)")
+  args: z5.object({
+    id: z5.string().describe("Policy ID (ply_...)")
   }),
   examples: [
     { args: { id: "ply_1a2b3c4d" }, description: "Get policy details with rules" }
   ],
-  output: z6.object({
-    id: z6.string(),
-    createdAt: z6.number(),
-    scope: z6.string(),
-    description: z6.string().nullable(),
-    accountId: z6.string().nullable(),
-    enabled: z6.boolean(),
-    priority: z6.number(),
-    rules: z6.array(z6.any())
+  output: z5.object({
+    id: z5.string(),
+    createdAt: z5.number(),
+    scope: z5.string(),
+    description: z5.string().nullable(),
+    accountId: z5.string().nullable(),
+    enabled: z5.boolean(),
+    priority: z5.number(),
+    rules: z5.array(z5.record(z5.string(), z5.unknown()))
   }),
   async run(c) {
-    const p = await c.var.openfort.policies.get(c.args.id);
+    const p = await getOpenfort().policies.get(c.args.id);
     return c.ok({
       id: p.id,
       createdAt: p.createdAt,
@@ -1305,29 +1297,29 @@ policies.command("get", {
 });
 policies.command("update", {
   description: "Update a policy.",
-  args: z6.object({
-    id: z6.string().describe("Policy ID (ply_...)")
+  args: z5.object({
+    id: z5.string().describe("Policy ID (ply_...)")
   }),
-  options: z6.object({
-    description: z6.string().optional().describe("New description"),
-    enabled: z6.boolean().optional().describe("Enable or disable"),
-    priority: z6.number().optional().describe("New priority"),
-    rules: z6.string().optional().describe("New rules as JSON string")
+  options: z5.object({
+    description: z5.string().optional().describe("New description"),
+    enabled: z5.boolean().optional().describe("Enable or disable"),
+    priority: z5.number().optional().describe("New priority"),
+    rules: z5.string().optional().describe("New rules as JSON string")
   }),
   examples: [
     { args: { id: "ply_1a2b3c4d" }, options: { enabled: false }, description: "Disable a policy" },
     { args: { id: "ply_1a2b3c4d" }, options: { priority: 10 }, description: "Change policy priority" }
   ],
-  output: z6.object({
-    id: z6.string(),
-    createdAt: z6.number(),
-    scope: z6.string(),
-    description: z6.string().nullable(),
-    enabled: z6.boolean(),
-    priority: z6.number()
+  output: z5.object({
+    id: z5.string(),
+    createdAt: z5.number(),
+    scope: z5.string(),
+    description: z5.string().nullable(),
+    enabled: z5.boolean(),
+    priority: z5.number()
   }),
   async run(c) {
-    const res = await c.var.openfort.policies.update(c.args.id, {
+    const res = await getOpenfort().policies.update(c.args.id, {
       description: c.options.description,
       enabled: c.options.enabled,
       priority: c.options.priority,
@@ -1345,41 +1337,41 @@ policies.command("update", {
 });
 policies.command("delete", {
   description: "Delete a policy.",
-  args: z6.object({
-    id: z6.string().describe("Policy ID (ply_...)")
+  args: z5.object({
+    id: z5.string().describe("Policy ID (ply_...)")
   }),
   examples: [
     { args: { id: "ply_1a2b3c4d" }, description: "Delete a policy" }
   ],
-  output: z6.object({
-    id: z6.string(),
-    deleted: z6.boolean()
+  output: z5.object({
+    id: z5.string(),
+    deleted: z5.boolean()
   }),
   async run(c) {
-    const res = await c.var.openfort.policies.delete(c.args.id);
+    const res = await getOpenfort().policies.delete(c.args.id);
     return c.ok({ id: res.id, deleted: res.deleted });
   }
 });
 policies.command("evaluate", {
   description: "Pre-flight check if an operation would be allowed.",
-  options: z6.object({
-    operation: z6.string().describe("Operation to evaluate (e.g. signEvmTransaction)"),
-    accountId: z6.string().optional().describe("Account ID")
+  options: z5.object({
+    operation: z5.string().describe("Operation to evaluate (e.g. signEvmTransaction)"),
+    accountId: z5.string().optional().describe("Account ID")
   }),
   examples: [
     { options: { operation: "signEvmTransaction", accountId: "acc_1a2b3c4d" }, description: "Check if EVM signing is allowed" },
     { options: { operation: "sponsorEvmTransaction" }, description: "Check if gas sponsorship is allowed" }
   ],
-  output: z6.object({
-    allowed: z6.boolean(),
-    reason: z6.string(),
-    operation: z6.string(),
-    accountId: z6.string().optional(),
-    matchedPolicyId: z6.string().optional(),
-    matchedRuleId: z6.string().optional()
+  output: z5.object({
+    allowed: z5.boolean(),
+    reason: z5.string(),
+    operation: z5.string(),
+    accountId: z5.string().optional(),
+    matchedPolicyId: z5.string().optional(),
+    matchedRuleId: z5.string().optional()
   }),
   async run(c) {
-    const res = await c.var.openfort.policies.evaluate({
+    const res = await getOpenfort().policies.evaluate({
       operation: c.options.operation,
       accountId: c.options.accountId
     });
@@ -1395,45 +1387,44 @@ policies.command("evaluate", {
 });
 
 // src/commands/sponsorship.ts
-import { Cli as Cli5, z as z7 } from "incur";
+import { Cli as Cli6, z as z6 } from "incur";
 var sponsorSchemas = ["pay_for_user", "charge_custom_tokens", "fixed_rate"];
-var sponsorshipItem = z7.object({
-  id: z7.string(),
-  createdAt: z7.number(),
-  name: z7.string().nullable(),
-  chainId: z7.number().nullable(),
-  enabled: z7.boolean(),
-  strategy: z7.object({
-    sponsorSchema: z7.string(),
-    tokenContract: z7.string().optional(),
-    tokenContractAmount: z7.string().optional(),
-    dynamicExchangeRate: z7.boolean().optional()
-  }),
-  paymasterId: z7.string().nullable(),
-  policyId: z7.string().nullable()
-});
-var sponsorship = Cli5.create("sponsorship", {
-  description: "Manage fee sponsorship strategies linked to policies.",
-  vars: varsSchema
+var sponsorshipItem = z6.object({
+  id: z6.string(),
+  createdAt: z6.number(),
+  name: z6.string().nullable(),
+  chainId: z6.number().nullable(),
+  enabled: z6.boolean(),
+  strategy: z6.object({
+    sponsorSchema: z6.string(),
+    tokenContract: z6.string().optional(),
+    tokenContractAmount: z6.string().optional(),
+    dynamicExchangeRate: z6.boolean().optional()
+  }),
+  paymasterId: z6.string().nullable(),
+  policyId: z6.string().nullable()
+});
+var sponsorship = Cli6.create("sponsorship", {
+  description: "Manage fee sponsorship strategies linked to policies."
 });
 sponsorship.command("list", {
   description: "List fee sponsorships.",
-  options: z7.object({
-    limit: z7.number().optional().describe("Max results"),
-    skip: z7.number().optional().describe("Offset"),
-    enabled: z7.boolean().optional().describe("Filter by enabled status")
+  options: z6.object({
+    limit: z6.number().optional().describe("Max results"),
+    skip: z6.number().optional().describe("Offset"),
+    enabled: z6.boolean().optional().describe("Filter by enabled status")
   }),
   alias: { limit: "l" },
   examples: [
     { description: "List all sponsorships" },
     { options: { enabled: true }, description: "List active sponsorships only" }
   ],
-  output: z7.object({
-    data: z7.array(sponsorshipItem),
-    total: z7.number()
+  output: z6.object({
+    data: z6.array(sponsorshipItem),
+    total: z6.number()
   }),
   async run(c) {
-    const res = await c.var.openfort.feeSponsorship.list({
+    const res = await getOpenfort().feeSponsorship.list({
       limit: c.options.limit,
       skip: c.options.skip,
       enabled: c.options.enabled
@@ -1455,11 +1446,11 @@ sponsorship.command("list", {
 });
 sponsorship.command("create", {
   description: "Create a fee sponsorship linked to a policy.",
-  options: z7.object({
-    policyId: z7.string().describe("Policy ID to link (ply_...)"),
-    name: z7.string().optional().describe("Sponsorship name"),
-    strategy: z7.enum(sponsorSchemas).default("pay_for_user").describe("Sponsorship strategy"),
-    chainId: z7.number().optional().describe("Chain ID")
+  options: z6.object({
+    policyId: z6.string().describe("Policy ID to link (ply_...)"),
+    name: z6.string().optional().describe("Sponsorship name"),
+    strategy: z6.enum(sponsorSchemas).default("pay_for_user").describe("Sponsorship strategy"),
+    chainId: z6.number().optional().describe("Chain ID")
   }),
   output: sponsorshipItem,
   examples: [
@@ -1474,7 +1465,7 @@ sponsorship.command("create", {
   ],
   async run(c) {
     const strategy = { sponsorSchema: c.options.strategy };
-    const res = await c.var.openfort.feeSponsorship.create({
+    const res = await getOpenfort().feeSponsorship.create({
       policyId: c.options.policyId,
       name: c.options.name,
       strategy,
@@ -1505,15 +1496,15 @@ sponsorship.command("create", {
 });
 sponsorship.command("get", {
   description: "Get a fee sponsorship by ID.",
-  args: z7.object({
-    id: z7.string().describe("Fee sponsorship ID (pol_...)")
+  args: z6.object({
+    id: z6.string().describe("Fee sponsorship ID (pol_...)")
   }),
   examples: [
     { args: { id: "pol_1a2b3c4d" }, description: "Get sponsorship details" }
   ],
   output: sponsorshipItem,
   async run(c) {
-    const s = await c.var.openfort.feeSponsorship.get(c.args.id);
+    const s = await getOpenfort().feeSponsorship.get(c.args.id);
     return c.ok({
       id: s.id,
       createdAt: s.createdAt,
@@ -1528,13 +1519,13 @@ sponsorship.command("get", {
 });
 sponsorship.command("update", {
   description: "Update a fee sponsorship.",
-  args: z7.object({
-    id: z7.string().describe("Fee sponsorship ID (pol_...)")
+  args: z6.object({
+    id: z6.string().describe("Fee sponsorship ID (pol_...)")
   }),
-  options: z7.object({
-    name: z7.string().optional().describe("New name"),
-    strategy: z7.enum(sponsorSchemas).optional().describe("New strategy"),
-    policyId: z7.string().optional().describe("New policy ID")
+  options: z6.object({
+    name: z6.string().optional().describe("New name"),
+    strategy: z6.enum(sponsorSchemas).optional().describe("New strategy"),
+    policyId: z6.string().optional().describe("New policy ID")
   }),
   examples: [
     { args: { id: "pol_1a2b3c4d" }, options: { name: "Mainnet Gas Sponsor" }, description: "Rename a sponsorship" }
@@ -1542,7 +1533,7 @@ sponsorship.command("update", {
   output: sponsorshipItem,
   async run(c) {
     const strategy = c.options.strategy ? { sponsorSchema: c.options.strategy } : void 0;
-    const res = await c.var.openfort.feeSponsorship.update(c.args.id, {
+    const res = await getOpenfort().feeSponsorship.update(c.args.id, {
       name: c.options.name,
       strategy,
       policyId: c.options.policyId
@@ -1561,15 +1552,15 @@ sponsorship.command("update", {
 });
 sponsorship.command("enable", {
   description: "Enable a fee sponsorship.",
-  args: z7.object({
-    id: z7.string().describe("Fee sponsorship ID (pol_...)")
+  args: z6.object({
+    id: z6.string().describe("Fee sponsorship ID (pol_...)")
   }),
   examples: [
     { args: { id: "pol_1a2b3c4d" }, description: "Enable a sponsorship" }
   ],
   output: sponsorshipItem,
   async run(c) {
-    const res = await c.var.openfort.feeSponsorship.enable(c.args.id);
+    const res = await getOpenfort().feeSponsorship.enable(c.args.id);
     return c.ok({
       id: res.id,
       createdAt: res.createdAt,
@@ -1584,15 +1575,15 @@ sponsorship.command("enable", {
 });
 sponsorship.command("disable", {
   description: "Disable a fee sponsorship.",
-  args: z7.object({
-    id: z7.string().describe("Fee sponsorship ID (pol_...)")
+  args: z6.object({
+    id: z6.string().describe("Fee sponsorship ID (pol_...)")
   }),
   examples: [
     { args: { id: "pol_1a2b3c4d" }, description: "Disable a sponsorship" }
   ],
   output: sponsorshipItem,
   async run(c) {
-    const res = await c.var.openfort.feeSponsorship.disable(c.args.id);
+    const res = await getOpenfort().feeSponsorship.disable(c.args.id);
     return c.ok({
       id: res.id,
       createdAt: res.createdAt,
@@ -1607,24 +1598,24 @@ sponsorship.command("disable", {
 });
 sponsorship.command("delete", {
   description: "Delete a fee sponsorship.",
-  args: z7.object({
-    id: z7.string().describe("Fee sponsorship ID (pol_...)")
+  args: z6.object({
+    id: z6.string().describe("Fee sponsorship ID (pol_...)")
   }),
   examples: [
     { args: { id: "pol_1a2b3c4d" }, description: "Delete a sponsorship" }
   ],
-  output: z7.object({
-    id: z7.string(),
-    deleted: z7.boolean()
+  output: z6.object({
+    id: z6.string(),
+    deleted: z6.boolean()
   }),
   async run(c) {
-    const res = await c.var.openfort.feeSponsorship.delete(c.args.id);
+    const res = await getOpenfort().feeSponsorship.delete(c.args.id);
     return c.ok({ id: res.id, deleted: res.deleted });
   }
 });
 
 // src/commands/subscriptions.ts
-import { Cli as Cli6, z as z8 } from "incur";
+import { Cli as Cli7, z as z7 } from "incur";
 var apiTopics = [
   "transaction_intent.broadcast",
   "transaction_intent.successful",
@@ -1640,28 +1631,27 @@ var apiTopics = [
   "account.created"
 ];
 var apiTriggerTypes = ["webhook", "email"];
-var triggers = Cli6.create("triggers", {
-  description: "Manage subscription triggers.",
-  vars: varsSchema
+var triggers = Cli7.create("triggers", {
+  description: "Manage subscription triggers."
 });
 triggers.command("list", {
   description: "List triggers for a subscription.",
-  args: z8.object({
-    subscriptionId: z8.string().describe("Subscription ID (sub_...)")
+  args: z7.object({
+    subscriptionId: z7.string().describe("Subscription ID (sub_...)")
   }),
   examples: [
     { args: { subscriptionId: "sub_1a2b3c4d" }, description: "List triggers" }
   ],
-  output: z8.object({
-    data: z8.array(z8.object({
-      id: z8.string(),
-      createdAt: z8.number(),
-      target: z8.string(),
-      type: z8.string()
+  output: z7.object({
+    data: z7.array(z7.object({
+      id: z7.string(),
+      createdAt: z7.number(),
+      target: z7.string(),
+      type: z7.string()
     }))
   }),
   async run(c) {
-    const res = await c.var.openfort.triggers.list(c.args.subscriptionId);
+    const res = await getOpenfort().triggers.list(c.args.subscriptionId);
     return c.ok({
       data: res.data.map((t) => ({
         id: t.id,
@@ -1674,12 +1664,12 @@ triggers.command("list", {
 });
 triggers.command("create", {
   description: "Create a trigger for a subscription.",
-  args: z8.object({
-    subscriptionId: z8.string().describe("Subscription ID (sub_...)")
+  args: z7.object({
+    subscriptionId: z7.string().describe("Subscription ID (sub_...)")
   }),
-  options: z8.object({
-    target: z8.string().describe("Webhook URL or email address"),
-    type: z8.enum(apiTriggerTypes).default("webhook").describe("Trigger type: webhook or email")
+  options: z7.object({
+    target: z7.string().describe("Webhook URL or email address"),
+    type: z7.enum(apiTriggerTypes).default("webhook").describe("Trigger type: webhook or email")
   }),
   examples: [
     {
@@ -1688,14 +1678,14 @@ triggers.command("create", {
       description: "Create a webhook trigger"
     }
   ],
-  output: z8.object({
-    id: z8.string(),
-    createdAt: z8.number(),
-    target: z8.string(),
-    type: z8.string()
+  output: z7.object({
+    id: z7.string(),
+    createdAt: z7.number(),
+    target: z7.string(),
+    type: z7.string()
   }),
   async run(c) {
-    const res = await c.var.openfort.triggers.create(c.args.subscriptionId, {
+    const res = await getOpenfort().triggers.create(c.args.subscriptionId, {
       target: c.options.target,
       type: c.options.type
     });
@@ -1709,21 +1699,21 @@ triggers.command("create", {
 });
 triggers.command("get", {
   description: "Get a trigger by ID.",
-  args: z8.object({
-    subscriptionId: z8.string().describe("Subscription ID (sub_...)"),
-    triggerId: z8.string().describe("Trigger ID (tri_...)")
+  args: z7.object({
+    subscriptionId: z7.string().describe("Subscription ID (sub_...)"),
+    triggerId: z7.string().describe("Trigger ID (tri_...)")
   }),
   examples: [
     { args: { subscriptionId: "sub_1a2b3c4d", triggerId: "tri_1a2b3c4d" }, description: "Get trigger details" }
   ],
-  output: z8.object({
-    id: z8.string(),
-    createdAt: z8.number(),
-    target: z8.string(),
-    type: z8.string()
+  output: z7.object({
+    id: z7.string(),
+    createdAt: z7.number(),
+    target: z7.string(),
+    type: z7.string()
   }),
   async run(c) {
-    const t = await c.var.openfort.triggers.get(c.args.subscriptionId, c.args.triggerId);
+    const t = await getOpenfort().triggers.get(c.args.subscriptionId, c.args.triggerId);
     return c.ok({
       id: t.id,
       createdAt: t.createdAt,
@@ -1734,46 +1724,45 @@ triggers.command("get", {
 });
 triggers.command("delete", {
   description: "Delete a trigger.",
-  args: z8.object({
-    subscriptionId: z8.string().describe("Subscription ID (sub_...)"),
-    triggerId: z8.string().describe("Trigger ID (tri_...)")
+  args: z7.object({
+    subscriptionId: z7.string().describe("Subscription ID (sub_...)"),
+    triggerId: z7.string().describe("Trigger ID (tri_...)")
   }),
   examples: [
     { args: { subscriptionId: "sub_1a2b3c4d", triggerId: "tri_1a2b3c4d" }, description: "Delete a trigger" }
   ],
-  output: z8.object({
-    id: z8.string(),
-    deleted: z8.boolean()
+  output: z7.object({
+    id: z7.string(),
+    deleted: z7.boolean()
   }),
   async run(c) {
-    const res = await c.var.openfort.triggers.delete(c.args.subscriptionId, c.args.triggerId);
+    const res = await getOpenfort().triggers.delete(c.args.subscriptionId, c.args.triggerId);
     return c.ok({ id: res.id, deleted: res.deleted });
   }
 });
-var subscriptions = Cli6.create("subscriptions", {
-  description: "Manage webhook subscriptions.",
-  vars: varsSchema
+var subscriptions = Cli7.create("subscriptions", {
+  description: "Manage webhook subscriptions."
 });
 subscriptions.command("list", {
   description: "List webhook subscriptions.",
   examples: [
     { description: "List all subscriptions" }
   ],
-  output: z8.object({
-    data: z8.array(z8.object({
-      id: z8.string(),
-      createdAt: z8.number(),
-      topic: z8.string(),
-      triggers: z8.array(z8.object({
-        id: z8.string(),
-        target: z8.string(),
-        type: z8.string()
+  output: z7.object({
+    data: z7.array(z7.object({
+      id: z7.string(),
+      createdAt: z7.number(),
+      topic: z7.string(),
+      triggers: z7.array(z7.object({
+        id: z7.string(),
+        target: z7.string(),
+        type: z7.string()
       }))
     })),
-    total: z8.number()
+    total: z7.number()
   }),
   async run(c) {
-    const res = await c.var.openfort.subscriptions.list();
+    const res = await getOpenfort().subscriptions.list();
     return c.ok({
       data: res.data.map((s) => ({
         id: s.id,
@@ -1787,9 +1776,9 @@ subscriptions.command("list", {
 });
 subscriptions.command("create", {
   description: "Create a webhook subscription.",
-  options: z8.object({
-    topic: z8.enum(apiTopics).describe("Event topic (e.g. transaction_intent.successful, user.created)"),
-    triggers: z8.string().describe('Triggers as JSON: [{"type":"webhook","target":"https://..."}]')
+  options: z7.object({
+    topic: z7.enum(apiTopics).describe("Event topic (e.g. transaction_intent.successful, user.created)"),
+    triggers: z7.string().describe('Triggers as JSON: [{"type":"webhook","target":"https://..."}]')
   }),
   examples: [
     {
@@ -1800,19 +1789,19 @@ subscriptions.command("create", {
       description: "Get notified when transactions succeed"
     }
   ],
-  output: z8.object({
-    id: z8.string(),
-    createdAt: z8.number(),
-    topic: z8.string(),
-    triggers: z8.array(z8.object({
-      id: z8.string(),
-      target: z8.string(),
-      type: z8.string()
+  output: z7.object({
+    id: z7.string(),
+    createdAt: z7.number(),
+    topic: z7.string(),
+    triggers: z7.array(z7.object({
+      id: z7.string(),
+      target: z7.string(),
+      type: z7.string()
     }))
   }),
   async run(c) {
     const parsedTriggers = JSON.parse(c.options.triggers);
-    const res = await c.var.openfort.subscriptions.create({
+    const res = await getOpenfort().subscriptions.create({
       topic: c.options.topic,
       triggers: parsedTriggers
     });
@@ -1837,24 +1826,24 @@ subscriptions.command("create", {
 });
 subscriptions.command("get", {
   description: "Get a subscription by ID.",
-  args: z8.object({
-    id: z8.string().describe("Subscription ID (sub_...)")
+  args: z7.object({
+    id: z7.string().describe("Subscription ID (sub_...)")
   }),
   examples: [
     { args: { id: "sub_1a2b3c4d" }, description: "Get subscription details" }
   ],
-  output: z8.object({
-    id: z8.string(),
-    createdAt: z8.number(),
-    topic: z8.string(),
-    triggers: z8.array(z8.object({
-      id: z8.string(),
-      target: z8.string(),
-      type: z8.string()
+  output: z7.object({
+    id: z7.string(),
+    createdAt: z7.number(),
+    topic: z7.string(),
+    triggers: z7.array(z7.object({
+      id: z7.string(),
+      target: z7.string(),
+      type: z7.string()
     }))
   }),
   async run(c) {
-    const s = await c.var.openfort.subscriptions.get(c.args.id);
+    const s = await getOpenfort().subscriptions.get(c.args.id);
     return c.ok({
       id: s.id,
       createdAt: s.createdAt,
@@ -1865,65 +1854,64 @@ subscriptions.command("get", {
 });
 subscriptions.command("delete", {
   description: "Delete a subscription.",
-  args: z8.object({
-    id: z8.string().describe("Subscription ID (sub_...)")
+  args: z7.object({
+    id: z7.string().describe("Subscription ID (sub_...)")
   }),
   examples: [
     { args: { id: "sub_1a2b3c4d" }, description: "Delete a subscription" }
   ],
-  output: z8.object({
-    id: z8.string(),
-    deleted: z8.boolean()
+  output: z7.object({
+    id: z7.string(),
+    deleted: z7.boolean()
   }),
   async run(c) {
-    const res = await c.var.openfort.subscriptions.delete(c.args.id);
+    const res = await getOpenfort().subscriptions.delete(c.args.id);
     return c.ok({ id: res.id, deleted: res.deleted });
   }
 });
 subscriptions.command(triggers);
 
 // src/commands/sessions.ts
-import { Cli as Cli7, z as z9 } from "incur";
-var sessionItem = z9.object({
-  id: z9.string(),
-  createdAt: z9.number(),
-  updatedAt: z9.number(),
-  address: z9.string(),
-  validAfter: z9.string(),
-  validUntil: z9.string(),
-  whitelist: z9.array(z9.string()).optional(),
-  isActive: z9.boolean(),
-  nextAction: z9.object({
-    type: z9.string(),
-    payload: z9.any().optional()
+import { Cli as Cli8, z as z8 } from "incur";
+var sessionItem = z8.object({
+  id: z8.string(),
+  createdAt: z8.number(),
+  updatedAt: z8.number(),
+  address: z8.string(),
+  validAfter: z8.string(),
+  validUntil: z8.string(),
+  whitelist: z8.array(z8.string()).optional(),
+  isActive: z8.boolean(),
+  nextAction: z8.object({
+    type: z8.string(),
+    payload: z8.record(z8.string(), z8.unknown()).optional()
   }).optional()
 });
-var sessions = Cli7.create("sessions", {
-  description: "Manage session keys.",
-  vars: varsSchema
+var sessions = Cli8.create("sessions", {
+  description: "Manage session keys."
 });
 sessions.command("list", {
   description: "List session keys for a player.",
-  options: z9.object({
-    player: z9.string().describe("Player ID (pla_...)"),
-    limit: z9.number().optional().describe("Max results"),
-    skip: z9.number().optional().describe("Offset")
+  options: z8.object({
+    player: z8.string().describe("Player ID (pla_...)"),
+    limit: z8.number().optional().describe("Max results"),
+    skip: z8.number().optional().describe("Offset")
   }),
   alias: { limit: "l" },
   examples: [
     { options: { player: "pla_1a2b3c4d" }, description: "List sessions for a player" }
   ],
-  output: z9.object({
-    data: z9.array(z9.object({
-      id: z9.string(),
-      createdAt: z9.number(),
-      address: z9.string(),
-      isActive: z9.boolean()
+  output: z8.object({
+    data: z8.array(z8.object({
+      id: z8.string(),
+      createdAt: z8.number(),
+      address: z8.string(),
+      isActive: z8.boolean()
     })),
-    total: z9.number()
+    total: z8.number()
   }),
   async run(c) {
-    const res = await c.var.openfort.sessions.list({
+    const res = await getOpenfort().sessions.list({
       player: c.options.player,
       limit: c.options.limit,
       skip: c.options.skip
@@ -1941,16 +1929,16 @@ sessions.command("list", {
 });
 sessions.command("create", {
   description: "Create a session key.",
-  options: z9.object({
-    address: z9.string().describe("Session key address"),
-    chainId: z9.number().describe("Chain ID"),
-    validAfter: z9.number().describe("Valid after (unix timestamp in seconds)"),
-    validUntil: z9.number().describe("Valid until (unix timestamp in seconds)"),
-    player: z9.string().optional().describe("Player ID (pla_...)"),
-    account: z9.string().optional().describe("Account ID (acc_...)"),
-    limit: z9.number().optional().describe("Max session uses"),
-    policy: z9.string().optional().describe("Fee sponsorship ID (pol_...)"),
-    whitelist: z9.string().optional().describe("Whitelisted contract addresses as JSON array")
+  options: z8.object({
+    address: z8.string().describe("Session key address"),
+    chainId: z8.number().describe("Chain ID"),
+    validAfter: z8.number().describe("Valid after (unix timestamp in seconds)"),
+    validUntil: z8.number().describe("Valid until (unix timestamp in seconds)"),
+    player: z8.string().optional().describe("Player ID (pla_...)"),
+    account: z8.string().optional().describe("Account ID (acc_...)"),
+    limit: z8.number().optional().describe("Max session uses"),
+    policy: z8.string().optional().describe("Fee sponsorship ID (pol_...)"),
+    whitelist: z8.string().optional().describe("Whitelisted contract addresses as JSON array")
   }),
   examples: [
     {
@@ -1966,7 +1954,7 @@ sessions.command("create", {
   ],
   output: sessionItem,
   async run(c) {
-    const res = await c.var.openfort.sessions.create({
+    const res = await getOpenfort().sessions.create({
       address: c.options.address,
       chainId: c.options.chainId,
       validAfter: c.options.validAfter,
@@ -2002,15 +1990,15 @@ sessions.command("create", {
 });
 sessions.command("get", {
   description: "Get a session key by ID.",
-  args: z9.object({
-    id: z9.string().describe("Session ID (ses_...)")
+  args: z8.object({
+    id: z8.string().describe("Session ID (ses_...)")
   }),
   examples: [
     { args: { id: "ses_1a2b3c4d" }, description: "Get session details" }
   ],
   output: sessionItem,
   async run(c) {
-    const s = await c.var.openfort.sessions.get(c.args.id);
+    const s = await getOpenfort().sessions.get(c.args.id);
     return c.ok({
       id: s.id,
       createdAt: s.createdAt,
@@ -2026,18 +2014,18 @@ sessions.command("get", {
 });
 sessions.command("revoke", {
   description: "Revoke a session key.",
-  options: z9.object({
-    address: z9.string().describe("Session key address to revoke"),
-    chainId: z9.number().describe("Chain ID"),
-    player: z9.string().optional().describe("Player ID (pla_...)"),
-    policy: z9.string().optional().describe("Fee sponsorship ID (pol_...)")
+  options: z8.object({
+    address: z8.string().describe("Session key address to revoke"),
+    chainId: z8.number().describe("Chain ID"),
+    player: z8.string().optional().describe("Player ID (pla_...)"),
+    policy: z8.string().optional().describe("Fee sponsorship ID (pol_...)")
   }),
   examples: [
     { options: { address: "0x1234...", chainId: 137 }, description: "Revoke a session key" }
   ],
   output: sessionItem,
   async run(c) {
-    const res = await c.var.openfort.sessions.revoke({
+    const res = await getOpenfort().sessions.revoke({
       address: c.options.address,
       chainId: c.options.chainId,
       player: c.options.player,
@@ -2058,19 +2046,19 @@ sessions.command("revoke", {
 });
 sessions.command("sign", {
   description: "Sign and broadcast a session userOperationHash.",
-  args: z9.object({
-    id: z9.string().describe("Session ID (ses_...)")
+  args: z8.object({
+    id: z8.string().describe("Session ID (ses_...)")
   }),
-  options: z9.object({
-    signature: z9.string().describe("Hex signature"),
-    optimistic: z9.boolean().optional().describe("Return before on-chain confirmation")
+  options: z8.object({
+    signature: z8.string().describe("Hex signature"),
+    optimistic: z8.boolean().optional().describe("Return before on-chain confirmation")
   }),
   examples: [
     { args: { id: "ses_1a2b3c4d" }, options: { signature: "0xabcd1234..." }, description: "Sign a session" }
   ],
   output: sessionItem,
   async run(c) {
-    const res = await c.var.openfort.sessions.signature(c.args.id, {
+    const res = await getOpenfort().sessions.signature(c.args.id, {
       signature: c.options.signature,
       optimistic: c.options.optimistic
     });
@@ -2089,61 +2077,60 @@ sessions.command("sign", {
 });
 
 // src/commands/transactions.ts
-import { Cli as Cli8, z as z10 } from "incur";
-var transactionIntentItem = z10.object({
-  id: z10.string(),
-  createdAt: z10.number(),
-  updatedAt: z10.number(),
-  chainId: z10.number(),
-  abstractionType: z10.string().describe("e.g. accountAbstractionV6, standard"),
-  userOperationHash: z10.string().optional(),
-  response: z10.object({
-    createdAt: z10.number(),
-    blockNumber: z10.number().optional(),
-    transactionHash: z10.string().optional(),
-    gasUsed: z10.string().optional(),
-    gasFee: z10.string().optional(),
-    status: z10.number().optional(),
-    to: z10.string().optional(),
-    error: z10.any().optional()
+import { Cli as Cli9, z as z9 } from "incur";
+var transactionIntentItem = z9.object({
+  id: z9.string(),
+  createdAt: z9.number(),
+  updatedAt: z9.number(),
+  chainId: z9.number(),
+  abstractionType: z9.string().describe("e.g. accountAbstractionV6, standard"),
+  userOperationHash: z9.string().optional(),
+  response: z9.object({
+    createdAt: z9.number(),
+    blockNumber: z9.number().optional(),
+    transactionHash: z9.string().optional(),
+    gasUsed: z9.string().optional(),
+    gasFee: z9.string().optional(),
+    status: z9.number().optional(),
+    to: z9.string().optional(),
+    error: z9.record(z9.string(), z9.unknown()).optional()
   }).optional(),
-  interactions: z10.array(z10.object({
-    to: z10.string().optional(),
-    data: z10.string().optional(),
-    value: z10.string().optional()
+  interactions: z9.array(z9.object({
+    to: z9.string().optional(),
+    data: z9.string().optional(),
+    value: z9.string().optional()
   })).optional(),
-  nextAction: z10.object({
-    type: z10.string(),
-    payload: z10.any().optional()
+  nextAction: z9.object({
+    type: z9.string(),
+    payload: z9.record(z9.string(), z9.unknown()).optional()
   }).optional()
 });
-var transactions = Cli8.create("transactions", {
-  description: "Manage transaction intents.",
-  vars: varsSchema
+var transactions = Cli9.create("transactions", {
+  description: "Manage transaction intents."
 });
 transactions.command("list", {
   description: "List transaction intents.",
-  options: z10.object({
-    limit: z10.number().optional().describe("Max results"),
-    skip: z10.number().optional().describe("Offset")
+  options: z9.object({
+    limit: z9.number().optional().describe("Max results"),
+    skip: z9.number().optional().describe("Offset")
   }),
   alias: { limit: "l" },
   examples: [
     { description: "List all transactions" },
     { options: { limit: 10 }, description: "List last 10 transactions" }
   ],
-  output: z10.object({
-    data: z10.array(z10.object({
-      id: z10.string(),
-      createdAt: z10.number(),
-      updatedAt: z10.number(),
-      chainId: z10.number(),
-      abstractionType: z10.string()
+  output: z9.object({
+    data: z9.array(z9.object({
+      id: z9.string(),
+      createdAt: z9.number(),
+      updatedAt: z9.number(),
+      chainId: z9.number(),
+      abstractionType: z9.string()
     })),
-    total: z10.number()
+    total: z9.number()
   }),
   async run(c) {
-    const res = await c.var.openfort.transactionIntents.list({
+    const res = await getOpenfort().transactionIntents.list({
       limit: c.options.limit,
       skip: c.options.skip
     });
@@ -2161,12 +2148,12 @@ transactions.command("list", {
 });
 transactions.command("create", {
   description: "Create a transaction intent.",
-  options: z10.object({
-    account: z10.string().describe("Account ID (acc_...)"),
-    chainId: z10.number().describe("Chain ID"),
-    interactions: z10.string().describe('Interactions as JSON: [{"to":"0x...","data":"0x...","value":"0"}]'),
-    policy: z10.string().optional().describe("Fee sponsorship ID (pol_...)."),
-    signedAuthorization: z10.string().optional().describe("Signed EIP-7702 authorization hex (for delegated accounts)")
+  options: z9.object({
+    account: z9.string().describe("Account ID (acc_...)"),
+    chainId: z9.number().describe("Chain ID"),
+    interactions: z9.string().describe('Interactions as JSON: [{"to":"0x...","data":"0x...","value":"0"}]'),
+    policy: z9.string().optional().describe("Fee sponsorship ID (pol_...)."),
+    signedAuthorization: z9.string().optional().describe("Signed EIP-7702 authorization hex (for delegated accounts)")
   }),
   output: transactionIntentItem,
   examples: [
@@ -2190,7 +2177,7 @@ transactions.command("create", {
   ],
   async run(c) {
     const interactions = JSON.parse(c.options.interactions);
-    const res = await c.var.openfort.transactionIntents.create({
+    const res = await getOpenfort().transactionIntents.create({
       account: c.options.account,
       chainId: c.options.chainId,
       interactions,
@@ -2222,15 +2209,15 @@ transactions.command("create", {
 });
 transactions.command("get", {
   description: "Get a transaction intent by ID.",
-  args: z10.object({
-    id: z10.string().describe("Transaction intent ID (tin_...)")
+  args: z9.object({
+    id: z9.string().describe("Transaction intent ID (tin_...)")
   }),
   examples: [
     { args: { id: "tin_1a2b3c4d" }, description: "Get transaction status and receipt" }
   ],
   output: transactionIntentItem,
   async run(c) {
-    const t = await c.var.openfort.transactionIntents.get(c.args.id);
+    const t = await getOpenfort().transactionIntents.get(c.args.id);
     return c.ok({
       id: t.id,
       createdAt: t.createdAt,
@@ -2246,12 +2233,12 @@ transactions.command("get", {
 });
 transactions.command("sign", {
   description: "Sign and broadcast a transaction intent.",
-  args: z10.object({
-    id: z10.string().describe("Transaction intent ID (tin_...)")
+  args: z9.object({
+    id: z9.string().describe("Transaction intent ID (tin_...)")
   }),
-  options: z10.object({
-    signature: z10.string().describe("Hex signature"),
-    optimistic: z10.boolean().optional().describe("Return before on-chain confirmation")
+  options: z9.object({
+    signature: z9.string().describe("Hex signature"),
+    optimistic: z9.boolean().optional().describe("Return before on-chain confirmation")
   }),
   examples: [
     { args: { id: "tin_1a2b3c4d" }, options: { signature: "0xabcd1234..." }, description: "Sign and broadcast a transaction" },
@@ -2259,7 +2246,7 @@ transactions.command("sign", {
   ],
   output: transactionIntentItem,
   async run(c) {
-    const res = await c.var.openfort.transactionIntents.signature(c.args.id, {
+    const res = await getOpenfort().transactionIntents.signature(c.args.id, {
       signature: c.options.signature,
       optimistic: c.options.optimistic
     });
@@ -2288,11 +2275,11 @@ transactions.command("sign", {
 });
 transactions.command("estimate", {
   description: "Estimate gas cost for a transaction.",
-  options: z10.object({
-    account: z10.string().describe("Account ID (acc_...)"),
-    chainId: z10.number().describe("Chain ID"),
-    interactions: z10.string().describe("Interactions as JSON"),
-    policy: z10.string().optional().describe("Fee sponsorship ID (pol_...)")
+  options: z9.object({
+    account: z9.string().describe("Account ID (acc_...)"),
+    chainId: z9.number().describe("Chain ID"),
+    interactions: z9.string().describe("Interactions as JSON"),
+    policy: z9.string().optional().describe("Fee sponsorship ID (pol_...)")
   }),
   examples: [
     {
@@ -2300,16 +2287,16 @@ transactions.command("estimate", {
       description: "Estimate gas for a USDC transfer on Polygon"
     }
   ],
-  output: z10.object({
-    estimatedTXGas: z10.string(),
-    estimatedTXGasFee: z10.string(),
-    estimatedTXGasFeeUSD: z10.string(),
-    estimatedTXGasFeeToken: z10.string().optional(),
-    gasPrice: z10.string()
+  output: z9.object({
+    estimatedTXGas: z9.string(),
+    estimatedTXGasFee: z9.string(),
+    estimatedTXGasFeeUSD: z9.string(),
+    estimatedTXGasFeeToken: z9.string().optional(),
+    gasPrice: z9.string()
   }),
   async run(c) {
     const interactions = JSON.parse(c.options.interactions);
-    const res = await c.var.openfort.transactionIntents.estimateCost({
+    const res = await getOpenfort().transactionIntents.estimateCost({
       account: c.options.account,
       chainId: c.options.chainId,
       interactions,
@@ -2326,21 +2313,19 @@ transactions.command("estimate", {
 });
 
 // src/commands/embedded-wallet.ts
-import { Cli as Cli9, z as z11, Errors as Errors2 } from "incur";
-var SHIELD_API_URL = OPENFORT_SHIELD_URL;
-var embeddedWallet = Cli9.create("embedded-wallet", {
-  description: "Configure embedded wallet (Shield) API keys.",
-  vars: varsSchema
+import { Cli as Cli10, z as z10, Errors } from "incur";
+var embeddedWallet = Cli10.create("embedded-wallet", {
+  description: "Configure embedded wallet (Shield) API keys."
 });
 embeddedWallet.command("setup", {
   description: "Generate and register embedded wallet (Shield) API keys.",
-  options: z11.object({
-    project: z11.string().optional().describe("Project ID (pro_...). Defaults to OPENFORT_PROJECT_ID env var.")
+  options: z10.object({
+    project: z10.string().optional().describe("Project ID (pro_...). Defaults to OPENFORT_PROJECT_ID env var.")
   }),
   alias: { project: "p" },
-  output: z11.object({
-    message: z11.string(),
-    credentialsPath: z11.string()
+  output: z10.object({
+    message: z10.string(),
+    credentialsPath: z10.string()
   }),
   examples: [
     {
@@ -2352,23 +2337,23 @@ embeddedWallet.command("setup", {
   async run(c) {
     const publishableKey = process.env.OPENFORT_PUBLISHABLE_KEY;
     if (!publishableKey) {
-      throw new Errors2.IncurError({
+      throw new Errors.IncurError({
         code: "MISSING_PUBLISHABLE_KEY",
         message: "OPENFORT_PUBLISHABLE_KEY environment variable is required to create Shield keys.",
         hint: "Run: openfort login"
       });
     }
-    const apiKey = process.env.OPENFORT_API_KEY;
+    const apiKey = requireApiKey();
     const environment = apiKey.startsWith("sk_live_") ? "live" : "test";
     const projectId = c.options.project || process.env.OPENFORT_PROJECT_ID;
     if (!projectId) {
-      throw new Errors2.IncurError({
+      throw new Errors.IncurError({
         code: "MISSING_PROJECT_ID",
         message: "Project ID is required. Pass --project or set OPENFORT_PROJECT_ID.",
         hint: "Run: openfort login"
       });
     }
-    const registerRes = await fetch(`${SHIELD_API_URL}/register`, {
+    const registerRes = await fetch(`${OPENFORT_SHIELD_URL}/register`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -2382,7 +2367,7 @@ embeddedWallet.command("setup", {
     });
     if (!registerRes.ok) {
       const text = await registerRes.text();
-      throw new Errors2.IncurError({
+      throw new Errors.IncurError({
         code: "SHIELD_REGISTER_FAILED",
         message: `Shield registration failed: ${text}`,
         retryable: true
@@ -2390,7 +2375,7 @@ embeddedWallet.command("setup", {
     }
     const shieldData = await registerRes.json();
     if (shieldData.error) {
-      throw new Errors2.IncurError({
+      throw new Errors.IncurError({
         code: "SHIELD_REGISTER_ERROR",
         message: `Shield registration error: ${shieldData.error}`
       });
@@ -2406,7 +2391,7 @@ embeddedWallet.command("setup", {
       });
       if (!res.ok) {
         const text = await res.text();
-        throw new Errors2.IncurError({
+        throw new Errors.IncurError({
           code: "PERSIST_KEY_FAILED",
           message: `Failed to persist ${type} key: ${text}`,
           retryable: true
@@ -2417,7 +2402,7 @@ embeddedWallet.command("setup", {
       persistKey("pk_shield", shieldData.api_key),
       persistKey("sk_shield", shieldData.api_secret)
     ]);
-    const linkRes = await fetch(`${SHIELD_API_URL}/project/providers`, {
+    const linkRes = await fetch(`${OPENFORT_SHIELD_URL}/project/providers`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -2434,7 +2419,7 @@ embeddedWallet.command("setup", {
     });
     if (!linkRes.ok) {
       const text = await linkRes.text();
-      throw new Errors2.IncurError({
+      throw new Errors.IncurError({
         code: "SHIELD_LINK_FAILED",
         message: `Failed to link Openfort provider to Shield: ${text}`,
         retryable: true
@@ -2461,49 +2446,48 @@ embeddedWallet.command("setup", {
 });
 
 // src/commands/users.ts
-import { Cli as Cli10, z as z12 } from "incur";
-var userItem = z12.object({
-  id: z12.string(),
-  createdAt: z12.number(),
-  name: z12.string(),
-  email: z12.string().nullable(),
-  emailVerified: z12.boolean(),
-  phoneNumber: z12.string().nullable(),
-  phoneNumberVerified: z12.boolean(),
-  isAnonymous: z12.boolean().optional(),
-  linkedAccounts: z12.array(z12.object({
-    provider: z12.string(),
-    createdAt: z12.number(),
-    updatedAt: z12.number(),
-    accountId: z12.string().optional(),
-    chainType: z12.string().optional(),
-    connectorType: z12.string().optional(),
-    walletClientType: z12.string().optional()
+import { Cli as Cli11, z as z11 } from "incur";
+var userItem = z11.object({
+  id: z11.string(),
+  createdAt: z11.number(),
+  name: z11.string(),
+  email: z11.string().nullable(),
+  emailVerified: z11.boolean(),
+  phoneNumber: z11.string().nullable(),
+  phoneNumberVerified: z11.boolean(),
+  isAnonymous: z11.boolean().optional(),
+  linkedAccounts: z11.array(z11.object({
+    provider: z11.string(),
+    createdAt: z11.number(),
+    updatedAt: z11.number(),
+    accountId: z11.string().optional(),
+    chainType: z11.string().optional(),
+    connectorType: z11.string().optional(),
+    walletClientType: z11.string().optional()
   }))
 });
-var users = Cli10.create("users", {
-  description: "Manage authenticated users.",
-  vars: varsSchema
+var users = Cli11.create("users", {
+  description: "Manage authenticated users."
 });
 users.command("list", {
   description: "List users.",
-  options: z12.object({
-    limit: z12.number().optional().describe("Max results"),
-    skip: z12.number().optional().describe("Offset"),
-    email: z12.string().optional().describe("Filter by email"),
-    name: z12.string().optional().describe("Filter by name")
+  options: z11.object({
+    limit: z11.number().optional().describe("Max results"),
+    skip: z11.number().optional().describe("Offset"),
+    email: z11.string().optional().describe("Filter by email"),
+    name: z11.string().optional().describe("Filter by name")
   }),
   alias: { limit: "l" },
   examples: [
     { description: "List all users" },
     { options: { email: "user@example.com" }, description: "Find user by email" }
   ],
-  output: z12.object({
-    data: z12.array(userItem),
-    total: z12.number()
+  output: z11.object({
+    data: z11.array(userItem),
+    total: z11.number()
   }),
   async run(c) {
-    const res = await c.var.openfort.iam.users.list({
+    const res = await getOpenfort().iam.users.list({
       limit: c.options.limit,
       skip: c.options.skip,
       email: c.options.email,
@@ -2527,15 +2511,15 @@ users.command("list", {
 });
 users.command("get", {
   description: "Get a user by ID.",
-  args: z12.object({
-    id: z12.string().describe("User ID (usr_...)")
+  args: z11.object({
+    id: z11.string().describe("User ID (usr_...)")
   }),
   examples: [
     { args: { id: "usr_1a2b3c4d" }, description: "Get user profile and linked accounts" }
   ],
   output: userItem,
   async run(c) {
-    const u = await c.var.openfort.iam.users.get(c.args.id);
+    const u = await getOpenfort().iam.users.get(c.args.id);
     return c.ok({
       id: u.id,
       createdAt: u.createdAt,
@@ -2551,25 +2535,25 @@ users.command("get", {
 });
 users.command("delete", {
   description: "Delete a user.",
-  args: z12.object({
-    id: z12.string().describe("User ID (usr_...)")
+  args: z11.object({
+    id: z11.string().describe("User ID (usr_...)")
   }),
   examples: [
     { args: { id: "usr_1a2b3c4d" }, description: "Delete a user and their accounts" }
   ],
-  output: z12.object({
-    id: z12.string(),
-    deleted: z12.boolean()
+  output: z11.object({
+    id: z11.string(),
+    deleted: z11.boolean()
   }),
   async run(c) {
-    const res = await c.var.openfort.iam.users.delete(c.args.id);
+    const res = await getOpenfort().iam.users.delete(c.args.id);
     return c.ok({ id: res.id, deleted: res.deleted });
   }
 });
 
 // src/commands/backend-wallet.ts
 import { randomBytes as randomBytes2, subtle } from "crypto";
-import { Cli as Cli11, z as z13, Errors as Errors3 } from "incur";
+import { Cli as Cli12, z as z12, Errors as Errors2 } from "incur";
 function arrayBufferToBase64(buffer) {
   return Buffer.from(buffer).toString("base64");
 }
@@ -2577,7 +2561,7 @@ function arrayBufferToBase64Url(buffer) {
   return Buffer.from(buffer).toString("base64url");
 }
 function stringToArrayBuffer(str) {
-  return new TextEncoder().encode(str).buffer;
+  return new TextEncoder().encode(str);
 }
 function formatPEMBody(base64) {
   return base64.match(/.{1,64}/g)?.join("\n") || base64;
@@ -2585,9 +2569,10 @@ function formatPEMBody(base64) {
 function sortObjectKeys(obj) {
   if (obj === null || typeof obj !== "object") return obj;
   if (Array.isArray(obj)) return obj.map(sortObjectKeys);
+  const record = obj;
   const sorted = {};
-  for (const key of Object.keys(obj).sort()) {
-    sorted[key] = sortObjectKeys(obj[key]);
+  for (const key of Object.keys(record).sort()) {
+    sorted[key] = sortObjectKeys(record[key]);
   }
   return sorted;
 }
@@ -2639,15 +2624,14 @@ async function signWalletAuthJwt(privateKey, method, path, body) {
   );
   return `${signingInput}.${arrayBufferToBase64Url(signature)}`;
 }
-var backendWallet = Cli11.create("backend-wallet", {
-  description: "Configure backend wallet signing keys.",
-  vars: varsSchema
+var backendWallet = Cli12.create("backend-wallet", {
+  description: "Configure backend wallet signing keys."
 });
 backendWallet.command("setup", {
   description: "Generate and register backend wallet signing keys (ECDSA P-256).",
-  output: z13.object({
-    message: z13.string(),
-    credentialsPath: z13.string()
+  output: z12.object({
+    message: z12.string(),
+    credentialsPath: z12.string()
   }),
   examples: [
     {
@@ -2656,7 +2640,7 @@ backendWallet.command("setup", {
   ],
   hint: 'Requires OPENFORT_API_KEY. Run "openfort login" first.',
   async run(c) {
-    const apiKey = process.env.OPENFORT_API_KEY;
+    const apiKey = requireApiKey();
     const { publicKey, privateKey, privateKeyCrypto } = await generateKeyPair();
     const publicKeyPEM = `-----BEGIN PUBLIC KEY-----
 ${publicKey}
@@ -2678,7 +2662,7 @@ ${publicKey}
     });
     if (!registerRes.ok) {
       const text = await registerRes.text();
-      throw new Errors3.IncurError({
+      throw new Errors2.IncurError({
         code: "REGISTER_SECRET_FAILED",
         message: `Failed to register wallet secret: ${text}`,
         retryable: true
@@ -2694,7 +2678,7 @@ ${publicKey}
     });
     if (!storeRes.ok) {
       const text = await storeRes.text();
-      throw new Errors3.IncurError({
+      throw new Errors2.IncurError({
         code: "STORE_KEY_FAILED",
         message: `Failed to store wallet key reference: ${text}`,
         retryable: true
@@ -2719,10 +2703,10 @@ ${publicKey}
 });
 backendWallet.command("revoke", {
   description: "Revoke the current backend wallet signing secret.",
-  output: z13.object({
-    keyId: z13.string(),
-    revoked: z13.boolean(),
-    revokedAt: z13.number()
+  output: z12.object({
+    keyId: z12.string(),
+    revoked: z12.boolean(),
+    revokedAt: z12.number()
   }),
   examples: [
     {
@@ -2731,11 +2715,11 @@ backendWallet.command("revoke", {
   ],
   hint: 'Requires OPENFORT_WALLET_KEY_ID and OPENFORT_WALLET_SECRET. Run "openfort backend-wallet setup" first.',
   async run(c) {
-    const apiKey = process.env.OPENFORT_API_KEY;
+    const apiKey = requireApiKey();
     const keyId = process.env.OPENFORT_WALLET_KEY_ID;
     const privateKeyBase64 = process.env.OPENFORT_WALLET_SECRET;
     if (!keyId || !privateKeyBase64) {
-      throw new Errors3.IncurError({
+      throw new Errors2.IncurError({
         code: "MISSING_WALLET_KEY",
         message: "OPENFORT_WALLET_KEY_ID and OPENFORT_WALLET_SECRET must be set. Run `backend-wallet setup` first.",
         hint: "Run: openfort backend-wallet setup"
@@ -2756,7 +2740,7 @@ backendWallet.command("revoke", {
     });
     if (!res.ok) {
       const text = await res.text();
-      throw new Errors3.IncurError({
+      throw new Errors2.IncurError({
         code: "REVOKE_SECRET_FAILED",
         message: `Failed to revoke wallet secret: ${text}`,
         retryable: true
@@ -2768,9 +2752,9 @@ backendWallet.command("revoke", {
 });
 backendWallet.command("rotate", {
   description: "Rotate backend wallet signing secret (generates new ECDSA P-256 key pair).",
-  output: z13.object({
-    message: z13.string(),
-    credentialsPath: z13.string()
+  output: z12.object({
+    message: z12.string(),
+    credentialsPath: z12.string()
   }),
   examples: [
     {
@@ -2779,7 +2763,7 @@ backendWallet.command("rotate", {
   ],
   hint: 'Requires OPENFORT_API_KEY. Run "openfort login" first.',
   async run(c) {
-    const apiKey = process.env.OPENFORT_API_KEY;
+    const apiKey = requireApiKey();
     const { publicKey, privateKey, privateKeyCrypto } = await generateKeyPair();
     const newPublicKeyPEM = `-----BEGIN PUBLIC KEY-----
 ${publicKey}
@@ -2801,7 +2785,7 @@ ${publicKey}
     });
     if (!rotateRes.ok) {
       const text = await rotateRes.text();
-      throw new Errors3.IncurError({
+      throw new Errors2.IncurError({
         code: "ROTATE_SECRET_FAILED",
         message: `Failed to rotate wallet secret: ${text}`,
         retryable: true
@@ -2817,7 +2801,7 @@ ${publicKey}
     });
     if (!storeRes.ok) {
       const text = await storeRes.text();
-      throw new Errors3.IncurError({
+      throw new Errors2.IncurError({
         code: "STORE_KEY_FAILED",
         message: `Failed to store rotated wallet key reference: ${text}`,
         retryable: true
@@ -2832,22 +2816,21 @@ ${publicKey}
 });
 
 // src/commands/message.ts
-import { Cli as Cli12, z as z14 } from "incur";
+import { Cli as Cli13, z as z13 } from "incur";
 import { keccak256, toBytes } from "viem";
-var message = Cli12.create("message", {
-  description: "Message utilities.",
-  vars: varsSchema
+var message = Cli13.create("message", {
+  description: "Message utilities."
 });
 message.command("hash", {
   description: "Hash a message using keccak256.",
-  args: z14.object({
-    message: z14.string().describe("The message to hash")
+  args: z13.object({
+    message: z13.string().describe("The message to hash")
   }),
   examples: [
     { args: { message: "Hello World" }, description: "Hash a message" }
   ],
-  output: z14.object({
-    hash: z14.string()
+  output: z13.object({
+    hash: z13.string()
   }),
   async run(c) {
     const hash = keccak256(toBytes(c.args.message));
@@ -2856,17 +2839,15 @@ message.command("hash", {
 });
 
 // src/cli.ts
-var pkg = JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf-8"));
-var cli = Cli13.create("openfort", {
+var pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+var cli = Cli14.create("openfort", {
   version: pkg.version,
-  aliases: ["of"],
   description: "Openfort CLI \u2014 manage wallets, policies, and transactions from the terminal.",
-  vars: varsSchema,
-  env: z15.object({
-    OPENFORT_API_KEY: z15.string().optional().describe("Openfort secret API key (sk_test_... or sk_live_...)"),
-    OPENFORT_WALLET_SECRET: z15.string().optional().describe("Wallet encryption secret"),
-    OPENFORT_PUBLISHABLE_KEY: z15.string().optional().describe("Publishable key for client-side ops"),
-    OPENFORT_BASE_URL: z15.string().optional().describe("Custom API base URL")
+  env: z14.object({
+    OPENFORT_API_KEY: z14.string().optional().describe("Openfort secret API key (sk_test_... or sk_live_...)"),
+    OPENFORT_WALLET_SECRET: z14.string().optional().describe("Wallet encryption secret"),
+    OPENFORT_PUBLISHABLE_KEY: z14.string().optional().describe("Publishable key for client-side ops"),
+    OPENFORT_BASE_URL: z14.string().optional().describe("Custom API base URL")
   }),
   sync: {
     depth: 2,
@@ -2883,28 +2864,7 @@ var cli = Cli13.create("openfort", {
     agents: ["claude-code", "cursor", "amp"]
   }
 });
-cli.command("login", loginConfig);
-cli.use(async (c, next) => {
-  const isLoginCommand = process.argv.slice(2).some((arg) => arg === "login");
-  if (isLoginCommand) {
-    await next();
-    return;
-  }
-  const apiKey = process.env.OPENFORT_API_KEY;
-  if (!apiKey) {
-    throw new Errors4.IncurError({
-      code: "MISSING_API_KEY",
-      message: "OPENFORT_API_KEY environment variable is required.",
-      hint: "Run: openfort login"
-    });
-  }
-  c.set("openfort", new Openfort(apiKey, {
-    walletSecret: process.env.OPENFORT_WALLET_SECRET,
-    publishableKey: process.env.OPENFORT_PUBLISHABLE_KEY,
-    basePath: API_BASE_URL
-  }));
-  await next();
-});
+cli.command(login);
 cli.command(accounts).command(contracts).command(paymasters).command(policies).command(embeddedWallet).command(sponsorship).command(sessions).command(subscriptions).command(transactions).command(users).command(backendWallet).command(message);
 var cli_default = cli;
 export {