@itpay/cli 2.1.46 → 2.1.47

package/dist/src/state/account_auth.js

@@ -1,358 +0,0 @@
-import { HttpError } from '../client/http.js';
-import { HttpTransportError } from '../client/transport.js';
-import { DeviceAuthorizationError, DeviceStateError } from './device_authority.js';
-import { createHash } from 'node:crypto';
-import { dirname, resolve } from 'node:path';
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, rmSync } from 'node:fs';
-import { writeLocalPNG } from '../render/qr.js';
-import { TaskJournal } from './task_journal.js';
-import { taskJournalPath } from './config.js';
-export function sellerAuthPath(baseURL, env = process.env, purpose = "seller") {
-    return resolve(stateDir(env), `${purpose}-${createHash('sha256').update(baseURL).digest('hex').slice(0, 16)}.json`);
-}
-function read(baseURL, env = process.env, purpose = "seller") {
-    const path = sellerAuthPath(baseURL, env, purpose);
-    if (!existsSync(path))
-        return;
-    const state = JSON.parse(readFileSync(path, 'utf8'));
-    if (state.baseURL !== baseURL)
-        throw new Error('Seller session backend mismatch');
-    return state;
-}
-function save(state, env = process.env, purpose = "seller") {
-    const path = sellerAuthPath(state.baseURL, env, purpose);
-    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-    const tmp = `${path}.${process.pid}.tmp`;
-    writeFileSync(tmp, JSON.stringify(state), { mode: 0o600 });
-    renameSync(tmp, path);
-}
-export function sellerSessionToken(baseURL, env = process.env) {
-    const state = read(baseURL, env);
-    return state?.expiresAt && Date.parse(state.expiresAt) > Date.now() ? state.sessionToken : undefined;
-}
-export function sellerAuth(action, baseURL, env = process.env, fetcher = fetch) {
-    return accountAuth(action, baseURL, env, fetcher);
-}
-export function agentAuth(action, baseURL, backend, env = process.env, fetcher = fetch, options = {}) {
-    return accountAuth(action, baseURL, env, fetcher, backend, options.readOnlyStatus === true && action === 'status');
-}
-// AUTH01: dashboard session stages stay distinct — the human must know exactly
-// what the official page still needs instead of a generic "pending".
-const ACTIVE_SESSION_STAGES = ['created', 'waiting_provider', 'email_verification_required', 'merge_confirmation_required'];
-function stageInstruction(stage) {
-    if (stage === 'email_verification_required') {
-        return '官方页返回显式或历史身份验证状态；按页面当前要求完成验证。普通登录只需一种有效身份，不要求补齐邮箱和手机。完成后恢复原执行。';
-    }
-    if (stage === 'merge_confirmation_required') {
-        return '官方页需要用户核对两侧账号证明及主账号，再明确确认或取消合并；这不是付款确认。不要替用户同意，不自动重启原服务或授权请求。';
-    }
-    return '用户仍在官方页面完成登录；保留当前 handoff，不要生成新二维码或新请求。';
-}
-// AUTH07: distinct outcomes stay distinct — a technical failure is never
-// reported as a user denial, and a missing session is its own state.
-const TERMINAL_SESSION_STATES = {
-    expired: {
-        status: 'auth_expired',
-        instruction: '授权请求已过期。重新运行 itpay auth login 生成新请求；之前的查询输入在服务端保留，可恢复。',
-    },
-    failed: {
-        status: 'auth_failed',
-        instruction: '官方授权因技术原因未完成（不是用户拒绝）。重新运行 itpay auth login 生成新请求。',
-    },
-    cancelled: {
-        status: 'auth_cancelled',
-        instruction: '用户在官方页取消了授权；停止登录。只有用户明确重新要求授权时才发起新的登录。',
-    },
-    denied: {
-        status: 'auth_denied',
-        instruction: '官方授权被拒绝；停止登录，不自动创建新请求。只有用户明确重新要求授权时才重新登录。',
-    },
-};
-class AuthRequestError extends Error {
-    httpStatus;
-    constructor(httpStatus, message) {
-        super(message);
-        this.httpStatus = httpStatus;
-        this.name = 'AuthRequestError';
-    }
-}
-// AUTH03: transport/read uncertainty never maps to "denied" or a new session —
-// the stored session stays on disk and the caller retries the same poll.
-function authStatusUnknown(sessionID, error, failureStage = "authorization_status_read") {
-    // These errors have definite compatibility/identity/state facts. Let the
-    // command boundary report them rather than turning them into polling.
-    if ((error instanceof HttpError && error.status < 500)
-        || (error instanceof AuthRequestError && error.httpStatus < 500)
-        || error instanceof DeviceAuthorizationError || error instanceof DeviceStateError)
-        throw error;
-    const hostFailure = error && typeof error === "object" && "code" in error
-        && (error.code === "CODEBUDDY_BROKER_DENY" || error.code === "CODEBUDDY_BROKER_OUTCOME_UNKNOWN");
-    const failure = error instanceof HttpTransportError
-        ? { category: error.code, attempts: error.attempts, source: "network_transport" }
-        : error instanceof HttpError || error instanceof AuthRequestError
-            ? { category: "http_server_error", http_status: error instanceof HttpError ? error.status : error.httpStatus, source: "http_response" }
-            : hostFailure ? { category: "host_operation_unavailable", source: "host_broker" }
-                : { category: "authorization_status_unavailable", source: "unclassified" };
-    return {
-        status: 'auth_status_unknown',
-        result: { ...failure, failure_stage: failureStage, ...(sessionID ? { dashboard_auth_session_id: sessionID } : {}) },
-        instruction: hostFailure || failure.source === 'unclassified'
-            ? '本轮授权检查未完成，底层原因尚未确定；保留设备和已有授权，请维护方核对当前失败阶段及宿主结果，不自动登录、换身份或盲目重复修改。'
-            : sessionID
-                ? '读取官方授权状态失败；原授权请求已保留。稍后重读同一状态，不要新建授权、不要清除本地登记。'
-                : '本轮账号绑定检查未完成，设备与绑定状态尚未确认；没有保存的授权请求。结束本轮，网络或服务恢复后可重新检查，不发起登录。',
-        next: sessionID && !hostFailure && failure.source !== 'unclassified' ? { command: 'itpay auth status --json', reason: '稍后重读同一授权状态', poll_after_ms: 5000 } : null,
-        recovery: [],
-    };
-}
-function sessionGone(env, purpose, baseURL, sessionID) {
-    rmSync(sellerAuthPath(baseURL, env, purpose), { force: true });
-    return {
-        status: 'auth_session_missing',
-        result: sessionID ? { dashboard_auth_session_id: sessionID } : {},
-        instruction: '之前的授权请求在服务端已不存在。重新运行 itpay auth login 生成新请求。',
-        next: { command: 'itpay auth login --json', reason: '重新发起官方授权' },
-        recovery: [],
-    };
-}
-// AUTH04: a successful bind resumes the SAME task that paused for login —
-// from the local task journal, never a placeholder and never a guess at the
-// latest order.
-function authenticatedEnvelope(env, phoneVerified) {
-    const paused = new TaskJournal(taskJournalPath(env)).pausedTasks()
-        .filter((task) => task.stage === 'login_required' || task.stage === 'quota_paused');
-    const resumable = paused.filter((task) => typeof task.resume_command === 'string');
-    const result = { bound: true, phone_verified: phoneVerified };
-    let instruction = '登录与绑定已完成，告知用户可继续之前的查询；已注册账号查询不消耗试用次数，仍受正常限流。';
-    let next = null;
-    if (resumable.length === 1) {
-        next = { command: resumable[0].resume_command, reason: '恢复登录前暂停的同一查询' };
-    }
-    else if (resumable.length > 1) {
-        result.paused_executions = resumable.map((task) => ({
-            service_execution_id: task.service_execution_id,
-            ...(task.service_id ? { service_id: task.service_id } : {}),
-            resume_command: task.resume_command,
-        }));
-        instruction += ' 有多个暂停的查询：只恢复与当前用户目标对应的那一个，不要一次恢复全部。';
-    }
-    else {
-        instruction += ' 当前没有待恢复的暂停查询；不构造恢复命令。';
-    }
-    return { status: 'authenticated', result, instruction, next, recovery: [] };
-}
-async function accountAuth(action, baseURL, env, fetcher, backend, readOnlyStatus = false) {
-    const purpose = backend ? 'agent-login' : 'seller';
-    const command = backend ? 'itpay auth status' : 'itpay sell auth status';
-    if (backend) {
-        try {
-            const current = await backend.agentAccountStatus();
-            if (current.status !== 'authenticated' && current.status !== 'login_required')
-                throw new Error('Unexpected account binding status');
-            // Preparation must not poll, bind or consume a saved browser authorization.
-            if (readOnlyStatus)
-                return { status: current.status, result: { bound: current.status === 'authenticated' }, instruction: '设备账号状态已读取。', next: null, recovery: [] };
-            if (current.status === 'authenticated')
-                return authenticatedEnvelope(env, current.phone_verified === true);
-        }
-        catch (error) {
-            if (error instanceof AuthRequestError)
-                throw error;
-            // AUTH03: even the binding-status probe can hit transport failure; the
-            // truthful state is "unknown", never an implicit unbound or a fresh login.
-            return authStatusUnknown(readOnlyStatus ? undefined : read(baseURL, env, purpose)?.sessionID, error, "account_binding_probe");
-        }
-    }
-    async function request(path, init = {}) {
-        const response = await fetcher(baseURL + path, { ...init, redirect: 'error', signal: AbortSignal.timeout(15000) });
-        if (!response.ok)
-            throw new AuthRequestError(response.status, `ItPay authorization failed (${response.status}); retry login if expired`);
-        return response;
-    }
-    function pollOpenSession(state) {
-        return request(`/v1/dashboard/auth-sessions/${encodeURIComponent(state.sessionID)}?poll_token=${encodeURIComponent(state.pollToken)}`)
-            .then((response) => response.json());
-    }
-    async function bindSavedSession(state) {
-        const bound = await backend.bindAgentAccount({ dashboard_auth_session_id: state.sessionID, start_token: state.startToken });
-        if (bound.status !== 'authenticated')
-            throw new Error('Agent binding did not complete');
-        rmSync(sellerAuthPath(baseURL, env, purpose), { force: true });
-        return authenticatedEnvelope(env, bound.phone_verified === true);
-    }
-    if (action === 'login') {
-        if (backend) {
-            const open = read(baseURL, env, purpose);
-            if (open?.sessionID && open.pollToken && open.startToken) {
-                try {
-                    const current = await pollOpenSession(open);
-                    // AUTH02: a completed-but-unbound session binds in place; never
-                    // create a second auth session for the same login.
-                    if (current.status === 'completed')
-                        return await bindSavedSession(open);
-                    if (ACTIVE_SESSION_STAGES.includes(current.status)) {
-                        const url = open.authURL ?? '';
-                        const qr = url ? await writeLocalPNG(url).catch(() => undefined) : undefined;
-                        return {
-                            status: 'auth_pending',
-                            result: {
-                                dashboard_auth_session_id: open.sessionID,
-                                stage: current.status,
-                                expires_at: current.expires_at,
-                                methods: ['phone', 'email', 'alipay', 'wechat'],
-                            },
-                            // SEC01: the handoff URL carries one-time credentials — it goes
-                            // to the human only, never into logs, prompts, or PR material.
-                            handoff: {
-                                url,
-                                contains_credentials: true,
-                                ...(qr ? { qr_local_path: qr.filePath, markdown: `![ItPay 官方授权二维码](${qr.filePath})` } : {}),
-                            },
-                            instruction: `${stageInstruction(current.status)} 沿用同一链接或二维码；不要生成新请求。`,
-                            next: { command: 'itpay auth status --json', reason: '用户完成页面登录后确认绑定', poll_after_ms: 5000 },
-                            recovery: [],
-                        };
-                    }
-                    const terminal = TERMINAL_SESSION_STATES[current.status];
-                    if (terminal) {
-                        rmSync(sellerAuthPath(baseURL, env, purpose), { force: true });
-                        // Fall through to a fresh session only after a definitive
-                        // terminal state; anything else keeps the stored session.
-                    }
-                    else {
-                        return authStatusUnknown(open.sessionID);
-                    }
-                }
-                catch (error) {
-                    if (error instanceof AuthRequestError && (error.httpStatus === 404 || error.httpStatus === 410)) {
-                        rmSync(sellerAuthPath(baseURL, env, purpose), { force: true });
-                        // The explicit login call may open one fresh session now. Status
-                        // remains read-only and still reports the missing old session.
-                    }
-                    else {
-                        return authStatusUnknown(open.sessionID, error);
-                    }
-                }
-            }
-        }
-        const response = await request('/v1/dashboard/auth-sessions', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ return_to: backend ? '/' : '/seller' }) });
-        const result = await response.json();
-        const url = new URL(result.start_url, baseURL);
-        const sameOrigin = url.origin === new URL(baseURL).origin;
-        const alipay = url.origin === 'https://openauth.alipay.com' && url.pathname === '/oauth2/publicAppAuthorize.htm' && !url.username && !url.password;
-        const local = response.headers.get('X-ItPay-Environment') === 'local_simulation'
-            && new URL(baseURL).protocol === 'http:' && new URL(baseURL).hostname === '127.0.0.1'
-            && url.protocol === 'http:' && url.hostname === '127.0.0.1' && !url.username && !url.password;
-        if (!sameOrigin && !alipay && !local)
-            throw new Error('Unexpected authorization origin');
-        const fragment = new URLSearchParams(url.hash.replace(/^#dashboard-auth\?/, ''));
-        const state = url.searchParams.get('state')?.split('.');
-        const startToken = alipay
-            ? (state?.length === 2 && state[0] === result.dashboard_auth_session_id ? state[1] : undefined)
-            : url.searchParams.get('start_token') || fragment.get('start_token');
-        if (!startToken || !result.poll_token || !result.dashboard_auth_session_id)
-            throw new Error('Incomplete authorization response');
-        save({ baseURL, sessionID: result.dashboard_auth_session_id, pollToken: result.poll_token, startToken, authURL: url.href }, env, purpose);
-        if (backend) {
-            const qr = await writeLocalPNG(url.href).catch(() => undefined);
-            return {
-                status: 'auth_pending',
-                result: {
-                    dashboard_auth_session_id: result.dashboard_auth_session_id,
-                    stage: 'created',
-                    expires_at: result.expires_at,
-                    methods: ['phone', 'email', 'alipay', 'wechat'],
-                },
-                handoff: {
-                    url: url.href,
-                    contains_credentials: true,
-                    ...(qr ? { qr_local_path: qr.filePath, markdown: `![ItPay 官方授权二维码](${qr.filePath})` } : {}),
-                },
-                instruction: '把官方授权页或二维码交给用户。用户在页面内选择手机号验证码、邮箱或钱包完成登录；不要替用户输入手机号或验证码，start_token 不要写入聊天记录或日志。',
-                next: { command: 'itpay auth status --json', reason: '用户完成页面登录后确认绑定', poll_after_ms: 5000 },
-                recovery: [],
-            };
-        }
-        return { status: 'authorization_required', authorization_url: url.href, instruction: `Complete ItPay login in the browser, then run ${command}.` };
-    }
-    const state = read(baseURL, env, purpose);
-    if (action === 'logout') {
-        const token = sellerSessionToken(baseURL, env);
-        if (token)
-            await request('/v1/me/logout', { method: 'POST', headers: { Authorization: `Bearer ${token}` } });
-        rmSync(sellerAuthPath(baseURL, env), { force: true });
-        return { status: 'logged_out' };
-    }
-    if (!backend && sellerSessionToken(baseURL, env))
-        return { status: 'authenticated', base_url: baseURL, expires_at: state?.expiresAt };
-    if (!state?.sessionID || !state.pollToken || !state.startToken) {
-        // AUTH07: a bare `status` with no session is its own truthful state, not a
-        // failure and not an implicit login.
-        if (!backend)
-            return { status: 'login_required' };
-        return {
-            status: 'login_required',
-            result: {},
-            instruction: '当前设备尚未绑定账号，也没有进行中的授权请求。需要时运行 itpay auth login 发起官方登录。',
-            next: { command: 'itpay auth login --json', reason: '需要账号绑定时发起官方授权' },
-            recovery: [],
-        };
-    }
-    let progress;
-    try {
-        progress = await pollOpenSession(state);
-    }
-    catch (error) {
-        if (error instanceof AuthRequestError && (error.httpStatus === 404 || error.httpStatus === 410)) {
-            return sessionGone(env, purpose, baseURL, state.sessionID);
-        }
-        return authStatusUnknown(state.sessionID, error);
-    }
-    if (progress.status !== 'completed') {
-        if (backend) {
-            const terminal = TERMINAL_SESSION_STATES[progress.status];
-            if (terminal) {
-                rmSync(sellerAuthPath(baseURL, env, purpose), { force: true });
-                return {
-                    status: terminal.status,
-                    result: { dashboard_auth_session_id: state.sessionID, stage: progress.status },
-                    instruction: terminal.instruction,
-                    next: ['denied', 'cancelled'].includes(progress.status) ? null : { command: 'itpay auth login --json', reason: '需要登录时重新发起官方授权' },
-                    recovery: [],
-                };
-            }
-            return {
-                status: 'auth_pending',
-                result: {
-                    dashboard_auth_session_id: state.sessionID,
-                    stage: progress.status,
-                    ...(progress.expires_at ? { expires_at: progress.expires_at } : {}),
-                },
-                instruction: stageInstruction(progress.status),
-                next: { command: 'itpay auth status --json', reason: '轮询同一授权请求', poll_after_ms: 5000 },
-                recovery: [],
-            };
-        }
-        return { status: progress.status, instruction: 'Finish login and email verification in the browser.' };
-    }
-    if (backend) {
-        try {
-            return await bindSavedSession(state);
-        }
-        catch (error) {
-            if (error instanceof AuthRequestError)
-                throw error;
-            // Binding outcome unknown: keep the session so a retry can still bind
-            // the same completed login instead of creating a new one.
-            return authStatusUnknown(state.sessionID, error);
-        }
-    }
-    const claimed = await request(`/v1/dashboard/auth-sessions/${encodeURIComponent(state.sessionID)}/claim?start_token=${encodeURIComponent(state.startToken)}`, { method: 'POST' });
-    const token = /(?:^|[, ]+)itpay_buyer_session=([^;]+)/.exec(claimed.headers.get('set-cookie') ?? '')?.[1];
-    const session = await claimed.json();
-    if (!token || !session.expires_at || !(Date.parse(session.expires_at) > Date.now()))
-        throw new Error('Incomplete Seller session');
-    save({ baseURL, sessionToken: token, expiresAt: session.expires_at }, env);
-    return { status: 'authenticated', base_url: baseURL, expires_at: session.expires_at };
-}
-import { stateDir } from "./config.js";

package/dist/src/state/agent_type.js

@@ -1,25 +0,0 @@
-export function declaredAgentType(env = process.env, argv = process.argv) {
-    if (env.ITPAY_AGENT_TYPE)
-        return canonicalAgentType(env.ITPAY_AGENT_TYPE);
-    for (let index = 0; index < argv.length; index += 1) {
-        const value = argv[index];
-        if (value === "--agent-type")
-            return canonicalAgentType(argv[index + 1]);
-        if (value?.startsWith("--agent-type="))
-            return canonicalAgentType(value.slice("--agent-type=".length));
-    }
-    return undefined;
-}
-export function canonicalAgentType(value) {
-    const normalized = value?.trim().toLowerCase();
-    if (!normalized)
-        return undefined;
-    return normalized === "codex" ? "codex-desktop" : normalized;
-}
-export function qualifyItPayCommand(command, agentType) {
-    if (!agentType || !/^[a-z0-9-]+$/.test(agentType))
-        return command;
-    if (!command.startsWith("itpay ") || /^itpay\s+--agent-type(?:=|\s)/.test(command))
-        return command;
-    return `itpay --agent-type ${agentType} ${command.slice("itpay ".length)}`;
-}

package/dist/src/state/cart_session.js

@@ -1,150 +0,0 @@
-// Cart session for the V3 CLI with file persistence. Server cart is the
-// business source of truth; this file is a handle cache plus an explicit local
-// draft compatibility layer. Do not rely on local items for Service Execution
-// or quota facts.
-import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { randomUUID } from "node:crypto";
-import { dirname } from "node:path";
-export class CartSession {
-    state;
-    loadFailed = false;
-    constructor(currency) {
-        this.state = { currency, items: [] };
-    }
-    static loadFromFile(path, currency) {
-        const session = new CartSession(currency);
-        if (existsSync(path)) {
-            try {
-                const raw = readFileSync(path, "utf-8");
-                const persisted = JSON.parse(raw);
-                if (Array.isArray(persisted.items)) {
-                    persisted.items.forEach((item) => {
-                        if (item.catalogVariantID && item.offerID && item.quantity > 0) {
-                            session.state.items.push({ ...item });
-                        }
-                    });
-                }
-                if (persisted.lastCartID)
-                    session.state.lastCartID = persisted.lastCartID;
-                if (persisted.lastCartItemID)
-                    session.state.lastCartItemID = persisted.lastCartItemID;
-                if (persisted.lastServiceExecutionID)
-                    session.state.lastServiceExecutionID = persisted.lastServiceExecutionID;
-                if (persisted.lastCheckoutID)
-                    session.state.lastCheckoutID = persisted.lastCheckoutID;
-                if (persisted.lastDisplayToken)
-                    session.state.lastDisplayToken = persisted.lastDisplayToken;
-                if (persisted.lastCheckoutURL)
-                    session.state.lastCheckoutURL = persisted.lastCheckoutURL;
-            }
-            catch {
-                session.state.items = [];
-                session.loadFailed = true;
-            }
-        }
-        return session;
-    }
-    saveToFile(path) {
-        const toSave = {
-            currency: this.state.currency,
-            items: this.state.items.map((item) => ({ ...item })),
-            ...(this.state.lastCartID ? { lastCartID: this.state.lastCartID } : {}),
-            ...(this.state.lastCartItemID ? { lastCartItemID: this.state.lastCartItemID } : {}),
-            ...(this.state.lastServiceExecutionID ? { lastServiceExecutionID: this.state.lastServiceExecutionID } : {}),
-            ...(this.state.lastCheckoutID ? { lastCheckoutID: this.state.lastCheckoutID } : {}),
-            ...(this.state.lastDisplayToken ? { lastDisplayToken: this.state.lastDisplayToken } : {}),
-            ...(this.state.lastCheckoutURL ? { lastCheckoutURL: this.state.lastCheckoutURL } : {}),
-        };
-        const contents = JSON.stringify(toSave, null, 2);
-        if (existsSync(path) && readFileSync(path, "utf-8") === contents)
-            return;
-        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-        const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
-        writeFileSync(temporary, contents, { encoding: "utf-8", mode: 0o600 });
-        chmodSync(temporary, 0o600);
-        renameSync(temporary, path);
-        chmodSync(path, 0o600);
-    }
-    add(item) {
-        if (item.quantity <= 0) {
-            throw new Error("quantity must be > 0");
-        }
-        const existing = this.state.items.find((i) => i.catalogVariantID === item.catalogVariantID && i.offerID === item.offerID);
-        if (existing) {
-            existing.quantity += item.quantity;
-            if (item.input)
-                existing.input = item.input;
-            return;
-        }
-        this.state.items.push({ ...item });
-    }
-    remove(variantID, offerID) {
-        const before = this.state.items.length;
-        this.state.items = this.state.items.filter((i) => !(i.catalogVariantID === variantID && i.offerID === offerID));
-        if (this.state.items.length === before) {
-            throw new Error(`no line matches variant=${variantID} offer=${offerID}`);
-        }
-    }
-    clear() {
-        this.state = { currency: this.state.currency, items: [] };
-    }
-    show() {
-        return JSON.parse(JSON.stringify(this.state));
-    }
-    toCreateCartRequest() {
-        return {
-            currency: this.state.currency,
-            items: this.state.items.map((item) => ({
-                catalog_item_id: item.catalogItemID,
-                catalog_variant_id: item.catalogVariantID,
-                offer_id: item.offerID,
-                quantity: item.quantity,
-                ...(item.input ? { input: item.input } : {}),
-            })),
-        };
-    }
-    rememberCheckout(input) {
-        this.state.items = [];
-        delete this.state.lastCartID;
-        delete this.state.lastCartItemID;
-        this.state.lastCheckoutID = input.checkoutID;
-        this.state.lastDisplayToken = input.displayToken;
-        this.state.lastCheckoutURL = input.checkoutURL;
-        if (input.serviceExecutionID)
-            this.state.lastServiceExecutionID = input.serviceExecutionID;
-    }
-    rememberServerCart(input) {
-        this.state.items = [];
-        this.state.lastCartID = input.cartID;
-        delete this.state.lastCartItemID;
-        delete this.state.lastServiceExecutionID;
-        delete this.state.lastCheckoutID;
-        delete this.state.lastDisplayToken;
-        delete this.state.lastCheckoutURL;
-        if (input.cartItemID)
-            this.state.lastCartItemID = input.cartItemID;
-        if (input.serviceExecutionID)
-            this.state.lastServiceExecutionID = input.serviceExecutionID;
-    }
-    get lastCartID() {
-        return this.state.lastCartID;
-    }
-    get lastCartItemID() {
-        return this.state.lastCartItemID;
-    }
-    get lastServiceExecutionID() {
-        return this.state.lastServiceExecutionID;
-    }
-    get lastCheckoutID() {
-        return this.state.lastCheckoutID;
-    }
-    get lastDisplayToken() {
-        return this.state.lastDisplayToken;
-    }
-    get currency() {
-        return this.state.currency;
-    }
-    get stateLoadFailed() {
-        return this.loadFailed;
-    }
-}