@goplausible/openclaw-algorand-plugin 1.9.5 → 2.0.0

package/lib/mcporter.ts

@@ -0,0 +1,75 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+
+import { ALGORAND_MCP } from "./mcp-servers.js";
+
+export function getMcpBinaryPath(pluginRoot: string): string {
+  const pluginBin = join(pluginRoot, "node_modules", ".bin", "algorand-mcp");
+  return existsSync(pluginBin) ? pluginBin : "algorand-mcp";
+}
+
+export function isMcpBinaryBundled(pluginRoot: string): boolean {
+  return existsSync(join(pluginRoot, "node_modules", ".bin", "algorand-mcp"));
+}
+
+export function mcporterConfigPath(): string {
+  return join(homedir(), ".mcporter", "mcporter.json");
+}
+
+type McporterServerEntry = {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+  description?: string;
+};
+
+type McporterConfig = {
+  mcpServers: Record<string, McporterServerEntry>;
+  imports: string[];
+};
+
+export function isMcporterConfigured(): boolean {
+  const cfgPath = mcporterConfigPath();
+  if (!existsSync(cfgPath)) return false;
+  try {
+    const cfg = JSON.parse(readFileSync(cfgPath, "utf-8"));
+    return Boolean(cfg.mcpServers?.[ALGORAND_MCP.id]);
+  } catch {
+    return false;
+  }
+}
+
+export function upsertMcporterConfig(pluginRoot: string): { success: boolean; message: string } {
+  const cfgPath = mcporterConfigPath();
+  const cfgDir = dirname(cfgPath);
+
+  if (!existsSync(cfgDir)) mkdirSync(cfgDir, { recursive: true });
+
+  let cfg: McporterConfig = { mcpServers: {}, imports: [] };
+  if (existsSync(cfgPath)) {
+    try {
+      const parsed = JSON.parse(readFileSync(cfgPath, "utf-8"));
+      cfg = {
+        mcpServers: parsed.mcpServers ?? {},
+        imports: Array.isArray(parsed.imports) ? parsed.imports : [],
+      };
+    } catch (err) {
+      return { success: false, message: `Failed to parse ${cfgPath}: ${err}` };
+    }
+  }
+
+  const entry: McporterServerEntry = {
+    command: getMcpBinaryPath(pluginRoot),
+    description: "Algorand blockchain MCP (GoPlausible)",
+  };
+
+  const existing = cfg.mcpServers[ALGORAND_MCP.id];
+  if (existing?.command === entry.command && existing?.description === entry.description) {
+    return { success: true, message: `algorand-mcp already registered in ${cfgPath}` };
+  }
+
+  cfg.mcpServers[ALGORAND_MCP.id] = entry;
+  writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
+  return { success: true, message: `algorand-mcp registered in ${cfgPath}` };
+}

package/lib/workspace.ts

@@ -0,0 +1,216 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+
+import { upsertMcporterConfig } from "./mcporter.js";
+
+const PLUGIN_ID = "openclaw-algorand-plugin";
+
+export type WorkspaceApi = {
+  logger: { info: (m: string) => void; warn: (m: string) => void; error: (m: string) => void };
+  runtime?: {
+    agent?: {
+      resolveAgentWorkspaceDir?: () => string;
+      ensureAgentWorkspace?: () => Promise<string> | string;
+    };
+  };
+  config: Record<string, unknown>;
+};
+
+export function resolveWorkspaceDir(api: WorkspaceApi): string {
+  const rt = api.runtime?.agent;
+  if (rt?.resolveAgentWorkspaceDir) {
+    try { return rt.resolveAgentWorkspaceDir(); } catch { /* fall through */ }
+  }
+  const cfg = api.config as { agents?: { defaults?: { workspace?: string } } };
+  return cfg.agents?.defaults?.workspace ?? join(homedir(), ".openclaw", "workspace");
+}
+
+export function writeMemoryFile(pluginRoot: string, workspacePath: string): { success: boolean; message: string } {
+  const sourceFile = join(pluginRoot, "memory", "algorand-plugin.md");
+  const memoryDir = join(workspacePath, "memory");
+  const targetFile = join(memoryDir, "algorand-plugin.md");
+
+  if (!existsSync(sourceFile)) {
+    return { success: false, message: `Source memory/algorand-plugin.md not found at ${sourceFile}` };
+  }
+
+  if (!existsSync(memoryDir)) mkdirSync(memoryDir, { recursive: true });
+
+  writeFileSync(targetFile, readFileSync(sourceFile, "utf-8"));
+  return { success: true, message: `Plugin memory written to ${targetFile}` };
+}
+
+export function ensureWorkspaceMemoryIndex(pluginRoot: string, workspacePath: string): { success: boolean; message: string } {
+  const templateFile = join(pluginRoot, "memory", "MEMORY.md");
+
+  if (!existsSync(templateFile)) {
+    return { success: false, message: "Template MEMORY.md not found in plugin" };
+  }
+
+  const templateContent = readFileSync(templateFile, "utf-8");
+
+  const neverForgetMatch = templateContent.match(/## NEVER FORGET\n([\s\S]*?)(?=\n## (?!NEVER)|$)/);
+  if (!neverForgetMatch) {
+    return { success: false, message: "No NEVER FORGET section found in template MEMORY.md" };
+  }
+  const templateNeverForget = neverForgetMatch[1].trimEnd();
+
+  const memoryMdPath = join(workspacePath, "MEMORY.md");
+  const memoryMdLower = join(workspacePath, "memory.md");
+
+  const existingPath = existsSync(memoryMdPath) ? memoryMdPath
+    : existsSync(memoryMdLower) ? memoryMdLower
+    : null;
+
+  if (!existingPath) {
+    if (!existsSync(workspacePath)) mkdirSync(workspacePath, { recursive: true });
+    writeFileSync(memoryMdPath, templateContent);
+    return { success: true, message: `Created ${memoryMdPath} with NEVER FORGET section` };
+  }
+
+  let existing = readFileSync(existingPath, "utf-8");
+
+  if (!/## NEVER FORGET/i.test(existing)) {
+    const firstHeadingEnd = existing.match(/^# .+\n/m);
+    if (firstHeadingEnd) {
+      const insertPos = (firstHeadingEnd.index ?? 0) + firstHeadingEnd[0].length;
+      existing = existing.slice(0, insertPos) + "\n## NEVER FORGET\n" + templateNeverForget + "\n\n" + existing.slice(insertPos);
+    } else {
+      existing = "# OpenClaw Agent Long-Term Memory\n\n## NEVER FORGET\n" + templateNeverForget + "\n\n" + existing;
+    }
+    writeFileSync(existingPath, existing);
+    return { success: true, message: `Added NEVER FORGET section to ${existingPath}` };
+  }
+
+  const parseSubsections = (text: string): { header: string; content: string }[] => {
+    const sections: { header: string; content: string }[] = [];
+    const lines = text.split("\n");
+    let currentHeader = "";
+    let currentLines: string[] = [];
+    for (const line of lines) {
+      if (line.startsWith("### ")) {
+        if (currentHeader) sections.push({ header: currentHeader, content: currentLines.join("\n").trimEnd() });
+        currentHeader = line;
+        currentLines = [];
+      } else if (currentHeader) {
+        currentLines.push(line);
+      }
+    }
+    if (currentHeader) sections.push({ header: currentHeader, content: currentLines.join("\n").trimEnd() });
+    return sections;
+  };
+
+  const templateSections = parseSubsections(templateNeverForget);
+  const nfSectionMatch = existing.match(/(## NEVER FORGET\n)([\s\S]*?)(?=\n## (?!#)|$)/);
+  if (!nfSectionMatch) {
+    return { success: true, message: `NEVER FORGET section in ${existingPath} is up to date` };
+  }
+
+  let nfContent = nfSectionMatch[2];
+  let updated = false;
+
+  for (const templateSec of templateSections) {
+    if (templateSec.header === "### Never Do This") {
+      const neverDoRegex = /(### Never Do This\n)([\s\S]*?)(?=\n### |$)/;
+      const existingNeverDoMatch = nfContent.match(neverDoRegex);
+
+      if (!existingNeverDoMatch) {
+        nfContent = nfContent.trimEnd() + "\n\n" + templateSec.header + "\n" + templateSec.content + "\n";
+        updated = true;
+      } else {
+        let existingBullets = existingNeverDoMatch[2];
+        const templateBullets = templateSec.content.split("\n").filter((l: string) => l.startsWith("* "));
+        const existingBulletLines = existingBullets.split("\n").filter((l: string) => l.startsWith("* "));
+
+        for (const bullet of templateBullets) {
+          const fingerprint = bullet.slice(2, 52).trim();
+          const existingMatch = existingBulletLines.find((l: string) => l.includes(fingerprint));
+          if (existingMatch) {
+            if (existingMatch !== bullet) {
+              nfContent = nfContent.replace(existingMatch, bullet);
+              updated = true;
+            }
+          } else {
+            existingBullets = existingBullets.trimEnd() + "\n" + bullet;
+            nfContent = nfContent.replace(existingNeverDoMatch[2], existingBullets);
+            updated = true;
+          }
+        }
+      }
+    } else {
+      const escapedHeader = templateSec.header.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const sectionRegex = new RegExp("(" + escapedHeader + "\\n)([\\s\\S]*?)(?=\\n### |$)");
+      const existingSecMatch = nfContent.match(sectionRegex);
+
+      if (existingSecMatch) {
+        if (existingSecMatch[2].trimEnd() !== templateSec.content) {
+          nfContent = nfContent.replace(existingSecMatch[0], templateSec.header + "\n" + templateSec.content);
+          updated = true;
+        }
+      } else {
+        const neverDoPos = nfContent.indexOf("### Never Do This");
+        if (neverDoPos !== -1) {
+          nfContent = nfContent.slice(0, neverDoPos) + templateSec.header + "\n" + templateSec.content + "\n\n" + nfContent.slice(neverDoPos);
+        } else {
+          nfContent = nfContent.trimEnd() + "\n\n" + templateSec.header + "\n" + templateSec.content + "\n";
+        }
+        updated = true;
+      }
+    }
+  }
+
+  if (!updated) return { success: true, message: `NEVER FORGET section in ${existingPath} is up to date` };
+
+  existing = existing.replace(nfSectionMatch[2], nfContent);
+  writeFileSync(existingPath, existing);
+  return { success: true, message: `Updated NEVER FORGET subsections in ${existingPath}` };
+}
+
+export function runFirstLoadInit(api: WorkspaceApi, pluginRoot: string, workspacePath: string): void {
+  const markerPath = join(workspacePath, ".openclaw", `${PLUGIN_ID}.initialized`);
+  if (existsSync(markerPath)) return;
+
+  const markerDir = dirname(markerPath);
+  if (!existsSync(markerDir)) mkdirSync(markerDir, { recursive: true });
+
+  const mem = writeMemoryFile(pluginRoot, workspacePath);
+  if (mem.success) api.logger.info(`[algorand-plugin] ${mem.message}`);
+  else api.logger.warn(`[algorand-plugin] ${mem.message}`);
+
+  const memIdx = ensureWorkspaceMemoryIndex(pluginRoot, workspacePath);
+  if (memIdx.success) api.logger.info(`[algorand-plugin] ${memIdx.message}`);
+  else api.logger.warn(`[algorand-plugin] ${memIdx.message}`);
+
+  const mcp = upsertMcporterConfig(pluginRoot);
+  if (mcp.success) api.logger.info(`[algorand-plugin] ${mcp.message}`);
+  else api.logger.warn(`[algorand-plugin] ${mcp.message}`);
+
+  writeFileSync(markerPath, new Date().toISOString());
+}
+
+export function writePluginConfig(pluginConfig: Record<string, unknown>): { success: boolean; error?: string } {
+  try {
+    const configPath = join(homedir(), ".openclaw", "openclaw.json");
+    const configDir = dirname(configPath);
+    if (!existsSync(configDir)) mkdirSync(configDir, { recursive: true });
+
+    let config: Record<string, any> = {};
+    if (existsSync(configPath)) {
+      config = JSON.parse(readFileSync(configPath, "utf-8"));
+    }
+
+    config.plugins ??= {};
+    config.plugins.entries ??= {};
+    config.plugins.entries[PLUGIN_ID] ??= {};
+    config.plugins.entries[PLUGIN_ID].config = pluginConfig;
+
+    config.plugins.allow ??= [];
+    if (!config.plugins.allow.includes(PLUGIN_ID)) config.plugins.allow.push(PLUGIN_ID);
+
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: String(err) };
+  }
+}

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "openclaw-algorand-plugin",
   "name": "Algorand Integration",
   "description": "Algorand blockchain integration with MCP and skills — by GoPlausible",
-  "version": "1.9.5",
+  "version": "2.0.0",
   "skills": [
     "skills/algorand-development",
     "skills/algorand-typescript",
@@ -14,6 +14,15 @@
     "skills/haystack-router-interaction",
     "skills/alpha-arcade-interaction"
   ],
+  "activation": {
+    "commands": ["algorand-plugin"]
+  },
+  "commandAliases": [
+    {
+      "name": "algorand-plugin",
+      "description": "Algorand blockchain integration (GoPlausible)"
+    }
+  ],
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
@@ -21,7 +30,7 @@
       "enableX402": {
         "type": "boolean",
         "default": true,
-        "description": "Enable x402 micropayments skills"
+        "description": "Enable x402 micropayments skills and x402_fetch tool"
       }
     }
   },
@@ -29,5 +38,19 @@
     "enableX402": {
       "label": "Enable x402 Micropayments"
     }
+  },
+  "setup": {
+    "summary": "Configure Algorand blockchain integration",
+    "steps": [
+      {
+        "id": "x402",
+        "label": "x402 Micropayments",
+        "description": "Enable the x402 HTTP-native payment protocol support (x402_fetch tool + skills).",
+        "configKey": "enableX402"
+      }
+    ],
+    "postSetup": {
+      "message": "Restart the OpenClaw gateway to apply changes. algorand-mcp is auto-registered in ~/.mcporter/mcporter.json on first load."
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goplausible/openclaw-algorand-plugin",
-  "version": "1.9.5",
+  "version": "2.0.0",
   "publishConfig": {
     "access": "public"
   },
@@ -27,16 +27,25 @@
     "index.ts",
     "setup.ts",
     "lib/",
-    "scripts/",
     "skills/",
     "memory/",
     "openclaw.plugin.json"
   ],
   "openclaw": {
-    "extensions": ["./index.ts"]
+    "extensions": ["./index.ts"],
+    "compat": {
+      "pluginApi": ">=2026.3.14",
+      "minGatewayVersion": "2026.3.14"
+    }
   },
   "dependencies": {
     "@clack/prompts": "^0.7.0",
     "@goplausible/algorand-mcp": "latest"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.3.14"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0"
   }
 }

package/setup.ts

@@ -1,30 +1,15 @@
 import * as p from "@clack/prompts";
-import { execSync } from "node:child_process";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
 import { ALGORAND_MCP, GOPLAUSIBLE_SERVICES } from "./lib/mcp-servers.js";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
 export interface AlgorandPluginConfig {
   enableX402: boolean;
 }
 
 export async function runSetup(
-  existingConfig?: Partial<AlgorandPluginConfig>
+  existingConfig?: Partial<AlgorandPluginConfig>,
 ): Promise<AlgorandPluginConfig | null> {
   p.intro("🔷 Algorand Plugin Setup — powered by GoPlausible");
 
-  // Step 1: Keyring persistence check & setup
-  p.log.step("Checking keyring persistence for wallet storage...");
-  try {
-    const scriptPath = join(__dirname, "scripts", "setup-keyring.sh");
-    execSync(`bash "${scriptPath}" --setup`, { stdio: "inherit" });
-  } catch {
-    p.log.warn("Keyring setup script failed — you may need to configure manually.");
-  }
-
-  // Step 2: x402 integration
   const enableX402 = await p.confirm({
     message: "Enable x402 micropayments integration?",
     initialValue: existingConfig?.enableX402 ?? true,
@@ -35,23 +20,22 @@ export async function runSetup(
     return null;
   }
 
-  // Summary
   const config: AlgorandPluginConfig = {
     enableX402: enableX402 as boolean,
   };
 
   p.note(
     `x402 Micropayments: ${config.enableX402 ? "Enabled" : "Disabled"}\n\n` +
-      `MCP Server Setup:\n` +
-      `  The Algorand MCP server (${ALGORAND_MCP.command}) provides 107 blockchain tools.\n` +
-      `  x402 micropayment and AP2 mandate verifiable credentials flows are fully supported in Algorand MCP.\n` ,
+      `MCP Server:\n` +
+      `  ${ALGORAND_MCP.name} (${ALGORAND_MCP.command}) — 107 blockchain tools.\n` +
+      `  Registered in ~/.mcporter/mcporter.json on first load.\n` +
+      `  x402 micropayment and AP2 mandate flows are fully supported.\n`,
   );
 
   p.outro(
     `🔷 Algorand plugin configured!\n\n` +
-      `   Next steps:\n` +
-      `   3. Restart OpenClaw gateway\n\n` +
-      `   GoPlausible website: ${GOPLAUSIBLE_SERVICES.website}`
+      `   Next step: restart OpenClaw gateway.\n\n` +
+      `   Docs: ${GOPLAUSIBLE_SERVICES.website}`,
   );
 
   return config;

package/scripts/backup-keyring.js

@@ -1,117 +0,0 @@
-#!/usr/bin/env node
-// Usage:
-//   node backup-keyring.js backup <output-file>    — dump address\tmnemonic pairs
-//   node backup-keyring.js restore <input-file>     — restore mnemonics from backup
-//   node backup-keyring.js count                    — print number of accounts in wallet.db
-//   node backup-keyring.js verify                   — check which accounts have mnemonics in keyring
-
-const { Entry } = require('@napi-rs/keyring');
-const initSqlJs = require('sql.js');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const KEYCHAIN_SERVICE = 'algorand-mcp';
-const WALLET_DB = path.join(os.homedir(), '.algorand-mcp', 'wallet.db');
-
-async function getAccounts() {
-  if (!fs.existsSync(WALLET_DB)) return [];
-  const SQL = await initSqlJs();
-  const buf = fs.readFileSync(WALLET_DB);
-  const db = new SQL.Database(buf);
-  const rows = db.exec('SELECT address FROM accounts');
-  db.close();
-  if (!rows.length || !rows[0].values.length) return [];
-  return rows[0].values.map(r => r[0]);
-}
-
-function getMnemonic(address) {
-  try {
-    const entry = new Entry(KEYCHAIN_SERVICE, address);
-    const pw = entry.getPassword();
-    return pw || null;
-  } catch {
-    return null;
-  }
-}
-
-function setMnemonic(address, mnemonic) {
-  const entry = new Entry(KEYCHAIN_SERVICE, address);
-  entry.setPassword(mnemonic);
-}
-
-async function main() {
-  const mode = process.argv[2];
-  const file = process.argv[3];
-
-  if (mode === 'count') {
-    const accounts = await getAccounts();
-    console.log(accounts.length);
-    return;
-  }
-
-  if (mode === 'verify') {
-    const accounts = await getAccounts();
-    let ok = 0, missing = 0;
-    for (const addr of accounts) {
-      if (getMnemonic(addr)) {
-        console.log('OK ' + addr);
-        ok++;
-      } else {
-        console.log('MISSING ' + addr);
-        missing++;
-      }
-    }
-    console.log(`TOTAL=${accounts.length} OK=${ok} MISSING=${missing}`);
-    return;
-  }
-
-  if (mode === 'backup') {
-    if (!file) { console.error('Usage: backup-keyring.js backup <output-file>'); process.exit(1); }
-    const accounts = await getAccounts();
-    if (accounts.length === 0) {
-      console.log('NO_ACCOUNTS');
-      return;
-    }
-    let backed = 0, failed = 0;
-    const lines = [];
-    for (const addr of accounts) {
-      const mnemonic = getMnemonic(addr);
-      if (mnemonic) {
-        lines.push(addr + '\t' + mnemonic);
-        backed++;
-      } else {
-        console.error('MISSING ' + addr);
-        failed++;
-      }
-    }
-    if (lines.length > 0) {
-      fs.writeFileSync(file, lines.join('\n') + '\n', { mode: 0o600 });
-    }
-    console.log(`BACKED_UP=${backed} FAILED=${failed}`);
-    return;
-  }
-
-  if (mode === 'restore') {
-    if (!file) { console.error('Usage: backup-keyring.js restore <input-file>'); process.exit(1); }
-    if (!fs.existsSync(file)) { console.error('File not found: ' + file); process.exit(1); }
-    const content = fs.readFileSync(file, 'utf-8').trim();
-    if (!content) { console.log('RESTORED=0'); return; }
-    let restored = 0;
-    for (const line of content.split('\n')) {
-      const [addr, ...rest] = line.split('\t');
-      const mnemonic = rest.join('\t');
-      if (addr && mnemonic) {
-        setMnemonic(addr, mnemonic);
-        restored++;
-      }
-    }
-    console.log(`RESTORED=${restored}`);
-    return;
-  }
-
-  console.error('Usage: backup-keyring.js <backup|restore|count|verify> [file]');
-  process.exit(1);
-}
-
-main().catch(err => { console.error(err.message); process.exit(1); });