@itpay/cli 2.1.34 → 2.1.41

package/dist/src/sell/local.js

@@ -1,260 +0,0 @@
-import { newBackendClient, loadConfig } from "../state/config.js";
-import { createHash, randomUUID } from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, rmSync, readdirSync } from 'node:fs';
-import { resolve, join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { spawn } from 'node:child_process';
-const hash = (value) => 'sha256:' + createHash('sha256').update(value).digest('hex');
-function read(path) { return JSON.parse(readFileSync(path, 'utf8')); }
-function save(path, value) { mkdirSync(dirname(path), { recursive: true, mode: 0o700 }); const tmp = path + '.' + randomUUID() + '.tmp'; writeFileSync(tmp, JSON.stringify(value, null, 2) + '\n', { mode: 0o600 }); renameSync(tmp, path); }
-export function project(directory) { const root = resolve(directory); return { root, state: join(root, '.itpay-sell'), config: read(join(root, 'service.json')), yaml: readFileSync(join(root, 'workflow.yaml'), 'utf8') }; }
-export function localDependencies(state) {
-    const platformPath = join(state, 'platform-dependencies.json');
-    const dependencies = existsSync(platformPath) ? read(platformPath) : {};
-    const sources = join(state, 'sources');
-    if (existsSync(sources))
-        for (const file of readdirSync(sources)) {
-            const source = read(join(sources, file));
-            for (const operation of source.operations)
-                dependencies[operation.provider_operation_version_id] = {
-                    provider_operation_version_id: operation.provider_operation_version_id,
-                    provider_key: source.provider_key, operation_key: operation.operation_key,
-                    operation_hash: operation.operation_hash, operation: operation.operation,
-                    request_schema: operation.request_schema, response_schema: operation.response_schema,
-                    retry_policy: operation.retry_policy ?? {},
-                };
-        }
-    return dependencies;
-}
-export async function companion(input, onEvent) {
-    const target = `${process.platform === 'win32' ? 'windows' : process.platform}-${process.arch === 'x64' ? 'amd64' : process.arch}/itpay-sell${process.platform === 'win32' ? '.exe' : ''}`;
-    const packaged = fileURLToPath(new URL(`../../../bin/${target}`, import.meta.url));
-    const binary = process.env.ITPAY_SELL_RUNNER ?? (existsSync(packaged) ? packaged : fileURLToPath(new URL(`../../bin/${target}`, import.meta.url)));
-    if (!existsSync(binary))
-        throw new Error(`Local runner missing for ${process.platform}-${process.arch}; install a CLI package including its native runner`);
-    return new Promise((done, fail) => {
-        const child = spawn(binary, [], { stdio: ['pipe', 'pipe', 'pipe'] });
-        let buffer = '', stderr = '';
-        const events = [];
-        child.on('error', fail);
-        child.stderr.on('data', chunk => { stderr += String(chunk).slice(0, 2000); });
-        child.stdout.on('data', chunk => {
-            buffer += String(chunk);
-            let index;
-            while ((index = buffer.indexOf('\n')) >= 0) {
-                const line = buffer.slice(0, index);
-                buffer = buffer.slice(index + 1);
-                try {
-                    const event = JSON.parse(line);
-                    events.push(event);
-                    onEvent?.(event);
-                }
-                catch {
-                    child.kill();
-                    fail(new Error('Invalid local runner response'));
-                }
-            }
-        });
-        child.on('close', code => {
-            if (code !== 0)
-                fail(new Error(events.find(event => event.type === 'error')?.value?.message ?? stderr ?? 'Local runner failed'));
-            else
-                done(events);
-        });
-        child.stdin.on('error', () => { });
-        child.stdin.end(JSON.stringify(input));
-    });
-}
-function last(events, type) { return [...events].reverse().find(event => event.type === type)?.value; }
-export async function localAction(action, directory, options) {
-    const root = resolve(directory), state = join(root, '.itpay-sell');
-    if (action === 'init') {
-        if (existsSync(join(root, 'service.json')) || existsSync(join(root, 'workflow.yaml')) || existsSync(state))
-            throw new Error('Project already exists; existing files were not replaced');
-        mkdirSync(root, { recursive: true });
-        const config = { format_version: 1, service_id: options.serviceId ?? '', public_name: options.name ?? '', pricing: { billing_mode: 'per_call' }, policy: {}, fixtures: [] };
-        save(join(root, 'service.json'), config);
-        writeFileSync(join(root, 'workflow.yaml'), '# Generate the workflow from locked API contracts using itpay sell guide.\n', { flag: 'wx' });
-        save(join(state, 'versions.json'), { versions: [] });
-        return { root, next: 'itpay sell sources add --file <openapi> --provider-key <key>', missing: ['workflow', 'price', 'fixtures'] };
-    }
-    const p = project(root);
-    if (action === 'workflow import') {
-        if (!options.file)
-            throw new Error('--file is required');
-        const yaml = readFileSync(resolve(options.file), 'utf8');
-        const validation = last(await companion({ action: 'validate', dependencies: localDependencies(state), document: yaml, pricing: p.config.pricing, policy: p.config.policy }), 'validation');
-        const backup = join(state, 'imports', hash(p.yaml).slice(7) + '.yaml');
-        mkdirSync(dirname(backup), { recursive: true, mode: 0o700 });
-        writeFileSync(backup, p.yaml, { mode: 0o600 });
-        writeFileSync(join(root, 'workflow.yaml'), yaml);
-        return { imported: true, validation, next: 'Resolve all imported API references and save a new workflow version' };
-    }
-    if (action === 'config') {
-        if (options.file) {
-            const value = read(resolve(options.file));
-            for (const key of Object.keys(value))
-                if (!['service_id', 'public_name', 'pricing', 'policy', 'fixtures', 'merchant_id', 'draft_id', 'expected_revision'].includes(key))
-                    throw new Error('Unsupported setting: ' + key);
-            save(join(root, 'service.json'), { ...p.config, ...value });
-        }
-        return read(join(root, 'service.json'));
-    }
-    if (action === 'sources add') {
-        if ((!options.file && !options.url) || !options.providerKey)
-            throw new Error('--file or --url, and --provider-key are required');
-        if (options.file && options.url)
-            throw new Error('Choose file or URL, not both');
-        const raw = options.file ? readFileSync(resolve(options.file), 'utf8') : last(await companion({ action: 'fetch', source_url: options.url }), 'source').document;
-        const id = hash(raw).slice(7);
-        const operations = last(await companion({ action: 'compile', document: raw, provider_key: options.providerKey }), 'compiled');
-        const path = join(state, 'sources', id + '.json');
-        save(path, { provider_key: options.providerKey, source_hash: hash(raw), original: raw, operations });
-        return { source_hash: hash(raw), operations, instruction: 'Use these exact contracts when constructing workflow.yaml; bind local credentials by environment reference' };
-    }
-    if (action === 'credentials bind') {
-        if (!options.profile || !options.file)
-            throw new Error('--profile and --file are required; file must map credential fields to environment variable names, not secret values');
-        const bindings = read(resolve(options.file));
-        for (const value of Object.values(bindings))
-            if (typeof value !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(value))
-                throw new Error('Credential bindings must be environment variable names');
-        const path = join(state, 'credentials.json');
-        save(path, { ...(existsSync(path) ? read(path) : {}), [options.profile]: bindings });
-        return { profile: options.profile, bound_fields: Object.keys(bindings) };
-    }
-    if (action === 'credentials upload') {
-        if (!options.confirm || !options.profile || !options.providerKey || !options.merchantId)
-            throw new Error('Merchant, provider, local profile and explicit confirmation are required');
-        const bindings = read(join(state, 'credentials.json'))[options.profile];
-        if (!bindings)
-            throw new Error('Local profile not bound');
-        const secrets = {};
-        for (const [field, env] of Object.entries(bindings)) {
-            const value = process.env[String(env)];
-            if (!value)
-                throw new Error('Missing credential environment for ' + field);
-            secrets[field] = value;
-        }
-        const result = await newBackendClient(loadConfig()).sellRequest({ method: 'POST', path: '/v1/seller/organizations/' + encodeURIComponent(options.merchantId) + '/provider-credential-profiles', body: { provider_key: options.providerKey, profile_key: options.profile, display_name: options.name ?? options.profile, environment: options.environment ?? 'sandbox', secrets, metadata: options.file ? read(resolve(options.file)) : {} } });
-        return result;
-    }
-    const versionsPath = join(state, 'versions.json');
-    const versions = read(versionsPath);
-    if (action === 'workflow versions save') {
-        const validation = last(await companion({ action: 'validate', dependencies: localDependencies(state), document: p.yaml, pricing: p.config.pricing, policy: p.config.policy }), 'validation');
-        const version = { version_id: randomUUID(), name: options.name ?? 'Saved version', hash: hash(p.yaml), config_hash: hash(JSON.stringify(p.config)), created_at: new Date().toISOString() };
-        save(join(state, 'versions', version.version_id + '.json'), { ...version, document: p.yaml, config: p.config });
-        versions.versions.push(version);
-        versions.selected = version.version_id;
-        save(versionsPath, versions);
-        return { ...version, validation };
-    }
-    if (action === 'workflow versions list')
-        return versions;
-    if (action === 'workflow versions use' || action === 'workflow versions delete') {
-        const version = versions.versions.find((v) => v.version_id === options.version);
-        if (!version)
-            throw new Error('Saved version not found');
-        if (action.endsWith('use')) {
-            const saved = read(join(state, 'versions', version.version_id + '.json'));
-            writeFileSync(join(root, 'workflow.yaml'), saved.document);
-            save(join(root, 'service.json'), saved.config);
-            versions.selected = version.version_id;
-        }
-        else {
-            if (!options.confirm)
-                throw new Error('Confirm version deletion with --confirm');
-            versions.versions = versions.versions.filter((v) => v.version_id !== version.version_id);
-            if (versions.selected === version.version_id)
-                delete versions.selected;
-            rmSync(join(state, 'versions', version.version_id + '.json'));
-            const runs = join(state, 'runs');
-            if (existsSync(runs))
-                for (const run of readdirSync(runs)) {
-                    const meta = join(runs, run, 'meta.json');
-                    if (existsSync(meta) && read(meta).version_id === version.version_id)
-                        rmSync(join(runs, run), { recursive: true });
-                }
-        }
-        save(versionsPath, versions);
-        return versions;
-    }
-    if (action === 'workflow validate')
-        return last(await companion({ action: 'validate', dependencies: localDependencies(state), document: p.yaml, pricing: p.config.pricing, policy: p.config.policy }), 'validation');
-    if (action === 'test get') {
-        if (!options.run)
-            throw new Error('--run is required');
-        return read(join(state, 'runs', safeID(options.run), 'report.json'));
-    }
-    const selected = versions.versions.find((v) => v.version_id === versions.selected);
-    if (!selected || selected.hash !== hash(p.yaml) || selected.config_hash !== hash(JSON.stringify(p.config)))
-        throw new Error('Save the current workflow and configuration before confirming or running');
-    if (action === 'workflow confirm') {
-        if (!options.confirm)
-            return { version: selected, config: p.config, workflow: p.yaml, instruction: 'Review this exact workflow and service configuration with the user, then confirm' };
-        save(join(state, 'confirmation.json'), { version_id: selected.version_id, hash: selected.hash, config_hash: selected.config_hash, confirmed_at: new Date().toISOString() });
-        return { confirmed: selected };
-    }
-    if (action === 'test run' || action === 'test resume') {
-        if (!options.confirm)
-            throw new Error('Live Provider calls may cost money or change data. Review dependencies and confirm with --confirm');
-        const dependencies = localDependencies(state);
-        const credentials = {};
-        const credentialPath = join(state, 'credentials.json');
-        if (existsSync(credentialPath))
-            for (const [profile, fields] of Object.entries(read(credentialPath))) {
-                const secrets = {};
-                for (const [field, env] of Object.entries(fields)) {
-                    if (!process.env[String(env)])
-                        throw new Error(`Missing local environment variable for credential field ${field}`);
-                    secrets[field] = process.env[String(env)];
-                }
-                credentials[profile] = { ID: profile, Secrets: secrets, Metadata: {} };
-            }
-        if (action === 'test resume' && !options.run)
-            throw new Error('--run is required for resume');
-        const runID = options.run ? safeID(options.run) : randomUUID(), runDirectory = join(state, 'runs', runID);
-        const metaPath = join(runDirectory, 'meta.json');
-        if (action === 'test resume' && !existsSync(metaPath))
-            throw new Error('Run does not exist');
-        if (existsSync(metaPath) && read(metaPath).version_id !== selected.version_id)
-            throw new Error('Run belongs to a different version');
-        save(metaPath, { run_id: runID, version_id: selected.version_id, hash: selected.hash, config_hash: selected.config_hash });
-        save(join(state, "last-run.json"), { run_id: runID });
-        const events = await companion({ action: 'run', document: p.yaml, pricing: p.config.pricing, policy: p.config.policy, fixtures: p.config.fixtures, dependencies, credentials, run_directory: runDirectory, confirmed: true }, event => {
-            if (event.type === 'nodes')
-                save(join(runDirectory, 'nodes.json'), event.value);
-        });
-        const result = last(events, 'result');
-        save(join(runDirectory, 'report.json'), result);
-        return { run_id: runID, ...result };
-    }
-    throw new Error('Unsupported local action: ' + action);
-}
-function safeID(value) {
-    if (!/^[A-Za-z0-9_-]+$/.test(value))
-        throw new Error('Invalid local run ID');
-    return value;
-}
-export const LOCAL_ACTIONS = ['init', 'config', 'workflow import', 'sources add', 'credentials bind', 'credentials upload', 'workflow validate', 'workflow confirm', 'workflow versions save', 'workflow versions list', 'workflow versions use', 'workflow versions delete', 'test run', 'test resume', 'test get'];
-export function registerLocal(sell) {
-    for (const name of LOCAL_ACTIONS) {
-        let parent = sell;
-        const parts = name.split(' ');
-        const leaf = parts.pop();
-        for (const part of parts) {
-            parent = parent.commands.find(cmd => cmd.name() === part) ?? parent.command(part);
-        }
-        parent.command(leaf).description('Local Sell: ' + name).option('--project <directory>', 'Project directory', '.').option('--file <file>').option('--url <https-url>').option('--name <name>').option('--service-id <id>').option('--provider-key <key>').option('--profile <id>').option('--merchant-id <id>').option('--environment <environment>').option('--version-id <id>').option('--run <id>').option('--confirm').option('--json').action(async (options) => {
-            try {
-                const result = await localAction(name.replace('list-local', 'list'), options.project, { ...options, version: options.versionId });
-                process.stdout.write(JSON.stringify({ status: 'ok', result }, null, 2) + '\n');
-            }
-            catch (error) {
-                process.exitCode = 1;
-                process.stdout.write(JSON.stringify({ status: 'error', message: error instanceof Error ? error.message : 'Local action failed' }) + '\n');
-            }
-        });
-    }
-}

package/dist/src/sell/mcp.js

@@ -1,49 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { z } from 'zod';
-import { SELL_GUIDE, SELL_OPERATIONS, sellRequest } from './contract.js';
-import { LOCAL_ACTIONS, localAction } from './local.js';
-import { newBackendClient, loadConfig } from '../state/config.js';
-import { syncProject } from './sync.js';
-import { preview } from './preview.js';
-export async function serveSellMCP(directory) {
-    const server = new McpServer({ name: 'itpay-sell-local', version: SELL_GUIDE.version }, { instructions: 'Use itpay_seller_guide first. Local tests call Provider APIs and may incur cost; disclose side effects and obtain user approval. Never pass secret values in tool arguments. This server uses its configured project directory.' });
-    server.tool('itpay_seller_guide', 'Read the publishing guide and constraints', {}, async () => ({ content: [{ type: 'text', text: JSON.stringify({ ...SELL_GUIDE, operations: SELL_OPERATIONS }) }] }));
-    for (const action of LOCAL_ACTIONS) {
-        server.tool('itpay_seller_local_' + action.replaceAll(' ', '_').replaceAll('-', '_'), `Local ${action}. Paths are user-provided files; never scan for credentials. Confirm only after explicit user approval.`, { merchant_id: z.string().optional(), environment: z.string().optional(), service_id: z.string().optional(), url: z.string().url().optional(), file: z.string().optional(), name: z.string().optional(), provider_key: z.string().optional(), profile: z.string().optional(), version: z.string().optional(), run: z.string().optional(), confirmed: z.boolean().default(false) }, async (args) => {
-            try {
-                const result = await localAction(action, directory, { ...args, merchantId: args.merchant_id, providerKey: args.provider_key, serviceId: args.service_id, confirm: args.confirmed });
-                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-            }
-            catch (error) {
-                return { isError: true, content: [{ type: 'text', text: error instanceof Error ? error.message : 'Local action failed' }] };
-            }
-        });
-    }
-    server.tool('itpay_seller_sync', 'Upload or download the configured project after explicit user confirmation. Never pass credential values.', { action: z.enum(['push', 'pull']), merchant_id: z.string(), draft_id: z.string().optional(), bindings_file: z.string().optional(), confirmed: z.boolean().default(false) }, async (args) => {
-        try {
-            const result = await syncProject(args.action, directory, { merchantId: args.merchant_id, draftId: args.draft_id, bindings: args.bindings_file, confirm: args.confirmed });
-            return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-        }
-        catch (error) {
-            return { isError: true, content: [{ type: 'text', text: error instanceof Error ? error.message : 'Sync failed' }] };
-        }
-    });
-    let display;
-    server.tool('itpay_seller_preview', 'Open the existing Builder for this local workflow; user can then confirm through the local workflow tool.', {}, async () => { display ??= await preview(directory); return { content: [{ type: 'text', text: JSON.stringify({ url: display.url }) }] }; });
-    for (const operation of SELL_OPERATIONS) {
-        server.tool('itpay_seller_platform_' + operation.command.replaceAll(' ', '_').replaceAll('-', '_'), `${operation.description}. Input contract: ${JSON.stringify(operation.fields)}. Optional fields: ${JSON.stringify(operation.optional ?? [])}.`, { merchant_id: z.string().optional(), draft_id: z.string().optional(), library_api_id: z.string().optional(), intake_id: z.string().optional(), version_id: z.string().optional(), run_id: z.string().optional(), submission_id: z.string().optional(), input: z.record(z.unknown()).default({}), confirmed: z.boolean().default(false) }, async (args) => {
-            try {
-                if (operation.confirmation && !args.confirmed)
-                    throw new Error('Explicit user confirmation required');
-                const result = await newBackendClient(loadConfig()).sellRequest(sellRequest(operation, args, args.input));
-                return { content: [{ type: 'text', text: JSON.stringify(result ?? {}) }] };
-            }
-            catch (error) {
-                return { isError: true, content: [{ type: 'text', text: error instanceof Error ? error.message : 'Platform action failed' }] };
-            }
-        });
-    }
-    process.stdin.on('end', () => display?.close());
-    await server.connect(new StdioServerTransport());
-}

package/dist/src/sell/preview.js

@@ -1,70 +0,0 @@
-import { createServer } from 'node:http';
-import { randomBytes, createHash } from 'node:crypto';
-import { readFileSync, existsSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { resolve, extname } from 'node:path';
-import { project } from './local.js';
-export async function preview(directory) {
-    const packaged = fileURLToPath(new URL('../../../assets/sell-preview/', import.meta.url));
-    const assets = existsSync(packaged) ? packaged : fileURLToPath(new URL('../../assets/sell-preview/', import.meta.url));
-    if (!existsSync(resolve(assets, 'index.html')))
-        throw new Error('CLI preview assets are missing; install the complete CLI package');
-    const token = randomBytes(24).toString('hex');
-    const server = createServer((req, res) => {
-        res.setHeader('Cache-Control', 'no-store');
-        res.setHeader('Referrer-Policy', 'no-referrer');
-        res.setHeader('X-Content-Type-Options', 'nosniff');
-        if (req.method !== 'GET' || !req.url?.startsWith('/' + token + '/')) {
-            res.writeHead(404).end();
-            return;
-        }
-        try {
-            const path = req.url.slice(token.length + 2).split('?')[0] ?? '';
-            if (path === 'document') {
-                const p = project(directory);
-                const versions = JSON.parse(readFileSync(resolve(p.state, 'versions.json'), 'utf8'));
-                const version = versions.versions.find((v) => v.version_id === versions.selected);
-                res.setHeader('Content-Type', 'application/json');
-                const actualHash = 'sha256:' + createHash('sha256').update(p.yaml).digest('hex');
-                let run;
-                const marker = resolve(p.state, 'last-run.json');
-                if (existsSync(marker)) {
-                    const id = JSON.parse(readFileSync(marker, 'utf8')).run_id;
-                    if (typeof id === 'string' && /^[A-Za-z0-9_-]+$/.test(id) && existsSync(resolve(p.state, 'runs', id, 'meta.json'))) {
-                        const dir = resolve(p.state, 'runs', id), meta = JSON.parse(readFileSync(resolve(dir, 'meta.json'), 'utf8'));
-                        const traces = existsSync(resolve(dir, 'nodes.json')) ? JSON.parse(readFileSync(resolve(dir, 'nodes.json'), 'utf8')) : [];
-                        const report = existsSync(resolve(dir, 'report.json')) ? JSON.parse(readFileSync(resolve(dir, 'report.json'), 'utf8')).report : undefined;
-                        const configHash = 'sha256:' + createHash('sha256').update(JSON.stringify(p.config)).digest('hex');
-                        const stale = meta.hash !== actualHash || meta.config_hash !== configHash;
-                        const fixtures = p.config.fixtures ?? [];
-                        run = { status: stale ? 'stale' : report?.status ?? 'running', issues: report?.issues ?? [], validation: { fixture_runs: fixtures.map((f) => ({ ...f, nodes: traces.filter((t) => t.record_type === 'node' && t.fixture_id === f.fixture_id) })), api_recognitions: [], side_effect_operations: [] } };
-                    }
-                }
-                res.end(JSON.stringify({ document: p.yaml, version: version?.hash === actualHash ? version.name : 'Unsaved', hash: actualHash, pricing: p.config.pricing, run }));
-                return;
-            }
-            const file = resolve(assets, path || 'index.html');
-            if (!file.startsWith(resolve(assets) + '/')) {
-                res.writeHead(404).end();
-                return;
-            }
-            const types = { '.html': 'text/html; charset=utf-8', '.js': 'text/javascript', '.css': 'text/css', '.svg': 'image/svg+xml', '.woff2': 'font/woff2' };
-            res.setHeader('Content-Type', types[extname(file)] ?? 'application/octet-stream');
-            res.end(readFileSync(file));
-        }
-        catch {
-            res.writeHead(404).end();
-        }
-    });
-    return new Promise((done, fail) => {
-        server.on('error', fail);
-        server.listen(0, '127.0.0.1', () => {
-            const address = server.address();
-            if (!address || typeof address === 'string') {
-                fail(new Error('Preview address unavailable'));
-                return;
-            }
-            done({ url: `http://127.0.0.1:${address.port}/${token}/`, close: () => server.close() });
-        });
-    });
-}

package/dist/src/sell/sync.js

@@ -1,145 +0,0 @@
-import { HttpError } from "../client/http.js";
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { createHash } from 'node:crypto';
-import { newBackendClient, loadConfig } from '../state/config.js';
-import { companion, project, localDependencies } from './local.js';
-const encode = encodeURIComponent;
-const hash = (value) => 'sha256:' + createHash('sha256').update(value).digest('hex');
-function read(path) { return JSON.parse(readFileSync(path, 'utf8')); }
-function save(path, value) { writeFileSync(path, JSON.stringify(value, null, 2) + '\n', { mode: 0o600 }); }
-function platformWorkflow(draft) {
-    const document = draft.arazzo?.arazzo_document;
-    if (typeof document !== 'string' || !document.trim())
-        throw new Error('Platform response is missing the workflow document');
-    return document;
-}
-export async function syncProject(action, directory, options) {
-    const p = project(directory), cloudPath = join(p.state, 'cloud.json');
-    let cloud = existsSync(cloudPath) ? read(cloudPath) : {};
-    const merchant = options.merchantId ?? cloud.merchant_id ?? p.config.merchant_id;
-    if (!merchant)
-        throw new Error('--merchant-id is required');
-    if (cloud.merchant_id && cloud.merchant_id !== merchant)
-        throw new Error('Project is bound to a different merchant');
-    const api = newBackendClient(loadConfig()), org = '/v1/seller/organizations/' + encode(merchant);
-    const call = async (method, path, body) => await api.sellRequest({ method, path, ...(body !== undefined ? { body } : {}) });
-    if (action === 'pull') {
-        const draftID = options.draftId ?? cloud.draft_id;
-        if (!draftID)
-            throw new Error('--draft-id is required');
-        if (!options.confirm)
-            throw new Error('Pull replaces local workflow/settings; inspect changes and confirm first');
-        const bundle = await call('GET', `${org}/service-drafts/${encode(draftID)}/bundle`);
-        const backup = join(p.state, 'backups', String(Date.now()));
-        mkdirSync(backup, { recursive: true, mode: 0o700 });
-        writeFileSync(join(backup, 'workflow.yaml'), p.yaml);
-        save(join(backup, 'service.json'), p.config);
-        const draft = bundle.draft;
-        writeFileSync(join(p.root, 'workflow.yaml'), platformWorkflow(draft));
-        save(join(p.root, 'service.json'), { ...p.config, service_id: draft.service_id, public_name: draft.public_name, pricing: draft.pricing, policy: draft.policy, fixtures: bundle.fixtures.fixtures });
-        save(join(p.state, 'platform-dependencies.json'), bundle.dependencies);
-        cloud = { merchant_id: merchant, draft_id: draftID, revision: draft.semantic_revision, hash: draft.semantic_hash };
-        save(cloudPath, cloud);
-        return { cloud, backup, next: 'Save a new local version. Platform credentials were not downloaded.' };
-    }
-    const versions = read(join(p.state, 'versions.json'));
-    const version = versions.versions.find((v) => v.version_id === versions.selected);
-    const confirmation = existsSync(join(p.state, 'confirmation.json')) ? read(join(p.state, 'confirmation.json')) : {};
-    if (!version || version.hash !== hash(p.yaml) || version.config_hash !== hash(JSON.stringify(p.config)) || confirmation.version_id !== version.version_id || confirmation.hash !== version.hash || confirmation.config_hash !== version.config_hash)
-        throw new Error('Save and confirm the exact current version before uploading');
-    const validation = (await companion({ action: 'validate', dependencies: localDependencies(p.state), document: p.yaml, pricing: p.config.pricing, policy: p.config.policy })).find(event => event.type === 'validation')?.value;
-    if (!validation?.result?.valid)
-        throw new Error('Workflow does not pass validation');
-    if (!options.confirm)
-        return { local_version: version, cloud, pricing: p.config.pricing, instruction: 'Review the service package and platform API calls, then confirm upload. Platform verification is a separate explicit action.' };
-    if (!cloud.draft_id) {
-        const drafts = await call('GET', `${org}/service-drafts`);
-        const existing = drafts.drafts?.find((d) => d.service_id === p.config.service_id);
-        if (existing)
-            throw new Error('Service ID already exists. Pull that draft explicitly before updating it.');
-        const draft = await call('POST', `${org}/service-drafts`, { service_id: p.config.service_id, public_name: p.config.public_name });
-        cloud = { merchant_id: merchant, draft_id: draft.draft_id, revision: draft.semantic_revision, operation_bindings: {} };
-        save(cloudPath, cloud);
-    }
-    const base = `${org}/service-drafts/${encode(cloud.draft_id)}`;
-    let current = await call('GET', base + '/workflow');
-    if (current.semantic_revision !== cloud.revision)
-        throw new Error('Remote draft changed; pull and review before retrying');
-    if (cloud.local_version_id === version.version_id && cloud.hash === current.semantic_hash && cloud.version_id) {
-        const saved = await call('GET', base + '/workflow/versions');
-        if (saved.versions.some((item) => item.version_id === cloud.version_id)) {
-            const fixtureState = await call('GET', base + '/fixtures');
-            if (fixtureState.revision !== cloud.fixture_revision)
-                throw new Error('Remote test inputs changed; pull and review before retrying');
-            return { cloud, already_uploaded: true, next: 'Read the platform Guide and verify the saved version' };
-        }
-    }
-    const sources = join(p.state, 'sources');
-    cloud.operation_bindings ??= {};
-    if (existsSync(sources))
-        for (const file of readdirSync(sources)) {
-            const source = read(join(sources, file));
-            const imported = await call('POST', `${org}/api-intakes`, { provider_key: source.provider_key, document: source.original, media_type: 'application/yaml' });
-            for (const local of source.operations) {
-                const remote = imported.operations.find((operation) => operation.operation_key === local.operation_key && operation.method === local.method && operation.path === local.path);
-                if (!remote)
-                    throw new Error('Platform import differs from the local API contract');
-                if (remote.operation_hash !== local.operation_hash)
-                    throw new Error('Platform API contract changed; download and review the imported contract');
-                cloud.operation_bindings[local.provider_operation_version_id] = remote.provider_operation_version_id;
-            }
-            save(cloudPath, cloud);
-        }
-    const credentials = options.bindings ? read(resolve(options.bindings)) : {};
-    const document = validation.document;
-    for (const workflow of document.workflows)
-        for (const step of workflow.steps) {
-            const meta = step['x-itpay-operation'];
-            if (meta?.type === 'api_call') {
-                meta.providerOperationVersionId = cloud.operation_bindings[meta.providerOperationVersionId] ?? meta.providerOperationVersionId;
-                if (credentials[meta.credentialProfileId])
-                    meta.credentialProfileId = credentials[meta.credentialProfileId];
-            }
-        }
-    // Each durable boundary is recorded. On an ambiguous write, pull explicitly;
-    // never retry a guessed revision or overwrite another editor's changes.
-    current = await call('PUT', base + '/workflow', { expected_revision: cloud.revision, public_name: p.config.public_name, arazzo: document });
-    cloud.revision = current.semantic_revision;
-    save(cloudPath, cloud);
-    current = await call('PUT', base + '/pricing', { expected_revision: cloud.revision, pricing: p.config.pricing, policy: p.config.policy });
-    cloud.revision = current.semantic_revision;
-    save(cloudPath, cloud);
-    let fixtures;
-    try {
-        fixtures = await call('GET', base + '/fixtures');
-    }
-    catch (error) {
-        if (error instanceof HttpError && error.status === 404)
-            fixtures = { revision: 0 };
-        else
-            throw error;
-    }
-    const savedFixtures = await call('PUT', base + '/fixtures', { expected_revision: fixtures.revision, fixtures: p.config.fixtures });
-    const existingVersions = await call('GET', base + '/workflow/versions');
-    const saved = existingVersions.versions.find((item) => item.name === version.name && item.arazzo_document === platformWorkflow(current)) ?? await call('POST', base + '/workflow/versions', { name: version.name, source: 'current', expected_revision: cloud.revision, arazzo_document: platformWorkflow(current) });
-    cloud.version_id = saved.version_id;
-    cloud.fixture_revision = savedFixtures.revision;
-    cloud.local_version_id = version.version_id;
-    cloud.hash = current.semantic_hash;
-    save(cloudPath, cloud);
-    await call('POST', base + '/workflow/validate', {});
-    return { cloud, platform_verified: false, next: { command: 'itpay sell verify', input: { workflow_version_id: cloud.version_id, expected_semantic_revision: cloud.revision, expected_fixture_revision: cloud.fixture_revision } }, instruction: 'Review and confirm platform verification before any real API calls. Local test success is not platform evidence.' };
-}
-export function registerSync(sell) {
-    for (const action of ['push', 'pull'])
-        sell.command(action).option('--project <directory>', 'Project directory', '.').option('--merchant-id <id>').option('--draft-id <id>').option('--bindings <file>', 'Local profile ID to platform credential profile ID map').option('--confirm').option('--json').action(async (options) => {
-            try {
-                process.stdout.write(JSON.stringify({ status: 'ok', result: await syncProject(action, options.project, options) }, null, 2) + '\n');
-            }
-            catch (error) {
-                process.exitCode = 1;
-                process.stdout.write(JSON.stringify({ status: 'error', message: error instanceof Error ? error.message : 'Sync failed' }) + '\n');
-            }
-        });
-}