@lucid-agents/pi-xgate 0.1.5 → 0.1.7

package/dist/extension.js

@@ -0,0 +1,132 @@
+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.js";
+function privateText(path, max = 8192) {
+    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) {
+    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) {
+    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 = {}) {
+    return (pi) => register(pi, options);
+}
+export default createXgateExtension();
+async function register(pi, options) {
+    const injected = options.transport;
+    const configPath = process.env.XGATE_CONFIG ?? join(homedir(), ".pi", "agent", "xgate.json");
+    let broker;
+    let context;
+    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" } : 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");
+            }
+        },
+    });
+}