@sage-protocol/cli 0.8.0 → 0.8.3

package/dist/cli/commands/install.js

@@ -18,6 +18,92 @@ const { handleCLIError } = require('../utils/error-handler');
 const { withSpinner } = require('../utils/progress');
 const { readWorkspace, addDependency, initWorkspace } = require('../services/prompts/workspace');
 
+function uniqStrings(list) {
+  const seen = new Set();
+  const out = [];
+  for (const item of list || []) {
+    const value = String(item || '').trim();
+    if (!value || seen.has(value)) continue;
+    seen.add(value);
+    out.push(value);
+  }
+  return out;
+}
+
+function buildGatewayUrl(base, cid) {
+  const trimmed = String(base || '').trim().replace(/\/$/, '');
+  if (!trimmed) return '';
+  if (trimmed.endsWith('/ipfs')) return `${trimmed}/${cid}`;
+  if (trimmed.includes('/ipfs/')) return `${trimmed}/${cid}`;
+  return `${trimmed}/ipfs/${cid}`;
+}
+
+function buildGatewayList(preferred) {
+  const envList = process.env.SAGE_IPFS_GATEWAYS
+    ? process.env.SAGE_IPFS_GATEWAYS.split(',').map((v) => v.trim())
+    : [];
+  const defaults = [
+    preferred,
+    'https://dweb.link/ipfs/',
+    'https://nftstorage.link/ipfs/',
+    'https://ipfs.io/ipfs/',
+    'https://gateway.pinata.cloud/ipfs/',
+  ];
+  return uniqStrings([...envList, ...defaults]);
+}
+
+function parseIpfsBody(body) {
+  if (body && typeof body.content === 'string') return { raw: body.content };
+  if (body && body.library) return { json: body };
+  if (typeof body === 'string') return { raw: body };
+  if (body && typeof body === 'object') return { json: body };
+  return {};
+}
+
+async function fetchIpfsContent({ cid, workerClient, gateways, logger }) {
+  if (workerClient) {
+    try {
+      const { res, body } = await workerClient._fetchJson(`/ipfs/content/${cid}`);
+      const parsed = parseIpfsBody(body);
+      if (res?.ok && (parsed.raw || parsed.json)) {
+        return { source: 'worker', ...parsed };
+      }
+    } catch (err) {
+      logger?.debug?.('install_worker_fetch_failed', { cid, err: err.message || String(err) });
+    }
+  }
+
+  const axios = require('axios');
+  let lastError;
+  for (const gateway of gateways || []) {
+    const url = buildGatewayUrl(gateway, cid);
+    if (!url) continue;
+    try {
+      const response = await axios.get(url, {
+        timeout: 12000,
+        maxRedirects: 5,
+        validateStatus: (status) => status < 400,
+      });
+      const parsed = parseIpfsBody(response.data);
+      if (parsed.raw || parsed.json) {
+        return { source: 'gateway', url, ...parsed };
+      }
+      if (typeof response.data === 'string') {
+        return { source: 'gateway', url, raw: response.data };
+      }
+      // If object, treat as json
+      if (response.data && typeof response.data === 'object') {
+        return { source: 'gateway', url, json: response.data };
+      }
+    } catch (err) {
+      logger?.debug?.('install_gateway_fetch_failed', { cid, gateway: url, err: err.message || String(err) });
+      lastError = err;
+    }
+  }
+  const message = lastError ? lastError.message || String(lastError) : `Failed to download content from ${cid}`;
+  throw new Error(message);
+}
+
 /**
  * Detect source type from input string
  * @param {string} source - Input source string
@@ -161,6 +247,7 @@ async function installFromDao(daoAddress, projectDir, opts) {
   const { resolveRegistryAddress } = require('../utils/address-resolution');
   const { WorkerClient } = require('../services/ipfs/worker-client');
   const { DEFAULT_WORKER_BASE } = require('../services/ipfs/onboarding');
+  const IPFSManager = require('../ipfs-manager');
   const config = require('../config');
 
   const provider = new ethers.JsonRpcProvider(
@@ -196,17 +283,28 @@ async function installFromDao(daoAddress, projectDir, opts) {
     process.env.SAGE_IPFS_WORKER_URL ||
     DEFAULT_WORKER_BASE;
 
+  const gatewayConfig = config.readIpfsConfig?.().gateway || process.env.SAGE_IPFS_GATEWAY || '';
+  const gatewayList = buildGatewayList(gatewayConfig);
+
   const client = new WorkerClient({ baseUrl });
-  const { body } = await client._fetchJson(`/ipfs/content/${manifestCID}`);
+  const ipfs = new IPFSManager({ gateway: gatewayConfig });
+  await ipfs.initialize();
 
-  // Worker returns wrapped content - parse if needed
   let manifest;
-  if (body && typeof body.content === 'string') {
-    manifest = JSON.parse(body.content);
-  } else if (body && body.library) {
-    manifest = body;
-  } else {
-    throw new Error(`Failed to download manifest from ${manifestCID}`);
+  try {
+    const result = await fetchIpfsContent({
+      cid: manifestCID,
+      workerClient: client,
+      gateways: gatewayList,
+      logger: ui,
+    });
+    if (result.json) {
+      manifest = result.json;
+    } else if (result.raw) {
+      manifest = JSON.parse(result.raw);
+    }
+  } catch (err) {
+    throw new Error(`Failed to download manifest from ${manifestCID}: ${err.message}`);
   }
 
   const libraryName = manifest.library?.name || 'library';
@@ -234,15 +332,26 @@ async function installFromDao(daoAddress, projectDir, opts) {
     if (!prompt.cid) continue;
 
     try {
-      const { body: contentBody } = await client._fetchJson(`/ipfs/content/${prompt.cid}`);
-
-      // Worker returns wrapped content
       let content;
-      if (contentBody && typeof contentBody.content === 'string') {
-        content = contentBody.content;
-      } else if (typeof contentBody === 'string') {
-        content = contentBody;
-      } else {
+      try {
+        const result = await fetchIpfsContent({
+          cid: prompt.cid,
+          workerClient: client,
+          gateways: gatewayList,
+          logger: ui,
+        });
+        if (result.raw) {
+          content = result.raw;
+        } else if (result.json) {
+          content = JSON.stringify(result.json, null, 2);
+        }
+      } catch (err) {
+        if (verbose) ui.warn(`Worker fetch failed for ${prompt.cid}: ${err.message}. Trying gateway download...`);
+        const data = await ipfs.downloadJson(prompt.cid);
+        content = data?.content || JSON.stringify(data, null, 2);
+      }
+
+      if (!content) {
         throw new Error('Unexpected content format');
       }
 
@@ -345,30 +454,45 @@ async function installFromCid(cid, projectDir, opts) {
   const { verbose = false, name } = opts;
   const { WorkerClient } = require('../services/ipfs/worker-client');
   const { DEFAULT_WORKER_BASE } = require('../services/ipfs/onboarding');
+  const IPFSManager = require('../ipfs-manager');
   const config = require('../config');
 
   const baseUrl = config.readIpfsConfig?.().workerBaseUrl ||
     process.env.SAGE_IPFS_WORKER_URL ||
     DEFAULT_WORKER_BASE;
 
-  const client = new WorkerClient({ baseUrl });
+  const gatewayConfig = config.readIpfsConfig?.().gateway || process.env.SAGE_IPFS_GATEWAY || '';
+  const gatewayList = buildGatewayList(gatewayConfig);
 
-  // Try to download content
-  const { body } = await client._fetchJson(`/ipfs/content/${cid}`);
+  const client = new WorkerClient({ baseUrl });
+  const ipfs = new IPFSManager({ gateway: gatewayConfig });
+  await ipfs.initialize();
 
-  // Check if it's a manifest
+  // Try to download content (worker first, then gateways)
   let manifest;
   let rawContent;
-  if (body && typeof body.content === 'string') {
-    try {
-      manifest = JSON.parse(body.content);
-    } catch (_) {
-      rawContent = body.content;
+  try {
+    const result = await fetchIpfsContent({
+      cid,
+      workerClient: client,
+      gateways: gatewayList,
+      logger: ui,
+    });
+    if (result.json) {
+      if (result.json.library) {
+        manifest = result.json;
+      } else {
+        rawContent = result.json.content || JSON.stringify(result.json, null, 2);
+      }
+    } else if (result.raw) {
+      try {
+        manifest = JSON.parse(result.raw);
+      } catch (_) {
+        rawContent = result.raw;
+      }
     }
-  } else if (body && body.library) {
-    manifest = body;
-  } else if (typeof body === 'string') {
-    rawContent = body;
+  } catch (err) {
+    throw new Error(`Failed to download content from ${cid}: ${err.message}`);
   }
 
   if (manifest && manifest.library) {
@@ -388,13 +512,26 @@ async function installFromCid(cid, projectDir, opts) {
     for (const prompt of manifest.prompts || []) {
       if (!prompt.cid) continue;
       try {
-        const { body: contentBody } = await client._fetchJson(`/ipfs/content/${prompt.cid}`);
         let content;
-        if (contentBody && typeof contentBody.content === 'string') {
-          content = contentBody.content;
-        } else if (typeof contentBody === 'string') {
-          content = contentBody;
-        } else {
+        try {
+          const result = await fetchIpfsContent({
+            cid: prompt.cid,
+            workerClient: client,
+            gateways: gatewayList,
+            logger: ui,
+          });
+          if (result.raw) {
+            content = result.raw;
+          } else if (result.json) {
+            content = JSON.stringify(result.json, null, 2);
+          }
+        } catch (err) {
+          if (verbose) ui.warn(`Worker fetch failed for ${prompt.cid}: ${err.message}. Trying gateway download...`);
+          const data = await ipfs.downloadJson(prompt.cid);
+          content = data?.content || JSON.stringify(data, null, 2);
+        }
+
+        if (!content) {
           throw new Error('Unexpected content format');
         }
 
@@ -419,7 +556,7 @@ async function installFromCid(cid, projectDir, opts) {
     };
   } else {
     // Single file - use raw content
-    const content = rawContent || (body && body.content) || '';
+    const content = rawContent || '';
     if (!content) {
       throw new Error(`Failed to download content from ${cid}`);
     }
@@ -458,6 +595,7 @@ function resolveAlias(alias) {
  */
 function copyDirRecursive(src, dest, copied, verbose, label) {
   for (const file of fs.readdirSync(src)) {
+    if (file === '.git') continue;
     const srcPath = path.join(src, file);
     const destPath = path.join(dest, file);
     const stat = fs.statSync(srcPath);
@@ -582,6 +720,7 @@ function register(program) {
     .option('--to <dir>', 'Installation directory (default: auto-detect)')
     .option('--as-prompt', 'Force install as prompt (to prompts/)')
     .option('--branch <name>', 'Git branch for GitHub sources', 'main')
+    .option('--subpath <path>', 'Subpath within a GitHub repo (overrides path in github:owner/repo/path)')
     .option('--name <name>', 'Override the installed name')
     .option('-y, --yes', 'Skip confirmations')
     .option('-v, --verbose', 'Show detailed output')
@@ -592,6 +731,9 @@ function register(program) {
 
         const projectDir = opts.to || process.cwd();
         const sourceInfo = detectSourceType(source);
+        if (sourceInfo.type === 'github' && opts.subpath) {
+          sourceInfo.subpath = opts.subpath;
+        }
 
         if (!opts.json) {
           ui.info(`Installing from ${sourceInfo.type}: ${source}`);

package/dist/cli/commands/ipfs.js

@@ -369,9 +369,19 @@ function register(program) {
             ui.configure({ verbose: opts.verbose, json: opts.json });
 
             const baseUrl = opts.workerUrl || (config.readIpfsConfig && (config.readIpfsConfig().workerBaseUrl || '')) || DEFAULT_WORKER_BASE;
-            const wc = new WorkerClient({ baseUrl, token: opts.workerToken, address: opts.workerAddress });
+            let workerAddress = opts.workerAddress;
+            if (!workerAddress) {
+              try {
+                const wallet = await getConnectedWallet();
+                workerAddress = wallet?.account || (wallet?.signer && await wallet.signer.getAddress()) || null;
+              } catch (_) { /* ignore */ }
+            }
+            if (!workerAddress) {
+              throw new Error('address required (set --worker-address or configure a wallet)');
+            }
+            const wc = new WorkerClient({ baseUrl, token: opts.workerToken, address: workerAddress });
             const result = await wc.listPins({
-              address: opts.workerAddress,
+              address: workerAddress,
               status: opts.status,
               limit: opts.limit,
             });