@lucid-agents/taskmarket 1.16.0 → 1.17.1

package/dist/doctor-BY2PBHS7.js

@@ -0,0 +1,216 @@
+import { createRequire as __tmCreateRequire } from 'node:module'; import { fileURLToPath as __tmFileURLToPath } from 'node:url'; import { dirname as __tmDirname } from 'node:path'; const require = __tmCreateRequire(import.meta.url); const __tmFilename = __tmFileURLToPath(import.meta.url); const __tmDirnameValue = __tmDirname(__tmFilename);
+import {
+  AGENT_COMPATIBILITY,
+  assertAgentCompatibility,
+  nodeVersionSupported
+} from "./chunk-OKZ2NRYZ.js";
+import {
+  listSandboxes
+} from "./chunk-JAZ5BWPB.js";
+import "./chunk-MI2GPMCZ.js";
+import "./chunk-EIHZYRIU.js";
+import {
+  channelView,
+  loadAgentPolicy,
+  openAgentChannels
+} from "./chunk-F5SS4NUF.js";
+import {
+  apiUrl,
+  getX402PolicyPath,
+  keystoreExists,
+  loadKeystore,
+  loadX402Policy,
+  rpcUrlForNetwork
+} from "./chunk-3S63AB3C.js";
+import "./chunk-YM4S6IE4.js";
+import {
+  AGENT_VIEW_VERSION
+} from "./chunk-73RXOYME.js";
+import "./chunk-S7SJMJ2I.js";
+
+// src/lib/agent/doctor.ts
+var CHAIN_IDS = { "eip155:8453": "0x2105", "eip155:84532": "0x14a34" };
+function reason(error) {
+  return error.code ?? error.message;
+}
+function loopback(url) {
+  return ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+}
+async function runDoctor(deps = {}) {
+  const fetchImpl = deps.fetch ?? fetch;
+  const nodeVersion = deps.nodeVersion ?? process.versions.node;
+  const apiBase = deps.apiUrl ?? apiUrl();
+  const checks = [];
+  const add = (id, status, summary) => checks.push({ id, status, summary });
+  const get = (url, init = {}) => fetchImpl(url, { redirect: "error", signal: AbortSignal.timeout(1e4), ...init });
+  add(
+    "node",
+    nodeVersionSupported(nodeVersion) ? "pass" : "fail",
+    `Node ${nodeVersion}; taskmarket agent needs ${AGENT_COMPATIBILITY.node.minimum} or later`
+  );
+  try {
+    (deps.checkRuntime ?? (() => assertAgentCompatibility({ nodeVersion: "99.0.0" })))();
+    add(
+      "runtime",
+      "pass",
+      `Bundled Pi ${AGENT_COMPATIBILITY.pi.version} and pi-xgate ${AGENT_COMPATIBILITY.piXgate.version} match this build`
+    );
+  } catch (error) {
+    add("runtime", "fail", error.message);
+  }
+  let credentials;
+  let walletAddress;
+  if (await keystoreExists()) {
+    const keystore = await loadKeystore();
+    credentials = { deviceId: keystore.deviceId, apiToken: keystore.apiToken };
+    walletAddress = keystore.walletAddress;
+    add("wallet", "pass", `Wallet ${keystore.walletAddress} (not unlocked)`);
+  } else {
+    add("wallet", "fail", "No wallet; run taskmarket wallet import");
+  }
+  let policy;
+  try {
+    policy = await loadAgentPolicy();
+    const foreign = policy.rails.filter(
+      (rail) => walletAddress && rail.wallet.toLowerCase() !== walletAddress.toLowerCase()
+    );
+    add(
+      "policy",
+      foreign.length > 0 ? "fail" : "pass",
+      foreign.length > 0 ? `Rail ${foreign[0].id} pays from ${foreign[0].wallet}, not this wallet` : `${policy.models.length} approved model(s), ${policy.rails.length} rail(s)`
+    );
+  } catch (error) {
+    add("policy", "fail", error.message);
+  }
+  const rpcUrls = /* @__PURE__ */ new Map();
+  if (policy) {
+    try {
+      const x402Policy = await loadX402Policy(getX402PolicyPath());
+      for (const rail of policy.rails)
+        rpcUrls.set(rail.network, rpcUrlForNetwork(x402Policy, rail.network));
+      add("payment_policy", "pass", `RPC configured for ${[...rpcUrls.keys()].join(", ")}`);
+    } catch (error) {
+      add("payment_policy", "fail", reason(error));
+    }
+  } else {
+    add("payment_policy", "skip", "No spending policy to check");
+  }
+  if (policy && rpcUrls.size > 0 && walletAddress) {
+    try {
+      const opened = await openAgentChannels();
+      const problems = [];
+      for (const rail of opened.rails) {
+        const channel = await channelView(rail);
+        if (channel.pendingOperation) {
+          problems.push(
+            `${channel.rail} has an unresolved ${channel.pendingOperation.kind} ${channel.pendingOperation.id}`
+          );
+        } else if (channel.state !== "open") {
+          problems.push(`${channel.rail} is ${channel.state}`);
+        }
+      }
+      add(
+        "channels",
+        problems.length > 0 ? "warn" : "pass",
+        problems.length > 0 ? problems.join("; ") : `${opened.rails.length} channel(s) open, nothing unresolved`
+      );
+    } catch (error) {
+      add("channels", "fail", reason(error));
+    }
+  } else {
+    add("channels", "skip", "Needs a wallet and a usable spending policy");
+  }
+  try {
+    const response = await get(`${apiBase.replace(/\/+$/, "")}/api/compute/pricing`);
+    await response.body?.cancel().catch(() => void 0);
+    add(
+      "api",
+      response.ok ? "pass" : "fail",
+      `${new URL(apiBase).origin} answered ${response.status}`
+    );
+  } catch (error) {
+    add("api", "fail", `${apiBase} is unreachable: ${reason(error)}`);
+  }
+  if (credentials) {
+    try {
+      const sandboxes = await listSandboxes(credentials, fetchImpl);
+      add(
+        "sandbox",
+        "pass",
+        `The sandbox broker answered; ${sandboxes.length} sandbox(es) on this wallet`
+      );
+    } catch (error) {
+      add("sandbox", "fail", `The sandbox broker is unavailable: ${reason(error)}`);
+    }
+  } else {
+    add("sandbox", "skip", "Needs a wallet");
+  }
+  const api = new URL(apiBase);
+  add(
+    "host_key",
+    api.protocol === "https:" ? "pass" : loopback(api) ? "warn" : "fail",
+    api.protocol === "https:" ? "Sandbox host keys are pinned per connection (ssh-ed25519 only) from the broker over HTTPS; never trusted on first use" : loopback(api) ? "The API is a local development server without TLS; host keys are only as trustworthy as it is" : `The API ${api.origin} is not HTTPS, so the sandbox host keys it returns cannot be trusted`
+  );
+  if (policy) {
+    for (const origin of new Set(policy.rails.map((rail) => rail.origin))) {
+      try {
+        const response = await get(`${origin}/v1/models`, {
+          headers: { accept: "application/json" }
+        });
+        await response.body?.cancel().catch(() => void 0);
+        add(
+          "xgate",
+          response.ok ? "pass" : "fail",
+          `${origin} catalog answered ${response.status}`
+        );
+      } catch (error) {
+        add("xgate", "fail", `${origin} is unreachable: ${reason(error)}`);
+      }
+    }
+    for (const [network, url] of rpcUrls) {
+      try {
+        const response = await get(url, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_chainId", params: [] })
+        });
+        const body = await response.json();
+        const expected = CHAIN_IDS[network];
+        add(
+          "rpc",
+          body.result === expected ? "pass" : "fail",
+          body.result === expected ? `${network} RPC reachable` : `${network} RPC answered chain ${String(body.result)}, expected ${expected}`
+        );
+      } catch (error) {
+        add("rpc", "fail", `${network} RPC is unreachable: ${reason(error)}`);
+      }
+    }
+  } else {
+    add("xgate", "skip", "No spending policy names an xgate origin");
+  }
+  return {
+    version: AGENT_VIEW_VERSION,
+    kind: "taskmarket.agent.doctor",
+    ok: !checks.some((check) => check.status === "fail"),
+    compatibility: {
+      node: nodeVersion,
+      nodeMinimum: AGENT_COMPATIBILITY.node.minimum,
+      pi: AGENT_COMPATIBILITY.pi.version,
+      piXgate: AGENT_COMPATIBILITY.piXgate.version,
+      protocol: AGENT_COMPATIBILITY.protocol
+    },
+    checks
+  };
+}
+function doctorLines(report) {
+  return [
+    `taskmarket agent doctor (view v${report.version}): ${report.ok ? "ready" : "problems found"}`,
+    ...report.checks.map(
+      (check) => `${check.status.toUpperCase().padEnd(4)} ${check.id}: ${check.summary}`
+    )
+  ];
+}
+export {
+  doctorLines,
+  runDoctor
+};

package/dist/errors-2L357HGA.js

@@ -0,0 +1,8 @@
+import { createRequire as __tmCreateRequire } from 'node:module'; import { fileURLToPath as __tmFileURLToPath } from 'node:url'; import { dirname as __tmDirname } from 'node:path'; const require = __tmCreateRequire(import.meta.url); const __tmFilename = __tmFileURLToPath(import.meta.url); const __tmDirnameValue = __tmDirname(__tmFilename);
+import {
+  AgentLaunchError
+} from "./chunk-YM4S6IE4.js";
+import "./chunk-S7SJMJ2I.js";
+export {
+  AgentLaunchError
+};