xytara 3.1.16 → 3.2.0

package/lib/release_pack.js

@@ -1,453 +0,0 @@
-"use strict";
-
-const packageJson = require("../package.json");
-const {
-  buildDefaultTransactionCenter,
-  summarizeCatalog,
-  summarizeCreditPacks,
-  summarizeDefaultTransactionEconomics,
-  summarizeDefaultTransactionGuidedLoops,
-  summarizeDefaultTransactionTaskPacks,
-  summarizeInteractionResultPackages,
-  summarizeInteractionSpinePaths,
-  summarizePrecommitInteractionPacks,
-  summarizeTransactionClassPacks
-} = require("./catalog_contract");
-const {
-  summarizeIntegrationProtocols,
-  summarizeIntegrationSettlementModes,
-  summarizeIntegrations
-} = require("../integrations/registry");
-
-function buildComparisonPack() {
-  return {
-    ok: true,
-    product: packageJson.name,
-    category: "machine-commerce-comparison",
-    comparisons: [
-      {
-        alternative: "runtime_only_stack",
-        missing_capabilities: [
-          "priced_quote_before_execution",
-          "native_payment_admission",
-          "reusable_credit_balance",
-          "settlement_aware_runtime_records",
-          "proof_ready_result_handoff"
-        ],
-        xytara_advantage: "one spine for discovery, pricing, payment or credit spend, execution, inspection, and proof-compatible handoff"
-      },
-      {
-        alternative: "payment_only_stack",
-        missing_capabilities: [
-          "task_catalog_and_workflow_classes",
-          "deterministic_usage_metering",
-          "runtime_result_packages",
-          "operator_payment_to_execution_linkage",
-          "post_payment_proof_followthrough"
-        ],
-        xytara_advantage: "payments remain attached to actual machine work, settlement state, treasury state, and result delivery"
-      },
-      {
-        alternative: "ad_hoc_agent_glue",
-        missing_capabilities: [
-          "stable_default_transaction_center",
-          "typed_task_pack_catalog",
-          "credit_and_entitlement_posture",
-          "operator_pack_surfaces",
-          "consistent_machine_contracts"
-        ],
-        xytara_advantage: "direct machine-commerce defaults reduce custom glue while preserving adapter breadth"
-      }
-    ],
-    strongest_reasons_to_try: [
-      "one-line direct run with payment-aware retry posture",
-      "credits-first repeat execution without changing the public runtime surface",
-      "operator-facing payment and settlement inspection surfaces",
-      "proof-compatible handoff into xoonya instead of dead-end runtime output"
-    ]
-  };
-}
-
-function summarizeComparisonPack() {
-  const pack = buildComparisonPack();
-  return {
-    ok: true,
-    product: pack.product,
-    comparison_count: pack.comparisons.length,
-    strongest_reason_count: pack.strongest_reasons_to_try.length,
-    alternatives: pack.comparisons.map((entry) => entry.alternative)
-  };
-}
-
-function buildAdoptionPack() {
-  return {
-    ok: true,
-    product: packageJson.name,
-    category: "machine-commerce-adoption",
-    positioning_line: "neutral machine transaction spine for agents that need governed execution, payment, proof, and replayability",
-    best_initial_wedge: "paid machine capability execution where trust is weak and proof matters",
-    initial_adoption_targets: [
-      {
-        target: "paid_agent_tools_and_services",
-        why_now: "builders already need quote, pay, execute, and inspect behavior around premium machine capabilities"
-      },
-      {
-        target: "cross_organization_agent_workflows",
-        why_now: "weak-trust interactions make payment and proof linkage materially more valuable than plain orchestration"
-      },
-      {
-        target: "high_frequency_microtask_systems",
-        why_now: "credits-first spend, deterministic metering, and reusable runtime posture reduce friction for repeated machine work"
-      },
-      {
-        target: "adapter_rich_execution_environments",
-        why_now: "protocol and settlement neutrality matters when teams do not want to lock into one runtime or one rail"
-      }
-    ],
-    target_ecosystems: [
-      "agent_builders",
-      "mcp_tool_authors",
-      "agent_marketplaces",
-      "x402_and_machine_payment_builders",
-      "weak_trust_multi_org_automation_teams"
-    ],
-    first_success_paths: [
-      {
-        path: "direct_pay_single_run",
-        start_with: "xytara-run",
-        success_condition: "agent discovers one capability, quotes it, pays, executes, and receives inspectable result records"
-      },
-      {
-        path: "credits_first_repeat_run",
-        start_with: "credit_pack_and_balance_surfaces",
-        success_condition: "funded agent reuses credits across repeated tasks without changing the public execution surface"
-      },
-      {
-        path: "runtime_to_proof_followthrough",
-        start_with: "result_package_export",
-        success_condition: "runtime output continues directly into xoonya proof review without ad hoc glue"
-      }
-    ],
-    what_to_say_publicly: [
-      "quote pay execute prove in one machine flow",
-      "governed execution for weak-trust agent interactions",
-      "payment, settlement, metering, and proof continuity in one stack",
-      "adapter-first machine commerce instead of one-off glue"
-    ],
-    what_not_to_lead_with: [
-      "just another agent framework",
-      "generic ai infrastructure",
-      "wallet-first branding",
-      "provider-specific lock-in language"
-    ]
-  };
-}
-
-function summarizeAdoptionPack() {
-  const pack = buildAdoptionPack();
-  return {
-    ok: true,
-    product: pack.product,
-    wedge: pack.best_initial_wedge,
-    target_count: pack.initial_adoption_targets.length,
-    ecosystem_count: pack.target_ecosystems.length,
-    first_success_path_count: pack.first_success_paths.length,
-    lead_message_count: pack.what_to_say_publicly.length
-  };
-}
-
-function buildScenarioPack() {
-  return {
-    ok: true,
-    product: packageJson.name,
-    category: "machine-commerce-scenarios",
-    scenarios: [
-      {
-        scenario_ref: "scenario.direct_pay.trust_verify",
-        title: "Direct Pay Trust Verify",
-        intended_for: "first_paid_machine_call",
-        why_it_matters: "shows the full quote pay execute inspect loop with the smallest strong-signal task",
-        steps: [
-          "inspect /v1/catalog/summary",
-          "run xytara-run for trust.verify",
-          "inspect transaction, payment, and settlement records"
-        ],
-        entrypoint: "xytara first-run --run-quote --account ACCOUNT_REF --pretty",
-        surfaces: [
-          "/v1/catalog/summary",
-          "/x402/commands/execute",
-          "/v1/payment-ledger",
-          "/v1/settlement/bsv-teranode"
-        ],
-        success_signals: [
-          "transaction recorded",
-          "payment admitted",
-          "settlement record created",
-          "deliverable available"
-        ]
-      },
-      {
-        scenario_ref: "scenario.credits_first.repeat_run",
-        title: "Credits-First Repeat Run",
-        intended_for: "reusable_machine_balance",
-        why_it_matters: "shows repeat machine execution without reintroducing pay-in friction for each call",
-        steps: [
-          "fund credits through credit packs or external grant",
-          "inspect credit balance",
-          "execute with payment_preference credits_first",
-          "inspect usage meters and entitlements"
-        ],
-        entrypoint: "POST /v1/commands/execute with payment_preference=credits_first",
-        surfaces: [
-          "/v1/credit-packs/summary",
-          "/v1/economics/accounts/:account_id/credit-balance",
-          "/v1/economics/accounts/:account_id/usage-meters",
-          "/v1/economics/accounts/:account_id/entitlements"
-        ],
-        success_signals: [
-          "available units decrease",
-          "usage meter recorded",
-          "same execution surface reused",
-          "no extra payment challenge required"
-        ]
-      },
-      {
-        scenario_ref: "scenario.runtime_to_proof.followthrough",
-        title: "Runtime To Proof Followthrough",
-        intended_for: "proof_aware_machine_execution",
-        why_it_matters: "shows that runtime output is not a dead end and can continue into proof review directly",
-        steps: [
-          "execute one transaction-class or default loop",
-          "export result package or economic consequence handoff",
-          "continue into xoonya review"
-        ],
-        entrypoint: "POST /v1/transaction-center/result-packages/export or xytara result-package surfaces",
-        surfaces: [
-          "/v1/transaction-center/result-packages",
-          "/v1/transaction-center/result-package/export-template",
-          "/v1/economics/handoff-bundles/economic-consequence"
-        ],
-        success_signals: [
-          "result package produced",
-          "handoff bundle emitted",
-          "proof-side review path clear"
-        ]
-      }
-    ]
-  };
-}
-
-function summarizeScenarioPack() {
-  const pack = buildScenarioPack();
-  return {
-    ok: true,
-    product: pack.product,
-    scenario_count: pack.scenarios.length,
-    scenario_refs: pack.scenarios.map((entry) => entry.scenario_ref),
-    first_entrypoint: pack.scenarios[0] ? pack.scenarios[0].entrypoint : null
-  };
-}
-
-function buildLaunchPack(options = {}) {
-  const releaseSummary = summarizeReleasePack();
-  const comparisonSummary = summarizeComparisonPack();
-  const adoptionSummary = summarizeAdoptionPack();
-  const scenarioSummary = summarizeScenarioPack();
-  return {
-    ok: true,
-    product: packageJson.name,
-    category: "machine-commerce-launch-pack",
-    launch_readiness: {
-      release_summary: releaseSummary,
-      comparison_summary: comparisonSummary,
-      adoption_summary: adoptionSummary,
-      scenario_summary: scenarioSummary,
-      live_readiness: options.liveReadiness || null,
-      operator_posture: {
-        payment_ledger_surface: "/v1/payment-ledger",
-        settlement_surface: "/v1/settlement/bsv-teranode",
-        durability_surface: "/v1/runtime/durability"
-      }
-    },
-    launch_operator_checks: [
-      "release summary is reachable",
-      "comparison summary is reachable",
-      "adoption summary is reachable",
-      "scenario summary is reachable",
-      "runtime durability is inspectable",
-      "native settlement readiness is inspectable"
-    ],
-    first_public_pointer: "/v1/release-pack/launch/summary"
-  };
-}
-
-function summarizeLaunchPack(options = {}) {
-  const pack = buildLaunchPack(options);
-  return {
-    ok: true,
-    product: pack.product,
-    category: pack.category,
-    task_count: pack.launch_readiness.release_summary.task_count,
-    integration_count: pack.launch_readiness.release_summary.integration_count,
-    comparison_count: pack.launch_readiness.comparison_summary.comparison_count,
-    target_count: pack.launch_readiness.adoption_summary.target_count,
-    scenario_count: pack.launch_readiness.scenario_summary.scenario_count,
-    operator_check_count: pack.launch_operator_checks.length,
-    live_ready: pack.launch_readiness.live_readiness ? pack.launch_readiness.live_readiness.ready : null
-  };
-}
-
-function buildReleasePack() {
-  const transactionCenter = buildDefaultTransactionCenter();
-  const catalogSummary = summarizeCatalog();
-  const transactionEconomics = summarizeDefaultTransactionEconomics();
-  const taskPackSummary = summarizeDefaultTransactionTaskPacks();
-  const guidedLoopSummary = summarizeDefaultTransactionGuidedLoops();
-  const transactionClassSummary = summarizeTransactionClassPacks();
-  const precommitSummary = summarizePrecommitInteractionPacks();
-  const spineSummary = summarizeInteractionSpinePaths();
-  const resultPackageSummary = summarizeInteractionResultPackages();
-  const creditPackSummary = summarizeCreditPacks();
-  const integrationSummary = summarizeIntegrations();
-  const protocolSummary = summarizeIntegrationProtocols();
-  const settlementModeSummary = summarizeIntegrationSettlementModes();
-  const defaultProtocol = transactionCenter && transactionCenter.default_protocol
-    ? transactionCenter.default_protocol.protocol
-    : null;
-  const defaultPaymentProtocol = transactionCenter && transactionCenter.default_payment
-    ? transactionCenter.default_payment.protocol
-    : null;
-  const defaultSettlementMode = transactionCenter && transactionCenter.default_settlement
-    ? transactionCenter.default_settlement.settlement_mode
-    : null;
-
-  return {
-    ok: true,
-    product: {
-      name: packageJson.name,
-      version: packageJson.version,
-      description: packageJson.description,
-      homepage: packageJson.homepage,
-      repository: packageJson.repository && packageJson.repository.url ? packageJson.repository.url : null,
-      license: packageJson.license
-    },
-    positioning: {
-      category: "machine-commerce-spine",
-      primary_audiences: [
-        "agent_builders",
-        "machine_economy_developers",
-        "adapter_authors",
-        "settlement_aware_runtime_operators"
-      ],
-      core_claims: [
-        "discover_quote_pay_execute_inspect_handoff",
-        "credits_first_or_direct_payment",
-        "deterministic_usage_metering",
-        "settlement_aware_runtime_records",
-        "proof_compatible_handoff_into_xoonya"
-      ]
-    },
-    first_contact: {
-      install: "npm install xytara",
-      direct_run_cli: "xytara first-run --run-quote --account ACCOUNT_REF --pretty",
-      discovery_surface: "/v1/catalog/summary",
-      transaction_center_surface: "/v1/transaction-center/summary",
-      economics_surface: "/v1/transaction-center/economics/summary",
-      handoff_expectation: "transaction result packages should continue into xoonya proof review and proof-native completion"
-    },
-    package_usage: {
-      install_command: "npm install xytara",
-      verify_command: "npm run verify:all",
-      local_service_command: "npm start",
-      release_cli: "xytara-release --summary",
-      docs: [
-        "README.md",
-        "START_HERE.md",
-        "FINAL_CONTRACT.md",
-        "SERVICE_CONTRACT.md",
-        "REAL_PAYMENT_SETUP.md"
-      ]
-    },
-    default_path: {
-      protocol: defaultProtocol,
-      payment_protocol: defaultPaymentProtocol,
-      settlement_mode: defaultSettlementMode,
-      suggested_paths: Array.isArray(transactionCenter && transactionCenter.suggested_paths)
-        ? transactionCenter.suggested_paths
-        : []
-    },
-    commerce_loop: {
-      stages: ["discover", "quote", "pay_or_spend", "execute", "deliver", "inspect", "prove"],
-      spend_postures: ["direct_payment", "credits_first", "bounded_spend_credential"],
-      operator_surfaces: [
-        "/v1/operator-shell/summary",
-        "/v1/payment-ledger",
-        "/v1/settlement/bsv-teranode",
-        "/v1/runtime/durability"
-      ]
-    },
-    catalog_summary: catalogSummary,
-    transaction_economics_summary: transactionEconomics,
-    task_pack_summary: taskPackSummary,
-    guided_loop_summary: guidedLoopSummary,
-    transaction_class_summary: transactionClassSummary,
-    precommit_summary: precommitSummary,
-    spine_summary: spineSummary,
-    result_package_summary: resultPackageSummary,
-    credit_pack_summary: creditPackSummary,
-    integration_summary: integrationSummary,
-    protocol_summary: protocolSummary,
-    settlement_mode_summary: settlementModeSummary
-  };
-}
-
-function summarizeReleasePack() {
-  const pack = buildReleasePack();
-  return {
-    ok: true,
-    product: pack.product.name,
-    version: pack.product.version,
-    category: pack.positioning.category,
-    primary_audience_count: pack.positioning.primary_audiences.length,
-    core_claim_count: pack.positioning.core_claims.length,
-    default_protocol: pack.default_path.protocol,
-    default_payment_protocol: pack.default_path.payment_protocol,
-    default_settlement_mode: pack.default_path.settlement_mode,
-    suggested_path_count: Array.isArray(pack.default_path.suggested_paths) ? pack.default_path.suggested_paths.length : 0,
-    task_count: pack.catalog_summary.task_count,
-    workflow_count: pack.catalog_summary.workflow_count,
-    credit_pack_count: pack.credit_pack_summary.credit_pack_count,
-    integration_count: pack.integration_summary.integration_count,
-    production_default_integration_count: pack.integration_summary.production_default_count,
-    protocol_count: pack.protocol_summary.protocol_count,
-    settlement_mode_count: pack.settlement_mode_summary.settlement_mode_count,
-    transaction_class_count: pack.transaction_class_summary.class_pack_count,
-    result_package_count: pack.result_package_summary.result_package_count,
-    first_contact_cli: pack.first_contact.direct_run_cli,
-    install_command: pack.package_usage.install_command,
-    verify_command: pack.package_usage.verify_command,
-    release_cli: pack.package_usage.release_cli,
-    doc_count: pack.package_usage.docs.length,
-    comparison_surface: "/v1/release-pack/comparison",
-    comparison_cli: "xytara-release --comparison",
-    adoption_surface: "/v1/release-pack/adoption",
-    adoption_cli: "xytara-release --adoption",
-    scenario_surface: "/v1/release-pack/scenarios",
-    scenario_cli: "xytara-release --scenarios",
-    launch_surface: "/v1/release-pack/launch",
-    launch_cli: "xytara-release --launch"
-  };
-}
-
-module.exports = {
-  buildReleasePack,
-  summarizeReleasePack,
-  buildComparisonPack,
-  summarizeComparisonPack,
-  buildAdoptionPack,
-  summarizeAdoptionPack,
-  buildScenarioPack,
-  summarizeScenarioPack,
-  buildLaunchPack,
-  summarizeLaunchPack
-};

package/lib/request_rate_limit.js

@@ -1,144 +0,0 @@
-"use strict";
-
-function loadRateLimitConfig() {
-  const enabled = String(process.env.XYTARA_RATE_LIMIT_ENABLED || "true").trim().toLowerCase() !== "false";
-  const windowMs = Math.max(1000, Number(process.env.XYTARA_RATE_LIMIT_WINDOW_MS || 60000) || 60000);
-  const maxRequests = Math.max(1, Number(process.env.XYTARA_RATE_LIMIT_MAX_REQUESTS || 600) || 600);
-  const routeScoped = String(process.env.XYTARA_RATE_LIMIT_ROUTE_SCOPED || "true").trim().toLowerCase() !== "false";
-  return {
-    enabled,
-    window_ms: windowMs,
-    max_requests: maxRequests,
-    route_scoped: routeScoped
-  };
-}
-
-function resolveRequestIdentity(req) {
-  const forwarded = req && req.headers && typeof req.headers["x-forwarded-for"] === "string"
-    ? req.headers["x-forwarded-for"].split(",")[0].trim()
-    : "";
-  if (forwarded) return forwarded;
-  const socketAddress = req && req.socket && typeof req.socket.remoteAddress === "string"
-    ? req.socket.remoteAddress.trim()
-    : "";
-  return socketAddress || "unknown";
-}
-
-function resolveRouteScope(pathname) {
-  const path = typeof pathname === "string" && pathname.trim()
-    ? pathname.trim()
-    : "/";
-  if (path === "/v1/credit-bridge/grants" || path.startsWith("/v1/credit-bridge/grants/")) {
-    return "/v1/credit-bridge/grants";
-  }
-  if (path.startsWith("/v1/economics/rails/credits/")) {
-    return "/v1/economics/rails/credits";
-  }
-  if (path.startsWith("/v1/economics/")) {
-    return "/v1/economics";
-  }
-  if (path.startsWith("/v1/account-auth/")) {
-    return "/v1/account-auth";
-  }
-  if (path.startsWith("/v1/commands/")) {
-    return "/v1/commands";
-  }
-  if (path.startsWith("/v1/")) {
-    const parts = path.split("/").filter(Boolean);
-    return parts.length >= 2 ? `/${parts[0]}/${parts[1]}` : "/v1";
-  }
-  const parts = path.split("/").filter(Boolean);
-  return parts.length ? `/${parts[0]}` : "/";
-}
-
-function normalizeTrustedIdentity(value) {
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  if (!trimmed) return null;
-  return trimmed.replace(/[^a-zA-Z0-9_.:-]/g, "_").slice(0, 120);
-}
-
-function createRequestRateLimiter(config = {}) {
-  const cfg = {
-    ...loadRateLimitConfig(),
-    ...(config || {})
-  };
-  const buckets = new Map();
-
-  function sweep(nowMs) {
-    for (const [key, bucket] of buckets.entries()) {
-      if (!bucket || Number(bucket.reset_at_ms || 0) <= nowMs) {
-        buckets.delete(key);
-      }
-    }
-  }
-
-  function check(req, options = {}) {
-    if (!cfg.enabled) {
-      return { ok: true, rate_limit: null };
-    }
-    const method = req && typeof req.method === "string" ? req.method.toUpperCase() : "GET";
-    if (["GET", "HEAD", "OPTIONS"].includes(method)) {
-      return { ok: true, rate_limit: null };
-    }
-    if (typeof cfg.skipRateLimitResolver === "function" && cfg.skipRateLimitResolver(req, options) === true) {
-      return { ok: true, rate_limit: null, bypassed: true };
-    }
-
-    const nowMs = Date.now();
-    sweep(nowMs);
-    const trustedIdentity = typeof cfg.trustedIdentityResolver === "function"
-      ? normalizeTrustedIdentity(cfg.trustedIdentityResolver(req, options))
-      : null;
-    const identity = trustedIdentity ? `trusted:${trustedIdentity}` : `ip:${resolveRequestIdentity(req)}`;
-    const routeScope = cfg.route_scoped ? resolveRouteScope(options.pathname) : "*";
-    const key = `${method}:${routeScope}:${identity}`;
-    const current = buckets.get(key);
-    if (!current || Number(current.reset_at_ms || 0) <= nowMs) {
-      const next = {
-        count: 1,
-        reset_at_ms: nowMs + cfg.window_ms
-      };
-      buckets.set(key, next);
-      return {
-        ok: true,
-        rate_limit: {
-          remaining: cfg.max_requests - 1,
-          reset_at_ms: next.reset_at_ms
-        }
-      };
-    }
-    if (current.count >= cfg.max_requests) {
-      return {
-        ok: false,
-        status: 429,
-        payload: {
-          ok: false,
-          reason: "rate_limit_exceeded",
-          retry_after_ms: Math.max(0, current.reset_at_ms - nowMs)
-        }
-      };
-    }
-    current.count += 1;
-    buckets.set(key, current);
-    return {
-      ok: true,
-      rate_limit: {
-        remaining: Math.max(0, cfg.max_requests - current.count),
-        reset_at_ms: current.reset_at_ms
-      }
-    };
-  }
-
-  return {
-    check,
-    config: cfg
-  };
-}
-
-module.exports = {
-  createRequestRateLimiter,
-  loadRateLimitConfig,
-  resolveRequestIdentity,
-  resolveRouteScope
-};

package/lib/resource_views.js

@@ -1,31 +0,0 @@
-"use strict";
-
-function buildMissingResponse(reason) {
-  return {
-    status: 404,
-    payload: { ok: false, reason }
-  };
-}
-
-function buildNamedRecordResponse(key, record, missingReason) {
-  if (!record) {
-    return buildMissingResponse(missingReason);
-  }
-  return {
-    status: 200,
-    payload: { ok: true, [key]: record }
-  };
-}
-
-function buildNamedRecordListResponse(key, records) {
-  return {
-    status: 200,
-    payload: { ok: true, [key]: records }
-  };
-}
-
-module.exports = {
-  buildMissingResponse,
-  buildNamedRecordListResponse,
-  buildNamedRecordResponse
-};