@lucid-agents/pi-xgate 0.0.0-stage → 0.1.6

package/src/extension.ts

@@ -0,0 +1,178 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { BrokerClient } from "@lucid-agents/xgate-client/broker";
+import { XgateError } from "@lucid-agents/xgate-client/types";
+import { readFileSync, lstatSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join } from "node:path";
+import { homedir } from "node:os";
+import { createXgateProvider } from "./provider.ts";
+import type { XgatePayment, XgateTransport } from "./transport.ts";
+export interface XgateExtensionOptions {
+  /**
+   * Host-managed transport, or a factory called on load and `/xgate refresh`. When set, the
+   * extension reads no broker configuration and `/xgate setup` is unavailable. Without it, the
+   * standalone `BrokerClient` from `XGATE_CONFIG` or `~/.pi/agent/xgate.json` is used.
+   */
+  transport?: XgateTransport | (() => XgateTransport | Promise<XgateTransport>);
+}
+function privateText(path: string, max = 8192): string {
+  if (!isAbsolute(path)) throw new XgateError("absolute_config_path_required");
+  const s = lstatSync(path);
+  if (
+    !s.isFile() ||
+    s.isSymbolicLink() ||
+    (s.mode & 0o077) !== 0 ||
+    s.size > max
+  )
+    throw new XgateError("private_config_required");
+  return readFileSync(path, "utf8").trim();
+}
+function standalone(configPath: string): BrokerClient {
+  const cfg = JSON.parse(privateText(configPath));
+  if (typeof cfg.url !== "string" || typeof cfg.tokenFile !== "string")
+    throw new XgateError("invalid_config");
+  return new BrokerClient(cfg.url, privateText(cfg.tokenFile, 128));
+}
+/** Rail-neutral: atomic units of the named asset; decimals are not assumed. */
+export function paymentStatus(p: XgatePayment): string {
+  const left = p.channel
+    ? `; channel ${p.channel.refundableAtomic} refundable`
+    : "";
+  return `xgate paid ${p.chargedAtomic ?? "?"}/${p.authorizedAtomic} ${p.asset} on ${p.network} (${p.scheme})${left}`;
+}
+/** Pi extension factory. The default export is the standalone wallet-broker extension. */
+export function createXgateExtension(
+  options: XgateExtensionOptions = {},
+): (pi: ExtensionAPI) => Promise<void> {
+  return (pi) => register(pi, options);
+}
+export default createXgateExtension();
+async function register(
+  pi: ExtensionAPI,
+  options: XgateExtensionOptions,
+): Promise<void> {
+  const injected = options.transport;
+  const configPath =
+    process.env.XGATE_CONFIG ?? join(homedir(), ".pi", "agent", "xgate.json");
+  let broker: XgateTransport | undefined;
+  let context: ExtensionContext | undefined;
+  const load = async () => {
+    const next =
+      injected === undefined
+        ? standalone(configPath)
+        : typeof injected === "function"
+          ? await injected()
+          : injected;
+    const provider = await createXgateProvider(next, {
+      sessionId: () => context?.sessionManager.getSessionId() ?? "standalone",
+      onPaid: (r) =>
+        context?.ui.setStatus(
+          "xgate",
+          r.payment
+            ? paymentStatus(r.payment)
+            : `xgate paid ${(Number(r.settlement.chargedAtomic) / 1e6).toFixed(6)}`,
+        ),
+      onPurchaseFailed: (f) =>
+        context?.ui.setStatus(
+          "xgate",
+          `xgate ${f.pending ? "unresolved" : "failed"}: ${f.invocationId}`,
+        ),
+    });
+    pi.registerProvider(provider);
+    broker = next;
+  };
+  try {
+    await load();
+  } catch {}
+  pi.on("session_start", async (_event, ctx) => {
+    context = ctx;
+    ctx.ui.setStatus(
+      "xgate",
+      broker ? "xgate wallet ready" : "xgate: /xgate refresh or /xgate setup",
+    );
+  });
+  pi.on("cache_warming_decision", async (event, ctx) =>
+    ctx.model?.provider === "xgate" ? { action: "stop" as const } : undefined,
+  );
+  pi.registerCommand("xgate", {
+    description:
+      "Set up the wallet broker; show budget or reconcile an existing purchase.",
+    handler: async (args, ctx) => {
+      context = ctx;
+      const [command, id] = args.trim().split(/\s+/);
+      try {
+        if (command === "setup") {
+          if (injected !== undefined)
+            throw new XgateError("transport_managed_by_host");
+          if (!ctx.hasUI)
+            throw new XgateError("configure_XGATE_CONFIG_for_headless_mode");
+          const url = await ctx.ui.input(
+            "xgate wallet service",
+            "http://127.0.0.1:4021",
+          );
+          if (!url) return;
+          const tokenFile = await ctx.ui.input(
+            "Absolute path to the broker token file",
+            "/private/path/broker-token",
+          );
+          if (!tokenFile) return;
+          const next = new BrokerClient(url, privateText(tokenFile, 128));
+          await next.status();
+          mkdirSync(dirname(configPath), { recursive: true, mode: 0o700 });
+          writeFileSync(configPath, JSON.stringify({ url, tokenFile }) + "\n", {
+            mode: 0o600,
+            flag: "wx",
+          });
+          await load();
+          ctx.ui.notify(
+            "xgate configured. Select a qualified model with /model.",
+            "info",
+          );
+          return;
+        }
+        if (command === "refresh") {
+          await load();
+          ctx.ui.notify("xgate model list refreshed.", "info");
+          return;
+        }
+        if (!broker) throw new XgateError("wallet_not_configured");
+        if (command === "reconcile") {
+          if (!id) throw new XgateError("purchase_id_required");
+          if (!broker.reconcile)
+            throw new XgateError("unsupported_by_transport");
+          const result = await broker.reconcile(id);
+          ctx.ui.notify(JSON.stringify(result), "info");
+          return;
+        }
+        if (command === "receipts") {
+          if (!broker.receipts)
+            throw new XgateError("unsupported_by_transport");
+          ctx.ui.notify(
+            JSON.stringify(await broker.receipts(), null, 2),
+            "info",
+          );
+          return;
+        }
+        if (command === "status" || command === "budget" || !command) {
+          if (!broker.status) throw new XgateError("unsupported_by_transport");
+          const status = await broker.status();
+          ctx.ui.notify(JSON.stringify(status, null, 2), "info");
+          return;
+        }
+        ctx.ui.notify(
+          "Use /xgate setup, refresh, status, budget, receipts or reconcile <invocation ID>. Budgets are configured at the wallet service.",
+          "info",
+        );
+      } catch (error) {
+        ctx.ui.notify(
+          error instanceof XgateError
+            ? error.message
+            : "xgate setup failed; check the private configuration and wallet service.",
+          "error",
+        );
+      }
+    },
+  });
+}