xytara 2.1.0 → 2.2.0

package/examples/adapter_review_walkthrough.js

@@ -0,0 +1,53 @@
+"use strict";
+
+const assert = require("assert");
+const { createServer } = require("../server");
+
+async function fetchJson(url) {
+  const response = await fetch(url);
+  assert.strictEqual(response.ok, true, `request failed: ${url}`);
+  return response.json();
+}
+
+async function postJson(url, body) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  assert.strictEqual(response.ok, true, `request failed: ${url}`);
+  return response.json();
+}
+
+async function main() {
+  const server = createServer();
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const { port } = server.address();
+  const baseUrl = `http://127.0.0.1:${port}`;
+
+  try {
+    const partnerSummary = await fetchJson(`${baseUrl}/v1/adapter-partners/summary`);
+    assert.strictEqual(typeof partnerSummary.category, "string", "adapter partner summary missing");
+
+    const readiness = await fetchJson(`${baseUrl}/v1/integrations/promotion-readiness`);
+    assert.strictEqual(readiness.ok, true, "promotion readiness summary missing");
+
+    const actionPreview = await postJson(`${baseUrl}/v1/integrations/promotion-actions/preview`, {
+      integration_id: "partner.protocol.acme_mcp",
+      action: "complete_certification"
+    });
+    assert.strictEqual(actionPreview.ok, true, "promotion action preview missing");
+    assert.strictEqual(actionPreview.valid_now, true, "promotion action preview should be valid");
+
+    console.log("xytara adapter review walkthrough passed");
+  } finally {
+    await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/examples/export_carried_handoff.js

@@ -0,0 +1,80 @@
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const path = require("path");
+const { createServer } = require("../server");
+const { createClient } = require("../index.js");
+
+function parseOutputPath(argv) {
+  const args = Array.isArray(argv) ? argv : [];
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] === "--output" && args[index + 1]) {
+      return path.resolve(process.cwd(), args[index + 1]);
+    }
+  }
+  return path.resolve(process.cwd(), "examples", "generated.carried-handoff.json");
+}
+
+async function main() {
+  const outputPath = parseOutputPath(process.argv.slice(2));
+  const server = createServer();
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const address = server.address();
+  const baseUrl = `http://127.0.0.1:${address.port}`;
+
+  try {
+    const client = createClient({
+      baseUrl,
+      apiKey: "demo-api-key",
+      walletId: "demo-wallet",
+      walletSecret: "demo-wallet-secret",
+      accountId: "acct_demo"
+    });
+
+    const health = await client.getHealthSummary();
+    assert.strictEqual(health.status, "ok", "health summary missing");
+
+    const exported = await client.exportInteractionResultPackage("result.spine.job.commitment", {
+      job_type: "batch.render",
+      job_id: "job-carried-handoff-demo",
+      source_zone_id: "zone.alpha",
+      target_zone_id: "zone.beta",
+      interaction_class: "cross_zone_job"
+    }, {
+      command: "carried-handoff-demo-export"
+    });
+
+    assert.strictEqual(
+      exported.portable_handoff_bundle.result_package_ref,
+      "result.spine.job.commitment",
+      "portable handoff result package ref missing"
+    );
+
+    const reviewInput = {
+      handoff_bundle: exported.portable_handoff_bundle
+    };
+
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, JSON.stringify(reviewInput, null, 2));
+
+    process.stdout.write(JSON.stringify({
+      ok: true,
+      output_file: outputPath,
+      result_package_ref: exported.portable_handoff_bundle.result_package_ref,
+      committed_ref: exported.portable_handoff_bundle.committed_ref,
+      proof_review_summary_surface: "/v1/proof-center/result-package-handoff/review/summary",
+      proof_run_surface: "/v1/proof-center/result-package-handoff/run",
+      next_xoonya_cli: `xoonya-review --file "${outputPath}" --summary`
+    }, null, 2));
+  } finally {
+    await new Promise((resolve, reject) => {
+      server.close((error) => (error ? reject(error) : resolve()));
+    });
+  }
+}
+
+main().catch((error) => {
+  process.stderr.write(`${error.stack || error.message}\n`);
+  process.exitCode = 1;
+});

package/examples/funded_runtime_walkthrough.js

@@ -0,0 +1,70 @@
+"use strict";
+
+const assert = require("assert");
+const { createServer } = require("../server");
+
+async function fetchJson(url, options) {
+  const response = await fetch(url, options);
+  assert.strictEqual(response.ok, true, `request failed: ${url}`);
+  return response.json();
+}
+
+async function postJson(url, body, headers = {}) {
+  return fetchJson(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: "Bearer demo-api-key",
+      ...headers
+    },
+    body: JSON.stringify(body)
+  });
+}
+
+async function main() {
+  const server = createServer();
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const { port } = server.address();
+  const baseUrl = `http://127.0.0.1:${port}`;
+
+  try {
+    const packSummary = await fetchJson(`${baseUrl}/v1/credit-packs/summary`);
+    assert.strictEqual(packSummary.ok, true, "credit pack summary missing");
+    assert.strictEqual(packSummary.credit_pack_count > 0, true, "credit pack count missing");
+
+    const grant = await postJson(
+      `${baseUrl}/v1/credit-bridge/grants`,
+      {
+        account_id: "acct_demo",
+        pack_id: "credits.agent",
+        grant_units: 120,
+        settlement_ref: "settlement-funded-runtime-demo-1",
+        external_ref: "external-funded-runtime-demo-1"
+      },
+      {
+        authorization: "Bearer demo-credit-bridge-token"
+      }
+    );
+    assert.strictEqual(grant.ok, true, "credit bridge grant missing");
+
+    const balance = await fetchJson(`${baseUrl}/v1/economics/accounts/acct_demo/credit-balance`);
+    assert.strictEqual(balance.account_id, "acct_demo", "credit balance missing");
+    assert.strictEqual(balance.available_units > 0, true, "credit balance not funded");
+
+    const preview = await postJson(`${baseUrl}/v1/economics/rails/credits/preview-spend`, {
+      account_id: "acct_demo",
+      task_ref: "trust.verify",
+      units: 40
+    });
+    assert.strictEqual(preview.ok, true, "credit preview missing");
+
+    console.log("xytara funded runtime walkthrough passed");
+  } finally {
+    await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/examples/partner_launch_walkthrough.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const assert = require("assert");
+const { createServer } = require("../server");
+
+async function fetchJson(url, options) {
+  const response = await fetch(url, options);
+  assert.strictEqual(response.ok, true, `request failed: ${url}`);
+  return response.json();
+}
+
+async function main() {
+  const server = createServer();
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const address = server.address();
+  const baseUrl = `http://127.0.0.1:${address.port}`;
+
+  try {
+    const releaseCenterSummary = await fetchJson(`${baseUrl}/v1/release-center/summary`);
+    assert.strictEqual(typeof releaseCenterSummary.category, "string", "release-center summary category missing");
+
+    const releaseCandidateSummary = await fetchJson(`${baseUrl}/v1/release-candidate/summary`);
+    assert.strictEqual(typeof releaseCandidateSummary.category, "string", "release-candidate summary category missing");
+
+    const durability = await fetchJson(`${baseUrl}/v1/runtime/durability`);
+    assert.strictEqual(durability.ok, true, "durability surface missing");
+    assert.strictEqual(typeof durability.operator_guidance, "string", "durability guidance missing");
+
+    const adapterPartnersSummary = await fetchJson(`${baseUrl}/v1/adapter-partners/summary`);
+    assert.strictEqual(typeof adapterPartnersSummary.category, "string", "adapter partners summary category missing");
+
+    console.log("xytara partner launch walkthrough passed");
+  } finally {
+    await new Promise((resolve, reject) => {
+      server.close((error) => (error ? reject(error) : resolve()));
+    });
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});