@xiashe/sdk 0.1.8 → 0.1.10

package/alipayWallet.mjs

@@ -0,0 +1,165 @@
+import { createHash } from 'node:crypto';
+import { execFile } from 'node:child_process';
+
+const DEFAULT_TIMEOUT_MS = 8 * 60 * 1000;
+const MAX_OUTPUT_BYTES = 32 * 1024;
+const SENSITIVE_OUTPUT = /payment[-_ ]?proof|payment[-_ ]?needed|seller_signature|runtimeToken|authorization\s*:/i;
+
+export class AlipayWalletError extends Error {
+  constructor(code, message, options = {}) {
+    super(message);
+    this.name = 'AlipayWalletError';
+    this.code = code;
+    this.status = options.status;
+  }
+}
+
+function safeText(value, maxLength = 240) {
+  return String(value || '').replace(/\s+/g, ' ').trim().slice(0, maxLength);
+}
+
+function digest(value) {
+  return createHash('sha256').update(String(value || '')).digest('hex').slice(0, 16);
+}
+
+function safeDiagnostic(value) {
+  const text = safeText(value, MAX_OUTPUT_BYTES);
+  if (!text) return 'no_wallet_output';
+  // CLI output is not a protocol API: never forward it to an Agent. This
+  // protects future vendor versions even when they add fields we do not know.
+  return SENSITIVE_OUTPUT.test(text) ? 'protocol_payload_processed' : 'official_wallet_response_received';
+}
+
+function normalizeResourceUrl(value) {
+  let url;
+  try {
+    url = new URL(String(value || '').trim());
+  } catch {
+    throw new AlipayWalletError('ALIPAY_RESOURCE_URL_INVALID', '支付资源地址无效。');
+  }
+  if (url.protocol !== 'https:' || !url.hostname || url.username || url.password) {
+    throw new AlipayWalletError('ALIPAY_RESOURCE_URL_UNSAFE', '支付资源必须是没有凭据的 HTTPS 地址。');
+  }
+  return url.toString();
+}
+
+function normalizeIntentSummary(value) {
+  const summary = safeText(value, 180);
+  if (!summary) {
+    throw new AlipayWalletError('ALIPAY_INTENT_SUMMARY_REQUIRED', '必须提供付款用途摘要。');
+  }
+  return summary;
+}
+
+function defaultRunFile(command, args, options) {
+  return new Promise((resolve, reject) => {
+    execFile(command, args, {
+      timeout: options.timeoutMs,
+      maxBuffer: MAX_OUTPUT_BYTES,
+      windowsHide: true,
+      env: options.env
+    }, (error, stdout, stderr) => {
+      if (error) {
+        error.stdout = stdout;
+        error.stderr = stderr;
+        reject(error);
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+
+function normalizedRunnerResult(result) {
+  if (typeof result === 'string') return { stdout: result, stderr: '' };
+  return { stdout: String(result?.stdout || ''), stderr: String(result?.stderr || '') };
+}
+
+async function runOfficialCli(args, options = {}) {
+  const command = safeText(options.command || process.env.XIASHE_ALIPAY_BOT_COMMAND || 'alipay-bot', 200);
+  if (!command || /\s/.test(command)) {
+    throw new AlipayWalletError('ALIPAY_BOT_COMMAND_INVALID', '支付宝钱包命令配置无效。');
+  }
+  const runner = options.runFile || defaultRunFile;
+  try {
+    return normalizedRunnerResult(await runner(command, args, {
+      timeoutMs: options.timeoutMs || DEFAULT_TIMEOUT_MS,
+      env: options.env || process.env
+    }));
+  } catch (error) {
+    if (error?.code === 'ENOENT') {
+      throw new AlipayWalletError('ALIPAY_BOT_NOT_INSTALLED', '未找到支付宝官方钱包工具。请先在当前 Agent 环境安装并授权 @alipay/agent-payment。');
+    }
+    if (error?.killed || error?.signal === 'SIGTERM') {
+      throw new AlipayWalletError('ALIPAY_WALLET_TIMEOUT', '支付宝钱包操作超时；没有确认付款。');
+    }
+    throw new AlipayWalletError('ALIPAY_WALLET_COMMAND_FAILED', '支付宝钱包未完成该操作。');
+  }
+}
+
+function walletStateFromOutput(stdout, stderr) {
+  const output = `${stdout}\n${stderr}`;
+  const enabled = /"code"\s*:\s*200|已开启支付宝支付功能|wallet.*(?:ready|enabled|active)/i.test(output);
+  const unavailable = /未开启|not.*(?:enabled|authorized)|not.*found|未安装/i.test(output);
+  return enabled ? 'ready' : unavailable ? 'unavailable' : 'unknown';
+}
+
+/**
+ * Runs only the official local wallet client. It never returns Payment-Needed,
+ * Payment-Proof, or raw wallet output to an Agent caller.
+ */
+export async function checkAlipayWallet(options = {}) {
+  const { stdout, stderr } = await runOfficialCli(['check-wallet'], options);
+  const state = walletStateFromOutput(stdout, stderr);
+  return {
+    ok: state === 'ready',
+    state,
+    provider: 'alipay-agent-payment',
+    message: state === 'ready' ? '支付宝钱包已开启。' : '支付宝钱包尚未就绪。',
+    diagnostic: safeDiagnostic(stdout || stderr)
+  };
+}
+
+/**
+ * Starts one explicit buyer-side 402 payment. The official CLI owns the
+ * protocol payload and App confirmation; callers only receive a safe result.
+ */
+export async function payAlipay402Resource(input, options = {}) {
+  if (input?.confirm !== true) {
+    throw new AlipayWalletError('ALIPAY_CONFIRMATION_REQUIRED', '付款操作必须由用户明确确认。请在展示付款用途后使用 --confirm。');
+  }
+  const resourceUrl = normalizeResourceUrl(input?.resourceUrl);
+  const intentSummary = normalizeIntentSummary(input?.intentSummary);
+  const wallet = await checkAlipayWallet(options);
+  if (!wallet.ok) {
+    throw new AlipayWalletError('ALIPAY_WALLET_NOT_READY', '支付宝钱包未开启；请先完成钱包授权。');
+  }
+  const { stdout, stderr } = await runOfficialCli([
+    '402-buyer-pay',
+    '--resource-url', resourceUrl,
+    '--intent-summary', intentSummary
+  ], options);
+  return {
+    ok: true,
+    status: 'submitted',
+    provider: 'alipay-agent-payment',
+    attemptId: `alipay-402:${digest(`${resourceUrl}\n${intentSummary}`)}`,
+    message: '已交给支付宝钱包处理；请在支付宝 App 中确认本次付款。',
+    diagnostic: safeDiagnostic(stdout || stderr)
+  };
+}
+
+export async function queryAlipay402Resource(input, options = {}) {
+  const resourceUrl = normalizeResourceUrl(input?.resourceUrl);
+  const { stdout, stderr } = await runOfficialCli(['402-query-payment-status', '--resource-url', resourceUrl], options);
+  const output = `${stdout}\n${stderr}`;
+  const complete = /success|成功|paid|已支付|completed|完成/i.test(output) && !/pending|等待|处理中/i.test(output);
+  const pending = /pending|等待|处理中|confirm/i.test(output);
+  return {
+    ok: true,
+    status: complete ? 'completed' : pending ? 'pending_confirmation' : 'unknown',
+    provider: 'alipay-agent-payment',
+    message: complete ? '支付宝钱包显示付款已完成。' : pending ? '等待用户在支付宝 App 中确认。' : '支付宝钱包尚未返回可确认的付款状态。',
+    diagnostic: safeDiagnostic(stdout || stderr)
+  };
+}

package/index.mjs

@@ -6,7 +6,7 @@ import path from 'node:path';
 import { ConvexHttpClient } from 'convex/browser';
 import { anyApi as api } from 'convex/server';
 
-export const VERSION = '0.1.7';
+export const VERSION = '0.1.10';
 
 export const DEFAULTS = {
   cn: {
@@ -22,9 +22,9 @@ export const DEFAULTS = {
     market: 'intl',
     locale: 'en',
     convexUrl: 'https://adept-porcupine-970.convex.cloud',
-    actionsUrl: 'https://actions.agentpie.app',
-    mcpUrl: 'https://actions.agentpie.app/mcp/xiashe',
-    agentClaimUrl: 'https://actions.agentpie.app/agent-gateway/claim',
+    actionsUrl: 'https://agentpie.app',
+    mcpUrl: 'https://agentpie.app/mcp/xiashe',
+    agentClaimUrl: 'https://agentpie.app/agent-gateway/claim',
     relayUrl: 'https://relay.agentpie.app'
   }
 };
@@ -515,8 +515,36 @@ export class XiasheClient {
     return this.query(api.skillInstallJobs.listForConnection, this.authArgs({ connectionId, limit }));
   }
 
-  async createSkillSubmissionDraft(draft = {}) {
-    return this.mutation(api.skillsCatalog.createSkillSubmissionDraft, this.authArgs({ draft }));
+  async createSkillSubmissionDraft(draft = {}, options = {}) {
+    const registryPublicToken = options.registryPublicToken || draft.registryPublicToken || draft._registryPublicToken;
+    const cleanDraft = { ...draft };
+    delete cleanDraft.registryPublicToken;
+    delete cleanDraft._registryPublicToken;
+    try {
+      return await this.mutation(api.skillsCatalog.createSkillSubmissionDraft, this.authArgs({ draft: cleanDraft }));
+    } catch (error) {
+      if (error?.code !== 'AUTH_REQUIRED' || !registryPublicToken || (!cleanDraft.registryEntryId && !cleanDraft.registryPublicSkillId)) {
+        throw error;
+      }
+      return await this.createSkillSubmissionDraftFromRegistry({
+        registryEntryId: cleanDraft.registryEntryId,
+        registryPublicSkillId: cleanDraft.registryPublicSkillId,
+        publicToken: registryPublicToken,
+        draft: cleanDraft
+      });
+    }
+  }
+
+  async createSkillSubmissionDraftFromRegistry(options = {}) {
+    const draft = { ...(options.draft || {}) };
+    delete draft.registryPublicToken;
+    delete draft._registryPublicToken;
+    return this.mutation(api.skillsCatalog.createSkillSubmissionDraftFromRegistry, {
+      registryEntryId: options.registryEntryId || draft.registryEntryId || undefined,
+      registryPublicSkillId: options.registryPublicSkillId || draft.registryPublicSkillId || undefined,
+      publicToken: options.publicToken || options.registryPublicToken,
+      draft
+    });
   }
 
   async updateSkillSubmissionDraft(submissionId, patch = {}) {
@@ -593,6 +621,388 @@ export class XiasheClient {
     );
   }
 
+  async submitAgentRuntimeListing(options = {}) {
+    return this.action(
+      api.agentRuntimeMarketplace.submitListing,
+      this.authArgs({
+        agentCardUrl: options.agentCardUrl,
+        registryEntryId: options.registryEntryId || undefined,
+        skillCatalogId: options.skillCatalogId || undefined,
+        pricingModel: options.pricingModel || undefined,
+        priceCredits: options.priceCredits ?? undefined,
+        category: options.category || undefined,
+        tags: options.tags || undefined,
+        reviewState: options.reviewState || undefined,
+        listingState: options.listingState || undefined
+      })
+    );
+  }
+
+  async listAgentRuntimeListings(options = {}) {
+    return this.query(
+      api.agentRuntimeMarketplace.listListings,
+      this.authArgs({
+        includeHidden: Boolean(options.includeHidden),
+        limit: options.limit || 30
+      })
+    );
+  }
+
+  async grantAgentRuntimeEntitlement(listingId, options = {}) {
+    return this.mutation(
+      api.agentRuntimeMarketplace.grantEntitlement,
+      this.authArgs({
+        listingId,
+        source: options.source || undefined,
+        expiresAt: options.expiresAt || undefined,
+        idempotencyKey: options.idempotencyKey || undefined
+      })
+    );
+  }
+
+  async adminReviewAgentRuntimeListing(listingId, options = {}) {
+    return this.mutation(
+      api.agentRuntimeMarketplace.adminReviewListing,
+      this.authArgs({
+        listingId,
+        reviewState: options.reviewState || 'approved',
+        listingState: options.listingState || undefined,
+        safetyState: options.safetyState || undefined,
+        reviewNotes: options.reviewNotes || undefined
+      })
+    );
+  }
+
+  async invokeAgentRuntimeListing(options = {}) {
+    return this.action(
+      api.agentRuntimeMarketplace.invokeListing,
+      this.authArgs({
+        listingId: options.listingId,
+        chatId: options.chatId || undefined,
+        content: options.content,
+        callbackUrl: options.callbackUrl || undefined,
+        idempotencyKey: options.idempotencyKey || undefined
+      })
+    );
+  }
+
+  async getRuntimePurchasePreview(listingId, options = {}) {
+    return this.query(
+      api.marketplaceBilling.getRuntimePurchasePreview,
+      this.authArgs({
+        listingId,
+        promptBytes: options.promptBytes ?? undefined,
+        fileBytes: options.fileBytes ?? undefined
+      })
+    );
+  }
+
+  async setRuntimeBudgetSettings(options = {}) {
+    return this.mutation(
+      api.marketplaceBilling.setRuntimeBudgetSettings,
+      this.authArgs({
+        listingId: options.listingId || undefined,
+        singleRunMaxCredits: options.singleRunMaxCredits ?? 0,
+        dailyMaxCredits: options.dailyMaxCredits ?? 0,
+        allowAutoRetry: Boolean(options.allowAutoRetry)
+      })
+    );
+  }
+
+  async generateCreatorAlipayAppKeys(options = {}) {
+    return this.action(
+      api.marketplaceBilling.generateCreatorAlipayAppKeys,
+      this.authArgs({
+        alipayAppId: options.alipayAppId,
+        merchantName: options.merchantName || undefined,
+        merchantAccount: options.merchantAccount || options.sellerId || undefined,
+        serviceId: options.serviceId || undefined,
+        alipayPublicKeyPem: options.alipayPublicKeyPem || undefined
+      })
+    );
+  }
+
+  async saveCreatorAlipayCollectConfig(options = {}) {
+    return this.generateCreatorAlipayAppKeys(options);
+  }
+
+  async listCreatorAlipayApps(options = {}) {
+    return this.query(
+      api.marketplaceBilling.listCreatorAlipayApps,
+      this.authArgs({ limit: options.limit || 20 })
+    );
+  }
+
+  async verifyCreatorAlipayAppConfig(creatorAlipayAppId, options = {}) {
+    return this.mutation(
+      api.marketplaceBilling.verifyCreatorAlipayAppConfig,
+      this.authArgs({
+        creatorAlipayAppId,
+        uploadedToAlipay: options.uploadedToAlipay !== false
+      })
+    );
+  }
+
+  async createSkillPlan(options = {}) {
+    return this.mutation(
+      api.marketplaceBilling.createSkillPlan,
+      this.authArgs({
+        skillCatalogId: options.skillCatalogId,
+        name: options.name,
+        planType: 'one_time',
+        monetizationMode: options.monetizationMode || undefined,
+        priceCredits: options.priceCredits ?? 0,
+        priceCents: options.priceCents ?? undefined,
+        currency: options.currency || undefined,
+        creatorAlipayAppId: options.creatorAlipayAppId || undefined,
+        benefits: options.benefits || undefined,
+        status: options.status || undefined
+      })
+    );
+  }
+
+  async setSkillPrice(skillCatalogId, options = {}) {
+    const amount = options.priceAmount ?? options.priceYuan ?? options.price;
+    const priceCents = options.priceCents ?? (
+      amount === undefined || amount === null || amount === ''
+        ? 0
+        : Math.round(Number(amount) * 100)
+    );
+    return this.mutation(
+      api.marketplaceBilling.setSkillPricing,
+      this.authArgs({
+        skillCatalogId,
+        priceCents,
+        currency: options.currency || (options.payableChannel === 'stripe' ? 'USD' : 'CNY'),
+        payableChannel: options.payableChannel || 'alipay_ai_collect',
+        creatorAlipayAppId: options.creatorAlipayAppId || undefined,
+        status: options.status || 'active'
+      })
+    );
+  }
+
+  async setPaidSkillPrice(skillCatalogId, options = {}) {
+    return this.setSkillPrice(skillCatalogId, options);
+  }
+
+  async listSkillPlans(skillCatalogId, options = {}) {
+    return this.query(
+      api.marketplaceBilling.listSkillPlans,
+      this.authArgs({
+        skillCatalogId,
+        includeInactive: Boolean(options.includeInactive)
+      })
+    );
+  }
+
+  async createPaymentIntent(options = {}) {
+    return this.mutation(
+      api.marketplaceBilling.createPaymentIntent,
+      this.authArgs({
+        orderType: options.orderType,
+        payableChannel: options.payableChannel,
+        sourceSurface: options.sourceSurface || 'web_dashboard',
+        amountCents: options.amountCents ?? undefined,
+        currency: options.currency || undefined,
+        credits: options.credits ?? undefined,
+        runtimeListingId: options.runtimeListingId || undefined,
+        skillCatalogId: options.skillCatalogId || undefined,
+        skillPlanId: options.skillPlanId || undefined,
+        creatorAlipayAppId: options.creatorAlipayAppId || undefined,
+        description: options.description || undefined,
+        idempotencyKey: options.idempotencyKey || createIdempotencyKey('payment-intent', [
+          options.orderType,
+          options.runtimeListingId,
+          options.skillCatalogId,
+          options.skillPlanId,
+          options.creatorAlipayAppId,
+          options.credits,
+          options.amountCents
+        ])
+      })
+    );
+  }
+
+  async createAlipayAiCollectSkillCheckout(options = {}) {
+    return this.action(
+      api.marketplaceBilling.createAlipayAiCollectSkillCheckout,
+      this.authArgs({
+        skillCatalogId: options.skillCatalogId,
+        skillPlanId: options.skillPlanId,
+        amountCents: options.amountCents,
+        currency: options.currency || 'CNY',
+        description: options.description || undefined,
+        sourceSurface: options.sourceSurface || 'web_dashboard',
+        idempotencyKey: options.idempotencyKey || createIdempotencyKey('alipay-ai-collect-skill', [
+          options.skillCatalogId,
+          options.skillPlanId,
+          options.amountCents
+        ])
+      })
+    );
+  }
+
+  alipayAiCollectPaymentResourceUrl(orderIdOrUrl, options = {}) {
+    const value = String(orderIdOrUrl || options.orderId || options.paymentResourceUrl || '').trim();
+    if (!value) {
+      throw new XiasheError('Missing Alipay AI Collect order id or payment resource URL.', {
+        code: 'ALIPAY_AI_COLLECT_RESOURCE_REQUIRED'
+      });
+    }
+    if (/^https?:\/\//i.test(value)) {
+      return value;
+    }
+    const actionsUrl = normalizeBaseUrl(options.actionsUrl || this.profile.actionsUrl);
+    if (!actionsUrl) {
+      throw new XiasheError('Missing actions URL for Alipay AI Collect payment resource.', {
+        code: 'ACTIONS_URL_REQUIRED'
+      });
+    }
+    return `${actionsUrl}/payment/alipay-ai-collect?orderId=${encodeURIComponent(value)}`;
+  }
+
+  async getAlipayAiCollectPaymentNeeded(orderIdOrUrl, options = {}) {
+    const url = this.alipayAiCollectPaymentResourceUrl(orderIdOrUrl, options);
+    const response = await withTimeout(
+      (signal) =>
+        fetch(url, {
+          method: 'GET',
+          headers: {
+            accept: 'application/json',
+            ...(options.headers || {})
+          },
+          signal
+        }),
+      options.timeoutMs || this.timeoutMs
+    );
+    const text = await response.text();
+    let payload = {};
+    try {
+      payload = text ? JSON.parse(text) : {};
+    } catch {
+      payload = { text };
+    }
+    if (response.status !== 402 && !response.ok) {
+      throw new XiasheError(payload.error || payload.message || `HTTP ${response.status}`, {
+        code: payload.error || `HTTP_${response.status}`,
+        status: response.status,
+        details: payload
+      });
+    }
+    return {
+      status: response.status,
+      ok: response.ok,
+      paymentResourceUrl: url,
+      paymentNeededHeader: response.headers.get('Payment-Needed') || response.headers.get('payment-needed') || null,
+      payload
+    };
+  }
+
+  async completeAlipayAiCollectPayment(orderIdOrUrl, paymentProofHeader, options = {}) {
+    const paymentProof = String(paymentProofHeader || options.paymentProof || '').trim();
+    if (!paymentProof) {
+      throw new XiasheError('Missing Payment-Proof header.', { code: 'PAYMENT_PROOF_REQUIRED' });
+    }
+    const url = this.alipayAiCollectPaymentResourceUrl(orderIdOrUrl, options);
+    const response = await withTimeout(
+      (signal) =>
+        fetch(url, {
+          method: 'GET',
+          headers: {
+            accept: 'application/json',
+            'Payment-Proof': paymentProof,
+            ...(options.headers || {})
+          },
+          signal
+        }),
+      options.timeoutMs || this.timeoutMs
+    );
+    const text = await response.text();
+    let payload = {};
+    try {
+      payload = text ? JSON.parse(text) : {};
+    } catch {
+      payload = { text };
+    }
+    if (!response.ok) {
+      throw new XiasheError(payload.error || payload.message || `HTTP ${response.status}`, {
+        code: payload.error || `HTTP_${response.status}`,
+        status: response.status,
+        details: payload
+      });
+    }
+    return {
+      status: response.status,
+      paymentResourceUrl: url,
+      paymentValidationHeader: response.headers.get('Payment-Validation') || response.headers.get('payment-validation') || null,
+      payload
+    };
+  }
+
+  async requestOrderRefund(orderId, options = {}) {
+    return this.mutation(
+      api.marketplaceBilling.requestOrderRefund,
+      this.authArgs({
+        orderId,
+        reason: options.reason || undefined
+      })
+    );
+  }
+
+  async openOrderDispute(orderId, reason) {
+    return this.mutation(
+      api.marketplaceBilling.openOrderDispute,
+      this.authArgs({ orderId, reason })
+    );
+  }
+
+  async adminCompleteOrderRefund(orderId, options = {}) {
+    return this.mutation(
+      api.marketplaceBilling.completeOrderRefundForAdmin,
+      this.authArgs({
+        orderId,
+        providerRefundNo: options.providerRefundNo || undefined,
+        reason: options.reason || undefined
+      })
+    );
+  }
+
+  async listMyOrders(options = {}) {
+    return this.query(
+      api.marketplaceBilling.listMyOrders,
+      this.authArgs({ limit: options.limit || 30 })
+    );
+  }
+
+  async listCreatorEarnings(options = {}) {
+    return this.query(
+      api.marketplaceBilling.listCreatorEarnings,
+      this.authArgs({
+        payoutState: options.payoutState || undefined,
+        limit: options.limit || 50
+      })
+    );
+  }
+
+  async adminRecordPaymentReconciliation(options = {}) {
+    return this.mutation(
+      api.marketplaceBilling.recordPaymentReconciliation,
+      this.authArgs({
+        provider: options.provider,
+        providerOrderId: options.providerOrderId,
+        orderId: options.orderId,
+        status: options.status || 'paid',
+        amountCents: options.amountCents ?? 0,
+        idempotencyKey: options.idempotencyKey || createIdempotencyKey('payment-reconcile', [
+          options.provider,
+          options.providerOrderId,
+          options.orderId,
+          options.status
+        ])
+      })
+    );
+  }
+
   async listChats() {
     return this.query(api.chats.listForUserSidebar, this.authArgs());
   }
@@ -947,3 +1357,10 @@ export function printableAgentPrompt(issue) {
 export function stableTaskId() {
   return `xiashe-cli-${randomUUID()}`;
 }
+
+export {
+  AlipayWalletError,
+  checkAlipayWallet,
+  payAlipay402Resource,
+  queryAlipay402Resource
+} from './alipayWallet.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiashe/sdk",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "type": "module",
   "main": "index.mjs",
   "exports": {