@echoclaw/echo-0g 1.0.0

package/dist/commands/0g-compute.js

@@ -0,0 +1,850 @@
+/**
+ * `echo 0g-compute` (alias: `echo 0g`) — 0G Compute Network integration.
+ *
+ * Commands:
+ *   setup [--json]                                            Read-only readiness check
+ *   providers [--detailed] [--json]                           List available services
+ *   ledger status [--json]                                    Ledger + sub-account balances
+ *   ledger deposit <amount> --yes [--json]                    Deposit to ledger
+ *   ledger fund --provider <addr> --amount <0G> --yes [--json] Transfer to sub-account
+ *   provider <addr> info [--json]                             Provider metadata + ack status
+ *   provider <addr> ack --yes [--json]                        Acknowledge provider signer
+ *   provider <addr> verify [--json]                           Verify TEE
+ *   api-key create --provider <addr> --token-id <n> [--json]  Create persistent API key
+ *   api-key revoke --provider <addr> --token-id <n> --yes     Revoke API key
+ *   api-key revoke-all --provider <addr> --yes                Revoke all API keys
+ *   openclaw use --provider <addr> --token-id <n> --yes       Patch openclaw.json
+ *   monitor start/stop/status                                 Balance monitor daemon
+ */
+import { Command } from "commander";
+import { isAddress, getAddress, formatUnits, parseUnits } from "viem";
+import { EchoError, ErrorCodes } from "../errors.js";
+import { isHeadless, writeJsonSuccess } from "../utils/output.js";
+import { respond } from "../utils/respond.js";
+import { getAuthenticatedBroker } from "../0g-compute/broker-factory.js";
+import { withSuppressedConsole } from "../0g-compute/bridge.js";
+import { normalizeSubAccount, normalizeInferTuple, serializeSubAccount } from "../0g-compute/account.js";
+import { calculateProviderPricing, formatPricePerMTokens } from "../0g-compute/pricing.js";
+import { patchOpenclawConfig } from "../openclaw/config.js";
+import logger from "../utils/logger.js";
+// ── Helpers ──────────────────────────────────────────────────────────
+function requireAddress(raw, label) {
+    if (!isAddress(raw)) {
+        throw new EchoError(ErrorCodes.INVALID_ADDRESS, `Invalid ${label} address: ${raw}`);
+    }
+    return getAddress(raw);
+}
+function requirePositiveNumber(raw, label) {
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n <= 0) {
+        throw new EchoError(ErrorCodes.INVALID_AMOUNT, `Invalid ${label}: ${raw} (must be > 0)`);
+    }
+    return n;
+}
+function requireTokenId(raw) {
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n < 0 || n > 254) {
+        throw new EchoError(ErrorCodes.INVALID_AMOUNT, `Invalid token-id: ${raw} (must be 0-254)`);
+    }
+    return n;
+}
+function requireYes(yes, action) {
+    if (!yes) {
+        throw new EchoError(ErrorCodes.CONFIRMATION_REQUIRED, `On-chain action requires confirmation: ${action}`, "Add --yes to confirm.");
+    }
+}
+function redactToken(token) {
+    if (token.startsWith("app-sk-"))
+        return "app-sk-***";
+    return "***";
+}
+/** Serialize bigint fields in SDK responses for JSON output. */
+function serializeBigInts(obj) {
+    if (typeof obj === "bigint")
+        return obj.toString();
+    if (Array.isArray(obj))
+        return obj.map(serializeBigInts);
+    if (obj !== null && typeof obj === "object") {
+        const result = {};
+        for (const [k, v] of Object.entries(obj)) {
+            result[k] = serializeBigInts(v);
+        }
+        return result;
+    }
+    return obj;
+}
+// ── Command tree ─────────────────────────────────────────────────────
+export function create0gComputeCommand() {
+    const root = new Command("0g-compute")
+        .alias("0g")
+        .description("0G Compute Network: inference, funding, and provider management");
+    // ── setup ────────────────────────────────────────────────────────
+    root
+        .command("setup")
+        .description("Readiness check (read-only, no transactions)")
+        .option("--json", "JSON output")
+        .action(async () => {
+        const { requireWalletAndKeystore } = await import("../bot/executor.js");
+        const checks = {};
+        // 1. Wallet
+        let walletAddress = null;
+        let walletHint;
+        try {
+            const { address } = requireWalletAndKeystore();
+            walletAddress = address;
+            checks.wallet = { ok: true, address };
+        }
+        catch (err) {
+            walletHint = err instanceof EchoError ? err.hint : undefined;
+            checks.wallet = { ok: false, error: err instanceof EchoError ? err.message : String(err) };
+        }
+        if (!walletAddress) {
+            respond({
+                data: { checks },
+                ui: { type: "warn", title: "0G Compute Setup", body: walletHint ?? "Wallet not configured. Run: echo wallet create" },
+            });
+            return;
+        }
+        // 2. Wallet 0G balance
+        try {
+            const { getPublicClient } = await import("../wallet/client.js");
+            const client = getPublicClient();
+            const balance = await client.getBalance({ address: walletAddress });
+            checks.walletBalance = { ok: true, balance: formatUnits(balance, 18) + " 0G" };
+        }
+        catch (err) {
+            checks.walletBalance = { ok: false, error: err instanceof Error ? err.message : String(err) };
+        }
+        // 3. Broker init
+        try {
+            const broker = await getAuthenticatedBroker();
+            checks.broker = { ok: true };
+            // 4. Ledger
+            try {
+                const ledger = await withSuppressedConsole(() => broker.ledger.getLedger());
+                checks.ledger = { ok: true, info: serializeBigInts(ledger) };
+            }
+            catch {
+                checks.ledger = { ok: false, hint: "Run: echo 0g-compute ledger deposit <amount> --yes" };
+            }
+            // 5. Services available
+            const services = await withSuppressedConsole(() => broker.inference.listService());
+            checks.services = { ok: true, count: services.length };
+        }
+        catch (err) {
+            checks.broker = { ok: false, error: err instanceof Error ? err.message : String(err) };
+        }
+        const allOk = Object.values(checks).every((c) => typeof c === "object" && c !== null && c.ok === true);
+        respond({
+            data: { ready: allOk, checks },
+            ui: {
+                type: allOk ? "success" : "warn",
+                title: "0G Compute Setup",
+                body: allOk
+                    ? "All checks passed. Ready to use 0G Compute."
+                    : "Some checks failed. Review the output above.",
+            },
+        });
+    });
+    // ── providers ────────────────────────────────────────────────────
+    root
+        .command("providers")
+        .description("List available 0G Compute services (requires wallet)")
+        .option("--detailed", "Include detailed info (TEE status, health, pricing)")
+        .option("--with-balances", "Include sub-account balances per provider (requires --detailed)")
+        .option("--json", "JSON output")
+        .action(async (options) => {
+        if (options.withBalances && !options.detailed) {
+            throw new EchoError(ErrorCodes.INVALID_AMOUNT, "--with-balances requires --detailed", "Use: echo 0g providers --detailed --with-balances");
+        }
+        const broker = await getAuthenticatedBroker();
+        if (options.detailed) {
+            const services = await withSuppressedConsole(() => broker.inference.listServiceWithDetail());
+            // Build enriched provider data
+            const enriched = [];
+            for (const svc of services) {
+                const inputPrice = svc.inputPrice;
+                const outputPrice = svc.outputPrice;
+                const pricing = calculateProviderPricing(inputPrice, outputPrice);
+                const entry = {
+                    ...serializeBigInts(svc),
+                    inputPricePerMTokens: formatPricePerMTokens(inputPrice),
+                    outputPricePerMTokens: formatPricePerMTokens(outputPrice),
+                    recommendedMinLockedOg: pricing.recommendedMinLockedOg,
+                    recommendedAlertLockedOg: pricing.recommendedAlertLockedOg,
+                };
+                // Optionally fetch sub-account balance
+                if (options.withBalances) {
+                    try {
+                        const account = await withSuppressedConsole(() => broker.inference.getAccount(svc.provider));
+                        const normalized = normalizeSubAccount(account);
+                        const needsTopUp = normalized.lockedOg < pricing.recommendedMinLockedOg;
+                        entry.totalOg = normalized.totalOg;
+                        entry.pendingRefundOg = normalized.pendingRefundOg;
+                        entry.lockedOg = normalized.lockedOg;
+                        entry.needsTopUp = needsTopUp;
+                        entry.suggestedTopUpOg = needsTopUp
+                            ? Math.max(0, pricing.recommendedMinLockedOg - normalized.lockedOg)
+                            : 0;
+                    }
+                    catch {
+                        entry.totalOg = null;
+                        entry.pendingRefundOg = null;
+                        entry.lockedOg = null;
+                        entry.needsTopUp = null;
+                        entry.suggestedTopUpOg = null;
+                    }
+                }
+                enriched.push(entry);
+            }
+            if (isHeadless()) {
+                writeJsonSuccess({ providers: enriched });
+            }
+            else {
+                if (services.length === 0) {
+                    process.stderr.write("No providers found.\n");
+                    return;
+                }
+                process.stderr.write(`Found ${services.length} provider(s):\n\n`);
+                for (let i = 0; i < services.length; i++) {
+                    const svc = services[i];
+                    const e = enriched[i];
+                    const inputPrice = svc.inputPrice;
+                    const outputPrice = svc.outputPrice;
+                    process.stderr.write(`  Provider: ${svc.provider}\n`);
+                    process.stderr.write(`  Model:    ${svc.model}\n`);
+                    process.stderr.write(`  Type:     ${svc.serviceType}\n`);
+                    process.stderr.write(`  URL:      ${svc.url}\n`);
+                    process.stderr.write(`  Input:    ${formatPricePerMTokens(inputPrice)} 0G/M tokens\n`);
+                    process.stderr.write(`  Output:   ${formatPricePerMTokens(outputPrice)} 0G/M tokens\n`);
+                    process.stderr.write(`  TEE ack:  ${svc.teeSignerAcknowledged}\n`);
+                    process.stderr.write(`  Recommended locked: ~${e.recommendedMinLockedOg.toFixed(3)} 0G` +
+                        ` (alert when < ${e.recommendedAlertLockedOg.toFixed(3)} 0G)\n`);
+                    if (options.withBalances && e.lockedOg != null) {
+                        const locked = e.lockedOg;
+                        const recMin = e.recommendedMinLockedOg;
+                        const ok = locked >= recMin;
+                        const status = ok
+                            ? "OK"
+                            : `TOP UP ~${e.suggestedTopUpOg.toFixed(3)} 0G`;
+                        process.stderr.write(`  Locked: ${locked.toFixed(4)} 0G (recommended: ${recMin.toFixed(3)} 0G) — ${status}\n`);
+                    }
+                    else if (options.withBalances) {
+                        process.stderr.write("  Locked: (no sub-account)\n");
+                    }
+                    process.stderr.write("\n");
+                }
+            }
+        }
+        else {
+            const services = await withSuppressedConsole(() => broker.inference.listService());
+            if (isHeadless()) {
+                writeJsonSuccess({ providers: services.map((s) => serializeBigInts(s)) });
+            }
+            else {
+                if (services.length === 0) {
+                    process.stderr.write("No providers found.\n");
+                    return;
+                }
+                process.stderr.write(`Provider                                     | Model                          | URL\n`);
+                process.stderr.write("-".repeat(110) + "\n");
+                for (const svc of services) {
+                    const provider = String(svc[0]).slice(0, 42).padEnd(42);
+                    const model = String(svc[6]).padEnd(30);
+                    const url = String(svc[2]);
+                    process.stderr.write(`${provider} | ${model} | ${url}\n`);
+                }
+                process.stderr.write(`\nTotal: ${services.length}\n`);
+            }
+        }
+    });
+    // ── ledger ───────────────────────────────────────────────────────
+    const ledger = root.command("ledger").description("Manage 0G Compute ledger");
+    ledger
+        .command("status")
+        .description("Show ledger status and sub-account balances")
+        .option("--json", "JSON output")
+        .action(async () => {
+        const broker = await getAuthenticatedBroker();
+        // Try getLedgerWithDetail (returns sub-accounts without extra RPC)
+        let ledgerInfo;
+        let subAccounts = [];
+        try {
+            const detail = await withSuppressedConsole(() => broker.ledger
+                .getLedgerWithDetail());
+            ledgerInfo = detail.ledgerInfo;
+            if (Array.isArray(detail.infers)) {
+                subAccounts = detail.infers.map((t) => normalizeInferTuple(t));
+            }
+        }
+        catch {
+            // Fallback to plain getLedger
+            try {
+                ledgerInfo = await withSuppressedConsole(() => broker.ledger.getLedger());
+            }
+            catch {
+                throw new EchoError(ErrorCodes.ZG_LEDGER_NOT_FOUND, "No ledger found for this wallet.", "Create one with: echo 0g-compute ledger deposit <amount> --yes");
+            }
+        }
+        if (isHeadless()) {
+            writeJsonSuccess({
+                ledger: serializeBigInts(ledgerInfo),
+                subAccounts: subAccounts.map((sa) => ({
+                    provider: sa.provider,
+                    ...serializeSubAccount(sa),
+                })),
+            });
+        }
+        else {
+            process.stderr.write("Ledger:\n");
+            process.stderr.write(JSON.stringify(serializeBigInts(ledgerInfo), null, 2) + "\n");
+            if (subAccounts.length > 0) {
+                process.stderr.write("\nSub-accounts:\n");
+                process.stderr.write("  Provider                                     | Total       | Pending     | Locked\n");
+                process.stderr.write("  " + "-".repeat(95) + "\n");
+                for (const sa of subAccounts) {
+                    const addr = sa.provider.slice(0, 42).padEnd(42);
+                    const total = sa.totalOg.toFixed(4).padStart(10);
+                    const pending = sa.pendingRefundOg.toFixed(4).padStart(10);
+                    const locked = sa.lockedOg.toFixed(4).padStart(10);
+                    process.stderr.write(`  ${addr} | ${total} 0G | ${pending} 0G | ${locked} 0G\n`);
+                }
+            }
+        }
+    });
+    ledger
+        .command("deposit <amount>")
+        .description("Deposit 0G to the compute ledger (creates if needed)")
+        .option("--yes", "Confirm on-chain transaction")
+        .option("--json", "JSON output")
+        .action(async (amountStr, options) => {
+        requireYes(options.yes, "ledger deposit");
+        const amount = requirePositiveNumber(amountStr, "deposit amount");
+        const broker = await getAuthenticatedBroker();
+        // Try depositFund first; if no ledger exists, use addLedger
+        try {
+            await withSuppressedConsole(() => broker.ledger.getLedger());
+            logger.info(`[0G Compute] Depositing ${amount} 0G to existing ledger...`);
+            await withSuppressedConsole(() => broker.ledger.depositFund(amount));
+        }
+        catch {
+            logger.info(`[0G Compute] No ledger found, creating with ${amount} 0G...`);
+            await withSuppressedConsole(() => broker.ledger.addLedger(amount));
+        }
+        respond({
+            data: { deposited: amount, unit: "0G" },
+            ui: { type: "success", title: "Ledger Deposit", body: `Deposited ${amount} 0G to compute ledger.` },
+        });
+    });
+    ledger
+        .command("fund")
+        .description("Transfer 0G from ledger to a provider sub-account")
+        .requiredOption("--provider <addr>", "Provider address")
+        .requiredOption("--amount <0G>", "Amount in 0G")
+        .option("--yes", "Confirm on-chain transaction")
+        .option("--json", "JSON output")
+        .action(async (options) => {
+        requireYes(options.yes, "ledger fund transfer");
+        const provider = requireAddress(options.provider, "provider");
+        const amount = requirePositiveNumber(options.amount, "fund amount");
+        const amountWei = parseUnits(options.amount, 18);
+        const broker = await getAuthenticatedBroker();
+        try {
+            await withSuppressedConsole(() => broker.ledger.transferFund(provider, "inference", amountWei));
+        }
+        catch (err) {
+            throw new EchoError(ErrorCodes.ZG_TRANSFER_FAILED, `Transfer failed: ${err instanceof Error ? err.message : String(err)}`, "Check ledger balance with: echo 0g-compute ledger status");
+        }
+        respond({
+            data: { transferred: amount, unit: "0G", provider },
+            ui: {
+                type: "success",
+                title: "Ledger Fund",
+                body: `Transferred ${amount} 0G to provider sub-account ${provider.slice(0, 10)}...`,
+            },
+        });
+    });
+    // ── provider ─────────────────────────────────────────────────────
+    const providerCmd = root.command("provider <address>").description("Provider-specific operations");
+    providerCmd
+        .command("info")
+        .description("Show provider metadata, ack status, and sub-account balance")
+        .option("--json", "JSON output")
+        .action(async (_options, cmd) => {
+        const providerAddress = requireAddress(cmd.parent.args[0], "provider");
+        const broker = await getAuthenticatedBroker();
+        const [metadata, userAcked] = await withSuppressedConsole(() => Promise.all([
+            broker.inference.getServiceMetadata(providerAddress),
+            broker.inference.acknowledged(providerAddress),
+        ]));
+        let normalizedAccount = null;
+        try {
+            const rawAccount = await withSuppressedConsole(() => broker.inference.getAccount(providerAddress));
+            normalizedAccount = normalizeSubAccount(rawAccount);
+        }
+        catch {
+            // No sub-account yet
+        }
+        const result = {
+            provider: providerAddress,
+            ...metadata,
+            userAcknowledged: userAcked,
+            subAccount: normalizedAccount ? serializeSubAccount(normalizedAccount) : null,
+        };
+        const balanceLine = normalizedAccount
+            ? `Balance: Total=${normalizedAccount.totalOg.toFixed(4)} | Pending=${normalizedAccount.pendingRefundOg.toFixed(4)} | Locked=${normalizedAccount.lockedOg.toFixed(4)} 0G`
+            : "Sub-account: none";
+        respond({
+            data: result,
+            ui: {
+                type: "info",
+                title: `Provider ${providerAddress.slice(0, 10)}...`,
+                body: [
+                    `Model:    ${metadata.model}`,
+                    `Endpoint: ${metadata.endpoint}`,
+                    `User ACK: ${userAcked}`,
+                    balanceLine,
+                ].join("\n"),
+            },
+        });
+    });
+    providerCmd
+        .command("ack")
+        .description("Acknowledge provider signer (user-level, on-chain)")
+        .option("--yes", "Confirm on-chain transaction")
+        .option("--json", "JSON output")
+        .action(async (options, cmd) => {
+        requireYes(options.yes, "acknowledge provider signer");
+        const providerAddress = requireAddress(cmd.parent.args[0], "provider");
+        const broker = await getAuthenticatedBroker();
+        try {
+            await withSuppressedConsole(() => broker.inference.acknowledgeProviderSigner(providerAddress));
+        }
+        catch (err) {
+            throw new EchoError(ErrorCodes.ZG_ACKNOWLEDGE_FAILED, `Acknowledge failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        respond({
+            data: { acknowledged: true, provider: providerAddress },
+            ui: {
+                type: "success",
+                title: "Provider Acknowledged",
+                body: `Provider ${providerAddress.slice(0, 10)}... signer acknowledged.`,
+            },
+        });
+    });
+    providerCmd
+        .command("verify")
+        .description("Verify provider TEE attestation")
+        .option("--json", "JSON output")
+        .action(async (_options, cmd) => {
+        const providerAddress = requireAddress(cmd.parent.args[0], "provider");
+        const broker = await getAuthenticatedBroker();
+        const result = await withSuppressedConsole(() => broker.inference.verifyService(providerAddress));
+        if (isHeadless()) {
+            writeJsonSuccess({ verification: serializeBigInts(result) });
+        }
+        else {
+            process.stderr.write(`TEE Verification for ${providerAddress.slice(0, 10)}...:\n`);
+            process.stderr.write(JSON.stringify(serializeBigInts(result), null, 2) + "\n");
+        }
+    });
+    // ── api-key ──────────────────────────────────────────────────────
+    const apiKey = root.command("api-key").description("Manage persistent API keys");
+    apiKey
+        .command("create")
+        .description("Create a persistent API key for a provider")
+        .requiredOption("--provider <addr>", "Provider address")
+        .requiredOption("--token-id <n>", "Token ID (0-254)")
+        .option("--expires <sec>", "Expiry in seconds (0 = never)", "0")
+        .option("--yes", "Confirm on-chain transaction")
+        .option("--json", "JSON output")
+        .action(async (options) => {
+        requireYes(options.yes, "create API key");
+        const provider = requireAddress(options.provider, "provider");
+        const tokenId = requireTokenId(options.tokenId);
+        const expiresIn = Number(options.expires) * 1000; // SDK expects ms
+        const broker = await getAuthenticatedBroker();
+        let apiKeyInfo;
+        try {
+            apiKeyInfo = await withSuppressedConsole(() => broker.inference.requestProcessor.createApiKey(provider, { tokenId, expiresIn }));
+        }
+        catch (err) {
+            throw new EchoError(ErrorCodes.ZG_API_KEY_FAILED, `API key creation failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        respond({
+            data: {
+                tokenId: apiKeyInfo.tokenId,
+                createdAt: apiKeyInfo.createdAt,
+                expiresAt: apiKeyInfo.expiresAt,
+                token: redactToken(apiKeyInfo.rawToken),
+                provider,
+            },
+            ui: {
+                type: "success",
+                title: "API Key Created",
+                body: `Token ID: ${apiKeyInfo.tokenId}\nProvider: ${provider.slice(0, 10)}...\nToken: ${redactToken(apiKeyInfo.rawToken)}`,
+            },
+        });
+    });
+    apiKey
+        .command("revoke")
+        .description("Revoke a specific API key")
+        .requiredOption("--provider <addr>", "Provider address")
+        .requiredOption("--token-id <n>", "Token ID to revoke")
+        .option("--yes", "Confirm on-chain transaction")
+        .option("--json", "JSON output")
+        .action(async (options) => {
+        requireYes(options.yes, "revoke API key");
+        const provider = requireAddress(options.provider, "provider");
+        const tokenId = requireTokenId(options.tokenId);
+        const broker = await getAuthenticatedBroker();
+        await withSuppressedConsole(() => broker.inference.revokeApiKey(provider, tokenId));
+        respond({
+            data: { revoked: true, tokenId, provider },
+            ui: {
+                type: "success",
+                title: "API Key Revoked",
+                body: `Token ID ${tokenId} for provider ${provider.slice(0, 10)}... revoked.`,
+            },
+        });
+    });
+    apiKey
+        .command("revoke-all")
+        .description("Revoke all API keys for a provider")
+        .requiredOption("--provider <addr>", "Provider address")
+        .option("--yes", "Confirm on-chain transaction")
+        .option("--json", "JSON output")
+        .action(async (options) => {
+        requireYes(options.yes, "revoke all API keys");
+        const provider = requireAddress(options.provider, "provider");
+        const broker = await getAuthenticatedBroker();
+        await withSuppressedConsole(() => broker.inference.revokeAllTokens(provider));
+        respond({
+            data: { revokedAll: true, provider },
+            ui: {
+                type: "success",
+                title: "All API Keys Revoked",
+                body: `All API keys for provider ${provider.slice(0, 10)}... revoked.`,
+            },
+        });
+    });
+    // ── openclaw ─────────────────────────────────────────────────────
+    const openclaw = root.command("openclaw").description("OpenClaw AI gateway integration");
+    openclaw
+        .command("use")
+        .description("Create API key and patch openclaw.json for a 0G provider")
+        .requiredOption("--provider <addr>", "Provider address")
+        .requiredOption("--token-id <n>", "Token ID for persistent API key (0-254)")
+        .option("--set-default", "Set as default model in agents.defaults.model")
+        .option("--fallback <ref>", "Fallback model reference (e.g., anthropic/claude-sonnet-4-5)")
+        .option("--force", "Overwrite existing openclaw.json provider config")
+        .option("--yes", "Confirm (required — creates API key on-chain)")
+        .option("--json", "JSON output")
+        .action(async (options) => {
+        requireYes(options.yes, "openclaw use (creates API key on-chain)");
+        const provider = requireAddress(options.provider, "provider");
+        const tokenId = requireTokenId(options.tokenId);
+        const broker = await getAuthenticatedBroker();
+        // 1. Validate provider exists
+        const metadata = await withSuppressedConsole(() => broker.inference.getServiceMetadata(provider));
+        logger.info(`[0G Compute] Provider: ${metadata.model} at ${metadata.endpoint}`);
+        // 2. Acknowledge provider signer (idempotent)
+        await withSuppressedConsole(() => broker.inference.acknowledgeProviderSigner(provider));
+        logger.info("[0G Compute] Provider signer acknowledged");
+        // 3. Create API key
+        let apiKeyInfo;
+        try {
+            apiKeyInfo = await withSuppressedConsole(() => broker.inference.requestProcessor.createApiKey(provider, { tokenId, expiresIn: 0 }));
+        }
+        catch (err) {
+            throw new EchoError(ErrorCodes.ZG_API_KEY_FAILED, `API key creation failed: ${err instanceof Error ? err.message : String(err)}`, "Check if tokenId is already in use. Try a different --token-id.");
+        }
+        logger.info(`[0G Compute] API key created: tokenId=${apiKeyInfo.tokenId}, token=${redactToken(apiKeyInfo.rawToken)}`);
+        // 4. Patch openclaw.json — models.providers.zg
+        const providerConfig = {
+            baseUrl: metadata.endpoint,
+            apiKey: apiKeyInfo.rawToken,
+            api: "openai-completions",
+            models: [
+                {
+                    id: metadata.model,
+                    name: `${metadata.model} (0G Compute)`,
+                    contextWindow: 128000,
+                    maxTokens: 8192,
+                },
+            ],
+        };
+        const providerPatch = patchOpenclawConfig("models.providers.zg", providerConfig, { force: options.force ?? false });
+        // Ensure models.mode = "merge"
+        patchOpenclawConfig("models.mode", "merge", { force: false });
+        // 5. Optionally set as default model
+        let defaultPatch;
+        if (options.setDefault) {
+            const defaultModel = {
+                primary: `zg/${metadata.model}`,
+            };
+            if (options.fallback) {
+                defaultModel.fallbacks = [options.fallback];
+            }
+            defaultPatch = patchOpenclawConfig("agents.defaults.model", defaultModel, { force: options.force ?? false });
+        }
+        const resultData = {
+            provider,
+            model: metadata.model,
+            endpoint: metadata.endpoint,
+            apiKey: { tokenId: apiKeyInfo.tokenId, token: redactToken(apiKeyInfo.rawToken) },
+            openclawConfig: {
+                providerPatch: {
+                    status: providerPatch.status,
+                    path: providerPatch.path,
+                    keysSkipped: providerPatch.keysSkipped,
+                },
+                defaultPatch: defaultPatch
+                    ? { status: defaultPatch.status }
+                    : null,
+            },
+        };
+        const hasSkipped = providerPatch.keysSkipped.length > 0;
+        const bodyLines = [
+            `Model:  ${metadata.model} (0G Compute)`,
+            `Config: ${providerPatch.path} (${providerPatch.status})`,
+        ];
+        if (hasSkipped) {
+            bodyLines.push("");
+            bodyLines.push(`Skipped existing keys: ${providerPatch.keysSkipped.join(", ")}`);
+            bodyLines.push("Use --force to overwrite.");
+        }
+        bodyLines.push("");
+        bodyLines.push("Next steps:");
+        bodyLines.push("  1. Restart OpenClaw gateway");
+        bodyLines.push("  2. Run /reset in your agent session");
+        bodyLines.push(options.setDefault
+            ? `  3. Default model set to zg/${metadata.model}`
+            : `  3. (Optional) Set default: --set-default`);
+        respond({
+            data: resultData,
+            ui: {
+                type: hasSkipped ? "warn" : "success",
+                title: "OpenClaw Configured",
+                body: bodyLines.join("\n"),
+            },
+        });
+    });
+    // ── monitor ──────────────────────────────────────────────────────
+    const monitor = root.command("monitor").description("Balance monitor daemon");
+    monitor
+        .command("start")
+        .description("Start balance monitor (foreground or --daemon)")
+        .requiredOption("--providers <addrs>", "Comma-separated provider addresses")
+        .option("--mode <mode>", "Monitor mode: fixed | recommended", "fixed")
+        .option("--threshold <0G>", "Alert threshold in 0G (required for --mode fixed)")
+        .option("--buffer <0G>", "Extra buffer above recommended min (default 0, recommended mode)", "0")
+        .option("--ratio <n>", "Alert ratio multiplier (default 1.2, recommended mode)", "1.2")
+        .option("--interval <sec>", "Polling interval in seconds", "300")
+        .option("--daemon", "Run detached as background process")
+        .option("--json", "JSON output")
+        .action(async (options) => {
+        const providers = options.providers.split(",").map((a) => requireAddress(a.trim(), "provider"));
+        const mode = options.mode;
+        const interval = Math.max(60, Number(options.interval) || 300);
+        const buffer = Number(options.buffer) || 0;
+        const alertRatio = Number(options.ratio) || 1.2;
+        if (mode !== "fixed" && mode !== "recommended") {
+            throw new EchoError(ErrorCodes.INVALID_AMOUNT, `Invalid mode: ${options.mode}`, "Use: fixed | recommended");
+        }
+        let threshold;
+        if (mode === "fixed") {
+            if (!options.threshold) {
+                throw new EchoError(ErrorCodes.INVALID_AMOUNT, "--threshold is required for --mode fixed", "Use: --threshold <0G> or switch to --mode recommended");
+            }
+            threshold = requirePositiveNumber(options.threshold, "threshold");
+        }
+        if (options.daemon) {
+            // Spawn detached child process
+            const { spawn } = await import("node:child_process");
+            const { existsSync: fsExists, openSync, mkdirSync, closeSync } = await import("node:fs");
+            const { fileURLToPath } = await import("node:url");
+            const { ZG_COMPUTE_DIR, ZG_MONITOR_LOG_FILE } = await import("../0g-compute/constants.js");
+            // Ensure log directory exists
+            if (!fsExists(ZG_COMPUTE_DIR)) {
+                mkdirSync(ZG_COMPUTE_DIR, { recursive: true });
+            }
+            // Build args for the child — replay the same command without --daemon
+            const childArgs = [
+                "0g-compute", "monitor", "start",
+                "--providers", options.providers,
+                "--mode", mode,
+                "--interval", String(interval),
+                "--buffer", String(buffer),
+                "--ratio", String(alertRatio),
+            ];
+            if (threshold != null) {
+                childArgs.push("--threshold", String(threshold));
+            }
+            const cliPath = fileURLToPath(new URL("../cli.js", import.meta.url));
+            const logFd = openSync(ZG_MONITOR_LOG_FILE, "a");
+            const child = spawn(process.execPath, [cliPath, ...childArgs], {
+                detached: true,
+                stdio: ["ignore", logFd, logFd],
+            });
+            child.unref();
+            closeSync(logFd);
+            respond({
+                data: { daemon: true, pid: child.pid, logFile: ZG_MONITOR_LOG_FILE },
+                ui: {
+                    type: "success",
+                    title: "Monitor Daemon",
+                    body: `Started (PID ${child.pid})\nLog: ${ZG_MONITOR_LOG_FILE}`,
+                },
+            });
+            return;
+        }
+        const { BalanceMonitor } = await import("../0g-compute/monitor.js");
+        const monitorInstance = new BalanceMonitor({
+            providers,
+            mode,
+            threshold,
+            buffer,
+            alertRatio,
+            intervalSec: interval,
+        });
+        await monitorInstance.start();
+        // Keep alive
+        await new Promise(() => { });
+    });
+    monitor
+        .command("stop")
+        .description("Stop the running balance monitor")
+        .option("--json", "JSON output")
+        .action(async () => {
+        const { existsSync, readFileSync, writeFileSync, unlinkSync } = await import("node:fs");
+        const { ZG_MONITOR_PID_FILE, ZG_MONITOR_SHUTDOWN_FILE } = await import("../0g-compute/constants.js");
+        if (!existsSync(ZG_MONITOR_PID_FILE)) {
+            throw new EchoError(ErrorCodes.ZG_MONITOR_NOT_RUNNING, "Balance monitor is not running (no pidfile)");
+        }
+        const pid = parseInt(readFileSync(ZG_MONITOR_PID_FILE, "utf-8").trim(), 10);
+        let alive = false;
+        try {
+            process.kill(pid, 0);
+            alive = true;
+        }
+        catch {
+            unlinkSync(ZG_MONITOR_PID_FILE);
+            throw new EchoError(ErrorCodes.ZG_MONITOR_NOT_RUNNING, `Monitor not running (stale PID ${pid})`);
+        }
+        // SIGTERM
+        try {
+            process.kill(pid, "SIGTERM");
+        }
+        catch { /* ignore */ }
+        // Wait up to 5s
+        const deadline = Date.now() + 5000;
+        while (Date.now() < deadline) {
+            await new Promise((r) => setTimeout(r, 500));
+            try {
+                process.kill(pid, 0);
+            }
+            catch {
+                respond({
+                    data: { stopped: true, pid },
+                    ui: { type: "success", title: "Monitor Stopped", body: `Balance monitor stopped (PID ${pid})` },
+                });
+                return;
+            }
+        }
+        // Fallback: shutdown file
+        writeFileSync(ZG_MONITOR_SHUTDOWN_FILE, String(Date.now()), "utf-8");
+        const deadline2 = Date.now() + 10000;
+        while (Date.now() < deadline2) {
+            await new Promise((r) => setTimeout(r, 1000));
+            try {
+                process.kill(pid, 0);
+            }
+            catch {
+                respond({
+                    data: { stopped: true, pid, method: "shutdown-file" },
+                    ui: { type: "success", title: "Monitor Stopped", body: `Monitor stopped via shutdown file (PID ${pid})` },
+                });
+                return;
+            }
+        }
+        // SIGKILL
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch { /* ignore */ }
+        try {
+            if (existsSync(ZG_MONITOR_PID_FILE))
+                unlinkSync(ZG_MONITOR_PID_FILE);
+        }
+        catch { /* ignore */ }
+        try {
+            if (existsSync(ZG_MONITOR_SHUTDOWN_FILE))
+                unlinkSync(ZG_MONITOR_SHUTDOWN_FILE);
+        }
+        catch { /* ignore */ }
+        respond({
+            data: { stopped: true, pid, method: "SIGKILL" },
+            ui: { type: "warn", title: "Monitor Killed", body: `Monitor force-killed (PID ${pid})` },
+        });
+    });
+    monitor
+        .command("status")
+        .description("Show balance monitor status")
+        .option("--json", "JSON output")
+        .action(async () => {
+        const { existsSync, readFileSync } = await import("node:fs");
+        const { ZG_MONITOR_PID_FILE, ZG_MONITOR_STATE_FILE, ZG_MONITOR_LOG_FILE } = await import("../0g-compute/constants.js");
+        let running = false;
+        let pid;
+        if (existsSync(ZG_MONITOR_PID_FILE)) {
+            pid = parseInt(readFileSync(ZG_MONITOR_PID_FILE, "utf-8").trim(), 10);
+            try {
+                process.kill(pid, 0);
+                running = true;
+            }
+            catch {
+                running = false;
+            }
+        }
+        let state = {};
+        if (existsSync(ZG_MONITOR_STATE_FILE)) {
+            try {
+                state = JSON.parse(readFileSync(ZG_MONITOR_STATE_FILE, "utf-8"));
+            }
+            catch { /* ignore corrupt state */ }
+        }
+        const logFileExists = existsSync(ZG_MONITOR_LOG_FILE);
+        if (isHeadless()) {
+            writeJsonSuccess({ running, pid, logFile: ZG_MONITOR_LOG_FILE, logFileExists, ...state });
+        }
+        else {
+            if (!running) {
+                process.stderr.write("Not running\n");
+                return;
+            }
+            const lines = [`Running (PID ${pid})`];
+            if (state.mode)
+                lines.push(`Mode: ${state.mode}`);
+            if (state.threshold != null)
+                lines.push(`Threshold: ${state.threshold} 0G`);
+            if (state.intervalSec != null)
+                lines.push(`Interval: ${state.intervalSec}s`);
+            if (state.lastCheckAt) {
+                lines.push(`Last check: ${new Date(state.lastCheckAt).toISOString()}`);
+            }
+            if (state.providerThresholds) {
+                lines.push("Provider thresholds:");
+                for (const [addr, pt] of Object.entries(state.providerThresholds)) {
+                    lines.push(`  ${addr.slice(0, 10)}... threshold=${pt.threshold.toFixed(4)} recommendedMin=${pt.recommendedMin.toFixed(4)}`);
+                }
+            }
+            if (logFileExists) {
+                lines.push(`Log: ${ZG_MONITOR_LOG_FILE}`);
+            }
+            process.stderr.write(lines.join("\n") + "\n");
+        }
+    });
+    return root;
+}
+//# sourceMappingURL=0g-compute.js.map