@itpay/cli 0.2.17 → 2.0.0-rc.2

package/dist/src/state/cart_session.js

@@ -0,0 +1,151 @@
+// 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;
+    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.agentDeviceID)
+                    session.state.agentDeviceID = persisted.agentDeviceID;
+                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 = [];
+            }
+        }
+        return session;
+    }
+    saveToFile(path) {
+        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 } : {}),
+            ...(this.state.lastCheckoutID ? { lastCheckoutID: this.state.lastCheckoutID } : {}),
+            ...(this.state.lastDisplayToken ? { lastDisplayToken: this.state.lastDisplayToken } : {}),
+            ...(this.state.lastCheckoutURL ? { lastCheckoutURL: this.state.lastCheckoutURL } : {}),
+        };
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+        writeFileSync(temporary, JSON.stringify(toSave, null, 2), { 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: [],
+            ...(this.state.agentDeviceID ? { agentDeviceID: this.state.agentDeviceID } : {}),
+        };
+    }
+    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 = [];
+        this.state.lastCartID = input.cartID;
+        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;
+        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;
+    }
+    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;
+    }
+}

package/dist/src/state/client_context.js

@@ -0,0 +1,73 @@
+// V3 CLI client-context: which host is the CLI running under, and what
+// target (chat id, channel id, etc.) it has. Mirrors the role of V1's
+// `lib/client-context.js` but kept narrow: no I/O, no env I/O beyond the
+// raw values the caller passes in.
+export const SUPPORTED_HOSTS = new Set([
+    "terminal",
+    "codex",
+    "claude-code",
+    "telegram",
+    "discord",
+    "whatsapp",
+    "feishu",
+    "lark",
+    "plain-chat",
+]);
+// Hosts that have a real renderer attached. Discord / WhatsApp currently
+// only have host validation and fall back to plain-chat, matching V1.
+export const HOSTS_WITH_DEDICATED_RENDERER = new Set([
+    "terminal",
+    "codex",
+    "claude-code",
+    "telegram",
+    "feishu",
+    "lark",
+]);
+// Telegram/Discord/WhatsApp/Feishu/Lark all require a stable target so we
+// can route replies / callback answers back to the right chat.
+export const HOSTS_REQUIRING_TARGET = new Set([
+    "telegram",
+    "discord",
+    "whatsapp",
+    "feishu",
+    "lark",
+]);
+const HOST_ALIASES = {
+    tg: "telegram",
+    "openclaw-telegram": "telegram",
+    trae: "codex",
+    "trae-agent": "codex",
+    feishu_im: "feishu",
+    fs: "feishu",
+};
+export function normalizeHost(raw) {
+    if (!raw)
+        return undefined;
+    const lower = raw.trim().toLowerCase();
+    if (SUPPORTED_HOSTS.has(lower))
+        return lower;
+    return HOST_ALIASES[lower];
+}
+export function requiresTarget(host) {
+    return HOSTS_REQUIRING_TARGET.has(host);
+}
+export function hasDedicatedRenderer(host) {
+    return HOSTS_WITH_DEDICATED_RENDERER.has(host);
+}
+export function defaultHostForAgentType(agentType) {
+    const normalized = agentType?.trim().toLowerCase() ?? "";
+    if (normalized.startsWith("codex"))
+        return "codex";
+    if (normalized.startsWith("claude-code"))
+        return "claude-code";
+    return "terminal";
+}
+export function validateContext(host, target) {
+    if (!host) {
+        return { code: "client_context_required", message: "--host is required" };
+    }
+    if (requiresTarget(host) && !target) {
+        return { code: "target_required", message: `--target is required for host ${host}` };
+    }
+    return undefined;
+}

package/dist/src/state/config.js

@@ -0,0 +1,82 @@
+// CLI configuration loader. Reads config from environment only. Checkout
+// display-token persistence belongs to the cart session file, protected with
+// owner-only permissions. Provider secrets are explicitly out of scope here.
+import { homedir } from "node:os";
+import { mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { HttpClient } from "../client/http.js";
+import { BackendClient } from "../client/backend.js";
+import { DeviceAuthority } from "./device_authority.js";
+import { OperationJournal } from "./operation_journal.js";
+export const DEFAULT_BASE_URL = "https://test.itpay.ai";
+export const CLI_VERSION = "2.0.0-rc.2";
+export const API_CONTRACT_REVISION = "sha256:2c2829f4618c47bc505efc0ded853cf639d775585ba13aa23012197e39efa31f";
+const CART_SESSION_DEFAULT_DIR = ".itpay-v3";
+const CART_SESSION_FILENAME = "cart.json";
+const OPERATION_JOURNAL_FILENAME = "operations.json";
+export function cartSessionPath(env = process.env) {
+    if (env.ITPAY_CART_SESSION_PATH) {
+        return resolve(env.ITPAY_CART_SESSION_PATH);
+    }
+    const dir = resolve(homedir(), CART_SESSION_DEFAULT_DIR);
+    mkdirSync(dir, { recursive: true });
+    return resolve(dir, CART_SESSION_FILENAME);
+}
+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 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,
+        ...(!env.ITPAY_IDEMPOTENCY_KEY ? { operationJournal: new OperationJournal(resolve(homedir(), CART_SESSION_DEFAULT_DIR, OPERATION_JOURNAL_FILENAME)) } : {}),
+        ideImageAttach,
+        ...(ideImageDirOverride ? { ideImageDirOverride } : {}),
+        ...(bearerToken ? { bearerToken } : {}),
+    };
+}
+export function operationID(config, operationKey) {
+    if (config.operationJournal)
+        return config.operationJournal.getOrCreate(operationKey);
+    return Promise.resolve(config.idempotencyKey);
+}
+export function newBackendClient(config) {
+    const authority = new DeviceAuthority({
+        baseURL: config.baseURL,
+        ...(config.agentType ? { requestedAgentType: config.agentType } : {}),
+        compatibilityHeaders: {
+            "X-ItPay-CLI-Version": CLI_VERSION,
+            "X-ItPay-Contract-Revision": API_CONTRACT_REVISION,
+        },
+    });
+    const http = new HttpClient({
+        baseURL: config.baseURL,
+        defaultHeaders: {
+            "X-ItPay-CLI-Version": CLI_VERSION,
+            "X-ItPay-Contract-Revision": API_CONTRACT_REVISION,
+        },
+        requestAuthorizer: (input) => authority.authorizationHeaders(input),
+    });
+    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

@@ -0,0 +1,217 @@
+import { createHash, createPrivateKey, generateKeyPairSync, randomUUID, sign, } from "node:crypto";
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, 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"];
+export class DeviceAuthority {
+    baseURL;
+    requestedAgentType;
+    compatibilityHeaders;
+    statePath;
+    privateKeyPath;
+    fetchImpl;
+    pending;
+    constructor(options) {
+        this.baseURL = options.baseURL.replace(/\/$/, "");
+        this.requestedAgentType = options.requestedAgentType;
+        this.compatibilityHeaders = options.compatibilityHeaders;
+        const root = resolve(homedir(), ".itpay-v3", "device");
+        this.statePath = options.statePath ?? resolve(root, "identity.json");
+        this.privateKeyPath = options.privateKeyPath ?? resolve(root, "device-private.pem");
+        this.fetchImpl = (options.fetchImpl ?? globalThis.fetch).bind(globalThis);
+    }
+    async authorizationHeaders(input) {
+        if (!PROTECTED_PATHS.some((prefix) => input.path.startsWith(prefix)))
+            return {};
+        const auth = await this.ensureAuthorization();
+        const timestamp = new Date().toISOString();
+        const jti = randomUUID();
+        const bodyHash = sha256(input.body);
+        const message = requestProofMessage(input.method, input.path, bodyHash, timestamp, jti);
+        const signature = sign(null, Buffer.from(message), auth.privateKey).toString("base64");
+        return {
+            Authorization: `ItPayDevice ${auth.session.token}`,
+            "X-ItPay-Agent-Instance-ID": auth.state.agentInstances[auth.agentType] ?? "",
+            "X-ItPay-Agent-Type": auth.agentType,
+            "X-ItPay-Agent-Timestamp": timestamp,
+            "X-ItPay-Agent-Proof-JTI": jti,
+            "X-ItPay-Agent-Body-SHA256": bodyHash,
+            "X-ItPay-Agent-Signature": signature,
+        };
+    }
+    async ensureAuthorization() {
+        if (!this.pending) {
+            this.pending = withFileLock(`${this.statePath}.lock`, () => this.prepareAuthorization()).finally(() => {
+                this.pending = undefined;
+            });
+        }
+        return this.pending;
+    }
+    async prepareAuthorization() {
+        let state = this.readState();
+        const agentType = this.requestedAgentType ?? firstAgentType(state);
+        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 (!state.agentInstances[agentType]) {
+            const existingType = firstAgentType(state);
+            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 session = await this.ensureSession(state, agentType, privateKey);
+        return { state, agentType, session, privateKey };
+    }
+    async enroll(agentType) {
+        const pair = generateKeyPairSync("ed25519");
+        const publicJWK = pair.publicKey.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",
+            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) {
+        const existing = state.sessions[agentType];
+        if (existing && Date.parse(existing.expiresAt) > Date.now() + 60_000)
+            return existing;
+        const instanceID = state.agentInstances[agentType];
+        if (!instanceID)
+            throw new Error(`agent instance is not registered for ${agentType}`);
+        const challenge = await this.publicJSON("/v1/agent-device-session-challenges", {
+            agent_device_id: state.deviceID,
+            agent_instance_id: instanceID,
+        });
+        const proof = deviceSessionProofMessage(challenge.agent_device_session_challenge_id, challenge.challenge);
+        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) {
+        const body = JSON.stringify(bodyValue);
+        const timestamp = new Date().toISOString();
+        const jti = randomUUID();
+        const bodyHash = sha256(body);
+        const signature = sign(null, Buffer.from(requestProofMessage("POST", path, bodyHash, timestamp, jti)), privateKey).toString("base64");
+        return this.fetchJSON(path, body, {
+            Authorization: `ItPayDevice ${session.token}`,
+            "X-ItPay-Agent-Instance-ID": state.agentInstances[agentType] ?? "",
+            "X-ItPay-Agent-Type": agentType,
+            "X-ItPay-Agent-Timestamp": timestamp,
+            "X-ItPay-Agent-Proof-JTI": jti,
+            "X-ItPay-Agent-Body-SHA256": bodyHash,
+            "X-ItPay-Agent-Signature": signature,
+        });
+    }
+    publicJSON(path, bodyValue) {
+        return this.fetchJSON(path, JSON.stringify(bodyValue), {});
+    }
+    async fetchJSON(path, body, extraHeaders) {
+        const response = await this.fetchImpl(this.baseURL + path, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Accept: "application/json", ...this.compatibilityHeaders, ...extraHeaders },
+            body,
+        });
+        const payload = await response.json().catch(() => ({}));
+        if (!response.ok)
+            throw new Error(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"));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    readPrivateKey() {
+        if (!existsSync(this.privateKeyPath))
+            return undefined;
+        try {
+            return createPrivateKey(readFileSync(this.privateKeyPath, "utf8"));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    writeState(state) { atomicOwnerOnlyWrite(this.statePath, JSON.stringify(state, null, 2)); }
+    writePrivateKey(value) { atomicOwnerOnlyWrite(this.privateKeyPath, value); }
+}
+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 });
+    const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    writeFileSync(temporary, value, { encoding: "utf8", mode: 0o600 });
+    chmodSync(temporary, 0o600);
+    renameSync(temporary, path);
+    chmodSync(path, 0o600);
+}
+async function withFileLock(path, run) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    let descriptor;
+    for (let attempt = 0; attempt < 200; attempt += 1) {
+        try {
+            descriptor = openSync(path, "wx", 0o600);
+            break;
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== "EEXIST")
+                throw error;
+            try {
+                if (Date.now() - statSync(path).mtimeMs > 30_000)
+                    unlinkSync(path);
+            }
+            catch (statError) {
+                if (statError.code !== "ENOENT")
+                    throw statError;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+    }
+    if (descriptor === undefined)
+        throw new Error("timed out waiting for ItPay device identity lock");
+    try {
+        return await run();
+    }
+    finally {
+        closeSync(descriptor);
+        try {
+            unlinkSync(path);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+}

package/dist/src/state/operation_journal.js

@@ -0,0 +1,80 @@
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { randomUUID } from "node:crypto";
+export class OperationJournal {
+    path;
+    constructor(path) {
+        this.path = path;
+    }
+    async getOrCreate(operationKey) {
+        return withFileLock(`${this.path}.lock`, async () => {
+            const state = this.read();
+            const existing = state.operations[operationKey];
+            if (existing)
+                return existing.id;
+            const id = `op_${randomUUID().replaceAll("-", "")}`;
+            state.operations[operationKey] = { id, createdAt: new Date().toISOString() };
+            atomicOwnerOnlyWrite(this.path, JSON.stringify(state, null, 2));
+            return id;
+        });
+    }
+    read() {
+        if (existsSync(this.path)) {
+            try {
+                const parsed = JSON.parse(readFileSync(this.path, "utf8"));
+                if (parsed.schemaVersion === "itpay.operations.v1" && parsed.operations)
+                    return parsed;
+            }
+            catch {
+                // A malformed local cache is replaced; server facts remain authoritative.
+            }
+        }
+        return { schemaVersion: "itpay.operations.v1", operations: {} };
+    }
+}
+function atomicOwnerOnlyWrite(path, value) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    writeFileSync(temporary, value, { encoding: "utf8", mode: 0o600 });
+    chmodSync(temporary, 0o600);
+    renameSync(temporary, path);
+    chmodSync(path, 0o600);
+}
+async function withFileLock(path, run) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    let descriptor;
+    for (let attempt = 0; attempt < 200; attempt += 1) {
+        try {
+            descriptor = openSync(path, "wx", 0o600);
+            break;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            try {
+                if (Date.now() - statSync(path).mtimeMs > 30_000)
+                    unlinkSync(path);
+            }
+            catch (statError) {
+                if (statError.code !== "ENOENT")
+                    throw statError;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+    }
+    if (descriptor === undefined)
+        throw new Error("timed out waiting for ItPay operation journal lock");
+    try {
+        return await run();
+    }
+    finally {
+        closeSync(descriptor);
+        try {
+            unlinkSync(path);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+}