web3agent 0.1.0

package/dist/init-DKWQSYDZ.js

@@ -0,0 +1,434 @@
+#!/usr/bin/env node
+import {
+  BLOCKSCOUT_DEFAULT_URL,
+  ETHERSCAN_DEFAULT_URL
+} from "./chunk-BF4PA46E.js";
+
+// src/cli/init.ts
+import { resolve } from "path";
+
+// src/hosts/context/index.ts
+import { existsSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+var MARKER_START = "<!-- web3agent:start -->";
+var MARKER_END = "<!-- web3agent:end -->";
+var CONTEXT_BODY = `## Web3
+
+This project has web3agent configured. Use the MCP tools for Web3 operations.
+See: web3agent server_status, list_supported_chains for available capabilities.`;
+var MANAGED_BLOCK = `${MARKER_START}
+${CONTEXT_BODY}
+${MARKER_END}`;
+var CURSOR_FRONTMATTER = `---
+description: Web3 capabilities
+globs: []
+alwaysApply: false
+---`;
+function contextFilePath(host, projectDir) {
+  switch (host) {
+    case "claude":
+      return join(projectDir, "CLAUDE.md");
+    case "cursor":
+      return join(projectDir, ".cursor", "rules", "web3agent.mdc");
+    case "windsurf":
+      return join(projectDir, ".windsurf", "rules", "web3agent.md");
+    case "opencode":
+      return join(projectDir, "AGENTS.md");
+  }
+}
+function buildContent(host) {
+  if (host === "cursor") {
+    return `${CURSOR_FRONTMATTER}
+
+${MANAGED_BLOCK}
+`;
+  }
+  return `${MANAGED_BLOCK}
+`;
+}
+function replaceManagedBlock(existing, newBlock) {
+  const startIdx = existing.indexOf(MARKER_START);
+  const endIdx = existing.indexOf(MARKER_END);
+  if (startIdx !== -1 && endIdx !== -1) {
+    const before = existing.slice(0, startIdx);
+    const after = existing.slice(endIdx + MARKER_END.length);
+    return `${before}${newBlock}${after}`;
+  }
+  const trimmed = existing.trimEnd();
+  return `${trimmed}
+
+${newBlock}
+`;
+}
+async function installContext(host, options) {
+  const filePath = contextFilePath(host, options.projectDir);
+  const newBlock = host === "cursor" ? buildContent("cursor") : MANAGED_BLOCK;
+  if (existsSync(filePath)) {
+    const existing = await readFile(filePath, "utf-8");
+    if (host === "cursor" || host === "windsurf") {
+      const updated2 = buildContent(host);
+      if (existing === updated2) {
+        return { configPath: filePath, action: "unchanged" };
+      }
+      if (options.dryRun) {
+        return { configPath: filePath, action: "updated", diff: `Would update ${filePath}` };
+      }
+      await writeFile(filePath, updated2, "utf-8");
+      return { configPath: filePath, action: "updated" };
+    }
+    const hasMarkers = existing.includes(MARKER_START) && existing.includes(MARKER_END);
+    const updated = replaceManagedBlock(existing, MANAGED_BLOCK);
+    if (existing === updated) {
+      return { configPath: filePath, action: "unchanged" };
+    }
+    if (options.dryRun) {
+      const verb = hasMarkers ? "update managed section in" : "append managed section to";
+      return { configPath: filePath, action: "updated", diff: `Would ${verb} ${filePath}` };
+    }
+    await writeFile(filePath, updated, "utf-8");
+    return { configPath: filePath, action: "updated" };
+  }
+  if (options.dryRun) {
+    return { configPath: filePath, action: "created", diff: `Would create ${filePath}` };
+  }
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, buildContent(host), "utf-8");
+  return { configPath: filePath, action: "created" };
+}
+
+// src/hosts/detect.ts
+import { access } from "fs/promises";
+import { homedir } from "os";
+import { join as join2 } from "path";
+var SUPPORTED_HOSTS = ["claude", "cursor", "windsurf", "opencode"];
+async function dirExists(p) {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectHosts(projectDir, homeDir) {
+  const home = homeDir ?? homedir();
+  const detected = [];
+  const checks = [
+    { host: "claude", paths: [join2(home, ".claude")] },
+    { host: "cursor", paths: [join2(projectDir, ".cursor")] },
+    {
+      host: "windsurf",
+      paths: [join2(projectDir, ".windsurf"), join2(home, ".codeium", "windsurf")]
+    },
+    { host: "opencode", paths: [join2(projectDir, ".opencode")] }
+  ];
+  await Promise.all(
+    checks.map(async ({ host, paths }) => {
+      for (const p of paths) {
+        if (await dirExists(p)) {
+          detected.push(host);
+          return;
+        }
+      }
+    })
+  );
+  const ordered = SUPPORTED_HOSTS.filter((h) => detected.includes(h));
+  return { detected: ordered, projectDir };
+}
+function assertSingleHost(detected, explicitHost) {
+  if (explicitHost) {
+    if (!SUPPORTED_HOSTS.includes(explicitHost)) {
+      throw new Error(
+        `Unsupported host "${explicitHost}". Supported: ${SUPPORTED_HOSTS.join(", ")}`
+      );
+    }
+    return explicitHost;
+  }
+  if (detected.length === 0) {
+    throw new Error(
+      `No supported agent host detected. Run with --host to specify one of: ${SUPPORTED_HOSTS.join(", ")}`
+    );
+  }
+  if (detected.length > 1) {
+    throw new Error(
+      `Multiple agent hosts detected: ${detected.join(", ")}. Use --host to specify which one.`
+    );
+  }
+  return detected[0];
+}
+
+// src/hosts/writers/claude.ts
+import { existsSync as existsSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+
+// src/hosts/writers/base.ts
+import { existsSync as existsSync2 } from "fs";
+import { copyFile, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+var MANAGED_KEYS = ["web3agent", "blockscout", "etherscan", "evm"];
+function proxyEntries() {
+  return {
+    web3agent: {
+      type: "stdio",
+      command: "npx",
+      args: ["web3agent"]
+    }
+  };
+}
+function multiServerEntries() {
+  return {
+    web3agent: {
+      type: "stdio",
+      command: "npx",
+      args: ["web3agent"]
+    },
+    blockscout: {
+      type: "sse",
+      url: BLOCKSCOUT_DEFAULT_URL
+    },
+    etherscan: {
+      type: "sse",
+      url: ETHERSCAN_DEFAULT_URL
+    },
+    evm: {
+      command: "npx",
+      args: ["-y", "@mcpdotdirect/evm-mcp-server"]
+    }
+  };
+}
+function mergeServers(existing, incoming) {
+  const merged = { ...existing };
+  let changed = false;
+  for (const key of MANAGED_KEYS) {
+    if (key in incoming) {
+      const oldVal = JSON.stringify(merged[key]);
+      const newVal = JSON.stringify(incoming[key]);
+      if (oldVal !== newVal) {
+        merged[key] = incoming[key];
+        changed = true;
+      }
+    }
+  }
+  return { merged, changed };
+}
+async function safeWriteConfig(configPath, content, dryRun) {
+  const exists = existsSync2(configPath);
+  if (dryRun) {
+    return { action: exists ? "updated" : "created" };
+  }
+  await mkdir2(dirname2(configPath), { recursive: true });
+  let backupPath;
+  if (exists) {
+    backupPath = `${configPath}.bak`;
+    await copyFile(configPath, backupPath);
+  }
+  await writeFile2(configPath, content, "utf-8");
+  return { action: exists ? "updated" : "created", backupPath };
+}
+async function readJsonFile(path) {
+  try {
+    const raw = await readFile2(path, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+var BaseHostWriter = class {
+  getConfigSectionKey() {
+    return "mcpServers";
+  }
+  getEntries(options) {
+    return options.mode === "proxy" ? proxyEntries() : multiServerEntries();
+  }
+  async write(options) {
+    const configPath = this.getConfigPath(options);
+    const incoming = this.getEntries(options);
+    const sectionKey = this.getConfigSectionKey();
+    const existing = await readJsonFile(configPath);
+    if (existing) {
+      const servers = existing[sectionKey] ?? {};
+      const { merged, changed } = mergeServers(servers, incoming);
+      if (!changed) {
+        return { configPath, action: "unchanged" };
+      }
+      const updated = { ...existing, [sectionKey]: merged };
+      const content2 = `${JSON.stringify(updated, null, 2)}
+`;
+      if (options.dryRun) {
+        return {
+          configPath,
+          action: "updated",
+          diff: `Would update ${sectionKey} in ${configPath}`
+        };
+      }
+      const { backupPath } = await safeWriteConfig(configPath, content2, false);
+      return { configPath, action: "updated", backupPath };
+    }
+    const fresh = { [sectionKey]: incoming };
+    const content = `${JSON.stringify(fresh, null, 2)}
+`;
+    if (options.dryRun) {
+      return {
+        configPath,
+        action: "created",
+        diff: `Would create ${configPath}`
+      };
+    }
+    await safeWriteConfig(configPath, content, false);
+    return { configPath, action: "created" };
+  }
+};
+
+// src/hosts/writers/claude.ts
+var ClaudeWriter = class extends BaseHostWriter {
+  getConfigPath(options) {
+    const projectLocal = join3(options.projectDir, ".mcp.json");
+    if (existsSync3(projectLocal)) {
+      return projectLocal;
+    }
+    return join3(homedir2(), ".claude", "mcp.json");
+  }
+};
+
+// src/hosts/writers/cursor.ts
+import { join as join4 } from "path";
+var CursorWriter = class extends BaseHostWriter {
+  getConfigPath(options) {
+    return join4(options.projectDir, ".cursor", "mcp.json");
+  }
+};
+
+// src/hosts/writers/opencode.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join5 } from "path";
+var OpenCodeWriter = class extends BaseHostWriter {
+  getConfigPath(options) {
+    const dotOpencode = join5(options.projectDir, ".opencode", "config.json");
+    if (existsSync4(dotOpencode)) return dotOpencode;
+    const rootConfig = join5(options.projectDir, "opencode.json");
+    if (existsSync4(rootConfig)) return rootConfig;
+    return dotOpencode;
+  }
+  getConfigSectionKey() {
+    return "mcp";
+  }
+  getEntries(options) {
+    if (options.mode === "proxy") {
+      return {
+        web3agent: { type: "local", command: ["npx", "web3agent"] }
+      };
+    }
+    return {
+      web3agent: { type: "local", command: ["npx", "web3agent"] },
+      blockscout: { type: "sse", url: BLOCKSCOUT_DEFAULT_URL },
+      etherscan: { type: "sse", url: ETHERSCAN_DEFAULT_URL },
+      evm: { type: "local", command: ["npx", "-y", "@mcpdotdirect/evm-mcp-server"] }
+    };
+  }
+};
+
+// src/hosts/writers/windsurf.ts
+import { homedir as homedir3 } from "os";
+import { join as join6 } from "path";
+var WindsurfWriter = class extends BaseHostWriter {
+  getConfigPath(_options) {
+    return join6(homedir3(), ".codeium", "windsurf", "mcp_config.json");
+  }
+  getEntries(options) {
+    if (options.mode === "proxy") {
+      return {
+        web3agent: { command: "npx", args: ["web3agent"] }
+      };
+    }
+    return {
+      web3agent: { command: "npx", args: ["web3agent"] },
+      blockscout: { serverUrl: BLOCKSCOUT_DEFAULT_URL },
+      etherscan: { serverUrl: ETHERSCAN_DEFAULT_URL },
+      evm: { command: "npx", args: ["-y", "@mcpdotdirect/evm-mcp-server"] }
+    };
+  }
+};
+
+// src/cli/init.ts
+function parseArgs(args) {
+  const options = {
+    mode: "proxy",
+    project: process.cwd(),
+    dryRun: false
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--host" && i + 1 < args.length) {
+      options.host = args[++i];
+    } else if (arg === "--mode" && i + 1 < args.length) {
+      options.mode = args[++i];
+    } else if (arg === "--project" && i + 1 < args.length) {
+      options.project = resolve(args[++i]);
+    } else if (arg === "--dry-run") {
+      options.dryRun = true;
+    }
+  }
+  return options;
+}
+function getWriter(host) {
+  switch (host) {
+    case "claude":
+      return new ClaudeWriter();
+    case "cursor":
+      return new CursorWriter();
+    case "windsurf":
+      return new WindsurfWriter();
+    case "opencode":
+      return new OpenCodeWriter();
+  }
+}
+async function runInit(args) {
+  const options = parseArgs(args);
+  const projectDir = options.project;
+  if (options.dryRun) {
+    process.stderr.write("[dry-run] No files will be modified\n");
+  }
+  const { detected } = await detectHosts(projectDir);
+  const host = assertSingleHost(detected, options.host);
+  process.stderr.write(`Configuring web3agent for ${host}...
+`);
+  const writer = getWriter(host);
+  const writeResult = await writer.write({
+    projectDir,
+    mode: options.mode,
+    dryRun: options.dryRun
+  });
+  const contextResult = await installContext(host, {
+    projectDir,
+    mode: options.mode,
+    dryRun: options.dryRun
+  });
+  process.stderr.write(`
+Config: ${writeResult.configPath} (${writeResult.action})
+`);
+  if (writeResult.diff) {
+    process.stderr.write(`  ${writeResult.diff}
+`);
+  }
+  if (writeResult.backupPath) {
+    process.stderr.write(`  Backup: ${writeResult.backupPath}
+`);
+  }
+  process.stderr.write(`Context: ${contextResult.configPath} (${contextResult.action})
+`);
+  if (contextResult.diff) {
+    process.stderr.write(`  ${contextResult.diff}
+`);
+  }
+  if (options.dryRun) {
+    process.stderr.write("\n[dry-run] Complete. Re-run without --dry-run to apply changes.\n");
+  } else {
+    process.stderr.write(`
+Done. Restart ${host} to activate web3agent.
+`);
+  }
+}
+export {
+  runInit
+};