@keypro/cli 0.1.0 → 0.1.4

package/dist/index.js

@@ -133,6 +133,15 @@ var KeyproClient = class {
   orderKeys(id) {
     return this.request("GET", `/api/v1/orders/${id}/keys`);
   }
+  orderCancel(id) {
+    return this.request("POST", `/api/v1/orders/${id}/cancel`);
+  }
+  orderPaymentPreview(id, newMethod) {
+    return this.request("POST", `/api/v1/orders/${id}/payment/preview`, { newMethod });
+  }
+  orderChangePayment(id, body) {
+    return this.request("POST", `/api/v1/orders/${id}/payment`, body);
+  }
   licenseKeys() {
     return this.request("GET", "/api/v1/license-keys");
   }
@@ -179,6 +188,9 @@ var KeyproClient = class {
     if (type) qs.set("type", type);
     return this.request("GET", `/api/v1/shipping/parcelshops?${qs}`);
   }
+  exchangeRate() {
+    return this.request("GET", "/api/v1/exchange-rate");
+  }
 };
 function createClient(opts) {
   return new KeyproClient(opts);
@@ -244,13 +256,15 @@ utmutato AI-agenteknek (Claude Code, Codex) szol.
 
 ## Setup
 
-1. The user needs a KeyPro account (approved reseller) and an API key.
-   Either run \`keypro login\` (interactive email + password, stores a fresh
-   key) or create a key on the website under "API kulcsok" and store it:
-   - env var: KEYPRO_API_KEY=kp_live_... (recommended for agents)
-   - or config file: ~/.config/keypro/config.json
-2. API base URL: production is the default. For the dev site use
-   KEYPRO_API_BASE=https://dev.keypro.hu or \`keypro config set api-base ...\`.
+1. The user needs a KeyPro account (approved reseller) and an API key. Easiest:
+   \`keypro setup\` - interactive wizard (asks the server, then API key [default]
+   or email+password). Alternatives:
+   - \`keypro login\` (email + password, mints + stores a fresh key)
+   - a key made on the website under "API kulcsok", stored via
+     \`keypro config set api-key kp_live_...\`, the KEYPRO_API_KEY env var
+     (recommended for agents), or ~/.config/keypro/config.json
+2. API base URL: production is the default. For the dev site use \`keypro setup\`,
+   KEYPRO_API_BASE=https://dev.keypro.hu, or \`keypro config set api-base ...\`.
 3. Verify with: \`keypro whoami --json\`
 
 ## Output contract
@@ -296,7 +310,13 @@ for gls_parcelshop also \`--parcelshop <ID>\`
 ## Queries
 
 - \`keypro products search <query>\` / \`keypro products get <sku|id>\`
+- \`keypro rate\` - current EUR/HUF rate the shop uses (net prices are stored in
+  EUR; HUF price = round(EUR * rate) to whole forint, EUR to 2 decimals)
 - \`keypro order list [--status <status>]\` / \`keypro order get <id>\`
+- \`keypro order cancel <id>\` - cancel an UNPAID order (bacs / stripe / cod;
+  NOT 8-day cheque or already-paid orders)
+- \`keypro order change-payment <id> --payment <method> [--yes]\` - change an
+  unpaid order's payment method (preview first; wallet/stripe move money)
 - \`keypro keys list [--order <id>]\` - delivered license keys
 - \`keypro invoices list [--order <id>]\` / \`keypro invoices get <id>\`
   (each invoice has a public \`downloadUrl\` PDF link)
@@ -309,7 +329,7 @@ for gls_parcelshop also \`--parcelshop <ID>\`
 
 Register the CLI as a native MCP toolset (recommended for Claude Code):
 
-    claude mcp add keypro -- keypro mcp
+    claude mcp add keypro -- npx -y @keypro/cli mcp
 
 Auth comes from KEYPRO_API_KEY / config; there is no login tool over MCP.
 The keypro_order_create tool requires the confirmToken from
@@ -431,6 +451,8 @@ function eurFmt(value) {
 // src/mcp.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/mcp-tools.ts
 import { z } from "zod";
 var addressShape = z.object({
   firstName: z.string().optional(),
@@ -486,8 +508,7 @@ async function run(fn) {
     return errorResult(err);
   }
 }
-async function runMcpServer(client) {
-  const server = new McpServer({ name: "keypro", version: "0.1.0" });
+function registerKeyproTools(server, client) {
   server.registerTool(
     "keypro_whoami",
     {
@@ -496,6 +517,14 @@ async function runMcpServer(client) {
     },
     () => run(() => client.me())
   );
+  server.registerTool(
+    "keypro_exchange_rate",
+    {
+      description: "Current EUR->HUF exchange rate the shop uses and displays (ECB daily reference + 3% markup). Product net prices are stored in EUR; the HUF price = round(EUR * rate) to whole forint (EUR shown with 2 decimals). Call this to price products accurately in both currencies.",
+      inputSchema: {}
+    },
+    () => run(() => client.exchangeRate())
+  );
   server.registerTool(
     "keypro_products_search",
     {
@@ -574,6 +603,44 @@ async function runMcpServer(client) {
     },
     (args) => run(() => client.orderKeys(args.orderId))
   );
+  server.registerTool(
+    "keypro_order_cancel",
+    {
+      description: "Cancel an UNPAID order. Only orders awaiting payment can be cancelled: bacs (bank transfer / proforma), stripe (card checkout not completed), and cod (cash on delivery, still processing). 8-day-deferred (cheque) and already-paid orders CANNOT be cancelled. Idempotent.",
+      inputSchema: { orderId: z.number().int().positive() }
+    },
+    (args) => run(() => client.orderCancel(args.orderId))
+  );
+  server.registerTool(
+    "keypro_order_change_payment_preview",
+    {
+      description: "Preview changing an UNPAID order's payment method (only on-hold=bacs / pending=stripe orders qualify). Returns the recomputed totals for the new method (cheque adds +5%, cod adds a fixed fee; bacs/wallet/stripe add none) and a confirmToken. ALWAYS show the new totals to the user, then call keypro_order_change_payment.",
+      inputSchema: {
+        orderId: z.number().int().positive(),
+        newMethod: z.enum(["bacs", "cheque", "cod", "wallet", "stripe"])
+      }
+    },
+    (args) => run(() => client.orderPaymentPreview(args.orderId, args.newMethod))
+  );
+  server.registerTool(
+    "keypro_order_change_payment",
+    {
+      description: "Change an UNPAID order's payment method. Requires the confirmToken from keypro_order_change_payment_preview. wallet debits the KEP balance now and fulfils; cheque/cod add their fee and fulfil (final invoice + keys where due); bacs issues a proforma (awaits transfer); stripe charges the saved card or returns a payment link in payment.paymentUrl. Pass cardId (pm_...) to pick a specific card for stripe.",
+      inputSchema: {
+        orderId: z.number().int().positive(),
+        newMethod: z.enum(["bacs", "cheque", "cod", "wallet", "stripe"]),
+        confirmToken: z.string().describe("Token from keypro_order_change_payment_preview"),
+        cardId: z.string().optional().describe("Saved card id (pm_...) for stripe")
+      }
+    },
+    (args) => run(
+      () => client.orderChangePayment(args.orderId, {
+        newMethod: args.newMethod,
+        confirmToken: args.confirmToken,
+        cardId: args.cardId
+      })
+    )
+  );
   server.registerTool(
     "keypro_license_keys",
     {
@@ -648,15 +715,72 @@ async function runMcpServer(client) {
     },
     (args) => run(() => client.parcelshopsSearch(args.q, args.type))
   );
+}
+
+// src/mcp.ts
+async function runMcpServer(client) {
+  const server = new McpServer({ name: "keypro", version: "0.1.4" });
+  registerKeyproTools(server, client);
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
 
+// src/prompt.ts
+var ESC = String.fromCharCode(27);
+var BRACKETED_PASTE = new RegExp(ESC + "\\[20[01]~", "g");
+function consumeHiddenChunk(current, chunk) {
+  const s = chunk.replace(BRACKETED_PASTE, "");
+  let value = current;
+  for (const ch of s) {
+    const code = ch.charCodeAt(0);
+    if (code === 10 || code === 13 || code === 4) {
+      return { value, status: "submit" };
+    }
+    if (code === 3) {
+      return { value, status: "cancel" };
+    }
+    if (code === 127 || code === 8) {
+      value = value.slice(0, -1);
+    } else {
+      value += ch;
+    }
+  }
+  return { value, status: "typing" };
+}
+async function promptHidden(question) {
+  process.stdout.write(question);
+  return new Promise((resolve, reject) => {
+    const stdin = process.stdin;
+    let value = "";
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY) stdin.setRawMode(true);
+    stdin.resume();
+    const stop = () => {
+      stdin.off("data", onData);
+      if (stdin.isTTY) stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+      process.stdout.write("\n");
+    };
+    const onData = (chunk) => {
+      const res = consumeHiddenChunk(value, chunk.toString("utf8"));
+      value = res.value;
+      if (res.status === "submit") {
+        stop();
+        resolve(value);
+      } else if (res.status === "cancel") {
+        stop();
+        reject(new Error("Megszak\xEDtva."));
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+
 // src/index.ts
 var program = new Command();
 program.name("keypro").description(
   "KeyPro.hu B2B licencshop CLI - rendeles, szamlak, term\xE9kkulcsok, profil. AI-agent utmutato: keypro agent-docs"
-).version("0.1.0").option("--json", "gepi (JSON) kimenet a stdout-ra", false).option("--api-key <kulcs>", "API kulcs (felulirja az env/config erteket)").option("--api-base <url>", "API kiszolgalo cime (alap: eles bolt)").hook("preAction", (thisCommand) => {
+).version("0.1.4").option("--json", "gepi (JSON) kimenet a stdout-ra", false).option("--api-key <kulcs>", "API kulcs (felulirja az env/config erteket)").option("--api-base <url>", "API kiszolgalo cime (alap: eles bolt)").hook("preAction", (thisCommand) => {
   setJsonMode(Boolean(thisCommand.optsWithGlobals().json));
 });
 function resolved(cmd) {
@@ -673,36 +797,6 @@ function clientFor(cmd, requireKey = true) {
   }
   return createClient({ apiBase: cfg.apiBase, apiKey: cfg.apiKey });
 }
-async function promptHidden(question) {
-  process.stdout.write(question);
-  return new Promise((resolve, reject) => {
-    const stdin = process.stdin;
-    let value = "";
-    const wasRaw = stdin.isRaw;
-    if (stdin.isTTY) stdin.setRawMode(true);
-    stdin.resume();
-    const onData = (chunk) => {
-      const ch = chunk.toString("utf8");
-      if (ch === "\n" || ch === "\r" || ch === "") {
-        stdin.off("data", onData);
-        if (stdin.isTTY) stdin.setRawMode(wasRaw ?? false);
-        stdin.pause();
-        process.stdout.write("\n");
-        resolve(value);
-      } else if (ch === "") {
-        stdin.off("data", onData);
-        if (stdin.isTTY) stdin.setRawMode(wasRaw ?? false);
-        process.stdout.write("\n");
-        reject(new Error("Megszak\xEDtva."));
-      } else if (ch === "\x7F" || ch === "\b") {
-        value = value.slice(0, -1);
-      } else {
-        value += ch;
-      }
-    };
-    stdin.on("data", onData);
-  });
-}
 async function promptText(question) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   try {
@@ -766,6 +860,61 @@ program.command("whoami").description("a bejelentkezett fiok adatai").action(asy
     fail(err);
   }
 });
+program.command("setup").description("interaktiv beallitas: szerver + hitelesites (API kulcs vagy jelszo)").action(async (_opts, cmd) => {
+  try {
+    const current = resolveConfig({});
+    const baseInput = (await promptText(`API szerver [${current.apiBase}]: `)).trim();
+    const apiBase = (baseInput || current.apiBase).replace(/\/$/, "");
+    if (!/^https?:\/\//.test(apiBase)) {
+      usageError("Az API szerver http(s) URL kell legyen, pl. https://keypro.hu");
+    }
+    const method = (await promptText(
+      "Hiteles\xEDt\xE9s - [1] API kulcs (aj\xE1nlott)  [2] Email + jelsz\xF3  [1]: "
+    )).trim();
+    let apiKey;
+    if (method === "2") {
+      const email = await promptText("Email: ");
+      const password = await promptHidden("Jelsz\xF3: ");
+      const result = await createClient({ apiBase }).login(
+        email,
+        password,
+        "CLI setup"
+      );
+      apiKey = result.token;
+    } else {
+      const key2 = (await promptHidden("API kulcs (kp_live_...): ")).trim();
+      if (!key2.startsWith("kp_live_")) {
+        usageError(
+          "\xC9rv\xE9nytelen kulcs form\xE1tum (kp_live_...). Kulcsot a weben az /api-keys oldalon k\xE9sz\xEDthetsz."
+        );
+      }
+      apiKey = key2;
+    }
+    writeConfig({ apiBase, apiKey });
+    const me = await createClient({ apiBase, apiKey }).me();
+    output(
+      {
+        apiBase,
+        configPath: configPath(),
+        account: { id: me.id, email: me.email, role: me.role }
+      },
+      () => {
+        process.stdout.write(
+          `
+Be\xE1ll\xEDtva.
+  Szerver: ${apiBase}
+  Fi\xF3k:    ${me.email} (#${me.id}, ${me.role})
+  Config:  ${configPath()}
+
+Pr\xF3b\xE1ld ki: keypro whoami
+`
+        );
+      }
+    );
+  } catch (err) {
+    fail(err);
+  }
+});
 var config = program.command("config").description("CLI beallitasok");
 config.command("get").description("aktualis beallitasok").action((_opts, cmd) => {
   const cfg = resolved(cmd);
@@ -787,18 +936,29 @@ config.command("get").description("aktualis beallitasok").action((_opts, cmd) =>
     }
   );
 });
-config.command("set <kulcs> <ertek>").description("beallitas mentese (tamogatott kulcs: api-base)").action((key2, value) => {
-  if (key2 !== "api-base") {
-    usageError(`Ismeretlen be\xE1ll\xEDt\xE1s: ${key2}. T\xE1mogatott: api-base`);
+config.command("set <kulcs> <ertek>").description("beallitas mentese (tamogatott kulcs: api-base, api-key)").action((key2, value) => {
+  if (key2 === "api-base") {
+    if (!/^https?:\/\//.test(value)) {
+      usageError("Az api-base http(s) URL kell legyen, pl. https://keypro.hu");
+    }
+    const next = writeConfig({ apiBase: value.replace(/\/$/, "") });
+    output({ apiBase: next.apiBase }, () => {
+      process.stdout.write(`API c\xEDm be\xE1ll\xEDtva: ${next.apiBase}
+`);
+    });
+    return;
   }
-  if (!/^https?:\/\//.test(value)) {
-    usageError("Az api-base http(s) URL kell legyen, pl. https://keypro.hu");
+  if (key2 === "api-key") {
+    if (!value.startsWith("kp_live_")) {
+      usageError("\xC9rv\xE9nytelen kulcs form\xE1tum (kp_live_...).");
+    }
+    writeConfig({ apiKey: value });
+    output({ apiKeySet: true, configPath: configPath() }, () => {
+      process.stdout.write("API kulcs elmentve a configba.\n");
+    });
+    return;
   }
-  const next = writeConfig({ apiBase: value.replace(/\/$/, "") });
-  output({ apiBase: next.apiBase }, () => {
-    process.stdout.write(`API c\xEDm be\xE1ll\xEDtva: ${next.apiBase}
-`);
-  });
+  usageError(`Ismeretlen be\xE1ll\xEDt\xE1s: ${key2}. T\xE1mogatott: api-base, api-key`);
 });
 var key = program.command("key").description("API kulcsok kezelese");
 key.command("list").description("a fiok API kulcsai").action(async (_opts, cmd) => {
@@ -1154,6 +1314,75 @@ order.command("get <id>").description("rendeles reszletei").action(async (id, _o
     fail(err);
   }
 });
+order.command("cancel <id>").description("fizetetlen rendeles visszamondasa (torlese)").action(async (id, _opts, cmd) => {
+  try {
+    const result = await clientFor(cmd).orderCancel(Number(id));
+    output(result, () => {
+      const o = result.order;
+      printKV([
+        ["Rendel\xE9s", `#${o.number} (id: ${o.id})`],
+        ["\xC1llapot", String(o.statusLabel)]
+      ]);
+      process.stdout.write(`
+${result.note}
+`);
+    });
+  } catch (err) {
+    fail(err);
+  }
+});
+order.command("change-payment <id>").description("fizetetlen rendeles fizetesi modjanak modositasa (elonezet; --yes nelkul nem valt)").requiredOption("--payment <mod>", "uj fizetesi mod: bacs|cheque|cod|wallet|stripe").option("--card <pm_id>", "mentett kartya id (stripe-hoz, opcionalis)").option("--yes", "a valtas tenyleges vegrehajtasa", false).action(
+  async (id, opts, cmd) => {
+    try {
+      const client = clientFor(cmd);
+      const preview = await client.orderPaymentPreview(Number(id), opts.payment);
+      if (!opts.yes) {
+        output(
+          { preview, hint: "Add hozz\xE1 a --yes kapcsol\xF3t a m\xF3dos\xEDt\xE1shoz." },
+          () => {
+            printKV([
+              ["Jelenlegi m\xF3d", preview.currentMethod],
+              ["\xDAj m\xF3d", preview.newMethod],
+              ["\xDAj nett\xF3", eurFmt(preview.newTotals.netTotalEur)],
+              ["\xDAj brutt\xF3", eurFmt(preview.newTotals.grossTotalEur)],
+              ["D\xEDj-v\xE1ltoz\xE1s (brutt\xF3)", eurFmt(preview.feeDeltaEur)],
+              [
+                "KEP fedezet",
+                preview.wallet ? preview.wallet.sufficient ? "el\xE9g" : "NEM el\xE9g" : null
+              ]
+            ]);
+            process.stdout.write(
+              "\nEz csak el\u0151n\xE9zet. Add hozz\xE1 a --yes kapcsol\xF3t a m\xF3dos\xEDt\xE1shoz.\n"
+            );
+          }
+        );
+        process.exit(1);
+      }
+      const result = await client.orderChangePayment(Number(id), {
+        newMethod: opts.payment,
+        confirmToken: preview.confirmToken,
+        cardId: opts.card
+      });
+      output(result, () => {
+        const o = result.order;
+        const p = result.payment;
+        printKV([
+          ["Rendel\xE9s", `#${o.number} (id: ${o.id})`],
+          ["\xC1llapot", String(o.statusLabel)],
+          ["Fizet\xE9si m\xF3d", String(o.paymentMethodLabel)],
+          ["Fizet\xE9s", String(p.note)],
+          ["Fizet\xE9si link", p.paymentUrl ? String(p.paymentUrl) : null],
+          [
+            "KEP egyenleg",
+            p.walletBalanceAfterEur !== void 0 ? eurFmt(Number(p.walletBalanceAfterEur)) : null
+          ]
+        ]);
+      });
+    } catch (err) {
+      fail(err);
+    }
+  }
+);
 var keysCmd = program.command("keys").description("term\xE9kkulcsok");
 keysCmd.command("list").description("kezbesitett term\xE9kkulcsok (osszes vagy egy rendelese)").option("--order <id>", "csak az adott rendeles kulcsai").action(async (opts, cmd) => {
   try {
@@ -1369,6 +1598,22 @@ profile.command("set <mezo=ertek...>").description(
     fail(err);
   }
 });
+program.command("rate").description("Aktu\xE1lis EUR/HUF \xE1rfolyam (amit a webshop haszn\xE1l \xE9s megjelen\xEDt)").action(async (_opts, cmd) => {
+  try {
+    const result = await clientFor(cmd).exchangeRate();
+    output(result, () => {
+      printKV([
+        ["EUR -> HUF", `${result.rate.toFixed(2)} Ft`],
+        ["ECB referencia (fel\xE1r n\xE9lk\xFCl)", `${result.referenceRate.toFixed(2)} Ft`],
+        ["Fel\xE1r", `${result.markupPct}%`],
+        ["1 HUF -> EUR", result.hufToEur.toFixed(6)],
+        ["Forr\xE1s", result.source]
+      ]);
+    });
+  } catch (err) {
+    fail(err);
+  }
+});
 var wallet = program.command("wallet").description("KEP egyenleg");
 wallet.action(async (_opts, cmd) => {
   try {

package/dist/mcp-tools.d.ts

@@ -0,0 +1,258 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+/**
+ * Vekony HTTP kliens a KeyPro /api/v1 vegpontokhoz (nativ fetch).
+ * Minden uzleti logika a szerveren el; itt csak a boritek ({ ok, data |
+ * error }) kibontasa es a hibak tipusositasa tortenik. A parancsok ES az
+ * MCP szerver is ezt a klienst hasznalja.
+ */
+declare class KeyproApiError extends Error {
+    status: number;
+    code: string;
+    details?: unknown | undefined;
+    constructor(status: number, code: string, message: string, details?: unknown | undefined);
+}
+interface OrderItemInput {
+    sku?: string;
+    productId?: number;
+    qty: number;
+}
+interface AddressInput {
+    firstName?: string;
+    lastName?: string;
+    company?: string;
+    address1?: string;
+    address2?: string;
+    city?: string;
+    postcode?: string;
+    state?: string;
+    country?: string;
+    email?: string;
+    phone?: string;
+}
+interface OrderRequestInput {
+    items: OrderItemInput[];
+    paymentMethod: "bacs" | "cheque" | "cod" | "wallet" | "stripe";
+    shippingMethodId?: "gls_hd" | "gls_parcelshop" | "combine_free";
+    parcelshopId?: string;
+    couponCode?: string;
+    currency?: "EUR" | "HUF";
+    billing?: AddressInput;
+    shipping?: AddressInput;
+    taxNumber?: string;
+    cardId?: string;
+}
+interface KeyproClientOptions {
+    apiBase: string;
+    apiKey?: string | null;
+}
+declare class KeyproClient {
+    private readonly opts;
+    constructor(opts: KeyproClientOptions);
+    private request;
+    login(email: string, password: string, name?: string): Promise<{
+        token: string;
+        keyId: number;
+        prefix: string;
+        scopes: string[];
+        name: string;
+    }>;
+    me(): Promise<{
+        id: number;
+        email: string;
+        companyName: string | null;
+        firstName: string | null;
+        role: string;
+        walletBalanceEurNet: number;
+        key: {
+            id: number;
+            prefix: string;
+            name: string;
+            scopes: string[];
+        };
+    }>;
+    keysList(): Promise<{
+        keys: Array<Record<string, unknown>>;
+    }>;
+    keyRevoke(keyId: number): Promise<{
+        revoked: boolean;
+        keyId: number;
+    }>;
+    productsSearch(params: {
+        q?: string;
+        category?: string;
+        onSale?: boolean;
+        sort?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        total: number;
+        products: Array<Record<string, unknown>>;
+    }>;
+    productGet(key: string): Promise<Record<string, unknown>>;
+    orderPreview(req: OrderRequestInput): Promise<{
+        lines: Array<Record<string, unknown>>;
+        totals: Record<string, number>;
+        payment: Record<string, unknown>;
+        shipping: Record<string, unknown> | null;
+        coupon: Record<string, unknown> | null;
+        currency: string;
+        eurRate: number;
+        displayGrossTotal: number;
+        wallet: {
+            balanceEurNet: number;
+            sufficient: boolean;
+        } | null;
+        confirmToken: string;
+        confirmTokenExpiresAt: string;
+    }>;
+    orderCreate(req: OrderRequestInput & {
+        confirmToken: string;
+    }, idempotencyKey?: string): Promise<{
+        order: Record<string, unknown>;
+        invoices: Array<Record<string, unknown>>;
+        deliveredKeyCount: number;
+        payment: {
+            method: string;
+            charged: boolean;
+            paymentUrl?: string;
+            declineCode?: string | null;
+            walletBalanceAfterEur?: number;
+            note: string;
+        };
+        idempotentReplay: boolean;
+    }>;
+    ordersList(params: {
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        orders: Array<Record<string, unknown>>;
+    }>;
+    orderGet(id: number): Promise<{
+        order: Record<string, unknown>;
+        invoices: Array<Record<string, unknown>>;
+        paymentUrl: string | null;
+    }>;
+    orderKeys(id: number): Promise<{
+        orderId: number;
+        orderStatus: string;
+        keys: Array<{
+            productId: number;
+            productName: string;
+            keyValue: string;
+            deliveredAt: string | null;
+        }>;
+        licenses: Array<Record<string, unknown>>;
+    }>;
+    orderCancel(id: number): Promise<{
+        order: Record<string, unknown>;
+        invoices: Array<Record<string, unknown>>;
+        cancelled: boolean;
+        alreadyCancelled: boolean;
+        note: string;
+    }>;
+    orderPaymentPreview(id: number, newMethod: string): Promise<{
+        currentMethod: string;
+        newMethod: string;
+        newTotals: {
+            netTotalEur: number;
+            grossTotalEur: number;
+        };
+        feeDeltaEur: number;
+        fees: Array<{
+            label: string;
+            netEur: number;
+        }>;
+        confirmToken: string;
+        confirmTokenExpiresAt: string;
+        wallet: {
+            balanceEurNet: number;
+            sufficient: boolean;
+        } | null;
+    }>;
+    orderChangePayment(id: number, body: {
+        newMethod: string;
+        confirmToken: string;
+        cardId?: string;
+    }): Promise<{
+        order: Record<string, unknown>;
+        invoices: Array<Record<string, unknown>>;
+        payment: Record<string, unknown>;
+    }>;
+    licenseKeys(): Promise<{
+        products: Array<{
+            productId: number;
+            productName: string;
+            keys: Array<Record<string, unknown>>;
+        }>;
+    }>;
+    invoicesList(params: {
+        orderId?: number;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        invoices: Array<Record<string, unknown>>;
+    }>;
+    invoiceGet(id: number): Promise<{
+        invoice: Record<string, unknown>;
+    }>;
+    profileGet(): Promise<{
+        profile: Record<string, unknown>;
+    }>;
+    profileUpdate(patch: Record<string, unknown>): Promise<{
+        updated: string[];
+        profile: Record<string, unknown>;
+    }>;
+    wallet(params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        balanceEurNet: number;
+        transactions: Array<Record<string, unknown>>;
+    }>;
+    cardsList(): Promise<{
+        stripeEnabled: boolean;
+        cards: Array<{
+            id: string;
+            brand: string;
+            last4: string;
+            expMonth: number;
+            expYear: number;
+            isDefault: boolean;
+        }>;
+    }>;
+    parcelshopsSearch(q: string, type?: string): Promise<{
+        truncated: boolean;
+        parcelshops: Array<Record<string, unknown>>;
+    }>;
+    exchangeRate(): Promise<{
+        base: string;
+        quote: string;
+        rate: number;
+        eurToHuf: number;
+        hufToEur: number;
+        referenceRate: number;
+        markupPct: number;
+        source: string;
+        rounding: {
+            HUF: number;
+            EUR: number;
+        };
+        note: string;
+    }>;
+}
+declare function createClient(opts: KeyproClientOptions): KeyproClient;
+
+/**
+ * Megosztott MCP tool-registry: a KeyPro muveletek nativ MCP tool-kent, ugyanazon
+ * a KeyproClient-en keresztul. Ezt hasznalja a CLI stdio szerver (mcp.ts) ES a
+ * webes tavoli MCP route (src/app/mcp/route.ts) - igy a tool-definiciok nem
+ * csusznak szet. A McpServer csak tipuskent kell (type-only import), igy ez a
+ * modul nem huzza be a stdio transportot a webes buildbe.
+ */
+
+/** A KeyPro MCP tool-jait regisztralja a megadott McpServer-re. */
+declare function registerKeyproTools(server: McpServer, client: KeyproClient): void;
+
+export { KeyproApiError, KeyproClient, type KeyproClientOptions, createClient, registerKeyproTools };

package/dist/mcp-tools.js

@@ -0,0 +1,461 @@
+// src/mcp-tools.ts
+import { z } from "zod";
+
+// src/client.ts
+var KeyproApiError = class extends Error {
+  constructor(status, code, message, details) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.details = details;
+    this.name = "KeyproApiError";
+  }
+  status;
+  code;
+  details;
+};
+var KeyproClient = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  async request(method, path, body, extraHeaders) {
+    const headers = {
+      accept: "application/json",
+      ...extraHeaders
+    };
+    if (this.opts.apiKey) headers.authorization = `Bearer ${this.opts.apiKey}`;
+    if (body !== void 0) headers["content-type"] = "application/json";
+    let response;
+    try {
+      response = await fetch(`${this.opts.apiBase}${path}`, {
+        method,
+        headers,
+        body: body === void 0 ? void 0 : JSON.stringify(body)
+      });
+    } catch (err) {
+      throw new KeyproApiError(
+        0,
+        "network_error",
+        `Nem siker\xFClt el\xE9rni a szervert (${this.opts.apiBase}): ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    let payload;
+    try {
+      payload = await response.json();
+    } catch {
+      throw new KeyproApiError(
+        response.status,
+        "invalid_response",
+        `A szerver nem JSON v\xE1laszt adott (HTTP ${response.status}). J\xF3 az api-base be\xE1ll\xEDt\xE1s?`
+      );
+    }
+    const envelope = payload;
+    if (envelope.ok === true && envelope.data !== void 0) {
+      return envelope.data;
+    }
+    const error = envelope.error ?? {};
+    throw new KeyproApiError(
+      response.status,
+      error.code ?? "unknown_error",
+      error.message ?? `Ismeretlen hiba (HTTP ${response.status}).`,
+      error.details
+    );
+  }
+  // --- Auth / kulcsok ---
+  login(email, password, name) {
+    return this.request("POST", "/api/v1/auth/login", { email, password, name });
+  }
+  me() {
+    return this.request("GET", "/api/v1/me");
+  }
+  keysList() {
+    return this.request(
+      "GET",
+      "/api/v1/keys"
+    );
+  }
+  keyRevoke(keyId) {
+    return this.request(
+      "DELETE",
+      `/api/v1/keys/${keyId}`
+    );
+  }
+  // --- Termekek ---
+  productsSearch(params) {
+    const qs = new URLSearchParams();
+    if (params.q) qs.set("q", params.q);
+    if (params.category) qs.set("category", params.category);
+    if (params.onSale) qs.set("on_sale", "true");
+    if (params.sort) qs.set("sort", params.sort);
+    if (params.limit) qs.set("limit", String(params.limit));
+    if (params.offset) qs.set("offset", String(params.offset));
+    const suffix = qs.size > 0 ? `?${qs}` : "";
+    return this.request("GET", `/api/v1/products${suffix}`);
+  }
+  productGet(key) {
+    return this.request(
+      "GET",
+      `/api/v1/products/${encodeURIComponent(key)}`
+    );
+  }
+  // --- Rendelesek ---
+  orderPreview(req) {
+    return this.request("POST", "/api/v1/orders/preview", req);
+  }
+  orderCreate(req, idempotencyKey) {
+    return this.request(
+      "POST",
+      "/api/v1/orders",
+      req,
+      idempotencyKey ? { "idempotency-key": idempotencyKey } : void 0
+    );
+  }
+  ordersList(params) {
+    const qs = new URLSearchParams();
+    if (params.status) qs.set("status", params.status);
+    if (params.limit) qs.set("limit", String(params.limit));
+    if (params.offset) qs.set("offset", String(params.offset));
+    const suffix = qs.size > 0 ? `?${qs}` : "";
+    return this.request(
+      "GET",
+      `/api/v1/orders${suffix}`
+    );
+  }
+  orderGet(id) {
+    return this.request("GET", `/api/v1/orders/${id}`);
+  }
+  orderKeys(id) {
+    return this.request("GET", `/api/v1/orders/${id}/keys`);
+  }
+  orderCancel(id) {
+    return this.request("POST", `/api/v1/orders/${id}/cancel`);
+  }
+  orderPaymentPreview(id, newMethod) {
+    return this.request("POST", `/api/v1/orders/${id}/payment/preview`, { newMethod });
+  }
+  orderChangePayment(id, body) {
+    return this.request("POST", `/api/v1/orders/${id}/payment`, body);
+  }
+  licenseKeys() {
+    return this.request("GET", "/api/v1/license-keys");
+  }
+  // --- Szamlak ---
+  invoicesList(params) {
+    const qs = new URLSearchParams();
+    if (params.orderId) qs.set("order_id", String(params.orderId));
+    if (params.limit) qs.set("limit", String(params.limit));
+    if (params.offset) qs.set("offset", String(params.offset));
+    const suffix = qs.size > 0 ? `?${qs}` : "";
+    return this.request(
+      "GET",
+      `/api/v1/invoices${suffix}`
+    );
+  }
+  invoiceGet(id) {
+    return this.request(
+      "GET",
+      `/api/v1/invoices/${id}`
+    );
+  }
+  // --- Profil / wallet / kartyak / csomagpontok ---
+  profileGet() {
+    return this.request(
+      "GET",
+      "/api/v1/profile"
+    );
+  }
+  profileUpdate(patch) {
+    return this.request("PATCH", "/api/v1/profile", patch);
+  }
+  wallet(params = {}) {
+    const qs = new URLSearchParams();
+    if (params.limit) qs.set("limit", String(params.limit));
+    if (params.offset) qs.set("offset", String(params.offset));
+    const suffix = qs.size > 0 ? `?${qs}` : "";
+    return this.request("GET", `/api/v1/wallet${suffix}`);
+  }
+  cardsList() {
+    return this.request("GET", "/api/v1/cards");
+  }
+  parcelshopsSearch(q, type) {
+    const qs = new URLSearchParams({ q });
+    if (type) qs.set("type", type);
+    return this.request("GET", `/api/v1/shipping/parcelshops?${qs}`);
+  }
+  exchangeRate() {
+    return this.request("GET", "/api/v1/exchange-rate");
+  }
+};
+function createClient(opts) {
+  return new KeyproClient(opts);
+}
+
+// src/mcp-tools.ts
+var addressShape = z.object({
+  firstName: z.string().optional(),
+  lastName: z.string().optional(),
+  company: z.string().optional(),
+  address1: z.string().optional(),
+  address2: z.string().optional(),
+  city: z.string().optional(),
+  postcode: z.string().optional(),
+  state: z.string().optional(),
+  country: z.string().optional(),
+  email: z.string().optional(),
+  phone: z.string().optional()
+}).optional();
+var orderRequestShape = {
+  items: z.array(
+    z.object({
+      sku: z.string().optional().describe("Product SKU (either sku or productId)"),
+      productId: z.number().int().positive().optional(),
+      qty: z.number().int().min(1).max(999).default(1)
+    })
+  ).min(1).describe("Order lines"),
+  paymentMethod: z.enum(["bacs", "cheque", "cod", "wallet", "stripe"]).describe(
+    "bacs=bank transfer (proforma first), cheque=8-day terms (+5%), cod=cash on delivery, wallet=KEP balance, stripe=saved card"
+  ),
+  shippingMethodId: z.enum(["gls_hd", "gls_parcelshop", "combine_free"]).optional().describe("Required when the cart contains physical products"),
+  parcelshopId: z.string().optional().describe("GLS pickup point id (required for gls_parcelshop)"),
+  couponCode: z.string().optional(),
+  currency: z.enum(["EUR", "HUF"]).default("EUR"),
+  billing: addressShape.describe(
+    "Per-field billing address overrides (defaults come from the user profile)"
+  ),
+  shipping: addressShape.describe(
+    "Separate shipping address (omit to ship to the billing address)"
+  ),
+  taxNumber: z.string().optional(),
+  cardId: z.string().optional().describe("Saved card id (pm_...) for stripe payments; omit for default card")
+};
+function jsonResult(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function errorResult(err) {
+  const payload = err instanceof KeyproApiError ? { code: err.code, message: err.message, details: err.details } : { code: "cli_error", message: err instanceof Error ? err.message : String(err) };
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: payload }) }],
+    isError: true
+  };
+}
+async function run(fn) {
+  try {
+    return jsonResult(await fn());
+  } catch (err) {
+    return errorResult(err);
+  }
+}
+function registerKeyproTools(server, client) {
+  server.registerTool(
+    "keypro_whoami",
+    {
+      description: "The authenticated KeyPro account (email, company, role, KEP wallet balance, API key scopes).",
+      inputSchema: {}
+    },
+    () => run(() => client.me())
+  );
+  server.registerTool(
+    "keypro_exchange_rate",
+    {
+      description: "Current EUR->HUF exchange rate the shop uses and displays (ECB daily reference + 3% markup). Product net prices are stored in EUR; the HUF price = round(EUR * rate) to whole forint (EUR shown with 2 decimals). Call this to price products accurately in both currencies.",
+      inputSchema: {}
+    },
+    () => run(() => client.exchangeRate())
+  );
+  server.registerTool(
+    "keypro_products_search",
+    {
+      description: "Search the KeyPro product catalog by name or SKU. Returns id, sku, name, net EUR price.",
+      inputSchema: {
+        q: z.string().optional().describe("Search text (name or SKU)"),
+        category: z.string().optional().describe("Category slug filter"),
+        onSale: z.boolean().optional().describe("Only discounted products"),
+        limit: z.number().int().min(1).max(100).optional()
+      }
+    },
+    (args) => run(
+      () => client.productsSearch({
+        q: args.q,
+        category: args.category,
+        onSale: args.onSale,
+        limit: args.limit
+      })
+    )
+  );
+  server.registerTool(
+    "keypro_product_get",
+    {
+      description: "Product details by id, slug or SKU, including the caller's effective unit price with discounts.",
+      inputSchema: { key: z.string().describe("Product id, slug or SKU") }
+    },
+    (args) => run(() => client.productGet(args.key))
+  );
+  server.registerTool(
+    "keypro_order_preview",
+    {
+      description: "Preview an order WITHOUT placing it: priced lines, fees, shipping, totals, and a confirmToken (valid 15 minutes). ALWAYS show the returned totals to the user and get their approval before calling keypro_order_create.",
+      inputSchema: orderRequestShape
+    },
+    (args) => run(() => client.orderPreview(args))
+  );
+  server.registerTool(
+    "keypro_order_create",
+    {
+      description: "Place an order. Requires the confirmToken from keypro_order_preview (same items, payment method and total). If the response contains payment.paymentUrl, give that link to the user to finish paying in a browser. Pass idempotencyKey to make retries safe.",
+      inputSchema: {
+        ...orderRequestShape,
+        confirmToken: z.string().describe("Token from keypro_order_preview"),
+        idempotencyKey: z.string().optional().describe("Unique retry-dedup key; the same key never creates a second order")
+      }
+    },
+    (args) => run(() => {
+      const { idempotencyKey, ...request } = args;
+      return client.orderCreate(request, idempotencyKey);
+    })
+  );
+  server.registerTool(
+    "keypro_orders_list",
+    {
+      description: "List the user's orders (newest first), optional status filter.",
+      inputSchema: {
+        status: z.string().optional().describe("e.g. pending, processing, completed"),
+        limit: z.number().int().min(1).max(100).optional()
+      }
+    },
+    (args) => run(() => client.ordersList({ status: args.status, limit: args.limit }))
+  );
+  server.registerTool(
+    "keypro_order_get",
+    {
+      description: "Order details: items, totals, status, invoices, and a payment link if the order is awaiting card payment.",
+      inputSchema: { orderId: z.number().int().positive() }
+    },
+    (args) => run(() => client.orderGet(args.orderId))
+  );
+  server.registerTool(
+    "keypro_order_keys",
+    {
+      description: "License keys delivered for one order. COD orders release keys only after completion.",
+      inputSchema: { orderId: z.number().int().positive() }
+    },
+    (args) => run(() => client.orderKeys(args.orderId))
+  );
+  server.registerTool(
+    "keypro_order_cancel",
+    {
+      description: "Cancel an UNPAID order. Only orders awaiting payment can be cancelled: bacs (bank transfer / proforma), stripe (card checkout not completed), and cod (cash on delivery, still processing). 8-day-deferred (cheque) and already-paid orders CANNOT be cancelled. Idempotent.",
+      inputSchema: { orderId: z.number().int().positive() }
+    },
+    (args) => run(() => client.orderCancel(args.orderId))
+  );
+  server.registerTool(
+    "keypro_order_change_payment_preview",
+    {
+      description: "Preview changing an UNPAID order's payment method (only on-hold=bacs / pending=stripe orders qualify). Returns the recomputed totals for the new method (cheque adds +5%, cod adds a fixed fee; bacs/wallet/stripe add none) and a confirmToken. ALWAYS show the new totals to the user, then call keypro_order_change_payment.",
+      inputSchema: {
+        orderId: z.number().int().positive(),
+        newMethod: z.enum(["bacs", "cheque", "cod", "wallet", "stripe"])
+      }
+    },
+    (args) => run(() => client.orderPaymentPreview(args.orderId, args.newMethod))
+  );
+  server.registerTool(
+    "keypro_order_change_payment",
+    {
+      description: "Change an UNPAID order's payment method. Requires the confirmToken from keypro_order_change_payment_preview. wallet debits the KEP balance now and fulfils; cheque/cod add their fee and fulfil (final invoice + keys where due); bacs issues a proforma (awaits transfer); stripe charges the saved card or returns a payment link in payment.paymentUrl. Pass cardId (pm_...) to pick a specific card for stripe.",
+      inputSchema: {
+        orderId: z.number().int().positive(),
+        newMethod: z.enum(["bacs", "cheque", "cod", "wallet", "stripe"]),
+        confirmToken: z.string().describe("Token from keypro_order_change_payment_preview"),
+        cardId: z.string().optional().describe("Saved card id (pm_...) for stripe")
+      }
+    },
+    (args) => run(
+      () => client.orderChangePayment(args.orderId, {
+        newMethod: args.newMethod,
+        confirmToken: args.confirmToken,
+        cardId: args.cardId
+      })
+    )
+  );
+  server.registerTool(
+    "keypro_license_keys",
+    {
+      description: "All delivered license keys of the user, grouped by product.",
+      inputSchema: {}
+    },
+    () => run(() => client.licenseKeys())
+  );
+  server.registerTool(
+    "keypro_invoices_list",
+    {
+      description: "List invoices/proformas (each has a public downloadUrl PDF link). Optional order filter.",
+      inputSchema: {
+        orderId: z.number().int().positive().optional(),
+        limit: z.number().int().min(1).max(100).optional()
+      }
+    },
+    (args) => run(() => client.invoicesList({ orderId: args.orderId, limit: args.limit }))
+  );
+  server.registerTool(
+    "keypro_invoice_get",
+    {
+      description: "One invoice with totals and public downloadUrl.",
+      inputSchema: { invoiceId: z.number().int().positive() }
+    },
+    (args) => run(() => client.invoiceGet(args.invoiceId))
+  );
+  server.registerTool(
+    "keypro_profile_get",
+    {
+      description: "The account profile: contact data, billing and shipping address.",
+      inputSchema: {}
+    },
+    () => run(() => client.profileGet())
+  );
+  server.registerTool(
+    "keypro_profile_update",
+    {
+      description: "Update profile fields (partial). Allowed keys: firstName, phone, website, companyName, taxNumber, billingFirstName, billingLastName, billingCompany, billingAddress1, billingAddress2, billingCity, billingPostcode, billingState, billingCountry, billingEmail, billingPhone, and the same shipping* fields (no shippingEmail). Empty string clears a field.",
+      inputSchema: {
+        fields: z.record(z.string(), z.string()).describe("Field name -> new value map (flat API field names)")
+      }
+    },
+    (args) => run(() => client.profileUpdate(args.fields))
+  );
+  server.registerTool(
+    "keypro_wallet",
+    {
+      description: "KEP wallet balance (net EUR) and transaction history (topup/payment/refund/bonus with running balance).",
+      inputSchema: {
+        limit: z.number().int().min(1).max(100).optional().describe("History length")
+      }
+    },
+    (args) => run(() => client.wallet({ limit: args.limit }))
+  );
+  server.registerTool(
+    "keypro_cards_list",
+    {
+      description: "Saved bank cards (brand, last4, default flag). New cards can only be added on the website.",
+      inputSchema: {}
+    },
+    () => run(() => client.cardsList())
+  );
+  server.registerTool(
+    "keypro_parcelshops_search",
+    {
+      description: "Search GLS pickup points (city, zip prefix or name). Use the returned id as parcelshopId for gls_parcelshop shipping.",
+      inputSchema: {
+        q: z.string().describe("City, zip prefix or name"),
+        type: z.enum(["parcel-shop", "parcel-locker", "all"]).optional()
+      }
+    },
+    (args) => run(() => client.parcelshopsSearch(args.q, args.type))
+  );
+}
+export {
+  KeyproApiError,
+  createClient,
+  registerKeyproTools
+};

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "@keypro/cli",
-  "version": "0.1.0",
+  "version": "0.1.4",
   "description": "KeyPro.hu B2B szoftverlicenc webshop CLI: rendeles leadas, rendelesek/szamlak/termekkulcsok lekerdezese, profil kezeles. AI-ugynok (Claude Code, Codex) barat: --json kimenet es beepitett MCP szerver (keypro mcp).",
   "license": "MIT",
   "type": "module",
   "bin": {
     "keypro": "dist/index.js"
   },
+  "exports": {
+    "./mcp-tools": {
+      "types": "./dist/mcp-tools.d.ts",
+      "import": "./dist/mcp-tools.js"
+    }
+  },
   "files": [
     "dist",
     "AGENTS.md",