@itpay/cli 0.2.17 → 2.0.0-rc.1

package/dist/src/commands/buy.js

@@ -0,0 +1,351 @@
+// V3 `buy` flow:
+//   1. validate client context (host/target)
+//   2. create cart via POST /v1/carts
+//   3. create checkout via POST /v1/checkouts (consumes the cart)
+//   4. build a checkout_qr render plan + dispatch to host renderer
+//   5. [--pay] create payment intent → render payment QR → optionally SSE wait
+//   6. [--json] output JSON instead of terminal text
+//
+// The display token is passed to the renderer and persisted in the local cart
+// session so a restarted agent can resume the same checkout.
+import { operationID } from "../state/config.js";
+import { validateContext } from "../state/client_context.js";
+import { dispatchRender } from "../render/index.js";
+import { dispatchInteractionRequest } from "../render/interaction.js";
+import { ensureIdeImageAttach, readFileAsDataURL } from "../render/ide.js";
+import { buildAgentChatHandoff } from "../render/markdown.js";
+export async function runBuy(backend, config, options) {
+    const err = validateContext(options.host, options.target);
+    if (err) {
+        throw new Error(`${err.code}: ${err.message}`);
+    }
+    const snap = options.cartSession.show();
+    if (!options.cartID && snap.items.length === 0) {
+        throw new Error("cart is empty; add an item with `itpay cart add` first");
+    }
+    const missingContactFields = findMissingContactFields(options.contact, options.requiredContactFields ?? []);
+    if (missingContactFields.length > 0) {
+        const interactionRequest = buildMissingContactInteractionRequest(missingContactFields);
+        await dispatchInteractionRequest(options.host, interactionRequest, {
+            ...(options.isTTY !== undefined ? { isTTY: options.isTTY } : {}),
+            ...(options.target ? { target: options.target } : {}),
+            ...(options.output ? { output: options.output } : {}),
+        });
+        return {
+            kind: "interaction_requested",
+            interactionRequest,
+        };
+    }
+    let cart;
+    if (options.cartID) {
+        cart = await backend.getCart(options.cartID);
+    }
+    else {
+        const request = options.cartSession.toCreateCartRequest();
+        request.client_context = {
+            host: options.host,
+            target: options.target,
+            agent_device_id: options.cartSession.ensureAgentDeviceID(config.agentDeviceID),
+        };
+        const agentDeviceID = options.cartSession.ensureAgentDeviceID(config.agentDeviceID);
+        request.agent_device_id = agentDeviceID;
+        cart = await backend.createCart(request);
+    }
+    const checkoutRequest = {
+        cart_id: cart.cart_id,
+        client_reference_id: options.clientReferenceID ?? await operationID(config, `checkout.create:${cart.cart_id}`),
+        ...(options.contact ? { delivery_contact: options.contact } : {}),
+    };
+    const checkout = await backend.createCheckout(checkoutRequest);
+    options.cartSession.rememberCheckout({
+        cartID: cart.cart_id,
+        checkoutID: checkout.checkout.checkout_id,
+        displayToken: checkout.display_token,
+        checkoutURL: tokenizedCheckoutURL(checkout.checkout_url, checkout.display_token, checkout.qr_payload),
+    });
+    const checkoutID = checkout.checkout.checkout_id;
+    const displayToken = checkout.display_token;
+    const checkoutURL = tokenizedCheckoutURL(checkout.checkout_url, displayToken, checkout.qr_payload);
+    const orderItems = cart.items.map((item) => ({
+        title: item.title,
+        quantity: item.quantity,
+        amountMinor: item.amount_minor,
+        currency: item.currency,
+    }));
+    // --- Payment flow (optional) ---
+    let paymentIntent;
+    let waitStatus = "skipped";
+    if (options.pay) {
+        const method = options.payMethod ?? "alipay";
+        paymentIntent = await backend.createPaymentIntent(checkoutID, { payment_method_type: method, display_token: displayToken }, await operationID(config, `payment.intent:${checkoutID}:${method}`));
+        if (!options.jsonOutput) {
+            process.stdout.write("\n--- payment intent ---\n");
+            process.stdout.write(`  id:     ${paymentIntent.payment_intent_id}\n`);
+            process.stdout.write(`  method: ${paymentIntent.payment_method_type}\n`);
+            process.stdout.write(`  status: ${paymentIntent.status}\n`);
+            if (paymentIntent.action?.qr_image_url) {
+                process.stdout.write(`  qr:     ${paymentIntent.action.qr_image_url}\n`);
+            }
+            if (paymentIntent.action?.mobile_wallet_url) {
+                process.stdout.write(`  wallet: ${paymentIntent.action.mobile_wallet_url}\n`);
+            }
+        }
+        if (!options.noWait) {
+            waitStatus = await waitForPaymentSSE(backend, checkoutID, displayToken, options.payTimeoutSec ?? 120);
+            if (!options.jsonOutput) {
+                process.stdout.write(`  wait:    ${waitStatus}\n`);
+            }
+        }
+    }
+    // --- Build render plan (after payment if --pay) ---
+    const planInput = {
+        host: options.host,
+        checkoutID,
+        checkoutURL,
+        displayToken,
+        qrPayload: checkout.qr_payload,
+        nextAction: checkout.checkout.next_action,
+        orderItems,
+        orderCurrency: checkout.checkout.currency,
+    };
+    if (checkout.qr_png_url)
+        planInput.qrPNGURL = checkout.qr_png_url;
+    if (paymentIntent) {
+        planInput.paymentIntentID = paymentIntent.payment_intent_id;
+        planInput.paymentMethod = paymentIntent.payment_method_type;
+        planInput.paymentStatus = paymentIntent.status;
+    }
+    const plan = buildCheckoutQRPlan(planInput);
+    // --- Download brand QR for IDE image attach (every output mode) ---
+    await ensureIdeImageAttach(plan, {
+        enabled: config.ideImageAttach,
+        ...(config.baseURL ? { baseURL: config.baseURL } : {}),
+        ...(options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}),
+    });
+    // --- Output ---
+    if (options.jsonOutput) {
+        const jsonInput = {
+            checkout: { ...checkout, checkout_url: checkoutURL },
+            cart,
+            waitStatus,
+            plan,
+        };
+        if (paymentIntent) {
+            jsonInput.paymentIntent = paymentIntent;
+        }
+        if (plan.ideImageAttach) {
+            jsonInput.ideImageAttach = {
+                localPath: plan.ideImageAttach.localPath,
+                mirrors: plan.ideImageAttach.mirrors,
+                mimeType: plan.ideImageAttach.mimeType,
+                ...(plan.ideImageAttach.caption ? { caption: plan.ideImageAttach.caption } : {}),
+                mustRenderReason: plan.ideImageAttach.mustRenderReason,
+                status: plan.ideImageAttach.status,
+                ...(plan.ideImageAttach.error ? { error: plan.ideImageAttach.error } : {}),
+            };
+        }
+        const json = buildJSONOutput(jsonInput);
+        (options.output ?? ((line) => process.stdout.write(line + "\n")))(JSON.stringify(json, null, 2) + "\n");
+        return {
+            kind: "checkout_rendered",
+            plan,
+            checkoutID,
+            displayToken,
+            json,
+        };
+    }
+    // Text output — always render QR for non-JSON mode
+    const renderOptions = {
+        host: options.host,
+        isTTY: options.isTTY ?? Boolean(process.stdout.isTTY),
+        ...(options.target ? { target: options.target } : {}),
+        ...(options.qrFormat ? { qrFormat: options.qrFormat } : {}),
+        ...(options.qrFilePath ? { qrFilePath: options.qrFilePath } : {}),
+        ...(options.output ? { output: options.output } : {}),
+        ...(options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}),
+        baseURL: config.baseURL,
+    };
+    await dispatchRender(plan, renderOptions);
+    return {
+        kind: "checkout_rendered",
+        plan,
+        checkoutID,
+        displayToken,
+    };
+}
+// --- SSE wait for payment verification ---
+async function waitForPaymentSSE(backend, checkoutID, displayToken, timeoutSec) {
+    return new Promise((resolve) => {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => {
+            controller.abort();
+            resolve("timeout");
+        }, timeoutSec * 1000);
+        backend.streamCheckoutEvents(checkoutID, displayToken, (event) => {
+            if (event.type === "payment_intent.verified") {
+                clearTimeout(timeout);
+                controller.abort();
+                resolve("verified");
+            }
+        }, controller.signal).catch(() => {
+            // stream ended or aborted
+        }).finally(() => {
+            clearTimeout(timeout);
+        });
+    });
+}
+export function buildJSONOutput(input) {
+    const output = {
+        kind: "checkout_created",
+        checkout_id: input.checkout.checkout.checkout_id,
+        checkout_url: input.checkout.checkout_url,
+        display_token: input.checkout.display_token,
+        qr_payload: input.checkout.qr_payload,
+        checkout_status: input.checkout.checkout.status,
+        wait_status: input.waitStatus,
+    };
+    if (input.checkout.qr_png_url) {
+        output.qr_png_url = input.checkout.qr_png_url;
+    }
+    const serviceExecutions = input.cart?.items
+        .filter((item) => item.service_execution_id)
+        .map((item) => ({
+        service_execution_id: item.service_execution_id,
+        ...(item.service_capability_id ? { service_capability_id: item.service_capability_id } : {}),
+        ...(item.title ? { title: item.title } : {}),
+    }));
+    if (serviceExecutions && serviceExecutions.length > 0) {
+        output.service_executions = serviceExecutions;
+    }
+    if (input.paymentIntent) {
+        output.payment_intent_id = input.paymentIntent.payment_intent_id;
+        output.payment_status = input.paymentIntent.status;
+        if (input.paymentIntent.action) {
+            const pa = {};
+            if (input.paymentIntent.action.qr_image_url)
+                pa.qr_image_url = input.paymentIntent.action.qr_image_url;
+            if (input.paymentIntent.action.mobile_wallet_url)
+                pa.mobile_wallet_url = input.paymentIntent.action.mobile_wallet_url;
+            output.payment_action = pa;
+        }
+        output.kind = "payment_handoff_required";
+    }
+    if (input.waitStatus === "verified") {
+        output.kind = "payment_verified";
+    }
+    if (input.ideImageAttach) {
+        output.brand_qr_status = input.ideImageAttach.status;
+        if (input.ideImageAttach.localPath) {
+            output.brand_qr_local_path = input.ideImageAttach.localPath;
+            const dataURL = readFileAsDataURL(input.ideImageAttach.localPath, input.ideImageAttach.mimeType);
+            if (dataURL)
+                output.brand_qr_data_url = dataURL;
+            const stableName = input.ideImageAttach.localPath.split("/").pop();
+            if (stableName)
+                output.brand_qr_stable_name = stableName;
+        }
+        if (input.ideImageAttach.mirrors.length > 0) {
+            output.brand_qr_mirrors = [...input.ideImageAttach.mirrors];
+        }
+        output.brand_qr_mime_type = input.ideImageAttach.mimeType;
+        if (input.ideImageAttach.caption)
+            output.brand_qr_caption = input.ideImageAttach.caption;
+        if (input.ideImageAttach.error)
+            output.brand_qr_error = input.ideImageAttach.error;
+        output.brand_qr_must_render_reason = input.ideImageAttach.mustRenderReason;
+        output.brand_qr_render_action = "agent_must_read_local_path_into_ide_chat";
+    }
+    output.next = input.waitStatus === "verified"
+        ? "itpay orders"
+        : `itpay checkout --id ${input.checkout.checkout.checkout_id} --token ${input.checkout.display_token}`;
+    if (input.plan)
+        output.agent_action = buildAgentChatHandoff(input.plan);
+    return output;
+}
+// --- checkout QR plan ---
+export function buildCheckoutQRPlan(input) {
+    const summary = `Scan the QR or open ${input.checkoutURL} to start the human checkout flow.`;
+    const isPayment = input.paymentIntentID != null;
+    const afterCommand = isPayment
+        ? `itpay checkout --id ${input.checkoutID} --token ${input.displayToken}`
+        : `itpay checkout --id ${input.checkoutID} --token ${input.displayToken}`;
+    const platform = {
+        text: summary,
+        links: [
+            { label: "打开付款页面", url: input.checkoutURL },
+        ],
+        buttons: [
+            { label: "打开收银台", kind: "url", url: input.checkoutURL },
+            ...(input.checkoutID
+                ? [{ label: "查询 Checkout 状态", kind: "callback", intent: "check_checkout_status", ref: input.checkoutID }]
+                : []),
+        ],
+        blocks: [],
+        ...(input.qrPNGURL ? { media: [{ url: input.qrPNGURL, label: "Branded QR", mimeType: "image/png" }] } : {}),
+    };
+    const plan = {
+        kind: isPayment ? "payment_qr" : "checkout_qr",
+        host: input.host,
+        summary,
+        url: input.qrPayload,
+        preferredQRSources: [input.qrPNGURL ?? input.qrPayload],
+        checkoutID: input.checkoutID,
+        platform,
+        afterActionCommand: afterCommand,
+        afterActionLabel: "扫码或点击链接完成支付后，执行以下命令查询状态：",
+    };
+    if (input.orderItems)
+        plan.orderItems = input.orderItems;
+    if (input.orderCurrency)
+        plan.orderCurrency = input.orderCurrency;
+    if (input.paymentMethod)
+        plan.paymentMethod = input.paymentMethod;
+    if (input.paymentStatus)
+        plan.paymentStatus = input.paymentStatus;
+    if (input.paymentIntentID)
+        plan.paymentIntentID = input.paymentIntentID;
+    return plan;
+}
+// --- contact field interaction ---
+export function buildMissingContactInteractionRequest(fields) {
+    return {
+        kind: "input",
+        id: "collect_delivery_contact",
+        title: "Collect buyer contact",
+        prompt: "Before creating the checkout, ask the buyer to provide the missing contact details.",
+        fields: fields.map((field) => ({
+            id: field,
+            label: field === "email" ? "Email" : "Phone number",
+            inputType: field === "email" ? "email" : "phone",
+            required: true,
+            placeholder: field === "email" ? "buyer@example.com" : "+86 138...",
+            description: field === "email" ? "Used for receipts or delivery follow-up." : "Used when the order requires buyer verification.",
+        })),
+        submitLabel: "Submit contact",
+    };
+}
+function findMissingContactFields(contact, fields) {
+    return fields.filter((field) => {
+        const value = contact?.[field];
+        return typeof value !== "string" || value.trim().length === 0;
+    });
+}
+function tokenizedCheckoutURL(checkoutURL, displayToken, qrPayload) {
+    if (qrPayload.trim().length > 0) {
+        return qrPayload;
+    }
+    if (checkoutURL.trim().length === 0 || displayToken.trim().length === 0) {
+        return checkoutURL;
+    }
+    try {
+        const parsed = new URL(checkoutURL);
+        if (!parsed.searchParams.has("display_token")) {
+            parsed.searchParams.set("display_token", displayToken);
+        }
+        return parsed.toString();
+    }
+    catch {
+        const separator = checkoutURL.includes("?") ? "&" : "?";
+        return `${checkoutURL}${separator}display_token=${encodeURIComponent(displayToken)}`;
+    }
+}

package/dist/src/commands/cart.js

@@ -0,0 +1,264 @@
+// CLI cart commands. Server cart is canonical for agent purchase/free-trial
+// flows; local cart helpers are kept for explicit local draft compatibility.
+import { HttpError } from "../client/http.js";
+import { resolveOutput } from "../render/sink.js";
+import { attachAgentGuidance, buildCartGuidance, printAgentGuidance } from "./guidance.js";
+export function runCartAdd(session, options) {
+    const out = resolveOutput(options.output);
+    const item = {
+        catalogItemID: options.catalogItemID,
+        catalogVariantID: options.catalogVariantID,
+        offerID: options.offerID,
+        quantity: options.quantity,
+        ...(options.input ? { input: options.input } : {}),
+    };
+    session.add(item);
+    out(`added ${item.quantity} × variant=${item.catalogVariantID} offer=${item.offerID} to cart\n`);
+}
+export async function runCartAddServer(options) {
+    const out = resolveOutput(options.output);
+    const agentDeviceID = options.session.ensureAgentDeviceID(options.config.agentDeviceID);
+    const item = {
+        catalog_item_id: options.catalogItemID,
+        catalog_variant_id: options.catalogVariantID,
+        offer_id: options.offerID,
+        quantity: options.quantity,
+        ...(options.input ? { input: options.input } : {}),
+    };
+    const clientContext = {
+        host: options.host,
+        ...(options.target ? { target: options.target } : {}),
+        agent_device_id: agentDeviceID,
+    };
+    const cart = options.session.lastCartID
+        ? await options.backend.addCartItem(options.session.lastCartID, {
+            ...item,
+            agent_device_id: agentDeviceID,
+            client_context: clientContext,
+        })
+        : await options.backend.createCart({
+            currency: options.config.checkoutCurrency,
+            agent_device_id: agentDeviceID,
+            client_context: clientContext,
+            items: [item],
+        });
+    const line = cart.items[cart.items.length - 1];
+    options.session.rememberServerCart({
+        cartID: cart.cart_id,
+        ...(line?.cart_item_id ? { cartItemID: line.cart_item_id } : {}),
+        ...(line?.service_execution_id ? { serviceExecutionID: line.service_execution_id } : {}),
+        agentDeviceID,
+    });
+    const serviceModel = line?.service_execution_id
+        ? await getServiceReadModel(options.backend, line.service_execution_id)
+        : undefined;
+    const guidance = buildCartGuidance(cart, serviceModel);
+    if (options.jsonOutput) {
+        out(JSON.stringify(attachAgentGuidance(cart, guidance), null, 2) + "\n");
+    }
+    else {
+        out(`cart: ${cart.cart_id}\n`);
+        if (line?.cart_item_id)
+            out(`line: ${line.cart_item_id}\n`);
+        if (line?.service_execution_id)
+            out(`service execution: ${line.service_execution_id}\n`);
+        printAgentGuidance(guidance, options.output);
+    }
+    return cart;
+}
+export function runCartRemove(session, options) {
+    const out = resolveOutput(options.output);
+    session.remove(options.catalogVariantID, options.offerID);
+    out(`removed variant=${options.catalogVariantID} offer=${options.offerID}\n`);
+}
+export async function runCartRemoveServer(backend, session, cartItemID, options = {}) {
+    const out = resolveOutput(options.output);
+    const cartID = session.lastCartID;
+    if (!cartID) {
+        throw new Error("no canonical server cart is remembered; use --local for local draft removal");
+    }
+    const lineID = cartItemID || session.lastCartItemID;
+    if (!lineID) {
+        throw new Error("missing cart item id; pass --line <cart_item_id>");
+    }
+    const cart = await backend.removeCartItem(cartID, lineID);
+    out(`removed line=${lineID} from cart=${cart.cart_id}\n`);
+    out(`cart ${cart.cart_id} (${cart.status}, ${cart.amount_minor} ${cart.currency})\n`);
+    return cart;
+}
+export function runCartShow(session, options = {}) {
+    const out = resolveOutput(options.output);
+    const snap = session.show();
+    out(`cart (currency=${snap.currency})\n`);
+    if (snap.items.length === 0) {
+        out("  (empty)\n");
+        return;
+    }
+    for (const item of snap.items) {
+        out(`  - ${item.quantity} × variant=${item.catalogVariantID} offer=${item.offerID}` +
+            (item.input ? ` input=${JSON.stringify(item.input)}` : "") +
+            "\n");
+    }
+    if (snap.lastCheckoutID) {
+        out(`last checkout: ${snap.lastCheckoutID}\n`);
+        if (snap.lastCheckoutURL) {
+            out(`checkout url:  ${snap.lastCheckoutURL}\n`);
+        }
+    }
+}
+export async function runCartShowServer(backend, session, options = {}) {
+    const out = resolveOutput(options.output);
+    if (!session.lastCartID) {
+        runCartShow(session, options);
+        return undefined;
+    }
+    const cart = await backend.getCart(session.lastCartID);
+    out(`cart ${cart.cart_id} (${cart.status}, ${cart.amount_minor} ${cart.currency})\n`);
+    if (cart.items.length === 0) {
+        out("  (empty)\n");
+        return cart;
+    }
+    for (const item of cart.items) {
+        out(`  - ${item.quantity} × ${item.title} ${item.amount_minor} ${item.currency}\n`);
+        out(`    line=${item.cart_item_id ?? ""} variant=${item.catalog_variant_id ?? ""} offer=${item.offer_id ?? ""}\n`);
+        if (item.service_execution_id) {
+            out(`    service_execution=${item.service_execution_id} next_action=${item.next_action ?? ""} checkout_required=${String(item.checkout_required ?? false)}\n`);
+        }
+        if (item.service_quote_lock_id) {
+            out(`    service_quote_lock=${item.service_quote_lock_id}\n`);
+        }
+    }
+    const serviceModel = await getServiceReadModelForCart(backend, cart);
+    printAgentGuidance(buildCartGuidance(cart, serviceModel), options.output);
+    return cart;
+}
+export function runCartClear(session, options = {}) {
+    const out = resolveOutput(options.output);
+    session.clear();
+    out("cart cleared\n");
+}
+export async function runCartAbandonServer(backend, session, options = {}) {
+    const out = resolveOutput(options.output);
+    if (!session.lastCartID) {
+        runCartClear(session, options);
+        return undefined;
+    }
+    let cart;
+    try {
+        cart = await backend.abandonCart(session.lastCartID);
+    }
+    catch (error) {
+        if (error instanceof HttpError && (error.code === "cart_item_locked" || error.status === 409)) {
+            const cartID = session.lastCartID;
+            session.clear();
+            out(`cart local handle cleared; server cart ${cartID} is locked by quote/checkout\n`);
+            return undefined;
+        }
+        throw error;
+    }
+    session.clear();
+    out(`cart abandoned: ${cart.cart_id}\n`);
+    return cart;
+}
+export async function runCartNext(backend, session, options = {}) {
+    const out = resolveOutput(options.output);
+    if (session.lastCartID) {
+        const cart = await backend.getCart(session.lastCartID);
+        const guidance = buildCartGuidance(cart, await getServiceReadModelForCart(backend, cart));
+        if (options.jsonOutput) {
+            out(JSON.stringify(guidance, null, 2) + "\n");
+        }
+        else {
+            printAgentGuidance(guidance, options.output);
+        }
+        return;
+    }
+    const snap = session.show();
+    if (snap.lastServiceExecutionID) {
+        const model = await getServiceReadModel(backend, snap.lastServiceExecutionID);
+        const guidance = model
+            ? buildCartGuidance({
+                cart_id: snap.lastCartID ?? "<unknown_cart>",
+                status: "unknown",
+                amount_minor: 0,
+                currency: snap.currency,
+                items: [{
+                        title: "Service Execution",
+                        quantity: 1,
+                        amount_minor: 0,
+                        currency: snap.currency,
+                        service_execution_id: snap.lastServiceExecutionID,
+                    }],
+            }, model)
+            : buildCartGuidance({
+                cart_id: snap.lastCartID ?? "<unknown_cart>",
+                status: "unknown",
+                amount_minor: 0,
+                currency: snap.currency,
+                items: [{
+                        title: "Service Execution",
+                        quantity: 1,
+                        amount_minor: 0,
+                        currency: snap.currency,
+                        service_execution_id: snap.lastServiceExecutionID,
+                    }],
+            });
+        if (options.jsonOutput) {
+            out(JSON.stringify(guidance, null, 2) + "\n");
+        }
+        else {
+            printAgentGuidance(guidance, options.output);
+        }
+        return;
+    }
+    if (snap.lastCheckoutID && snap.lastDisplayToken) {
+        const guidance = {
+            kind: "checkout_handle",
+            summary: `checkout ${snap.lastCheckoutID}: continue human checkout`,
+            state: { checkout_id: snap.lastCheckoutID },
+            next_actions: [{
+                    id: "open_checkout",
+                    label: "Open saved checkout presentation",
+                    command: `itpay checkout --id ${snap.lastCheckoutID} --token ${snap.lastDisplayToken}`,
+                    requires_human: true,
+                }],
+            recovery: [],
+        };
+        if (options.jsonOutput) {
+            out(JSON.stringify(guidance, null, 2) + "\n");
+        }
+        else {
+            printAgentGuidance(guidance, options.output);
+        }
+        return;
+    }
+    const guidance = {
+        kind: "no_active_handle",
+        summary: "no active server cart, service execution, or checkout handle remembered",
+        state: {},
+        next_actions: [{
+                id: "browse_catalog",
+                label: "Browse services",
+                command: "itpay catalog list",
+            }],
+        recovery: [],
+    };
+    if (options.jsonOutput) {
+        out(JSON.stringify(guidance, null, 2) + "\n");
+    }
+    else {
+        printAgentGuidance(guidance, options.output);
+    }
+}
+async function getServiceReadModelForCart(backend, cart) {
+    const serviceExecutionID = [...cart.items].reverse().find((item) => item.service_execution_id)?.service_execution_id;
+    return serviceExecutionID ? getServiceReadModel(backend, serviceExecutionID) : undefined;
+}
+async function getServiceReadModel(backend, serviceExecutionID) {
+    try {
+        return await backend.getServiceExecution(serviceExecutionID);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/src/commands/catalog.js

@@ -0,0 +1,26 @@
+import { formatMoney } from "../render/output.js";
+import { resolveOutput } from "../render/sink.js";
+export async function runCatalogList(backend, options = {}) {
+    const manifest = await backend.getCatalogManifest();
+    const items = manifest.manifest.items;
+    const out = resolveOutput(options.output);
+    if (options.jsonOutput) {
+        out(JSON.stringify(manifest, null, 2) + "\n");
+        return;
+    }
+    out(`Catalog: ${manifest.version} (${manifest.status}, ${items.length} items)\n\n`);
+    for (const item of items) {
+        out(`  ${item.catalog_item_id}\n`);
+        out(`    title:    ${item.title}\n`);
+        out(`    provider: ${item.provider} | type: ${item.service_type} | category: ${item.category}\n`);
+        if (item.service_id)
+            out(`    service:  ${item.service_id} (use: itpay services start ${item.service_id})\n`);
+        if (item.variants.length > 0) {
+            out(`    variants:\n`);
+            for (const variant of item.variants) {
+                out(`      - ${variant.catalog_variant_id}  ${variant.title}  ${variant.offer_id}  ${formatMoney(variant.amount_minor, variant.currency)}\n`);
+            }
+        }
+        out("\n");
+    }
+}