@itpay/cli 2.0.3 → 2.0.7

package/dist/src/render/output.js

@@ -3,9 +3,6 @@ export function formatMoney(amountMinor, currency) {
     const major = (amountMinor / 100).toFixed(2);
     return `${major} ${currency}`;
 }
-export function renderReady(payload) {
-    return `backend ${payload.status} (version ${payload.version})`;
-}
 export function renderOrder(order) {
     const lines = [];
     lines.push(`order ${order.order_id}`);
@@ -36,6 +33,8 @@ export function renderRefund(refund) {
         `  status:  ${refund.status}`,
         `  amount:  ${formatMoney(refund.amount_minor, refund.currency)}`,
         refund.reason ? `  reason:  ${refund.reason}` : "",
+        `  access:  ${refund.access_locked ? "locked" : "available"}`,
+        `  policy:  ${refund.decision_mode === "automatic" ? "automatic" : "admin review"}`,
     ]
         .filter((line) => line.length > 0)
         .join("\n");

package/dist/src/state/agent_type.js

@@ -0,0 +1,19 @@
+export function declaredAgentType(env = process.env, argv = process.argv) {
+    if (env.ITPAY_AGENT_TYPE)
+        return env.ITPAY_AGENT_TYPE;
+    for (let index = 0; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value === "--agent-type")
+            return argv[index + 1];
+        if (value?.startsWith("--agent-type="))
+            return value.slice("--agent-type=".length);
+    }
+    return undefined;
+}
+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

@@ -7,6 +7,7 @@ import { randomUUID } from "node:crypto";
 import { dirname } from "node:path";
 export class CartSession {
     state;
+    loadFailed = false;
     constructor(currency) {
         this.state = { currency, items: [] };
     }
@@ -23,8 +24,6 @@ export class CartSession {
                         }
                     });
                 }
-                if (persisted.agentDeviceID)
-                    session.state.agentDeviceID = persisted.agentDeviceID;
                 if (persisted.lastCartID)
                     session.state.lastCartID = persisted.lastCartID;
                 if (persisted.lastCartItemID)
@@ -40,6 +39,7 @@ export class CartSession {
             }
             catch {
                 session.state.items = [];
+                session.loadFailed = true;
             }
         }
         return session;
@@ -48,7 +48,6 @@ export class CartSession {
         const toSave = {
             currency: this.state.currency,
             items: this.state.items.map((item) => ({ ...item })),
-            ...(this.state.agentDeviceID ? { agentDeviceID: this.state.agentDeviceID } : {}),
             ...(this.state.lastCartID ? { lastCartID: this.state.lastCartID } : {}),
             ...(this.state.lastCartItemID ? { lastCartItemID: this.state.lastCartItemID } : {}),
             ...(this.state.lastServiceExecutionID ? { lastServiceExecutionID: this.state.lastServiceExecutionID } : {}),
@@ -84,11 +83,7 @@ export class CartSession {
         }
     }
     clear() {
-        this.state = {
-            currency: this.state.currency,
-            items: [],
-            ...(this.state.agentDeviceID ? { agentDeviceID: this.state.agentDeviceID } : {}),
-        };
+        this.state = { currency: this.state.currency, items: [] };
     }
     show() {
         return JSON.parse(JSON.stringify(this.state));
@@ -107,7 +102,8 @@ export class CartSession {
     }
     rememberCheckout(input) {
         this.state.items = [];
-        this.state.lastCartID = input.cartID;
+        delete this.state.lastCartID;
+        delete this.state.lastCartItemID;
         this.state.lastCheckoutID = input.checkoutID;
         this.state.lastDisplayToken = input.displayToken;
         this.state.lastCheckoutURL = input.checkoutURL;
@@ -117,18 +113,15 @@ export class CartSession {
     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;
-        if (input.agentDeviceID)
-            this.state.agentDeviceID = input.agentDeviceID;
-    }
-    ensureAgentDeviceID(fallback) {
-        if (!this.state.agentDeviceID) {
-            this.state.agentDeviceID = fallback;
-        }
-        return this.state.agentDeviceID;
     }
     get lastCartID() {
         return this.state.lastCartID;
@@ -148,4 +141,7 @@ export class CartSession {
     get currency() {
         return this.state.currency;
     }
+    get stateLoadFailed() {
+        return this.loadFailed;
+    }
 }

package/dist/src/state/client_context.js

@@ -56,10 +56,12 @@ export function hasDedicatedRenderer(host) {
 }
 export function defaultHostForAgentType(agentType) {
     const normalized = agentType?.trim().toLowerCase() ?? "";
-    if (normalized.startsWith("codex"))
+    if (normalized === "codex-desktop")
         return "codex";
-    if (normalized.startsWith("claude-code"))
+    if (normalized === "claude-code-desktop")
         return "claude-code";
+    if (normalized === "workbuddy")
+        return "plain-chat";
     return "terminal";
 }
 export function validateContext(host, target) {

package/dist/src/state/config.js

@@ -6,11 +6,12 @@ import { mkdirSync } from "node:fs";
 import { resolve } from "node:path";
 import { HttpClient } from "../client/http.js";
 import { BackendClient } from "../client/backend.js";
+import { declaredAgentType } from "./agent_type.js";
 import { DeviceAuthority } from "./device_authority.js";
 import { OperationJournal } from "./operation_journal.js";
 export const DEFAULT_BASE_URL = "https://app.itpay.ai";
-export const CLI_VERSION = "2.0.3";
-export const API_CONTRACT_REVISION = "sha256:d2870f3ee6fa4ee8a0a3ee75ae272a1a476935aae824123cf46607d62168f1f2";
+export const CLI_VERSION = "2.0.7";
+export const API_CONTRACT_REVISION = "sha256:47d42ab7bbe74a806b9ec989384b28ad715ffcf05a5eb913449b8bc224ffcf49";
 const CART_SESSION_DEFAULT_DIR = ".itpay-v3";
 const CART_SESSION_FILENAME = "cart.json";
 const OPERATION_JOURNAL_FILENAME = "operations.json";
@@ -25,15 +26,13 @@ export function cartSessionPath(env = process.env) {
 export function loadConfig(env = process.env) {
     const baseURL = env.ITPAY_BACKEND_URL || DEFAULT_BASE_URL;
     const bearerToken = env.ITPAY_BEARER_TOKEN || undefined;
-    const agentDeviceID = env.ITPAY_AGENT_DEVICE_ID || "";
-    const agentType = env.ITPAY_AGENT_TYPE || agentTypeFromArgv(process.argv);
+    const agentType = declaredAgentType(env);
     const checkoutCurrency = env.ITPAY_CURRENCY || "CNY";
     const idempotencyKey = env.ITPAY_IDEMPOTENCY_KEY || `cli_${shortRandom()}`;
     const ideImageAttach = env.ITPAY_IDE_IMAGE_ATTACH !== "0";
     const ideImageDirOverride = env.ITPAY_IDE_IMAGE_DIR_OVERRIDE;
     return {
         baseURL,
-        agentDeviceID,
         ...(agentType ? { agentType } : {}),
         checkoutCurrency,
         idempotencyKey,
@@ -64,19 +63,10 @@ export function newBackendClient(config) {
             "X-ItPay-Contract-Revision": API_CONTRACT_REVISION,
         },
         requestAuthorizer: (input) => authority.authorizationHeaders(input),
+        recoverAuthorization: () => authority.recoverAuthorization(),
     });
     return new BackendClient(http);
 }
-function agentTypeFromArgv(argv) {
-    for (let index = 0; index < argv.length; index += 1) {
-        const value = argv[index];
-        if (value === "--agent-type")
-            return argv[index + 1];
-        if (value?.startsWith("--agent-type="))
-            return value.slice("--agent-type=".length);
-    }
-    return undefined;
-}
 function shortRandom() {
     return Math.random().toString(36).slice(2, 10) + Math.random().toString(36).slice(2, 6);
 }

package/dist/src/state/device_authority.js

@@ -1,10 +1,11 @@
-import { createHash, createPrivateKey, generateKeyPairSync, randomUUID, sign, } from "node:crypto";
-import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync, randomUUID, sign, } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmdirSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, resolve } from "node:path";
-const PROTECTED_PATHS = ["/v1/carts", "/v1/service-executions", "/v1/agent-instances"];
+const PROTECTED_PATHS = ["/v1/carts", "/v1/service-executions", "/v1/agent-instances", "/v1/orders", "/v1/refunds"];
 export class DeviceAuthority {
     baseURL;
+    backendKey;
     requestedAgentType;
     compatibilityHeaders;
     statePath;
@@ -13,6 +14,7 @@ export class DeviceAuthority {
     pending;
     constructor(options) {
         this.baseURL = options.baseURL.replace(/\/$/, "");
+        this.backendKey = normalizeBackendKey(options.baseURL);
         this.requestedAgentType = options.requestedAgentType;
         this.compatibilityHeaders = options.compatibilityHeaders;
         const root = resolve(homedir(), ".itpay-v3", "device");
@@ -47,54 +49,93 @@ export class DeviceAuthority {
         }
         return this.pending;
     }
+    async recoverAuthorization() {
+        await withFileLock(`${this.statePath}.lock`, async () => {
+            const state = this.readState();
+            if (!state || !this.requestedAgentType)
+                return;
+            const registration = state.registrations[this.backendKey];
+            if (!registration)
+                return;
+            delete registration.sessions[this.requestedAgentType];
+            this.writeState(state);
+        });
+    }
+    async recoverBackendReset() {
+        return withFileLock(`${this.statePath}.lock`, async () => {
+            const state = this.readState();
+            const registration = state?.registrations[this.backendKey];
+            if (!state || !registration)
+                return { removed: false, agentTypes: [] };
+            const agentTypes = Object.keys(registration.agentInstances).sort();
+            delete state.registrations[this.backendKey];
+            this.writeState(state);
+            return { removed: true, agentTypes };
+        });
+    }
     async prepareAuthorization() {
-        let state = this.readState();
-        const agentType = this.requestedAgentType ?? firstAgentType(state);
+        let state = this.readState() ?? emptyDeviceState();
+        const agentType = this.requestedAgentType;
         if (!agentType) {
             throw new Error("agent type is required for ItPay commerce; pass --agent-type <type> or set ITPAY_AGENT_TYPE");
         }
         let privateKey = this.readPrivateKey();
-        if (!state || !privateKey) {
-            const enrolled = await this.enroll(agentType);
-            state = enrolled.state;
-            privateKey = enrolled.privateKey;
+        if (!privateKey) {
+            const pair = generateKeyPairSync("ed25519");
+            privateKey = pair.privateKey;
+            this.writePrivateKey(pair.privateKey.export({ format: "pem", type: "pkcs8" }).toString());
+            state = emptyDeviceState();
         }
-        if (!state.agentInstances[agentType]) {
-            const existingType = firstAgentType(state);
+        let registration = state.registrations[this.backendKey];
+        if (!registration && state.legacyRegistration) {
+            try {
+                await this.ensureRegistrationAgentType(state.legacyRegistration, agentType, privateKey, true);
+                registration = state.legacyRegistration;
+                delete state.legacyRegistration;
+            }
+            catch (error) {
+                if (!canMovePastLegacyRegistration(error))
+                    throw error;
+            }
+        }
+        if (!registration) {
+            registration = await this.enroll(agentType, privateKey);
+        }
+        state.registrations[this.backendKey] = registration;
+        const session = await this.ensureRegistrationAgentType(registration, agentType, privateKey, false);
+        this.writeState(state);
+        return { state: registration, agentType, session, privateKey };
+    }
+    async ensureRegistrationAgentType(registration, agentType, privateKey, forceSession) {
+        if (!registration.agentInstances[agentType]) {
+            const existingType = firstAgentType(registration);
             if (!existingType)
                 throw new Error("device has no registered agent instance");
-            const existingSession = await this.ensureSession(state, existingType, privateKey);
-            const registered = await this.signedJSON("/v1/agent-instances", { agent_type: agentType }, state, existingType, existingSession, privateKey);
-            state.agentInstances[agentType] = registered.agent_instance_id;
-            this.writeState(state);
+            const existingSession = await this.ensureSession(registration, existingType, privateKey, forceSession);
+            const registered = await this.signedJSON("/v1/agent-instances", { agent_type: agentType }, registration, existingType, existingSession, privateKey);
+            registration.agentInstances[agentType] = registered.agent_instance_id;
         }
-        const session = await this.ensureSession(state, agentType, privateKey);
-        return { state, agentType, session, privateKey };
+        return this.ensureSession(registration, agentType, privateKey, forceSession);
     }
-    async enroll(agentType) {
-        const pair = generateKeyPairSync("ed25519");
-        const publicJWK = pair.publicKey.export({ format: "jwk" });
+    async enroll(agentType, privateKey) {
+        const publicJWK = createPublicKey(privateKey).export({ format: "jwk" });
         if (!publicJWK.x)
             throw new Error("unable to export Ed25519 public key");
         const publicKey = Buffer.from(publicJWK.x, "base64url").toString("base64");
         const started = await this.publicJSON("/v1/agent-device-enrollments", { public_key: publicKey, agent_type: agentType });
         const proof = enrollmentProofMessage(started.agent_device_enrollment_id, started.challenge);
-        const verified = await this.publicJSON(`/v1/agent-device-enrollments/${encodeURIComponent(started.agent_device_enrollment_id)}/verify`, { challenge: started.challenge, signature: sign(null, Buffer.from(proof), pair.privateKey).toString("base64") });
-        const state = {
-            schemaVersion: "itpay.device.v1",
+        const verified = await this.publicJSON(`/v1/agent-device-enrollments/${encodeURIComponent(started.agent_device_enrollment_id)}/verify`, { challenge: started.challenge, signature: sign(null, Buffer.from(proof), privateKey).toString("base64") });
+        return {
             deviceID: verified.agent_device_id,
             deviceKeyID: verified.agent_device_key_id,
             quotaLineageID: verified.quota_lineage_id,
             agentInstances: { [verified.agent_type]: verified.agent_instance_id },
             sessions: {},
         };
-        this.writePrivateKey(pair.privateKey.export({ format: "pem", type: "pkcs8" }).toString());
-        this.writeState(state);
-        return { state, privateKey: pair.privateKey };
     }
-    async ensureSession(state, agentType, privateKey) {
+    async ensureSession(state, agentType, privateKey, force = false) {
         const existing = state.sessions[agentType];
-        if (existing && Date.parse(existing.expiresAt) > Date.now() + 60_000)
+        if (!force && existing && Date.parse(existing.expiresAt) > Date.now() + 60_000)
             return existing;
         const instanceID = state.agentInstances[agentType];
         if (!instanceID)
@@ -107,7 +148,6 @@ export class DeviceAuthority {
         const verified = await this.publicJSON(`/v1/agent-device-session-challenges/${encodeURIComponent(challenge.agent_device_session_challenge_id)}/verify`, { challenge: challenge.challenge, signature: sign(null, Buffer.from(proof), privateKey).toString("base64") });
         const session = { token: verified.session_token, expiresAt: verified.expires_at };
         state.sessions[agentType] = session;
-        this.writeState(state);
         return session;
     }
     async signedJSON(path, bodyValue, state, agentType, session, privateKey) {
@@ -137,16 +177,26 @@ export class DeviceAuthority {
         });
         const payload = await response.json().catch(() => ({}));
         if (!response.ok)
-            throw new Error(payload.message || payload.code || `ItPay device request failed: ${response.status}`);
+            throw new DeviceAuthorizationError(response.status, payload.code, payload.message || payload.code || `ItPay device request failed: ${response.status}`);
         return payload;
     }
     readState() {
         if (!existsSync(this.statePath))
             return undefined;
         try {
-            return JSON.parse(readFileSync(this.statePath, "utf8"));
+            const parsed = JSON.parse(readFileSync(this.statePath, "utf8"));
+            if (parsed.schemaVersion === "itpay.device.v2")
+                return parsed;
+            if (parsed.schemaVersion === "itpay.device.v1") {
+                const { schemaVersion: _, ...legacyRegistration } = parsed;
+                return { ...emptyDeviceState(), legacyRegistration };
+            }
+            return undefined;
         }
-        catch {
+        catch (error) {
+            const stateError = asDeviceStateError(error, "read_state");
+            if (stateError)
+                throw stateError;
             return undefined;
         }
     }
@@ -156,62 +206,130 @@ export class DeviceAuthority {
         try {
             return createPrivateKey(readFileSync(this.privateKeyPath, "utf8"));
         }
-        catch {
+        catch (error) {
+            const stateError = asDeviceStateError(error, "read_private_key");
+            if (stateError)
+                throw stateError;
             return undefined;
         }
     }
-    writeState(state) { atomicOwnerOnlyWrite(this.statePath, JSON.stringify(state, null, 2)); }
-    writePrivateKey(value) { atomicOwnerOnlyWrite(this.privateKeyPath, value); }
+    writeState(state) { atomicOwnerOnlyWrite(this.statePath, JSON.stringify(state, null, 2), "write_state"); }
+    writePrivateKey(value) { atomicOwnerOnlyWrite(this.privateKeyPath, value, "write_private_key"); }
+}
+export class DeviceAuthorizationError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "DeviceAuthorizationError";
+    }
+}
+export class DeviceStateError extends Error {
+    operation;
+    causeCode;
+    code = "device_state_unwritable";
+    constructor(operation, causeCode) {
+        super(`ItPay device state operation failed: ${operation} (${causeCode})`);
+        this.operation = operation;
+        this.causeCode = causeCode;
+        this.name = "DeviceStateError";
+    }
+}
+function emptyDeviceState() {
+    return { schemaVersion: "itpay.device.v2", registrations: {} };
+}
+function firstAgentType(state) { return Object.keys(state.agentInstances)[0]; }
+function canMovePastLegacyRegistration(error) {
+    return error instanceof DeviceAuthorizationError && (error.code === "agent_device_revoked" || error.status === 404);
+}
+function normalizeBackendKey(value) {
+    const url = new URL(value);
+    url.search = "";
+    url.hash = "";
+    url.pathname = url.pathname.replace(/\/+$/, "");
+    return url.toString().replace(/\/$/, "");
 }
-function firstAgentType(state) { return state ? Object.keys(state.agentInstances)[0] : undefined; }
 function sha256(value) { return `sha256:${createHash("sha256").update(value).digest("hex")}`; }
 function enrollmentProofMessage(id, challenge) { return `itpay-device-enrollment/v1\n${id}\n${challenge}`; }
 function deviceSessionProofMessage(id, challenge) { return `itpay-device-session/v1\n${id}\n${challenge}`; }
 function requestProofMessage(method, path, bodyHash, timestamp, jti) { return ["itpay-agent-request/v1", method, path, bodyHash, timestamp, jti].join("\n"); }
-function atomicOwnerOnlyWrite(path, value) {
-    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+function atomicOwnerOnlyWrite(path, value, operation) {
     const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
-    writeFileSync(temporary, value, { encoding: "utf8", mode: 0o600 });
-    chmodSync(temporary, 0o600);
-    renameSync(temporary, path);
-    chmodSync(path, 0o600);
+    try {
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        writeFileSync(temporary, value, { encoding: "utf8", mode: 0o600 });
+        chmodSync(temporary, 0o600);
+        renameSync(temporary, path);
+        chmodSync(path, 0o600);
+    }
+    catch (error) {
+        try {
+            unlinkSync(temporary);
+        }
+        catch { /* best-effort cleanup */ }
+        throw asDeviceStatePathError(error, operation) ?? error;
+    }
 }
 async function withFileLock(path, run) {
-    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-    let descriptor;
+    try {
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    }
+    catch (error) {
+        throw asDeviceStatePathError(error, "prepare_lock") ?? error;
+    }
+    let acquired = false;
     for (let attempt = 0; attempt < 200; attempt += 1) {
         try {
-            descriptor = openSync(path, "wx", 0o600);
+            mkdirSync(path, { mode: 0o700 });
+            acquired = true;
             break;
         }
         catch (error) {
             const code = error.code;
             if (code !== "EEXIST")
-                throw error;
+                throw asDeviceStateError(error, "acquire_lock") ?? error;
             try {
                 if (Date.now() - statSync(path).mtimeMs > 30_000)
-                    unlinkSync(path);
+                    removeLock(path, "remove_stale_lock");
             }
             catch (statError) {
-                if (statError.code !== "ENOENT")
-                    throw statError;
+                if (statError.code !== "ENOENT") {
+                    throw asDeviceStateError(statError, "inspect_lock") ?? statError;
+                }
             }
             await new Promise((resolve) => setTimeout(resolve, 25));
         }
     }
-    if (descriptor === undefined)
+    if (!acquired)
         throw new Error("timed out waiting for ItPay device identity lock");
     try {
         return await run();
     }
     finally {
-        closeSync(descriptor);
-        try {
+        removeLock(path, "release_lock");
+    }
+}
+function removeLock(path, operation) {
+    try {
+        if (statSync(path).isDirectory())
+            rmdirSync(path);
+        else
             unlinkSync(path);
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                throw error;
-        }
     }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw asDeviceStateError(error, operation) ?? error;
+    }
+}
+function asDeviceStateError(error, operation) {
+    const code = error.code;
+    return code === "EACCES" || code === "EPERM" || code === "EROFS" || code === "ENOTDIR" || code === "EISDIR"
+        ? new DeviceStateError(operation, code)
+        : undefined;
+}
+function asDeviceStatePathError(error, operation) {
+    const code = error.code;
+    return code === "EEXIST" ? new DeviceStateError(operation, code) : asDeviceStateError(error, operation);
 }