@sage-protocol/cli 0.8.0 → 0.8.3

package/dist/cli/commands/members.js

@@ -20,6 +20,7 @@ function register(program) {
     .option('--all', 'List members for all SubDAOs', false)
     .option('--limit <n>', 'Max members per SubDAO to print', '100')
     .option('--include-inactive', 'Include inactive members', false)
+    .option('--json', 'Output JSON', false)
     .action(async (opts) => {
       try {
         const { ethers } = require('ethers');
@@ -34,26 +35,52 @@ function register(program) {
           subdaos = [addr];
         }
         const first = Number(opts.limit || '100');
+        const results = [];
         for (const s of subdaos) {
           const where = opts.includeInactive ? `subdao: "${ethers.getAddress(s)}"` : `subdao: "${ethers.getAddress(s)}", active: true`;
-          const q = `query($first:Int,$skip:Int){ members(where:{${where}}, first:$first, skip:$skip, orderBy: account, orderDirection: asc){ account currentStake active } }`;
+          const qWithStake = `query($first:Int,$skip:Int){ members(where:{${where}}, first:$first, skip:$skip, orderBy: account, orderDirection: asc){ account currentStake active } }`;
+          const qNoStake = `query($first:Int,$skip:Int){ members(where:{${where}}, first:$first, skip:$skip, orderBy: account, orderDirection: asc){ account active } }`;
+          let stakeSupported = true;
           let skip = 0; let printed = 0; let batch;
-          ui.newline();
-          ui.output(`SubDAO: ${s}`);
-          ui.output('Account                              Active  CurrentStake');
-          ui.output('----------------------------------------------------------');
+          const members = [];
+          if (!opts.json) {
+            ui.newline();
+            ui.output(`SubDAO: ${s}`);
+            ui.output('Account                              Active  CurrentStake');
+            ui.output('----------------------------------------------------------');
+          }
           do {
-            batch = (await fetchGraph(q, { first: Math.min(first - printed, 1000), skip })).members || [];
+            try {
+              batch = (await fetchGraph(stakeSupported ? qWithStake : qNoStake, { first: Math.min(first - printed, 1000), skip })).members || [];
+            } catch (e) {
+              const msg = String(e && e.message ? e.message : e);
+              if (stakeSupported && /currentStake/i.test(msg)) {
+                stakeSupported = false;
+                batch = (await fetchGraph(qNoStake, { first: Math.min(first - printed, 1000), skip })).members || [];
+              } else {
+                throw e;
+              }
+            }
             for (const m of batch) {
               const acct = m.account;
-              const stake = m.currentStake;
+              const stake = stakeSupported ? m.currentStake : '0';
               const active = m.active ? 'yes ' : 'no  ';
-              ui.output(`${acct}  ${active}  ${stake}`);
+              members.push(opts.json
+                ? { account: acct, active: !!m.active, currentStake: stake }
+                : { account: acct, active: !!m.active, currentStake: stake }
+              );
+              if (!opts.json) {
+                ui.output(`${acct}  ${active}  ${stake}`);
+              }
               printed += 1; if (printed >= first) break;
             }
             skip += batch.length;
           } while (batch.length && printed < first);
-          if (printed === 0) ui.output('(no members found)');
+          if (!opts.json && printed === 0) ui.output('(no members found)');
+          results.push({ subdao: s, count: members.length, members });
+        }
+        if (opts.json) {
+          ui.json({ ok: true, subdaos: results });
         }
       } catch (e) {
         handleCLIError('members:list', e);
@@ -65,6 +92,7 @@ function register(program) {
     .option('--subdao <address>', 'SubDAO address')
     .option('--all', 'List stakes for all SubDAOs', false)
     .option('--limit <n>', 'Max rows per SubDAO', '100')
+    .option('--json', 'Output JSON', false)
     .action(async (opts) => {
       try {
         const { ethers } = require('ethers');
@@ -79,32 +107,118 @@ function register(program) {
           subdaos = [addr];
         }
         const first = Number(opts.limit || '100');
+        const results = [];
         for (const s of subdaos) {
           const q = `query($first:Int,$skip:Int){ members(where:{subdao: "${ethers.getAddress(s)}", currentStake_gt: "0"}, first:$first, skip:$skip, orderBy: currentStake, orderDirection: desc){ account currentStake active } }`;
           let skip = 0; let printed = 0; let batch; let total = 0n;
-          ui.newline();
-          ui.output(`SubDAO: ${s}`);
-          ui.output('Account                              Active  CurrentStake');
-          ui.output('----------------------------------------------------------');
+          const members = [];
+          if (!opts.json) {
+            ui.newline();
+            ui.output(`SubDAO: ${s}`);
+            ui.output('Account                              Active  CurrentStake');
+            ui.output('----------------------------------------------------------');
+          }
           do {
-            batch = (await fetchGraph(q, { first: Math.min(first - printed, 1000), skip })).members || [];
+            try {
+              batch = (await fetchGraph(q, { first: Math.min(first - printed, 1000), skip })).members || [];
+            } catch (e) {
+              const msg = String(e && e.message ? e.message : e);
+              if (/currentStake/i.test(msg)) {
+                throw new Error('Subgraph schema missing currentStake. Redeploy subgraph or use `sage members list` instead.');
+              }
+              throw e;
+            }
             for (const m of batch) {
               const acct = m.account; const stake = BigInt(m.currentStake); const active = m.active ? 'yes ' : 'no  ';
               total += stake;
-              ui.output(`${acct}  ${active}  ${m.currentStake}`);
+              members.push({ account: acct, active: !!m.active, currentStake: m.currentStake });
+              if (!opts.json) {
+                ui.output(`${acct}  ${active}  ${m.currentStake}`);
+              }
               printed += 1; if (printed >= first) break;
             }
             skip += batch.length;
           } while (batch.length && printed < first);
-          ui.output('----------------------------------------------------------');
-          ui.output(`Total current stake (visible subset): ${total.toString()}`);
-          if (printed === 0) ui.output('(no stakers found)');
+          if (!opts.json) {
+            ui.output('----------------------------------------------------------');
+            ui.output(`Total current stake (visible subset): ${total.toString()}`);
+            if (printed === 0) ui.output('(no stakers found)');
+          }
+          results.push({ subdao: s, count: members.length, totalStake: total.toString(), members });
+        }
+        if (opts.json) {
+          ui.json({ ok: true, subdaos: results });
         }
       } catch (e) {
         handleCLIError('members:current-stake', e);
       }
     });
 
+  cmd.command('voting-power')
+    .description('List delegated SXXX voting power for members (via token getVotes)')
+    .option('--subdao <address>', 'SubDAO address; omit to select interactively or use --all')
+    .option('--all', 'List members for all SubDAOs', false)
+    .option('--limit <n>', 'Max members per SubDAO to print', '100')
+    .option('--include-inactive', 'Include inactive members', false)
+    .option('--json', 'Output JSON', false)
+    .action(async (opts) => {
+      try {
+        const { ethers } = require('ethers');
+        const cliConfig = require('../config');
+        const SubDAOManager = require('../subdao-manager');
+        const manager = new SubDAOManager(); await manager.initialize();
+        const rpcUrl = cliConfig.resolveRpcUrl({ allowEnv: true });
+        const provider = new ethers.JsonRpcProvider(rpcUrl);
+        const sxxxAddress = cliConfig.resolveAddress('SXXX_TOKEN_ADDRESS');
+        if (!sxxxAddress) throw new Error('SXXX_TOKEN_ADDRESS not configured');
+        const sxxx = new ethers.Contract(sxxxAddress, ['function getVotes(address) view returns (uint256)'], provider);
+
+        let subdaos = [];
+        if (opts.all) {
+          const data = await fetchGraph('{ subDAOs(first: 1000) { id address } }');
+          subdaos = (data.subDAOs || []).map(s => s.address || s.id);
+        } else {
+          const addr = await manager.resolveSubDAOAddress(opts.subdao);
+          subdaos = [addr];
+        }
+        const first = Number(opts.limit || '100');
+        const results = [];
+        for (const s of subdaos) {
+          const where = opts.includeInactive ? `subdao: "${ethers.getAddress(s)}"` : `subdao: "${ethers.getAddress(s)}", active: true`;
+          const q = `query($first:Int,$skip:Int){ members(where:{${where}}, first:$first, skip:$skip, orderBy: account, orderDirection: asc){ account active } }`;
+          let skip = 0; let printed = 0; let batch;
+          const members = [];
+          if (!opts.json) {
+            ui.newline();
+            ui.output(`SubDAO: ${s}`);
+            ui.output('Account                              Active  VotingPower(SXXX)');
+            ui.output('----------------------------------------------------------------');
+          }
+          do {
+            batch = (await fetchGraph(q, { first: Math.min(first - printed, 1000), skip })).members || [];
+            for (const m of batch) {
+              const acct = m.account;
+              const active = m.active ? 'yes ' : 'no  ';
+              const votes = await sxxx.getVotes(acct).catch(() => 0n);
+              members.push({ account: acct, active: !!m.active, votingPower: votes.toString() });
+              if (!opts.json) {
+                ui.output(`${acct}  ${active}  ${ethers.formatEther(votes)}`);
+              }
+              printed += 1; if (printed >= first) break;
+            }
+            skip += batch.length;
+          } while (batch.length && printed < first);
+          if (!opts.json && printed === 0) ui.output('(no members found)');
+          results.push({ subdao: s, count: members.length, members });
+        }
+        if (opts.json) {
+          ui.json({ ok: true, subdaos: results });
+        }
+      } catch (e) {
+        handleCLIError('members:voting-power', e);
+      }
+    });
+
   program.addCommand(cmd);
 }
 

package/dist/cli/commands/multiplier.js

@@ -52,6 +52,10 @@ const AUCTION_ABI = [
   'function settleCurrentAndCreateNewAuction()'
 ];
 
+const SUBDAO_ABI = [
+  'function governor() view returns (address)'
+];
+
 const TOKEN_ABI = [
   'function name() view returns (string)',
   'function symbol() view returns (string)',
@@ -61,10 +65,38 @@ const TOKEN_ABI = [
 ];
 
 function getProvider() {
-  const rpcUrl = process.env.RPC_URL || 'https://base-sepolia.publicnode.com';
+  const rpcUrl = cliConfig.resolveRpcUrl({ allowEnv: true });
   return new ethers.JsonRpcProvider(rpcUrl);
 }
 
+/**
+ * Resolve a Governor address from a SubDAO or Governor address.
+ * If the address is a SubDAO, calls governor() to get the Governor.
+ * If the address is already a Governor, returns it directly.
+ */
+async function resolveGovernorAddress(address, provider) {
+  const normalized = ethers.getAddress(address);
+  // Try calling governor() - if it works, the address is a SubDAO
+  try {
+    const subdao = new ethers.Contract(normalized, SUBDAO_ABI, provider);
+    const governorAddr = await subdao.governor();
+    if (governorAddr && governorAddr !== ethers.ZeroAddress) {
+      return { governor: governorAddr, subdao: normalized, isSubDAO: true };
+    }
+  } catch (_) {
+    // Not a SubDAO or doesn't have governor() - assume it's a Governor
+  }
+
+  // Verify governor interface before returning
+  try {
+    const gov = new ethers.Contract(normalized, GOVERNOR_ABI, provider);
+    await gov.token();
+    return { governor: normalized, subdao: null, isSubDAO: false };
+  } catch (err) {
+    throw new Error(`Address ${normalized} is not a SubDAO or Governor. Use --gov for governor address or --subdao for SubDAO.`);
+  }
+}
+
 async function resolveAccountAddress(address) {
   if (address) return address;
 
@@ -92,11 +124,21 @@ function register(program) {
   addDAOAddressOptions(statusCmd);
   statusCmd.action(async (options) => {
     try {
-      const governorAddr = resolveDAOAddress(options, { required: true });
+      const inputAddr = resolveDAOAddress(options, { required: true });
       const provider = getProvider();
-      const governor = new ethers.Contract(governorAddr, GOVERNOR_ABI, provider);
 
-      ui.info(`Checking multiplier status for governor: ${governorAddr}`);
+      // Auto-resolve Governor from SubDAO if needed
+      const resolved = await resolveGovernorAddress(inputAddr, provider);
+      const governorAddr = resolved.governor;
+
+      if (resolved.isSubDAO) {
+        ui.info(`SubDAO detected: ${inputAddr}`);
+        ui.info(`Resolved Governor: ${governorAddr}`);
+      } else {
+        ui.info(`Checking multiplier status for governor: ${governorAddr}`);
+      }
+
+      const governor = new ethers.Contract(governorAddr, GOVERNOR_ABI, provider);
 
       // Check if multipliers are enabled
       const isEnabled = await governor.isMultiplierEnabled().catch(() => false);
@@ -158,30 +200,44 @@ function register(program) {
   // Build calculate command
   const calculateCmd = new Command('calculate')
     .description('Show voting power breakdown for an account')
-    .argument('[address]', 'Account address (defaults to connected wallet)');
+    .argument('[address]', 'Account address (defaults to connected wallet)')
+    .option('--json', 'Output JSON', false);
   addDAOAddressOptions(calculateCmd);
   calculateCmd.action(async (address, options) => {
     try {
-      const governorAddr = resolveDAOAddress(options, { required: true });
+      const inputAddr = resolveDAOAddress(options, { required: true });
       const account = await resolveAccountAddress(address);
       if (!account) {
         throw new Error('No address provided. Pass an address or connect a wallet.');
       }
 
       const provider = getProvider();
+
+      // Auto-resolve Governor from SubDAO if needed
+      const resolved = await resolveGovernorAddress(inputAddr, provider);
+      const governorAddr = resolved.governor;
+
       const governor = new ethers.Contract(governorAddr, GOVERNOR_ABI, provider);
 
-      ui.output('\nVoting Power Breakdown');
-      ui.keyValue({
-        'Account': account,
-        'Governor': governorAddr
-      });
+      if (!options.json) {
+        ui.output('\nVoting Power Breakdown');
+        const displayInfo = { 'Account': account };
+        if (resolved.isSubDAO) {
+          displayInfo['SubDAO'] = resolved.subdao;
+          displayInfo['Governor'] = governorAddr;
+        } else {
+          displayInfo['Governor'] = governorAddr;
+        }
+        ui.keyValue(displayInfo);
+      }
 
       // Check if multipliers are enabled
       const isEnabled = await governor.isMultiplierEnabled().catch(() => false);
       const votingToken = await governor.token();
+      const baseVotesToken = await governor.baseVotesToken().catch(() => null);
+      const isWrapperMode = isEnabled || (baseVotesToken && baseVotesToken.toLowerCase() !== votingToken.toLowerCase());
 
-      if (!isEnabled) {
+      if (!isWrapperMode) {
         // Simple ERC20Votes - no multiplier
         const token = new ethers.Contract(votingToken, TOKEN_ABI, provider);
         const [name, symbol, decimals, balance, votes] = await Promise.all([
@@ -192,6 +248,22 @@ function register(program) {
           token.getVotes(account)
         ]);
 
+        if (options.json) {
+          ui.json({
+            ok: true,
+            account,
+            governor: governorAddr,
+            token: votingToken,
+            name,
+            symbol,
+            decimals,
+            balance: balance.toString(),
+            votingPower: votes.toString(),
+            multiplier: '1x'
+          });
+          return;
+        }
+
         ui.output(`\n${name} (${symbol})`);
         ui.keyValue({
           'Balance': `${ethers.formatUnits(balance, decimals)}`,
@@ -203,7 +275,7 @@ function register(program) {
 
       // Multiplied votes - get breakdown
       const multipliedVotes = new ethers.Contract(votingToken, MULTIPLIED_VOTES_ABI, provider);
-      const baseTokenAddr = await multipliedVotes.baseToken();
+      const baseTokenAddr = baseVotesToken || await multipliedVotes.baseToken();
       const nftAddr = await multipliedVotes.multiplierNFT();
       const basis = await multipliedVotes.BASIS();
 
@@ -221,6 +293,22 @@ function register(program) {
       const baseDisplay = ethers.formatUnits(baseVotes, decimals);
       const effectiveDisplay = ethers.formatUnits(effectiveVotes, decimals);
 
+      if (options.json) {
+        ui.json({
+          ok: true,
+          account,
+          governor: governorAddr,
+          baseToken: baseTokenAddr,
+          votingToken,
+          baseVotes: baseVotes.toString(),
+          multiplier: multiplier.toString(),
+          multiplierDisplay: multDisplay,
+          effectiveVotes: effectiveVotes.toString(),
+          hasBonus: !!hasBonus
+        });
+        return;
+      }
+
       ui.output(`\n${name} (${symbol}) with NFT Multipliers`);
       ui.keyValue({
         'Base Votes': `${baseDisplay} ${symbol}`,

package/dist/cli/commands/nft.js

@@ -176,9 +176,10 @@ Automation:
     .option('--dao <address>', 'DAO address (auto-detected from context if not provided)')
     .option('--account <address>', 'Account to check (default: your wallet)')
     .option('-v, --verbose', 'Show detailed output')
+    .option('--json', 'Output JSON', false)
     .action(async (opts) => {
       try {
-        ui.configure({ verbose: opts.verbose });
+        ui.configure({ verbose: opts.verbose, json: opts.json });
         const rpcUrl = cliConfig.resolveRpcUrl();
         const provider = new ethers.JsonRpcProvider(rpcUrl);
         const nftAddr = cliConfig.resolveAddress('VOTING_MULTIPLIER_NFT_ADDRESS');
@@ -208,6 +209,18 @@ Automation:
         const multiplier = await contract.getMultiplier(account, daoAddr);
         const multiplierDisplay = (Number(multiplier) / 10000).toFixed(4);
 
+        if (opts.json) {
+          ui.json({
+            ok: true,
+            account,
+            dao: daoAddr,
+            nft: nftAddr,
+            multiplier: multiplier.toString(),
+            multiplierDisplay: `${multiplierDisplay}x`
+          });
+          return;
+        }
+
         ui.header(`Voting Multiplier for ${ui.formatAddress(account)}`);
         ui.keyValue([
           ['DAO', ui.formatAddress(daoAddr)],
@@ -269,10 +282,10 @@ Automation:
           throw new Error('Multiplier must be >= 100 (100 = 1x)');
         }
 
-        // Build calldata for createTier
+        // Build calldata for governance-safe createTierViaGovernance
         const abi = resolveArtifact('contracts/VotingMultiplierNFT.sol/VotingMultiplierNFT.json').abi;
         const iface = new ethers.Interface(abi);
-        const calldata = iface.encodeFunctionData('createTier', [
+        const calldata = iface.encodeFunctionData('createTierViaGovernance', [
           daoAddr,
           String(opts.name),
           BigInt(multiplier),

package/dist/cli/commands/personal.js

@@ -1,7 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const axios = require('axios');
-const { getAddress, id, parseUnits, formatUnits, Contract, MaxUint256 } = require('ethers');
+const { getAddress, id, parseUnits, formatUnits, Contract, MaxUint256, ZeroAddress } = require('ethers');
 const { decryptAesGcm, fromB64 } = require('../utils/aes');
 const sdk = require('@sage-protocol/sdk');
 const { formatJson } = require('../utils/format');
@@ -244,6 +244,42 @@ const PERSONAL_REGISTRY_QUERY = `
 async function resolveOrCreatePersonalRegistry(wallet, opts = {}) {
   const ownerAddress = getAddress(await wallet.getAddress());
   const subgraphUrl = resolveSubgraphUrl(opts.subgraph);
+  const provider = wallet.provider || await getProvider();
+
+  const { resolveArtifact } = require('../utils/artifacts');
+  const PromptRegistryABI = resolveArtifact('contracts/PromptRegistry.sol/PromptRegistry.json').abi;
+
+  async function validateRegistryCandidate(registryAddr) {
+    try {
+      const code = await provider.getCode(registryAddr);
+      if (!code || code === '0x') {
+        return { ok: false, reason: 'no_code' };
+      }
+
+      const read = new Contract(registryAddr, PromptRegistryABI, provider);
+
+      // Ensure this registry is actually usable by the current wallet.
+      const govRole = await read.GOVERNANCE_ROLE().catch(() => null);
+      if (!govRole) return { ok: false, reason: 'missing_governance_role' };
+
+      const hasGovRole = await read.hasRole(govRole, ownerAddress).catch(() => null);
+      if (!hasGovRole) return { ok: false, reason: 'missing_governance_role_for_owner' };
+
+      // Personal registries should not be linked to a SubDAO.
+      const subdao = await read.subDAO().catch(() => null);
+      if (subdao && getAddress(subdao) !== getAddress(ZeroAddress)) {
+        return { ok: false, reason: 'linked_to_subdao', subdao: getAddress(subdao) };
+      }
+
+      // If paused, addPrompt will revert.
+      const paused = await read.paused().catch(() => false);
+      if (paused) return { ok: false, reason: 'paused' };
+
+      return { ok: true };
+    } catch (e) {
+      return { ok: false, reason: 'validation_error', error: e };
+    }
+  }
 
   // Try subgraph lookup first
   if (subgraphUrl) {
@@ -254,7 +290,14 @@ async function resolveOrCreatePersonalRegistry(wallet, opts = {}) {
       });
       const registries = resp.data?.data?.personalRegistries || [];
       if (registries.length > 0) {
-        return getAddress(registries[0].id);
+        const candidate = getAddress(registries[0].id);
+        const validation = await validateRegistryCandidate(candidate);
+        if (validation.ok) return candidate;
+
+        if (!opts.json) {
+          const extra = validation.subdao ? ` (subDAO=${validation.subdao})` : '';
+          ui.warn(`Resolved personal registry ${candidate} is not usable (${validation.reason}${extra}). Creating a fresh registry...`);
+        }
       }
     } catch (_) {
       // Subgraph unavailable, fall through to create
@@ -309,6 +352,30 @@ async function addPromptToRegistry(wallet, registryAddr, promptData, opts = {})
   const PromptRegistryABI = resolveArtifact('contracts/PromptRegistry.sol/PromptRegistry.json').abi;
   const registry = new Contract(registryAddr, PromptRegistryABI, wallet);
 
+  // Proactive checks to surface actionable errors before spending gas.
+  try {
+    const ownerAddress = getAddress(await wallet.getAddress());
+    const govRole = await registry.GOVERNANCE_ROLE().catch(() => null);
+    if (!govRole) {
+      throw new Error(`Resolved registry ${registryAddr} does not expose GOVERNANCE_ROLE(); is this a valid PromptRegistry?`);
+    }
+    const hasGov = await registry.hasRole(govRole, ownerAddress).catch(() => null);
+    if (!hasGov) {
+      throw new Error(`Wallet ${ownerAddress} lacks GOVERNANCE_ROLE on registry ${registryAddr}. This usually means the registry is not your personal registry (or it was not initialized as personal).`);
+    }
+    const subdao = await registry.subDAO().catch(() => null);
+    if (subdao && getAddress(subdao) !== getAddress(ZeroAddress)) {
+      throw new Error(`Registry ${registryAddr} is linked to SubDAO ${getAddress(subdao)}; personal publish requires a personal registry (subDAO=0x0).`);
+    }
+    const paused = await registry.paused().catch(() => false);
+    if (paused) {
+      throw new Error(`Registry ${registryAddr} is paused; unpause it (DEFAULT_ADMIN_ROLE) or create a fresh personal registry.`);
+    }
+  } catch (e) {
+    // Re-throw with a cleaner message for JSON/non-JSON callers.
+    throw e;
+  }
+
   const title = promptData.title || promptData.name || promptData.key || 'Untitled';
   const tags = promptData.tags || [];
   const contentCID = promptData.contentCID || '';

package/dist/cli/commands/prompt.js

@@ -105,7 +105,7 @@ async function fetchPlatformPrompts(opts = {}) {
 
   if (opts.search) {
     params.set('q', opts.search);
-    const { body } = await client._fetchJson(`/discover/search?${params}`);
+    const { body } = await client._fetchJson(`/prompts/search?${params}`);
     return (body.results || []).map(r => ({
       ...r,
       source: 'platform',